wowok 2.1.38 → 2.1.40

package/dist/esm/w/local/wip.js

@@ -1,162 +1,17 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * WIP (Witness Immutable Promise) - 见证不可篡改承诺
- *
- * WIP 是一种用于通过网络向 AI 传递不可篡改承诺信息的 JSON 文件格式。
- * 该格式设计用于确保内容完整性，支持文字和多图片的组合，并通过哈希值防止篡改。
- *
- * === 完整示例 ===
- *
- * 基础示例（无签名）:
- * ```json
- * {
- *   "wip": "https://schema.wip/v1",
- *   "payload": {
- *     "content": {
- *       "text": "我承诺在2024年12月31日前完成项目交付。",
- *       "format": "plain"
- *     },
- *     "media": [
- *       {
- *         "id": "img-001",
- *         "type": "image/png",
- *         "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
- *         "filename": "contract-signature.png"
- *       }
- *     ]
- *   },
- *   "meta": {
- *     "type": "wip",
- *     "version": "1.0.0",
- *     "created": "2024-03-15T08:30:00Z",
- *     "hash": "sha256:3a6eb0790f39ac87c94f3856b2dd2c5d110e6811602261a9a923d3bb23adc8b7",
- *     "algorithm": "sha256"
- *   }
- * }
- * ```
- *
- * 带数字签名的示例:
- * ```json
- * {
- *   "wip": "https://schema.wip/v1",
- *   "payload": {
- *     "content": {
- *       "text": "我承诺在2024年12月31日前完成项目交付。",
- *       "format": "plain"
- *     },
- *     "media": [
- *       {
- *         "id": "img-001",
- *         "type": "image/png",
- *         "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
- *       }
- *     ]
- *   },
- *   "meta": {
- *     "type": "wip",
- *     "version": "1.0.0",
- *     "created": "2024-03-15T08:30:00Z",
- *     "hash": "sha256:3a6eb0790f39ac87c94f3856b2dd2c5d110e6811602261a9a923d3bb23adc8b7",
- *     "algorithm": "sha256",
- *     "signature": {
- *       "value": "base64EncodedSignatureValue",
- *       "publicKey": "did:web:example.com#keys-1",
- *       "algorithm": "Ed25519"
- *     }
- *   }
- * }
- * ```
- *
- * === 字段说明 ===
- *
- * - wip: 根级标识，值为 schema URL
- * - payload: 内容载荷
- *   - content: 文字内容
- *     - text: 文字内容
- *     - format: 格式 (plain | markdown | html)
- *   - media: 媒体文件数组
- *     - id: 唯一标识
- *     - type: MIME 类型 (image/png, image/jpeg, image/gif, image/webp)
- *     - data: Base64 编码的文件数据
- *     - filename: 可选文件名
- * - meta: 元数据
- *   - type: 文件类型标识，固定为 "wip"
- *     - 全称: Witness Immutable Promise (见证不可篡改承诺)
- *     - 用途: 用于通过网络向 AI 传递不可篡改的承诺信息，确保内容完整性
- *   - version: 格式版本号
- *   - created: 创建时间 (ISO 8601)
- *   - hash: payload 的 SHA-256 哈希值，格式为 "sha256:hexString"
- *   - algorithm: 哈希算法标识
- *   - signature: 可选的数字签名
- *     - value: Base64 编码的签名值
- *     - publicKey: 验证公钥或 DID
- *     - algorithm: 签名算法
- *
- * === 缓存目录建议 ===
- *
- * 对于频繁使用的 WIP 文件，建议配置本地缓存目录：
- *
- * 1. 缓存目录位置:
- *    - Windows: %LOCALAPPDATA%\wip\cache\ (如 C:\Users\<user>\AppData\Local\wip\cache\)
- *    - macOS: ~/Library/Caches/wip/
- *    - Linux: ~/.cache/wip/
- *
- * 2. 缓存结构:
- *    ```
- *    wip-cache/
- *    ├── files/          # 缓存的 WIP JSON 文件
- *    │   ├── <hash1>.json
- *    │   └── <hash2>.json
- *    ├── images/         # 缓存的图片文件
- *    │   └── <hash>.png
- *    └── index.json      # 缓存索引，记录元数据
- *    ```
- *
- * 3. 缓存策略:
- *    - 使用 content hash 作为文件名，天然去重
- *    - 设置最大缓存大小 (如 100MB)，LRU 淘汰
- *    - 缓存过期时间 (如 30 天)
- *
- * 4. 使用示例:
- *    ```typescript
- *    const wip = new WIP();
- *    const cache = new WipCache("~/.cache/wip");
- *
- *    // 检查缓存
- *    const cached = cache.get(hash);
- *    if (cached) return cached;
- *
- *    // 从网络加载并缓存
- *    const wipFile = await wip.loadFromUrl(url);
- *    cache.set(hash, wipFile);
- *    ```
- */
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex } from "@noble/hashes/utils";
 import * as fs from "fs";
 import * as path from "path";
 import * as https from "https";
 import * as http from "http";
