@rayadesu/dsh-llm-billing 0.3.15 → 0.3.17

package/lib/types/pricing.js

@@ -0,0 +1,203 @@
+/**
+ * DeepSeek pricing: the peak/off-peak pricing table, the per-event pricing, and
+ * the resolved-billing shape. Pure functions over token usage 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} / {@link priceUsage}; the
+ * fold state machine that consumes it (`BillingFolder` / {@link applyBillingEvent})
+ * lives in `fold.ts`, and every scan path prices through these primitives so a
+ * pricing-table change cannot drift one path from the others.
+ * @module @rayadesu/dsh-llm-billing/pricing
+ */
+import { beijingPartsOf } from "./beijing-time.js";
+import { DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS } from "./pricing-table.js";
+// Declared here before the table moved out; re-exported so the package's public
+// surface and its tests keep importing them from the billing entry point.
+export { DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, FLASH_SERIES_RATE_CHANGE_AT, V4_PRO_ROUTE_SWITCH_AT } from "./pricing-table.js";
+/**
+ * Resolve optional configuration to a pricing table, defaulting omitted or
+ * empty rows to the published rates. Schemastery materializes an absent
+ * `z.array` as `[]` rather than `undefined`, so emptiness — not just absence —
+ * selects the defaults. Explicit non-empty rows override the same model; a
+ * supplied non-empty `models` list is authoritative.
+ *
+ * Rows sharing a model are that model's rate revisions, kept in ascending
+ * `effectiveFrom` order (an undated base revision first). Two rows declaring
+ * the same effective instant are one revision and the later row wins — the
+ * historical override rule — so re-declaring a model can neither duplicate a
+ * revision nor install a second undated base.
+ * @param config - optional raw billing configuration.
+ * @returns the resolved table (per model: its revisions plus the newest rates) and peak-hour windows.
+ */
+export function resolveBilling(config) {
+    const peakHours = config?.peakHours !== undefined && config.peakHours.length > 0
+        ? config.peakHours
+        : DEFAULT_PEAK_HOURS;
+    const rows = config?.models !== undefined && config.models.length > 0
+        ? config.models
+        : DEFAULT_MODEL_PRICING;
+    const schedules = new Map();
+    for (const row of rows) {
+        // Spelled out per branch: `exactOptionalPropertyTypes` forbids handing an
+        // explicit `undefined` to an optional field.
+        const revision = row.effectiveFrom === undefined
+            ? { peak: row.peak, offPeak: row.offPeak }
+            : { effectiveFrom: row.effectiveFrom, peak: row.peak, offPeak: row.offPeak };
+        const revisions = schedules.get(row.model);
+        if (revisions === undefined) {
+            schedules.set(row.model, [revision]);
+            continue;
+        }
+        const duplicate = revisions.findIndex(candidate => candidate.effectiveFrom === revision.effectiveFrom);
+        if (duplicate >= 0)
+            revisions[duplicate] = revision;
+        else
+            revisions.push(revision);
+    }
+    const models = new Map();
+    for (const [model, revisions] of schedules) {
+        revisions.sort((left, right) => (left.effectiveFrom ?? Number.NEGATIVE_INFINITY) - (right.effectiveFrom ?? Number.NEGATIVE_INFINITY));
+        const newest = revisions[revisions.length - 1];
+        models.set(model, { peak: newest.peak, offPeak: newest.offPeak, revisions });
+    }
+    return { peakHours, models };
+}
+/**
+ * The rate revision in effect at one instant: the newest revision that took
+ * effect at or before it. Revisions are ascending, so the scan stops at the
+ * first future one. An instant before the earliest dated revision bills at that
+ * earliest revision — a model with only dated rows is never left unpriced.
+ */
+function ratesAt(revisions, time) {
+    let chosen = revisions[0];
+    for (let index = 1; index < revisions.length; index += 1) {
+        const revision = revisions[index];
+        if (revision.effectiveFrom === undefined || revision.effectiveFrom > time)
+            break;
+        chosen = revision;
+    }
+    return chosen;
+}
+/** Whether a Beijing (hour, weekday) pair falls inside any peak-hour window. */
+function isPeakParts(billing, hour, weekday) {
+    if (weekday === 0 || weekday === 6)
+        return false;
+    return billing.peakHours.some(({ start, end }) => hour >= start && hour < end);
+}
+/**
+ * Whether a timestamp falls inside any peak-hour window (Beijing time,
+ * weekdays Monday–Friday only). Weekends (Saturday and Sunday) are always
+ * off-peak, matching the published peak-hours rule.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param now - the moment to classify.
+ * @returns true during a weekday peak hour.
+ */
+export function isPeak(billing, now) {
+    const { hour, weekday } = beijingPartsOf(now.getTime());
+    return isPeakParts(billing, hour, weekday);
+}
+/**
+ * Price one event at the official per-model rates, applying the peak/off-peak
+ * table by its Beijing-time hour and weekday (peak windows apply Monday–Friday
+ * only; weekends are off-peak) and the rate revision in effect at its own
+ * timestamp. Each `assistant/message` event with usage
+ * contributes cache-hit input, cache-miss input (uncached input plus cache
+ * writes), and output (reasoning included) tokens at the rate of its own
+ * timestamp; a model with usage but no pricing row contributes nothing.
+ * @param event - the event to price.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the priced contribution, or `undefined` when the event has no priced usage.
+ */
+export function priceEvent(event, billing, names) {
+    return priceEventAt(beijingPartsOf(event.time), event, billing, names);
+}
+/**
+ * Price one event at the official per-model rates using a precomputed
+ * Beijing-time view — the day-filtering and pricing of one event share a
+ * single timezone parse (see {@link beijingPartsOf}). Semantics are identical
+ * to {@link priceEvent}.
+ * @param parts - the event's Beijing-time view.
+ * @param event - the event to price.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the priced contribution, or `undefined` when the event has no priced usage.
+ */
+export function priceEventAt(parts, event, billing, names) {
+    if (event.type !== 'assistant/message')
+        return undefined;
+    const reported = event.data.usage;
+    if (reported === undefined)
+        return undefined;
+    return priceUsage(parts, reported, event.data.message.source.model, billing, names);
+}
+/** Every token one usage sample reports, whether or not it gets priced. */
+export function usageTokens(usage) {
+    return usage.inputTokens + usage.outputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+}
+/** Max distinct model ids remembered for the once-only warning. */
+const UNPRICED_WARN_LIMIT = 64;
+/** Model ids already reported, so a long-running host logs each one once. */
+const reportedUnpricedModels = new Set();
+/**
+ * Report a model carrying no rate row, at most once per id (and at most
+ * {@link UNPRICED_WARN_LIMIT} ids per process). Every figure reads as zero when
+ * the upstream model is unknown, which looks exactly like "no usage" rather
+ * than a missing row — the one thing this warning exists to separate.
+ *
+ * Deliberately NOT guessed: model ids are chosen by whoever ships the model, so
+ * a similar-looking name says nothing about a similar price — and a wrong number
+ * that LOOKS authoritative is worse than a visible gap. The fix is one row under
+ * `billing.models`, which is exactly what the warning points at.
+ * @param model - the unlisted wire model id.
+ */
+export function reportUnpricedModel(model) {
+    if (reportedUnpricedModels.has(model) || reportedUnpricedModels.size >= UNPRICED_WARN_LIMIT)
+        return;
+    reportedUnpricedModels.add(model);
+    console.warn(`[llm-billing] no pricing row for model "${model}" — its usage is NOT billed; add its row under billing.models to price it`);
+}
+/**
+ * Price one provider-reported usage sample for one model at the rates of the
+ * sample's own Beijing-time hour and weekday — the peak or off-peak price of
+ * the rate revision in effect at the sample's own timestamp (a re-priced series
+ * bills its history at the rates that applied then). `undefined` when the model
+ * has no pricing row.
+ * @param parts - the sample's Beijing-time view.
+ * @param usage - the reported token buckets.
+ * @param model - the wire model id the sample belongs to.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the priced contribution, or `undefined` when the model has no rate row.
+ */
+export function priceUsage(parts, usage, model, billing, names) {
+    const pricing = billing.models.get(model);
+    if (pricing === undefined)
+        return undefined;
+    const peak = isPeakParts(billing, parts.hour, parts.weekday);
+    const revision = ratesAt(pricing.revisions, parts.time);
+    const price = peak ? revision.peak : revision.offPeak;
+    const hit = usage.cacheReadTokens ?? 0;
+    const miss = usage.inputTokens + (usage.cacheWriteTokens ?? 0);
+    const output = usage.outputTokens;
+    const hitCost = (hit * price.cacheHitInput) / 1_000_000;
+    const missCost = (miss * price.cacheMissInput) / 1_000_000;
+    const outputCost = (output * price.output) / 1_000_000;
+    const cost = hitCost + missCost + outputCost;
+    return {
+        dayKey: parts.dayKey,
+        model,
+        displayName: names.get(model) ?? model,
+        cost,
+        peakCost: peak ? cost : 0,
+        offPeakCost: peak ? 0 : cost,
+        cacheHitInputTokens: hit,
+        cacheMissInputTokens: miss,
+        outputTokens: output,
+        cacheHitInputCost: hitCost,
+        cacheMissInputCost: missCost,
+        outputCost,
+    };
+}
+//# sourceMappingURL=pricing.js.map

