@shi-yangyang/dsh-token-dashboard 0.0.0-stage → 0.2.0

package/lib/host/fold.js

@@ -0,0 +1,375 @@
+/**
+ * The pure token fold.
+ *
+ * It mirrors the official `tokenUsage` projection from
+ * `@deepseek-ai/dsh-token-meter`: the four provider buckets
+ * (`inputTokens`, `cacheReadTokens`, `cacheWriteTokens`, `outputTokens`) are
+ * disjoint, a later sample for the same (turn, step) replaces the previous
+ * sample instead of adding to it, and `llm/retry-started` closes that
+ * replacement scope so the retried attempt is billed separately. It also
+ * attributes each sample to the provider/model route the log records, buckets
+ * usage by local day and hour, and derives the session title.
+ *
+ * Events inherited by a seeded (forked) session are folded into `allTotals`
+ * for diagnostics but excluded from the session's own totals and from every
+ * global aggregate, so a forked prefix is never counted twice.
+ */
+import { dayKey, hourKey } from '../shared/dates.js';
+import { addBuckets, cacheHitRate, emptyBuckets, modelKeyOf, subtractBuckets, totalTokens, } from '../shared/model.js';
+const DEFAULT_KEEP_HOURS_MS = 48 * 60 * 60 * 1000;
+/** Create an empty aggregate for one session. */
+export function createAggregate(header, inheritedEventCount) {
+    const createdAt = finiteNumber(header.createdAt) ?? Date.now();
+    return {
+        totals: emptyBuckets(),
+        allTotals: emptyBuckets(),
+        requests: 0,
+        allRequests: 0,
+        models: {},
+        days: {},
+        hours: {},
+        title: null,
+        lastActivity: createdAt,
+        createdAt,
+        processed: 0,
+        inheritedEventCount: Math.max(0, Math.trunc(inheritedEventCount)),
+        requestSamples: [],
+        carry: {
+            lastSeq: -1,
+            own: null,
+            all: null,
+            currentProvider: '',
+            currentModel: '',
+            stepStart: null,
+        },
+    };
+}
+/** Fold additional contiguous events into one aggregate in place. */
+export function foldInto(aggregate, events, options = {}) {
+    const now = options.now ?? Date.now();
+    const keepHoursMs = options.keepHoursMs ?? DEFAULT_KEEP_HOURS_MS;
+    const inherited = aggregate.inheritedEventCount;
+    for (const event of events) {
+        if (!isEvent(event))
+            continue;
+        if (event.seq <= aggregate.carry.lastSeq)
+            continue;
+        const data = asRecord(event.data);
+        const time = finiteNumber(event.time) ?? aggregate.createdAt;
+        const isOwn = event.seq >= inherited;
+        if (event.type === 'request/header') {
+            const config = asRecord(asRecord(data?.header)?.config);
+            const provider = cleanText(config?.provider);
+            const model = cleanText(config?.model);
+            if (model !== '') {
+                aggregate.carry.currentProvider = provider;
+                aggregate.carry.currentModel = model;
+            }
+        }
+        else if (event.type === 'llm/retry-started') {
+            const turn = finiteNumber(data?.turn);
+            const step = finiteNumber(data?.step);
+            if (turn !== null && step !== null) {
+                if (aggregate.carry.own?.turn === turn && aggregate.carry.own.step === step)
+                    aggregate.carry.own = null;
+                if (aggregate.carry.all?.turn === turn && aggregate.carry.all.step === step)
+                    aggregate.carry.all = null;
+            }
+        }
+        else if (event.type === 'step/start') {
+            const turn = finiteNumber(data?.turn);
+            const step = finiteNumber(data?.step);
+            if (turn !== null && step !== null) {
+                aggregate.carry.stepStart = { turn, step, time };
+            }
+        }
+        else if (event.type === 'session/title') {
+            const title = cleanText(data?.title);
+            if (title !== '')
+                aggregate.title = title;
+        }
+        else if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
+            const turn = finiteNumber(data?.turn);
+            const step = finiteNumber(data?.step);
+            const usage = readUsage(event);
+            if (turn !== null && step !== null && usage !== undefined) {
+                const buckets = bucketsOf(usage);
+                const identity = identityOf(event, aggregate.carry);
+                const timing = isOwn ? readTiming(data, aggregate.carry.stepStart, turn, step, time) : null;
+                const requestKey = `${event.seq}:${turn}:${step}`;
+                const next = {
+                    turn,
+                    step,
+                    time,
+                    buckets,
+                    provider: identity.provider,
+                    model: identity.model,
+                    modelKey: modelKeyOf(identity.provider, identity.model),
+                    timing,
+                    requestKey,
+                };
+                const previousAll = aggregate.carry.all !== null
+                    && aggregate.carry.all.turn === turn
+                    && aggregate.carry.all.step === step
+                    ? aggregate.carry.all
+                    : null;
+                if (previousAll === null) {
+                    aggregate.allRequests += 1;
+                }
+                else {
+                    subtractBuckets(aggregate.allTotals, previousAll.buckets);
+                }
+                addBuckets(aggregate.allTotals, buckets);
+                aggregate.carry.all = next;
+                if (isOwn) {
+                    const previous = aggregate.carry.own !== null
+                        && aggregate.carry.own.turn === turn
+                        && aggregate.carry.own.step === step
+                        ? aggregate.carry.own
+                        : null;
+                    if (previous !== null) {
+                        subtractBuckets(aggregate.totals, previous.buckets);
+                        applyModelDelta(aggregate, previous, -1);
+                        applyBucketDelta(aggregate, previous, -1, now, keepHoursMs);
+                        aggregate.requestSamples = aggregate.requestSamples.filter(sample => sample.key !== previous.requestKey);
+                    }
+                    else {
+                        aggregate.requests += 1;
+                    }
+                    addBuckets(aggregate.totals, next.buckets);
+                    applyModelDelta(aggregate, next, 1);
+                    applyBucketDelta(aggregate, next, 1, now, keepHoursMs);
+                    aggregate.requestSamples.push(requestSample(next, timing));
+                    aggregate.carry.own = next;
+                }
+            }
+        }
+        if (isOwn && time > aggregate.lastActivity)
+            aggregate.lastActivity = time;
+        aggregate.carry.lastSeq = event.seq;
+    }
+    aggregate.processed = aggregate.carry.lastSeq + 1;
+}
+/** Fold one complete session log from scratch. */
+export function foldSession(header, events, inheritedEventCount, options = {}) {
+    const aggregate = createAggregate(header, inheritedEventCount);
+    foldInto(aggregate, events, options);
+    return aggregate;
+}
+/** Detached, wire-safe session counters for diagnostics and row rendering. */
+export function summarizeSession(aggregate) {
+    return {
+        totals: { ...aggregate.totals },
+        requests: aggregate.requests,
+        cacheHitRate: cacheHitRate(aggregate.totals),
+        models: Object.values(aggregate.models)
+            .filter(model => model.requests > 0 || totalTokens(model) > 0)
+            .sort((left, right) => totalTokens(right) - totalTokens(left)),
+        eventCount: aggregate.processed,
+        inheritedEventCount: aggregate.inheritedEventCount,
+    };
+}
+function applyModelDelta(aggregate, slot, sign) {
+    const row = aggregate.models[slot.modelKey] ?? (sign > 0
+        ? (aggregate.models[slot.modelKey] = {
+            key: slot.modelKey,
+            provider: slot.provider,
+            model: slot.model,
+            requests: 0,
+            ...emptyBuckets(),
+        })
+        : undefined);
+    if (row === undefined)
+        return;
+    if (sign > 0)
+        addBuckets(row, slot.buckets);
+    else
+        subtractBuckets(row, slot.buckets);
+    row.requests += sign;
+    if (row.requests <= 0 && totalTokens(row) <= 0)
+        delete aggregate.models[slot.modelKey];
+}
+/** Derive first-token latency and generation window from recorded stream times. */
+function readTiming(data, stepStart, turn, step, messageTime) {
+    let first = null;
+    let last = null;
+    const stream = data?.stream;
+    if (Array.isArray(stream)) {
+        for (const item of stream) {
+            const record = asRecord(item);
+            if (record === undefined)
+                continue;
+            const at = finiteNumber(record.time) ?? finiteNumber(record.time0);
+            if (at !== null) {
+                first = first === null ? at : Math.min(first, at);
+                last = last === null ? at : Math.max(last, at);
+            }
+            const start = finiteNumber(record.time0);
+            if (start !== null) {
+                first = first === null ? start : Math.min(first, start);
+                const dt = Array.isArray(record.dt) ? record.dt : [];
+                const elapsed = dt.reduce((sum, value) => sum + (finiteNumber(value) ?? 0), 0);
+                last = last === null ? start + elapsed : Math.max(last, start + elapsed);
+            }
+        }
+    }
+    const started = stepStart !== null && stepStart.turn === turn && stepStart.step === step
+        ? stepStart.time
+        : null;
+    let firstTokenMs = null;
+    if (started !== null && first !== null && first >= started) {
+        firstTokenMs = first - started;
+    }
+    let generationMs = null;
+    if (first !== null && last !== null && last > first) {
+        generationMs = last - first;
+    }
+    else if (started !== null && messageTime > started) {
+        generationMs = messageTime - started;
+    }
+    else if (first !== null && messageTime > first) {
+        generationMs = messageTime - first;
+    }
+    const totalMs = firstTokenMs !== null && generationMs !== null
+        ? firstTokenMs + generationMs
+        : generationMs ?? firstTokenMs;
+    return firstTokenMs === null && generationMs === null
+        ? null
+        : { firstTokenMs, generationMs, totalMs };
+}
+function requestSample(slot, timing) {
+    const total = timing?.totalMs ?? null;
+    const speed = total !== null && total > 0 && slot.buckets.outputTokens > 0
+        ? slot.buckets.outputTokens / (total / 1_000)
+        : null;
+    return {
+        key: slot.requestKey,
+        time: slot.time,
+        provider: slot.provider,
+        model: slot.model,
+        modelKey: slot.modelKey,
+        buckets: { ...slot.buckets },
+        speed,
+        firstToken: timing?.firstTokenMs ?? null,
+    };
+}
+function applyBucketDelta(aggregate, slot, sign, now, keepHoursMs) {
+    applyOneBucket(aggregate.days, dayKey(slot.time), slot, sign);
+    if (slot.time >= now - keepHoursMs) {
+        applyOneBucket(aggregate.hours, hourKey(slot.time), slot, sign);
+    }
+}
+function applyOneBucket(buckets, key, slot, sign) {
+    const existing = buckets[key];
+    if (sign < 0) {
+        if (existing === undefined)
+            return;
+        subtractBuckets(existing, slot.buckets);
+        existing.requests += sign;
+        applyBucketModelDelta(existing, slot, sign);
+        if (existing.requests <= 0 && totalTokens(existing) <= 0)
+            delete buckets[key];
+        return;
+    }
+    const bucket = existing ?? (buckets[key] = { bucket: key, requests: 0, models: [], ...emptyBuckets() });
+    addBuckets(bucket, slot.buckets);
+    bucket.requests += sign;
+    applyBucketModelDelta(bucket, slot, sign);
+}
+function applyBucketModelDelta(bucket, slot, sign) {
+    const index = bucket.models.findIndex(model => model.key === slot.modelKey);
+    if (index === -1) {
+        if (sign < 0)
+            return;
+        bucket.models.push({
+            key: slot.modelKey,
+            provider: slot.provider,
+            model: slot.model,
+            requests: 1,
+            ...slot.buckets,
+        });
+        return;
+    }
+    const row = bucket.models[index];
+    if (row === undefined)
+        return;
+    if (sign > 0)
+        addBuckets(row, slot.buckets);
+    else
+        subtractBuckets(row, slot.buckets);
+    row.requests += sign;
+    if (row.requests <= 0 && totalTokens(row) <= 0)
+        bucket.models.splice(index, 1);
+}
+function readUsage(event) {
+    const data = asRecord(event.data);
+    if (data === undefined)
+        return undefined;
+    if (event.type === 'assistant/message') {
+        const direct = asRecord(data.usage);
+        if (direct !== undefined)
+            return direct;
+    }
+    const stream = data.stream;
+    if (!Array.isArray(stream))
+        return undefined;
+    for (let index = stream.length - 1; index >= 0; index -= 1) {
+        const record = asRecord(stream[index]);
+        if (record?.type !== 'chunk')
+            continue;
+        const chunk = asRecord(record.chunk);
+        if (chunk?.type !== 'usage')
+            continue;
+        const usage = asRecord(chunk.usage);
+        if (usage !== undefined)
+            return usage;
+    }
+    return undefined;
+}
+function bucketsOf(usage) {
+    return {
+        uncachedInputTokens: countOf(usage.inputTokens),
+        cacheReadTokens: countOf(usage.cacheReadTokens),
+        cacheWriteTokens: countOf(usage.cacheWriteTokens),
+        outputTokens: countOf(usage.outputTokens),
+    };
+}
+function identityOf(event, carry) {
+    if (event.type === 'assistant/message') {
+        const data = asRecord(event.data);
+        const source = asRecord(asRecord(data?.message)?.source);
+        if (source?.kind === 'model') {
+            const model = cleanText(source.model);
+            if (model !== '')
+                return { provider: cleanText(source.provider), model };
+        }
+    }
+    return { provider: carry.currentProvider, model: carry.currentModel };
+}
+function isEvent(value) {
+    const record = asRecord(value);
+    return record !== undefined
+        && typeof record.type === 'string'
+        && typeof record.seq === 'number'
+        && Number.isFinite(record.seq)
+        && record.seq >= 0;
+}
+function asRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function countOf(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0)
+        return 0;
+    return Math.round(value);
+}
+function cleanText(value) {
+    if (typeof value !== 'string')
+        return '';
+    const trimmed = value.trim();
+    return trimmed.length > 160 ? trimmed.slice(0, 160) : trimmed;
+}

