velocious 1.0.503 → 1.0.504

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

@@ -1,14 +1,19 @@
 // @ts-check
 import SyncApiClient from "./sync-api-client.js";
+import { VELOCIOUS_SYNC_CHANNEL } from "./sync-channel-name.js";
 /** @typedef {import("../configuration-types.js").VelociousSyncRealtimeChannelDescriptor} VelociousSyncRealtimeChannelDescriptor */
 /** @typedef {import("../configuration-types.js").VelociousSyncRealtimeWebsocketClient} VelociousSyncRealtimeWebsocketClient */
 /**
- * Derived realtime push bridge for the sync client. Subscribes the declared
- * websocket channels (config `sync.client.realtime.channels` callback plus
- * model-level `static sync = {realtime: {channel}}` declarations), applies
- * pushed changes through the same derived resource applier as pulls (with echo
- * suppression against tracked re-queueing), drops own-device messages by echo
- * origin, and fires a coalesced `pull()` when subscriptions become ready or
+ * Derived realtime push bridge for the sync client. Subscribes every declared
+ * pull scope to the framework sync channel ({@link VELOCIOUS_SYNC_CHANNEL})
+ * automatically — the subscribe params mirror the scope's
+ * `{resourceType, conditions}` so the server authorizes them through the same
+ * sync resource authorization as pulls — plus any deprecated legacy channels
+ * (config `sync.client.realtime.channels` callback and model-level
+ * `static sync = {realtime: {channel}}` declarations). Pushed changes apply
+ * through the same derived resource applier as pulls (with echo suppression
+ * against tracked re-queueing), own-device messages are dropped by echo
+ * origin, and a coalesced `pull()` fires when subscriptions become ready or
  * resume so offline gaps close.
  */
 export default class SyncRealtimeBridge {
@@ -37,7 +42,7 @@ export default class SyncRealtimeBridge {
      * Subscribes the derived realtime channels (idempotent and single-flighted):
      * an active subscription is kept as-is and a concurrent subscribe awaits the
      * in-flight attempt. Call `unsubscribe()` first to change the context.
-     * @param {?} [context] - App context passed to the `sync.client.realtime.channels` callback (runtime values like eventId).
+     * @param {?} [context] - App context passed to the deprecated `sync.client.realtime.channels` callback (runtime scope values).
      * @returns {Promise<void>}
      */
     async subscribe(context) {
@@ -175,15 +180,24 @@ export default class SyncRealtimeBridge {
         return realtime;
     }
     /**
-     * Derives the channel descriptors to subscribe: model-level static realtime
-     * declarations plus the config channels callback, failing loudly when none exist.
-     * @param {?} context - App context passed to the channels callback.
+     * Derives the channel descriptors to subscribe: one framework sync channel
+     * subscription per declared pull scope (the params mirror the scope's
+     * `{resourceType, conditions}`), plus the deprecated legacy paths —
+     * model-level static realtime declarations and the config channels callback.
+     * Fails loudly when nothing is subscribable.
+     * @param {?} context - App context passed to the deprecated channels callback.
      * @returns {Promise<Array<VelociousSyncRealtimeChannelDescriptor>>} Channel descriptors.
      */
     async channelDescriptors(context) {
         const realtime = this.realtimeConfiguration();
         /** @type {Array<VelociousSyncRealtimeChannelDescriptor>} */
         const channelDescriptors = [];
+        for (const scopeRow of await this.syncClient.scopeStore().activeScopes()) {
+            channelDescriptors.push({
+                channel: VELOCIOUS_SYNC_CHANNEL,
+                params: { conditions: this.attributeNamedConditions(scopeRow), resourceType: scopeRow.resourceType }
+            });
+        }
         for (const [resourceType, resourceConfig] of Object.entries(this.syncClient.config.resources)) {
             if (!resourceConfig.realtime)
                 continue;
@@ -193,10 +207,35 @@ export default class SyncRealtimeBridge {
             channelDescriptors.push(...await realtime.channels(context));
         }
         if (channelDescriptors.length === 0) {
-            throw new Error("subscribeRealtime found no realtime channels - declare sync.client.realtime.channels or static sync = {realtime: {channel}} on a model");
+            throw new Error("subscribeRealtime found no channels to subscribe - declare a sync scope (syncClient().sync(query)) so its framework sync channel subscription can be derived, or the deprecated sync.client.realtime.channels callback");
         }
         return channelDescriptors;
     }
+    /**
+     * Translates a persisted scope's condition keys to the model's attribute
+     * names so the framework channel subscription matches the publisher's
+     * attribute-named scoping params: `serializedScopeFromQuery` persists the
+     * query's model-normalized column names (for example `project_id`), while
+     * scope-partition broadcasts carry attribute names (`projectId`). Keys
+     * without a column mapping are already attribute names and pass through;
+     * scopes on models without a declared sync resource fail loudly because no
+     * attribute mapping exists for them.
+     * @param {{conditions: Record<string, ?>, resourceType: string}} scopeRow - Active scope row.
+     * @returns {Record<string, ?>} Attribute-named scope conditions.
+     */
+    attributeNamedConditions(scopeRow) {
+        const resourceConfig = this.syncClient.config.resources[scopeRow.resourceType];
+        if (!resourceConfig) {
+            throw new Error(`subscribeRealtime can't derive attribute names for the sync scope declared on ${scopeRow.resourceType} - declare static sync on that model so its resource is registered`);
+        }
+        const columnNameToAttributeName = resourceConfig.modelClass.getColumnNameToAttributeNameMap();
+        /** @type {Record<string, ?>} */
+        const conditions = {};
+        for (const [conditionName, conditionValue] of Object.entries(scopeRow.conditions)) {
+            conditions[columnNameToAttributeName[conditionName] || conditionName] = conditionValue;
+        }
+        return conditions;
+    }
     /**
      * Chains one pushed message onto the serialized apply queue so changes apply
      * in arrival order; failures go to the sync client's error reporting.
@@ -259,4 +298,4 @@ export default class SyncRealtimeBridge {
         })();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-realtime-bridge.js","sourceRoot":"","sources":["../../../src/sync/sync-realtime-bridge.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,aAAa,MAAM,sBAAsB,CAAA;AAEhD,mIAAmI;AACnI,+HAA+H;AAE/H;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC;;;OAGG;IACH,YAAY,EAAC,UAAU,EAAC;QACtB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,yJAAyJ;QACzJ,IAAI,CAAC,SAAS,GAAG,EAAE,CAAA;QACnB,0DAA0D;QAC1D,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;QACnB,4BAA4B;QAC5B,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,OAAO,EAAE,CAAA;QACtC,uHAAuH;QACvH,IAAI,CAAC,WAAW,GAAG,CAAC,CAAA;QACpB,mCAAmC;QACnC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAA;QAC1B,mCAAmC;QACnC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAA;QAC7B,4DAA4D;QAC5D,IAAI,CAAC,MAAM,GAAG,cAAc,CAAA;IAC9B,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,SAAS,CAAC,OAAO;QACrB,IAAI,IAAI,CAAC,MAAM,KAAK,YAAY;YAAE,OAAM;QAExC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC5B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;gBAC7D,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAA;YAC/B,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,MAAM,IAAI,CAAC,iBAAiB,CAAA;IAC9B,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,UAAU,CAAC,OAAO;QACtB,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAA;QAEnC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAA;QAE3B,yJAAyJ;QACzJ,MAAM,QAAQ,GAAG,EAAE,CAAA;QACnB,0DAA0D;QAC1D,IAAI,MAAM,GAAG,IAAI,CAAA;QACjB;;;WAGG;QACH,MAAM,QAAQ,GAAG,KAAK,IAAI,EAAE;YAC1B,KAAK,MAAM,EAAC,YAAY,EAAC,IAAI,QAAQ,EAAE,CAAC;gBACtC,YAAY,CAAC,KAAK,EAAE,CAAA;YACtB,CAAC;YAED,IAAI,MAAM;gBAAE,MAAM,MAAM,CAAC,0BAA0B,EAAE,CAAA;QACvD,CAAC,CAAA;QAED,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAA;YAC7C,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;YAEjE,IAAI,UAAU,KAAK,IAAI,CAAC,WAAW;gBAAE,OAAM;YAE3C,MAAM,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,CAAA;YAEtC,IAAI,UAAU,KAAK,IAAI,CAAC,WAAW;gBAAE,OAAM;YAE3C,MAAM,MAAM,CAAC,OAAO,EAAE,CAAA;YAEtB,IAAI,UAAU,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC;gBACpC,MAAM,QAAQ,EAAE,CAAA;gBAChB,OAAM;YACR,CAAC;YAED,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAA;YAE9E,IAAI,UAAU,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC;gBACpC,MAAM,QAAQ,EAAE,CAAA;gBAChB,OAAM;YACR,CAAC;YAED,KAAK,MAAM,iBAAiB,IAAI,kBAAkB,EAAE,CAAC;gBACnD,IAAI,iBAAiB,CAAC,MAAM,IAAI,qBAAqB,IAAI,iBAAiB,CAAC,MAAM,EAAE,CAAC;oBAClF,MAAM,IAAI,KAAK,CAAC,qBAAqB,iBAAiB,CAAC,OAAO,yHAAyH,CAAC,CAAA;gBAC1L,CAAC;gBAED,MAAM,YAAY,GAAG,iBAAiB,CAAC,YAAY,IAAI,IAAI,CAAA;gBAC3D,MAAM,YAAY,GAAG,MAAM,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,OAAO,EAAE;oBACtE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,EAAC,IAAI,EAAE,YAAY,EAAC,CAAC;oBAC5D,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE;oBACnC,MAAM,EAAE,EAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,EAAC;iBAC3D,CAAC,CAAA;gBAEF,QAAQ,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAC,CAAC,CAAA;YACjF,CAAC;YAED,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,YAAY,EAAC,EAAE,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,CAAC,CAAA;YAEhF,IAAI,UAAU,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC;gBACpC,MAAM,QAAQ,EAAE,CAAA;gBAChB,OAAM;YACR,CAAC;YAED,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;YACzB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;YACrB,IAAI,CAAC,MAAM,GAAG,YAAY,CAAA;YAC1B,IAAI,CAAC,YAAY,EAAE,CAAA;QACrB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,QAAQ,EAAE,CAAA;YAEhB,IAAI,UAAU,KAAK,IAAI,CAAC,WAAW;gBAAE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAA;YAEjE,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,WAAW;QACf,IAAI,CAAC,WAAW,IAAI,CAAC,CAAA;QAErB,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAA;QAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAA;QAE3B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAA;QACnB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;QACnB,IAAI,CAAC,MAAM,GAAG,cAAc,CAAA;QAE5B,KAAK,MAAM,EAAC,YAAY,EAAC,IAAI,QAAQ,EAAE,CAAC;YACtC,YAAY,CAAC,KAAK,EAAE,CAAA;QACtB,CAAC;QAED,IAAI,MAAM;YAAE,MAAM,MAAM,CAAC,0BAA0B,EAAE,CAAA;IACvD,CAAC;IAED;;;OAGG;IACH,MAAM;QACJ,OAAO;YACL,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAC,EAAE,EAAE,CAAC,CAAC,EAAC,OAAO,EAAE,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,EAAE,YAAY,EAAC,CAAC,CAAC;YACjI,KAAK,EAAE,IAAI,CAAC,MAAM;SACnB,CAAA;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc;QAClB,MAAM,IAAI,CAAC,aAAa,CAAA;QACxB,IAAI,IAAI,CAAC,cAAc;YAAE,MAAM,IAAI,CAAC,cAAc,CAAA;IACpD,CAAC;IAED;;;OAGG;IACH,qBAAqB;QACnB,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAA;QAEhD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,oGAAoG,CAAC,CAAA;QACvH,CAAC;QAED,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,kBAAkB,CAAC,OAAO;QAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAA;QAC7C,4DAA4D;QAC5D,MAAM,kBAAkB,GAAG,EAAE,CAAA;QAE7B,KAAK,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9F,IAAI,CAAC,cAAc,CAAC,QAAQ;gBAAE,SAAQ;YAEtC,kBAAkB,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAC,CAAC,CAAA;QAC3H,CAAC;QAED,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,kBAAkB,CAAC,IAAI,CAAC,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAA;QAC9D,CAAC;QAED,IAAI,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,wIAAwI,CAAC,CAAA;QAC3J,CAAC;QAED,OAAO,kBAAkB,CAAA;IAC3B,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,EAAC,IAAI,EAAE,YAAY,EAAC;QAC/B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YACtD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,YAAY,CAAC,EAAC,IAAI,EAAE,YAAY,EAAC,CAAC,CAAA;YAC/C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAA;YAC3D,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,YAAY,CAAC,EAAC,IAAI,EAAE,YAAY,EAAC;QACrC,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7D,MAAM,IAAI,KAAK,CAAC,yDAAyD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QAClG,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAA;QAE7C,IAAI,QAAQ,CAAC,WAAW,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YACtF,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAA;YAExD,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,WAAW;gBAAE,OAAM;QACrD,CAAC;QAED,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;QACpE,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,EAAC,MAAM,EAAE,eAAe,EAAC,CAAC,CAAA;QAE5E,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACvC,MAAM,IAAI,GAAG,aAAa,CAAC,uBAAuB,CAAC,EAAC,YAAY,EAAE,GAAG,WAAW,EAAC,CAAC,CAAA;YAElF,MAAM,SAAS,CAAC,IAAI,CAAC,CAAA;QACvB,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,YAAY;QACV,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC,eAAe,KAAK,KAAK;YAAE,OAAM;QAElE,IAAI,CAAC,cAAc,KAAK,CAAC,KAAK,IAAI,EAAE;YAClC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAA;YAC9B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAA;YAC3D,CAAC;oBAAS,CAAC;gBACT,IAAI,CAAC,cAAc,GAAG,IAAI,CAAA;YAC5B,CAAC;QACH,CAAC,CAAC,EAAE,CAAA;IACN,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport SyncApiClient from \"./sync-api-client.js\"\n\n/** @typedef {import(\"../configuration-types.js\").VelociousSyncRealtimeChannelDescriptor} VelociousSyncRealtimeChannelDescriptor */\n/** @typedef {import(\"../configuration-types.js\").VelociousSyncRealtimeWebsocketClient} VelociousSyncRealtimeWebsocketClient */\n\n/**\n * Derived realtime push bridge for the sync client. Subscribes the declared\n * websocket channels (config `sync.client.realtime.channels` callback plus\n * model-level `static sync = {realtime: {channel}}` declarations), applies\n * pushed changes through the same derived resource applier as pulls (with echo\n * suppression against tracked re-queueing), drops own-device messages by echo\n * origin, and fires a coalesced `pull()` when subscriptions become ready or\n * resume so offline gaps close.\n */\nexport default class SyncRealtimeBridge {\n  /**\n   * Builds the bridge for a sync client.\n   * @param {{syncClient: import(\"./sync-client.js\").default}} args - Bridge args.\n   */\n  constructor({syncClient}) {\n    this.syncClient = syncClient\n    /** @type {Array<{channel: string, resourceType: string | null, subscription: import(\"../configuration-types.js\").VelociousSyncRealtimeSubscription}>} */\n    this._channels = []\n    /** @type {VelociousSyncRealtimeWebsocketClient | null} */\n    this._client = null\n    /** @type {Promise<void>} */\n    this._applyPromise = Promise.resolve()\n    /** @type {number} Subscription generation - bumped by unsubscribe so in-flight subscribes detect they became stale. */\n    this._generation = 0\n    /** @type {Promise<void> | null} */\n    this._scheduledPull = null\n    /** @type {Promise<void> | null} */\n    this._subscribePromise = null\n    /** @type {\"subscribed\" | \"subscribing\" | \"unsubscribed\"} */\n    this._state = \"unsubscribed\"\n  }\n\n  /**\n   * Subscribes the derived realtime channels (idempotent and single-flighted):\n   * an active subscription is kept as-is and a concurrent subscribe awaits the\n   * in-flight attempt. Call `unsubscribe()` first to change the context.\n   * @param {?} [context] - App context passed to the `sync.client.realtime.channels` callback (runtime values like eventId).\n   * @returns {Promise<void>}\n   */\n  async subscribe(context) {\n    if (this._state === \"subscribed\") return\n\n    if (!this._subscribePromise) {\n      this._subscribePromise = this._subscribe(context).finally(() => {\n        this._subscribePromise = null\n      })\n    }\n\n    await this._subscribePromise\n  }\n\n  /**\n   * Connects the websocket client, subscribes every derived channel, and waits\n   * for each subscription's server acknowledgement before the gap-closing pull,\n   * so no change can land between the pull and the subscriptions going live.\n   * Locally created resources are only promoted to the bridge once everything\n   * is live; an unsubscribe arriving during any await marks this attempt stale\n   * and it tears its own resources down instead of resubscribing.\n   * @param {?} context - App context passed to the channels callback.\n   * @returns {Promise<void>}\n   */\n  async _subscribe(context) {\n    const generation = this._generation\n\n    this._state = \"subscribing\"\n\n    /** @type {Array<{channel: string, resourceType: string | null, subscription: import(\"../configuration-types.js\").VelociousSyncRealtimeSubscription}>} */\n    const channels = []\n    /** @type {VelociousSyncRealtimeWebsocketClient | null} */\n    let client = null\n    /**\n     * Tears down everything this stale/failed subscribe attempt created itself.\n     * @returns {Promise<void>}\n     */\n    const teardown = async () => {\n      for (const {subscription} of channels) {\n        subscription.close()\n      }\n\n      if (client) await client.disconnectAndStopReconnect()\n    }\n\n    try {\n      const realtime = this.realtimeConfiguration()\n      const channelDescriptors = await this.channelDescriptors(context)\n\n      if (generation !== this._generation) return\n\n      client = await realtime.createClient()\n\n      if (generation !== this._generation) return\n\n      await client.connect()\n\n      if (generation !== this._generation) {\n        await teardown()\n        return\n      }\n\n      const authenticationToken = await this.syncClient.config.authenticationToken()\n\n      if (generation !== this._generation) {\n        await teardown()\n        return\n      }\n\n      for (const channelDescriptor of channelDescriptors) {\n        if (channelDescriptor.params && \"authenticationToken\" in channelDescriptor.params) {\n          throw new Error(`Realtime channel \"${channelDescriptor.channel}\" params must not include authenticationToken - the framework injects the sync.client authenticationToken automatically`)\n        }\n\n        const resourceType = channelDescriptor.resourceType ?? null\n        const subscription = client.subscribeChannel(channelDescriptor.channel, {\n          onMessage: (body) => this.enqueueApply({body, resourceType}),\n          onResume: () => this.schedulePull(),\n          params: {...channelDescriptor.params, authenticationToken}\n        })\n\n        channels.push({channel: channelDescriptor.channel, resourceType, subscription})\n      }\n\n      await Promise.all(channels.map(({subscription}) => subscription.waitForReady()))\n\n      if (generation !== this._generation) {\n        await teardown()\n        return\n      }\n\n      this._channels = channels\n      this._client = client\n      this._state = \"subscribed\"\n      this.schedulePull()\n    } catch (error) {\n      await teardown()\n\n      if (generation === this._generation) this._state = \"unsubscribed\"\n\n      throw error\n    }\n  }\n\n  /**\n   * Closes every channel subscription and disconnects the websocket client\n   * (idempotent). Also marks any in-flight subscribe attempt stale so it tears\n   * itself down instead of finishing the subscription afterwards.\n   * @returns {Promise<void>}\n   */\n  async unsubscribe() {\n    this._generation += 1\n\n    const channels = this._channels\n    const client = this._client\n\n    this._channels = []\n    this._client = null\n    this._state = \"unsubscribed\"\n\n    for (const {subscription} of channels) {\n      subscription.close()\n    }\n\n    if (client) await client.disconnectAndStopReconnect()\n  }\n\n  /**\n   * Reports the bridge subscription state and per-channel readiness.\n   * @returns {{channels: Array<{channel: string, ready: boolean, resourceType: string | null}>, state: \"subscribed\" | \"subscribing\" | \"unsubscribed\"}} Realtime status.\n   */\n  status() {\n    return {\n      channels: this._channels.map(({channel, resourceType, subscription}) => ({channel, ready: subscription.isReady(), resourceType})),\n      state: this._state\n    }\n  }\n\n  /**\n   * Awaits all enqueued message applies and any scheduled pull (tests, shutdown flows).\n   * @returns {Promise<void>}\n   */\n  async waitForApplied() {\n    await this._applyPromise\n    if (this._scheduledPull) await this._scheduledPull\n  }\n\n  /**\n   * Resolves the realtime configuration, failing loudly when it is missing.\n   * @returns {import(\"../configuration-types.js\").VelociousSyncClientRealtimeConfiguration} Realtime configuration.\n   */\n  realtimeConfiguration() {\n    const realtime = this.syncClient.config.realtime\n\n    if (!realtime) {\n      throw new Error(\"subscribeRealtime requires a sync.client.realtime configuration block with a createClient callback\")\n    }\n\n    return realtime\n  }\n\n  /**\n   * Derives the channel descriptors to subscribe: model-level static realtime\n   * declarations plus the config channels callback, failing loudly when none exist.\n   * @param {?} context - App context passed to the channels callback.\n   * @returns {Promise<Array<VelociousSyncRealtimeChannelDescriptor>>} Channel descriptors.\n   */\n  async channelDescriptors(context) {\n    const realtime = this.realtimeConfiguration()\n    /** @type {Array<VelociousSyncRealtimeChannelDescriptor>} */\n    const channelDescriptors = []\n\n    for (const [resourceType, resourceConfig] of Object.entries(this.syncClient.config.resources)) {\n      if (!resourceConfig.realtime) continue\n\n      channelDescriptors.push({channel: resourceConfig.realtime.channel, params: resourceConfig.realtime.params, resourceType})\n    }\n\n    if (realtime.channels) {\n      channelDescriptors.push(...await realtime.channels(context))\n    }\n\n    if (channelDescriptors.length === 0) {\n      throw new Error(\"subscribeRealtime found no realtime channels - declare sync.client.realtime.channels or static sync = {realtime: {channel}} on a model\")\n    }\n\n    return channelDescriptors\n  }\n\n  /**\n   * Chains one pushed message onto the serialized apply queue so changes apply\n   * in arrival order; failures go to the sync client's error reporting.\n   * @param {{body: ?, resourceType: string | null}} args - Message args.\n   * @returns {void}\n   */\n  enqueueApply({body, resourceType}) {\n    this._applyPromise = this._applyPromise.then(async () => {\n      try {\n        await this.applyMessage({body, resourceType})\n      } catch (error) {\n        this.syncClient.reportError(/** @type {Error} */ (error))\n      }\n    })\n  }\n\n  /**\n   * Applies one pushed message through the derived resource applier: drops\n   * own-device messages by echo origin, defaults the channel's resourceType onto\n   * envelopes without one, and fails loudly on unknown resource types.\n   * @param {{body: ?, resourceType: string | null}} args - Message args.\n   * @returns {Promise<void>}\n   */\n  async applyMessage({body, resourceType}) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) {\n      throw new Error(`Realtime sync messages must be envelope objects, got: ${JSON.stringify(body)}`)\n    }\n\n    const realtime = this.realtimeConfiguration()\n\n    if (realtime.localOrigin && body.echoOrigin !== undefined && body.echoOrigin !== null) {\n      const localOrigin = String(await realtime.localOrigin())\n\n      if (String(body.echoOrigin) === localOrigin) return\n    }\n\n    const syncPayloads = Array.isArray(body.syncs) ? body.syncs : [body]\n    const applySync = this.syncClient.remoteApplySync({source: \"remote change\"})\n\n    for (const syncPayload of syncPayloads) {\n      const sync = SyncApiClient.syncEnvelopeFromPayload({resourceType, ...syncPayload})\n\n      await applySync(sync)\n    }\n  }\n\n  /**\n   * Schedules a coalesced background pull closing offline gaps after\n   * (re)subscription readiness. Resumes arriving while a pull is already\n   * scheduled or in flight coalesce into that pull instead of stacking.\n   * @returns {void}\n   */\n  schedulePull() {\n    if (this.realtimeConfiguration().pullOnReconnect === false) return\n\n    this._scheduledPull ||= (async () => {\n      try {\n        await this.syncClient.pull()\n      } catch (error) {\n        this.syncClient.reportError(/** @type {Error} */ (error))\n      } finally {\n        this._scheduledPull = null\n      }\n    })()\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-realtime-bridge.js","sourceRoot":"","sources":["../../../src/sync/sync-realtime-bridge.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport SyncApiClient from \"./sync-api-client.js\"\nimport {VELOCIOUS_SYNC_CHANNEL} from \"./sync-channel-name.js\"\n\n/** @typedef {import(\"../configuration-types.js\").VelociousSyncRealtimeChannelDescriptor} VelociousSyncRealtimeChannelDescriptor */\n/** @typedef {import(\"../configuration-types.js\").VelociousSyncRealtimeWebsocketClient} VelociousSyncRealtimeWebsocketClient */\n\n/**\n * Derived realtime push bridge for the sync client. Subscribes every declared\n * pull scope to the framework sync channel ({@link VELOCIOUS_SYNC_CHANNEL})\n * automatically — the subscribe params mirror the scope's\n * `{resourceType, conditions}` so the server authorizes them through the same\n * sync resource authorization as pulls — plus any deprecated legacy channels\n * (config `sync.client.realtime.channels` callback and model-level\n * `static sync = {realtime: {channel}}` declarations). Pushed changes apply\n * through the same derived resource applier as pulls (with echo suppression\n * against tracked re-queueing), own-device messages are dropped by echo\n * origin, and a coalesced `pull()` fires when subscriptions become ready or\n * resume so offline gaps close.\n */\nexport default class SyncRealtimeBridge {\n  /**\n   * Builds the bridge for a sync client.\n   * @param {{syncClient: import(\"./sync-client.js\").default}} args - Bridge args.\n   */\n  constructor({syncClient}) {\n    this.syncClient = syncClient\n    /** @type {Array<{channel: string, resourceType: string | null, subscription: import(\"../configuration-types.js\").VelociousSyncRealtimeSubscription}>} */\n    this._channels = []\n    /** @type {VelociousSyncRealtimeWebsocketClient | null} */\n    this._client = null\n    /** @type {Promise<void>} */\n    this._applyPromise = Promise.resolve()\n    /** @type {number} Subscription generation - bumped by unsubscribe so in-flight subscribes detect they became stale. */\n    this._generation = 0\n    /** @type {Promise<void> | null} */\n    this._scheduledPull = null\n    /** @type {Promise<void> | null} */\n    this._subscribePromise = null\n    /** @type {\"subscribed\" | \"subscribing\" | \"unsubscribed\"} */\n    this._state = \"unsubscribed\"\n  }\n\n  /**\n   * Subscribes the derived realtime channels (idempotent and single-flighted):\n   * an active subscription is kept as-is and a concurrent subscribe awaits the\n   * in-flight attempt. Call `unsubscribe()` first to change the context.\n   * @param {?} [context] - App context passed to the deprecated `sync.client.realtime.channels` callback (runtime scope values).\n   * @returns {Promise<void>}\n   */\n  async subscribe(context) {\n    if (this._state === \"subscribed\") return\n\n    if (!this._subscribePromise) {\n      this._subscribePromise = this._subscribe(context).finally(() => {\n        this._subscribePromise = null\n      })\n    }\n\n    await this._subscribePromise\n  }\n\n  /**\n   * Connects the websocket client, subscribes every derived channel, and waits\n   * for each subscription's server acknowledgement before the gap-closing pull,\n   * so no change can land between the pull and the subscriptions going live.\n   * Locally created resources are only promoted to the bridge once everything\n   * is live; an unsubscribe arriving during any await marks this attempt stale\n   * and it tears its own resources down instead of resubscribing.\n   * @param {?} context - App context passed to the channels callback.\n   * @returns {Promise<void>}\n   */\n  async _subscribe(context) {\n    const generation = this._generation\n\n    this._state = \"subscribing\"\n\n    /** @type {Array<{channel: string, resourceType: string | null, subscription: import(\"../configuration-types.js\").VelociousSyncRealtimeSubscription}>} */\n    const channels = []\n    /** @type {VelociousSyncRealtimeWebsocketClient | null} */\n    let client = null\n    /**\n     * Tears down everything this stale/failed subscribe attempt created itself.\n     * @returns {Promise<void>}\n     */\n    const teardown = async () => {\n      for (const {subscription} of channels) {\n        subscription.close()\n      }\n\n      if (client) await client.disconnectAndStopReconnect()\n    }\n\n    try {\n      const realtime = this.realtimeConfiguration()\n      const channelDescriptors = await this.channelDescriptors(context)\n\n      if (generation !== this._generation) return\n\n      client = await realtime.createClient()\n\n      if (generation !== this._generation) return\n\n      await client.connect()\n\n      if (generation !== this._generation) {\n        await teardown()\n        return\n      }\n\n      const authenticationToken = await this.syncClient.config.authenticationToken()\n\n      if (generation !== this._generation) {\n        await teardown()\n        return\n      }\n\n      for (const channelDescriptor of channelDescriptors) {\n        if (channelDescriptor.params && \"authenticationToken\" in channelDescriptor.params) {\n          throw new Error(`Realtime channel \"${channelDescriptor.channel}\" params must not include authenticationToken - the framework injects the sync.client authenticationToken automatically`)\n        }\n\n        const resourceType = channelDescriptor.resourceType ?? null\n        const subscription = client.subscribeChannel(channelDescriptor.channel, {\n          onMessage: (body) => this.enqueueApply({body, resourceType}),\n          onResume: () => this.schedulePull(),\n          params: {...channelDescriptor.params, authenticationToken}\n        })\n\n        channels.push({channel: channelDescriptor.channel, resourceType, subscription})\n      }\n\n      await Promise.all(channels.map(({subscription}) => subscription.waitForReady()))\n\n      if (generation !== this._generation) {\n        await teardown()\n        return\n      }\n\n      this._channels = channels\n      this._client = client\n      this._state = \"subscribed\"\n      this.schedulePull()\n    } catch (error) {\n      await teardown()\n\n      if (generation === this._generation) this._state = \"unsubscribed\"\n\n      throw error\n    }\n  }\n\n  /**\n   * Closes every channel subscription and disconnects the websocket client\n   * (idempotent). Also marks any in-flight subscribe attempt stale so it tears\n   * itself down instead of finishing the subscription afterwards.\n   * @returns {Promise<void>}\n   */\n  async unsubscribe() {\n    this._generation += 1\n\n    const channels = this._channels\n    const client = this._client\n\n    this._channels = []\n    this._client = null\n    this._state = \"unsubscribed\"\n\n    for (const {subscription} of channels) {\n      subscription.close()\n    }\n\n    if (client) await client.disconnectAndStopReconnect()\n  }\n\n  /**\n   * Reports the bridge subscription state and per-channel readiness.\n   * @returns {{channels: Array<{channel: string, ready: boolean, resourceType: string | null}>, state: \"subscribed\" | \"subscribing\" | \"unsubscribed\"}} Realtime status.\n   */\n  status() {\n    return {\n      channels: this._channels.map(({channel, resourceType, subscription}) => ({channel, ready: subscription.isReady(), resourceType})),\n      state: this._state\n    }\n  }\n\n  /**\n   * Awaits all enqueued message applies and any scheduled pull (tests, shutdown flows).\n   * @returns {Promise<void>}\n   */\n  async waitForApplied() {\n    await this._applyPromise\n    if (this._scheduledPull) await this._scheduledPull\n  }\n\n  /**\n   * Resolves the realtime configuration, failing loudly when it is missing.\n   * @returns {import(\"../configuration-types.js\").VelociousSyncClientRealtimeConfiguration} Realtime configuration.\n   */\n  realtimeConfiguration() {\n    const realtime = this.syncClient.config.realtime\n\n    if (!realtime) {\n      throw new Error(\"subscribeRealtime requires a sync.client.realtime configuration block with a createClient callback\")\n    }\n\n    return realtime\n  }\n\n  /**\n   * Derives the channel descriptors to subscribe: one framework sync channel\n   * subscription per declared pull scope (the params mirror the scope's\n   * `{resourceType, conditions}`), plus the deprecated legacy paths —\n   * model-level static realtime declarations and the config channels callback.\n   * Fails loudly when nothing is subscribable.\n   * @param {?} context - App context passed to the deprecated channels callback.\n   * @returns {Promise<Array<VelociousSyncRealtimeChannelDescriptor>>} Channel descriptors.\n   */\n  async channelDescriptors(context) {\n    const realtime = this.realtimeConfiguration()\n    /** @type {Array<VelociousSyncRealtimeChannelDescriptor>} */\n    const channelDescriptors = []\n\n    for (const scopeRow of await this.syncClient.scopeStore().activeScopes()) {\n      channelDescriptors.push({\n        channel: VELOCIOUS_SYNC_CHANNEL,\n        params: {conditions: this.attributeNamedConditions(scopeRow), resourceType: scopeRow.resourceType}\n      })\n    }\n\n    for (const [resourceType, resourceConfig] of Object.entries(this.syncClient.config.resources)) {\n      if (!resourceConfig.realtime) continue\n\n      channelDescriptors.push({channel: resourceConfig.realtime.channel, params: resourceConfig.realtime.params, resourceType})\n    }\n\n    if (realtime.channels) {\n      channelDescriptors.push(...await realtime.channels(context))\n    }\n\n    if (channelDescriptors.length === 0) {\n      throw new Error(\"subscribeRealtime found no channels to subscribe - declare a sync scope (syncClient().sync(query)) so its framework sync channel subscription can be derived, or the deprecated sync.client.realtime.channels callback\")\n    }\n\n    return channelDescriptors\n  }\n\n  /**\n   * Translates a persisted scope's condition keys to the model's attribute\n   * names so the framework channel subscription matches the publisher's\n   * attribute-named scoping params: `serializedScopeFromQuery` persists the\n   * query's model-normalized column names (for example `project_id`), while\n   * scope-partition broadcasts carry attribute names (`projectId`). Keys\n   * without a column mapping are already attribute names and pass through;\n   * scopes on models without a declared sync resource fail loudly because no\n   * attribute mapping exists for them.\n   * @param {{conditions: Record<string, ?>, resourceType: string}} scopeRow - Active scope row.\n   * @returns {Record<string, ?>} Attribute-named scope conditions.\n   */\n  attributeNamedConditions(scopeRow) {\n    const resourceConfig = this.syncClient.config.resources[scopeRow.resourceType]\n\n    if (!resourceConfig) {\n      throw new Error(`subscribeRealtime can't derive attribute names for the sync scope declared on ${scopeRow.resourceType} - declare static sync on that model so its resource is registered`)\n    }\n\n    const columnNameToAttributeName = resourceConfig.modelClass.getColumnNameToAttributeNameMap()\n    /** @type {Record<string, ?>} */\n    const conditions = {}\n\n    for (const [conditionName, conditionValue] of Object.entries(scopeRow.conditions)) {\n      conditions[columnNameToAttributeName[conditionName] || conditionName] = conditionValue\n    }\n\n    return conditions\n  }\n\n  /**\n   * Chains one pushed message onto the serialized apply queue so changes apply\n   * in arrival order; failures go to the sync client's error reporting.\n   * @param {{body: ?, resourceType: string | null}} args - Message args.\n   * @returns {void}\n   */\n  enqueueApply({body, resourceType}) {\n    this._applyPromise = this._applyPromise.then(async () => {\n      try {\n        await this.applyMessage({body, resourceType})\n      } catch (error) {\n        this.syncClient.reportError(/** @type {Error} */ (error))\n      }\n    })\n  }\n\n  /**\n   * Applies one pushed message through the derived resource applier: drops\n   * own-device messages by echo origin, defaults the channel's resourceType onto\n   * envelopes without one, and fails loudly on unknown resource types.\n   * @param {{body: ?, resourceType: string | null}} args - Message args.\n   * @returns {Promise<void>}\n   */\n  async applyMessage({body, resourceType}) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) {\n      throw new Error(`Realtime sync messages must be envelope objects, got: ${JSON.stringify(body)}`)\n    }\n\n    const realtime = this.realtimeConfiguration()\n\n    if (realtime.localOrigin && body.echoOrigin !== undefined && body.echoOrigin !== null) {\n      const localOrigin = String(await realtime.localOrigin())\n\n      if (String(body.echoOrigin) === localOrigin) return\n    }\n\n    const syncPayloads = Array.isArray(body.syncs) ? body.syncs : [body]\n    const applySync = this.syncClient.remoteApplySync({source: \"remote change\"})\n\n    for (const syncPayload of syncPayloads) {\n      const sync = SyncApiClient.syncEnvelopeFromPayload({resourceType, ...syncPayload})\n\n      await applySync(sync)\n    }\n  }\n\n  /**\n   * Schedules a coalesced background pull closing offline gaps after\n   * (re)subscription readiness. Resumes arriving while a pull is already\n   * scheduled or in flight coalesce into that pull instead of stacking.\n   * @returns {void}\n   */\n  schedulePull() {\n    if (this.realtimeConfiguration().pullOnReconnect === false) return\n\n    this._scheduledPull ||= (async () => {\n      try {\n        await this.syncClient.pull()\n      } catch (error) {\n        this.syncClient.reportError(/** @type {Error} */ (error))\n      } finally {\n        this._scheduledPull = null\n      }\n    })()\n  }\n}\n"]}

package/build/src/sync/sync-scope-attributes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reads and validates a sync/change model's declared scope-partition
+ * attributes (`static syncScopeAttributes`).
+ *
+ * The declaration names the attribute(s) partitioning the app's sync feed —
+ * the same attribute names client pull scopes use as conditions (for example
+ * `["eventId"]` or `["accountId"]`). The publisher persists them onto every
+ * published sync row and broadcasts them as the framework sync channel's
+ * scoping params, and the change feed serializes them onto every changes row
+ * under their own names. Velocious itself has no built-in partition name.
+ * @param {?} syncModel - Sync/change model class.
+ * @returns {string[] | null} Declared scope attributes, or null when the model declares none.
+ */
+export function declaredSyncScopeAttributes(syncModel: unknown): string[] | null;
+//# sourceMappingURL=sync-scope-attributes.d.ts.map

package/build/src/sync/sync-scope-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-scope-attributes.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-scope-attributes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,uDAHW,OAAC,GACC,MAAM,EAAE,GAAG,IAAI,CAY3B"}

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

@@ -0,0 +1,24 @@
+// @ts-check
+/**
+ * Reads and validates a sync/change model's declared scope-partition
+ * attributes (`static syncScopeAttributes`).
+ *
+ * The declaration names the attribute(s) partitioning the app's sync feed —
+ * the same attribute names client pull scopes use as conditions (for example
+ * `["eventId"]` or `["accountId"]`). The publisher persists them onto every
+ * published sync row and broadcasts them as the framework sync channel's
+ * scoping params, and the change feed serializes them onto every changes row
+ * under their own names. Velocious itself has no built-in partition name.
+ * @param {?} syncModel - Sync/change model class.
+ * @returns {string[] | null} Declared scope attributes, or null when the model declares none.
+ */
+export function declaredSyncScopeAttributes(syncModel) {
+    const declared = syncModel.syncScopeAttributes;
+    if (declared === undefined || declared === null)
+        return null;
+    if (!Array.isArray(declared) || declared.length === 0 || declared.some((attributeName) => typeof attributeName !== "string" || !attributeName)) {
+        throw new Error(`${syncModel.name} static syncScopeAttributes must be a non-empty array of attribute-name strings, got: ${String(declared)}`);
+    }
+    return declared;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/sync/sync-websocket-channel.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Framework-owned websocket channel for synced resources
+ * ({@link VELOCIOUS_SYNC_CHANNEL}).
+ *
+ * Subscribe params mirror a declared pull scope — `{resourceType, conditions}`
+ * plus the client-injected `authenticationToken` — and subscribe-time
+ * authorization delegates to the app sync resource's existing
+ * `authorizeChanges({params, scope})` (the `sync.api.resourceClass`), so apps
+ * hook in through the authorization they already declared instead of writing
+ * their own channel classes. Broadcast routing matches the publisher's
+ * scoping params against the subscription's scope conditions.
+ */
+export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
+    /**
+     * Registers the framework sync channel on a configuration declaring a
+     * `sync.api` block (guarded so repeated server boots with the same
+     * configuration register it only once). No-op without `sync.api` — the
+     * channel authorizes through the app's sync resource class.
+     * @param {import("../configuration.js").default} configuration - Configuration instance.
+     * @returns {void}
+     */
+    static registerFromConfiguration(configuration: import("../configuration.js").default): void;
+    /**
+     * Scope the subscription was authorized for, set by {@link SyncWebsocketChannel#canSubscribe}.
+     * @type {import("./sync-resource-base.js").SerializedChangesScope | null}
+     */
+    _scope: import("./sync-resource-base.js").SerializedChangesScope | null;
+    /**
+     * Authorizes the subscription through the app sync resource: the subscribe
+     * params are parsed into the same serialized scope the changes endpoint
+     * consumes and passed to the resource's `authorizeChanges({params, scope})`.
+     * Denials and malformed scopes throw, rejecting the subscription.
+     * @returns {Promise<boolean>} Whether the subscription is allowed.
+     */
+    canSubscribe(): Promise<boolean>;
+    /**
+     * Builds the app sync resource authorizing this subscription, mirroring the
+     * sync transport controller's resource construction with the ability
+     * resolved from the subscribe params (which carry the client-injected
+     * authenticationToken).
+     * @returns {Promise<import("./sync-resource-base.js").default>} App sync resource instance.
+     */
+    buildSyncResource(): Promise<import("./sync-resource-base.js").default>;
+    /**
+     * Routes a publisher broadcast to this subscription when the published
+     * resource type equals the type the subscription was authorized for and the
+     * scoping params satisfy every scope condition: each condition key must be
+     * present in the broadcast params and match by string comparison (array
+     * conditions match by membership). Broadcasts without a resource type and
+     * conditions the publisher's scoping params do not carry never match, so a
+     * subscription cannot receive changes outside its authorized scope.
+     * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} broadcastParams - Publisher scoping params (the published resourceType plus the change's scope-partition values).
+     * @returns {boolean} Whether the broadcast belongs to this subscription's scope.
+     */
+    matches(broadcastParams: import("../http-server/websocket-channel.js").WebsocketJsonValue): boolean;
+}
+import VelociousWebsocketChannel from "../http-server/websocket-channel.js";
+//# sourceMappingURL=sync-websocket-channel.d.ts.map

package/build/src/sync/sync-websocket-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-websocket-channel.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-websocket-channel.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH;IAOE;;;;;;;OAOG;IACH,gDAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAOhB;IAnBD;;;OAGG;IACH,QAFU,OAAO,yBAAyB,EAAE,sBAAsB,GAAG,IAAI,CAE5D;IAiBb;;;;;;OAMG;IACH,gBAFa,OAAO,CAAC,OAAO,CAAC,CAW5B;IAED;;;;;;OAMG;IACH,qBAFa,OAAO,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAkC9D;IAED;;;;;;;;;;OAUG;IACH,yBAHW,OAAO,qCAAqC,EAAE,kBAAkB,GAC9D,OAAO,CA0BnB;CASF;sCA/IqC,qCAAqC"}

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

@@ -0,0 +1,131 @@
+// @ts-check
+import VelociousWebsocketChannel from "../http-server/websocket-channel.js";
+import { VELOCIOUS_SYNC_CHANNEL } from "./sync-channel-name.js";
+/** Configurations whose framework sync channel has already been registered. */
+const registeredConfigurations = new WeakSet();
+/**
+ * Framework-owned websocket channel for synced resources
+ * ({@link VELOCIOUS_SYNC_CHANNEL}).
+ *
+ * Subscribe params mirror a declared pull scope — `{resourceType, conditions}`
+ * plus the client-injected `authenticationToken` — and subscribe-time
+ * authorization delegates to the app sync resource's existing
+ * `authorizeChanges({params, scope})` (the `sync.api.resourceClass`), so apps
+ * hook in through the authorization they already declared instead of writing
+ * their own channel classes. Broadcast routing matches the publisher's
+ * scoping params against the subscription's scope conditions.
+ */
+export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
+    /**
+     * Scope the subscription was authorized for, set by {@link SyncWebsocketChannel#canSubscribe}.
+     * @type {import("./sync-resource-base.js").SerializedChangesScope | null}
+     */
+    _scope = null;
+    /**
+     * Registers the framework sync channel on a configuration declaring a
+     * `sync.api` block (guarded so repeated server boots with the same
+     * configuration register it only once). No-op without `sync.api` — the
+     * channel authorizes through the app's sync resource class.
+     * @param {import("../configuration.js").default} configuration - Configuration instance.
+     * @returns {void}
+     */
+    static registerFromConfiguration(configuration) {
+        if (!configuration.getSyncConfiguration().api || registeredConfigurations.has(configuration))
+            return;
+        registeredConfigurations.add(configuration);
+        configuration.registerWebsocketChannel(VELOCIOUS_SYNC_CHANNEL, this);
+    }
+    /**
+     * Authorizes the subscription through the app sync resource: the subscribe
+     * params are parsed into the same serialized scope the changes endpoint
+     * consumes and passed to the resource's `authorizeChanges({params, scope})`.
+     * Denials and malformed scopes throw, rejecting the subscription.
+     * @returns {Promise<boolean>} Whether the subscription is allowed.
+     */
+    async canSubscribe() {
+        const resource = await this.buildSyncResource();
+        const scope = resource.changesScope({ scope: { conditions: this.params.conditions, resourceType: this.params.resourceType } });
+        await resource.authorizeChanges({ params: this.params, scope });
+        this._scope = scope;
+        return true;
+    }
+    /**
+     * Builds the app sync resource authorizing this subscription, mirroring the
+     * sync transport controller's resource construction with the ability
+     * resolved from the subscribe params (which carry the client-injected
+     * authenticationToken).
+     * @returns {Promise<import("./sync-resource-base.js").default>} App sync resource instance.
+     */
+    async buildSyncResource() {
+        const configuration = this.session.configuration;
+        const api = configuration.getSyncConfiguration().api;
+        if (!api) {
+            throw new Error(`The ${VELOCIOUS_SYNC_CHANNEL} channel requires a sync.api configuration block with the app's sync resource class`);
+        }
+        // Narrows the configured resource class to the sync resource contract
+        // (changesScope/authorizeChanges) the sync.api validation requires.
+        const ResourceClass = /** @type {typeof import("./sync-resource-base.js").default} */ (api.resourceClass);
+        // Narrows the websocket subscribe params to the resource params contract.
+        const params = /** @type {import("../configuration-types.js").VelociousParams} */ ( /** @type {unknown} */(this.params));
+        const request = this.session.upgradeRequest;
+        const ability = await configuration.resolveAbility({ params, request });
+        return new ResourceClass({
+            ability,
+            context: {
+                ...(ability?.getContext() || {}),
+                params,
+                request
+            },
+            locals: ability?.getLocals() || {},
+            modelClass: ResourceClass.ModelClass,
+            modelName: ResourceClass.ModelClass?.name,
+            params,
+            resourceConfiguration: /** @type {import("../configuration-types.js").FrontendModelResourceConfiguration} */ ({
+                attributes: ResourceClass.attributes || {},
+                sync: { enabled: true }
+            })
+        });
+    }
+    /**
+     * Routes a publisher broadcast to this subscription when the published
+     * resource type equals the type the subscription was authorized for and the
+     * scoping params satisfy every scope condition: each condition key must be
+     * present in the broadcast params and match by string comparison (array
+     * conditions match by membership). Broadcasts without a resource type and
+     * conditions the publisher's scoping params do not carry never match, so a
+     * subscription cannot receive changes outside its authorized scope.
+     * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} broadcastParams - Publisher scoping params (the published resourceType plus the change's scope-partition values).
+     * @returns {boolean} Whether the broadcast belongs to this subscription's scope.
+     */
+    matches(broadcastParams) {
+        const scope = this._scope;
+        if (!scope)
+            return false;
+        const scopingParams = broadcastParams && typeof broadcastParams === "object" && !Array.isArray(broadcastParams)
+            ? /** @type {Record<string, ?>} */ (broadcastParams)
+            : {};
+        if (!Object.hasOwn(scopingParams, "resourceType") || String(scopingParams.resourceType) !== String(scope.resourceType))
+            return false;
+        for (const [conditionName, conditionValue] of Object.entries(scope.conditions)) {
+            if (!Object.hasOwn(scopingParams, conditionName))
+                return false;
+            const scopingValue = scopingParams[conditionName];
+            if (Array.isArray(conditionValue)) {
+                if (!conditionValue.some((value) => String(value) === String(scopingValue)))
+                    return false;
+            }
+            else if (String(conditionValue) !== String(scopingValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Returns the authorized scope for debug snapshots.
+     * @returns {Record<string, ?>} Debug-safe subscription details.
+     */
+    debugSnapshot() {
+        return { scope: this._scope };
+    }
+}
+//# 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}})\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      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   * @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, ?>} */ (broadcastParams)\n      : {}\n\n    if (!Object.hasOwn(scopingParams, \"resourceType\") || String(scopingParams.resourceType) !== String(scope.resourceType)) return false\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   * Returns the authorized scope for debug snapshots.\n   * @returns {Record<string, ?>} Debug-safe subscription details.\n   */\n  debugSnapshot() {\n    return {scope: this._scope}\n  }\n}\n"]}

package/build/sync/sync-channel-name.js

@@ -0,0 +1,10 @@
+// @ts-check
+
+/**
+ * Canonical framework-owned websocket channel for synced resources. The server
+ * registers it automatically when `sync.api` is configured (subscribe
+ * authorization delegates to the app sync resource's `authorizeChanges`), the
+ * sync publisher broadcasts standard sync envelopes on it, and the derived
+ * sync client subscribes its declared pull scopes to it automatically.
+ */
+export const VELOCIOUS_SYNC_CHANNEL = "velocious-sync"

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

@@ -9,8 +9,8 @@
 
 /**
  * Static realtime channel declaration on a model's `static sync`, for channels
- * whose name and params are static. Channels needing runtime params (like
- * eventId) belong in the `sync.client.realtime.channels` callback instead.
+ * whose name and params are static.
+ * @deprecated Declared pull scopes subscribe the framework sync channel automatically; keep this only for legacy app channels.
  * @typedef {object} ModelSyncRealtimeDeclaration
  * @property {string} channel - Server channel name to subscribe.
  * @property {Record<string, ?>} [params] - Static subscribe params. The framework injects `authenticationToken` automatically.
@@ -29,13 +29,14 @@
  * @property {"upsert" | ((args: {operation: "create" | "update" | "destroy", record: ?}) => string)} [syncType] - Maps a mutation operation to a sync type. The "upsert" flag queues creates and updates as "update" rows (the server upserts by resource id) and destroys as "delete". Defaults to the operation name with destroy mapped to "delete".
  * @property {(args: {operation: "create" | "update" | "destroy", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.
  * @property {boolean | {operations: Array<"create" | "update" | "destroy">}} [track] - Automatic mutation tracking policy. On by default (creates and updates queue automatically); `false` opts the resource out, `true` adds destroys, `{operations}` narrows the tracked operations.
- * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`.
+ * @property {ModelSyncRealtimeDeclaration} [realtime] - Deprecated: static legacy realtime channel this resource subscribes through `subscribeRealtime(...)`. Declared pull scopes subscribe the framework sync channel automatically.
  */
 
 /**
  * Model-level client sync declaration read from `static sync` by
  * `SyncClient.fromConfiguration(...)`. `true` opts the model in with all
  * defaults; an object customizes the derived resource config.
+ * @template [TModel=any]
  * @typedef {object} ModelSyncDeclarationConfig
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["afterApply"]} [afterApply] - Post-apply hook.
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["attributes"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.
@@ -43,14 +44,19 @@
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["findRecord"]} [findRecord] - Custom pull-apply record resolver.
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["findRecordForDelete"]} [findRecordForDelete] - Custom pull-apply delete resolver.
  * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.
- * @property {import("./sync-publisher-types.js").SyncPublishDeclaration} [publish] - Server-side publish declaration consumed by `SyncPublisher.fromConfiguration(...)` on the backend; ignored by the client.
+ * @property {import("./sync-publisher-types.js").SyncPublishDeclaration<TModel>} [publish] - Server-side publish declaration consumed by `SyncPublisher.fromConfiguration(...)` on the backend; ignored by the client.
  * @property {"upsert" | ((args: {operation: "create" | "update" | "destroy", record: ?}) => string)} [syncType] - Sync type flag or mapper (see SyncClientResourceConfig).
  * @property {boolean | Array<"create" | "update" | "destroy"> | {operations: Array<"create" | "update" | "destroy">}} [track] - Automatic mutation tracking policy; an array is shorthand for {operations}. On by default (creates and updates queue automatically); `false` opts the model out (for models written by non-user flows), `true` adds destroys.
  * @property {(args: {operation: "create" | "update" | "destroy", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.
- * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`; use the `sync.client.realtime.channels` callback for channels needing runtime params.
+ * @property {ModelSyncRealtimeDeclaration} [realtime] - Deprecated: static legacy realtime channel this resource subscribes through `subscribeRealtime(...)`. Declared pull scopes subscribe the framework sync channel automatically.
  */
 
-/** @typedef {boolean | ModelSyncDeclarationConfig} ModelSyncDeclaration */
+/**
+ * Model-level sync declaration value: `true` opts in with all defaults, an
+ * object customizes the derived resource config.
+ * @template [TModel=any]
+ * @typedef {boolean | ModelSyncDeclarationConfig<TModel>} ModelSyncDeclaration
+ */
 
 /**
  * Options for building a sync client. Everything else — resources, transport

package/build/sync/sync-client.js

@@ -452,7 +452,7 @@ export default class SyncClient {
   /**
    * Subscribes the derived realtime channels so pushed websocket changes apply
    * through the same derived applier as pulls (idempotent, single-flighted).
-   * @param {?} [context] - App context passed to the `sync.client.realtime.channels` callback (runtime values like eventId).
+   * @param {?} [context] - App context passed to the deprecated `sync.client.realtime.channels` callback (runtime scope values).
    * @returns {Promise<void>}
    */
   async subscribeRealtime(context) {

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

@@ -2,6 +2,8 @@
 
 import VelociousError from "../velocious-error.js"
 
+import {declaredSyncScopeAttributes} from "./sync-scope-attributes.js"
+
 /**
  * Generic cursor-paginated change feed over an app-owned sync/change model.
  *
@@ -173,14 +175,20 @@ export default class SyncModelChangeFeedService {
   }
 
   /**
-   * Serializes a record using the standard sync envelope shape.
+   * Serializes a record using the standard sync envelope shape plus the sync
+   * model's declared scope-partition attributes (`static syncScopeAttributes`),
+   * each emitted under its own attribute name. Models declaring no scope
+   * attributes keep the deprecated 1.0.503 wire and emit `eventId`. Keys are
+   * sorted so a declared `["eventId"]` partition stays byte-identical with the
+   * 1.0.503 wire.
    * @param {?} record - Sync/change record.
    * @returns {Record<string, unknown>} Default serialized row.
    */
   defaultSerializeRecord(record) {
-    return {
+    const scopeAttributes = declaredSyncScopeAttributes(this.modelClass)
+    /** @type {Record<string, unknown>} */
+    const serialized = {
       data: this.recordData(record),
-      eventId: this.recordValue(record, "eventId"),
       id: this.recordValue(record, "id"),
       resourceId: this.recordValue(record, "resourceId"),
       resourceType: this.recordValue(record, "resourceType"),
@@ -188,6 +196,12 @@ export default class SyncModelChangeFeedService {
       syncType: this.recordValue(record, "syncType"),
       updatedAt: this.isoDate(this.recordValue(record, "updatedAt"))
     }
+
+    for (const scopeAttribute of scopeAttributes || ["eventId"]) {
+      serialized[scopeAttribute] = this.recordValue(record, scopeAttribute)
+    }
+
+    return Object.fromEntries(Object.entries(serialized).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)))
   }
 
   /**