velocious 1.0.663 → 1.0.665

package/build/sync/sync-publisher.js

@@ -4,6 +4,8 @@ import Configuration from "../configuration.js"
 import Logger from "../logger.js"
 import {scalarModelPrimaryKeyValue} from "../utils/model-primary-key.js"
 import restArgsError from "../utils/rest-args-error.js"
+import sha256Hex from "../utils/sha256-hex.js"
+import stableJsonStringify from "../utils/stable-json.js"
 
 import {declaredSyncScopeAttributes} from "./sync-scope-attributes.js"
 import {deliverDeclaredBroadcasts, upsertSyncRow} from "./sync-change-fanout.js"
@@ -211,7 +213,8 @@ export default class SyncPublisher {
 
       await record.connection().afterCommit(async () => {
         try {
-          const syncRow = await this.upsertPublishedSyncRow(attributes, operationScope)
+          const scopeColumnNames = resourceConfig.scopePlan.map(({columnName}) => columnName)
+          const syncRow = await this.upsertPublishedSyncRow(attributes, operationScope, scopeColumnNames)
 
           await this.broadcaster()({
             body: {
@@ -250,12 +253,17 @@ export default class SyncPublisher {
     const columns = {}
     /** @type {Record<string, string | null>} */
     const params = {}
+    const computedScopeAttributes = resourceConfig.scopeAttributesResolver
+      ? await this.resolveComputedScopeAttributes({record, resourceConfig})
+      : null
 
     for (const scopePlanEntry of resourceConfig.scopePlan) {
       /** @type {ReturnType<typeof JSON.parse>} */
       let rawValue
 
-      if (scopePlanEntry.resolver) {
+      if (computedScopeAttributes) {
+        rawValue = computedScopeAttributes[scopePlanEntry.scopeAttribute]
+      } else if (scopePlanEntry.resolver) {
         rawValue = await scopePlanEntry.resolver(record)
       } else if (scopePlanEntry.recordAttribute) {
         rawValue = record.readAttribute(scopePlanEntry.recordAttribute)
@@ -272,6 +280,52 @@ export default class SyncPublisher {
     return {columns, params}
   }
 
+  /**
+   * Resolves and validates one computed scope-attributes declaration. The
+   * resolver runs once per published mutation with the exact connection that
+   * owns that mutation; every declared scope value is then reused for row
+   * persistence and broadcast routing so those two identities cannot drift.
+   * @param {{record: ReturnType<typeof JSON.parse>, resourceConfig: import("./sync-publisher-types.js").SyncPublisherResourceConfig}} args - Record and resource configuration.
+   * @returns {Promise<Record<string, string | number | null>>} Complete computed scope values.
+   */
+  async resolveComputedScopeAttributes({record, resourceConfig}) {
+    const resolver = resourceConfig.scopeAttributesResolver
+
+    if (!resolver) throw new Error(`No computed scope-attributes resolver configured for ${resourceConfig.resourceType}`)
+
+    const resolved = await resolver({
+      configuration: this.config.configuration,
+      connection: record.connection(),
+      record
+    })
+
+    if (!isPlainObject(resolved)) {
+      throw new Error(`${resourceConfig.resourceType} static sync publish scopeAttributes resolver must resolve to a plain object`)
+    }
+
+    const declaredAttributes = resourceConfig.scopePlan.map(({scopeAttribute}) => scopeAttribute)
+
+    for (const scopeAttribute of Object.keys(resolved)) {
+      if (!declaredAttributes.includes(scopeAttribute)) {
+        throw new Error(`${resourceConfig.resourceType} static sync publish scopeAttributes resolver returned unknown scope attribute: ${scopeAttribute} (the sync model declares: ${declaredAttributes.join(", ")})`)
+      }
+    }
+
+    for (const scopeAttribute of declaredAttributes) {
+      if (!Object.hasOwn(resolved, scopeAttribute)) {
+        throw new Error(`${resourceConfig.resourceType} static sync publish scopeAttributes resolver must resolve the declared scope attribute ${scopeAttribute}`)
+      }
+
+      const value = resolved[scopeAttribute]
+
+      if (value !== null && typeof value !== "string" && typeof value !== "number") {
+        throw new Error(`${resourceConfig.resourceType} static sync publish scope attribute ${scopeAttribute} must be a string, number, or null`)
+      }
+    }
+
+    return /** @type {Record<string, string | number | null>} */ (resolved)
+  }
+
   /**
    * Builds the framework sync channel entry for one published change: the
    * snapshotted payload plus the persisted sync row's public exact-row metadata
@@ -311,22 +365,50 @@ export default class SyncPublisher {
   /**
    * Upserts the published server-origin sync row for a resource identity:
    * server-origin rows carry a null actor column (no device to echo the
-   * change back to), so repeated server changes to one resource reuse and
-   * re-sequence one feed row.
+   * change back to), so repeated server changes to one complete resource and
+   * scope identity reuse and re-sequence one feed row. A database advisory
+   * lock serializes reconciliation plus the shared upsert because unique
+   * constraints containing nullable actor/scope columns do not enforce this
+   * identity portably across supported databases. Reconciliation retains the
+   * row with the newest feed sequence (then lowest id for a deterministic tie)
+   * and removes older matching server-origin rows before applying the current
+   * mutation.
    * @param {Record<string, ReturnType<typeof JSON.parse>>} attributes - Snapshotted sync row attributes.
    * @param {ReturnType<typeof JSON.parse>} syncModel - Operation-bound or static Sync model interface.
+   * @param {string[]} scopeColumnNames - Persisted scope columns participating in the complete identity.
    * @returns {Promise<ReturnType<typeof JSON.parse>>} Upserted sync row.
    */
-  async upsertPublishedSyncRow(attributes, syncModel = this.config.syncModel) {
-    const existingSync = await syncModel
-      .where({
-        [this.config.actorForeignKeyColumn]: null,
-        resource_id: attributes.resource_id,
-        resource_type: attributes.resource_type
-      })
-      .first()
+  async upsertPublishedSyncRow(attributes, syncModel = this.config.syncModel, scopeColumnNames = []) {
+    /** @type {Record<string, ReturnType<typeof JSON.parse>>} */
+    const identity = {
+      [this.config.actorForeignKeyColumn]: null,
+      resource_id: attributes.resource_id,
+      resource_type: attributes.resource_type
+    }
+
+    for (const columnName of scopeColumnNames) {
+      if (!Object.hasOwn(attributes, columnName)) {
+        throw new Error(`Published sync row identity is missing the scope column ${columnName}`)
+      }
+
+      identity[columnName] = attributes[columnName]
+    }
+
+    return await this.config.syncModel.withAdvisoryLock(syncPublisherIdentityLockName(identity), async () => {
+      const matchingSyncs = await syncModel
+        .where(identity)
+        .toArray()
 
-    return await upsertSyncRow({attributes, existingSync, syncModel})
+      matchingSyncs.sort(comparePublishedSyncRowsByRecency)
+
+      const [existingSync, ...duplicateSyncs] = matchingSyncs
+
+      for (const duplicateSync of duplicateSyncs) {
+        await duplicateSync.destroy()
+      }
+
+      return await upsertSyncRow({attributes, existingSync, syncModel})
+    }, {dedicatedConnection: true})
   }
 
   /**
@@ -383,6 +465,40 @@ export default class SyncPublisher {
   }
 }
 
+/**
+ * Returns a deterministic, MySQL-safe advisory-lock name for one complete
+ * server-origin publisher identity. Stable JSON preserves null actor/scope
+ * components distinctly from strings, and the truncated SHA-256 digest keeps
+ * the final name below MySQL/MariaDB's 64-character `GET_LOCK` limit.
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} identity - Complete sync-row identity in column form.
+ * @returns {string} Advisory-lock name.
+ */
+function syncPublisherIdentityLockName(identity) {
+  const hash = sha256Hex(stableJsonStringify(identity)).slice(0, 32)
+
+  return `vsp:${hash}`
+}
+
+/**
+ * Orders matching published rows by the feed's public recency contract so
+ * legacy duplicates have one deterministic survivor. Server sequences are
+ * positive and monotonic; a legacy null sequence is older than any assigned
+ * sequence, and the immutable row id breaks otherwise-equal ties.
+ * @param {ReturnType<typeof JSON.parse>} left - First matching sync row.
+ * @param {ReturnType<typeof JSON.parse>} right - Second matching sync row.
+ * @returns {number} Sort comparison with the canonical survivor first.
+ */
+function comparePublishedSyncRowsByRecency(left, right) {
+  const leftSequence = left.serverSequence()
+  const rightSequence = right.serverSequence()
+
+  if (leftSequence === null && rightSequence !== null) return 1
+  if (leftSequence !== null && rightSequence === null) return -1
+  if (leftSequence !== rightSequence) return rightSequence - leftSequence
+
+  return left.id().localeCompare(right.id())
+}
+
 /**
  * Resolves a model class's active publish declaration from `static sync`.
  * Opted-out (`publish: false`) and undeclared models resolve to null; every
@@ -434,12 +550,15 @@ function resourceConfigFromPublishDeclaration({modelClass, publish, scopeAttribu
     }
   }
 
+  const scopePlan = scopePlanFor({eventId, modelClass, modelName, scopeAttributes, syncModel, syncScopeAttributes})
+
   return {
     broadcasts,
     modelClass,
     operations: operations === undefined ? DEFAULT_PUBLISHED_OPERATIONS : operations,
     resourceType: resourceType === undefined ? modelName : resourceType,
-    scopePlan: scopePlanFor({eventId, modelClass, modelName, scopeAttributes, syncModel, syncScopeAttributes}),
+    scopeAttributesResolver: typeof scopeAttributes === "function" ? scopeAttributes : undefined,
+    scopePlan,
     serialize: serialize === undefined ? defaultSerializedAttributes : serialize
   }
 }
@@ -452,7 +571,7 @@ function resourceConfigFromPublishDeclaration({modelClass, publish, scopeAttribu
  * name map), or the record's own id when the model has no such attribute
  * (scope-root models). The deprecated `eventId` declaration forms map to a
  * fixed `eventId`/`event_id` plan for 1.0.503 compatibility.
- * @param {{eventId: import("./sync-publisher-types.js").SyncPublishDeclarationConfig["eventId"], modelClass: ReturnType<typeof JSON.parse>, modelName: string, scopeAttributes: Record<string, string> | undefined, syncModel: ReturnType<typeof JSON.parse>, syncScopeAttributes: string[] | null}} args - Declaration and sync-model scope args.
+ * @param {{eventId: import("./sync-publisher-types.js").SyncPublishDeclarationConfig["eventId"], modelClass: ReturnType<typeof JSON.parse>, modelName: string, scopeAttributes: import("./sync-publisher-types.js").SyncPublishDeclarationConfig["scopeAttributes"], syncModel: ReturnType<typeof JSON.parse>, syncScopeAttributes: string[] | null}} args - Declaration and sync-model scope args.
  * @returns {Array<import("./sync-publisher-types.js").SyncPublisherScopePlanEntry>} Derived scope plan.
  */
 function scopePlanFor({eventId, modelClass, modelName, scopeAttributes, syncModel, syncScopeAttributes}) {
@@ -481,6 +600,15 @@ function scopePlanFor({eventId, modelClass, modelName, scopeAttributes, syncMode
 
   if (!syncScopeAttributes) return []
 
+  if (typeof scopeAttributes === "function") {
+    return syncScopeAttributes.map((scopeAttribute) => ({
+      columnName: syncScopeColumnName({scopeAttribute, syncModel}),
+      recordAttribute: null,
+      resolver: undefined,
+      scopeAttribute
+    }))
+  }
+
   if (scopeAttributes !== undefined && (typeof scopeAttributes !== "object" || Array.isArray(scopeAttributes))) {
     throw new Error(`${modelName} static sync publish scopeAttributes must be an object mapping scope attributes to record attribute names, got: ${String(scopeAttributes)}`)
   }
@@ -511,6 +639,19 @@ function scopePlanFor({eventId, modelClass, modelName, scopeAttributes, syncMode
   })
 }
 
+/**
+ * Checks that a computed declaration returned an ordinary key/value object.
+ * @param {unknown} value - Resolver result.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false
+
+  const prototype = Object.getPrototypeOf(value)
+
+  return prototype === Object.prototype || prototype === null
+}
+
 /**
  * Resolves the sync-row column persisting a declared scope attribute.
  * @param {{scopeAttribute: string, syncModel: ReturnType<typeof JSON.parse>}} args - Scope attribute and sync model.

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

@@ -52,13 +52,14 @@ export default class SyncRealtimeBridge {
    * an active subscription is kept as-is and a concurrent subscribe awaits the
    * in-flight attempt. Call `unsubscribe()` first to change the context.
    * @param {ReturnType<typeof JSON.parse>} [context] - App context passed to the deprecated `sync.client.realtime.channels` callback (runtime scope values).
+   * @param {{signal?: AbortSignal}} [options] - Subscription lifecycle options.
    * @returns {Promise<void>}
    */
-  async subscribe(context) {
+  async subscribe(context, {signal} = {}) {
     if (this._state === "subscribed") return
 
     if (!this._subscribePromise) {
-      this._subscribePromise = this._subscribe(context).finally(() => {
+      this._subscribePromise = this._subscribe(context, signal).finally(() => {
         this._subscribePromise = null
       })
     }
@@ -74,9 +75,10 @@ export default class SyncRealtimeBridge {
    * is live; an unsubscribe arriving during any await marks this attempt stale
    * and it tears its own resources down instead of resubscribing.
    * @param {ReturnType<typeof JSON.parse>} context - App context passed to the channels callback.
+   * @param {AbortSignal | undefined} signal - Subscription lifecycle signal.
    * @returns {Promise<void>}
    */
-  async _subscribe(context) {
+  async _subscribe(context, signal) {
     const generation = this._generation
 
     this._state = "subscribing"
@@ -103,10 +105,13 @@ export default class SyncRealtimeBridge {
     }
 
     try {
+      throwIfAborted(signal)
+
       const sharedClient = this.syncClient.syncConnection()
       const realtime = this.requireClientSource(sharedClient)
       const channelDescriptors = await this.channelDescriptors(context)
 
+      throwIfAborted(signal)
       if (generation !== this._generation) return
 
       if (sharedClient) {
@@ -122,8 +127,9 @@ export default class SyncRealtimeBridge {
         return
       }
 
-      await client.connect()
+      await client.connect({signal})
 
+      throwIfAborted(signal)
       if (generation !== this._generation) {
         await teardown()
         return
@@ -131,6 +137,7 @@ export default class SyncRealtimeBridge {
 
       const authenticationToken = await this.syncClient.config.authenticationToken()
 
+      throwIfAborted(signal)
       if (generation !== this._generation) {
         await teardown()
         return
@@ -148,16 +155,17 @@ export default class SyncRealtimeBridge {
           params: {...channelDescriptor.params, authenticationToken}
         })
         const subscription = client.subscribeChannel(channelDescriptor.channel, {
-          onMessage: (body) => this.enqueueApply({body, resourceType}),
-          onResume: () => this.schedulePull(),
+          onMessage: (body) => this.enqueueApply({body, generation, resourceType}),
+          onResume: () => this.schedulePull(generation),
           params
         })
 
         channels.push({channel: channelDescriptor.channel, resourceType, subscription})
       }
 
-      await Promise.all(channels.map(({subscription}) => subscription.waitForReady()))
+      await Promise.all(channels.map(({subscription}) => subscription.waitForReady({signal})))
 
+      throwIfAborted(signal)
       if (generation !== this._generation) {
         await teardown()
         return
@@ -167,7 +175,7 @@ export default class SyncRealtimeBridge {
       this._client = client
       this._ownsClient = ownsClient
       this._state = "subscribed"
-      this.schedulePull()
+      this.schedulePull(generation)
     } catch (error) {
       await teardown()
 
@@ -333,11 +341,13 @@ export default class SyncRealtimeBridge {
   /**
    * Chains one pushed message onto the serialized apply queue so changes apply
    * in arrival order; failures go to the sync client's error reporting.
-   * @param {{body: ReturnType<typeof JSON.parse>, resourceType: string | null}} args - Message args.
+   * @param {{body: ReturnType<typeof JSON.parse>, generation?: number, resourceType: string | null}} args - Message args.
    * @returns {void}
    */
-  enqueueApply({body, resourceType}) {
+  enqueueApply({body, generation = this._generation, resourceType}) {
     this._applyPromise = this._applyPromise.then(async () => {
+      if (generation !== this._generation) return
+
       try {
         await this.applyMessage({body, resourceType})
       } catch (error) {
@@ -383,19 +393,34 @@ export default class SyncRealtimeBridge {
    * Schedules a coalesced background pull closing offline gaps after
    * (re)subscription readiness. Resumes arriving while a pull is already
    * scheduled or in flight coalesce into that pull instead of stacking.
+   * @param {number} [generation] - Subscription generation owning the resume/readiness callback.
    * @returns {void}
    */
-  schedulePull() {
+  schedulePull(generation = this._generation) {
+    if (generation !== this._generation) return
     if (this.realtimeConfiguration()?.pullOnReconnect === false) return
 
     this._scheduledPull ||= (async () => {
       try {
         await this.syncClient.pull()
       } catch (error) {
-        this.syncClient.reportError(/** @type {Error} */ (error))
+        if (!this.syncClient.isLifecycleAbort(error)) {
+          this.syncClient.reportError(/** @type {Error} */ (error))
+        }
       } finally {
         this._scheduledPull = null
       }
     })()
   }
 }
+
+/**
+ * Throws the lifecycle abort reason when the subscription is no longer owned.
+ * @param {AbortSignal | undefined} signal - Subscription lifecycle signal.
+ * @returns {void}
+ */
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return
+
+  throw signal.reason instanceof Error ? signal.reason : new Error("Sync realtime subscription was aborted")
+}

package/build/sync/sync-scope-store.js

@@ -237,13 +237,15 @@ export default class SyncScopeStore {
     await this.ensureReady()
 
     if (this._usesMemoryStorage()) {
-      return this._memoryScopes.get(scopeRow.scopeDigest)?.cursorPayload ?? null
+      const currentScope = this._memoryScopes.get(scopeRow.scopeDigest)
+
+      return currentScope?.id === scopeRow.id ? currentScope.cursorPayload : null
     }
 
     return await this._withDb(async (db) => {
       const row = await this._rowByScopeDigest(db, scopeRow.scopeDigest)
 
-      return row ? row.cursorPayload : null
+      return row?.id === scopeRow.id ? row.cursorPayload : null
     })
   }
 
@@ -265,6 +267,7 @@ export default class SyncScopeStore {
       const memoryScope = this._memoryScopes.get(scopeRow.scopeDigest)
 
       if (!memoryScope) throw new Error(`No sync scope found for: ${scopeRow.scopeDigest}`)
+      if (memoryScope.id !== scopeRow.id || memoryScope.state !== "active") return
 
       memoryScope.cursorPayload = cursorPayload
       return
@@ -272,7 +275,7 @@ export default class SyncScopeStore {
 
     await this._withDb(async (db) => {
       await db.update({
-        conditions: {scope_digest: scopeRow.scopeDigest},
+        conditions: {id: scopeRow.id, scope_digest: scopeRow.scopeDigest, state: "active"},
         data: {cursor_json: cursorPayload, updated_at: new Date()},
         tableName: TABLE_NAME
       })
@@ -302,6 +305,79 @@ export default class SyncScopeStore {
     })
   }
 
+  /**
+   * Atomically deactivates selected scopes, clears their cursors and rotates
+   * their row identities. A cursor save carrying a pre-reset row identity can
+   * therefore never repopulate the reset scope. The optional cleanup hook runs
+   * inside the same database transaction, allowing an app to purge the local
+   * rows owned by those scopes without a cursor/cache split.
+   * @param {import("./sync-client-types.js").SerializedSyncScope[]} scopes - Selected scopes to reset.
+   * @param {object} [options] - Reset options.
+   * @param {(args: {connection: import("../database/drivers/base.js").default | null, scopes: import("./sync-client-types.js").SerializedSyncScope[]}) => Promise<void> | void} [options.cleanup] - App-owned local-row cleanup hook.
+   * @returns {Promise<void>}
+   */
+  async reset(scopes, {cleanup} = {}) {
+    if (!Array.isArray(scopes) || scopes.length === 0) throw new Error("SyncScopeStore.reset requires at least one serialized scope")
+    if (cleanup !== undefined && typeof cleanup !== "function") throw new Error("SyncScopeStore.reset cleanup must be a function")
+
+    await this.ensureReady()
+
+    const uniqueScopes = [...new Map(scopes.map((scope) => [scopeDigestForScope(scope), scope])).values()]
+
+    if (this._usesMemoryStorage()) {
+      if (cleanup) await cleanup({connection: null, scopes: uniqueScopes})
+
+      for (const scope of uniqueScopes) this._resetMemoryScope(scope)
+
+      return
+    }
+
+    await this._withDb(async (db) => {
+      await db.transaction(async () => {
+        if (cleanup) await cleanup({connection: db, scopes: uniqueScopes})
+
+        for (const scope of uniqueScopes) await this._resetDatabaseScope({db, scope})
+      })
+    })
+  }
+
+  /**
+   * Resets one memory-backed scope while preserving repeated-reset idempotence.
+   * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Scope to reset.
+   * @returns {void}
+   */
+  _resetMemoryScope(scope) {
+    const digest = scopeDigestForScope(scope)
+    const memoryScope = this._memoryScopes.get(digest)
+
+    if (!memoryScope || (memoryScope.state === "removed" && memoryScope.cursorPayload === null)) return
+
+    this._memoryScopes.set(digest, {
+      ...memoryScope,
+      cursorPayload: null,
+      id: new UUID(4).format(),
+      state: "removed"
+    })
+  }
+
+  /**
+   * Resets one database-backed scope while preserving repeated-reset idempotence.
+   * @param {{db: import("../database/drivers/base.js").default, scope: import("./sync-client-types.js").SerializedSyncScope}} args - Database and scope.
+   * @returns {Promise<void>}
+   */
+  async _resetDatabaseScope({db, scope}) {
+    const digest = scopeDigestForScope(scope)
+    const existingRow = await this._rowByScopeDigest(db, digest)
+
+    if (!existingRow || (existingRow.state === "removed" && existingRow.cursorPayload === null)) return
+
+    await db.update({
+      conditions: {id: existingRow.id, scope_digest: digest},
+      data: {cursor_json: null, id: new UUID(4).format(), state: "removed", updated_at: new Date()},
+      tableName: TABLE_NAME
+    })
+  }
+
   /**
    * Whether the store runs without a configured database.
    * @returns {boolean} Whether memory storage is used.

package/package.json

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

package/src/background-jobs/client.js

@@ -66,18 +66,44 @@ export default class BackgroundJobsClient {
      */
     const enqueueAttempt = async (attemptAcknowledgement) => {
       const request = await this._request()
-
-      return await timeout({
-        errorMessage: `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`,
+      const requestAbortController = new AbortController()
+      const timeoutErrorMessage = `Background job enqueue acknowledgement timed out after ${this.enqueueTimeoutMs}ms`
+      /**
+       * Resolves the pre-send phase when the mutation has entered the socket.
+       * @type {() => void}
+       */
+      let markRequestSent = () => {}
+      const requestSent = new Promise((resolve) => {
+        markRequestSent = () => resolve(undefined)
+      })
+      /**
+       * Applies the configured deadline independently to one request phase.
+       * @template T
+       * @param {() => Promise<T>} callback - Phase work.
+       * @returns {Promise<T>} - Phase result.
+       */
+      const withEnqueueTimeout = async (callback) => await timeout({
+        errorMessage: timeoutErrorMessage,
         timeout: this.enqueueTimeoutMs
-      }, async ({control}) => await request.run({
-        signal: control.signal,
+      }, async ({control}) => {
+        const abortRequest = () => requestAbortController.abort(control.signal.reason)
+
+        control.signal.addEventListener("abort", abortRequest)
+        try {
+          return await callback()
+        } finally {
+          control.signal.removeEventListener("abort", abortRequest)
+        }
+      })
+      const requestPromise = request.run({
+        signal: requestAbortController.signal,
         onConnect: (jsonSocket) => {
           jsonSocket.send(message)
           if (attemptAcknowledgement) {
             attemptAcknowledgement.generationFenced = Boolean(request.generationId)
             attemptAcknowledgement.requestSent = true
           }
+          markRequestSent()
         },
         onMessage: ({message, resolve, reject}) => {
           if (message?.type === "enqueued") {
@@ -90,7 +116,11 @@ export default class BackgroundJobsClient {
             reject(new Error(message.error || "Failed to enqueue job"))
           }
         }
-      }))
+      })
+
+      await withEnqueueTimeout(async () => await Promise.race([requestSent, requestPromise]))
+
+      return await withEnqueueTimeout(async () => await requestPromise)
     }
 
     try {

package/src/configuration-types.js

@@ -501,14 +501,14 @@
  * Client-side sync transport owning HTTP POSTs to the framework sync endpoints,
  * matching the frontend-model websocket client post contract.
  * @typedef {object} VelociousSyncClientTransport
- * @property {(path: string, body?: ReturnType<typeof JSON.parse>, options?: {headers?: Record<string, string>}) => Promise<{json: () => ReturnType<typeof JSON.parse>}>} post - Posts one request and resolves a response with a json accessor.
+ * @property {(path: string, body?: ReturnType<typeof JSON.parse>, options?: {headers?: Record<string, string>, signal?: AbortSignal}) => Promise<{json: () => ReturnType<typeof JSON.parse>}>} post - Posts one request and resolves a response with a json accessor.
  */
 
 /**
  * Websocket client contract required from `sync.client.realtime.createClient`,
  * matching `VelociousWebsocketClient` / snapreq's websocket client.
  * @typedef {object} VelociousSyncRealtimeWebsocketClient
- * @property {() => Promise<ReturnType<typeof JSON.parse>>} connect - Connects the websocket.
+ * @property {(options?: {signal?: AbortSignal}) => Promise<ReturnType<typeof JSON.parse>>} connect - Connects the websocket.
  * @property {(channelType: string, options?: {params?: Record<string, ReturnType<typeof JSON.parse>>, onMessage?: (body: ReturnType<typeof JSON.parse>) => void, onResume?: () => void, onClose?: (reason: string) => void}) => VelociousSyncRealtimeSubscription} subscribeChannel - Opens one channel subscription.
  * @property {() => Promise<void>} disconnectAndStopReconnect - Closes the socket and stops auto-reconnect.
  */
@@ -518,7 +518,7 @@
  * @typedef {object} VelociousSyncRealtimeSubscription
  * @property {() => void} close - Closes the subscription.
  * @property {() => boolean} isReady - Whether the subscription is acknowledged and ready.
- * @property {(params?: {timeoutMs?: number}) => Promise<void>} waitForReady - Resolves once the server acknowledges the subscription.
+ * @property {(params?: {signal?: AbortSignal, timeoutMs?: number}) => Promise<void>} waitForReady - Resolves once the server acknowledges the subscription.
  */
 
 /**

package/src/database/query/alter-table-base.js

@@ -32,21 +32,30 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
 
     let sql = `ALTER TABLE ${options.quoteTableName(tableData.getName())} `
     let actionCount = 0
+    let previousActionWasMssqlColumnAdd = false
 
     for (const column of tableData.getColumns()) {
       if (actionCount > 0) sql += ", "
 
       if (column.isNewColumn()) {
-        sql += databaseType == "mssql" ? "ADD " : "ADD COLUMN "
+        if (databaseType != "mssql") {
+          sql += "ADD COLUMN "
+        } else if (!previousActionWasMssqlColumnAdd) {
+          sql += "ADD "
+        }
+
         sql += column.getSQL({driver: this.getDriver(), forAlterTable: false})
+        previousActionWasMssqlColumnAdd = databaseType == "mssql"
       } else if (column.getNewName()) {
         const newColumnName = column.getNewName()
 
         if (!newColumnName) throw new Error(`Expected new column name for ${column.getName()}`)
 
         sql += `RENAME COLUMN ${options.quoteColumnName(column.getName())} TO ${options.quoteColumnName(newColumnName)}`
+        previousActionWasMssqlColumnAdd = false
       } else if (column.getDropColumn()) {
         sql += `DROP COLUMN ${options.quoteColumnName(column.getName())}`
+        previousActionWasMssqlColumnAdd = false
       } else {
         if (databaseType == "mssql" || databaseType == "pgsql") {
           sql += "ALTER COLUMN "
@@ -55,6 +64,7 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
         }
 
         sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
+        previousActionWasMssqlColumnAdd = false
       }