@rayadesu/dsh-llm-billing 0.2.1 → 0.2.3

package/lib/types/billing.js

@@ -3,9 +3,20 @@
  * 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.
- * @module @deepseek-ai/dsh-llm-billing/billing
+ *
+ * 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.
+ * @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).
  */
-/** Published peak-hour windows (Beijing time): 09:00–12:00 and 14:00–18:00. */
 export const DEFAULT_PEAK_HOURS = [
     { start: 9, end: 12 },
     { start: 14, end: 18 },
@@ -22,6 +33,13 @@ export const DEFAULT_MODEL_PRICING = [
         peak: { cacheHitInput: 0.30, cacheMissInput: 9.0, output: 27.0 },
         offPeak: { cacheHitInput: 0.15, cacheMissInput: 4.5, output: 13.5 },
     },
+    // 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',
+        peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
+        offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
+    },
 ];
 /**
  * Resolve optional configuration to a pricing table, defaulting omitted or
@@ -44,27 +62,184 @@ export function resolveBilling(config) {
         models.set(row.model, { peak: row.peak, offPeak: row.offPeak });
     return { peakHours, models };
 }
-/** The Beijing (Asia/Shanghai, UTC+8, no DST) hour of a timestamp. */
-function beijingHour(now) {
-    return new Date(now.getTime() + 8 * 3_600_000).getUTCHours();
+/**
+ * Derive the Beijing hour, weekday, and calendar-day key of one timestamp from
+ * a single shifted `Date` — every timezone-sensitive read shares this one
+ * implementation, so the pieces cannot drift apart.
+ * @param time - epoch milliseconds.
+ */
+function beijingParts(time) {
+    const shifted = new Date(time + 8 * 3_600_000);
+    return {
+        hour: shifted.getUTCHours(),
+        weekday: shifted.getUTCDay(),
+        dayKey: shifted.toISOString().slice(0, 10),
+    };
 }
 /** The Beijing (Asia/Shanghai, UTC+8, no DST) calendar-day key of a timestamp. */
-function beijingDayKey(now) {
-    return new Date(now.getTime() + 8 * 3_600_000).toISOString().slice(0, 10);
+export function beijingDayKey(now) {
+    return beijingParts(now.getTime()).dayKey;
+}
+/** 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).
+ * 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 peak hours.
+ * @returns true during a weekday peak hour.
  */
 export function isPeak(billing, now) {
-    const hour = beijingHour(now);
-    return billing.peakHours.some(({ start, end }) => hour >= start && hour < end);
+    const { hour, weekday } = beijingParts(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). 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 (the
+ * published table prices only the two V4 rows).
+ * @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) {
+    if (event.type !== 'assistant/message')
+        return undefined;
+    const reported = event.data.usage;
+    if (reported === undefined)
+        return undefined;
+    const model = event.data.message.source.model;
+    const pricing = billing.models.get(model);
+    if (pricing === undefined)
+        return undefined;
+    const { hour, weekday, dayKey } = beijingParts(event.time);
+    const peak = isPeakParts(billing, hour, weekday);
+    const price = peak ? pricing.peak : pricing.offPeak;
+    const hit = reported.cacheReadTokens ?? 0;
+    const miss = reported.inputTokens + (reported.cacheWriteTokens ?? 0);
+    const output = reported.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,
+        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()] };
+    }
+}
+/**
+ * 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 a set of billed events at the official per-model rates, applying the
- * peak/off-peak table per event by its Beijing-time hour. Each
+ * peak/off-peak table per event by its Beijing-time hour and weekday (peak
+ * windows apply Monday–Friday only; weekends are off-peak). 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, with the three component costs
@@ -72,69 +247,19 @@ export function isPeak(billing, now) {
  * published table prices only the two V4 rows).
  * @param events - the events to price.
  * @param billing - resolved pricing with peak-hour windows.
- * @param catalog - model display rows, in presentation order.
+ * @param names - model id → display label.
+ * @param dayKey - when provided, only events on this Beijing calendar day contribute.
  * @returns the total cost plus one row per priced model.
  */
