dsh-layered-memory 0.8.6 → 0.8.8

package/dist/store/download-queue.d.ts

@@ -1,24 +1,7 @@
 import type { MemoryLogger } from '../types.js';
 import { type CatalogEntry } from './model-catalog.js';
-export type DownloadPhase = 'downloading' | 'verifying' | 'done' | 'cancelled' | 'error';
-export interface DownloadProgress {
-    modelId: string;
-    phase: DownloadPhase;
-    /** 当前文件序号（1-based）。 */
-    fileIndex: number;
-    fileCount: number;
-    /** 当前文件已收字节（含续传基线）。 */
-    fileReceived: number;
-    fileTotal: number;
-    /** 整模型累计字节（含已完成文件；分母 = 目录总大小）。 */
-    overallReceived: number;
-    overallTotal: number;
-    /** EMA 平滑速度（字节/秒）。 */
-    speedBps: number;
-    startedAt: number;
-    /** phase=error 时的原因。 */
-    error?: string;
-}
+import type { DownloadProgress } from '../contract.js';
+export type { DownloadPhase, DownloadProgress } from '../contract.js';
 export interface ModelStatus {
     id: string;
     /** none=未下载；partial=有断点/不完整；downloaded=全部文件就位且尺寸吻合。 */
@@ -104,4 +87,3 @@ export declare function resolveProxyUrl(setting: string | undefined, host: strin
 /** 代理 URL 日志脱敏：剥掉 userinfo（内网代理常带 user:pass 凭据），只留 scheme//host；
  *  解析失败的串原样也可能是凭据形态，返回占位符。 */
 export declare function maskProxyUrl(proxy: string): string;
-export {};

package/dist/store/embedding-source.d.ts

@@ -7,7 +7,8 @@ import { LocalEmbeddingService } from './local-embedding.js';
 import { ModelDownloadQueue } from './download-queue.js';
 import { RuntimeInstaller } from './runtime-installer.js';
 import type { MemoryDb } from './sqlite.js';
-export type EmbeddingSourceKind = 'remote' | 'local' | 'off';
+import type { EmbeddingSourceKind, EmbeddingStateView } from '../contract.js';
+export type { ApplyPhase, EmbeddingSourceKind, EmbeddingStateView, ReindexProgressState } from '../contract.js';
 export interface EmbeddingSourceState {
     source: EmbeddingSourceKind;
     /** source=local 时启用的目录模型 id。 */
@@ -38,17 +39,6 @@ export declare function resolveInitialEmbedding(cfg: MemoryConfig, sourceStore:
 /** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。
  *  推理在 worker 线程（见 local-embedding.ts）；此处只传 runtime 目录与模型目录。 */
 export declare function makeLocalServiceFactory(installer: RuntimeInstaller, downloader: ModelDownloadQueue, logger?: MemoryLogger, maxInputChars?: number): (modelId: string) => LocalEmbeddingService | null;
-export type ApplyPhase = 'idle' | 'installing-runtime' | 'warming' | 'switching' | 'reindexing' | 'done' | 'error';
-export interface ReindexProgressState {
-    running: boolean;
-    l1Done: number;
-    l1Total: number;
-    l0Done: number;
-    l0Total: number;
-    startedAt: number;
-    cancelled: boolean;
-    error?: string;
-}
 export interface EmbeddingManagerDeps {
     dataDir: string;
     cfg: MemoryConfig;
@@ -119,43 +109,3 @@ export declare class EmbeddingManager {
     /** RPC 快照（设置页嵌入区块数据源；client 忙时 1s 轮询）。 */
     snapshot(): Promise<EmbeddingStateView>;
 }
-export interface EmbeddingStateView {
-    source: EmbeddingSourceKind;
-    activeModel: string | null;
-    ceilings: {
-        remote: boolean;
-        local: boolean;
-    };
-    runtime: {
-        targetVersion: string;
-        phase: 'idle' | 'installing' | 'ready' | 'error' | 'cancelled';
-        installedVersion: string | null;
-        elapsedMs: number;
-        lastLines: string[];
-        error?: string;
-    };
-    models: Array<{
-        id: string;
-        name: string;
-        dims: number;
-        contextTokens: number;
-        tags: string[];
-        description: string;
-        totalBytes: number;
-        bytesOnDisk: number;
-        state: 'none' | 'partial' | 'downloaded';
-    }>;
-    download: ReturnType<ModelDownloadQueue['getProgress']>;
-    apply: {
-        phase: ApplyPhase;
-        message: string;
-        startedAt: number;
-        busy: boolean;
-    };
-    local: {
-        state: 'idle' | 'loading' | 'ready' | 'failed' | 'terminated';
-        error: string | null;
-    } | null;
-    reindex: ReindexProgressState;
-    activeNote?: string;
-}

package/dist/store/runtime-installer.d.ts

@@ -1,19 +1,8 @@
 import type { MemoryLogger } from '../types.js';
 /** 钉死的 transformers.js 版本（D8：精确版本，升级插件时在此变更并重装运行时）。 */
 export declare const PINNED_TRANSFORMERS_VERSION = "4.2.0";
-export interface RuntimeProgress {
-    phase: 'idle' | 'installing' | 'ready' | 'error' | 'cancelled';
-    /** 插件钉死的目标版本。 */
-    targetVersion: string;
-    /** runtime 里实际就位的版本（未安装为 null）。 */
-    installedVersion: string | null;
-    startedAt: number;
-    /** 已运行毫秒（读时计算）。 */
-    elapsedMs: number;
-    /** npm 输出尾行（最近 5 行，让用户看到 npm 在干什么）。 */
-    lastLines: string[];
-    error?: string;
-}
+import type { RuntimeProgress } from '../contract.js';
+export type { RuntimeProgress } from '../contract.js';
 /** 子进程抽象（测试注入缝）：注册输出行回调 + 终止 + 终态。 */
 export interface SpawnedProcess {
     onStdout(cb: (line: string) => void): void;

package/dist/store/sqlite.d.ts

@@ -9,6 +9,10 @@ export interface StoreCapabilities {
     ftsSearch: boolean;
     vectorSearch: boolean;
 }
+import { CostLedger } from './cost-ledger.js';
+import type { BucketRow, CostAggregate, CostByLayer } from './cost-ledger.js';
+export type { BucketRow, CostAggregate, CostByLayer } from './cost-ledger.js';
+import type { CostByModel } from '../contract.js';
 /** L1 检索命中（含 BM25/余弦归一分数）。 */
 export interface L1SearchHit {
     id: string;
@@ -23,6 +27,7 @@ export interface L1SearchHit {
 export interface L0SearchHit extends L0MessageRecord {
     score: number;
 }
+/** 已排序序列的中位数（偶数个取中间两者平均；空返回 0）。 */
 export declare class MemoryDb {
     private db;
     private degraded;
@@ -44,6 +49,8 @@ export declare class MemoryDb {
     private stmtL1FtsDelete;
     private stmtL1FtsSearch;
     private stmtL1FtsSearchFamily;
+    /** 成本账本（token_cost 表族；init 内初始化，未就绪时方法返回零值）。 */
+    readonly costLedger: CostLedger;
     private stmtUpsertL0;
     private stmtGetL0;
     /** 主表存在性点查（同 L1：防御性 FTS 删除的前置判断）。 */
@@ -145,6 +152,17 @@ export declare class MemoryDb {
     searchL1Vector(embedding: Float32Array, topK: number, family?: string): L1SearchHit[];
     /** 批量 upsert L0 消息（元数据 + FTS；embeddings 与 records 等长，可省略）。 */
     upsertL0Batch(records: L0MessageRecord[], embeddings?: Array<Float32Array | undefined>): boolean;
+    /** 记录一次蒸馏调用成本（委托 cost-ledger；语义见 CostLedger.insertCostCall）。 */
+    insertCostCall(provider: string, model: string, layer: string, inputChars: number, outputTokens: number, reasoningTokens: number, retentionDays: number): void;
+    /** 查询 token_cost 单窗口聚合（委托 cost-ledger；降级/异常返回零值）。 */
+    aggregateCost(since: number): {
+        total: CostAggregate;
+        byModel: CostByModel[];
+    };
+    /** 按层级归并聚合（委托 cost-ledger；降级/异常返回空数组）。 */
+    aggregateCostByLayer(since: number): CostByLayer[];
+    /** 按时间桶 + model 聚合（委托 cost-ledger；趋势图与日均/周均/月均共用）。 */
+    aggregateByBucket(bucketMs: number, offsetMs: number, since: number, layer: string): BucketRow[];
     countL0(): number;
     /** 统计 recorded_at >= iso 的消息数（状态面板"今日捕获"用）。 */
     countL0Since(iso: string): number;

package/dist/store/sqlite.js

@@ -22,6 +22,9 @@ import { bm25RankToScore, buildFtsQuery, tokenizeForFts } from './search-utils.j
 import { describeTokenizer, ensureTokenizer, tokenizerStamp } from '../util/tokenizer.js';
 const require = createRequire(import.meta.url);
 const TAG = '[memory][sqlite]';
+// 成本账本（token_cost 表族：类型 + 实现）已整体迁出到 ./cost-ledger.ts——与检索引擎
+// 零关系的独立职责；此处 re-export 不断裂既有引用，MemoryDb 四个公开方法改为一行委托。
+import { CostLedger } from './cost-ledger.js';
 /** vec0 KNN 对遗留零向量的补偿缓冲（官方同款）。 */
 const ZERO_VEC_BUFFER = 10;
 /** IN 查询/删除的分块大小（保守避开 SQLite 变量数上限：现代构建 32766，老版 999）。 */
@@ -35,6 +38,10 @@ function chunkIds(ids) {
         out.push(ids.slice(i, i + IN_CHUNK));
     return out;
 }
+function emptyCostAggregate() {
+    return { calls: 0, inputChars: 0, outputTokens: 0, reasoningTokens: 0, avgOutputTokens: 0, medianOutputTokens: 0 };
+}
+/** 已排序序列的中位数（偶数个取中间两者平均；空返回 0）。 */
 export class MemoryDb {
     db;
     degraded = false;
@@ -56,6 +63,8 @@ export class MemoryDb {
     stmtL1FtsDelete;
     stmtL1FtsSearch;
     stmtL1FtsSearchFamily;
+    /** 成本账本（token_cost 表族；init 内初始化，未就绪时方法返回零值）。 */
+    costLedger = new CostLedger();
     stmtUpsertL0;
     stmtGetL0;
     /** 主表存在性点查（同 L1：防御性 FTS 删除的前置判断）。 */
@@ -325,6 +334,8 @@ export class MemoryDb {
         this.stmtGetL0 = this.db.prepare('SELECT session_id, role, message_text, recorded_at, timestamp FROM l0_conversations WHERE record_id = ?');
         this.stmtL0Exists = this.db.prepare('SELECT 1 FROM l0_conversations WHERE record_id = ?');
         this.prepareL0VecStatements();
+        // ── token_cost：蒸馏成本明细表（成本账本自治；见 cost-ledger.ts） ──
+        this.costLedger.init(this.db, this.logger);
         // ── FTS5 全文索引（建表失败仅停用 FTS，不降级整个库） ──
         try {
             // 索引重建判据（FTS5 无法 ALTER，只能 drop 后从源表全量回灌）：
@@ -978,6 +989,22 @@ export class MemoryDb {
             return false;
         }
     }
+    /** 记录一次蒸馏调用成本（委托 cost-ledger；语义见 CostLedger.insertCostCall）。 */
+    insertCostCall(provider, model, layer, inputChars, outputTokens, reasoningTokens, retentionDays) {
+        this.costLedger.insertCostCall(provider, model, layer, inputChars, outputTokens, reasoningTokens, retentionDays);
+    }
+    /** 查询 token_cost 单窗口聚合（委托 cost-ledger；降级/异常返回零值）。 */
+    aggregateCost(since) {
+        return this.costLedger.aggregateCost(since);
+    }
+    /** 按层级归并聚合（委托 cost-ledger；降级/异常返回空数组）。 */
+    aggregateCostByLayer(since) {
+        return this.costLedger.aggregateCostByLayer(since);
+    }
+    /** 按时间桶 + model 聚合（委托 cost-ledger；趋势图与日均/周均/月均共用）。 */
+    aggregateByBucket(bucketMs, offsetMs, since, layer) {
+        return this.costLedger.aggregateByBucket(bucketMs, offsetMs, since, layer);
+    }
     countL0() {
         if (this.degraded)
             return 0;

package/dist/token-cost.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 蒸馏成本看板账本：把每次蒸馏调用（model × layer）的 token 成本写入 SQLite 明细表。
+ *
+ * 模块级单例 + init 注入 db：callLLM 拿不到 db（db 在 index.ts 运行时创建），
+ * 故通过 initTokenCost(db, retentionDays) 在插件启动时注入；recordCostCall 每次调用写一行明细。
+ *
+ * 与作者 llm-usage.ts 的关系：作者是"按 layer 累计的纯内存计数器"（给 bench 用）；
+ * 本模块补上三个缺口——按 model 分组、持久化（保留期可配置，默认 365 天）、面向 UI 成本看板。
+ */
+import type { CostSnapshot, Granularity } from './contract.js';
+import type { DistillLayer } from './llm-usage.js';
+import type { MemoryDb } from './store/sqlite.js';
+export type { CostWindow, Granularity, ModelMetrics, LayerMetrics, LayerWindow, LayerCost, TrendBucket, TrendSnapshot, CostSnapshot, } from './contract.js';
+/** 插件启动时注入 db 与明细保留期（index.ts 调用；retentionDays 0 = 永久保留）。 */
+export declare function initTokenCost(d: MemoryDb, retention: number): void;
+/** 插件卸载时清空 db 引用（index.ts 的 ctx.effect 清理里调用，防悬空引用）。 */
+export declare function resetTokenCost(): void;
+/** 记录一次蒸馏调用成本（callLLM 出口调用；provider/model 由调用方传入）。 */
+export declare function recordCostCall(provider: string, model: string, layer: DistillLayer, inputChars: number, outputTokens: number, reasoningTokens: number): void;
+/** 读成本看板快照（db 未注入/降级时返回全零结构，不抛错；rangeDays>0 = 趋势展示近 N 天）。 */
+export declare function snapshotTokenCost(granularity: Granularity, rangeDays: number): CostSnapshot;

package/dist/token-cost.js

@@ -0,0 +1,178 @@
+let db = null;
+let retentionDays = 365;
+/** 插件启动时注入 db 与明细保留期（index.ts 调用；retentionDays 0 = 永久保留）。 */
+export function initTokenCost(d, retention) {
+    db = d;
+    retentionDays = Math.max(0, Math.round(retention));
+}
+/** 插件卸载时清空 db 引用（index.ts 的 ctx.effect 清理里调用，防悬空引用）。 */
+export function resetTokenCost() {
+    db = null;
+}
+/** 记录一次蒸馏调用成本（callLLM 出口调用；provider/model 由调用方传入）。 */
+export function recordCostCall(provider, model, layer, inputChars, outputTokens, reasoningTokens) {
+    if (!db)
+        return;
+    db.insertCostCall(provider, model, layer, inputChars, outputTokens, reasoningTokens, retentionDays);
+}
+/** 四窗口定义：range + 回看毫秒数（all 的 ms 恒 0）。 */
+const WINDOW_DEFS = [
+    { range: 'day', ms: 24 * 3600_000 },
+    { range: 'week', ms: 7 * 24 * 3600_000 },
+    { range: 'month', ms: 30 * 24 * 3600_000 },
+    { range: 'all', ms: 0 },
+];
+/** 趋势桶宽（毫秒）与桶数。 */
+const TREND_MS = { day: 24 * 3600_000, week: 7 * 24 * 3600_000, month: 30 * 24 * 3600_000 };
+const TREND_COUNT = { day: 30, week: 12, month: 12 };
+/** 三个归并层级。 */
+const LAYERS = ['l1', 'l2', 'l3'];
+/** 本地时区偏移（东正西负）：把 SQL 端 UTC epoch 桶边界对齐到本地午夜。 */
+function localOffsetMs() {
+    return -new Date().getTimezoneOffset() * 60_000;
+}
+/** 已排序序列的中位数（偶数取中间两者平均；空返回 0）。 */
+function medianOf(sorted) {
+    const n = sorted.length;
+    if (n === 0)
+        return 0;
+    const mid = Math.floor(n / 2);
+    return n % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/** provider/model 复合键（避免跨 provider 同名 model 在聚合里混淆）。 */
+function modelKey(provider, model) {
+    return provider + '/' + model;
+}
+/** 从某模型某粒度的 bucket 序列算均值/中位数（活跃桶口径：只除有调用的桶数）。 */
+function statOf(rows) {
+    const active = rows.filter((r) => r.calls > 0);
+    if (active.length === 0)
+        return { avgCalls: 0, avgOutput: 0, medianOutput: 0 };
+    const calls = active.reduce((s, r) => s + r.calls, 0);
+    const output = active.reduce((s, r) => s + r.outputTokens, 0);
+    return {
+        avgCalls: calls / active.length,
+        avgOutput: output / active.length,
+        medianOutput: medianOf(active.map((r) => r.outputTokens).sort((a, b) => a - b)),
+    };
+}
+/** 从 day/week/month 三组 bucket 行组装每个模型的统计指标（provider/model 复合键）。 */
+function buildModelMetrics(dayRows, weekRows, monthRows) {
+    const keys = new Set();
+    for (const r of dayRows)
+        keys.add(modelKey(r.provider, r.model));
+    for (const r of weekRows)
+        keys.add(modelKey(r.provider, r.model));
+    for (const r of monthRows)
+        keys.add(modelKey(r.provider, r.model));
+    return Array.from(keys)
+        .sort()
+        .map((key) => {
+        const d = statOf(dayRows.filter((r) => modelKey(r.provider, r.model) === key));
+        const w = statOf(weekRows.filter((r) => modelKey(r.provider, r.model) === key));
+        const m = statOf(monthRows.filter((r) => modelKey(r.provider, r.model) === key));
+        return {
+            model: key,
+            dayCalls: d.avgCalls,
+            weekCalls: w.avgCalls,
+            monthCalls: m.avgCalls,
+            dayOutput: d.avgOutput,
+            dayMedian: d.medianOutput,
+            weekOutput: w.avgOutput,
+            weekMedian: w.medianOutput,
+            monthOutput: m.avgOutput,
+            monthMedian: m.medianOutput,
+        };
+    });
+}
+/** 从某层级某粒度的 bucket 行生成连续趋势桶（空桶补 0；count 为桶数，由调用方按展示范围算）。 */
+function buildTrend(rows, granularity, now, count) {
+    const bucketMs = TREND_MS[granularity];
+    const offset = localOffsetMs();
+    const cur = Math.floor((now + offset) / bucketMs);
+    const buckets = [];
+    for (let i = count - 1; i >= 0; i--) {
+        const b = cur - i;
+        buckets.push({ ts: b * bucketMs - offset, total: 0, byModel: {} });
+    }
+    for (const r of rows) {
+        const idx = count - 1 - (cur - r.bucket);
+        if (idx < 0 || idx >= count)
+            continue;
+        const tb = buckets[idx];
+        tb.total += r.outputTokens;
+        const key = modelKey(r.provider, r.model);
+        tb.byModel[key] = (tb.byModel[key] ?? 0) + r.outputTokens;
+    }
+    return buckets;
+}
+/** 读成本看板快照（db 未注入/降级时返回全零结构，不抛错；rangeDays>0 = 趋势展示近 N 天）。 */
+export function snapshotTokenCost(granularity, rangeDays) {
+    const now = Date.now();
+    const emptyWindow = (range, ms) => ({
+        range,
+        since: ms === 0 ? 0 : now - ms,
+        calls: 0,
+        inputChars: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+        avgOutputTokens: 0,
+        medianOutputTokens: 0,
+    });
+    if (!db) {
+        return {
+            windows: WINDOW_DEFS.map((w) => emptyWindow(w.range, w.ms)),
+            byModel: [],
+            byLayer: [],
+            byLayerStats: [],
+            trend: { granularity, byLayer: { l1: [], l2: [], l3: [] } },
+        };
+    }
+    // 四窗口总聚合（累计窗口顺带取 byModel）
+    const d = db;
+    const windows = [];
+    let byModel = [];
+    for (const w of WINDOW_DEFS) {
+        const since = w.ms === 0 ? 0 : now - w.ms;
+        const agg = d.aggregateCost(since);
+        windows.push({ range: w.range, since, ...agg.total });
+        if (w.range === 'all')
+            byModel = agg.byModel;
+    }
+    // 按层级 × 窗口聚合（层级×窗口表格）：每个窗口调一次 aggregateCostByLayer，再按层组装
+    const layerByWindow = WINDOW_DEFS.map((w) => {
+        const since = w.ms === 0 ? 0 : now - w.ms;
+        return { range: w.range, rows: d.aggregateCostByLayer(since) };
+    });
+    const byLayer = LAYERS.map((layer) => ({
+        layer,
+        windows: layerByWindow.map(({ range, rows }) => {
+            const row = rows.find((r) => r.layer === layer);
+            return {
+                range,
+                calls: row?.calls ?? 0,
+                inputChars: row?.inputChars ?? 0,
+                outputTokens: row?.outputTokens ?? 0,
+                reasoningTokens: row?.reasoningTokens ?? 0,
+                avgOutputTokens: row?.avgOutputTokens ?? 0,
+                medianOutputTokens: row?.medianOutputTokens ?? 0,
+            };
+        }),
+    }));
+    // 每层级模型统计（全量历史口径）+ 趋势（按展示范围）
+    const offset = localOffsetMs();
+    const byLayerStats = [];
+    const trendByLayer = { l1: [], l2: [], l3: [] };
+    // 趋势展示范围：rangeDays > 0 = 近 N 天（强制按「日」粒度出 N 个日桶，不受周/月聚合影响）；否则用默认窗口
+    const trendGranularity = rangeDays > 0 ? 'day' : granularity;
+    const trendSince = rangeDays > 0 ? now - rangeDays * 24 * 3600_000 : 0;
+    const trendCount = rangeDays > 0 ? rangeDays : TREND_COUNT[granularity];
+    for (const layer of LAYERS) {
+        const dayRows = d.aggregateByBucket(TREND_MS.day, offset, 0, layer);
+        const weekRows = d.aggregateByBucket(TREND_MS.week, offset, 0, layer);
+        const monthRows = d.aggregateByBucket(TREND_MS.month, offset, 0, layer);
+        byLayerStats.push({ layer, models: buildModelMetrics(dayRows, weekRows, monthRows) });
+        trendByLayer[layer] = buildTrend(d.aggregateByBucket(TREND_MS[trendGranularity], offset, trendSince, layer), trendGranularity, now, trendCount);
+    }
+    return { windows, byModel, byLayer, byLayerStats, trend: { granularity: trendGranularity, byLayer: trendByLayer } };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",
@@ -31,9 +31,11 @@
     "cordis.patch.yml"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-client.mjs",
-    "smoke": "node dist-smoke/smoke.js",
-    "verify-catalog": "npm run build && node scripts/verify-catalog.mjs"
+    "build": "tsc -p tsconfig.json && node scripts/build-client.mjs && node scripts/copy-client.mjs",
+    "smoke": "npm run build:smoke && node dist-smoke/smoke.js",
+    "verify-catalog": "npm run build && node scripts/verify-catalog.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "build:smoke": "tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution nodenext --target es2022 --strict --skipLibCheck --esModuleInterop"
   },
   "engines": {
     "node": ">=22.16.0"
@@ -78,6 +80,8 @@
     "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
     "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
     "@types/node": "^22.0.0",
+    "@types/react": "^19.2.18",
+    "esbuild": "^0.28.2",
     "typescript": "^5.6.0"
   }
 }