velocious 1.0.504 → 1.0.506

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

@@ -120,12 +120,83 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
         }
         return true;
     }
+    /**
+     * Delivers a matched broadcast. Scoped subscriptions (with explicit
+     * conditions) already routed through {@link SyncWebsocketChannel#matches}, so
+     * the change is in scope and delivers unchanged. User-scope subscriptions
+     * (empty conditions, "everything my ability can see") match every broadcast
+     * of the resource type, so each published change is re-checked against the
+     * subscriber's ability at fan-out through the app sync resource's
+     * `changeDeliverable`; only accessible changes are delivered, and a broadcast
+     * with no accessible change is dropped.
+     * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} body - Broadcast body (sync envelope).
+     * @param {{eventId?: string}} [meta] - Optional event metadata.
+     * @returns {Promise<void>}
+     */
+    async deliverBroadcast(body, meta) {
+        if (!this._isUserScope()) {
+            this.sendMessage(body, meta);
+            return;
+        }
+        const deliverableBody = await this._userScopeDeliverableBody(body);
+        if (deliverableBody !== null)
+            this.sendMessage(deliverableBody, meta);
+    }
+    /**
+     * Whether this subscription is a user scope: authorized with empty conditions
+     * ("everything my ability can see").
+     * @returns {boolean} Whether the subscription is a user scope.
+     */
+    _isUserScope() {
+        return Boolean(this._scope) && Object.keys(/** @type {import("./sync-resource-base.js").SerializedChangesScope} */ (this._scope).conditions).length === 0;
+    }
+    /**
+     * Filters a user-scope broadcast to the sync entries the subscriber's ability
+     * can access, re-checking each through the app sync resource's
+     * `changeDeliverable`. Returns the broadcast narrowed to accessible entries,
+     * or null when none are accessible. Non-envelope bodies and entries without a
+     * resource id are dropped (fail closed).
+     * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} body - Broadcast body.
+     * @returns {Promise<import("../http-server/websocket-channel.js").WebsocketJsonValue | null>} Deliverable body, or null.
+     */
+    async _userScopeDeliverableBody(body) {
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            return null;
+        const envelope = /** @type {Record<string, ?>} */ (body);
+        const scope = /** @type {import("./sync-resource-base.js").SerializedChangesScope} */ (this._scope);
+        const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope];
+        const configuration = this.session.configuration;
+        /** @type {Array<Record<string, ?>>} */
+        const deliverableSyncs = [];
+        // Broadcast fan-out runs through `withoutCurrentConnectionContexts` (see
+        // Configuration#_broadcastToChannelLocal), so there is no ambient database
+        // connection here. Resolve the resource's ability and run the per-delivery
+        // access query inside a checked-out connection context, mirroring how other
+        // broadcast-time DB work (the frontend-model channel) obtains connections.
+        await configuration.ensureConnections({ name: `${VELOCIOUS_SYNC_CHANNEL} user-scope delivery access check` }, async () => {
+            const resource = await this.buildSyncResource();
+            for (const sync of syncs) {
+                const resourceId = sync?.resourceId;
+                const resourceType = sync?.resourceType ?? scope.resourceType;
+                if (resourceId === undefined || resourceId === null)
+                    continue;
+                if (await resource.changeDeliverable({ params: this.params, scope, sync: { resourceId: String(resourceId), resourceType: String(resourceType) } })) {
+                    deliverableSyncs.push(sync);
+                }
+            }
+        });
+        if (deliverableSyncs.length === 0)
+            return null;
+        if (Array.isArray(envelope.syncs))
+            return { ...envelope, syncs: deliverableSyncs };
+        return deliverableSyncs[0];
+    }
     /**
      * Returns the authorized scope for debug snapshots.
      * @returns {Record<string, ?>} Debug-safe subscription details.
      */
     debugSnapshot() {
-        return { scope: this._scope };
+        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}})\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"]}
+//# 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   * 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, ?>} */ (body)\n    const scope = /** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope)\n    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]\n    const configuration = this.session.configuration\n    /** @type {Array<Record<string, ?>>} */\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        if (await resource.changeDeliverable({params: this.params, scope, sync: {resourceId: String(resourceId), resourceType: String(resourceType)}})) {\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, ?>} Debug-safe subscription details.\n   */\n  debugSnapshot() {\n    return {scope: this._scope, userScope: this._isUserScope()}\n  }\n}\n"]}

