@qimen-lab/core 0.1.1

package/dist/task/hash-task/hash/HashTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashTask.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/hash/HashTask.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAa,MAAM,UAAU,CAAC;AACpD,OAAO,EAAoB,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAI5E,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;GAIG;AACH,KAAK,gBAAgB,GAAG,CAAC,QAAQ,EAAE,oBAAoB,KAAK,IAAI,CAAC;AAEjE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B,qCAAqC;IACrC,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC;IACtE,yBAAyB;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,6BAA6B;IAC7B,aAAa,EAAE,aAAa,CAAC;IAC7B,yBAAyB;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,QAAQ;IAkBL,OAAO,CAAC,QAAQ,CAAC,OAAO;IAjBpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IAExC,OAAO,CAAC,iBAAiB,CAA+B;IACxD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAsB;IAE1C;;;;;;OAMG;gBAC0B,OAAO,EAAE,eAAe;IAgBrD;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACH,MAAM,IAAI,IAAI;IAId;;;;OAIG;IACH,MAAM,IAAI,IAAI;IAId;;;;;;OAMG;IACH,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC;IAI9B;;;;;;;OAOG;IACH,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,IAAI;IAKlD;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;CAkB/B"}

package/dist/task/hash-task/hash/HashTask.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashTask = void 0;
+const HashTaskProgress_1 = require("./HashTaskProgress");
+const HashTaskRunner_1 = require("./HashTaskRunner");
+const HashTaskState_1 = require("./HashTaskState");
+const HashTaskResources_1 = require("./HashTaskResources");
+/**
+ * 哈希任务类
+ *
+ * 用于处理大文件或数据流的哈希计算任务，支持进度监控、暂停/恢复/取消操作
+ *
+ * 设计原则：
+ * - 仅负责任务的生命周期管理
+ * - 串联各个组件（State, Progress, Resources, Runner）
+ * - 提供统一的外部接口
+ *
+ * 明确不负责：
+ * - 不执行具体的哈希计算（由Runner和Worker负责）
+ * - 不管理内存（由MemoryManager负责）
+ * - 不调度Worker（由WorkerPool负责）
+ *
+ * @example
+ * ```ts
+ * const task = new HashTask({
+ *   algorithm: 'sha256',
+ *   chunkProvider: new FileChunkProvider(file),
+ *   memoryManager: new MemoryManager(),
+ *   workerPool: new BrowserWorkerPool(),
+ * });
+ *
+ * task.onProgress((snapshot) => {
+ *   console.log(`Progress: ${snapshot.percentage}%`);
+ * });
+ *
+ * task.start();
+ * const result = await task.result();
+ * ```
+ */
+class HashTask {
+    /**
+     * 构造函数
+     *
+     * 初始化哈希任务的各项组件和状态
+     *
+     * @param options 哈希任务配置选项
+     */
+    constructor(options) {
+        this.options = options;
+        this.state = new HashTaskState_1.HashTaskState();
+        this.progress = new HashTaskProgress_1.HashTaskProgress();
+        this.progressListeners = new Set();
+        this.state = new HashTaskState_1.HashTaskState();
+        this.progress = new HashTaskProgress_1.HashTaskProgress();
+        const totalSize = options.chunkProvider.getTotalSize();
+        this.progress.init(totalSize);
+        this.resources = new HashTaskResources_1.HashTaskResources(options.memoryManager, options.workerPool);
+        this.runner = new HashTaskRunner_1.HashTaskRunner(this.state, this.progress, this.resources, options);
+        this.resultPromise = new Promise((resolve, reject) => {
+            this.resolveResult = resolve;
+            this.rejectResult = reject;
+        });
+    }
+    /**
+     * 启动任务
+     *
+     * 开始执行哈希计算任务，并启动进度轮询机制
+     */
+    async start() {
+        try {
+            const result = await this.runner.run();
+            this.resolveResult(result);
+        }
+        catch (err) {
+            // 这里的处理逻辑会立刻被测试捕获
+            this.rejectResult(err);
+            // 如果需要让外部也感知到错误，可以继续 throw
+            throw err;
+        }
+        finally {
+            this.startProgressPolling();
+        }
+    }
+    /**
+     * 暂停任务
+     *
+     * 暂停当前正在执行的哈希计算任务
+     */
+    pause() {
+        this.runner.pause();
+    }
+    /**
+     * 恢复任务
+     *
+     * 恢复之前暂停的哈希计算任务
+     */
+    resume() {
+        this.runner.resume();
+    }
+    /**
+     * 取消任务
+     *
+     * 取消当前正在执行的哈希计算任务
+     */
+    cancel() {
+        this.runner.cancel();
+    }
+    /**
+     * 获取最终 hash 结果
+     *
+     * 返回一个Promise，当任务完成时包含哈希计算结果
+     *
+     * @returns 包含哈希结果的Promise
+     */
+    result() {
+        return this.resultPromise;
+    }
+    /**
+     * 订阅进度
+     *
+     * 添加进度监听器，当任务进度更新时会调用监听器
+     *
+     * @param listener 进度监听器函数
+     * @returns 用于取消监听的函数
+     */
+    onProgress(listener) {
+        this.progressListeners.add(listener);
+        return () => this.progressListeners.delete(listener);
+    }
+    /**
+     * 轮询推送进度（简单稳定）
+     *
+     * 启动一个定时器，定期向所有进度监听器发送进度更新
+     *
+     * @private
+     */
+    startProgressPolling() {
+        const tick = () => {
+            if (this.state.value === 'completed' ||
+                this.state.value === 'failed' ||
+                this.state.value === 'cancelled') {
+                return;
+            }
+            const snapshot = this.progress.snapshot();
+            this.progressListeners.forEach(fn => fn(snapshot));
+            setTimeout(tick, 200);
+        };
+        tick();
+    }
+}
+exports.HashTask = HashTask;
+//# sourceMappingURL=HashTask.js.map

