velocious 1.0.501 → 1.0.502

package/build/src/sync/sync-client-types.d.ts

@@ -77,7 +77,7 @@ export type SyncClientResourceConfig = {
         record: unknown;
     }) => Record<string, unknown>) | undefined;
     /**
-     * - Enables automatic mutation tracking through model lifecycle callbacks.
+     * - Automatic mutation tracking policy. On by default (creates and updates queue automatically); `false` opts the resource out, `true` adds destroys, `{operations}` narrows the tracked operations.
      */
     track?: boolean | {
         operations: Array<"create" | "update" | "destroy">;
@@ -129,7 +129,7 @@ export type ModelSyncDeclarationConfig = {
         record: unknown;
     }) => string) | undefined;
     /**
-     * - Enables automatic mutation tracking; an array is shorthand for {operations}.
+     * - Automatic mutation tracking policy; an array is shorthand for {operations}. On by default (creates and updates queue automatically); `false` opts the model out (for models written by non-user flows), `true` adds destroys.
      */
     track?: boolean | ("update" | "destroy" | "create")[] | {
         operations: Array<"create" | "update" | "destroy">;

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

@@ -1,3 +1,3 @@
 // @ts-check
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-client-types.js","sourceRoot":"","sources":["../../../src/sync/sync-client-types.js"],"names":[],"mappings":"AAAA,YAAY","sourcesContent":["// @ts-check\n\n/**\n * Client-declared sync scope serialized from a model query.\n * @typedef {object} SerializedSyncScope\n * @property {Record<string, ?>} conditions - Plain attribute conditions from the query.\n * @property {string} resourceType - Resource/model name the scope was declared for.\n */\n\n/**\n * Static realtime channel declaration on a model's `static sync`, for channels\n * whose name and params are static. Channels needing runtime params (like\n * eventId) belong in the `sync.client.realtime.channels` callback instead.\n * @typedef {object} ModelSyncRealtimeDeclaration\n * @property {string} channel - Server channel name to subscribe.\n * @property {Record<string, ?>} [params] - Static subscribe params. The framework injects `authenticationToken` automatically.\n */\n\n/**\n * Declarative per-resource sync policy.\n * @typedef {object} SyncClientResourceConfig\n * @property {?} modelClass - Local model class for this resource.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {string[]} [booleanAttributes] - Attributes coerced through sync boolean parsing when queueing.\n * @property {string[]} [localOnlyAttributes] - Attributes stripped from queued payloads.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Maps a mutation operation to a sync type. The \"upsert\" flag queues creates and updates as \"update\" rows (the server upserts by resource id) and destroys as \"delete\". Defaults to the operation name with destroy mapped to \"delete\".\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {boolean | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Enables automatic mutation tracking through model lifecycle callbacks.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`.\n */\n\n/**\n * Model-level client sync declaration read from `static sync` by\n * `SyncClient.fromConfiguration(...)`. `true` opts the model in with all\n * defaults; an object customizes the derived resource config.\n * @typedef {object} ModelSyncDeclarationConfig\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {string[]} [booleanAttributes] - Extra boolean attributes merged with the boolean columns derived from column types.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Sync type flag or mapper (see SyncClientResourceConfig).\n * @property {boolean | Array<\"create\" | \"update\" | \"destroy\"> | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Enables automatic mutation tracking; an array is shorthand for {operations}.\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`; use the `sync.client.realtime.channels` callback for channels needing runtime params.\n */\n\n/** @typedef {boolean | ModelSyncDeclarationConfig} ModelSyncDeclaration */\n\n/**\n * Options for building a sync client. Everything else — resources, transport\n * POSTers, auth, connectivity, batch size — is derived from the configuration's\n * registered models (`static sync`) and its `sync.client` block.\n * @typedef {object} SyncClientOptions\n * @property {import(\"../configuration.js\").default} [configuration] - Configuration owning the registered models, the `sync.client` block, and the scope-store database. Defaults to the current configuration.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {import(\"./sync-scope-store.js\").default} [scopeStore] - Scope store override (tests).\n * @property {?} [syncModel] - Pending-sync model override. Defaults to the registered \"Sync\" model.\n */\n\n/**\n * Internal derived sync client configuration built by the SyncClient\n * constructor — not an app-facing API.\n * @typedef {object} SyncClientConfig\n * @property {() => string | Promise<string>} authenticationToken - Resolves the auth token sent with sync requests.\n * @property {number} [batchSize] - Max syncs per request.\n * @property {import(\"../configuration.js\").default} configuration - Configuration owning the scope-store database.\n * @property {() => boolean | Promise<boolean>} [isOnline] - Connectivity gate for pulls and replays. Defaults to always online.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {(error: Error) => void} [onError] - Reports background replay/pull failures. Defaults to rethrowing.\n * @property {(payload: import(\"./sync-api-client-types.js\").SyncChangesRequest & {scope: SerializedSyncScope}) => Promise<import(\"./sync-api-client-types.js\").SyncChangesResponse>} postChanges - Posts one changes request.\n * @property {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<import(\"./sync-api-client-types.js\").SyncReplayResponse>} postReplay - Posts one replay request.\n * @property {import(\"../configuration-types.js\").VelociousSyncClientRealtimeConfiguration} [realtime] - Realtime push configuration consumed by `subscribeRealtime(...)`.\n * @property {Record<string, SyncClientResourceConfig>} resources - Derived resource policies keyed by resource/model name.\n * @property {?} syncModel - Local pending-sync model class.\n */\n\nexport {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-client-types.js","sourceRoot":"","sources":["../../../src/sync/sync-client-types.js"],"names":[],"mappings":"AAAA,YAAY","sourcesContent":["// @ts-check\n\n/**\n * Client-declared sync scope serialized from a model query.\n * @typedef {object} SerializedSyncScope\n * @property {Record<string, ?>} conditions - Plain attribute conditions from the query.\n * @property {string} resourceType - Resource/model name the scope was declared for.\n */\n\n/**\n * Static realtime channel declaration on a model's `static sync`, for channels\n * whose name and params are static. Channels needing runtime params (like\n * eventId) belong in the `sync.client.realtime.channels` callback instead.\n * @typedef {object} ModelSyncRealtimeDeclaration\n * @property {string} channel - Server channel name to subscribe.\n * @property {Record<string, ?>} [params] - Static subscribe params. The framework injects `authenticationToken` automatically.\n */\n\n/**\n * Declarative per-resource sync policy.\n * @typedef {object} SyncClientResourceConfig\n * @property {?} modelClass - Local model class for this resource.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {string[]} [booleanAttributes] - Attributes coerced through sync boolean parsing when queueing.\n * @property {string[]} [localOnlyAttributes] - Attributes stripped from queued payloads.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Maps a mutation operation to a sync type. The \"upsert\" flag queues creates and updates as \"update\" rows (the server upserts by resource id) and destroys as \"delete\". Defaults to the operation name with destroy mapped to \"delete\".\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {boolean | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Automatic mutation tracking policy. On by default (creates and updates queue automatically); `false` opts the resource out, `true` adds destroys, `{operations}` narrows the tracked operations.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`.\n */\n\n/**\n * Model-level client sync declaration read from `static sync` by\n * `SyncClient.fromConfiguration(...)`. `true` opts the model in with all\n * defaults; an object customizes the derived resource config.\n * @typedef {object} ModelSyncDeclarationConfig\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {string[]} [booleanAttributes] - Extra boolean attributes merged with the boolean columns derived from column types.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Sync type flag or mapper (see SyncClientResourceConfig).\n * @property {boolean | Array<\"create\" | \"update\" | \"destroy\"> | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Automatic mutation tracking policy; an array is shorthand for {operations}. On by default (creates and updates queue automatically); `false` opts the model out (for models written by non-user flows), `true` adds destroys.\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`; use the `sync.client.realtime.channels` callback for channels needing runtime params.\n */\n\n/** @typedef {boolean | ModelSyncDeclarationConfig} ModelSyncDeclaration */\n\n/**\n * Options for building a sync client. Everything else — resources, transport\n * POSTers, auth, connectivity, batch size — is derived from the configuration's\n * registered models (`static sync`) and its `sync.client` block.\n * @typedef {object} SyncClientOptions\n * @property {import(\"../configuration.js\").default} [configuration] - Configuration owning the registered models, the `sync.client` block, and the scope-store database. Defaults to the current configuration.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {import(\"./sync-scope-store.js\").default} [scopeStore] - Scope store override (tests).\n * @property {?} [syncModel] - Pending-sync model override. Defaults to the registered \"Sync\" model.\n */\n\n/**\n * Internal derived sync client configuration built by the SyncClient\n * constructor — not an app-facing API.\n * @typedef {object} SyncClientConfig\n * @property {() => string | Promise<string>} authenticationToken - Resolves the auth token sent with sync requests.\n * @property {number} [batchSize] - Max syncs per request.\n * @property {import(\"../configuration.js\").default} configuration - Configuration owning the scope-store database.\n * @property {() => boolean | Promise<boolean>} [isOnline] - Connectivity gate for pulls and replays. Defaults to always online.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {(error: Error) => void} [onError] - Reports background replay/pull failures. Defaults to rethrowing.\n * @property {(payload: import(\"./sync-api-client-types.js\").SyncChangesRequest & {scope: SerializedSyncScope}) => Promise<import(\"./sync-api-client-types.js\").SyncChangesResponse>} postChanges - Posts one changes request.\n * @property {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<import(\"./sync-api-client-types.js\").SyncReplayResponse>} postReplay - Posts one replay request.\n * @property {import(\"../configuration-types.js\").VelociousSyncClientRealtimeConfiguration} [realtime] - Realtime push configuration consumed by `subscribeRealtime(...)`.\n * @property {Record<string, SyncClientResourceConfig>} resources - Derived resource policies keyed by resource/model name.\n * @property {?} syncModel - Local pending-sync model class.\n */\n\nexport {}\n"]}

package/build/src/sync/sync-client.d.ts

@@ -71,11 +71,18 @@ export default class SyncClient {
     }>;
     /** @type {WeakSet<object>} */
     _remoteApplyRecords: WeakSet<object>;
+    _withoutTrackingDepth: number;
+    /** @type {Logger | {error: (...messages: Array<?>) => Promise<void>} | null} */
+    _logger: Logger | {
+        error: (...messages: Array<unknown>) => Promise<void>;
+    } | null;
     _started: boolean;
     /**
-     * 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>}
      */
     start(): Promise<void>;
@@ -86,6 +93,9 @@ export default class SyncClient {
     stop(): void;
     /**
      * 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.
      */
@@ -94,7 +104,15 @@ export default class SyncClient {
         resourceType: string;
     }): Array<"create" | "update" | "destroy">;
     /**
-     * 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.
      */
@@ -102,12 +120,60 @@ export default class SyncClient {
         operation: "create" | "update" | "destroy";
         resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig;
     }): (record: unknown) => Promise<void>;
