tallyd 0.0.0-stage → 0.1.0

package/dist/ledger/entry.js

@@ -0,0 +1,264 @@
+/**
+ * Journal entries and the balancing invariant.
+ *
+ * The central rule of this file: an unbalanced `JournalEntry` cannot be
+ * constructed. The check lives in the factory, the constructor is private, and
+ * every field is frozen — so no code downstream of this module has to remember
+ * to validate anything, and no code can un-balance an entry after the fact.
+ *
+ * Sign convention: a posting's amount is positive for a debit and negative for
+ * a credit. One signed number is easier to sum than a (side, magnitude) pair,
+ * and "the postings sum to zero" is then literally the invariant.
+ */
+import { Money, sumMoney } from "../money/money.js";
+import { date as parseDate } from "./date.js";
+export class UnbalancedEntryError extends Error {
+    residuals;
+    narration;
+    constructor(residuals, narration) {
+        const detail = residuals.map((r) => r.toString()).join(", ");
+        super(`Entry "${narration}" does not balance; residual: ${detail}`);
+        this.residuals = residuals;
+        this.narration = narration;
+        this.name = "UnbalancedEntryError";
+    }
+}
+export class InvalidEntryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidEntryError";
+    }
+}
+export class JournalEntry {
+    id;
+    date;
+    narration;
+    postings;
+    reference;
+    tags;
+    reverses;
+    constructor(fields) {
+        this.id = fields.id;
+        this.date = fields.date;
+        this.narration = fields.narration;
+        this.postings = Object.freeze(fields.postings);
+        this.reference = fields.reference;
+        this.tags = Object.freeze(fields.tags);
+        this.reverses = fields.reverses;
+        Object.freeze(this);
+    }
+    /**
+     * Build a validated entry. Throws unless:
+     * - there are at least two postings,
+     * - no posting is for zero,
+     * - the postings sum to zero *within each currency*,
+     * - and, when a chart is supplied, every account exists and is postable.
+     */
+    static create(input, chart) {
+        if (input.id.trim() === "")
+            throw new InvalidEntryError("Entry id must not be blank");
+        if (input.narration.trim() === "") {
+            throw new InvalidEntryError(`Entry ${input.id} must have a narration`);
+        }
+        if (input.postings.length < 2) {
+            throw new InvalidEntryError(`Entry ${input.id} has ${input.postings.length} posting(s); at least 2 are required`);
+        }
+        const when = parseDate(input.date);
+        const postings = input.postings.map((p, index) => {
+            if (p.amount.isZero) {
+                throw new InvalidEntryError(`Entry ${input.id} posting ${index} to ${p.account} is for zero`);
+            }
+            if (chart !== undefined)
+                chart.assertPostable(p.account);
+            const foreign = p.foreign ?? null;
+            if (foreign !== null) {
+                if (foreign.isZero) {
+                    throw new InvalidEntryError(`Entry ${input.id} posting ${index} to ${p.account} has a foreign amount of zero`);
+                }
+                if (foreign.currency.code === p.amount.currency.code) {
+                    throw new InvalidEntryError(`Entry ${input.id} posting ${index} to ${p.account} gives a ${foreign.currency.code} ` +
+                        `amount as the foreign side of a ${p.amount.currency.code} posting`);
+                }
+                if (foreign.sign !== p.amount.sign) {
+                    throw new InvalidEntryError(`Entry ${input.id} posting ${index} to ${p.account}: ${foreign.toString()} and ` +
+                        `${p.amount.toString()} are on opposite sides`);
+                }
+                // An account's declared currency is what its foreign balance is in.
+                // Letting a EUR posting land on a USD account would produce a balance
+                // that no single closing rate can retranslate.
+                const declared = chart?.find(p.account)?.currency;
+                if (declared !== undefined && declared.code !== foreign.currency.code) {
+                    throw new InvalidEntryError(`Entry ${input.id} posting ${index}: account ${p.account} is denominated in ` +
+                        `${declared.code}, not ${foreign.currency.code}`);
+                }
+            }
+            return Object.freeze({
+                account: p.account,
+                amount: p.amount,
+                memo: p.memo ?? "",
+                index,
+                reference: p.reference ?? null,
+                foreign,
+            });
+        });
+        const residuals = residualsByCurrency(postings.map((p) => p.amount));
+        if (residuals.length > 0)
+            throw new UnbalancedEntryError(residuals, input.narration);
+        return new JournalEntry({
+            id: input.id,
+            date: when,
+            narration: input.narration,
+            postings,
+            reference: input.reference ?? null,
+            tags: Object.freeze([...(input.tags ?? [])]),
+            reverses: input.reverses ?? null,
+        });
+    }
+    /** Convenience for the overwhelmingly common two-line entry. */
+    static simple(input, chart) {
+        if (input.amount.isNegative) {
+            throw new InvalidEntryError(`Entry ${input.id}: use a positive amount and name the debit and credit sides`);
+        }
+        const create = {
+            id: input.id,
+            date: input.date,
+            narration: input.narration,
+            postings: [
+                { account: input.debit, amount: input.amount },
+                { account: input.credit, amount: input.amount.negated() },
+            ],
+        };
+        if (input.reference !== undefined)
+            create.reference = input.reference;
+        if (input.tags !== undefined)
+            create.tags = input.tags;
+        return JournalEntry.create(create, chart);
+    }
+    // ---------------------------------------------------------------- accessors
+    get debits() {
+        return this.postings.filter((p) => p.amount.isPositive);
+    }
+    get credits() {
+        return this.postings.filter((p) => p.amount.isNegative);
+    }
+    get accounts() {
+        return [...new Set(this.postings.map((p) => p.account))];
+    }
+    get currencies() {
+        const seen = new Map();
+        for (const p of this.postings)
+            seen.set(p.amount.currency.code, p.amount.currency);
+        return [...seen.values()];
+    }
+    get isMultiCurrency() {
+        return this.currencies.length > 1;
+    }
+    /** Postings that record something that happened in another currency. */
+    get foreignPostings() {
+        return this.postings.filter((p) => p.foreign !== null);
+    }
+    get hasForeignAmounts() {
+        return this.postings.some((p) => p.foreign !== null);
+    }
+    /** The transaction currencies this entry touches, deduplicated. */
+    get foreignCurrencies() {
+        const seen = new Map();
+        for (const p of this.postings) {
+            if (p.foreign !== null)
+                seen.set(p.foreign.currency.code, p.foreign.currency);
+        }
+        return [...seen.values()];
+    }
+    /** Net foreign-currency effect on one account within this entry. */
+    foreignAmountFor(account, currency) {
+        const code = typeof currency === "string" ? currency.toUpperCase() : currency.code;
+        return sumMoney(this.postings
+            .filter((p) => p.account === account && p.foreign?.currency.code === code)
+            .map((p) => p.foreign), code);
+    }
+    /** Total of the debit side in the given currency — the entry's "size". */
+    total(currency) {
+        const code = currency === undefined
+            ? this.currencies[0].code
+            : typeof currency === "string"
+                ? currency.toUpperCase()
+                : currency.code;
+        const matching = this.debits.filter((p) => p.amount.currency.code === code);
+        return sumMoney(matching.map((p) => p.amount), code);
+    }
+    /** The open item a posting belongs to: its own, or the entry's. */
+    referenceFor(posting) {
+        return posting.reference ?? this.reference;
+    }
+    touches(account) {
+        return this.postings.some((p) => p.account === account);
+    }
+    /** Net effect on one account, summed across its postings in this entry. */
+    amountFor(account, currency) {
+        const relevant = this.postings.filter((p) => p.account === account);
+        const code = currency === undefined
+            ? (relevant[0]?.amount.currency ?? this.currencies[0]).code
+            : typeof currency === "string"
+                ? currency.toUpperCase()
+                : currency.code;
+        return sumMoney(relevant.filter((p) => p.amount.currency.code === code).map((p) => p.amount), code);
+    }
+    /** A mirror-image entry that undoes this one. */
+    reversal(input) {
+        return JournalEntry.create({
+            id: input.id,
+            date: input.date,
+            narration: input.narration ?? `Reversal of ${this.narration}`,
+            postings: this.postings.map((p) => ({
+                account: p.account,
+                amount: p.amount.negated(),
+                memo: p.memo,
+                ...(p.reference === null ? {} : { reference: p.reference }),
+                ...(p.foreign === null ? {} : { foreign: p.foreign.negated() }),
+            })),
+            ...(this.reference !== null ? { reference: this.reference } : {}),
+            tags: this.tags,
+            reverses: this.id,
+        });
+    }
+    toString() {
+        const lines = this.postings.map((p) => {
+            const base = `  ${p.account.padEnd(8)} ${p.amount.toDecimalString().padStart(12)}`;
+            return p.foreign === null ? base : `${base}  (${p.foreign.toString()})`;
+        });
+        return [`${this.date} ${this.id} ${this.narration}`, ...lines].join("\n");
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            date: this.date,
+            narration: this.narration,
+            reference: this.reference,
+            tags: this.tags,
+            reverses: this.reverses,
+            postings: this.postings.map((p) => ({
+                account: p.account,
+                amount: p.amount.toJSON(),
+                memo: p.memo,
+                reference: p.reference,
+                foreign: p.foreign === null ? null : p.foreign.toJSON(),
+            })),
+        };
+    }
+}
+/**
+ * Per-currency sums that are not zero. An empty result means the set balances.
+ * Exported because the ledger uses it to re-check invariants in bulk.
+ */
+export function residualsByCurrency(amounts) {
+    const totals = new Map();
+    for (const amount of amounts) {
+        const code = amount.currency.code;
+        const running = totals.get(code);
+        totals.set(code, running === undefined ? amount : running.plus(amount));
+    }
+    return [...totals.values()].filter((m) => !m.isZero);
+}
+export function isBalanced(amounts) {
+    return residualsByCurrency(amounts).length === 0;
+}