package/dist/task/hash-task/hash/HashTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashTask.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/hash/HashTask.ts"],"names":[],"mappings":"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"}

package/dist/task/hash-task/hash/HashTaskHealthMonitor.d.ts

@@ -0,0 +1,124 @@
+import { HashTaskState } from './HashTaskState';
+import { HashTaskProgress } from './HashTaskProgress';
+import { HashTaskResources } from './HashTaskResources';
+/**
+ * 健康事件联合类型
+ *
+ * 定义了任务健康监控可能检测到的各种事件
+ */
+export type HealthEvent = {
+    /** 任务卡死事件 */
+    type: 'stalled';
+    /** 卡死持续时间（毫秒） */
+    durationMs: number;
+} | {
+    /** Worker无响应事件 */
+    type: 'worker_unresponsive';
+} | {
+    /** 资源泄漏事件 */
+    type: 'resource_leak';
+};
+/**
+ * 健康事件监听器类型
+ *
+ * 定义了处理健康事件的回调函数类型
+ */
+type HealthListener = (event: HealthEvent) => void;
+/**
+ * 健康监控选项接口
+ *
+ * 定义了健康监控的配置选项
+ */
+export interface HealthMonitorOptions {
+    /** 多久未推进进度视为卡死，默认为10秒 */
+    stallThresholdMs?: number;
+    /** 轮询间隔，默认为1秒 */
+    intervalMs?: number;
+}
+/**
+ * HashTaskHealthMonitor类
+ *
+ * 该类只负责监控与判断：
+ * - 是否长时间无进展
+ * - Worker 是否假活着
+ * - 内存是否未释放
+ * - 是否触发 fail-fast
+ *
+ * 明确不负责：
+ * - 不直接取消任务
+ * - 不直接重试
+ * - 不处理UI
+ * - 不做日志聚合
+ *
+ * 它只发出"健康事件"。
+ *
+ * 设计原则：
+ * - 只负责监控和判断
+ * - 不直接干预任务执行
+ * - 通过事件机制通知外部
+ */
+export declare class HashTaskHealthMonitor {
+    private readonly state;
+    private readonly progress;
+    private readonly resources;
+    private listeners;
+    private timer?;
+    private lastProgressBytes;
+    private lastProgressTime;
+    private readonly stallThresholdMs;
+    private readonly intervalMs;
+    /**
+     * 构造函数
+     *
+     * @param state 任务状态管理器
+     * @param progress 任务进度管理器
+     * @param resources 任务资源管理器
+     * @param options 健康监控选项
+     */
+    constructor(state: HashTaskState, progress: HashTaskProgress, resources: HashTaskResources, options?: HealthMonitorOptions);
+    /**
+     * 开始健康监控
+     *
+     * 启动定时器，定期检查任务健康状态
+     *
+     * 检查包括：
+     * - 任务进度是否卡死
+     * - Worker是否无响应
+     * - 资源是否泄漏
+     */
+    start(): void;
+    /**
+     * 停止健康监控
+     *
+     * 清除定时器，停止健康检查
+     */
+    stop(): void;
+    /**
+     * 添加健康事件监听器
+     *
+     * @param listener 健康事件监听器
+     * @returns 用于移除监听器的函数
+     */
+    onEvent(listener: HealthListener): () => void;
+    /**
+     * 触发健康事件
+     *
+     * @param event 健康事件
+     * @private
+     */
+    private emit;
+    /**
+     * 执行健康检查
+     *
+     * 检查任务进度是否卡死、资源是否泄漏等情况
+     *
+     * 检查内容包括：
+     * 1. 进度卡死检测：检查任务是否在stallThresholdMs时间内无进展
+     * 2. 资源泄漏检测：检查任务结束后资源是否被正确释放
+     *
+     * @private
+     */
+    private check;
+}
+export {};
+//# sourceMappingURL=HashTaskHealthMonitor.d.ts.map

