velocious 1.0.663 → 1.0.665

package/build/src/sync/sync-scope-store.js

@@ -204,11 +204,12 @@ export default class SyncScopeStore {
         this._assertScopeRow(scopeRow);
         await this.ensureReady();
         if (this._usesMemoryStorage()) {
-            return this._memoryScopes.get(scopeRow.scopeDigest)?.cursorPayload ?? null;
+            const currentScope = this._memoryScopes.get(scopeRow.scopeDigest);
+            return currentScope?.id === scopeRow.id ? currentScope.cursorPayload : null;
         }
         return await this._withDb(async (db) => {
             const row = await this._rowByScopeDigest(db, scopeRow.scopeDigest);
-            return row ? row.cursorPayload : null;
+            return row?.id === scopeRow.id ? row.cursorPayload : null;
         });
     }
     /**
@@ -227,12 +228,14 @@ export default class SyncScopeStore {
             const memoryScope = this._memoryScopes.get(scopeRow.scopeDigest);
             if (!memoryScope)
                 throw new Error(`No sync scope found for: ${scopeRow.scopeDigest}`);
+            if (memoryScope.id !== scopeRow.id || memoryScope.state !== "active")
+                return;
             memoryScope.cursorPayload = cursorPayload;
             return;
         }
         await this._withDb(async (db) => {
             await db.update({
-                conditions: { scope_digest: scopeRow.scopeDigest },
+                conditions: { id: scopeRow.id, scope_digest: scopeRow.scopeDigest, state: "active" },
                 data: { cursor_json: cursorPayload, updated_at: new Date() },
                 tableName: TABLE_NAME
             });
@@ -256,6 +259,73 @@ export default class SyncScopeStore {
             await db.update({ conditions: { scope_digest: digest }, data: { state: "removed", updated_at: new Date() }, tableName: TABLE_NAME });
         });
     }
+    /**
+     * Atomically deactivates selected scopes, clears their cursors and rotates
+     * their row identities. A cursor save carrying a pre-reset row identity can
+     * therefore never repopulate the reset scope. The optional cleanup hook runs
+     * inside the same database transaction, allowing an app to purge the local
+     * rows owned by those scopes without a cursor/cache split.
+     * @param {import("./sync-client-types.js").SerializedSyncScope[]} scopes - Selected scopes to reset.
+     * @param {object} [options] - Reset options.
+     * @param {(args: {connection: import("../database/drivers/base.js").default | null, scopes: import("./sync-client-types.js").SerializedSyncScope[]}) => Promise<void> | void} [options.cleanup] - App-owned local-row cleanup hook.
+     * @returns {Promise<void>}
+     */
+    async reset(scopes, { cleanup } = {}) {
+        if (!Array.isArray(scopes) || scopes.length === 0)
+            throw new Error("SyncScopeStore.reset requires at least one serialized scope");
+        if (cleanup !== undefined && typeof cleanup !== "function")
+            throw new Error("SyncScopeStore.reset cleanup must be a function");
+        await this.ensureReady();
+        const uniqueScopes = [...new Map(scopes.map((scope) => [scopeDigestForScope(scope), scope])).values()];
+        if (this._usesMemoryStorage()) {
+            if (cleanup)
+                await cleanup({ connection: null, scopes: uniqueScopes });
+            for (const scope of uniqueScopes)
+                this._resetMemoryScope(scope);
+            return;
+        }
+        await this._withDb(async (db) => {
+            await db.transaction(async () => {
+                if (cleanup)
+                    await cleanup({ connection: db, scopes: uniqueScopes });
+                for (const scope of uniqueScopes)
+                    await this._resetDatabaseScope({ db, scope });
+            });
+        });
+    }
+    /**
+     * Resets one memory-backed scope while preserving repeated-reset idempotence.
+     * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Scope to reset.
+     * @returns {void}
+     */
+    _resetMemoryScope(scope) {
+        const digest = scopeDigestForScope(scope);
+        const memoryScope = this._memoryScopes.get(digest);
+        if (!memoryScope || (memoryScope.state === "removed" && memoryScope.cursorPayload === null))
+            return;
+        this._memoryScopes.set(digest, {
+            ...memoryScope,
+            cursorPayload: null,
+            id: new UUID(4).format(),
+            state: "removed"
+        });
+    }
+    /**
+     * Resets one database-backed scope while preserving repeated-reset idempotence.
+     * @param {{db: import("../database/drivers/base.js").default, scope: import("./sync-client-types.js").SerializedSyncScope}} args - Database and scope.
+     * @returns {Promise<void>}
+     */
+    async _resetDatabaseScope({ db, scope }) {
+        const digest = scopeDigestForScope(scope);
+        const existingRow = await this._rowByScopeDigest(db, digest);
+        if (!existingRow || (existingRow.state === "removed" && existingRow.cursorPayload === null))
+            return;
+        await db.update({
+            conditions: { id: existingRow.id, scope_digest: digest },
+            data: { cursor_json: null, id: new UUID(4).format(), state: "removed", updated_at: new Date() },
+            tableName: TABLE_NAME
+        });
+    }
     /**
      * Whether the store runs without a configured database.
      * @returns {boolean} Whether memory storage is used.
@@ -349,4 +419,4 @@ export default class SyncScopeStore {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-scope-store.js","sourceRoot":"","sources":["../../../src/sync/sync-scope-store.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport TableData from \"../database/table-data/index.js\"\nimport UUID from \"pure-uuid\"\n\nimport {scopeKey} from \"./query-scope.js\"\nimport stableJsonStringify from \"./stable-json.js\"\n\n/**\n * @typedef {object} SyncScopeRow\n * @property {Record<string, ReturnType<typeof JSON.parse>>} conditions - Scope attribute conditions.\n * @property {string | null} cursorPayload - Persisted cursor JSON payload.\n * @property {string} id - Scope row id.\n * @property {string | null} resourceType - Scope resource/model name, or null for the all-types (user) scope.\n * @property {string} scopeDigest - Fixed-size deterministic digest of the canonical scope key.\n * @property {string} state - Scope state (\"active\" or \"removed\").\n * @property {string} storeIdentity - Physical store identity owning this row.\n */\nconst TABLE_NAME = \"velocious_sync_scopes\"\nconst SCOPE_DIGEST_PREFIX = \"velocious-sync-scope:\"\n\n/**\n * Digests a serialized scope into a fixed-size deterministic key, so scope\n * identities with long condition values fit an indexed string column.\n * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n * @returns {string} Deterministic UUIDv5 digest of the canonical scope key.\n */\nfunction scopeDigestForScope(scope) {\n  return new UUID(5, \"ns:URL\", `${SCOPE_DIGEST_PREFIX}${scopeKey(scope)}`).format()\n}\n\n/**\n * Framework-owned local persistence for declared sync scopes and their cursors.\n *\n * Backed by an auto-created `velocious_sync_scopes` table on the configured\n * database, with a process-local memory fallback when no database is\n * configured (mirroring the server change-feed store).\n */\nexport default class SyncScopeStore {\n  /**\n   * Creates a sync scope store.\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration owning the database.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   * @param {import(\"../tenants/tenant-handle.js\").default} [args.tenantHandle] - Immutable tenant handle owning the physical store.\n   */\n  constructor({configuration, databaseIdentifier = \"default\", tenantHandle}) {\n    if (tenantHandle) tenantHandle.assertConfiguration(configuration)\n\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.tenantHandle = tenantHandle\n    this.storeIdentity = tenantHandle\n      ? tenantHandle.databaseIdentity(databaseIdentifier)\n      : `configuration:${databaseIdentifier}`\n    /** @type {Map<string, SyncScopeRow>} */\n    this._memoryScopes = new Map()\n    this._isReady = false\n    /** @type {Promise<void> | null} */\n    this._readyPromise = null\n    /** @type {WeakMap<import(\"../database/drivers/base.js\").default, {completion: Promise<void>, promise: Promise<void>}>} */\n    this._transactionReadyPromises = new WeakMap()\n  }\n\n  /**\n   * Ensures the backing table exists.\n   * @returns {Promise<void>} Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._isReady) return\n\n    if (this._usesMemoryStorage()) {\n      this._isReady = true\n      return\n    }\n\n    await this._withDb(async (db) => await this._ensureReadyWithDb(db))\n  }\n\n  /**\n   * Coordinates durable and transaction-local readiness on one connection.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} Resolves when this caller can use the table.\n   */\n  async _ensureReadyWithDb(db) {\n    if (this._isReady) return\n\n    const transactionCompletion = db.insideTransaction() ? db.transactionCompletion() : null\n    const transactionReady = this._transactionReadyPromises.get(db)\n\n    if (transactionCompletion && transactionReady?.completion === transactionCompletion) {\n      await transactionReady.promise\n      return\n    }\n\n    if (this._readyPromise) {\n      const readyPromise = this._readyPromise\n\n      await readyPromise\n      if (this._readyPromise === readyPromise) this._readyPromise = null\n      if (this._isReady) return\n\n      await this.ensureReady()\n      return\n    }\n\n    if (transactionCompletion) {\n      const tableReadyPromise = this._ensureScopesTable(db)\n      const transactionReadyPromise = tableReadyPromise.then(() => undefined)\n\n      const durableReadyPromise = tableReadyPromise.then(async (created) => {\n        if (!created) {\n          this._isReady = true\n          return\n        }\n\n        await transactionCompletion\n      })\n\n      this._transactionReadyPromises.set(db, {completion: transactionCompletion, promise: transactionReadyPromise})\n      this._readyPromise = durableReadyPromise\n      await transactionReadyPromise\n      return\n    }\n\n    this._readyPromise = this._ensureScopesTable(db).then(() => {\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   * Finds or creates the scope row for a serialized scope, reactivating removed scopes.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n   * @returns {Promise<SyncScopeRow>} Persisted scope row.\n   */\n  async findOrCreateScope(scope) {\n    await this.ensureReady()\n\n    const digest = scopeDigestForScope(scope)\n\n    if (this._usesMemoryStorage()) {\n      const existingScope = this._memoryScopes.get(digest)\n\n      if (existingScope) {\n        if (existingScope.state !== \"active\") existingScope.state = \"active\"\n\n        return existingScope\n      }\n\n      const newScope = {\n        conditions: scope.conditions,\n        cursorPayload: null,\n        id: new UUID(4).format(),\n        resourceType: scope.resourceType ?? null,\n        scopeDigest: digest,\n        state: \"active\",\n        storeIdentity: this.storeIdentity\n      }\n\n      this._memoryScopes.set(digest, newScope)\n\n      return newScope\n    }\n\n    return await this._withDb(async (db) => {\n      const existingRow = await this._rowByScopeDigest(db, digest)\n\n      if (existingRow) {\n        if (existingRow.state !== \"active\") {\n          await db.update({conditions: {id: existingRow.id}, data: {state: \"active\", updated_at: new Date()}, tableName: TABLE_NAME})\n          existingRow.state = \"active\"\n        }\n\n        return existingRow\n      }\n\n      await db.insert({\n        tableName: TABLE_NAME,\n        data: {\n          conditions_json: stableJsonStringify(scope.conditions),\n          created_at: new Date(),\n          cursor_json: null,\n          id: new UUID(4).format(),\n          // The all-types (user) scope has no resource type; the column is non-null, so it\n          // stores as an empty string and normalizes back to null on read.\n          resource_type: scope.resourceType ?? \"\",\n          scope_digest: digest,\n          state: \"active\",\n          updated_at: new Date()\n        }\n      })\n\n      const createdRow = await this._rowByScopeDigest(db, digest)\n\n      if (!createdRow) throw new Error(\"Failed to persist sync scope\")\n\n      return createdRow\n    })\n  }\n\n  /**\n   * Returns all active scope rows.\n   * @returns {Promise<SyncScopeRow[]>} Active scope rows.\n   */\n  async activeScopes() {\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) {\n      return [...this._memoryScopes.values()].filter((scope) => scope.state === \"active\")\n    }\n\n    return await this._withDb(async (db) => {\n      const rows = /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */ (await db\n        .newQuery()\n        .from(TABLE_NAME)\n        .where({state: \"active\"})\n        .order(\"created_at ASC\")\n        .results())\n\n      return rows.map((row) => this._normalizeScopeRow(row))\n    })\n  }\n\n  /**\n   * Loads the persisted cursor payload for a scope row.\n   * @param {SyncScopeRow} scopeRow - Scope row.\n   * @returns {Promise<string | null>} Cursor JSON payload.\n   */\n  async loadCursor(scopeRow) {\n    this._assertScopeRow(scopeRow)\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) {\n      return this._memoryScopes.get(scopeRow.scopeDigest)?.cursorPayload ?? null\n    }\n\n    return await this._withDb(async (db) => {\n      const row = await this._rowByScopeDigest(db, scopeRow.scopeDigest)\n\n      return row ? row.cursorPayload : null\n    })\n  }\n\n  /**\n   * Persists the acknowledged cursor for a scope row.\n   * @param {SyncScopeRow} scopeRow - Scope row.\n   * @param {import(\"./sync-api-client-types.js\").SyncCursor} cursor - Acknowledged cursor.\n   * @returns {Promise<void>}\n   */\n  async saveCursor(scopeRow, cursor) {\n    this._assertScopeRow(scopeRow)\n    if (!cursor) return\n\n    await this.ensureReady()\n\n    const cursorPayload = JSON.stringify(cursor)\n\n    if (this._usesMemoryStorage()) {\n      const memoryScope = this._memoryScopes.get(scopeRow.scopeDigest)\n\n      if (!memoryScope) throw new Error(`No sync scope found for: ${scopeRow.scopeDigest}`)\n\n      memoryScope.cursorPayload = cursorPayload\n      return\n    }\n\n    await this._withDb(async (db) => {\n      await db.update({\n        conditions: {scope_digest: scopeRow.scopeDigest},\n        data: {cursor_json: cursorPayload, updated_at: new Date()},\n        tableName: TABLE_NAME\n      })\n    })\n  }\n\n  /**\n   * Deactivates the scope row for a serialized scope.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n   * @returns {Promise<void>}\n   */\n  async deactivate(scope) {\n    await this.ensureReady()\n\n    const digest = scopeDigestForScope(scope)\n\n    if (this._usesMemoryStorage()) {\n      const memoryScope = this._memoryScopes.get(digest)\n\n      if (memoryScope) memoryScope.state = \"removed\"\n\n      return\n    }\n\n    await this._withDb(async (db) => {\n      await db.update({conditions: {scope_digest: digest}, data: {state: \"removed\", updated_at: new Date()}, tableName: TABLE_NAME})\n    })\n  }\n\n  /**\n   * Whether the store runs without a configured database.\n   * @returns {boolean} Whether memory storage is used.\n   */\n  _usesMemoryStorage() {\n    try {\n      return !this.configuration.getDatabaseConfiguration()[this.databaseIdentifier]\n    } catch {\n      return true\n    }\n  }\n\n  /**\n   * Runs a callback with a database connection.\n   * @template Result\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<Result>} callback - Database callback.\n   * @returns {Promise<Result>} Callback result.\n   */\n  async _withDb(callback) {\n    if (this.tenantHandle) {\n      return await this.tenantHandle.databaseOperation({databaseIdentifier: this.databaseIdentifier, name: \"Tenant sync scope store\"}, async (operation) => {\n        return await callback(operation.connection())\n      })\n    }\n\n    return await this.configuration.ensureConnections({databaseIdentifiers: [this.databaseIdentifier], name: \"Sync scope 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   * Ensures the scopes table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<boolean>} Whether the table had to be created.\n   */\n  async _ensureScopesTable(db) {\n    if (await db.tableExists(TABLE_NAME)) return false\n\n    const table = new TableData(TABLE_NAME, {ifNotExists: true})\n\n    table.string(\"id\", {null: false, primaryKey: true})\n    table.string(\"scope_digest\", {index: true, null: false})\n    table.string(\"resource_type\", {index: true, null: false})\n    table.text(\"conditions_json\", {null: false})\n    table.text(\"cursor_json\", {null: true})\n    table.string(\"state\", {index: true, null: false})\n    table.datetime(\"created_at\", {null: false})\n    table.datetime(\"updated_at\", {null: false})\n\n    await db.createTable(table)\n\n    return true\n  }\n\n  /**\n   * Resolves a scope row by its digest.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} digest - Fixed-size scope digest.\n   * @returns {Promise<SyncScopeRow | null>} Scope row or null.\n   */\n  async _rowByScopeDigest(db, digest) {\n    const rows = /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */ (await db\n      .newQuery()\n      .from(TABLE_NAME)\n      .where({scope_digest: digest})\n      .limit(1)\n      .results())\n\n    return rows[0] ? this._normalizeScopeRow(rows[0]) : null\n  }\n\n  /**\n   * Normalizes a raw scope table row.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} row - Raw table row.\n   * @returns {SyncScopeRow} Normalized scope row.\n   */\n  _normalizeScopeRow(row) {\n    return {\n      conditions: /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (JSON.parse(String(row.conditions_json))),\n      cursorPayload: row.cursor_json === null || row.cursor_json === undefined ? null : String(row.cursor_json),\n      id: String(row.id),\n      resourceType: String(row.resource_type) === \"\" ? null : String(row.resource_type),\n      scopeDigest: String(row.scope_digest),\n      state: String(row.state),\n      storeIdentity: this.storeIdentity\n    }\n  }\n\n  /**\n   * Rejects passing a scope row captured from another physical store.\n   * @param {SyncScopeRow} scopeRow - Scope row to validate.\n   * @returns {void}\n   */\n  _assertScopeRow(scopeRow) {\n    if (scopeRow.storeIdentity !== this.storeIdentity) {\n      throw new Error(\"Sync scope row belongs to another physical tenant database\")\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-scope-store.js","sourceRoot":"","sources":["../../../src/sync/sync-scope-store.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport TableData from \"../database/table-data/index.js\"\nimport UUID from \"pure-uuid\"\n\nimport {scopeKey} from \"./query-scope.js\"\nimport stableJsonStringify from \"./stable-json.js\"\n\n/**\n * @typedef {object} SyncScopeRow\n * @property {Record<string, ReturnType<typeof JSON.parse>>} conditions - Scope attribute conditions.\n * @property {string | null} cursorPayload - Persisted cursor JSON payload.\n * @property {string} id - Scope row id.\n * @property {string | null} resourceType - Scope resource/model name, or null for the all-types (user) scope.\n * @property {string} scopeDigest - Fixed-size deterministic digest of the canonical scope key.\n * @property {string} state - Scope state (\"active\" or \"removed\").\n * @property {string} storeIdentity - Physical store identity owning this row.\n */\nconst TABLE_NAME = \"velocious_sync_scopes\"\nconst SCOPE_DIGEST_PREFIX = \"velocious-sync-scope:\"\n\n/**\n * Digests a serialized scope into a fixed-size deterministic key, so scope\n * identities with long condition values fit an indexed string column.\n * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n * @returns {string} Deterministic UUIDv5 digest of the canonical scope key.\n */\nfunction scopeDigestForScope(scope) {\n  return new UUID(5, \"ns:URL\", `${SCOPE_DIGEST_PREFIX}${scopeKey(scope)}`).format()\n}\n\n/**\n * Framework-owned local persistence for declared sync scopes and their cursors.\n *\n * Backed by an auto-created `velocious_sync_scopes` table on the configured\n * database, with a process-local memory fallback when no database is\n * configured (mirroring the server change-feed store).\n */\nexport default class SyncScopeStore {\n  /**\n   * Creates a sync scope store.\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration owning the database.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   * @param {import(\"../tenants/tenant-handle.js\").default} [args.tenantHandle] - Immutable tenant handle owning the physical store.\n   */\n  constructor({configuration, databaseIdentifier = \"default\", tenantHandle}) {\n    if (tenantHandle) tenantHandle.assertConfiguration(configuration)\n\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.tenantHandle = tenantHandle\n    this.storeIdentity = tenantHandle\n      ? tenantHandle.databaseIdentity(databaseIdentifier)\n      : `configuration:${databaseIdentifier}`\n    /** @type {Map<string, SyncScopeRow>} */\n    this._memoryScopes = new Map()\n    this._isReady = false\n    /** @type {Promise<void> | null} */\n    this._readyPromise = null\n    /** @type {WeakMap<import(\"../database/drivers/base.js\").default, {completion: Promise<void>, promise: Promise<void>}>} */\n    this._transactionReadyPromises = new WeakMap()\n  }\n\n  /**\n   * Ensures the backing table exists.\n   * @returns {Promise<void>} Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._isReady) return\n\n    if (this._usesMemoryStorage()) {\n      this._isReady = true\n      return\n    }\n\n    await this._withDb(async (db) => await this._ensureReadyWithDb(db))\n  }\n\n  /**\n   * Coordinates durable and transaction-local readiness on one connection.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} Resolves when this caller can use the table.\n   */\n  async _ensureReadyWithDb(db) {\n    if (this._isReady) return\n\n    const transactionCompletion = db.insideTransaction() ? db.transactionCompletion() : null\n    const transactionReady = this._transactionReadyPromises.get(db)\n\n    if (transactionCompletion && transactionReady?.completion === transactionCompletion) {\n      await transactionReady.promise\n      return\n    }\n\n    if (this._readyPromise) {\n      const readyPromise = this._readyPromise\n\n      await readyPromise\n      if (this._readyPromise === readyPromise) this._readyPromise = null\n      if (this._isReady) return\n\n      await this.ensureReady()\n      return\n    }\n\n    if (transactionCompletion) {\n      const tableReadyPromise = this._ensureScopesTable(db)\n      const transactionReadyPromise = tableReadyPromise.then(() => undefined)\n\n      const durableReadyPromise = tableReadyPromise.then(async (created) => {\n        if (!created) {\n          this._isReady = true\n          return\n        }\n\n        await transactionCompletion\n      })\n\n      this._transactionReadyPromises.set(db, {completion: transactionCompletion, promise: transactionReadyPromise})\n      this._readyPromise = durableReadyPromise\n      await transactionReadyPromise\n      return\n    }\n\n    this._readyPromise = this._ensureScopesTable(db).then(() => {\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   * Finds or creates the scope row for a serialized scope, reactivating removed scopes.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n   * @returns {Promise<SyncScopeRow>} Persisted scope row.\n   */\n  async findOrCreateScope(scope) {\n    await this.ensureReady()\n\n    const digest = scopeDigestForScope(scope)\n\n    if (this._usesMemoryStorage()) {\n      const existingScope = this._memoryScopes.get(digest)\n\n      if (existingScope) {\n        if (existingScope.state !== \"active\") existingScope.state = \"active\"\n\n        return existingScope\n      }\n\n      const newScope = {\n        conditions: scope.conditions,\n        cursorPayload: null,\n        id: new UUID(4).format(),\n        resourceType: scope.resourceType ?? null,\n        scopeDigest: digest,\n        state: \"active\",\n        storeIdentity: this.storeIdentity\n      }\n\n      this._memoryScopes.set(digest, newScope)\n\n      return newScope\n    }\n\n    return await this._withDb(async (db) => {\n      const existingRow = await this._rowByScopeDigest(db, digest)\n\n      if (existingRow) {\n        if (existingRow.state !== \"active\") {\n          await db.update({conditions: {id: existingRow.id}, data: {state: \"active\", updated_at: new Date()}, tableName: TABLE_NAME})\n          existingRow.state = \"active\"\n        }\n\n        return existingRow\n      }\n\n      await db.insert({\n        tableName: TABLE_NAME,\n        data: {\n          conditions_json: stableJsonStringify(scope.conditions),\n          created_at: new Date(),\n          cursor_json: null,\n          id: new UUID(4).format(),\n          // The all-types (user) scope has no resource type; the column is non-null, so it\n          // stores as an empty string and normalizes back to null on read.\n          resource_type: scope.resourceType ?? \"\",\n          scope_digest: digest,\n          state: \"active\",\n          updated_at: new Date()\n        }\n      })\n\n      const createdRow = await this._rowByScopeDigest(db, digest)\n\n      if (!createdRow) throw new Error(\"Failed to persist sync scope\")\n\n      return createdRow\n    })\n  }\n\n  /**\n   * Returns all active scope rows.\n   * @returns {Promise<SyncScopeRow[]>} Active scope rows.\n   */\n  async activeScopes() {\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) {\n      return [...this._memoryScopes.values()].filter((scope) => scope.state === \"active\")\n    }\n\n    return await this._withDb(async (db) => {\n      const rows = /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */ (await db\n        .newQuery()\n        .from(TABLE_NAME)\n        .where({state: \"active\"})\n        .order(\"created_at ASC\")\n        .results())\n\n      return rows.map((row) => this._normalizeScopeRow(row))\n    })\n  }\n\n  /**\n   * Loads the persisted cursor payload for a scope row.\n   * @param {SyncScopeRow} scopeRow - Scope row.\n   * @returns {Promise<string | null>} Cursor JSON payload.\n   */\n  async loadCursor(scopeRow) {\n    this._assertScopeRow(scopeRow)\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) {\n      const currentScope = this._memoryScopes.get(scopeRow.scopeDigest)\n\n      return currentScope?.id === scopeRow.id ? currentScope.cursorPayload : null\n    }\n\n    return await this._withDb(async (db) => {\n      const row = await this._rowByScopeDigest(db, scopeRow.scopeDigest)\n\n      return row?.id === scopeRow.id ? row.cursorPayload : null\n    })\n  }\n\n  /**\n   * Persists the acknowledged cursor for a scope row.\n   * @param {SyncScopeRow} scopeRow - Scope row.\n   * @param {import(\"./sync-api-client-types.js\").SyncCursor} cursor - Acknowledged cursor.\n   * @returns {Promise<void>}\n   */\n  async saveCursor(scopeRow, cursor) {\n    this._assertScopeRow(scopeRow)\n    if (!cursor) return\n\n    await this.ensureReady()\n\n    const cursorPayload = JSON.stringify(cursor)\n\n    if (this._usesMemoryStorage()) {\n      const memoryScope = this._memoryScopes.get(scopeRow.scopeDigest)\n\n      if (!memoryScope) throw new Error(`No sync scope found for: ${scopeRow.scopeDigest}`)\n      if (memoryScope.id !== scopeRow.id || memoryScope.state !== \"active\") return\n\n      memoryScope.cursorPayload = cursorPayload\n      return\n    }\n\n    await this._withDb(async (db) => {\n      await db.update({\n        conditions: {id: scopeRow.id, scope_digest: scopeRow.scopeDigest, state: \"active\"},\n        data: {cursor_json: cursorPayload, updated_at: new Date()},\n        tableName: TABLE_NAME\n      })\n    })\n  }\n\n  /**\n   * Deactivates the scope row for a serialized scope.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n   * @returns {Promise<void>}\n   */\n  async deactivate(scope) {\n    await this.ensureReady()\n\n    const digest = scopeDigestForScope(scope)\n\n    if (this._usesMemoryStorage()) {\n      const memoryScope = this._memoryScopes.get(digest)\n\n      if (memoryScope) memoryScope.state = \"removed\"\n\n      return\n    }\n\n    await this._withDb(async (db) => {\n      await db.update({conditions: {scope_digest: digest}, data: {state: \"removed\", updated_at: new Date()}, tableName: TABLE_NAME})\n    })\n  }\n\n  /**\n   * Atomically deactivates selected scopes, clears their cursors and rotates\n   * their row identities. A cursor save carrying a pre-reset row identity can\n   * therefore never repopulate the reset scope. The optional cleanup hook runs\n   * inside the same database transaction, allowing an app to purge the local\n   * rows owned by those scopes without a cursor/cache split.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope[]} scopes - Selected scopes to reset.\n   * @param {object} [options] - Reset options.\n   * @param {(args: {connection: import(\"../database/drivers/base.js\").default | null, scopes: import(\"./sync-client-types.js\").SerializedSyncScope[]}) => Promise<void> | void} [options.cleanup] - App-owned local-row cleanup hook.\n   * @returns {Promise<void>}\n   */\n  async reset(scopes, {cleanup} = {}) {\n    if (!Array.isArray(scopes) || scopes.length === 0) throw new Error(\"SyncScopeStore.reset requires at least one serialized scope\")\n    if (cleanup !== undefined && typeof cleanup !== \"function\") throw new Error(\"SyncScopeStore.reset cleanup must be a function\")\n\n    await this.ensureReady()\n\n    const uniqueScopes = [...new Map(scopes.map((scope) => [scopeDigestForScope(scope), scope])).values()]\n\n    if (this._usesMemoryStorage()) {\n      if (cleanup) await cleanup({connection: null, scopes: uniqueScopes})\n\n      for (const scope of uniqueScopes) this._resetMemoryScope(scope)\n\n      return\n    }\n\n    await this._withDb(async (db) => {\n      await db.transaction(async () => {\n        if (cleanup) await cleanup({connection: db, scopes: uniqueScopes})\n\n        for (const scope of uniqueScopes) await this._resetDatabaseScope({db, scope})\n      })\n    })\n  }\n\n  /**\n   * Resets one memory-backed scope while preserving repeated-reset idempotence.\n   * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Scope to reset.\n   * @returns {void}\n   */\n  _resetMemoryScope(scope) {\n    const digest = scopeDigestForScope(scope)\n    const memoryScope = this._memoryScopes.get(digest)\n\n    if (!memoryScope || (memoryScope.state === \"removed\" && memoryScope.cursorPayload === null)) return\n\n    this._memoryScopes.set(digest, {\n      ...memoryScope,\n      cursorPayload: null,\n      id: new UUID(4).format(),\n      state: \"removed\"\n    })\n  }\n\n  /**\n   * Resets one database-backed scope while preserving repeated-reset idempotence.\n   * @param {{db: import(\"../database/drivers/base.js\").default, scope: import(\"./sync-client-types.js\").SerializedSyncScope}} args - Database and scope.\n   * @returns {Promise<void>}\n   */\n  async _resetDatabaseScope({db, scope}) {\n    const digest = scopeDigestForScope(scope)\n    const existingRow = await this._rowByScopeDigest(db, digest)\n\n    if (!existingRow || (existingRow.state === \"removed\" && existingRow.cursorPayload === null)) return\n\n    await db.update({\n      conditions: {id: existingRow.id, scope_digest: digest},\n      data: {cursor_json: null, id: new UUID(4).format(), state: \"removed\", updated_at: new Date()},\n      tableName: TABLE_NAME\n    })\n  }\n\n  /**\n   * Whether the store runs without a configured database.\n   * @returns {boolean} Whether memory storage is used.\n   */\n  _usesMemoryStorage() {\n    try {\n      return !this.configuration.getDatabaseConfiguration()[this.databaseIdentifier]\n    } catch {\n      return true\n    }\n  }\n\n  /**\n   * Runs a callback with a database connection.\n   * @template Result\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<Result>} callback - Database callback.\n   * @returns {Promise<Result>} Callback result.\n   */\n  async _withDb(callback) {\n    if (this.tenantHandle) {\n      return await this.tenantHandle.databaseOperation({databaseIdentifier: this.databaseIdentifier, name: \"Tenant sync scope store\"}, async (operation) => {\n        return await callback(operation.connection())\n      })\n    }\n\n    return await this.configuration.ensureConnections({databaseIdentifiers: [this.databaseIdentifier], name: \"Sync scope 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   * Ensures the scopes table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<boolean>} Whether the table had to be created.\n   */\n  async _ensureScopesTable(db) {\n    if (await db.tableExists(TABLE_NAME)) return false\n\n    const table = new TableData(TABLE_NAME, {ifNotExists: true})\n\n    table.string(\"id\", {null: false, primaryKey: true})\n    table.string(\"scope_digest\", {index: true, null: false})\n    table.string(\"resource_type\", {index: true, null: false})\n    table.text(\"conditions_json\", {null: false})\n    table.text(\"cursor_json\", {null: true})\n    table.string(\"state\", {index: true, null: false})\n    table.datetime(\"created_at\", {null: false})\n    table.datetime(\"updated_at\", {null: false})\n\n    await db.createTable(table)\n\n    return true\n  }\n\n  /**\n   * Resolves a scope row by its digest.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} digest - Fixed-size scope digest.\n   * @returns {Promise<SyncScopeRow | null>} Scope row or null.\n   */\n  async _rowByScopeDigest(db, digest) {\n    const rows = /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */ (await db\n      .newQuery()\n      .from(TABLE_NAME)\n      .where({scope_digest: digest})\n      .limit(1)\n      .results())\n\n    return rows[0] ? this._normalizeScopeRow(rows[0]) : null\n  }\n\n  /**\n   * Normalizes a raw scope table row.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} row - Raw table row.\n   * @returns {SyncScopeRow} Normalized scope row.\n   */\n  _normalizeScopeRow(row) {\n    return {\n      conditions: /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (JSON.parse(String(row.conditions_json))),\n      cursorPayload: row.cursor_json === null || row.cursor_json === undefined ? null : String(row.cursor_json),\n      id: String(row.id),\n      resourceType: String(row.resource_type) === \"\" ? null : String(row.resource_type),\n      scopeDigest: String(row.scope_digest),\n      state: String(row.state),\n      storeIdentity: this.storeIdentity\n    }\n  }\n\n  /**\n   * Rejects passing a scope row captured from another physical store.\n   * @param {SyncScopeRow} scopeRow - Scope row to validate.\n   * @returns {void}\n   */\n  _assertScopeRow(scopeRow) {\n    if (scopeRow.storeIdentity !== this.storeIdentity) {\n      throw new Error(\"Sync scope row belongs to another physical tenant database\")\n    }\n  }\n}\n"]}