package/dist/ledger/index.d.ts

@@ -0,0 +1,6 @@
+export { type CalendarDate, type DateRange, InvalidDateError, date, isValidDate, parts, daysInMonth, toEpochDay, fromEpochDay, daysBetween, addDays, compareDates, minDate, maxDate, dayOfWeek, isWeekend, startOfMonth, endOfMonth, dateRange, withinRange, } from "./date.js";
+export { type Posting, type PostingInput, type JournalEntryInput, JournalEntry, UnbalancedEntryError, InvalidEntryError, residualsByCurrency, isBalanced, } from "./entry.js";
+export { type AccountBalance, Ledger, DuplicateEntryError, LedgerIntegrityError, } from "./ledger.js";
+export { type TrialBalance, type TrialBalanceRow, type TrialBalanceOptions, trialBalance, balancesByType, equationResidual, renderTrialBalance, } from "./trialBalance.js";
+export { type LedgerDocument, type EntryDocument, type PostingDocument, type AccountDocument, LedgerDocumentError, entryToDocument, ledgerToDocument, ledgerToJson, ledgerFromDocument, ledgerFromJson, } from "./serialise.js";
+export { type CloseOptions, CloseError, closingEntry, resultOver, withResultClosed, } from "./close.js";

package/dist/ledger/index.js

