tallyd 0.0.0-stage → 0.1.0

package/dist/money/money.js

@@ -0,0 +1,300 @@
+/**
+ * `Money` — an exact amount in a single currency.
+ *
+ * The amount is a bigint count of minor units (pence, cents, yen). There is no
+ * float anywhere in this file and no way to construct a `Money` from one
+ * without going through an explicit, rounded conversion.
+ *
+ * Binary operations between different currencies throw. That is deliberate:
+ * a silent currency mix-up is the kind of bug that reconciles to zero and is
+ * wrong by thousands.
+ */
+import { currency as lookupCurrency, minorUnitScale, } from "./currency.js";
+import { decimalToRational, divideRound, numberToRational, } from "./rounding.js";
+export class CurrencyMismatchError extends Error {
+    left;
+    right;
+    constructor(left, right) {
+        super(`Currency mismatch: ${left.code} and ${right.code}`);
+        this.left = left;
+        this.right = right;
+        this.name = "CurrencyMismatchError";
+    }
+}
+export class Money {
+    /** Signed count of minor units. */
+    minorUnits;
+    currency;
+    constructor(minorUnits, currency) {
+        this.minorUnits = minorUnits;
+        this.currency = currency;
+        Object.freeze(this);
+    }
+    // ---------------------------------------------------------------- factories
+    /** Construct directly from minor units: `Money.ofMinor(1250n, GBP)` is £12.50. */
+    static ofMinor(minorUnits, currency) {
+        const c = typeof currency === "string" ? lookupCurrency(currency) : currency;
+        if (typeof minorUnits === "number") {
+            if (!Number.isSafeInteger(minorUnits)) {
+                throw new RangeError(`Minor units must be a safe integer, got: ${minorUnits}`);
+            }
+            return new Money(BigInt(minorUnits), c);
+        }
+        return new Money(minorUnits, c);
+    }
+    /**
+     * Parse a decimal string in major units: `Money.parse("12.50", GBP)`.
+     *
+     * Extra precision is an error rather than a silent rounding, because a
+     * statement line reading `1.005` means the importer misread the file.
+     * Pass a rounding mode to opt into truncation explicitly.
+     */
+    static parse(text, currency, rounding) {
+        const c = typeof currency === "string" ? lookupCurrency(currency) : currency;
+        const cleaned = text.trim().replace(/,/g, "");
+        const { numerator, denominator } = decimalToRational(cleaned);
+        const scale = minorUnitScale(c);
+        const scaledNumerator = numerator * scale;
+        if (rounding === undefined && scaledNumerator % denominator !== 0n) {
+            throw new RangeError(`${text} has more precision than ${c.code} allows (${c.exponent} dp)`);
+        }
+        return new Money(divideRound(scaledNumerator, denominator, rounding ?? "half-even"), c);
+    }
+    /** Zero in the given currency. */
+    static zero(currency) {
+        return Money.ofMinor(0n, currency);
+    }
+    /**
+     * Convert from a JS number of major units. Lossy by nature, so the rounding
+     * mode is required at the call site — no defaults to hide behind.
+     */
+    static fromNumber(value, currency, rounding) {
+        const c = typeof currency === "string" ? lookupCurrency(currency) : currency;
+        const { numerator, denominator } = numberToRational(value);
+        return new Money(divideRound(numerator * minorUnitScale(c), denominator, rounding), c);
+    }
+    // --------------------------------------------------------------- predicates
+    get isZero() {
+        return this.minorUnits === 0n;
+    }
+    get isPositive() {
+        return this.minorUnits > 0n;
+    }
+    get isNegative() {
+        return this.minorUnits < 0n;
+    }
+    get sign() {
+        if (this.minorUnits > 0n)
+            return 1;
+        if (this.minorUnits < 0n)
+            return -1;
+        return 0;
+    }
+    sameCurrency(other) {
+        return this.currency.code === other.currency.code;
+    }
+    assertSameCurrency(other) {
+        if (!this.sameCurrency(other)) {
+            throw new CurrencyMismatchError(this.currency, other.currency);
+        }
+    }
+    // --------------------------------------------------------------- arithmetic
+    plus(other) {
+        this.assertSameCurrency(other);
+        return new Money(this.minorUnits + other.minorUnits, this.currency);
+    }
+    minus(other) {
+        this.assertSameCurrency(other);
+        return new Money(this.minorUnits - other.minorUnits, this.currency);
+    }
+    negated() {
+        return new Money(-this.minorUnits, this.currency);
+    }
+    abs() {
+        return this.minorUnits < 0n ? this.negated() : this;
+    }
+    /** Multiply by a whole number. Always exact — no rounding mode needed. */
+    timesInteger(factor) {
+        const f = typeof factor === "number" ? BigInt(assertSafeInteger(factor)) : factor;
+        return new Money(this.minorUnits * f, this.currency);
+    }
+    /**
+     * Multiply by an arbitrary factor — a rate, a percentage, a decimal string.
+     * Rounds to whole minor units using the given mode (banker's by default).
+     */
+    times(factor, rounding = "half-even") {
+        if (typeof factor === "bigint")
+            return this.timesInteger(factor);
+        const { numerator, denominator } = typeof factor === "number" ? numberToRational(factor) : decimalToRational(factor);
+        return new Money(divideRound(this.minorUnits * numerator, denominator, rounding), this.currency);
+    }
+    /** Divide by a number, rounding to whole minor units. */
+    dividedBy(divisor, rounding = "half-even") {
+        const { numerator, denominator } = typeof divisor === "bigint"
+            ? { numerator: divisor, denominator: 1n }
+            : typeof divisor === "number"
+                ? numberToRational(divisor)
+                : decimalToRational(divisor);
+        if (numerator === 0n)
+            throw new RangeError("Division by zero");
+        return new Money(divideRound(this.minorUnits * denominator, numerator, rounding), this.currency);
+    }
+    /** The ratio of two amounts as a plain number. Presentation only. */
+    ratioTo(other) {
+        this.assertSameCurrency(other);
+        if (other.minorUnits === 0n)
+            throw new RangeError("Division by zero");
+        return Number(this.minorUnits) / Number(other.minorUnits);
+    }
+    // ---------------------------------------------------------------- splitting
+    /**
+     * Split into `n` parts that sum exactly back to the original.
+     *
+     * The remainder is handed out one minor unit at a time from the front, so
+     * £100 / 3 gives 33.34, 33.33, 33.33. Negative amounts distribute the
+     * remainder the same way, keeping `split(n).reduce(add) === original`.
+     */
+    split(parts) {
+        if (!Number.isSafeInteger(parts) || parts <= 0) {
+            throw new RangeError(`Split count must be a positive integer, got: ${parts}`);
+        }
+        const n = BigInt(parts);
+        const base = this.minorUnits / n; // bigint division truncates toward zero
+        let remainder = this.minorUnits - base * n;
+        const step = remainder < 0n ? -1n : 1n;
+        const out = [];
+        for (let i = 0n; i < n; i++) {
+            let share = base;
+            if (remainder !== 0n) {
+                share += step;
+                remainder -= step;
+            }
+            out.push(new Money(share, this.currency));
+        }
+        return out;
+    }
+    /**
+     * Split in proportion to `weights` using the largest-remainder method.
+     *
+     * Every unit is accounted for: the parts always sum to the original. Where
+     * two candidates have the same remainder the earlier one wins, which makes
+     * the result deterministic rather than merely correct in aggregate.
+     */
+    allocate(weights) {
+        if (weights.length === 0)
+            throw new RangeError("Allocation needs at least one weight");
+        const w = weights.map((x) => (typeof x === "bigint" ? x : BigInt(assertSafeInteger(x))));
+        if (w.some((x) => x < 0n))
+            throw new RangeError("Allocation weights must be non-negative");
+        const total = w.reduce((a, b) => a + b, 0n);
+        if (total === 0n)
+            throw new RangeError("Allocation weights must not all be zero");
+        const negative = this.minorUnits < 0n;
+        const magnitude = negative ? -this.minorUnits : this.minorUnits;
+        const shares = w.map((weight) => (magnitude * weight) / total);
+        const remainders = w.map((weight, i) => {
+            const share = shares[i];
+            return { index: i, remainder: magnitude * weight - share * total };
+        });
+        let leftover = magnitude - shares.reduce((a, b) => a + b, 0n);
+        remainders.sort((a, b) => a.remainder === b.remainder ? a.index - b.index : a.remainder > b.remainder ? -1 : 1);
+        for (const entry of remainders) {
+            if (leftover <= 0n)
+                break;
+            shares[entry.index] = shares[entry.index] + 1n;
+            leftover -= 1n;
+        }
+        return shares.map((s) => new Money(negative ? -s : s, this.currency));
+    }
+    // -------------------------------------------------------------- comparisons
+    compare(other) {
+        this.assertSameCurrency(other);
+        if (this.minorUnits > other.minorUnits)
+            return 1;
+        if (this.minorUnits < other.minorUnits)
+            return -1;
+        return 0;
+    }
+    equals(other) {
+        return this.sameCurrency(other) && this.minorUnits === other.minorUnits;
+    }
+    greaterThan(other) {
+        return this.compare(other) > 0;
+    }
+    greaterThanOrEqual(other) {
+        return this.compare(other) >= 0;
+    }
+    lessThan(other) {
+        return this.compare(other) < 0;
+    }
+    lessThanOrEqual(other) {
+        return this.compare(other) <= 0;
+    }
+    /** True when the two differ by no more than `tolerance` (which must be >= 0). */
+    within(other, tolerance) {
+        this.assertSameCurrency(other);
+        this.assertSameCurrency(tolerance);
+        if (tolerance.isNegative)
+            throw new RangeError("Tolerance must be non-negative");
+        return this.minus(other).abs().lessThanOrEqual(tolerance);
+    }
+    // ------------------------------------------------------------- presentation
+    /** The amount as a decimal string in major units, e.g. "-12.50". */
+    toDecimalString() {
+        const scale = minorUnitScale(this.currency);
+        const negative = this.minorUnits < 0n;
+        const magnitude = negative ? -this.minorUnits : this.minorUnits;
+        const whole = magnitude / scale;
+        const sign = negative ? "-" : "";
+        if (this.currency.exponent === 0)
+            return `${sign}${whole}`;
+        const fraction = (magnitude % scale).toString().padStart(this.currency.exponent, "0");
+        return `${sign}${whole}.${fraction}`;
+    }
+    /** Human-facing form with symbol and thousands separators: "£1,234.50". */
+    format(options = {}) {
+        const { symbol = true, grouping = true } = options;
+        const decimal = this.toDecimalString();
+        const negative = decimal.startsWith("-");
+        const body = negative ? decimal.slice(1) : decimal;
+        const dot = body.indexOf(".");
+        let whole = dot === -1 ? body : body.slice(0, dot);
+        const fraction = dot === -1 ? "" : body.slice(dot);
+        if (grouping)
+            whole = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+        const prefix = symbol ? this.currency.symbol : "";
+        return `${negative ? "-" : ""}${prefix}${whole}${fraction}`;
+    }
+    toString() {
+        return `${this.toDecimalString()} ${this.currency.code}`;
+    }
+    toJSON() {
+        return { amount: this.minorUnits.toString(), currency: this.currency.code };
+    }
+    static fromJSON(value) {
+        return Money.ofMinor(BigInt(value.amount), lookupCurrency(value.currency));
+    }
+}
+function assertSafeInteger(value) {
+    if (!Number.isSafeInteger(value)) {
+        throw new RangeError(`Expected a safe integer, got: ${value}`);
+    }
+    return value;
+}
+/** Sum a list of amounts. Requires the currency when the list may be empty. */
+export function sumMoney(amounts, currency) {
+    const first = amounts[0];
+    if (first === undefined) {
+        if (currency === undefined) {
+            throw new RangeError("Cannot sum an empty list without an explicit currency");
+        }
+        return Money.zero(currency);
+    }
+    return amounts.reduce((a, b) => a.plus(b), Money.zero(currency ?? first.currency));
+}
+export function minMoney(a, b) {
+    return a.lessThanOrEqual(b) ? a : b;
+}
+export function maxMoney(a, b) {
+    return a.greaterThanOrEqual(b) ? a : b;
+}