package/build/sync/sync-api-client.js

@@ -71,16 +71,19 @@ export default class SyncApiClient {
    * @param {string} args.authenticationToken - Authentication token.
    * @param {number} [args.batchSize] - Batch size.
    * @param {import("./sync-client-types.js").SyncClientConflictTrackingConfig} args.conflictTracking - Tracking configuration.
-   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}) => Promise<SyncReplayResponse>} args.postReplay - Transport boundary.
+   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}, options?: {signal?: AbortSignal}) => Promise<SyncReplayResponse>} args.postReplay - Transport boundary.
    * @param {(identity: string) => number} args.remoteGeneration - Current remote generation.
    * @param {string} args.resourceType - Resource whose log records should drain.
+   * @param {AbortSignal} [args.signal] - Lifecycle cancellation signal.
    * @returns {Promise<void>} Resolves when no ready intent remains.
    */
-  static async replayConflictTrackedSyncs({authenticationToken, batchSize, conflictTracking, postReplay, remoteGeneration, resourceType}) {
+  static async replayConflictTrackedSyncs({authenticationToken, batchSize, conflictTracking, postReplay, remoteGeneration, resourceType, signal}) {
     const maxBatchSize = this.normalizedBatchSize(batchSize)
 
     while (true) {
+      throwIfSyncAborted(signal)
       const records = await conflictTracking.mutationLog.records()
+      throwIfSyncAborted(signal)
       const statuses = new Map(records.map((record) => [record.mutation.clientMutationId, record.status]))
       const pending = records.filter((record) => record.status === "pending" && record.mutation.model === resourceType)
       const ready = pending.filter((record) => record.dependencies.every((dependency) => statuses.get(dependency.clientMutationId) === "synced"))
@@ -92,13 +95,15 @@ export default class SyncApiClient {
       const response = await postReplay({
         authenticationToken,
         syncs: groups.map((group) => this.conflictReplayPayload(group))
-      })
+      }, {signal})
 
+      throwIfSyncAborted(signal)
       this.ensureSuccessfulResponse(response)
 
       const responsesById = new Map((response.syncs || []).map((result) => [String(result.id), result]))
 
       for (const group of groups) {
+        throwIfSyncAborted(signal)
         const result = responsesById.get(group[0].mutation.clientMutationId)
 
         if (!result) throw new Error(`Sync response missing result for mutation ${group[0].mutation.clientMutationId}`)
@@ -108,6 +113,7 @@ export default class SyncApiClient {
 
         for (const record of group) {
           await applySyncReplayResultToLocalMutationLog({mutationLog: conflictTracking.mutationLog, record, result: /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (result)})
+          throwIfSyncAborted(signal)
         }
 
         if (["successful", "duplicate"].includes(result.syncState) && result.serverVersion !== undefined) {
@@ -115,6 +121,7 @@ export default class SyncApiClient {
 
           if (remoteGeneration(identity) === generations.get(group[0].mutation.clientMutationId)) {
             await this.rebaseConflictSuccessor({conflictTracking, predecessor: group[group.length - 1], serverVersion: result.serverVersion})
+            throwIfSyncAborted(signal)
           }
         }
       }
@@ -261,6 +268,7 @@ export default class SyncApiClient {
    * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
    * @param {Record<string, SyncResourceConfig>} args.resources - Resource policies.
    * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [args.onProgress] - Progress callback.
+   * @param {AbortSignal} [args.signal] - Lifecycle cancellation signal.
    * @returns {Promise<SyncChangesResult>} Pull result.
    */
   static async pullChangesWithCursor(args) {
@@ -271,7 +279,8 @@ export default class SyncApiClient {
       saveCursor: async (cursor) => await this.saveSyncCursor({cursor, cursorKey: args.cursorKey, cursorModel: args.cursorModel}),
       postChanges: args.postChanges,
       applySync: this.resourceApplier(args.resources),
-      onProgress: args.onProgress
+      onProgress: args.onProgress,
+      signal: args.signal
     })
   }
 
@@ -309,12 +318,14 @@ export default class SyncApiClient {
    * @param {number} [args.batchSize] - Max syncs per request. Defaults to 100.
    * @param {() => Promise<SyncCursor | string | null | undefined>} args.loadCursor - Loads the persisted local cursor.
    * @param {(cursor: SyncCursor) => Promise<void>} args.saveCursor - Persists the final acknowledged cursor.
-   * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
+   * @param {(payload: SyncChangesRequest, options?: {signal?: AbortSignal}) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
    * @param {(sync: SyncChangeEnvelope) => Promise<SyncChangeApplyResult>} args.applySync - Applies one normalized sync row locally.
    * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [args.onProgress] - Progress callback invoked per applied page (and once for an empty pull) with the applied counts and the stable server total.
+   * @param {AbortSignal} [args.signal] - Lifecycle cancellation signal.
    * @returns {Promise<SyncChangesResult>} Pull result.
    */
   static async pullChanges(args) {
+    throwIfSyncAborted(args.signal)
     let afterCursor = this.syncCursorFromPayload(await args.loadCursor())
     let upToCursor = null
     let pages = 0
@@ -326,7 +337,9 @@ export default class SyncApiClient {
     const batchSize = this.normalizedBatchSize(args.batchSize)
 
     while (true) {
+      throwIfSyncAborted(args.signal)
       const changesResponse = await this.changesPage({...args, afterCursor, batchSize, upToCursor})
+      throwIfSyncAborted(args.signal)
       const syncs = changesResponse.syncs
 
       if (!upToCursor) upToCursor = changesResponse.upToCursor
@@ -341,6 +354,7 @@ export default class SyncApiClient {
       if (syncs.length === 0) {
         // Report the terminal progress once for an entirely empty pull so consumers observe
         // total 0; a pull that already applied pages reported its final counts on its last page.
+        throwIfSyncAborted(args.signal)
         if (pages === 0 && args.onProgress) args.onProgress({pages, syncedCount, total})
 
         break
@@ -354,7 +368,9 @@ export default class SyncApiClient {
       // waiting for the rest of the pull.
       await recordChanges.batch(async () => {
         for (const sync of syncs) {
+          throwIfSyncAborted(args.signal)
           const applyResult = await args.applySync(sync)
+          throwIfSyncAborted(args.signal)
           const resourceType = applyResult.resourceType ?? sync.resourceType()
 
           changed ||= applyResult.changed === true
@@ -369,11 +385,14 @@ export default class SyncApiClient {
 
       afterCursor = changesResponse.nextCursor
 
+      throwIfSyncAborted(args.signal)
       if (args.onProgress) args.onProgress({pages, syncedCount, total})
       if (syncs.length < batchSize) break
     }
 
+    throwIfSyncAborted(args.signal)
     if (afterCursor) await args.saveCursor(afterCursor)
+    throwIfSyncAborted(args.signal)
 
     return {changed, pages, resourceChanged, resourceCounts, syncedCount, total}
   }
@@ -384,18 +403,21 @@ export default class SyncApiClient {
    * @param {SyncCursor} args.afterCursor - Last acknowledged cursor.
    * @param {string} args.authenticationToken - Auth token.
    * @param {number} args.batchSize - Page size.
-   * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Changes poster.
+   * @param {(payload: SyncChangesRequest, options?: {signal?: AbortSignal}) => Promise<SyncChangesResponse>} args.postChanges - Changes poster.
+   * @param {AbortSignal} [args.signal] - Lifecycle cancellation signal.
    * @param {SyncCursor} args.upToCursor - Snapshot upper-bound cursor.
    * @returns {Promise<{nextCursor: SyncCursor, syncs: SyncChangeEnvelope[], total: number | null, upToCursor: SyncCursor}>} Normalized changes page.
    */
-  static async changesPage({afterCursor, authenticationToken, batchSize, postChanges, upToCursor}) {
+  static async changesPage({afterCursor, authenticationToken, batchSize, postChanges, signal, upToCursor}) {
+    throwIfSyncAborted(signal)
     const response = await postChanges({
       authenticationToken,
       limit: batchSize,
       ...this.cursorPayload("after", afterCursor),
       ...this.cursorPayload("upTo", upToCursor)
-    })
+    }, {signal})
 
+    throwIfSyncAborted(signal)
     this.ensureSuccessfulChangesResponse(response)
 
     const syncs = /** @type {unknown[]} */ (response.syncs)
@@ -578,7 +600,8 @@ export default class SyncApiClient {
    * @param {string} args.authenticationToken - Auth token to send with replay requests.
    * @param {number} [args.batchSize] - Max syncs per request.
    * @param {ReturnType<typeof JSON.parse>} args.syncModel - Local Sync model class.
-   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}) => Promise<SyncReplayResponse>} args.postReplay - Replay poster.
+   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}, options?: {signal?: AbortSignal}) => Promise<SyncReplayResponse>} args.postReplay - Replay poster.
+   * @param {AbortSignal} [args.signal] - Lifecycle cancellation signal.
    * @returns {Promise<void>}
    */
   static async replayLocalSyncs(args) {
@@ -602,6 +625,7 @@ export default class SyncApiClient {
       },
       pendingSyncs: async () => await args.syncModel.preload({resource: true}).where({state: "pending"}).order("created_at").toArray(),
       postReplay: args.postReplay,
+      signal: args.signal,
       syncId: (sync) => (/** @type {{id: () => string | number | null | undefined}} */ (sync)).id(),
       syncPayload: (sync) => {
         postedSnapshotsBySyncId.set(String((/** @type {{id: () => string | number | null | undefined}} */ (sync)).id()), this.localSyncReplaySnapshot(sync))
@@ -810,15 +834,19 @@ export default class SyncApiClient {
    * @param {() => Promise<Array<unknown>>} args.pendingSyncs - Loads pending local sync rows in replay order.
    * @param {(sync: unknown) => string | number | null | undefined} args.syncId - Returns the local sync id.
    * @param {(sync: unknown) => Record<string, ReturnType<typeof JSON.parse>>} args.syncPayload - Builds the API sync envelope.
-   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}) => Promise<SyncReplayResponse>} args.postReplay - Posts one replay request.
+   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}, options?: {signal?: AbortSignal}) => Promise<SyncReplayResponse>} args.postReplay - Posts one replay request.
    * @param {(sync: unknown, response: SyncReplayItem) => Promise<void>} args.markSuccessful - Marks one sync as successful locally.
+   * @param {AbortSignal} [args.signal] - Lifecycle cancellation signal.
    * @returns {Promise<void>} Resolves after all batches are replayed.
    */
   static async replayPending(args) {
+    throwIfSyncAborted(args.signal)
     const pendingSyncs = await args.pendingSyncs()
+    throwIfSyncAborted(args.signal)
     const batchSize = this.normalizedBatchSize(args.batchSize)
 
     for (let offset = 0; offset < pendingSyncs.length; offset += batchSize) {
+      throwIfSyncAborted(args.signal)
       await this.replayBatch({...args, pendingSyncs: pendingSyncs.slice(offset, offset + batchSize)})
     }
   }
@@ -830,14 +858,16 @@ export default class SyncApiClient {
    * @param {Array<unknown>} args.pendingSyncs - Batch syncs.
    * @param {(sync: unknown) => string | number | null | undefined} args.syncId - Sync id getter.
    * @param {(sync: unknown) => Record<string, ReturnType<typeof JSON.parse>>} args.syncPayload - Payload builder.
-   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}) => Promise<SyncReplayResponse>} args.postReplay - Replay poster.
+   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}, options?: {signal?: AbortSignal}) => Promise<SyncReplayResponse>} args.postReplay - Replay poster.
    * @param {(sync: unknown, response: SyncReplayItem) => Promise<void>} args.markSuccessful - Success hook.
+   * @param {AbortSignal} [args.signal] - Lifecycle cancellation signal.
    * @returns {Promise<void>} Resolves after the batch is acknowledged.
    */
   static async replayBatch(args) {
-    const {authenticationToken, markSuccessful, pendingSyncs, postReplay, syncId, syncPayload} = args
+    const {authenticationToken, markSuccessful, pendingSyncs, postReplay, signal, syncId, syncPayload} = args
 
     if (pendingSyncs.length === 0) return
+    throwIfSyncAborted(signal)
 
     const syncsById = new Map()
 
@@ -850,11 +880,13 @@ export default class SyncApiClient {
     const response = await postReplay({
       authenticationToken,
       syncs: pendingSyncs.map((sync) => syncPayload(sync))
-    })
+    }, {signal})
 
+    throwIfSyncAborted(signal)
     this.ensureSuccessfulResponse(response)
 
     for (const syncResponse of response.syncs || []) {
+      throwIfSyncAborted(signal)
       const sync = syncsById.get(String(syncResponse.id))
 
       if (!sync) continue
@@ -863,6 +895,7 @@ export default class SyncApiClient {
       }
 
       await markSuccessful(sync, syncResponse)
+      throwIfSyncAborted(signal)
     }
   }
 
@@ -887,3 +920,15 @@ export default class SyncApiClient {
     return Math.floor(batchSize)
   }
 }
