@rayadesu/dsh-llm-billing 0.3.16 → 0.3.18

package/lib/types/cache.d.ts

@@ -0,0 +1,110 @@
+/**
+ * The read-path cache: one 60-second Beijing-day window per process with
+ * in-flight coalescing and stale-while-revalidate, plus the bounded fan-out
+ * helper the cold scan parallelises with. Split out of `today-spend.ts` — it is
+ * the one piece that knows nothing about sessions at all.
+ * @module @rayadesu/dsh-llm-billing/cache
+ */
+import type { DeepSeekTodaySpend } from './types.ts';
+/**
+ * Bounded parallel fan-out: run `run` over `items` with at most `limit` in
+ * flight. A shared index counter hands each worker its next job, so the
+ * dispatch is O(n) overall (array `shift()` would be O(n) per pop). The cold
+ * scan parallelises its session reads through this.
+ */
+export declare function withConcurrency<T>(items: readonly T[], limit: number, run: (item: T) => Promise<void>): Promise<void>;
+/**
+ * How many sessions one uninterrupted slice of a scan may fold before the scan
+ * hands the host's event loop back.
+ */
+export declare const SCAN_YIELD_SESSIONS = 8;
+/**
+ * Hand the host's event loop back between session folds.
+ *
+ * The folds are synchronous CPU work — the pricing fold and `foldSessionTitle`
+ * walk a whole log without an `await` — and they run on the same main loop that
+ * serves the GUI's own round trips (switching model, creating a session). A
+ * scan that never yields blocks those requests for its entire duration, which
+ * is exactly what a cold scan did. `setImmediate` schedules the continuation
+ * for the check phase, so the poll phase is served first: pending I/O — the
+ * GUI's requests among it — completes before the next slice of folding.
+ */
+export declare function yieldToEventLoop(): Promise<void>;
+/**
+ * The A1 cache: one Beijing-day key + a 60s window, an in-flight promise that
+ * coalesces concurrent misses, a stale-while-revalidate path so a lapsed window
+ * never makes a plain reader wait on the day's scan, and a `force` bypass that
+ * makes a reader wait for a fresh scan instead. Cross-day invalidation is
+ * automatic (the day key changes, and the previous day's value is never
+ * served); a failed scan leaves the previous value in place and retries on the
+ * next call.
+ * @typeParam T - the cached aggregate's value shape (the spend or its
+ *   per-session breakdown).
+ */
+export declare class TodaySpendCache<T = DeepSeekTodaySpend> {
+    private readonly scan;
+    private readonly ttlMs;
+    private readonly now;
+    private cachedDayKey;
+    private cachedValue;
+    private cachedAt;
+    private inFlight;
+    /**
+     * @param scan - the aggregate computation behind a miss.
+     * @param ttlMs - time window in milliseconds (default 60 000).
+     * @param now - clock source (injectable for tests).
+     */
+    constructor(scan: (dayKey: string) => Promise<T>, ttlMs?: number, now?: () => Date);
+    /**
+     * Read today's spend, cached per Beijing day within the TTL window.
+     *
+     * Two reads share this entry point, and `force` is the switch between them —
+     * its two values are exactly the two policies a caller can want, so there is
+     * no third mode:
+     *
+     * - **plain (`force: false`)** — stale-while-revalidate. A value for the
+     *   queried day is returned AT ONCE; once its window has lapsed the scan that
+     *   refreshes it runs behind the answer. This is the read for everything the
+     *   user did not just cause: a mount, a panel open, a poll, a session switch.
+     * - **forced (`force: true`)** — recompute now and WAIT: both the window and
+     *   the stale shortcut are bypassed. This is the read for a manual refresh and
+     *   for a settled turn, which have just changed the answer and must not be
+     *   handed the value from before they ran. A plain read there would report the
+     *   day's pre-turn figure one turn late.
+     *
+     * A day with no value yet (the first read of the day, or a Beijing-day
+     * rollover — yesterday's total is never served as today's) waits either way,
+     * because there is nothing honest to show. A failed revalidation leaves the
+     * previous value in place, and a pass already in flight is joined rather than
+     * duplicated.
+     * @param force - `true` recomputes now and waits; `false` serves the value on
+     *   hand and refreshes behind it.
+     * @returns today's spend.
+     */
+    get(force?: boolean): Promise<T>;
+    /**
+     * Run one scan and publish its result.
+     *
+     * `cachedAt` is stamped when the scan COMPLETES, not when it starts: a pass
+     * slower than the TTL would otherwise be born expired, and every read after
+     * it would start another pass back-to-back.
+     * @param dayKey - the Beijing day the pass aggregates.
+     * @returns the freshly scanned value.
+     */
+    private run;
+}
+/** Max session-ids kept in the scanner's cold-resolution cache before eviction. */
+export declare const COLD_RESOLVE_CACHE_LIMIT = 1024;
+/** Max session-ids kept in the scanner's cold-failure cache before eviction. */
+export declare const COLD_FAILED_CACHE_LIMIT = 1024;
+/**
+ * How long a failed cold resolution is remembered before it is retried even
+ * though the log is unchanged. Most read failures are transient (a lock held
+ * during a concurrent write), so remembering them forever would cost a session
+ * for the rest of the process.
+ */
+export declare const COLD_FAILED_RETRY_MS = 300000;
+/** Bounded parallel fan-out for cold-session resolution. */
+export declare const COLD_RESOLVE_CONCURRENCY = 8;
+/** The live SessionStore slice a scan reads (resolved once per scan). */ 
+//# sourceMappingURL=cache.d.ts.map