package/dist/money/rounding.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Integer division with an explicit rounding policy.
+ *
+ * Every rounding decision in the accounting path routes through here, so there
+ * is exactly one place where the tie-breaking rules live. All arithmetic is on
+ * bigints: nothing in this file can lose precision, only choose a direction.
+ */
+export type RoundingMode = 
+/** Toward +infinity. */
+"ceil"
+/** Toward -infinity. */
+ | "floor"
+/** Toward zero (truncate). */
+ | "down"
+/** Away from zero. */
+ | "up"
+/** Nearest; ties away from zero. The intuitive schoolbook rule. */
+ | "half-up"
+/** Nearest; ties toward zero. */
+ | "half-down"
+/** Nearest; ties to the even neighbour. Banker's rounding. */
+ | "half-even";
+export declare const ROUNDING_MODES: readonly RoundingMode[];
+/**
+ * Divide `numerator` by `denominator`, returning an exact integer under the
+ * given rounding mode. Throws on a zero denominator.
+ */
+export declare function divideRound(numerator: bigint, denominator: bigint, mode?: RoundingMode): bigint;
+/**
+ * Parse a decimal literal into an exact rational. Accepts optional sign,
+ * digits, a fractional part and scientific notation: "-1.25", "3", "2.5e-3".
+ */
+export declare function decimalToRational(input: string): {
+    numerator: bigint;
+    denominator: bigint;
+};
+/** Convert a finite JS number to an exact rational via its shortest decimal form. */
+export declare function numberToRational(value: number): {
+    numerator: bigint;
+    denominator: bigint;
+};

