velocious 1.0.513 → 1.0.514

package/build/src/sync/sync-model-change-feed-service.js

@@ -28,14 +28,18 @@ export default class SyncModelChangeFeedService {
         this.serializeRecord = serializeRecord || ((record) => this.defaultSerializeRecord(record));
     }
     /**
-     * Builds a stable change-feed page.
-     * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
+     * Builds a stable change-feed page. The additive `total` is the scope's pending
+     * change count from the request cursor to the snapshot bound (a COUNT, not a
+     * materialized read), so a client can render a "synced of total" progress bar;
+     * older clients ignore it.
+     * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
      */
     async changes() {
         const limit = this.normalizedLimit(this.params.limit);
         const upToCursor = await this.resolveUpToCursor();
         if (!upToCursor)
-            return { status: "success", nextCursor: null, syncs: [], upToCursor: null };
+            return { status: "success", nextCursor: null, syncs: [], total: 0, upToCursor: null };
+        const total = await this.totalPendingChanges({ upToCursor });
         const query = this.pageQuery({ limit, upToCursor });
         const records = await query.toArray();
         const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor;
@@ -43,6 +47,7 @@ export default class SyncModelChangeFeedService {
             status: "success",
             nextCursor,
             syncs: records.map((record) => this.serializeRecord(record)),
+            total,
             upToCursor
         };
     }
