@rayadesu/dsh-llm-billing 0.1.0 → 0.2.0

package/lib/index.js

@@ -3,7 +3,8 @@ import { LlmError, assertUsableApiKey } from "@deepseek-ai/dsh-llm";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
-//#region ../../../../DeepSeek-Harness-chat-billing/packages/llm-billing/lib/types/balance.js
+import { z as z$1 } from "zod";
+//#region lib/types/balance.js
 /**
 * DeepSeek account-balance capability: the `GET /user/balance` transport and
 * the Remote gateway that exposes one snapshot to trusted clients. The fetch
@@ -207,20 +208,29 @@ let DeepSeekBalanceGateway = (() => {
 		/**
 		* Read today's billed spend across every session, priced per event by its
 		* Beijing-time calendar day, hour, and weekday (weekends are always off-peak).
+		* @param force - bypass the host-side 60s cache (manual refresh); omitted
+		*   means a cached read. Remote parameters cannot carry default values, so
+		*   the thunk receives `undefined` for an omitted argument.
 		* @returns today's total cost plus one row per priced model.
 		*/
-		getTodaySpend() {
-			return this.options.fetchTodaySpend();
+		getTodaySpend(force) {
+			return this.options.fetchTodaySpend(force ?? false);
 		}
 	};
 })();
 //#endregion