package/dist/money/rounding.js

@@ -0,0 +1,117 @@
+/**
+ * Integer division with an explicit rounding policy.
+ *
+ * Every rounding decision in the accounting path routes through here, so there
+ * is exactly one place where the tie-breaking rules live. All arithmetic is on
+ * bigints: nothing in this file can lose precision, only choose a direction.
+ */
+export const ROUNDING_MODES = [
+    "ceil",
+    "floor",
+    "down",
+    "up",
+    "half-up",
+    "half-down",
+    "half-even",
+];
+function abs(v) {
+    return v < 0n ? -v : v;
+}
+/**
+ * Divide `numerator` by `denominator`, returning an exact integer under the
+ * given rounding mode. Throws on a zero denominator.
+ */
+export function divideRound(numerator, denominator, mode = "half-even") {
+    if (denominator === 0n)
+        throw new RangeError("Division by zero");
+    // Normalise so the denominator is positive; the sign lives in the numerator.
+    let n = numerator;
+    let d = denominator;
+    if (d < 0n) {
+        n = -n;
+        d = -d;
+    }
+    const negative = n < 0n;
+    const magnitude = abs(n);
+    const quotient = magnitude / d;
+    const remainder = magnitude - quotient * d;
+    if (remainder === 0n)
+        return negative ? -quotient : quotient;
+    // `roundAway` decides whether to move the magnitude up to the next integer.
+    let roundAway;
+    switch (mode) {
+        case "down":
+            roundAway = false;
+            break;
+        case "up":
+            roundAway = true;
+            break;
+        case "ceil":
+            roundAway = !negative;
+            break;
+        case "floor":
+            roundAway = negative;
+            break;
+        case "half-up":
+        case "half-down":
+        case "half-even": {
+            const twice = remainder * 2n;
+            if (twice > d) {
+                roundAway = true;
+            }
+            else if (twice < d) {
+                roundAway = false;
+            }
+            else if (mode === "half-up") {
+                roundAway = true;
+            }
+            else if (mode === "half-down") {
+                roundAway = false;
+            }
+            else {
+                roundAway = quotient % 2n !== 0n;
+            }
+            break;
+        }
+    }
+    const rounded = roundAway ? quotient + 1n : quotient;
+    return negative ? -rounded : rounded;
+}
+/**
+ * Parse a decimal literal into an exact rational. Accepts optional sign,
+ * digits, a fractional part and scientific notation: "-1.25", "3", "2.5e-3".
+ */
+export function decimalToRational(input) {
+    const text = input.trim();
+    const match = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(text);
+    if (match === null)
+        throw new RangeError(`Not a decimal number: ${JSON.stringify(input)}`);
+    const [, sign = "", whole = "", fraction = "", exponent] = match;
+    if (whole === "" && fraction === "") {
+        throw new RangeError(`Not a decimal number: ${JSON.stringify(input)}`);
+    }
+    let numerator = BigInt((whole === "" ? "0" : whole) + fraction);
+    let denominator = 10n ** BigInt(fraction.length);
+    if (exponent !== undefined) {
+        let e = BigInt(exponent);
+        // Cancel against the fractional denominator before growing the numerator,
+        // so "2.5e2" comes back as 250/1 rather than 2500/10.
+        while (e > 0n && denominator % 10n === 0n && denominator > 1n) {
+            denominator /= 10n;
+            e -= 1n;
+        }
+        if (e > 0n)
+            numerator *= 10n ** e;
+        else if (e < 0n)
+            denominator *= 10n ** -e;
+    }
+    if (sign === "-")
+        numerator = -numerator;
+    return { numerator, denominator };
+}
+/** Convert a finite JS number to an exact rational via its shortest decimal form. */
+export function numberToRational(value) {
+    if (!Number.isFinite(value))
+        throw new RangeError(`Factor must be finite, got: ${value}`);
+    return decimalToRational(value.toString());
+}

