velocious 1.0.500 → 1.0.502

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

@@ -1,14 +1,23 @@
 // @ts-check
 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 { serializedScopeFromQuery } from "./query-scope.js";
 import SyncApiClient from "./sync-api-client.js";
+import SyncRealtimeBridge from "./sync-realtime-bridge.js";
 import SyncScopeStore from "./sync-scope-store.js";
 import { currentSyncClient, setCurrentSyncClient } from "./sync-client-registry.js";
 let clientCounter = 0;
 /** @type {{create: "afterCreate", update: "afterUpdate", destroy: "afterDestroy"}} */
 const TRACKED_CALLBACK_NAMES = { create: "afterCreate", destroy: "afterDestroy", update: "afterUpdate" };
+/**
+ * Operations tracked by default for models declaring `static sync` without a
+ * `track` key: local creates and updates queue automatically. Destroys are not
+ * tracked by default because a local destroy is often cache eviction rather
+ * than a server delete; opt in with `track: true` or an operations list.
+ * @type {Array<"create" | "update" | "destroy">} */
+const DEFAULT_TRACKED_OPERATIONS = ["create", "update"];
 /** Attribute names treated as client-local sync bookkeeping when deriving localOnlyAttributes. */
 const LOCAL_BOOKKEEPING_ATTRIBUTE_NAMES = ["createdAt", "updatedAt", "lastSyncChangeAt"];
 /** @type {WeakMap<Configuration, SyncClient>} */
@@ -70,10 +79,13 @@ export default class SyncClient {
             onError: clientConfiguration.onError,
             postChanges: transportPoster({ path: `${clientConfiguration.mountPath}/changes`, transport: clientConfiguration.transport }),
             postReplay: transportPoster({ path: `${clientConfiguration.mountPath}/replay`, transport: clientConfiguration.transport }),
+            realtime: clientConfiguration.realtime,
             resources,
             syncModel: resolvedSyncModel
         };
         this._clientNumber = ++clientCounter;
+        /** @type {SyncRealtimeBridge | null} */
+        this._realtimeBridge = null;
         /** @type {import("./sync-scope-store.js").default | null} */
         this._scopeStore = scopeStore || null;
         /** @type {Promise<void> | null} */