-function priceEvents(events, billing, catalog) {
-    const names = new Map(catalog.map(model => [model.id, model.name]));
-    const rows = new Map();
+function priceEvents(events, billing, names, dayKey) {
+    const accumulator = new SpendAccumulator();
     for (const event of events) {
-        if (event.type !== 'assistant/message')
-            continue;
-        const reported = event.data.usage;
-        if (reported === undefined)
-            continue;
-        const model = event.data.message.source.model;
-        const pricing = billing.models.get(model);
-        if (pricing === undefined)
+        const priced = priceEvent(event, billing, names);
+        if (priced === undefined || (dayKey !== undefined && priced.dayKey !== dayKey))
             continue;
-        const peak = isPeak(billing, new Date(event.time));
-        const price = peak ? pricing.peak : pricing.offPeak;
-        const hit = reported.cacheReadTokens ?? 0;
-        const miss = reported.inputTokens + (reported.cacheWriteTokens ?? 0);
-        const output = reported.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;
-        let row = rows.get(model);
-        if (row === undefined) {
-            row = {
-                cacheHitInputTokens: 0, cacheMissInputTokens: 0, outputTokens: 0,
-                cost: 0, peakCost: 0, offPeakCost: 0,
-                cacheHitInputCost: 0, cacheMissInputCost: 0, outputCost: 0,
-            };
-            rows.set(model, row);
-        }
-        row.cacheHitInputTokens += hit;
-        row.cacheMissInputTokens += miss;
-        row.outputTokens += output;
-        row.cost += cost;
-        row.cacheHitInputCost += hitCost;
-        row.cacheMissInputCost += missCost;
-        row.outputCost += outputCost;
-        if (peak)
-            row.peakCost += cost;
-        else
-            row.offPeakCost += cost;
+        accumulator.add(priced);
     }
-    const models = [...rows.entries()].map(([model, row]) => ({
-        model,
-        displayName: names.get(model) ?? model,
-        cost: row.cost,
-        peakCost: row.peakCost,
-        offPeakCost: row.offPeakCost,
-        cacheHitInputTokens: row.cacheHitInputTokens,
-        cacheMissInputTokens: row.cacheMissInputTokens,
-        outputTokens: row.outputTokens,
-        cacheHitInputCost: row.cacheHitInputCost,
-        cacheMissInputCost: row.cacheMissInputCost,
-        outputCost: row.outputCost,
-    }));
-    return {
-        total: models.reduce((sum, model) => sum + model.cost, 0),
-        models,
-    };
+    return accumulator.finish();
 }
 /**
  * Price one session's complete event log at the official per-model rates.
@@ -144,7 +269,8 @@ function priceEvents(events, billing, catalog) {
  * @returns the session's total cost plus one row per priced model.
  */
 export function computeSessionSpend(events, billing, catalog) {
-    return priceEvents(events, billing, catalog);
+    const names = new Map(catalog.map(model => [model.id, model.name]));
+    return priceEvents(events, billing, names);
 }
 /**
  * Price every event whose Beijing-time calendar day is the day of `now`,
@@ -158,6 +284,7 @@ export function computeSessionSpend(events, billing, catalog) {
  */
 export function computeTodaySpend(events, billing, catalog, now = new Date()) {
     const day = beijingDayKey(now);
-    return priceEvents(events.filter(event => beijingDayKey(new Date(event.time)) === day), billing, catalog);
+    const names = new Map(catalog.map(model => [model.id, model.name]));
+    return priceEvents(events, billing, names, day);
 }
 //# sourceMappingURL=billing.js.map

package/lib/types/index.d.ts

@@ -4,15 +4,33 @@
  * the credential/environment seams, prices each session's billed usage with the
  * peak/off-peak table, and exposes the `billing` Remote (`getBalance`, the
  * per-session `getSessionSpend`, and the all-sessions `getTodaySpend`).
- * @module @deepseek-ai/dsh-llm-billing
+ *
+ * Today's spend never scans every session log per request: a 60-second
+ * Beijing-day cache with in-flight coalescing serves the message-triggered
+ * reads, the manual refresh may bypass the time window (`force`), and the
+ * computation behind a miss reads only sessions whose persisted revision
+ * changed since the last resolution (see today-spend.ts). When the
+ * session-projection registry is composed, the plugin additionally registers
+ * the `billingTodaySpend` projection unit, which folds each session's spend
+ * eagerly and lets cold reads ride the projection-cache ladder.
+ *
+ * A per-session spend cache makes the badge's turn-settled recompute
+ * incremental: session logs are append-only and chronological (the same
+ * assumption the projection unit makes), so the spend is reused while the log
+ * length is unchanged, and only the appended tail is priced when it grows.
+ * @module @rayadesu/dsh-llm-billing
  */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import type { BillingConfig } from './billing.ts';
 export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from './balance.ts';
-export { computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, isPeak, resolveBilling, } from './billing.ts';
-export type { BillingConfig, BillingConfigModel, DeepSeekModelPricing, DeepSeekTokenPrice, PeakHourWindow, ResolvedBilling, } from './billing.ts';
+export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, isPeak, mergeTodaySpend, priceEvent, resolveBilling, SpendAccumulator, } from './billing.ts';
+export type { BillingConfig, BillingConfigModel, BillingEventContribution, DeepSeekModelPricing, DeepSeekTokenPrice, PeakHourWindow, ResolvedBilling, } from './billing.ts';
 export type * from './types.ts';
