@rayadesu/dsh-llm-billing 0.2.1 → 0.2.2

package/lib/types/billing.js

@@ -3,9 +3,19 @@
  * 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}, 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
+ */
+/**
+ * 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 +32,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
@@ -48,23 +65,157 @@ export function resolveBilling(config) {
 function beijingHour(now) {
     return new Date(now.getTime() + 8 * 3_600_000).getUTCHours();
 }
+/**
+ * The Beijing (Asia/Shanghai, UTC+8, no DST) weekday of a timestamp, as
+ * `getUTCDay()`: `0` is Sunday, `6` is Saturday.
+ */
+function beijingWeekday(now) {
+    return new Date(now.getTime() + 8 * 3_600_000).getUTCDay();
+}
 /** The Beijing (Asia/Shanghai, UTC+8, no DST) calendar-day key of a timestamp. */
-function beijingDayKey(now) {
+export function beijingDayKey(now) {
     return new Date(now.getTime() + 8 * 3_600_000).toISOString().slice(0, 10);
 }
 /**
- * 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 weekday = beijingWeekday(now);
+    if (weekday === 0 || weekday === 6)
+        return false;
     const hour = beijingHour(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.
+ */
+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 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) / 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: 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. */
+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,
+    };
+}
+/**
+ * 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 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.
+ */
+export 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. 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
@@ -77,64 +228,14 @@ export function isPeak(billing, now) {
  */
 function priceEvents(events, billing, catalog) {
     const names = new Map(catalog.map(model => [model.id, model.name]));
-    const rows = 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 === undefined)
+        const priced = priceEvent(event, billing, names);
+        if (priced === undefined)
             continue;
-        const model = event.data.message.source.model;
-        const pricing = billing.models.get(model);
-        if (pricing === undefined)
-            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;
+        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.
@@ -158,6 +259,14 @@ 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]));
+    let spend = emptyTodaySpend();
+    for (const event of events) {
+        const priced = priceEvent(event, billing, names);
+        if (priced === undefined || priced.dayKey !== day)
+            continue;
+        spend = addEventContribution(spend, priced);
+    }
+    return spend;
 }
 //# sourceMappingURL=billing.js.map

package/lib/types/index.d.ts

@@ -4,15 +4,28 @@
  * 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.
+ * @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, } 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 +47,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,29 @@
  * 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.
+ * @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, 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, } 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 +35,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 +63,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 +83,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 +121,46 @@ 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 }));
     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);
+    // 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. */

package/lib/types/projection.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `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
+ */
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ResolvedBilling } from './billing.ts';
+import type { DeepSeekTodaySpend } from './types.ts';
+/** The projection key this unit owns. */
+export declare const BILLING_UNIT_KEY = "billingTodaySpend";
+/**
+ * Per-session unit state: the Beijing day of the session's latest priced
+ * event and that day's billed spend. `dayKey` is `''` while the session has no
+ * priced usage, and the state only ever describes ONE day (the latest) —
+ * plain JSON, as the persisted-cache contract requires.
+ */
+export interface BillingUnitState {
+    /** Beijing-time calendar-day key of the state's spend; `''` for no priced usage. */
+    dayKey: string;
+    /** The spend of the session's latest priced Beijing day. */
+    spend: DeepSeekTodaySpend;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        billingTodaySpend: BillingUnitState;
+    }
+    interface SessionProjectionMap {
+        billingTodaySpend: BillingUnitState;
+    }
+}
+/**
+ * The unit definition with a required `wire` — the shape {@link register}
+ * accepts for a client-visible unit (the plain `ProjectionDefinition` type
+ * leaves `wire` optional).
+ */
+export type BillingUnitDefinition = Omit<ProjectionDefinition<'billingTodaySpend', BillingUnitState>, 'wire'> & {
+    wire: NonNullable<ProjectionDefinition<'billingTodaySpend', BillingUnitState>['wire']>;
+};
+/**
+ * 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`.
+ */
+export declare function billingTodaySpendDefinition(billing: ResolvedBilling, catalog: readonly {
+    id: string;
+    name: string;
+}[]): BillingUnitDefinition;
+/** Fold a unit from init over one session's event log (the detached cold recipe). */
+export declare function foldBillingUnit(unit: Pick<ProjectionDefinition<'billingTodaySpend', BillingUnitState>, 'init' | 'apply'>, events: readonly SessionEvent[]): BillingUnitState;
+//# sourceMappingURL=projection.d.ts.map