mcard-js 2.1.41 → 2.1.43

package/dist/chunk-2VNRWIBZ.js

@@ -1,389 +0,0 @@
-import {
-  initCoreSchemas
-} from "./chunk-DWXNZ5AJ.js";
-import {
-  createPage,
-  validateHandle
-} from "./chunk-NZ6OQ7UT.js";
-import {
-  MCard
-} from "./chunk-WVFWNVT2.js";
-
-// src/storage/engines/SqliteNodeEngine.ts
-var DEFAULT_PAGE_SIZE = 10;
-var SqliteNodeEngine = class _SqliteNodeEngine {
-  db;
-  dbPath;
-  /**
-   * Convert a database row into an MCard instance.
-   */
-  static rowToCard(row) {
-    const content = row.content instanceof Buffer ? new Uint8Array(row.content) : new Uint8Array(row.content);
-    return MCard.fromData(content, row.hash, 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) {
-    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 = 5000");
-    this.db.pragma("synchronous = NORMAL");
-    initCoreSchemas(this.db);
-  }
-  /**
-   * Close the database connection
-   */
-  close() {
-    this.db.close();
-  }
-  /**
-   * Get the database path
-   */
-  getDbPath() {
-    return this.dbPath;
-  }
-  // =========== Card Operations ===========
-  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;
-  }
-  /**
-   * Add a card synchronously (for performance-critical paths)
-   */
-  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;
-  }
-  async get(hash) {
-    return this.getSync(hash);
-  }
-  /**
-   * Get a card synchronously
-   */
-  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 _SqliteNodeEngine.rowToCard(row);
-  }
-  async delete(hash) {
-    this.deleteSync(hash);
-  }
-  /**
-   * Delete a card synchronously
-   */
-  deleteSync(hash) {
-    const stmt = this.db.prepare("DELETE FROM card WHERE hash = ?");
-    const result = stmt.run(hash);
-    return result.changes > 0;
-  }
-  async getPage(pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
-    return this.getPageSync(pageNumber, pageSize);
-  }
-  /**
-   * Get a page of cards synchronously
-   */
-  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) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  async count() {
-    return this.countSync();
-  }
-  /**
-   * Count cards synchronously
-   */
-  countSync() {
-    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM card");
-    const row = stmt.get();
-    return row.count;
-  }
-  async searchByHash(hashPrefix) {
-    const rows = this.db.prepare("SELECT hash, content, g_time FROM card WHERE hash LIKE ?").all(`${hashPrefix}%`);
-    return rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-  }
-  async search(query, pageNumber, pageSize) {
-    const offset = (pageNumber - 1) * pageSize;
-    const searchPattern = `%${query}%`;
-    const countResult = this.db.prepare("SELECT COUNT(*) as count FROM card WHERE CAST(content AS TEXT) LIKE ?").get(searchPattern);
-    const totalItems = countResult.count;
-    const rows = this.db.prepare("SELECT hash, content, g_time FROM card WHERE CAST(content AS TEXT) LIKE ? LIMIT ? OFFSET ?").all(searchPattern, pageSize, offset);
-    const items = rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  async getAll() {
-    const rows = this.db.prepare("SELECT hash, content, g_time FROM card").all();
-    return rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-  }
-  async clear() {
-    this.clearSync();
-  }
-  /**
-   * Clear all data synchronously
-   * Delete in FK-safe order: children first, then parents
-   */
-  clearSync() {
-    this.db.exec("DELETE FROM handle_history");
-    this.db.exec("DELETE FROM handle_registry");
-    this.db.exec("DELETE FROM card");
-  }
-  // =========== Search Operations ===========
-  /**
-   * Search cards by string in content, hash, or g_time
-   */
-  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 count 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.count;
-    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) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  /**
-   * Search cards by content pattern (binary-safe)
-   */
-  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 count FROM card WHERE INSTR(content, ?) > 0");
-    const countRow = countStmt.get(searchBytes);
-    const totalItems = countRow.count;
-    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) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  /**
-   * Get all cards (single page with all items)
-   */
-  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) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, items.length, 1, items.length || 1);
-  }
-  // =========== Handle Operations ===========
-  async registerHandle(handle, hash) {
-    this.registerHandleSync(handle, hash);
-  }
-  /**
-   * Register a handle synchronously
-   */
-  registerHandleSync(handle, hash) {
-    const normalized = validateHandle(handle);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const checkStmt = this.db.prepare("SELECT handle FROM handle_registry WHERE handle = ?");
-    const existing = checkStmt.get(normalized);
-    if (existing) {
-      throw new Error(`Handle '${handle}' already exists.`);
-    }
-    const stmt = this.db.prepare(
-      "INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, ?, ?)"
-    );
-    stmt.run(normalized, hash, now, now);
-  }
-  async resolveHandle(handle) {
-    return this.resolveHandleSync(handle);
-  }
-  /**
-   * Resolve a handle synchronously
-   */
-  resolveHandleSync(handle) {
-    const normalized = validateHandle(handle);
-    const stmt = this.db.prepare("SELECT current_hash FROM handle_registry WHERE handle = ?");
-    const row = stmt.get(normalized);
-    return row?.current_hash || null;
-  }
-  async getByHandle(handle) {
-    return this.getByHandleSync(handle);
-  }
-  /**
-   * Get card by handle synchronously
-   */
-  getByHandleSync(handle) {
-    const hash = this.resolveHandleSync(handle);
-    if (!hash) return null;
-    return this.getSync(hash);
-  }
-  async updateHandle(handle, newHash) {
-    return this.updateHandleSync(handle, newHash);
-  }
-  /**
-   * Update a handle synchronously
-   */
-  updateHandleSync(handle, newHash) {
-    const normalized = validateHandle(handle);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const getStmt = this.db.prepare("SELECT current_hash FROM handle_registry WHERE handle = ?");
-    const row = getStmt.get(normalized);
-    if (!row) {
-      throw new Error(`Handle '${handle}' not found.`);
-    }
-    const previousHash = row.current_hash;
-    const historyStmt = this.db.prepare(
-      "INSERT INTO handle_history (handle, previous_hash, changed_at) VALUES (?, ?, ?)"
-    );
-    historyStmt.run(normalized, previousHash, now);
-    const updateStmt = this.db.prepare(
-      "UPDATE handle_registry SET current_hash = ?, updated_at = ? WHERE handle = ?"
-    );
-    updateStmt.run(newHash, now, normalized);
-    return previousHash;
-  }
-  async getHandleHistory(handle) {
-    return this.getHandleHistorySync(handle);
-  }
-  /**
-   * Get handle history synchronously
-   */
-  getHandleHistorySync(handle) {
-    const normalized = validateHandle(handle);
-    const stmt = this.db.prepare(
-      "SELECT previous_hash, changed_at FROM handle_history WHERE handle = ? ORDER BY id DESC"
-    );
-    const rows = stmt.all(normalized);
-    return rows.map((row) => ({
-      previousHash: row.previous_hash,
-      changedAt: row.changed_at
-    }));
-  }
-  async pruneHandleHistory(handle, options = {}) {
-    return this.pruneHandleHistorySync(handle, options);
-  }
-  /**
-   * Prune handle history synchronously
-   */
-  pruneHandleHistorySync(handle, options = {}) {
-    const normalized = validateHandle(handle);
-    let stmt;
-    if (options.deleteAll) {
-      stmt = this.db.prepare("DELETE FROM handle_history WHERE handle = ?");
-      const result = stmt.run(normalized);
-      return result.changes;
-    } else if (options.olderThan) {
-      stmt = this.db.prepare("DELETE FROM handle_history WHERE handle = ? AND changed_at < ?");
-      const result = stmt.run(normalized, options.olderThan);
-      return result.changes;
-    }
-    return 0;
-  }
-  // =========== Handle Management Operations ===========
-  async getAllHandles() {
-    return this.getAllHandlesSync();
-  }
-  getAllHandlesSync() {
-    const stmt = this.db.prepare("SELECT handle, current_hash FROM handle_registry");
-    const rows = stmt.all();
-    return rows.map((row) => ({ handle: row.handle, hash: row.current_hash }));
-  }
-  async removeHandle(handle) {
-    this.removeHandleSync(handle);
-  }
-  removeHandleSync(handle) {
-    const normalized = validateHandle(handle);
-    this.db.prepare("DELETE FROM handle_history WHERE handle = ?").run(normalized);
-    this.db.prepare("DELETE FROM handle_registry WHERE handle = ?").run(normalized);
-  }
-  async renameHandle(oldHandle, newHandle) {
-    this.renameHandleSync(oldHandle, newHandle);
-  }
-  renameHandleSync(oldHandle, newHandle) {
-    const normalizedOld = validateHandle(oldHandle);
-    const normalizedNew = validateHandle(newHandle);
-    if (normalizedOld === normalizedNew) return;
-    const existsOld = this.db.prepare("SELECT handle FROM handle_registry WHERE handle = ?").get(normalizedOld);
-    if (!existsOld) throw new Error(`Handle '${oldHandle}' not found.`);
-    const existsNew = this.db.prepare("SELECT handle FROM handle_registry WHERE handle = ?").get(normalizedNew);
-    if (existsNew) throw new Error(`Handle '${newHandle}' already exists.`);
-    const performRename = this.db.transaction(() => {
-      this.db.pragma("defer_foreign_keys = ON");
-      this.db.prepare("UPDATE handle_registry SET handle = ? WHERE handle = ?").run(normalizedNew, normalizedOld);
-      this.db.prepare("UPDATE handle_history SET handle = ? WHERE handle = ?").run(normalizedNew, normalizedOld);
-    });
-    performRename();
-  }
-  async deleteHistoryEntry(handle, previousHash) {
-    this.deleteHistoryEntrySync(handle, previousHash);
-  }
-  deleteHistoryEntrySync(handle, previousHash) {
-    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
-};

package/dist/chunk-2VOQRXWH.js

@@ -1,296 +0,0 @@
-import {
-  MCard
-} from "./chunk-4UIWXZHY.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-MW6QF4IO.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-MW6QF4IO.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 = 10) {
-    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 = 10) {
-    return this.engine.search(query, pageNumber, pageSize);
-  }
-  async searchByContent(query, pageNumber = 1, pageSize = 10) {
-    return this.engine.search(query, pageNumber, pageSize);
-  }
-  async searchByHash(hashPrefix) {
-    return this.engine.searchByHash(hashPrefix);
-  }
-  async getAllMCardsRaw() {
-    return this.engine.getAll();
-  }
-  async getAllCards(pageSize = 10, 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
-};