package/lib/host/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * dsh-token-dashboard — Host half.
+ *
+ * Reads every local session through the official SessionPersistence service,
+ * folds provider-reported usage with token-meter's published semantics, keeps
+ * a revision-keyed in-memory cache, and serves the dashboard over one
+ * authenticated, read-only same-origin route.
+ *
+ * The plugin never writes session logs, never alters a model request, and
+ * holds no second ledger: the durable logs remain the only source of truth.
+ */
+export declare const name = "dsh-token-dashboard";
+/** The durable session store is the one hard dependency. */
+export declare const inject: string[];
+/** Minimal Cordis Context surface used by this plugin. */
+interface HostContextLike {
+    effect(callback: () => void | (() => void), label?: string): unknown;
+    on(event: string, listener: (...args: any[]) => void): unknown;
+    inject(services: readonly string[], callback: (ctx: HostContextLike) => void): unknown;
+    get(name: string): unknown;
+}
+/** Register the dashboard against one Host context. */
+export declare function apply(ctx: HostContextLike): void;
+export {};

package/lib/host/index.js

@@ -0,0 +1,116 @@
+/**
+ * dsh-token-dashboard — Host half.
+ *
+ * Reads every local session through the official SessionPersistence service,
+ * folds provider-reported usage with token-meter's published semantics, keeps
+ * a revision-keyed in-memory cache, and serves the dashboard over one
+ * authenticated, read-only same-origin route.
+ *
+ * The plugin never writes session logs, never alters a model request, and
+ * holds no second ledger: the durable logs remain the only source of truth.
+ */
+import { TokenAggregator } from './aggregate.js';
+import { createPriceService } from './prices.js';
+import { registerDashboardRoutes } from './server.js';
+import { createDshSource } from './source.js';
+export const name = 'dsh-token-dashboard';
+/** The durable session store is the one hard dependency. */
+export const inject = ['sessionPersistence'];
+/** Register the dashboard against one Host context. */
+export function apply(ctx) {
+    const access = {
+        persistence: () => ctx.get('sessionPersistence'),
+        sessions: () => ctx.get('sessions'),
+        sessionQuery: () => ctx.get('sessionQuery'),
+        workspaces: () => ctx.get('workspaceRegistry'),
+    };
+    const source = createDshSource(access);
+    const aggregator = new TokenAggregator(source, { concurrency: 3 });
+    const prices = createPriceService();
+    wireLiveEvents(ctx, aggregator);
+    wireRoutes(ctx, aggregator, source, prices);
+}
+/** Fold live events without rescanning history; resync only on a gap. */
+function wireLiveEvents(ctx, aggregator) {
+    ctx.effect(() => {
+        let timer = null;
+        const scheduleRefresh = () => {
+            if (aggregator.isInitialized === false)
+                return;
+            if (timer !== null)
+                return;
+            timer = setTimeout(() => {
+                timer = null;
+                void aggregator.refresh().catch(error => {
+                    warn('live resync failed', error);
+                });
+            }, 700);
+            const handle = timer;
+            handle.unref?.();
+        };
+        const disposers = [];
+        const remember = (value) => {
+            if (typeof value === 'function')
+                disposers.push(value);
+        };
+        remember(ctx.on('session/event', (session, event) => {
+            // A passive observer must never throw into the Session append path.
+            try {
+                if (aggregator.isInitialized === false)
+                    return;
+                const id = session?.id;
+                if (typeof id !== 'string' || id === '')
+                    return;
+                if (!aggregator.applyLiveEvent(id, event))
+                    scheduleRefresh();
+            }
+            catch (error) {
+                warn('live fold failed', error);
+                scheduleRefresh();
+            }
+        }));
+        remember(ctx.on('session/created', () => {
+            scheduleRefresh();
+        }));
+        remember(ctx.on('session/disposed', () => {
+            scheduleRefresh();
+        }));
+        return () => {
+            if (timer !== null)
+                clearTimeout(timer);
+            for (const dispose of disposers) {
+                try {
+                    dispose();
+                }
+                catch {
+                    // A listener already removed by its owning fiber is not an error.
+                }
+            }
+        };
+    }, 'dsh-token-dashboard: live usage');
+}
+/** Register the read-only HTTP surface when the deployment serves a web UI. */
+function wireRoutes(ctx, aggregator, source, prices) {
+    ctx.inject(['webServer'], (webCtx) => {
+        const server = webCtx.get('webServer');
+        if (server === undefined)
+            return;
+        webCtx.effect(() => registerDashboardRoutes({
+            server,
+            aggregator,
+            source,
+            prices,
+            connection: () => ctx.get('connection'),
+        }), 'dsh-token-dashboard: dashboard routes');
+    });
+}
+function warn(message, error) {
+    console.warn(`[dsh-token-dashboard] ${message}: ${errorName(error)}`);
+}
+function errorName(error) {
+    if (error instanceof Error) {
+        const code = error.code;
+        return typeof code === 'string' ? `${error.name}:${code}` : error.name;
+    }
+    return 'UnknownError';
+}