package/build/sync/query-scope.js

@@ -44,12 +44,19 @@ export function serializedScopeFromQuery(query) {
 }
 
 /**
- * Returns a stable canonical key identifying a sync scope.
+ * Returns a stable canonical key identifying a sync scope. When an `owner` is
+ * present (the authenticated identity that declared the scope locally), it
+ * participates in the key so the same wire scope owned by a different user gets
+ * its own local identity and cursor — a user scope's empty-conditions cursor
+ * never leaks across accounts on a shared device, while the same user
+ * reconnecting keeps continuity. Owner-less scopes keep their pre-owner key.
  * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
  * @returns {string} Stable scope key.
  */
 export function scopeKey(scope) {
-  return `${scope.resourceType}:${stableJsonStringify(scope.conditions)}`
+  const ownerPrefix = scope.owner === undefined || scope.owner === null ? "" : `owner=${stableJsonStringify(scope.owner)}|`
+
+  return `${ownerPrefix}${scope.resourceType}:${stableJsonStringify(scope.conditions)}`
 }
 
 /**

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

@@ -5,6 +5,7 @@
  * @typedef {object} SerializedSyncScope
  * @property {Record<string, ?>} conditions - Plain attribute conditions from the query.
  * @property {string} resourceType - Resource/model name the scope was declared for.
+ * @property {string} [owner] - Local partition key: the authenticated identity that declared the scope. Used only to partition the local scope/cursor store (never sent to the server as scope conditions), so a user scope's empty-conditions cursor does not leak across accounts on a shared device.
  */
 
 /**
@@ -58,6 +59,13 @@
  * @typedef {boolean | ModelSyncDeclarationConfig<TModel>} ModelSyncDeclaration
  */
 
+/**
+ * Shared app-lifetime websocket connection all sync traffic rides. Matches the
+ * realtime websocket client contract; the sync client rides it without owning
+ * its connect/disconnect lifecycle.
+ * @typedef {import("../configuration-types.js").VelociousSyncRealtimeWebsocketClient} SyncClientSharedConnection
+ */
+
 /**
  * Options for building a sync client. Everything else — resources, transport
  * POSTers, auth, connectivity, batch size — is derived from the configuration's
@@ -84,6 +92,8 @@
  * @property {import("../configuration-types.js").VelociousSyncClientRealtimeConfiguration} [realtime] - Realtime push configuration consumed by `subscribeRealtime(...)`.
  * @property {Record<string, SyncClientResourceConfig>} resources - Derived resource policies keyed by resource/model name.
  * @property {?} syncModel - Local pending-sync model class.
+ * @property {SyncClientSharedConnection} [websocketClient] - Shared app-lifetime websocket client instance (the low-level shared-connection form).
+ * @property {string | (() => string | null | undefined)} [websocketUrl] - Shared app-lifetime websocket URL the framework builds a client from.
  */
 
 export {}

package/build/sync/sync-client.js

@@ -4,6 +4,7 @@ import Configuration from "../configuration.js"
 import {isBooleanColumnType} from "../database/column-types.js"
 import Logger from "../logger.js"
 import restArgsError from "../utils/rest-args-error.js"
+import VelociousWebsocketClient from "../http-client/websocket-client.js"
 
 import {serializedScopeFromQuery} from "./query-scope.js"
 import SyncApiClient from "./sync-api-client.js"
@@ -99,11 +100,19 @@ export default class SyncClient {
       postReplay: transportPoster({path: `${clientConfiguration.mountPath}/replay`, transport: clientConfiguration.transport}),
       realtime: clientConfiguration.realtime,
       resources,
-      syncModel: resolvedSyncModel
+      syncModel: resolvedSyncModel,
+      websocketClient: clientConfiguration.websocketClient,
+      websocketUrl: clientConfiguration.websocketUrl
     }
     this._clientNumber = ++clientCounter
     /** @type {SyncRealtimeBridge | null} */
     this._realtimeBridge = null