package/lib/types/cache.js

@@ -0,0 +1,155 @@
+/**
+ * The read-path cache: one 60-second Beijing-day window per process with
+ * in-flight coalescing and stale-while-revalidate, plus the bounded fan-out
+ * helper the cold scan parallelises with. Split out of `today-spend.ts` — it is
+ * the one piece that knows nothing about sessions at all.
+ * @module @rayadesu/dsh-llm-billing/cache
+ */
+import { beijingDayKey } from "./billing.js";
+/**
+ * Bounded parallel fan-out: run `run` over `items` with at most `limit` in
+ * flight. A shared index counter hands each worker its next job, so the
+ * dispatch is O(n) overall (array `shift()` would be O(n) per pop). The cold
+ * scan parallelises its session reads through this.
+ */
+export async function withConcurrency(items, limit, run) {
+    const total = items.length;
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, total) }, async () => {
+        for (let job = next; job < total; job = next) {
+            next += 1;
+            await run(items[job]);
+        }
+    }));
+}
+/**
+ * How many sessions one uninterrupted slice of a scan may fold before the scan
+ * hands the host's event loop back.
+ */
+export const SCAN_YIELD_SESSIONS = 8;
+/**
+ * Hand the host's event loop back between session folds.
+ *
+ * The folds are synchronous CPU work — the pricing fold and `foldSessionTitle`
+ * walk a whole log without an `await` — and they run on the same main loop that
+ * serves the GUI's own round trips (switching model, creating a session). A
+ * scan that never yields blocks those requests for its entire duration, which
+ * is exactly what a cold scan did. `setImmediate` schedules the continuation
+ * for the check phase, so the poll phase is served first: pending I/O — the
+ * GUI's requests among it — completes before the next slice of folding.
+ */
+export function yieldToEventLoop() {
+    return new Promise((resolve) => { setImmediate(resolve); });
+}
+/**
+ * The A1 cache: one Beijing-day key + a 60s window, an in-flight promise that
+ * coalesces concurrent misses, a stale-while-revalidate path so a lapsed window
+ * never makes a plain reader wait on the day's scan, and a `force` bypass that
+ * makes a reader wait for a fresh scan instead. Cross-day invalidation is
+ * automatic (the day key changes, and the previous day's value is never
+ * served); a failed scan leaves the previous value in place and retries on the
+ * next call.
+ * @typeParam T - the cached aggregate's value shape (the spend or its
+ *   per-session breakdown).
+ */
+export class TodaySpendCache {
+    scan;
+    ttlMs;
+    now;
+    cachedDayKey;
+    cachedValue;
+    cachedAt = 0;
+    inFlight;
+    /**
+     * @param scan - the aggregate computation behind a miss.
+     * @param ttlMs - time window in milliseconds (default 60 000).
+     * @param now - clock source (injectable for tests).
+     */
+    constructor(scan, ttlMs = 60_000, now = () => new Date()) {
+        this.scan = scan;
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    /**
+     * Read today's spend, cached per Beijing day within the TTL window.
+     *
+     * Two reads share this entry point, and `force` is the switch between them —
+     * its two values are exactly the two policies a caller can want, so there is
+     * no third mode:
+     *
+     * - **plain (`force: false`)** — stale-while-revalidate. A value for the
+     *   queried day is returned AT ONCE; once its window has lapsed the scan that
+     *   refreshes it runs behind the answer. This is the read for everything the
+     *   user did not just cause: a mount, a panel open, a poll, a session switch.
+     * - **forced (`force: true`)** — recompute now and WAIT: both the window and
+     *   the stale shortcut are bypassed. This is the read for a manual refresh and
+     *   for a settled turn, which have just changed the answer and must not be
+     *   handed the value from before they ran. A plain read there would report the
+     *   day's pre-turn figure one turn late.
+     *
+     * A day with no value yet (the first read of the day, or a Beijing-day
+     * rollover — yesterday's total is never served as today's) waits either way,
+     * because there is nothing honest to show. A failed revalidation leaves the
+     * previous value in place, and a pass already in flight is joined rather than
+     * duplicated.
+     * @param force - `true` recomputes now and waits; `false` serves the value on
+     *   hand and refreshes behind it.
+     * @returns today's spend.
+     */
+    get(force = false) {
+        const now = this.now();
+        const dayKey = beijingDayKey(now);
+        // Only the queried day's value is servable: yesterday's total is not
+        // today's, so a rollover blocks exactly like a cold read.
+        const cached = this.cachedDayKey === dayKey ? this.cachedValue : undefined;
+        if (!force && cached !== undefined) {
+            if (now.getTime() - this.cachedAt < this.ttlMs)
+                return Promise.resolve(cached);
+            // Stale, same day: serve it now and refresh behind it. The background
+            // pass must not surface as an unhandled rejection.
+            if (this.inFlight === undefined)
+                void this.run(dayKey).catch(() => undefined);
+            return Promise.resolve(cached);
+        }
+        // No value for the queried day (or a forced read): a scan already in
+        // flight is fresh by definition, so a forced caller joins it instead of
+        // starting a second pass.
+        if (this.inFlight !== undefined)
+            return this.inFlight;
+        return this.run(dayKey);
+    }
+    /**
+     * Run one scan and publish its result.
+     *
+     * `cachedAt` is stamped when the scan COMPLETES, not when it starts: a pass
+     * slower than the TTL would otherwise be born expired, and every read after
+     * it would start another pass back-to-back.
+     * @param dayKey - the Beijing day the pass aggregates.
+     * @returns the freshly scanned value.
+     */
+    run(dayKey) {
+        const run = this.scan(dayKey).then((value) => {
+            this.cachedDayKey = dayKey;
+            this.cachedValue = value;
+            this.cachedAt = this.now().getTime();
+            return value;
+        }).finally(() => { this.inFlight = undefined; });
+        this.inFlight = run;
+        return run;
+    }
+}
+/** Max session-ids kept in the scanner's cold-resolution cache before eviction. */
+export const COLD_RESOLVE_CACHE_LIMIT = 1024;
+/** Max session-ids kept in the scanner's cold-failure cache before eviction. */
+export const COLD_FAILED_CACHE_LIMIT = 1024;
+/**
+ * How long a failed cold resolution is remembered before it is retried even
+ * though the log is unchanged. Most read failures are transient (a lock held
+ * during a concurrent write), so remembering them forever would cost a session
+ * for the rest of the process.
+ */
+export const COLD_FAILED_RETRY_MS = 300_000;
+/** Bounded parallel fan-out for cold-session resolution. */
+export const COLD_RESOLVE_CONCURRENCY = 8;
+/** The live SessionStore slice a scan reads (resolved once per scan). */ 
+//# sourceMappingURL=cache.js.map

package/lib/types/fold.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The single-pass fold state machine that turns a committed event log into a
+ * session's billed spend. Consumes the pricing primitives in `pricing.ts`
+ * (`priceUsage` / `reportUnpricedModel`) and the spend algebra in `spend.ts`
+ * (`addEventContribution` / `subtractSpend` / `noteUnpriced` / `emptyTodaySpend`);
+ * every scan path prices through {@link applyBillingEvent} so a pricing-table
+ * change cannot drift one path from the others.
+ * @module @rayadesu/dsh-llm-billing/fold
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { DeepSeekTodaySpend } from './types.ts';
+import type { ResolvedBilling } from './pricing.ts';
+/**
+ * One priced attempt sample kept for same-step replacement: DSH can report the
+ * same `(turn, step)` twice (an `assistant/attempt` stream and the
+ * `assistant/message` that assembles from it), and a later sample replaces the
+ * earlier one instead of adding to it. `llm/retry-started` clears the slot, so
+ * a retried attempt adds rather than replaces (both requests were billed).
+ */
+export interface BillingFoldSample {
+    /** Turn of the producing attempt. */
+    turn: number;
+    /** Step of the producing attempt. */
+    step: number;
+    /** Beijing day of the sample's timestamp. */
+    dayKey: string;
+    /** The sample's contribution as a one-row spend (subtracted on replacement). */
+    spend: DeepSeekTodaySpend;
+}
+/**
+ * Plain-JSON fold state of one session's billed spend: the latest priced day,
+ * the whole-session total, the fork boundary, the model of the latest request
+ * (needed to price an `assistant/attempt`, which carries no route), and the
+ * last sample kept for replacement.
+ */
+export interface BillingFoldState {
+    /** Beijing-time calendar-day key of `spend`; `''` for no priced usage. */
+    dayKey: string;
+    /** The spend of the session's latest priced Beijing day (own events only). */
+    spend: DeepSeekTodaySpend;
+    /** The spend of the session's OWN events across every day. */
+    session: DeepSeekTodaySpend;
+    /** Fork-inherited prefix length; events below it belong to the source session. */
+    inheritedEventCount: number;
+    /** Wire model of the latest `request/header`; `''` before the first one. */
+    model: string;
+    /** Latest priced attempt sample, for same-step replacement. */
+    last: BillingFoldSample | null;
+}
+/** The empty fold state for one fork boundary. */
+export declare function emptyBillingFoldState(inheritedEventCount?: number): BillingFoldState;
+/**
+ * Fold one committed event into a session's billed-spend state.
+ *
+ * Priced samples come from `assistant/message` (its own reported usage, or the
+ * stream's last usage chunk) and `assistant/attempt` (the stream's last usage
+ * chunk, priced with the model of the latest `request/header`, since an
+ * attempt carries no route). A sample for the same `(turn, step)` replaces the
+ * previous one; `llm/retry-started` closes the replacement slot so a retried
+ * attempt adds. Every other event is inert and returns the same state
+ * reference.
+ * @param state - the previous fold state.
+ * @param event - the committed event.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the next state (the same reference when nothing was priced).
+ */
+export declare function applyBillingEvent(state: BillingFoldState, event: SessionEvent, billing: ResolvedBilling, names: ReadonlyMap<string, string>): BillingFoldState;
+/**
+ * Mutable wrapper over {@link applyBillingEvent} for the pure pricing paths:
+ * feed events in order, read the folded spend.
+ */
+export declare class BillingFolder {
+    private readonly billing;
+    private state;
+    /**
+     * @param billing - resolved pricing with peak-hour windows.
+     * @param catalog - model display rows, in presentation order.
+     * @param inheritedEventCount - fork boundary to skip (default 0).
+     */
+    constructor(billing: ResolvedBilling, catalog: readonly {
+        id: string;
+        name: string;
+    }[], inheritedEventCount?: number);
+    private readonly names;
+    /** Fold one event. */
+    add(event: SessionEvent): void;
+    /** Fold every event, in order. */
+    addAll(events: readonly SessionEvent[]): void;
+    /** The folded state (live reference; do not mutate). */
+    get fold(): BillingFoldState;
+}
+//# sourceMappingURL=fold.d.ts.map

package/lib/types/fold.js

@@ -0,0 +1,188 @@
+/**
+ * The single-pass fold state machine that turns a committed event log into a
+ * session's billed spend. Consumes the pricing primitives in `pricing.ts`
+ * (`priceUsage` / `reportUnpricedModel`) and the spend algebra in `spend.ts`
+ * (`addEventContribution` / `subtractSpend` / `noteUnpriced` / `emptyTodaySpend`);
+ * every scan path prices through {@link applyBillingEvent} so a pricing-table
+ * change cannot drift one path from the others.
+ * @module @rayadesu/dsh-llm-billing/fold
+ */
+import { beijingPartsOf } from "./beijing-time.js";
+import { priceUsage, reportUnpricedModel, usageTokens } from "./pricing.js";
+import { addEventContribution, contributionSpend, emptyTodaySpend, noteUnpriced, subtractSpend } from "./spend.js";
+/** The empty fold state for one fork boundary. */
+export function emptyBillingFoldState(inheritedEventCount = 0) {
+    return {
+        dayKey: '',
+        spend: emptyTodaySpend(),
+        session: emptyTodaySpend(),
+        inheritedEventCount,
+        model: '',
+        last: null,
+    };
+}
+/** Whether an unknown value looks like a provider usage report. */
+function isTokenUsage(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return typeof candidate.inputTokens === 'number' && typeof candidate.outputTokens === 'number';
+}
+/**
+ * The last `usage` sample embedded in an event's stream, if any. `assistant/
+ * attempt` and the embedded streams are newer than the plugin's npm baseline,
+ * so the stream is read structurally (a failed/retried attempt reports its
+ * usage only there).
+ */
+function streamUsageOf(event) {
+    const stream = event.data === undefined
+        ? undefined
+        : event.data.stream;
+    if (!Array.isArray(stream))
+        return undefined;
+    for (let index = stream.length - 1; index >= 0; index -= 1) {
+        const chunk = stream[index]?.chunk;
+        if (chunk === undefined || chunk.type !== 'usage')
+            continue;
+        return isTokenUsage(chunk.usage) ? chunk.usage : undefined;
+    }
+    return undefined;
+}
+/**
+ * Fold one committed event into a session's billed-spend state.
+ *
+ * Priced samples come from `assistant/message` (its own reported usage, or the
+ * stream's last usage chunk) and `assistant/attempt` (the stream's last usage
+ * chunk, priced with the model of the latest `request/header`, since an
+ * attempt carries no route). A sample for the same `(turn, step)` replaces the
+ * previous one; `llm/retry-started` closes the replacement slot so a retried
+ * attempt adds. Every other event is inert and returns the same state
+ * reference.
+ * @param state - the previous fold state.
+ * @param event - the committed event.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the next state (the same reference when nothing was priced).
+ */
+export function applyBillingEvent(state, event, billing, names) {
+    if (event.seq < state.inheritedEventCount)
+        return state;
+    // `assistant/attempt`, `llm/retry-started`, and the embedded stream are all
+    // newer than the npm baseline this package builds against, so their fields
+    // are read structurally.
+    const type = event.type;
+    if (type === 'request/header') {
+        const model = event.data
+            ?.header?.config?.model;
+        return typeof model === 'string' && model.length > 0 && model !== state.model ? { ...state, model } : state;
+    }
+    const data = event.data;
+    if (type === 'llm/retry-started') {
+        if (typeof data?.turn !== 'number' || typeof data.step !== 'number')
+            return state;
+        const last = state.last;
+        if (last === null || last.turn !== data.turn || last.step !== data.step)
+            return state;
+        return { ...state, last: null };
+    }
+    if (type !== 'assistant/message' && type !== 'assistant/attempt')
+        return state;
+    const usage = (type === 'assistant/message' ? data?.usage : undefined) ?? streamUsageOf(event);
+    if (!isTokenUsage(usage))
+        return state;
+    const model = type === 'assistant/message' ? data?.message?.source?.model : state.model;
+    if (typeof model !== 'string' || model.length === 0)
+        return state;
+    const parts = beijingPartsOf(event.time);
+    const rows = billing.models.get(model);
+    if (rows === undefined) {
+        // Unlisted upstream model: no rate row means no price, and no price is
+        // guessed — a similar-looking id says nothing about a similar price, and a
+        // wrong number that LOOKS authoritative is worse than a visible gap. The
+        // usage is recorded rather than dropped, so today's ¥0 can say WHY.
+        reportUnpricedModel(model);
+        const tokens = usageTokens(usage);
+        // Mirror the priced day rule so the tally reaches the day view: an
+        // unpriced sample opens the day when the fold has none yet and rolls it
+        // forward. Otherwise the very case this exists for — a session whose
+        // EVERY sample is unpriced — would keep reading as "no usage at all"
+        // with nothing recorded anywhere the today figure is read from.
+        const opens = state.dayKey === '' || parts.dayKey > state.dayKey;
+        const sameDay = parts.dayKey === state.dayKey;
+        return {
+            ...state,
+            dayKey: opens ? parts.dayKey : state.dayKey,
+            spend: opens
+                ? noteUnpriced(emptyTodaySpend(), model, tokens)
+                : sameDay ? noteUnpriced(state.spend, model, tokens) : state.spend,
+            session: noteUnpriced(state.session, model, tokens),
+        };
+    }
+    const priced = priceUsage(parts, usage, model, billing, names);
+    // Unreachable — the row was resolved just above — but the lookup's own type
+    // says `| undefined`, so the branch is spelled out rather than asserted away.
+    if (priced === undefined)
+        return state;
+    let session = state.session;
+    let spend = state.spend;
+    let dayKey = state.dayKey;
+    const last = state.last;
+    const turn = typeof data?.turn === 'number' ? data.turn : 0;
+    const step = typeof data?.step === 'number' ? data.step : 0;
+    if (last !== null && last.turn === turn && last.step === step) {
+        session = subtractSpend(session, last.spend);
+        if (last.dayKey === dayKey)
+            spend = subtractSpend(spend, last.spend);
+    }
+    session = addEventContribution(session, priced);
+    if (dayKey === priced.dayKey) {
+        spend = addEventContribution(spend, priced);
+    }
+    else if (dayKey === '' || priced.dayKey > dayKey) {
+        // The session log is append-only and chronological, so a strictly older
+        // day cannot legally follow; ignore it for the latest-day state (the
+        // whole-session total still accrues).
+        dayKey = priced.dayKey;
+        spend = addEventContribution(emptyTodaySpend(), priced);
+    }
+    return {
+        ...state,
+        dayKey,
+        spend,
+        session,
+        last: { turn, step, dayKey: priced.dayKey, spend: contributionSpend(priced) },
+    };
+}
+/**
+ * Mutable wrapper over {@link applyBillingEvent} for the pure pricing paths:
+ * feed events in order, read the folded spend.
+ */
+export class BillingFolder {
+    billing;
+    state;
+    /**
+     * @param billing - resolved pricing with peak-hour windows.
+     * @param catalog - model display rows, in presentation order.
+     * @param inheritedEventCount - fork boundary to skip (default 0).
+     */
+    constructor(billing, catalog, inheritedEventCount = 0) {
+        this.billing = billing;
+        this.names = new Map(catalog.map(model => [model.id, model.name]));
+        this.state = emptyBillingFoldState(inheritedEventCount);
+    }
+    names;
+    /** Fold one event. */
+    add(event) {
+        this.state = applyBillingEvent(this.state, event, this.billing, this.names);
+    }
+    /** Fold every event, in order. */
+    addAll(events) {
+        for (const event of events)
+            this.add(event);
+    }
+    /** The folded state (live reference; do not mutate). */
+    get fold() {
+        return this.state;
+    }
+}
+//# sourceMappingURL=fold.js.map

package/lib/types/index.d.ts

@@ -30,7 +30,7 @@ export type * from './types.ts';
 export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit, foldOwnBilling } from './projection.ts';
 export type { BillingUnitFold, BillingUnitState } from './projection.ts';
 export { delegatedSpendOf, foldSessionTitle, isSubagentSession, liveSessionEvents, persistenceInspect, persistenceListSnapshots, rollUpSubagentSpend, TodaySpendCache, TodaySpendScanner, topLevelSessionOf, } from './today-spend.ts';
-export type { ColdResolution, ScannerPersistedHeader, ScannerPersistence, ScannerPersistenceHandle, ScannerPersistenceLegacy, ScannerPersistedRead, ScannerSession, SessionHeaderSlice, SessionLineage, TodaySpendScannerDeps, } from './today-spend.ts';
+export type { ColdResolution, ScannerPersistedHeader, ScannerPersistence, ScannerPersistenceHandle, ScannerPersistedRead, ScannerSession, SessionHeaderSlice, SessionLineage, 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";

package/lib/types/index.js

@@ -116,7 +116,7 @@ function evictOldest(map, limit) {
 /**
  * Read one session's event log and durable seed boundary: the live
  * SessionStore first, then the persistence backend for a flushed session
- * (inspected directly by id — no header listing). The live-session surface
+ * (opened directly by id — no header listing). The live-session surface
  * is read structurally across both DSH runtime families — `Session.events`
  * (≤ 0.1.1-rc.2) or `Session.snapshotEvents()` + `Session.inheritedEventCount`
  * (0.1.2-alpha.4+) — via {@link liveSessionEvents} / {@link forkBoundaryOf}.