package/lib/host/prices.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Optional online price lookup. The Host fetches the public OpenRouter model
+ * list only when the user presses "Refresh online"; no request is made at
+ * startup and no session data leaves the dashboard.
+ */
+import type { ModelPrice } from '../shared/pricing.js';
+export interface PricePayload {
+    source: string;
+    fetchedAt: string;
+    prices: Record<string, ModelPrice>;
+}
+export interface PriceLookup {
+    lookup(models: readonly string[], force: boolean): Promise<PricePayload>;
+}
+interface FetchResponseLike {
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}
+export type PriceFetch = (url: string, init: {
+    signal: AbortSignal;
+    headers: Record<string, string>;
+}) => Promise<FetchResponseLike>;
+export interface PriceServiceOptions {
+    fetch?: PriceFetch;
+    now?: () => number;
+    ttlMs?: number;
+    url?: string;
+}
+export interface OpenRouterEntry {
+    id: string;
+    keys: readonly string[];
+    price: ModelPrice;
+    rank: number;
+}
+/** Parse the subset of the OpenRouter response the dashboard needs. */
+export declare function parseOpenRouterEntries(payload: unknown): OpenRouterEntry[];
+/** Resolve one requested model against the parsed list, preferring standard variants. */
+export declare function resolveOpenRouterPrice(entries: readonly OpenRouterEntry[], requested: string): ModelPrice | undefined;
+/** Create a cached lookup service for the Host route. */
+export declare function createPriceService(options?: PriceServiceOptions): PriceLookup;
+export {};

