@arcaelas/whatsapp 4.5.0 → 6.0.0

package/build/esm/lib/store/engine/lib/redis/index.js

@@ -3,21 +3,21 @@
  * @description Driver de persistencia con Redis.
  * Redis persistence driver.
  */
-/**
- * Normaliza un path colapsando slashes redundantes.
- * Normalizes a path by collapsing redundant slashes.
- */
-function normalize_path(path) {
-    return path.replace(/\/+/g, '/').replace(/^\/|\/$/g, '');
-}
+import { normalize_path, split_path } from '../../../../../lib/store/engine/lib/index.js';
 /**
  * Driver de persistencia con Redis.
  *
  * Keyspaces:
  * - `<prefix>:doc:<path>` → string del documento.
- * - `<prefix>:idx:<parent>` → sorted set (score=mtime, member=path completo).
+ * - `<prefix>:idx:<parent>` → sorted set (score explícito o de escritura, member=path completo).
  *
- * `list` combina ZREVRANGE + MGET → O(log N + M) en una sola round-trip.
+ * El índice ordenado vive en Redis: `list` combina ZREVRANGE + MGET (dos round-trips, O(log N + M))
+ * y `count` es un ZCARD O(1); las escrituras agrupan documento e índice en un pipeline para que
+ * no queden documentos huérfanos del índice si el proceso muere entre ambas operaciones.
+ *
+ * Redis persistence driver. The sorted index lives in Redis: `list` combines ZREVRANGE + MGET
+ * and `count` is an O(1) ZCARD; writes group document and index in a pipeline so no document
+ * is left orphaned from the index when the process dies between both operations.
  *
  * @example
  * import IORedis from 'ioredis';
@@ -36,15 +36,6 @@ export class RedisEngine {
     _idx_key(parent) {
         return `${this._prefix}:idx:${normalize_path(parent)}`;
     }
-    /** @internal */
-    _split(path) {
-        const full = normalize_path(path);
-        const i = full.lastIndexOf('/');
-        if (i === -1) {
-            return { parent: '', full };
-        }
-        return { parent: full.slice(0, i), full };
-    }
     /**
      * Lee el valor de un documento.
      * Reads a document's value.
@@ -53,38 +44,62 @@ export class RedisEngine {
         return this._client.get(this._doc_key(path));
     }
     /**
-     * Escribe el valor y actualiza el índice del padre con el timestamp actual.
-     * Writes the value and updates the parent's index with current timestamp.
+     * Escribe el valor y su entrada de índice en una sola operación; `score` fija el orden
+     * de `list` (por defecto, la hora de escritura).
+     * Writes the value and its index entry in a single operation; `score` drives `list`
+     * ordering (write time by default).
      */