package/dist/task/hash-task/hash/HashTaskHealthMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashTaskHealthMonitor.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/hash/HashTaskHealthMonitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACjB;IACI,aAAa;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,iBAAiB;IACjB,UAAU,EAAE,MAAM,CAAC;CACtB,GACD;IACI,kBAAkB;IAClB,IAAI,EAAE,qBAAqB,CAAC;CAC/B,GACD;IACI,aAAa;IACb,IAAI,EAAE,eAAe,CAAC;CACzB,CAAC;AAER;;;;GAIG;AACH,KAAK,cAAc,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC,yBAAyB;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,qBAAqB;IAmB1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IApB9B,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,KAAK,CAAC,CAAiB;IAE/B,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,gBAAgB,CAAc;IAEtC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC;;;;;;;OAOG;gBAEkB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,iBAAiB,EAC7C,OAAO,GAAE,oBAAyB;IAMtC;;;;;;;;;OASG;IACH,KAAK,IAAI,IAAI;IAMb;;;;OAIG;IACH,IAAI,IAAI,IAAI;IAOZ;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,IAAI;IAK7C;;;;;OAKG;IACH,OAAO,CAAC,IAAI;IAIZ;;;;;;;;;;OAUG;IACH,OAAO,CAAC,KAAK;CAkChB"}

