velocious 1.0.720 → 1.0.722

package/build/src/sync/sync-websocket-channel.js

@@ -1,8 +1,46 @@
 // @ts-check
 import VelociousWebsocketChannel from "../http-server/websocket-channel.js";
 import { VELOCIOUS_SYNC_CHANNEL } from "./sync-channel-name.js";
+import { cursorFromSyncEntry, isCursorAfter } from "./sync-cursor.js";
+import SyncModelChangeFeedService from "./sync-model-change-feed-service.js";
 /** Configurations whose framework sync channel has already been registered. */
 const registeredConfigurations = new WeakSet();
+/** Default catch-up replay page size when the subscriber sends no `limit` param. */
+const DEFAULT_REPLAY_LIMIT = 1000;
+/**
+ * Serializes a cursor into the change-feed request params under the given prefix.
+ * @param {"after" | "upTo"} prefix - Request field prefix.
+ * @param {import("./sync-api-client-types.js").SyncCursor} cursor - Cursor to serialize.
+ * @returns {Record<string, string | number | null>} Serialized cursor params.
+ */
+function cursorParams(prefix, cursor) {
+    if (!cursor)
+        return {};
+    return {
+        [`${prefix}Id`]: cursor.id,
+        ...(cursor.serverSequence !== null ? { [`${prefix}ServerSequence`]: cursor.serverSequence } : {}),
+        [`${prefix}UpdatedAt`]: cursor.updatedAt
+    };
+}
+/**
+ * Reads the after-cursor the subscriber declared in its subscribe params, or null
+ * when it sent none (a fresh subscription replays the whole scope).
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Subscribe params.
+ * @returns {import("./sync-api-client-types.js").SyncCursor} Declared after-cursor, or null.
+ */
+function cursorFromParams(params) {
+    const updatedAt = typeof params.afterUpdatedAt === "string" ? params.afterUpdatedAt : null;
+    if (!updatedAt)
+        return null;
+    const serverSequence = params.afterServerSequence === null || params.afterServerSequence === undefined
+        ? null
+        : Number(params.afterServerSequence);
+    return {
+        id: params.afterId === null || params.afterId === undefined ? null : String(params.afterId),
+        serverSequence,
+        updatedAt
+    };
+}
 /**
  * Framework-owned websocket channel for synced resources
  * ({@link VELOCIOUS_SYNC_CHANNEL}).
@@ -21,6 +59,13 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
      * @type {import("./sync-resource-base.js").SerializedChangesScope | null}
      */
     _scope = null;
