mcard-js 2.1.39 → 2.1.41

package/dist/index.cjs

@@ -959,6 +959,25 @@ var init_mime_extensions = __esm({
   }
 });
 
+// src/config/constants.ts
+var DEFAULT_PAGE_SIZE, DETECTION_SAMPLE_CAP, MAX_FILE_SIZE, KNOWN_TYPE_SIZE_LIMIT, BINARY_CHECK_SAMPLE_SIZE, CONTENT_DETECTION_SAMPLE_SIZE, DEFAULT_MAX_PROBLEM_BYTES, INDEXEDDB_DEFAULT_DB_NAME, INDEXEDDB_DEFAULT_DB_VERSION, SQLITE_BUSY_TIMEOUT_MS, DEFAULT_SQLJS_WASM_URL;
+var init_constants = __esm({
+  "src/config/constants.ts"() {
+    "use strict";
+    DEFAULT_PAGE_SIZE = 10;
+    DETECTION_SAMPLE_CAP = 8192;
+    MAX_FILE_SIZE = 50 * 1024 * 1024;
+    KNOWN_TYPE_SIZE_LIMIT = 1024 * 1024;
+    BINARY_CHECK_SAMPLE_SIZE = 32 * 1024;
+    CONTENT_DETECTION_SAMPLE_SIZE = 1024 * 1024;
+    DEFAULT_MAX_PROBLEM_BYTES = 2 * 1024 * 1024;
+    INDEXEDDB_DEFAULT_DB_NAME = "mcard-db";
+    INDEXEDDB_DEFAULT_DB_VERSION = 1;
+    SQLITE_BUSY_TIMEOUT_MS = 5e3;
+    DEFAULT_SQLJS_WASM_URL = "https://sql.js.org/dist/";
+  }
+});
+
 // src/model/strategies/DetectionStrategy.ts
 function loadSharedMimeData() {
   return {
@@ -975,6 +994,7 @@ var init_DetectionStrategy = __esm({
     "use strict";
     init_registry();
     init_mime_extensions();
+    init_constants();
     _sharedData = loadSharedMimeData();
     DefaultDetectionStrategy = class _DefaultDetectionStrategy {
       constructor(customRegistry) {
@@ -997,7 +1017,7 @@ var init_DetectionStrategy = __esm({
         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] || "";
@@ -1031,9 +1051,9 @@ var init_DetectionStrategy = __esm({
       }
       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);
@@ -1303,6 +1323,12 @@ var init_MCard = __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);
 }
@@ -1313,7 +1339,7 @@ function validateHandle(handle) {
   if (!handle) {
     throw new HandleValidationError("Handle cannot be empty.");
   }
-  const normalized = handle.trim().normalize("NFC").toLowerCase();
+  const normalized = handle.trim().normalize("NFC");
   if (normalized.length === 0) {
     throw new HandleValidationError("Handle cannot be empty after normalization.");
   }
@@ -1454,7 +1480,7 @@ var init_Maybe = __esm({
 
 // src/model/constants.ts
 var EVENT_CONSTANTS, ALGORITHM_HIERARCHY;
-var init_constants = __esm({
+var init_constants2 = __esm({
   "src/model/constants.ts"() {
     "use strict";
     EVENT_CONSTANTS = {
@@ -1521,7 +1547,7 @@ function nextHashFunction(current) {
 var init_EventProducer = __esm({
   "src/model/EventProducer.ts"() {
     "use strict";
-    init_constants();
+    init_constants2();
     init_GTime();
     init_HashValidator();
   }
@@ -1537,6 +1563,7 @@ var init_CardCollection = __esm({
   "src/model/CardCollection.ts"() {
     "use strict";
     init_MCard();
+    init_constants();
     init_Maybe();
     CardCollection = class {
       engine;
@@ -1596,7 +1623,7 @@ var init_CardCollection = __esm({
       /**
        * 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);
       }
       /**
@@ -1686,10 +1713,10 @@ var init_CardCollection = __esm({
       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) {
@@ -1698,7 +1725,7 @@ var init_CardCollection = __esm({
       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;
@@ -1789,17 +1816,18 @@ var init_IndexedDBEngine = __esm({
     init_MCard();
     init_Handle();
     init_StorageAdapter();
+    init_constants();
     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" });
@@ -1844,7 +1872,7 @@ var init_IndexedDBEngine = __esm({
         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");
@@ -1865,7 +1893,7 @@ var init_IndexedDBEngine = __esm({
         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();
@@ -2707,167 +2735,135 @@ var init_schema = __esm({
   }
 });
 
-// src/storage/engines/SqliteWasmEngine.ts
-var SqliteWasmEngine;
-var init_SqliteWasmEngine = __esm({
-  "src/storage/engines/SqliteWasmEngine.ts"() {
+// src/storage/engines/AbstractSqlEngine.ts
+var AbstractSqlEngine;
+var init_AbstractSqlEngine = __esm({
+  "src/storage/engines/AbstractSqlEngine.ts"() {
     "use strict";
-    init_MCard();
     init_Handle();
     init_StorageAdapter();
-    init_schema();
-    SqliteWasmEngine = class {
-      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 || `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;
-      }
+    init_constants();
+    AbstractSqlEngine = class {
       /**
-       * Export database as Uint8Array (for persistence)
+       * SQL expression for casting content to text in search queries.
+       * Override in subclasses: SQLite uses 'TEXT', DuckDB uses 'VARCHAR'.
        */
-      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);
@@ -2875,42 +2871,216 @@ var init_SqliteWasmEngine = __esm({
         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;
+var init_SqliteWasmEngine = __esm({
+  "src/storage/engines/SqliteWasmEngine.ts"() {
+    "use strict";
+    init_MCard();
+    init_schema();
+    init_AbstractSqlEngine();
+    init_constants();
+    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]);
@@ -2930,67 +3100,6 @@ var init_SqliteWasmEngine = __esm({
         }
         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]);
-        }
-      }
     };
   }
 });
@@ -3008,24 +3117,25 @@ var init_SqliteWasmEngine2 = __esm({
 });
 
 // src/storage/engines/SqliteNodeEngine.ts
-var DEFAULT_PAGE_SIZE, SqliteNodeEngine;
+var SqliteNodeEngine;
 var init_SqliteNodeEngine = __esm({
   "src/storage/engines/SqliteNodeEngine.ts"() {
     "use strict";
     init_MCard();
-    init_Handle();
     init_StorageAdapter();
     init_schema();
-    DEFAULT_PAGE_SIZE = 10;
-    SqliteNodeEngine = class _SqliteNodeEngine {
+    init_AbstractSqlEngine();
+    init_constants();
+    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.
@@ -3037,6 +3147,7 @@ var init_SqliteNodeEngine = __esm({
         return engine;
       }
       constructor(dbPath) {
+        super();
         this.dbPath = dbPath;
       }
       async init() {
@@ -3055,10 +3166,26 @@ var init_SqliteNodeEngine = __esm({
        */
       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
        */
@@ -3071,7 +3198,7 @@ var init_SqliteNodeEngine = __esm({
       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 (?, ?, ?)"
@@ -3079,9 +3206,7 @@ var init_SqliteNodeEngine = __esm({
         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 (?, ?, ?)"
@@ -3089,35 +3214,17 @@ var init_SqliteNodeEngine = __esm({
         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);
+        return this.rowToCard(row);
       }
-      /**
-       * 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");
@@ -3127,76 +3234,40 @@ var init_SqliteNodeEngine = __esm({
           "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;
+        return row.cnt;
       }
-      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
-       */
+      // =========== 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");
@@ -3205,172 +3276,28 @@ var init_SqliteNodeEngine = __esm({
         }
         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"
@@ -3621,7 +3548,7 @@ async function isProblematicFile(filePath) {
     const stats = await fs.stat(filePath);
     if (stats.size === 0) return false;
     if (path.basename(filePath).startsWith(".")) return true;
-    if (stats.size > MAX_FILE_SIZE) return true;
+    if (stats.size > MAX_FILE_SIZE2) return true;
     const ext = path.extname(filePath);
     const isKnownType = ContentTypeInterpreter.isKnownLongLineExtension(ext);
     if (isKnownType && stats.size > 1024 * 1024) return true;
@@ -3642,7 +3569,7 @@ async function isProblematicFile(filePath) {
 }
 async function readFileSafely(filePath, options = {}) {
   const stats = await fs.stat(filePath);
-  if (stats.size > MAX_FILE_SIZE) throw new Error(`File too large: ${stats.size}`);
+  if (stats.size > MAX_FILE_SIZE2) throw new Error(`File too large: ${stats.size}`);
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), READ_TIMEOUT_MS);
   try {
@@ -3707,7 +3634,7 @@ async function processFileContent(filePath, options = {}) {
     size: rawContent.length
   };
 }
-var crypto2, fs, path, MAX_FILE_SIZE, READ_TIMEOUT_MS;
+var crypto2, fs, path, MAX_FILE_SIZE2, READ_TIMEOUT_MS;
 var init_FileIO = __esm({
   "src/FileIO.ts"() {
     "use strict";
@@ -3715,7 +3642,7 @@ var init_FileIO = __esm({
     fs = __toESM(require("fs/promises"), 1);
     path = __toESM(require("path"), 1);
     init_ContentTypeInterpreter();
-    MAX_FILE_SIZE = 50 * 1024 * 1024;
+    MAX_FILE_SIZE2 = 50 * 1024 * 1024;
     READ_TIMEOUT_MS = 5e3;
   }
 });
@@ -3729,7 +3656,7 @@ __export(Loader_exports, {
 async function processAndStoreFile(filePath, collection, options = {}) {
   const {
     allowProblematic = false,
-    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES,
+    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES2,
     metadataOnly = false,
     rootPath
   } = options;
@@ -3843,7 +3770,7 @@ async function loadFileToCollection(targetPath, collection, options = {}) {
   const {
     recursive = false,
     includeProblematic = false,
-    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES,
+    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES2,
     metadataOnly = false
   } = options;
   const resolvedPath = path2.resolve(targetPath);
@@ -3889,7 +3816,7 @@ async function loadFileToCollection(targetPath, collection, options = {}) {
   }
   return { metrics, results };
 }
-var fs2, path2, DEFAULT_MAX_PROBLEM_BYTES, WRAP_WIDTH_KNOWN, WRAP_WIDTH_DEFAULT;
+var fs2, path2, DEFAULT_MAX_PROBLEM_BYTES2, WRAP_WIDTH_KNOWN, WRAP_WIDTH_DEFAULT;
 var init_Loader = __esm({
   "src/Loader.ts"() {
     "use strict";
@@ -3898,7 +3825,7 @@ var init_Loader = __esm({
     init_MCard();
     init_FileIO();
     init_ContentTypeInterpreter();
-    DEFAULT_MAX_PROBLEM_BYTES = 2 * 1024 * 1024;
+    DEFAULT_MAX_PROBLEM_BYTES2 = 2 * 1024 * 1024;
     WRAP_WIDTH_KNOWN = 1e3;
     WRAP_WIDTH_DEFAULT = 80;
   }
@@ -6007,8 +5934,8 @@ var init_lean = __esm({
       async execute(code, context, config) {
         const contextStr = typeof context === "string" ? context : JSON.stringify(context);
         const sourcePath = await getCachedLeanSource(code);
-        const os = await import("os");
-        const elanPath = path8.join(os.homedir(), ".elan", "bin", "elan");
+        const os2 = await import("os");
+        const elanPath = path8.join(os2.homedir(), ".elan", "bin", "elan");
         let stdout;
         if (fs6.existsSync(elanPath)) {
           const result = await execFile2(elanPath, [
@@ -6031,12 +5958,13 @@ var init_lean = __esm({
 });
 
 // src/ptr/node/runtimes/loader.ts
-var fs7, path9, LoaderRuntime, CollectionLoaderRuntime;
+var fs7, path9, os, LoaderRuntime, CollectionLoaderRuntime;
 var init_loader = __esm({
   "src/ptr/node/runtimes/loader.ts"() {
     "use strict";
     fs7 = __toESM(require("fs"), 1);
     path9 = __toESM(require("path"), 1);
+    os = __toESM(require("os"), 1);
     init_MCard();
     init_SqliteNodeEngine2();
     init_CardCollection();
@@ -6111,11 +6039,12 @@ var init_loader = __esm({
        */
       async execute(_code, context, config) {
         const ctx = context;
+        const defaultDbPath = path9.join(os.tmpdir(), "loader_clm.db");
         const loaderParams = extractLoaderParams(ctx, {
           sourceDir: "chapters/chapter_04_load_dir/test_data",
-          dbPath: "data/loader_clm.db"
+          dbPath: defaultDbPath
         });
-        const { sourceDir, recursive, dbPath = "data/loader_clm.db" } = loaderParams;
+        const { sourceDir, recursive, dbPath = defaultDbPath } = loaderParams;
         const projectRoot = findProjectRoot();
         const sourcePath = path9.isAbsolute(sourceDir) ? sourceDir : path9.join(projectRoot, sourceDir);
         if (!fs7.existsSync(sourcePath)) {
@@ -8770,7 +8699,7 @@ init_GTime();
 init_Handle();
 init_CardCollection();
 init_ContentTypeInterpreter();
-init_constants();
+init_constants2();
 init_IndexedDBEngine2();
 init_SqliteWasmEngine2();
 init_SqliteNodeEngine2();