mcard-js 2.1.39 → 2.1.41

package/dist/index.browser.cjs

@@ -176,6 +176,90 @@ var init_GTime = __esm({
   }
 });
 
+// src/model/Handle.ts
+var Handle_exports = {};
+__export(Handle_exports, {
+  ContentHandle: () => ContentHandle,
+  HandleValidationError: () => HandleValidationError,
+  validateHandle: () => validateHandle
+});
+function isValidStartChar(char) {
+  return /^\p{L}$/u.test(char);
+}
+function isValidBodyChar(char) {
+  return /^[\p{L}\p{N}_./ -]$/u.test(char);
+}
+function validateHandle(handle) {
+  if (!handle) {
+    throw new HandleValidationError("Handle cannot be empty.");
+  }
+  const normalized = handle.trim().normalize("NFC");
+  if (normalized.length === 0) {
+    throw new HandleValidationError("Handle cannot be empty after normalization.");
+  }
+  if (normalized.length > MAX_HANDLE_LENGTH) {
+    throw new HandleValidationError(
+      `Handle '${handle}' is too long (${normalized.length} chars). Maximum is ${MAX_HANDLE_LENGTH}.`
+    );
+  }
+  if (!isValidStartChar(normalized[0])) {
+    throw new HandleValidationError(
+      `Invalid handle '${handle}'. Must start with a letter (any language).`
+    );
+  }
+  for (let i = 1; i < normalized.length; i++) {
+    if (!isValidBodyChar(normalized[i])) {
+      throw new HandleValidationError(
+        `Invalid character '${normalized[i]}' at position ${i} in handle '${handle}'.`
+      );
+    }
+  }
+  return normalized;
+}
+var MAX_HANDLE_LENGTH, HandleValidationError, ContentHandle;
+var init_Handle = __esm({
+  "src/model/Handle.ts"() {
+    "use strict";
+    MAX_HANDLE_LENGTH = 255;
+    HandleValidationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "HandleValidationError";
+      }
+    };
+    ContentHandle = class {
+      handle;
+      currentHash;
+      createdAt;
+      updatedAt;
+      constructor(handle, currentHash, createdAt, updatedAt) {
+        this.handle = validateHandle(handle);
+        this.currentHash = currentHash;
+        this.createdAt = createdAt ?? /* @__PURE__ */ new Date();
+        this.updatedAt = updatedAt ?? this.createdAt;
+      }
+      /**
+       * Update handle to point to new hash
+       * @returns Previous hash for history tracking
+       */
+      update(newHash) {
+        const previousHash = this.currentHash;
+        this.currentHash = newHash;
+        this.updatedAt = /* @__PURE__ */ new Date();
+        return previousHash;
+      }
+      toObject() {
+        return {
+          handle: this.handle,
+          currentHash: this.currentHash,
+          createdAt: this.createdAt.toISOString(),
+          updatedAt: this.updatedAt.toISOString()
+        };
+      }
+    };
+  }
+});
+
 // src/model/constants.ts
 var EVENT_CONSTANTS, ALGORITHM_HIERARCHY;
 var init_constants = __esm({
@@ -1025,6 +1109,18 @@ var mime_extensions_default = {
   }
 };
 
+// src/config/constants.ts
+var DEFAULT_PAGE_SIZE = 10;
+var DETECTION_SAMPLE_CAP = 8192;
+var MAX_FILE_SIZE = 50 * 1024 * 1024;
+var KNOWN_TYPE_SIZE_LIMIT = 1024 * 1024;
+var BINARY_CHECK_SAMPLE_SIZE = 32 * 1024;
+var CONTENT_DETECTION_SAMPLE_SIZE = 1024 * 1024;
+var DEFAULT_MAX_PROBLEM_BYTES = 2 * 1024 * 1024;
+var INDEXEDDB_DEFAULT_DB_NAME = "mcard-db";
+var INDEXEDDB_DEFAULT_DB_VERSION = 1;
+var DEFAULT_SQLJS_WASM_URL = "https://sql.js.org/dist/";
+
 // src/model/strategies/DetectionStrategy.ts
 function loadSharedMimeData() {
   return {
@@ -1057,7 +1153,7 @@ var DefaultDetectionStrategy = class _DefaultDetectionStrategy {
     return this.extensionsRegistry[mimeType] || "";
   }
   detect(content, fileExtension) {
-    const contentSample = typeof content === "string" ? content.slice(0, 8192) : content.slice(0, 8192);
+    const contentSample = typeof content === "string" ? content.slice(0, DETECTION_SAMPLE_CAP) : content.slice(0, DETECTION_SAMPLE_CAP);
     const textSample = this.getTextSample(contentSample);
     const lines = textSample.split("\n").slice(0, 20);
     const firstLine = lines[0] || "";
@@ -1091,9 +1187,9 @@ var DefaultDetectionStrategy = class _DefaultDetectionStrategy {
   }
   getTextSample(content) {
     if (typeof content === "string") {
-      return content.slice(0, 8192);
+      return content.slice(0, DETECTION_SAMPLE_CAP);
     }
-    return new TextDecoder("utf-8", { fatal: false }).decode(content.slice(0, 8192));
+    return new TextDecoder("utf-8", { fatal: false }).decode(content.slice(0, DETECTION_SAMPLE_CAP));
   }
   getExtension(mimeType) {
     return _DefaultDetectionStrategy.getExtension(mimeType);
@@ -1313,78 +1409,7 @@ var MCard = class _MCard {
 
 // src/index.browser.ts
 init_GTime();
-
-// src/model/Handle.ts
-var MAX_HANDLE_LENGTH = 255;
-function isValidStartChar(char) {
-  return /^\p{L}$/u.test(char);
-}
-function isValidBodyChar(char) {
-  return /^[\p{L}\p{N}_./ -]$/u.test(char);
-}
-var HandleValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "HandleValidationError";
-  }
-};
-function validateHandle(handle) {
-  if (!handle) {
-    throw new HandleValidationError("Handle cannot be empty.");
-  }
-  const normalized = handle.trim().normalize("NFC").toLowerCase();
-  if (normalized.length === 0) {
-    throw new HandleValidationError("Handle cannot be empty after normalization.");
-  }
-  if (normalized.length > MAX_HANDLE_LENGTH) {
-    throw new HandleValidationError(
-      `Handle '${handle}' is too long (${normalized.length} chars). Maximum is ${MAX_HANDLE_LENGTH}.`
-    );
-  }
-  if (!isValidStartChar(normalized[0])) {
-    throw new HandleValidationError(
-      `Invalid handle '${handle}'. Must start with a letter (any language).`
-    );
-  }
-  for (let i = 1; i < normalized.length; i++) {
-    if (!isValidBodyChar(normalized[i])) {
-      throw new HandleValidationError(
-        `Invalid character '${normalized[i]}' at position ${i} in handle '${handle}'.`
-      );
-    }
-  }
-  return normalized;
-}
-var ContentHandle = class {
-  handle;
-  currentHash;
-  createdAt;
-  updatedAt;
-  constructor(handle, currentHash, createdAt, updatedAt) {
-    this.handle = validateHandle(handle);
-    this.currentHash = currentHash;
-    this.createdAt = createdAt ?? /* @__PURE__ */ new Date();
-    this.updatedAt = updatedAt ?? this.createdAt;
-  }
-  /**
-   * Update handle to point to new hash
-   * @returns Previous hash for history tracking
-   */
-  update(newHash) {
-    const previousHash = this.currentHash;
-    this.currentHash = newHash;
-    this.updatedAt = /* @__PURE__ */ new Date();
-    return previousHash;
-  }
-  toObject() {
-    return {
-      handle: this.handle,
-      currentHash: this.currentHash,
-      createdAt: this.createdAt.toISOString(),
-      updatedAt: this.updatedAt.toISOString()
-    };
-  }
-};
+init_Handle();
 
 // src/monads/Maybe.ts
 var Maybe = class _Maybe {
@@ -1511,7 +1536,7 @@ var CardCollection = class {
   /**
    * Get a page of cards
    */
-  async getPage(pageNumber = 1, pageSize = 10) {
+  async getPage(pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
     return this.engine.getPage(pageNumber, pageSize);
   }
   /**
@@ -1601,10 +1626,10 @@ var CardCollection = class {
   async clear() {
     return this.engine.clear();
   }
-  async searchByString(query, pageNumber = 1, pageSize = 10) {
+  async searchByString(query, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
     return this.engine.search(query, pageNumber, pageSize);
   }
-  async searchByContent(query, pageNumber = 1, pageSize = 10) {
+  async searchByContent(query, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
     return this.engine.search(query, pageNumber, pageSize);
   }
   async searchByHash(hashPrefix) {
@@ -1613,7 +1638,7 @@ var CardCollection = class {
   async getAllMCardsRaw() {
     return this.engine.getAll();
   }
-  async getAllCards(pageSize = 10, processCallback) {
+  async getAllCards(pageSize = DEFAULT_PAGE_SIZE, processCallback) {
     const cards = [];
     let pageNumber = 1;
     let total = 0;
@@ -1679,6 +1704,7 @@ init_constants();
 
 // src/storage/engines/IndexedDBEngine.ts
 var import_idb = require("idb");
+init_Handle();
 
 // src/storage/StorageAdapter.ts
 function createPage(items, totalItems, pageNumber, pageSize) {
@@ -1698,14 +1724,14 @@ function createPage(items, totalItems, pageNumber, pageSize) {
 var IndexedDBEngine = class {
   db = null;
   dbName;
-  constructor(dbName = "mcard-db") {
+  constructor(dbName = INDEXEDDB_DEFAULT_DB_NAME) {
     this.dbName = dbName;
   }
   /**
    * Initialize the database connection
    */
   async init() {
-    this.db = await (0, import_idb.openDB)(this.dbName, 1, {
+    this.db = await (0, import_idb.openDB)(this.dbName, INDEXEDDB_DEFAULT_DB_VERSION, {
       upgrade(db) {
         if (!db.objectStoreNames.contains("cards")) {
           db.createObjectStore("cards", { keyPath: "hash" });
@@ -1750,7 +1776,7 @@ var IndexedDBEngine = class {
     const db = this.ensureDb();
     await db.delete("cards", hash);
   }
-  async getPage(pageNumber, pageSize) {
+  async getPage(pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
     const db = this.ensureDb();
     const totalItems = await db.count("cards");
     const allCards = await db.getAll("cards");
@@ -1771,7 +1797,7 @@ var IndexedDBEngine = class {
     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) {
+  async search(query, pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
     const db = this.ensureDb();
     const records = await db.getAll("cards");
     const decoder = new TextDecoder();
@@ -2581,159 +2607,129 @@ var CORE_SCHEMAS = {
   handleIndex: HANDLE_INDEX_SCHEMA
 };
 
-// src/storage/engines/SqliteWasmEngine.ts
-var SqliteWasmEngine = class {
-  db = null;
-  SQL = null;
+// src/storage/engines/AbstractSqlEngine.ts
+init_Handle();
+var AbstractSqlEngine = class {
   /**
-   * Initialize the database
-   * @param wasmUrl URL to sql-wasm.wasm file (optional, defaults to CDN)
-   * @param existingData Optional existing database as Uint8Array
+   * SQL expression for casting content to text in search queries.
+   * Override in subclasses: SQLite uses 'TEXT', DuckDB uses 'VARCHAR'.
    */
-  async init(wasmUrl, existingData) {
-    const initSqlJs = (await import("sql.js")).default;
-    const SQL = await initSqlJs({
-      locateFile: (file) => wasmUrl || `https://sql.js.org/dist/${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;
-  }
-  /**
-   * Export database as Uint8Array (for persistence)
-   */
-  export() {
-    return this.ensureDb().export();
+  get castContentAs() {
+    return "TEXT";
   }
+  // ======================================================================
+  // Concrete: Card Operations (shared across all SQL engines)
+  // ======================================================================
   /**
-   * Get raw sql.js Database for use with VectorStore adapter.
-   * 
-   * Example:
-   *   const vecStore = createWasmVectorStore(engine.getRawDb());
+   * Add a card. Default uses INSERT OR REPLACE (SQLite).
+   * DuckDB overrides with DELETE + INSERT.
    */
-  getRawDb() {
-    return this.ensureDb();
-  }
-  // =========== Card Operations ===========
   async add(card) {
-    const db = this.ensureDb();
-    db.run(
+    const contentBytes = card.content instanceof Uint8Array ? card.content : new TextEncoder().encode(String(card.content));
+    await this.execSql(
       "INSERT OR REPLACE INTO card (hash, content, g_time) VALUES (?, ?, ?)",
-      [card.hash, card.content, card.g_time]
+      card.hash,
+      contentBytes,
+      card.g_time
     );
     return card.hash;
   }
   async get(hash) {
-    const db = this.ensureDb();
-    const stmt = db.prepare("SELECT hash, content, g_time FROM card WHERE hash = ?");
-    stmt.bind([hash]);
-    if (!stmt.step()) {
-      stmt.free();
-      return null;
-    }
-    const row = stmt.get();
-    stmt.free();
-    return MCard.fromData(new Uint8Array(row[1]), row[0], row[2]);
+    const rows = await this.queryRows(
+      "SELECT hash, content, g_time FROM card WHERE hash = ?",
+      hash
+    );
+    if (rows.length === 0) return null;
+    return this.rowToCard(rows[0]);
   }
   async delete(hash) {
-    this.ensureDb().run("DELETE FROM card WHERE hash = ?", [hash]);
+    await this.execSql("DELETE FROM card WHERE hash = ?", hash);
   }
-  async getPage(pageNumber, pageSize) {
-    const db = this.ensureDb();
+  async getPage(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 = await this.count();
     const offset = (pageNumber - 1) * pageSize;
-    const stmt = db.prepare("SELECT hash, content, g_time FROM card LIMIT ? OFFSET ?");
-    stmt.bind([pageSize, offset]);
-    const items = [];
-    while (stmt.step()) {
-      const row = stmt.get();
-      items.push(MCard.fromData(new Uint8Array(row[1]), row[0], row[2]));
-    }
-    stmt.free();
+    const rows = await this.queryRows(
+      "SELECT hash, content, g_time FROM card ORDER BY g_time DESC LIMIT ? OFFSET ?",
+      pageSize,
+      offset
+    );
+    const items = rows.map((r) => this.rowToCard(r));
     return createPage(items, totalItems, pageNumber, pageSize);
   }
   async count() {
-    const result = this.ensureDb().exec("SELECT COUNT(*) FROM card");
-    return result[0]?.values[0]?.[0] || 0;
+    const rows = await this.queryRows("SELECT COUNT(*) as cnt FROM card");
+    return Number(rows[0]?.cnt ?? 0);
   }
   async searchByHash(hashPrefix) {
-    const db = this.ensureDb();
-    const stmt = db.prepare("SELECT hash, content, g_time FROM card WHERE hash LIKE ?");
-    stmt.bind([`${hashPrefix}%`]);
-    const items = [];
-    while (stmt.step()) {
-      const row = stmt.get();
-      items.push(MCard.fromData(new Uint8Array(row[1]), row[0], row[2]));
-    }
-    stmt.free();
-    return items;
+    const rows = await this.queryRows(
+      "SELECT hash, content, g_time FROM card WHERE hash LIKE ?",
+      `${hashPrefix}%`
+    );
+    return rows.map((r) => this.rowToCard(r));
   }
-  async search(query, pageNumber, pageSize) {
-    const db = this.ensureDb();
+  async search(queryStr, 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 offset = (pageNumber - 1) * pageSize;
-    const pattern = `%${query}%`;
-    let stmt = db.prepare("SELECT COUNT(*) FROM card WHERE CAST(content AS TEXT) LIKE ?");
-    stmt.bind([pattern]);
-    stmt.step();
-    const totalItems = stmt.get()[0];
-    stmt.free();
-    stmt = db.prepare("SELECT hash, content, g_time FROM card WHERE CAST(content AS TEXT) LIKE ? LIMIT ? OFFSET ?");
-    stmt.bind([pattern, pageSize, offset]);
-    const items = [];
-    while (stmt.step()) {
-      const row = stmt.get();
-      items.push(MCard.fromData(new Uint8Array(row[1]), row[0], row[2]));
-    }
-    stmt.free();
+    const pattern = `%${queryStr}%`;
+    const cast = this.castContentAs;
+    const countRows = await this.queryRows(
+      `SELECT COUNT(*) as cnt FROM card WHERE CAST(content AS ${cast}) LIKE ?`,
+      pattern
+    );
+    const totalItems = Number(countRows[0]?.cnt ?? 0);
+    const rows = await this.queryRows(
+      `SELECT hash, content, g_time FROM card WHERE CAST(content AS ${cast}) LIKE ? ORDER BY g_time DESC LIMIT ? OFFSET ?`,
+      pattern,
+      pageSize,
+      offset
+    );
+    const items = rows.map((r) => this.rowToCard(r));
     return createPage(items, totalItems, pageNumber, pageSize);
   }
   async getAll() {
-    const result = this.ensureDb().exec("SELECT hash, content, g_time FROM card");
-    return (result[0]?.values || []).map(
-      ([h, content, g_time]) => MCard.fromData(new Uint8Array(content), h, g_time)
-    );
+    const rows = await this.queryRows("SELECT hash, content, g_time FROM card ORDER BY g_time DESC");
+    return rows.map((r) => this.rowToCard(r));
   }
+  // ======================================================================
+  // Concrete: clear (FK-safe delete order)
+  // ======================================================================
   async clear() {
-    const db = this.ensureDb();
-    db.run("DELETE FROM card");
-    db.run("DELETE FROM handle_registry");
-    db.run("DELETE FROM handle_history");
+    await this.execSql("DELETE FROM handle_history");
+    await this.execSql("DELETE FROM handle_registry");
+    await this.execSql("DELETE FROM card");
   }
-  // =========== Handle Operations ===========
+  // ======================================================================
+  // Concrete: Handle Operations
+  // ======================================================================
   async registerHandle(handle, hash) {
-    const db = this.ensureDb();
     const normalized = validateHandle(handle);
-    const checkStmt = db.prepare("SELECT handle FROM handle_registry WHERE handle = ?");
-    checkStmt.bind([normalized]);
-    const exists = checkStmt.step();
-    checkStmt.free();
-    if (exists) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = await this.queryRows(
+      "SELECT handle FROM handle_registry WHERE handle = ?",
+      normalized
+    );
+    if (existing.length > 0) {
       throw new Error(`Handle '${handle}' already exists.`);
     }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    db.run(
+    await this.execSql(
       "INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, ?, ?)",
-      [normalized, hash, now, now]
+      normalized,
+      hash,
+      now,
+      now
     );
   }
   async resolveHandle(handle) {
     const normalized = validateHandle(handle);
-    const stmt = this.ensureDb().prepare("SELECT current_hash FROM handle_registry WHERE handle = ?");
-    stmt.bind([normalized]);
-    if (!stmt.step()) {
-      stmt.free();
-      return null;
-    }
-    const hash = stmt.get()[0];
-    stmt.free();
-    return hash || null;
+    const rows = await this.queryRows(
+      "SELECT current_hash FROM handle_registry WHERE handle = ?",
+      normalized
+    );
+    if (rows.length === 0) return null;
+    return String(rows[0].current_hash);
   }
   async getByHandle(handle) {
     const hash = await this.resolveHandle(handle);
@@ -2741,42 +2737,206 @@ var SqliteWasmEngine = class {
     return this.get(hash);
   }
   async updateHandle(handle, newHash) {
-    const db = this.ensureDb();
     const normalized = validateHandle(handle);
-    const getStmt = db.prepare("SELECT current_hash FROM handle_registry WHERE handle = ?");
-    getStmt.bind([normalized]);
-    if (!getStmt.step()) {
-      getStmt.free();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = await this.queryRows(
+      "SELECT current_hash FROM handle_registry WHERE handle = ?",
+      normalized
+    );
+    if (rows.length === 0) {
       throw new Error(`Handle '${handle}' not found.`);
     }
-    const previousHash = getStmt.get()[0];
-    getStmt.free();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    db.run(
+    const previousHash = String(rows[0].current_hash);
+    await this.execSql(
       "INSERT INTO handle_history (handle, previous_hash, changed_at) VALUES (?, ?, ?)",
-      [normalized, previousHash, now]
+      normalized,
+      previousHash,
+      now
     );
-    db.run(
+    await this.execSql(
       "UPDATE handle_registry SET current_hash = ?, updated_at = ? WHERE handle = ?",
-      [newHash, now, normalized]
+      newHash,
+      now,
+      normalized
     );
     return previousHash;
   }
   async getHandleHistory(handle) {
     const normalized = validateHandle(handle);
-    const stmt = this.ensureDb().prepare("SELECT previous_hash, changed_at FROM handle_history WHERE handle = ? ORDER BY id DESC");
-    stmt.bind([normalized]);
+    const rows = await this.queryRows(
+      "SELECT previous_hash, changed_at FROM handle_history WHERE handle = ? ORDER BY id DESC",
+      normalized
+    );
+    return rows.map((r) => ({
+      previousHash: String(r.previous_hash),
+      changedAt: String(r.changed_at)
+    }));
+  }
+  async pruneHandleHistory(handle, options = {}) {
+    const normalized = validateHandle(handle);
+    if (options.deleteAll) {
+      return this.execSql("DELETE FROM handle_history WHERE handle = ?", normalized);
+    } else if (options.olderThan) {
+      return this.execSql(
+        "DELETE FROM handle_history WHERE handle = ? AND changed_at < ?",
+        normalized,
+        options.olderThan
+      );
+    }
+    return 0;
+  }
+  // ======================================================================
+  // Concrete: Handle Management Operations
+  // ======================================================================
+  async getAllHandles() {
+    const rows = await this.queryRows("SELECT handle, current_hash FROM handle_registry");
+    return rows.map((r) => ({
+      handle: String(r.handle),
+      hash: String(r.current_hash)
+    }));
+  }
+  async removeHandle(handle) {
+    const normalized = validateHandle(handle);
+    await this.execSql("DELETE FROM handle_history WHERE handle = ?", normalized);
+    await this.execSql("DELETE FROM handle_registry WHERE handle = ?", normalized);
+  }
+  async renameHandle(oldHandle, newHandle) {
+    const normalizedOld = validateHandle(oldHandle);
+    const normalizedNew = validateHandle(newHandle);
+    if (normalizedOld === normalizedNew) return;
+    const existsOld = await this.queryRows(
+      "SELECT handle FROM handle_registry WHERE handle = ?",
+      normalizedOld
+    );
+    if (existsOld.length === 0) throw new Error(`Handle '${oldHandle}' not found.`);
+    const existsNew = await this.queryRows(
+      "SELECT handle FROM handle_registry WHERE handle = ?",
+      normalizedNew
+    );
+    if (existsNew.length > 0) throw new Error(`Handle '${newHandle}' already exists.`);
+    const oldRow = await this.queryRows(
+      "SELECT current_hash, created_at, updated_at FROM handle_registry WHERE handle = ?",
+      normalizedOld
+    );
+    await this.execSql(
+      "INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, ?, ?)",
+      normalizedNew,
+      String(oldRow[0].current_hash),
+      String(oldRow[0].created_at),
+      String(oldRow[0].updated_at)
+    );
+    await this.execSql(
+      "UPDATE handle_history SET handle = ? WHERE handle = ?",
+      normalizedNew,
+      normalizedOld
+    );
+    await this.execSql(
+      "DELETE FROM handle_registry WHERE handle = ?",
+      normalizedOld
+    );
+  }
+  async deleteHistoryEntry(handle, previousHash) {
+    const normalized = validateHandle(handle);
+    const rOutRows = await this.queryRows(
+      "SELECT id, previous_hash FROM handle_history WHERE handle = ? AND previous_hash = ? ORDER BY id DESC LIMIT 1",
+      normalized,
+      previousHash
+    );
+    if (rOutRows.length === 0) return;
+    const rOutId = Number(rOutRows[0].id);
+    const rInRows = await this.queryRows(
+      "SELECT id, previous_hash FROM handle_history WHERE handle = ? AND id < ? ORDER BY id DESC LIMIT 1",
+      normalized,
+      rOutId
+    );
+    if (rInRows.length > 0) {
+      const rInId = Number(rInRows[0].id);
+      const rInPrevHash = String(rInRows[0].previous_hash);
+      await this.execSql("UPDATE handle_history SET previous_hash = ? WHERE id = ?", rInPrevHash, rOutId);
+      await this.execSql("DELETE FROM handle_history WHERE id = ?", rInId);
+    } else {
+      await this.execSql("DELETE FROM handle_history WHERE id = ?", rOutId);
+    }
+  }
+};
+
+// 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.get();
-      results.push({ previousHash: row[0], changedAt: row[1] });
+      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: validateHandle2 } = await Promise.resolve().then(() => (init_Handle(), Handle_exports));
     const db = this.ensureDb();
-    const normalized = validateHandle(handle);
+    const normalized = validateHandle2(handle);
     if (options.deleteAll) {
       const stmt = db.prepare("SELECT COUNT(*) FROM handle_history WHERE handle = ?");
       stmt.bind([normalized]);
@@ -2796,67 +2956,6 @@ var SqliteWasmEngine = class {
     }
     return 0;
   }
-  // =========== Handle Management Operations ===========
-  async getAllHandles() {
-    const result = this.ensureDb().exec("SELECT handle, current_hash FROM handle_registry");
-    return (result[0]?.values || []).map(([handle, hash]) => ({
-      handle,
-      hash
-    }));
-  }
-  async removeHandle(handle) {
-    const db = this.ensureDb();
-    const normalized = validateHandle(handle);
-    db.run("DELETE FROM handle_history WHERE handle = ?", [normalized]);
-    db.run("DELETE FROM handle_registry WHERE handle = ?", [normalized]);
-  }
-  async renameHandle(oldHandle, newHandle) {
-    const db = this.ensureDb();
-    const normalizedOld = validateHandle(oldHandle);
-    const normalizedNew = validateHandle(newHandle);
-    if (normalizedOld === normalizedNew) return;
-    const checkOld = db.prepare("SELECT handle FROM handle_registry WHERE handle = ?");
-    checkOld.bind([normalizedOld]);
-    const oldExists = checkOld.step();
-    checkOld.free();
-    if (!oldExists) throw new Error(`Handle '${oldHandle}' not found.`);
-    const checkNew = db.prepare("SELECT handle FROM handle_registry WHERE handle = ?");
-    checkNew.bind([normalizedNew]);
-    const newExists = checkNew.step();
-    checkNew.free();
-    if (newExists) throw new Error(`Handle '${newHandle}' already exists.`);
-    db.run("UPDATE handle_registry SET handle = ? WHERE handle = ?", [normalizedNew, normalizedOld]);
-    db.run("UPDATE handle_history SET handle = ? WHERE handle = ?", [normalizedNew, normalizedOld]);
-  }
-  async deleteHistoryEntry(handle, previousHash) {
-    const db = this.ensureDb();
-    const normalized = validateHandle(handle);
-    const rOutStmt = db.prepare(
-      "SELECT id, previous_hash FROM handle_history WHERE handle = ? AND previous_hash = ? ORDER BY id DESC LIMIT 1"
-    );
-    rOutStmt.bind([normalized, previousHash]);
-    if (!rOutStmt.step()) {
-      rOutStmt.free();
-      return;
-    }
-    const rOutId = rOutStmt.get()[0];
-    rOutStmt.free();
-    const rInStmt = db.prepare(
-      "SELECT id, previous_hash FROM handle_history WHERE handle = ? AND id < ? ORDER BY id DESC LIMIT 1"
-    );
-    rInStmt.bind([normalized, rOutId]);
-    const hasRIn = rInStmt.step();
-    if (hasRIn) {
-      const rInPrevHash = rInStmt.get()[1];
-      const rInId = rInStmt.get()[0];
-      rInStmt.free();
-      db.run("UPDATE handle_history SET previous_hash = ? WHERE id = ?", [rInPrevHash, rOutId]);
-      db.run("DELETE FROM handle_history WHERE id = ?", [rInId]);
-    } else {
-      rInStmt.free();
-      db.run("DELETE FROM handle_history WHERE id = ?", [rOutId]);
-    }
-  }
 };
 
 // src/index.browser.ts