package/dist/task/hash-task/hash/HashTaskHealthMonitor.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashTaskHealthMonitor = void 0;
+/**
+ * HashTaskHealthMonitor类
+ *
+ * 该类只负责监控与判断：
+ * - 是否长时间无进展
+ * - Worker 是否假活着
+ * - 内存是否未释放
+ * - 是否触发 fail-fast
+ *
+ * 明确不负责：
+ * - 不直接取消任务
+ * - 不直接重试
+ * - 不处理UI
+ * - 不做日志聚合
+ *
+ * 它只发出"健康事件"。
+ *
+ * 设计原则：
+ * - 只负责监控和判断
+ * - 不直接干预任务执行
+ * - 通过事件机制通知外部
+ */
+class HashTaskHealthMonitor {
+    /**
+     * 构造函数
+     *
+     * @param state 任务状态管理器
+     * @param progress 任务进度管理器
+     * @param resources 任务资源管理器
+     * @param options 健康监控选项
+     */
+    constructor(state, progress, resources, options = {}) {
+        var _a, _b;
+        this.state = state;
+        this.progress = progress;
+        this.resources = resources;
+        this.listeners = new Set();
+        this.lastProgressBytes = 0;
+        this.lastProgressTime = Date.now();
+        this.stallThresholdMs = (_a = options.stallThresholdMs) !== null && _a !== void 0 ? _a : 10000;
+        this.intervalMs = (_b = options.intervalMs) !== null && _b !== void 0 ? _b : 1000;
+    }
+    /**
+     * 开始健康监控
+     *
+     * 启动定时器，定期检查任务健康状态
+     *
+     * 检查包括：
+     * - 任务进度是否卡死
+     * - Worker是否无响应
+     * - 资源是否泄漏
+     */
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => this.check(), this.intervalMs);
+    }
+    /**
+     * 停止健康监控
+     *
+     * 清除定时器，停止健康检查
+     */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    /**
+     * 添加健康事件监听器
+     *
+     * @param listener 健康事件监听器
+     * @returns 用于移除监听器的函数
+     */
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * 触发健康事件
+     *
+     * @param event 健康事件
+     * @private
+     */
+    emit(event) {
+        this.listeners.forEach(fn => fn(event));
+    }
+    /**
+     * 执行健康检查
+     *
+     * 检查任务进度是否卡死、资源是否泄漏等情况
+     *
+     * 检查内容包括：
+     * 1. 进度卡死检测：检查任务是否在stallThresholdMs时间内无进展
+     * 2. 资源泄漏检测：检查任务结束后资源是否被正确释放
+     *
+     * @private
+     */
+    check() {
+        const now = Date.now();
+        const stateValue = this.state.value;
+        const progressSnap = this.progress.snapshot();
+        const resourceSnap = this.resources.snapshot();
+        // ===== 1. 检测进度卡死 =====
+        if (stateValue === 'running') {
+            if (progressSnap.processedBytes !== this.lastProgressBytes) {
+                this.lastProgressBytes = progressSnap.processedBytes;
+                this.lastProgressTime = now;
+            }
+            else {
+                const stalledFor = now - this.lastProgressTime;
+                if (stalledFor > this.stallThresholdMs) {
+                    this.emit({ type: 'stalled', durationMs: stalledFor });
+                    if (resourceSnap.hasWorker) {
+                        this.emit({ type: 'worker_unresponsive' });
+                    }
+                    // 防止重复刷事件
+                    this.lastProgressTime = now;
+                }
+            }
+        }
+        // ===== 2. 检测资源泄漏 =====
+        if ((stateValue === 'completed' || stateValue === 'failed' || stateValue === 'cancelled') &&
+            resourceSnap.hasWorker) {
+            this.emit({ type: 'resource_leak' });
+        }
+    }
+}
+exports.HashTaskHealthMonitor = HashTaskHealthMonitor;
+//# sourceMappingURL=HashTaskHealthMonitor.js.map

package/dist/task/hash-task/hash/HashTaskHealthMonitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashTaskHealthMonitor.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/hash/HashTaskHealthMonitor.ts"],"names":[],"mappings":"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"}

package/dist/task/hash-task/hash/HashTaskProgress.d.ts

@@ -0,0 +1,71 @@
+/**
+ * HashTaskProgress 只负责 4 件事：
+ * - 记录总量（如果已知）
+ * - 累计已处理量
+ * - 计算进度百分比
+ * - 生成稳定 snapshot
+ *
+ * 明确不负责：
+ * - 不关心 chunk 怎么来
+ * - 不关心 hash 算法
+ * - 不关心 worker
+ * - 不判断状态是否合法（那是 State 的事）
+ */
+/**
+ * 任务进度快照接口
+ *
+ * 定义了任务进度的快照信息
+ */
+export interface TaskProgressSnapshot {
+    /** 进度百分比，范围为0到1，如果总量未知则为 undefined */
+    progress?: number;
+    /** 已处理的字节数 */
+    processedBytes: number;
+    /** 总字节数（如果已知） */
+    totalBytes?: number;
+    /** 已处理的块数 */
+    processedChunks: number;
+}
+/**
+ * 哈希任务进度管理类
+ *
+ * 负责跟踪和管理哈希任务的执行进度
+ *
+ * 设计原则：
+ * - 仅负责进度跟踪和快照生成
+ * - 不关心数据块的来源
+ * - 不关心哈希算法的实现
+ * - 不管理Worker或任务状态
+ */
+export declare class HashTaskProgress {
+    private processedBytes;
+    private processedChunks;
+    private totalBytes?;
+    /**
+     * 初始化进度（可选总量）
+     *
+     * @param totalBytes 总字节数，可选参数
+     */
+    init(totalBytes?: number): void;
+    /**
+     * 处理数据块，更新进度
+     *
+     * 该方法会更新已处理的块数和字节数
+     *
+     * @param chunk 要处理的数据块，包含字节数信息
+     */
+    onChunk(chunk: {
+        data: {
+            byteLength: number;
+        };
+    }): void;
+    /**
+     * 生成只读快照
+     *
+     * 计算当前进度百分比并返回进度快照
+     *
+     * @returns 任务进度快照
+     */
+    snapshot(): TaskProgressSnapshot;
+}
+//# sourceMappingURL=HashTaskProgress.d.ts.map