-    async set(path, value) {
-        const { parent, full } = this._split(path);
-        await this._client.set(this._doc_key(full), value);
-        await this._client.zadd(this._idx_key(parent), Date.now(), full);
+    async set(path, value, score) {
+        const { parent } = split_path(path);
+        const full = normalize_path(path);
+        const doc_key = this._doc_key(full);
+        const idx_key = this._idx_key(parent);
+        const rank = score ?? Date.now();
+        const pipeline = this._client.pipeline?.();
+        if (pipeline) {
+            pipeline.set(doc_key, value);
+            pipeline.zadd(idx_key, rank, full);
+            await pipeline.exec();
+        }
+        else {
+            await this._client.set(doc_key, value);
+            await this._client.zadd(idx_key, rank, full);
+        }
     }
     /**
-     * Elimina el doc, su índice y todo el sub-árbol.
-     * Deletes the doc, its index, and the entire subtree.
+     * Elimina el doc, su entrada de índice y todo el sub-árbol.
+     * Deletes the doc, its index entry, and the entire subtree.
      */
     async unset(path) {
-        const { parent, full } = this._split(path);
-        await this._client.del(this._doc_key(full));
-        await this._client.zrem(this._idx_key(parent), full);
-        await this._delete_pattern(`${this._prefix}:doc:${full}/*`);
-        await this._delete_pattern(`${this._prefix}:idx:${full}`);
-        await this._delete_pattern(`${this._prefix}:idx:${full}/*`);
+        const { parent } = split_path(path);
+        const full = normalize_path(path);
+        const pipeline = this._client.pipeline?.();
+        if (pipeline) {
+            pipeline.del([this._doc_key(full), `${this._doc_key(full)}:bin`]);
+            pipeline.zrem(this._idx_key(parent), full);
+            await pipeline.exec();
+        }
+        else {
+            await this._client.del([this._doc_key(full), `${this._doc_key(full)}:bin`]);
+            await this._client.zrem(this._idx_key(parent), full);
+        }
+        await Promise.all([
+            this._delete_pattern(`${this._prefix}:doc:${full}/*`),
+            this._delete_pattern(`${this._prefix}:idx:${full}`),
+            this._delete_pattern(`${this._prefix}:idx:${full}/*`),
+        ]);
         return true;
     }
     /**
-     * Lista valores de los hijos directos, ordenados por mtime DESC en una round-trip.
-     * Lists direct children values ordered by mtime DESC in a single round-trip.
+     * Lista valores de los hijos directos, ordenados por score DESC en dos round-trips.
+     * Lists direct children values ordered by score DESC in two round-trips.
      */
     async list(path, offset = 0, limit = 50) {
-        const { full } = this._split(path);
-        const members = await this._client.zrevrange(this._idx_key(full), offset, offset + limit - 1);
+        const members = await this._client.zrevrange(this._idx_key(path), offset, offset + limit - 1);
         if (members.length === 0) {
             return [];
         }
-        const raws = await this._client.mget(members.map((m) => this._doc_key(m)));
+        const raws = await this._client.mget(members.map((member) => this._doc_key(member)));
         return raws.filter((raw) => raw !== null);
     }
     /**
@@ -92,8 +107,26 @@ export class RedisEngine {
      * Counts direct children in O(1) via ZCARD.
      */
     async count(path) {
-        const { full } = this._split(path);
-        return this._client.zcard(this._idx_key(full));
+        return this._client.zcard(this._idx_key(path));
+    }
+    /**
+     * Lee el binario del documento. Requiere un cliente con soporte de buffers (ioredis lo
+     * trae con `getBuffer`); sin él la librería cae al documento serializado.
+     * Reads the document binary. Requires a buffer-capable client (ioredis ships `getBuffer`);
+     * without it the library falls back to the serialized document.
+     */
+    async get_buffer(path) {
+        return (await this._client.getBuffer?.(`${this._doc_key(path)}:bin`)) ?? null;
+    }
+    /**
+     * Escribe el binario del documento en su propia key, sin JSON ni base64.
+     * Writes the document binary in its own key, with no JSON nor base64.
+     */
+    async set_buffer(path, data, score) {
+        const { parent } = split_path(path);
+        const full = normalize_path(path);
+        await this._client.setBuffer?.(`${this._doc_key(full)}:bin`, data);
+        await this._client.zadd(this._idx_key(parent), score ?? Date.now(), full);
     }
     /**
      * Vacía todo el prefix del cliente.
@@ -111,7 +144,7 @@ export class RedisEngine {
     async _delete_pattern(pattern) {
         let cursor = '0';
         do {
-            const [next, batch] = await this._client.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+            const [next, batch] = await this._client.scan(cursor, 'MATCH', pattern, 'COUNT', 500);
             cursor = next;
             if (batch.length > 0) {
                 await this._client.del(batch);
@@ -119,4 +152,3 @@ export class RedisEngine {
         } while (cursor !== '0');
     }
 }
-//# sourceMappingURL=index.js.map

package/build/esm/lib/store/engine/lib/s3/index.d.ts

@@ -33,7 +33,26 @@ interface S3EngineOptions {
      * Default: `false` (no cache).
      */
     cache?: false | CacheOptions;
+    /** Prefijos indexados simultáneamente en memoria. / Simultaneously in-memory indexed prefixes. */
+    cached?: number;
 }
