@g9tm/syncdata 1.2.1

package/dist/sqlite/store.js

@@ -0,0 +1,664 @@
+// Twin of G9SyncData.Client.Sqlite/G9CSqliteSyncStore.cs (+ .Incarnation.cs, .Recovery.cs): the SQLite implementation of
+// the client store. Every object it creates is the one the .NET store creates (AiGuides/08-Client-Sqlite.md), so the same
+// database file serves the MAUI app and the Lynx app.
+import { G9EMoveOutPolicy, G9ESyncDirection } from '../abstractions/enums.js';
+import { G9SyncErrorCodes, G9SyncException } from '../abstractions/errors.js';
+import { guidToN, newGuid } from '../abstractions/guid.js';
+import { G9Long } from '../abstractions/long.js';
+import { G9SyncParameters } from '../abstractions/parameters.js';
+import { G9ApplyReport, G9ERevocationReason, G9ESubscriptionState, } from '../client/storeTypes.js';
+import * as apply from './apply.js';
+import * as commands from './commands.js';
+import { asNumber, asOptionalString, asString, G9AsyncLock, G9SqliteConnection } from './connection.js';
+import { byTid, LocalTable, logTo, meta, nowMs, persistedJson, readLocalValues, readPersistedDefinitions, readPersistedNegotiated, readSubscriptions, serializeValues, setMeta, } from './internals.js';
+import { resolveStoreOptions } from './options.js';
+import * as push from './push.js';
+import * as query from './query.js';
+import * as revocation from './revocation.js';
+import { allColumnsMask, bit, columnDefinition, createCommandTriggers, createTable, createTriggers, dropTriggers, EPHEMERAL_SLOT, keyExpression, METADATA, modelHash, quote } from './sql.js';
+/**
+ * The SQLite client store over a G9SqliteDriver. Library writes are serialised in-process; app writes on other
+ * connections are captured by triggers and wait on SQLite's busy timeout.
+ */
+export class G9SqliteSyncStore {
+    constructor(options) {
+        this.writeLock = new G9AsyncLock();
+        this.byLocal = new Map();
+        this.byServerId = new Map();
+        /** True when this initialisation found a database of another installation and gave it a new identity (ADR-0067). */
+        this.replicaIdentityWasReplaced = false;
+        this._model = null;
+        this._writer = null;
+        this._reader = null;
+        this._opening = null;
+        this.options = resolveStoreOptions(options);
+    }
+    // ================================================================ internals
+    writer() {
+        if (!this._writer)
+            throw new Error('The SQLite sync store is not open; call initialize first.');
+        return this._writer;
+    }
+    reader() {
+        if (!this._reader)
+            throw new Error('The SQLite sync store is not open; call initialize first.');
+        return this._reader;
+    }
+    ensureInitialized() {
+        if (!this._model)
+            throw new Error('The SQLite sync store is not initialised; call initialize first.');
+        return this._model;
+    }
+    log(level, eventId, message, error) {
+        logTo(this.options.logger, level, eventId, message, error);
+    }
+    async _open() {
+        if (this._writer && this._reader)
+            return;
+        if (!this._opening) {
+            this._opening = (async () => {
+                const driver = this.options.driver;
+                const pragmas = { busyTimeoutMs: this.options.busyTimeoutMs, foreignKeys: false };
+                const writerSession = await driver.open({ path: this.options.databasePath, create: true, pragmas });
+                const writer = new G9SqliteConnection(driver, writerSession);
+                await this._configure(writer);
+                if (this.options.useWriteAheadLog)
+                    await writer.query('PRAGMA journal_mode = WAL');
+                const readerSession = await driver.open({ path: this.options.databasePath, create: true, pragmas });
+                const reader = new G9SqliteConnection(driver, readerSession);
+                await this._configure(reader);
+                this._writer = writer;
+                this._reader = reader;
+            })();
+            this._opening.catch(() => (this._opening = null));
+        }
+        await this._opening;
+    }
+    /** The PRAGMAs the .NET store sets on every connection it opens. */
+    async _configure(connection) {
+        await connection.exec('PRAGMA busy_timeout = ' + this.options.busyTimeoutMs + '; PRAGMA foreign_keys = OFF; PRAGMA journal_size_limit = ' + this.options.walSizeLimitBytes + ';');
+    }
+    // ================================================================ initialise
+    async initialize(model) {
+        if (!model)
+            throw new TypeError('A model is required.');
+        await this._open();
+        await this.writeLock.run(async () => {
+            const connection = this.writer();
+            const tables = [];
+            await connection.transaction('immediate', async () => {
+                await connection.exec(METADATA);
+                if (asNumber(await connection.scalar("SELECT count(*) FROM pragma_table_info('g9_ctx') WHERE name = 'command_id'")) === 0) {
+                    // Stores created before commands existed (ADR-0025).
+                    await connection.exec('ALTER TABLE g9_ctx ADD COLUMN command_id TEXT NULL');
+                }
+                if (asNumber(await connection.scalar("SELECT count(*) FROM pragma_table_info('g9_stage_runs') WHERE name = 'generation'")) === 0) {
+                    // Stores created before stages were validated on resume (ADR-0046): a stage in flight is dropped and replanned.
+                    await connection.exec('ALTER TABLE g9_stage_runs ADD COLUMN generation TEXT NULL');
+                    await connection.exec('ALTER TABLE g9_stage_runs ADD COLUMN stage_seq INTEGER NOT NULL DEFAULT 0');
+                    await connection.exec('DELETE FROM g9_stage; DELETE FROM g9_stage_runs;');
+                }
+                if (asNumber(await connection.scalar("SELECT count(*) FROM pragma_table_info('g9_stage_runs') WHERE name = 'from_cursors_json'")) === 0) {
+                    await connection.exec('ALTER TABLE g9_stage_runs ADD COLUMN from_cursors_json TEXT NULL');
+                }
+                if (asNumber(await connection.scalar("SELECT count(*) FROM pragma_table_info('g9_subscriptions') WHERE name = 'move_out_policy'")) === 0) {
+                    await connection.exec('ALTER TABLE g9_subscriptions ADD COLUMN move_out_policy INTEGER NULL');
+                }
+                if ((await meta(connection, 'client_id')) === null)
+                    await setMeta(connection, 'client_id', newGuid());
+                if ((await meta(connection, 'next_batch_id')) === null)
+                    await setMeta(connection, 'next_batch_id', '1');
+                await this._verifyIncarnation(connection);
+                for (const table of model.tables)
+                    tables.push(await this._provisionTable(connection, table));
+            });
+            this._model = model;
+            this.byLocal = new Map(tables.map((t) => [t.model.localName.toLowerCase(), t]));
+            this.byServerId = new Map(tables.filter((t) => t.negotiated !== null).map((t) => [t.negotiated.tableId, t]));
+            this.log('information', 20101, `G9SyncData SQLite store initialised with ${tables.length} tables`);
+        });
+    }
+    async _provisionTable(connection, table) {
+        const hash = modelHash(table);
+        let tid = -1;
+        let existingHash = null;
+        let negotiatedJson = null;
+        let syncedJson = null;
+        let isNew = false;
+        const found = (await connection.query('SELECT tid, model_hash, negotiated_json, synced_columns FROM g9_tables WHERE local_name = $n', { $n: table.localName }))[0];
+        if (found) {
+            tid = asNumber(found[0]);
+            existingHash = asString(found[1]);
+            negotiatedJson = asOptionalString(found[2]);
+            syncedJson = asOptionalString(found[3]);
+        }
+        if (tid < 0) {
+            await connection.exec("INSERT INTO g9_tables (local_name, server_name, model_hash) VALUES ($n, $s, '')", { $n: table.localName, $s: table.serverName });
+            tid = asNumber(await connection.scalar('SELECT last_insert_rowid()'));
+            isNew = true;
+        }
+        else {
+            await connection.exec('UPDATE g9_tables SET server_name = $s WHERE tid = $t', { $s: table.serverName, $t: tid });
+        }
+        const exists = (await connection.scalar("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = $n COLLATE NOCASE", { $n: table.localName })) !== null;
+        if (!exists) {
+            await connection.exec(createTable(table, this.options));
+        }
+        else {
+            const existing = new Set((await connection.query('SELECT name FROM pragma_table_info($n)', { $n: table.localName })).map((r) => asString(r[0]).toLowerCase()));
+            for (const column of table.columns) {
+                if (existing.has(column.name.toLowerCase()))
+                    continue;
+                await connection.exec('ALTER TABLE ' + quote(table.localName) + ' ADD COLUMN ' + columnDefinition(column, this.options));
+                this.log('information', 20102, `Added column ${table.localName}.${column.name} from the client model`);
+            }
+        }
+        for (const index of table.indexes) {
+            await connection.exec(`CREATE ${index.unique ? 'UNIQUE ' : ''}INDEX IF NOT EXISTS ${quote(index.name)} ON ${quote(table.localName)} (${index.columns.map(quote).join(', ')})`);
+        }
+        const negotiated = readPersistedNegotiated(negotiatedJson);
+        const captureWanted = !negotiated || negotiated.direction !== G9ESyncDirection.DownloadOnly;
+        const triggerCount = asNumber(await connection.scalar("SELECT count(*) FROM sqlite_master WHERE type = 'trigger' AND name IN ($a, $b, $c)", {
+            $a: 'g9_' + table.localName + '_ai',
+            $b: 'g9_' + table.localName + '_au',
+            $c: 'g9_' + table.localName + '_ad',
+        }));
+        const commandTriggerCount = asNumber(await connection.scalar("SELECT count(*) FROM sqlite_master WHERE type = 'trigger' AND name IN ($a, $b, $c)", {
+            $a: 'g9_' + table.localName + '_ci',
+            $b: 'g9_' + table.localName + '_cu',
+            $c: 'g9_' + table.localName + '_cd',
+        }));
+        if (existingHash !== hash || (captureWanted && triggerCount !== 3) || commandTriggerCount !== 3) {
+            await connection.exec(dropTriggers(table));
+            if (captureWanted)
+                await connection.exec(createTriggers(table, tid));
+            await connection.exec(createCommandTriggers(table, tid));
+            if (existingHash !== null && existingHash.length > 0 && existingHash !== hash) {
+                // Column order may have changed: pending rows upload every column rather than trusting old mask bits.
+                await connection.exec('UPDATE g9_rows SET dirty_mask = $m WHERE tid = $t AND dirty = 1', { $m: allColumnsMask(table.columns.length), $t: tid });
+            }
+            await connection.exec('UPDATE g9_tables SET model_hash = $h WHERE tid = $t', { $h: hash, $t: tid });
+        }
+        if (isNew && exists) {
+            const adopted = await connection.exec(`INSERT OR IGNORE INTO g9_rows (tid, pk) SELECT $t, ${keyExpression(table, 'b')} FROM ${quote(table.localName)} AS b`, { $t: tid });
+            if (adopted > 0)
+                this.log('information', 20103, `Adopted ${adopted} existing rows of ${table.localName} into change capture`);
+        }
+        const synced = syncedJson === null ? [] : JSON.parse(syncedJson);
+        return new LocalTable(table, tid, negotiated, Array.isArray(synced) ? synced.map(String) : []);
+    }
+    /** ADR-0067: a database restored from a backup or copied from another device gets a new identity. */
+    async _verifyIncarnation(connection) {
+        const marker = this.options.incarnationMarker;
+        if (!marker)
+            return;
+        const inDatabase = await meta(connection, 'incarnation');
+        const inMarker = await marker.read();
+        if (inDatabase !== null && inDatabase === inMarker)
+            return;
+        // The marker is written BEFORE the transaction commits; if that fails nothing is recorded and nothing is reset.
+        const incarnation = guidToN(newGuid());
+        if (!(await marker.write(incarnation))) {
+            this.log('warning', 20106, 'The incarnation marker could not be read or written; restore detection is off for this run');
+            return;
+        }
+        if (inDatabase === null) {
+            // A database from before this check existed, or a brand-new one: adopt it.
+            await setMeta(connection, 'incarnation', incarnation);
+            return;
+        }
+        const pending = asNumber(await connection.scalar('SELECT count(*) FROM g9_rows WHERE dirty <> 0'));
+        await setMeta(connection, 'incarnation', incarnation);
+        await setMeta(connection, 'client_id', newGuid());
+        await setMeta(connection, 'next_batch_id', '1');
+        await connection.exec("DELETE FROM g9_meta WHERE key IN ('inflight_batch_id', 'inflight_max_seq'); UPDATE g9_commands SET batch_id = NULL WHERE state = 0; DELETE FROM g9_stage; DELETE FROM g9_stage_runs;");
+        this.replicaIdentityWasReplaced = true;
+        this.log('warning', 20105, `This database was restored or copied from another installation: it has a new client id and its push batch counter starts again. ${pending} pending row(s) were kept and upload as usual`);
+    }
+    async getClientId() {
+        await this._open();
+        const id = await meta(this.reader(), 'client_id');
+        if (id === null)
+            throw new Error('The store is not initialised.');
+        return id;
+    }
+    // ================================================================ server state
+    async getServerState() {
+        await this._open();
+        const connection = this.reader();
+        const epoch = await meta(connection, 'epoch');
+        const lastHello = await meta(connection, 'last_hello_utc');
+        const offset = await meta(connection, 'server_offset_ms');
+        const definitions = await meta(connection, 'definitions_json');
+        const tables = await meta(connection, 'tables_json');
+        const parsedTables = tables === null ? [] : JSON.parse(tables);
+        return {
+            epoch,
+            lastHelloUtcMs: lastHello === null ? null : Number(lastHello),
+            serverClockOffsetMs: offset === null ? 0 : Number(offset),
+            definitions: readPersistedDefinitions(definitions),
+            tables: Array.isArray(parsedTables) ? parsedTables.map((t) => readPersistedNegotiated(JSON.stringify(t))) : [],
+        };
+    }
+    async saveHello(hello) {
+        const model = this.ensureInitialized();
+        await this.writeLock.run(async () => {
+            const connection = this.writer();
+            const updates = [];
+            await connection.transaction('immediate', async () => {
+                await setMeta(connection, 'epoch', hello.epoch);
+                await setMeta(connection, 'last_hello_utc', String(nowMs()));
+                await setMeta(connection, 'server_offset_ms', String(Math.trunc(hello.serverTimeUtcMs - Date.now())));
+                await setMeta(connection, 'definitions_json', persistedJson(hello.definitions));
+                await setMeta(connection, 'tables_json', persistedJson(hello.tables));
+                // Kept per subscription: a caller who loses access stops being told the definition (ADR-0048).
+                for (const definition of hello.definitions) {
+                    await connection.exec('UPDATE g9_subscriptions SET move_out_policy = $p WHERE name = $n', { $p: definition.moveOutPolicy, $n: definition.name });
+                }
+                for (const negotiated of hello.tables) {
+                    const clientTable = model.findByServerName(negotiated.name);
+                    const local = clientTable ? this.byLocal.get(clientTable.localName.toLowerCase()) : undefined;
+                    if (!local)
+                        continue;
+                    const names = negotiated.columns.map((c) => c.name);
+                    let synced;
+                    if (local.negotiated === null) {
+                        synced = names;
+                    }
+                    else {
+                        synced = local.syncedColumns.slice();
+                        const added = names.filter((n) => !synced.some((s) => s.toLowerCase() === n.toLowerCase()));
+                        if (added.length > 0 && (await connection.scalar('SELECT 1 FROM g9_rows WHERE tid = $t AND deleted = 0 LIMIT 1', { $t: local.tid })) === null) {
+                            for (const a of added)
+                                synced.push(a);
+                        }
+                    }
+                    await connection.exec('UPDATE g9_tables SET server_table_id = $s, negotiated_json = $j, synced_columns = $c WHERE tid = $t', {
+                        $s: negotiated.tableId,
+                        $j: persistedJson(negotiated),
+                        $c: persistedJson(synced),
+                        $t: local.tid,
+                    });
+                    if (negotiated.direction === G9ESyncDirection.DownloadOnly) {
+                        await connection.exec(dropTriggers(local.model));
+                    }
+                    else if (local.negotiated && local.negotiated.direction === G9ESyncDirection.DownloadOnly) {
+                        await connection.exec(dropTriggers(local.model) + createTriggers(local.model, local.tid));
+                    }
+                    updates.push({ local, negotiated, synced });
+                }
+            });
+            for (const { local, negotiated, synced } of updates) {
+                local.negotiated = negotiated;
+                local.syncedColumns = synced;
+            }
+            const byServerId = new Map();
+            this.byLocal.forEach((t) => {
+                if (t.negotiated)
+                    byServerId.set(t.negotiated.tableId, t);
+            });
+            this.byServerId = byServerId;
+        });
+    }
+    async getPendingBackfills() {
+        this.ensureInitialized();
+        const backfills = [];
+        this.byLocal.forEach((table) => {
+            if (!table.negotiated)
+                return;
+            const missing = table.negotiated.columns.map((c) => c.name).filter((n) => !table.syncedColumns.some((s) => s.toLowerCase() === n.toLowerCase()));
+            if (missing.length > 0)
+                backfills.push({ tableId: table.negotiated.tableId, columns: missing });
+        });
+        return backfills;
+    }
+    // ================================================================ subscriptions
+    async getSubscriptions() {
+        await this._open();
+        return readSubscriptions(this.reader(), null);
+    }
+    async ensureSubscription(name, parameters, ephemeral, ttlMs, adoptExistingRows) {
+        if (typeof name !== 'string' || name.trim() === '')
+            throw new TypeError('A subscription name is required.');
+        const key = G9SyncParameters.buildSubscriptionKey(name, parameters);
+        await this._open();
+        return this.writeLock.run(() => this.writer().transaction('immediate', async () => {
+            const connection = this.writer();
+            const existing = await readSubscriptions(connection, key);
+            if (existing.length > 0)
+                return existing[0];
+            let slot = EPHEMERAL_SLOT;
+            if (!ephemeral) {
+                const used = new Set((await connection.query('SELECT slot FROM g9_subscriptions WHERE ephemeral = 0')).map((r) => asNumber(r[0])));
+                slot = -1;
+                for (let s = 0; s < EPHEMERAL_SLOT; s++) {
+                    if (!used.has(s)) {
+                        slot = s;
+                        break;
+                    }
+                }
+                if (slot < 0) {
+                    throw new G9SyncException(G9SyncErrorCodes.LocalStoreError, 'At most 63 persistent subscriptions per database; declare per-item subscriptions Ephemeral(ttl) on the server.');
+                }
+            }
+            const now = nowMs();
+            await connection.exec('INSERT INTO g9_subscriptions (key, name, params, slot, ephemeral, ttl_seconds, state, created_utc, last_access_utc) VALUES ($k, $n, $p, $s, $e, $t, $st, $c, $c)', {
+                $k: key,
+                $n: name,
+                $p: JSON.stringify(parameters.values),
+                $s: slot,
+                $e: ephemeral ? 1 : 0,
+                $t: ttlMs === null ? null : Math.trunc(ttlMs / 1000),
+                $st: adoptExistingRows ? G9ESubscriptionState.NeedsReconcile : G9ESubscriptionState.Active,
+                $c: now,
+            });
+            return (await readSubscriptions(connection, key))[0];
+        }));
+    }
+    removeSubscription(key, policy) {
+        return this._removeSubscription(key, policy, G9ERevocationReason.Unsubscribed, false, null);
+    }
+    async releaseSubscriptionRows(key) {
+        // The policy comes from the last definition the server announced for this subscription (ADR-0048).
+        const report = new G9ApplyReport();
+        await this._removeSubscription(key, null, G9ERevocationReason.AccessRevoked, true, report);
+        return report;
+    }
+    async _removeSubscription(key, policy, reason, keepSubscription, report) {
+        this.ensureInitialized();
+        await this.writeLock.run(() => this.writer().transaction('immediate', async () => {
+            var _a;
+            const connection = this.writer();
+            const record = (await readSubscriptions(connection, key))[0];
+            if (!record)
+                return;
+            const effective = (_a = policy !== null && policy !== void 0 ? policy : record.moveOutPolicy) !== null && _a !== void 0 ? _a : G9EMoveOutPolicy.Delete;
+            await connection.exec('UPDATE g9_ctx SET applying = 1 WHERE id = 1');
+            await connection.exec('DROP TABLE IF EXISTS temp.g9_affected; CREATE TEMP TABLE g9_affected (tid INTEGER NOT NULL, pk TEXT NOT NULL, PRIMARY KEY (tid, pk)) WITHOUT ROWID');
+            if (record.ephemeral) {
+                await connection.exec('INSERT INTO temp.g9_affected (tid, pk) SELECT tid, pk FROM g9_ephemeral_rows WHERE sub_key = $k', { $k: key });
+                await connection.exec('DELETE FROM g9_ephemeral_rows WHERE sub_key = $k', { $k: key });
+                await connection.exec('UPDATE g9_rows SET subs = subs & $n WHERE (tid, pk) IN (SELECT tid, pk FROM temp.g9_affected) AND NOT EXISTS (SELECT 1 FROM g9_ephemeral_rows e WHERE e.tid = g9_rows.tid AND e.pk = g9_rows.pk)', { $n: bit(EPHEMERAL_SLOT).not() });
+            }
+            else {
+                const b = bit(record.slot);
+                await connection.exec('INSERT INTO temp.g9_affected (tid, pk) SELECT tid, pk FROM g9_rows WHERE (subs & $b) <> 0', { $b: b });
+                await connection.exec('UPDATE g9_rows SET subs = subs & $n WHERE (subs & $b) <> 0', { $n: b.not(), $b: b });
+            }
+            if (effective === G9EMoveOutPolicy.Delete) {
+                // Rows no other subscription holds go through the revocation policy (ADR-0026), pending changes included.
+                const releasedSql = 'SELECT r.tid, r.pk FROM g9_rows r JOIN temp.g9_affected a ON a.tid = r.tid AND a.pk = r.pk WHERE r.subs = 0 AND r.deleted = 0';
+                let removed = 0;
+                if ((await apply.foreignTriggerNames(this, connection)).length === 0) {
+                    removed = await revocation.disposeReleasedRows(this, connection, releasedSql, {}, reason, key, report);
+                }
+                else {
+                    // A foreign trigger may write what the next row's decision reads: row by row, each decision after the last.
+                    const released = (await connection.query(releasedSql)).map((r) => ({ tid: asNumber(r[0]), key: asString(r[1]) }));
+                    for (const row of released) {
+                        const table = byTid(this, row.tid);
+                        // The .NET store advances its sequence for every released row of a known table, whether or not it moved.
+                        if (!table)
+                            continue;
+                        if (await revocation.disposeReleasedRow(this, connection, table, row.key, reason, key, report))
+                            removed++;
+                        await connection.exec('UPDATE g9_clock SET seq = seq + 1 WHERE id = 1');
+                    }
+                }
+                this.log('information', 20104, `Removed subscription ${key}; deleted ${removed} rows no other subscription held`);
+            }
+            await connection.exec(keepSubscription
+                ? 'UPDATE g9_subscriptions SET cursor = NULL, last_success_utc = NULL, last_reconcile_utc = NULL WHERE key = $k'
+                : 'DELETE FROM g9_subscriptions WHERE key = $k', { $k: key });
+            await connection.exec('DROP TABLE temp.g9_affected; UPDATE g9_ctx SET applying = 0 WHERE id = 1');
+        }));
+    }
+    async updateSubscription(key, update) {
+        const sets = [];
+        const params = { $k: key };
+        if (update.cursor !== undefined && update.cursor !== null) {
+            sets.push('cursor = $cursor');
+            params.$cursor = update.cursor;
+        }
+        if (update.clearCursor)
+            sets.push('cursor = NULL');
+        if (update.definitionHash !== undefined && update.definitionHash !== null) {
+            sets.push('definition_hash = $def');
+            params.$def = update.definitionHash;
+        }
+        if (update.authHash !== undefined && update.authHash !== null) {
+            sets.push('auth_hash = $auth');
+            params.$auth = update.authHash;
+        }
+        if (update.state !== undefined && update.state !== null) {
+            sets.push('state = $state');
+            params.$state = update.state;
+        }
+        if (update.errorCode !== undefined && update.errorCode !== null) {
+            sets.push('error_code = $error');
+            params.$error = update.errorCode;
+        }
+        if (update.clearError)
+            sets.push('error_code = NULL');
+        const now = nowMs();
+        if (update.succeeded)
+            sets.push('last_success_utc = ' + now);
+        if (update.reconciled)
+            sets.push('last_reconcile_utc = ' + now);
+        if (update.accessed)
+            sets.push('last_access_utc = ' + now);
+        if (sets.length === 0)
+            return;
+        await this._open();
+        await this.writeLock.run(() => this.writer().exec('UPDATE g9_subscriptions SET ' + sets.join(', ') + ' WHERE key = $k', params));
+    }
+    async collectExpiredEphemeral(utcNowMs) {
+        await this._open();
+        const expired = (await this.reader().query('SELECT key FROM g9_subscriptions WHERE ephemeral = 1 AND ttl_seconds IS NOT NULL AND coalesce(last_access_utc, created_utc) + ttl_seconds * 1000 < $now', { $now: utcNowMs })).map((r) => asString(r[0]));
+        for (const key of expired)
+            await this._removeSubscription(key, G9EMoveOutPolicy.Delete, G9ERevocationReason.Expired, false, null);
+        return expired.length;
+    }
+    // ================================================================ push
+    buildPushBatch(tables, maxRows, maxBytes) {
+        return push.buildPushBatch(this, tables, maxRows, maxBytes);
+    }
+    forgetUploadedRows(localTable, keys) {
+        return push.forgetUploadedRows(this, localTable, keys);
+    }
+    applyPushResult(batch, result, signal) {
+        return push.applyPushResult(this, batch, result, signal);
+    }
+    // ================================================================ pull
+    async getStagedPull() {
+        await this._open();
+        return query.getStagedPull(this, null);
+    }
+    async getStagedPullForGeneration(generation) {
+        await this._open();
+        return query.getStagedPull(this, generation);
+    }
+    beginStagedPull(pull) {
+        return query.beginStagedPull(this, pull);
+    }
+    pruneStagedPulls(olderThanUtcMs, maxBytes, keepGeneration) {
+        return query.pruneStagedPulls(this, olderThanUtcMs, maxBytes, keepGeneration);
+    }
+    discardAllStagedPulls() {
+        return query.discardAllStagedPulls(this);
+    }
+    stageChunk(runId, chunk) {
+        return query.stageChunk(this, runId, chunk, (connection) => apply.downloadDurability(this, connection));
+    }
+    getResumePoint(runId) {
+        return query.getResumePoint(this, runId);
+    }
+    applyStagedPull(runId, rowsApplied, slices, signal) {
+        return apply.applyStagedPull(this, runId, rowsApplied, slices, query.readStagedRun, signal);
+    }
+    discardStagedPull(runId) {
+        return query.discardStagedPull(this, runId);
+    }
+    // ================================================================ reconcile
+    computeDigest(subscriptionKey, table) {
+        return query.computeDigest(this, subscriptionKey, table);
+    }
+    readLocalEntries(subscriptionKey, table, buckets, serverKeys) {
+        return query.readLocalEntries(this, subscriptionKey, table, buckets, serverKeys);
+    }
+    applyReconcile(subscriptionKey, table, fetchedFrames, addMembership, moveOut, policy, signal) {
+        return apply.applyReconcile(this, subscriptionKey, table, fetchedFrames, addMembership, moveOut, policy, signal);
+    }
+    // ================================================================ queries and maintenance
+    getPendingSummary() {
+        return query.getPendingSummary(this);
+    }
+    enqueueCommand(request, applyLocally, signal) {
+        return commands.enqueueCommand(this, request, applyLocally, signal);
+    }
+    /**
+     * Records a command on a connection the APP owns (its own driver session, inside its own transaction or not), so the
+     * command and the effects the app writes in `applyLocally` commit or roll back together (the .NET overload that takes the
+     * app's `sqlite3` handle). The session must be open on this store's database file.
+     */
+    enqueueCommandOnSession(session, request, applyLocally) {
+        var _a;
+        this.ensureInitialized();
+        const connection = new G9SqliteConnection(session.driver, session.session);
+        connection.tx = (_a = session.tx) !== null && _a !== void 0 ? _a : null;
+        return commands.enqueueCommandOnConnection(connection, request, applyLocally);
+    }
+    getQuarantined() {
+        return revocation.getQuarantined(this);
+    }
+    restoreQuarantined(localTable, key) {
+        return revocation.restoreQuarantined(this, localTable, key);
+    }
+    discardQuarantined(localTable, key) {
+        return revocation.discardQuarantined(this, localTable, key);
+    }
+    getRetained() {
+        return revocation.getRetained(this);
+    }
+    reevaluateRetained() {
+        return revocation.reevaluateRetained(this);
+    }
+    getCommands(state, limit) {
+        return commands.getCommands(this, state, limit);
+    }
+    readChangeFeed(localTable, afterSequence, limit) {
+        return query.readChangeFeed(this, localTable, afterSequence, limit);
+    }
+    getChangeSequence() {
+        return query.getChangeSequence(this);
+    }
+    getChangeFeedFloor() {
+        return query.getChangeFeedFloor(this);
+    }
+    getRejections() {
+        return query.getRejections(this);
+    }
+    retryRejected(localTable, key) {
+        return query.retryRejected(this, localTable, key);
+    }
+    markDirty(localTable, keys) {
+        return query.markDirty(this, localTable, keys);
+    }
+    adoptExistingRows() {
+        return query.adoptExistingRows(this);
+    }
+    saveRunReport(report, keep) {
+        return query.saveRunReport(this, report, keep);
+    }
+    getRecentRunReports(count) {
+        return query.getRecentRunReports(this, count);
+    }
+    getPhaseStatistics() {
+        return query.getPhaseStatistics(this);
+    }
+    recordPhaseStatistics(samples) {
+        return query.recordPhaseStatistics(this, samples);
+    }
+    purgeDeletedFeed(keep) {
+        return query.purgeDeletedFeed(this, keep);
+    }
+    /** The triggers in the database that the library did not create (they keep trigger execution on during applies). */
+    async getForeignTriggers() {
+        this.ensureInitialized();
+        return apply.foreignTriggerNames(this, this.reader());
+    }
+    // ================================================================ recovery (ADR-0068)
+    /** Runs SQLite's quick_check; an empty list means the file is sound. A file too damaged to check is one problem. */
+    async checkIntegrity() {
+        const problems = [];
+        try {
+            await this._open();
+            for (const r of await this.reader().query('PRAGMA quick_check(50)')) {
+                const line = asString(r[0]);
+                if (line.toLowerCase() !== 'ok')
+                    problems.push(line);
+            }
+        }
+        catch (error) {
+            problems.push(error instanceof Error ? error.message : String(error));
+        }
+        if (problems.length > 0)
+            this.log('error', 20107, `The device database failed its integrity check with ${problems.length} problem(s); first: ${problems[0]}`);
+        return problems;
+    }
+    /**
+     * Hands every pending local change to `write`, one JSON line per row — `{"table":…,"key":…,"deleted":…,"values":{…}}` —
+     * best effort: a row that cannot be read is listed with its key and no values. Nothing in the database changes.
+     */
+    async exportPendingChanges(write) {
+        this.ensureInitialized();
+        const connection = this.reader();
+        const pending = (await connection.query('SELECT tid, pk, dirty FROM g9_rows WHERE dirty <> 0 ORDER BY local_seq')).map((r) => ({
+            tid: asNumber(r[0]),
+            key: asString(r[1]),
+            deleted: asNumber(r[2]) === 2,
+        }));
+        let rows = 0;
+        let unreadable = 0;
+        for (const row of pending) {
+            const table = byTid(this, row.tid);
+            if (!table)
+                continue;
+            let values = null;
+            if (!row.deleted) {
+                try {
+                    const read = await readLocalValues(connection, table, row.key);
+                    if (Object.keys(read).length > 0)
+                        values = serializeValues(read);
+                }
+                catch {
+                    // The page this row lives on is one of the damaged ones. Its key is still worth keeping.
+                }
+                if (values === null)
+                    unreadable++;
+            }
+            const line = '{"table":' + JSON.stringify(table.model.localName) + ',"key":' + JSON.stringify(row.key) + ',"deleted":' + (row.deleted ? 'true' : 'false') + (values === null ? '' : ',"values":' + values) + '}';
+            await write(line);
+            rows++;
+        }
+        if (rows > 0)
+            this.log('warning', 20108, `Exported ${rows} pending row(s) (${unreadable} without readable values)`);
+        return { rows, unreadable };
+    }
+    async dispose() {
+        const writer = this._writer;
+        const reader = this._reader;
+        this._writer = null;
+        this._reader = null;
+        this._opening = null;
+        if (writer) {
+            await writer.rollback();
+            await this.options.driver.close(writer.session);
+        }
+        if (reader)
+            await this.options.driver.close(reader.session);
+    }
+}
+/** Long values the store exposes for tests and tools. */
+export { G9Long };
+//# sourceMappingURL=store.js.map