+    /**
+     * 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>}
+     */
+    reportAfterCommitError(error: Error): Promise<void>;
+    /**
+     * Returns the lazily built client logger.
+     * @returns {Logger | {error: (...messages: Array<?>) => Promise<void>}} Client logger.
+     */
+    logger(): Logger | {
+        error: (...messages: Array<unknown>) => Promise<void>;
+    };
     /**
      * Whether a record is currently being written by pull-apply (echo suppression).
      * @param {?} record - Local model record.
      * @returns {boolean} Whether the record write originates from a remote change.
      */
     isRemoteApply(record: unknown): boolean;
+    /**
+     * 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: unknown): boolean;
+    /**
+     * 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.
+     */
+    withoutTracking<T>(callback: () => Promise<T> | T): Promise<T>;
+    /**
+     * 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: unknown): () => void;
     /**
      * Registers this client as the app's current sync client.
      * @returns {void}
@@ -242,4 +308,5 @@ export default class SyncClient {
 }
 import Configuration from "../configuration.js";
 import SyncRealtimeBridge from "./sync-realtime-bridge.js";
+import Logger from "../logger.js";
 //# sourceMappingURL=sync-client.d.ts.map

package/build/src/sync/sync-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-client.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"sync-client.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client.js"],"names":[],"mappings":"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"}

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

@@ -1,6 +1,7 @@
 // @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";
@@ -10,6 +11,13 @@ import { currentSyncClient, setCurrentSyncClient } from "./sync-client-registry.
 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>} */
