@abloatai/humans 0.37.1 → 0.39.0

package/src/local/SyncClient.ts

@@ -1290,34 +1290,25 @@ export class SyncClient extends EventEmitter {
    * local model has unsynced changes, so the two sides stay consistent.
    */
   resolveConflicts(localModel: Model, serverData: Record<string, unknown>): Model {
-    const hasLocalChanges = localModel.hasChanges;
-    // Safely get timestamp, handling both Date objects and strings
-    const localUpdatedAt = localModel.updatedAt
-      ? localModel.updatedAt instanceof Date
-        ? localModel.updatedAt.getTime()
-        : new Date(localModel.updatedAt).getTime()
-      : 0;
-    const serverUpdatedAt = toEpochMs(serverData.updatedAt);
-
-    this.runtime.logger.debug('Conflict resolution', {
-      modelId: localModel.id,
-      modelType: localModel.getModelName(),
-      hasLocalChanges,
-      localUpdatedAt: localModel.updatedAt?.toString(),
-      serverUpdatedAt: serverData.updatedAt,
-      localChanges: localModel.getChanges(),
-      serverState: this.extractCriticalState(serverData),
-    });
-
-    // PRIORITY 1: Check for critical server states that must be respected
-    // These states override any local changes to maintain data consistency
-    const criticalServerStates = this.extractCriticalState(serverData);
-    const shouldForceAcceptServer = this.hasCriticalStateChange(criticalServerStates);
+    // No entry-point debug here: this runs once per incoming update delta,
+    // and a debug call's payload is BUILT even when the logger discards it —
+    // a per-delta model scan on the apply hot path. The outcome branches
+    // below log the cases worth reading.
+
+    // PRIORITY 1: Check for critical server states that must be respected.
+    // These states override any local changes to maintain data consistency.
+    // Checked inline — the collected-object form (`extractCriticalState`)
+    // only materializes on the rare force-accept branch, for its log line.
+    const shouldForceAcceptServer =
+      (serverData.deletedAt !== undefined && serverData.deletedAt !== null) ||
+      (serverData.archivedAt !== undefined && serverData.archivedAt !== null) ||
+      serverData.isActive === false ||
+      (serverData.unassignedAt !== undefined && serverData.unassignedAt !== null);
 
     if (shouldForceAcceptServer) {
       this.runtime.logger.debug('Accepting server update - critical state change detected', {
         modelId: localModel.id,
-        criticalStates: criticalServerStates,
+        criticalStates: this.extractCriticalState(serverData),
       });
 
       // Force accept server state for critical changes
@@ -1329,7 +1320,7 @@ export class SyncClient extends EventEmitter {
 
     // Local-first: if we have local dirty fields, merge by field.
     // Keep locally changed fields; apply server for the rest.
-    if (hasLocalChanges) {
+    if (localModel.hasChanges) {
       const localChanges = localModel.getChanges();
       this.runtime.logger.debug('Merging server update with local dirty fields', {
         modelId: localModel.id,
@@ -1341,6 +1332,13 @@ export class SyncClient extends EventEmitter {
 
       // Preserve the most recent updatedAt without clearing dirty flags
       if (serverData.updatedAt || localModel.updatedAt) {
+        // Safely get timestamp, handling both Date objects and strings
+        const localUpdatedAt = localModel.updatedAt
+          ? localModel.updatedAt instanceof Date
+            ? localModel.updatedAt.getTime()
+            : new Date(localModel.updatedAt).getTime()
+          : 0;
+        const serverUpdatedAt = toEpochMs(serverData.updatedAt);
         const mergedUpdatedAt = new Date(Math.max(localUpdatedAt, serverUpdatedAt));
         // updateFromData accepts Date or ISO string for dates
         merged.updatedAt = mergedUpdatedAt;
@@ -1351,10 +1349,9 @@ export class SyncClient extends EventEmitter {
       return localModel;
     }
 
-    // No local changes: fall back to LWW to converge
-    // Accept server regardless of timestamp equality to stay in sync
-    const acceptReason = serverUpdatedAt > localUpdatedAt ? 'server is newer' : 'no local changes';
-    this.runtime.logger.debug(`Accepting server update - ${acceptReason}`);
+    // No local changes: fall back to LWW to converge. Accept server
+    // regardless of timestamp equality to stay in sync. Not logged — this is
+    // the common path for every collaborator update a client receives.
     localModel.updateFromData(serverData);
     localModel.clearChanges();
     localModel.markAsSynced();
@@ -1392,17 +1389,6 @@ export class SyncClient extends EventEmitter {
     return critical;
   }
 
-  /**
-   * Check if critical state changes exist that require forcing server state
-   */
-  private hasCriticalStateChange(criticalStates: Record<string, unknown>): boolean {
-    // Any critical state present means we should force accept server
-    return (
-      Object.keys(criticalStates).length > 0 &&
-      Object.values(criticalStates).some((v) => v !== null && v !== undefined)
-    );
-  }
-
   /**
    * Handle network reconnection
    */
@@ -1901,6 +1887,22 @@ export class SyncClient extends EventEmitter {
   applyDeltaBatchToPool(
     dbResults: readonly AppliedChange[],
     enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>,
+  ): void {
+    // The WHOLE batch — conflict resolution and model mutation included, not
+    // just the pool bookkeeping at the end — runs in one MobX action.
+    // `resolveConflicts` writes model fields via `updateFromData`; when those
+    // writes ran before the action, every delta opened its own top-level
+    // action and flushed reactions at its boundary, so a large frame paid one
+    // reaction pass per delta and an observer could see a partially applied
+    // frame between them.
+    runInAction(() => {
+      this.applyDeltaBatchToPoolInAction(dbResults, enrichRelations);
+    });
+  }
+
+  private applyDeltaBatchToPoolInAction(
+    dbResults: readonly AppliedChange[],
+    enrichRelations: (modelName: string, data: Record<string, unknown>) => Record<string, unknown>,
   ): void {
     const modelsToAdd: Model[] = [];
     const modelsToUpsert: Model[] = [];
@@ -2002,27 +2004,21 @@ export class SyncClient extends EventEmitter {
       }
     }
 
-    // Reveal the whole frame in a single MobX action. `addBatch`,
-    // `upsertBatch`, `removeBatch`, and `updateScope` are each individually
-    // wrapped in an action, so calling them in sequence flushes reactions at
-    // every action boundary — a catch-up frame that adds, updates, and removes
-    // would fire every dependent reaction several times in a row, re-rendering
-    // and re-sorting on each. Wrapping them in one outer `runInAction` defers
-    // all reaction flushes to a single boundary, so dependents recompute
-    // exactly once regardless of how many models or operation kinds the frame
-    // touched. The app therefore never observes a partially applied frame.
-    runInAction(() => {
-      if (modelsToAdd.length > 0) this.objectPool.addBatch(modelsToAdd, ModelScope.live);
-      if (modelsToUpsert.length > 0) this.objectPool.upsertBatch(modelsToUpsert, ModelScope.live);
-      if (idsToRemove.length > 0) this.objectPool.removeBatch(idsToRemove);
-      for (const id of idsToArchive) this.objectPool.updateScope(id, ModelScope.archived);
-
-      // Emit changed model types so QueryProcessor can auto-invalidate.
-      // Kept inside the action so any observable query-cache state it
-      // flips is part of the same atomic reveal.
-      const changedTypes = new Set(dbResults.map(r => r.modelName));
-      if (changedTypes.size > 0) this.emit('models:changed', changedTypes);
-    });
+    // Reveal the whole frame at one reaction boundary: the caller's single
+    // action covers the collection loop above and these batch pool writes, so
+    // dependents recompute exactly once regardless of how many models or
+    // operation kinds the frame touched, and the app never observes a
+    // partially applied frame.
+    if (modelsToAdd.length > 0) this.objectPool.addBatch(modelsToAdd, ModelScope.live);
+    if (modelsToUpsert.length > 0) this.objectPool.upsertBatch(modelsToUpsert, ModelScope.live);
+    if (idsToRemove.length > 0) this.objectPool.removeBatch(idsToRemove);
+    for (const id of idsToArchive) this.objectPool.updateScope(id, ModelScope.archived);
+
+    // Emit changed model types so QueryProcessor can auto-invalidate.
+    // Kept inside the action so any observable query-cache state it
+    // flips is part of the same atomic reveal.
+    const changedTypes = new Set(dbResults.map(r => r.modelName));
+    if (changedTypes.size > 0) this.emit('models:changed', changedTypes);
   }
 
   /**

package/src/local/client/createModelProxy.ts

@@ -521,15 +521,17 @@ export function createModelProxy<T, C>(
       | ModelDeleteParams<T, C>,
   ): MutationOptions => {
     const rest: MutationOptions = {
-      idempotencyKey: params.idempotencyKey,
-      label: params.label,
-      wait: params.wait,
-      readAt: params.readAt,
-      onStale: params.onStale,
-      fenceToken: params.fenceToken,
-      claimRef: params.claimRef,
-      reads: params.reads,
-      track: params.track,
+      ...(params.idempotencyKey !== undefined
+        ? { idempotencyKey: params.idempotencyKey }
+        : {}),
+      ...(params.label !== undefined ? { label: params.label } : {}),
+      ...(params.wait !== undefined ? { wait: params.wait } : {}),
+      ...(params.readAt !== undefined ? { readAt: params.readAt } : {}),
+      ...(params.onStale !== undefined ? { onStale: params.onStale } : {}),
+      ...(params.fenceToken !== undefined ? { fenceToken: params.fenceToken } : {}),
+      ...(params.claimRef !== undefined ? { claimRef: params.claimRef } : {}),
+      ...(params.reads !== undefined ? { reads: params.reads } : {}),
+      ...(params.track !== undefined ? { track: params.track } : {}),
     };
     // The write-options schema — the runtime twin of the compile-time params.
     // Catches plain-JavaScript callers (for example `onStale: 'rejct'`) at the
@@ -713,7 +715,7 @@ export function createModelProxy<T, C>(
     return {
       object: 'claim',
       id: lease.id,
-      readAt: snapshot.stamp,
+      readAt: lease.readAt ?? snapshot.stamp,
       // The fencing token the server minted for this grant, forwarded from the
       // lease so writes taken under this handle carry it (Option B).
       ...(lease.fenceToken !== undefined ? { fenceToken: lease.fenceToken } : {}),
@@ -1227,7 +1229,7 @@ export function createModelProxy<T, C>(
         const effective: MutationOptions | undefined = claimed
           ? {
               wait: 'confirmed',
-              readAt: claimed.snapshot.stamp,
+              readAt: claimed.lease.readAt ?? claimed.snapshot.stamp,
               onStale: 'reject',
               claimRef: { id: claimed.lease.id },
               ...opts,
@@ -1311,7 +1313,7 @@ export function createModelProxy<T, C>(
       const effective: MutationOptions | undefined = claimed
         ? {
             wait: 'confirmed',
-            readAt: claimed.snapshot.stamp,
+            readAt: claimed.lease.readAt ?? claimed.snapshot.stamp,
             onStale: 'reject',
             claimRef: { id: claimed.lease.id },
             ...(claimed.lease.fenceToken !== undefined

package/src/local/client/options.ts

@@ -520,6 +520,15 @@ export interface InternalAbloOptions<S extends SchemaRecord = SchemaRecord> {
    */
   organizationId?: string;
 
+  /**
+   * Immutable branch selected by a self-hosted credential. Hosted clients
+   * receive this from the credential exchange.
+   */
+  branchId?: string;
+
+  /** Whether the selected self-hosted branch is the project's root branch. */
+  branchRoot?: boolean;
+
   /** The client-wide write default — see {@link AbloOptions.wait}. Projected
    *  from the public option rather than restated, so the two cannot diverge. */
   wait?: AbloOptions['wait'];

package/src/local/client/reactiveEngine.ts

@@ -13,6 +13,7 @@
  */
 
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
+import { omittedModelError } from '@abloatai/transaction/schema/select';
 import {
   durableCommitOperationSchema,
   type DurableCommitOperation,
@@ -401,6 +402,7 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
 	    claim: Claim,
 	    waited = false,
 	    fenceToken?: number,
+	    readAt?: number,
 	  ): Claim {
 	    const release = (): Promise<void> => {
 	      claim.revoke?.();
@@ -416,6 +418,7 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
 	      description: claim.description,
 	      target: claim.target,
 	      waited,
+	      ...(readAt !== undefined ? { readAt } : {}),
 	      ...(resolvedFenceToken !== undefined ? { fenceToken: resolvedFenceToken } : {}),
 	      release,
 	      revoke: claim.revoke,
@@ -448,9 +451,10 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
 	      // holds the lease, never a half-claimed one racing the queue.
 	      let waited = false;
 	      let fenceToken: number | undefined;
+	      let readAt: number | undefined;
 	      if (claimOptions.queue) {
 	        try {
-	          ({ waited, fenceToken } = await awaitClaimGrant(transport, claim.id, {
+	          ({ waited, fenceToken, readAt } = await awaitClaimGrant(transport, claim.id, {
 	            timeoutMs: claimOptions.waitTimeoutMs,
 	            maxQueueDepth: claimOptions.maxQueueDepth,
 	            signal: claimOptions.signal,
@@ -464,7 +468,7 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
 	          throw err;
 	        }
 	      }
-	      return wrapClaimHandle(claim, waited, fenceToken);
+	      return wrapClaimHandle(claim, waited, fenceToken, readAt);
 	    },
 	    list(target?: Partial<ModelTarget>): readonly ModelClaim[] {
 	      return listModelClaims(target);
@@ -931,5 +935,22 @@ export function buildReactiveEngine<const S extends SchemaRecord>(
     },
   } as Ablo<S>;
 
+  // A model the schema projection left out answers with an error naming the
+  // model and the fix, not `undefined`. An app can compile against the full
+  // source schema while running a projection, so the type system never sees
+  // this gap; without the stub the caller crashes one property later with a
+  // bare TypeError ("reading 'local'") that names neither. Non-enumerable so
+  // spread, Object.keys, and JSON.stringify walk past the stubs untriggered.
+  for (const name of schema.omittedModels ?? []) {
+    if (name in engine) continue;
+    Object.defineProperty(engine, name, {
+      get() {
+        throw omittedModelError(name);
+      },
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
   return engine;
 }

package/src/local/client/storeLifecycle.ts

@@ -194,8 +194,8 @@ export function startStoreLifecycle<S extends SchemaRecord>(
           userId,
           accountScope,
           projectId,
-          environment,
-          sandboxId,
+          branchId,
+          branchRoot,
           teamIds,
           capabilityToken,
           syncGroups,
@@ -257,13 +257,19 @@ export function startStoreLifecycle<S extends SchemaRecord>(
         // option doc) and everyone else defaults to 'full'.
         const resolvedBootstrapMode: 'full' | 'none' =
           internalOptions.bootstrapMode ?? (participantKind === 'agent' ? 'none' : 'full');
+        if (!branchId) {
+          throw new AbloConnectionError(
+            'The server did not resolve an Ablo branch for this credential.',
+            { code: 'invalid_request' },
+          );
+        }
 
         const gen = store.initialize({
           userId,
           organizationId: accountScope,
           projectId,
-          environment,
-          sandboxId,
+          branchId,
+          branchRoot,
           teamIds,
           kind: participantKind,
           capabilityToken,

package/src/local/stores/DatabaseManager.ts

@@ -31,8 +31,8 @@ export interface DatabaseInfo {
   workspaceId: string;
   participantKind: string;
   projectId: string | null;
-  environment: 'sandbox' | 'production' | null;
-  sandboxId: string | null;
+  branchId: string;
+  branchRoot: boolean;
   schemaHash: string;
   schemaVersion: number;
   userVersion?: number;
@@ -173,8 +173,8 @@ export class DatabaseManager {
       workspaceId: identity.organizationId,
       participantKind: identity.participantKind,
       projectId: identity.projectId,
-      environment: identity.environment,
-      sandboxId: identity.sandboxId,
+      branchId: identity.branchId,
+      branchRoot: identity.branchRoot,
       schemaHash,
       schemaVersion,
       userVersion,

package/src/local/stores/persistenceIdentity.ts

@@ -1,17 +1,16 @@
 import { AbloConnectionError } from '@abloatai/transaction/errors';
 
 /**
- * The complete authenticated plane that owns one local replica. The same
- * participant can have different data in a project, sandbox, or environment;
- * those replicas must never share a namespace.
+ * The complete authenticated branch that owns one local replica. A branch id
+ * is authoritative.
  */
 export interface PersistenceIdentity {
   readonly participantId: string;
   readonly participantKind: string;
   readonly organizationId: string;
   readonly projectId: string | null;
-  readonly environment: 'sandbox' | 'production' | null;
-  readonly sandboxId: string | null;
+  readonly branchId: string;
+  readonly branchRoot: boolean;
 }
 
 export interface PersistedIdentityMetadata {
@@ -20,11 +19,11 @@ export interface PersistedIdentityMetadata {
   readonly workspaceId: string;
   readonly participantKind?: string;
   readonly projectId?: string | null;
-  readonly environment?: 'sandbox' | 'production' | null;
-  readonly sandboxId?: string | null;
+  readonly branchId?: string;
+  readonly branchRoot?: boolean;
 }
 
-export const PERSISTENCE_NAMESPACE_VERSION = 2;
+export const PERSISTENCE_NAMESPACE_VERSION = 4;
 
 function canonicalIdentity(
   identity: PersistenceIdentity,
@@ -33,8 +32,7 @@ function canonicalIdentity(
   return JSON.stringify([
     PERSISTENCE_NAMESPACE_VERSION,
     identity.projectId,
-    identity.environment,
-    identity.sandboxId,
+    ['branch', identity.branchId, identity.branchRoot],
     identity.organizationId,
     identity.participantKind,
     identity.participantId,
@@ -77,7 +75,7 @@ export function persistenceIdentityMatches(
     info.workspaceId === identity.organizationId &&
     info.participantKind === identity.participantKind &&
     (info.projectId ?? null) === identity.projectId &&
-    (info.environment ?? null) === identity.environment &&
-    (info.sandboxId ?? null) === identity.sandboxId
+    info.branchId === identity.branchId &&
+    (info.branchRoot ?? false) === identity.branchRoot
   );
 }

package/src/local/sync/SyncWebSocket.ts

@@ -12,6 +12,7 @@
 
 import { getContext } from '../context.js';
 import { clientSyncDeltaSchema, type ClientSyncDelta } from '@abloatai/transaction/wire/delta';
+import { drainProfilingEnabled, observeDrainStage } from './drainProfile.js';
 import {
   WsTransport,
   type WsTransportOptions,
@@ -212,7 +213,23 @@ export class SyncWebSocket<
    * and an observability breadcrumb; it is never applied. There is one parse per
    * delta — callers must not re-parse.
    */
+  /**
+   * Wire validation runs once per delta, so at drain scale it is a per-delta
+   * fixed cost rather than a payload-proportional one. The guard keeps the
+   * normal path free: when profiling is off this is a boolean test and a
+   * direct call, with no closure allocated per delta.
+   */
   private normalizeWireDelta(raw: unknown): SyncDelta | null {
+    if (!drainProfilingEnabled()) return this.parseWireDelta(raw);
+    const startedAt = performance.now();
+    try {
+      return this.parseWireDelta(raw);
+    } finally {
+      observeDrainStage('parse', performance.now() - startedAt);
+    }
+  }
+
+  private parseWireDelta(raw: unknown): SyncDelta | null {
     let candidate: unknown = raw;
     if (isRecord(raw)) {
       const normalized: Record<string, unknown> = { ...raw };
@@ -255,12 +272,9 @@ export class SyncWebSocket<
   protected override handleDelta(rawDelta: unknown): void {
     const delta = this.normalizeWireDelta(rawDelta);
     if (!delta) return;
-    getContext().logger.debug('Received delta', {
-      action: delta.actionType,
-      model: delta.modelName,
-      id: delta.modelId,
-      syncId: delta.id,
-    });
+    // No per-delta debug here: the payload object is built even when the
+    // logger discards it, and this runs at the full live wire rate. Dropped
+    // malformed deltas are still logged by `normalizeWireDelta`.
 
     // Do not advance `this.cursor.lastSyncId` on receipt. The runtime cursor
     // must stay consistent with what has been persisted locally; otherwise the

package/src/local/sync/deltaPipeline.ts

@@ -24,6 +24,14 @@ import {
   type AbloPlugin,
   type AppliedChange,
 } from '../../plugin.js';
+import {
+  observeDrainBatch,
+  observeDrainAcknowledge,
+  timeDrainStage,
+  timeDrainStageAsync,
+  openDrainBatchRow,
+  closeDrainBatchRow,
+} from './drainProfile.js';
 
 /**
  * What the pipeline needs back from the surrounding store: the shared mutable
@@ -407,9 +415,22 @@ function yieldToHost(): Promise<void> {
 async function flushDeltaBatch(
   ctx: DeltaPipelineContext,
   queuedDeltas: SyncDelta[],
+): Promise<void> {
+  openDrainBatchRow(queuedDeltas.length);
+  try {
+    await flushDeltaBatchInner(ctx, queuedDeltas);
+  } finally {
+    closeDrainBatchRow();
+  }
+}
+
+async function flushDeltaBatchInner(
+  ctx: DeltaPipelineContext,
+  queuedDeltas: SyncDelta[],
 ): Promise<void> {
   const stagePlugins = ctx.stagePlugins ?? [];
-  const deduplicatedDeltas = ctx.deduplicateDeltas(queuedDeltas);
+  const deduplicatedDeltas = timeDrainStage('dedupe', () => ctx.deduplicateDeltas(queuedDeltas));
+  observeDrainBatch(queuedDeltas.length, deduplicatedDeltas.length);
   runStage(stagePlugins, 'dedupe', { deltas: deduplicatedDeltas });
 
   // Custom entities → apply straight to the pool, skipping the local store.
@@ -444,17 +465,19 @@ async function flushDeltaBatch(
   // handleGroupRemoved) and never reach here, though the persistence
   // signature accepts them defensively.
   const regularDeltas = deduplicatedDeltas.filter((d) => !ctx.isCustomEntity(d.modelName));
-  const batch = await ctx.processDeltaBatch(
-    regularDeltas.map((d) => ({
-      syncId: d.id,
-      actionType: d.actionType,
-      modelName: d.modelName,
-      modelId: d.modelId,
-      data: typeof d.data === 'string' ? JSON.parse(d.data) : d.data,
-      // Thread `transactionId` through so the receive layer can recognize
-      // echoes of locally-applied transactions and skip the pool mutation.
-      transactionId: d.transactionId,
-    }))
+  const batch = await timeDrainStageAsync('persist', () =>
+    ctx.processDeltaBatch(
+      regularDeltas.map((d) => ({
+        syncId: d.id,
+        actionType: d.actionType,
+        modelName: d.modelName,
+        modelId: d.modelId,
+        data: typeof d.data === 'string' ? JSON.parse(d.data) : d.data,
+        // Thread `transactionId` through so the receive layer can recognize
+        // echoes of locally-applied transactions and skip the pool mutation.
+        transactionId: d.transactionId,
+      }))
+    )
   );
   const dbResults = batch.results;
   runStage(stagePlugins, 'persist', { deltas: regularDeltas });
@@ -464,11 +487,13 @@ async function flushDeltaBatch(
   // materialiser attached where it said it would. The direct call is the
   // bridge for stores constructed without plugins (subclasses, tests),
   // whose own apply is the whole pipeline.
-  if (pluginsForStage(stagePlugins, 'apply').length > 0) {
-    runStage(stagePlugins, 'apply', { changes: dbResults });
-  } else {
-    ctx.applyDeltaBatchToPool(dbResults);
-  }
+  timeDrainStage('apply', () => {
+    if (pluginsForStage(stagePlugins, 'apply').length > 0) {
+      runStage(stagePlugins, 'apply', { changes: dbResults });
+    } else {
+      ctx.applyDeltaBatchToPool(dbResults);
+    }
+  });
 
   // Acknowledge and advance the sync cursor, gated on persistence.
   //
@@ -480,11 +505,16 @@ async function flushDeltaBatch(
   // be lost. The cursor and the persisted state must move together.
   const persistedSyncId = batch.persistedSyncId;
   if (persistedSyncId > ctx.lastAckedId) {
-    ctx.acknowledge(persistedSyncId);
-    ctx.advancePersisted(persistedSyncId);
-    runStage(stagePlugins, 'acknowledge', { syncId: persistedSyncId });
+    timeDrainStage('acknowledge', () => {
+      ctx.acknowledge(persistedSyncId);
+      ctx.advancePersisted(persistedSyncId);
+      observeDrainAcknowledge(persistedSyncId);
+      runStage(stagePlugins, 'acknowledge', { syncId: persistedSyncId });
+    });
   }
 
   // Cache invalidation happens automatically via the 'models:changed' event.
-  runStage(stagePlugins, 'notify', { changes: dbResults });
+  timeDrainStage('notify', () => {
+    runStage(stagePlugins, 'notify', { changes: dbResults });
+  });
 }