+export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit } from './projection.ts';
+export type { BillingUnitState } from './projection.ts';
+export { TodaySpendCache, TodaySpendScanner } from './today-spend.ts';
+export type { ScannerPersistedHeader, ScannerSession, TodaySpendScannerDeps } from './today-spend.ts';
 export declare const name = "llm-billing";
 /** Public API default; deployments may point elsewhere via $DEEPSEEK_BASE_URL. */
 export declare const PUBLIC_BASE_URL = "https://api.deepseek.com";
@@ -34,12 +52,16 @@ export interface Config {
     apiKeyEnv?: string;
     /** Endpoint base; defaults to `$DEEPSEEK_BASE_URL`, then `https://api.deepseek.com`. */
     baseURL?: string;
-    /** Advisory display rows, in presentation order; defaults to V4 Flash and V4 Pro. */
+    /** Advisory display rows, in presentation order; defaults to V4 Flash, V4 Pro, and V4 Flash Vision Exp. */
     models?: BillingModel[];
-    /** Pricing table and peak-hour windows; omission uses the published defaults. */
+    /** Pricing table and peak-hour windows; omission uses the published defaults. Peak windows apply weekdays (Monday–Friday) only; weekends are always off-peak. */
     billing?: BillingConfig;
 }
 export declare const Config: z<Config>;
+/** How often a Beijing-day "today spend" value may be recomputed (60s). */
+export declare const TODAY_SPEND_CACHE_MS = 60000;
+/** Hard cap on today's events collected by the events scan path. */
+export declare const TODAY_SPEND_MAX_EVENTS = 200000;
 /**
  * Register the `billing` Remote under the `billing` namespace.
  * @param ctx - owning plugin context.

package/lib/types/index.js

@@ -4,16 +4,34 @@
  * the credential/environment seams, prices each session's billed usage with the
  * peak/off-peak table, and exposes the `billing` Remote (`getBalance`, the
  * per-session `getSessionSpend`, and the all-sessions `getTodaySpend`).
- * @module @deepseek-ai/dsh-llm-billing
+ *
+ * Today's spend never scans every session log per request: a 60-second
+ * Beijing-day cache with in-flight coalescing serves the message-triggered
+ * reads, the manual refresh may bypass the time window (`force`), and the
+ * computation behind a miss reads only sessions whose persisted revision
+ * changed since the last resolution (see today-spend.ts). When the
+ * session-projection registry is composed, the plugin additionally registers
+ * the `billingTodaySpend` projection unit, which folds each session's spend
+ * eagerly and lets cold reads ride the projection-cache ladder.
+ *
+ * A per-session spend cache makes the badge's turn-settled recompute
+ * incremental: session logs are append-only and chronological (the same
+ * assumption the projection unit makes), so the spend is reused while the log
+ * length is unchanged, and only the appended tail is priced when it grows.
+ * @module @rayadesu/dsh-llm-billing
  */
 import z from '@deepseek-ai/schemastery';
 import { assertUsableApiKey, LlmError } from '@deepseek-ai/dsh-llm';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DeepSeekBalanceGateway, fetchDeepSeekBalance } from "./balance.js";
-import { computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, resolveBilling, } from "./billing.js";
+import { computeSessionSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, mergeTodaySpend, resolveBilling, } from "./billing.js";
+import { billingTodaySpendDefinition } from "./projection.js";
+import { TodaySpendCache, TodaySpendScanner } from "./today-spend.js";
 export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from "./balance.js";