package/lib/types/projection.js

@@ -33,9 +33,23 @@ const modelRowSchema = z.object({
     cacheMissInputCost: z.number().nonnegative(),
     outputCost: z.number().nonnegative(),
 }).strict();
+/**
+ * The advisory tally of usage that could not be billed at its own rate (see
+ * `DeepSeekTodaySpend.unpriced`). Declared here because the
+ * unit's schemas are `.strict()`: an undeclared key REJECTS the whole unit
+ * rather than being stripped, so adding these fields to the fold without
+ * declaring them here would fail every projection fold the moment a sample
+ * went unpriced.
+ */
+const usageTallySchema = z.object({
+    events: z.number().int().nonnegative(),
+    tokens: z.number().int().nonnegative(),
+    models: z.array(z.string()),
+}).strict();
 const todaySpendSchema = z.object({
     total: z.number().nonnegative(),
     models: z.array(modelRowSchema),
+    unpriced: usageTallySchema.optional(),
 }).strict();
 const billingUnitSchema = z.object({
     dayKey: z.string(),

package/lib/types/session-lineage.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Session lineage and titles: which session delegated which, where a subtree's
+ * spend belongs, and the title a ranking row is labelled with. Split out of
+ * `today-spend.ts` because neither the cache nor the scan strategies care
+ * about lineage for their own sake — they only ask for it.
+ * @module @rayadesu/dsh-llm-billing/session-lineage
+ */
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
+import type { DeepSeekTodaySessionSpend } from './types.ts';
+export declare function foldSessionTitle(events: readonly SessionEvent[]): string | null;
+/**
+ * Structural slice of a session's durable lineage: the header fields DSH
+ * stamps on a delegation child (`origin: 'subagent'`, the delegating session's
+ * id, and the depth that survives persistence). All three are read
+ * structurally, so the scanner works on every runtime family — a log written
+ * before the fields existed simply carries none of them and reads as a
+ * top-level session.
+ */
+export interface SessionLineage {
+    /** The session this one was forked from or delegated by; absent for a top-level session. */
+    readonly parentSession?: SessionId;
+    /** DSH's subagent-child classification (`childSessionMeta` stamps it). */
+    readonly origin?: 'subagent';
+    /** Delegation depth: absent (zero) at the top level, parent depth + 1 for a subagent child. */
+    readonly delegationDepth?: number;
+}
+/**
+ * Whether one session's durable header marks it as a subagent child. Either
+ * marker is enough: `origin` is DSH's navigation classification and
+ * `delegationDepth` is its persisted recursion budget, so a header carrying
+ * only the depth (or only the origin) is still a delegation child. A session
+ * created without either — an ordinary session, a user fork, or a cold resume
+ * — is top-level.
+ * @param header - the session's lineage slice; `undefined` reads as top-level.
+ * @returns true when the session was created as a subagent child.
+ */
+export declare function isSubagentSession(header: SessionLineage | undefined): boolean;
+/**
+ * The top-level session one session's ranking row belongs to: the session
+ * itself for a top-level session, and for a subagent child the first ancestor
+ * up the `parentSession` chain that is not itself a subagent child. A
+ * multi-generation delegation (a subagent that spawned subagents) therefore
+ * lands on the same root row as its parent, and a child whose parent header is
+ * unknown is attributed to the parent id its own header names — the parent is
+ * authoritative even when its log is not part of this scan.
+ * @param id - the session whose row is being attributed.
+ * @param lineage - lineage of every session this scan saw, by id.
+ * @returns the session id whose ranking row the input belongs to.
+ */
+export declare function topLevelSessionOf(id: SessionId, lineage: ReadonlyMap<SessionId, SessionLineage>): SessionId;
+/**
+ * Fold every subagent child's row into the top-level row it belongs to
+ * ({@link topLevelSessionOf}), so the ranking lists conversations rather than
+ * every delegation a conversation started. A child's spend is added to its
+ * ancestor's `total`; the ancestor's `ownTotal` keeps its own spend only. A
+ * top-level session whose own day was empty but whose subagents priced
+ * something still gets a row (with `ownTotal` 0), carrying the title the scan
+ * resolved for it in `titles`.
+ * @param rows - one row per session that priced something today (own spends).
+ * @param lineage - lineage of every session this scan saw, by id.
+ * @param titles - resolved display titles by session id; a session absent from
+ *   the map has no resolved title and its created row reports `null`.
+ * @returns the merged rows, sorted by `total` descending.
+ */
+export declare function rollUpSubagentSpend(rows: readonly DeepSeekTodaySessionSpend[], lineage: ReadonlyMap<SessionId, SessionLineage>, titles?: ReadonlyMap<SessionId, string | null>): DeepSeekTodaySessionSpend[];
+/**
+ * Structural slice of a live session's header: the fork boundary of both DSH
+ * runtime families plus the delegation lineage the ranking roll-up reads.
+ */ 
+//# sourceMappingURL=session-lineage.d.ts.map

package/lib/types/session-lineage.js

@@ -0,0 +1,99 @@
+/**
+ * Session lineage and titles: which session delegated which, where a subtree's
+ * spend belongs, and the title a ranking row is labelled with. Split out of
+ * `today-spend.ts` because neither the cache nor the scan strategies care
+ * about lineage for their own sake — they only ask for it.
+ * @module @rayadesu/dsh-llm-billing/session-lineage
+ */
+export function foldSessionTitle(events) {
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        // `session/title` joined the SessionEvent union after the npm
+        // 0.1.1-rc.2 baseline this package builds against; read its payload
+        // through the structural escape hatch (runtime logs carry it).
+        if (event.type !== 'session/title')
+            continue;
+        const data = event.data;
+        return typeof data.title === 'string' ? data.title : null;
+    }
+    return null;
+}
+/**
+ * Whether one session's durable header marks it as a subagent child. Either
+ * marker is enough: `origin` is DSH's navigation classification and
+ * `delegationDepth` is its persisted recursion budget, so a header carrying
+ * only the depth (or only the origin) is still a delegation child. A session
+ * created without either — an ordinary session, a user fork, or a cold resume
+ * — is top-level.
+ * @param header - the session's lineage slice; `undefined` reads as top-level.
+ * @returns true when the session was created as a subagent child.
+ */
+export function isSubagentSession(header) {
+    if (header === undefined)
+        return false;
+    return header.origin === 'subagent' || (header.delegationDepth ?? 0) > 0;
+}
+/**
+ * The top-level session one session's ranking row belongs to: the session
+ * itself for a top-level session, and for a subagent child the first ancestor
+ * up the `parentSession` chain that is not itself a subagent child. A
+ * multi-generation delegation (a subagent that spawned subagents) therefore
+ * lands on the same root row as its parent, and a child whose parent header is
+ * unknown is attributed to the parent id its own header names — the parent is
+ * authoritative even when its log is not part of this scan.
+ * @param id - the session whose row is being attributed.
+ * @param lineage - lineage of every session this scan saw, by id.
+ * @returns the session id whose ranking row the input belongs to.
+ */
+export function topLevelSessionOf(id, lineage) {
+    let current = id;
+    // A malformed log could claim a delegation cycle; each step visits a
+    // distinct ancestor, so a repeat ends the walk instead of spinning.
+    const seen = new Set([current]);
+    for (;;) {
+        const header = lineage.get(current);
+        if (!isSubagentSession(header))
+            return current;
+        const parent = header?.parentSession;
+        if (parent === undefined || seen.has(parent))
+            return current;
+        seen.add(parent);
+        current = parent;
+    }
+}
+/**
+ * Fold every subagent child's row into the top-level row it belongs to
+ * ({@link topLevelSessionOf}), so the ranking lists conversations rather than
+ * every delegation a conversation started. A child's spend is added to its
+ * ancestor's `total`; the ancestor's `ownTotal` keeps its own spend only. A
+ * top-level session whose own day was empty but whose subagents priced
+ * something still gets a row (with `ownTotal` 0), carrying the title the scan
+ * resolved for it in `titles`.
+ * @param rows - one row per session that priced something today (own spends).
+ * @param lineage - lineage of every session this scan saw, by id.
+ * @param titles - resolved display titles by session id; a session absent from
+ *   the map has no resolved title and its created row reports `null`.
+ * @returns the merged rows, sorted by `total` descending.
+ */
+export function rollUpSubagentSpend(rows, lineage, titles = new Map()) {
+    const merged = new Map();
+    for (const row of rows) {
+        const target = topLevelSessionOf(row.sessionId, lineage);
+        const carried = merged.get(target);
+        if (carried === undefined) {
+            // A row's own session keeps its own total as `ownTotal`; a row created
+            // for an ancestor that priced nothing today carries zero there.
+            merged.set(target, target === row.sessionId
+                ? row
+                : { sessionId: target, title: titles.get(target) ?? null, total: row.total, ownTotal: 0 });
+            continue;
+        }
+        merged.set(target, { ...carried, total: carried.total + row.total });
+    }
+    return [...merged.values()].sort((left, right) => right.total - left.total);
+}
+/**
+ * Structural slice of a live session's header: the fork boundary of both DSH
+ * runtime families plus the delegation lineage the ranking roll-up reads.
+ */ 
+//# sourceMappingURL=session-lineage.js.map

package/lib/types/spend.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Spend arithmetic: how two spends combine, how one is inverted, and how the
+ * samples that could NOT be priced are tallied beside them. Pure, and knowing
+ * nothing about rates, timezones or event shapes — the pricing engine
+ * (`billing.ts`) owns all of that.
+ * @module @rayadesu/dsh-llm-billing/spend
+ */
+import type { BillingEventContribution } from './pricing.ts';
+import type { DeepSeekTodaySpend } from './types.ts';
+/** A spend with no priced usage. */
+export declare function emptyTodaySpend(): DeepSeekTodaySpend;
+/** Note one sample that matched no pricing row and was therefore not billed. */
+export declare function noteUnpriced(spend: DeepSeekTodaySpend, model: string, tokens: number): DeepSeekTodaySpend;
+/**
+ * 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 declare class SpendAccumulator {
+    private readonly rows;
+    private total;
+    /** Add one priced contribution. */
+    add(priced: BillingEventContribution): void;
+    /** The folded spend; the accumulator stays usable afterwards. */
+    finish(): DeepSeekTodaySpend;
+}
+/** The additive inverse of one spend (pure): used to replace a priced sample. */
+export declare function negateSpend(spend: DeepSeekTodaySpend): DeepSeekTodaySpend;
+/**
+ * Subtract one spend from another (pure). Rows that cancel out completely are
+ * dropped so a replaced sample leaves no zero row behind.
+ * @param target - the spend to subtract from.
+ * @param source - the spend to remove.
+ * @returns the difference.
+ */
+export declare function subtractSpend(target: DeepSeekTodaySpend, source: DeepSeekTodaySpend): DeepSeekTodaySpend;
+/** The contribution as a one-row spend (the shape a sample keeps for replacement). */
+export declare function contributionSpend(priced: BillingEventContribution): DeepSeekTodaySpend;
+/**
+ * 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 declare function addEventContribution(spend: DeepSeekTodaySpend, priced: BillingEventContribution): DeepSeekTodaySpend;
+/**
+ * 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 declare function mergeTodaySpend(target: DeepSeekTodaySpend, source: DeepSeekTodaySpend): DeepSeekTodaySpend;
+//# sourceMappingURL=spend.d.ts.map

package/lib/types/spend.js

@@ -0,0 +1,190 @@
+/**
+ * Spend arithmetic: how two spends combine, how one is inverted, and how the
+ * samples that could NOT be priced are tallied beside them. Pure, and knowing
+ * nothing about rates, timezones or event shapes — the pricing engine
+ * (`billing.ts`) owns all of that.
+ * @module @rayadesu/dsh-llm-billing/spend
+ */
+/** A spend with no priced usage. */
+export function emptyTodaySpend() {
+    return { total: 0, models: [] };
+}
+/** Sum two usage tallies (pure); an absent side stays absent. */
+function mergeUsageTally(left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    return {
+        events: left.events + right.events,
+        tokens: left.tokens + right.tokens,
+        models: [...new Set([...left.models, ...right.models])],
+    };
+}
+/** Add one affected sample to a tally (pure). */
+function addUsageTally(previous, model, tokens) {
+    const models = previous?.models ?? [];
+    return {
+        events: (previous?.events ?? 0) + 1,
+        tokens: (previous?.tokens ?? 0) + tokens,
+        models: models.includes(model) ? models : [...models, model],
+    };
+}
+/**
+ * The advisory tallies carried BESIDE the priced rows, summed over `spends` as
+ * a partial you can spread into any spend literal. Keys stay absent rather
+ * than becoming `undefined` (`exactOptionalPropertyTypes`), so a fully priced
+ * spend stays structurally identical to what every existing test asserts.
+ */
+function usageTalliesOf(spends) {
+    let unpriced;
+    for (const spend of spends)
+        unpriced = mergeUsageTally(unpriced, spend.unpriced);
+    return { ...(unpriced === undefined ? {} : { unpriced }) };
+}
+/** Note one sample that matched no pricing row and was therefore not billed. */
+export function noteUnpriced(spend, model, tokens) {
+    return {
+        total: spend.total,
+        models: spend.models,
+        unpriced: addUsageTally(spend.unpriced, model, tokens),
+    };
+}
+/** The today-spend shape of a single priced contribution. */
+function contributionModel(priced) {
+    return {
+        model: priced.model,
+        displayName: priced.displayName,
+        cost: priced.cost,
+        peakCost: priced.peakCost,
+        offPeakCost: priced.offPeakCost,
+        cacheHitInputTokens: priced.cacheHitInputTokens,
+        cacheMissInputTokens: priced.cacheMissInputTokens,
+        outputTokens: priced.outputTokens,
+        cacheHitInputCost: priced.cacheHitInputCost,
+        cacheMissInputCost: priced.cacheMissInputCost,
+        outputCost: priced.outputCost,
+    };
+}
+/** Sum two model rows of the same model (pure). */
+function mergeModelRows(left, right) {
+    return {
+        model: left.model,
+        displayName: left.displayName,
+        cost: left.cost + right.cost,
+        peakCost: left.peakCost + right.peakCost,
+        offPeakCost: left.offPeakCost + right.offPeakCost,
+        cacheHitInputTokens: left.cacheHitInputTokens + right.cacheHitInputTokens,
+        cacheMissInputTokens: left.cacheMissInputTokens + right.cacheMissInputTokens,
+        outputTokens: left.outputTokens + right.outputTokens,
+        cacheHitInputCost: left.cacheHitInputCost + right.cacheHitInputCost,
+        cacheMissInputCost: left.cacheMissInputCost + right.cacheMissInputCost,
+        outputCost: left.outputCost + right.outputCost,
+    };
+}
+/**
+ * Mutable model-row accumulator behind every spend fold. Rows keep first-seen
+ * model order — the same shape a pure `addEventContribution` chain produces —
+ * so the single-pass scan path and the pure public paths cannot diverge. One
+ * `Map` lookup per contribution instead of a per-event array copy: the huge
+ * event-log folds allocate one row object per model, not one intermediate
+ * array per event.
+ */
+export class SpendAccumulator {
+    rows = new Map();
+    total = 0;
+    /** Add one priced contribution. */
+    add(priced) {
+        const row = contributionModel(priced);
+        const existing = this.rows.get(priced.model);
+        this.rows.set(priced.model, existing === undefined ? row : mergeModelRows(existing, row));
+        this.total += priced.cost;
+    }
+    /** The folded spend; the accumulator stays usable afterwards. */
+    finish() {
+        return { total: this.total, models: [...this.rows.values()] };
+    }
+}
+/** The additive inverse of one spend (pure): used to replace a priced sample. */
+export function negateSpend(spend) {
+    const negate = (value) => -value;
+    return {
+        total: negate(spend.total),
+        // Carried, not inverted: the tallies are counts of what was missed, not
+        // billed amounts, so subtracting a priced sample cannot cancel them.
+        ...usageTalliesOf([spend]),
+        models: spend.models.map(row => ({
+            ...row,
+            cost: negate(row.cost),
+            peakCost: negate(row.peakCost),
+            offPeakCost: negate(row.offPeakCost),
+            cacheHitInputTokens: negate(row.cacheHitInputTokens),
+            cacheMissInputTokens: negate(row.cacheMissInputTokens),
+            outputTokens: negate(row.outputTokens),
+            cacheHitInputCost: negate(row.cacheHitInputCost),
+            cacheMissInputCost: negate(row.cacheMissInputCost),
+            outputCost: negate(row.outputCost),
+        })),
+    };
+}
+/**
+ * Subtract one spend from another (pure). Rows that cancel out completely are
+ * dropped so a replaced sample leaves no zero row behind.
+ * @param target - the spend to subtract from.
+ * @param source - the spend to remove.
+ * @returns the difference.
+ */
+export function subtractSpend(target, source) {
+    const rows = new Map();
+    for (const row of target.models)
+        rows.set(row.model, row);
+    for (const row of source.models) {
+        const existing = rows.get(row.model);
+        if (existing === undefined)
+            continue;
+        const next = mergeModelRows(existing, negateSpend({ total: 0, models: [row] }).models[0]);
+        if (next.cost === 0 && next.cacheHitInputTokens === 0 && next.cacheMissInputTokens === 0 && next.outputTokens === 0) {
+            rows.delete(row.model);
+        }
+        else {
+            rows.set(row.model, next);
+        }
+    }
+    return { total: target.total - source.total, models: [...rows.values()], ...usageTalliesOf([target]) };
+}
+/** The contribution as a one-row spend (the shape a sample keeps for replacement). */
+export function contributionSpend(priced) {
+    return { total: priced.cost, models: [contributionModel(priced)] };
+}
+/**
+ * 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, ...usageTalliesOf([spend]) };
+}
+/**
+ * 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()], ...usageTalliesOf([target, source]) };
+}
+//# sourceMappingURL=spend.js.map