mcard-js 2.1.49 → 2.1.51

package/dist/chunk-PYP6T64W.js

@@ -0,0 +1,217 @@
+import {
+  AbstractSqlEngine,
+  initCoreSchemas
+} from "./chunk-DM2ABCA4.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-R3XRBAM7.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
+};

package/dist/chunk-QFT3COE2.js

@@ -0,0 +1,217 @@
+import {
+  AbstractSqlEngine,
+  initCoreSchemas
+} from "./chunk-DM2ABCA4.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-R3XRBAM7.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 = DELETE");
+    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
+};

package/dist/chunk-QFZFXMNX.js

@@ -0,0 +1,275 @@
+import {
+  createPage
+} from "./chunk-3EIBJPNF.js";
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+import {
+  init_Handle,
+  validateHandle
+} from "./chunk-ADV52544.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  INDEXEDDB_DEFAULT_DB_NAME,
+  INDEXEDDB_DEFAULT_DB_VERSION
+} from "./chunk-R3XRBAM7.js";
+
+// src/storage/engines/IndexedDBEngine.ts
+import { openDB } from "idb";
+init_Handle();
+var IndexedDBEngine = class {
+  db = null;
+  dbName;
+  constructor(dbName = INDEXEDDB_DEFAULT_DB_NAME) {
+    this.dbName = dbName;
+  }
+  /**
+   * Initialize the database connection
+   */
+  async init() {
+    this.db = await openDB(this.dbName, INDEXEDDB_DEFAULT_DB_VERSION, {
+      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 = DEFAULT_PAGE_SIZE) {
+    const db = this.ensureDb();
+    const totalItems = await db.count("cards");
+    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 createPage(items, totalItems, pageNumber, pageSize);
+  }
+  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 = DEFAULT_PAGE_SIZE) {
+    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 start = (pageNumber - 1) * pageSize;
+    const pageItems = filtered.slice(start, start + pageSize).map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+    return createPage(pageItems, totalItems, pageNumber, pageSize);
+  }
+  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();
+  }
+  async pruneHandleHistory(handle, options = {}) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    let toDelete;
+    if (options.deleteAll) {
+      toDelete = records;
+    } else if (options.olderThan) {
+      toDelete = records.filter((r) => r.changedAt < options.olderThan);
+    } else {
+      return 0;
+    }
+    const tx = db.transaction("handleHistory", "readwrite");
+    for (const record of toDelete) {
+      await tx.store.delete(record.id);
+    }
+    await tx.done;
+    return toDelete.length;
+  }
+  // =========== Handle Management Operations ===========
+  async getAllHandles() {
+    const db = this.ensureDb();
+    const records = await db.getAll("handles");
+    return records.map((r) => ({ handle: r.handle, hash: r.currentHash }));
+  }
+  async removeHandle(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const keysToTry = normalized !== handle.trim() ? [normalized, handle.trim()] : [normalized];
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    for (const key of keysToTry) {
+      await handleStore.delete(key);
+    }
+    const historyIndex = historyStore.index("by-handle");
+    for (const key of keysToTry) {
+      let cursor = await historyIndex.openCursor(key);
+      while (cursor) {
+        await cursor.delete();
+        cursor = await cursor.continue();
+      }
+    }
+    await tx.done;
+  }
+  async renameHandle(oldHandle, newHandle) {
+    const db = this.ensureDb();
+    const normalizedOld = validateHandle(oldHandle);
+    const normalizedNew = validateHandle(newHandle);
+    if (normalizedOld === normalizedNew) return;
+    const oldEntry = await db.get("handles", normalizedOld);
+    if (!oldEntry) throw new Error(`Handle '${oldHandle}' not found.`);
+    const newEntry = await db.get("handles", normalizedNew);
+    if (newEntry) throw new Error(`Handle '${newHandle}' already exists.`);
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await handleStore.put({
+      ...oldEntry,
+      handle: normalizedNew,
+      updatedAt: now
+    });
+    await handleStore.delete(normalizedOld);
+    const historyIndex = historyStore.index("by-handle");
+    let cursor = await historyIndex.openCursor(normalizedOld);
+    while (cursor) {
+      const record = cursor.value;
+      record.handle = normalizedNew;
+      await cursor.update(record);
+      cursor = await cursor.continue();
+    }
+    await tx.done;
+  }
+  async deleteHistoryEntry(handle, previousHash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    const entries = records.sort((a, b) => a.id - b.id);
+    const targetIdx = entries.findIndex((e) => e.previousHash === previousHash);
+    if (targetIdx === -1) return;
+    const target = entries[targetIdx];
+    const successor = entries[targetIdx + 1];
+    const tx = db.transaction("handleHistory", "readwrite");
+    const store = tx.objectStore("handleHistory");
+    if (successor && targetIdx > 0) {
+      const predecessor = entries[targetIdx - 1];
+      successor.previousHash = predecessor.previousHash;
+      await store.put(successor);
+    }
+    await store.delete(target.id);
+    await tx.done;
+  }
+};
+
+export {
+  IndexedDBEngine
+};