mcard-js 2.1.49 → 2.1.51

package/dist/chunk-4T3H25AP.js

@@ -0,0 +1,299 @@
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+import {
+  DEFAULT_PAGE_SIZE
+} from "./chunk-R3XRBAM7.js";
+
+// src/monads/Maybe.ts
+var Maybe = class _Maybe {
+  constructor(_value, _isNothing) {
+    this._value = _value;
+    this._isNothing = _isNothing;
+  }
+  /**
+   * Create a Just (has value)
+   */
+  static just(value) {
+    return new _Maybe(value, false);
+  }
+  /**
+   * Create a Nothing (no value)
+   */
+  static nothing() {
+    return new _Maybe(null, true);
+  }
+  /**
+   * Check if this is Nothing
+   */
+  get isNothing() {
+    return this._isNothing;
+  }
+  /**
+   * Check if this is Just
+   */
+  get isJust() {
+    return !this._isNothing;
+  }
+  /**
+   * Get the value (throws if Nothing)
+   */
+  get value() {
+    if (this._isNothing) {
+      throw new Error("Cannot get value from Nothing");
+    }
+    return this._value;
+  }
+  /**
+   * Monadic bind - chain operations
+   * Short-circuits on Nothing
+   */
+  bind(fn) {
+    if (this._isNothing) {
+      return _Maybe.nothing();
+    }
+    return fn(this._value);
+  }
+  /**
+   * Map a function over the value
+   */
+  map(fn) {
+    if (this._isNothing) {
+      return _Maybe.nothing();
+    }
+    return _Maybe.just(fn(this._value));
+  }
+  /**
+   * Get value or default
+   */
+  getOrElse(defaultValue) {
+    return this._isNothing ? defaultValue : this._value;
+  }
+};
+
+// src/model/CardCollection.ts
+var CardCollection = class {
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  // =========== Standard Operations ===========
+  /**
+   * Add a card to the collection
+   * Handles duplicates (same content, same hash) and collisions (diff content, same hash)
+   */
+  async add(card) {
+    const existingCard = await this.engine.get(card.hash);
+    if (existingCard) {
+      const isDuplicate = this.areContentsEqual(existingCard.content, card.content);
+      if (isDuplicate) {
+        const { generateDuplicationEvent } = await import("./EventProducer-VFDOM5W2.js");
+        const eventStr = generateDuplicationEvent(card);
+        const eventCard = await MCard.create(eventStr);
+        await this.engine.add(eventCard);
+        return card.hash;
+      } else {
+        const { generateCollisionEvent } = await import("./EventProducer-VFDOM5W2.js");
+        const eventStr = await generateCollisionEvent(card);
+        const eventCard = await MCard.create(eventStr);
+        await this.engine.add(eventCard);
+        const eventObj = JSON.parse(eventStr);
+        const nextAlgo = eventObj.upgraded_function;
+        if (!nextAlgo) {
+          throw new Error("Failed to determine next hash algorithm for collision");
+        }
+        const upgradedCard = await MCard.create(card.content, nextAlgo);
+        return this.engine.add(upgradedCard);
+      }
+    }
+    return this.engine.add(card);
+  }
+  areContentsEqual(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+  /**
+   * Get a card by hash
+   */
+  async get(hash) {
+    return this.engine.get(hash);
+  }
+  /**
+   * Delete a card by hash
+   */
+  async delete(hash) {
+    return this.engine.delete(hash);
+  }
+  /**
+   * Get a page of cards
+   */
+  async getPage(pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    return this.engine.getPage(pageNumber, pageSize);
+  }
+  /**
+   * Count total cards
+   */
+  async count() {
+    return this.engine.count();
+  }
+  // =========== Handle Operations ===========
+  /**
+   * Add a card and register a handle for it
+   */
+  async addWithHandle(card, handle) {
+    const hash = await this.add(card);
+    await this.engine.registerHandle(handle, hash);
+    return hash;
+  }
+  /**
+   * Get card by handle
+   */
+  async getByHandle(handle) {
+    return this.engine.getByHandle(handle);
+  }
+  /**
+   * Resolve handle to hash
+   */
+  async resolveHandle(handle) {
+    return this.engine.resolveHandle(handle);
+  }
+  /**
+   * Update handle to point to new card
+   */
+  async updateHandle(handle, newCard) {
+    const hash = await this.add(newCard);
+    await this.engine.updateHandle(handle, hash);
+    return hash;
+  }
+  /**
+   * Get version history for a handle
+   */
+  async getHandleHistory(handle) {
+    return this.engine.getHandleHistory(handle);
+  }
+  // =========== Monadic Operations ===========
+  /**
+   * Monadic get - returns Maybe<MCard>
+   */
+  async getM(hash) {
+    const card = await this.get(hash);
+    return card ? Maybe.just(card) : Maybe.nothing();
+  }
+  /**
+   * Monadic getByHandle - returns Maybe<MCard>
+   */
+  async getByHandleM(handle) {
+    const card = await this.getByHandle(handle);
+    return card ? Maybe.just(card) : Maybe.nothing();
+  }
+  /**
+   * Monadic resolveHandle - returns Maybe<string>
+   */
+  async resolveHandleM(handle) {
+    const hash = await this.resolveHandle(handle);
+    return hash ? Maybe.just(hash) : Maybe.nothing();
+  }
+  /**
+   * Resolve handle and get card in one monadic operation
+   */
+  async resolveAndGetM(handle) {
+    const maybeHash = await this.resolveHandleM(handle);
+    if (maybeHash.isNothing) return Maybe.nothing();
+    return this.getM(maybeHash.value);
+  }
+  /**
+   * Prune version history for a handle.
+   * @param handle The handle string.
+   * @param options Options for pruning (olderThan date, or deleteAll).
+   * @returns Number of deleted entries.
+   */
+  async pruneHandleHistory(handle, options = {}) {
+    if (this.engine.pruneHandleHistory) {
+      return this.engine.pruneHandleHistory(handle, options);
+    }
+    return 0;
+  }
+  // =========== Search & Bulk Operations ===========
+  async clear() {
+    return this.engine.clear();
+  }
+  async searchByString(query, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    return this.engine.search(query, pageNumber, pageSize);
+  }
+  async searchByContent(query, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    return this.engine.search(query, pageNumber, pageSize);
+  }
+  async searchByHash(hashPrefix) {
+    return this.engine.searchByHash(hashPrefix);
+  }
+  async getAllMCardsRaw() {
+    return this.engine.getAll();
+  }
+  async getAllCards(pageSize = DEFAULT_PAGE_SIZE, processCallback) {
+    const cards = [];
+    let pageNumber = 1;
+    let total = 0;
+    while (true) {
+      const page = await this.getPage(pageNumber, pageSize);
+      if (!page.items || page.items.length === 0) break;
+      for (const card of page.items) {
+        if (processCallback) {
+          processCallback(card);
+        }
+        cards.push(card);
+      }
+      total = page.totalItems;
+      if (!page.hasNext) break;
+      pageNumber++;
+    }
+    return { cards, total };
+  }
+  async printAllCards() {
+    const cards = await this.getAllMCardsRaw();
+    cards.forEach((card) => {
+      console.log(`Hash: ${card.hash}`);
+      try {
+        const text = new TextDecoder().decode(card.content);
+        const preview = text.slice(0, 100).replace(/\n/g, " ");
+        console.log(`Content: ${preview}${text.length > 100 ? "..." : ""}`);
+      } catch {
+        console.log(`Content (binary): ${card.content.length} bytes`);
+      }
+      console.log("---");
+    });
+  }
+  // =========== Handle Management Operations ===========
+  /**
+   * List all registered handles with their current hashes.
+   */
+  async getAllHandles() {
+    return this.engine.getAllHandles();
+  }
+  /**
+   * Remove a handle and all its history entries.
+   * Does NOT delete the underlying card(s).
+   */
+  async removeHandle(handle) {
+    return this.engine.removeHandle(handle);
+  }
+  /**
+   * Rename a handle atomically: updates handle registry and all history entries.
+   */
+  async renameHandle(oldHandle, newHandle) {
+    return this.engine.renameHandle(oldHandle, newHandle);
+  }
+  /**
+   * Delete a single history entry by handle + previousHash, stitching the chain.
+   */
+  async deleteHistoryEntry(handle, previousHash) {
+    return this.engine.deleteHistoryEntry(handle, previousHash);
+  }
+};
+
+export {
+  Maybe,
+  CardCollection
+};

package/dist/chunk-5DFXPIRL.js

@@ -0,0 +1,42 @@
+// src/ptr/node/NetworkConfig.ts
+var HTTP_DEFAULT_MAX_ATTEMPTS = 1;
+var HTTP_DEFAULT_BACKOFF = "exponential";
+var HTTP_DEFAULT_BASE_DELAY_MS = 1e3;
+var HTTP_DEFAULT_MAX_DELAY_MS = 3e4;
+var HTTP_DEFAULT_TIMEOUT_MS = 3e4;
+var HTTP_DEFAULT_CACHE_TTL_SECONDS = 300;
+var RATE_LIMIT_DEFAULT_TOKENS_PER_SECOND = 10;
+var RATE_LIMIT_DEFAULT_MAX_BURST = 20;
+var RATE_LIMIT_WAIT_INTERVAL_MS = 100;
+var NETWORK_DEFAULT_LISTEN_PORT = 3e3;
+var NETWORK_DEFAULT_SIGNALING_MAX_PORT_TRIES = 10;
+var NETWORK_DEFAULT_HOST = "localhost";
+var NETWORK_DEFAULT_ORCHESTRATOR_SLEEP_MS = 1e3;
+var WEBSOCKET_SERVER_START_WAIT_MS = 3e3;
+var STATIC_SERVER_START_WAIT_MS = 1500;
+var PROCESS_TERMINATE_WAIT_MS = 500;
+var SESSION_RECORD_DEFAULT_MAX_BUFFER_SIZE = 5;
+var WEBRTC_DEFAULT_TIMEOUT_MS = 3e4;
+var WEBRTC_DEFAULT_MOCK_DELAY_MS = 100;
+
+export {
+  HTTP_DEFAULT_MAX_ATTEMPTS,
+  HTTP_DEFAULT_BACKOFF,
+  HTTP_DEFAULT_BASE_DELAY_MS,
+  HTTP_DEFAULT_MAX_DELAY_MS,
+  HTTP_DEFAULT_TIMEOUT_MS,
+  HTTP_DEFAULT_CACHE_TTL_SECONDS,
+  RATE_LIMIT_DEFAULT_TOKENS_PER_SECOND,
+  RATE_LIMIT_DEFAULT_MAX_BURST,
+  RATE_LIMIT_WAIT_INTERVAL_MS,
+  NETWORK_DEFAULT_LISTEN_PORT,
+  NETWORK_DEFAULT_SIGNALING_MAX_PORT_TRIES,
+  NETWORK_DEFAULT_HOST,
+  NETWORK_DEFAULT_ORCHESTRATOR_SLEEP_MS,
+  WEBSOCKET_SERVER_START_WAIT_MS,
+  STATIC_SERVER_START_WAIT_MS,
+  PROCESS_TERMINATE_WAIT_MS,
+  SESSION_RECORD_DEFAULT_MAX_BUFFER_SIZE,
+  WEBRTC_DEFAULT_TIMEOUT_MS,
+  WEBRTC_DEFAULT_MOCK_DELAY_MS
+};

package/dist/chunk-5HRZV4R3.js

@@ -0,0 +1,217 @@
+import {
+  AbstractSqlEngine,
+  initCoreSchemas
+} from "./chunk-GIKMCG4D.js";
+import {
+  createPage
+} from "./chunk-3EIBJPNF.js";
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+import {
+  Handle_exports,
+  init_Handle
+} from "./chunk-ADV52544.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  SQLITE_BUSY_TIMEOUT_MS
+} from "./chunk-ETJWXHKZ.js";
+import {
+  __toCommonJS
+} from "./chunk-PNKVD2UK.js";
+
+// src/storage/engines/SqliteNodeEngine.ts
+var SqliteNodeEngine = class _SqliteNodeEngine extends AbstractSqlEngine {
+  db;
+  dbPath;
+  /**
+   * Convert a database row into an MCard instance.
+   */
+  rowToCard(row) {
+    const rawContent = row.content;
+    const content = rawContent instanceof Buffer ? new Uint8Array(rawContent) : new Uint8Array(rawContent);
+    return MCard.fromData(content, String(row.hash), String(row.g_time));
+  }
+  /**
+   * Create a new SqliteNodeEngine via async factory.
+   * @param dbPath Path to database file, or ':memory:' for in-memory database
+   */
+  static async create(dbPath = ":memory:") {
+    const engine = new _SqliteNodeEngine(dbPath);
+    await engine.init();
+    return engine;
+  }
+  constructor(dbPath) {
+    super();
+    this.dbPath = dbPath;
+  }
+  async init() {
+    try {
+      const mod = await import("better-sqlite3");
+      const Database = mod.default || mod;
+      this.db = new Database(this.dbPath);
+      this.setupDatabase();
+    } catch (e) {
+      console.error(`SqliteNodeEngine: Failed to load better-sqlite3: ${e.message}`);
+      throw e;
+    }
+  }
+  /**
+   * Initialize database schema
+   */
+  setupDatabase() {
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma(`busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
+    this.db.pragma("synchronous = NORMAL");
+    initCoreSchemas(this.db);
+  }
+  // ======================================================================
+  // AbstractSqlEngine primitives
+  // ======================================================================
+  async queryRows(sql, ...params) {
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params);
+  }
+  async execSql(sql, ...params) {
+    if (params.length === 0) {
+      this.db.exec(sql);
+      return 0;
+    }
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(...params);
+    return result.changes;
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Get the database path
+   */
+  getDbPath() {
+    return this.dbPath;
+  }
+  // =========== Card Operations (overrides to use Buffer.from for better-sqlite3) ===========
+  async add(card) {
+    const stmt = this.db.prepare(
+      "INSERT OR REPLACE INTO card (hash, content, g_time) VALUES (?, ?, ?)"
+    );
+    stmt.run(card.hash, Buffer.from(card.content), card.g_time);
+    return card.hash;
+  }
+  // =========== Sync card operations (for performance-critical callers) ===========
+  addSync(card) {
+    const stmt = this.db.prepare(
+      "INSERT OR REPLACE INTO card (hash, content, g_time) VALUES (?, ?, ?)"
+    );
+    stmt.run(card.hash, Buffer.from(card.content), card.g_time);
+    return card.hash;
+  }
+  getSync(hash) {
+    const stmt = this.db.prepare("SELECT hash, content, g_time FROM card WHERE hash = ?");
+    const row = stmt.get(hash);
+    if (!row) return null;
+    return this.rowToCard(row);
+  }
+  deleteSync(hash) {
+    const stmt = this.db.prepare("DELETE FROM card WHERE hash = ?");
+    const result = stmt.run(hash);
+    return result.changes > 0;
+  }
+  getPageSync(pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    if (pageNumber < 1) throw new Error("Page number must be >= 1");
+    if (pageSize < 1) throw new Error("Page size must be >= 1");
+    const totalItems = this.countSync();
+    const offset = (pageNumber - 1) * pageSize;
+    const stmt = this.db.prepare(
+      "SELECT hash, content, g_time FROM card ORDER BY g_time DESC LIMIT ? OFFSET ?"
+    );
+    const rows = stmt.all(pageSize, offset);
+    const items = rows.map((row) => this.rowToCard(row));
+    return createPage(items, totalItems, pageNumber, pageSize);
+  }
+  countSync() {
+    const stmt = this.db.prepare("SELECT COUNT(*) as cnt FROM card");
+    const row = stmt.get();
+    return row.cnt;
+  }
+  clearSync() {
+    this.db.exec("DELETE FROM handle_history");
+    this.db.exec("DELETE FROM handle_registry");
+    this.db.exec("DELETE FROM card");
+  }
+  // =========== Additional sync search operations ===========
+  searchByString(searchString, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    if (pageNumber < 1) throw new Error("Page number must be >= 1");
+    if (pageSize < 1) throw new Error("Page size must be >= 1");
+    const pattern = `%${searchString}%`;
+    const offset = (pageNumber - 1) * pageSize;
+    const countStmt = this.db.prepare(`
+            SELECT COUNT(*) as cnt FROM card
+            WHERE hash LIKE ? OR g_time LIKE ? OR CAST(content AS TEXT) LIKE ?
+        `);
+    const countRow = countStmt.get(pattern, pattern, pattern);
+    const totalItems = countRow.cnt;
+    const stmt = this.db.prepare(`
+            SELECT hash, content, g_time FROM card
+            WHERE hash LIKE ? OR g_time LIKE ? OR CAST(content AS TEXT) LIKE ?
+            ORDER BY g_time DESC LIMIT ? OFFSET ?
+        `);
+    const rows = stmt.all(pattern, pattern, pattern, pageSize, offset);
+    const items = rows.map((row) => this.rowToCard(row));
+    return createPage(items, totalItems, pageNumber, pageSize);
+  }
+  searchByContent(searchPattern, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    if (pageNumber < 1) throw new Error("Page number must be >= 1");
+    if (pageSize < 1) throw new Error("Page size must be >= 1");
+    if (!searchPattern || typeof searchPattern === "string" && searchPattern.length === 0) {
+      throw new Error("Search pattern cannot be empty");
+    }
+    const searchBytes = typeof searchPattern === "string" ? Buffer.from(searchPattern, "utf-8") : Buffer.from(searchPattern);
+    const offset = (pageNumber - 1) * pageSize;
+    const countStmt = this.db.prepare("SELECT COUNT(*) as cnt FROM card WHERE INSTR(content, ?) > 0");
+    const countRow = countStmt.get(searchBytes);
+    const totalItems = countRow.cnt;
+    const stmt = this.db.prepare(`
+            SELECT hash, content, g_time FROM card
+            WHERE INSTR(content, ?) > 0
+            ORDER BY g_time DESC LIMIT ? OFFSET ?
+        `);
+    const rows = stmt.all(searchBytes, pageSize, offset);
+    const items = rows.map((row) => this.rowToCard(row));
+    return createPage(items, totalItems, pageNumber, pageSize);
+  }
+  getAllCards() {
+    const stmt = this.db.prepare("SELECT hash, content, g_time FROM card ORDER BY g_time DESC");
+    const rows = stmt.all();
+    const items = rows.map((row) => this.rowToCard(row));
+    return createPage(items, items.length, 1, items.length || 1);
+  }
+  // =========== Unique sync method (not in AbstractSqlEngine) ===========
+  deleteHistoryEntrySync(handle, previousHash) {
+    const { validateHandle } = (init_Handle(), __toCommonJS(Handle_exports));
+    const normalized = validateHandle(handle);
+    const performStitch = this.db.transaction(() => {
+      const rOut = this.db.prepare(
+        "SELECT id, previous_hash FROM handle_history WHERE handle = ? AND previous_hash = ? ORDER BY id DESC LIMIT 1"
+      ).get(normalized, previousHash);
+      if (!rOut) return;
+      const rIn = this.db.prepare(
+        "SELECT id, previous_hash FROM handle_history WHERE handle = ? AND id < ? ORDER BY id DESC LIMIT 1"
+      ).get(normalized, rOut.id);
+      if (rIn) {
+        this.db.prepare("UPDATE handle_history SET previous_hash = ? WHERE id = ?").run(rIn.previous_hash, rOut.id);
+        this.db.prepare("DELETE FROM handle_history WHERE id = ?").run(rIn.id);
+      } else {
+        this.db.prepare("DELETE FROM handle_history WHERE id = ?").run(rOut.id);
+      }
+    });
+    performStitch();
+  }
+};
+
+export {
+  SqliteNodeEngine
+};