@@ -0,0 +1,6 @@
+export { InvalidDateError, date, isValidDate, parts, daysInMonth, toEpochDay, fromEpochDay, daysBetween, addDays, compareDates, minDate, maxDate, dayOfWeek, isWeekend, startOfMonth, endOfMonth, dateRange, withinRange, } from "./date.js";
+export { JournalEntry, UnbalancedEntryError, InvalidEntryError, residualsByCurrency, isBalanced, } from "./entry.js";
+export { Ledger, DuplicateEntryError, LedgerIntegrityError, } from "./ledger.js";
+export { trialBalance, balancesByType, equationResidual, renderTrialBalance, } from "./trialBalance.js";
+export { LedgerDocumentError, entryToDocument, ledgerToDocument, ledgerToJson, ledgerFromDocument, ledgerFromJson, } from "./serialise.js";
+export { CloseError, closingEntry, resultOver, withResultClosed, } from "./close.js";

package/dist/ledger/ledger.d.ts

@@ -0,0 +1,101 @@
+/**
+ * The ledger: an append-only sequence of journal entries with derived balances.
+ *
+ * `post` returns a *new* `Ledger` rather than mutating. That is not persistence
+ * theatre — reconciliation wants to try a set of proposed entries, look at the
+ * resulting balances, and throw the attempt away. Structural sharing keeps the
+ * entry list cheap; only the balance index is copied, and it is one small map.
+ */
+import { Money } from "../money/money.js";
+import type { Currency } from "../money/currency.js";
+import type { ChartOfAccounts } from "../accounts/chart.js";
+import { type CalendarDate, type DateRange } from "./date.js";
+import { JournalEntry, type JournalEntryInput } from "./entry.js";
+export declare class DuplicateEntryError extends Error {
+    readonly id: string;
+    constructor(id: string);
+}
+export declare class LedgerIntegrityError extends Error {
+    constructor(message: string);
+}
+export interface AccountBalance {
+    readonly account: string;
+    /** Signed: positive means a net debit, negative a net credit. */
+    readonly balance: Money;
+    /**
+     * The balance as an accountant would read it — positive when the account
+     * sits on its normal side. Income of 1,000 reads +1,000, not -1,000.
+     */
+    readonly natural: Money;
+    readonly debitTotal: Money;
+    readonly creditTotal: Money;
+    readonly postingCount: number;
+}
+export declare class Ledger {
+    private readonly entries;
+    private readonly index;
+    private readonly balances;
+    private readonly debitTotals;
+    private readonly creditTotals;
+    private readonly postingCounts;
+    readonly chart: ChartOfAccounts | undefined;
+    private constructor();
+    static empty(chart?: ChartOfAccounts): Ledger;
+    static from(entries: Iterable<JournalEntry>, chart?: ChartOfAccounts): Ledger;
+    /** Append an entry, returning a new ledger. Rejects duplicate ids. */
+    post(entry: JournalEntry): Ledger;
+    /** Build and post in one step, validating against the ledger's chart. */
+    record(input: JournalEntryInput): Ledger;
+    postMany(entries: Iterable<JournalEntry>): Ledger;
+    /** Append the reversal of an existing entry. */
+    reverse(entryId: string, options: {
+        id: string;
+        date: string;
+        narration?: string;
+    }): Ledger;
+    get size(): number;
+    get isEmpty(): boolean;
+    /** Entries in the order they were posted. */
+    all(): readonly JournalEntry[];
+    entry(id: string): JournalEntry | undefined;
+    has(id: string): boolean;
+    /** Entries sorted by date, ties broken by insertion order (stable). */
+    chronological(): readonly JournalEntry[];
+    filter(predicate: (entry: JournalEntry) => boolean): readonly JournalEntry[];
+    entriesFor(account: string): readonly JournalEntry[];
+    entriesIn(range: DateRange): readonly JournalEntry[];
+    entriesOn(day: CalendarDate): readonly JournalEntry[];
+    byReference(reference: string): readonly JournalEntry[];
+    /** Entries that have not been reversed by a later entry. */
+    live(): readonly JournalEntry[];
+    private currencyFor;
+    /** Signed balance of one account: positive is a net debit. */
+    balanceOf(account: string, currency?: Currency | string): Money;
+    /** Balance read on the account's normal side, using the chart's type. */
+    naturalBalanceOf(account: string, currency?: Currency | string): Money;
+    /** Balance of an account plus all its descendants. Requires a chart. */
+    rolledUpBalanceOf(account: string, currency?: Currency | string): Money;
+    /** Full detail for one account. */
+    accountBalance(account: string, currency?: Currency | string): AccountBalance;
+    /** Every account that has been posted to, sorted by code. */
+    activeAccounts(): readonly string[];
+    currenciesUsed(): readonly string[];
+    /**
+     * Balance of an account as at the end of a date, computed by replaying the
+     * relevant postings rather than from the index.
+     */
+    balanceAsAt(account: string, asAt: CalendarDate, currency?: Currency | string): Money;
+    /** Running balance after each posting to an account, in chronological order. */
+    statement(account: string, currency?: Currency | string): readonly {
+        entry: JournalEntry;
+        amount: Money;
+        running: Money;
+    }[];
+    /**
+     * Re-derive every balance from the entry list and compare against the index.
+     * The index is an optimisation; this is the check that it has not drifted.
+     */
+    verify(): void;
+    /** True when the whole ledger sums to zero in every currency. */
+    get isBalanced(): boolean;
+}