package/dist/reconcile/accuracy.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Scoring the matcher itself.
+ *
+ * A reconciliation engine can be wrong in two directions and they are not
+ * equally bad. Missing a match costs a reviewer a minute. *Making* a wrong
+ * match costs them an afternoon, because the evidence has been consumed and the
+ * two lines it should have paired are now stranded somewhere else in the
+ * report. So the two are reported separately rather than folded into one
+ * accuracy number that hides which kind of wrong it is.
+ *
+ * The vocabulary is the standard one, applied to whole matches rather than
+ * lines. A match is *correct* when the exact set of book lines and the exact
+ * set of statement lines in it agree with the ground truth; a batch that got
+ * eight of its nine invoices is not eight-ninths right, it is wrong, because a
+ * reviewer given it would have to redo the work.
+ *
+ * `suggested` matches are counted apart from `matched` ones throughout. A
+ * suggestion the engine got wrong is not a failure of the same kind: it was
+ * shown to a human and labelled as needing a decision, which is the system
+ * working as designed.
+ */
+import type { ReconciliationResult } from "./matcher.js";
+/** One statement line and the book lines it really came from. */
+export interface TruthLink {
+    readonly statementId: string;
+    readonly bookIds: readonly string[];
+}
+export interface AccuracyReport {
+    /** Auto-accepted matches that agree with the truth exactly. */
+    readonly correct: number;
+    /** Auto-accepted matches that pair lines the truth says do not belong together. */
+    readonly wrong: number;
+    /** True links the engine neither matched nor suggested. */
+    readonly missed: number;
+    /** Suggestions that turn out to be right — work saved, but not claimed. */
+    readonly suggestedCorrect: number;
+    /** Suggestions that turn out to be wrong — a reviewer's time, not an error. */
+    readonly suggestedWrong: number;
+    /** Links in the ground truth. */
+    readonly expected: number;
+    /**
+     * Of the pairings the engine committed to, the share that were right.
+     * The number that matters: a low precision means it is inventing matches.
+     */
+    readonly precision: number;
+    /** Of the pairings that existed, the share the engine committed to. */
+    readonly recall: number;
+    /** Recall counting suggestions as found, which is what a reviewer sees. */
+    readonly recallWithSuggestions: number;
+    /** Harmonic mean of precision and recall over committed matches. */
+    readonly f1: number;
+    /** The wrong auto-accepted matches, for looking at. */
+    readonly failures: readonly AccuracyFailure[];
+}
+export interface AccuracyFailure {
+    readonly statementIds: readonly string[];
+    readonly bookIds: readonly string[];
+    readonly score: number;
+    readonly reason: "no truth for these lines" | "paired the wrong lines";
+}
+/**
+ * How well did this reconciliation do against what really happened?
+ */
+export declare function measureAccuracy(result: ReconciliationResult, truth: readonly TruthLink[]): AccuracyReport;
+export declare function renderAccuracy(report: AccuracyReport): string;