+
+/**
+ * Throws the exact abort reason at lifecycle boundaries so callers can
+ * distinguish an expected cooperative stop from transport or apply failures.
+ * @param {AbortSignal | undefined} signal - Lifecycle signal.
+ * @returns {void}
+ */
+function throwIfSyncAborted(signal) {
+  if (!signal?.aborted) return
+
+  throw signal.reason instanceof Error ? signal.reason : new Error("Sync operation aborted")
+}

package/build/sync/sync-client-types.js

@@ -97,6 +97,26 @@
  * @property {import("../tenants/tenant-handle.js").default} [tenantHandle] - Immutable tenant handle binding every local sync state transition.
  */
 
+/**
+ * Local cleanup hook that runs transactionally with selected scope resets.
+ * @typedef {(args: {connection: import("../database/drivers/base.js").default | null, scopes: SerializedSyncScope[]}) => Promise<void> | void} SyncClientScopeCleanup
+ */
+
+/**
+ * Options for stopping and resetting a sync client lifecycle.
+ * @typedef {object} SyncClientStopOptions
+ * @property {SyncClientScopeCleanup} [cleanup] - App-owned local-row purge run atomically with resetScopes.
+ * @property {SerializedSyncScope[]} [resetScopes] - Selected scope rows to deactivate and restart from a null cursor.
+ */
+
+/**
+ * Options for atomically replacing the external identity read by sync.client.
+ * @typedef {SyncClientStopOptions & {
+ *   replace: () => Promise<void> | void,
+ *   subscribeUserScope?: boolean
+ * }} SyncClientReplaceIdentityOptions
+ */
+
 /**
  * Internal derived sync client configuration built by the SyncClient
  * constructor — not an app-facing API.
@@ -107,8 +127,8 @@
  * @property {() => boolean | Promise<boolean>} [isOnline] - Connectivity gate for pulls and replays. Defaults to always online.
  * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.
  * @property {(error: Error) => void} [onError] - Reports background replay/pull failures. Defaults to rethrowing.
- * @property {(payload: import("./sync-api-client-types.js").SyncChangesRequest & {scope: SerializedSyncScope}) => Promise<import("./sync-api-client-types.js").SyncChangesResponse>} postChanges - Posts one changes request.
- * @property {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}) => Promise<import("./sync-api-client-types.js").SyncReplayResponse>} postReplay - Posts one replay request.
+ * @property {(payload: import("./sync-api-client-types.js").SyncChangesRequest & {scope: SerializedSyncScope}, options?: {signal?: AbortSignal}) => Promise<import("./sync-api-client-types.js").SyncChangesResponse>} postChanges - Posts one changes request.
+ * @property {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}, options?: {signal?: AbortSignal}) => Promise<import("./sync-api-client-types.js").SyncReplayResponse>} postReplay - Posts one replay request.
  * @property {import("../configuration-types.js").VelociousSyncClientRealtimeConfiguration} [realtime] - Realtime push configuration consumed by `subscribeRealtime(...)`.
  * @property {import("../remote-request-context.js").RemoteRequestContext} requestContext - Immutable scalar context captured for this client.
  * @property {Record<string, SyncClientResourceConfig>} resources - Derived resource policies keyed by resource/model name.