mcard-js 2.1.47 → 2.1.49

package/dist/chunk-ASW6AOA7.js

@@ -0,0 +1,140 @@
+// src/model/hash/HashValidator.ts
+var HashValidator = class {
+  /**
+   * Compute hash of content using specified algorithm
+   */
+  static async computeHash(content, algorithm = "sha256") {
+    const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    let algoName = "SHA-256";
+    switch (algorithm.toLowerCase()) {
+      case "sha1":
+        algoName = "SHA-1";
+        break;
+      case "sha-1":
+        algoName = "SHA-1";
+        break;
+      case "sha256":
+        algoName = "SHA-256";
+        break;
+      case "sha-256":
+        algoName = "SHA-256";
+        break;
+      case "sha384":
+        algoName = "SHA-384";
+        break;
+      case "sha-384":
+        algoName = "SHA-384";
+        break;
+      case "sha512":
+        algoName = "SHA-512";
+        break;
+      case "sha-512":
+        algoName = "SHA-512";
+        break;
+      default:
+        console.warn(`Algorithm ${algorithm} not natively supported or mapped, defaulting to SHA-256`);
+        algoName = "SHA-256";
+    }
+    const buffer = new Uint8Array(data).buffer;
+    const hashBuffer = await crypto.subtle.digest(algoName, buffer);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Validate that content matches expected hash
+   */
+  static async validate(content, expectedHash) {
+    const computedHash = await this.computeHash(content);
+    return computedHash === expectedHash;
+  }
+};
+
+// src/model/GTime.ts
+var VALID_HASH_ALGORITHMS = ["md5", "sha1", "sha224", "sha256", "sha384", "sha512"];
+var GTime = class {
+  static DEFAULT_ALGORITHM = "sha256";
+  /**
+   * Generate a GTime stamp for the current moment
+   * Format: ALGORITHM|TIMESTAMP|LOCALE_OR_DID
+   * Representing the mathematical coordinate (a,b,c) for an event signature.
+   */
+  static stampNow(hashAlgorithm = this.DEFAULT_ALGORITHM, localeOrDID = "UTC") {
+    const algo = hashAlgorithm.toLowerCase();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `${algo}|${timestamp}|${localeOrDID}`;
+  }
+  /**
+   * Parse a GTime string
+   */
+  static parse(gtime) {
+    const parts = gtime.split("|");
+    if (parts.length !== 3) {
+      throw new Error(`Invalid GTime format: ${gtime}`);
+    }
+    return {
+      algorithm: parts[0],
+      timestamp: new Date(parts[1]),
+      localeOrDID: parts[2]
+    };
+  }
+  /** Extract coordinate a: Algorithm */
+  static getAlgorithm(gtime) {
+    return this.parse(gtime).algorithm;
+  }
+  /** Alias for backward compatibility */
+  static getHashAlgorithm(gtime) {
+    return this.getAlgorithm(gtime);
+  }
+  /** Extract coordinate b: Timestamp */
+  static getTimestamp(gtime) {
+    return this.parse(gtime).timestamp;
+  }
+  /** Extract coordinate c: Locale or DID */
+  static getLocaleOrDID(gtime) {
+    return this.parse(gtime).localeOrDID;
+  }
+  /** Alias for backward compatibility */
+  static getRegionCode(gtime) {
+    return this.getLocaleOrDID(gtime);
+  }
+  /**
+   * Check if the provided hash function is valid.
+   * Matches Python's GTime.is_valid_hash_function()
+   */
+  static isValidHashFunction(hashFunction) {
+    if (!hashFunction || typeof hashFunction !== "string") {
+      return false;
+    }
+    return VALID_HASH_ALGORITHMS.includes(hashFunction.toLowerCase());
+  }
+  /**
+   * Check if the provided locale/region code is valid.
+   * Maintains backward compatibility by checking for strings.
+   */
+  static isValidRegionCode(regionCode) {
+    return Boolean(regionCode && typeof regionCode === "string");
+  }
+  /**
+   * Check if the provided timestamp is in ISO format.
+   * Matches Python's GTime.is_iso_format()
+   */
+  static isIsoFormat(timestamp) {
+    if (!timestamp || typeof timestamp !== "string") {
+      return false;
+    }
+    try {
+      const date = new Date(timestamp);
+      if (isNaN(date.getTime())) {
+        return false;
+      }
+      const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+      return isoPattern.test(timestamp);
+    } catch {
+      return false;
+    }
+  }
+};
+
+export {
+  HashValidator,
+  GTime
+};

package/dist/chunk-BJJZWPIF.js

@@ -0,0 +1,112 @@
+import {
+  AbstractSqlEngine,
+  CORE_SCHEMAS
+} from "./chunk-FPW33LMV.js";
+import {
+  DEFAULT_SQLJS_WASM_URL
+} from "./chunk-J3IDWMDN.js";
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+
+// src/storage/engines/SqliteWasmEngine.ts
+var SqliteWasmEngine = class extends AbstractSqlEngine {
+  db = null;
+  SQL = null;
+  /**
+   * Initialize the database
+   * @param wasmUrl URL to sql-wasm.wasm file (optional, defaults to CDN)
+   * @param existingData Optional existing database as Uint8Array
+   */
+  async init(wasmUrl, existingData) {
+    const initSqlJs = (await import("sql.js")).default;
+    const SQL = await initSqlJs({
+      locateFile: (file) => wasmUrl || `${DEFAULT_SQLJS_WASM_URL}${file}`
+    });
+    this.SQL = SQL;
+    this.db = existingData ? new SQL.Database(existingData) : new SQL.Database();
+    this.db.run(CORE_SCHEMAS.card);
+    this.db.run(CORE_SCHEMAS.handleRegistry);
+    this.db.run(CORE_SCHEMAS.handleHistory);
+    this.db.run(CORE_SCHEMAS.handleIndex);
+  }
+  ensureDb() {
+    if (!this.db) throw new Error("Database not initialized. Call init() first.");
+    return this.db;
+  }
+  // ======================================================================
+  // AbstractSqlEngine primitives
+  // ======================================================================
+  async queryRows(sql, ...params) {
+    const db = this.ensureDb();
+    const stmt = db.prepare(sql);
+    if (params.length > 0) stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      results.push(row);
+    }
+    stmt.free();
+    return results;
+  }
+  async execSql(sql, ...params) {
+    const db = this.ensureDb();
+    if (params.length === 0) {
+      db.run(sql);
+    } else {
+      db.run(sql, params);
+    }
+    return 0;
+  }
+  // ======================================================================
+  // Row → MCard conversion (sql.js returns Uint8Array for BLOBs)
+  // ======================================================================
+  rowToCard(row) {
+    const rawContent = row.content;
+    const content = rawContent instanceof Uint8Array ? rawContent : typeof rawContent === "string" ? new TextEncoder().encode(rawContent) : new Uint8Array(0);
+    return MCard.fromData(content, String(row.hash), String(row.g_time));
+  }
+  // ======================================================================
+  // sql.js-specific helpers
+  // ======================================================================
+  /**
+   * Export database as Uint8Array (for persistence)
+   */
+  export() {
+    return this.ensureDb().export();
+  }
+  /**
+   * Get raw sql.js Database for use with VectorStore adapter.
+   */
+  getRawDb() {
+    return this.ensureDb();
+  }
+  // =========== pruneHandleHistory override (needs count before delete) ===========
+  async pruneHandleHistory(handle, options = {}) {
+    const { validateHandle } = await import("./Handle-3N4QOA3U.js");
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    if (options.deleteAll) {
+      const stmt = db.prepare("SELECT COUNT(*) FROM handle_history WHERE handle = ?");
+      stmt.bind([normalized]);
+      stmt.step();
+      const count = stmt.get()[0];
+      stmt.free();
+      db.run("DELETE FROM handle_history WHERE handle = ?", [normalized]);
+      return count;
+    } else if (options.olderThan) {
+      const stmt = db.prepare("SELECT COUNT(*) FROM handle_history WHERE handle = ? AND changed_at < ?");
+      stmt.bind([normalized, options.olderThan]);
+      stmt.step();
+      const count = stmt.get()[0];
+      stmt.free();
+      db.run("DELETE FROM handle_history WHERE handle = ? AND changed_at < ?", [normalized, options.olderThan]);
+      return count;
+    }
+    return 0;
+  }
+};
+
+export {
+  SqliteWasmEngine
+};