@@ -84,12 +96,17 @@ export default class SyncClient {
         this._trackedCallbacks = [];
         /** @type {WeakSet<object>} */
         this._remoteApplyRecords = new WeakSet();
+        this._withoutTrackingDepth = 0;
+        /** @type {Logger | {error: (...messages: Array<?>) => Promise<void>} | null} */
+        this._logger = null;
         this._started = false;
     }
     /**
-     * Registers automatic mutation tracking for every resource with `track` enabled:
-     * local model creates/updates/destroys queue pending sync rows and schedule an
-     * immediate replay attempt, without app-side queue calls.
+     * Registers automatic mutation tracking for every declared resource (on by
+     * default: local creates and updates queue pending sync rows once their
+     * transaction commits and schedule an immediate replay attempt, without
+     * app-side queue calls). `track: false` resources are skipped; `track: true`
+     * adds destroys; an operations list narrows the tracked operations.
      * @returns {Promise<void>}
      */
     async start() {
@@ -119,13 +136,18 @@ export default class SyncClient {
     }
     /**
      * Resolves and validates the tracked operations for a resource config.
+     * Tracking is on by default: models declaring `static sync` without a `track`
+     * key queue local creates and updates automatically; `track: false` opts a
+     * model out (for models written by non-user flows).
      * @param {{resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig, resourceType: string}} args - Resource config and name.
      * @returns {Array<"create" | "update" | "destroy">} Tracked operations.
      */
     trackedOperations({ resourceConfig, resourceType }) {
         const track = resourceConfig.track;
-        if (track === undefined || track === false)
+        if (track === false)
             return [];
+        if (track === undefined)
+            return DEFAULT_TRACKED_OPERATIONS;
         if (track === true)
             return ["create", "update", "destroy"];
         if (!track || typeof track !== "object" || !Array.isArray(track.operations) || track.operations.length === 0) {
@@ -139,25 +161,70 @@ export default class SyncClient {
         return track.operations;
     }
     /**
-     * Builds the lifecycle callback queueing one tracked mutation.
+     * Builds the lifecycle callback queueing one tracked mutation. The queued
+     * payload and sync type are snapshotted at mutation-callback time, so
+     * afterSave hooks assigning unsaved attributes (or any later drift on the
+     * record) cannot change what gets queued vs what was committed. Queueing is
+     * deferred through the model connection's afterCommit hook so it only runs
+     * once the mutation's transaction has committed (immediately when no
+     * transaction is open) - queued syncs never reference rolled-back rows.
+     * Post-commit queue failures are reported without rethrowing into the
+     * driver's afterCommit chain (see reportAfterCommitError).
      * @param {{operation: "create" | "update" | "destroy", resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig}} args - Operation and resource config.
      * @returns {(record: ?) => Promise<void>} Lifecycle callback.
      */
     trackedMutationCallback({ operation, resourceConfig }) {
         return async (record) => {
-            if (this.isRemoteApply(record))
+            if (this.isTrackingSuppressed(record))
                 return;
-            await SyncApiClient.queueLocalSync({
+            const data = SyncApiClient.queuedSyncData({
                 booleanAttributes: resourceConfig.booleanAttributes || [],
                 data: resourceConfig.trackedData ? resourceConfig.trackedData({ operation, record }) : undefined,
                 localOnlyAttributes: resourceConfig.localOnlyAttributes || [],
-                resource: record,
-                syncModel: this.config.syncModel,
-                syncType: this.defaultSyncType({ operation, record, resourceConfig })
+                resource: record
+            });
+            const syncType = this.defaultSyncType({ operation, record, resourceConfig });
+            await resourceConfig.modelClass.connection().afterCommit(async () => {
+                try {
+                    await SyncApiClient.queueLocalSync({
+                        data,
+                        resource: record,
+                        syncModel: this.config.syncModel,
+                        syncType
+                    });
+                }
+                catch (error) {
+                    await this.reportAfterCommitError(/** @type {Error} */ (error));
+                    return;
+                }
+                this.scheduleReplay();
             });
-            this.scheduleReplay();
         };
     }
+    /**
+     * Reports a post-commit tracked-queueing failure. The transaction has already
+     * committed when afterCommit callbacks run, so rethrowing here would poison
+     * the driver's awaited afterCommit chain (breaking unrelated callbacks) -
+     * instead the failure goes to the configured sync.client.onError hook, or is
+     * logged loudly through the client's logger when none is configured.
+     * @param {Error} error - Post-commit queueing failure.
+     * @returns {Promise<void>}
+     */
+    async reportAfterCommitError(error) {
+        if (this.config.onError) {
+            this.config.onError(error);
+            return;
+        }
+        await this.logger().error("SyncClient failed to queue a tracked mutation after commit", error);
+    }
+    /**
+     * Returns the lazily built client logger.
+     * @returns {Logger | {error: (...messages: Array<?>) => Promise<void>}} Client logger.
+     */
+    logger() {
+        this._logger ||= new Logger("SyncClient", { configuration: this.config.configuration });
+        return this._logger;
+    }
     /**
      * Whether a record is currently being written by pull-apply (echo suppression).
      * @param {?} record - Local model record.
@@ -166,6 +233,50 @@ export default class SyncClient {
     isRemoteApply(record) {
         return this._remoteApplyRecords.has(record);
     }
+    /**
+     * Whether tracked mutation queueing is currently suppressed for a record:
+     * either the record was marked as a remote apply (`markRemoteApply`, used by
+     * pull and realtime applies) or a `withoutTracking` callback is running on
+     * this client.
+     * @param {?} record - Local model record.
+     * @returns {boolean} Whether tracked queueing is suppressed for the record.
+     */
+    isTrackingSuppressed(record) {
+        return this._withoutTrackingDepth > 0 || this.isRemoteApply(record);
+    }
+    /**
+     * Runs a callback with tracked mutation queueing suppressed on this client -
+     * for code applying server-originated data outside the derived pull/realtime
+     * appliers (legacy pull paths, importers, sign-in backfills), so their writes
+     * are not echoed back to the server as device changes. Suppression covers the
+     * whole async duration of the callback (nested calls stack) and is
+     * client-wide while it runs: mutations from concurrently running tasks are
+     * also suppressed for that window, so prefer `markRemoteApply(record)` when
+     * writes from other flows can interleave.
+     * @template T
+     * @param {() => Promise<T> | T} callback - Work whose model writes should not queue tracked syncs.
+     * @returns {Promise<T>} The callback result.
+     */
+    async withoutTracking(callback) {
+        this._withoutTrackingDepth++;
+        try {
+            return await callback();
+        }
+        finally {
+            this._withoutTrackingDepth--;
+        }
+    }
+    /**
+     * Marks one record as being written from server-originated data so tracked
+     * mutation queueing skips it (record-precise suppression). The derived pull
+     * and realtime appliers use this internally around every applied write.
+     * @param {?} record - Local model record about to be written.
+     * @returns {() => void} Release callback re-enabling tracking for the record.
+     */
+    markRemoteApply(record) {
+        this._remoteApplyRecords.add(record);
+        return () => this._remoteApplyRecords.delete(record);
+    }
     /**
      * Registers this client as the app's current sync client.
      * @returns {void}
@@ -227,23 +338,7 @@ export default class SyncClient {
         await SyncApiClient.singleFlight(`velocious-sync-client-pull-${this._clientNumber}`, async () => {
             const authenticationToken = await this.config.authenticationToken();
             const scopeStore = this.scopeStore();
-            const pullResourceConfigs = this.pullResourceConfigs();
-            const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => {
-                this._remoteApplyRecords.add(record);
-                return () => this._remoteApplyRecords.delete(record);
-            });
-            /**
-             * Applies one pulled change, failing loudly instead of silently skipping unconfigured resources.
-             * @param {import("./sync-api-client-types.js").SyncChangeEnvelope} sync - Pulled change.
-             * @returns {Promise<import("./sync-api-client-types.js").SyncChangeApplyResult>} Apply result.
-             */
-            const applySync = async (sync) => {
-                const resourceType = sync.resourceType();
-                if (!resourceType || !pullResourceConfigs[resourceType]) {
-                    throw new Error(`No sync resource with pull attributes configured for pulled change: ${String(resourceType)}`);
-                }
-                return await applier(sync);
-            };
+            const applySync = this.remoteApplySync();
             const result = {
                 changed: false,
                 pages: 0,
@@ -277,6 +372,64 @@ export default class SyncClient {
         });
         return combinedResult;
     }
+    /**
+     * Builds the derived remote-change applier shared by pulls and realtime pushes:
+     * applies through the declared resource configs, registers each written record
+     * for echo suppression (tracked resources do not re-queue applied changes), and
+     * fails loudly instead of silently skipping unconfigured resources.
+     * @param {{source?: string}} [args] - Error context describing where the change came from.
+     * @returns {(sync: import("./sync-api-client-types.js").SyncChangeEnvelope) => Promise<import("./sync-api-client-types.js").SyncChangeApplyResult>} Loud remote-change applier.
+     */
+    remoteApplySync({ source = "pulled change" } = {}) {
+        const pullResourceConfigs = this.pullResourceConfigs();
+        const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => this.markRemoteApply(record));
+        return async (sync) => {
+            const resourceType = sync.resourceType();
+            if (!resourceType || !pullResourceConfigs[resourceType]) {
+                throw new Error(`No sync resource with pull attributes configured for ${source}: ${String(resourceType)}`);
+            }
+            return await applier(sync);
+        };
+    }
+    /**
+     * 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).
+     * @returns {Promise<void>}
+     */
+    async subscribeRealtime(context) {
+        await this.realtimeBridge().subscribe(context);
+    }
+    /**
+     * Unsubscribes the realtime channels and disconnects the websocket client (idempotent).
+     * @returns {Promise<void>}
+     */
+    async unsubscribeRealtime() {
+        await this.realtimeBridge().unsubscribe();
+    }
+    /**
+     * Reports the realtime subscription state and per-channel readiness.
+     * @returns {ReturnType<SyncRealtimeBridge["status"]>} Realtime status.
+     */
+    realtimeStatus() {
+        return this.realtimeBridge().status();
+    }
+    /**
+     * Awaits all pending realtime message applies and any scheduled
+     * pull-on-reconnect (useful in tests and shutdown flows).
+     * @returns {Promise<void>}
+     */
+    async waitForRealtimeApplied() {
+        await this.realtimeBridge().waitForApplied();
+    }
+    /**
+     * Returns the lazily built realtime bridge.
+     * @returns {SyncRealtimeBridge} Realtime bridge.
+     */
+    realtimeBridge() {
+        this._realtimeBridge ||= new SyncRealtimeBridge({ syncClient: this });
+        return this._realtimeBridge;
+    }
     /**
      * Queues a local model change as a pending sync row and schedules an immediate
      * replay attempt (kept pending while offline or when the backend rejects it).
@@ -426,10 +579,10 @@ function resourceConfigFromSyncDeclaration({ declaration, modelClass, resourceTy
     if (!normalizedDeclaration || typeof normalizedDeclaration !== "object" || Array.isArray(normalizedDeclaration)) {
         throw new Error(`${resourceType} static sync must be true or a sync declaration object, got: ${String(declaration)}`);
     }
-    const { afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, syncType, track, trackedData, ...restDeclaration } = normalizedDeclaration;
+    const { afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, realtime, syncType, track, trackedData, ...restDeclaration } = normalizedDeclaration;
     const unknownKeys = Object.keys(restDeclaration);
     if (unknownKeys.length > 0) {
-        throw new Error(`${resourceType} static sync received unknown keys: ${unknownKeys.join(", ")} (supported: afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, syncType, track, trackedData)`);
+        throw new Error(`${resourceType} static sync received unknown keys: ${unknownKeys.join(", ")} (supported: afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, realtime, syncType, track, trackedData)`);
     }
     if (syncType !== undefined && typeof syncType !== "function" && syncType !== "upsert") {
         throw new Error(`${resourceType} static sync syncType must be a function or the string "upsert", got: ${String(syncType)}`);
@@ -443,6 +596,7 @@ function resourceConfigFromSyncDeclaration({ declaration, modelClass, resourceTy
         findRecordForDelete,
         localOnlyAttributes: mergedAttributeNames(derived.localOnlyAttributes, localOnlyAttributes),
         modelClass,
+        realtime,
         syncType,
         track: normalizedTrack(track),
         trackedData
@@ -541,4 +695,4 @@ export function syncClient(configuration = Configuration.current()) {
 export async function sync(query) {
     return await SyncClient.current().sync(query);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-client.js","sourceRoot":"","sources":["../../../src/sync/sync-client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Configuration from \"../configuration.js\"\nimport {isBooleanColumnType} from \"../database/column-types.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\nimport {serializedScopeFromQuery} from \"./query-scope.js\"\nimport SyncApiClient from \"./sync-api-client.js\"\nimport SyncScopeStore from \"./sync-scope-store.js\"\nimport {currentSyncClient, setCurrentSyncClient} from \"./sync-client-registry.js\"\n\nlet clientCounter = 0\n\n/** @type {{create: \"afterCreate\", update: \"afterUpdate\", destroy: \"afterDestroy\"}} */\nconst TRACKED_CALLBACK_NAMES = {create: \"afterCreate\", destroy: \"afterDestroy\", update: \"afterUpdate\"}\n\n/** Attribute names treated as client-local sync bookkeeping when deriving localOnlyAttributes. */\nconst LOCAL_BOOKKEEPING_ATTRIBUTE_NAMES = [\"createdAt\", \"updatedAt\", \"lastSyncChangeAt\"]\n\n/** @type {WeakMap<Configuration, SyncClient>} */\nconst syncClientsByConfiguration = new WeakMap()\n\n/**\n * Declarative client-side sync driver.\n *\n * Everything is derived from the app's Velocious configuration: models declare\n * `static sync`, transport/auth/connectivity come from the `sync.client`\n * configuration block, and Velocious owns scope persistence, per-scope cursors,\n * pull paging/apply, local queueing, and online-gated replay. Declare sync\n * interest from queries:\n *\n *     await syncClient().start()\n *     await syncClient().sync(Event.where({partnerId}))\n */\nexport default class SyncClient {\n  /**\n   * Builds the sync client by deriving everything from the app's Velocious\n   * configuration: every registered model declaring `static sync` becomes a\n   * resource with booleanAttributes derived from column types and\n   * localOnlyAttributes derived from the primary key, createdAt/updatedAt, and\n   * sync bookkeeping columns; the pending-sync model is the registered \"Sync\"\n   * model; transport, auth, connectivity, and error reporting come from the\n   * `sync.client` configuration block, with the framework owning the\n   * `${mountPath}/changes` and `${mountPath}/replay` POSTers.\n   * @param {import(\"./sync-client-types.js\").SyncClientOptions} [options] - Optional overrides.\n   */\n  constructor(options = {}) {\n    const {configuration = Configuration.current(), legacyCursor, scopeStore, syncModel, ...restOptions} = options\n\n    restArgsError(restOptions)\n\n    const clientConfiguration = configuration.getSyncConfiguration().client\n\n    if (!clientConfiguration) {\n      throw new Error(\"SyncClient requires a sync.client configuration block: new Configuration({sync: {client: {authenticationToken, transport}}})\")\n    }\n\n    const modelClasses = configuration.getModelClasses()\n    /** @type {Record<string, import(\"./sync-client-types.js\").SyncClientResourceConfig>} */\n    const resources = {}\n\n    for (const modelClass of Object.values(modelClasses)) {\n      if (!modelClass.sync) continue\n\n      const resourceType = modelClass.getModelName()\n\n      resources[resourceType] = resourceConfigFromSyncDeclaration({declaration: modelClass.sync, modelClass, resourceType})\n    }\n\n    if (Object.keys(resources).length === 0) {\n      throw new Error(\"SyncClient found no registered models declaring static sync - declare `static sync = true` (or a sync declaration object) on the models that should sync\")\n    }\n\n    const resolvedSyncModel = syncModel || modelClasses.Sync\n\n    if (!resolvedSyncModel) {\n      throw new Error(\"SyncClient requires a registered \\\"Sync\\\" model for pending local sync rows (or pass options.syncModel)\")\n    }\n\n    /** @type {import(\"./sync-client-types.js\").SyncClientConfig} */\n    this.config = {\n      authenticationToken: clientConfiguration.authenticationToken,\n      batchSize: clientConfiguration.batchSize,\n      configuration,\n      isOnline: clientConfiguration.isOnline,\n      legacyCursor,\n      onError: clientConfiguration.onError,\n      postChanges: transportPoster({path: `${clientConfiguration.mountPath}/changes`, transport: clientConfiguration.transport}),\n      postReplay: transportPoster({path: `${clientConfiguration.mountPath}/replay`, transport: clientConfiguration.transport}),\n      resources,\n      syncModel: resolvedSyncModel\n    }\n    this._clientNumber = ++clientCounter\n    /** @type {import(\"./sync-scope-store.js\").default | null} */\n    this._scopeStore = scopeStore || null\n    /** @type {Promise<void> | null} */\n    this._scheduledReplay = null\n    /** @type {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig> | null} */\n    this._pullResourceConfigs = null\n    /** @type {Array<{callback: (record: ?) => Promise<void>, callbackName: \"afterCreate\" | \"afterUpdate\" | \"afterDestroy\", modelClass: ?}>} */\n    this._trackedCallbacks = []\n    /** @type {WeakSet<object>} */\n    this._remoteApplyRecords = new WeakSet()\n    this._started = false\n  }\n\n  /**\n   * Registers automatic mutation tracking for every resource with `track` enabled:\n   * local model creates/updates/destroys queue pending sync rows and schedule an\n   * immediate replay attempt, without app-side queue calls.\n   * @returns {Promise<void>}\n   */\n  async start() {\n    if (this._started) return\n\n    this._started = true\n\n    for (const [resourceType, resourceConfig] of Object.entries(this.config.resources)) {\n      const operations = this.trackedOperations({resourceConfig, resourceType})\n\n      for (const operation of operations) {\n        const callbackName = TRACKED_CALLBACK_NAMES[operation]\n        const callback = this.trackedMutationCallback({operation, resourceConfig})\n\n        resourceConfig.modelClass[callbackName](callback)\n        this._trackedCallbacks.push({callback, callbackName, modelClass: resourceConfig.modelClass})\n      }\n    }\n  }\n\n  /**\n   * Unregisters all tracking callbacks (tests, sign-out, hot reload).\n   * @returns {void}\n   */\n  stop() {\n    for (const {callback, callbackName, modelClass} of this._trackedCallbacks) {\n      modelClass.unregisterLifecycleCallback(callbackName, callback)\n    }\n\n    this._trackedCallbacks = []\n    this._started = false\n  }\n\n  /**\n   * Resolves and validates the tracked operations for a resource config.\n   * @param {{resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig, resourceType: string}} args - Resource config and name.\n   * @returns {Array<\"create\" | \"update\" | \"destroy\">} Tracked operations.\n   */\n  trackedOperations({resourceConfig, resourceType}) {\n    const track = resourceConfig.track\n\n    if (track === undefined || track === false) return []\n    if (track === true) return [\"create\", \"update\", \"destroy\"]\n\n    if (!track || typeof track !== \"object\" || !Array.isArray(track.operations) || track.operations.length === 0) {\n      throw new Error(`SyncClient resource ${resourceType} track must be true or {operations: [...]}`)\n    }\n\n    for (const operation of track.operations) {\n      if (!(operation in TRACKED_CALLBACK_NAMES)) {\n        throw new Error(`SyncClient resource ${resourceType} track.operations must be create/update/destroy, got: ${String(operation)}`)\n      }\n    }\n\n    return track.operations\n  }\n\n  /**\n   * Builds the lifecycle callback queueing one tracked mutation.\n   * @param {{operation: \"create\" | \"update\" | \"destroy\", resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig}} args - Operation and resource config.\n   * @returns {(record: ?) => Promise<void>} Lifecycle callback.\n   */\n  trackedMutationCallback({operation, resourceConfig}) {\n    return async (record) => {\n      if (this.isRemoteApply(record)) return\n\n      await SyncApiClient.queueLocalSync({\n        booleanAttributes: resourceConfig.booleanAttributes || [],\n        data: resourceConfig.trackedData ? resourceConfig.trackedData({operation, record}) : undefined,\n        localOnlyAttributes: resourceConfig.localOnlyAttributes || [],\n        resource: record,\n        syncModel: this.config.syncModel,\n        syncType: this.defaultSyncType({operation, record, resourceConfig})\n      })\n\n      this.scheduleReplay()\n    }\n  }\n\n  /**\n   * Whether a record is currently being written by pull-apply (echo suppression).\n   * @param {?} record - Local model record.\n   * @returns {boolean} Whether the record write originates from a remote change.\n   */\n  isRemoteApply(record) {\n    return this._remoteApplyRecords.has(record)\n  }\n\n  /**\n   * Registers this client as the app's current sync client.\n   * @returns {void}\n   */\n  setCurrent() {\n    setCurrentSyncClient(this)\n  }\n\n  /**\n   * Returns the app's current sync client.\n   * @returns {SyncClient} Current sync client.\n   */\n  static current() {\n    return /** @type {SyncClient} */ (currentSyncClient())\n  }\n\n  /**\n   * Builds a sync client derived from the given configuration. Alias for\n   * `new SyncClient({configuration, ...options})`.\n   * @param {Configuration} [configuration] - Configuration owning the registered models and the sync.client block. Defaults to the current configuration.\n   * @param {Omit<import(\"./sync-client-types.js\").SyncClientOptions, \"configuration\">} [options] - Optional overrides.\n   * @returns {SyncClient} Sync client derived from the configuration.\n   */\n  static fromConfiguration(configuration = Configuration.current(), options = {}) {\n    return new SyncClient({...options, configuration})\n  }\n\n  /**\n   * Declares (or re-activates) a sync scope from a model query and pulls it when online.\n   * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query declaring the sync scope.\n   * @returns {Promise<{scope: import(\"./sync-client-types.js\").SerializedSyncScope, pulled: import(\"./sync-api-client-types.js\").SyncChangesResult | null}>} Declared scope and pull result (null while offline).\n   */\n  async sync(query) {\n    const scope = serializedScopeFromQuery(query)\n    const scopeStore = this.scopeStore()\n    const scopeRow = await scopeStore.findOrCreateScope(scope)\n\n    if (!scopeRow.cursorPayload && this.config.legacyCursor) {\n      const legacyCursorPayload = await this.config.legacyCursor({scope})\n      const legacyCursor = SyncApiClient.syncCursorFromPayload(legacyCursorPayload)\n\n      if (legacyCursor) await scopeStore.saveCursor(scopeRow, legacyCursor)\n    }\n\n    return {pulled: await this.pull(), scope}\n  }\n\n  /**\n   * Deactivates the sync scope declared by a model query.\n   * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query whose scope should stop syncing.\n   * @returns {Promise<void>}\n   */\n  async unsync(query) {\n    await this.scopeStore().deactivate(serializedScopeFromQuery(query))\n  }\n\n  /**\n   * Pulls changes for every active scope with per-scope cursors (single-flighted, online-gated).\n   * @returns {Promise<import(\"./sync-api-client-types.js\").SyncChangesResult | null>} Combined pull result, or null while offline.\n   */\n  async pull() {\n    if (!(await this.isOnline())) return null\n\n    /** @type {import(\"./sync-api-client-types.js\").SyncChangesResult | null} */\n    let combinedResult = null\n\n    await SyncApiClient.singleFlight(`velocious-sync-client-pull-${this._clientNumber}`, async () => {\n      const authenticationToken = await this.config.authenticationToken()\n      const scopeStore = this.scopeStore()\n      const pullResourceConfigs = this.pullResourceConfigs()\n      const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => {\n        this._remoteApplyRecords.add(record)\n\n        return () => this._remoteApplyRecords.delete(record)\n      })\n      /**\n       * Applies one pulled change, failing loudly instead of silently skipping unconfigured resources.\n       * @param {import(\"./sync-api-client-types.js\").SyncChangeEnvelope} sync - Pulled change.\n       * @returns {Promise<import(\"./sync-api-client-types.js\").SyncChangeApplyResult>} Apply result.\n       */\n      const applySync = async (sync) => {\n        const resourceType = sync.resourceType()\n\n        if (!resourceType || !pullResourceConfigs[resourceType]) {\n          throw new Error(`No sync resource with pull attributes configured for pulled change: ${String(resourceType)}`)\n        }\n\n        return await applier(sync)\n      }\n      const result = {\n        changed: false,\n        pages: 0,\n        resourceChanged: /** @type {Record<string, boolean>} */ ({}),\n        resourceCounts: /** @type {Record<string, number>} */ ({}),\n        syncedCount: 0\n      }\n\n      for (const scopeRow of await scopeStore.activeScopes()) {\n        const scopeResult = await SyncApiClient.pullChanges({\n          applySync,\n          authenticationToken,\n          batchSize: this.config.batchSize,\n          loadCursor: async () => await scopeStore.loadCursor(scopeRow),\n          postChanges: async (payload) => await this.config.postChanges({\n            ...payload,\n            scope: {conditions: scopeRow.conditions, resourceType: scopeRow.resourceType}\n          }),\n          saveCursor: async (cursor) => await scopeStore.saveCursor(scopeRow, cursor)\n        })\n\n        result.changed ||= scopeResult.changed\n        result.pages += scopeResult.pages\n        result.syncedCount += scopeResult.syncedCount\n\n        for (const [resourceType, count] of Object.entries(scopeResult.resourceCounts)) {\n          result.resourceCounts[resourceType] = (result.resourceCounts[resourceType] || 0) + count\n        }\n        for (const [resourceType, changed] of Object.entries(scopeResult.resourceChanged)) {\n          result.resourceChanged[resourceType] ||= changed\n        }\n      }\n\n      combinedResult = result\n    })\n\n    return combinedResult\n  }\n\n  /**\n   * Queues a local model change as a pending sync row and schedules an immediate\n   * replay attempt (kept pending while offline or when the backend rejects it).\n   * @param {{resource: ?, data?: Record<string, ?>, syncType?: string}} args - Queue args.\n   * @returns {Promise<?>} Pending local sync row.\n   */\n  async queue({data, resource, syncType}) {\n    const resourceConfig = this.resourceConfigFor(resource)\n    const syncRow = await SyncApiClient.queueLocalSync({\n      booleanAttributes: resourceConfig.booleanAttributes || [],\n      data,\n      localOnlyAttributes: resourceConfig.localOnlyAttributes || [],\n      resource,\n      syncModel: this.config.syncModel,\n      syncType: syncType ?? this.defaultSyncType({operation: \"update\", record: resource, resourceConfig})\n    })\n\n    this.scheduleReplay()\n\n    return syncRow\n  }\n\n  /**\n   * Drains pending local sync rows to the backend (single-flighted, online-gated).\n   * Rows are only marked successful after the backend acknowledges them.\n   * @returns {Promise<void>}\n   */\n  async replayPending() {\n    if (!(await this.isOnline())) return\n\n    await SyncApiClient.singleFlight(`velocious-sync-client-replay-${this._clientNumber}`, async () => {\n      await SyncApiClient.replayLocalSyncs({\n        authenticationToken: await this.config.authenticationToken(),\n        batchSize: this.config.batchSize,\n        postReplay: this.config.postReplay,\n        syncModel: this.config.syncModel\n      })\n    })\n  }\n\n  /**\n   * Schedules a background replay attempt without blocking the caller.\n   * Failures go to config.onError (or rethrow when none is configured).\n   * @returns {void}\n   */\n  scheduleReplay() {\n    this._scheduledReplay = (async () => {\n      try {\n        await this.replayPending()\n      } catch (error) {\n        this.reportError(/** @type {Error} */ (error))\n      }\n    })()\n  }\n\n  /**\n   * Awaits the last scheduled background replay (useful in tests and shutdown flows).\n   * @returns {Promise<void>}\n   */\n  async waitForScheduledReplay() {\n    if (this._scheduledReplay) await this._scheduledReplay\n  }\n\n  /**\n   * Reports a background sync failure.\n   * @param {Error} error - Background failure.\n   * @returns {void}\n   */\n  reportError(error) {\n    if (this.config.onError) {\n      this.config.onError(error)\n      return\n    }\n\n    throw error\n  }\n\n  /**\n   * Resolves connectivity through the configured gate.\n   * @returns {Promise<boolean>} Whether the backend is considered reachable.\n   */\n  async isOnline() {\n    if (!this.config.isOnline) return true\n\n    return (await this.config.isOnline()) !== false\n  }\n\n  /**\n   * Returns the scope store backing declared scopes and cursors.\n   * @returns {import(\"./sync-scope-store.js\").default} Scope store.\n   */\n  scopeStore() {\n    this._scopeStore ||= new SyncScopeStore({configuration: this.config.configuration})\n\n    return this._scopeStore\n  }\n\n  /**\n   * Resolves the declared resource config for a local record.\n   * @param {?} resource - Local model record.\n   * @returns {import(\"./sync-client-types.js\").SyncClientResourceConfig} Declared resource config.\n   */\n  resourceConfigFor(resource) {\n    const modelClass = resource?.constructor\n\n    if (typeof modelClass?.getModelName !== \"function\") {\n      throw new Error(`Sync resources must be model records with a static getModelName(), got: ${String(resource)}`)\n    }\n\n    const resourceType = modelClass.getModelName()\n    const resourceConfig = this.config.resources[resourceType]\n\n    if (!resourceConfig) throw new Error(`No sync resource configured for: ${resourceType}`)\n\n    return resourceConfig\n  }\n\n  /**\n   * Resolves the sync type for a mutation through the resource config. The\n   * \"upsert\" flag queues creates and updates as \"update\" rows (the server\n   * upserts by resource id) and destroys as \"delete\" rows.\n   * @param {{operation: \"create\" | \"update\" | \"destroy\", record: ?, resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig}} args - Mutation args.\n   * @returns {string} Sync type.\n   */\n  defaultSyncType({operation, record, resourceConfig}) {\n    if (typeof resourceConfig.syncType === \"function\") return resourceConfig.syncType({operation, record})\n    if (operation === \"destroy\") return \"delete\"\n    if (resourceConfig.syncType === \"upsert\") return \"update\"\n\n    return operation\n  }\n\n  /**\n   * Derives the pull-apply resource configs from the declared resources.\n   * @returns {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig>} Pull-apply resource configs.\n   */\n  pullResourceConfigs() {\n    this._pullResourceConfigs ||= /** @type {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig>} */ (Object.fromEntries(\n      Object.entries(this.config.resources)\n        .filter(([, resource]) => Boolean(resource.attributes))\n        .map(([resourceType, resource]) => [resourceType, {\n          afterApply: resource.afterApply,\n          attributes: /** @type {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} */ (resource.attributes),\n          enabled: true,\n          findRecord: resource.findRecord,\n          findRecordForDelete: resource.findRecordForDelete,\n          modelClass: resource.modelClass\n        }])\n    ))\n\n    return this._pullResourceConfigs\n  }\n}\n\n/**\n * Builds one resource config from a model's `static sync` declaration plus its\n * derived column metadata.\n * @param {{declaration: import(\"./sync-client-types.js\").ModelSyncDeclaration, modelClass: ?, resourceType: string}} args - Declaration args.\n * @returns {import(\"./sync-client-types.js\").SyncClientResourceConfig} Derived resource config.\n */\nfunction resourceConfigFromSyncDeclaration({declaration, modelClass, resourceType}) {\n  const normalizedDeclaration = declaration === true ? {} : declaration\n\n  if (!normalizedDeclaration || typeof normalizedDeclaration !== \"object\" || Array.isArray(normalizedDeclaration)) {\n    throw new Error(`${resourceType} static sync must be true or a sync declaration object, got: ${String(declaration)}`)\n  }\n\n  const {afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, syncType, track, trackedData, ...restDeclaration} = normalizedDeclaration\n  const unknownKeys = Object.keys(restDeclaration)\n\n  if (unknownKeys.length > 0) {\n    throw new Error(`${resourceType} static sync received unknown keys: ${unknownKeys.join(\", \")} (supported: afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, syncType, track, trackedData)`)\n  }\n  if (syncType !== undefined && typeof syncType !== \"function\" && syncType !== \"upsert\") {\n    throw new Error(`${resourceType} static sync syncType must be a function or the string \"upsert\", got: ${String(syncType)}`)\n  }\n\n  const derived = derivedSyncAttributes({modelClass, resourceType})\n\n  return {\n    afterApply,\n    attributes,\n    booleanAttributes: mergedAttributeNames(derived.booleanAttributes, booleanAttributes),\n    findRecord,\n    findRecordForDelete,\n    localOnlyAttributes: mergedAttributeNames(derived.localOnlyAttributes, localOnlyAttributes),\n    modelClass,\n    syncType,\n    track: normalizedTrack(track),\n    trackedData\n  }\n}\n\n/**\n * Derives boolean and local-only attribute names from a model's column metadata:\n * booleans from boolean column types; local-only from the primary key,\n * createdAt/updatedAt, and sync bookkeeping columns.\n * @param {{modelClass: ?, resourceType: string}} args - Derivation args.\n * @returns {{booleanAttributes: string[], localOnlyAttributes: string[]}} Derived attribute names.\n */\nfunction derivedSyncAttributes({modelClass, resourceType}) {\n  if (\n    typeof modelClass.getColumnNames !== \"function\" ||\n    typeof modelClass.getColumnNameToAttributeNameMap !== \"function\" ||\n    typeof modelClass.getColumnTypeByName !== \"function\" ||\n    typeof modelClass.primaryKey !== \"function\" ||\n    typeof modelClass.hasPrimaryKey !== \"function\"\n  ) {\n    throw new Error(`${resourceType} static sync requires a Velocious model class with column metadata (getColumnNames, getColumnNameToAttributeNameMap, getColumnTypeByName, primaryKey, hasPrimaryKey)`)\n  }\n\n  const columnNameToAttributeName = modelClass.getColumnNameToAttributeNameMap()\n  /** @type {string[]} */\n  const booleanAttributes = []\n  /** @type {string[]} */\n  const localOnlyAttributes = []\n\n  if (modelClass.hasPrimaryKey()) {\n    const primaryKeyColumn = modelClass.primaryKey()\n\n    localOnlyAttributes.push(columnNameToAttributeName[primaryKeyColumn] || primaryKeyColumn)\n  }\n\n  for (const columnName of modelClass.getColumnNames()) {\n    const attributeName = columnNameToAttributeName[columnName] || columnName\n    const columnType = modelClass.getColumnTypeByName(columnName)\n\n    if (LOCAL_BOOKKEEPING_ATTRIBUTE_NAMES.includes(attributeName) && !localOnlyAttributes.includes(attributeName)) {\n      localOnlyAttributes.push(attributeName)\n    }\n    if (columnType && isBooleanColumnType(columnType)) {\n      booleanAttributes.push(attributeName)\n    }\n  }\n\n  return {booleanAttributes, localOnlyAttributes}\n}\n\n/**\n * Merges derived attribute names with declared extras into a sorted, duplicate-free list.\n * @param {string[]} derived - Derived attribute names.\n * @param {string[] | undefined} declared - Declared extra attribute names.\n * @returns {string[]} Merged attribute names.\n */\nfunction mergedAttributeNames(derived, declared) {\n  return [...new Set([...derived, ...(declared || [])])].sort()\n}\n\n/**\n * Normalizes a declaration's track value: an operations array is shorthand for\n * the {operations} form.\n * @param {import(\"./sync-client-types.js\").ModelSyncDeclarationConfig[\"track\"]} track - Declared track value.\n * @returns {import(\"./sync-client-types.js\").SyncClientResourceConfig[\"track\"]} Normalized track value.\n */\nfunction normalizedTrack(track) {\n  if (Array.isArray(track)) return {operations: track}\n\n  return track\n}\n\n/**\n * Builds a framework-owned sync endpoint POSTer over the configured transport.\n * @param {{path: string, transport: import(\"../configuration-types.js\").VelociousSyncClientTransport}} args - Poster args.\n * @returns {(payload: Record<string, ?>) => Promise<?>} Sync endpoint POSTer.\n */\nfunction transportPoster({path, transport}) {\n  return async (payload) => {\n    const response = await transport.post(path, payload)\n\n    if (!response || typeof response.json !== \"function\") {\n      throw new Error(`sync.client transport.post must resolve to a response with a json() method for ${path} (like the frontend-model websocket client)`)\n    }\n\n    return await response.json()\n  }\n}\n\n/**\n * Lazily builds (and memoizes per configuration) the sync client derived from the\n * app's Velocious configuration and registers it as the current sync client.\n * @param {Configuration} [configuration] - Configuration owning the registered models and the sync.client block. Defaults to the current configuration.\n * @returns {SyncClient} Memoized sync client for the configuration.\n */\nexport function syncClient(configuration = Configuration.current()) {\n  let client = syncClientsByConfiguration.get(configuration)\n\n  if (!client) {\n    client = SyncClient.fromConfiguration(configuration)\n    syncClientsByConfiguration.set(configuration, client)\n    client.setCurrent()\n  }\n\n  return client\n}\n\n/**\n * Declares a sync scope on the current sync client.\n * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query declaring the sync scope.\n * @returns {Promise<{scope: import(\"./sync-client-types.js\").SerializedSyncScope, pulled: import(\"./sync-api-client-types.js\").SyncChangesResult | null}>} Declared scope and pull result.\n */\nexport async function sync(query) {\n  return await SyncClient.current().sync(query)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-client.js","sourceRoot":"","sources":["../../../src/sync/sync-client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Configuration from \"../configuration.js\"\nimport {isBooleanColumnType} from \"../database/column-types.js\"\nimport Logger from \"../logger.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\n\nimport {serializedScopeFromQuery} from \"./query-scope.js\"\nimport SyncApiClient from \"./sync-api-client.js\"\nimport SyncRealtimeBridge from \"./sync-realtime-bridge.js\"\nimport SyncScopeStore from \"./sync-scope-store.js\"\nimport {currentSyncClient, setCurrentSyncClient} from \"./sync-client-registry.js\"\n\nlet clientCounter = 0\n\n/** @type {{create: \"afterCreate\", update: \"afterUpdate\", destroy: \"afterDestroy\"}} */\nconst TRACKED_CALLBACK_NAMES = {create: \"afterCreate\", destroy: \"afterDestroy\", update: \"afterUpdate\"}\n\n/**\n * Operations tracked by default for models declaring `static sync` without a\n * `track` key: local creates and updates queue automatically. Destroys are not\n * tracked by default because a local destroy is often cache eviction rather\n * than a server delete; opt in with `track: true` or an operations list.\n * @type {Array<\"create\" | \"update\" | \"destroy\">} */\nconst DEFAULT_TRACKED_OPERATIONS = [\"create\", \"update\"]\n\n/** Attribute names treated as client-local sync bookkeeping when deriving localOnlyAttributes. */\nconst LOCAL_BOOKKEEPING_ATTRIBUTE_NAMES = [\"createdAt\", \"updatedAt\", \"lastSyncChangeAt\"]\n\n/** @type {WeakMap<Configuration, SyncClient>} */\nconst syncClientsByConfiguration = new WeakMap()\n\n/**\n * Declarative client-side sync driver.\n *\n * Everything is derived from the app's Velocious configuration: models declare\n * `static sync`, transport/auth/connectivity come from the `sync.client`\n * configuration block, and Velocious owns scope persistence, per-scope cursors,\n * pull paging/apply, local queueing, and online-gated replay. Declare sync\n * interest from queries:\n *\n *     await syncClient().start()\n *     await syncClient().sync(Event.where({partnerId}))\n */\nexport default class SyncClient {\n  /**\n   * Builds the sync client by deriving everything from the app's Velocious\n   * configuration: every registered model declaring `static sync` becomes a\n   * resource with booleanAttributes derived from column types and\n   * localOnlyAttributes derived from the primary key, createdAt/updatedAt, and\n   * sync bookkeeping columns; the pending-sync model is the registered \"Sync\"\n   * model; transport, auth, connectivity, and error reporting come from the\n   * `sync.client` configuration block, with the framework owning the\n   * `${mountPath}/changes` and `${mountPath}/replay` POSTers.\n   * @param {import(\"./sync-client-types.js\").SyncClientOptions} [options] - Optional overrides.\n   */\n  constructor(options = {}) {\n    const {configuration = Configuration.current(), legacyCursor, scopeStore, syncModel, ...restOptions} = options\n\n    restArgsError(restOptions)\n\n    const clientConfiguration = configuration.getSyncConfiguration().client\n\n    if (!clientConfiguration) {\n      throw new Error(\"SyncClient requires a sync.client configuration block: new Configuration({sync: {client: {authenticationToken, transport}}})\")\n    }\n\n    const modelClasses = configuration.getModelClasses()\n    /** @type {Record<string, import(\"./sync-client-types.js\").SyncClientResourceConfig>} */\n    const resources = {}\n\n    for (const modelClass of Object.values(modelClasses)) {\n      if (!modelClass.sync) continue\n\n      const resourceType = modelClass.getModelName()\n\n      resources[resourceType] = resourceConfigFromSyncDeclaration({declaration: modelClass.sync, modelClass, resourceType})\n    }\n\n    if (Object.keys(resources).length === 0) {\n      throw new Error(\"SyncClient found no registered models declaring static sync - declare `static sync = true` (or a sync declaration object) on the models that should sync\")\n    }\n\n    const resolvedSyncModel = syncModel || modelClasses.Sync\n\n    if (!resolvedSyncModel) {\n      throw new Error(\"SyncClient requires a registered \\\"Sync\\\" model for pending local sync rows (or pass options.syncModel)\")\n    }\n\n    /** @type {import(\"./sync-client-types.js\").SyncClientConfig} */\n    this.config = {\n      authenticationToken: clientConfiguration.authenticationToken,\n      batchSize: clientConfiguration.batchSize,\n      configuration,\n      isOnline: clientConfiguration.isOnline,\n      legacyCursor,\n      onError: clientConfiguration.onError,\n      postChanges: transportPoster({path: `${clientConfiguration.mountPath}/changes`, transport: clientConfiguration.transport}),\n      postReplay: transportPoster({path: `${clientConfiguration.mountPath}/replay`, transport: clientConfiguration.transport}),\n      realtime: clientConfiguration.realtime,\n      resources,\n      syncModel: resolvedSyncModel\n    }\n    this._clientNumber = ++clientCounter\n    /** @type {SyncRealtimeBridge | null} */\n    this._realtimeBridge = null\n    /** @type {import(\"./sync-scope-store.js\").default | null} */\n    this._scopeStore = scopeStore || null\n    /** @type {Promise<void> | null} */\n    this._scheduledReplay = null\n    /** @type {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig> | null} */\n    this._pullResourceConfigs = null\n    /** @type {Array<{callback: (record: ?) => Promise<void>, callbackName: \"afterCreate\" | \"afterUpdate\" | \"afterDestroy\", modelClass: ?}>} */\n    this._trackedCallbacks = []\n    /** @type {WeakSet<object>} */\n    this._remoteApplyRecords = new WeakSet()\n    this._withoutTrackingDepth = 0\n    /** @type {Logger | {error: (...messages: Array<?>) => Promise<void>} | null} */\n    this._logger = null\n    this._started = false\n  }\n\n  /**\n   * Registers automatic mutation tracking for every declared resource (on by\n   * default: local creates and updates queue pending sync rows once their\n   * transaction commits and schedule an immediate replay attempt, without\n   * app-side queue calls). `track: false` resources are skipped; `track: true`\n   * adds destroys; an operations list narrows the tracked operations.\n   * @returns {Promise<void>}\n   */\n  async start() {\n    if (this._started) return\n\n    this._started = true\n\n    for (const [resourceType, resourceConfig] of Object.entries(this.config.resources)) {\n      const operations = this.trackedOperations({resourceConfig, resourceType})\n\n      for (const operation of operations) {\n        const callbackName = TRACKED_CALLBACK_NAMES[operation]\n        const callback = this.trackedMutationCallback({operation, resourceConfig})\n\n        resourceConfig.modelClass[callbackName](callback)\n        this._trackedCallbacks.push({callback, callbackName, modelClass: resourceConfig.modelClass})\n      }\n    }\n  }\n\n  /**\n   * Unregisters all tracking callbacks (tests, sign-out, hot reload).\n   * @returns {void}\n   */\n  stop() {\n    for (const {callback, callbackName, modelClass} of this._trackedCallbacks) {\n      modelClass.unregisterLifecycleCallback(callbackName, callback)\n    }\n\n    this._trackedCallbacks = []\n    this._started = false\n  }\n\n  /**\n   * Resolves and validates the tracked operations for a resource config.\n   * Tracking is on by default: models declaring `static sync` without a `track`\n   * key queue local creates and updates automatically; `track: false` opts a\n   * model out (for models written by non-user flows).\n   * @param {{resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig, resourceType: string}} args - Resource config and name.\n   * @returns {Array<\"create\" | \"update\" | \"destroy\">} Tracked operations.\n   */\n  trackedOperations({resourceConfig, resourceType}) {\n    const track = resourceConfig.track\n\n    if (track === false) return []\n    if (track === undefined) return DEFAULT_TRACKED_OPERATIONS\n    if (track === true) return [\"create\", \"update\", \"destroy\"]\n\n    if (!track || typeof track !== \"object\" || !Array.isArray(track.operations) || track.operations.length === 0) {\n      throw new Error(`SyncClient resource ${resourceType} track must be true or {operations: [...]}`)\n    }\n\n    for (const operation of track.operations) {\n      if (!(operation in TRACKED_CALLBACK_NAMES)) {\n        throw new Error(`SyncClient resource ${resourceType} track.operations must be create/update/destroy, got: ${String(operation)}`)\n      }\n    }\n\n    return track.operations\n  }\n\n  /**\n   * Builds the lifecycle callback queueing one tracked mutation. The queued\n   * payload and sync type are snapshotted at mutation-callback time, so\n   * afterSave hooks assigning unsaved attributes (or any later drift on the\n   * record) cannot change what gets queued vs what was committed. Queueing is\n   * deferred through the model connection's afterCommit hook so it only runs\n   * once the mutation's transaction has committed (immediately when no\n   * transaction is open) - queued syncs never reference rolled-back rows.\n   * Post-commit queue failures are reported without rethrowing into the\n   * driver's afterCommit chain (see reportAfterCommitError).\n   * @param {{operation: \"create\" | \"update\" | \"destroy\", resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig}} args - Operation and resource config.\n   * @returns {(record: ?) => Promise<void>} Lifecycle callback.\n   */\n  trackedMutationCallback({operation, resourceConfig}) {\n    return async (record) => {\n      if (this.isTrackingSuppressed(record)) return\n\n      const data = SyncApiClient.queuedSyncData({\n        booleanAttributes: resourceConfig.booleanAttributes || [],\n        data: resourceConfig.trackedData ? resourceConfig.trackedData({operation, record}) : undefined,\n        localOnlyAttributes: resourceConfig.localOnlyAttributes || [],\n        resource: record\n      })\n      const syncType = this.defaultSyncType({operation, record, resourceConfig})\n\n      await resourceConfig.modelClass.connection().afterCommit(async () => {\n        try {\n          await SyncApiClient.queueLocalSync({\n            data,\n            resource: record,\n            syncModel: this.config.syncModel,\n            syncType\n          })\n        } catch (error) {\n          await this.reportAfterCommitError(/** @type {Error} */ (error))\n\n          return\n        }\n\n        this.scheduleReplay()\n      })\n    }\n  }\n\n  /**\n   * Reports a post-commit tracked-queueing failure. The transaction has already\n   * committed when afterCommit callbacks run, so rethrowing here would poison\n   * the driver's awaited afterCommit chain (breaking unrelated callbacks) -\n   * instead the failure goes to the configured sync.client.onError hook, or is\n   * logged loudly through the client's logger when none is configured.\n   * @param {Error} error - Post-commit queueing failure.\n   * @returns {Promise<void>}\n   */\n  async reportAfterCommitError(error) {\n    if (this.config.onError) {\n      this.config.onError(error)\n\n      return\n    }\n\n    await this.logger().error(\"SyncClient failed to queue a tracked mutation after commit\", error)\n  }\n\n  /**\n   * Returns the lazily built client logger.\n   * @returns {Logger | {error: (...messages: Array<?>) => Promise<void>}} Client logger.\n   */\n  logger() {\n    this._logger ||= new Logger(\"SyncClient\", {configuration: this.config.configuration})\n\n    return this._logger\n  }\n\n  /**\n   * Whether a record is currently being written by pull-apply (echo suppression).\n   * @param {?} record - Local model record.\n   * @returns {boolean} Whether the record write originates from a remote change.\n   */\n  isRemoteApply(record) {\n    return this._remoteApplyRecords.has(record)\n  }\n\n  /**\n   * Whether tracked mutation queueing is currently suppressed for a record:\n   * either the record was marked as a remote apply (`markRemoteApply`, used by\n   * pull and realtime applies) or a `withoutTracking` callback is running on\n   * this client.\n   * @param {?} record - Local model record.\n   * @returns {boolean} Whether tracked queueing is suppressed for the record.\n   */\n  isTrackingSuppressed(record) {\n    return this._withoutTrackingDepth > 0 || this.isRemoteApply(record)\n  }\n\n  /**\n   * Runs a callback with tracked mutation queueing suppressed on this client -\n   * for code applying server-originated data outside the derived pull/realtime\n   * appliers (legacy pull paths, importers, sign-in backfills), so their writes\n   * are not echoed back to the server as device changes. Suppression covers the\n   * whole async duration of the callback (nested calls stack) and is\n   * client-wide while it runs: mutations from concurrently running tasks are\n   * also suppressed for that window, so prefer `markRemoteApply(record)` when\n   * writes from other flows can interleave.\n   * @template T\n   * @param {() => Promise<T> | T} callback - Work whose model writes should not queue tracked syncs.\n   * @returns {Promise<T>} The callback result.\n   */\n  async withoutTracking(callback) {\n    this._withoutTrackingDepth++\n\n    try {\n      return await callback()\n    } finally {\n      this._withoutTrackingDepth--\n    }\n  }\n\n  /**\n   * Marks one record as being written from server-originated data so tracked\n   * mutation queueing skips it (record-precise suppression). The derived pull\n   * and realtime appliers use this internally around every applied write.\n   * @param {?} record - Local model record about to be written.\n   * @returns {() => void} Release callback re-enabling tracking for the record.\n   */\n  markRemoteApply(record) {\n    this._remoteApplyRecords.add(record)\n\n    return () => this._remoteApplyRecords.delete(record)\n  }\n\n  /**\n   * Registers this client as the app's current sync client.\n   * @returns {void}\n   */\n  setCurrent() {\n    setCurrentSyncClient(this)\n  }\n\n  /**\n   * Returns the app's current sync client.\n   * @returns {SyncClient} Current sync client.\n   */\n  static current() {\n    return /** @type {SyncClient} */ (currentSyncClient())\n  }\n\n  /**\n   * Builds a sync client derived from the given configuration. Alias for\n   * `new SyncClient({configuration, ...options})`.\n   * @param {Configuration} [configuration] - Configuration owning the registered models and the sync.client block. Defaults to the current configuration.\n   * @param {Omit<import(\"./sync-client-types.js\").SyncClientOptions, \"configuration\">} [options] - Optional overrides.\n   * @returns {SyncClient} Sync client derived from the configuration.\n   */\n  static fromConfiguration(configuration = Configuration.current(), options = {}) {\n    return new SyncClient({...options, configuration})\n  }\n\n  /**\n   * Declares (or re-activates) a sync scope from a model query and pulls it when online.\n   * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query declaring the sync scope.\n   * @returns {Promise<{scope: import(\"./sync-client-types.js\").SerializedSyncScope, pulled: import(\"./sync-api-client-types.js\").SyncChangesResult | null}>} Declared scope and pull result (null while offline).\n   */\n  async sync(query) {\n    const scope = serializedScopeFromQuery(query)\n    const scopeStore = this.scopeStore()\n    const scopeRow = await scopeStore.findOrCreateScope(scope)\n\n    if (!scopeRow.cursorPayload && this.config.legacyCursor) {\n      const legacyCursorPayload = await this.config.legacyCursor({scope})\n      const legacyCursor = SyncApiClient.syncCursorFromPayload(legacyCursorPayload)\n\n      if (legacyCursor) await scopeStore.saveCursor(scopeRow, legacyCursor)\n    }\n\n    return {pulled: await this.pull(), scope}\n  }\n\n  /**\n   * Deactivates the sync scope declared by a model query.\n   * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query whose scope should stop syncing.\n   * @returns {Promise<void>}\n   */\n  async unsync(query) {\n    await this.scopeStore().deactivate(serializedScopeFromQuery(query))\n  }\n\n  /**\n   * Pulls changes for every active scope with per-scope cursors (single-flighted, online-gated).\n   * @returns {Promise<import(\"./sync-api-client-types.js\").SyncChangesResult | null>} Combined pull result, or null while offline.\n   */\n  async pull() {\n    if (!(await this.isOnline())) return null\n\n    /** @type {import(\"./sync-api-client-types.js\").SyncChangesResult | null} */\n    let combinedResult = null\n\n    await SyncApiClient.singleFlight(`velocious-sync-client-pull-${this._clientNumber}`, async () => {\n      const authenticationToken = await this.config.authenticationToken()\n      const scopeStore = this.scopeStore()\n      const applySync = this.remoteApplySync()\n      const result = {\n        changed: false,\n        pages: 0,\n        resourceChanged: /** @type {Record<string, boolean>} */ ({}),\n        resourceCounts: /** @type {Record<string, number>} */ ({}),\n        syncedCount: 0\n      }\n\n      for (const scopeRow of await scopeStore.activeScopes()) {\n        const scopeResult = await SyncApiClient.pullChanges({\n          applySync,\n          authenticationToken,\n          batchSize: this.config.batchSize,\n          loadCursor: async () => await scopeStore.loadCursor(scopeRow),\n          postChanges: async (payload) => await this.config.postChanges({\n            ...payload,\n            scope: {conditions: scopeRow.conditions, resourceType: scopeRow.resourceType}\n          }),\n          saveCursor: async (cursor) => await scopeStore.saveCursor(scopeRow, cursor)\n        })\n\n        result.changed ||= scopeResult.changed\n        result.pages += scopeResult.pages\n        result.syncedCount += scopeResult.syncedCount\n\n        for (const [resourceType, count] of Object.entries(scopeResult.resourceCounts)) {\n          result.resourceCounts[resourceType] = (result.resourceCounts[resourceType] || 0) + count\n        }\n        for (const [resourceType, changed] of Object.entries(scopeResult.resourceChanged)) {\n          result.resourceChanged[resourceType] ||= changed\n        }\n      }\n\n      combinedResult = result\n    })\n\n    return combinedResult\n  }\n\n  /**\n   * Builds the derived remote-change applier shared by pulls and realtime pushes:\n   * applies through the declared resource configs, registers each written record\n   * for echo suppression (tracked resources do not re-queue applied changes), and\n   * fails loudly instead of silently skipping unconfigured resources.\n   * @param {{source?: string}} [args] - Error context describing where the change came from.\n   * @returns {(sync: import(\"./sync-api-client-types.js\").SyncChangeEnvelope) => Promise<import(\"./sync-api-client-types.js\").SyncChangeApplyResult>} Loud remote-change applier.\n   */\n  remoteApplySync({source = \"pulled change\"} = {}) {\n    const pullResourceConfigs = this.pullResourceConfigs()\n    const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => this.markRemoteApply(record))\n\n    return async (sync) => {\n      const resourceType = sync.resourceType()\n\n      if (!resourceType || !pullResourceConfigs[resourceType]) {\n        throw new Error(`No sync resource with pull attributes configured for ${source}: ${String(resourceType)}`)\n      }\n\n      return await applier(sync)\n    }\n  }\n\n  /**\n   * Subscribes the derived realtime channels so pushed websocket changes apply\n   * through the same derived applier as pulls (idempotent, single-flighted).\n   * @param {?} [context] - App context passed to the `sync.client.realtime.channels` callback (runtime values like eventId).\n   * @returns {Promise<void>}\n   */\n  async subscribeRealtime(context) {\n    await this.realtimeBridge().subscribe(context)\n  }\n\n  /**\n   * Unsubscribes the realtime channels and disconnects the websocket client (idempotent).\n   * @returns {Promise<void>}\n   */\n  async unsubscribeRealtime() {\n    await this.realtimeBridge().unsubscribe()\n  }\n\n  /**\n   * Reports the realtime subscription state and per-channel readiness.\n   * @returns {ReturnType<SyncRealtimeBridge[\"status\"]>} Realtime status.\n   */\n  realtimeStatus() {\n    return this.realtimeBridge().status()\n  }\n\n  /**\n   * Awaits all pending realtime message applies and any scheduled\n   * pull-on-reconnect (useful in tests and shutdown flows).\n   * @returns {Promise<void>}\n   */\n  async waitForRealtimeApplied() {\n    await this.realtimeBridge().waitForApplied()\n  }\n\n  /**\n   * Returns the lazily built realtime bridge.\n   * @returns {SyncRealtimeBridge} Realtime bridge.\n   */\n  realtimeBridge() {\n    this._realtimeBridge ||= new SyncRealtimeBridge({syncClient: this})\n\n    return this._realtimeBridge\n  }\n\n  /**\n   * Queues a local model change as a pending sync row and schedules an immediate\n   * replay attempt (kept pending while offline or when the backend rejects it).\n   * @param {{resource: ?, data?: Record<string, ?>, syncType?: string}} args - Queue args.\n   * @returns {Promise<?>} Pending local sync row.\n   */\n  async queue({data, resource, syncType}) {\n    const resourceConfig = this.resourceConfigFor(resource)\n    const syncRow = await SyncApiClient.queueLocalSync({\n      booleanAttributes: resourceConfig.booleanAttributes || [],\n      data,\n      localOnlyAttributes: resourceConfig.localOnlyAttributes || [],\n      resource,\n      syncModel: this.config.syncModel,\n      syncType: syncType ?? this.defaultSyncType({operation: \"update\", record: resource, resourceConfig})\n    })\n\n    this.scheduleReplay()\n\n    return syncRow\n  }\n\n  /**\n   * Drains pending local sync rows to the backend (single-flighted, online-gated).\n   * Rows are only marked successful after the backend acknowledges them.\n   * @returns {Promise<void>}\n   */\n  async replayPending() {\n    if (!(await this.isOnline())) return\n\n    await SyncApiClient.singleFlight(`velocious-sync-client-replay-${this._clientNumber}`, async () => {\n      await SyncApiClient.replayLocalSyncs({\n        authenticationToken: await this.config.authenticationToken(),\n        batchSize: this.config.batchSize,\n        postReplay: this.config.postReplay,\n        syncModel: this.config.syncModel\n      })\n    })\n  }\n\n  /**\n   * Schedules a background replay attempt without blocking the caller.\n   * Failures go to config.onError (or rethrow when none is configured).\n   * @returns {void}\n   */\n  scheduleReplay() {\n    this._scheduledReplay = (async () => {\n      try {\n        await this.replayPending()\n      } catch (error) {\n        this.reportError(/** @type {Error} */ (error))\n      }\n    })()\n  }\n\n  /**\n   * Awaits the last scheduled background replay (useful in tests and shutdown flows).\n   * @returns {Promise<void>}\n   */\n  async waitForScheduledReplay() {\n    if (this._scheduledReplay) await this._scheduledReplay\n  }\n\n  /**\n   * Reports a background sync failure.\n   * @param {Error} error - Background failure.\n   * @returns {void}\n   */\n  reportError(error) {\n    if (this.config.onError) {\n      this.config.onError(error)\n      return\n    }\n\n    throw error\n  }\n\n  /**\n   * Resolves connectivity through the configured gate.\n   * @returns {Promise<boolean>} Whether the backend is considered reachable.\n   */\n  async isOnline() {\n    if (!this.config.isOnline) return true\n\n    return (await this.config.isOnline()) !== false\n  }\n\n  /**\n   * Returns the scope store backing declared scopes and cursors.\n   * @returns {import(\"./sync-scope-store.js\").default} Scope store.\n   */\n  scopeStore() {\n    this._scopeStore ||= new SyncScopeStore({configuration: this.config.configuration})\n\n    return this._scopeStore\n  }\n\n  /**\n   * Resolves the declared resource config for a local record.\n   * @param {?} resource - Local model record.\n   * @returns {import(\"./sync-client-types.js\").SyncClientResourceConfig} Declared resource config.\n   */\n  resourceConfigFor(resource) {\n    const modelClass = resource?.constructor\n\n    if (typeof modelClass?.getModelName !== \"function\") {\n      throw new Error(`Sync resources must be model records with a static getModelName(), got: ${String(resource)}`)\n    }\n\n    const resourceType = modelClass.getModelName()\n    const resourceConfig = this.config.resources[resourceType]\n\n    if (!resourceConfig) throw new Error(`No sync resource configured for: ${resourceType}`)\n\n    return resourceConfig\n  }\n\n  /**\n   * Resolves the sync type for a mutation through the resource config. The\n   * \"upsert\" flag queues creates and updates as \"update\" rows (the server\n   * upserts by resource id) and destroys as \"delete\" rows.\n   * @param {{operation: \"create\" | \"update\" | \"destroy\", record: ?, resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig}} args - Mutation args.\n   * @returns {string} Sync type.\n   */\n  defaultSyncType({operation, record, resourceConfig}) {\n    if (typeof resourceConfig.syncType === \"function\") return resourceConfig.syncType({operation, record})\n    if (operation === \"destroy\") return \"delete\"\n    if (resourceConfig.syncType === \"upsert\") return \"update\"\n\n    return operation\n  }\n\n  /**\n   * Derives the pull-apply resource configs from the declared resources.\n   * @returns {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig>} Pull-apply resource configs.\n   */\n  pullResourceConfigs() {\n    this._pullResourceConfigs ||= /** @type {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig>} */ (Object.fromEntries(\n      Object.entries(this.config.resources)\n        .filter(([, resource]) => Boolean(resource.attributes))\n        .map(([resourceType, resource]) => [resourceType, {\n          afterApply: resource.afterApply,\n          attributes: /** @type {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} */ (resource.attributes),\n          enabled: true,\n          findRecord: resource.findRecord,\n          findRecordForDelete: resource.findRecordForDelete,\n          modelClass: resource.modelClass\n        }])\n    ))\n\n    return this._pullResourceConfigs\n  }\n}\n\n/**\n * Builds one resource config from a model's `static sync` declaration plus its\n * derived column metadata.\n * @param {{declaration: import(\"./sync-client-types.js\").ModelSyncDeclaration, modelClass: ?, resourceType: string}} args - Declaration args.\n * @returns {import(\"./sync-client-types.js\").SyncClientResourceConfig} Derived resource config.\n */\nfunction resourceConfigFromSyncDeclaration({declaration, modelClass, resourceType}) {\n  const normalizedDeclaration = declaration === true ? {} : declaration\n\n  if (!normalizedDeclaration || typeof normalizedDeclaration !== \"object\" || Array.isArray(normalizedDeclaration)) {\n    throw new Error(`${resourceType} static sync must be true or a sync declaration object, got: ${String(declaration)}`)\n  }\n\n  const {afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, realtime, syncType, track, trackedData, ...restDeclaration} = normalizedDeclaration\n  const unknownKeys = Object.keys(restDeclaration)\n\n  if (unknownKeys.length > 0) {\n    throw new Error(`${resourceType} static sync received unknown keys: ${unknownKeys.join(\", \")} (supported: afterApply, attributes, booleanAttributes, findRecord, findRecordForDelete, localOnlyAttributes, realtime, syncType, track, trackedData)`)\n  }\n  if (syncType !== undefined && typeof syncType !== \"function\" && syncType !== \"upsert\") {\n    throw new Error(`${resourceType} static sync syncType must be a function or the string \"upsert\", got: ${String(syncType)}`)\n  }\n\n  const derived = derivedSyncAttributes({modelClass, resourceType})\n\n  return {\n    afterApply,\n    attributes,\n    booleanAttributes: mergedAttributeNames(derived.booleanAttributes, booleanAttributes),\n    findRecord,\n    findRecordForDelete,\n    localOnlyAttributes: mergedAttributeNames(derived.localOnlyAttributes, localOnlyAttributes),\n    modelClass,\n    realtime,\n    syncType,\n    track: normalizedTrack(track),\n    trackedData\n  }\n}\n\n/**\n * Derives boolean and local-only attribute names from a model's column metadata:\n * booleans from boolean column types; local-only from the primary key,\n * createdAt/updatedAt, and sync bookkeeping columns.\n * @param {{modelClass: ?, resourceType: string}} args - Derivation args.\n * @returns {{booleanAttributes: string[], localOnlyAttributes: string[]}} Derived attribute names.\n */\nfunction derivedSyncAttributes({modelClass, resourceType}) {\n  if (\n    typeof modelClass.getColumnNames !== \"function\" ||\n    typeof modelClass.getColumnNameToAttributeNameMap !== \"function\" ||\n    typeof modelClass.getColumnTypeByName !== \"function\" ||\n    typeof modelClass.primaryKey !== \"function\" ||\n    typeof modelClass.hasPrimaryKey !== \"function\"\n  ) {\n    throw new Error(`${resourceType} static sync requires a Velocious model class with column metadata (getColumnNames, getColumnNameToAttributeNameMap, getColumnTypeByName, primaryKey, hasPrimaryKey)`)\n  }\n\n  const columnNameToAttributeName = modelClass.getColumnNameToAttributeNameMap()\n  /** @type {string[]} */\n  const booleanAttributes = []\n  /** @type {string[]} */\n  const localOnlyAttributes = []\n\n  if (modelClass.hasPrimaryKey()) {\n    const primaryKeyColumn = modelClass.primaryKey()\n\n    localOnlyAttributes.push(columnNameToAttributeName[primaryKeyColumn] || primaryKeyColumn)\n  }\n\n  for (const columnName of modelClass.getColumnNames()) {\n    const attributeName = columnNameToAttributeName[columnName] || columnName\n    const columnType = modelClass.getColumnTypeByName(columnName)\n\n    if (LOCAL_BOOKKEEPING_ATTRIBUTE_NAMES.includes(attributeName) && !localOnlyAttributes.includes(attributeName)) {\n      localOnlyAttributes.push(attributeName)\n    }\n    if (columnType && isBooleanColumnType(columnType)) {\n      booleanAttributes.push(attributeName)\n    }\n  }\n\n  return {booleanAttributes, localOnlyAttributes}\n}\n\n/**\n * Merges derived attribute names with declared extras into a sorted, duplicate-free list.\n * @param {string[]} derived - Derived attribute names.\n * @param {string[] | undefined} declared - Declared extra attribute names.\n * @returns {string[]} Merged attribute names.\n */\nfunction mergedAttributeNames(derived, declared) {\n  return [...new Set([...derived, ...(declared || [])])].sort()\n}\n\n/**\n * Normalizes a declaration's track value: an operations array is shorthand for\n * the {operations} form.\n * @param {import(\"./sync-client-types.js\").ModelSyncDeclarationConfig[\"track\"]} track - Declared track value.\n * @returns {import(\"./sync-client-types.js\").SyncClientResourceConfig[\"track\"]} Normalized track value.\n */\nfunction normalizedTrack(track) {\n  if (Array.isArray(track)) return {operations: track}\n\n  return track\n}\n\n/**\n * Builds a framework-owned sync endpoint POSTer over the configured transport.\n * @param {{path: string, transport: import(\"../configuration-types.js\").VelociousSyncClientTransport}} args - Poster args.\n * @returns {(payload: Record<string, ?>) => Promise<?>} Sync endpoint POSTer.\n */\nfunction transportPoster({path, transport}) {\n  return async (payload) => {\n    const response = await transport.post(path, payload)\n\n    if (!response || typeof response.json !== \"function\") {\n      throw new Error(`sync.client transport.post must resolve to a response with a json() method for ${path} (like the frontend-model websocket client)`)\n    }\n\n    return await response.json()\n  }\n}\n\n/**\n * Lazily builds (and memoizes per configuration) the sync client derived from the\n * app's Velocious configuration and registers it as the current sync client.\n * @param {Configuration} [configuration] - Configuration owning the registered models and the sync.client block. Defaults to the current configuration.\n * @returns {SyncClient} Memoized sync client for the configuration.\n */\nexport function syncClient(configuration = Configuration.current()) {\n  let client = syncClientsByConfiguration.get(configuration)\n\n  if (!client) {\n    client = SyncClient.fromConfiguration(configuration)\n    syncClientsByConfiguration.set(configuration, client)\n    client.setCurrent()\n  }\n\n  return client\n}\n\n/**\n * Declares a sync scope on the current sync client.\n * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query declaring the sync scope.\n * @returns {Promise<{scope: import(\"./sync-client-types.js\").SerializedSyncScope, pulled: import(\"./sync-api-client-types.js\").SyncChangesResult | null}>} Declared scope and pull result.\n */\nexport async function sync(query) {\n  return await SyncClient.current().sync(query)\n}\n"]}