@rayadesu/dsh-llm-billing 0.3.15 → 0.3.17

package/lib/types/billing.js

@@ -1,233 +1,25 @@
 /**
- * DeepSeek billing: the peak/off-peak pricing table and the per-session spend
- * pricing. Pure functions over session events and the pricing table, so the
- * Remote gateway stays transport-free and the whole spend is testable without
- * a key.
+ * DeepSeek billing aggregation: the session/turn/today spend computations
+ * over the pricing engine (`pricing.ts`) and the per-event fold state machine
+ * (`fold.ts`). Pure functions over session events, so the whole spend is
+ * testable without a key and the Remote gateway stays transport-free.
  *
- * The per-event pricing lives in {@link priceEvent} and the fold in the
- * {@link SpendAccumulator}: the events-scan paths ({@link computeSessionSpend},
- * {@link computeTodaySpend}), the session-projection unit (`billingTodaySpend`
- * in projection.ts), and the scanner's single-pass events path all price
- * through the same primitives, so a pricing-table change cannot drift one path
- * from the others.
+ * The fold in {@link BillingFolder} / {@link applyBillingEvent} (see `fold.ts`)
+ * and the per-event pricing in `pricing.ts` are the single source of truth the
+ * events-scan paths, the session-projection unit, and the scanner all price
+ * through, so a pricing-table change cannot drift one path from the others.
  * @module @rayadesu/dsh-llm-billing/billing
  */