+    /** @type {import("./sync-client-types.js").SyncClientSharedConnection | null | undefined} Shared app-lifetime websocket connection (undefined until first resolved, null when none is configured). */
+    this._syncConnection = undefined
+    /** @type {Promise<void> | null} */
+    this._subscribeUserScopePromise = null
+    /** @type {"subscribed" | "subscribing" | "unsubscribed"} */
+    this._userScopeState = "unsubscribed"
     /** @type {import("./sync-scope-store.js").default | null} */
     this._scopeStore = scopeStore || null
     /** @type {Promise<void> | null} */
@@ -449,6 +458,33 @@ export default class SyncClient {
     }
   }
 
+  /**
+   * Resolves the shared app-lifetime websocket connection all sync traffic
+   * rides, or null when none is configured. Built once and memoized (per
+   * client): an app-provided `sync.client.websocketClient` instance wins (the
+   * frontend-model transport can pass its own client so one socket carries
+   * everything), else a framework-owned reconnecting {@link VelociousWebsocketClient}
+   * built from `sync.client.websocketUrl`. The realtime bridge rides this
+   * connection without owning its lifecycle; when neither is configured the
+   * bridge falls back to the deprecated per-cycle `realtime.createClient`.
+   * @returns {import("./sync-client-types.js").SyncClientSharedConnection | null} Shared websocket connection, or null.
+   */
+  syncConnection() {
+    if (this._syncConnection !== undefined) return this._syncConnection
+
+    if (this.config.websocketClient) {
+      this._syncConnection = this.config.websocketClient
+    } else if (this.config.websocketUrl) {
+      const url = typeof this.config.websocketUrl === "function" ? this.config.websocketUrl() : this.config.websocketUrl
+
+      this._syncConnection = url ? new VelociousWebsocketClient({url}) : null
+    } else {
+      this._syncConnection = null
+    }
+
+    return this._syncConnection
+  }
+
   /**
    * Subscribes the derived realtime channels so pushed websocket changes apply
    * through the same derived applier as pulls (idempotent, single-flighted).
@@ -459,6 +495,94 @@ export default class SyncClient {
     await this.realtimeBridge().subscribe(context)
   }
 
+  /**
+   * Subscribes the server-enumerated user scope: "everything my ability can
+   * see". Declares a user scope (empty conditions) for every pullable synced
+   * resource type, subscribes realtime so their framework sync channel
+   * subscriptions go live, and pulls so the device catches up. The server
+   * authorizes each empty-conditions scope through the app sync resource's
+   * `authorizeChanges` and re-checks record access per delivery, so the client
+   * subscribes with just its token and the server decides membership.
+   * Idempotent and single-flighted like {@link SyncClient#subscribeRealtime}.
+   * @returns {Promise<void>}
+   */
+  async subscribeUserScope() {
+    if (this._userScopeState === "subscribed") return
+
+    if (!this._subscribeUserScopePromise) {
+      this._subscribeUserScopePromise = this._subscribeUserScope().finally(() => {
+        this._subscribeUserScopePromise = null
+      })
+    }
+
+    await this._subscribeUserScopePromise
+  }
+
+  /**
+   * Declares and activates the user scope for every pullable resource, then
+   * subscribes realtime and pulls.
+   * @returns {Promise<void>}
+   */
+  async _subscribeUserScope() {
+    this._userScopeState = "subscribing"
+
+    const scopeStore = this.scopeStore()
+    const owner = await this.userScopeOwner()
+
+    for (const resourceType of this.userScopeResourceTypes()) {
+      await scopeStore.findOrCreateScope({conditions: {}, owner, resourceType})
+    }
+
+    await this.subscribeRealtime()
+    await this.pull()
+
+    this._userScopeState = "subscribed"
+  }
+
+  /**
+   * Unsubscribes the user scope: deactivates the per-resource user scopes and
+   * closes the realtime channel subscriptions. The shared websocket connection
+   * stays open when one is configured (sign-out drops subscriptions without
+   * disconnecting), so a subsequent sign-in resubscribes over the same socket.
+   * @returns {Promise<void>}
+   */
+  async unsubscribeUserScope() {
+    const scopeStore = this.scopeStore()
+    const owner = await this.userScopeOwner()
+
+    for (const resourceType of this.userScopeResourceTypes()) {
+      await scopeStore.deactivate({conditions: {}, owner, resourceType})
+    }
+
+    await this.unsubscribeRealtime()
+
+    this._userScopeState = "unsubscribed"
+    this._subscribeUserScopePromise = null
+  }
+
+  /**
+   * The resource types a user scope covers: every declared resource that
+   * receives pulled changes (has pull `attributes`).
+   * @returns {string[]} Pullable resource type names.
+   */
+  userScopeResourceTypes() {
+    return Object.keys(this.pullResourceConfigs())
+  }
+
+  /**
+   * Resolves the local partition key for the user scope: the currently
+   * configured authenticated identity (the sync auth token). Partitioning the
+   * user scope's local scope/cursor rows by this owner keeps the
+   * empty-conditions cursor from leaking across accounts on a shared device
+   * (account B signing in after account A gets a fresh cursor) while the same
+   * account reconnecting keeps its cursor continuity. The owner is a local
+   * partition key only — pulls still post empty conditions to the server.
+   * @returns {Promise<string>} User-scope owner partition key.
+   */
+  async userScopeOwner() {
+    return String(await this.config.authenticationToken())
+  }
+
   /**
    * Unsubscribes the realtime channels and disconnects the websocket client (idempotent).
    * @returns {Promise<void>}

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

@@ -30,6 +30,8 @@ export default class SyncRealtimeBridge {
     this._channels = []
     /** @type {VelociousSyncRealtimeWebsocketClient | null} */
     this._client = null
