velocious 1.0.476 → 1.0.478

package/build/src/sync/server-change-feed.js

@@ -0,0 +1,475 @@
+// @ts-check
+import { randomUUID } from "crypto";
+import TableData from "../database/table-data/index.js";
+const DEFAULT_RETENTION_SIZE = 10000;
+const DEFAULT_PAGE_SIZE = 100;
+const MAX_PAGE_SIZE = 1000;
+const TABLE_NAME = "frontend_model_sync_changes";
+const stores = new WeakMap();
+/**
+ * Shared server change-feed store for a configuration.
+ * @param {import("../configuration.js").default} configuration - Configuration.
+ * @returns {ServerChangeFeedStore} - Store.
+ */
+export function serverChangeFeedStoreForConfiguration(configuration) {
+    let store = stores.get(configuration);
+    if (!store) {
+        store = new ServerChangeFeedStore({ configuration });
+        stores.set(configuration, store);
+    }
+    return store;
+}
+export default class ServerChangeFeedStore {
+    /**
+     * Runs constructor.
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration.
+     * @param {string} [args.databaseIdentifier] - Database identifier.
+     * @param {number} [args.retentionSize] - Number of feed entries to retain.
+     */
+    constructor({ configuration, databaseIdentifier = "default", retentionSize }) {
+        const syncConfiguration = configuration.getSyncConfiguration();
+        this.configuration = configuration;
+        this.databaseIdentifier = databaseIdentifier;
+        this.retentionSize = retentionSize || syncConfiguration.changeFeedRetentionSize || DEFAULT_RETENTION_SIZE;
+        /** @type {ServerChangeFeedEntry[]} */
+        this._memoryChanges = [];
+        this._memorySequence = 0;
+        this._isReady = false;
+        this._readyPromise = null;
+    }
+    /**
+     * Ensures the backing table exists.
+     * @returns {Promise<void>} - Resolves when ready.
+     */
+    async ensureReady() {
+        if (this._usesMemoryStorage()) {
+            this._isReady = true;
+            return;
+        }
+        if (await this._schemaReady())
+            return;
+        if (this._readyPromise)
+            return await this._readyPromise;
+        this._readyPromise = (async () => {
+            this.configuration.setCurrent();
+            await this._withDb(async (db) => {
+                await this._ensureChangesTable(db);
+            });
+            this._isReady = true;
+        })();
+        try {
+            await this._readyPromise;
+        }
+        finally {
+            if (!this._isReady)
+                this._readyPromise = null;
+        }
+    }
+    /**
+     * Appends a change and assigns the next server sequence.
+     * @param {Omit<ServerChangeFeedEntry, "createdAt" | "id" | "serverSequence"> & {createdAt?: string, id?: string}} change - Change payload.
+     * @returns {Promise<ServerChangeFeedEntry>} - Persisted change.
+     */
+    async append(change) {
+        await this.ensureReady();
+        const id = change.id || randomUUID();
+        const createdAt = change.createdAt || new Date().toISOString();
+        if (this._usesMemoryStorage())
+            return this._appendMemory({ ...change, createdAt, id });
+        return await this._withDb(async (db) => {
+            await db.insert({
+                tableName: TABLE_NAME,
+                data: {
+                    actor_device_id: change.actorDeviceId,
+                    actor_user_id: change.actorUserId,
+                    attributes_json: JSON.stringify(change.attributes || null),
+                    created_at: new Date(createdAt),
+                    id,
+                    idempotency_key: change.idempotencyKey,
+                    model: change.model,
+                    operation: change.operation,
+                    payload_json: JSON.stringify(change.payload || null),
+                    record_id: change.recordId === null || change.recordId === undefined ? null : String(change.recordId),
+                    response_json: JSON.stringify(change.response || null),
+                    scope_json: stableJsonStringify(change.scope || null)
+                }
+            });
+            const row = await this._changeById(db, id);
+            if (!row)
+                throw new Error("Failed to persist server change-feed entry");
+            await this._pruneRetainedChanges(db, row.serverSequence);
+            return row;
+        });
+    }
+    /**
+     * Returns current latest server sequence.
+     * @returns {Promise<number>} - Latest sequence.
+     */
+    async latestSequence() {
+        await this.ensureReady();
+        if (this._usesMemoryStorage())
+            return this._memorySequence;
+        return await this._withDb(async (db) => {
+            const rows = await db
+                .newQuery()
+                .from(TABLE_NAME)
+                .order("server_sequence DESC")
+                .limit(1)
+                .results();
+            const row = /** @type {{server_sequence?: number | string} | undefined} */ (rows[0]);
+            return row ? Number(row.server_sequence) : 0;
+        });
+    }
+    /**
+     * Returns oldest retained server sequence.
+     * @returns {Promise<number | null>} - Oldest retained sequence.
+     */
+    async oldestSequence() {
+        await this.ensureReady();
+        if (this._usesMemoryStorage())
+            return this._memoryChanges[0]?.serverSequence || null;
+        return await this._withDb(async (db) => await this._oldestSequence(db));
+    }
+    /**
+     * Returns ordered changes after a cursor.
+     * @param {object} args - Arguments.
+     * @param {number} args.afterSequence - Exclusive lower bound.
+     * @param {number} [args.limit] - Maximum number of changes.
+     * @param {number} [args.upToSequence] - Inclusive upper bound.
+     * @param {Record<string, ?>} [args.scope] - Caller sync scope.
+     * @returns {Promise<{changes: ServerChangeFeedEntry[], hasMore: boolean, nextSequence: number, oldestSequence: number | null, snapshotRequired: boolean, upToSequence: number}>} - Ordered page.
+     */
+    async changesAfter({ afterSequence, limit = DEFAULT_PAGE_SIZE, scope, upToSequence }) {
+        await this.ensureReady();
+        const pageSize = normalizeLimit(limit);
+        if (this._usesMemoryStorage())
+            return this._memoryChangesAfter({ afterSequence, limit: pageSize, scope, upToSequence });
+        return await this._withDb(async (db) => {
+            const latestSequence = typeof upToSequence === "number" ? upToSequence : await this._latestSequence(db);
+            const oldestSequence = await this._oldestSequence(db);
+            const snapshotRequired = afterSequence > 0 && oldestSequence !== null && oldestSequence > afterSequence + 1;
+            if (snapshotRequired) {
+                return {
+                    changes: [],
+                    hasMore: false,
+                    nextSequence: afterSequence,
+                    oldestSequence,
+                    snapshotRequired: true,
+                    upToSequence: latestSequence
+                };
+            }
+            const rows = /** @type {ServerChangeFeedRow[]} */ (await db
+                .newQuery()
+                .from(TABLE_NAME)
+                .where(`server_sequence > ${db.quote(afterSequence)}`)
+                .where(`server_sequence <= ${db.quote(latestSequence)}`)
+                .where(scope === undefined ? "1 = 1" : { scope_json: stableJsonStringify(scope) })
+                .order("server_sequence ASC")
+                .limit(pageSize + 1)
+                .results());
+            const hasMore = rows.length > pageSize;
+            const pageRows = rows.slice(0, pageSize);
+            const changes = pageRows.map((row) => this._normalizeChangeRow(row));
+            const lastChange = changes[changes.length - 1];
+            return {
+                changes,
+                hasMore,
+                nextSequence: lastChange ? lastChange.serverSequence : afterSequence,
+                oldestSequence,
+                snapshotRequired: false,
+                upToSequence: latestSequence
+            };
+        });
+    }
+    /**
+     * Ensures schema is still present.
+     * @returns {Promise<boolean>} - Whether ready.
+     */
+    async _schemaReady() {
+        if (this._usesMemoryStorage())
+            return this._isReady;
+        if (!this._isReady)
+            return false;
+        if (await this._withDb(async (db) => await db.tableExists(TABLE_NAME)))
+            return true;
+        this._isReady = false;
+        this._readyPromise = null;
+        return false;
+    }
+    /**
+     * Ensures changes table exists.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _ensureChangesTable(db) {
+        if (await db.tableExists(TABLE_NAME))
+            return;
+        const table = new TableData(TABLE_NAME, { ifNotExists: true });
+        table.integer("server_sequence", { autoIncrement: true, null: false, primaryKey: true });
+        table.string("id", { index: true, null: false });
+        table.string("model", { index: true, null: false });
+        table.string("operation", { null: false });
+        table.string("record_id", { index: true, null: true });
+        table.text("payload_json", { null: true });
+        table.text("attributes_json", { null: true });
+        table.string("idempotency_key", { index: true, null: true });
+        table.string("actor_user_id", { index: true, null: true });
+        table.string("actor_device_id", { index: true, null: true });
+        table.text("scope_json", { null: true });
+        table.text("response_json", { null: true });
+        table.datetime("created_at", { index: true, null: false });
+        await db.createTable(table);
+    }
+    /**
+     * Resolves a persisted change by id.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} id - Entry id.
+     * @returns {Promise<ServerChangeFeedEntry | null>} - Entry or null.
+     */
+    async _changeById(db, id) {
+        const rows = /** @type {ServerChangeFeedRow[]} */ (await db
+            .newQuery()
+            .from(TABLE_NAME)
+            .where({ id })
+            .limit(1)
+            .results());
+        return rows[0] ? this._normalizeChangeRow(rows[0]) : null;
+    }
+    /**
+     * Resolves current latest sequence without readiness checks.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<number>} - Latest sequence.
+     */
+    async _latestSequence(db) {
+        const rows = /** @type {Array<{server_sequence?: number | string}>} */ (await db
+            .newQuery()
+            .from(TABLE_NAME)
+            .order("server_sequence DESC")
+            .limit(1)
+            .results());
+        return rows[0] ? Number(rows[0].server_sequence) : 0;
+    }
+    /**
+     * Resolves current oldest sequence without readiness checks.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<number | null>} - Oldest sequence.
+     */
+    async _oldestSequence(db) {
+        const rows = /** @type {Array<{server_sequence?: number | string}>} */ (await db
+            .newQuery()
+            .from(TABLE_NAME)
+            .order("server_sequence ASC")
+            .limit(1)
+            .results());
+        return rows[0] ? Number(rows[0].server_sequence) : null;
+    }
+    /**
+     * Prunes old retained changes.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {number} latestSequence - Latest sequence after append.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _pruneRetainedChanges(db, latestSequence) {
+        if (!Number.isInteger(this.retentionSize) || this.retentionSize < 1)
+            return;
+        const pruneBeforeOrAt = latestSequence - this.retentionSize;
+        if (pruneBeforeOrAt < 1)
+            return;
+        const rows = /** @type {Array<{id: string}>} */ (await db
+            .newQuery()
+            .from(TABLE_NAME)
+            .where(`server_sequence <= ${db.quote(pruneBeforeOrAt)}`)
+            .results());
+        for (const row of rows) {
+            await db.delete({ conditions: { id: row.id }, tableName: TABLE_NAME });
+        }
+    }
+    /**
+     * Normalizes a change row.
+     * @param {ServerChangeFeedRow} row - Raw database row.
+     * @returns {ServerChangeFeedEntry} - Normalized change.
+     */
+    _normalizeChangeRow(row) {
+        const createdAtValue = row.created_at;
+        return {
+            actorDeviceId: row.actor_device_id || null,
+            actorUserId: row.actor_user_id || null,
+            attributes: parseJsonOrNull(row.attributes_json),
+            createdAt: createdAtValue instanceof Date ? createdAtValue.toISOString() : new Date(createdAtValue).toISOString(),
+            id: row.id,
+            idempotencyKey: row.idempotency_key || null,
+            model: row.model,
+            operation: row.operation,
+            payload: parseJsonOrNull(row.payload_json),
+            recordId: row.record_id || null,
+            response: parseJsonOrNull(row.response_json),
+            scope: parseJsonOrNull(row.scope_json),
+            serverSequence: Number(row.server_sequence)
+        };
+    }
+    /**
+     * Whether this store should use process-local memory because no database identifier is configured.
+     * @returns {boolean} - Whether memory storage is active.
+     */
+    _usesMemoryStorage() {
+        try {
+            return !this.configuration.getDatabaseConfiguration()[this.databaseIdentifier];
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Appends a process-local memory entry when no database is configured.
+     * @param {Omit<ServerChangeFeedEntry, "serverSequence">} change - Change payload.
+     * @returns {ServerChangeFeedEntry} - Appended entry.
+     */
+    _appendMemory(change) {
+        const entry = /** @type {ServerChangeFeedEntry} */ ({
+            actorDeviceId: change.actorDeviceId,
+            actorUserId: change.actorUserId,
+            attributes: change.attributes || null,
+            createdAt: change.createdAt,
+            id: change.id,
+            idempotencyKey: change.idempotencyKey,
+            model: change.model,
+            operation: change.operation,
+            payload: change.payload || null,
+            recordId: change.recordId === null || change.recordId === undefined ? null : String(change.recordId),
+            response: change.response || null,
+            scope: change.scope || null,
+            serverSequence: ++this._memorySequence
+        });
+        this._memoryChanges.push(entry);
+        if (this._memoryChanges.length > this.retentionSize)
+            this._memoryChanges.splice(0, this._memoryChanges.length - this.retentionSize);
+        return entry;
+    }
+    /**
+     * Returns a process-local memory change page.
+     * @param {object} args - Arguments.
+     * @param {number} args.afterSequence - Exclusive lower bound.
+     * @param {number} args.limit - Page size.
+     * @param {number} [args.upToSequence] - Inclusive upper bound.
+     * @param {Record<string, ?>} [args.scope] - Caller sync scope.
+     * @returns {{changes: ServerChangeFeedEntry[], hasMore: boolean, nextSequence: number, oldestSequence: number | null, snapshotRequired: boolean, upToSequence: number}} - Ordered page.
+     */
+    _memoryChangesAfter({ afterSequence, limit, scope, upToSequence }) {
+        const latestSequence = typeof upToSequence === "number" ? upToSequence : this._memorySequence;
+        const oldestSequence = this._memoryChanges[0]?.serverSequence || null;
+        const snapshotRequired = afterSequence > 0 && oldestSequence !== null && oldestSequence > afterSequence + 1;
+        if (snapshotRequired) {
+            return { changes: [], hasMore: false, nextSequence: afterSequence, oldestSequence, snapshotRequired: true, upToSequence: latestSequence };
+        }
+        const rows = this._memoryChanges.filter((change) => {
+            return change.serverSequence > afterSequence && change.serverSequence <= latestSequence && scopesEqual(change.scope, scope);
+        });
+        const hasMore = rows.length > limit;
+        const changes = rows.slice(0, limit);
+        const lastChange = changes[changes.length - 1];
+        return { changes, hasMore, nextSequence: lastChange ? lastChange.serverSequence : afterSequence, oldestSequence, snapshotRequired: false, upToSequence: latestSequence };
+    }
+    /**
+     * Runs with db.
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<?>} callback - Callback.
+     * @returns {Promise<?>} - Callback result.
+     */
+    async _withDb(callback) {
+        return await this.configuration.ensureConnections({ name: "Server change-feed store" }, async (dbs) => {
+            const db = dbs[this.databaseIdentifier];
+            if (!db)
+                throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`);
+            return await callback(db);
+        });
+    }
+}
+/**
+ * Normalizes page limit.
+ * @param {?} limit - Requested limit.
+ * @returns {number} - Page size.
+ */
+function normalizeLimit(limit) {
+    if (typeof limit === "number" && Number.isInteger(limit) && limit > 0)
+        return Math.min(limit, MAX_PAGE_SIZE);
+    if (typeof limit === "string" && /^\d+$/.test(limit))
+        return Math.min(Number(limit), MAX_PAGE_SIZE);
+    return DEFAULT_PAGE_SIZE;
+}
+/**
+ * Parses JSON-ish values.
+ * @param {?} value - JSON string.
+ * @returns {?} - Parsed value.
+ */
+function parseJsonOrNull(value) {
+    if (typeof value !== "string" || value.length < 1)
+        return null;
+    return JSON.parse(value);
+}
+/**
+ * Compares sync scopes by stable JSON representation.
+ * @param {Record<string, ?> | null} changeScope - Persisted change scope.
+ * @param {Record<string, ?> | undefined} requestedScope - Caller scope.
+ * @returns {boolean} - Whether the change is visible for the requested scope.
+ */
+function scopesEqual(changeScope, requestedScope) {
+    if (requestedScope === undefined)
+        return true;
+    return stableJsonStringify(changeScope || null) === stableJsonStringify(requestedScope);
+}
+/**
+ * Stable JSON serialization for persisted sync scopes.
+ * @param {?} value - JSON-compatible value.
+ * @returns {string} - Stable JSON representation.
+ */
+function stableJsonStringify(value) {
+    return JSON.stringify(stableJsonValue(value));
+}
+/**
+ * Produces a recursively key-sorted JSON value.
+ * @param {?} value - JSON-compatible value.
+ * @returns {?} - Stable JSON-compatible value.
+ */
+function stableJsonValue(value) {
+    if (Array.isArray(value))
+        return value.map((item) => stableJsonValue(item));
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.keys(value).sort().reduce((memo, key) => {
+        memo[key] = stableJsonValue(value[key]);
+        return memo;
+    }, /** @type {Record<string, ?>} */ ({}));
+}
+/**
+ * @typedef {object} ServerChangeFeedEntry
+ * @property {string | null} actorDeviceId - Signed mutation actor device id when available.
+ * @property {string | null} actorUserId - Signed mutation actor user id when available.
+ * @property {Record<string, ?> | null} attributes - Serialized mutation attributes.
+ * @property {string} createdAt - Server change creation timestamp.
+ * @property {string} id - Server change id.
+ * @property {string | null} idempotencyKey - Mutation idempotency key when available.
+ * @property {string} model - Frontend model name.
+ * @property {string} operation - Mutation operation.
+ * @property {Record<string, ?> | null} payload - Serialized mutation payload.
+ * @property {string | null} recordId - Changed record id when known.
+ * @property {Record<string, ?> | null} response - Command response payload.
+ * @property {Record<string, ?> | null} scope - Offline grant scope.
+ * @property {number} serverSequence - Monotonic server sequence.
+ */
+/**
+ * @typedef {object} ServerChangeFeedRow
+ * @property {string | null} actor_device_id - Actor device id.
+ * @property {string | null} actor_user_id - Actor user id.
+ * @property {string | null} attributes_json - Attributes JSON.
+ * @property {Date | string} created_at - Creation time.
+ * @property {string} id - Entry id.
+ * @property {string | null} idempotency_key - Mutation idempotency key.
+ * @property {string} model - Frontend model name.
+ * @property {string} operation - Mutation operation.
+ * @property {string | null} payload_json - Mutation payload JSON.
+ * @property {string | null} record_id - Record id.
+ * @property {string | null} response_json - Response JSON.
+ * @property {string | null} scope_json - Scope JSON.
+ * @property {number | string} server_sequence - Server sequence.
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-change-feed.js","sourceRoot":"","sources":["../../../src/sync/server-change-feed.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"crypto\"\nimport TableData from \"../database/table-data/index.js\"\n\nconst DEFAULT_RETENTION_SIZE = 10000\nconst DEFAULT_PAGE_SIZE = 100\nconst MAX_PAGE_SIZE = 1000\nconst TABLE_NAME = \"frontend_model_sync_changes\"\nconst stores = new WeakMap()\n\n/**\n * Shared server change-feed store for a configuration.\n * @param {import(\"../configuration.js\").default} configuration - Configuration.\n * @returns {ServerChangeFeedStore} - Store.\n */\nexport function serverChangeFeedStoreForConfiguration(configuration) {\n  let store = stores.get(configuration)\n\n  if (!store) {\n    store = new ServerChangeFeedStore({configuration})\n    stores.set(configuration, store)\n  }\n\n  return store\n}\n\nexport default class ServerChangeFeedStore {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   * @param {number} [args.retentionSize] - Number of feed entries to retain.\n   */\n  constructor({configuration, databaseIdentifier = \"default\", retentionSize}) {\n    const syncConfiguration = configuration.getSyncConfiguration()\n\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.retentionSize = retentionSize || syncConfiguration.changeFeedRetentionSize || DEFAULT_RETENTION_SIZE\n    /** @type {ServerChangeFeedEntry[]} */\n    this._memoryChanges = []\n    this._memorySequence = 0\n    this._isReady = false\n    this._readyPromise = null\n  }\n\n  /**\n   * Ensures the backing table exists.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._usesMemoryStorage()) {\n      this._isReady = true\n      return\n    }\n\n    if (await this._schemaReady()) return\n    if (this._readyPromise) return await this._readyPromise\n\n    this._readyPromise = (async () => {\n      this.configuration.setCurrent()\n      await this._withDb(async (db) => {\n        await this._ensureChangesTable(db)\n      })\n      this._isReady = true\n    })()\n\n    try {\n      await this._readyPromise\n    } finally {\n      if (!this._isReady) this._readyPromise = null\n    }\n  }\n\n  /**\n   * Appends a change and assigns the next server sequence.\n   * @param {Omit<ServerChangeFeedEntry, \"createdAt\" | \"id\" | \"serverSequence\"> & {createdAt?: string, id?: string}} change - Change payload.\n   * @returns {Promise<ServerChangeFeedEntry>} - Persisted change.\n   */\n  async append(change) {\n    await this.ensureReady()\n\n    const id = change.id || randomUUID()\n    const createdAt = change.createdAt || new Date().toISOString()\n\n    if (this._usesMemoryStorage()) return this._appendMemory({...change, createdAt, id})\n\n    return await this._withDb(async (db) => {\n      await db.insert({\n        tableName: TABLE_NAME,\n        data: {\n          actor_device_id: change.actorDeviceId,\n          actor_user_id: change.actorUserId,\n          attributes_json: JSON.stringify(change.attributes || null),\n          created_at: new Date(createdAt),\n          id,\n          idempotency_key: change.idempotencyKey,\n          model: change.model,\n          operation: change.operation,\n          payload_json: JSON.stringify(change.payload || null),\n          record_id: change.recordId === null || change.recordId === undefined ? null : String(change.recordId),\n          response_json: JSON.stringify(change.response || null),\n          scope_json: stableJsonStringify(change.scope || null)\n        }\n      })\n\n      const row = await this._changeById(db, id)\n      if (!row) throw new Error(\"Failed to persist server change-feed entry\")\n\n      await this._pruneRetainedChanges(db, row.serverSequence)\n\n      return row\n    })\n  }\n\n  /**\n   * Returns current latest server sequence.\n   * @returns {Promise<number>} - Latest sequence.\n   */\n  async latestSequence() {\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) return this._memorySequence\n\n    return await this._withDb(async (db) => {\n      const rows = await db\n        .newQuery()\n        .from(TABLE_NAME)\n        .order(\"server_sequence DESC\")\n        .limit(1)\n        .results()\n      const row = /** @type {{server_sequence?: number | string} | undefined} */ (rows[0])\n\n      return row ? Number(row.server_sequence) : 0\n    })\n  }\n\n  /**\n   * Returns oldest retained server sequence.\n   * @returns {Promise<number | null>} - Oldest retained sequence.\n   */\n  async oldestSequence() {\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) return this._memoryChanges[0]?.serverSequence || null\n\n    return await this._withDb(async (db) => await this._oldestSequence(db))\n  }\n\n  /**\n   * Returns ordered changes after a cursor.\n   * @param {object} args - Arguments.\n   * @param {number} args.afterSequence - Exclusive lower bound.\n   * @param {number} [args.limit] - Maximum number of changes.\n   * @param {number} [args.upToSequence] - Inclusive upper bound.\n   * @param {Record<string, ?>} [args.scope] - Caller sync scope.\n   * @returns {Promise<{changes: ServerChangeFeedEntry[], hasMore: boolean, nextSequence: number, oldestSequence: number | null, snapshotRequired: boolean, upToSequence: number}>} - Ordered page.\n   */\n  async changesAfter({afterSequence, limit = DEFAULT_PAGE_SIZE, scope, upToSequence}) {\n    await this.ensureReady()\n\n    const pageSize = normalizeLimit(limit)\n\n    if (this._usesMemoryStorage()) return this._memoryChangesAfter({afterSequence, limit: pageSize, scope, upToSequence})\n\n    return await this._withDb(async (db) => {\n      const latestSequence = typeof upToSequence === \"number\" ? upToSequence : await this._latestSequence(db)\n      const oldestSequence = await this._oldestSequence(db)\n      const snapshotRequired = afterSequence > 0 && oldestSequence !== null && oldestSequence > afterSequence + 1\n\n      if (snapshotRequired) {\n        return {\n          changes: [],\n          hasMore: false,\n          nextSequence: afterSequence,\n          oldestSequence,\n          snapshotRequired: true,\n          upToSequence: latestSequence\n        }\n      }\n\n      const rows = /** @type {ServerChangeFeedRow[]} */ (await db\n        .newQuery()\n        .from(TABLE_NAME)\n        .where(`server_sequence > ${db.quote(afterSequence)}`)\n        .where(`server_sequence <= ${db.quote(latestSequence)}`)\n        .where(scope === undefined ? \"1 = 1\" : {scope_json: stableJsonStringify(scope)})\n        .order(\"server_sequence ASC\")\n        .limit(pageSize + 1)\n        .results())\n      const hasMore = rows.length > pageSize\n      const pageRows = rows.slice(0, pageSize)\n      const changes = pageRows.map((row) => this._normalizeChangeRow(row))\n      const lastChange = changes[changes.length - 1]\n\n      return {\n        changes,\n        hasMore,\n        nextSequence: lastChange ? lastChange.serverSequence : afterSequence,\n        oldestSequence,\n        snapshotRequired: false,\n        upToSequence: latestSequence\n      }\n    })\n  }\n\n  /**\n   * Ensures schema is still present.\n   * @returns {Promise<boolean>} - Whether ready.\n   */\n  async _schemaReady() {\n    if (this._usesMemoryStorage()) return this._isReady\n    if (!this._isReady) return false\n    if (await this._withDb(async (db) => await db.tableExists(TABLE_NAME))) return true\n\n    this._isReady = false\n    this._readyPromise = null\n\n    return false\n  }\n\n  /**\n   * Ensures changes table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureChangesTable(db) {\n    if (await db.tableExists(TABLE_NAME)) return\n\n    const table = new TableData(TABLE_NAME, {ifNotExists: true})\n\n    table.integer(\"server_sequence\", {autoIncrement: true, null: false, primaryKey: true})\n    table.string(\"id\", {index: true, null: false})\n    table.string(\"model\", {index: true, null: false})\n    table.string(\"operation\", {null: false})\n    table.string(\"record_id\", {index: true, null: true})\n    table.text(\"payload_json\", {null: true})\n    table.text(\"attributes_json\", {null: true})\n    table.string(\"idempotency_key\", {index: true, null: true})\n    table.string(\"actor_user_id\", {index: true, null: true})\n    table.string(\"actor_device_id\", {index: true, null: true})\n    table.text(\"scope_json\", {null: true})\n    table.text(\"response_json\", {null: true})\n    table.datetime(\"created_at\", {index: true, null: false})\n\n    await db.createTable(table)\n  }\n\n  /**\n   * Resolves a persisted change by id.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} id - Entry id.\n   * @returns {Promise<ServerChangeFeedEntry | null>} - Entry or null.\n   */\n  async _changeById(db, id) {\n    const rows = /** @type {ServerChangeFeedRow[]} */ (await db\n      .newQuery()\n      .from(TABLE_NAME)\n      .where({id})\n      .limit(1)\n      .results())\n\n    return rows[0] ? this._normalizeChangeRow(rows[0]) : null\n  }\n\n  /**\n   * Resolves current latest sequence without readiness checks.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<number>} - Latest sequence.\n   */\n  async _latestSequence(db) {\n    const rows = /** @type {Array<{server_sequence?: number | string}>} */ (await db\n      .newQuery()\n      .from(TABLE_NAME)\n      .order(\"server_sequence DESC\")\n      .limit(1)\n      .results())\n\n    return rows[0] ? Number(rows[0].server_sequence) : 0\n  }\n\n  /**\n   * Resolves current oldest sequence without readiness checks.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<number | null>} - Oldest sequence.\n   */\n  async _oldestSequence(db) {\n    const rows = /** @type {Array<{server_sequence?: number | string}>} */ (await db\n      .newQuery()\n      .from(TABLE_NAME)\n      .order(\"server_sequence ASC\")\n      .limit(1)\n      .results())\n\n    return rows[0] ? Number(rows[0].server_sequence) : null\n  }\n\n  /**\n   * Prunes old retained changes.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {number} latestSequence - Latest sequence after append.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _pruneRetainedChanges(db, latestSequence) {\n    if (!Number.isInteger(this.retentionSize) || this.retentionSize < 1) return\n\n    const pruneBeforeOrAt = latestSequence - this.retentionSize\n    if (pruneBeforeOrAt < 1) return\n\n    const rows = /** @type {Array<{id: string}>} */ (await db\n      .newQuery()\n      .from(TABLE_NAME)\n      .where(`server_sequence <= ${db.quote(pruneBeforeOrAt)}`)\n      .results())\n\n    for (const row of rows) {\n      await db.delete({conditions: {id: row.id}, tableName: TABLE_NAME})\n    }\n  }\n\n  /**\n   * Normalizes a change row.\n   * @param {ServerChangeFeedRow} row - Raw database row.\n   * @returns {ServerChangeFeedEntry} - Normalized change.\n   */\n  _normalizeChangeRow(row) {\n    const createdAtValue = row.created_at\n\n    return {\n      actorDeviceId: row.actor_device_id || null,\n      actorUserId: row.actor_user_id || null,\n      attributes: parseJsonOrNull(row.attributes_json),\n      createdAt: createdAtValue instanceof Date ? createdAtValue.toISOString() : new Date(createdAtValue).toISOString(),\n      id: row.id,\n      idempotencyKey: row.idempotency_key || null,\n      model: row.model,\n      operation: row.operation,\n      payload: parseJsonOrNull(row.payload_json),\n      recordId: row.record_id || null,\n      response: parseJsonOrNull(row.response_json),\n      scope: parseJsonOrNull(row.scope_json),\n      serverSequence: Number(row.server_sequence)\n    }\n  }\n\n  /**\n   * Whether this store should use process-local memory because no database identifier is configured.\n   * @returns {boolean} - Whether memory storage is active.\n   */\n  _usesMemoryStorage() {\n    try {\n      return !this.configuration.getDatabaseConfiguration()[this.databaseIdentifier]\n    } catch {\n      return true\n    }\n  }\n\n  /**\n   * Appends a process-local memory entry when no database is configured.\n   * @param {Omit<ServerChangeFeedEntry, \"serverSequence\">} change - Change payload.\n   * @returns {ServerChangeFeedEntry} - Appended entry.\n   */\n  _appendMemory(change) {\n    const entry = /** @type {ServerChangeFeedEntry} */ ({\n      actorDeviceId: change.actorDeviceId,\n      actorUserId: change.actorUserId,\n      attributes: change.attributes || null,\n      createdAt: change.createdAt,\n      id: change.id,\n      idempotencyKey: change.idempotencyKey,\n      model: change.model,\n      operation: change.operation,\n      payload: change.payload || null,\n      recordId: change.recordId === null || change.recordId === undefined ? null : String(change.recordId),\n      response: change.response || null,\n      scope: change.scope || null,\n      serverSequence: ++this._memorySequence\n    })\n\n    this._memoryChanges.push(entry)\n    if (this._memoryChanges.length > this.retentionSize) this._memoryChanges.splice(0, this._memoryChanges.length - this.retentionSize)\n\n    return entry\n  }\n\n  /**\n   * Returns a process-local memory change page.\n   * @param {object} args - Arguments.\n   * @param {number} args.afterSequence - Exclusive lower bound.\n   * @param {number} args.limit - Page size.\n   * @param {number} [args.upToSequence] - Inclusive upper bound.\n   * @param {Record<string, ?>} [args.scope] - Caller sync scope.\n   * @returns {{changes: ServerChangeFeedEntry[], hasMore: boolean, nextSequence: number, oldestSequence: number | null, snapshotRequired: boolean, upToSequence: number}} - Ordered page.\n   */\n  _memoryChangesAfter({afterSequence, limit, scope, upToSequence}) {\n    const latestSequence = typeof upToSequence === \"number\" ? upToSequence : this._memorySequence\n    const oldestSequence = this._memoryChanges[0]?.serverSequence || null\n    const snapshotRequired = afterSequence > 0 && oldestSequence !== null && oldestSequence > afterSequence + 1\n\n    if (snapshotRequired) {\n      return {changes: [], hasMore: false, nextSequence: afterSequence, oldestSequence, snapshotRequired: true, upToSequence: latestSequence}\n    }\n\n    const rows = this._memoryChanges.filter((change) => {\n      return change.serverSequence > afterSequence && change.serverSequence <= latestSequence && scopesEqual(change.scope, scope)\n    })\n    const hasMore = rows.length > limit\n    const changes = rows.slice(0, limit)\n    const lastChange = changes[changes.length - 1]\n\n    return {changes, hasMore, nextSequence: lastChange ? lastChange.serverSequence : afterSequence, oldestSequence, snapshotRequired: false, upToSequence: latestSequence}\n  }\n\n  /**\n   * Runs with db.\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<?>} callback - Callback.\n   * @returns {Promise<?>} - Callback result.\n   */\n  async _withDb(callback) {\n    return await this.configuration.ensureConnections({name: \"Server change-feed store\"}, async (dbs) => {\n      const db = dbs[this.databaseIdentifier]\n\n      if (!db) throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`)\n\n      return await callback(db)\n    })\n  }\n}\n\n/**\n * Normalizes page limit.\n * @param {?} limit - Requested limit.\n * @returns {number} - Page size.\n */\nfunction normalizeLimit(limit) {\n  if (typeof limit === \"number\" && Number.isInteger(limit) && limit > 0) return Math.min(limit, MAX_PAGE_SIZE)\n  if (typeof limit === \"string\" && /^\\d+$/.test(limit)) return Math.min(Number(limit), MAX_PAGE_SIZE)\n\n  return DEFAULT_PAGE_SIZE\n}\n\n/**\n * Parses JSON-ish values.\n * @param {?} value - JSON string.\n * @returns {?} - Parsed value.\n */\nfunction parseJsonOrNull(value) {\n  if (typeof value !== \"string\" || value.length < 1) return null\n\n  return JSON.parse(value)\n}\n\n/**\n * Compares sync scopes by stable JSON representation.\n * @param {Record<string, ?> | null} changeScope - Persisted change scope.\n * @param {Record<string, ?> | undefined} requestedScope - Caller scope.\n * @returns {boolean} - Whether the change is visible for the requested scope.\n */\nfunction scopesEqual(changeScope, requestedScope) {\n  if (requestedScope === undefined) return true\n\n  return stableJsonStringify(changeScope || null) === stableJsonStringify(requestedScope)\n}\n\n/**\n * Stable JSON serialization for persisted sync scopes.\n * @param {?} value - JSON-compatible value.\n * @returns {string} - Stable JSON representation.\n */\nfunction stableJsonStringify(value) {\n  return JSON.stringify(stableJsonValue(value))\n}\n\n/**\n * Produces a recursively key-sorted JSON value.\n * @param {?} value - JSON-compatible value.\n * @returns {?} - Stable JSON-compatible value.\n */\nfunction stableJsonValue(value) {\n  if (Array.isArray(value)) return value.map((item) => stableJsonValue(item))\n  if (!value || typeof value !== \"object\") return value\n\n  return Object.keys(value).sort().reduce((memo, key) => {\n    memo[key] = stableJsonValue(value[key])\n\n    return memo\n  }, /** @type {Record<string, ?>} */ ({}))\n}\n\n/**\n * @typedef {object} ServerChangeFeedEntry\n * @property {string | null} actorDeviceId - Signed mutation actor device id when available.\n * @property {string | null} actorUserId - Signed mutation actor user id when available.\n * @property {Record<string, ?> | null} attributes - Serialized mutation attributes.\n * @property {string} createdAt - Server change creation timestamp.\n * @property {string} id - Server change id.\n * @property {string | null} idempotencyKey - Mutation idempotency key when available.\n * @property {string} model - Frontend model name.\n * @property {string} operation - Mutation operation.\n * @property {Record<string, ?> | null} payload - Serialized mutation payload.\n * @property {string | null} recordId - Changed record id when known.\n * @property {Record<string, ?> | null} response - Command response payload.\n * @property {Record<string, ?> | null} scope - Offline grant scope.\n * @property {number} serverSequence - Monotonic server sequence.\n */\n\n/**\n * @typedef {object} ServerChangeFeedRow\n * @property {string | null} actor_device_id - Actor device id.\n * @property {string | null} actor_user_id - Actor user id.\n * @property {string | null} attributes_json - Attributes JSON.\n * @property {Date | string} created_at - Creation time.\n * @property {string} id - Entry id.\n * @property {string | null} idempotency_key - Mutation idempotency key.\n * @property {string} model - Frontend model name.\n * @property {string} operation - Mutation operation.\n * @property {string | null} payload_json - Mutation payload JSON.\n * @property {string | null} record_id - Record id.\n * @property {string | null} response_json - Response JSON.\n * @property {string | null} scope_json - Scope JSON.\n * @property {number | string} server_sequence - Server sequence.\n */\n"]}