@@ -106,16 +111,38 @@ export default class SyncModelChangeFeedService {
      * @returns {import("../database/query/model-class-query.js").default} Page query.
      */
     pageQuery({ limit, upToCursor }) {
+        const query = this.cursorFilteredQuery({ upToCursor });
+        const driver = query.driver;
+        const serverSequenceColumn = `${driver.quoteTable(this.modelClass.tableName())}.${driver.quoteColumn("server_sequence")}`;
+        return query
+            .order(`${serverSequenceColumn} ASC`)
+            .limit(limit);
+    }
+    /**
+     * Counts the scope's pending change rows from the request cursor to the snapshot
+     * bound without materializing them, so the client can render a stable "of Y"
+     * progress denominator.
+     * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Count args.
+     * @returns {Promise<number>} Pending change count from the request cursor.
+     */
+    async totalPendingChanges({ upToCursor }) {
+        return await this.cursorFilteredQuery({ upToCursor }).count();
+    }
+    /**
+     * Builds a scoped query with the snapshot upper bound and after-cursor filters
+     * applied, but without ordering or a page limit. Shared by the page read and the
+     * total-count so both count the same set of rows.
+     * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Filter args.
+     * @returns {import("../database/query/model-class-query.js").default} Cursor-filtered query.
+     */
+    cursorFilteredQuery({ upToCursor }) {
         const query = this.scopedQuery();
         const driver = query.driver;
         const table = driver.quoteTable(this.modelClass.tableName());
         const serverSequenceColumn = `${table}.${driver.quoteColumn("server_sequence")}`;
         const updatedAtColumn = `${table}.${driver.quoteColumn("updated_at")}`;
         const idColumn = `${table}.${driver.quoteColumn("id")}`;
-        query
-            .where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)
-            .order(`${serverSequenceColumn} ASC`)
-            .limit(limit);
+        query.where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`);
         const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, "afterServerSequence");
         if (afterServerSequence !== null) {
             query.where(`${serverSequenceColumn} > ${driver.quote(afterServerSequence)}`);
@@ -220,4 +247,4 @@ export default class SyncModelChangeFeedService {
         return date.toISOString();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-model-change-feed-service.js","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nimport {declaredSyncScopeAttributes} from \"./sync-scope-attributes.js\"\n\n/**\n * Generic cursor-paginated change feed over an app-owned sync/change model.\n *\n * Apps provide the model and optional scoping/serialization hooks. Velocious owns\n * cursor parsing, snapshot high-water resolution, stable ordering, page limits,\n * and response shape for `/velocious/sync/changes` style endpoints.\n */\nexport default class SyncModelChangeFeedService {\n  /**\n   * Creates a generic sync-model change-feed service.\n   * @param {object} args - Service arguments.\n   * @param {typeof import(\"../database/record/index.js\").default} args.modelClass - Sync/change model class.\n   * @param {Record<string, unknown>} args.params - Request params.\n   * @param {number} [args.defaultLimit] - Default page size.\n   * @param {number} [args.maxLimit] - Maximum page size.\n   * @param {(record: ?) => Record<string, unknown>} [args.serializeRecord] - Record serializer.\n   * @param {function({query: import(\"../database/query/model-class-query.js\").default}): void} [args.scopeQuery] - Applies app-owned visibility scope.\n   */\n  constructor({defaultLimit = 1000, maxLimit = 1000, modelClass, params, scopeQuery, serializeRecord}) {\n    this.defaultLimit = defaultLimit\n    this.maxLimit = maxLimit\n    this.modelClass = modelClass\n    this.params = params\n    this.scopeQuery = scopeQuery || null\n    this.serializeRecord = serializeRecord || ((record) => this.defaultSerializeRecord(record))\n  }\n\n  /**\n   * Builds a stable change-feed page.\n   * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.\n   */\n  async changes() {\n    const limit = this.normalizedLimit(this.params.limit)\n    const upToCursor = await this.resolveUpToCursor()\n\n    if (!upToCursor) return {status: \"success\", nextCursor: null, syncs: [], upToCursor: null}\n\n    const query = this.pageQuery({limit, upToCursor})\n    const records = await query.toArray()\n    const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor\n\n    return {\n      status: \"success\",\n      nextCursor,\n      syncs: records.map((record) => this.serializeRecord(record)),\n      upToCursor\n    }\n  }\n\n  /**\n   * Normalizes the requested page limit.\n   * @param {unknown} value - Raw limit param.\n   * @returns {number} Normalized page limit.\n   */\n  normalizedLimit(value) {\n    if (value === undefined || value === null || value === \"\") return this.defaultLimit\n\n    const limit = Number(value)\n\n    if (!Number.isSafeInteger(limit) || limit <= 0) {\n      throw VelociousError.safe(\"Sync changes limit must be a positive integer.\", {code: \"sync-invalid-changes-limit\"})\n    }\n\n    return Math.min(limit, this.maxLimit)\n  }\n\n  /**\n   * Parses an optional positive integer cursor field.\n   * @param {unknown} value - Raw integer param.\n   * @param {string} name - Param name for error messages.\n   * @returns {number | null} Positive integer value, or null when omitted.\n   */\n  optionalPositiveIntegerParam(value, name) {\n    if (value === undefined || value === null || value === \"\") return null\n\n    const integer = Number(value)\n\n    if (!Number.isSafeInteger(integer) || integer <= 0) {\n      throw VelociousError.safe(`${name} must be a positive integer.`, {code: \"sync-invalid-changes-cursor\"})\n    }\n\n    return integer\n  }\n\n  /**\n   * Resolves the high-water cursor that bounds the current feed page.\n   * @returns {Promise<{id: string, serverSequence: number, updatedAt: string} | null>} Snapshot upper-bound cursor.\n   */\n  async resolveUpToCursor() {\n    const upToServerSequence = this.optionalPositiveIntegerParam(this.params.upToServerSequence, \"upToServerSequence\")\n\n    if (upToServerSequence !== null && typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      return {id: this.params.upToId, serverSequence: upToServerSequence, updatedAt: this.params.upToUpdatedAt}\n    }\n\n    if (typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      const upToRecord = await this.modelClass.findBy({id: this.params.upToId})\n\n      if (upToRecord) return this.cursorForRecord(upToRecord)\n    }\n\n    const query = this.scopedQuery()\n    const table = query.driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = query.driver.quoteColumn(\"server_sequence\")\n    const latestRecords = await query\n      .order(`${table}.${serverSequenceColumn} DESC`)\n      .limit(1)\n      .toArray()\n\n    if (latestRecords.length === 0) return null\n\n    return this.cursorForRecord(latestRecords[0])\n  }\n\n  /**\n   * Builds the ordered and cursor-filtered page query.\n   * @param {{limit: number, upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Page query args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Page query.\n   */\n  pageQuery({limit, upToCursor}) {\n    const query = this.scopedQuery()\n    const driver = query.driver\n    const table = driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = `${table}.${driver.quoteColumn(\"server_sequence\")}`\n    const updatedAtColumn = `${table}.${driver.quoteColumn(\"updated_at\")}`\n    const idColumn = `${table}.${driver.quoteColumn(\"id\")}`\n\n    query\n      .where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)\n      .order(`${serverSequenceColumn} ASC`)\n      .limit(limit)\n\n    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, \"afterServerSequence\")\n\n    if (afterServerSequence !== null) {\n      query.where(`${serverSequenceColumn} > ${driver.quote(afterServerSequence)}`)\n    } else if (typeof this.params.afterUpdatedAt === \"string\" && this.params.afterUpdatedAt !== \"\") {\n      const isPagingExistingSnapshot = typeof this.params.upToUpdatedAt === \"string\" && this.params.upToUpdatedAt !== \"\" && typeof this.params.upToId === \"string\" && this.params.upToId !== \"\"\n\n      if (isPagingExistingSnapshot && typeof this.params.afterId === \"string\" && this.params.afterId !== \"\") {\n        query.where(`(${updatedAtColumn} > ${driver.quote(this.params.afterUpdatedAt)} OR (${updatedAtColumn} = ${driver.quote(this.params.afterUpdatedAt)} AND ${idColumn} > ${driver.quote(this.params.afterId)}))`)\n      } else {\n        query.where(`${updatedAtColumn} >= ${driver.quote(this.params.afterUpdatedAt)}`)\n      }\n    }\n\n    return query\n  }\n\n  /**\n   * Builds a base query with app-owned scope applied.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Scoped base query.\n   */\n  scopedQuery() {\n    const query = this.modelClass.where({})\n\n    if (this.scopeQuery) this.scopeQuery({query})\n\n    return query\n  }\n\n  /**\n   * Serializes a record into a transport cursor.\n   * @param {?} record - Sync/change record.\n   * @returns {{id: string, serverSequence: number, updatedAt: string}} Cursor for row.\n   */\n  cursorForRecord(record) {\n    return {id: String(this.recordValue(record, \"id\")), serverSequence: Number(this.recordValue(record, \"serverSequence\")), updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))}\n  }\n\n  /**\n   * Serializes a record using the standard sync envelope shape plus the sync\n   * model's declared scope-partition attributes (`static syncScopeAttributes`),\n   * each emitted under its own attribute name. Models declaring no scope\n   * attributes keep the deprecated 1.0.503 wire and emit `eventId`. Keys are\n   * sorted so a declared `[\"eventId\"]` partition stays byte-identical with the\n   * 1.0.503 wire.\n   * @param {?} record - Sync/change record.\n   * @returns {Record<string, unknown>} Default serialized row.\n   */\n  defaultSerializeRecord(record) {\n    const scopeAttributes = declaredSyncScopeAttributes(this.modelClass)\n    /** @type {Record<string, unknown>} */\n    const serialized = {\n      data: this.recordData(record),\n      id: this.recordValue(record, \"id\"),\n      resourceId: this.recordValue(record, \"resourceId\"),\n      resourceType: this.recordValue(record, \"resourceType\"),\n      serverSequence: this.recordValue(record, \"serverSequence\"),\n      syncType: this.recordValue(record, \"syncType\"),\n      updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))\n    }\n\n    for (const scopeAttribute of scopeAttributes || [\"eventId\"]) {\n      serialized[scopeAttribute] = this.recordValue(record, scopeAttribute)\n    }\n\n    return Object.fromEntries(Object.entries(serialized).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)))\n  }\n\n  /**\n   * Reads and parses the record data payload.\n   * @param {?} record - Sync/change record.\n   * @returns {unknown} Parsed data value.\n   */\n  recordData(record) {\n    const data = this.recordValue(record, \"data\")\n\n    if (data === \"\" || data === null || data === undefined) return null\n    if (typeof data !== \"string\") return data\n\n    return JSON.parse(data)\n  }\n\n  /**\n   * Reads a value from either a record accessor method or plain property.\n   * @param {?} record - Sync/change record.\n   * @param {string} name - Camel-cased value/method name.\n   * @returns {unknown} Record value.\n   */\n  recordValue(record, name) {\n    if (!record || typeof record !== \"object\") {\n      throw new Error(\"Sync changes row must be an object.\")\n    }\n\n    const recordObject = /** @type {Record<string, ?>} */ (record)\n    const method = recordObject[name]\n    const value = typeof method === \"function\" ? method.call(record) : method\n\n    if (value === undefined) {\n      throw new Error(`Sync changes row is missing ${name}.`)\n    }\n\n    return value\n  }\n\n  /**\n   * Converts a date-like value to an ISO string.\n   * @param {Date | string | null | undefined | unknown} value - Date value.\n   * @returns {string} ISO date.\n   */\n  isoDate(value) {\n    const date = value instanceof Date ? value : new Date(typeof value === \"string\" || typeof value === \"number\" ? value : 0)\n\n    if (Number.isNaN(date.getTime())) {\n      throw VelociousError.safe(\"Sync changes row has an invalid updated_at value.\", {code: \"sync-invalid-changes-row\"})\n    }\n\n    return date.toISOString()\n  }\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-model-change-feed-service.js","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nimport {declaredSyncScopeAttributes} from \"./sync-scope-attributes.js\"\n\n/**\n * Generic cursor-paginated change feed over an app-owned sync/change model.\n *\n * Apps provide the model and optional scoping/serialization hooks. Velocious owns\n * cursor parsing, snapshot high-water resolution, stable ordering, page limits,\n * and response shape for `/velocious/sync/changes` style endpoints.\n */\nexport default class SyncModelChangeFeedService {\n  /**\n   * Creates a generic sync-model change-feed service.\n   * @param {object} args - Service arguments.\n   * @param {typeof import(\"../database/record/index.js\").default} args.modelClass - Sync/change model class.\n   * @param {Record<string, unknown>} args.params - Request params.\n   * @param {number} [args.defaultLimit] - Default page size.\n   * @param {number} [args.maxLimit] - Maximum page size.\n   * @param {(record: ?) => Record<string, unknown>} [args.serializeRecord] - Record serializer.\n   * @param {function({query: import(\"../database/query/model-class-query.js\").default}): void} [args.scopeQuery] - Applies app-owned visibility scope.\n   */\n  constructor({defaultLimit = 1000, maxLimit = 1000, modelClass, params, scopeQuery, serializeRecord}) {\n    this.defaultLimit = defaultLimit\n    this.maxLimit = maxLimit\n    this.modelClass = modelClass\n    this.params = params\n    this.scopeQuery = scopeQuery || null\n    this.serializeRecord = serializeRecord || ((record) => this.defaultSerializeRecord(record))\n  }\n\n  /**\n   * Builds a stable change-feed page. The additive `total` is the scope's pending\n   * change count from the request cursor to the snapshot bound (a COUNT, not a\n   * materialized read), so a client can render a \"synced of total\" progress bar;\n   * older clients ignore it.\n   * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.\n   */\n  async changes() {\n    const limit = this.normalizedLimit(this.params.limit)\n    const upToCursor = await this.resolveUpToCursor()\n\n    if (!upToCursor) return {status: \"success\", nextCursor: null, syncs: [], total: 0, upToCursor: null}\n\n    const total = await this.totalPendingChanges({upToCursor})\n    const query = this.pageQuery({limit, upToCursor})\n    const records = await query.toArray()\n    const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor\n\n    return {\n      status: \"success\",\n      nextCursor,\n      syncs: records.map((record) => this.serializeRecord(record)),\n      total,\n      upToCursor\n    }\n  }\n\n  /**\n   * Normalizes the requested page limit.\n   * @param {unknown} value - Raw limit param.\n   * @returns {number} Normalized page limit.\n   */\n  normalizedLimit(value) {\n    if (value === undefined || value === null || value === \"\") return this.defaultLimit\n\n    const limit = Number(value)\n\n    if (!Number.isSafeInteger(limit) || limit <= 0) {\n      throw VelociousError.safe(\"Sync changes limit must be a positive integer.\", {code: \"sync-invalid-changes-limit\"})\n    }\n\n    return Math.min(limit, this.maxLimit)\n  }\n\n  /**\n   * Parses an optional positive integer cursor field.\n   * @param {unknown} value - Raw integer param.\n   * @param {string} name - Param name for error messages.\n   * @returns {number | null} Positive integer value, or null when omitted.\n   */\n  optionalPositiveIntegerParam(value, name) {\n    if (value === undefined || value === null || value === \"\") return null\n\n    const integer = Number(value)\n\n    if (!Number.isSafeInteger(integer) || integer <= 0) {\n      throw VelociousError.safe(`${name} must be a positive integer.`, {code: \"sync-invalid-changes-cursor\"})\n    }\n\n    return integer\n  }\n\n  /**\n   * Resolves the high-water cursor that bounds the current feed page.\n   * @returns {Promise<{id: string, serverSequence: number, updatedAt: string} | null>} Snapshot upper-bound cursor.\n   */\n  async resolveUpToCursor() {\n    const upToServerSequence = this.optionalPositiveIntegerParam(this.params.upToServerSequence, \"upToServerSequence\")\n\n    if (upToServerSequence !== null && typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      return {id: this.params.upToId, serverSequence: upToServerSequence, updatedAt: this.params.upToUpdatedAt}\n    }\n\n    if (typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      const upToRecord = await this.modelClass.findBy({id: this.params.upToId})\n\n      if (upToRecord) return this.cursorForRecord(upToRecord)\n    }\n\n    const query = this.scopedQuery()\n    const table = query.driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = query.driver.quoteColumn(\"server_sequence\")\n    const latestRecords = await query\n      .order(`${table}.${serverSequenceColumn} DESC`)\n      .limit(1)\n      .toArray()\n\n    if (latestRecords.length === 0) return null\n\n    return this.cursorForRecord(latestRecords[0])\n  }\n\n  /**\n   * Builds the ordered and cursor-filtered page query.\n   * @param {{limit: number, upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Page query args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Page query.\n   */\n  pageQuery({limit, upToCursor}) {\n    const query = this.cursorFilteredQuery({upToCursor})\n    const driver = query.driver\n    const serverSequenceColumn = `${driver.quoteTable(this.modelClass.tableName())}.${driver.quoteColumn(\"server_sequence\")}`\n\n    return query\n      .order(`${serverSequenceColumn} ASC`)\n      .limit(limit)\n  }\n\n  /**\n   * Counts the scope's pending change rows from the request cursor to the snapshot\n   * bound without materializing them, so the client can render a stable \"of Y\"\n   * progress denominator.\n   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Count args.\n   * @returns {Promise<number>} Pending change count from the request cursor.\n   */\n  async totalPendingChanges({upToCursor}) {\n    return await this.cursorFilteredQuery({upToCursor}).count()\n  }\n\n  /**\n   * Builds a scoped query with the snapshot upper bound and after-cursor filters\n   * applied, but without ordering or a page limit. Shared by the page read and the\n   * total-count so both count the same set of rows.\n   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Filter args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Cursor-filtered query.\n   */\n  cursorFilteredQuery({upToCursor}) {\n    const query = this.scopedQuery()\n    const driver = query.driver\n    const table = driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = `${table}.${driver.quoteColumn(\"server_sequence\")}`\n    const updatedAtColumn = `${table}.${driver.quoteColumn(\"updated_at\")}`\n    const idColumn = `${table}.${driver.quoteColumn(\"id\")}`\n\n    query.where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)\n\n    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, \"afterServerSequence\")\n\n    if (afterServerSequence !== null) {\n      query.where(`${serverSequenceColumn} > ${driver.quote(afterServerSequence)}`)\n    } else if (typeof this.params.afterUpdatedAt === \"string\" && this.params.afterUpdatedAt !== \"\") {\n      const isPagingExistingSnapshot = typeof this.params.upToUpdatedAt === \"string\" && this.params.upToUpdatedAt !== \"\" && typeof this.params.upToId === \"string\" && this.params.upToId !== \"\"\n\n      if (isPagingExistingSnapshot && typeof this.params.afterId === \"string\" && this.params.afterId !== \"\") {\n        query.where(`(${updatedAtColumn} > ${driver.quote(this.params.afterUpdatedAt)} OR (${updatedAtColumn} = ${driver.quote(this.params.afterUpdatedAt)} AND ${idColumn} > ${driver.quote(this.params.afterId)}))`)\n      } else {\n        query.where(`${updatedAtColumn} >= ${driver.quote(this.params.afterUpdatedAt)}`)\n      }\n    }\n\n    return query\n  }\n\n  /**\n   * Builds a base query with app-owned scope applied.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Scoped base query.\n   */\n  scopedQuery() {\n    const query = this.modelClass.where({})\n\n    if (this.scopeQuery) this.scopeQuery({query})\n\n    return query\n  }\n\n  /**\n   * Serializes a record into a transport cursor.\n   * @param {?} record - Sync/change record.\n   * @returns {{id: string, serverSequence: number, updatedAt: string}} Cursor for row.\n   */\n  cursorForRecord(record) {\n    return {id: String(this.recordValue(record, \"id\")), serverSequence: Number(this.recordValue(record, \"serverSequence\")), updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))}\n  }\n\n  /**\n   * Serializes a record using the standard sync envelope shape plus the sync\n   * model's declared scope-partition attributes (`static syncScopeAttributes`),\n   * each emitted under its own attribute name. Models declaring no scope\n   * attributes keep the deprecated 1.0.503 wire and emit `eventId`. Keys are\n   * sorted so a declared `[\"eventId\"]` partition stays byte-identical with the\n   * 1.0.503 wire.\n   * @param {?} record - Sync/change record.\n   * @returns {Record<string, unknown>} Default serialized row.\n   */\n  defaultSerializeRecord(record) {\n    const scopeAttributes = declaredSyncScopeAttributes(this.modelClass)\n    /** @type {Record<string, unknown>} */\n    const serialized = {\n      data: this.recordData(record),\n      id: this.recordValue(record, \"id\"),\n      resourceId: this.recordValue(record, \"resourceId\"),\n      resourceType: this.recordValue(record, \"resourceType\"),\n      serverSequence: this.recordValue(record, \"serverSequence\"),\n      syncType: this.recordValue(record, \"syncType\"),\n      updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))\n    }\n\n    for (const scopeAttribute of scopeAttributes || [\"eventId\"]) {\n      serialized[scopeAttribute] = this.recordValue(record, scopeAttribute)\n    }\n\n    return Object.fromEntries(Object.entries(serialized).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)))\n  }\n\n  /**\n   * Reads and parses the record data payload.\n   * @param {?} record - Sync/change record.\n   * @returns {unknown} Parsed data value.\n   */\n  recordData(record) {\n    const data = this.recordValue(record, \"data\")\n\n    if (data === \"\" || data === null || data === undefined) return null\n    if (typeof data !== \"string\") return data\n\n    return JSON.parse(data)\n  }\n\n  /**\n   * Reads a value from either a record accessor method or plain property.\n   * @param {?} record - Sync/change record.\n   * @param {string} name - Camel-cased value/method name.\n   * @returns {unknown} Record value.\n   */\n  recordValue(record, name) {\n    if (!record || typeof record !== \"object\") {\n      throw new Error(\"Sync changes row must be an object.\")\n    }\n\n    const recordObject = /** @type {Record<string, ?>} */ (record)\n    const method = recordObject[name]\n    const value = typeof method === \"function\" ? method.call(record) : method\n\n    if (value === undefined) {\n      throw new Error(`Sync changes row is missing ${name}.`)\n    }\n\n    return value\n  }\n\n  /**\n   * Converts a date-like value to an ISO string.\n   * @param {Date | string | null | undefined | unknown} value - Date value.\n   * @returns {string} ISO date.\n   */\n  isoDate(value) {\n    const date = value instanceof Date ? value : new Date(typeof value === \"string\" || typeof value === \"number\" ? value : 0)\n\n    if (Number.isNaN(date.getTime())) {\n      throw VelociousError.safe(\"Sync changes row has an invalid updated_at value.\", {code: \"sync-invalid-changes-row\"})\n    }\n\n    return date.toISOString()\n  }\n}\n\n"]}

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

@@ -49,9 +49,17 @@
  * @property {SyncCursor | Record<string, ?>} [nextCursor] - Next cursor.
  * @property {string} [status] - Response status.
  * @property {Array<unknown>} [syncs] - Sync rows.
+ * @property {number} [total] - Total pending change count for the scope from the request cursor (additive; absent on older servers).
  * @property {SyncCursor | Record<string, ?>} [upToCursor] - Snapshot upper-bound cursor.
  */
 
+/**
+ * @typedef {object} SyncPullProgress
+ * @property {number} pages - Applied page count so far.
+ * @property {number} syncedCount - Applied row count so far.
+ * @property {number} total - Total pending change count for the pull, stable across pages (0 when nothing to sync, null-free once the server reports it).
+ */
+
 /**
  * @typedef {object} SyncChangesResult
  * @property {boolean} changed - Whether any local record changed.
@@ -59,6 +67,7 @@
  * @property {Record<string, boolean>} resourceChanged - Changed flags by resource type.
  * @property {Record<string, number>} resourceCounts - Applied counts by resource type.
  * @property {number} syncedCount - Applied row count.
+ * @property {number} total - Total pending change count across the pulled scopes (the "of Y" denominator for a syncedCount-of-total progress bar).
  */
 
 /**

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

@@ -57,7 +57,7 @@ export default class SyncApiClient {
    * @param {string} args.cursorKey - Cursor option key.
    * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
    * @param {Record<string, SyncResourceConfig>} args.resources - Resource policies.
-   * @param {(progress: {pages: number, syncedCount: number}) => void} [args.onProgress] - Progress callback.
+   * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [args.onProgress] - Progress callback.
    * @returns {Promise<SyncChangesResult>} Pull result.
    */
   static async pullChangesWithCursor(args) {
@@ -108,7 +108,7 @@ export default class SyncApiClient {
    * @param {(cursor: SyncCursor) => Promise<void>} args.saveCursor - Persists the final acknowledged cursor.
    * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
    * @param {(sync: SyncChangeEnvelope) => Promise<SyncChangeApplyResult>} args.applySync - Applies one normalized sync row locally.
-   * @param {(progress: {pages: number, syncedCount: number}) => void} [args.onProgress] - Progress callback.
+   * @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.
    * @returns {Promise<SyncChangesResult>} Pull result.
    */
   static async pullChanges(args) {
@@ -116,6 +116,7 @@ export default class SyncApiClient {
     let upToCursor = null
     let pages = 0
     let syncedCount = 0
+    let total = 0
     let changed = false
     const resourceCounts = /** @type {Record<string, number>} */ ({})
     const resourceChanged = /** @type {Record<string, boolean>} */ ({})
@@ -126,7 +127,21 @@ export default class SyncApiClient {
       const syncs = changesResponse.syncs
 
       if (!upToCursor) upToCursor = changesResponse.upToCursor
-      if (syncs.length === 0) break
+
+      // The server counts pending rows from this request's cursor, so already-applied
+      // pages plus this request's count stays the same total across every page: a stable
+      // "of Y" denominator even as the cursor advances. A server that doesn't report the
+      // count at all leaves the total at 0 for every page rather than drifting upwards
+      // with the applied rows.
+      if (changesResponse.total !== null) total = syncedCount + changesResponse.total
+
+      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.
+        if (pages === 0 && args.onProgress) args.onProgress({pages, syncedCount, total})
+
+        break
+      }
 
       pages += 1
 
@@ -151,13 +166,13 @@ export default class SyncApiClient {
 
       afterCursor = changesResponse.nextCursor
 
-      if (args.onProgress) args.onProgress({pages, syncedCount})
+      if (args.onProgress) args.onProgress({pages, syncedCount, total})
       if (syncs.length < batchSize) break
     }
 
     if (afterCursor) await args.saveCursor(afterCursor)
 
-    return {changed, pages, resourceChanged, resourceCounts, syncedCount}
+    return {changed, pages, resourceChanged, resourceCounts, syncedCount, total}
   }
 
   /**
@@ -168,7 +183,7 @@ export default class SyncApiClient {
    * @param {number} args.batchSize - Page size.
    * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Changes poster.
    * @param {SyncCursor} args.upToCursor - Snapshot upper-bound cursor.
-   * @returns {Promise<{nextCursor: SyncCursor, syncs: SyncChangeEnvelope[], upToCursor: SyncCursor}>} Normalized changes page.
+   * @returns {Promise<{nextCursor: SyncCursor, syncs: SyncChangeEnvelope[], total: number | null, upToCursor: SyncCursor}>} Normalized changes page.
    */
   static async changesPage({afterCursor, authenticationToken, batchSize, postChanges, upToCursor}) {
     const response = await postChanges({
@@ -185,6 +200,7 @@ export default class SyncApiClient {
     return {
       nextCursor: this.syncCursorFromPayload(response.nextCursor ?? null),
       syncs: syncs.map((syncPayload) => this.syncEnvelopeFromPayload(syncPayload)),
+      total: optionalInteger(response.total),
       upToCursor: this.syncCursorFromPayload(response.upToCursor ?? null)
     }
   }

package/build/sync/sync-client.js

@@ -356,9 +356,11 @@ export default class SyncClient {
   /**
    * Declares (or re-activates) a sync scope from a model query and pulls it when online.
    * @param {import("../database/query/model-class-query.js").default<?>} query - Query declaring the sync scope.
+   * @param {object} [options] - Sync options.
+   * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [options.onProgress] - Called per applied page of the pull this declaration triggers, so the initial import of a newly declared scope can drive a "syncedCount of total" progress bar. See `pull()`.
    * @returns {Promise<{scope: import("./sync-client-types.js").SerializedSyncScope, pulled: import("./sync-api-client-types.js").SyncChangesResult | null}>} Declared scope and pull result (null while offline).
    */
-  async sync(query) {
+  async sync(query, {onProgress} = {}) {
     const scope = serializedScopeFromQuery(query)
     const scopeStore = this.scopeStore()
     const scopeRow = await scopeStore.findOrCreateScope(scope)
@@ -370,7 +372,7 @@ export default class SyncClient {
       if (legacyCursor) await scopeStore.saveCursor(scopeRow, legacyCursor)
     }
 
-    return {pulled: await this.pull(), scope}
+    return {pulled: await this.pull({onProgress}), scope}
   }
 
   /**
@@ -384,9 +386,11 @@ export default class SyncClient {
 
   /**
    * Pulls changes for every active scope with per-scope cursors (single-flighted, online-gated).
+   * @param {object} [options] - Pull options.
+   * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [options.onProgress] - Called per applied page with cumulative `{pages, syncedCount, total}` across the pulled scopes, for rendering a "syncedCount of total" progress bar (e.g. a full-import screen). Optional; omitting it keeps the existing behavior.
    * @returns {Promise<import("./sync-api-client-types.js").SyncChangesResult | null>} Combined pull result, or null while offline.
    */
-  async pull() {
+  async pull({onProgress} = {}) {
     if (!(await this.isOnline())) return null
 
     /** @type {import("./sync-api-client-types.js").SyncChangesResult | null} */
@@ -401,15 +405,27 @@ export default class SyncClient {
         pages: 0,
         resourceChanged: /** @type {Record<string, boolean>} */ ({}),
         resourceCounts: /** @type {Record<string, number>} */ ({}),
-        syncedCount: 0
+        syncedCount: 0,
+        total: 0
       }
 
       for (const scopeRow of await scopeStore.activeScopes()) {
+        // Cumulate scope progress onto the counts of the scopes already pulled so a single
+        // scope's per-page progress reads exactly its own counts (base 0), and multi-scope
+        // pulls report a running cumulative total across every scope.
+        const basePages = result.pages
+        const baseSyncedCount = result.syncedCount
+        const baseTotal = result.total
         const scopeResult = await SyncApiClient.pullChanges({
           applySync,
           authenticationToken,
           batchSize: this.config.batchSize,
           loadCursor: async () => await scopeStore.loadCursor(scopeRow),
+          onProgress: onProgress ? (progress) => onProgress({
+            pages: basePages + progress.pages,
+            syncedCount: baseSyncedCount + progress.syncedCount,
+            total: baseTotal + progress.total
+          }) : undefined,
           postChanges: async (payload) => await this.config.postChanges({
             ...payload,
             scope: {conditions: scopeRow.conditions, resourceType: scopeRow.resourceType}
@@ -420,6 +436,7 @@ export default class SyncClient {
         result.changed ||= scopeResult.changed
         result.pages += scopeResult.pages
         result.syncedCount += scopeResult.syncedCount
+        result.total += scopeResult.total
 
         for (const [resourceType, count] of Object.entries(scopeResult.resourceCounts)) {
           result.resourceCounts[resourceType] = (result.resourceCounts[resourceType] || 0) + count

package/build/sync/sync-model-change-feed-service.js

@@ -32,15 +32,19 @@ export default class SyncModelChangeFeedService {
   }
 
   /**
-   * Builds a stable change-feed page.
-   * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
+   * Builds a stable change-feed page. The additive `total` is the scope's pending
+   * change count from the request cursor to the snapshot bound (a COUNT, not a
+   * materialized read), so a client can render a "synced of total" progress bar;
+   * older clients ignore it.
+   * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, total: number, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
    */
   async changes() {
     const limit = this.normalizedLimit(this.params.limit)
     const upToCursor = await this.resolveUpToCursor()
 
-    if (!upToCursor) return {status: "success", nextCursor: null, syncs: [], upToCursor: null}
+    if (!upToCursor) return {status: "success", nextCursor: null, syncs: [], total: 0, upToCursor: null}
 
+    const total = await this.totalPendingChanges({upToCursor})
     const query = this.pageQuery({limit, upToCursor})
     const records = await query.toArray()
     const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor
@@ -49,6 +53,7 @@ export default class SyncModelChangeFeedService {
       status: "success",
       nextCursor,
       syncs: records.map((record) => this.serializeRecord(record)),
+      total,
       upToCursor
     }
   }
@@ -124,6 +129,34 @@ export default class SyncModelChangeFeedService {
    * @returns {import("../database/query/model-class-query.js").default} Page query.
    */
   pageQuery({limit, upToCursor}) {
+    const query = this.cursorFilteredQuery({upToCursor})
+    const driver = query.driver
+    const serverSequenceColumn = `${driver.quoteTable(this.modelClass.tableName())}.${driver.quoteColumn("server_sequence")}`
+
+    return query
+      .order(`${serverSequenceColumn} ASC`)
+      .limit(limit)
+  }
+
+  /**
+   * Counts the scope's pending change rows from the request cursor to the snapshot
+   * bound without materializing them, so the client can render a stable "of Y"
+   * progress denominator.
+   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Count args.
+   * @returns {Promise<number>} Pending change count from the request cursor.
+   */
+  async totalPendingChanges({upToCursor}) {
+    return await this.cursorFilteredQuery({upToCursor}).count()
+  }
+
+  /**
+   * Builds a scoped query with the snapshot upper bound and after-cursor filters
+   * applied, but without ordering or a page limit. Shared by the page read and the
+   * total-count so both count the same set of rows.
+   * @param {{upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Filter args.
+   * @returns {import("../database/query/model-class-query.js").default} Cursor-filtered query.
+   */
+  cursorFilteredQuery({upToCursor}) {
     const query = this.scopedQuery()
     const driver = query.driver
     const table = driver.quoteTable(this.modelClass.tableName())
@@ -131,10 +164,7 @@ export default class SyncModelChangeFeedService {
     const updatedAtColumn = `${table}.${driver.quoteColumn("updated_at")}`
     const idColumn = `${table}.${driver.quoteColumn("id")}`
 
-    query
-      .where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)
-      .order(`${serverSequenceColumn} ASC`)
-      .limit(limit)
+    query.where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)
 
     const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, "afterServerSequence")
 

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.513",
+  "version": "1.0.514",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/sync/sync-api-client-types.js

@@ -49,9 +49,17 @@
  * @property {SyncCursor | Record<string, ?>} [nextCursor] - Next cursor.
  * @property {string} [status] - Response status.
  * @property {Array<unknown>} [syncs] - Sync rows.
+ * @property {number} [total] - Total pending change count for the scope from the request cursor (additive; absent on older servers).
  * @property {SyncCursor | Record<string, ?>} [upToCursor] - Snapshot upper-bound cursor.
  */
 
+/**
+ * @typedef {object} SyncPullProgress
+ * @property {number} pages - Applied page count so far.
+ * @property {number} syncedCount - Applied row count so far.
+ * @property {number} total - Total pending change count for the pull, stable across pages (0 when nothing to sync, null-free once the server reports it).
+ */
+
 /**
  * @typedef {object} SyncChangesResult
  * @property {boolean} changed - Whether any local record changed.
@@ -59,6 +67,7 @@
  * @property {Record<string, boolean>} resourceChanged - Changed flags by resource type.
  * @property {Record<string, number>} resourceCounts - Applied counts by resource type.
  * @property {number} syncedCount - Applied row count.
+ * @property {number} total - Total pending change count across the pulled scopes (the "of Y" denominator for a syncedCount-of-total progress bar).
  */
 
 /**

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

@@ -57,7 +57,7 @@ export default class SyncApiClient {
    * @param {string} args.cursorKey - Cursor option key.
    * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
    * @param {Record<string, SyncResourceConfig>} args.resources - Resource policies.
-   * @param {(progress: {pages: number, syncedCount: number}) => void} [args.onProgress] - Progress callback.
+   * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [args.onProgress] - Progress callback.
    * @returns {Promise<SyncChangesResult>} Pull result.
    */
   static async pullChangesWithCursor(args) {
@@ -108,7 +108,7 @@ export default class SyncApiClient {
    * @param {(cursor: SyncCursor) => Promise<void>} args.saveCursor - Persists the final acknowledged cursor.
    * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
    * @param {(sync: SyncChangeEnvelope) => Promise<SyncChangeApplyResult>} args.applySync - Applies one normalized sync row locally.
-   * @param {(progress: {pages: number, syncedCount: number}) => void} [args.onProgress] - Progress callback.
+   * @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.
    * @returns {Promise<SyncChangesResult>} Pull result.
    */
   static async pullChanges(args) {
@@ -116,6 +116,7 @@ export default class SyncApiClient {
     let upToCursor = null
     let pages = 0
     let syncedCount = 0
+    let total = 0
     let changed = false
     const resourceCounts = /** @type {Record<string, number>} */ ({})
     const resourceChanged = /** @type {Record<string, boolean>} */ ({})
@@ -126,7 +127,21 @@ export default class SyncApiClient {
       const syncs = changesResponse.syncs
 
       if (!upToCursor) upToCursor = changesResponse.upToCursor
-      if (syncs.length === 0) break
+
+      // The server counts pending rows from this request's cursor, so already-applied
+      // pages plus this request's count stays the same total across every page: a stable
+      // "of Y" denominator even as the cursor advances. A server that doesn't report the
+      // count at all leaves the total at 0 for every page rather than drifting upwards
+      // with the applied rows.
+      if (changesResponse.total !== null) total = syncedCount + changesResponse.total
+
+      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.
+        if (pages === 0 && args.onProgress) args.onProgress({pages, syncedCount, total})
+
+        break
+      }
 
       pages += 1
 
@@ -151,13 +166,13 @@ export default class SyncApiClient {
 
       afterCursor = changesResponse.nextCursor
 
-      if (args.onProgress) args.onProgress({pages, syncedCount})
+      if (args.onProgress) args.onProgress({pages, syncedCount, total})
       if (syncs.length < batchSize) break
     }
 
     if (afterCursor) await args.saveCursor(afterCursor)
 
-    return {changed, pages, resourceChanged, resourceCounts, syncedCount}
+    return {changed, pages, resourceChanged, resourceCounts, syncedCount, total}
   }
 
   /**
@@ -168,7 +183,7 @@ export default class SyncApiClient {
    * @param {number} args.batchSize - Page size.
    * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Changes poster.
    * @param {SyncCursor} args.upToCursor - Snapshot upper-bound cursor.
-   * @returns {Promise<{nextCursor: SyncCursor, syncs: SyncChangeEnvelope[], upToCursor: SyncCursor}>} Normalized changes page.
+   * @returns {Promise<{nextCursor: SyncCursor, syncs: SyncChangeEnvelope[], total: number | null, upToCursor: SyncCursor}>} Normalized changes page.
    */
   static async changesPage({afterCursor, authenticationToken, batchSize, postChanges, upToCursor}) {
     const response = await postChanges({
@@ -185,6 +200,7 @@ export default class SyncApiClient {
     return {
       nextCursor: this.syncCursorFromPayload(response.nextCursor ?? null),
       syncs: syncs.map((syncPayload) => this.syncEnvelopeFromPayload(syncPayload)),
+      total: optionalInteger(response.total),
       upToCursor: this.syncCursorFromPayload(response.upToCursor ?? null)
     }
   }

package/src/sync/sync-client.js

@@ -356,9 +356,11 @@ export default class SyncClient {
   /**
    * Declares (or re-activates) a sync scope from a model query and pulls it when online.
    * @param {import("../database/query/model-class-query.js").default<?>} query - Query declaring the sync scope.
+   * @param {object} [options] - Sync options.
+   * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [options.onProgress] - Called per applied page of the pull this declaration triggers, so the initial import of a newly declared scope can drive a "syncedCount of total" progress bar. See `pull()`.
    * @returns {Promise<{scope: import("./sync-client-types.js").SerializedSyncScope, pulled: import("./sync-api-client-types.js").SyncChangesResult | null}>} Declared scope and pull result (null while offline).
    */
-  async sync(query) {
+  async sync(query, {onProgress} = {}) {
     const scope = serializedScopeFromQuery(query)
     const scopeStore = this.scopeStore()
     const scopeRow = await scopeStore.findOrCreateScope(scope)
@@ -370,7 +372,7 @@ export default class SyncClient {
       if (legacyCursor) await scopeStore.saveCursor(scopeRow, legacyCursor)
     }
 
-    return {pulled: await this.pull(), scope}
+    return {pulled: await this.pull({onProgress}), scope}
   }
 
   /**
@@ -384,9 +386,11 @@ export default class SyncClient {
 
   /**
    * Pulls changes for every active scope with per-scope cursors (single-flighted, online-gated).
+   * @param {object} [options] - Pull options.
+   * @param {(progress: import("./sync-api-client-types.js").SyncPullProgress) => void} [options.onProgress] - Called per applied page with cumulative `{pages, syncedCount, total}` across the pulled scopes, for rendering a "syncedCount of total" progress bar (e.g. a full-import screen). Optional; omitting it keeps the existing behavior.
    * @returns {Promise<import("./sync-api-client-types.js").SyncChangesResult | null>} Combined pull result, or null while offline.
    */
-  async pull() {
+  async pull({onProgress} = {}) {
     if (!(await this.isOnline())) return null
 
     /** @type {import("./sync-api-client-types.js").SyncChangesResult | null} */
@@ -401,15 +405,27 @@ export default class SyncClient {
         pages: 0,
         resourceChanged: /** @type {Record<string, boolean>} */ ({}),
         resourceCounts: /** @type {Record<string, number>} */ ({}),
-        syncedCount: 0
+        syncedCount: 0,
+        total: 0
       }
 
       for (const scopeRow of await scopeStore.activeScopes()) {
+        // Cumulate scope progress onto the counts of the scopes already pulled so a single
+        // scope's per-page progress reads exactly its own counts (base 0), and multi-scope
+        // pulls report a running cumulative total across every scope.
+        const basePages = result.pages
+        const baseSyncedCount = result.syncedCount
+        const baseTotal = result.total
         const scopeResult = await SyncApiClient.pullChanges({
           applySync,
           authenticationToken,
           batchSize: this.config.batchSize,
           loadCursor: async () => await scopeStore.loadCursor(scopeRow),
+          onProgress: onProgress ? (progress) => onProgress({
+            pages: basePages + progress.pages,
+            syncedCount: baseSyncedCount + progress.syncedCount,
+            total: baseTotal + progress.total
+          }) : undefined,
           postChanges: async (payload) => await this.config.postChanges({
             ...payload,
             scope: {conditions: scopeRow.conditions, resourceType: scopeRow.resourceType}
@@ -420,6 +436,7 @@ export default class SyncClient {
         result.changed ||= scopeResult.changed
         result.pages += scopeResult.pages
         result.syncedCount += scopeResult.syncedCount
+        result.total += scopeResult.total
 
         for (const [resourceType, count] of Object.entries(scopeResult.resourceCounts)) {
           result.resourceCounts[resourceType] = (result.resourceCounts[resourceType] || 0) + count