earnrate 0.2.0 → 0.2.1

package/dist/cli/wallet.js

@@ -1,9 +1,9 @@
 import { parseArgs } from 'node:util';
 import { CLI_NAME } from "../brand.js";
+import { FileWalletStore } from "../data/file-store.js";
 import { loadCatalog, loadWallet, walletPath } from "../data/load.js";
-import { addCard, removeCard, setMemberships, updateCard, } from "../data/wallet-setup.js";
 import { knownMemberships, searchCards } from "../engine/setup.js";
-import { formatCardInfo, formatNotes } from "./cards.js";
+import { formatCardInfo, formatNotes } from "../format/cards.js";
 import { displayPath, RUNTIME_ERROR, USAGE_ERROR } from "./run.js";
 const CARD_OPTIONS = `Options:
   --label <text>             How the card appears at checkout, e.g. "Amex Gold".
@@ -148,6 +148,7 @@ export async function runWalletCommand(command, argv, io) {
     const catalog = await loadCatalog();
     const file = walletPath(io.env);
     const where = displayPath(file);
+    const store = new FileWalletStore(catalog, file);
     if (command === 'cards') {
         const query = positionals.join(' ');
         const result = searchCards(catalog, query, await heldWallet(io), io.today);
@@ -169,7 +170,7 @@ export async function runWalletCommand(command, argv, io) {
             return usage('Give memberships or --none, not both.');
         }
         const list = values.none ? [] : positionals;
-        return report(await setMemberships(file, catalog, list), list.length > 0
+        return report(await store.setMemberships(list), list.length > 0
             ? `Memberships set to ${list.join(', ')} in ${where}.`
             : `Memberships cleared in ${where}.`, null, io);
     }
@@ -179,7 +180,7 @@ export async function runWalletCommand(command, argv, io) {
     const id = positionals[0] ?? '';
     const name = catalog.cards.find((c) => c.id === id)?.name ?? id;
     if (command === 'remove') {
-        return report(await removeCard(file, catalog, id), `Removed ${name} from ${where}.`, null, io);
+        return report(await store.removeCard(id), `Removed ${name} from ${where}.`, null, io);
     }
     const input = { id };
     if (values.label !== undefined)
@@ -227,8 +228,8 @@ export async function runWalletCommand(command, argv, io) {
         return usage('Give --bonus-opened with the other --bonus options.');
     }
     if (command === 'add') {
-        const result = await addCard(file, catalog, input, io.today);
+        const result = await store.addCard(input, io.today);
         return report(result, `Added ${name} to ${where}${result.ok && result.created ? ' (a new wallet)' : ''}.`, id, io);
     }
-    return report(await updateCard(file, catalog, input, io.today), `Updated ${name} in ${where}.`, id, io);
+    return report(await store.updateCard(input, io.today), `Updated ${name} in ${where}.`, id, io);
 }

package/dist/data/file-store.js

@@ -1,9 +1,22 @@
 import { bookPurchase } from "../engine/record.js";
+import { addToWallet, removeFromWallet, updateInWallet, withMemberships, } from "../engine/wallet-change.js";
 import { loadWallet } from "./load.js";
-import { addCard, removeCard, setMemberships, updateCard, } from "./wallet-setup.js";
-import { withWalletLock, writeBonusSpent, writeCapBooking, } from "./wallet-write.js";
-// The wallet as a YAML file (the CLI, the local MCP server, the .mcpb and the
-// local plugin). Edits splice lines so the user's comments survive.
+import { addCardText, commitWalletText, readWalletText, removeCardText, setMembershipsText, updateCardText, writeProgress, } from "./wallet-edit.js";
+const failed = (error) => ({ ok: false, error });
+const errorText = (e) => (e instanceof Error ? e.message : String(e));
+const queues = new Map();
+// Runs `task` after every earlier task for the same file has settled, so a
+// read-modify-write of the wallet never interleaves with another.
+function withWalletLock(file, task) {
+    const previous = queues.get(file) ?? Promise.resolve();
+    const run = previous.then(task, task);
+    queues.set(file, run.catch(() => undefined));
+    return run;
+}
+// The wallet as a YAML file (the CLI, the local MCP server and the .mcpb).
+// Each change is worked out on the parsed wallet, then spliced into the text,
+// which must re-parse to exactly that wallet before it's written, so the
+// user's comments survive.
 export class FileWalletStore {
     where;
     catalog;
@@ -21,34 +34,60 @@ export class FileWalletStore {
             throw e;
         }
     }
+    change(plan, edit) {
+        return withWalletLock(this.where, async () => {
+            try {
+                const { text, wallet } = await readWalletText(this.where);
+                const change = plan(wallet);
+                if (typeof change === 'string')
+                    return failed(change);
+                if (!change.ok)
+                    return change;
+                await commitWalletText(this.where, edit(text, change), change.wallet);
+                return {
+                    ok: true,
+                    wallet: change.wallet,
+                    created: text === null,
+                    notes: change.notes,
+                };
+            }
+            catch (e) {
+                return failed(errorText(e));
+            }
+        });
+    }
+    // Changes other than adding a card need a wallet file to change.
+    existing(apply) {
+        return (wallet) => wallet === null
+            ? `No wallet at ${this.where} yet. Add a card first to create it.`
+            : apply(wallet);
+    }
     addCard(input, today) {
-        return withWalletLock(this.where, () => addCard(this.where, this.catalog, input, today));
+        return this.change((wallet) => addToWallet(this.catalog, wallet, input, today), (text, change) => addCardText(text, { id: input.id, ...change.fields }));
     }
     updateCard(input, today) {
-        return withWalletLock(this.where, () => updateCard(this.where, this.catalog, input, today));
+        return this.change(this.existing((w) => updateInWallet(this.catalog, w, input, today)), (text, change) => updateCardText(text ?? '', input.id, change.fields));
     }
     removeCard(cardId) {
-        return withWalletLock(this.where, () => removeCard(this.where, this.catalog, cardId));
+        return this.change(this.existing((w) => removeFromWallet(w, cardId)), (text) => removeCardText(text ?? '', cardId));
     }
     setMemberships(memberships) {
-        return withWalletLock(this.where, () => setMemberships(this.where, this.catalog, memberships));
+        return this.change(this.existing((w) => withMemberships(this.catalog, w, memberships)), (text, change) => setMembershipsText(text ?? '', change.wallet.memberships));
     }
     record(purchase, merchant) {
         return withWalletLock(this.where, async () => {
             const wallet = await this.load();
             if (!wallet)
-                return { ok: false, error: "There's no saved wallet to record it in." };
+                return failed("There's no saved wallet to record it in.");
             if (!wallet.cards.some((c) => c.id === purchase.cardId))
-                return { ok: false, error: `${purchase.cardId} isn't in the wallet.` };
+                return failed(`${purchase.cardId} isn't in the wallet.`);
             const booked = bookPurchase(this.catalog, wallet, purchase, merchant);
             try {
-                if (booked.cap)
-                    await writeCapBooking(this.where, booked.cap);
-                if (booked.bonus)
-                    await writeBonusSpent(this.where, purchase.cardId, booked.bonus.after);
+                if (booked.cap || booked.bonus)
+                    await writeProgress(this.where, booked.cap ? [booked.cap] : [], booked.bonus ? [booked.bonus] : []);
             }
             catch (e) {
-                return { ok: false, error: e instanceof Error ? e.message : String(e) };
+                return failed(errorText(e));
             }
             return { ok: true, ...booked };
         });