-// ========== 常量定义 ==========
 const WIP_SCHEMA_URL = "https://schema.wowok.net/wip/v1";
 const WIP_VERSION = "1.0.0";
-/**
- * 默认限制配置
- *
- * 设计考虑:
- * - maxImageSize: 2MB - 单张图片限制，确保 Base64 编码后不会过大
- * - maxTotalSize: 10MB - 整个 WIP 文件大小限制，适合网络传输
- * - maxImageCount: 10 - 最多10张图片，满足大多数承诺场景
- * - maxTextLength: 10000 - 文字内容长度限制，约5000个汉字
- */
 export const DEFAULT_LIMITS = {
-    maxImageSize: 2 * 1024 * 1024, // 2MB
-    maxTotalSize: 10 * 1024 * 1024, // 10MB
+    maxImageSize: 2 * 1024 * 1024,
+    maxTotalSize: 10 * 1024 * 1024,
     maxImageCount: 10,
     maxTextLength: 10000,
 };
-// ========== 错误类 ==========
 export class WipError extends Error {
     constructor(message) {
         super(message);
@@ -175,12 +30,7 @@ export class WipSizeError extends WipError {
         this.name = "WipSizeError";
     }
 }
-// ========== 工具函数 ==========
-/**
- * 检测 MIME 类型从文件数据
- */
 function detectMimeType(buffer) {
-    // PNG: 89 50 4E 47
     if (buffer.length >= 4 &&
         buffer[0] === 0x89 &&
         buffer[1] === 0x50 &&
@@ -188,21 +38,18 @@ function detectMimeType(buffer) {
         buffer[3] === 0x47) {
         return "image/png";
     }
-    // JPEG: FF D8 FF
     if (buffer.length >= 3 &&
         buffer[0] === 0xff &&
         buffer[1] === 0xd8 &&
         buffer[2] === 0xff) {
         return "image/jpeg";
     }
-    // GIF: GIF87a 或 GIF89a
     if (buffer.length >= 6 &&
         buffer[0] === 0x47 &&
         buffer[1] === 0x49 &&
         buffer[2] === 0x46) {
         return "image/gif";
     }
-    // WebP: RIFF....WEBP
     if (buffer.length >= 12 &&
         buffer[0] === 0x52 &&
         buffer[1] === 0x49 &&
@@ -216,9 +63,6 @@ function detectMimeType(buffer) {
     }
     return null;
 }
-/**
- * 将 Uint8Array 转换为 Base64 字符串
- */
 function uint8ArrayToBase64(array) {
     let binary = "";
     const len = array.length;
@@ -227,9 +71,6 @@ function uint8ArrayToBase64(array) {
     }
     return btoa(binary);
 }
-/**
- * 将 Base64 字符串转换为 Uint8Array
- */
 function base64ToUint8Array(base64) {
     const binary = atob(base64);
     const len = binary.length;
@@ -239,9 +80,6 @@ function base64ToUint8Array(base64) {
     }
     return array;
 }
-/**
- * 规范化 JSON 对象（按键名排序）
- */
 function canonicalizeJson(obj) {
     if (obj === null || typeof obj !== "object") {
         return JSON.stringify(obj);
@@ -254,24 +92,15 @@ function canonicalizeJson(obj) {
     const pairs = keys.map((key) => `"${key}":${canonicalizeJson(sortedObj[key])}`);
     return "{" + pairs.join(",") + "}";
 }
-/**
- * 计算 SHA-256 哈希
- */
 function computeHash(data) {
     const hash = sha256(new TextEncoder().encode(data));
-    return "sha256:" + bytesToHex(hash);
+    return bytesToHex(hash);
 }
-/**
- * 生成唯一 ID
- */
 function generateId(prefix) {
     const timestamp = Date.now().toString(36);
     const random = Math.random().toString(36).substring(2, 8);
     return `${prefix}-${timestamp}-${random}`;
 }
-/**
- * 获取 MIME 类型对应的文件扩展名
- */
 function getExtensionFromMimeType(mimeType) {
     const map = {
         "image/png": "png",
@@ -281,38 +110,23 @@ function getExtensionFromMimeType(mimeType) {
     };
     return map[mimeType] || "bin";
 }
-// ========== 文件加载器类（复用代码） ==========
-/**
- * 统一的资源加载器
- * 支持本地文件、网络 URL、Data URL
- */
 class ResourceLoader {
     maxSize;
     constructor(maxSize) {
         this.maxSize = maxSize;
     }
-    /**
-     * 加载资源
-     */
     async load(source) {
-        // 空字符串检查
         if (!source || source.trim() === "") {
             throw new WipError("WIP file path cannot be empty");
         }
-        // 处理 Data URL
         if (source.startsWith("data:")) {
             return this.loadFromDataUrl(source);
         }
-        // 处理 HTTP/HTTPS 网络 URL
         if (source.startsWith("http://") || source.startsWith("https://")) {
             return this.loadFromNetwork(source);
         }
-        // 处理本地文件
         return this.loadFromFile(source);
     }
-    /**
-     * 从 Data URL 加载
-     */
     loadFromDataUrl(dataUrl) {
         const match = dataUrl.match(/^data:image\/(\w+);base64,(.+)$/);
         if (!match) {
@@ -326,9 +140,6 @@ class ResourceLoader {
             throw new WipError(`Failed to decode data URL: ${error}`);
         }
     }
-    /**
-     * 从网络加载
-     */
     async loadFromNetwork(url) {
         return new Promise((resolve, reject) => {
             const timeoutId = setTimeout(() => {
@@ -341,8 +152,6 @@ class ResourceLoader {
                     Accept: "application/json,*/*",
                 },
             };
-            // 允许不安全的 SSL 连接（用于测试环境）
-            // 注意：生产环境应该使用有效的 SSL 证书
             if (isHttps) {
                 options.rejectUnauthorized = false;
             }
@@ -352,7 +161,6 @@ class ResourceLoader {
                     reject(new WipError(`Failed to fetch: ${response.statusCode} ${response.statusMessage}`));
                     return;
                 }
-                // 检查 Content-Length
                 const contentLength = response.headers["content-length"];
                 if (contentLength && parseInt(contentLength) > this.maxSize) {
                     reject(new WipSizeError(`Resource from ${url} size (${contentLength} bytes) exceeds limit (${this.maxSize} bytes)`));
@@ -380,9 +188,6 @@ class ResourceLoader {
             });
         });
     }
-    /**
-     * 从本地文件加载
-     */
     loadFromFile(filePath) {
         const resolvedPath = path.resolve(filePath);
         if (!fs.existsSync(resolvedPath)) {
@@ -399,7 +204,6 @@ class ResourceLoader {
         return new Uint8Array(buffer);
     }
 }
-// ========== WIP 类 ==========
 export class WIP {
     limits;
     resourceLoader;
@@ -407,15 +211,10 @@ export class WIP {
         this.limits = { ...DEFAULT_LIMITS, ...limits };
         this.resourceLoader = new ResourceLoader(this.limits.maxImageSize);
     }
-    /**
-     * 创建 WIP 文件
-     */
     async create(options) {
-        // 验证文字长度
         if (options.text.length > this.limits.maxTextLength) {
             throw new WipSizeError(`Text length (${options.text.length}) exceeds limit (${this.limits.maxTextLength})`);
         }
-        // 处理图片
         const media = [];
         if (options.images && options.images.length > 0) {
             if (options.images.length > this.limits.maxImageCount) {
@@ -426,7 +225,6 @@ export class WIP {
                 media.push(wipMedia);
             }
         }
-        // 构建 payload
         const payload = {
             content: {
                 text: options.text,
@@ -434,10 +232,8 @@ export class WIP {
             },
             media,
         };
-        // 计算哈希
         const canonicalPayload = canonicalizeJson(payload);
         const hash = computeHash(canonicalPayload);
-        // 构建 meta
         const meta = {
             type: "wip",
             version: WIP_VERSION,
@@ -445,7 +241,6 @@ export class WIP {
             hash,
             algorithm: "sha256",
         };
-        // 添加签名
         if (options.signKeyPair) {
             const signatureValue = await this.sign(hash, options.signKeyPair.privateKey, options.signAlgorithm || "Ed25519");
             meta.signature = {
@@ -459,16 +254,12 @@ export class WIP {
             payload,
             meta,
         };
-        // 验证总大小
         const jsonString = JSON.stringify(wipFile);
         if (jsonString.length > this.limits.maxTotalSize) {
             throw new WipSizeError(`Total WIP file size (${jsonString.length} bytes) exceeds limit (${this.limits.maxTotalSize} bytes)`);
         }
         return wipFile;
     }
-    /**
-     * 处理图片源
-     */
     async processImage(source, index) {
         const data = await this.resourceLoader.load(source.source);
         const mimeType = detectMimeType(data);
@@ -496,9 +287,6 @@ export class WIP {
             filename,
         };
     }
-    /**
-     * 签名（真实实现）
-     */
     async sign(data, privateKey, algorithm) {
         if (algorithm !== "Ed25519") {
             throw new WipError(`Unsupported signature algorithm: ${algorithm}`);
@@ -508,9 +296,6 @@ export class WIP {
         const signature = await keypair.sign(new TextEncoder().encode(data));
         return uint8ArrayToBase64(signature);
     }
-    /**
-     * 验证 WIP 文件（私有方法，内部使用）
-     */
     async verify(wipFile) {
         try {
             if (!wipFile.wip || !wipFile.payload || !wipFile.meta) {
@@ -532,7 +317,6 @@ export class WIP {
             }
             const signatures = [];
             if (wipFile.meta.signature) {
-                // 支持多签名验证
                 const sigArray = Array.isArray(wipFile.meta.signature)
                     ? wipFile.meta.signature
                     : [wipFile.meta.signature];
@@ -557,9 +341,6 @@ export class WIP {
             return { valid: false, error: `Verification error: ${error}` };
         }
     }
-    /**
-     * 验证签名
-     */
     async verifySignature(data, signature, publicKey, algorithm) {
         if (algorithm !== "Ed25519") {
             throw new WipError(`Unsupported signature algorithm: ${algorithm}`);
@@ -577,17 +358,13 @@ export class WIP {
                 }
             }
             else {
-                // 处理 base64 公钥（可能是 33 字节带 flag 或 32 字节原始公钥）
                 try {
                     const buffer = Buffer.from(publicKey, "base64");
                     if (buffer.length === 33) {
-                        // 33 字节：包含 flag，取后 32 字节
                         pkToUse = buffer.slice(1).toString("base64");
                     }
-                    // 32 字节：直接使用
                 }
                 catch {
-                    // 解码失败，使用原始值
                 }
             }
             const pubKey = new Ed25519PublicKey(pkToUse);
@@ -599,9 +376,6 @@ export class WIP {
             return false;
         }
     }
-    /**
-     * 转换为 HTML
-     */
     async toHtml(wipFile, options = {}) {
         const { title = "WIP Document", theme = "light" } = options;
         const { payload, meta } = wipFile;
@@ -646,7 +420,6 @@ export class WIP {
 				</div>
 			`)
             .join("");
-        // 签名详情不在 HTML 中显示，只显示验证结果
         return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -704,17 +477,11 @@ export class WIP {
 </body>
 </html>`;
     }
-    /**
-     * 序列化为 JSON
-     */
     stringify(wipFile, pretty = true) {
         return pretty
             ? JSON.stringify(wipFile, null, 2)
             : JSON.stringify(wipFile);
     }
-    /**
-     * 从 JSON 解析
-     */
     parse(jsonString) {
         try {
             const obj = JSON.parse(jsonString);
@@ -730,30 +497,18 @@ export class WIP {
             throw new WipValidationError(`Failed to parse WIP file: ${error}`);
         }
     }
-    /**
-     * 从 URL 或本地路径加载 WIP 文件
-     */
     async load(source) {
         const data = await this.resourceLoader.load(source);
         const content = new TextDecoder().decode(data);
         return this.parse(content);
     }
-    /**
-     * 获取 WIP 文件的哈希值（用于 Service 销售）
-     * @param wipFile WIP 文件
-     * @returns 纯哈希值（不含 sha256: 前缀）
-     */
     getHash(wipFile) {
         const hash = wipFile.meta.hash;
-        // 移除 sha256: 前缀如果存在
         if (hash.includes(":")) {
             return hash.split(":")[1];
         }
         return hash;
     }
-    /**
-     * 提取图片
-     */
     extractImages(wipFile, outputDir) {
         if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
@@ -769,9 +524,6 @@ export class WIP {
         }
         return savedPaths;
     }
-    /**
-     * 保存到文件
-     */
     save(wipFile, filePath, pretty = true) {
         const dir = path.dirname(filePath);
         if (!fs.existsSync(dir)) {
@@ -779,29 +531,27 @@ export class WIP {
         }
         fs.writeFileSync(filePath, this.stringify(wipFile, pretty), "utf-8");
     }
-    /**
-     * 获取限制配置
-     */
     getLimits() {
         return { ...this.limits };
     }
-    /**
-     * 更新限制配置
-     */
     setLimits(limits) {
         this.limits = { ...this.limits, ...limits };
         this.resourceLoader = new ResourceLoader(this.limits.maxImageSize);
     }
 }
-// ========== 便捷函数 ==========
 export async function createWip(options, limits) {
     const wip = new WIP(limits);
     return wip.create(options);
 }
 export async function verifyWip(wipFile, hash_equal) {
-    if (hash_equal !== undefined &&
-        wipFile.meta.hash.toLowerCase() !== hash_equal.toLowerCase()) {
-        return { valid: false, error: "Hash mismatch" };
+    if (hash_equal !== undefined) {
+        const fileHash = wipFile.meta.hash
+            .toLowerCase()
+            .replace(/^sha256:/, "");
+        const expectedHash = hash_equal.toLowerCase().replace(/^sha256:/, "");
+        if (fileHash !== expectedHash) {
+            return { valid: false, error: "Hash mismatch" };
+        }
     }
     const wip = new WIP();
     const result = await wip.verify(wipFile);
@@ -815,38 +565,24 @@ export async function loadWip(source, limits) {
     const wip = new WIP(limits);
     return wip.load(source);
 }
-/**
- * 生成 WIP 文件并保存到指定路径
- *
- * @param options 生成选项
- * @param outputPath 输出文件路径
- * @param limits 可选的限制配置
- * @returns 生成的 WIP 文件路径
- */
 export async function generate_wip(options, outputPath) {
     const wip = new WIP(DEFAULT_LIMITS);
-    // 1. 创建 WIP 文件（无签名）
     let wipFile = await wip.create({
         text: options.markdown_text,
         textFormat: "markdown",
         images: options.images,
     });
-    // 2. 如果指定了 account，使用 Account 模块进行签名
     if (options.account) {
-        // eslint-disable-next-line import/no-cycle
         const { Account } = await import("./account.js");
         const address = await Account.Instance().get_address(options.account);
         if (!address) {
             throw new WipValidationError(`Account not found: ${options.account}`);
         }
-        // 使用 Account 签名
         const signature = await Account.Instance().sign(address, wipFile.meta.hash);
-        // 获取公钥
         const accountData = await Account.Instance().get(address);
         if (!accountData || !accountData.pubkey) {
             throw new WipValidationError(`Cannot get public key for account: ${address}`);
         }
-        // 转换公钥格式为 base64 (32字节)
         let publicKeyBase64;
         if (accountData.pubkey.startsWith("0x")) {
             const buffer = Buffer.from(accountData.pubkey.slice(2), "hex");
@@ -863,19 +599,15 @@ export async function generate_wip(options, outputPath) {
         else {
             publicKeyBase64 = accountData.pubkey;
         }
-        // 转换签名为 base64
         const signatureBase64 = Buffer.from(signature.slice(2), "hex").toString("base64");
-        // 构建新签名
         const newSignature = {
             value: signatureBase64,
             publicKey: publicKeyBase64,
             algorithm: "Ed25519",
             address,
         };
-        // 处理多签名：如果已有签名，追加到数组中
         let signatures;
         if (wipFile.meta.signature) {
-            // 如果已有签名是数组，追加；如果是单个，转换为数组
             signatures = Array.isArray(wipFile.meta.signature)
                 ? [...wipFile.meta.signature, newSignature]
                 : [wipFile.meta.signature, newSignature];
@@ -883,7 +615,6 @@ export async function generate_wip(options, outputPath) {
         else {
             signatures = [newSignature];
         }
-        // 添加签名到 meta
         wipFile = {
             ...wipFile,
             meta: {
@@ -895,22 +626,8 @@ export async function generate_wip(options, outputPath) {
     wip.save(wipFile, outputPath, true);
     return outputPath;
 }
-/**
- * 验证 WIP 文件
- * 验证内容包括：
- * 1. 基本结构验证
- * 2. 哈希值验证（内容完整性）
- * 3. 数字签名验证（如果存在）
- * 4. 可选：要求必须有签名
- *
- * @param wipFilePath WIP 文件路径（支持本地文件和网络 URL）
- * @param hash_equal 可选的预期哈希值，用于验证文件哈希是否匹配
- * @param requireSignature 可选的标志，如果为 true，则文件必须有签名
- * @returns 验证结果，包含哈希验证和签名验证状态
- */
 export async function verify_wip(wipFilePath, hash_equal, requireSignature) {
     const wip = new WIP();
-    // 加载 WIP 文件
     let wipFile;
     try {
         wipFile = await wip.load(wipFilePath);
@@ -923,7 +640,6 @@ export async function verify_wip(wipFilePath, hash_equal, requireSignature) {
             hasSignature: false,
         };
     }
-    // 验证基本结构
     if (!wipFile.wip || !wipFile.payload || !wipFile.meta) {
         return {
             valid: false,
@@ -940,26 +656,28 @@ export async function verify_wip(wipFilePath, hash_equal, requireSignature) {
             hasSignature: !!wipFile.meta.signature,
         };
     }
-    // 如果提供了 hash_equal，先验证文件 meta.hash 是否匹配
-    if (hash_equal !== undefined &&
-        wipFile.meta.hash.toLowerCase() !== hash_equal.toLowerCase()) {
-        return {
-            valid: false,
-            error: "Hash mismatch",
-            hashValid: false,
-            hasSignature: !!wipFile.meta.signature,
-        };
+    if (hash_equal !== undefined) {
+        const fileHash = wipFile.meta.hash
+            .toLowerCase()
+            .replace(/^sha256:/, "");
+        const expectedHash = hash_equal.toLowerCase().replace(/^sha256:/, "");
+        if (fileHash !== expectedHash) {
+            return {
+                valid: false,
+                error: "Hash mismatch",
+                hashValid: false,
+                hasSignature: !!wipFile.meta.signature,
+            };
+        }
     }
-    // 检查是否要求签名但文件没有签名
     if (requireSignature && !wipFile.meta.signature) {
         return {
             valid: false,
             error: "Signature required but WIP file has no signature",
-            hashValid: true, // 哈希可能有效，但缺少签名
+            hashValid: true,
             hasSignature: false,
         };
     }
-    // 验证哈希
     const canonicalPayload = canonicalizeJson(wipFile.payload);
     const computedHash = computeHash(canonicalPayload);
     const hashValid = computedHash === wipFile.meta.hash;
@@ -971,18 +689,15 @@ export async function verify_wip(wipFilePath, hash_equal, requireSignature) {
             hasSignature: !!wipFile.meta.signature,
         };
     }
-    // 验证签名（如果存在）
     let signatureValid;
     const signatures = [];
     if (wipFile.meta.signature) {
-        // 支持多签名验证
         const sigArray = Array.isArray(wipFile.meta.signature)
             ? wipFile.meta.signature
             : [wipFile.meta.signature];
         let allValid = true;
         for (const sig of sigArray) {
             const isValid = await wip["verifySignature"](wipFile.meta.hash, sig.value, sig.publicKey, sig.algorithm);
-            // 通过公钥推导地址
             let address;
             try {
                 const { Ed25519PublicKey } = await import("../../keypairs/ed25519/publickey.js");
@@ -990,7 +705,6 @@ export async function verify_wip(wipFilePath, hash_equal, requireSignature) {
                 address = pubKey.toWAddress();
             }
             catch {
-                // 推导失败不影响验证结果
             }
             signatures.push({
                 publicKey: sig.publicKey,
@@ -1003,7 +717,6 @@ export async function verify_wip(wipFilePath, hash_equal, requireSignature) {
         }
         signatureValid = allValid;
         if (!signatureValid) {
-            // 收集失败的地址
             const failedAddresses = signatures
                 .filter((s) => !s.valid && s.address)
                 .map((s) => s.address);
@@ -1025,37 +738,21 @@ export async function verify_wip(wipFilePath, hash_equal, requireSignature) {
         signatures: signatures.length > 0 ? signatures : undefined,
     };
 }
-/**
- * 对 WIP 文件进行签名
- *
- * 该函数会加载 WIP 文件、验证格式、使用 Account 添加数字签名并保存。
- * 支持多签名，如果文件已有签名，新签名会追加到签名列表中。
- *
- * @param wipFilePath WIP 文件路径
- * @param account 签名账号（账户名或地址）
- * @param outputPath 输出文件路径（可选，默认覆盖原文件）
- * @returns 签名后的 WIP 文件路径
- */
 export async function sign_wip(wipFilePath, account, outputPath) {
     const wip = new WIP();
-    // 1. 加载 WIP 文件
     const wipFile = await wip.load(wipFilePath);
-    // 2. 验证基本结构
     if (!wipFile.wip || !wipFile.payload || !wipFile.meta) {
         throw new WipValidationError("Invalid WIP file structure");
     }
     if (wipFile.meta.type !== "wip") {
         throw new WipValidationError(`Invalid meta.type: ${wipFile.meta.type}`);
     }
-    // 3. 获取签名者地址
     const { Account } = await import("./account.js");
     const address = await Account.Instance().get_address(account);
     if (!address) {
         throw new WipValidationError(`Account not found: ${account}`);
     }
-    // 4. 使用 Account 签名（同时获取公钥）
     const signResult = await Account.Instance().signData(address, wipFile.meta.hash);
-    // 5. 转换公钥格式为 base64 (32字节)
     let publicKeyBase64;
     const pk = signResult.publicKey;
     if (pk.startsWith("0x")) {
@@ -1073,36 +770,29 @@ export async function sign_wip(wipFilePath, account, outputPath) {
     else {
         publicKeyBase64 = pk;
     }
-    // 6. 构建新签名
     const newSignature = {
         value: Buffer.from(signResult.signature.slice(2), "hex").toString("base64"),
         publicKey: publicKeyBase64,
         algorithm: "Ed25519",
         address: signResult.address,
     };
-    // 7. 处理多签名：相同公钥只能有一个签名（替换已有签名）
     let signatures;
     if (wipFile.meta.signature) {
-        // 将已有签名转换为数组
         const existingSigs = Array.isArray(wipFile.meta.signature)
             ? [...wipFile.meta.signature]
             : [wipFile.meta.signature];
-        // 检查是否已存在相同公钥的签名
         const existingIndex = existingSigs.findIndex((sig) => sig.publicKey === publicKeyBase64);
         if (existingIndex >= 0) {
-            // 替换已有签名
             existingSigs[existingIndex] = newSignature;
             signatures = existingSigs;
         }
         else {
-            // 追加新签名
             signatures = [...existingSigs, newSignature];
         }
     }
     else {
         signatures = [newSignature];
     }
-    // 8. 添加签名到 meta
     const signedWipFile = {
         ...wipFile,
         meta: {
@@ -1110,13 +800,11 @@ export async function sign_wip(wipFilePath, account, outputPath) {
             signature: signatures,
         },
     };
-    // 10. 确定保存路径
     let savePath;
     if (outputPath) {
         savePath = outputPath;
     }
     else {
-        // 在原文件名前添加 signed_ 前缀
         const dir = path.dirname(wipFilePath);
         const ext = path.extname(wipFilePath);
         const baseName = path.basename(wipFilePath, ext);
@@ -1125,20 +813,11 @@ export async function sign_wip(wipFilePath, account, outputPath) {
     wip.save(signedWipFile, savePath, true);
     return savePath;
 }
-/**
- * 将 WIP 文件或文件夹转换为 HTML
- *
- * @param wipPath WIP 文件路径或文件夹路径
- * @param options 转换选项（支持 outputPath 直接保存到文件）
- * @returns HTML 字符串、保存的文件路径，或转换的文件路径数组
- */
 export async function wip2html(wipPath, options = {}) {
     const fs = await import("fs");
     const path = await import("path");
-    // 检查是文件还是文件夹
     const stats = fs.statSync(wipPath);
     if (stats.isFile()) {
-        // 处理单个文件
         const wip = new WIP();
         const wipFile = await wip.load(wipPath);
         const html = await wip.toHtml(wipFile, options);
@@ -1146,10 +825,14 @@ export async function wip2html(wipPath, options = {}) {
             fs.writeFileSync(options.outputPath, html);
             return options.outputPath;
         }
-        return html;
+        const dir = path.dirname(wipPath);
+        const ext = path.extname(wipPath);
+        const baseName = path.basename(wipPath, ext);
+        const outputFilePath = path.join(dir, `${baseName}.html`);
+        fs.writeFileSync(outputFilePath, html);
+        return outputFilePath;
     }
     else if (stats.isDirectory()) {
-        // 处理文件夹中的所有 .wip 文件
         const files = fs.readdirSync(wipPath);
         const wipFiles = files.filter((f) => f.endsWith(".wip"));
         if (wipFiles.length === 0) {
@@ -1161,12 +844,10 @@ export async function wip2html(wipPath, options = {}) {
             const filePath = path.join(wipPath, file);
             const wipFile = await wip.load(filePath);
             const html = await wip.toHtml(wipFile, options);
-            // 生成输出文件名
             const outputFileName = file.replace(".wip", ".html");
             const outputFilePath = options.outputPath
                 ? path.join(options.outputPath, outputFileName)
                 : path.join(wipPath, outputFileName);
-            // 确保输出目录存在
             const outputDir = path.dirname(outputFilePath);
             if (!fs.existsSync(outputDir)) {
                 fs.mkdirSync(outputDir, { recursive: true });
@@ -1181,4 +862,3 @@ export async function wip2html(wipPath, options = {}) {
     }
 }
 export default WIP;
-//# sourceMappingURL=wip.js.map