package/dist/ledger/ledger.js

@@ -0,0 +1,308 @@
+/**
+ * The ledger: an append-only sequence of journal entries with derived balances.
+ *
+ * `post` returns a *new* `Ledger` rather than mutating. That is not persistence
+ * theatre — reconciliation wants to try a set of proposed entries, look at the
+ * resulting balances, and throw the attempt away. Structural sharing keeps the
+ * entry list cheap; only the balance index is copied, and it is one small map.
+ */
+import { Money, sumMoney } from "../money/money.js";
+import { debitSign } from "../accounts/types.js";
+import { withinRange } from "./date.js";
+import { JournalEntry, residualsByCurrency } from "./entry.js";
+export class DuplicateEntryError extends Error {
+    id;
+    constructor(id) {
+        super(`Entry ${id} is already in the ledger`);
+        this.id = id;
+        this.name = "DuplicateEntryError";
+    }
+}
+export class LedgerIntegrityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LedgerIntegrityError";
+    }
+}
+/** Key for the balance index: one running total per account *and* currency. */
+function key(account, currencyCode) {
+    return `${account}\u0000${currencyCode}`;
+}
+export class Ledger {
+    entries;
+    index;
+    balances;
+    debitTotals;
+    creditTotals;
+    postingCounts;
+    chart;
+    constructor(entries, index, balances, debitTotals, creditTotals, postingCounts, chart) {
+        this.entries = entries;
+        this.index = index;
+        this.balances = balances;
+        this.debitTotals = debitTotals;
+        this.creditTotals = creditTotals;
+        this.postingCounts = postingCounts;
+        this.chart = chart;
+        Object.freeze(this);
+    }
+    static empty(chart) {
+        return new Ledger([], new Map(), new Map(), new Map(), new Map(), new Map(), chart);
+    }
+    static from(entries, chart) {
+        let ledger = Ledger.empty(chart);
+        for (const entry of entries)
+            ledger = ledger.post(entry);
+        return ledger;
+    }
+    // ------------------------------------------------------------------ writing
+    /** Append an entry, returning a new ledger. Rejects duplicate ids. */
+    post(entry) {
+        if (this.index.has(entry.id))
+            throw new DuplicateEntryError(entry.id);
+        if (this.chart !== undefined) {
+            for (const posting of entry.postings)
+                this.chart.assertPostable(posting.account);
+        }
+        const balances = new Map(this.balances);
+        const debitTotals = new Map(this.debitTotals);
+        const creditTotals = new Map(this.creditTotals);
+        const postingCounts = new Map(this.postingCounts);
+        for (const posting of entry.postings) {
+            const k = key(posting.account, posting.amount.currency.code);
+            const minor = posting.amount.minorUnits;
+            balances.set(k, (balances.get(k) ?? 0n) + minor);
+            if (minor > 0n)
+                debitTotals.set(k, (debitTotals.get(k) ?? 0n) + minor);
+            else
+                creditTotals.set(k, (creditTotals.get(k) ?? 0n) - minor);
+            postingCounts.set(k, (postingCounts.get(k) ?? 0) + 1);
+        }
+        const index = new Map(this.index);
+        index.set(entry.id, entry.id);
+        return new Ledger([...this.entries, entry], index, balances, debitTotals, creditTotals, postingCounts, this.chart);
+    }
+    /** Build and post in one step, validating against the ledger's chart. */
+    record(input) {
+        return this.post(JournalEntry.create(input, this.chart));
+    }
+    postMany(entries) {
+        let ledger = this;
+        for (const entry of entries)
+            ledger = ledger.post(entry);
+        return ledger;
+    }
+    /** Append the reversal of an existing entry. */
+    reverse(entryId, options) {
+        const original = this.entry(entryId);
+        if (original === undefined) {
+            throw new LedgerIntegrityError(`Cannot reverse unknown entry ${entryId}`);
+        }
+        return this.post(original.reversal(options));
+    }
+    // ------------------------------------------------------------------ reading
+    get size() {
+        return this.entries.length;
+    }
+    get isEmpty() {
+        return this.entries.length === 0;
+    }
+    /** Entries in the order they were posted. */
+    all() {
+        return this.entries;
+    }
+    entry(id) {
+        return this.index.has(id) ? this.entries.find((e) => e.id === id) : undefined;
+    }
+    has(id) {
+        return this.index.has(id);
+    }
+    /** Entries sorted by date, ties broken by insertion order (stable). */
+    chronological() {
+        return this.entries
+            .map((entry, position) => ({ entry, position }))
+            .sort((a, b) => a.entry.date === b.entry.date
+            ? a.position - b.position
+            : a.entry.date < b.entry.date
+                ? -1
+                : 1)
+            .map((x) => x.entry);
+    }
+    filter(predicate) {
+        return this.entries.filter(predicate);
+    }
+    entriesFor(account) {
+        return this.entries.filter((e) => e.touches(account));
+    }
+    entriesIn(range) {
+        return this.entries.filter((e) => withinRange(e.date, range));
+    }
+    entriesOn(day) {
+        return this.entries.filter((e) => e.date === day);
+    }
+    byReference(reference) {
+        return this.entries.filter((e) => e.reference === reference);
+    }
+    /** Entries that have not been reversed by a later entry. */
+    live() {
+        const reversed = new Set(this.entries.map((e) => e.reverses).filter((id) => id !== null));
+        return this.entries.filter((e) => !reversed.has(e.id) && e.reverses === null);
+    }
+    // ----------------------------------------------------------------- balances
+    currencyFor(account) {
+        const fromChart = this.chart?.find(account)?.currency;
+        if (fromChart !== undefined)
+            return fromChart;
+        for (const entry of this.entries) {
+            for (const posting of entry.postings) {
+                if (posting.account === account)
+                    return posting.amount.currency;
+            }
+        }
+        return this.chart?.defaultCurrency ?? Money.parse("0", "GBP").currency;
+    }
+    /** Signed balance of one account: positive is a net debit. */
+    balanceOf(account, currency) {
+        const c = currency ?? this.currencyFor(account);
+        const code = typeof c === "string" ? c.toUpperCase() : c.code;
+        return Money.ofMinor(this.balances.get(key(account, code)) ?? 0n, code);
+    }
+    /** Balance read on the account's normal side, using the chart's type. */
+    naturalBalanceOf(account, currency) {
+        const signed = this.balanceOf(account, currency);
+        const type = this.chart?.find(account)?.type;
+        if (type === undefined)
+            return signed;
+        return debitSign(type) === 1 ? signed : signed.negated();
+    }
+    /** Balance of an account plus all its descendants. Requires a chart. */
+    rolledUpBalanceOf(account, currency) {
+        if (this.chart === undefined) {
+            throw new LedgerIntegrityError("Rolled-up balances need a chart of accounts");
+        }
+        const codes = this.chart.subtree(account).map((a) => a.code);
+        const c = currency ?? this.chart.get(account).currency;
+        return sumMoney(codes.map((code) => this.balanceOf(code, c)), typeof c === "string" ? c : c.code);
+    }
+    /** Full detail for one account. */
+    accountBalance(account, currency) {
+        const c = currency ?? this.currencyFor(account);
+        const code = typeof c === "string" ? c.toUpperCase() : c.code;
+        const k = key(account, code);
+        const balance = Money.ofMinor(this.balances.get(k) ?? 0n, code);
+        const type = this.chart?.find(account)?.type;
+        return Object.freeze({
+            account,
+            balance,
+            natural: type === undefined || debitSign(type) === 1 ? balance : balance.negated(),
+            debitTotal: Money.ofMinor(this.debitTotals.get(k) ?? 0n, code),
+            creditTotal: Money.ofMinor(this.creditTotals.get(k) ?? 0n, code),
+            postingCount: this.postingCounts.get(k) ?? 0,
+        });
+    }
+    /** Every account that has been posted to, sorted by code. */
+    activeAccounts() {
+        const codes = new Set();
+        for (const k of this.balances.keys())
+            codes.add(k.split("\u0000")[0]);
+        return [...codes].sort();
+    }
+    currenciesUsed() {
+        const codes = new Set();
+        for (const k of this.balances.keys())
+            codes.add(k.split("\u0000")[1]);
+        return [...codes].sort();
+    }
+    /**
+     * Balance of an account as at the end of a date, computed by replaying the
+     * relevant postings rather than from the index.
+     */
+    balanceAsAt(account, asAt, currency) {
+        const c = currency ?? this.currencyFor(account);
+        const code = typeof c === "string" ? c.toUpperCase() : c.code;
+        let total = 0n;
+        for (const entry of this.entries) {
+            if (entry.date > asAt)
+                continue;
+            for (const posting of entry.postings) {
+                if (posting.account === account && posting.amount.currency.code === code) {
+                    total += posting.amount.minorUnits;
+                }
+            }
+        }
+        return Money.ofMinor(total, code);
+    }
+    /** Running balance after each posting to an account, in chronological order. */
+    statement(account, currency) {
+        const c = currency ?? this.currencyFor(account);
+        const code = typeof c === "string" ? c.toUpperCase() : c.code;
+        let running = 0n;
+        const rows = [];
+        for (const entry of this.chronological()) {
+            for (const posting of entry.postings) {
+                if (posting.account !== account)
+                    continue;
+                if (posting.amount.currency.code !== code)
+                    continue;
+                running += posting.amount.minorUnits;
+                rows.push({
+                    entry,
+                    amount: posting.amount,
+                    running: Money.ofMinor(running, code),
+                });
+            }
+        }
+        return rows;
+    }
+    // ---------------------------------------------------------------- integrity
+    /**
+     * Re-derive every balance from the entry list and compare against the index.
+     * The index is an optimisation; this is the check that it has not drifted.
+     */
+    verify() {
+        const recomputed = new Map();
+        const seen = new Set();
+        for (const entry of this.entries) {
+            if (seen.has(entry.id)) {
+                throw new LedgerIntegrityError(`Duplicate entry id in ledger: ${entry.id}`);
+            }
+            seen.add(entry.id);
+            const residuals = residualsByCurrency(entry.postings.map((p) => p.amount));
+            if (residuals.length > 0) {
+                throw new LedgerIntegrityError(`Entry ${entry.id} does not balance`);
+            }
+            for (const posting of entry.postings) {
+                const k = key(posting.account, posting.amount.currency.code);
+                recomputed.set(k, (recomputed.get(k) ?? 0n) + posting.amount.minorUnits);
+            }
+        }
+        for (const [k, expected] of recomputed) {
+            if ((this.balances.get(k) ?? 0n) !== expected) {
+                throw new LedgerIntegrityError(`Balance index drifted for ${k.replace("\u0000", "/")}`);
+            }
+        }
+        for (const [k, actual] of this.balances) {
+            if ((recomputed.get(k) ?? 0n) !== actual) {
+                throw new LedgerIntegrityError(`Stale balance index entry for ${k.replace("\u0000", "/")}`);
+            }
+        }
+        for (const code of this.currenciesUsed()) {
+            const total = [...this.balances.entries()]
+                .filter(([k]) => k.endsWith(`\u0000${code}`))
+                .reduce((a, [, v]) => a + v, 0n);
+            if (total !== 0n) {
+                throw new LedgerIntegrityError(`Ledger does not balance in ${code}: residual ${total} minor units`);
+            }
+        }
+    }
+    /** True when the whole ledger sums to zero in every currency. */
+    get isBalanced() {
+        try {
+            this.verify();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}