+    /** @type {boolean} Whether the bridge created its own client (deprecated per-cycle path) and must disconnect it on unsubscribe. A shared connection is never owned. */
+    this._ownsClient = false
     /** @type {Promise<void>} */
     this._applyPromise = Promise.resolve()
     /** @type {number} Subscription generation - bumped by unsubscribe so in-flight subscribes detect they became stale. */
@@ -80,8 +82,13 @@ export default class SyncRealtimeBridge {
     const channels = []
     /** @type {VelociousSyncRealtimeWebsocketClient | null} */
     let client = null
+    /** @type {boolean} Whether this attempt created its own client and must disconnect it on teardown. */
+    let ownsClient = false
     /**
-     * Tears down everything this stale/failed subscribe attempt created itself.
+     * Tears down everything this stale/failed subscribe attempt created itself:
+     * always closes its channel subscriptions, and disconnects the websocket
+     * only when the bridge owns it (deprecated per-cycle path); a shared
+     * connection stays open.
      * @returns {Promise<void>}
      */
     const teardown = async () => {
@@ -89,18 +96,28 @@ export default class SyncRealtimeBridge {
         subscription.close()
       }
 
-      if (client) await client.disconnectAndStopReconnect()
+      if (client && ownsClient) await client.disconnectAndStopReconnect()
     }
 
     try {
-      const realtime = this.realtimeConfiguration()
+      const sharedClient = this.syncClient.syncConnection()
+      const realtime = this.requireClientSource(sharedClient)
       const channelDescriptors = await this.channelDescriptors(context)
 
       if (generation !== this._generation) return
 
-      client = await realtime.createClient()
+      if (sharedClient) {
+        client = sharedClient
+      } else {
+        // requireClientSource guaranteed realtime.createClient when there is no shared connection.
+        client = await /** @type {import("../configuration-types.js").VelociousSyncClientRealtimeConfiguration} */ (realtime).createClient()
+        ownsClient = true
+      }
 
-      if (generation !== this._generation) return
+      if (generation !== this._generation) {
+        await teardown()
+        return
+      }
 
       await client.connect()
 
@@ -140,6 +157,7 @@ export default class SyncRealtimeBridge {
 
       this._channels = channels
       this._client = client
+      this._ownsClient = ownsClient
       this._state = "subscribed"
       this.schedulePull()
     } catch (error) {
@@ -152,9 +170,12 @@ export default class SyncRealtimeBridge {
   }
 
   /**
-   * Closes every channel subscription and disconnects the websocket client
-   * (idempotent). Also marks any in-flight subscribe attempt stale so it tears
-   * itself down instead of finishing the subscription afterwards.
+   * Closes every channel subscription (idempotent). The websocket is
+   * disconnected only when the bridge owns it (deprecated per-cycle
+   * `realtime.createClient` path); a shared app-lifetime connection stays open
+   * so unsubscribing drops subscriptions without tearing down the socket. Also
+   * marks any in-flight subscribe attempt stale so it tears itself down instead
+   * of finishing the subscription afterwards.
    * @returns {Promise<void>}
    */
   async unsubscribe() {
@@ -162,16 +183,18 @@ export default class SyncRealtimeBridge {
 
     const channels = this._channels
     const client = this._client
+    const ownsClient = this._ownsClient
 
     this._channels = []
     this._client = null
+    this._ownsClient = false
     this._state = "unsubscribed"
 
     for (const {subscription} of channels) {
       subscription.close()
     }
 
-    if (client) await client.disconnectAndStopReconnect()
+    if (client && ownsClient) await client.disconnectAndStopReconnect()
   }
 
   /**
@@ -195,14 +218,26 @@ export default class SyncRealtimeBridge {
   }
 
   /**
-   * Resolves the realtime configuration, failing loudly when it is missing.
-   * @returns {import("../configuration-types.js").VelociousSyncClientRealtimeConfiguration} Realtime configuration.
+   * Resolves the realtime configuration block, or null when the app declared
+   * none (valid when a shared connection is configured).
+   * @returns {import("../configuration-types.js").VelociousSyncClientRealtimeConfiguration | null} Realtime configuration, or null.
    */
   realtimeConfiguration() {
-    const realtime = this.syncClient.config.realtime
+    return this.syncClient.config.realtime || null
+  }
+
+  /**
+   * Resolves the realtime configuration and asserts a websocket client source
+   * exists: a shared connection rides its own lifecycle, otherwise the
+   * deprecated per-cycle `realtime.createClient` must be configured.
+   * @param {import("../configuration-types.js").VelociousSyncRealtimeWebsocketClient | null} sharedClient - Shared connection, or null.
+   * @returns {import("../configuration-types.js").VelociousSyncClientRealtimeConfiguration | null} Realtime configuration, or null.
+   */
+  requireClientSource(sharedClient) {
+    const realtime = this.realtimeConfiguration()
 
-    if (!realtime) {
-      throw new Error("subscribeRealtime requires a sync.client.realtime configuration block with a createClient callback")
+    if (!sharedClient && typeof realtime?.createClient !== "function") {
+      throw new Error("subscribeRealtime requires a shared connection (sync.client.websocketUrl or sync.client.websocketClient) or the deprecated sync.client.realtime.createClient callback")
     }
 
     return realtime
@@ -235,7 +270,7 @@ export default class SyncRealtimeBridge {
       channelDescriptors.push({channel: resourceConfig.realtime.channel, params: resourceConfig.realtime.params, resourceType})
     }
 
-    if (realtime.channels) {
+    if (realtime?.channels) {
       channelDescriptors.push(...await realtime.channels(context))
     }
 
@@ -306,7 +341,7 @@ export default class SyncRealtimeBridge {
 
     const realtime = this.realtimeConfiguration()
 
-    if (realtime.localOrigin && body.echoOrigin !== undefined && body.echoOrigin !== null) {
+    if (realtime?.localOrigin && body.echoOrigin !== undefined && body.echoOrigin !== null) {
       const localOrigin = String(await realtime.localOrigin())
 
       if (String(body.echoOrigin) === localOrigin) return
@@ -329,7 +364,7 @@ export default class SyncRealtimeBridge {
    * @returns {void}
    */
   schedulePull() {
-    if (this.realtimeConfiguration().pullOnReconnect === false) return
+    if (this.realtimeConfiguration()?.pullOnReconnect === false) return
 
     this._scheduledPull ||= (async () => {
       try {

package/build/sync/sync-resource-base.js

@@ -215,6 +215,27 @@ export default class SyncResourceBase extends FrontendModelBaseResource {
     throw new Error("SyncResourceBase#scopeChangesQuery must be implemented")
   }
 
+  /**
+   * Decides whether one published change is deliverable to a user-scope
+   * subscription (the framework sync channel's per-delivery access re-check).
+   * The default reuses the app's ability scoping: it applies
+   * {@link SyncResourceBase#scopeChangesQuery} to the change-feed model — which
+   * for an empty-conditions user scope falls back to ability scoping — and
+   * checks whether the published change's feed row is visible within that
+   * scope. Apps get this for free from the scoping they already declared;
+   * override only for custom per-delivery rules.
+   * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null, sync: {resourceId: string, resourceType: string}}} args - Request params, subscription scope, and the published change's identity.
+   * @returns {Promise<boolean>} Whether the change may be delivered to this subscription.
+   */
+  async changeDeliverable({params, scope, sync}) {
+    const query = this.syncModelClass().where({})
+
+    this.scopeChangesQuery({params, query, scope})
+    query.where({resource_id: String(sync.resourceId), resource_type: String(sync.resourceType)})
+
+    return Boolean(await query.first())
+  }
+
   /**
    * Resolves the replay service class handling replay mutations: the
    * declarative {@link SyncResourceBase.ReplayServiceClass} static (shared

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

@@ -136,11 +136,90 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
     return true
   }
 
+  /**
+   * Delivers a matched broadcast. Scoped subscriptions (with explicit
+   * conditions) already routed through {@link SyncWebsocketChannel#matches}, so
+   * the change is in scope and delivers unchanged. User-scope subscriptions
+   * (empty conditions, "everything my ability can see") match every broadcast
+   * of the resource type, so each published change is re-checked against the
+   * subscriber's ability at fan-out through the app sync resource's
+   * `changeDeliverable`; only accessible changes are delivered, and a broadcast
+   * with no accessible change is dropped.
+   * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} body - Broadcast body (sync envelope).
+   * @param {{eventId?: string}} [meta] - Optional event metadata.
+   * @returns {Promise<void>}
+   */
+  async deliverBroadcast(body, meta) {
+    if (!this._isUserScope()) {
+      this.sendMessage(body, meta)
+
+      return
+    }
+
+    const deliverableBody = await this._userScopeDeliverableBody(body)
+
+    if (deliverableBody !== null) this.sendMessage(deliverableBody, meta)
+  }
+
+  /**
+   * Whether this subscription is a user scope: authorized with empty conditions
+   * ("everything my ability can see").
+   * @returns {boolean} Whether the subscription is a user scope.
+   */
+  _isUserScope() {
+    return Boolean(this._scope) && Object.keys(/** @type {import("./sync-resource-base.js").SerializedChangesScope} */ (this._scope).conditions).length === 0
+  }
+
+  /**
+   * Filters a user-scope broadcast to the sync entries the subscriber's ability
+   * can access, re-checking each through the app sync resource's
+   * `changeDeliverable`. Returns the broadcast narrowed to accessible entries,
+   * or null when none are accessible. Non-envelope bodies and entries without a
+   * resource id are dropped (fail closed).
+   * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} body - Broadcast body.
+   * @returns {Promise<import("../http-server/websocket-channel.js").WebsocketJsonValue | null>} Deliverable body, or null.
+   */
+  async _userScopeDeliverableBody(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body)) return null
+
+    const envelope = /** @type {Record<string, ?>} */ (body)
+    const scope = /** @type {import("./sync-resource-base.js").SerializedChangesScope} */ (this._scope)
+    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]
+    const configuration = this.session.configuration
+    /** @type {Array<Record<string, ?>>} */
+    const deliverableSyncs = []
+
+    // Broadcast fan-out runs through `withoutCurrentConnectionContexts` (see
+    // Configuration#_broadcastToChannelLocal), so there is no ambient database
+    // connection here. Resolve the resource's ability and run the per-delivery
+    // access query inside a checked-out connection context, mirroring how other
+    // broadcast-time DB work (the frontend-model channel) obtains connections.
+    await configuration.ensureConnections({name: `${VELOCIOUS_SYNC_CHANNEL} user-scope delivery access check`}, async () => {
+      const resource = await this.buildSyncResource()
+
+      for (const sync of syncs) {
+        const resourceId = sync?.resourceId
+        const resourceType = sync?.resourceType ?? scope.resourceType
+
+        if (resourceId === undefined || resourceId === null) continue
+
+        if (await resource.changeDeliverable({params: this.params, scope, sync: {resourceId: String(resourceId), resourceType: String(resourceType)}})) {
+          deliverableSyncs.push(sync)
+        }
+      }
+    })
+
+    if (deliverableSyncs.length === 0) return null
+    if (Array.isArray(envelope.syncs)) return {...envelope, syncs: deliverableSyncs}
+
+    return deliverableSyncs[0]
+  }
+
   /**
    * Returns the authorized scope for debug snapshots.
    * @returns {Record<string, ?>} Debug-safe subscription details.
    */
   debugSnapshot() {
-    return {scope: this._scope}
+    return {scope: this._scope, userScope: this._isUserScope()}
   }
 }

package/package.json

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