invest.isa-allowance Unreviewed

export function isaAllowance(taxYearDate: string, subscriptions: readonly IsaSubscription[], dateOfBirth: string | null): IsaAllowance

export type IsaKind = "cash" | "stocks-and-shares" | "innovative-finance" | "lifetime" | "junior";

/** One payment into an ISA. */
export interface IsaSubscription {
  readonly date: string;
  readonly kind: IsaKind;
  /** greater than zero */
  readonly amount: Money;
}

/** One limit and how much of it is used. */
export interface IsaLimitUse {
  readonly limit: Money;
  readonly used: Money;
  /** what can still go in: never below zero, and never more than the overall allowance has left */
  readonly remaining: Money;
  /** true when used is over the limit */
  readonly exceeded: boolean;
}

/** Each limit for the tax year, and whether any is broken. */
export interface IsaAllowance {
  /** HMRC's label, 2026/27 */
  readonly taxYear: string;
  /** every adult ISA together */
  readonly overall: IsaLimitUse;
  /** Lifetime ISA, inside the overall limit */
  readonly lifetime: IsaLimitUse;
  /** cash ISA, inside the overall limit; null in a year or for a saver with no separate cash limit */
  readonly cash: IsaLimitUse | null;
  /** Junior ISA, a separate allowance for the child */
  readonly junior: IsaLimitUse;
  /** true when any limit is exceeded */
  readonly exceeded: boolean;
}

import { isaAllowance } from "#fune/invest.isa-allowance@^1";

import { type Money } from "./money_amount.ts";  ← from money.amount ^1.0.0 · built alongside by fune
import { ISA_LIMITS, ISA_LIMITS_HISTORY, ISA_LIMITS_HORIZON } from "./invest_isa_allowance_data.ts";  ← this capability’s own data, compiled from data/isa-limits.json into the same file by fune build
import { type IsaAllowance, type IsaLimitUse, type IsaSubscription } from "./invest_isa_allowance_types.ts";

const ISO_DATE = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
const KINDS = ["cash", "stocks-and-shares", "innovative-finance", "lifetime", "junior"];

function gbp(minor: number): Money {
  return { minor, currency: "GBP" };
}

function use(limit: number, used: number, room: number): IsaLimitUse {
  return {
    limit: gbp(limit),
    used: gbp(used),
    remaining: gbp(Math.max(0, Math.min(limit - used, room))),
    exceeded: used > limit,
  };
}

/**
 * How much of each ISA subscription limit a saver has used in a UK tax year
 * and how much is left.
 *
 * The Lifetime ISA limit and (from 2027/28, for savers under 65) the cash ISA
 * limit sit inside the overall limit, so what is left of them is also capped by
 * what is left overall: £18,000 in a stocks and shares ISA leaves £2,000 for a
 * Lifetime ISA, not £4,000. The Junior ISA limit is the child's own and is
 * counted on its own.
 */