package/dist/task/hash-task/hash/HashTaskProgress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashTaskProgress.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/hash/HashTaskProgress.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,cAAc;IACd,cAAc,EAAE,MAAM,CAAC;IAEvB,iBAAiB;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,aAAa;IACb,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,UAAU,CAAC,CAAS;IAE5B;;;;OAIG;IACH,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IAM/B;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE;YAAE,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,GAAG,IAAI;IAKtD;;;;;;OAMG;IACH,QAAQ,IAAI,oBAAoB;CAcnC"}

package/dist/task/hash-task/hash/HashTaskProgress.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashTaskProgress = void 0;
+/**
+ * 哈希任务进度管理类
+ *
+ * 负责跟踪和管理哈希任务的执行进度
+ *
+ * 设计原则：
+ * - 仅负责进度跟踪和快照生成
+ * - 不关心数据块的来源
+ * - 不关心哈希算法的实现
+ * - 不管理Worker或任务状态
+ */
+class HashTaskProgress {
+    constructor() {
+        this.processedBytes = 0;
+        this.processedChunks = 0;
+    }
+    /**
+     * 初始化进度（可选总量）
+     *
+     * @param totalBytes 总字节数，可选参数
+     */
+    init(totalBytes) {
+        this.totalBytes = totalBytes;
+        this.processedBytes = 0;
+        this.processedChunks = 0;
+    }
+    /**
+     * 处理数据块，更新进度
+     *
+     * 该方法会更新已处理的块数和字节数
+     *
+     * @param chunk 要处理的数据块，包含字节数信息
+     */
+    onChunk(chunk) {
+        this.processedChunks += 1;
+        this.processedBytes += chunk.data.byteLength;
+    }
+    /**
+     * 生成只读快照
+     *
+     * 计算当前进度百分比并返回进度快照
+     *
+     * @returns 任务进度快照
+     */
+    snapshot() {
+        // ✅ 符合原则：在生成快照时计算百分比（0~1）
+        const progress = this.totalBytes !== undefined && this.totalBytes > 0
+            ? Math.min(this.processedBytes / this.totalBytes, 1)
+            : undefined;
+        return {
+            progress,
+            processedBytes: this.processedBytes,
+            totalBytes: this.totalBytes,
+            processedChunks: this.processedChunks,
+        };
+    }
+}
+exports.HashTaskProgress = HashTaskProgress;
+//# sourceMappingURL=HashTaskProgress.js.map

package/dist/task/hash-task/hash/HashTaskProgress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashTaskProgress.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/hash/HashTaskProgress.ts"],"names":[],"mappings":";;;AAmCA;;;;;;;;;;GAUG;AACH,MAAa,gBAAgB;IAA7B;QACY,mBAAc,GAAG,CAAC,CAAC;QACnB,oBAAe,GAAG,CAAC,CAAC;IA+ChC,CAAC;IA5CG;;;;OAIG;IACH,IAAI,CAAC,UAAmB;QACpB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,KAAuC;QAC3C,IAAI,CAAC,eAAe,IAAI,CAAC,CAAC;QAC1B,IAAI,CAAC,cAAc,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACH,QAAQ;QACJ,0BAA0B;QAC1B,MAAM,QAAQ,GACV,IAAI,CAAC,UAAU,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC;YAChD,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YACpD,CAAC,CAAC,SAAS,CAAC;QAEpB,OAAO;YACH,QAAQ;YACR,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,eAAe,EAAE,IAAI,CAAC,eAAe;SACxC,CAAC;IACN,CAAC;CACJ;AAjDD,4CAiDC"}

package/dist/task/hash-task/hash/HashTaskResources.d.ts

