autosnippet 3.2.16 → 3.2.18

package/dist/lib/service/search/CrossEncoderReranker.d.ts

@@ -26,11 +26,6 @@ interface RerankCandidate {
 }
 export declare class CrossEncoderReranker {
     #private;
-    /**
-     * @param {object} opts
-     * @param {import('../../external/ai/AiProvider.js').AiProvider} opts.aiProvider
-     * @param {object} [opts.logger]
-     */
     constructor(opts?: {
         aiProvider?: {
             chatWithStructuredOutput: (prompt: string, opts: Record<string, unknown>) => Promise<unknown>;
@@ -42,9 +37,9 @@ export declare class CrossEncoderReranker {
     /**
      * 对候选列表进行语义重排
      *
-     * @param {string} query 用户查询
-     * @param {Array<object>} candidates - Layer 1 输出的候选列表
-     * @returns {Promise<Array<object>>} 附带 semanticScore 的候选列表（降序）
+     * @param query 用户查询
+     * @param candidates Layer 1 输出的候选列表
+     * @returns 附带 semanticScore 的候选列表（降序）
      */
     rerank(query: string, candidates: RerankCandidate[]): Promise<RerankCandidate[] | {
         semanticScore: any;
@@ -57,4 +52,3 @@ export declare class CrossEncoderReranker {
     }[]>;
 }
 export {};
-//# sourceMappingURL=CrossEncoderReranker.d.ts.map

package/dist/lib/service/search/CrossEncoderReranker.js

@@ -21,11 +21,6 @@ const MAX_DOC_LEN = 300; // 每个文档最大字符数
 export class CrossEncoderReranker {
     #aiProvider;
     #logger;
-    /**
-     * @param {object} opts
-     * @param {import('../../external/ai/AiProvider.js').AiProvider} opts.aiProvider
-     * @param {object} [opts.logger]
-     */
     constructor(opts = {}) {
         this.#aiProvider = opts.aiProvider || null;
         this.#logger = opts.logger || console;
@@ -33,9 +28,9 @@ export class CrossEncoderReranker {
     /**
      * 对候选列表进行语义重排
      *
-     * @param {string} query 用户查询
-     * @param {Array<object>} candidates - Layer 1 输出的候选列表
-     * @returns {Promise<Array<object>>} 附带 semanticScore 的候选列表（降序）
+     * @param query 用户查询
+     * @param candidates Layer 1 输出的候选列表
+     * @returns 附带 semanticScore 的候选列表（降序）
      */
     async rerank(query, candidates) {
         if (!candidates || candidates.length === 0) {
@@ -68,9 +63,7 @@ export class CrossEncoderReranker {
             return this.#jaccardFallback(query, candidates);
         }
     }
-    /**
-     * 批量 AI 评分 — 单次 chatWithStructuredOutput 调用
-     */
+    /** 批量 AI 评分 — 单次 chatWithStructuredOutput 调用 */
     async #batchScore(query, candidates) {
         const pairs = candidates.map((c, i) => {
             const doc = this.#extractDocText(c);
@@ -124,9 +117,7 @@ Return ONLY a JSON array, no markdown or explanation.`;
         }))
             .sort((a, b) => b.semanticScore - a.semanticScore);
     }
-    /**
-     * 从候选对象提取用于评分的文本表示
-     */
+    /** 从候选对象提取用于评分的文本表示 */
     #extractDocText(candidate) {
         const parts = [
             candidate.title,
@@ -137,9 +128,7 @@ Return ONLY a JSON array, no markdown or explanation.`;
         ].filter(Boolean);
         return parts.join(' | ');
     }
-    /**
-     * Jaccard 降级 — 当 AI 不可用时使用
-     */
+    /** Jaccard 降级 — 当 AI 不可用时使用 */
     #jaccardFallback(query, candidates) {
         const queryTokens = new Set(tokenize(query));
         if (queryTokens.size === 0) {
@@ -155,4 +144,3 @@ Return ONLY a JSON array, no markdown or explanation.`;
             .sort((a, b) => b.semanticScore - a.semanticScore);
     }
 }
-//# sourceMappingURL=CrossEncoderReranker.js.map

package/dist/lib/service/search/HybridRetriever.d.ts

@@ -23,10 +23,8 @@ interface RetrievalResult {
 export declare class HybridRetriever {
     #private;
     /**
-     * @param {object} options
-     * @param {import('../../infrastructure/vector/VectorStore.js').VectorStore} options.vectorStore
-     * @param {number} [options.rrfK=60] - RRF 常数 (k), 值越大越平滑
-     * @param {number} [options.alpha=0.5] - Dense 权重 (1-alpha = Sparse 权重)
+     * @param [options.rrfK=60] RRF 常数 (k), 值越大越平滑
+     * @param [options.alpha=0.5] Dense 权重 (1-alpha = Sparse 权重)
      */
     constructor(options?: {
         vectorStore?: {
@@ -44,12 +42,10 @@ export declare class HybridRetriever {
      * Dense: vectorStore 向量搜索 (HNSW or brute-force)
      * Sparse: BM25 关键词搜索 (由外部传入结果)
      *
-     * @param {object} params
      * @param {Array<{ id: string, score: number, [key: string]: unknown }>} params.denseResults - 向量搜索结果
      * @param {Array<{ id: string, score: number, [key: string]: unknown }>} params.sparseResults - 关键词搜索结果
-     * @param {number} [params.topK=10]
-     * @param {number} [params.alpha=0.5] - Dense 权重
-     * @returns {Array<{ id: string, score: number, rrfScore: number, denseRank: number, sparseRank: number, data: object }>}
+     * @param [params.alpha=0.5] Dense 权重
+     * @returns >}
      */
     fuse({ denseResults, sparseResults, topK, alpha, }: {
         denseResults?: RetrievalResult[] | undefined;
@@ -60,14 +56,9 @@ export declare class HybridRetriever {
     /**
      * 完整搜索: 同时执行 Dense + Sparse 并融合
      *
-     * @param {string} query - 查询文本
-     * @param {number[]} queryVector - 查询向量
-     * @param {object} [options]
-     * @param {number} [options.topK=10]
-     * @param {number} [options.alpha=0.5]
-     * @param {object} [options.filter]
-     * @param {function} [options.sparseSearchFn] - 外部 sparse 搜索函数 (query, limit) => results[]
-     * @returns {Promise<Array>}
+     * @param query 查询文本
+     * @param queryVector 查询向量
+     * @param [options.sparseSearchFn] 外部 sparse 搜索函数 (query, limit) => results[]
      */
     search(query: string, queryVector: number[] | null, options?: {
         topK?: number;
@@ -77,4 +68,3 @@ export declare class HybridRetriever {
     }): Promise<any[]>;
 }
 export {};
-//# sourceMappingURL=HybridRetriever.d.ts.map

package/dist/lib/service/search/HybridRetriever.js

@@ -17,10 +17,8 @@ export class HybridRetriever {
     #rrfK;
     #defaultAlpha;
     /**
-     * @param {object} options
-     * @param {import('../../infrastructure/vector/VectorStore.js').VectorStore} options.vectorStore
-     * @param {number} [options.rrfK=60] - RRF 常数 (k), 值越大越平滑
-     * @param {number} [options.alpha=0.5] - Dense 权重 (1-alpha = Sparse 权重)
+     * @param [options.rrfK=60] RRF 常数 (k), 值越大越平滑
+     * @param [options.alpha=0.5] Dense 权重 (1-alpha = Sparse 权重)
      */
     constructor(options = {}) {
         this.#vectorStore = options.vectorStore || null;
@@ -33,12 +31,10 @@ export class HybridRetriever {
      * Dense: vectorStore 向量搜索 (HNSW or brute-force)
      * Sparse: BM25 关键词搜索 (由外部传入结果)
      *
-     * @param {object} params
      * @param {Array<{ id: string, score: number, [key: string]: unknown }>} params.denseResults - 向量搜索结果
      * @param {Array<{ id: string, score: number, [key: string]: unknown }>} params.sparseResults - 关键词搜索结果
-     * @param {number} [params.topK=10]
-     * @param {number} [params.alpha=0.5] - Dense 权重
-     * @returns {Array<{ id: string, score: number, rrfScore: number, denseRank: number, sparseRank: number, data: object }>}
+     * @param [params.alpha=0.5] Dense 权重
+     * @returns >}
      */
     fuse({ denseResults = [], sparseResults = [], topK = 10, alpha = 0.5, }) {
         const k = this.#rrfK;
@@ -93,14 +89,9 @@ export class HybridRetriever {
     /**
      * 完整搜索: 同时执行 Dense + Sparse 并融合
      *
-     * @param {string} query - 查询文本
-     * @param {number[]} queryVector - 查询向量
-     * @param {object} [options]
-     * @param {number} [options.topK=10]
-     * @param {number} [options.alpha=0.5]
-     * @param {object} [options.filter]
-     * @param {function} [options.sparseSearchFn] - 外部 sparse 搜索函数 (query, limit) => results[]
-     * @returns {Promise<Array>}
+     * @param query 查询文本
+     * @param queryVector 查询向量
+     * @param [options.sparseSearchFn] 外部 sparse 搜索函数 (query, limit) => results[]
      */
     async search(query, queryVector, options = {}) {
         const { topK = 10, alpha = this.#defaultAlpha, filter = null, sparseSearchFn = null } = options;
@@ -120,4 +111,3 @@ export class HybridRetriever {
         });
     }
 }
-//# sourceMappingURL=HybridRetriever.js.map

package/dist/lib/service/search/MultiSignalRanker.d.ts

@@ -32,21 +32,15 @@ interface SignalContext {
     tags?: string[];
     [key: string]: unknown;
 }
-/**
- * 相关性信号 — BM25 + 标题匹配 + 内容匹配
- */
+/** 相关性信号 — BM25 + 标题匹配 + 内容匹配 */
 export declare class RelevanceSignal {
     compute(candidate: SignalCandidate, context: SignalContext): number;
 }
-/**
- * 权威性信号 — 基于质量评分、使用次数、作者
- */
+/** 权威性信号 — 基于质量评分、使用次数、作者 */
 export declare class AuthoritySignal {
     compute(candidate: SignalCandidate): number;
 }
-/**
- * 时间衰减信号
- */
+/** 时间衰减信号 */
 export declare class RecencySignal {
     compute(candidate: SignalCandidate): number;
 }
@@ -57,9 +51,7 @@ export declare class RecencySignal {
 export declare class PopularitySignal {
     compute(candidate: SignalCandidate): number;
 }
-/**
- * 难度信号 — 用于学习场景的难度匹配
- */
+/** 难度信号 — 用于学习场景的难度匹配 */
 export declare class DifficultySignal {
     compute(candidate: SignalCandidate, context: SignalContext): number;
 }
@@ -77,9 +69,7 @@ export declare class ContextMatchSignal {
 export declare class VectorSignal {
     compute(candidate: SignalCandidate, _context: SignalContext): number;
 }
-/**
- * MultiSignalRanker — 多信号排序引擎
- */
+/** MultiSignalRanker — 多信号排序引擎 */
 export declare class MultiSignalRanker {
     #private;
     constructor(options?: {
@@ -87,9 +77,8 @@ export declare class MultiSignalRanker {
     });
     /**
      * 对候选列表进行多信号加权排序
-     * @param {Array} candidates
-     * @param {object} context - { query, scenario, language, userLevel, ... }
-     * @returns {Array} - sorted candidates with rankerScore
+     * @param context { query, scenario, language, userLevel, ... }
+     * @returns sorted candidates with rankerScore
      */
     rank(candidates: SignalCandidate[], context?: SignalContext): {
         rankerScore: number;
@@ -113,4 +102,3 @@ export declare class MultiSignalRanker {
     }[];
 }
 export {};
-//# sourceMappingURL=MultiSignalRanker.d.ts.map

package/dist/lib/service/search/MultiSignalRanker.js

@@ -51,9 +51,7 @@ const SCENARIO_WEIGHTS = {
         vector: 0.2,
     },
 };
-/**
- * 相关性信号 — BM25 + 标题匹配 + 内容匹配
- */
+/** 相关性信号 — BM25 + 标题匹配 + 内容匹配 */
 export class RelevanceSignal {
     compute(candidate, context) {
         let score = candidate.bm25Score || candidate.score || 0;
@@ -83,9 +81,7 @@ export class RelevanceSignal {
         return Math.min(score, 1.0);
     }
 }
-/**
- * 权威性信号 — 基于质量评分、使用次数、作者
- */
+/** 权威性信号 — 基于质量评分、使用次数、作者 */
 export class AuthoritySignal {
     compute(candidate) {
         let score = 0;
@@ -101,9 +97,7 @@ export class AuthoritySignal {
         return Math.min(score || 0.5, 1.0);
     }
 }
-/**
- * 时间衰减信号
- */
+/** 时间衰减信号 */
 export class RecencySignal {
     compute(candidate) {
         const updated = candidate.updatedAt || candidate.lastModified || candidate.createdAt;
@@ -139,9 +133,7 @@ export class PopularitySignal {
         return Math.min(Math.log10(usage + 1) / 3, 1.0);
     }
 }
-/**
- * 难度信号 — 用于学习场景的难度匹配
- */
+/** 难度信号 — 用于学习场景的难度匹配 */
 export class DifficultySignal {
     compute(candidate, context) {
         const levels = { beginner: 1, intermediate: 2, advanced: 3, expert: 4 };
@@ -213,9 +205,7 @@ export class VectorSignal {
         return 0;
     }
 }
-/**
- * MultiSignalRanker — 多信号排序引擎
- */
+/** MultiSignalRanker — 多信号排序引擎 */
 export class MultiSignalRanker {
     #signals;
     #scenarioWeights;
@@ -243,9 +233,8 @@ export class MultiSignalRanker {
     }
     /**
      * 对候选列表进行多信号加权排序
-     * @param {Array} candidates
-     * @param {object} context - { query, scenario, language, userLevel, ... }
-     * @returns {Array} - sorted candidates with rankerScore
+     * @param context { query, scenario, language, userLevel, ... }
+     * @returns sorted candidates with rankerScore
      */
     rank(candidates, context = {}) {
         if (!candidates || candidates.length === 0) {
@@ -273,4 +262,3 @@ export class MultiSignalRanker {
         return scored.sort((a, b) => b.rankerScore - a.rankerScore);
     }
 }
-//# sourceMappingURL=MultiSignalRanker.js.map

package/dist/lib/service/search/SearchEngine.d.ts

@@ -40,18 +40,14 @@ export declare class SearchEngine {
     constructor(db: SearchDb & {
         getDb?: () => SearchDb;
     }, options?: SearchEngineOptions);
-    /**
-     * 构建搜索索引 - 从数据库加载所有可搜索实体
-     */
+    /** 构建搜索索引 - 从数据库加载所有可搜索实体 */
     buildIndex(): void;
-    /**
-     * 确保索引已构建（幂等），supply 给需要准确 stats 的调用方
-     */
+    /** 确保索引已构建（幂等），supply 给需要准确 stats 的调用方 */
     ensureIndex(): void;
     /**
      * 统一搜索入口
-     * @param {string} query 搜索关键词
-     * @param {object} options - {type, limit, mode, useAI}
+     * @param query 搜索关键词
+     * @param options {type, limit, mode, useAI}
      */
     search(query: string, options?: SearchOptions): Promise<SearchResponse>;
     /**
@@ -113,7 +109,7 @@ export declare class SearchEngine {
     /**
      * 语义搜索 - 需要 AI Provider 的 embed 功能
      * 降级到 BM25 如果 AI 不可用
-     * @returns {Promise<{ items: Array, actualMode: string }>}
+     * @returns >}
      */
     _semanticSearch(query: string, type: string, limit: number): Promise<{
         items: SearchResultItem[];
@@ -169,9 +165,7 @@ export declare class SearchEngine {
         authorityScore: number;
         qualityScore: number;
     };
-    /**
-     * 获取索引统计（如果尚未构建索引，自动触发构建）
-     */
+    /** 获取索引统计（如果尚未构建索引，自动触发构建） */
     getStats(): {
         indexed: boolean;
         totalDocuments: number;
@@ -186,4 +180,3 @@ export declare class SearchEngine {
     _setCache(key: string, data: SearchResponse): void;
 }
 export default SearchEngine;
-//# sourceMappingURL=SearchEngine.d.ts.map

package/dist/lib/service/search/SearchEngine.js

@@ -52,9 +52,7 @@ export class SearchEngine {
         this._fusionBm25Weight = options.fusionBm25Weight ?? 0.6;
         this._fusionSemanticWeight = options.fusionSemanticWeight ?? 0.4;
     }
-    /**
-     * 构建搜索索引 - 从数据库加载所有可搜索实体
-     */
+    /** 构建搜索索引 - 从数据库加载所有可搜索实体 */
     buildIndex() {
         this.scorer.clear();
         this._cache.clear();
@@ -92,9 +90,7 @@ export class SearchEngine {
             this.logger.error('Failed to build search index', { error: err.message });
         }
     }
-    /**
-     * 确保索引已构建（幂等），supply 给需要准确 stats 的调用方
-     */
+    /** 确保索引已构建（幂等），supply 给需要准确 stats 的调用方 */
     ensureIndex() {
         if (!this._indexed) {
             this.buildIndex();
@@ -102,8 +98,8 @@ export class SearchEngine {
     }
     /**
      * 统一搜索入口
-     * @param {string} query 搜索关键词
-     * @param {object} options - {type, limit, mode, useAI}
+     * @param query 搜索关键词
+     * @param options {type, limit, mode, useAI}
      */
     async search(query, options = {}) {
         const { type = 'all', limit = 20, mode = 'keyword', context } = options;
@@ -427,7 +423,7 @@ export class SearchEngine {
     /**
      * 语义搜索 - 需要 AI Provider 的 embed 功能
      * 降级到 BM25 如果 AI 不可用
-     * @returns {Promise<{ items: Array, actualMode: string }>}
+     * @returns >}
      */
     async _semanticSearch(query, type, limit) {
         // 优先使用 VectorService (统一向量服务层)
@@ -780,9 +776,7 @@ export class SearchEngine {
             qualityScore: qualityOverall,
         };
     }
-    /**
-     * 获取索引统计（如果尚未构建索引，自动触发构建）
-     */
+    /** 获取索引统计（如果尚未构建索引，自动触发构建） */
     getStats() {
         return {
             indexed: this._indexed,
@@ -825,4 +819,3 @@ export class SearchEngine {
     }
 }
 export default SearchEngine;
-//# sourceMappingURL=SearchEngine.js.map

package/dist/lib/service/search/SearchTypes.d.ts

@@ -221,9 +221,7 @@ export interface SlimSearchResult {
  * @returns 瘦身后的结果项
  */
 export declare function slimSearchResult(item: SearchResultItem): SlimSearchResult;
-/**
- * items → byKind 分组（统一实现）
- */
+/** items → byKind 分组（统一实现） */
 export declare function groupByKind<T extends {
     kind?: string;
 }>(items: T[]): {
@@ -255,4 +253,3 @@ export interface SearchVectorService {
         [key: string]: unknown;
     }>>;
 }
-//# sourceMappingURL=SearchTypes.d.ts.map

package/dist/lib/service/search/SearchTypes.js

@@ -35,9 +35,7 @@ export function slimSearchResult(item) {
         knowledgeType: item.knowledgeType || undefined,
     };
 }
-/**
- * items → byKind 分组（统一实现）
- */
+/** items → byKind 分组（统一实现） */
 export function groupByKind(items) {
     const byKind = { rule: [], pattern: [], fact: [] };
     for (const it of items) {
@@ -47,4 +45,3 @@ export function groupByKind(items) {
     }
     return byKind;
 }
-//# sourceMappingURL=SearchTypes.js.map

package/dist/lib/service/search/contextBoost.d.ts

@@ -10,11 +10,9 @@
  * @module contextBoost
  */
 /**
- * @param {Array} items  - 已排序的候选列表（需有 rankerScore / coarseScore / score）
- * @param {object} context
+ * @param items 已排序的候选列表（需有 rankerScore / coarseScore / score）
  * @param {Array<{content?: string, rawInput?: string}>} [context.sessionHistory]
- * @param {string} [context.language]
- * @returns {Array} - 含 contextScore / contextBoost 字段的排序列表
+ * @returns 含 contextScore / contextBoost 字段的排序列表
  */
 export interface SearchItem {
     title?: string;
@@ -44,4 +42,3 @@ export declare function contextBoost(items: SearchItem[], context?: SearchContex
     coarseScore?: number;
     score?: number;
 }[];
-//# sourceMappingURL=contextBoost.d.ts.map

package/dist/lib/service/search/contextBoost.js

@@ -42,4 +42,3 @@ export function contextBoost(items, context = {}) {
     })
         .sort((a, b) => b.contextScore - a.contextScore);
 }
-//# sourceMappingURL=contextBoost.js.map

package/dist/lib/service/search/tokenizer.d.ts

@@ -15,4 +15,3 @@ export declare const BM25_B = 0.75;
  * 中文: bigram + 完整片段 — 停用词级别单字被过滤，无需分词词典即可支持子串匹配
  */
 export declare function tokenize(text: string): string[];
-//# sourceMappingURL=tokenizer.d.ts.map

package/dist/lib/service/search/tokenizer.js

@@ -101,9 +101,7 @@ const CJK_STOPWORDS = new Set([
     '该',
     '应',
 ]);
-/**
- * 英文停用词表 — 过滤常见虚词
- */
+/** 英文停用词表 — 过滤常见虚词 */
 const EN_STOPWORDS = new Set([
     'the',
     'is',
@@ -212,4 +210,3 @@ export function tokenize(text) {
     }
     return [...new Set(tokens)];
 }
-//# sourceMappingURL=tokenizer.js.map

package/dist/lib/service/skills/AIRecallStrategy.d.ts

@@ -21,10 +21,7 @@ export declare class AIRecallStrategy implements RecallStrategy {
     constructor(signalCollector: SignalCollectorLike | null);
     recall(context: RecommendationContext): Promise<RecommendationCandidate[]>;
     isAvailable(context: RecommendationContext): boolean;
-    /**
-     * 更新 SignalCollector 引用 (用于延迟注入)
-     */
+    /** 更新 SignalCollector 引用 (用于延迟注入) */
     setSignalCollector(sc: SignalCollectorLike): void;
 }
 export default AIRecallStrategy;
-//# sourceMappingURL=AIRecallStrategy.d.ts.map

package/dist/lib/service/skills/AIRecallStrategy.js

@@ -40,12 +40,9 @@ export class AIRecallStrategy {
         // AI 策略只在 suggest/auto 模式下可用
         return mode === 'suggest' || mode === 'auto';
     }
-    /**
-     * 更新 SignalCollector 引用 (用于延迟注入)
-     */
+    /** 更新 SignalCollector 引用 (用于延迟注入) */
     setSignalCollector(sc) {
         this.#signalCollector = sc;
     }
 }
 export default AIRecallStrategy;
-//# sourceMappingURL=AIRecallStrategy.js.map

package/dist/lib/service/skills/EventAggregator.d.ts

@@ -20,10 +20,9 @@
 export declare class EventAggregator {
     #private;
     /**
-     * @param {object} [opts]
-     * @param {number} [opts.windowMs=5000]    聚合时间窗口（毫秒）
-     * @param {number} [opts.maxBatch=50]      单次 batch 最大事件数
-     * @param {number} [opts.dedupeMs=60000]   相同事件去重窗口（毫秒）
+     * @param [opts.windowMs=5000] 聚合时间窗口（毫秒）
+     * @param [opts.maxBatch=50] 单次 batch 最大事件数
+     * @param [opts.dedupeMs=60000] 相同事件去重窗口（毫秒）
      */
     constructor({ windowMs, maxBatch, dedupeMs, }?: {
         windowMs?: number | undefined;
@@ -32,32 +31,20 @@ export declare class EventAggregator {
     });
     /**
      * 推送一个事件到聚合器
-     * @param {string} key 聚合键（如 'file_change', 'guard_violation'）
-     * @param {object} event 事件数据
-     * @param {object} [opts]
-     * @param {string} [opts.dedupeId] 去重标识（默认为 JSON hash）
+     * @param key 聚合键（如 'file_change', 'guard_violation'）
+     * @param event 事件数据
+     * @param [opts.dedupeId] 去重标识（默认为 JSON hash）
      */
     push(key: string, event: Record<string, unknown>, { dedupeId }?: {
         dedupeId?: string;
     }): void;
-    /**
-     * 注册 batch 事件监听器
-     * @param {'batch'} eventName
-     * @param {(key: string, events: Record<string, unknown>[]) => void} fn
-     */
+    /** 注册 batch 事件监听器 */
     on(eventName: string, fn: (key: string, events: Record<string, unknown>[]) => void): void;
-    /**
-     * 立即刷新所有待处理 bucket
-     */
+    /** 立即刷新所有待处理 bucket */
     flushAll(): void;
-    /**
-     * 停止所有计时器
-     */
+    /** 停止所有计时器 */
     destroy(): void;
-    /**
-     * 获取待处理事件数
-     */
+    /** 获取待处理事件数 */
     get pendingCount(): number;
 }
 export default EventAggregator;
-//# sourceMappingURL=EventAggregator.d.ts.map

package/dist/lib/service/skills/EventAggregator.js

@@ -32,10 +32,9 @@ export class EventAggregator {
     #dedupeMs;
     #logger;
     /**
-     * @param {object} [opts]
-     * @param {number} [opts.windowMs=5000]    聚合时间窗口（毫秒）
-     * @param {number} [opts.maxBatch=50]      单次 batch 最大事件数
-     * @param {number} [opts.dedupeMs=60000]   相同事件去重窗口（毫秒）
+     * @param [opts.windowMs=5000] 聚合时间窗口（毫秒）
+     * @param [opts.maxBatch=50] 单次 batch 最大事件数
+     * @param [opts.dedupeMs=60000] 相同事件去重窗口（毫秒）
      */
     constructor({ windowMs = DEFAULT_WINDOW_MS, maxBatch = DEFAULT_MAX_BATCH, dedupeMs = DEFAULT_DEDUPE_MS, } = {}) {
         this.#windowMs = windowMs;
@@ -45,10 +44,9 @@ export class EventAggregator {
     }
     /**
      * 推送一个事件到聚合器
-     * @param {string} key 聚合键（如 'file_change', 'guard_violation'）
-     * @param {object} event 事件数据
-     * @param {object} [opts]
-     * @param {string} [opts.dedupeId] 去重标识（默认为 JSON hash）
+     * @param key 聚合键（如 'file_change', 'guard_violation'）
+     * @param event 事件数据
+     * @param [opts.dedupeId] 去重标识（默认为 JSON hash）
      */
     push(key, event, { dedupeId } = {}) {
         // 去重检查
@@ -75,28 +73,20 @@ export class EventAggregator {
         }
         bucket.timer = setTimeout(() => this.#flush(key), this.#windowMs);
     }
-    /**
-     * 注册 batch 事件监听器
-     * @param {'batch'} eventName
-     * @param {(key: string, events: Record<string, unknown>[]) => void} fn
-     */
+    /** 注册 batch 事件监听器 */
     on(eventName, fn) {
         if (!this.#listeners.has(eventName)) {
             this.#listeners.set(eventName, []);
         }
         this.#listeners.get(eventName).push(fn);
     }
-    /**
-     * 立即刷新所有待处理 bucket
-     */
+    /** 立即刷新所有待处理 bucket */
     flushAll() {
         for (const key of this.#buckets.keys()) {
             this.#flush(key);
         }
     }
-    /**
-     * 停止所有计时器
-     */
+    /** 停止所有计时器 */
     destroy() {
         for (const [, bucket] of this.#buckets) {
             if (bucket.timer) {
@@ -107,9 +97,7 @@ export class EventAggregator {
         this.#dedupeMap.clear();
         this.#listeners.clear();
     }
-    /**
-     * 获取待处理事件数
-     */
+    /** 获取待处理事件数 */
     get pendingCount() {
         let count = 0;
         for (const [, bucket] of this.#buckets) {
@@ -175,4 +163,3 @@ export class EventAggregator {
     }
 }
 export default EventAggregator;
-//# sourceMappingURL=EventAggregator.js.map