wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,882 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex } from "@noble/hashes/utils";
+import * as fs from "fs";
+import * as path from "path";
+const WIP_SCHEMA_URL = "https://schema.wip/v1";
+const WIP_VERSION = "1.0.0";
+const DEFAULT_LIMITS = {
+  maxImageSize: 2 * 1024 * 1024,
+  // 2MB
+  maxTotalSize: 10 * 1024 * 1024,
+  // 10MB
+  maxImageCount: 10,
+  maxTextLength: 1e4
+};
+class WipError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WipError";
+  }
+}
+class WipValidationError extends WipError {
+  constructor(message) {
+    super(message);
+    this.name = "WipValidationError";
+  }
+}
+class WipSizeError extends WipError {
+  constructor(message) {
+    super(message);
+    this.name = "WipSizeError";
+  }
+}
+function detectMimeType(buffer) {
+  if (buffer.length >= 4 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+    return "image/jpeg";
+  }
+  if (buffer.length >= 6 && buffer[0] === 71 && buffer[1] === 73 && buffer[2] === 70) {
+    return "image/gif";
+  }
+  if (buffer.length >= 12 && buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer[8] === 87 && buffer[9] === 69 && buffer[10] === 66 && buffer[11] === 80) {
+    return "image/webp";
+  }
+  return null;
+}
+function uint8ArrayToBase64(array) {
+  let binary = "";
+  const len = array.length;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(array[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binary = atob(base64);
+  const len = binary.length;
+  const array = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = binary.charCodeAt(i);
+  }
+  return array;
+}
+function canonicalizeJson(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(canonicalizeJson).join(",") + "]";
+  }
+  const sortedObj = obj;
+  const keys = Object.keys(sortedObj).sort();
+  const pairs = keys.map(
+    (key) => `"${key}":${canonicalizeJson(sortedObj[key])}`
+  );
+  return "{" + pairs.join(",") + "}";
+}
+function computeHash(data) {
+  const hash = sha256(new TextEncoder().encode(data));
+  return "sha256:" + bytesToHex(hash);
+}
+function generateId(prefix) {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${prefix}-${timestamp}-${random}`;
+}
+function getExtensionFromMimeType(mimeType) {
+  const map = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp"
+  };
+  return map[mimeType] || "bin";
+}
+class ResourceLoader {
+  constructor(maxSize) {
+    __publicField(this, "maxSize");
+    this.maxSize = maxSize;
+  }
+  /**
+   * 加载资源
+   */
+  async load(source) {
+    if (source.startsWith("data:")) {
+      return this.loadFromDataUrl(source);
+    }
+    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) {
+      throw new WipValidationError(
+        `Invalid data URL format: ${dataUrl.substring(0, 50)}...`
+      );
+    }
+    const base64Data = match[2];
+    try {
+      return base64ToUint8Array(base64Data);
+    } catch (error) {
+      throw new WipError(`Failed to decode data URL: ${error}`);
+    }
+  }
+  /**
+   * 从网络加载
+   */
+  async loadFromNetwork(url) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e4);
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          Accept: "image/png,image/jpeg,image/gif,image/webp,image/*"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new WipError(
+          `Failed to fetch: ${response.status} ${response.statusText}`
+        );
+      }
+      const contentLength = response.headers.get("content-length");
+      if (contentLength && parseInt(contentLength) > this.maxSize) {
+        throw new WipSizeError(
+          `Resource from ${url} size (${contentLength} bytes) exceeds limit (${this.maxSize} bytes)`
+        );
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      if (arrayBuffer.byteLength > this.maxSize) {
+        throw new WipSizeError(
+          `Resource from ${url} size (${arrayBuffer.byteLength} bytes) exceeds limit (${this.maxSize} bytes)`
+        );
+      }
+      return new Uint8Array(arrayBuffer);
+    } catch (error) {
+      if (error instanceof WipError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new WipError(
+            `Network timeout while fetching: ${url}`
+          );
+        }
+        throw new WipError(`Network error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 从本地文件加载
+   */
+  loadFromFile(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    if (!fs.existsSync(resolvedPath)) {
+      throw new WipError(`File not found: ${resolvedPath}`);
+    }
+    const stats = fs.statSync(resolvedPath);
+    if (!stats.isFile()) {
+      throw new WipError(`Path is not a file: ${resolvedPath}`);
+    }
+    if (stats.size > this.maxSize) {
+      throw new WipSizeError(
+        `File ${resolvedPath} size (${stats.size} bytes) exceeds limit (${this.maxSize} bytes)`
+      );
+    }
+    const buffer = fs.readFileSync(resolvedPath);
+    return new Uint8Array(buffer);
+  }
+}
+class WIP {
+  constructor(limits = {}) {
+    __publicField(this, "limits");
+    __publicField(this, "resourceLoader");
+    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) {
+        throw new WipSizeError(
+          `Image count (${options.images.length}) exceeds limit (${this.limits.maxImageCount})`
+        );
+      }
+      for (let i = 0; i < options.images.length; i++) {
+        const wipMedia = await this.processImage(options.images[i], i);
+        media.push(wipMedia);
+      }
+    }
+    const payload = {
+      content: {
+        text: options.text,
+        format: options.textFormat || "plain"
+      },
+      media
+    };
+    const canonicalPayload = canonicalizeJson(payload);
+    const hash = computeHash(canonicalPayload);
+    const meta = {
+      type: "wip",
+      version: WIP_VERSION,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      hash,
+      algorithm: "sha256"
+    };
+    if (options.signKeyPair) {
+      const signatureValue = await this.sign(
+        hash,
+        options.signKeyPair.privateKey,
+        options.signAlgorithm || "Ed25519"
+      );
+      meta.signature = {
+        value: signatureValue,
+        publicKey: options.signKeyPair.publicKey,
+        algorithm: options.signAlgorithm || "Ed25519"
+      };
+    }
+    const wipFile = {
+      wip: WIP_SCHEMA_URL,
+      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);
+    if (!mimeType) {
+      throw new WipValidationError(
+        `Unsupported image format: ${source.source}`
+      );
+    }
+    let filename = source.filename;
+    if (!filename) {
+      if (source.source.startsWith("http")) {
+        const url = new URL(source.source);
+        const pathname = url.pathname;
+        filename = pathname.substring(pathname.lastIndexOf("/") + 1) || `image-${index}`;
+      } else {
+        filename = source.source.substring(
+          source.source.lastIndexOf("/") + 1
+        ) || `image-${index}`;
+      }
+    }
+    return {
+      id: source.id || generateId("img"),
+      type: mimeType,
+      data: uint8ArrayToBase64(data),
+      filename
+    };
+  }
+  /**
+   * 签名（真实实现）
+   */
+  async sign(data, privateKey, algorithm) {
+    if (algorithm !== "Ed25519") {
+      throw new WipError(`Unsupported signature algorithm: ${algorithm}`);
+    }
+    const { Ed25519Keypair } = await import("../../keypairs/ed25519/index.js");
+    const keypair = Ed25519Keypair.fromSecretKey(privateKey);
+    const signature = await keypair.sign(new TextEncoder().encode(data));
+    return uint8ArrayToBase64(signature);
+  }
+  /**
+   * 验证 WIP 文件
+   */
+  async verify(wipFile) {
+    try {
+      if (!wipFile.wip || !wipFile.payload || !wipFile.meta) {
+        return { valid: false, error: "Invalid WIP file structure" };
+      }
+      if (wipFile.meta.type !== "wip") {
+        return {
+          valid: false,
+          error: `Invalid meta.type: ${wipFile.meta.type}`
+        };
+      }
+      const canonicalPayload = canonicalizeJson(wipFile.payload);
+      const computedHash = computeHash(canonicalPayload);
+      if (computedHash !== wipFile.meta.hash) {
+        return {
+          valid: false,
+          error: "Hash mismatch - content has been tampered"
+        };
+      }
+      const signatures = [];
+      if (wipFile.meta.signature) {
+        const sigArray = Array.isArray(wipFile.meta.signature) ? wipFile.meta.signature : [wipFile.meta.signature];
+        for (const sig of sigArray) {
+          const signValid = await this.verifySignature(
+            wipFile.meta.hash,
+            sig.value,
+            sig.publicKey,
+            sig.algorithm
+          );
+          signatures.push({
+            address: sig.address,
+            valid: signValid
+          });
+          if (!signValid) {
+            return {
+              valid: false,
+              error: "Invalid signature",
+              signatures
+            };
+          }
+        }
+      }
+      return { valid: true, signatures };
+    } catch (error) {
+      return { valid: false, error: `Verification error: ${error}` };
+    }
+  }
+  /**
+   * 验证签名
+   */
+  async verifySignature(data, signature, publicKey, algorithm) {
+    if (algorithm !== "Ed25519") {
+      throw new WipError(`Unsupported signature algorithm: ${algorithm}`);
+    }
+    try {
+      const { Ed25519PublicKey } = await import("../../keypairs/ed25519/publickey.js");
+      let pkToUse = publicKey;
+      if (publicKey.startsWith("0x")) {
+        const buffer = Buffer.from(publicKey.slice(2), "hex");
+        if (buffer.length === 33) {
+          pkToUse = buffer.slice(1).toString("base64");
+        } else if (buffer.length === 32) {
+          pkToUse = buffer.toString("base64");
+        }
+      } else {
+        try {
+          const buffer = Buffer.from(publicKey, "base64");
+          if (buffer.length === 33) {
+            pkToUse = buffer.slice(1).toString("base64");
+          }
+        } catch {
+        }
+      }
+      const pubKey = new Ed25519PublicKey(pkToUse);
+      const signatureBytes = Uint8Array.from(
+        Buffer.from(signature, "base64")
+      );
+      return await pubKey.verify(
+        new TextEncoder().encode(data),
+        signatureBytes
+      );
+    } catch (error) {
+      console.error("Signature verification error:", error);
+      return false;
+    }
+  }
+  /**
+   * 转换为 HTML
+   */
+  async toHtml(wipFile, options = {}) {
+    const { title = "WIP Document", theme = "light" } = options;
+    const { payload, meta } = wipFile;
+    const escapeHtml = (text) => {
+      return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+    };
+    const formatText = (text, format) => {
+      switch (format) {
+        case "html":
+          return text;
+        case "markdown":
+          return text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\*(.+?)\*/g, "<em>$1</em>").replace(/\n/g, "<br>");
+        case "plain":
+        default:
+          return escapeHtml(text).replace(/\n/g, "<br>");
+      }
+    };
+    const bgColor = theme === "dark" ? "#1a1a1a" : "#ffffff";
+    const textColor = theme === "dark" ? "#e0e0e0" : "#333333";
+    const borderColor = theme === "dark" ? "#444444" : "#e0e0e0";
+    const verifiedColor = "#4caf50";
+    const warningColor = "#ff9800";
+    const verifyResult = await this.verify(wipFile);
+    const statusBadge = verifyResult.valid ? `<span style="background: ${verifiedColor}; color: white; padding: 4px 8px; border-radius: 4px; font-size: 12px;">\u2713 Verified</span>` : `<span style="background: ${warningColor}; color: white; padding: 4px 8px; border-radius: 4px; font-size: 12px;">\u26A0 Tampered</span>`;
+    const imagesHtml = payload.media.map(
+      (media) => `
+				<div style="margin: 16px 0; border: 1px solid ${borderColor}; border-radius: 8px; overflow: hidden;">
+					<img src="data:${media.type};base64,${media.data}" 
+					     style="max-width: 100%; height: auto; display: block;" 
+					     alt="${escapeHtml(media.filename || media.id)}" />
+					${media.filename ? `<div style="padding: 8px; font-size: 12px; color: #666; background: ${theme === "dark" ? "#2a2a2a" : "#f5f5f5"}; border-top: 1px solid ${borderColor};">${escapeHtml(media.filename)}</div>` : ""}
+				</div>
+			`
+    ).join("");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${escapeHtml(title)}</title>
+</head>
+<body style="margin: 0; padding: 20px; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: ${bgColor}; color: ${textColor}; line-height: 1.6;">
+    <div style="max-width: 800px; margin: 0 auto; background: ${theme === "dark" ? "#252525" : "#ffffff"}; border-radius: 12px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); overflow: hidden;">
+        <div style="padding: 20px 24px; border-bottom: 1px solid ${borderColor};">
+            <div style="display: flex; justify-content: space-between; align-items: center;">
+                <div>
+                    <h1 style="margin: 0; font-size: 20px; font-weight: 600;">${escapeHtml(title)}</h1>
+                    <div style="font-size: 12px; color: #666; margin-top: 4px;">
+                        WIP v${meta.version} \u2022 ${new Date(meta.created).toLocaleString()}
+                    </div>
+                </div>
+                ${statusBadge}
+            </div>
+            <div style="font-size: 11px; color: #999; margin-top: 12px; padding: 8px; background: ${theme === "dark" ? "#2a2a2a" : "#f5f5f5"}; border-radius: 4px; font-style: italic;">
+                Important Note: This page is for document browsing and verification reference only. Please verify the document integrity through the API using the WIP file.
+            </div>
+            ${verifyResult.signatures && verifyResult.signatures.length > 0 ? `
+            <div style="margin-top: 12px; padding: 8px; background: ${theme === "dark" ? "#2a3f2a" : "#e8f5e9"}; border-radius: 4px;">
+                <div style="font-size: 11px; color: ${theme === "dark" ? "#81c784" : "#2e7d32"}; margin-bottom: 4px;">\u2713 Signature Verification (${verifyResult.signatures.length} signature${verifyResult.signatures.length > 1 ? "s" : ""})</div>
+                ${verifyResult.signatures.map(
+      (s, idx) => `
+                    <div style="font-size: 10px; color: ${textColor}; margin-left: 8px;">
+                        ${idx + 1}. ${s.address ? escapeHtml(s.address.slice(0, 20)) + "..." : "Unknown"}: ${s.valid ? '<span style="color: #4caf50;">\u2713 Valid</span>' : '<span style="color: #f44336;">\u2717 Invalid</span>'}
+                    </div>
+                `
+    ).join("")}
+            </div>
+            ` : ""}
+        </div>
+        <div style="padding: 24px;">
+            <div style="font-size: 16px; line-height: 1.8; margin-bottom: 24px;">
+                ${formatText(payload.content.text, payload.content.format)}
+            </div>
+            ${imagesHtml}
+        </div>
+        <div style="padding: 16px 24px; background: ${theme === "dark" ? "#2a2a2a" : "#f8f9fa"}; border-top: 1px solid ${borderColor}; font-size: 11px; color: #666;">
+            <div style="display: flex; justify-content: space-between; align-items: center; flex-wrap: wrap; gap: 8px;">
+                <div>
+                    <strong>Hash:</strong> <code style="background: ${theme === "dark" ? "#333" : "#e9ecef"}; padding: 2px 6px; border-radius: 3px;">${escapeHtml(meta.hash)}</code>
+                </div>
+                <div>
+                    ${verifyResult.valid ? "Content integrity verified" : `Verification failed: ${escapeHtml(verifyResult.error || "Unknown error")}`}
+                </div>
+            </div>
+        </div>
+    </div>
+</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);
+      if (!obj.wip || !obj.payload || !obj.meta) {
+        throw new WipValidationError("Invalid WIP file structure");
+      }
+      return obj;
+    } catch (error) {
+      if (error instanceof WipError) {
+        throw error;
+      }
+      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);
+  }
+  /**
+   * 提取图片
+   */
+  extractImages(wipFile, outputDir) {
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const savedPaths = [];
+    for (const media of wipFile.payload.media) {
+      const ext = getExtensionFromMimeType(media.type);
+      const filename = media.filename || `${media.id}.${ext}`;
+      const outputPath = path.join(outputDir, filename);
+      const buffer = Buffer.from(base64ToUint8Array(media.data));
+      fs.writeFileSync(outputPath, buffer);
+      savedPaths.push(outputPath);
+    }
+    return savedPaths;
+  }
+  /**
+   * 保存到文件
+   */
+  save(wipFile, filePath, pretty = true) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    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);
+  }
+}
+async function createWip(options, limits) {
+  const wip = new WIP(limits);
+  return wip.create(options);
+}
+async function verifyWip(wipFile, hash_equal) {
+  if (hash_equal !== void 0 && wipFile.meta.hash.toLowerCase() !== hash_equal.toLowerCase()) {
+    return { valid: false, error: "Hash mismatch" };
+  }
+  const wip = new WIP();
+  return wip.verify(wipFile);
+}
+async function wipToHtml(wipFile, options) {
+  const wip = new WIP();
+  return wip.toHtml(wipFile, options);
+}
+async function loadWip(source, limits) {
+  const wip = new WIP(limits);
+  return wip.load(source);
+}
+async function generate_wip(options, outputPath) {
+  const wip = new WIP(DEFAULT_LIMITS);
+  let wipFile = await wip.create({
+    text: options.markdown_text,
+    textFormat: "markdown",
+    images: options.images
+  });
+  if (options.account) {
+    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}`
+      );
+    }
+    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}`
+      );
+    }
+    let publicKeyBase64;
+    if (accountData.pubkey.startsWith("0x")) {
+      const buffer = Buffer.from(accountData.pubkey.slice(2), "hex");
+      if (buffer.length === 33) {
+        publicKeyBase64 = buffer.slice(1).toString("base64");
+      } else if (buffer.length === 32) {
+        publicKeyBase64 = buffer.toString("base64");
+      } else {
+        throw new WipValidationError(
+          `Invalid public key length: ${buffer.length}, expected 32 or 33 bytes`
+        );
+      }
+    } else {
+      publicKeyBase64 = accountData.pubkey;
+    }
+    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];
+    } else {
+      signatures = [newSignature];
+    }
+    wipFile = {
+      ...wipFile,
+      meta: {
+        ...wipFile.meta,
+        signature: signatures
+      }
+    };
+  }
+  wip.save(wipFile, outputPath, true);
+  return outputPath;
+}
+async function verify_wip(wipFilePath, hash_equal) {
+  const wip = new WIP();
+  let wipFile;
+  try {
+    wipFile = await wip.load(wipFilePath);
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Failed to load WIP file: ${error}`,
+      hashValid: false,
+      hasSignature: false
+    };
+  }
+  if (!wipFile.wip || !wipFile.payload || !wipFile.meta) {
+    return {
+      valid: false,
+      error: "Invalid WIP file structure",
+      hashValid: false,
+      hasSignature: false
+    };
+  }
+  if (wipFile.meta.type !== "wip") {
+    return {
+      valid: false,
+      error: `Invalid meta.type: ${wipFile.meta.type}`,
+      hashValid: false,
+      hasSignature: !!wipFile.meta.signature
+    };
+  }
+  if (hash_equal !== void 0 && wipFile.meta.hash.toLowerCase() !== hash_equal.toLowerCase()) {
+    return {
+      valid: false,
+      error: "Hash mismatch",
+      hashValid: false,
+      hasSignature: !!wipFile.meta.signature
+    };
+  }
+  const canonicalPayload = canonicalizeJson(wipFile.payload);
+  const computedHash = computeHash(canonicalPayload);
+  const hashValid = computedHash === wipFile.meta.hash;
+  if (!hashValid) {
+    return {
+      valid: false,
+      error: "Hash mismatch - content has been tampered",
+      hashValid: false,
+      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");
+        const pubKey = new Ed25519PublicKey(sig.publicKey);
+        address = pubKey.toWAddress();
+      } catch {
+      }
+      signatures.push({
+        publicKey: sig.publicKey,
+        address,
+        valid: isValid
+      });
+      if (!isValid) {
+        allValid = false;
+      }
+    }
+    signatureValid = allValid;
+    if (!signatureValid) {
+      const failedAddresses = signatures.filter((s) => !s.valid && s.address).map((s) => s.address);
+      return {
+        valid: false,
+        error: `Signatures from the following addresses are invalid: ${failedAddresses.join(", ")}`,
+        hashValid: true,
+        signatureValid: false,
+        hasSignature: true,
+        signatures
+      };
+    }
+  }
+  return {
+    valid: true,
+    hashValid: true,
+    signatureValid,
+    hasSignature: !!wipFile.meta.signature,
+    signatures: signatures.length > 0 ? signatures : void 0
+  };
+}
+async function sign_wip(wipFilePath, account, outputPath) {
+  const wip = new WIP();
+  const wipFile = await wip.load(wipFilePath);
+  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}`);
+  }
+  const { Account } = await import("./account.js");
+  const address = await Account.Instance().get_address(account);
+  if (!address) {
+    throw new WipValidationError(`Account not found: ${account}`);
+  }
+  const signResult = await Account.Instance().signData(
+    address,
+    wipFile.meta.hash
+  );
+  let publicKeyBase64;
+  const pk = signResult.publicKey;
+  if (pk.startsWith("0x")) {
+    const buffer = Buffer.from(pk.slice(2), "hex");
+    if (buffer.length === 33) {
+      publicKeyBase64 = buffer.slice(1).toString("base64");
+    } else if (buffer.length === 32) {
+      publicKeyBase64 = buffer.toString("base64");
+    } else {
+      throw new WipValidationError(
+        `Invalid public key length: ${buffer.length}, expected 32 or 33 bytes`
+      );
+    }
+  } else {
+    publicKeyBase64 = pk;
+  }
+  const newSignature = {
+    value: Buffer.from(signResult.signature.slice(2), "hex").toString(
+      "base64"
+    ),
+    publicKey: publicKeyBase64,
+    algorithm: "Ed25519",
+    address: signResult.address
+  };
+  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];
+  }
+  const signedWipFile = {
+    ...wipFile,
+    meta: {
+      ...wipFile.meta,
+      signature: signatures
+    }
+  };
+  let savePath;
+  if (outputPath) {
+    savePath = outputPath;
+  } else {
+    const dir = path.dirname(wipFilePath);
+    const ext = path.extname(wipFilePath);
+    const baseName = path.basename(wipFilePath, ext);
+    savePath = path.join(dir, `signed_${baseName}${ext}`);
+  }
+  wip.save(signedWipFile, savePath, true);
+  return savePath;
+}
+async function wip2html(wipPath, options = {}) {
+  const fs2 = await import("fs");
+  const path2 = await import("path");
+  const stats = fs2.statSync(wipPath);
+  if (stats.isFile()) {
+    const wip = new WIP();
+    const wipFile = await wip.load(wipPath);
+    const html = await wip.toHtml(wipFile, options);
+    if (options.outputPath) {
+      fs2.writeFileSync(options.outputPath, html);
+      return options.outputPath;
+    }
+    return html;
+  } else if (stats.isDirectory()) {
+    const files = fs2.readdirSync(wipPath);
+    const wipFiles = files.filter((f) => f.endsWith(".wip"));
+    if (wipFiles.length === 0) {
+      throw new WipValidationError(
+        `No .wip files found in directory: ${wipPath}`
+      );
+    }
+    const results = [];
+    const wip = new WIP();
+    for (const file of wipFiles) {
+      const filePath = path2.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 ? path2.join(options.outputPath, outputFileName) : path2.join(wipPath, outputFileName);
+      const outputDir = path2.dirname(outputFilePath);
+      if (!fs2.existsSync(outputDir)) {
+        fs2.mkdirSync(outputDir, { recursive: true });
+      }
+      fs2.writeFileSync(outputFilePath, html);
+      results.push(outputFilePath);
+    }
+    return results;
+  } else {
+    throw new WipValidationError(`Invalid path: ${wipPath}`);
+  }
+}
+var wip_default = WIP;
+export {
+  DEFAULT_LIMITS,
+  WIP,
+  WipError,
+  WipSizeError,
+  WipValidationError,
+  createWip,
+  wip_default as default,
+  generate_wip,
+  loadWip,
+  sign_wip,
+  verifyWip,
+  verify_wip,
+  wip2html,
+  wipToHtml
+};