-/**
- * Published peak-hour windows (Beijing time): 09:00–12:00 and 14:00–18:00,
- * applied on weekdays (Monday–Friday) only — weekends are always off-peak
- * (effective 2026-08-23).
- */
-export const DEFAULT_PEAK_HOURS = [
-    { start: 9, end: 12 },
-    { start: 14, end: 18 },
-];
-/**
- * Inclusive epoch ms of the published V4 Flash series re-pricing:
- * 2026-09-10 12:00 Beijing time (UTC+8, no DST) = 04:00 UTC. Samples before
- * this instant keep the base rates; samples at or after it bill at the second
- * revision.
- */
-export const FLASH_SERIES_RATE_CHANGE_AT = Date.UTC(2026, 8, 10, 4, 0, 0);
-/**
- * Inclusive epoch ms of the announced V4 Pro route switch: 2026-09-14 12:00
- * Beijing time (UTC+8, no DST) = 04:00 UTC. From that instant the V4 Pro route
- * is served by V4.1 Flash and billed at the V4.1 Flash rates.
- */
-export const V4_PRO_ROUTE_SWITCH_AT = Date.UTC(2026, 8, 14, 4, 0, 0);
-/** The V4 Flash series' base rates (effective 2026-08-17), CNY per 1M tokens. */
-const FLASH_BASE_RATES = {
-    peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
-    offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
-};
-/**
- * The V4 Flash series' second revision (effective
- * {@link FLASH_SERIES_RATE_CHANGE_AT}): off-peak 0.02 / 1.0 / 4.0, peak at
- * twice those prices.
- */
-const FLASH_REPRICED_RATES = {
-    effectiveFrom: FLASH_SERIES_RATE_CHANGE_AT,
-    peak: { cacheHitInput: 0.04, cacheMissInput: 2.0, output: 8.0 },
-    offPeak: { cacheHitInput: 0.02, cacheMissInput: 1.0, output: 4.0 },
-};
-/**
- * The V4.1 Flash rates as they reach the retired V4 Pro route from
- * {@link V4_PRO_ROUTE_SWITCH_AT}: the same price pair as the flash series'
- * second revision, carried at its own effective instant.
- */
-const V4_PRO_SWITCHED_RATES = {
-    effectiveFrom: V4_PRO_ROUTE_SWITCH_AT,
-    peak: FLASH_REPRICED_RATES.peak,
-    offPeak: FLASH_REPRICED_RATES.offPeak,
-};
-/**
- * Official peak/off-peak rates (CNY per 1M tokens) per model, as dated
- * revisions. Base rows are the schedule effective 2026-08-17; the V4 Flash
- * series (V4.1 Flash, V4 Flash, V4 Flash Vision Exp) carries the second
- * revision effective 2026-09-10 12:00 Beijing, and the V4 Pro row the V4.1
- * Flash rates from its announced route switch (2026-09-14 12:00 Beijing) —
- * the MiMo-V2.5 series is untouched by either adjustment. Rows sharing a model
- * are that model's rate history.
- */
-export const DEFAULT_MODEL_PRICING = [
-    // deepseek-flash is the V4.1 Flash route, DSH's default catalog entry; image
-    // inputs are converted to tokens at the same per-token price.
-    { model: 'deepseek-flash', ...FLASH_BASE_RATES },
-    { model: 'deepseek-flash', ...FLASH_REPRICED_RATES },
-    { model: 'deepseek-v4-flash', ...FLASH_BASE_RATES },
-    { model: 'deepseek-v4-flash', ...FLASH_REPRICED_RATES },
-    // deepseek-v4.1-flash-expires-on-0910 was the V4.1 Flash preview route,
-    // retired when the model was released on 2026-09-10; its rows stay so the
-    // logs that used it keep pricing.
-    { model: 'deepseek-v4.1-flash-expires-on-0910', ...FLASH_BASE_RATES },
-    { model: 'deepseek-v4.1-flash-expires-on-0910', ...FLASH_REPRICED_RATES },
-    {
-        model: 'deepseek-v4-pro',
-        peak: { cacheHitInput: 0.30, cacheMissInput: 9.0, output: 27.0 },
-        offPeak: { cacheHitInput: 0.15, cacheMissInput: 4.5, output: 13.5 },
-    },
-    // From the announced route switch V4 Pro is served by V4.1 Flash and billed
-    // at the V4.1 Flash rates.
-    { model: 'deepseek-v4-pro', ...V4_PRO_SWITCHED_RATES },
-    // deepseek-v4-flash-vision-exp bills at the same rates as deepseek-v4-flash;
-    // images are converted to tokens at the same per-token price.
-    { model: 'deepseek-v4-flash-vision-exp', ...FLASH_BASE_RATES },
-    { model: 'deepseek-v4-flash-vision-exp', ...FLASH_REPRICED_RATES },
-    // MiMo-V2.5 series (Xiaomi): flat rate, no peak/off-peak distinction.
-    {
-        model: 'mimo-v2.5-pro',
-        peak: { cacheHitInput: 0.025, cacheMissInput: 3.0, output: 6.0 },
-        offPeak: { cacheHitInput: 0.025, cacheMissInput: 3.0, output: 6.0 },
-    },
-    {
-        model: 'mimo-v2.5',
-        peak: { cacheHitInput: 0.02, cacheMissInput: 1.0, output: 2.0 },
-        offPeak: { cacheHitInput: 0.02, cacheMissInput: 1.0, output: 2.0 },
-    },
-];
-/**
- * Resolve optional configuration to a pricing table, defaulting omitted or
- * empty rows to the published rates. Schemastery materializes an absent
- * `z.array` as `[]` rather than `undefined`, so emptiness — not just absence —
- * selects the defaults. Explicit non-empty rows override the same model; a
- * supplied non-empty `models` list is authoritative.
- *
- * Rows sharing a model are that model's rate revisions, kept in ascending
- * `effectiveFrom` order (an undated base revision first). Two rows declaring
- * the same effective instant are one revision and the later row wins — the
- * historical override rule — so re-declaring a model can neither duplicate a
- * revision nor install a second undated base.
- * @param config - optional raw billing configuration.
- * @returns the resolved table (per model: its revisions plus the newest rates) and peak-hour windows.
- */
-export function resolveBilling(config) {
-    const peakHours = config?.peakHours !== undefined && config.peakHours.length > 0
-        ? config.peakHours
-        : DEFAULT_PEAK_HOURS;
-    const rows = config?.models !== undefined && config.models.length > 0
-        ? config.models
-        : DEFAULT_MODEL_PRICING;
-    const schedules = new Map();
-    for (const row of rows) {
-        // Spelled out per branch: `exactOptionalPropertyTypes` forbids handing an
-        // explicit `undefined` to an optional field.
-        const revision = row.effectiveFrom === undefined
-            ? { peak: row.peak, offPeak: row.offPeak }
-            : { effectiveFrom: row.effectiveFrom, peak: row.peak, offPeak: row.offPeak };
-        const revisions = schedules.get(row.model);
-        if (revisions === undefined) {
-            schedules.set(row.model, [revision]);
-            continue;
-        }
-        const duplicate = revisions.findIndex(candidate => candidate.effectiveFrom === revision.effectiveFrom);
-        if (duplicate >= 0)
-            revisions[duplicate] = revision;
-        else
-            revisions.push(revision);
-    }
-    const models = new Map();
-    for (const [model, revisions] of schedules) {
-        revisions.sort((left, right) => (left.effectiveFrom ?? Number.NEGATIVE_INFINITY) - (right.effectiveFrom ?? Number.NEGATIVE_INFINITY));
-        const newest = revisions[revisions.length - 1];
-        models.set(model, { peak: newest.peak, offPeak: newest.offPeak, revisions });
-    }
-    return { peakHours, models };
-}
-/**
- * The rate revision in effect at one instant: the newest revision that took
- * effect at or before it. Revisions are ascending, so the scan stops at the
- * first future one. An instant before the earliest dated revision bills at that
- * earliest revision — a model with only dated rows is never left unpriced.
- */
-function ratesAt(revisions, time) {
-    let chosen = revisions[0];
-    for (let index = 1; index < revisions.length; index += 1) {
-        const revision = revisions[index];
-        if (revision.effectiveFrom === undefined || revision.effectiveFrom > time)
-            break;
-        chosen = revision;
-    }
-    return chosen;
-}
-/** Beijing is a fixed UTC+8 offset with no DST. */
-const BEIJING_OFFSET_MS = 8 * 3_600_000;
-/** Milliseconds in one day. */
-const DAY_MS = 86_400_000;
-/** Epoch day of 1970-01-01 in the civil-date algorithm below. */
-const CIVIL_EPOCH_DAY = 719_468;
-/** Two-digit zero pad for a calendar field. */
-function pad2(value) {
-    return value < 10 ? `0${value}` : String(value);
-}
-/**
- * Civil date of an epoch day (Howard Hinnant's days-from-civil inverse):
- * pure integer arithmetic, no `Date` allocation and no ISO-string slicing.
- */
-function civilDateOf(epochDay) {
-    const shifted = epochDay + CIVIL_EPOCH_DAY;
-    const era = Math.floor(shifted / 146_097);
-    const dayOfEra = shifted - era * 146_097;
-    const yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1_460) + Math.floor(dayOfEra / 36_524) - Math.floor(dayOfEra / 146_096)) / 365);
-    const year = yearOfEra + era * 400;
-    const dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));
-    const monthPrime = Math.floor((5 * dayOfYear + 2) / 153);
-    const month = monthPrime + (monthPrime < 10 ? 3 : -9);
-    return {
-        // January/February belong to the civil year AFTER the era year.
-        year: month <= 2 ? year + 1 : year,
-        month,
-        day: dayOfYear - Math.floor((153 * monthPrime + 2) / 5) + 1,
-    };
-}
-/**
- * Derive the Beijing hour, weekday, and calendar-day key of one timestamp with
- * pure integer arithmetic — every timezone-sensitive read shares this one
- * implementation, so the pieces cannot drift apart. Callers that filter by
- * day and then price the same event reuse the returned view, so each event is
- * parsed exactly once. (The hot fold path runs this per committed event; the
- * previous `Date` + `toISOString().slice()` version allocated a `Date` and a
- * 24-character string per call.)
- * @param time - epoch milliseconds.
- * @throws {RangeError} when `time` is not a finite number.
- */
-export function beijingPartsOf(time) {
-    if (!Number.isFinite(time))
-        throw new RangeError(`billing: event time is not finite (${String(time)})`);
-    const shifted = time + BEIJING_OFFSET_MS;
-    const epochDay = Math.floor(shifted / DAY_MS);
-    const msOfDay = shifted - epochDay * DAY_MS;
-    const civil = civilDateOf(epochDay);
-    return {
-        time,
-        hour: Math.floor(msOfDay / 3_600_000),
-        // 1970-01-01 was a Thursday (4).
-        weekday: ((epochDay + 4) % 7 + 7) % 7,
-        dayKey: `${civil.year}-${pad2(civil.month)}-${pad2(civil.day)}`,
-    };
-}
-/** The Beijing (Asia/Shanghai, UTC+8, no DST) calendar-day key of a timestamp. */
-export function beijingDayKey(now) {
-    return beijingPartsOf(now.getTime()).dayKey;
-}
+import { beijingDayKey, beijingDayRangeOfKey } from "./beijing-time.js";
+import { emptyTodaySpend } from "./spend.js";
+import { BillingFolder } from "./fold.js";
+// Re-exported so the package's public surface and its tests keep importing
+// them from this module: the pricing engine, the fold state machine, the
+// Beijing-time helpers, and the spend algebra.
+export * from "./beijing-time.js";
+export * from "./spend.js";
+export * from "./pricing.js";
+export * from "./fold.js";
 /**
  * The durable inherited-prefix boundary of one session: the number of leading
  * events it inherited verbatim from its fork source, 0 for a session created
@@ -235,9 +27,9 @@ export function beijingDayKey(now) {
  * in its session state; every event with `seq < seedLength` is a copy of an
  * event already billed in that source session, so pricing must skip them or
  * the same model output is counted once per copy. Accepts the durable field
- * of both DSH runtime families (see {@link ForkBoundarySource}).
- * @param source - the session, inspection result, header slice, or durable
- *   header carrying the boundary; `undefined` reads as 0.
+ * of the live-session and handle surfaces (see {@link ForkBoundarySource}).
+ * @param source - the session, header slice, or opened handle carrying the
+ *   boundary; `undefined` reads as 0.
  * @returns the inherited-prefix length; 0 for an unseeded session.
  */
 export function forkBoundaryOf(source) {
@@ -246,9 +38,9 @@ export function forkBoundaryOf(source) {
     const inherited = source.inheritedEventCount;
     if (inherited !== undefined && Number.isSafeInteger(inherited))
         return inherited;
-    return source.header?.seedLength ?? source.meta?.seedLength ?? source.seedLength ?? 0;
+    return source.header?.seedLength ?? source.seedLength ?? 0;
 }
-/** Whether a durable header marks a fork-inherited (seeded) session across both runtime families. */
+/** Whether a durable header marks a fork-inherited (seeded) session across the live-session and handle surfaces. */
 export function isSeededSession(header) {
     if (header === undefined)
         return false;
@@ -256,387 +48,6 @@ export function isSeededSession(header) {
         return true;
     return (header.seedLength ?? 0) > 0;
 }
-/** Whether a Beijing (hour, weekday) pair falls inside any peak-hour window. */
-function isPeakParts(billing, hour, weekday) {
-    if (weekday === 0 || weekday === 6)
-        return false;
-    return billing.peakHours.some(({ start, end }) => hour >= start && hour < end);
-}
-/**
- * Whether a timestamp falls inside any peak-hour window (Beijing time,
- * weekdays Monday–Friday only). Weekends (Saturday and Sunday) are always
- * off-peak, matching the published peak-hours rule.
- * @param billing - resolved pricing with peak-hour windows.
- * @param now - the moment to classify.
- * @returns true during a weekday peak hour.
- */
-export function isPeak(billing, now) {
-    const { hour, weekday } = beijingPartsOf(now.getTime());
-    return isPeakParts(billing, hour, weekday);
-}
-/**
- * Price one event at the official per-model rates, applying the peak/off-peak
- * table by its Beijing-time hour and weekday (peak windows apply Monday–Friday
- * only; weekends are off-peak) and the rate revision in effect at its own
- * timestamp. Each `assistant/message` event with usage
- * contributes cache-hit input, cache-miss input (uncached input plus cache
- * writes), and output (reasoning included) tokens at the rate of its own
- * timestamp; a model with usage but no pricing row contributes nothing.
- * @param event - the event to price.
- * @param billing - resolved pricing with peak-hour windows.
- * @param names - model id → display label.
- * @returns the priced contribution, or `undefined` when the event has no priced usage.
- */
-export function priceEvent(event, billing, names) {
-    return priceEventAt(beijingPartsOf(event.time), event, billing, names);
-}
-/**
- * Price one event at the official per-model rates using a precomputed
- * Beijing-time view — the day-filtering and pricing of one event share a
- * single timezone parse (see {@link beijingPartsOf}). Semantics are identical
- * to {@link priceEvent}.
- * @param parts - the event's Beijing-time view.
- * @param event - the event to price.
- * @param billing - resolved pricing with peak-hour windows.
- * @param names - model id → display label.
- * @returns the priced contribution, or `undefined` when the event has no priced usage.
- */
-export function priceEventAt(parts, event, billing, names) {
-    if (event.type !== 'assistant/message')
-        return undefined;
-    const reported = event.data.usage;
-    if (reported === undefined)
-        return undefined;
-    return priceUsage(parts, reported, event.data.message.source.model, billing, names);
-}
-/**
- * Price one provider-reported usage sample for one model at the rates of the
- * sample's own Beijing-time hour and weekday — the peak or off-peak price of
- * the rate revision in effect at the sample's own timestamp (a re-priced series
- * bills its history at the rates that applied then). `undefined` when the model
- * has no pricing row.
- * @param parts - the sample's Beijing-time view.
- * @param usage - the reported token buckets.
- * @param model - the wire model id the sample belongs to.
- * @param billing - resolved pricing with peak-hour windows.
- * @param names - model id → display label.
- * @returns the priced contribution, or `undefined` when the model has no rate row.
- */
-export function priceUsage(parts, usage, model, billing, names) {
-    const pricing = billing.models.get(model);
-    if (pricing === undefined)
-        return undefined;
-    const peak = isPeakParts(billing, parts.hour, parts.weekday);
-    const revision = ratesAt(pricing.revisions, parts.time);
-    const price = peak ? revision.peak : revision.offPeak;
-    const hit = usage.cacheReadTokens ?? 0;
-    const miss = usage.inputTokens + (usage.cacheWriteTokens ?? 0);
-    const output = usage.outputTokens;
-    const hitCost = (hit * price.cacheHitInput) / 1_000_000;
-    const missCost = (miss * price.cacheMissInput) / 1_000_000;
-    const outputCost = (output * price.output) / 1_000_000;
-    const cost = hitCost + missCost + outputCost;
-    return {
-        dayKey: parts.dayKey,
-        model,
-        displayName: names.get(model) ?? model,
-        cost,
-        peakCost: peak ? cost : 0,
-        offPeakCost: peak ? 0 : cost,
-        cacheHitInputTokens: hit,
-        cacheMissInputTokens: miss,
-        outputTokens: output,
-        cacheHitInputCost: hitCost,
-        cacheMissInputCost: missCost,
-        outputCost,
-    };
-}
-/** A spend with no priced usage. */
-export function emptyTodaySpend() {
-    return { total: 0, models: [] };
-}
-/** The today-spend shape of a single priced contribution. */
-function contributionModel(priced) {
-    return {
-        model: priced.model,
-        displayName: priced.displayName,
-        cost: priced.cost,
-        peakCost: priced.peakCost,
-        offPeakCost: priced.offPeakCost,
-        cacheHitInputTokens: priced.cacheHitInputTokens,
-        cacheMissInputTokens: priced.cacheMissInputTokens,
-        outputTokens: priced.outputTokens,
-        cacheHitInputCost: priced.cacheHitInputCost,
-        cacheMissInputCost: priced.cacheMissInputCost,
-        outputCost: priced.outputCost,
-    };
-}
-/** Sum two model rows of the same model (pure). */
-function mergeModelRows(left, right) {
-    return {
-        model: left.model,
-        displayName: left.displayName,
-        cost: left.cost + right.cost,
-        peakCost: left.peakCost + right.peakCost,
-        offPeakCost: left.offPeakCost + right.offPeakCost,
-        cacheHitInputTokens: left.cacheHitInputTokens + right.cacheHitInputTokens,
-        cacheMissInputTokens: left.cacheMissInputTokens + right.cacheMissInputTokens,
-        outputTokens: left.outputTokens + right.outputTokens,
-        cacheHitInputCost: left.cacheHitInputCost + right.cacheHitInputCost,
-        cacheMissInputCost: left.cacheMissInputCost + right.cacheMissInputCost,
-        outputCost: left.outputCost + right.outputCost,
-    };
-}
-/**
- * Mutable model-row accumulator behind every spend fold. Rows keep first-seen
- * model order — the same shape a pure `addEventContribution` chain produces —
- * so the single-pass scan path and the pure public paths cannot diverge. One
- * `Map` lookup per contribution instead of a per-event array copy: the huge
- * event-log folds allocate one row object per model, not one intermediate
- * array per event.
- */
-export class SpendAccumulator {
-    rows = new Map();
-    total = 0;
-    /** Add one priced contribution. */
-    add(priced) {
-        const row = contributionModel(priced);
-        const existing = this.rows.get(priced.model);
-        this.rows.set(priced.model, existing === undefined ? row : mergeModelRows(existing, row));
-        this.total += priced.cost;
-    }
-    /** The folded spend; the accumulator stays usable afterwards. */
-    finish() {
-        return { total: this.total, models: [...this.rows.values()] };
-    }
-}
-/** The additive inverse of one spend (pure): used to replace a priced sample. */
-export function negateSpend(spend) {
-    const negate = (value) => -value;
-    return {
-        total: negate(spend.total),
-        models: spend.models.map(row => ({
-            ...row,
-            cost: negate(row.cost),
-            peakCost: negate(row.peakCost),
-            offPeakCost: negate(row.offPeakCost),
-            cacheHitInputTokens: negate(row.cacheHitInputTokens),
-            cacheMissInputTokens: negate(row.cacheMissInputTokens),
-            outputTokens: negate(row.outputTokens),
-            cacheHitInputCost: negate(row.cacheHitInputCost),
-            cacheMissInputCost: negate(row.cacheMissInputCost),
-            outputCost: negate(row.outputCost),
-        })),
-    };
-}
-/**
- * Subtract one spend from another (pure). Rows that cancel out completely are
- * dropped so a replaced sample leaves no zero row behind.
- * @param target - the spend to subtract from.
- * @param source - the spend to remove.
- * @returns the difference.
- */
-export function subtractSpend(target, source) {
-    const rows = new Map();
-    for (const row of target.models)
-        rows.set(row.model, row);
-    for (const row of source.models) {
-        const existing = rows.get(row.model);
-        if (existing === undefined)
-            continue;
-        const next = mergeModelRows(existing, negateSpend({ total: 0, models: [row] }).models[0]);
-        if (next.cost === 0 && next.cacheHitInputTokens === 0 && next.cacheMissInputTokens === 0 && next.outputTokens === 0) {
-            rows.delete(row.model);
-        }
-        else {
-            rows.set(row.model, next);
-        }
-    }
-    return { total: target.total - source.total, models: [...rows.values()] };
-}
-/** The empty fold state for one fork boundary. */
-export function emptyBillingFoldState(inheritedEventCount = 0) {
-    return {
-        dayKey: '',
-        spend: emptyTodaySpend(),
-        session: emptyTodaySpend(),
-        inheritedEventCount,
-        model: '',
-        last: null,
-    };
-}
-/** Whether an unknown value looks like a provider usage report. */
-function isTokenUsage(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const candidate = value;
-    return typeof candidate.inputTokens === 'number' && typeof candidate.outputTokens === 'number';
-}
-/**
- * The last `usage` sample embedded in an event's stream, if any. `assistant/
- * attempt` and the embedded streams are newer than the plugin's npm baseline,
- * so the stream is read structurally (a failed/retried attempt reports its
- * usage only there).
- */
-function streamUsageOf(event) {
-    const stream = event.data === undefined
-        ? undefined
-        : event.data.stream;
-    if (!Array.isArray(stream))
-        return undefined;
-    for (let index = stream.length - 1; index >= 0; index -= 1) {
-        const chunk = stream[index]?.chunk;
-        if (chunk === undefined || chunk.type !== 'usage')
-            continue;
-        return isTokenUsage(chunk.usage) ? chunk.usage : undefined;
-    }
-    return undefined;
-}
-/** The contribution as a one-row spend (the shape a sample keeps for replacement). */
-function contributionSpend(priced) {
-    return { total: priced.cost, models: [contributionModel(priced)] };
-}
-/**
- * Fold one committed event into a session's billed-spend state.
- *
- * Priced samples come from `assistant/message` (its own reported usage, or the
- * stream's last usage chunk) and `assistant/attempt` (the stream's last usage
- * chunk, priced with the model of the latest `request/header`, since an
- * attempt carries no route). A sample for the same `(turn, step)` replaces the
- * previous one; `llm/retry-started` closes the replacement slot so a retried
- * attempt adds. Every other event is inert and returns the same state
- * reference.
- * @param state - the previous fold state.
- * @param event - the committed event.
- * @param billing - resolved pricing with peak-hour windows.
- * @param names - model id → display label.
- * @returns the next state (the same reference when nothing was priced).
- */
-export function applyBillingEvent(state, event, billing, names) {
-    if (event.seq < state.inheritedEventCount)
-        return state;
-    // `assistant/attempt`, `llm/retry-started`, and the embedded stream are all
-    // newer than the npm baseline this package builds against, so their fields
-    // are read structurally.
-    const type = event.type;
-    if (type === 'request/header') {
-        const model = event.data
-            ?.header?.config?.model;
-        return typeof model === 'string' && model.length > 0 && model !== state.model ? { ...state, model } : state;
-    }
-    const data = event.data;
-    if (type === 'llm/retry-started') {
-        if (typeof data?.turn !== 'number' || typeof data.step !== 'number')
-            return state;
-        const last = state.last;
-        if (last === null || last.turn !== data.turn || last.step !== data.step)
-            return state;
-        return { ...state, last: null };
-    }
-    if (type !== 'assistant/message' && type !== 'assistant/attempt')
-        return state;
-    const usage = (type === 'assistant/message' ? data?.usage : undefined) ?? streamUsageOf(event);
-    if (!isTokenUsage(usage))
-        return state;
-    const model = type === 'assistant/message' ? data?.message?.source?.model : state.model;
-    if (typeof model !== 'string' || model.length === 0)
-        return state;
-    const priced = priceUsage(beijingPartsOf(event.time), usage, model, billing, names);
-    if (priced === undefined)
-        return state;
-    let session = state.session;
-    let spend = state.spend;
-    let dayKey = state.dayKey;
-    const last = state.last;
-    const turn = typeof data?.turn === 'number' ? data.turn : 0;
-    const step = typeof data?.step === 'number' ? data.step : 0;
-    if (last !== null && last.turn === turn && last.step === step) {
-        session = subtractSpend(session, last.spend);
-        if (last.dayKey === dayKey)
-            spend = subtractSpend(spend, last.spend);
-    }
-    session = addEventContribution(session, priced);
-    if (dayKey === priced.dayKey) {
-        spend = addEventContribution(spend, priced);
-    }
-    else if (dayKey === '' || priced.dayKey > dayKey) {
-        // The session log is append-only and chronological, so a strictly older
-        // day cannot legally follow; ignore it for the latest-day state (the
-        // whole-session total still accrues).
-        dayKey = priced.dayKey;
-        spend = addEventContribution(emptyTodaySpend(), priced);
-    }
-    return {
-        ...state,
-        dayKey,
-        spend,
-        session,
-        last: { turn, step, dayKey: priced.dayKey, spend: contributionSpend(priced) },
-    };
-}
-/**
- * Mutable wrapper over {@link applyBillingEvent} for the pure pricing paths:
- * feed events in order, read the folded spend.
- */
-export class BillingFolder {
-    billing;
-    state;
-    /**
-     * @param billing - resolved pricing with peak-hour windows.
-     * @param catalog - model display rows, in presentation order.
-     * @param inheritedEventCount - fork boundary to skip (default 0).
-     */
-    constructor(billing, catalog, inheritedEventCount = 0) {
-        this.billing = billing;
-        this.names = new Map(catalog.map(model => [model.id, model.name]));
-        this.state = emptyBillingFoldState(inheritedEventCount);
-    }
-    names;
-    /** Fold one event. */
-    add(event) {
-        this.state = applyBillingEvent(this.state, event, this.billing, this.names);
-    }
-    /** Fold every event, in order. */
-    addAll(events) {
-        for (const event of events)
-            this.add(event);
-    }
-    /** The folded state (live reference; do not mutate). */
-    get fold() {
-        return this.state;
-    }
-}
-/**
- * Merge one priced event's contribution into an accumulator spend (pure:
- * returns a new spend, never mutates its input).
- * @param spend - the accumulator (per session and day, or across sessions).
- * @param priced - the priced contribution to add.
- * @returns the merged spend.
- */
-export function addEventContribution(spend, priced) {
-    const row = contributionModel(priced);
-    const rows = spend.models.map(existing => existing.model === priced.model ? mergeModelRows(existing, row) : existing);
-    if (!rows.some(existing => existing.model === priced.model))
-        rows.push(row);
-    return { total: spend.total + priced.cost, models: rows };
-}
-/**
- * Sum two spends (per session and day, or across sessions) into one (pure:
- * returns a new spend, never mutates its inputs).
- * @param target - the accumulator spend.
- * @param source - the spend to add.
- * @returns the summed spend.
- */
-export function mergeTodaySpend(target, source) {
-    const rows = new Map();
-    for (const row of target.models)
-        rows.set(row.model, row);
-    for (const row of source.models) {
-        const existing = rows.get(row.model);
-        rows.set(row.model, existing === undefined ? row : mergeModelRows(existing, row));
-    }
-    return { total: target.total + source.total, models: [...rows.values()] };
-}
 /**
  * Price one session's complete event log at the official per-model rates,
  * with DSH's attempt semantics: every provider-reported sample (an
@@ -824,10 +235,13 @@ export function computeSessionTurnSpends(events, billing, catalog) {
  */
 export function computeTodaySpend(events, billing, catalog, now = new Date()) {
     const day = beijingDayKey(now);
+    // Events past the reference day cannot contribute: one numeric bound for the
+    // scan instead of a date string per event.
+    const dayRange = beijingDayRangeOfKey(day);
+    const dayEnd = dayRange?.end ?? Number.POSITIVE_INFINITY;
     const folder = new BillingFolder(billing, catalog);
     for (const event of events) {
-        // Only events up to the reference day can contribute.
-        if (beijingPartsOf(event.time).dayKey > day)
+        if (event.time >= dayEnd)
             continue;
         folder.add(event);
     }