@@ -0,0 +1,115 @@
+import { MemoryManager } from '@qimenjs/runtime';
+import { WorkerHandle, WorkerPool } from '../worker';
+/**
+ * HashTaskResources 只做 3 件事：
+ * - 申请资源
+ *   - 内存预算
+ *   - Worker槽位
+ * - 释放资源
+ * - 暴露一个只读视图，给 Runner 用
+ *
+ * 明确不负责：
+ * - 不分块
+ * - 不调度任务
+ * - 不执行哈希计算
+ * - 不处理进度
+ * - 不做健康判断（HealthMonitor 的事）
+ */
+/**
+ * 哈希任务资源快照接口
+ *
+ * 定义了哈希任务资源的快照信息
+ */
+export interface HashTaskResourceSnapshot {
+    /** 已分配的内存字节数（可选） */
+    memoryBytes?: number;
+    /** 是否拥有Worker */
+    hasWorker: boolean;
+}
+/**
+ * 哈希任务资源管理类
+ *
+ * 负责管理哈希任务所需的资源，包括内存和Worker。
+ * 这是一个资源管理器，用于在执行哈希任务时获取和释放必要的计算资源。
+ * 设计原则是单一职责，只负责资源的申请和释放，不涉及具体的哈希计算逻辑。
+ *
+ * 设计原则：
+ * - 仅负责资源的申请与释放
+ * - 不涉及具体哈希计算逻辑
+ * - 保证资源操作的原子性
+ * - 提供资源状态快照
+ */
+export declare class HashTaskResources {
+    private readonly memoryManager;
+    private readonly workerPool;
+    private memoryTicket?;
+    private worker?;
+    private acquired;
+    /**
+     * 构造函数
+     *
+     * @param memoryManager 内存管理器，用于申请和释放内存资源
+     * @param workerPool Worker池，用于获取和归还Worker线程
+     */
+    constructor(memoryManager: MemoryManager, workerPool: WorkerPool);
+    /**
+     * 核心：申请计算所需的资源（内存 + 线程）
+     *
+     * 此方法用于为哈希任务申请必要的计算资源。如果资源已经获取，则直接返回。
+     * 方法具有原子性，要么成功获取所有资源，要么在失败时释放已获取的资源。
+     *
+     * @param scriptSource 经过 Builder 转换后的算法源码字符串，将被注入到Worker中
+     * @param memoryBytes 需要锁定的内存预算，以字节为单位
+     * @returns 当资源成功获取后解析的Promise
+     * @throws 当资源申请失败时，会抛出相应的错误，并确保已申请的资源被释放
+     */
+    acquire(scriptSource: string, memoryBytes: number): Promise<void>;
+    /**
+     * 专用方法：获取内存资源
+     *
+     * 尝试从内存管理器获取指定数量的字节，如果失败则抛出内存资源不可用错误
+     *
+     * @param memoryBytes 需要获取的内存字节数
+     * @throws ResourceUnavailableError 如果内存不足或获取失败
+     */
+    private acquireMemory;
+    /**
+     * 专用方法：获取Worker资源
+     *
+     * 尝试从Worker池获取一个Worker实例，如果失败则抛出Worker资源不可用错误
+     *
+     * @param scriptSource 要注入到Worker中的脚本源码
+     * @throws ResourceUnavailableError 如果Worker池已满或获取失败
+     */
+    private acquireWorker;
+    /**
+     * 释放所有资源（幂等）
+     *
+     * 释放之前通过acquire方法获取的所有资源。此方法是幂等的，
+     * 即可以安全地多次调用而不会产生副作用。
+     * 无论资源是否已经被释放，或者从未被获取，调用此方法都是安全的。
+     *
+     * @returns 当资源成功释放后解析的Promise
+     */
+    release(): Promise<void>;
+    /**
+     * 访问 worker（只允许 Runner 用）
+     *
+     * 获取当前持有的Worker句柄，供Runner使用来执行实际的哈希计算。
+     * 如果尚未获取Worker或Worker已被释放，则抛出错误。
+     *
+     * @returns Worker句柄，可用于向Worker发送消息和接收结果
+     * @throws 如果Worker尚未获取则抛出错误，确保使用者意识到资源未就绪
+     */
+    getWorker(): WorkerHandle;
+    /**
+     * 当前资源快照（给 health / debug）
+     *
+     * 获取当前资源使用情况的快照，主要用于健康检查和调试目的。
+     * 返回一个不可变的对象，包含当前内存使用量和Worker状态。
+     *
+     * @returns 资源快照对象，包含内存字节数（如果有）和Worker存在状态
+     */
+    snapshot(): HashTaskResourceSnapshot;
+}
+//# sourceMappingURL=HashTaskResources.d.ts.map