+    /**
+     * Cursor of the last sync entry delivered to this subscription, advanced by
+     * live broadcasts and catch-up replay so a resume replays only the rows missed
+     * while the socket was down.
+     * @type {import("./sync-api-client-types.js").SyncCursor}
+     */
+    _deliveredCursor = null;
     /**
      * Registers the framework sync channel on a configuration declaring a
      * `sync.api` block (guarded so repeated server boots with the same
@@ -154,11 +199,14 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
     async deliverBroadcast(body, meta) {
         if (!this._isUserScope()) {
             this.sendMessage(body, meta);
+            this._trackDeliveredCursor(body);
             return;
         }
         const deliverableBody = await this._userScopeDeliverableBody(body);
-        if (deliverableBody !== null)
+        if (deliverableBody !== null) {
             this.sendMessage(deliverableBody, meta);
+            this._trackDeliveredCursor(deliverableBody);
+        }
     }
     /**
      * Whether this subscription is a user scope: authorized with empty conditions
@@ -221,6 +269,94 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
             return { ...envelope, syncs: deliverableSyncs };
         return deliverableSyncs[0];
     }
+    /**
+     * Replays the catch-up backlog to this subscriber once its subscription is
+     * authorized: pages the scoped change feed from the cursor the client declared
+     * in its subscribe params and sends each page as a standard sync envelope, then
+     * live broadcasts continue from there. A fresh subscription with no cursor
+     * replays the whole authorized scope.
+     * @returns {Promise<void>}
+     */
+    async subscribed() {
+        if (!this._scope)
+            return;
+        await this._replayFrom(cursorFromParams(this.params));
+    }
+    /**
+     * Replays rows missed while the socket was down, resuming from the cursor of
+     * the last entry this subscription delivered instead of re-reading the whole
+     * scope from the subscribe-time cursor.
+     * @returns {Promise<void>}
+     */
+    async onResume() {
+        if (!this._scope)
+            return;
+        await this._replayFrom(this._deliveredCursor ?? cursorFromParams(this.params));
+    }
+    /**
+     * Pages the scoped change feed from a cursor and delivers each page to this
+     * subscriber as a `{echoOrigin, syncs}` envelope. The snapshot high-water is
+     * resolved once and pinned across pages so rows arriving mid-replay are left to
+     * the live broadcast path instead of looping the replay. The delivered cursor
+     * advances so a later resume resumes from here.
+     * @param {import("./sync-api-client-types.js").SyncCursor} afterCursor - Cursor to replay after.
+     * @returns {Promise<void>}
+     */
+    async _replayFrom(afterCursor) {
+        const configuration = this.session.configuration;
+        const scope = this._scope;
+        await configuration.ensureConnections({ name: `${VELOCIOUS_SYNC_CHANNEL} catch-up replay` }, async () => {
+            const resource = await this.buildSyncResource();
+            const limit = this._replayLimit(resource);
+            /** @type {import("./sync-api-client-types.js").SyncCursor} */
+            let upToCursor = null;
+            while (true) {
+                const page = await resource.changeFeedService({
+                    params: { ...this.params, ...cursorParams("after", afterCursor), ...(upToCursor ? cursorParams("upTo", upToCursor) : {}) },
+                    scope
+                }).changes();
+                if (!upToCursor)
+                    upToCursor = page.upToCursor;
+                if (page.syncs.length === 0)
+                    break;
+                await this.deliverBroadcast({ echoOrigin: null, syncs: page.syncs });
+                afterCursor = page.nextCursor;
+                if (afterCursor)
+                    this._deliveredCursor = afterCursor;
+                if (page.syncs.length < limit)
+                    break;
+            }
+        });
+    }
+    /**
+     * Resolves the catch-up replay page size from the subscriber's `limit` param
+     * (defaulting to {@link DEFAULT_REPLAY_LIMIT}).
+     * @param {import("./sync-resource-base.js").default} resource - Authorizing sync resource.
+     * @returns {number} Replay page size.
+     */
+    _replayLimit(resource) {
+        return new SyncModelChangeFeedService({ modelClass: resource.syncModelClass(), params: this.params }).normalizedLimit(this.params.limit);
+    }
+    /**
+     * Advances the delivered-cursor watermark from a delivered envelope so a resume
+     * resumes after the newest row actually sent to this subscriber. Broadcasts may
+     * arrive out of order across resources, so each entry only advances the
+     * watermark when it is later than the current one.
+     * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} body - Delivered envelope.
+     * @returns {void}
+     */
+    _trackDeliveredCursor(body) {
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            return;
+        const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body);
+        const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope];
+        for (const entry of syncs) {
+            const syncEntry = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (entry);
+            const cursor = cursorFromSyncEntry(syncEntry);
+            if (cursor && isCursorAfter(cursor, this._deliveredCursor))
+                this._deliveredCursor = cursor;
+        }
+    }
     /**
      * Returns the authorized scope for debug snapshots.
      * @returns {Record<string, ReturnType<typeof JSON.parse>>} Debug-safe subscription details.
@@ -229,4 +365,4 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
         return { scope: this._scope, userScope: this._isUserScope() };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-websocket-channel.js","sourceRoot":"","sources":["../../../src/sync/sync-websocket-channel.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousWebsocketChannel from \"../http-server/websocket-channel.js\"\nimport {VELOCIOUS_SYNC_CHANNEL} from \"./sync-channel-name.js\"\n\n/** Configurations whose framework sync channel has already been registered. */\nconst registeredConfigurations = new WeakSet()\n\n/**\n * Framework-owned websocket channel for synced resources\n * ({@link VELOCIOUS_SYNC_CHANNEL}).\n *\n * Subscribe params mirror a declared pull scope — `{resourceType, conditions}`\n * plus the client-injected `authenticationToken` — and subscribe-time\n * authorization delegates to the app sync resource's existing\n * `authorizeChanges({params, scope})` (the `sync.api.resourceClass`), so apps\n * hook in through the authorization they already declared instead of writing\n * their own channel classes. Broadcast routing matches the publisher's\n * scoping params against the subscription's scope conditions.\n */\nexport default class SyncWebsocketChannel extends VelociousWebsocketChannel {\n  /**\n   * Scope the subscription was authorized for, set by {@link SyncWebsocketChannel#canSubscribe}.\n   * @type {import(\"./sync-resource-base.js\").SerializedChangesScope | null}\n   */\n  _scope = null\n\n  /**\n   * Registers the framework sync channel on a configuration declaring a\n   * `sync.api` block (guarded so repeated server boots with the same\n   * configuration register it only once). No-op without `sync.api` — the\n   * channel authorizes through the app's sync resource class.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {void}\n   */\n  static registerFromConfiguration(configuration) {\n    if (!configuration.getSyncConfiguration().api || registeredConfigurations.has(configuration)) return\n\n    registeredConfigurations.add(configuration)\n    configuration.registerWebsocketChannel(VELOCIOUS_SYNC_CHANNEL, this)\n  }\n\n  /**\n   * Authorizes the subscription through the app sync resource: the subscribe\n   * params are parsed into the same serialized scope the changes endpoint\n   * consumes and passed to the resource's `authorizeChanges({params, scope})`.\n   * Denials and malformed scopes throw, rejecting the subscription.\n   * @returns {Promise<boolean>} Whether the subscription is allowed.\n   */\n  async canSubscribe() {\n    const resource = await this.buildSyncResource()\n    const scope = resource.changesScope({scope: {conditions: this.params.conditions, resourceType: this.params.resourceType, resourceTypes: this.params.resourceTypes}})\n\n    await resource.authorizeChanges({params: this.params, scope})\n\n    this._scope = scope\n\n    return true\n  }\n\n  /**\n   * Builds the app sync resource authorizing this subscription, mirroring the\n   * sync transport controller's resource construction with the ability\n   * resolved from the subscribe params (which carry the client-injected\n   * authenticationToken).\n   * @returns {Promise<import(\"./sync-resource-base.js\").default>} App sync resource instance.\n   */\n  async buildSyncResource() {\n    const configuration = this.session.configuration\n    const api = configuration.getSyncConfiguration().api\n\n    if (!api) {\n      throw new Error(`The ${VELOCIOUS_SYNC_CHANNEL} channel requires a sync.api configuration block with the app's sync resource class`)\n    }\n\n    // Narrows the configured resource class to the sync resource contract\n    // (changesScope/authorizeChanges) the sync.api validation requires.\n    const ResourceClass = /** @type {typeof import(\"./sync-resource-base.js\").default} */ (api.resourceClass)\n    // Narrows the websocket subscribe params to the resource params contract.\n    const params = /** @type {import(\"../configuration-types.js\").VelociousParams} */ (/** @type {unknown} */ (this.params))\n    const request = this.session.upgradeRequest\n    const ability = await configuration.resolveAbility({params, request})\n\n    return new ResourceClass({\n      ability,\n      configuration,\n      context: {\n        ...(ability?.getContext() || {}),\n        params,\n        request\n      },\n      locals: ability?.getLocals() || {},\n      modelClass: ResourceClass.ModelClass,\n      modelName: ResourceClass.ModelClass?.name,\n      params,\n      resourceConfiguration: /** @type {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} */ ({\n        attributes: ResourceClass.attributes || {},\n        sync: {enabled: true}\n      })\n    })\n  }\n\n  /**\n   * Routes a publisher broadcast to this subscription when the published\n   * resource type equals the type the subscription was authorized for and the\n   * scoping params satisfy every scope condition: each condition key must be\n   * present in the broadcast params and match by string comparison (array\n   * conditions match by membership). Broadcasts without a resource type and\n   * conditions the publisher's scoping params do not carry never match, so a\n   * subscription cannot receive changes outside its authorized scope.\n   *\n   * The all-types (user) scope declares no single resource type - it subscribes\n   * once for every type it can apply, listed in `scope.resourceTypes` - so it\n   * matches a broadcast of any of those types. Types outside that list are\n   * dropped here, by this cheap check, and never reach the per-delivery access\n   * re-check in {@link SyncWebsocketChannel#_userScopeDeliverableBody}: that\n   * re-check checks out a database connection and runs a query per matched\n   * broadcast, so matching every type would put DB work on every broadcast for\n   * every subscribed device. A broadcast carrying no resource type at all still\n   * never matches.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} broadcastParams - Publisher scoping params (the published resourceType plus the change's scope-partition values).\n   * @returns {boolean} Whether the broadcast belongs to this subscription's scope.\n   */\n  matches(broadcastParams) {\n    const scope = this._scope\n\n    if (!scope) return false\n\n    const scopingParams = broadcastParams && typeof broadcastParams === \"object\" && !Array.isArray(broadcastParams)\n      ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (broadcastParams)\n      : {}\n\n    if (!Object.hasOwn(scopingParams, \"resourceType\")) return false\n\n    if (scope.resourceType === null) {\n      if (scope.resourceTypes && !scope.resourceTypes.some((resourceType) => resourceType === String(scopingParams.resourceType))) return false\n    } else if (String(scopingParams.resourceType) !== String(scope.resourceType)) {\n      return false\n    }\n\n    for (const [conditionName, conditionValue] of Object.entries(scope.conditions)) {\n      if (!Object.hasOwn(scopingParams, conditionName)) return false\n\n      const scopingValue = scopingParams[conditionName]\n\n      if (Array.isArray(conditionValue)) {\n        if (!conditionValue.some((value) => String(value) === String(scopingValue))) return false\n      } else if (String(conditionValue) !== String(scopingValue)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  /**\n   * Delivers a matched broadcast. Scoped subscriptions (with explicit\n   * conditions) already routed through {@link SyncWebsocketChannel#matches}, so\n   * the change is in scope and delivers unchanged. User-scope subscriptions\n   * (empty conditions, \"everything my ability can see\") match every broadcast\n   * of the resource type, so each published change is re-checked against the\n   * subscriber's ability at fan-out through the app sync resource's\n   * `changeDeliverable`; only accessible changes are delivered, and a broadcast\n   * with no accessible change is dropped.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body (sync envelope).\n   * @param {{eventId?: string}} [meta] - Optional event metadata.\n   * @returns {Promise<void>}\n   */\n  async deliverBroadcast(body, meta) {\n    if (!this._isUserScope()) {\n      this.sendMessage(body, meta)\n\n      return\n    }\n\n    const deliverableBody = await this._userScopeDeliverableBody(body)\n\n    if (deliverableBody !== null) this.sendMessage(deliverableBody, meta)\n  }\n\n  /**\n   * Whether this subscription is a user scope: authorized with empty conditions\n   * (\"everything my ability can see\").\n   * @returns {boolean} Whether the subscription is a user scope.\n   */\n  _isUserScope() {\n    return Boolean(this._scope) && Object.keys(/** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope).conditions).length === 0\n  }\n\n  /**\n   * Filters a user-scope broadcast to the sync entries the subscriber's ability\n   * can access, re-checking each through the app sync resource's\n   * `changeDeliverable`. Returns the broadcast narrowed to accessible entries,\n   * or null when none are accessible. Non-envelope bodies and entries without a\n   * resource id are dropped (fail closed).\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body.\n   * @returns {Promise<import(\"../http-server/websocket-channel.js\").WebsocketJsonValue | null>} Deliverable body, or null.\n   */\n  async _userScopeDeliverableBody(body) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) return null\n\n    const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body)\n    const scope = /** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope)\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]\n    const configuration = this.session.configuration\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const deliverableSyncs = []\n\n    // Broadcast fan-out runs through `withoutCurrentConnectionContexts` (see\n    // Configuration#_broadcastToChannelLocal), so there is no ambient database\n    // connection here. Resolve the resource's ability and run the per-delivery\n    // access query inside a checked-out connection context, mirroring how other\n    // broadcast-time DB work (the frontend-model channel) obtains connections.\n    await configuration.ensureConnections({name: `${VELOCIOUS_SYNC_CHANNEL} user-scope delivery access check`}, async () => {\n      const resource = await this.buildSyncResource()\n\n      for (const sync of syncs) {\n        const resourceId = sync?.resourceId\n        const resourceType = sync?.resourceType ?? scope.resourceType\n\n        if (resourceId === undefined || resourceId === null) continue\n\n        // Pass the complete broadcast entry through so the app's\n        // changeDeliverable can authorize by exact-row identity (immutable\n        // sync-row id, actor-specific metadata) — concurrent targeted and\n        // shared broadcasts for the same resource identity authorize\n        // independently. Only resourceId/resourceType are normalized to\n        // strings, on a copy so the published entry is never mutated.\n        const syncEntry = {\n          ...sync,\n          resourceId: String(resourceId),\n          resourceType: String(resourceType)\n        }\n\n        if (await resource.changeDeliverable({params: this.params, scope, sync: syncEntry})) {\n          deliverableSyncs.push(sync)\n        }\n      }\n    })\n\n    if (deliverableSyncs.length === 0) return null\n    if (Array.isArray(envelope.syncs)) return {...envelope, syncs: deliverableSyncs}\n\n    return deliverableSyncs[0]\n  }\n\n  /**\n   * Returns the authorized scope for debug snapshots.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} Debug-safe subscription details.\n   */\n  debugSnapshot() {\n    return {scope: this._scope, userScope: this._isUserScope()}\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-websocket-channel.js","sourceRoot":"","sources":["../../../src/sync/sync-websocket-channel.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousWebsocketChannel from \"../http-server/websocket-channel.js\"\nimport {VELOCIOUS_SYNC_CHANNEL} from \"./sync-channel-name.js\"\nimport {cursorFromSyncEntry, isCursorAfter} from \"./sync-cursor.js\"\nimport SyncModelChangeFeedService from \"./sync-model-change-feed-service.js\"\n\n/** Configurations whose framework sync channel has already been registered. */\nconst registeredConfigurations = new WeakSet()\n\n/** Default catch-up replay page size when the subscriber sends no `limit` param. */\nconst DEFAULT_REPLAY_LIMIT = 1000\n\n/**\n * Serializes a cursor into the change-feed request params under the given prefix.\n * @param {\"after\" | \"upTo\"} prefix - Request field prefix.\n * @param {import(\"./sync-api-client-types.js\").SyncCursor} cursor - Cursor to serialize.\n * @returns {Record<string, string | number | null>} Serialized cursor params.\n */\nfunction cursorParams(prefix, cursor) {\n  if (!cursor) return {}\n\n  return {\n    [`${prefix}Id`]: cursor.id,\n    ...(cursor.serverSequence !== null ? {[`${prefix}ServerSequence`]: cursor.serverSequence} : {}),\n    [`${prefix}UpdatedAt`]: cursor.updatedAt\n  }\n}\n\n/**\n * Reads the after-cursor the subscriber declared in its subscribe params, or null\n * when it sent none (a fresh subscription replays the whole scope).\n * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Subscribe params.\n * @returns {import(\"./sync-api-client-types.js\").SyncCursor} Declared after-cursor, or null.\n */\nfunction cursorFromParams(params) {\n  const updatedAt = typeof params.afterUpdatedAt === \"string\" ? params.afterUpdatedAt : null\n\n  if (!updatedAt) return null\n\n  const serverSequence = params.afterServerSequence === null || params.afterServerSequence === undefined\n    ? null\n    : Number(params.afterServerSequence)\n\n  return {\n    id: params.afterId === null || params.afterId === undefined ? null : String(params.afterId),\n    serverSequence,\n    updatedAt\n  }\n}\n\n/**\n * Framework-owned websocket channel for synced resources\n * ({@link VELOCIOUS_SYNC_CHANNEL}).\n *\n * Subscribe params mirror a declared pull scope — `{resourceType, conditions}`\n * plus the client-injected `authenticationToken` — and subscribe-time\n * authorization delegates to the app sync resource's existing\n * `authorizeChanges({params, scope})` (the `sync.api.resourceClass`), so apps\n * hook in through the authorization they already declared instead of writing\n * their own channel classes. Broadcast routing matches the publisher's\n * scoping params against the subscription's scope conditions.\n */\nexport default class SyncWebsocketChannel extends VelociousWebsocketChannel {\n  /**\n   * Scope the subscription was authorized for, set by {@link SyncWebsocketChannel#canSubscribe}.\n   * @type {import(\"./sync-resource-base.js\").SerializedChangesScope | null}\n   */\n  _scope = null\n\n  /**\n   * Cursor of the last sync entry delivered to this subscription, advanced by\n   * live broadcasts and catch-up replay so a resume replays only the rows missed\n   * while the socket was down.\n   * @type {import(\"./sync-api-client-types.js\").SyncCursor}\n   */\n  _deliveredCursor = null\n\n  /**\n   * Registers the framework sync channel on a configuration declaring a\n   * `sync.api` block (guarded so repeated server boots with the same\n   * configuration register it only once). No-op without `sync.api` — the\n   * channel authorizes through the app's sync resource class.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {void}\n   */\n  static registerFromConfiguration(configuration) {\n    if (!configuration.getSyncConfiguration().api || registeredConfigurations.has(configuration)) return\n\n    registeredConfigurations.add(configuration)\n    configuration.registerWebsocketChannel(VELOCIOUS_SYNC_CHANNEL, this)\n  }\n\n  /**\n   * Authorizes the subscription through the app sync resource: the subscribe\n   * params are parsed into the same serialized scope the changes endpoint\n   * consumes and passed to the resource's `authorizeChanges({params, scope})`.\n   * Denials and malformed scopes throw, rejecting the subscription.\n   * @returns {Promise<boolean>} Whether the subscription is allowed.\n   */\n  async canSubscribe() {\n    const resource = await this.buildSyncResource()\n    const scope = resource.changesScope({scope: {conditions: this.params.conditions, resourceType: this.params.resourceType, resourceTypes: this.params.resourceTypes}})\n\n    await resource.authorizeChanges({params: this.params, scope})\n\n    this._scope = scope\n\n    return true\n  }\n\n  /**\n   * Builds the app sync resource authorizing this subscription, mirroring the\n   * sync transport controller's resource construction with the ability\n   * resolved from the subscribe params (which carry the client-injected\n   * authenticationToken).\n   * @returns {Promise<import(\"./sync-resource-base.js\").default>} App sync resource instance.\n   */\n  async buildSyncResource() {\n    const configuration = this.session.configuration\n    const api = configuration.getSyncConfiguration().api\n\n    if (!api) {\n      throw new Error(`The ${VELOCIOUS_SYNC_CHANNEL} channel requires a sync.api configuration block with the app's sync resource class`)\n    }\n\n    // Narrows the configured resource class to the sync resource contract\n    // (changesScope/authorizeChanges) the sync.api validation requires.\n    const ResourceClass = /** @type {typeof import(\"./sync-resource-base.js\").default} */ (api.resourceClass)\n    // Narrows the websocket subscribe params to the resource params contract.\n    const params = /** @type {import(\"../configuration-types.js\").VelociousParams} */ (/** @type {unknown} */ (this.params))\n    const request = this.session.upgradeRequest\n    const ability = await configuration.resolveAbility({params, request})\n\n    return new ResourceClass({\n      ability,\n      configuration,\n      context: {\n        ...(ability?.getContext() || {}),\n        params,\n        request\n      },\n      locals: ability?.getLocals() || {},\n      modelClass: ResourceClass.ModelClass,\n      modelName: ResourceClass.ModelClass?.name,\n      params,\n      resourceConfiguration: /** @type {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} */ ({\n        attributes: ResourceClass.attributes || {},\n        sync: {enabled: true}\n      })\n    })\n  }\n\n  /**\n   * Routes a publisher broadcast to this subscription when the published\n   * resource type equals the type the subscription was authorized for and the\n   * scoping params satisfy every scope condition: each condition key must be\n   * present in the broadcast params and match by string comparison (array\n   * conditions match by membership). Broadcasts without a resource type and\n   * conditions the publisher's scoping params do not carry never match, so a\n   * subscription cannot receive changes outside its authorized scope.\n   *\n   * The all-types (user) scope declares no single resource type - it subscribes\n   * once for every type it can apply, listed in `scope.resourceTypes` - so it\n   * matches a broadcast of any of those types. Types outside that list are\n   * dropped here, by this cheap check, and never reach the per-delivery access\n   * re-check in {@link SyncWebsocketChannel#_userScopeDeliverableBody}: that\n   * re-check checks out a database connection and runs a query per matched\n   * broadcast, so matching every type would put DB work on every broadcast for\n   * every subscribed device. A broadcast carrying no resource type at all still\n   * never matches.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} broadcastParams - Publisher scoping params (the published resourceType plus the change's scope-partition values).\n   * @returns {boolean} Whether the broadcast belongs to this subscription's scope.\n   */\n  matches(broadcastParams) {\n    const scope = this._scope\n\n    if (!scope) return false\n\n    const scopingParams = broadcastParams && typeof broadcastParams === \"object\" && !Array.isArray(broadcastParams)\n      ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (broadcastParams)\n      : {}\n\n    if (!Object.hasOwn(scopingParams, \"resourceType\")) return false\n\n    if (scope.resourceType === null) {\n      if (scope.resourceTypes && !scope.resourceTypes.some((resourceType) => resourceType === String(scopingParams.resourceType))) return false\n    } else if (String(scopingParams.resourceType) !== String(scope.resourceType)) {\n      return false\n    }\n\n    for (const [conditionName, conditionValue] of Object.entries(scope.conditions)) {\n      if (!Object.hasOwn(scopingParams, conditionName)) return false\n\n      const scopingValue = scopingParams[conditionName]\n\n      if (Array.isArray(conditionValue)) {\n        if (!conditionValue.some((value) => String(value) === String(scopingValue))) return false\n      } else if (String(conditionValue) !== String(scopingValue)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  /**\n   * Delivers a matched broadcast. Scoped subscriptions (with explicit\n   * conditions) already routed through {@link SyncWebsocketChannel#matches}, so\n   * the change is in scope and delivers unchanged. User-scope subscriptions\n   * (empty conditions, \"everything my ability can see\") match every broadcast\n   * of the resource type, so each published change is re-checked against the\n   * subscriber's ability at fan-out through the app sync resource's\n   * `changeDeliverable`; only accessible changes are delivered, and a broadcast\n   * with no accessible change is dropped.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body (sync envelope).\n   * @param {{eventId?: string}} [meta] - Optional event metadata.\n   * @returns {Promise<void>}\n   */\n  async deliverBroadcast(body, meta) {\n    if (!this._isUserScope()) {\n      this.sendMessage(body, meta)\n      this._trackDeliveredCursor(body)\n\n      return\n    }\n\n    const deliverableBody = await this._userScopeDeliverableBody(body)\n\n    if (deliverableBody !== null) {\n      this.sendMessage(deliverableBody, meta)\n      this._trackDeliveredCursor(deliverableBody)\n    }\n  }\n\n  /**\n   * Whether this subscription is a user scope: authorized with empty conditions\n   * (\"everything my ability can see\").\n   * @returns {boolean} Whether the subscription is a user scope.\n   */\n  _isUserScope() {\n    return Boolean(this._scope) && Object.keys(/** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope).conditions).length === 0\n  }\n\n  /**\n   * Filters a user-scope broadcast to the sync entries the subscriber's ability\n   * can access, re-checking each through the app sync resource's\n   * `changeDeliverable`. Returns the broadcast narrowed to accessible entries,\n   * or null when none are accessible. Non-envelope bodies and entries without a\n   * resource id are dropped (fail closed).\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body.\n   * @returns {Promise<import(\"../http-server/websocket-channel.js\").WebsocketJsonValue | null>} Deliverable body, or null.\n   */\n  async _userScopeDeliverableBody(body) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) return null\n\n    const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body)\n    const scope = /** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope)\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]\n    const configuration = this.session.configuration\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const deliverableSyncs = []\n\n    // Broadcast fan-out runs through `withoutCurrentConnectionContexts` (see\n    // Configuration#_broadcastToChannelLocal), so there is no ambient database\n    // connection here. Resolve the resource's ability and run the per-delivery\n    // access query inside a checked-out connection context, mirroring how other\n    // broadcast-time DB work (the frontend-model channel) obtains connections.\n    await configuration.ensureConnections({name: `${VELOCIOUS_SYNC_CHANNEL} user-scope delivery access check`}, async () => {\n      const resource = await this.buildSyncResource()\n\n      for (const sync of syncs) {\n        const resourceId = sync?.resourceId\n        const resourceType = sync?.resourceType ?? scope.resourceType\n\n        if (resourceId === undefined || resourceId === null) continue\n\n        // Pass the complete broadcast entry through so the app's\n        // changeDeliverable can authorize by exact-row identity (immutable\n        // sync-row id, actor-specific metadata) — concurrent targeted and\n        // shared broadcasts for the same resource identity authorize\n        // independently. Only resourceId/resourceType are normalized to\n        // strings, on a copy so the published entry is never mutated.\n        const syncEntry = {\n          ...sync,\n          resourceId: String(resourceId),\n          resourceType: String(resourceType)\n        }\n\n        if (await resource.changeDeliverable({params: this.params, scope, sync: syncEntry})) {\n          deliverableSyncs.push(sync)\n        }\n      }\n    })\n\n    if (deliverableSyncs.length === 0) return null\n    if (Array.isArray(envelope.syncs)) return {...envelope, syncs: deliverableSyncs}\n\n    return deliverableSyncs[0]\n  }\n\n  /**\n   * Replays the catch-up backlog to this subscriber once its subscription is\n   * authorized: pages the scoped change feed from the cursor the client declared\n   * in its subscribe params and sends each page as a standard sync envelope, then\n   * live broadcasts continue from there. A fresh subscription with no cursor\n   * replays the whole authorized scope.\n   * @returns {Promise<void>}\n   */\n  async subscribed() {\n    if (!this._scope) return\n\n    await this._replayFrom(cursorFromParams(this.params))\n  }\n\n  /**\n   * Replays rows missed while the socket was down, resuming from the cursor of\n   * the last entry this subscription delivered instead of re-reading the whole\n   * scope from the subscribe-time cursor.\n   * @returns {Promise<void>}\n   */\n  async onResume() {\n    if (!this._scope) return\n\n    await this._replayFrom(this._deliveredCursor ?? cursorFromParams(this.params))\n  }\n\n  /**\n   * Pages the scoped change feed from a cursor and delivers each page to this\n   * subscriber as a `{echoOrigin, syncs}` envelope. The snapshot high-water is\n   * resolved once and pinned across pages so rows arriving mid-replay are left to\n   * the live broadcast path instead of looping the replay. The delivered cursor\n   * advances so a later resume resumes from here.\n   * @param {import(\"./sync-api-client-types.js\").SyncCursor} afterCursor - Cursor to replay after.\n   * @returns {Promise<void>}\n   */\n  async _replayFrom(afterCursor) {\n    const configuration = this.session.configuration\n    const scope = this._scope\n\n    await configuration.ensureConnections({name: `${VELOCIOUS_SYNC_CHANNEL} catch-up replay`}, async () => {\n      const resource = await this.buildSyncResource()\n      const limit = this._replayLimit(resource)\n      /** @type {import(\"./sync-api-client-types.js\").SyncCursor} */\n      let upToCursor = null\n\n      while (true) {\n        const page = await resource.changeFeedService({\n          params: {...this.params, ...cursorParams(\"after\", afterCursor), ...(upToCursor ? cursorParams(\"upTo\", upToCursor) : {})},\n          scope\n        }).changes()\n\n        if (!upToCursor) upToCursor = page.upToCursor\n\n        if (page.syncs.length === 0) break\n\n        await this.deliverBroadcast({echoOrigin: null, syncs: page.syncs})\n\n        afterCursor = page.nextCursor\n        if (afterCursor) this._deliveredCursor = afterCursor\n\n        if (page.syncs.length < limit) break\n      }\n    })\n  }\n\n  /**\n   * Resolves the catch-up replay page size from the subscriber's `limit` param\n   * (defaulting to {@link DEFAULT_REPLAY_LIMIT}).\n   * @param {import(\"./sync-resource-base.js\").default} resource - Authorizing sync resource.\n   * @returns {number} Replay page size.\n   */\n  _replayLimit(resource) {\n    return new SyncModelChangeFeedService({modelClass: resource.syncModelClass(), params: this.params}).normalizedLimit(this.params.limit)\n  }\n\n  /**\n   * Advances the delivered-cursor watermark from a delivered envelope so a resume\n   * resumes after the newest row actually sent to this subscriber. Broadcasts may\n   * arrive out of order across resources, so each entry only advances the\n   * watermark when it is later than the current one.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Delivered envelope.\n   * @returns {void}\n   */\n  _trackDeliveredCursor(body) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) return\n\n    const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body)\n    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]\n\n    for (const entry of syncs) {\n      const syncEntry = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (entry)\n      const cursor = cursorFromSyncEntry(syncEntry)\n\n      if (cursor && isCursorAfter(cursor, this._deliveredCursor)) this._deliveredCursor = cursor\n    }\n  }\n\n  /**\n   * Returns the authorized scope for debug snapshots.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} Debug-safe subscription details.\n   */\n  debugSnapshot() {\n    return {scope: this._scope, userScope: this._isUserScope()}\n  }\n}\n"]}

package/build/sync/sync-cursor.js

@@ -0,0 +1,56 @@
+// @ts-check
+
+/**
+ * @module sync-cursor
+ *
+ * Shared cursor helpers for the sync change feed: building a cursor from a
+ * serialized sync entry and ordering two cursors under the feed's stable order
+ * (server sequence when present, else updated-at then id). The server channel
+ * advances its per-subscription replay watermark with these across out-of-order
+ * live broadcasts, and the realtime bridge advances the persisted scope cursor
+ * monotonically on pushed changes.
+ */
+
+/** @typedef {import("./sync-api-client-types.js").SyncCursor} SyncCursor */
+
+/**
+ * Builds a cursor from a serialized sync entry, or null when the entry carries
+ * no cursor identity (no updated-at).
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} entry - Serialized sync entry.
+ * @returns {SyncCursor} Cursor for the entry, or null.
+ */
+export function cursorFromSyncEntry(entry) {
+  const updatedAt = entry.updatedAt
+
+  if (typeof updatedAt !== "string" || updatedAt === "") return null
+
+  return {
+    id: entry.id === null || entry.id === undefined ? null : String(entry.id),
+    serverSequence: typeof entry.serverSequence === "number" ? entry.serverSequence : null,
+    updatedAt
+  }
+}
+
+/**
+ * Whether one cursor is strictly later than another under the change-feed order.
+ * A sequenced cursor is always later than an unsequenced one; both sequenced
+ * cursors order by server sequence; both unsequenced cursors order by updated-at
+ * then id.
+ * @param {SyncCursor} candidate - Candidate cursor.
+ * @param {SyncCursor} current - Current cursor.
+ * @returns {boolean} Whether the candidate is later.
+ */
+export function isCursorAfter(candidate, current) {
+  if (!candidate) return false
+  if (!current) return true
+
+  if (candidate.serverSequence !== null && current.serverSequence !== null) {
+    return candidate.serverSequence > current.serverSequence
+  }
+  if (candidate.serverSequence !== null) return true
+  if (current.serverSequence !== null) return false
+
+  if (candidate.updatedAt !== current.updatedAt) return candidate.updatedAt > current.updatedAt
+
+  return (candidate.id ?? "") > (current.id ?? "")
+}

package/build/sync/sync-realtime-bridge.js

@@ -5,10 +5,46 @@ import {mergeRemoteRequestContext} from "../remote-request-context.js"
 
 import SyncApiClient from "./sync-api-client.js"
 import {VELOCIOUS_SYNC_CHANNEL} from "./sync-channel-name.js"
+import {cursorFromSyncEntry, isCursorAfter} from "./sync-cursor.js"
 
 /** @typedef {import("../configuration-types.js").VelociousSyncRealtimeChannelDescriptor} VelociousSyncRealtimeChannelDescriptor */
 /** @typedef {import("../configuration-types.js").VelociousSyncRealtimeWebsocketClient} VelociousSyncRealtimeWebsocketClient */
 
+/**
+ * The persisted scope row the bridge carries so it can advance the scope's cursor
+ * on applied pushes. Mirrors the framework-owned scope store row shape.
+ * @typedef {object} SyncRealtimeScopeRow
+ * @property {Record<string, ReturnType<typeof JSON.parse>>} conditions - Scope attribute conditions.
+ * @property {string | null} cursorPayload - Persisted cursor JSON payload.
+ * @property {string} id - Scope row id.
+ * @property {string | null} resourceType - Scope resource type.
+ * @property {string} scopeDigest - Fixed-size scope digest.
+ * @property {string} state - Scope state.
+ * @property {string} storeIdentity - Physical store identity.
+ */
+
+/**
+ * One derived channel subscription carrying its owning scope row (null for legacy
+ * app channels) and the in-memory cursor watermark advanced by applied pushes.
+ * @typedef {object} DerivedSyncChannel
+ * @property {string} channel - Channel name.
+ * @property {import("./sync-api-client-types.js").SyncCursor} cursor - In-memory cursor watermark.
+ * @property {string | null} resourceType - Default resource type for pushed changes.
+ * @property {SyncRealtimeScopeRow | null} scopeRow - Owning scope row, or null for legacy channels.
+ * @property {import("../configuration-types.js").VelociousSyncRealtimeSubscription} subscription - Subscription handle.
+ */
+
+/**
+ * One derived channel to subscribe, carrying its owning scope row and cursor for
+ * framework sync channel subscriptions (null scope row for legacy app channels).
+ * @typedef {object} DerivedSyncChannelDescriptor
+ * @property {string} channel - Channel name.
+ * @property {import("./sync-api-client-types.js").SyncCursor} cursor - In-memory cursor watermark (null for legacy channels).
+ * @property {Record<string, ReturnType<typeof JSON.parse>>} params - Subscribe params (without the framework-injected auth token).
+ * @property {string | null} resourceType - Default resource type for pushed changes.
+ * @property {SyncRealtimeScopeRow | null} scopeRow - Owning scope row, or null for legacy channels.
+ */
+
 /**
  * Derived realtime push bridge for the sync client. Subscribes every declared
  * pull scope to the framework sync channel ({@link VELOCIOUS_SYNC_CHANNEL})
@@ -29,7 +65,7 @@ export default class SyncRealtimeBridge {
    */
   constructor({syncClient}) {
     this.syncClient = syncClient
-    /** @type {Array<{channel: string, resourceType: string | null, subscription: import("../configuration-types.js").VelociousSyncRealtimeSubscription}>} */
+    /** @type {Array<DerivedSyncChannel>} */
     this._channels = []
     /** @type {VelociousSyncRealtimeWebsocketClient | null} */
     this._client = null
@@ -40,8 +76,6 @@ export default class SyncRealtimeBridge {
     /** @type {number} Subscription generation - bumped by unsubscribe so in-flight subscribes detect they became stale. */
     this._generation = 0
     /** @type {Promise<void> | null} */
-    this._scheduledPull = null
-    /** @type {Promise<void> | null} */
     this._subscribePromise = null
     /** @type {"subscribed" | "subscribing" | "unsubscribed"} */
     this._state = "unsubscribed"
@@ -83,7 +117,7 @@ export default class SyncRealtimeBridge {
 
     this._state = "subscribing"
 
-    /** @type {Array<{channel: string, resourceType: string | null, subscription: import("../configuration-types.js").VelociousSyncRealtimeSubscription}>} */
+    /** @type {Array<DerivedSyncChannel>} */
     const channels = []
     /** @type {VelociousSyncRealtimeWebsocketClient | null} */
     let client = null
@@ -154,13 +188,19 @@ export default class SyncRealtimeBridge {
           label: "Sync client request context",
           params: {...channelDescriptor.params, authenticationToken}
         })
-        const subscription = client.subscribeChannel(channelDescriptor.channel, {
-          onMessage: (body) => this.enqueueApply({body, generation, resourceType}),
-          onResume: () => this.schedulePull(generation),
-          params
-        })
+        /** @type {DerivedSyncChannel} */
+        const channel = {
+          channel: channelDescriptor.channel,
+          cursor: channelDescriptor.cursor,
+          resourceType,
+          scopeRow: channelDescriptor.scopeRow,
+          subscription: client.subscribeChannel(channelDescriptor.channel, {
+            onMessage: (body) => this.enqueueApply({body, channel, generation}),
+            params
+          })
+        }
 
-        channels.push({channel: channelDescriptor.channel, resourceType, subscription})
+        channels.push(channel)
       }
 
       await Promise.all(channels.map(({subscription}) => subscription.waitForReady({signal})))
@@ -175,7 +215,6 @@ export default class SyncRealtimeBridge {
       this._client = client
       this._ownsClient = ownsClient
       this._state = "subscribed"
-      this.schedulePull(generation)
     } catch (error) {
       await teardown()
 
@@ -225,12 +264,11 @@ export default class SyncRealtimeBridge {
   }
 
   /**
-   * Awaits all enqueued message applies and any scheduled pull (tests, shutdown flows).
+   * Awaits all enqueued message applies (tests, shutdown flows).
    * @returns {Promise<void>}
    */
   async waitForApplied() {
     await this._applyPromise
-    if (this._scheduledPull) await this._scheduledPull
   }
 
   /**
@@ -266,33 +304,44 @@ export default class SyncRealtimeBridge {
    * model-level static realtime declarations and the config channels callback.
    * Fails loudly when nothing is subscribable.
    * @param {ReturnType<typeof JSON.parse>} context - App context passed to the deprecated channels callback.
-   * @returns {Promise<Array<VelociousSyncRealtimeChannelDescriptor>>} Channel descriptors.
+   * @returns {Promise<Array<DerivedSyncChannelDescriptor>>} Channel descriptors.
    */
   async channelDescriptors(context) {
     const realtime = this.realtimeConfiguration()
-    /** @type {Array<VelociousSyncRealtimeChannelDescriptor>} */
+    /** @type {Array<DerivedSyncChannelDescriptor>} */
     const channelDescriptors = []
 
     for (const scopeRow of await this.syncClient.scopeStore().activeScopes()) {
+      const cursorPayload = await this.syncClient.scopeStore().loadCursor(scopeRow)
+      const cursor = SyncApiClient.syncCursorFromPayload(cursorPayload)
+
       channelDescriptors.push({
         channel: VELOCIOUS_SYNC_CHANNEL,
+        cursor,
         params: {
           conditions: this.attributeNamedConditions(scopeRow),
           resourceType: scopeRow.resourceType,
           // Only the all-types scope carries the type list; a type-declared scope needs none.
-          ...(scopeRow.resourceType === null ? {resourceTypes: this.syncClient.userScopeResourceTypes()} : {})
-        }
+          ...(scopeRow.resourceType === null ? {resourceTypes: this.syncClient.userScopeResourceTypes()} : {}),
+          // Reuse the changes-endpoint cursor fields so the server replays the
+          // catch-up backlog from the scope's persisted cursor on subscribe.
+          ...SyncApiClient.cursorPayload("after", cursor)
+        },
+        resourceType: scopeRow.resourceType,
+        scopeRow
       })
     }
 
     for (const [resourceType, resourceConfig] of Object.entries(this.syncClient.config.resources)) {
       if (!resourceConfig.realtime) continue
 
-      channelDescriptors.push({channel: resourceConfig.realtime.channel, params: resourceConfig.realtime.params, resourceType})
+      channelDescriptors.push({channel: resourceConfig.realtime.channel, cursor: null, params: resourceConfig.realtime.params ?? {}, resourceType, scopeRow: null})
     }
 
     if (realtime?.channels) {
-      channelDescriptors.push(...await realtime.channels(context))
+      const legacyChannels = await realtime.channels(context)
+
+      channelDescriptors.push(...legacyChannels.map((descriptor) => ({channel: descriptor.channel, cursor: null, params: descriptor.params ?? {}, resourceType: descriptor.resourceType ?? null, scopeRow: null})))
     }
 
     if (channelDescriptors.length === 0) {
@@ -341,15 +390,15 @@ export default class SyncRealtimeBridge {
   /**
    * Chains one pushed message onto the serialized apply queue so changes apply
    * in arrival order; failures go to the sync client's error reporting.
-   * @param {{body: ReturnType<typeof JSON.parse>, generation?: number, resourceType: string | null}} args - Message args.
+   * @param {{body: ReturnType<typeof JSON.parse>, channel: DerivedSyncChannel, generation?: number}} args - Message args.
    * @returns {void}
    */
-  enqueueApply({body, generation = this._generation, resourceType}) {
+  enqueueApply({body, channel, generation = this._generation}) {
     this._applyPromise = this._applyPromise.then(async () => {
       if (generation !== this._generation) return
 
       try {
-        await this.applyMessage({body, resourceType})
+        await this.applyMessage({body, channel})
       } catch (error) {
         this.syncClient.reportError(/** @type {Error} */ (error))
       }
@@ -359,11 +408,12 @@ export default class SyncRealtimeBridge {
   /**
    * Applies one pushed message through the derived resource applier: drops
    * own-device messages by echo origin, defaults the channel's resourceType onto
-   * envelopes without one, and fails loudly on unknown resource types.
-   * @param {{body: ReturnType<typeof JSON.parse>, resourceType: string | null}} args - Message args.
+   * envelopes without one, fails loudly on unknown resource types, and advances
+   * the owning scope's cursor so a later replay resumes after the applied rows.
+   * @param {{body: ReturnType<typeof JSON.parse>, channel: DerivedSyncChannel}} args - Message args.
    * @returns {Promise<void>}
    */
-  async applyMessage({body, resourceType}) {
+  async applyMessage({body, channel}) {
     if (!body || typeof body !== "object" || Array.isArray(body)) {
       throw new Error(`Realtime sync messages must be envelope objects, got: ${JSON.stringify(body)}`)
     }
@@ -382,44 +432,40 @@ export default class SyncRealtimeBridge {
     // Coalesce record-change events across the pushed batch so it triggers one live-query re-run.
     await recordChanges.batch(async () => {
       for (const syncPayload of syncPayloads) {
-        const sync = SyncApiClient.syncEnvelopeFromPayload({resourceType, ...syncPayload})
+        const sync = SyncApiClient.syncEnvelopeFromPayload({resourceType: channel.resourceType, ...syncPayload})
 
         await applySync(sync)
       }
     })
+
+    await this.advanceScopeCursor(channel, syncPayloads)
   }
 
   /**
-   * Schedules a coalesced background pull closing offline gaps after
-   * (re)subscription readiness. Resumes arriving while a pull is already
-   * scheduled or in flight coalesce into that pull instead of stacking.
-   * @param {number} [generation] - Subscription generation owning the resume/readiness callback.
-   * @returns {void}
+   * Advances the owning scope's persisted cursor to the newest applied row,
+   * monotonically (never backwards) so an out-of-order or duplicate push cannot
+   * regress the cursor and re-deliver already-applied rows on a later replay.
+   * Legacy channels with no owning scope are skipped.
+   * @param {DerivedSyncChannel} channel - Channel owning the scope.
+   * @param {Array<ReturnType<typeof JSON.parse>>} syncPayloads - Applied sync entries.
+   * @returns {Promise<void>}
    */
-  schedulePull(generation = this._generation) {
-    if (generation !== this._generation) return
-    if (this.realtimeConfiguration()?.pullOnReconnect === false) return
+  async advanceScopeCursor(channel, syncPayloads) {
+    if (!channel.scopeRow) return
 
-    const coordinatorRun = this.syncClient.requestCoordinatorSync("realtime")
+    let latestCursor = channel.cursor
 
-    if (coordinatorRun) {
-      this._scheduledPull ||= coordinatorRun.finally(() => {
-        this._scheduledPull = null
-      })
-      return
+    for (const syncPayload of syncPayloads) {
+      const entry = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (syncPayload)
+      const cursor = cursorFromSyncEntry(entry)
+
+      if (cursor && isCursorAfter(cursor, latestCursor)) latestCursor = cursor
     }
 
-    this._scheduledPull ||= (async () => {
-      try {
-        await this.syncClient.pull()
-      } catch (error) {
-        if (!this.syncClient.isLifecycleAbort(error)) {
-          this.syncClient.reportError(/** @type {Error} */ (error))
-        }
-      } finally {
-        this._scheduledPull = null
-      }
-    })()
+    if (latestCursor && latestCursor !== channel.cursor) {
+      channel.cursor = latestCursor
+      await this.syncClient.scopeStore().saveCursor(channel.scopeRow, latestCursor)
+    }
   }
 }