-export { computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, isPeak, resolveBilling, } from "./billing.js";
+export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, isPeak, mergeTodaySpend, priceEvent, resolveBilling, SpendAccumulator, } from "./billing.js";
+export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit } from "./projection.js";
+export { TodaySpendCache, TodaySpendScanner } from "./today-spend.js";
 export const name = 'llm-billing';
 const DEFAULT_API_KEY_ENV = 'DEEPSEEK_API_KEY';
 const BASE_URL_ENV = 'DEEPSEEK_BASE_URL';
@@ -22,6 +40,7 @@ export const PUBLIC_BASE_URL = 'https://api.deepseek.com';
 const DEFAULT_MODELS = [
     { id: 'deepseek-v4-flash', name: 'DeepSeek-V4-Flash' },
     { id: 'deepseek-v4-pro', name: 'DeepSeek-V4-Pro' },
+    { id: 'deepseek-v4-flash-vision-exp', name: 'DeepSeek-V4-Flash-Vision-Exp' },
 ];
 const billingModel = z.object({
     id: z.string().required(),
@@ -49,9 +68,14 @@ export const Config = z.object({
     models: z.array(billingModel).default(DEFAULT_MODELS),
     billing: billingConfig,
 });
+/** How often a Beijing-day "today spend" value may be recomputed (60s). */
+export const TODAY_SPEND_CACHE_MS = 60_000;
+/** Hard cap on today's events collected by the events scan path. */
+export const TODAY_SPEND_MAX_EVENTS = 200_000;
 /**
  * Read one session's event log: the live SessionStore first, then the
- * persistence backend for a flushed session.
+ * persistence backend for a flushed session (inspected directly by id — no
+ * header listing).
  * @param ctx - plugin context carrying the SessionStore and optional persistence.
  * @param sessionId - the session to read.
  * @returns the session's complete event log.
@@ -64,52 +88,14 @@ async function sessionEvents(ctx, sessionId) {
         return live.events;
     const persistence = ctx.get('sessionPersistence');
     if (persistence !== undefined) {
-        for (const header of await persistence.list()) {
-            if (header.id !== sessionId)
-                continue;
-            const inspection = await persistence.inspect(sessionId);
-            return inspection.events;
+        try {
+            return (await persistence.inspect(sessionId)).events;
         }
-    }
-    throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND');
-}
-/**
- * Read every session's event log, concatenated: each live SessionStore
- * session first (its log may hold events not yet flushed), then each persisted
- * session that is not live, so no event is counted twice. Events are appended
- * one at a time: spreading a very large log into `push(...)` exceeds the
- * engine's argument limit and throws a stack RangeError.
- * @param ctx - plugin context carrying the SessionStore and optional persistence.
- * @returns every session's complete event log, concatenated.
- */
-async function allSessionEvents(ctx) {
-    const events = [];
-    const sessions = ctx.get('sessions');
-    const liveIds = new Set();
-    if (sessions !== undefined) {
-        for (const session of sessions.list()) {
-            liveIds.add(session.id);
-            for (const event of session.events)
-                events.push(event);
+        catch (error) {
+            throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND', { cause: error });
         }
     }
-    const persistence = ctx.get('sessionPersistence');
-    if (persistence !== undefined) {
-        for (const header of await persistence.list()) {
-            if (liveIds.has(header.id))
-                continue;
-            try {
-                const inspection = await persistence.inspect(header.id);
-                for (const event of inspection.events)
-                    events.push(event);
-            }
-            catch (error) {
-                // One unreadable session must not blank the whole-day aggregate.
-                ctx.logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
-            }
-        }
-    }
-    return events;
+    throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND');
 }
 /**
  * Register the `billing` Remote under the `billing` namespace.
@@ -140,16 +126,67 @@ export function apply(ctx, config) {
         const apiKey = await resolveApiKey();
         return fetchDeepSeekBalance(baseURL(), apiKey);
     };
+    const billing = resolveBilling(config.billing);
+    const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }));
+    // Per-session incremental spend cache: a session log is append-only and
+    // chronological (the same assumption the projection unit makes), so a spend
+    // computed for `count` events stays valid while the log length is unchanged,
+    // and only the appended tail needs pricing when it grows. A pricing-table
+    // change does not retroactively reprice (same caveat as the projection
+    // path); the map is capped so an unbounded session-id space cannot grow it
+    // without bound.
+    const sessionSpendCache = new Map();
     const fetchSessionSpend = async (sessionId) => {
-        const billing = resolveBilling(config.billing);
-        const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }));
-        return computeSessionSpend(await sessionEvents(ctx, sessionId), billing, catalog);
+        const events = await sessionEvents(ctx, sessionId);
+        const cached = sessionSpendCache.get(sessionId);
+        if (cached !== undefined && cached.count === events.length)
+            return cached.spend;
+        if (cached !== undefined && cached.count < events.length) {
+            const spend = mergeTodaySpend(cached.spend, computeSessionSpend(events.slice(cached.count), billing, catalog));
+            sessionSpendCache.set(sessionId, { count: events.length, spend });
+            return spend;
+        }
+        const spend = computeSessionSpend(events, billing, catalog);
+        if (sessionSpendCache.size >= 1024)
+            sessionSpendCache.clear();
+        sessionSpendCache.set(sessionId, { count: events.length, spend });
+        return spend;
     };
-    const fetchTodaySpend = async () => {
-        const billing = resolveBilling(config.billing);
-        const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }));
-        return computeTodaySpend(await allSessionEvents(ctx), billing, catalog);
+    // Plan C: register the per-session spend projection unit on the projection
+    // registry. Registration is lazy — it happens on the first projection-path
+    // scan, not through `ctx.inject` (whose plugin-mount wait would also engage
+    // the test-invariant host in suites that never provide the registry). The
+    // registry builds cells lazily over the in-memory log, so events committed
+    // before registration are folded on first touch; without the registry the
+    // events path serves today's spend.
+    const unit = billingTodaySpendDefinition(billing, catalog);
+    let unitRegistered = false;
+    const ensureUnit = () => {
+        if (unitRegistered)
+            return;
+        const registry = ctx.get('sessionProjections');
+        if (registry === undefined)
+            return;
+        registry.register(unit);
+        unitRegistered = true;
     };
+    // Plans A1–A3: 60s Beijing-day cache with in-flight coalescing and a force
+    // bypass, over a revision-gated scanner (projection path when the registry
+    // is composed, events path otherwise).
+    const scanner = new TodaySpendScanner({
+        sessions: () => ctx.get('sessions'),
+        persistence: () => ctx.get('sessionPersistence'),
+        projections: () => ctx.get('sessionProjections'),
+        projectionCache: () => ctx.get('sessionProjectionCache'),
+        ensureUnit,
+        unit,
+        maxEvents: TODAY_SPEND_MAX_EVENTS,
+        logger: ctx.logger,
+        billing,
+        catalog,
+    });
+    const todayCache = new TodaySpendCache(dayKey => scanner.scan(dayKey), TODAY_SPEND_CACHE_MS);
+    const fetchTodaySpend = async (force = false) => todayCache.get(force);
     new DeepSeekBalanceGateway(ctx, { fetchBalance, fetchSessionSpend, fetchTodaySpend });
 }
 //# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -1,6 +1,6 @@
 /**
- * Package-owned invariant companion for `@deepseek-ai/dsh-llm-billing`.
- * @module @deepseek-ai/dsh-llm-billing/invariant
+ * Package-owned invariant companion for `@rayadesu/dsh-llm-billing`.
+ * @module @rayadesu/dsh-llm-billing/invariant
  */
 import type { Context } from '@deepseek-ai/cordis';
 /** Cordis companion plugin name. */

package/lib/types/invariant.js

@@ -1,8 +1,8 @@
 /**
- * Package-owned invariant companion for `@deepseek-ai/dsh-llm-billing`.
- * @module @deepseek-ai/dsh-llm-billing/invariant
+ * Package-owned invariant companion for `@rayadesu/dsh-llm-billing`.
+ * @module @rayadesu/dsh-llm-billing/invariant
  */
-const PACKAGE_NAME = '@deepseek-ai/dsh-llm-billing';
+const PACKAGE_NAME = '@rayadesu/dsh-llm-billing';
 /** Cordis companion plugin name. */
 export const name = 'llm-billing-invariant';
 /** Service required before the companion can reserve package ownership. */