package/dist/data/load.js

@@ -11,7 +11,7 @@ import { CurrenciesFileSchema } from "../schema/currency.js";
 import { MerchantsFileSchema } from "../schema/merchant.js";
 import { WalletSchema } from "../schema/wallet.js";
 export const DATA_DIR = fileURLToPath(new URL('../../data/', import.meta.url));
-export async function readYaml(file, schema) {
+async function readYaml(file, schema) {
     const raw = parse(await readFile(file, 'utf8'));
     const result = schema.safeParse(raw);
     if (!result.success) {

package/dist/data/store.js

@@ -76,8 +76,6 @@ export class JsonWalletStore {
         });
     }
 }
-// A store with nothing behind it, for tests and for a session that starts
-// empty and is thrown away.
 export function memoryBackend(initial = null) {
     let text = initial;
     return {
@@ -92,17 +90,3 @@ export function memoryBackend(initial = null) {
         },
     };
 }
-// No saved wallet, and saving refused: the public remote server before
-// anonymous saved wallets exist. Cards named in the conversation still work.
-export function noSavedWallet(where) {
-    const refused = () => Promise.resolve(failed("Saving a wallet isn't available here yet. Name your cards in the conversation instead; nothing is stored."));
-    return {
-        where,
-        load: () => Promise.resolve(null),
-        addCard: refused,
-        updateCard: refused,
-        removeCard: refused,
-        setMemberships: refused,
-        record: refused,
-    };
-}