package/lib/host/prices.js

@@ -0,0 +1,118 @@
+/**
+ * Optional online price lookup. The Host fetches the public OpenRouter model
+ * list only when the user presses "Refresh online"; no request is made at
+ * startup and no session data leaves the dashboard.
+ */
+import { modelKeyCandidates, modelVariantRank } from '../shared/builtin-prices.js';
+const OPENROUTER_URL = 'https://openrouter.ai/api/v1/models';
+const DEFAULT_TTL_MS = 5 * 60 * 1_000;
+/** Parse the subset of the OpenRouter response the dashboard needs. */
+export function parseOpenRouterEntries(payload) {
+    if (payload === null || typeof payload !== 'object')
+        return [];
+    const data = payload.data;
+    if (!Array.isArray(data))
+        return [];
+    const entries = [];
+    for (const raw of data) {
+        if (raw === null || typeof raw !== 'object')
+            continue;
+        const record = raw;
+        if (typeof record.id !== 'string' || record.id.trim() === '')
+            continue;
+        const pricing = record.pricing;
+        if (pricing === null || typeof pricing !== 'object' || Array.isArray(pricing))
+            continue;
+        const priceRecord = pricing;
+        const input = perMillion(priceRecord.prompt);
+        const output = perMillion(priceRecord.completion);
+        if (input === null || output === null)
+            continue;
+        entries.push({
+            id: record.id,
+            keys: modelKeyCandidates(record.id),
+            price: {
+                currency: 'USD',
+                input,
+                output,
+                cacheRead: perMillion(priceRecord.input_cache_read) ?? 0,
+                cacheWrite: perMillion(priceRecord.input_cache_write) ?? 0,
+            },
+            rank: modelVariantRank(record.id),
+        });
+    }
+    return entries;
+}
+/** Resolve one requested model against the parsed list, preferring standard variants. */
+export function resolveOpenRouterPrice(entries, requested) {
+    const keys = new Set(modelKeyCandidates(requested));
+    if (keys.size === 0)
+        return undefined;
+    let best;
+    for (const entry of entries) {
+        if (!entry.keys.some(key => keys.has(key)))
+            continue;
+        if (best === undefined || entry.rank < best.rank)
+            best = entry;
+    }
+    return best === undefined ? undefined : { ...best.price };
+}
+/** Create a cached lookup service for the Host route. */
+export function createPriceService(options = {}) {
+    const now = options.now ?? Date.now;
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    const url = options.url ?? OPENROUTER_URL;
+    const fetchImpl = options.fetch
+        ?? ((input, init) => globalThis.fetch(input, init));
+    let cache = null;
+    const load = async (force) => {
+        if (!force && cache !== null && now() - cache.at < ttlMs)
+            return cache.entries;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 8_000);
+        try {
+            const response = await fetchImpl(url, {
+                signal: controller.signal,
+                headers: {
+                    accept: 'application/json',
+                    'user-agent': 'dsh-token-dashboard/0.1',
+                },
+            });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            const entries = parseOpenRouterEntries(await response.json());
+            cache = { at: now(), entries };
+            return entries;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    return {
+        async lookup(models, force) {
+            if (models.length === 0) {
+                return { source: 'OpenRouter', fetchedAt: new Date(now()).toISOString(), prices: {} };
+            }
+            const entries = await load(force);
+            const prices = {};
+            for (const model of models) {
+                const price = resolveOpenRouterPrice(entries, model);
+                if (price !== undefined)
+                    prices[model] = price;
+            }
+            return {
+                source: 'OpenRouter',
+                fetchedAt: new Date(now()).toISOString(),
+                prices,
+            };
+        },
+    };
+}
+function perMillion(value) {
+    const rate = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim() !== '' ? Number(value) : Number.NaN;
+    if (!Number.isFinite(rate) || rate < 0)
+        return null;
+    return Math.round(rate * 1_000_000 * 1_000_000) / 1_000_000;
+}