+/**
+ * Driver de persistencia con AWS S3.
+ *
+ * Para que `list`/`count` no recorran todo el prefijo en cada página mantiene un índice
+ * ordenado por prefijo (`SortedIndex`), acotado por LRU y respaldado en el objeto `.order`:
+ * ahí viven los scores explícitos que S3 no puede representar (`LastModified` es de sólo
+ * lectura), de modo que el orden cronológico sobrevive a los re-syncs igual que en los
+ * demás drivers. Si el objeto `.order` falta, el índice se reconstruye listando el prefijo
+ * una única vez y ordenando por `LastModified`.
+ *
+ * AWS S3 persistence driver. To keep `list`/`count` from walking the whole prefix on every
+ * page it maintains a per-prefix sorted index (`SortedIndex`), LRU-bounded and backed by the
+ * `.order` object: it holds the explicit scores S3 cannot represent (`LastModified` is
+ * read-only), so chronological order survives re-syncs just like on the other drivers. When
+ * `.order` is missing the index is rebuilt listing the prefix once and ordering by
+ * `LastModified`.
+ */
 export declare class S3Engine implements Engine {
     private readonly _client;
     private readonly _bucket;
@@ -41,6 +60,8 @@ export declare class S3Engine implements Engine {
     private readonly _cache_opts;
     /** @internal Caché local de documentos, con su timer de expiración. / Local cache of documents, with its expiration timer. */
     private readonly _cache;
+    /** @internal Índices por prefijo, acotados por LRU. / Per-prefix indexes, LRU-bounded. */
+    private readonly _indexes;
     constructor(options: S3EngineOptions);
     private _key;
     /**
@@ -55,11 +76,33 @@ export declare class S3Engine implements Engine {
      * Replaces the previous timer when the key was already cached so timers don't pile up.
      */
     private _cache_set;
+    /**
+     * @internal
+     * Índice del prefijo: de la caché, del objeto `.order` o reconstruido listando el prefijo
+     * una sola vez y ordenando por `LastModified`.
+     * Prefix index: from the cache, from the `.order` object or rebuilt listing the prefix
+     * once and ordering by `LastModified`.
+     */
+    private _index;
     get(key: string): Promise<string | null>;
-    set(key: string, value: string): Promise<void>;
+    /**
+     * Escribe el valor y registra su score en el índice del prefijo, que S3 no puede
+     * derivar por sí solo (`LastModified` es de sólo lectura).
+     * Writes the value and records its score in the prefix index, which S3 cannot derive
+     * on its own (`LastModified` is read-only).
+     */
+    set(key: string, value: string, score?: number): Promise<void>;
+    /**
+     * Lista los valores de los hijos directos, ordenados por score DESC.
+     * Lists direct children values ordered by score DESC.
+     */
     list(path: string, offset?: number, limit?: number): Promise<string[]>;
     delete_prefix(prefix: string): Promise<number>;
     unset(path: string): Promise<boolean>;
+    /**
+     * Cuenta hijos directos desde el índice del prefijo.
+     * Counts direct children from the prefix index.
+     */
     count(path: string): Promise<number>;
     clear(): Promise<void>;
 }

package/build/esm/lib/store/engine/lib/s3/index.js

@@ -4,13 +4,26 @@
  * AWS S3 persistence driver (optional local cache).
  */
 import { DeleteObjectsCommand, GetObjectCommand, ListObjectsV2Command, PutObjectCommand } from '@aws-sdk/client-s3';
+import { IndexCache, normalize_path, SortedIndex, split_path } from '../../../../../lib/store/engine/lib/index.js';
+/** Objeto que guarda el orden de los hijos de un prefijo. / Object holding the ordering of a prefix children. */
+const ORDER_KEY = '.order';
 /**
- * Normaliza un path colapsando slashes redundantes.
- * Normalizes a path by collapsing redundant slashes.
+ * Driver de persistencia con AWS S3.
+ *
+ * Para que `list`/`count` no recorran todo el prefijo en cada página mantiene un índice
+ * ordenado por prefijo (`SortedIndex`), acotado por LRU y respaldado en el objeto `.order`:
+ * ahí viven los scores explícitos que S3 no puede representar (`LastModified` es de sólo
+ * lectura), de modo que el orden cronológico sobrevive a los re-syncs igual que en los
+ * demás drivers. Si el objeto `.order` falta, el índice se reconstruye listando el prefijo
+ * una única vez y ordenando por `LastModified`.
+ *
+ * AWS S3 persistence driver. To keep `list`/`count` from walking the whole prefix on every
+ * page it maintains a per-prefix sorted index (`SortedIndex`), LRU-bounded and backed by the
+ * `.order` object: it holds the explicit scores S3 cannot represent (`LastModified` is
+ * read-only), so chronological order survives re-syncs just like on the other drivers. When
+ * `.order` is missing the index is rebuilt listing the prefix once and ordering by
+ * `LastModified`.
  */
-function normalize_path(path) {
-    return path.replace(/\/+/g, '/').replace(/^\/|\/$/g, '');
-}
 export class S3Engine {
     constructor(options) {
         /** @internal Caché local de documentos, con su timer de expiración. / Local cache of documents, with its expiration timer. */
@@ -19,6 +32,7 @@ export class S3Engine {
         this._bucket = options.bucket;
         this._prefix = options.basedir.endsWith('/') ? options.basedir : `${options.basedir}/`;
         this._cache_opts = options.cache ?? false;
+        this._indexes = new IndexCache(options.cached ?? 12);
     }
     _key(key) {
         return `${this._prefix}${normalize_path(key).replace(/@/g, '_at_')}`;
@@ -46,69 +60,108 @@ export class S3Engine {
             timer: setTimeout(() => this._cache.delete(path), this._cache_opts.ttl),
         });
     }
+    /**
+     * @internal
+     * Índice del prefijo: de la caché, del objeto `.order` o reconstruido listando el prefijo
+     * una sola vez y ordenando por `LastModified`.
+     * Prefix index: from the cache, from the `.order` object or rebuilt listing the prefix
+     * once and ordering by `LastModified`.
+     */
+    async _index(path) {
+        const key = normalize_path(path);
+        const cached = this._indexes.get(key);
+        if (cached) {
+            return cached;
+        }
+        const parent = `${this._key(key)}/`;
+        const index = new SortedIndex(async (entries) => {
+            await this._client
+                .send(new PutObjectCommand({
+                Bucket: this._bucket,
+                Key: `${parent}${ORDER_KEY}`,
+                Body: entries.map(([name, score]) => `${score}\t${name}`).join('\n'),
+                ContentType: 'text/plain',
+            }))
+                .catch(() => null);
+        });
+        const persisted = await this._client
+            .send(new GetObjectCommand({ Bucket: this._bucket, Key: `${parent}${ORDER_KEY}` }))
+            .then((res) => res.Body?.transformToString('utf-8') ?? null)
+            .catch(() => null);
+        if (persisted) {
+            index.load(persisted
+                .split('\n')
+                .filter(Boolean)
+                .map((line) => {
+                const cut = line.indexOf('\t');
+                return [line.slice(cut + 1), Number(line.slice(0, cut))];
+            }));
+        }
+        else {
+            const children = new Map();
+            let token;
+            do {
+                const res = await this._client.send(new ListObjectsV2Command({ Bucket: this._bucket, Prefix: parent, ContinuationToken: token, MaxKeys: 1000 }));
+                for (const object of res.Contents ?? []) {
+                    const rest = object.Key?.slice(parent.length);
+                    const name = rest?.split('/')[0];
+                    if (name && name !== ORDER_KEY) {
+                        children.set(name, Math.max(children.get(name) ?? 0, object.LastModified?.getTime() ?? 0));
+                    }
+                }
+                token = res.NextContinuationToken;
+            } while (token);
+            index.load(children);
+        }
+        this._indexes.set(key, index);
+        return index;
+    }
     async get(key) {
         if (this._cacheable(key) && this._cache.has(key)) {
             return this._cache.get(key).value;
         }
-        const value = await (async () => {
-            try {
-                const res = await this._client.send(new GetObjectCommand({ Bucket: this._bucket, Key: this._key(key) }));
-                return (await res.Body?.transformToString('utf-8')) ?? null;
-            }
-            catch {
-                return null;
-            }
-        })();
+        const value = await this._client
+            .send(new GetObjectCommand({ Bucket: this._bucket, Key: this._key(key) }))
+            .then((res) => res.Body?.transformToString('utf-8') ?? null)
+            .catch(() => null);
         if (this._cacheable(key)) {
             this._cache_set(key, value);
         }
         return value;
     }
-    async set(key, value) {
+    /**
+     * Escribe el valor y registra su score en el índice del prefijo, que S3 no puede
+     * derivar por sí solo (`LastModified` es de sólo lectura).
+     * Writes the value and records its score in the prefix index, which S3 cannot derive
+     * on its own (`LastModified` is read-only).
+     */
+    async set(key, value, score) {
         const remote = this._client.send(new PutObjectCommand({ Bucket: this._bucket, Key: this._key(key), Body: value, ContentType: 'application/json' }));
         if (this._cacheable(key)) {
             this._cache_set(key, value);
         }
+        const { parent, name } = split_path(key);
+        // A diferencia del filesystem, S3 no tiene dónde guardar el score fuera del índice
+        // (`LastModified` es de sólo lectura), así que el índice se carga aunque nadie haya
+        // paginado todavía; si no, el orden cronológico se perdería en la primera escritura.
+        // Unlike the filesystem, S3 has nowhere to keep the score outside the index
+        // (`LastModified` is read-only), so the index is loaded even when nobody paginated
+        // yet; otherwise chronological order would be lost on the first write.
+        (await this._index(parent)).set(name, score ?? Date.now());
         await remote;
     }
+    /**
+     * Lista los valores de los hijos directos, ordenados por score DESC.
+     * Lists direct children values ordered by score DESC.
+     */
     async list(path, offset = 0, limit = 50) {
-        const parent = `${this._prefix}${normalize_path(path).replace(/@/g, '_at_')}/`;
-        const children = new Map();
-        let token;
-        do {
-            const res = await this._client.send(new ListObjectsV2Command({
-                Bucket: this._bucket,
-                Prefix: parent,
-                ContinuationToken: token,
-                MaxKeys: 1000,
-            }));
-            for (const obj of res.Contents ?? []) {
-                if (!obj.Key)
-                    continue;
-                const rest = obj.Key.slice(parent.length);
-                const child_key = `${parent}${rest.split('/')[0]}`;
-                const mtime = obj.LastModified?.getTime() ?? 0;
-                children.set(child_key, Math.max(children.get(child_key) ?? 0, mtime));
-            }
-            token = res.NextContinuationToken;
-        } while (token);
-        const ordered = [...children.entries()]
-            .sort((a, b) => b[1] - a[1])
-            .slice(offset, offset + limit)
-            .map(([key]) => key);
-        const values = await Promise.all(ordered.map(async (key) => {
-            try {
-                const res = await this._client.send(new GetObjectCommand({ Bucket: this._bucket, Key: key }));
-                return (await res.Body?.transformToString('utf-8')) ?? null;
-            }
-            catch {
-                return null;
-            }
-        }));
+        const parent = normalize_path(path);
+        const page = (await this._index(parent)).page(offset, limit);
+        const values = await Promise.all(page.map((name) => this.get(`${parent}/${name}`)));
         return values.filter((value) => value !== null);
     }
     async delete_prefix(prefix) {
-        const full_prefix = `${this._prefix}${normalize_path(prefix).replace(/@/g, '_at_')}`;
+        const full_prefix = this._key(prefix);
         let deleted = 0;
         let token;
         do {
@@ -136,30 +189,24 @@ export class S3Engine {
                 }
             }
         }
+        const { parent, name } = split_path(path);
+        (await this._index(parent)).delete(name);
+        this._indexes.drop(normalize_path(path));
         return (await this.delete_prefix(path)) > 0;
     }
+    /**
+     * Cuenta hijos directos desde el índice del prefijo.
+     * Counts direct children from the prefix index.
+     */
     async count(path) {
-        const full_prefix = `${this._prefix}${normalize_path(path).replace(/@/g, '_at_')}`;
-        let total = 0;
-        let token;
-        do {
-            const res = await this._client.send(new ListObjectsV2Command({
-                Bucket: this._bucket,
-                Prefix: full_prefix,
-                ContinuationToken: token,
-                MaxKeys: 1000,
-            }));
-            total += res.Contents?.length ?? 0;
-            token = res.NextContinuationToken;
-        } while (token);
-        return total;
+        return (await this._index(path)).size;
     }
     async clear() {
         for (const { timer } of this._cache.values()) {
             clearTimeout(timer);
         }
         this._cache.clear();
+        this._indexes.clear();
         await this.delete_prefix('');
     }
 }
-//# sourceMappingURL=index.js.map

package/build/esm/lib/store/engine/lib/sqlite/index.d.ts

@@ -0,0 +1,110 @@
+/**
+ * @file store/engine/lib/sqlite/index.ts
+ * @description Driver de persistencia con SQLite.
+ * SQLite persistence driver.
+ */
+import type { Engine } from '../../../../../lib/store/engine/index.js';
+/**
+ * Sentencia preparada, con la forma que exponen `better-sqlite3` y `node:sqlite`.
+ * Prepared statement, shaped as `better-sqlite3` and `node:sqlite` expose it.
+ */
+interface SQLiteStatement {
+    run(...params: unknown[]): unknown;
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+}
+/**
+ * Interface mínima de la base SQLite. La cumplen `better-sqlite3` (`new Database(file)`) y
+ * el `node:sqlite` nativo (`new DatabaseSync(file)`), así que el driver no agrega ninguna
+ * dependencia: la base se inyecta ya abierta, igual que el cliente de `RedisEngine`.
+ * Minimal SQLite database interface. Both `better-sqlite3` (`new Database(file)`) and the
+ * native `node:sqlite` (`new DatabaseSync(file)`) satisfy it, so this driver adds no
+ * dependency: the database is injected already open, just like `RedisEngine`'s client.
+ */
+export interface SQLiteDatabase {
+    exec(sql: string): unknown;
+    prepare(sql: string): SQLiteStatement;
+}
+/**
+ * Driver de persistencia con SQLite: una tabla `(path, parent, score, value)` con índice
+ * `(parent, score DESC)`.
+ *
+ * Es el driver más eficiente de los integrados porque delega en el motor lo que los demás
+ * resuelven a mano: `list` es un `ORDER BY score DESC LIMIT/OFFSET` sobre el índice (sin
+ * índice en memoria ni archivo de orden), `count` un `COUNT(*)` y el `unset` en cascada una
+ * sola sentencia por rango de `path`. Medido sobre un chat real de 55.146 mensajes frente al
+ * filesystem: 220 MB → 64 MB en disco, primer `list` 115 ms → 0,6 ms y dos archivos en total.
+ *
+ * SQLite persistence driver: a single `(path, parent, score, value)` table with a
+ * `(parent, score DESC)` index. The most efficient built-in driver, since it delegates to the
+ * engine what the others hand-roll: `list` is an indexed `ORDER BY score DESC LIMIT/OFFSET`
+ * (no in-memory index, no order file), `count` a `COUNT(*)` and cascading `unset` a single
+ * range statement. Measured on a real 55,146-message chat against the filesystem: 220 MB →
+ * 64 MB on disk, first `list` 115 ms → 0.6 ms and two files in total.
+ *
+ * @example
+ * import Database from 'better-sqlite3';
+ * const engine = new SQLiteEngine(new Database('.sessions/584144709840.db'));
+ *
+ * @example
+ * import { DatabaseSync } from 'node:sqlite';
+ * const engine = new SQLiteEngine(new DatabaseSync('.sessions/584144709840.db'));
+ */
+export declare class SQLiteEngine implements Engine {
+    private readonly _db;
+    private readonly _read;
+    private readonly _write;
+    private readonly _remove;
+    private readonly _page;
+    private readonly _total;
+    private readonly _wipe;
+    private readonly _read_blob;
+    private readonly _write_blob;
+    /**
+     * @param _db - Base SQLite ya abierta / Already open SQLite database
+     * @param table - Tabla donde viven los documentos / Table holding the documents
+     */
+    constructor(_db: SQLiteDatabase, table?: string);
+    /**
+     * Lee el valor de un documento.
+     * Reads a document's value.
+     */
+    get(path: string): Promise<string | null>;
+    /**
+     * Escribe el valor del documento; `score` fija el orden de `list` (por defecto, la hora
+     * de escritura).
+     * Writes the document value; `score` drives `list` ordering (write time by default).
+     */
+    set(path: string, value: string, score?: number): Promise<void>;
+    /**
+     * Elimina el documento y todos sus descendientes. Idempotente.
+     * Deletes the document and every descendant. Idempotent.
+     */
+    unset(path: string): Promise<boolean>;
+    /**
+     * Lista los valores de los hijos directos, ordenados por score DESC.
+     * Lists direct children values ordered by score DESC.
+     */
+    list(path: string, offset?: number, limit?: number): Promise<string[]>;
+    /**
+     * Cuenta los hijos directos.
+     * Counts direct children.
+     */
+    count(path: string): Promise<number>;
+    /**
+     * Lee el binario del documento, o null si la fila no lo tiene.
+     * Reads the document binary, or null when the row has none.
+     */
+    get_buffer(path: string): Promise<Buffer | null>;
+    /**
+     * Escribe el binario del documento como BLOB, sin JSON ni base64.
+     * Writes the document binary as a BLOB, with no JSON nor base64.
+     */
+    set_buffer(path: string, data: Buffer, score?: number): Promise<void>;
+    /**
+     * Vacía la tabla completa.
+     * Clears the entire table.
+     */
+    clear(): Promise<void>;
+}
+export {};