export function isaAllowance(
  taxYearDate: string,
  subscriptions: readonly IsaSubscription[],
  dateOfBirth: string | null
): IsaAllowance {
  if (!ISO_DATE.test(taxYearDate)) {
    throw new RangeError(`taxYearDate must be an ISO date (YYYY-MM-DD), received "${taxYearDate}"`);
  }
  const year = ISA_LIMITS.find((row) => row.validFrom <= taxYearDate && (row.validTo === null || taxYearDate <= row.validTo));
  if (year === undefined) {
    if (ISA_LIMITS_HORIZON !== null && taxYearDate < ISA_LIMITS_HORIZON) {
      throw new RangeError(
        `no ISA limits for ${taxYearDate}: this build was installed with history=${ISA_LIMITS_HISTORY}, ` +
          `so it only carries limits from ${ISA_LIMITS_HORIZON}. Reinstall with history=full for earlier years.`
      );
    }
    throw new RangeError(`no ISA limits for ${taxYearDate}`);
  }
  const end = year.validTo as string;

  const used: Record<string, number> = { cash: 0, "stocks-and-shares": 0, "innovative-finance": 0, lifetime: 0, junior: 0 };
  for (const s of subscriptions) {
    if (!KINDS.includes(s.kind)) {
      throw new RangeError(`kind must be cash, stocks-and-shares, innovative-finance, lifetime or junior, received "${s.kind}"`);
    }
    if (s.amount.currency !== "GBP") throw new RangeError(`subscriptions must be in GBP, received ${s.amount.currency}`);
    if (!Number.isInteger(s.amount.minor) || s.amount.minor <= 0) {
      throw new RangeError(`a subscription must be a whole number of pence greater than zero, received ${s.amount.minor}`);
    }
    if (!ISO_DATE.test(s.date) || s.date < year.validFrom || s.date > end) {
      throw new RangeError(`the subscription on ${s.date} is outside the ${year.taxYear} tax year`);
    }
    used[s.kind] += s.amount.minor;
  }

  // Cash has its own limit only for a saver under 65 for the whole tax year:
  // the higher limit applies from the start of the year they turn 65.
  let cashLimit: number | null = null;
  if (year.cashUnder65 !== null) {
    if (dateOfBirth === null) {
      throw new RangeError(`dateOfBirth is needed for ${year.taxYear}, when the cash ISA limit depends on age`);
    }
    if (!ISO_DATE.test(dateOfBirth)) {
      throw new RangeError(`dateOfBirth must be an ISO date (YYYY-MM-DD), received "${dateOfBirth}"`);
    }
    const birthday65 = `${String(Number(dateOfBirth.slice(0, 4)) + 65).padStart(4, "0")}${dateOfBirth.slice(4)}`;
    if (birthday65 > end) cashLimit = year.cashUnder65;
  }

  const adult = used.cash + used["stocks-and-shares"] + used["innovative-finance"] + used.lifetime;
  const overall = use(year.overall, adult, year.overall - adult);
  const room = overall.remaining.minor;
  const lifetime = use(year.lifetime, used.lifetime, room);
  const cash = cashLimit === null ? null : use(cashLimit, used.cash, room);
  const junior = use(year.junior, used.junior, year.junior - used.junior);
  return {
    taxYear: year.taxYear,
    overall,
    lifetime,
    cash,
    junior,
    exceeded: overall.exceeded || lifetime.exceeded || (cash !== null && cash.exceeded) || junior.exceeded,
  };
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and its 1 dependency, pins them in fune.lock, downloads only the TypeScript package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add invest.isa-allowance

The manifest, vectors and README with only the TypeScript implementation. Install it without the registry with fune add ./invest.isa-allowance-1.0.2-typescript.fune, or fetch it from a terminal with fune pull invest.isa-allowance@1.0.2:typescript.

The whole function, every language, is one file too: invest.isa-allowance-1.0.2.fune, 55,617 bytes, sha256 06a5b36689a7bd8fd074675a34bec845d691e192be1e38c70b6acc5c3efad5a2. It installs into a project of any language.

// fune: before invest.isa-allowance

// fune: after invest.isa-allowance

// fune: replace money.amount in invest.isa-allowance

// fune: step invest.isa-allowance after <n|label>

More from the author

- **Limits inside limits.** A Lifetime ISA's £4,000, and from 2027/28 an under-65's £12,000 of cash, count towards the £20,000. So what is left of them is also capped by what is left overall: £18,000 in a stocks and shares ISA leaves £2,000 of Lifetime ISA room, not £4,000. - **Junior ISA is separate.** It is the child's allowance, counted on its own and never against the adult's. Pass one child's subscriptions (or leave them out). - **`exceeded`, not an error.** An over-subscription is a fact to report (HMRC repairs or voids the excess), so the function answers with the flags set rather than throwing. - **Each tax year is its own row** in `data/isa-limits.json`, so the label and the 6 April to 5 April bounds come from the data and a year the data does not cover (before 2017/18, after 2027/28) is refused rather than guessed.

## The 2027/28 cash limit

From 6 April 2027 the government has announced a cash ISA limit of £12,000 for savers under 65, inside an unchanged £20,000, with savers 65 or over able to put the full £20,000 in cash "from the start of the tax year in which an individual turns 65". Here that means: a saver whose 65th birthday falls on or before 5 April at the end of the tax year has no separate cash limit (`cash` is null); anyone younger has the £12,000 limit, and `dateOfBirth` is then required. A 29 February birthday is compared as the string "YYYY-02-29", which sorts correctly.

At 2026-09-23 this is announced policy (policy paper published 17 September 2026) with the amending ISA Regulations still in draft. The row is marked so in its note; if the final regulations differ, publish a new version with the corrected row.

## Limits

| Tax years | Overall | Lifetime ISA | Junior ISA | Cash, under 65 | |---|---|---|---|---| | 2017/18 | £20,000 | £4,000 | £4,128 | none | | 2018/19 | £20,000 | £4,000 | £4,260 | none | | 2019/20 | £20,000 | £4,000 | £4,368 | none | | 2020/21 to 2026/27 | £20,000 | £4,000 | £9,000 | none | | 2027/28 | £20,000 | £4,000 | £9,000 | £12,000 |

## Out of scope

Lifetime ISA age rules (open under 40, pay in until 50) and the government bonus; whether a cash Lifetime ISA counts towards the cash limit (it is not counted as cash here); transfers between ISAs, which are not subscriptions; flexible ISA withdrawals and replacements; the 2027 anti-circumvention rules.

## Sources

Read on 2026-09-23:

- GOV.UK, "Individual Savings Accounts (ISAs): How ISAs work" (£20,000 a year; Lifetime ISA £4,000 a year, inside it): https://www.gov.uk/individual-savings-accounts/how-isas-work - GOV.UK, "Junior Individual Savings Accounts (ISA)" (£9,000 in 2026/27): https://www.gov.uk/junior-individual-savings-accounts - HMRC, "Annual savings statistics: background and methodology" (Tables of adult and Junior ISA subscription limits by tax year, 2008/09 to 2026/27): https://www.gov.uk/government/statistics/annual-savings-statistics-2026/annual-savings-statistics-background-and-methodology - HMRC policy paper, "Cash Individual Savings Account (ISA) limit reduction", published 17 September 2026: https://www.gov.uk/government/publications/reduction-in-the-cash-individual-savings-account-isa-limit/cash-individual-savings-account-isa-limit-reduction - "ISA reform 2027: anti-circumvention rules factsheet" (the age 65 test): https://www.gov.uk/government/publications/fiscal-events-2026-factsheets/isa-reform-2027-anti-circumvention-rules-factsheet

1.0.1 fixes Python accepting a trailing newline or non-ASCII digits in taxYearDate, dateOfBirth and subscription dates; adds tests.

## Before you rely on this

**Not professional advice.** This capability calculates investment figures from published rules. It is a software component for developers, not financial advice. Rules change and every rate here has an effective date. Check that the dates cover your case. Verify results against the official sources listed above, and have a tax adviser review how you use it, before anyone relies on the output. Provided "as is" under its licence, without warranty.

**Unreviewed.** This capability's implementations agree in every language and pass its published test vectors, which were worked out from the official sources cited. But no qualified tax adviser has yet checked those vectors, or confirmed that the capability covers the cases it claims. Treat it as a draft. Do not use it for real people, money or decisions without your own expert review. Once a qualified reviewer signs off, this notice is replaced with their name, qualification and the date. Each new version needs fresh sign-off.

## Notices

Contains public sector information licensed under the Open Government Licence v3.0 (https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).

1.0.2 marks it unreviewed and adds its attribution notices (NOTICE). The code and the tests are unchanged.

Files