mcard-js 2.1.41 → 2.1.43

package/dist/{chunk-AWGFLRLI.js → chunk-SP4YPKPR.js}

@@ -1,190 +1,3 @@
-import {
-  validateHandle
-} from "./chunk-U3FWUPD3.js";
-import {
-  MCard
-} from "./chunk-QPZ2HNSU.js";
-
-// src/storage/IndexedDBEngine.ts
-import { openDB } from "idb";
-var IndexedDBEngine = class {
-  db = null;
-  dbName;
-  constructor(dbName = "mcard-db") {
-    this.dbName = dbName;
-  }
-  /**
-   * Initialize the database connection
-   */
-  async init() {
-    this.db = await openDB(this.dbName, 1, {
-      upgrade(db) {
-        if (!db.objectStoreNames.contains("cards")) {
-          db.createObjectStore("cards", { keyPath: "hash" });
-        }
-        if (!db.objectStoreNames.contains("handles")) {
-          const handleStore = db.createObjectStore("handles", { keyPath: "handle" });
-          handleStore.createIndex("by-hash", "currentHash");
-        }
-        if (!db.objectStoreNames.contains("handleHistory")) {
-          const historyStore = db.createObjectStore("handleHistory", {
-            keyPath: "id",
-            autoIncrement: true
-          });
-          historyStore.createIndex("by-handle", "handle");
-        }
-      }
-    });
-  }
-  ensureDb() {
-    if (!this.db) {
-      throw new Error("Database not initialized. Call init() first.");
-    }
-    return this.db;
-  }
-  // =========== Card Operations ===========
-  async add(card) {
-    const db = this.ensureDb();
-    await db.put("cards", {
-      hash: card.hash,
-      content: card.content,
-      g_time: card.g_time
-    });
-    return card.hash;
-  }
-  async get(hash) {
-    const db = this.ensureDb();
-    const record = await db.get("cards", hash);
-    if (!record) return null;
-    return MCard.fromData(record.content, record.hash, record.g_time);
-  }
-  async delete(hash) {
-    const db = this.ensureDb();
-    await db.delete("cards", hash);
-  }
-  async getPage(pageNumber, pageSize) {
-    const db = this.ensureDb();
-    const totalItems = await db.count("cards");
-    const totalPages = Math.ceil(totalItems / pageSize);
-    const allCards = await db.getAll("cards");
-    const start = (pageNumber - 1) * pageSize;
-    const pageRecords = allCards.slice(start, start + pageSize);
-    const items = pageRecords.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
-    return {
-      items,
-      totalItems,
-      pageNumber,
-      pageSize,
-      totalPages,
-      hasNext: pageNumber < totalPages,
-      hasPrevious: pageNumber > 1
-    };
-  }
-  async count() {
-    const db = this.ensureDb();
-    return db.count("cards");
-  }
-  async searchByHash(hashPrefix) {
-    const db = this.ensureDb();
-    const start = hashPrefix;
-    const end = hashPrefix + "\uFFFF";
-    const range = IDBKeyRange.bound(start, end);
-    const records = await db.getAll("cards", range);
-    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
-  }
-  async search(query, pageNumber, pageSize) {
-    const db = this.ensureDb();
-    const records = await db.getAll("cards");
-    const decoder = new TextDecoder();
-    const filtered = records.filter((r) => {
-      try {
-        const text = decoder.decode(r.content);
-        return text.includes(query);
-      } catch {
-        return false;
-      }
-    });
-    const totalItems = filtered.length;
-    const totalPages = Math.ceil(totalItems / pageSize);
-    const start = (pageNumber - 1) * pageSize;
-    const pageItems = filtered.slice(start, start + pageSize).map((r) => MCard.fromData(r.content, r.hash, r.g_time));
-    return {
-      items: pageItems,
-      totalItems,
-      pageNumber,
-      pageSize,
-      totalPages,
-      hasNext: pageNumber < totalPages,
-      hasPrevious: pageNumber > 1
-    };
-  }
-  async getAll() {
-    const db = this.ensureDb();
-    const records = await db.getAll("cards");
-    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
-  }
-  async clear() {
-    const db = this.ensureDb();
-    await db.clear("cards");
-    await db.clear("handles");
-    await db.clear("handleHistory");
-  }
-  // =========== Handle Operations ===========
-  async registerHandle(handle, hash) {
-    const db = this.ensureDb();
-    const normalized = validateHandle(handle);
-    const existing = await db.get("handles", normalized);
-    if (existing) {
-      throw new Error(`Handle '${handle}' already exists.`);
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await db.put("handles", {
-      handle: normalized,
-      currentHash: hash,
-      createdAt: now,
-      updatedAt: now
-    });
-  }
-  async resolveHandle(handle) {
-    const db = this.ensureDb();
-    const normalized = validateHandle(handle);
-    const record = await db.get("handles", normalized);
-    return record?.currentHash ?? null;
-  }
-  async getByHandle(handle) {
-    const hash = await this.resolveHandle(handle);
-    if (!hash) return null;
-    return this.get(hash);
-  }
-  async updateHandle(handle, newHash) {
-    const db = this.ensureDb();
-    const normalized = validateHandle(handle);
-    const existing = await db.get("handles", normalized);
-    if (!existing) {
-      throw new Error(`Handle '${handle}' not found.`);
-    }
-    const previousHash = existing.currentHash;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await db.add("handleHistory", {
-      handle: normalized,
-      previousHash,
-      changedAt: now
-    });
-    await db.put("handles", {
-      ...existing,
-      currentHash: newHash,
-      updatedAt: now
-    });
-    return previousHash;
-  }
-  async getHandleHistory(handle) {
-    const db = this.ensureDb();
-    const normalized = validateHandle(handle);
-    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
-    return records.map((r) => ({ previousHash: r.previousHash, changedAt: r.changedAt })).reverse();
-  }
-};
-
 // src/model/hash/algorithms/LocalSHA256.ts
 async function computeHash(content) {
   let contentStr;
@@ -429,7 +242,7 @@ var VerificationStatus = /* @__PURE__ */ ((VerificationStatus2) => {
 })(VerificationStatus || {});
 
 // src/ptr/browser/storage/MCardStore.ts
-import { openDB as openDB2 } from "idb";
+import { openDB } from "idb";
 
 // src/ptr/browser/constants.ts
 var MCARD_DB_NAME = "mcard-store";
@@ -439,10 +252,12 @@ var MCARD_DB_VERSION = 8;
 var MCardStore = class {
   dbPromise;
   constructor(dbName = MCARD_DB_NAME) {
-    this.dbPromise = openDB2(dbName, MCARD_DB_VERSION, {
+    this.dbPromise = openDB(dbName, MCARD_DB_VERSION, {
       upgrade(db, oldVersion, newVersion, transaction) {
-        if (db.objectStoreNames.contains("mcards")) db.deleteObjectStore("mcards");
-        if (db.objectStoreNames.contains("handles")) db.deleteObjectStore("handles");
+        const existingStoreNames = Array.from(db.objectStoreNames);
+        const rawDb = db;
+        if (existingStoreNames.includes("mcards")) rawDb.deleteObjectStore("mcards");
+        if (existingStoreNames.includes("handles")) rawDb.deleteObjectStore("handles");
         let cardStore;
         if (!db.objectStoreNames.contains("card")) {
           cardStore = db.createObjectStore("card", { keyPath: "hash" });
@@ -633,11 +448,12 @@ var ServiceWorkerPTR = class {
   start() {
     this.ws.connect();
     self.addEventListener("message", (event) => {
-      if (event.data) {
-        if (event.data.type === "clm_execute") {
-          this.handleLocalRequest(event);
-        } else if (event.data.type === "EXECUTE_CLM") {
-          this.handleDirectExecution(event);
+      const typedEvent = event;
+      if (typedEvent.data) {
+        if (typedEvent.data.type === "clm_execute") {
+          this.handleLocalRequest(typedEvent);
+        } else if (typedEvent.data.type === "EXECUTE_CLM") {
+          this.handleDirectExecution(typedEvent);
         }
       }
     });
@@ -648,12 +464,16 @@ var ServiceWorkerPTR = class {
   }
   async onMeshMessage(msg) {
     console.log("[ServiceWorkerPTR] Received from mesh:", msg);
-    if (msg.type === "clm_execute") {
-      await this.executeCLM(msg.clm_hash, msg.input_hash, msg.request_id);
-    } else if (msg.type === "clm_result") {
+    if (!msg || typeof msg !== "object" || Array.isArray(msg)) {
+      return;
+    }
+    const meshMessage = msg;
+    if (meshMessage.type === "clm_execute") {
+      await this.executeCLM(meshMessage.clm_hash || "", meshMessage.input_hash || "", meshMessage.request_id || "");
+    } else if (meshMessage.type === "clm_result") {
       const clients = await self.clients.matchAll();
       for (const client of clients) {
-        client.postMessage(msg);
+        client.postMessage(meshMessage);
       }
     }
   }
@@ -674,7 +494,7 @@ var ServiceWorkerPTR = class {
     console.log("[ServiceWorkerPTR] Direct Execution Request");
     try {
       const input = { content: { count: 0 } };
-      const result = await this.executeJavaScript(code, input, {});
+      const result = await this.executeJavaScript(code || "", input, {});
       if (port) {
         port.postMessage({
           result,
@@ -682,10 +502,11 @@ var ServiceWorkerPTR = class {
         });
       }
     } catch (e) {
+      const error = e;
       console.error("[ServiceWorkerPTR] Execution error:", e);
       if (port) {
         port.postMessage({
-          logs: [`[ServiceWorkerPTR] Error: ${e.message}`]
+          logs: [`[ServiceWorkerPTR] Error: ${error.message || String(e)}`]
         });
       }
     }
@@ -697,7 +518,7 @@ var ServiceWorkerPTR = class {
       const code = clmHash.includes("return") ? clmHash : "return input.content.count + 1;";
       const result = await this.executeJavaScript(code, input || { content: { count: 0 } }, {});
       const resultHash = `sha256:result_${requestId}`;
-      await this.store.putCard(resultHash, result);
+      await this.store.putCard(resultHash, this.toStoredContent(result));
       this.ws.send({
         type: "clm_result",
         request_id: requestId,
@@ -705,13 +526,14 @@ var ServiceWorkerPTR = class {
         success: true
       });
     } catch (e) {
+      const error = e;
       console.error("[ServiceWorkerPTR] Execution error:", e);
       this.ws.send({
         type: "clm_result",
         request_id: requestId,
         output_hash: "",
         success: false,
-        error: e.message
+        error: error.message || String(e)
       });
     }
   }
@@ -725,11 +547,20 @@ var ServiceWorkerPTR = class {
     }
   }
   // Pyodide support placeholder
-  // Implementing full Pyodide loading requires handling caching and CDN usage 
+  // Implementing full Pyodide loading requires handling caching and CDN usage
   // similar to SandboxWorker.ts but adapted for ServiceWorker environment.
   async executePython(code, input, context) {
     throw new Error("Python execution not fully implemented yet in ServiceWorkerPTR");
   }
+  toStoredContent(value) {
+    if (typeof value === "string" || value instanceof Uint8Array) {
+      return value;
+    }
+    if (value && typeof value === "object") {
+      return value;
+    }
+    return { value };
+  }
 };
 
 // src/ptr/FaroSidecar.ts
@@ -754,7 +585,7 @@ var FaroSidecar = class _FaroSidecar {
   }
   /**
    * Initialize the Faro SDK
-   * 
+   *
    * @param config Configuration options
    * @returns The initialized Faro instance or null if not in a browser environment
    */
@@ -908,92 +739,6 @@ var TextValidator = class _TextValidator extends BaseValidator {
   }
 };
 
-// src/model/detectors/BinarySignatureDetector.ts
-var BinarySignatureDetector = class _BinarySignatureDetector {
-  // Dictionary of binary signatures mapped to MIME types
-  // Note: In TS, we use numbers or number arrays for bytes
-  static SIGNATURES = {
-    // Images
-    "89504e470d0a1a0a": "image/png",
-    // \x89PNG\r\n\x1a\n
-    "ffd8ff": "image/jpeg",
-    "474946383761": "image/gif",
-    // GIF87a
-    "474946383961": "image/gif",
-    // GIF89a
-    "424d": "image/bmp",
-    // BM
-    "00000100": "image/x-icon",
-    "00000200": "image/x-icon",
-    // MP4
-    "00000018667479706d703432": "video/mp4",
-    // ...ftypmp42
-    "000000186674797069736f6d": "video/mp4",
-    // ...ftypisom
-    // ... (simplified for key common ones)
-    // Documents
-    "25504446": "application/pdf",
-    // %PDF
-    // Archives
-    "504b0304": "application/zip",
-    // PK\x03\x04
-    "1f8b08": "application/gzip",
-    "526172211a0700": "application/x-rar-compressed",
-    // Rar!
-    "377abcaf271c": "application/x-7z-compressed",
-    // 7z...
-    // Database
-    "53514c69746520666f726d6174203300": "application/x-sqlite3"
-    // SQLite format 3\0
-  };
-  static OLE_SIGNATURE = "d0cf11e0a1b11ae1";
-  /**
-   * Helper to convert hex string to Uint8Array for easy comparison if needed,
-   * but we will convert input bytes to hex for lookup.
-   */
-  detect(content) {
-    return this.detectFromBytes(content);
-  }
-  detectFromBytes(content) {
-    if (this.startsWithAscii(content, "RIFF")) {
-      return this.detectRiffFormat(content);
-    }
-    const hexHeader = this.toHex(content.slice(0, 32));
-    for (const [signature, mimeType] of Object.entries(_BinarySignatureDetector.SIGNATURES)) {
-      if (hexHeader.startsWith(signature)) {
-        if (signature === _BinarySignatureDetector.OLE_SIGNATURE) {
-          return "application/oleobject";
-        }
-        if (signature === "504b0304") {
-          return "application/zip";
-        }
-        return mimeType;
-      }
-    }
-    return "application/octet-stream";
-  }
-  detectRiffFormat(content) {
-    if (content.length < 12) return "application/octet-stream";
-    const formatType = this.toAscii(content.slice(8, 12));
-    if (formatType === "WAVE") return "audio/wav";
-    if (formatType === "WEBP") return "image/webp";
-    return "application/octet-stream";
-  }
-  startsWithAscii(content, str) {
-    if (content.length < str.length) return false;
-    for (let i = 0; i < str.length; i++) {
-      if (content[i] !== str.charCodeAt(i)) return false;
-    }
-    return true;
-  }
-  toAscii(content) {
-    return Array.from(content).map((b) => String.fromCharCode(b)).join("");
-  }
-  toHex(content) {
-    return Array.from(content).map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-};
-
 // src/model/validators/BinaryValidator.ts
 var BinaryValidator = class _BinaryValidator extends BaseValidator {
   static BINARY_MIME_TYPES = /* @__PURE__ */ new Set([
@@ -1007,7 +752,6 @@ var BinaryValidator = class _BinaryValidator extends BaseValidator {
     "audio/wav",
     "application/octet-stream"
   ]);
-  detector = new BinarySignatureDetector();
   canValidate(mimeType) {
     return _BinaryValidator.BINARY_MIME_TYPES.has(mimeType) || mimeType.startsWith("image/") || mimeType.startsWith("audio/") || mimeType.startsWith("video/");
   }
@@ -1035,29 +779,19 @@ var BinaryValidator = class _BinaryValidator extends BaseValidator {
     } else if (mimeType === "image/gif" && content.length <= 6) {
       throw new ValidationError("Invalid GIF content: truncated file");
     }
-    const signatures = BinarySignatureDetector.SIGNATURES;
-    let expectedSig = null;
-    for (const [sig, mime] of Object.entries(signatures)) {
-      if (mime === mimeType) {
-        expectedSig = sig;
-      }
-    }
-    if (expectedSig) {
-      const contentHex = this.toHex(content.slice(0, expectedSig.length / 2));
-      if (contentHex !== expectedSig) {
-        let hasMatch = false;
-        for (const [sig, mime] of Object.entries(signatures)) {
-          if (mime === mimeType) {
-            const currentHex = this.toHex(content.slice(0, sig.length / 2));
-            if (currentHex === sig) {
-              hasMatch = true;
-              break;
-            }
-          }
-        }
-        if (!hasMatch) {
-          throw new ValidationError(`Invalid ${mimeType} content: missing proper header`);
-        }
+    const signatures = {
+      "image/png": "89504e470d0a1a0a",
+      // \x89PNG\r\n\x1a\n
+      "image/jpeg": "ffd8ff",
+      // \xff\xd8\xff
+      "image/gif": "47494638"
+      // GIF8
+    };
+    if (signatures[mimeType]) {
+      const expectedSig = signatures[mimeType];
+      const currentHex = this.toHex(content.slice(0, expectedSig.length / 2));
+      if (!currentHex.startsWith(expectedSig) && currentHex !== expectedSig) {
+        throw new ValidationError(`Invalid ${mimeType} content: missing proper header`);
       }
     }
   }
@@ -1095,7 +829,7 @@ var ValidationRegistry = class {
   }
   /**
    * Validate content using appropriate validator.
-   * 
+   *
    * @param content The content to validate
    * @param mimeType The detected MIME type
    * @throws ValidationError If content is invalid
@@ -1126,7 +860,6 @@ var ValidationRegistry = class {
 var validationRegistry = new ValidationRegistry();
 
 export {
-  IndexedDBEngine,
   computeHash,
   Reader,
   Writer,