dsh-layered-memory 0.8.8 → 0.8.10

package/dist/store/occupancy.js

@@ -0,0 +1,134 @@
+/**
+ * 记忆占用流水存储：sessionId → OccupancyLedger 的持久化映射。
+ *
+ * 动机（2026-08-27 票07）：占用账本是进程内存态，dsh 重启后历史会话"窗口里明明
+ * 有记忆、账面却为零"，指示器对重启前注入的存量失明。本存储让账目跨进程复生：
+ * - 每次账本迁移后写穿（recall-dedupe 同款：串行化原子写 + 失败降级内存态）；
+ * - 查询热路径仍是同步内存读——文件只在迁移时刻与启动载入时触碰；
+ * - stock 归零的条目不落盘（compaction 复位即天然删除）；
+ * - agent 销毁不删记录（持久化语义与召回去重一致：会话恢复后账目继续）；
+ * - 90 天未更新过期清理 + 会话条目上限（session-modes/dedupe 同款量级）。
+ */
+import * as path from 'node:path';
+import { errDetail } from '../util/filelog.js';
+import { atomicWriteJson, ensureDir, readJsonIfExists } from './io.js';
+/** 会话条目上限（按 updatedAt 淘汰最旧；防文件无限增长）。 */
+export const OCCUPANCY_SESSION_CAP = 200;
+/** 条目过期清理（90 天未更新即丢弃，与 session-modes/dedupe 同款量级）。 */
+const PRUNE_MS = 90 * 24 * 3600_000;
+export class OccupancyStore {
+    logger;
+    file;
+    entries = new Map();
+    persistFailed = false;
+    /** 串行化持久化写（避免并发原子写撞临时文件名）；init 链最前（先载入再落盘，防丢更新）。 */
+    writeChain;
+    constructor(dataDir, logger) {
+        this.logger = logger;
+        this.file = path.join(dataDir, 'occupancy.json');
+        this.writeChain = this.init();
+    }
+    /** 载入持久化账目（合并进内存——构造与载入之间发生的 save 不丢）；失败降级内存态。 */
+    async init() {
+        const data = await readJsonIfExists(this.file);
+        if (!data?.sessions || typeof data.sessions !== 'object')
+            return;
+        const now = Date.now();
+        let count = 0;
+        for (const [sid, entry] of Object.entries(data.sessions)) {
+            if (typeof entry?.stockTokens !== 'number')
+                continue;
+            if (now - (entry.updatedAt ?? 0) > PRUNE_MS)
+                continue;
+            const existing = this.entries.get(sid);
+            if (existing) {
+                if (entry.updatedAt > existing.updatedAt)
+                    this.entries.set(sid, { ...entry });
+            }
+            else {
+                this.entries.set(sid, { ...entry });
+            }
+            count++;
+        }
+        if (count > 0)
+            this.logger?.info(`[memory] 记忆占用账目载入 ${count} 个会话`);
+    }
+    /**
+     * 该会话的持久化账目（热路径同步读；从未注入/已复位返回 null）。
+     * 返回**浅拷贝**——调用方（ledgerFor 复生）会在其上做迁移；若交出内部引用，
+     * 原地修改会让 save() 的 prev/ledger 恒等比较误判“数值未变”而跳过写穿（实测踩坑）。
+     */
+    load(sessionId) {
+        const e = this.entries.get(sessionId);
+        return e ? { ...e } : null;
+    }
+    /**
+     * 迁移后写穿。数值未变只刷新内存时间戳不落盘（profile 稳定区每次请求组装都
+     * 触发迁移，但内容不变时不应产生文件写）；stock 归零即删除条目。
+     */
+    save(sessionId, ledger) {
+        const prev = this.entries.get(sessionId);
+        const sameNumbers = prev !== undefined &&
+            prev.stockTokens === ledger.stockTokens &&
+            prev.recallTokens === ledger.recallTokens &&
+            prev.profileTokens === ledger.profileTokens &&
+            prev.lastInjectTokens === ledger.lastInjectTokens;
+        if (sameNumbers) {
+            prev.updatedAt = ledger.updatedAt;
+            return;
+        }
+        if (ledger.stockTokens <= 0) {
+            if (prev === undefined)
+                return;
+            this.entries.delete(sessionId);
+        }
+        else {
+            this.entries.set(sessionId, { ...ledger });
+        }
+        this.writeChain = this.writeChain.then(() => this.persist());
+    }
+    /** 等待在途持久化写完成（测试/停机用）。 */
+    flush() {
+        return this.writeChain;
+    }
+    async persist() {
+        try {
+            await ensureDir(path.dirname(this.file));
+            await atomicWriteJson(this.file, this.serialize());
+            this.persistFailed = false;
+        }
+        catch (err) {
+            if (!this.persistFailed) {
+                this.persistFailed = true;
+                this.logger?.warn(`[memory] 记忆占用持久化失败（降级内存态）: ${errDetail(err)}`);
+            }
+        }
+    }
+    serialize() {
+        const now = Date.now();
+        for (const [sid, e] of this.entries) {
+            if (now - e.updatedAt > PRUNE_MS && e.updatedAt > 0)
+                this.entries.delete(sid);
+        }
+        while (this.entries.size > OCCUPANCY_SESSION_CAP) {
+            let oldest;
+            let oldestAt = Infinity;
+            for (const [sid, e] of this.entries) {
+                if (e.updatedAt > 0 && e.updatedAt < oldestAt) {
+                    oldest = sid;
+                    oldestAt = e.updatedAt;
+                }
+            }
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+        const sessions = {};
+        for (const [sid, e] of this.entries) {
+            if (e.stockTokens <= 0)
+                continue; // 归零条目不落盘
+            sessions[sid] = { ...e };
+        }
+        return { version: 1, sessions };
+    }
+}

package/dist/store/session-modes.d.ts

@@ -17,6 +17,13 @@ export declare class SessionModeStore {
     get default(): MemoryMode;
     /** 同步读取：未设置过的会话返回默认档。 */
     get(sessionId: string): MemoryMode;
+    /** 会话级注入覆盖原始值（#38）：undefined = 未覆盖，跟随全局。 */
+    getRecall(sessionId: string): boolean | undefined;
+    /** 解析后的注入开关：会话覆盖 ?? 全局运行时开关（部署级 cfg.recall.enabled
+     *  与主闸 s.enabled 不经此处，仍按既有硬门生效——覆盖打不穿部署上限）。 */
+    resolvedRecall(sessionId: string, globalRecall: boolean): boolean;
+    /** 设置会话级注入覆盖（#38；undefined = 清除覆盖跟随全局。写穿持久化）。 */
+    setRecall(sessionId: string, recall: boolean | undefined): void;
     /** 注册档位切换回调（同步调用；回调异常只记日志不阻断写穿）。 */
     setModeChangeHandler(cb: (sessionId: string, oldMode: MemoryMode, newMode: MemoryMode) => void): void;
     /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */

package/dist/store/session-modes.js

@@ -42,7 +42,12 @@ export class SessionModeStore {
                 continue;
             if (now - (entry.updatedAt ?? 0) > PRUNE_MS)
                 continue;
-            this.entries.set(sid, { mode: entry.mode, updatedAt: entry.updatedAt ?? now });
+            this.entries.set(sid, {
+                mode: entry.mode,
+                // 非布尔视为损坏丢弃（= 跟随全局）；旧文件无此键同款兼容
+                recall: typeof entry.recall === 'boolean' ? entry.recall : undefined,
+                updatedAt: entry.updatedAt ?? now,
+            });
             count++;
         }
         if (count > 0)
@@ -55,6 +60,25 @@ export class SessionModeStore {
     get(sessionId) {
         return this.entries.get(sessionId)?.mode ?? this.loaded;
     }
+    /** 会话级注入覆盖原始值（#38）：undefined = 未覆盖，跟随全局。 */
+    getRecall(sessionId) {
+        return this.entries.get(sessionId)?.recall;
+    }
+    /** 解析后的注入开关：会话覆盖 ?? 全局运行时开关（部署级 cfg.recall.enabled
+     *  与主闸 s.enabled 不经此处，仍按既有硬门生效——覆盖打不穿部署上限）。 */
+    resolvedRecall(sessionId, globalRecall) {
+        return this.entries.get(sessionId)?.recall ?? globalRecall;
+    }
+    /** 设置会话级注入覆盖（#38；undefined = 清除覆盖跟随全局。写穿持久化）。 */
+    setRecall(sessionId, recall) {
+        const entry = this.entries.get(sessionId);
+        this.entries.set(sessionId, {
+            mode: entry?.mode ?? this.loaded,
+            recall,
+            updatedAt: Date.now(),
+        });
+        this.writeChain = this.writeChain.then(() => this.persist());
+    }
     /** 注册档位切换回调（同步调用；回调异常只记日志不阻断写穿）。 */
     setModeChangeHandler(cb) {
         this.onModeChange = cb;
@@ -62,7 +86,9 @@ export class SessionModeStore {
     /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */
     set(sessionId, mode) {
         const old = this.get(sessionId);
-        this.entries.set(sessionId, { mode, updatedAt: Date.now() });
+        // 已有注入覆盖跨切档保留（#38：档位与注入正交，切档不动覆盖）
+        const recall = this.entries.get(sessionId)?.recall;
+        this.entries.set(sessionId, { mode, recall, updatedAt: Date.now() });
         this.writeChain = this.writeChain.then(() => this.persist());
         if (old !== mode && this.onModeChange) {
             try {

package/dist/tools/index.d.ts

@@ -4,9 +4,12 @@
  * 会话档位联动：execute 的 exec.agent 即发起调用的 agent（agent.id === sessionId），
  * memory_search 按会话档位过滤族（auto 不过滤，纯档只查本族）；off 档下三工具统一
  * 返回提示（本会话已对记忆系统隐身）。conversation_search 检索范围保持全库。
+ * 只写会话（#38：注入覆盖=关）同款拒读，notice 区分文案——写入走捕获钩子不经工具，
+ * 拒读不影响"只写"语义。
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { MemoryConfig } from '../config.js';
+import type { LiveSettingsHandle } from '../settings.js';
 import type { L0Store } from '../store/l0.js';
 import type { L1Store } from '../store/l1.js';
 import type { PersonaStore } from '../store/persona.js';
@@ -18,4 +21,4 @@ export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, sto
     l1: L1Store;
     scenes: Record<MemoryFamily, SceneStore>;
     persona: Record<MemoryFamily, PersonaStore>;
-}, logger: MemoryLogger, modes: SessionModeStore): void;
+}, logger: MemoryLogger, modes: SessionModeStore, live: LiveSettingsHandle): void;

package/dist/tools/index.js

@@ -1,10 +1,12 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 const OFF_NOTICE = '本会话的记忆档位为"关闭"：该会话对记忆系统完全隐身，不读取也不写入记忆。';
-export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
+const WRITE_ONLY_NOTICE = '本会话为只写模式：记忆照常沉淀，但不读取。';
+const GLOBAL_OFF_NOTICE = '记忆注入已全局停用：本会话不读取记忆（沉淀照常）。';
+export function registerMemoryTools(ctx, cfg, stores, logger, modes, live) {
     if (!cfg.tools)
         return;
     /**
-     * 调用会话的检索族（auto → undefined 不过滤；off → null 表示整体禁用）。
+     * 调用会话的检索族（auto → undefined 不过滤；off/只写 → null 表示整体禁用）。
      * fail-open：exec.agent 缺失（宿主调用路径未带 agent 标识）按全族检索放行——
      * 档位隔离依赖宿主正确传递 exec.agent.id，缺失只告警一次不拒绝工具调用。
      */
@@ -20,8 +22,24 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         const mode = modes.get(agentId);
         if (mode === 'off')
             return null;
+        // 只写会话拒读（#38，T2 裁决）：与注入同属读维度，不拒则"不注入"从工具路径漏风
+        if (!modes.resolvedRecall(agentId, live.get().recall))
+            return null;
         return mode === 'auto' ? undefined : mode;
     };
+    /** 拒读时的归因文案（familyOfCaller 判 null 后重查内存 Map，成本可忽略）：
+     *  off 完全隐身 / 会话只写覆盖 / 全局召回关——三种停用各说各话，不谎报只写。 */
+    const blockNoticeOf = (agentId) => {
+        if (agentId !== undefined) {
+            if (modes.get(agentId) === 'off')
+                return OFF_NOTICE;
+            if (modes.getRecall(agentId) === false)
+                return WRITE_ONLY_NOTICE;
+            if (!modes.resolvedRecall(agentId, live.get().recall))
+                return GLOBAL_OFF_NOTICE;
+        }
+        return OFF_NOTICE;
+    };
     // ── memory_search: L1 结构化记忆 ──
     ctx.tools.register(defineTool({
         name: 'memory_search',
@@ -59,7 +77,7 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         execute: async (args, exec) => {
             const family = familyOfCaller(exec.agent?.id);
             if (family === null)
-                return { items: [], notice: OFF_NOTICE };
+                return { items: [], notice: blockNoticeOf(exec.agent?.id) };
             const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
             const hits = await stores.l1.search(args.query, limit, { type: args.type || undefined, family: family ?? undefined });
             return {
@@ -107,7 +125,7 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         },
         execute: async (args, exec) => {
             if (familyOfCaller(exec.agent?.id) === null)
-                return { items: [], notice: OFF_NOTICE };
+                return { items: [], notice: blockNoticeOf(exec.agent?.id) };
             const limit = Math.min(Math.max(args.limit ?? 5, 1), 20);
             const records = await stores.l0.search(args.query, limit);
             return {
@@ -141,7 +159,7 @@ export function registerMemoryTools(ctx, cfg, stores, logger, modes) {
         },
         execute: async (args, exec) => {
             if (familyOfCaller(exec.agent?.id) === null)
-                return { content: OFF_NOTICE };
+                return { content: blockNoticeOf(exec.agent?.id) };
             const p = args.path.trim();
             let content;
             if (p === 'persona.md' || p === 'persona-chat.md' || p === 'persona' || p === 'persona-chat') {

package/dist/util/context-occupancy.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 上下文占用账本：插件注入内容在当前会话上下文窗口中的启发式 token 存量。
+ *
+ * 本模块是全部占用数字的**唯一算术来源**（host 记账与 client 渲染共用，esbuild
+ * 将其内联进 client bundle），任何一侧不得另写算法。口径与官方
+ * @deepseek-ai/dsh-token-meter/estimate 的固定密度启发式同式：
+ *
+ *   - text 块 = ceil(chars / 4) + 4（块开销）；
+ *   - 整条 user 消息（召回注入体的形态）再叠加 role overhead 4；
+ *   - 系统提示里的稳定区**子片**计入时不加任何 overhead——那 +8 是官方对整段
+ *     消息/整体系统提示的结构成本，切片重复计会与官方总数对不上；
+ *   - 字符数一律 JS `.length`（UTF-16 单元），与官方产出严格可比。
+ */
+/** 固定文本密度：每 4 字符记 1 token（官方 CHARS_PER_TOKEN 同值）。 */
+export declare const CHARS_PER_TOKEN = 4;
+/** 召回注入体（单 text 块 user message）的启发式 token 数。 */
+export declare function estimateInjectedMessageTokens(chars: number): number;
+/** 稳定区子片的启发式 token 数（不加结构开销，见模块头注释）。 */
+export declare function estimateStableSectionTokens(chars: number): number;
+/**
+ * 单会话占用账本（权威账本只存在于 host 侧；client 仅消费展示）。
+ * stockTokens = recallTokens + profileTokens 恒等式由三个迁移函数共同维护。
+ */
+export interface OccupancyLedger {
+    /** 当前估算仍在上下文窗口内的记忆存量（token）。 */
+    stockTokens: number;
+    /** 累计召回注入存留份额。 */
+    recallTokens: number;
+    /** 系统提示稳定区当前份额（OFF 使 text() 返回空时即时清零）。 */
+    profileTokens: number;
+    /** 最近一轮召回注入的增量（悬浮卡/面板"最近一次"语义）。 */
+    lastInjectTokens: number;
+    updatedAt: number;
+}
+export declare function emptyOccupancyLedger(now?: number): OccupancyLedger;
+/** 召回注入成功后的入账（失败跳过的轮次不调用——账目零扰动）。 */
+export declare function recordRecallInjection(l: OccupancyLedger, chars: number, now?: number): void;
+/**
+ * 稳定区份额随每次实际组进的文本同步（含切回非 OFF 的重新计入）：
+ * 增量记账保证重复调用不双算，清零后重设即可净额回补。
+ */
+export declare function recordProfileShare(l: OccupancyLedger, chars: number, now?: number): void;
+/** OFF 边界：稳定区随下一次请求组装物理离场，账目同边界清零（宁低勿高）。 */
+export declare function clearProfileShare(l: OccupancyLedger, now?: number): void;
+/**
+ * compaction 复位：v1 采用"清零重新累积"的低估近似——被压缩掉的注入以整数轮粒度
+ * 退出账本，幸存的摘要行不重复认领（已知限制，方向宁低勿高；事件级精确对齐留待 v2）。
+ */
+export declare function resetForCompaction(l: OccupancyLedger, now?: number): void;
+/**
+ * 官方上下文环周长：viewBox 14 内 r=5.5 圆（2π×5.5 ≈ 34.55751918948772），
+ * 与真机反推的官方 fill dasharray 分母逐字一致。
+ */
+export declare const CONTEXT_METER_CIRCUMFERENCE = 34.55751918948772;
+/**
+ * 光晕弧 stroke-dasharray：形状沿用官方 fill（len + 全周长 gap）。
+ * @param occupancyRatio 占窗口比 0..1（越界钳制）。
+ * @param minLen 最小可见弧长（单位=-viewBox 坐标；14px 渲染下 <1 单位即亚像素不可见，
+ *  真实占比常低至 0.6%≈0.2 单位——指示灯语义需要"存在即可见"，精确数字归面板）。
+ */
+export declare function haloDashArray(occupancyRatio: number, circumference?: number, minLen?: number): string;
+/** 官方环触发按钮的结构签名（locale 无关定位依据；见组件设计 C1 锚点节）。 */
+export interface ContextMeterAnchorSignature {
+    ariaHasPopup?: string | null;
+    viewBox?: string | null;
+    circleRadii?: ReadonlyArray<number>;
+}
+export declare function isContextMeterAnchor(sig: ContextMeterAnchorSignature): boolean;

package/dist/util/context-occupancy.js

@@ -0,0 +1,92 @@
+/**
+ * 上下文占用账本：插件注入内容在当前会话上下文窗口中的启发式 token 存量。
+ *
+ * 本模块是全部占用数字的**唯一算术来源**（host 记账与 client 渲染共用，esbuild
+ * 将其内联进 client bundle），任何一侧不得另写算法。口径与官方
+ * @deepseek-ai/dsh-token-meter/estimate 的固定密度启发式同式：
+ *
+ *   - text 块 = ceil(chars / 4) + 4（块开销）；
+ *   - 整条 user 消息（召回注入体的形态）再叠加 role overhead 4；
+ *   - 系统提示里的稳定区**子片**计入时不加任何 overhead——那 +8 是官方对整段
+ *     消息/整体系统提示的结构成本，切片重复计会与官方总数对不上；
+ *   - 字符数一律 JS `.length`（UTF-16 单元），与官方产出严格可比。
+ */
+/** 固定文本密度：每 4 字符记 1 token（官方 CHARS_PER_TOKEN 同值）。 */
+export const CHARS_PER_TOKEN = 4;
+const BLOCK_OVERHEAD = 4;
+const ROLE_OVERHEAD = 4;
+/** 召回注入体（单 text 块 user message）的启发式 token 数。 */
+export function estimateInjectedMessageTokens(chars) {
+    return Math.ceil(chars / CHARS_PER_TOKEN) + BLOCK_OVERHEAD + ROLE_OVERHEAD;
+}
+/** 稳定区子片的启发式 token 数（不加结构开销，见模块头注释）。 */
+export function estimateStableSectionTokens(chars) {
+    return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+export function emptyOccupancyLedger(now = Date.now()) {
+    return { stockTokens: 0, recallTokens: 0, profileTokens: 0, lastInjectTokens: 0, updatedAt: now };
+}
+/** 召回注入成功后的入账（失败跳过的轮次不调用——账目零扰动）。 */
+export function recordRecallInjection(l, chars, now = Date.now()) {
+    const tokens = estimateInjectedMessageTokens(chars);
+    l.recallTokens += tokens;
+    l.stockTokens += tokens;
+    l.lastInjectTokens = tokens;
+    l.updatedAt = now;
+}
+/**
+ * 稳定区份额随每次实际组进的文本同步（含切回非 OFF 的重新计入）：
+ * 增量记账保证重复调用不双算，清零后重设即可净额回补。
+ */
+export function recordProfileShare(l, chars, now = Date.now()) {
+    const tokens = estimateStableSectionTokens(chars);
+    l.stockTokens += tokens - l.profileTokens;
+    l.profileTokens = tokens;
+    l.updatedAt = now;
+}
+/** OFF 边界：稳定区随下一次请求组装物理离场，账目同边界清零（宁低勿高）。 */
+export function clearProfileShare(l, now = Date.now()) {
+    l.stockTokens -= l.profileTokens;
+    l.profileTokens = 0;
+    l.updatedAt = now;
+}
+/**
+ * compaction 复位：v1 采用"清零重新累积"的低估近似——被压缩掉的注入以整数轮粒度
+ * 退出账本，幸存的摘要行不重复认领（已知限制，方向宁低勿高；事件级精确对齐留待 v2）。
+ */
+export function resetForCompaction(l, now = Date.now()) {
+    l.stockTokens = 0;
+    l.recallTokens = 0;
+    l.profileTokens = 0;
+    l.lastInjectTokens = 0;
+    l.updatedAt = now;
+}
+/* ── 渲染侧纯函数（client 寄生组件用；宿主 smoke 一并断言，数字唯一来源在此） ── */
+/**
+ * 官方上下文环周长：viewBox 14 内 r=5.5 圆（2π×5.5 ≈ 34.55751918948772），
+ * 与真机反推的官方 fill dasharray 分母逐字一致。
+ */
+export const CONTEXT_METER_CIRCUMFERENCE = 34.55751918948772;
+/**
+ * 光晕弧 stroke-dasharray：形状沿用官方 fill（len + 全周长 gap）。
+ * @param occupancyRatio 占窗口比 0..1（越界钳制）。
+ * @param minLen 最小可见弧长（单位=-viewBox 坐标；14px 渲染下 <1 单位即亚像素不可见，
+ *  真实占比常低至 0.6%≈0.2 单位——指示灯语义需要"存在即可见"，精确数字归面板）。
+ */
+export function haloDashArray(occupancyRatio, circumference = CONTEXT_METER_CIRCUMFERENCE, minLen = 0) {
+    const clamped = Number.isFinite(occupancyRatio) ? Math.min(1, Math.max(0, occupancyRatio)) : 0;
+    const len = Math.max(clamped * circumference, clamped > 0 ? minLen : 0);
+    return `${len} ${circumference}`;
+}
+/** 半径比对容差：吞掉渲染库对属性值的无害浮点噪声。 */
+const RADIUS_EPSILON = 1e-6;
+export function isContextMeterAnchor(sig) {
+    if (sig.ariaHasPopup !== 'dialog')
+        return false;
+    if (sig.viewBox !== '0 0 14 14')
+        return false;
+    const radii = sig.circleRadii;
+    if (!Array.isArray(radii) || radii.length !== 2)
+        return false;
+    return radii.every((r) => Math.abs(r - 5.5) < RADIUS_EPSILON);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",