earnrate 0.2.16 → 0.2.18

package/dist/engine/offers.js

@@ -1,8 +1,10 @@
 import { bonusDollars } from "./bonus.js";
+import { allCreditsYear } from "./credits.js";
 import { matchesFilters } from "./explore.js";
+import { simulateAdditions, typicalSpendLines } from "./simulate.js";
 import { membershipCosts, paidMemberships } from "./memberships.js";
 import { inEffect } from "./periods.js";
-import { CREDITS_LEFT_OUT, heldName, listed, money, roundCents, } from "./text.js";
+import { CREDITS_APART, heldName, listed, money, roundCents } from "./text.js";
 import { cardValuation } from "./valuation.js";
 function ineligibleText(catalog, wallet, notWith) {
     const held = wallet.cards
@@ -24,8 +26,27 @@ export function offerTerms(o, currencyName) {
         : 'with no spending required';
     return `${o.varies ? 'Up to ' : ''}${amount} ${spend}`;
 }
-export function compareOffers(catalog, wallet, filters, today) {
+const WEEKS_A_MONTH = 52 / 12;
+function minimumSpend(spend, months, monthly) {
+    if (spend <= 0)
+        return null;
+    const weeks = monthly > 0 ? Math.ceil(spend / (monthly / WEEKS_A_MONTH)) : Infinity;
+    return {
+        reachable: monthly * months >= spend,
+        weeks: Number.isFinite(weeks) ? weeks : 0,
+    };
+}
+export function compareOffers(catalog, wallet, filters, today, spending = { lines: typicalSpendLines(catalog), typical: true }) {
     const held = new Set(wallet.cards.map((c) => c.id));
+    const skipped = new Set(wallet.skipped_issuers ?? []);
+    const monthly = spending.lines.reduce((sum, l) => sum + l.monthly, 0);
+    const { additions } = simulateAdditions(catalog, wallet, spending.lines, {
+        filters: { ...filters, issuer: null, includeClosed: true },
+        memberships: wallet.memberships,
+        valuations: wallet.valuations,
+        start: today,
+    });
+    const added = new Map(additions.map((a) => [a.cardId, a]));
     const paid = paidMemberships(catalog, {
         memberships: wallet.memberships,
         heldCards: [...held],
@@ -37,6 +58,8 @@ export function compareOffers(catalog, wallet, filters, today) {
             continue;
         if (!filters.includeHeld && held.has(card.id))
             continue;
+        if (skipped.has(card.issuer))
+            continue;
         if (!matchesFilters(card, { ...filters, issuer: null, includeClosed: true }))
             continue;
         const offer = card.welcome_offer;
@@ -49,6 +72,27 @@ export function compareOffers(catalog, wallet, filters, today) {
             0;
         const firstYearFee = card.first_year_fee ?? card.annual_fee ?? null;
         const membershipFee = membershipCosts(catalog, [card], paid)[0]?.annualFee ?? 0;
+        const firstYearValue = roundCents(value - (firstYearFee ?? 0) - membershipFee);
+        const credits = allCreditsYear(catalog, card, today).yearly;
+        const addition = added.get(card.id);
+        const minimum = minimumSpend(offer.spend, offer.months, monthly);
+        const plan = addition
+            ? (() => {
+                const reached = minimum === null || minimum.reachable;
+                const yearOne = roundCents(addition.extraRewards +
+                    (reached ? value : 0) -
+                    (firstYearFee ?? 0) -
+                    addition.membershipFee);
+                const yearTwo = roundCents(addition.extraRewards - addition.annualFee - addition.membershipFee);
+                return {
+                    extraRewards: addition.extraRewards,
+                    minimumSpend: minimum,
+                    yearOne,
+                    yearTwo,
+                    twoYears: roundCents(yearOne + yearTwo),
+                };
+            })()
+            : null;
         offers.push({
             cardId: card.id,
             cardName: card.name,
@@ -68,20 +112,30 @@ export function compareOffers(catalog, wallet, filters, today) {
             bonusValue: roundCents(value),
             membershipFee,
             ineligible: ineligibleText(catalog, wallet, offer.not_with ?? []),
-            firstYearValue: roundCents(value - (firstYearFee ?? 0) - membershipFee),
+            firstYearValue,
+            credits,
+            firstYearValueIfCreditsUsed: roundCents(firstYearValue + credits),
+            plan,
             held: held.has(card.id),
             lastVerified: card.last_verified,
             verifiedBy: card.verified_by,
         });
     }
     offers.sort((a, b) => Number(a.ineligible !== null) - Number(b.ineligible !== null) ||
+        (b.plan?.twoYears ?? -Infinity) - (a.plan?.twoYears ?? -Infinity) ||
         b.firstYearValue - a.firstYearValue ||
         a.cardId.localeCompare(b.cardId));
     const notes = [
         `Compares the ${String(catalog.cards.length)} cards earnrate knows, not every card on the market.`,
         `Each offer is the public one on the issuer's page on the date shown, checked weekly. ${OFFERS_MAY_DIFFER} Issuers also limit who can get a bonus; each card's note says how.`,
-        "First-year value is the bonus at your point values minus the first year's annual fee and any membership the card needs that you don't have. It leaves out what the card earns on your spending and any credits or perks.",
-        CREDITS_LEFT_OUT,
+        `Ranked on the first two years together: what each card ${wallet.cards.length > 0 ? 'adds to your cards' : 'earns'} on ${spending.typical ? 'typical U.S. spending' : 'your spending'}${wallet.cards.length > 0 ? ' (it takes the purchases where it earns more)' : ''}, plus the welcome bonus in year one if the minimum spend fits in the window with all your spending on it, less each year's annual fee and any membership it needs. Year one counts the card at its standard rates.`,
+        "First-year value is the bonus alone at your point values, less the first year's fee and membership.",
+        CREDITS_APART,
+        ...(skipped.size > 0
+            ? [
+                `Leaves out cards from ${listed([...skipped].map((i) => catalog.issuers.find((x) => x.id === i)?.name ?? i))}, as you asked.`,
+            ]
+            : []),
     ];
-    return { offers, withoutOffer, notes };
+    return { offers, withoutOffer, notes, typical: spending.typical };
 }

package/dist/engine/periods.js

@@ -20,6 +20,13 @@ export function periodKey(period, date, anniversary) {
             return String(date.slice(5) >= anniversary ? year : year - 1);
     }
 }
+// MM-DD that is a real day of the year; 02-29 counts.
+export function isAnniversary(text) {
+    if (!/^\d{2}-\d{2}$/.test(text))
+        return false;
+    const date = new Date(`2024-${text}T00:00:00Z`);
+    return (!Number.isNaN(date.getTime()) && date.toISOString().slice(5, 10) === text);
+}
 export function daysBetween(from, to) {
     return Math.round((Date.parse(to) - Date.parse(from)) / 86_400_000);
 }

package/dist/engine/recommend.js

@@ -1,6 +1,6 @@
 import { findMerchant, merchantFamily, resolveMerchant, resolveMerchantById, } from "../merchants/resolve.js";
 import { bonusStatus } from "./bonus.js";
-import { evaluateCard, paymentUpgrade, purchaseContext, usableAt, } from "./evaluate.js";
+import { amountUpgrade, evaluateCard, paymentUpgrade, purchaseContext, usableAt, } from "./evaluate.js";
 import { introWindows, openedOn, withIntro } from "./intro.js";
 import { membershipName } from "./memberships.js";
 import { milestonePoints, milestonesReached, reachedText, } from "./milestones.js";
@@ -9,7 +9,7 @@ import { creditAt, creditDollars } from "./credits.js";
 import { ruleWhat } from "./rule-text.js";
 import { rotationGap } from "./rotation.js";
 import { EPSILON, isClose } from "./compare.js";
-import { CAP_ADJECTIVES, categoryPhrase, creditAnswerText, codesAs, currencyLabel, currencyName, earnText, heldName, introRateText, introUnknownText, listed, money, NETWORK_NAMES, num, paidText, paymentUnknownText, pct, pointValuesText, roundCents, shortDate, wholeDollars, possessive, } from "./text.js";
+import { amountUnknownText, CAP_ADJECTIVES, categoryPhrase, codesAs, creditAnswerText, currencyLabel, currencyName, earnText, heldName, introRateText, introUnknownText, listed, money, NETWORK_NAMES, num, paidText, paymentUnknownText, pct, pointValuesText, possessive, roundCents, shortDate, wholeDollars, } from "./text.js";
 import { cardValuation } from "./valuation.js";
 export const STALE_AFTER_DAYS = 180;
 // The engine only tells the U.S. from everywhere else.
@@ -99,6 +99,7 @@ function rankEntries(catalog, wallet, purchase, merchant, category, options = {}
             }
             : null;
         const paid = paymentUpgrade(card, held, ctx, evaluation.best.rate);
+        const larger = amountUpgrade(card, held, ctx, evaluation.best.rate);
         const credit = options.credits === false
             ? null
             : creditAt(catalog, card, held, { ...merchant, category }, purchase.date);
@@ -133,6 +134,15 @@ function rankEntries(catalog, wallet, purchase, merchant, category, options = {}
                         creditPct,
                 }
                 : null,
+            ifLarger: larger
+                ? {
+                    amount: larger.amount,
+                    rate: larger.nominalRate,
+                    returnPct: (perDollar - evaluation.best.rate + larger.rate) *
+                        valuation.centsPerUnit -
+                        fee,
+                }
+                : null,
         });
     }
     entries.sort(compareEntries);
@@ -375,6 +385,15 @@ function assumptionsFor(catalog, merchant, purchase, entries) {
         const currency = e.valuation.currency;
         assumptions.push(paymentUnknownText(displayName(e), e.ifPaid.payment, earnText(catalog, e.ifPaid.rate, currency), earnText(catalog, e.evaluation.best.nominalRate, currency)));
     }
+    for (const e of entries) {
+        if (!e.ifLarger || !winner)
+            continue;
+        if (e !== winner &&
+            e.ifLarger.returnPct <= winner.effectiveReturnPct + EPSILON)
+            continue;
+        const currency = e.valuation.currency;
+        assumptions.push(amountUnknownText(displayName(e), e.ifLarger.amount, earnText(catalog, e.ifLarger.rate, currency), earnText(catalog, e.evaluation.best.nominalRate, currency)));
+    }
     for (const e of entries) {
         if (!e.ifNew || !winner)
             continue;

package/dist/engine/renewal.js

@@ -0,0 +1,101 @@
+import { ALL_PERSONAL_CARDS, matchesFilters } from "./explore.js";
+import { usedCreditsYear } from "./credits.js";
+import { daysBetween, isAnniversary } from "./periods.js";
+import { projectedWallet, simulateSingles, simulateWallet, typicalSpendLines, } from "./simulate.js";
+import { roundCents, shortCardName } from "./text.js";
+// Node-free: earnrate.dev runs it in the browser.
+// A fee card shows up this many days before its anniversary, and stays
+// until this many after: the fee posts on the statement after it.
+export const RENEWAL_BEFORE = 30;
+export const RENEWAL_AFTER = 15;
+// The card's anniversary as MM-DD: the saved one, or from the day it opened.
+export function anniversaryOf(held) {
+    return (held.anniversary ?? (held.opened ?? held.bonus?.opened)?.slice(5) ?? null);
+}
+const openedOf = (held) => held.opened ?? held.bonus?.opened ?? null;
+// A real date for MM-DD in `year`: Feb 29 falls on Feb 28 in other years.
+function onYear(year, mmdd) {
+    const date = `${String(year)}-${mmdd}`;
+    if (mmdd !== '02-29')
+        return date;
+    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    return leap ? date : `${String(year)}-02-28`;
+}
+// The renewal date near `today`, from RENEWAL_BEFORE days ahead back to
+// RENEWAL_AFTER days past; null outside that, without an anniversary, or
+// before the account's first year is nearly over.
+export function renewalDue(held, today) {
+    const mmdd = anniversaryOf(held);
+    if (mmdd === null || !isAnniversary(mmdd))
+        return null;
+    const opened = openedOf(held);
+    const year = Number(today.slice(0, 4));
+    for (const y of [year - 1, year, year + 1]) {
+        const due = onYear(y, mmdd);
+        const days = daysBetween(today, due);
+        if (days > RENEWAL_BEFORE || days < -RENEWAL_AFTER)
+            continue;
+        if (opened !== null && daysBetween(opened, due) < 300)
+            continue;
+        return due;
+    }
+    return null;
+}
+// Whether a fee card still pays for itself, for the year after `due`.
+export function renewalCheck(catalog, wallet, card, due, spending = {
+    lines: typicalSpendLines(catalog),
+    typical: true,
+}) {
+    const held = wallet.cards.find((c) => c.id === card.id);
+    const projected = projectedWallet(wallet, catalog, due);
+    const ids = projected.cards.map((c) => c.id);
+    const withCard = simulateWallet(catalog, projected, spending.lines, due, ids);
+    const others = projected.cards.filter((c) => c.id !== card.id);
+    let without = null;
+    let against = null;
+    if (others.length > 0) {
+        without = simulateWallet(catalog, { ...projected, cards: others }, spending.lines, due, ids.filter((id) => id !== card.id));
+    }
+    else {
+        const noFee = catalog.cards.filter((c) => matchesFilters(c, {
+            ...ALL_PERSONAL_CARDS,
+            business: card.business,
+            noAnnualFee: true,
+        }) &&
+            c.requires_membership === undefined &&
+            c.network !== 'store');
+        const [best] = simulateSingles(catalog, noFee, spending.lines, {
+            filters: { ...ALL_PERSONAL_CARDS, noAnnualFee: true },
+            memberships: wallet.memberships,
+            valuations: wallet.valuations,
+            start: due,
+        });
+        if (best) {
+            without = best;
+            const bestId = best.cards[0]?.cardId;
+            const bestCard = catalog.cards.find((c) => c.id === bestId);
+            against = bestCard ? shortCardName(bestCard.name) : null;
+        }
+    }
+    // From the saved card: projectedWallet drops credit usage, which is how
+    // a credit that needs no enrolling is confirmed in use.
+    const credits = held ? usedCreditsYear(catalog, card, held, due).yearly : 0;
+    const rewardsAdded = roundCents(withCard.rewards - (without?.rewards ?? 0));
+    const fee = card.annual_fee ?? 0;
+    const opened = held ? openedOf(held) : null;
+    return {
+        cardId: card.id,
+        due,
+        fee,
+        firstYearFee: opened !== null &&
+            daysBetween(opened, due) < 400 &&
+            (card.first_year_fee ?? fee) < fee
+            ? (card.first_year_fee ?? 0)
+            : null,
+        rewardsAdded,
+        credits,
+        net: roundCents(rewardsAdded + credits - fee),
+        against,
+        typical: spending.typical,
+    };
+}

package/dist/engine/rule-text.js

@@ -1,5 +1,5 @@
 import { findMerchant } from "../merchants/resolve.js";
-import { categoryPhrase, categoryReadsOn, choiceName, earnText, introPeriod, listed, num, PAYMENT_PHRASES, PICK_PERIODS, words, } from "./text.js";
+import { categoryPhrase, categoryReadsOn, choiceName, earnText, introPeriod, listed, num, PAYMENT_PHRASES, choicePhrase, wholeDollars, words, } from "./text.js";
 // What a rule or a pick covers, in words, for answers and wallet lists.
 // Travel-site bookings ("Flight through Amex Travel") read mid-sentence in
 // lower case and plural; brand names ("Airbnb through Amex Travel") keep theirs.
@@ -31,22 +31,19 @@ export function ruleParts(catalog, rule, card, { everyStore = false } = {}) {
         return [
             rule.geography === 'foreign_only'
                 ? 'purchases outside the U.S.'
-                : rule.requires?.payment !== undefined
-                    ? 'purchases'
-                    : card?.rules.every((r) => r.match.any)
-                        ? 'every purchase'
-                        : 'everything else',
+                : rule.min_amount !== undefined
+                    ? `purchases of ${wholeDollars(rule.min_amount)} or more`
+                    : rule.requires?.payment !== undefined
+                        ? 'purchases'
+                        : card?.rules.every((r) => r.match.any)
+                            ? 'every purchase'
+                            : 'everything else',
         ];
     if (m.choice !== undefined) {
         const choice = card?.choices.find((c) => c.id === m.choice);
         if (!choice)
             return [`your ${choiceName(m.choice)} picks`];
-        const which = choice.pick === 1
-            ? 'the category'
-            : `the ${String(choice.pick)} categories`;
-        return [
-            `${which} you pick${choice.period === 'until_changed' ? '' : ` ${PICK_PERIODS[choice.period]}`}`,
-        ];
+        return [choicePhrase(choice)];
     }
     const merchants = m.merchants ?? [];
     const categories = (m.categories ?? []).map((c) => categoryPhrase(catalog, c));
@@ -85,7 +82,10 @@ export function shortenedMerchants(catalog, merchants) {
 }
 export function ruleWhat(catalog, rule, card, options = {}) {
     const payment = rule.requires?.payment;
-    const what = listed(ruleParts(catalog, rule, card, options));
+    const parts = listed(ruleParts(catalog, rule, card, options));
+    const what = rule.min_amount === undefined || rule.match.any
+        ? parts
+        : `${parts}, on purchases of ${wholeDollars(rule.min_amount)} or more`;
     return payment === undefined ? what : `${what} ${PAYMENT_PHRASES[payment]}`;
 }
 // "on dining", "on your picks", "at Costco", "on Walmart+ membership": a
@@ -141,6 +141,14 @@ export function creditName(catalog, credit) {
         ...(credit.match.categories ?? []).map((c) => categoryPhrase(catalog, c)),
     ]);
 }
+// A short name for a list of credits: the first store a credit names
+// ("Grubhub" for the dining credit at five chains); creditName has them all.
+export function creditLabel(catalog, credit) {
+    const [first, ...more] = credit.match.merchants ?? [];
+    return first === undefined || more.length === 0
+        ? creditName(catalog, credit)
+        : merchantName(catalog, first);
+}
 // "at Lululemon", "at restaurants", "on travel", "on Walmart+ membership":
 // the category's or merchant's own preposition.
 export const creditWhere = (catalog, credit) => `${(credit.match.categories ?? []).some((c) => categoryReadsOn(catalog, c)) ||

package/dist/engine/setup.js

@@ -1,10 +1,10 @@
 import { isActivated, pickedCategories } from "./evaluate.js";
-import { membership, membershipName, sameGroup } from "./memberships.js";
-import { milestoneWhat } from "./milestones.js";
+import { effectiveMemberships, membership, membershipName, sameGroup, } from "./memberships.js";
+import { milestoneStarts, milestoneWhat } from "./milestones.js";
 import { daysBetween } from "./periods.js";
 import { rotationGap, rotationGapText } from "./rotation.js";
 import { creditName, creditWhere, introWhat } from "./rule-text.js";
-import { creditBack, ENROLL_FIRST, idList, listed, possessive } from "./text.js";
+import { choicePhrase, creditBack, creditTerms, ENROLL_FIRST, idList, listed, possessive, } from "./text.js";
 // Rules that start within this many days are worth activating now.
 const ACTIVATION_LOOKAHEAD_DAYS = 45;
 const searchWords = (s) => s
@@ -89,6 +89,7 @@ export function cardInfo(catalog, card, wallet, today) {
             id: c.id,
             pick: c.pick,
             period: c.period,
+            automatic: c.automatic === true,
             options: Object.keys(c.options),
             default: c.default ?? null,
         })),
@@ -108,7 +109,7 @@ export function cardInfo(catalog, card, wallet, today) {
             period: m.period,
             points: m.points ?? null,
             rewards: m.rewards ?? [],
-            text: milestoneWhat(m).replace(/^the /, ''),
+            text: `${milestoneWhat(m).replace(/^the /, '')}${milestoneStarts(m, today)}`,
         })),
         introRates: card.intro_rates.map((i) => ({
             id: i.id,
@@ -123,7 +124,7 @@ export function cardInfo(catalog, card, wallet, today) {
                 amount: c.amount,
                 period: c.period,
                 enroll: c.enroll === true,
-                text: `${creditBack(c)} ${creditWhere(catalog, c)}${c.enroll ? `, ${ENROLL_FIRST}` : ''}`,
+                text: `${creditBack(c)} ${creditWhere(catalog, c)}${creditTerms(c)}${c.enroll ? `, ${ENROLL_FIRST}` : ''}`,
             };
         }),
     };
@@ -172,12 +173,15 @@ export function setupNotes(catalog, wallet, held, today) {
         notes.push({
             kind: 'pick',
             text: choice.default && picked.has(choice.id)
-                ? `${possessive(name)} ${choice.id} pick is assumed to be ${idList(choice.default)}, the default. Set it if a different one was picked (${String(choice.pick)} of: ${options}).`
-                : `${name} needs its ${choice.id} pick for this period (${String(choice.pick)} of: ${options}). Until then those categories earn the base rate.`,
+                ? `${possessive(name)} ${choice.id} pick is assumed to be ${idList(choice.default)}, the default. Set it if ${choice.automatic ? 'you expect a different one to have the most spending' : 'a different one was picked'} (${String(choice.pick)} of: ${options}).`
+                : choice.automatic
+                    ? `${name} applies its bonus to ${choicePhrase(choice)}; set its ${choice.id} pick to the one you expect (${String(choice.pick)} of: ${options}). Until then those categories earn the base rate.`
+                    : `${name} needs its ${choice.id} pick for this period (${String(choice.pick)} of: ${options}). Until then those categories earn the base rate.`,
         });
     }
     // With one tier of a group saved, the others aren't missing.
-    const missing = membershipsUsed(card).filter((m) => !wallet.memberships.some((held) => held === m || sameGroup(catalog, held, m)));
+    const has = effectiveMemberships(catalog, wallet.memberships, wallet.cards.map((c) => c.id));
+    const missing = membershipsUsed(card).filter((m) => !has.some((held) => held === m || sameGroup(catalog, held, m)));
     if (missing.length > 0) {
         notes.push({
             kind: 'membership',

package/dist/engine/simulate.js

@@ -1,12 +1,13 @@
 import { categoryResolution, findCategory, resolvePlace, } from "../merchants/resolve.js";
+import { allCreditsYear, usedCreditsYear } from "./credits.js";
 import { evaluateCard, purchaseContext, usableAt } from "./evaluate.js";
 import { idealHolding, matchesFilters, } from "./explore.js";
 import { membershipCosts, membershipNote, paidMemberships, } from "./memberships.js";
 import { choicePeriod, periodKey } from "./periods.js";
 import { applyBooking, capBooking } from "./record.js";
-import { milestoneWhat } from "./milestones.js";
+import { liveMilestones, milestoneStarts, milestoneWhat } from "./milestones.js";
 import { rotationGap } from "./rotation.js";
-import { money, paymentNote, roundCents, wholeDollars, possessive, } from "./text.js";
+import { creditsCountedText, money, paymentNote, roundCents, shortCardName, wholeDollars, possessive, } from "./text.js";
 import { cardValuation } from "./valuation.js";
 import { EPSILON, HALF_CENT } from "./compare.js";
 const MONTHS = 12;
@@ -127,9 +128,11 @@ held = []) {
     // cardmember-year total is the same twelve months' spending.
     const milestones = [];
     const milestoneNotes = [];
+    const lastMonth = monthDates(start).at(-1) ?? start;
     for (const { card, cents } of cards) {
         const spent = results.reduce((sum, r) => sum + (r.byCard.get(card.id) ?? 0), 0);
-        for (const m of card.milestones) {
+        // One that starts during the year counts, as it will the year after.
+        for (const m of liveMilestones(card, lastMonth)) {
             if (spent + EPSILON < m.spend)
                 continue;
             const value = roundCents(((m.points ?? 0) * cents) / 100);
@@ -139,12 +142,25 @@ held = []) {
                 points: m.points ?? null,
                 value,
             });
-            milestoneNotes.push(`${card.name}: ${wholeDollars(spent)} a year on it reaches ${milestoneWhat(m)}${m.points === undefined ? '' : ` (about ${money(value)}, counted in its rewards)`}, assuming the same spending each year.`);
+            milestoneNotes.push(`${shortCardName(card.name)}: ${wholeDollars(spent)} a year on it reaches ${milestoneWhat(m)}${milestoneStarts(m, start)}${m.points === undefined ? '' : ` (about ${money(value)}, counted in its rewards)`}, assuming the same spending each year.`);
         }
     }
     const rewards = roundCents(lineResults.reduce((sum, l) => sum + l.earned, 0) +
         milestones.reduce((sum, m) => sum + m.value, 0));
     const annualFees = cards.reduce((sum, c) => sum + (c.card.annual_fee ?? 0), 0);
+    const credits = cards.flatMap(({ card }) => {
+        const holding = held.includes(card.id);
+        const raw = wallet.cards.find((h) => h.id === card.id);
+        const year = holding && raw
+            ? usedCreditsYear(catalog, card, raw, start)
+            : allCreditsYear(catalog, card, start);
+        return year.creditIds.length === 0 ? [] : [{ ...year, held: holding }];
+    });
+    const creditSum = (heldOnes) => roundCents(credits
+        .filter((c) => c.held === heldOnes)
+        .reduce((sum, c) => sum + c.yearly, 0));
+    const heldCredits = creditSum(true);
+    const otherCredits = creditSum(false);
     const paid = paidMemberships(catalog, {
         memberships: wallet.memberships,
         heldCards: held,
@@ -155,7 +171,12 @@ held = []) {
     const notes = [...milestoneNotes];
     for (const m of memberships)
         notes.push(membershipNote(catalog, m));
-    const paying = paymentNote(cards.map(({ card }) => ({ name: card.name, card })));
+    for (const c of credits.filter((c) => c.held)) {
+        const card = cards.find((x) => x.card.id === c.cardId)?.card;
+        if (card)
+            notes.push(creditsCountedText(shortCardName(card.name), card.annual_fee ?? 0, c));
+    }
+    const paying = paymentNote(cards.map(({ card }) => ({ name: shortCardName(card.name), card })));
     if (paying !== null)
         notes.push(paying);
     const dates = monthDates(start);
@@ -164,13 +185,13 @@ held = []) {
             ...new Set(dates.map((d) => rotationGap(card, d)).filter((g) => g !== null)),
         ];
         if (gaps.length > 0)
-            notes.push(`${possessive(card.name)} rotating categories for ${gaps.join(', ')} aren't in earnrate's data yet, so those quarters count at its everyday rates.`);
+            notes.push(`${possessive(shortCardName(card.name))} rotating categories for ${gaps.join(', ')} aren't in earnrate's data yet, so those quarters count at its everyday rates.`);
         if (card.annual_fee === undefined)
-            notes.push(`${possessive(card.name)} annual fee isn't on file, so none is subtracted.`);
+            notes.push(`${possessive(shortCardName(card.name))} annual fee isn't on file, so none is subtracted.`);
         else if (!held.includes(card.id) &&
             card.first_year_fee !== undefined &&
             card.first_year_fee !== card.annual_fee)
-            notes.push(`${possessive(card.name)} fee is ${money(card.first_year_fee)} the first year; the yearly figure uses the ${money(card.annual_fee)} that follows.`);
+            notes.push(`${possessive(shortCardName(card.name))} fee is ${money(card.first_year_fee)} the first year; the yearly figure uses the ${money(card.annual_fee)} that follows.`);
     }
     return {
         cards: wallet.cards.map((h) => ({
@@ -182,7 +203,11 @@ held = []) {
         annualFees,
         memberships,
         membershipFees,
-        net: roundCents(rewards - annualFees - membershipFees),
+        heldCredits,
+        net: roundCents(rewards + heldCredits - annualFees - membershipFees),
+        otherCredits,
+        netIfCreditsUsed: roundCents(rewards + heldCredits + otherCredits - annualFees - membershipFees),
+        credits,
         lines: lineResults,
         milestones,
         notes,
@@ -300,15 +325,16 @@ export function simulateCatalog(catalog, lines, options) {
     return { singles, pairs: foldTies(pairs).slice(0, 10) };
 }
 // The person's own wallet, set up as it would run all year: their picks carry
-// over, rotating categories get activated, caps start fresh.
-function projectedWallet(wallet, catalog, start) {
+// over, rotating categories get activated, caps start fresh. A card earnrate
+// no longer lists is left out, since it can't be simulated.
+export function projectedWallet(wallet, catalog, start) {
     return {
         ...wallet,
-        cards: wallet.cards.map((held) => {
+        cards: wallet.cards.flatMap((held) => {
             const card = catalog.cards.find((c) => c.id === held.id);
-            const ideal = card
-                ? idealHolding(card, start, held.chosen?.picks ?? {})
-                : held;
+            if (!card)
+                return [];
+            const ideal = idealHolding(card, start, held.chosen?.picks ?? {});
             return {
                 ...ideal,
                 ...(held.checkout_label !== undefined
@@ -317,6 +343,14 @@ function projectedWallet(wallet, catalog, start) {
                 ...(held.anniversary !== undefined
                     ? { anniversary: held.anniversary }
                     : {}),
+                ...(held.enrolled !== undefined ? { enrolled: held.enrolled } : {}),
+                ...(held.skipped_credits !== undefined
+                    ? { skipped_credits: held.skipped_credits }
+                    : {}),
+                // Usage confirms a credit that needs no enrolling is in use.
+                ...(held.credit_usage !== undefined
+                    ? { credit_usage: held.credit_usage }
+                    : {}),
             };
         }),
     };
@@ -328,7 +362,9 @@ export function simulateAdditions(catalog, wallet, lines, options) {
     const held = new Set(heldIds);
     const additions = [];
     for (const card of catalog.cards) {
-        if (held.has(card.id) || !matchesFilters(card, options.filters))
+        if (held.has(card.id) ||
+            !matchesFilters(card, options.filters) ||
+            (wallet.skipped_issuers ?? []).includes(card.issuer))
             continue;
         const simulation = bestSimulation(catalog, projected.cards, card, lines, {
             ...options,
@@ -339,13 +375,17 @@ export function simulateAdditions(catalog, wallet, lines, options) {
         const extraRewards = roundCents(simulation.rewards - current.rewards);
         const annualFee = card.annual_fee ?? 0;
         const membershipFee = roundCents(simulation.membershipFees - current.membershipFees);
+        const gain = roundCents(extraRewards - annualFee - membershipFee);
+        const credits = allCreditsYear(catalog, card, options.start).yearly;
         additions.push({
             cardId: card.id,
             picks: simulation.cards.at(-1)?.picks ?? {},
             extraRewards,
             annualFee,
             membershipFee,
-            gain: roundCents(extraRewards - annualFee - membershipFee),
+            gain,
+            credits,
+            gainIfCreditsUsed: roundCents(gain + credits),
             simulation,
         });
     }