@rayadesu/dsh-llm-billing 0.2.0 → 0.2.1

package/lib/types/billing.js

@@ -3,19 +3,9 @@
  * 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
- */
-/**
- * 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).
+ * @module @deepseek-ai/dsh-llm-billing/billing
  */
+/** 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 },
@@ -32,13 +22,6 @@ 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
@@ -65,157 +48,23 @@ 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. */
-export function beijingDayKey(now) {
+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,
- * weekdays Monday–Friday only). Weekends (Saturday and Sunday) are always
- * off-peak, matching the published peak-hours rule.
+ * Whether a timestamp falls inside any peak-hour window (Beijing time).
  * @param billing - resolved pricing with peak-hour windows.
  * @param now - the moment to classify.
- * @returns true during a weekday peak hour.
+ * @returns true during peak hours.
  */
 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 and weekday (peak
- * windows apply Monday–Friday only; weekends are off-peak). Each
+ * peak/off-peak table per event by its Beijing-time hour. 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
@@ -228,14 +77,64 @@ export function mergeTodaySpend(target, source) {
  */
 function priceEvents(events, billing, catalog) {
     const names = new Map(catalog.map(model => [model.id, model.name]));
-    let spend = { total: 0, models: [] };
+    const rows = new Map();
     for (const event of events) {
-        const priced = priceEvent(event, billing, names);
-        if (priced === undefined)
+        if (event.type !== 'assistant/message')
+            continue;
+        const reported = event.data.usage;
+        if (reported === undefined)
             continue;
-        spend = addEventContribution(spend, priced);
+        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;
     }
-    return spend;
+    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,
+    };
 }
 /**
  * Price one session's complete event log at the official per-model rates.
@@ -259,14 +158,6 @@ export function computeSessionSpend(events, billing, catalog) {
  */
 export function computeTodaySpend(events, billing, catalog, now = new Date()) {
     const day = beijingDayKey(now);
-    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;
+    return priceEvents(events.filter(event => beijingDayKey(new Date(event.time)) === day), billing, catalog);
 }
 //# sourceMappingURL=billing.js.map

package/lib/types/index.d.ts

@@ -4,28 +4,15 @@
  * 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
+ * @module @deepseek-ai/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 { 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 { 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 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";
@@ -47,16 +34,12 @@ 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, V4 Pro, and V4 Flash Vision Exp. */
+    /** Advisory display rows, in presentation order; defaults to V4 Flash and V4 Pro. */
     models?: BillingModel[];
-    /** Pricing table and peak-hour windows; omission uses the published defaults. Peak windows apply weekdays (Monday–Friday) only; weekends are always off-peak. */
+    /** Pricing table and peak-hour windows; omission uses the published defaults. */
     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,29 +4,16 @@
  * 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
+ * @module @deepseek-ai/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, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, resolveBilling, } from "./billing.js";
-import { billingTodaySpendDefinition } from "./projection.js";
-import { TodaySpendCache, TodaySpendScanner } from "./today-spend.js";
+import { computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, resolveBilling, } from "./billing.js";
 export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from "./balance.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 { computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, isPeak, resolveBilling, } from "./billing.js";
 export const name = 'llm-billing';
 const DEFAULT_API_KEY_ENV = 'DEEPSEEK_API_KEY';
 const BASE_URL_ENV = 'DEEPSEEK_BASE_URL';
@@ -35,7 +22,6 @@ 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(),
@@ -63,14 +49,9 @@ 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 (inspected directly by id — no
- * header listing).
+ * persistence backend for a flushed session.
  * @param ctx - plugin context carrying the SessionStore and optional persistence.
  * @param sessionId - the session to read.
  * @returns the session's complete event log.
@@ -83,15 +64,53 @@ async function sessionEvents(ctx, sessionId) {
         return live.events;
     const persistence = ctx.get('sessionPersistence');
     if (persistence !== undefined) {
-        try {
-            return (await persistence.inspect(sessionId)).events;
-        }
-        catch (error) {
-            throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND', { cause: error });
+        for (const header of await persistence.list()) {
+            if (header.id !== sessionId)
+                continue;
+            const inspection = await persistence.inspect(sessionId);
+            return inspection.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);
+        }
+    }
+    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;
+}
 /**
  * Register the `billing` Remote under the `billing` namespace.
  * @param ctx - owning plugin context.
@@ -121,46 +140,16 @@ 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);
     };
-    // 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;
+    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);
     };
-    // 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 `@rayadesu/dsh-llm-billing`.
- * @module @rayadesu/dsh-llm-billing/invariant
+ * Package-owned invariant companion for `@deepseek-ai/dsh-llm-billing`.
+ * @module @deepseek-ai/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 `@rayadesu/dsh-llm-billing`.
- * @module @rayadesu/dsh-llm-billing/invariant
+ * Package-owned invariant companion for `@deepseek-ai/dsh-llm-billing`.
+ * @module @deepseek-ai/dsh-llm-billing/invariant
  */
-const PACKAGE_NAME = '@rayadesu/dsh-llm-billing';
+const PACKAGE_NAME = '@deepseek-ai/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/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Client-safe balance and spend vocabulary shared by the `billing` Remote,
  * its generated artifacts, and the web UI.
- * @module @rayadesu/dsh-llm-billing/types
+ * @module @deepseek-ai/dsh-llm-billing/types
  */
 /** One currency line of the account balance returned by `GET /user/balance`. */
 export interface DeepSeekBalanceLine {
@@ -46,14 +46,14 @@ export interface DeepSeekSessionSpendModel {
     /** Billed cost of output tokens (reasoning included) in CNY. */
     outputCost: number;
 }
-/** The billed spend of one session, priced per event by its Beijing-time hour and weekday (peak hours apply Monday–Friday only; weekends are off-peak). */
+/** The billed spend of one session, priced per event by its Beijing-time peak/off-peak hour. */
 export interface DeepSeekSessionSpend {
     /** Total billed cost in CNY across every priced model. */
     total: number;
     /** One row per model that reported usage AND has a pricing row; empty when the session has no priced usage. */
     models: readonly DeepSeekSessionSpendModel[];
 }
-/** The billed spend of every session on one Beijing-time calendar day, priced per event by its Beijing-time hour and weekday (peak hours apply Monday–Friday only; weekends are off-peak). */
+/** The billed spend of every session on one Beijing-time calendar day, priced per event by its peak/off-peak hour. */
 export interface DeepSeekTodaySpend {
     /** Total billed cost in CNY across every priced model and every session. */
     total: number;

package/lib/types/types.js

@@ -1,7 +1,7 @@
 /**
  * Client-safe balance and spend vocabulary shared by the `billing` Remote,
  * its generated artifacts, and the web UI.
- * @module @rayadesu/dsh-llm-billing/types
+ * @module @deepseek-ai/dsh-llm-billing/types
  */
 export {};
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rayadesu/dsh-llm-billing",
   "description": "Standalone DeepSeek account-balance and session-spend provider exposed through the billing Remote",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "publishConfig": {
     "access": "public"
   },

package/lib/types/projection.d.ts

@@ -1,69 +0,0 @@
-/**
- * `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