package/dist/chunk-GGQCF7ZK.js

@@ -0,0 +1,170 @@
+import {
+  GTime,
+  HashValidator
+} from "./chunk-ASW6AOA7.js";
+
+// src/model/ContentTypeInterpreter.ts
+import { detect_content_type, is_binary_content as wasm_is_binary, get_extension as wasm_ext } from "mcard-wasm";
+var ContentTypeInterpreter = class {
+  static detect(content) {
+    return this.detectContentType(content).mimeType;
+  }
+  static detectContentType(content, fileExtension) {
+    const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    const result = detect_content_type(buffer, fileExtension);
+    return { mimeType: result[0], extension: result[1] };
+  }
+  static getExtension(mimeType) {
+    return wasm_ext(mimeType) || "bin";
+  }
+  static isBinaryContent(content, mimeType) {
+    const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    return wasm_is_binary(buffer);
+  }
+  // Stub or bypass irrelevant manual TS rules now managed by mcard-core
+  static registerExtension(mimeType, extension) {
+  }
+  static registerExtensions(mapping) {
+  }
+  static isKnownLongLineExtension(extension) {
+    return false;
+  }
+  static isUnstructuredBinary(sample) {
+    if (sample.length < 512) return false;
+    let nullCount = 0;
+    let controlChars = 0;
+    for (let i = 0; i < sample.length; i++) {
+      const b = sample[i];
+      if (b === 0) nullCount++;
+      if (b < 32 && b !== 9 && b !== 10 && b !== 13) controlChars++;
+    }
+    const nullRatio = nullCount / sample.length;
+    const controlRatio = controlChars / sample.length;
+    return nullRatio > 0.1 || controlRatio > 0.2;
+  }
+  static hasPathologicalLines(sample, isKnownType) {
+    return false;
+  }
+};
+
+// src/types/dots.ts
+function createMCardDOTSMetadata(tightRefs = [], looseRefs = []) {
+  return {
+    role: "Carrier" /* CARRIER */,
+    eosRole: "InvariantContent" /* INVARIANT_CONTENT */,
+    plane: "Data" /* DATA */,
+    tightRefs,
+    looseRefs
+  };
+}
+function createPCardDOTSMetadata(isLens, tightRefs = [], looseRefs = []) {
+  return {
+    role: isLens ? "Lens" /* LENS */ : "Chart" /* CHART */,
+    eosRole: "GenerativeLens" /* GENERATIVE_LENS */,
+    plane: "Control" /* CONTROL */,
+    tightRefs,
+    looseRefs
+  };
+}
+function createVCardDOTSMetadata() {
+  return {
+    role: "Arena" /* ARENA */,
+    eosRole: "SovereignDecision" /* SOVEREIGN_DECISION */,
+    plane: "Application" /* APPLICATION */
+  };
+}
+
+// src/model/MCard.ts
+var MCard = class _MCard {
+  content;
+  hash;
+  g_time;
+  contentType;
+  // Defaulting to specific string or null
+  hashFunction;
+  constructor(content, hash, g_time, contentType, hashFunction) {
+    this.content = content;
+    this.hash = hash;
+    this.g_time = g_time;
+    this.contentType = contentType;
+    this.hashFunction = hashFunction;
+  }
+  /**
+   * Create a new MCard from content
+   */
+  static async create(content, hashAlgorithm = "sha256") {
+    if (content === null || content === void 0) {
+      throw new Error("Content cannot be null or undefined");
+    }
+    const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    if (bytes.length === 0) {
+      throw new Error("Content cannot be empty");
+    }
+    const hash = await HashValidator.computeHash(bytes, hashAlgorithm);
+    const g_time = GTime.stampNow(hashAlgorithm);
+    const contentType = ContentTypeInterpreter.detect(bytes);
+    return new _MCard(bytes, hash, g_time, contentType, hashAlgorithm);
+  }
+  /**
+   * Create an MCard from existing data (e.g., from database)
+   */
+  static fromData(content, hash, g_time) {
+    const alg = GTime.getHashAlgorithm(g_time);
+    const contentType = ContentTypeInterpreter.detect(content);
+    return new _MCard(content, hash, g_time, contentType, alg);
+  }
+  /**
+   * Get content as text (UTF-8 decoded)
+   */
+  getContentAsText() {
+    return new TextDecoder().decode(this.content);
+  }
+  /**
+   * Get content as raw bytes
+   */
+  getContent() {
+    return this.content;
+  }
+  /**
+   * Convert to plain object
+   */
+  toObject() {
+    return {
+      hash: this.hash,
+      content: this.getContentAsText(),
+      g_time: this.g_time,
+      contentType: this.contentType,
+      hashFunction: this.hashFunction
+    };
+  }
+  /**
+   * Get DOTS vocabulary metadata for this MCard
+   *
+   * Returns the DOTS role information that positions this MCard
+   * in the Double Operadic Theory of Systems framework.
+   *
+   * MCard is always a CARRIER object in the Data Plane.
+   *
+   * @param tightRefs - Optional array of prerequisite MCard hashes (vertical composition)
+   * @param looseRefs - Optional array of alternative MCard hashes (horizontal composition)
+   * @returns DOTSMetadata describing this card's role in the compositional system
+   *
+   * @example
+   * ```typescript
+   * const card = await MCard.create('Hello World');
+   * const meta = card.getDOTSMetadata();
+   * console.log(meta.role);  // 'Carrier'
+   * console.log(meta.plane); // 'Data'
+   * ```
+   */
+  getDOTSMetadata(tightRefs = [], looseRefs = []) {
+    return createMCardDOTSMetadata(tightRefs, looseRefs);
+  }
+};
+
+export {
+  ContentTypeInterpreter,
+  createPCardDOTSMetadata,
+  createVCardDOTSMetadata,
+  MCard
+};