@@ -88,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() {
@@ -123,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) {
@@ -143,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.
@@ -170,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}
@@ -275,10 +382,7 @@ export default class SyncClient {
      */
     remoteApplySync({ source = "pulled change" } = {}) {
         const pullResourceConfigs = this.pullResourceConfigs();
-        const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => {
-            this._remoteApplyRecords.add(record);
-            return () => this._remoteApplyRecords.delete(record);
-        });
+        const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => this.markRemoteApply(record));
         return async (sync) => {
             const resourceType = sync.resourceType();
             if (!resourceType || !pullResourceConfigs[resourceType]) {
@@ -591,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 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/** 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._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 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) => {\n      this._remoteApplyRecords.add(record)\n\n      return () => this._remoteApplyRecords.delete(record)\n    })\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"]}
+//# 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"]}

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

@@ -28,7 +28,7 @@
  * @property {string[]} [localOnlyAttributes] - Attributes stripped from queued payloads.
  * @property {"upsert" | ((args: {operation: "create" | "update" | "destroy", record: ?}) => string)} [syncType] - Maps a mutation operation to a sync type. The "upsert" flag queues creates and updates as "update" rows (the server upserts by resource id) and destroys as "delete". Defaults to the operation name with destroy mapped to "delete".
  * @property {(args: {operation: "create" | "update" | "destroy", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.
- * @property {boolean | {operations: Array<"create" | "update" | "destroy">}} [track] - Enables automatic mutation tracking through model lifecycle callbacks.
+ * @property {boolean | {operations: Array<"create" | "update" | "destroy">}} [track] - Automatic mutation tracking policy. On by default (creates and updates queue automatically); `false` opts the resource out, `true` adds destroys, `{operations}` narrows the tracked operations.
  * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`.
  */
 
@@ -44,7 +44,7 @@
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["findRecordForDelete"]} [findRecordForDelete] - Custom pull-apply delete resolver.
  * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.
  * @property {"upsert" | ((args: {operation: "create" | "update" | "destroy", record: ?}) => string)} [syncType] - Sync type flag or mapper (see SyncClientResourceConfig).
- * @property {boolean | Array<"create" | "update" | "destroy"> | {operations: Array<"create" | "update" | "destroy">}} [track] - Enables automatic mutation tracking; an array is shorthand for {operations}.
+ * @property {boolean | Array<"create" | "update" | "destroy"> | {operations: Array<"create" | "update" | "destroy">}} [track] - Automatic mutation tracking policy; an array is shorthand for {operations}. On by default (creates and updates queue automatically); `false` opts the model out (for models written by non-user flows), `true` adds destroys.
  * @property {(args: {operation: "create" | "update" | "destroy", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.
  * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`; use the `sync.client.realtime.channels` callback for channels needing runtime params.
  */

package/build/sync/sync-client.js

@@ -2,6 +2,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 {serializedScopeFromQuery} from "./query-scope.js"
@@ -15,6 +16,14 @@ 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"]
 
@@ -105,13 +114,18 @@ 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() {
@@ -147,13 +161,17 @@ 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) return []
+    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) {
@@ -170,27 +188,78 @@ export default class SyncClient {
   }
 
   /**
-   * 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)) return
+      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.
@@ -200,6 +269,54 @@ export default class SyncClient {
     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}
@@ -319,11 +436,7 @@ export default class SyncClient {
    */
   remoteApplySync({source = "pulled change"} = {}) {
     const pullResourceConfigs = this.pullResourceConfigs()
-    const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => {
-      this._remoteApplyRecords.add(record)
-
-      return () => this._remoteApplyRecords.delete(record)
-    })
+    const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => this.markRemoteApply(record))
 
     return async (sync) => {
       const resourceType = sync.resourceType()

package/package.json

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

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

@@ -28,7 +28,7 @@
  * @property {string[]} [localOnlyAttributes] - Attributes stripped from queued payloads.
  * @property {"upsert" | ((args: {operation: "create" | "update" | "destroy", record: ?}) => string)} [syncType] - Maps a mutation operation to a sync type. The "upsert" flag queues creates and updates as "update" rows (the server upserts by resource id) and destroys as "delete". Defaults to the operation name with destroy mapped to "delete".
  * @property {(args: {operation: "create" | "update" | "destroy", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.
- * @property {boolean | {operations: Array<"create" | "update" | "destroy">}} [track] - Enables automatic mutation tracking through model lifecycle callbacks.
+ * @property {boolean | {operations: Array<"create" | "update" | "destroy">}} [track] - Automatic mutation tracking policy. On by default (creates and updates queue automatically); `false` opts the resource out, `true` adds destroys, `{operations}` narrows the tracked operations.
  * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`.
  */
 
@@ -44,7 +44,7 @@
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["findRecordForDelete"]} [findRecordForDelete] - Custom pull-apply delete resolver.
  * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.
  * @property {"upsert" | ((args: {operation: "create" | "update" | "destroy", record: ?}) => string)} [syncType] - Sync type flag or mapper (see SyncClientResourceConfig).
- * @property {boolean | Array<"create" | "update" | "destroy"> | {operations: Array<"create" | "update" | "destroy">}} [track] - Enables automatic mutation tracking; an array is shorthand for {operations}.
+ * @property {boolean | Array<"create" | "update" | "destroy"> | {operations: Array<"create" | "update" | "destroy">}} [track] - Automatic mutation tracking policy; an array is shorthand for {operations}. On by default (creates and updates queue automatically); `false` opts the model out (for models written by non-user flows), `true` adds destroys.
  * @property {(args: {operation: "create" | "update" | "destroy", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.
  * @property {ModelSyncRealtimeDeclaration} [realtime] - Static realtime channel this resource subscribes through `subscribeRealtime(...)`; use the `sync.client.realtime.channels` callback for channels needing runtime params.
  */

package/src/sync/sync-client.js

@@ -2,6 +2,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 {serializedScopeFromQuery} from "./query-scope.js"
@@ -15,6 +16,14 @@ 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"]
 
@@ -105,13 +114,18 @@ 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() {
@@ -147,13 +161,17 @@ 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) return []
+    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) {
@@ -170,27 +188,78 @@ export default class SyncClient {
   }
 
   /**
-   * 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)) return
+      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.
@@ -200,6 +269,54 @@ export default class SyncClient {
     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}
@@ -319,11 +436,7 @@ export default class SyncClient {
    */
   remoteApplySync({source = "pulled change"} = {}) {
     const pullResourceConfigs = this.pullResourceConfigs()
-    const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => {
-      this._remoteApplyRecords.add(record)
-
-      return () => this._remoteApplyRecords.delete(record)
-    })
+    const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => this.markRemoteApply(record))
 
     return async (sync) => {
       const resourceType = sync.resourceType()