-//#region ../../../../DeepSeek-Harness-chat-billing/packages/llm-billing/lib/types/billing.js
+//#region lib/types/billing.js
 /**
 * 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.
+*
+* The per-event pricing lives in {@link priceEvent}, the one shared fold
+* primitive: the events-scan paths ({@link computeSessionSpend},
+* {@link computeTodaySpend}) and the session-projection unit
+* (`billingTodaySpend` in projection.ts) all fold the same contribution, so a
+* pricing-table change cannot drift one path from the others.
 * @module @rayadesu/dsh-llm-billing/billing
 */
 /**
@@ -329,6 +339,125 @@ function isPeak(billing, now) {
 	return billing.peakHours.some(({ start, end }) => hour >= start && hour < end);
 }
 /**
+* 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.
+*/
+function priceEvent(event, billing, names) {
+	if (event.type !== "assistant/message") return void 0;
+	const reported = event.data.usage;
+	if (reported === void 0) return void 0;
+	const model = event.data.message.source.model;
+	const pricing = billing.models.get(model);
+	if (pricing === void 0) return void 0;
+	const time = new Date(event.time);
+	const peak = isPeak(billing, 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 / 1e6;
+	const missCost = miss * price.cacheMissInput / 1e6;
+	const outputCost = output * price.output / 1e6;
+	const cost = hitCost + missCost + outputCost;
+	return {
+		dayKey: beijingDayKey(time),
+		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. */
+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
+	};
+}
+/**
+* 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.
+*/
+function addEventContribution(spend, priced) {
+	const rows = spend.models.map((row) => row.model === priced.model ? {
+		...row,
+		cost: row.cost + priced.cost,
+		peakCost: row.peakCost + priced.peakCost,
+		offPeakCost: row.offPeakCost + priced.offPeakCost,
+		cacheHitInputTokens: row.cacheHitInputTokens + priced.cacheHitInputTokens,
+		cacheMissInputTokens: row.cacheMissInputTokens + priced.cacheMissInputTokens,
+		outputTokens: row.outputTokens + priced.outputTokens,
+		cacheHitInputCost: row.cacheHitInputCost + priced.cacheHitInputCost,
+		cacheMissInputCost: row.cacheMissInputCost + priced.cacheMissInputCost,
+		outputCost: row.outputCost + priced.outputCost
+	} : row);
+	if (!rows.some((row) => row.model === priced.model)) rows.push(contributionModel(priced));
+	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.
+*/
+function mergeTodaySpend(target, source) {
+	let merged = target;
+	for (const row of source.models) merged = addEventContribution(merged, {
+		dayKey: "",
+		model: row.model,
+		displayName: row.displayName,
+		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 merged;
+}
+/**
 * 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 and weekday (peak
 * windows apply Monday–Friday only; weekends are off-peak). Each
@@ -344,65 +473,16 @@ function isPeak(billing, now) {
 */
 function priceEvents(events, billing, catalog) {
 	const names = new Map(catalog.map((model) => [model.id, model.name]));
-	const rows = /* @__PURE__ */ new Map();
+	let spend = {
+		total: 0,
+		models: []
+	};
 	for (const event of events) {
-		if (event.type !== "assistant/message") continue;
-		const reported = event.data.usage;
-		if (reported === void 0) continue;
-		const model = event.data.message.source.model;
-		const pricing = billing.models.get(model);
-		if (pricing === void 0) 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 / 1e6;
-		const missCost = miss * price.cacheMissInput / 1e6;
-		const outputCost = output * price.output / 1e6;
-		const cost = hitCost + missCost + outputCost;
-		let row = rows.get(model);
-		if (row === void 0) {
-			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;
+		const priced = priceEvent(event, billing, names);
+		if (priced === void 0) continue;
+		spend = addEventContribution(spend, 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 spend;
 }
 /**
 * Price one session's complete event log at the official per-model rates.
@@ -426,16 +506,326 @@ function computeSessionSpend(events, billing, catalog) {
 */
 function computeTodaySpend(events, billing, catalog, now = /* @__PURE__ */ 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]));
+	let spend = emptyTodaySpend();
+	for (const event of events) {
+		const priced = priceEvent(event, billing, names);
+		if (priced === void 0 || priced.dayKey !== day) continue;
+		spend = addEventContribution(spend, priced);
+	}
+	return spend;
 }
 //#endregion
-//#region ../../../../DeepSeek-Harness-chat-billing/packages/llm-billing/lib/types/index.js
+//#region lib/types/projection.js
+/**
+* `billingTodaySpend` session-projection unit: per-session, per-Beijing-day
+* billed spend, folded eagerly by the DSH projection drive over committed
+* session events and checkpointed by the projection cache. The unit keeps only
+* the spend of the session's LATEST priced day (events are append-only and
+* chronological, so a day strictly older than the state's day never returns);
+* the aggregate "today" read sums the units whose `dayKey` matches the current
+* Beijing day — zero full-log scans once the fold is warm.
+*
+* The unit's fold shares {@link priceEvent} with the events-scan paths
+* (`computeTodaySpend`), so both price with the same table. The unit is
+* client-visible (`wire` = identity) because the persisted-cache read ladder
+* (`sessionProjectionCache.coldSnapshot` / registry `restore`) serves only
+* wired units; the wire value is the state itself.
+* @module @rayadesu/dsh-llm-billing/projection
+*/
+/** The projection key this unit owns. */
+const BILLING_UNIT_KEY = "billingTodaySpend";
+const modelRowSchema = z$1.object({
+	model: z$1.string(),
+	displayName: z$1.string(),
+	cost: z$1.number().nonnegative(),
+	peakCost: z$1.number().nonnegative(),
+	offPeakCost: z$1.number().nonnegative(),
+	cacheHitInputTokens: z$1.number().int().nonnegative(),
+	cacheMissInputTokens: z$1.number().int().nonnegative(),
+	outputTokens: z$1.number().int().nonnegative(),
+	cacheHitInputCost: z$1.number().nonnegative(),
+	cacheMissInputCost: z$1.number().nonnegative(),
+	outputCost: z$1.number().nonnegative()
+}).strict();
+const todaySpendSchema = z$1.object({
+	total: z$1.number().nonnegative(),
+	models: z$1.array(modelRowSchema)
+}).strict();
+const billingUnitSchema = z$1.object({
+	dayKey: z$1.string(),
+	spend: todaySpendSchema
+}).strict();
+/**
+* Build the `billingTodaySpend` unit for one resolved pricing table. The
+* pricing closure is fixed at registration; a pricing-table change therefore
+* prices only events folded after the change (historical spend keeps its
+* historical rates), unlike the events-scan paths which re-price the whole
+* log. Bump {@link ProjectionDefinition.stateVersion} whenever the state
+* shape or fold semantics change, so persisted checkpoint rows are discarded
+* instead of folded forward.
+* @param billing - resolved pricing with peak-hour windows.
+* @param catalog - model display rows, in presentation order.
+* @returns the unit definition to register on `ctx.sessionProjections`.
+*/
+function billingTodaySpendDefinition(billing, catalog) {
+	const names = new Map(catalog.map((model) => [model.id, model.name]));
+	return {
+		key: BILLING_UNIT_KEY,
+		stateVersion: 1,
+		stateSchema: billingUnitSchema,
+		init: () => ({
+			dayKey: "",
+			spend: emptyTodaySpend()
+		}),
+		apply: (state, event) => {
+			const priced = priceEvent(event, billing, names);
+			if (priced === void 0) return state;
+			if (state.dayKey === priced.dayKey) return {
+				dayKey: state.dayKey,
+				spend: addEventContribution(state.spend, priced)
+			};
+			if (state.dayKey !== "" && priced.dayKey < state.dayKey) return state;
+			return {
+				dayKey: priced.dayKey,
+				spend: addEventContribution(emptyTodaySpend(), priced)
+			};
+		},
+		wire: {
+			viewSchema: billingUnitSchema,
+			view: (state) => state
+		}
+	};
+}
+/** Fold a unit from init over one session's event log (the detached cold recipe). */
+function foldBillingUnit(unit, events) {
+	let state = unit.init();
+	for (const event of events) state = unit.apply(state, event);
+	return state;
+}
+//#endregion
+//#region lib/types/today-spend.js
+/**
+* Today-spend read path: the 60-second Beijing-day cache with in-flight
+* coalescing and a force bypass (plan A1), plus the two scan strategies that
+* compute the aggregate behind a cache miss:
+*
+* - projection path (plan C): live sessions read their eagerly folded
+*   `billingTodaySpend` projection cell; cold sessions resolve through the
+*   projection-cache ladder (cached row + tail replay + registry restore,
+*   with write-back) or, without the cache service, one detached local fold
+*   over a full `inspect`. Persisted revisions gate every cold read, so a
+*   session whose log did not change since the last resolution costs nothing.
+* - events path (plans A2/A3): collect only today's events (per-event
+*   Beijing-day filter during collection) with a hard cap, skipping sessions
+*   whose persisted revision is unchanged since the last scan.
+*
+* Both strategies run behind the same {@link TodaySpendCache}, so a miss
+* happens at most once per 60 seconds per process, and a manual refresh
+* (`force`) bypasses the time window but keeps the revision caches — an
+* unchanged log provably cannot change the aggregate.
+* @module @rayadesu/dsh-llm-billing/today-spend
+*/
+/** Bounded parallel fan-out: run `run` over `items` with at most `limit` in flight. */
+async function withConcurrency(items, limit, run) {
+	const queue = [...items];
+	await Promise.all(Array.from({ length: Math.min(limit, queue.length) }, async () => {
+		for (let job = queue.shift(); job !== void 0; job = queue.shift()) await run(job);
+	}));
+}
+/**
+* The A1 cache: one Beijing-day key + a 60s window, an in-flight promise that
+* coalesces concurrent misses, and a `force` bypass for the manual refresh
+* path. Cross-day invalidation is automatic (the day key changes); a failed
+* scan leaves the previous value in place and retries on the next call.
+*/
+var TodaySpendCache = class {
+	scan;
+	ttlMs;
+	now;
+	cachedDayKey;
+	cachedValue;
+	cachedAt = 0;
+	inFlight;
+	/**
+	* @param ttlMs - time window in milliseconds (default 60 000).
+	* @param now - clock source (injectable for tests).
+	* @param scan - the aggregate computation behind a miss.
+	*/
+	constructor(scan, ttlMs = 6e4, now = () => /* @__PURE__ */ new Date()) {
+		this.scan = scan;
+		this.ttlMs = ttlMs;
+		this.now = now;
+	}
+	/**
+	* Read today's spend, cached per Beijing day within the TTL window.
+	* @param force - bypass the time window (manual refresh); the day-key gate
+	*   and the in-flight coalescing still apply to non-force callers.
+	* @returns today's spend.
+	*/
+	get(force = false) {
+		const now = this.now();
+		const dayKey = beijingDayKey(now);
+		if (!force && this.cachedDayKey === dayKey && this.cachedValue !== void 0 && now.getTime() - this.cachedAt < this.ttlMs) return Promise.resolve(this.cachedValue);
+		if (!force && this.inFlight !== void 0) return this.inFlight;
+		const run = (async () => {
+			try {
+				const value = await this.scan(dayKey);
+				this.cachedDayKey = dayKey;
+				this.cachedValue = value;
+				this.cachedAt = now.getTime();
+				return value;
+			} finally {
+				this.inFlight = void 0;
+			}
+		})();
+		if (!force) this.inFlight = run;
+		return run;
+	}
+};
+/**
+* The aggregate computation behind a cache miss. Chooses the projection path
+* when the projection registry is composed, the events path otherwise; both
+* gate cold reads on persisted revisions so steady-state scans touch only
+* sessions whose logs actually changed.
+*/
+var TodaySpendScanner = class {
+	deps;
+	/** Cold sessions resolved on the projection path: id → revision + unit state. */
+	coldResolved = /* @__PURE__ */ new Map();
+	/** Cold sessions resolved on the events path: id → revision (events were collected). */
+	lastEventsScan;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/**
+	* Compute today's aggregate for one Beijing day.
+	* @param dayKey - the Beijing-time calendar-day key to aggregate.
+	* @returns today's spend across every session.
+	*/
+	async scan(dayKey) {
+		if (this.deps.projections?.() === void 0) return this.scanEvents(dayKey);
+		this.deps.ensureUnit?.();
+		return this.scanProjections(dayKey);
+	}
+	/** Projection path: eager cells for live sessions, revision-gated cold ladder for the rest. */
+	async scanProjections(dayKey) {
+		const { sessions, persistence, projections, projectionCache, unit, logger } = this.deps;
+		let total = emptyTodaySpend();
+		const liveIds = /* @__PURE__ */ new Set();
+		if (sessions !== void 0) {
+			const store = sessions();
+			if (store !== void 0) for (const session of store.list()) {
+				liveIds.add(session.id);
+				const state = projections?.()?.stateOf(session, BILLING_UNIT_KEY);
+				if (state !== void 0 && state.dayKey === dayKey) total = mergeTodaySpend(total, state.spend);
+			}
+		}
+		const persistenceService = persistence?.();
+		if (persistenceService === void 0) return total;
+		const snapshots = await persistenceService.listSnapshots();
+		const pending = [];
+		for (const { header, revision } of snapshots) {
+			if (liveIds.has(header.id)) continue;
+			const resolved = this.coldResolved.get(header.id);
+			if (resolved !== void 0 && resolved.revision === revision) {
+				if (resolved.value.dayKey === dayKey) total = mergeTodaySpend(total, resolved.value.spend);
+				continue;
+			}
+			pending.push({
+				id: header.id,
+				revision
+			});
+		}
+		await withConcurrency(pending, 8, async ({ id, revision }) => {
+			let value;
+			const cache = projectionCache?.();
+			if (cache !== void 0) try {
+				value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
+			} catch (error) {
+				logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
+			}
+			if (value === void 0) try {
+				value = foldBillingUnit(unit, (await persistenceService.inspect(id)).events);
+			} catch (error) {
+				logger.warn(`llm-billing: skipping unreadable session ${id}: ${String(error)}`);
+			}
+			if (value !== void 0) this.coldResolved.set(id, {
+				revision,
+				value
+			});
+		});
+		for (const { id } of pending) {
+			const resolved = this.coldResolved.get(id);
+			if (resolved !== void 0 && resolved.value.dayKey === dayKey) total = mergeTodaySpend(total, resolved.value.spend);
+		}
+		return total;
+	}
+	/** Events path: collect only today's events (capped), gated by revisions. */
+	async scanEvents(dayKey) {
+		const { sessions, persistence, maxEvents, logger, billing, catalog } = this.deps;
+		const events = [];
+		const liveIds = /* @__PURE__ */ new Set();
+		let truncated = false;
+		if (sessions !== void 0) {
+			const store = sessions();
+			if (store !== void 0) for (const session of store.list()) {
+				liveIds.add(session.id);
+				for (const event of session.events) {
+					if (beijingDayKey(new Date(event.time)) !== dayKey) continue;
+					events.push(event);
+					if (events.length >= maxEvents) {
+						truncated = true;
+						break;
+					}
+				}
+				if (truncated) break;
+			}
+		}
+		const persistenceService = persistence?.();
+		if (!truncated && persistenceService !== void 0) {
+			const snapshots = await persistenceService.listSnapshots();
+			for (const { header, revision } of snapshots) {
+				if (liveIds.has(header.id)) continue;
+				if (this.lastEventsScan?.get(header.id) === revision) continue;
+				try {
+					const inspection = await persistenceService.inspect(header.id);
+					for (const event of inspection.events) {
+						if (beijingDayKey(new Date(event.time)) !== dayKey) continue;
+						events.push(event);
+						if (events.length >= maxEvents) {
+							truncated = true;
+							break;
+						}
+					}
+				} catch (error) {
+					logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
+				}
+				if (truncated) break;
+			}
+			if (!truncated) this.lastEventsScan = new Map(snapshots.map((snapshot) => [snapshot.header.id, snapshot.revision]));
+		}
+		if (truncated) logger.warn(`llm-billing: today's events exceeded ${maxEvents}; result truncated`);
+		return computeTodaySpend(events, billing, catalog, /* @__PURE__ */ new Date(`${dayKey}T00:00:00Z`));
+	}
+};
+//#endregion
+//#region lib/types/index.js
 /**
 * DeepSeek account balance and session-spend provider, as a standalone host
 * plugin. It resolves the DeepSeek endpoint and API key from its own config and
 * 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`).
+*
+* 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.
 * @module @rayadesu/dsh-llm-billing
 */
 const name = "llm-billing";
@@ -483,9 +873,14 @@ 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). */
+const TODAY_SPEND_CACHE_MS = 6e4;
+/** Hard cap on today's events collected by the events scan path. */
+const TODAY_SPEND_MAX_EVENTS = 2e5;
 /**
 * 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.
@@ -495,42 +890,14 @@ async function sessionEvents(ctx, sessionId) {
 	const live = ctx.get("sessions")?.get(sessionId);
 	if (live !== void 0) return live.events;
 	const persistence = ctx.get("sessionPersistence");
-	if (persistence !== void 0) for (const header of await persistence.list()) {
-		if (header.id !== sessionId) continue;
+	if (persistence !== void 0) try {
 		return (await persistence.inspect(sessionId)).events;
+	} catch (error) {
+		throw new LlmError(`llm-billing: session ${sessionId} not found`, "NOT_FOUND", { cause: error });
 	}
 	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 = /* @__PURE__ */ new Set();
-	if (sessions !== void 0) for (const session of sessions.list()) {
-		liveIds.add(session.id);
-		for (const event of session.events) events.push(event);
-	}
-	const persistence = ctx.get("sessionPersistence");
-	if (persistence !== void 0) 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) {
-			ctx.logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
-		}
-	}
-	return events;
-}
-/**
 * Register the `billing` Remote under the `billing` namespace.
 * @param ctx - owning plugin context.
 * @param config - validated plugin config.
@@ -553,22 +920,37 @@ 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
+	}));
 	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 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);
+	const unit = billingTodaySpendDefinition(billing, catalog);
+	let unitRegistered = false;
+	const ensureUnit = () => {
+		if (unitRegistered) return;
+		const registry = ctx.get("sessionProjections");
+		if (registry === void 0) return;
+		registry.register(unit);
+		unitRegistered = true;
 	};
+	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,
@@ -576,4 +958,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, PUBLIC_BASE_URL, apply, computeSessionSpend, computeTodaySpend, fetchDeepSeekBalance, isPeak, name, parseDeepSeekBalance, resolveBilling };
+export { BILLING_UNIT_KEY, Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, PUBLIC_BASE_URL, TODAY_SPEND_CACHE_MS, TODAY_SPEND_MAX_EVENTS, TodaySpendCache, TodaySpendScanner, addEventContribution, apply, beijingDayKey, billingTodaySpendDefinition, computeSessionSpend, computeTodaySpend, emptyTodaySpend, fetchDeepSeekBalance, foldBillingUnit, isPeak, mergeTodaySpend, name, parseDeepSeekBalance, priceEvent, resolveBilling };

package/lib/invariant.js

@@ -1,4 +1,4 @@
-//#region ../../../../DeepSeek-Harness-chat-billing/packages/llm-billing/lib/types/invariant.js
+//#region lib/types/invariant.js
 /**
 * Package-owned invariant companion for `@rayadesu/dsh-llm-billing`.
 * @module @rayadesu/dsh-llm-billing/invariant