@bitsocial/pubsub-votes 0.0.2

package/dist/storage/browser.js

@@ -0,0 +1,110 @@
+import localForage from "localforage";
+import { makeMemoryStorage } from "./memory.js";
+/**
+ * The browser backend, swapped in for storage/node.ts by the package.json `browser` field
+ * remap (same mechanism pkc-js uses for its whole runtime tree, scoped here to one module).
+ * It is a port of pkc-js's localforage-lru (runtime/browser/localforage-lru.ts): two
+ * IndexedDB databases per named cache (`pubsub-votes-{cacheName}` and `…2`) with round-robin
+ * eviction — writes fill the active database, and when it reaches `maxItems` the databases
+ * swap roles and the new active one is cleared, so at most the oldest half of entries drops
+ * at once. A read hit in the inactive database promotes the entry to the active one, which is
+ * what makes the scheme approximate LRU rather than plain FIFO.
+ *
+ * `dataPath` is meaningless in the browser (pkc-js's browser `getDefaultDataPath()` is
+ * likewise `undefined`): a string is ignored, `false` still selects the in-memory backend.
+ */
+class LocalForageLruStorage {
+    #maxItems;
+    #name;
+    #initialized;
+    constructor(opts) {
+        this.#name = `pubsub-votes-${opts.cacheName}`;
+        this.#maxItems = opts.maxItems;
+    }
+    #init() {
+        this.#initialized ??= (async () => {
+            const database1 = localForage.createInstance({ name: this.#name });
+            const database2 = localForage.createInstance({ name: `${this.#name}2` });
+            const [size1, size2] = await Promise.all([database1.length(), database2.length()]);
+            // The largest database is the active one, unless it is full (a full database is
+            // always the inactive, about-to-be-dropped half) — pkc-js's exact recovery rule.
+            let [active, inactive] = (size1 >= size2 && size1 !== this.#maxItems) || size2 === this.#maxItems
+                ? [database1, database2]
+                : [database2, database1];
+            let activeSize = await active.length();
+            const swap = async () => {
+                activeSize = 0;
+                [active, inactive] = [inactive, active];
+                await active.clear();
+            };
+            return {
+                active: () => active,
+                inactive: () => inactive,
+                grow: async () => {
+                    activeSize += 1;
+                    if (activeSize >= this.#maxItems) {
+                        // removeItem/clear never decrement the counter, so it only ever
+                        // over-counts — reconcile at the threshold so a purge-heavy session
+                        // cannot swap (and clear) before the active half is actually full.
+                        activeSize = await active.length();
+                        if (activeSize >= this.#maxItems)
+                            await swap();
+                    }
+                },
+                swap
+            };
+        })();
+        return this.#initialized;
+    }
+    async getItem(key) {
+        const db = await this.#init();
+        const value = await db.active().getItem(key);
+        if (value !== null && value !== undefined)
+            return value;
+        const older = await db.inactive().getItem(key);
+        if (older === null || older === undefined)
+            return undefined;
+        await this.setItem(key, older); // promote: a hit in the older half re-enters the active one
+        return older;
+    }
+    async setItem(key, value) {
+        const db = await this.#init();
+        const existing = await db.active().getItem(key);
+        await db.active().setItem(key, value ?? null);
+        if (existing === null || existing === undefined)
+            await db.grow();
+    }
+    async removeItem(key) {
+        const db = await this.#init();
+        await Promise.all([db.active().removeItem(key), db.inactive().removeItem(key)]);
+    }
+    async keys() {
+        const db = await this.#init();
+        const [keys1, keys2] = await Promise.all([db.active().keys(), db.inactive().keys()]);
+        return [...new Set([...keys1, ...keys2])];
+    }
+    async clear() {
+        const db = await this.#init();
+        await Promise.all([db.active().clear(), db.inactive().clear()]);
+    }
+}
+/** Build the browser {@link VoteStorage}: IndexedDB via localforage, or in-memory for `false`. */
+export function makeStorage(options) {
+    if (options.dataPath === false)
+        return makeMemoryStorage();
+    const stores = new Map();
+    return {
+        openLru({ cacheName, maxItems }) {
+            let store = stores.get(cacheName);
+            if (!store) {
+                store = new LocalForageLruStorage({ cacheName, maxItems });
+                stores.set(cacheName, store);
+            }
+            return store;
+        },
+        // localforage holds no closeable handles; dropping the references is the whole teardown.
+        async destroy() {
+            stores.clear();
+        }
+    };
+}

package/dist/storage/memory.d.ts

@@ -0,0 +1,10 @@
+import type { LruStorage, VoteStorage } from "./types.js";
+/**
+ * The `dataPath: false` backend on both platforms (pkc-js's `noData` equivalent): a true-LRU
+ * `Map` — a `get` hit re-inserts the key so insertion order IS recency order, and eviction
+ * deletes the oldest key past `maxItems`. Nothing survives the process; semantics otherwise
+ * match the persistent backends so tests and no-disk hosts exercise the same code paths.
+ */
+export declare function makeMemoryLruStorage(maxItems: number): LruStorage;
+/** An all-in-memory {@link VoteStorage}; `destroy()` only drops the references. */
+export declare function makeMemoryStorage(): VoteStorage;

package/dist/storage/memory.js

@@ -0,0 +1,56 @@
+/**
+ * The `dataPath: false` backend on both platforms (pkc-js's `noData` equivalent): a true-LRU
+ * `Map` — a `get` hit re-inserts the key so insertion order IS recency order, and eviction
+ * deletes the oldest key past `maxItems`. Nothing survives the process; semantics otherwise
+ * match the persistent backends so tests and no-disk hosts exercise the same code paths.
+ */
+export function makeMemoryLruStorage(maxItems) {
+    const entries = new Map();
+    const touch = (key, value) => {
+        entries.delete(key);
+        entries.set(key, value);
+    };
+    return {
+        async getItem(key) {
+            if (!entries.has(key))
+                return undefined;
+            const value = entries.get(key);
+            touch(key, value);
+            return value;
+        },
+        async setItem(key, value) {
+            touch(key, value);
+            if (entries.size > maxItems) {
+                const oldest = entries.keys().next().value;
+                if (oldest !== undefined)
+                    entries.delete(oldest);
+            }
+        },
+        async removeItem(key) {
+            entries.delete(key);
+        },
+        async keys() {
+            return [...entries.keys()];
+        },
+        async clear() {
+            entries.clear();
+        }
+    };
+}
+/** An all-in-memory {@link VoteStorage}; `destroy()` only drops the references. */
+export function makeMemoryStorage() {
+    const stores = new Map();
+    return {
+        openLru({ cacheName, maxItems }) {
+            let store = stores.get(cacheName);
+            if (!store) {
+                store = makeMemoryLruStorage(maxItems);
+                stores.set(cacheName, store);
+            }
+            return store;
+        },
+        async destroy() {
+            stores.clear();
+        }
+    };
+}

package/dist/storage/node.d.ts

@@ -0,0 +1,5 @@
+import type { StorageOptions, VoteStorage } from "./types.js";
+/** Node's default data path when the host passes none (see {@link StorageOptions.dataPath}). */
+export declare function defaultDataPath(): string;
+/** Build the Node {@link VoteStorage}: sqlite under the data path, or in-memory for `false`. */
+export declare function makeStorage(options: StorageOptions): VoteStorage;

package/dist/storage/node.js

@@ -0,0 +1,106 @@
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { makeMemoryStorage } from "./memory.js";
+/**
+ * The Node backend: one better-sqlite3 database per named cache under
+ * `{dataPath}/lru-storage/{cacheName}.db`, a port of pkc-js's `SqliteCache`
+ * (runtime/node/sqlite-lru-cache.ts) with the same table shape and LRU rule — `lastAccess`
+ * updated on every hit, eviction deletes everything past `maxItems` in recency order. Ports
+ * differ in three deliberate ways: values are JSON text (not cbor blobs — callers already
+ * stringify, and it keeps this file dependency-free beyond the driver), there is no TTL
+ * column (freshness here is read-time policy: the name cache checks `resolvedAtMs` against a
+ * per-call max-age, the gate store is purged by sample-block expiry), and LRU cleanup runs
+ * inline on each write instead of on a timer (writes are per wallet-bucket / per name — rare
+ * — and no timer means nothing to keep the process alive or `unref`).
+ *
+ * WAL mode matches pkc-js: it reduces the lost-write window when two processes share a
+ * dataPath. The database opens lazily on first use, so constructing a voter touches no disk.
+ */
+class SqliteLruStorage {
+    #db;
+    #file;
+    #dir;
+    #maxItems;
+    #statements;
+    constructor(opts) {
+        this.#dir = opts.dir;
+        this.#file = join(opts.dir, `${opts.cacheName}.db`);
+        this.#maxItems = opts.maxItems;
+    }
+    #closed = false;
+    #open() {
+        if (this.#statements)
+            return this.#statements;
+        // A late fire-and-forget write after destroy() must fail (callers swallow cache
+        // errors), never silently re-create the database file.
+        if (this.#closed)
+            throw new Error("storage is closed");
+        mkdirSync(this.#dir, { recursive: true });
+        const db = new Database(this.#file);
+        db.pragma("journal_mode = WAL");
+        db.prepare(`CREATE TABLE IF NOT EXISTS cache (key TEXT PRIMARY KEY, value TEXT, lastAccess INT)`).run();
+        db.prepare(`CREATE INDEX IF NOT EXISTS lastAccess ON cache (lastAccess)`).run();
+        this.#db = db;
+        this.#statements = {
+            get: db.prepare(`UPDATE OR IGNORE cache SET lastAccess = @now WHERE key = @key RETURNING value`),
+            set: db.prepare(`INSERT OR REPLACE INTO cache (key, value, lastAccess) VALUES (@key, @value, @now)`),
+            remove: db.prepare(`DELETE FROM cache WHERE key = @key`),
+            keys: db.prepare(`SELECT key FROM cache`),
+            clear: db.prepare(`DELETE FROM cache`),
+            evict: db.prepare(`WITH lru AS (SELECT key FROM cache ORDER BY lastAccess DESC LIMIT -1 OFFSET @maxItems)
+                 DELETE FROM cache WHERE key IN lru`)
+        };
+        return this.#statements;
+    }
+    async getItem(key) {
+        const row = this.#open().get.get({ key, now: Date.now() });
+        return row === undefined ? undefined : JSON.parse(row.value);
+    }
+    async setItem(key, value) {
+        const statements = this.#open();
+        statements.set.run({ key, value: JSON.stringify(value ?? null), now: Date.now() });
+        statements.evict.run({ maxItems: this.#maxItems });
+    }
+    async removeItem(key) {
+        this.#open().remove.run({ key });
+    }
+    async keys() {
+        return this.#open().keys.all().map((row) => row.key);
+    }
+    async clear() {
+        this.#open().clear.run();
+    }
+    close() {
+        this.#closed = true;
+        this.#db?.close();
+        this.#db = undefined;
+        this.#statements = undefined;
+    }
+}
+/** Node's default data path when the host passes none (see {@link StorageOptions.dataPath}). */
+export function defaultDataPath() {
+    return join(process.cwd(), ".bitsocial-pubsub-votes");
+}
+/** Build the Node {@link VoteStorage}: sqlite under the data path, or in-memory for `false`. */
+export function makeStorage(options) {
+    if (options.dataPath === false)
+        return makeMemoryStorage();
+    const dir = join(options.dataPath ?? defaultDataPath(), "lru-storage");
+    const stores = new Map();
+    return {
+        openLru({ cacheName, maxItems }) {
+            let store = stores.get(cacheName);
+            if (!store) {
+                store = new SqliteLruStorage({ dir, cacheName, maxItems });
+                stores.set(cacheName, store);
+            }
+            return store;
+        },
+        async destroy() {
+            for (const store of stores.values())
+                store.close();
+            stores.clear();
+        }
+    };
+}

package/dist/storage/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The persistent-cache seam, mirroring pkc-js's LRU storage tier (`LRUStorageInterface` /
+ * `_createStorageLRU`): named, bounded, LRU-evicting key-value stores under the voter's data
+ * path. On Node the backing is one better-sqlite3 database per cache under
+ * `{dataPath}/lru-storage/` (storage/node.ts); in the browser it is localforage (IndexedDB)
+ * with pkc-js's dual-instance round-robin eviction (storage/browser.ts — bundlers swap the
+ * module via the package.json `browser` field remap); `dataPath: false` selects the in-memory
+ * backend on both (storage/memory.ts). Values must be JSON-serializable — callers stringify
+ * anything richer (a gate score `bigint` travels as a decimal string).
+ *
+ * Deliberate deviation from pkc-js's interface: no explicit `init()` — every store
+ * self-initializes lazily on first use, so opening a store is synchronous and cheap and the
+ * voter constructor stays non-async.
+ */
+export interface LruStorage {
+    /** The stored value, or `undefined` on a miss. A hit refreshes the entry's LRU position. */
+    getItem(key: string): Promise<unknown>;
+    /** Insert or replace. May evict the least-recently-used entry past the store's `maxItems`. */
+    setItem(key: string, value: unknown): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    /** Every live key (unordered). Used for the gate store's deterministic expiry purge. */
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+/** One voter's persistent-cache root: opens named LRU stores, closed as a unit on `destroy()`. */
+export interface VoteStorage {
+    /**
+     * Open (or return the already-open) named store. Names are fixed library-internal slugs
+     * (`gate-results`, `name-resolutions`), never user input.
+     */
+    openLru(opts: {
+        cacheName: string;
+        maxItems: number;
+    }): LruStorage;
+    /** Close every open store (Node: close the sqlite handles). Terminal, like `PubsubVoter.destroy`. */
+    destroy(): Promise<void>;
+}
+/**
+ * `PubsubVoterOptions.dataPath`, resolved: a directory for persistent caches, or `false` for
+ * in-memory-only (no disk, no IndexedDB — the pkc-js `noData` equivalent). `undefined` picks
+ * the platform default: `{cwd}/.bitsocial-pubsub-votes` on Node, named IndexedDB databases in
+ * the browser (where a path is meaningless and ignored).
+ */
+export interface StorageOptions {
+    dataPath?: string | false | undefined;
+}

package/dist/storage/types.js

@@ -0,0 +1 @@
+export {};

package/dist/store/indexeddb.d.ts

@@ -0,0 +1,9 @@
+import type { VoteIntent, VoteStore } from "./types.js";
+export declare class IndexedDbVoteStore implements VoteStore {
+    #private;
+    list(): Promise<VoteIntent[]>;
+    get(topic: string): Promise<VoteIntent | undefined>;
+    put(intent: VoteIntent): Promise<void>;
+    delete(topic: string): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/store/indexeddb.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { VoteSchema } from "../schema/votes.js";
+/**
+ * The browser {@link VoteStore} backend: this wallet's re-signable vote intents in an
+ * IndexedDB object store, so republishing survives a page reload (see DESIGN.md "Persistence").
+ * It holds only *this* voter's choices — never the CRDT of everyone's bundles.
+ *
+ * Selected by `selectVoteStore` when a global `indexedDB` is present (the browser); Node uses
+ * the SQLite backend instead. No third-party dependency — plain IndexedDB behind small
+ * promise wrappers. One record per contest, keyed by `topic`; each record is re-validated
+ * through {@link VoteSchema} on read so a corrupt entry cannot smuggle a malformed vote back
+ * into the signer.
+ */
+const DB_NAME = "bitsocial-pubsub-votes";
+const STORE_NAME = "vote_intents";
+/** The persisted intent shape, re-validated on read (IndexedDB returns `any`). */
+const StoredIntentSchema = z.object({
+    topic: z.string(),
+    address: z.string(),
+    votes: z.array(VoteSchema),
+    lastBucket: z.number()
+});
+/** Wrap an IndexedDB request as a promise. */
+function promisify(request) {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+export class IndexedDbVoteStore {
+    #db;
+    /** Open (creating the object store on first use) the vote-intents database. */
+    async #open() {
+        if (this.#db !== undefined)
+            return this.#db;
+        const db = await new Promise((resolve, reject) => {
+            const request = indexedDB.open(DB_NAME, 1);
+            request.onupgradeneeded = () => {
+                if (!request.result.objectStoreNames.contains(STORE_NAME)) {
+                    request.result.createObjectStore(STORE_NAME, { keyPath: "topic" });
+                }
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+        this.#db = db;
+        return db;
+    }
+    async #tx(mode, run) {
+        const db = await this.#open();
+        const store = db.transaction(STORE_NAME, mode).objectStore(STORE_NAME);
+        return run(store);
+    }
+    async list() {
+        const rows = await this.#tx("readonly", (store) => promisify(store.getAll()));
+        return rows.map((row) => StoredIntentSchema.parse(row));
+    }
+    async get(topic) {
+        const row = await this.#tx("readonly", (store) => promisify(store.get(topic)));
+        return row === undefined ? undefined : StoredIntentSchema.parse(row);
+    }
+    async put(intent) {
+        await this.#tx("readwrite", (store) => promisify(store.put(intent)));
+    }
+    async delete(topic) {
+        await this.#tx("readwrite", (store) => promisify(store.delete(topic)));
+    }
+    async destroy() {
+        this.#db?.close();
+        this.#db = undefined;
+    }
+}

package/dist/store/memory.d.ts

@@ -0,0 +1,15 @@
+import type { VoteIntent, VoteStore } from "./types.js";
+/**
+ * In-memory {@link VoteStore}: the fallback used on Node when no `dataPath` is given (the
+ * durable backends are the browser's IndexedDB and Node's SQLite-under-`dataPath` — see
+ * `selectVoteStore` and DESIGN.md "Persistence"). Intents live only for the lifetime of the
+ * process, so republishing does NOT survive a restart with this backend. It exists so the
+ * voter's lifecycle works with no configured persistence and so unit tests run with no I/O.
+ */
+export declare class MemoryVoteStore implements VoteStore {
+    #private;
+    list(): Promise<VoteIntent[]>;
+    get(topic: string): Promise<VoteIntent | undefined>;
+    put(intent: VoteIntent): Promise<void>;
+    delete(topic: string): Promise<void>;
+}

package/dist/store/memory.js

@@ -0,0 +1,22 @@
+/**
+ * In-memory {@link VoteStore}: the fallback used on Node when no `dataPath` is given (the
+ * durable backends are the browser's IndexedDB and Node's SQLite-under-`dataPath` — see
+ * `selectVoteStore` and DESIGN.md "Persistence"). Intents live only for the lifetime of the
+ * process, so republishing does NOT survive a restart with this backend. It exists so the
+ * voter's lifecycle works with no configured persistence and so unit tests run with no I/O.
+ */
+export class MemoryVoteStore {
+    #byTopic = new Map();
+    async list() {
+        return [...this.#byTopic.values()];
+    }
+    async get(topic) {
+        return this.#byTopic.get(topic);
+    }
+    async put(intent) {
+        this.#byTopic.set(intent.topic, intent);
+    }
+    async delete(topic) {
+        this.#byTopic.delete(topic);
+    }
+}

package/dist/store/select.d.ts

@@ -0,0 +1,15 @@
+import type { VoteStore } from "./types.js";
+/**
+ * Pick the vote store for a voter by environment:
+ *   - a global `indexedDB` (the browser) → the IndexedDB backend;
+ *   - otherwise Node with a `dataPath` → a **SQLite file under `dataPath`** (WAL mode, the same
+ *     `dataPath` convention pkc-js and `@bitsocial/bso-resolver` use);
+ *   - otherwise (Node, no `dataPath`) → in-memory (intents lost on restart).
+ *
+ * The concrete backends are imported **lazily** (dynamic `import()` inside {@link LazyVoteStore}):
+ * the Node backend pulls in the native `better-sqlite3`, which must never enter a browser bundle,
+ * and the browser backend touches `indexedDB`, absent on Node. Deferring the import to first use
+ * keeps each out of the other environment's module graph while leaving this function synchronous
+ * (the `PubsubVoter` constructor stays sync). See DESIGN.md "Persistence".
+ */
+export declare function selectVoteStore(dataPath: string | undefined): VoteStore;

package/dist/store/select.js

@@ -0,0 +1,64 @@
+import { MemoryVoteStore } from "./memory.js";
+/**
+ * Pick the vote store for a voter by environment:
+ *   - a global `indexedDB` (the browser) → the IndexedDB backend;
+ *   - otherwise Node with a `dataPath` → a **SQLite file under `dataPath`** (WAL mode, the same
+ *     `dataPath` convention pkc-js and `@bitsocial/bso-resolver` use);
+ *   - otherwise (Node, no `dataPath`) → in-memory (intents lost on restart).
+ *
+ * The concrete backends are imported **lazily** (dynamic `import()` inside {@link LazyVoteStore}):
+ * the Node backend pulls in the native `better-sqlite3`, which must never enter a browser bundle,
+ * and the browser backend touches `indexedDB`, absent on Node. Deferring the import to first use
+ * keeps each out of the other environment's module graph while leaving this function synchronous
+ * (the `PubsubVoter` constructor stays sync). See DESIGN.md "Persistence".
+ */
+export function selectVoteStore(dataPath) {
+    if (typeof indexedDB !== "undefined") {
+        return new LazyVoteStore(async () => {
+            const { IndexedDbVoteStore } = await import("./indexeddb.js");
+            return new IndexedDbVoteStore();
+        });
+    }
+    if (dataPath !== undefined) {
+        return new LazyVoteStore(async () => {
+            const { SqliteVoteStore } = await import("./sqlite.js");
+            return new SqliteVoteStore(dataPath);
+        });
+    }
+    return new MemoryVoteStore();
+}
+/**
+ * A {@link VoteStore} that defers constructing its backend until the first method call, so the
+ * backend module (and its environment-specific dependency) is only `import()`ed when actually
+ * used. The factory runs at most once; every method delegates to the resolved backend.
+ */
+class LazyVoteStore {
+    factory;
+    #backend;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    #resolve() {
+        if (this.#backend === undefined)
+            this.#backend = this.factory();
+        return this.#backend;
+    }
+    async list() {
+        return (await this.#resolve()).list();
+    }
+    async get(topic) {
+        return (await this.#resolve()).get(topic);
+    }
+    async put(intent) {
+        return (await this.#resolve()).put(intent);
+    }
+    async delete(topic) {
+        return (await this.#resolve()).delete(topic);
+    }
+    async destroy() {
+        // Nothing to release if the backend was never opened.
+        if (this.#backend === undefined)
+            return;
+        await (await this.#backend).destroy?.();
+    }
+}

package/dist/store/sqlite.d.ts

@@ -0,0 +1,11 @@
+import type { VoteIntent, VoteStore } from "./types.js";
+export declare class SqliteVoteStore implements VoteStore {
+    #private;
+    /** Open (creating if absent) the vote-intents DB inside the `dataPath` directory. */
+    constructor(dataPath: string);
+    list(): Promise<VoteIntent[]>;
+    get(topic: string): Promise<VoteIntent | undefined>;
+    put(intent: VoteIntent): Promise<void>;
+    delete(topic: string): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/store/sqlite.js

@@ -0,0 +1,68 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { z } from "zod";
+import { VoteSchema } from "../schema/votes.js";
+/**
+ * The Node {@link VoteStore} backend: this wallet's re-signable vote intents in a SQLite file
+ * under the constructor's `dataPath` directory (WAL mode), so republishing survives a process
+ * restart (see DESIGN.md "Persistence"). It holds only *this* voter's choices — never the CRDT
+ * of everyone's bundles, which lives in the host's Helia blockstore.
+ *
+ * `better-sqlite3` is a native Node module, so this file is imported **only dynamically** (via
+ * `selectVoteStore`), keeping it out of any browser bundle — the browser uses IndexedDB. One
+ * row per contest, keyed by `topic`; `votes` is stored as JSON and re-validated through
+ * {@link VoteSchema} on read so a hand-edited or corrupt row cannot smuggle a malformed vote
+ * back into the signer.
+ */
+/** The persisted `votes` column shape, re-validated on read (no `any` from `JSON.parse`). */
+const StoredVotesSchema = z.array(VoteSchema);
+/** The SQLite file name kept inside the `dataPath` directory. */
+const DB_FILENAME = "pubsub-votes.sqlite";
+export class SqliteVoteStore {
+    #db;
+    #listStmt;
+    #getStmt;
+    #putStmt;
+    #deleteStmt;
+    /** Open (creating if absent) the vote-intents DB inside the `dataPath` directory. */
+    constructor(dataPath) {
+        mkdirSync(dataPath, { recursive: true });
+        this.#db = new Database(join(dataPath, DB_FILENAME));
+        this.#db.pragma("journal_mode = WAL");
+        this.#db.exec(`CREATE TABLE IF NOT EXISTS vote_intents (
+                topic TEXT PRIMARY KEY,
+                address TEXT NOT NULL,
+                votes TEXT NOT NULL,
+                last_bucket INTEGER NOT NULL
+            )`);
+        this.#listStmt = this.#db.prepare("SELECT topic, address, votes, last_bucket FROM vote_intents");
+        this.#getStmt = this.#db.prepare("SELECT topic, address, votes, last_bucket FROM vote_intents WHERE topic = ?");
+        this.#putStmt = this.#db.prepare("INSERT OR REPLACE INTO vote_intents (topic, address, votes, last_bucket) VALUES (?, ?, ?, ?)");
+        this.#deleteStmt = this.#db.prepare("DELETE FROM vote_intents WHERE topic = ?");
+    }
+    #rowToIntent(row) {
+        return {
+            topic: row.topic,
+            address: row.address,
+            votes: StoredVotesSchema.parse(JSON.parse(row.votes)),
+            lastBucket: row.last_bucket
+        };
+    }
+    async list() {
+        return this.#listStmt.all().map((row) => this.#rowToIntent(row));
+    }
+    async get(topic) {
+        const row = this.#getStmt.get(topic);
+        return row === undefined ? undefined : this.#rowToIntent(row);
+    }
+    async put(intent) {
+        this.#putStmt.run(intent.topic, intent.address, JSON.stringify(intent.votes), intent.lastBucket);
+    }
+    async delete(topic) {
+        this.#deleteStmt.run(topic);
+    }
+    async destroy() {
+        this.#db.close();
+    }
+}