package/dist/reconcile/accuracy.js

@@ -0,0 +1,162 @@
+/**
+ * Scoring the matcher itself.
+ *
+ * A reconciliation engine can be wrong in two directions and they are not
+ * equally bad. Missing a match costs a reviewer a minute. *Making* a wrong
+ * match costs them an afternoon, because the evidence has been consumed and the
+ * two lines it should have paired are now stranded somewhere else in the
+ * report. So the two are reported separately rather than folded into one
+ * accuracy number that hides which kind of wrong it is.
+ *
+ * The vocabulary is the standard one, applied to whole matches rather than
+ * lines. A match is *correct* when the exact set of book lines and the exact
+ * set of statement lines in it agree with the ground truth; a batch that got
+ * eight of its nine invoices is not eight-ninths right, it is wrong, because a
+ * reviewer given it would have to redo the work.
+ *
+ * `suggested` matches are counted apart from `matched` ones throughout. A
+ * suggestion the engine got wrong is not a failure of the same kind: it was
+ * shown to a human and labelled as needing a decision, which is the system
+ * working as designed.
+ */
+/** A canonical key for a set of ids, so two orderings compare equal. */
+function setKey(ids) {
+    return [...new Set(ids)].sort().join("+");
+}
+function matchKey(match) {
+    return {
+        statement: setKey(match.statement.map((line) => line.id)),
+        book: setKey(match.book.map((line) => line.id)),
+    };
+}
+/**
+ * Fold the ground truth into the same shape a match has.
+ *
+ * Truth arrives one statement line at a time, but a many-to-one match covers
+ * several statement lines at once, so links that share book lines have to be
+ * merged before the two can be compared. Union-find over the shared ids does
+ * it: two links belong together exactly when they touch the same book line.
+ */
+function truthGroups(truth) {
+    const owner = new Map();
+    const parent = [];
+    const find = (node) => {
+        let root = node;
+        while (parent[root] !== root)
+            root = parent[root];
+        let walk = node;
+        while (parent[walk] !== walk) {
+            const next = parent[walk];
+            parent[walk] = root;
+            walk = next;
+        }
+        return root;
+    };
+    const union = (a, b) => {
+        const rootA = find(a);
+        const rootB = find(b);
+        if (rootA !== rootB)
+            parent[rootB] = rootA;
+    };
+    truth.forEach((link, index) => {
+        parent[index] = index;
+        for (const id of link.bookIds) {
+            const seen = owner.get(id);
+            if (seen === undefined)
+                owner.set(id, index);
+            else
+                union(seen, index);
+        }
+    });
+    const statementsByRoot = new Map();
+    const booksByRoot = new Map();
+    truth.forEach((link, index) => {
+        const root = find(index);
+        let statements = statementsByRoot.get(root);
+        if (statements === undefined) {
+            statements = [];
+            statementsByRoot.set(root, statements);
+        }
+        statements.push(link.statementId);
+        let books = booksByRoot.get(root);
+        if (books === undefined) {
+            books = [];
+            booksByRoot.set(root, books);
+        }
+        books.push(...link.bookIds);
+    });
+    // Keyed by the statement side, valued by the book side: a proposed match is
+    // correct when its statement key is present and its book key agrees.
+    const groups = new Map();
+    for (const [root, statements] of statementsByRoot) {
+        groups.set(setKey(statements), setKey(booksByRoot.get(root) ?? []));
+    }
+    return groups;
+}
+/**
+ * How well did this reconciliation do against what really happened?
+ */
+export function measureAccuracy(result, truth) {
+    const groups = truthGroups(truth);
+    const found = new Set();
+    const failures = [];
+    let correct = 0;
+    let wrong = 0;
+    for (const match of result.matched) {
+        const key = matchKey(match);
+        const expected = groups.get(key.statement);
+        if (expected === key.book) {
+            correct += 1;
+            found.add(key.statement);
+        }
+        else {
+            wrong += 1;
+            failures.push(Object.freeze({
+                statementIds: Object.freeze(match.statement.map((line) => line.id)),
+                bookIds: Object.freeze(match.book.map((line) => line.id)),
+                score: match.scored.score,
+                reason: expected === undefined ? "no truth for these lines" : "paired the wrong lines",
+            }));
+        }
+    }
+    let suggestedCorrect = 0;
+    let suggestedWrong = 0;
+    for (const match of result.suggested) {
+        const key = matchKey(match);
+        if (groups.get(key.statement) === key.book) {
+            suggestedCorrect += 1;
+            found.add(key.statement);
+        }
+        else {
+            suggestedWrong += 1;
+        }
+    }
+    const expected = groups.size;
+    const committed = correct + wrong;
+    const precision = committed === 0 ? 1 : correct / committed;
+    const recall = expected === 0 ? 1 : correct / expected;
+    const recallWithSuggestions = expected === 0 ? 1 : found.size / expected;
+    const f1 = precision + recall === 0 ? 0 : (2 * precision * recall) / (precision + recall);
+    return Object.freeze({
+        correct,
+        wrong,
+        missed: expected - found.size,
+        suggestedCorrect,
+        suggestedWrong,
+        expected,
+        precision,
+        recall,
+        recallWithSuggestions,
+        f1,
+        failures: Object.freeze(failures),
+    });
+}
+const percent = (value) => `${(value * 100).toFixed(1)}%`;
+export function renderAccuracy(report) {
+    return [
+        `expected ${report.expected}  correct ${report.correct}  wrong ${report.wrong}  missed ${report.missed}`,
+        `suggested ${report.suggestedCorrect} right / ${report.suggestedWrong} wrong`,
+        `precision ${percent(report.precision)}  recall ${percent(report.recall)}` +
+            `  recall incl. suggestions ${percent(report.recallWithSuggestions)}  F1 ${report.f1.toFixed(3)}`,
+    ].join("\n");
+}