package/dist/data/wallet-edit.js

@@ -2,6 +2,7 @@ import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { isMap, isSeq, parseDocument, stringify } from 'yaml';
+import { applyBonusBooking, applyBooking, } from "../engine/record.js";
 import { WalletSchema } from "../schema/wallet.js";
 const NEW_WALLET = `# Your earnrate wallet: the cards you hold, by id. Never card numbers.
 # Format: https://github.com/cwasley/earnrate#your-wallet
@@ -154,6 +155,71 @@ export function setMembershipsText(text, memberships) {
     const cards = root.items.find((p) => keyOf(p) === 'cards');
     return insertLines(text, lineStart(text, range(cards?.key)[0]), line);
 }
+function flowUsage(booking) {
+    const period = /^\d+$/.test(booking.period)
+        ? `"${booking.period}"`
+        : booking.period;
+    return `{ period: ${period}, spent: ${String(booking.after)} }`;
+}
+export function capUsageText(text, booking) {
+    const card = findCard(text, booking.cardId);
+    const value = flowUsage(booking);
+    const usage = card.get('cap_usage', true);
+    if (isMap(usage) && !usage.flow && usage.items.length > 0) {
+        const existing = usage.items.find((p) => keyOf(p) === booking.capKey);
+        if (existing) {
+            const [start, end] = range(existing.value);
+            return text.slice(0, start) + value + text.slice(end);
+        }
+        const indent = ' '.repeat(column(text, range(usage.items[0]?.key)[0]));
+        const at = afterLine(text, range(usage)[1] - 1);
+        return insertLines(text, at, `${indent}${booking.capKey}: ${value}\n`);
+    }
+    if (usage !== undefined)
+        throw new Error(`card '${booking.cardId}' has a cap_usage that isn't a block map; ${BY_HAND}`);
+    const indent = ' '.repeat(column(text, range(card.items[0]?.key)[0]));
+    const at = afterLine(text, range(card)[1] - 1);
+    return insertLines(text, at, `${indent}cap_usage:\n${indent}  ${booking.capKey}: ${value}\n`);
+}
+export function bonusSpentText(text, cardId, spent) {
+    const bonus = findCard(text, cardId).get('bonus', true);
+    if (!isMap(bonus))
+        throw new Error(`card '${cardId}' has no bonus`);
+    const value = String(spent);
+    const existing = bonus.items.find((p) => keyOf(p) === 'spent');
+    if (existing) {
+        const [start, end] = range(existing.value);
+        return text.slice(0, start) + value + text.slice(end);
+    }
+    if (bonus.flow) {
+        const close = text.lastIndexOf('}', range(bonus)[1]);
+        return `${text.slice(0, close).trimEnd()}, spent: ${value} ${text.slice(close)}`;
+    }
+    const indent = ' '.repeat(column(text, range(bonus.items[0]?.key)[0]));
+    const at = afterLine(text, range(bonus)[1] - 1);
+    return insertLines(text, at, `${indent}spent: ${value}\n`);
+}
+// Writes spending toward caps and welcome bonuses in one checked write.
+export async function writeProgress(file, caps, bonuses) {
+    const { text, wallet } = await readWalletText(file);
+    if (text === null || wallet === null)
+        throw new Error(`No wallet at ${file}.`);
+    let after = text;
+    let expected = wallet;
+    for (const b of caps) {
+        after = capUsageText(after, b);
+        expected = applyBooking(expected, b);
+    }
+    for (const b of bonuses) {
+        after = bonusSpentText(after, b.cardId, b.after);
+        expected = applyBonusBooking(expected, b);
+    }
+    const byHand = [
+        ...caps.map((b) => `${b.cardId} cap_usage ${b.capKey}: ${flowUsage(b)}`),
+        ...bonuses.map((b) => `${b.cardId} bonus spent: ${String(b.after)}`),
+    ].join('; ');
+    await commitWalletText(file, after, expected, `add it by hand: ${byHand}`);
+}
 async function readText(file) {
     try {
         return await readFile(file, 'utf8');
@@ -173,10 +239,10 @@ export async function readWalletText(file) {
 }
 // Writes `after` only if it parses to exactly `expected`, so a splice that
 // went wrong can never change anything it wasn't meant to.
-export async function commitWalletText(file, after, expected) {
+export async function commitWalletText(file, after, expected, fallback = BY_HAND) {
     const parsed = WalletSchema.safeParse(parseDocument(after).toJS());
     if (!parsed.success || !isDeepStrictEqual(parsed.data, expected)) {
-        throw new Error(`couldn't update ${file} safely; ${BY_HAND}`);
+        throw new Error(`couldn't update ${file} safely; ${fallback}`);
     }
     await mkdir(path.dirname(file), { recursive: true });
     const tmp = `${file}.${String(process.pid)}.tmp`;

package/dist/engine/bonus.js

@@ -1,4 +1,5 @@
 import { daysBetween } from "./periods.js";
+import { roundCents } from "./text.js";
 import { cardValuation } from "./valuation.js";
 // "Within 3 months of opening": the same day of the month, three months on,
 // or the month's last day when that day doesn't exist (Nov 30 + 3 → Feb 28).
@@ -11,7 +12,17 @@ export function addMonths(date, months) {
     const day = Math.min(d, last);
     return `${String(year)}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
 }
-const round = (n) => Math.round(n * 100) / 100;
+// A welcome bonus in dollars at the given point value; null when it has
+// neither points nor dollars.
+export function bonusDollars(card, centsPerUnit, points, dollars) {
+    if (points !== undefined)
+        return (points * centsPerUnit) / 100;
+    if (dollars === undefined)
+        return null;
+    // A cash back card's bonus is paid like its rewards, so it pools when they
+    // do; a points card's dollar bonus is a statement credit.
+    return card.currency === 'cash' ? dollars * centsPerUnit : dollars;
+}
 export function bonusStatus(catalog, wallet, held, today) {
     const bonus = held.bonus;
     if (!bonus)
@@ -25,22 +36,14 @@ export function bonusStatus(catalog, wallet, held, today) {
     const valuation = cardValuation(catalog, wallet, card);
     const points = bonus.points ?? (bonus.dollars === undefined ? offer?.points : undefined);
     const dollars = bonus.dollars ?? (bonus.points === undefined ? offer?.dollars : undefined);
-    let value = null;
-    if (points !== undefined)
-        value = (points * valuation.centsPerUnit) / 100;
-    else if (dollars !== undefined) {
-        // A cash back card's bonus is paid like its rewards, so it pools when they
-        // do; a points card's dollar bonus is a statement credit.
-        value =
-            card.currency === 'cash' ? dollars * valuation.centsPerUnit : dollars;
-    }
+    const value = bonusDollars(card, valuation.centsPerUnit, points, dollars);
     const base = {
         cardId: held.id,
         opened: bonus.opened,
         spent: bonus.spent,
         spend,
         deadline,
-        value: value === null ? null : round(value),
+        value: value === null ? null : roundCents(value),
     };
     if (spend === null || deadline === null) {
         return {
@@ -50,7 +53,7 @@ export function bonusStatus(catalog, wallet, held, today) {
             state: 'incomplete',
         };
     }
-    const remaining = round(Math.max(0, spend - bonus.spent));
+    const remaining = roundCents(Math.max(0, spend - bonus.spent));
     const daysLeft = daysBetween(today, deadline);
     return {
         ...base,

package/dist/engine/cheat-sheet.js

@@ -3,7 +3,7 @@ import { categoryResolution, exploreCards, } from "./explore.js";
 import { periodKey } from "./periods.js";
 import { recommend } from "./recommend.js";
 import { setupNotes } from "./setup.js";
-export const CHEAT_SHEET_ITEMS = [
+const CHEAT_SHEET_ITEMS = [
     { label: 'Groceries', category: 'grocery.supermarket' },
     { label: 'Dining', category: 'dining' },
     { label: 'Gas', category: 'gas' },
@@ -22,7 +22,7 @@ export function cheatSheet(catalog, wallet, date, items = CHEAT_SHEET_ITEMS) {
             ? resolveMerchantById(catalog, item.merchant, null)
             : categoryResolution(catalog, item.category, null);
         if (!merchant)
-            throw new Error(`unknown merchant '${item.label}'`);
+            throw new Error(`unknown merchant '${'merchant' in item ? item.merchant : item.category}' for ${item.label}`);
         const rec = recommend(catalog, wallet, {
             merchant: merchant.input,
             amount: null,

package/dist/engine/evaluate.js

@@ -15,10 +15,19 @@ export function purchaseContext(catalog, wallet, merchant, category, purchase) {
 }
 // A category with one typical MCC (travel agencies are 4722) implies it, the
 // same assumption explanations state.
-function singleMcc(catalog, category) {
+export function singleMcc(catalog, category) {
     const mccs = catalog.categories.find((c) => c.id === category)?.mccs ?? [];
     return mccs.length === 1 ? (mccs[0] ?? null) : null;
 }
+// A store card works only at its own stores; any other card wherever the
+// merchant takes its network, which counts as yes when unknown.
+export function usableAt(card, merchant) {
+    if (card.only_at)
+        return (merchant.merchantId !== null && card.only_at.includes(merchant.merchantId));
+    return (card.network === 'store' ||
+        merchant.accepts === null ||
+        merchant.accepts.includes(card.network));
+}
 export function categoryMatches(ruleCategory, category) {
     return category === ruleCategory || category.startsWith(`${ruleCategory}.`);
 }
@@ -93,20 +102,35 @@ function applicability(rule, ctx, held, picked) {
         return 'needs-activation';
     return 'applies';
 }
+// A cap's key in the wallet's cap_usage: the shared cap's id, or the rule's
+// id for a cap written on the rule.
+export function capByKey(card, key) {
+    const shared = card.caps.find((c) => c.id === key);
+    if (shared)
+        return shared;
+    const inline = card.rules.find((r) => r.id === key)?.cap;
+    return typeof inline === 'object' ? inline : undefined;
+}
+// How much of a cap has been spent in the period `date` falls in.
+export function capUsed(cap, key, held, date) {
+    const period = periodKey(cap.period, date, held.anniversary ?? null);
+    const usage = held.cap_usage[key];
+    return {
+        period,
+        spent: period !== null && usage?.period === period ? usage.spent : 0,
+    };
+}
 function capState(rule, card, held, date) {
     if (rule.cap === undefined)
         return null;
-    const capId = typeof rule.cap === 'string' ? rule.cap : null;
-    const cap = capId === null ? rule.cap : card.caps.find((c) => c.id === capId);
-    if (cap === undefined || typeof cap === 'string')
+    const key = typeof rule.cap === 'string' ? rule.cap : rule.id;
+    const cap = capByKey(card, key);
+    if (cap === undefined)
         return null;
-    const key = capId ?? rule.id;
-    const period = periodKey(cap.period, date, held.anniversary ?? null);
-    const usage = held.cap_usage[key];
-    const used = period !== null && usage?.period === period ? usage.spent : 0;
-    return { key, cap, period, remaining: Math.max(0, cap.amount - used) };
+    const { period, spent } = capUsed(cap, key, held, date);
+    return { key, cap, period, remaining: Math.max(0, cap.amount - spent) };
 }
-export function rateAfterCap(rate, cap, amount) {
+function rateAfterCap(rate, cap, amount) {
     if (!cap)
         return rate;
     if (amount !== null && amount > 0) {

package/dist/engine/explore.js

@@ -1,9 +1,10 @@
 import { resolveMerchant } from "../merchants/resolve.js";
 import { evaluateCard, purchaseContext } from "./evaluate.js";
-import { periodKey } from "./periods.js";
-import { categoryPhrase, currencyLabel, dollars, earnText, num, recommend, } from "./recommend.js";
+import { choicePeriod, periodKey } from "./periods.js";
+import { recommend } from "./recommend.js";
 import { rotationGap } from "./rotation.js";
 import { membershipsUsed } from "./setup.js";
+import { categoryPhrase, codesAs, earnText, money, pointValuesText, } from "./text.js";
 import { cardValuation } from "./valuation.js";
 const EPSILON = 1e-9;
 export const ALL_PERSONAL_CARDS = {
@@ -29,18 +30,11 @@ export function matchesFilters(card, filters) {
         return false;
     return true;
 }
-// The period a card's picks are keyed by in a wallet.
-export function choicePeriod(card) {
-    for (const c of card.choices)
-        if (c.period !== 'until_changed')
-            return c.period;
-    return 'quarter';
-}
 // A card as its holder would set it up for the best result: the given picks,
 // every activation done, and no cap used yet. The anniversary is `date`, so a
 // cardmember-year cap starts fresh.
 export function idealHolding(card, date, picks = {}) {
-    const period = choicePeriod(card);
+    const period = choicePeriod(card) ?? 'calendar_year';
     return {
         id: card.id,
         anniversary: date.slice(5),
@@ -163,7 +157,7 @@ function conditionsText(catalog, r) {
     if (r.membership !== null)
         conditions.push(`Needs ${r.membership}.`);
     if (r.cap) {
-        conditions.push(`Up to ${dollars(r.cap.amount)} ${CAP_PERIODS[r.cap.period] ?? ''} at this rate, then ${earnText(catalog, r.cap.thenRate, r.cap.currency)}.`);
+        conditions.push(`Up to ${money(r.cap.amount)} ${CAP_PERIODS[r.cap.period] ?? ''} at this rate, then ${earnText(catalog, r.cap.thenRate, r.cap.currency)}.`);
     }
     return conditions;
 }
@@ -262,22 +256,15 @@ function exploreAssumptions(catalog, merchant, ranked, options) {
         assumptions.push(`Ranks purchases that code as ${categoryPhrase(catalog, merchant.category)}.`);
     }
     else if (merchant.source !== 'none') {
-        const code = merchant.likelyMcc === null ? '' : ` (MCC ${String(merchant.likelyMcc)})`;
-        assumptions.push(`Assumes ${merchant.resolvedName} codes as ${categoryPhrase(catalog, merchant.category)}${code}.`);
+        assumptions.push(codesAs(catalog, merchant));
     }
     assumptions.push('Assumes each card is set up for this purchase: the right category pick, any activation done, and none of its cap used yet. A card you hold may differ.');
     assumptions.push(options.memberships.length === 0
         ? 'Assumes no memberships (like Amazon Prime). Rates that need one are listed separately.'
         : `Assumes these memberships: ${options.memberships.join(', ')}.`);
-    const values = new Map();
-    for (const e of ranked.slice(0, 10)) {
-        if (e.currency !== 'cash')
-            values.set(e.currency, e.centsPerUnit);
-    }
-    if (values.size > 0) {
-        const list = [...values].map(([id, cents]) => `${currencyLabel(catalog, id)} at ${num(cents)}¢`);
-        assumptions.push(`Values points at: ${list.join(', ')}.`);
-    }
+    const values = pointValuesText(catalog, ranked.slice(0, 10));
+    if (values !== null)
+        assumptions.push(values);
     return assumptions;
 }
 function exploreWarnings(catalog, merchant) {

package/dist/engine/offers.js

@@ -1,14 +1,7 @@
+import { bonusDollars } from "./bonus.js";
+import { matchesFilters } from "./explore.js";
+import { roundCents } from "./text.js";
 import { cardValuation } from "./valuation.js";
-const round = (n) => Math.round(n * 100) / 100;
-function bonusValue(card, centsPerUnit, points, dollars) {
-    if (points !== undefined)
-        return (points * centsPerUnit) / 100;
-    if (dollars === undefined)
-        return 0;
-    // A cash back card's bonus is paid like its rewards, so it pools when they
-    // do; a points card's dollar bonus is a statement credit.
-    return card.currency === 'cash' ? dollars * centsPerUnit : dollars;
-}
 export function compareOffers(catalog, wallet, filters, today) {
     const held = new Set(wallet.cards.map((c) => c.id));
     const offers = [];
@@ -16,16 +9,9 @@ export function compareOffers(catalog, wallet, filters, today) {
     for (const card of catalog.cards) {
         if (card.network === 'store')
             continue;
-        if (card.business !== filters.business)
-            continue;
         if (!filters.includeHeld && held.has(card.id))
             continue;
-        const isCash = card.currency === 'cash';
-        if (filters.kind === 'cash' && !isCash)
-            continue;
-        if (filters.kind === 'points' && isCash)
-            continue;
-        if (filters.noAnnualFee && card.annual_fee !== 0)
+        if (!matchesFilters(card, { ...filters, issuer: null, includeClosed: true }))
             continue;
         const offer = card.welcome_offer;
         if (!offer || (offer.valid_to !== undefined && offer.valid_to < today)) {
@@ -33,7 +19,8 @@ export function compareOffers(catalog, wallet, filters, today) {
             continue;
         }
         const valuation = cardValuation(catalog, wallet, card);
-        const value = bonusValue(card, valuation.centsPerUnit, offer.points, offer.dollars);
+        const value = bonusDollars(card, valuation.centsPerUnit, offer.points, offer.dollars) ??
+            0;
         const firstYearFee = card.first_year_fee ?? card.annual_fee ?? null;
         offers.push({
             cardId: card.id,
@@ -50,8 +37,8 @@ export function compareOffers(catalog, wallet, filters, today) {
             note: offer.note ?? null,
             annualFee: card.annual_fee ?? null,
             firstYearFee,
-            bonusValue: round(value),
-            firstYearValue: round(value - (firstYearFee ?? 0)),
+            bonusValue: roundCents(value),
+            firstYearValue: roundCents(value - (firstYearFee ?? 0)),
             held: held.has(card.id),
             lastVerified: card.last_verified,
             verifiedBy: card.verified_by,

package/dist/engine/periods.js

@@ -29,3 +29,12 @@ export function localToday(now = new Date()) {
         String(now.getDate()).padStart(2, '0'),
     ].join('-');
 }
+// The period a card's picks are filed under in a wallet. Picks that carry
+// over (until_changed) are never compared, so they file under the calendar
+// year. null when the card's picks reset on different schedules.
+export function choicePeriod(card) {
+    const periods = [
+        ...new Set(card.choices.map((c) => c.period).filter((p) => p !== 'until_changed')),
+    ];
+    return periods.length > 1 ? null : (periods[0] ?? 'calendar_year');
+}