mcard-js 2.1.39 → 2.1.41

package/dist/storage/SqliteNodeEngine.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,90 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// 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/storage/SqliteNodeEngine.ts
 var SqliteNodeEngine_exports = {};
 __export(SqliteNodeEngine_exports, {
@@ -905,6 +992,16 @@ 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 SQLITE_BUSY_TIMEOUT_MS = 5e3;
+
 // src/model/strategies/DetectionStrategy.ts
 function loadSharedMimeData() {
   return {
@@ -937,7 +1034,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] || "";
@@ -971,9 +1068,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);
@@ -1191,48 +1288,6 @@ var MCard = class _MCard {
   }
 };
 
-// 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;
-}
-
 // src/storage/StorageAdapter.ts
 function createPage(items, totalItems, pageNumber, pageSize) {
   const totalPages = Math.ceil(totalItems / pageSize) || 1;
@@ -1879,17 +1934,270 @@ function initCoreSchemas(db) {
   schema.initHandleTables(db);
 }
 
+// src/storage/engines/AbstractSqlEngine.ts
+init_Handle();
+var AbstractSqlEngine = class {
+  /**
+   * SQL expression for casting content to text in search queries.
+   * Override in subclasses: SQLite uses 'TEXT', DuckDB uses 'VARCHAR'.
+   */
+  get castContentAs() {
+    return "TEXT";
+  }
+  // ======================================================================
+  // Concrete: Card Operations (shared across all SQL engines)
+  // ======================================================================
+  /**
+   * Add a card. Default uses INSERT OR REPLACE (SQLite).
+   * DuckDB overrides with DELETE + INSERT.
+   */
+  async add(card) {
+    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,
+      contentBytes,
+      card.g_time
+    );
+    return card.hash;
+  }
+  async get(hash) {
+    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) {
+    await this.execSql("DELETE FROM card WHERE hash = ?", hash);
+  }
+  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 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 rows = await this.queryRows("SELECT COUNT(*) as cnt FROM card");
+    return Number(rows[0]?.cnt ?? 0);
+  }
+  async searchByHash(hashPrefix) {
+    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(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 = `%${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 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() {
+    await this.execSql("DELETE FROM handle_history");
+    await this.execSql("DELETE FROM handle_registry");
+    await this.execSql("DELETE FROM card");
+  }
+  // ======================================================================
+  // Concrete: Handle Operations
+  // ======================================================================
+  async registerHandle(handle, hash) {
+    const normalized = validateHandle(handle);
+    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.`);
+    }
+    await this.execSql(
+      "INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, ?, ?)",
+      normalized,
+      hash,
+      now,
+      now
+    );
+  }
+  async resolveHandle(handle) {
+    const normalized = validateHandle(handle);
+    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);
+    if (!hash) return null;
+    return this.get(hash);
+  }
+  async updateHandle(handle, newHash) {
+    const normalized = validateHandle(handle);
+    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 = String(rows[0].current_hash);
+    await this.execSql(
+      "INSERT INTO handle_history (handle, previous_hash, changed_at) VALUES (?, ?, ?)",
+      normalized,
+      previousHash,
+      now
+    );
+    await this.execSql(
+      "UPDATE handle_registry SET current_hash = ?, updated_at = ? WHERE handle = ?",
+      newHash,
+      now,
+      normalized
+    );
+    return previousHash;
+  }
+  async getHandleHistory(handle) {
+    const normalized = validateHandle(handle);
+    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/SqliteNodeEngine.ts
-var DEFAULT_PAGE_SIZE = 10;
-var SqliteNodeEngine = class _SqliteNodeEngine {
+var SqliteNodeEngine = class _SqliteNodeEngine extends AbstractSqlEngine {
   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);
+  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.
@@ -1901,6 +2209,7 @@ var SqliteNodeEngine = class _SqliteNodeEngine {
     return engine;
   }
   constructor(dbPath) {
+    super();
     this.dbPath = dbPath;
   }
   async init() {
@@ -1919,10 +2228,26 @@ var SqliteNodeEngine = class _SqliteNodeEngine {
    */
   setupDatabase() {
     this.db.pragma("journal_mode = WAL");
-    this.db.pragma("busy_timeout = 5000");
+    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
    */
@@ -1935,7 +2260,7 @@ var SqliteNodeEngine = class _SqliteNodeEngine {
   getDbPath() {
     return this.dbPath;
   }
-  // =========== Card Operations ===========
+  // =========== 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 (?, ?, ?)"
@@ -1943,9 +2268,7 @@ var SqliteNodeEngine = class _SqliteNodeEngine {
     stmt.run(card.hash, Buffer.from(card.content), card.g_time);
     return card.hash;
   }
-  /**
-   * Add a card synchronously (for performance-critical paths)
-   */
+  // =========== Sync card operations (for performance-critical callers) ===========
   addSync(card) {
     const stmt = this.db.prepare(
       "INSERT OR REPLACE INTO card (hash, content, g_time) VALUES (?, ?, ?)"
@@ -1953,35 +2276,17 @@ var SqliteNodeEngine = class _SqliteNodeEngine {
     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);
+    return this.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");
@@ -1991,76 +2296,40 @@ var SqliteNodeEngine = class _SqliteNodeEngine {
       "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));
+    const items = rows.map((row) => this.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 stmt = this.db.prepare("SELECT COUNT(*) as cnt 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));
+    return row.cnt;
   }
-  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
-   */
+  // =========== 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 count FROM card 
+            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.count;
+    const totalItems = countRow.cnt;
     const stmt = this.db.prepare(`
-            SELECT hash, content, g_time FROM card 
+            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));
+    const items = rows.map((row) => this.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");
@@ -2069,172 +2338,28 @@ var SqliteNodeEngine = class _SqliteNodeEngine {
     }
     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 countStmt = this.db.prepare("SELECT COUNT(*) as cnt FROM card WHERE INSTR(content, ?) > 0");
     const countRow = countStmt.get(searchBytes);
-    const totalItems = countRow.count;
+    const totalItems = countRow.cnt;
     const stmt = this.db.prepare(`
-            SELECT hash, content, g_time FROM card 
+            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));
+    const items = rows.map((row) => this.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));
+    const items = rows.map((row) => this.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);
-  }
+  // =========== Unique sync method (not in AbstractSqlEngine) ===========
   deleteHistoryEntrySync(handle, previousHash) {
-    const normalized = validateHandle(handle);
+    const { validateHandle: validateHandle2 } = (init_Handle(), __toCommonJS(Handle_exports));
+    const normalized = validateHandle2(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"