@syncular/server 0.15.45 → 0.15.46

package/src/postgres-storage.ts

@@ -36,6 +36,11 @@
  * does not tolerate). Cross-partition pushes never contend.
  */
 import type { PushOperationResult } from '@syncular/core';
+import {
+  bindAuthoritativePartition,
+  postgresPlaceholders,
+  prepareAuthoritativeQuery,
+} from './authoritative-query';
 import { syncError } from './errors';
 import {
   asBytes,
@@ -68,14 +73,24 @@ import {
 import type { CompiledSchema, CompiledTable } from './schema';
 import { matchesEffective } from './scopes';
 import type {
+  AuthoritativeQueryRequest,
+  AuthoritativeQueryResult,
   ClientCursorInfo,
   ClientRecord,
   ClientSubscription,
   CommitMetadata,
   CommitMetadataQuery,
   CommitWindowQuery,
+  DurableJsonValue,
   IndexRowScanQuery,
   NewCommit,
+  NewReaction,
+  PrunedReactionCounts,
+  ReactionClaimQuery,
+  ReactionFailure,
+  ReactionFailureUpdate,
+  ReactionListQuery,
+  ReactionPruneQuery,
   RowScanQuery,
   ScopeActivityQuery,
   ScopeCommitActivity,
@@ -84,6 +99,7 @@ import type {
   StoredChange,
   StoredCommit,
   StoredPushResult,
+  StoredReaction,
   StoredRow,
 } from './storage';
 import {
@@ -151,6 +167,26 @@ CREATE TABLE IF NOT EXISTS sync_push_results(
   client_commit_id TEXT NOT NULL, result JSONB NOT NULL,
   PRIMARY KEY(partition, client_id, client_commit_id)
 );
+CREATE TABLE IF NOT EXISTS sync_reactions(
+  partition TEXT NOT NULL, idempotency_key TEXT NOT NULL,
+  type TEXT NOT NULL, version INTEGER NOT NULL, payload JSONB NOT NULL,
+  source_client_id TEXT NOT NULL, source_client_commit_id TEXT NOT NULL,
+  source_commit_seq BIGINT NOT NULL, created_at_ms BIGINT NOT NULL,
+  available_at_ms BIGINT NOT NULL, status TEXT NOT NULL,
+  attempts INTEGER NOT NULL, max_attempts INTEGER NOT NULL,
+  lease_owner TEXT, lease_expires_at_ms BIGINT, completed_at_ms BIGINT,
+  last_failure JSONB,
+  PRIMARY KEY(partition, idempotency_key),
+  CHECK(status IN ('pending', 'leased', 'completed', 'dead-letter'))
+);
+CREATE INDEX IF NOT EXISTS sync_reactions_due
+  ON sync_reactions(partition, status, available_at_ms, created_at_ms, idempotency_key);
+CREATE INDEX IF NOT EXISTS sync_reactions_lease
+  ON sync_reactions(partition, status, lease_expires_at_ms);
+CREATE INDEX IF NOT EXISTS sync_reactions_completed
+  ON sync_reactions(partition, status, completed_at_ms, idempotency_key);
+CREATE INDEX IF NOT EXISTS sync_reactions_dead_letter
+  ON sync_reactions(partition, status, available_at_ms, idempotency_key);
 CREATE TABLE IF NOT EXISTS sync_clients(
   partition TEXT NOT NULL, client_id TEXT NOT NULL, actor_id TEXT NOT NULL,
   cursor BIGINT NOT NULL, subscriptions JSONB NOT NULL,
@@ -185,6 +221,52 @@ function fromBase64(text: string): Uint8Array {
   return new Uint8Array(Buffer.from(text, 'base64'));
 }
 
+interface PostgresReactionRecord {
+  idempotency_key: string;
+  type: string;
+  version: unknown;
+  payload: unknown;
+  source_client_id: string;
+  source_client_commit_id: string;
+  source_commit_seq: unknown;
+  created_at_ms: unknown;
+  available_at_ms: unknown;
+  status: StoredReaction['status'];
+  attempts: unknown;
+  max_attempts: unknown;
+  lease_owner: string | null;
+  lease_expires_at_ms: unknown | null;
+  completed_at_ms: unknown | null;
+  last_failure: unknown | null;
+}
+
+function toStoredReaction(record: PostgresReactionRecord): StoredReaction {
+  return {
+    idempotencyKey: record.idempotency_key,
+    type: record.type,
+    version: asNumber(record.version),
+    payload: asJson(record.payload) as DurableJsonValue,
+    sourceClientId: record.source_client_id,
+    sourceClientCommitId: record.source_client_commit_id,
+    sourceCommitSeq: asNumber(record.source_commit_seq),
+    createdAtMs: asNumber(record.created_at_ms),
+    maxAttempts: asNumber(record.max_attempts),
+    status: record.status,
+    attempts: asNumber(record.attempts),
+    availableAtMs: asNumber(record.available_at_ms),
+    ...(record.lease_owner !== null ? { leaseOwner: record.lease_owner } : {}),
+    ...(record.lease_expires_at_ms !== null
+      ? { leaseExpiresAtMs: asNumber(record.lease_expires_at_ms) }
+      : {}),
+    ...(record.completed_at_ms !== null
+      ? { completedAtMs: asNumber(record.completed_at_ms) }
+      : {}),
+    ...(record.last_failure !== null
+      ? { lastFailure: asJson(record.last_failure) as ReactionFailure }
+      : {}),
+  };
+}
+
 /**
  * Serialize a push result to a JSON-able object (stored in a JSONB column).
  * `serverRow` bytes are base64-encoded — JSONB cannot hold raw bytes.
@@ -719,6 +801,31 @@ class PostgresTransaction implements StorageTransaction {
     );
   }
 
+  async enqueueReactions(reactions: readonly NewReaction[]): Promise<void> {
+    this.#assertOpen();
+    for (const reaction of reactions) {
+      await this.#client.query(
+        `INSERT INTO sync_reactions(
+           partition, idempotency_key, type, version, payload,
+           source_client_id, source_client_commit_id, source_commit_seq,
+           created_at_ms, available_at_ms, status, attempts, max_attempts
+         ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$9,'pending',0,$10)`,
+        [
+          this.#partition,
+          reaction.idempotencyKey,
+          reaction.type,
+          reaction.version,
+          JSON.stringify(reaction.payload),
+          reaction.sourceClientId,
+          reaction.sourceClientCommitId,
+          reaction.sourceCommitSeq,
+          reaction.createdAtMs,
+          reaction.maxAttempts,
+        ],
+      );
+    }
+  }
+
   async commit(): Promise<void> {
     this.#assertOpen();
     this.#open = false;
@@ -940,6 +1047,46 @@ export class PostgresServerStorage implements ServerStorage {
     return rows[0] === undefined ? 0 : asNumber(rows[0].max_commit_seq);
   }
 
+  async queryAuthoritative(
+    partition: string,
+    query: AuthoritativeQueryRequest,
+  ): Promise<AuthoritativeQueryResult> {
+    if (this.#tables === undefined) {
+      throw new Error(
+        'ensureSchema(schema) must run before registered queries',
+      );
+    }
+    const prepared = bindAuthoritativePartition(
+      prepareAuthoritativeQuery(
+        query.sql,
+        query.params,
+        query.tables,
+        this.#tables,
+      ),
+      partition,
+    );
+    return this.#exec.transaction(async (client) => {
+      await client.query(
+        'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY',
+      );
+      const result = await client.query<Readonly<Record<string, unknown>>>(
+        postgresPlaceholders(prepared.sql),
+        prepared.params,
+      );
+      const cursor = await client.query<{ max_commit_seq: unknown }>(
+        'SELECT max_commit_seq FROM sync_partitions WHERE partition=$1',
+        [partition],
+      );
+      return {
+        rows: result.rows,
+        maxCommitSeq:
+          cursor.rows[0] === undefined
+            ? 0
+            : asNumber(cursor.rows[0].max_commit_seq),
+      };
+    });
+  }
+
   async getHorizonSeq(partition: string): Promise<number> {
     const { rows } = await this.#exec.query<{ horizon_seq: unknown }>(
       'SELECT horizon_seq FROM sync_partitions WHERE partition=$1',
@@ -1000,6 +1147,210 @@ export class PostgresServerStorage implements ServerStorage {
     return getPushResultOn(this.#exec, partition, clientId, clientCommitId);
   }
 
+  async claimReactions(
+    partition: string,
+    query: ReactionClaimQuery,
+  ): Promise<StoredReaction[]> {
+    if (query.types.length === 0 || query.limit <= 0) return [];
+    const typeParams = query.types.map((_, index) => `$${index + 2}`).join(',');
+    const nowParam = query.types.length + 2;
+    const limitParam = nowParam + 1;
+    const workerParam = limitParam + 1;
+    const expiresParam = workerParam + 1;
+    const { rows } = await this.#exec.query<PostgresReactionRecord>(
+      `WITH due AS (
+         SELECT partition, idempotency_key
+           FROM sync_reactions
+          WHERE partition=$1 AND type IN (${typeParams})
+            AND ((status='pending' AND available_at_ms<=$${nowParam})
+              OR (status='leased' AND lease_expires_at_ms<=$${nowParam}))
+          ORDER BY CASE WHEN status='leased' THEN lease_expires_at_ms
+                        ELSE available_at_ms END,
+                   created_at_ms, idempotency_key
+          FOR UPDATE SKIP LOCKED
+          LIMIT $${limitParam}
+       )
+       UPDATE sync_reactions AS reaction
+          SET status='leased', attempts=reaction.attempts+1,
+              lease_owner=$${workerParam}, lease_expires_at_ms=$${expiresParam},
+              completed_at_ms=NULL
+         FROM due
+        WHERE reaction.partition=due.partition
+          AND reaction.idempotency_key=due.idempotency_key
+      RETURNING reaction.*`,
+      [
+        partition,
+        ...query.types,
+        query.nowMs,
+        query.limit,
+        query.leaseOwner,
+        Math.min(Number.MAX_SAFE_INTEGER, query.nowMs + query.leaseDurationMs),
+      ],
+    );
+    return rows
+      .map(toStoredReaction)
+      .sort(
+        (a, b) =>
+          a.createdAtMs - b.createdAtMs ||
+          a.idempotencyKey.localeCompare(b.idempotencyKey),
+      );
+  }
+
+  async completeReaction(
+    partition: string,
+    idempotencyKey: string,
+    leaseOwner: string,
+    completedAtMs: number,
+  ): Promise<boolean> {
+    const result = await this.#exec.query(
+      `UPDATE sync_reactions
+          SET status='completed', completed_at_ms=$4,
+              lease_owner=NULL, lease_expires_at_ms=NULL
+        WHERE partition=$1 AND idempotency_key=$2
+          AND status='leased' AND lease_owner=$3`,
+      [partition, idempotencyKey, leaseOwner, completedAtMs],
+    );
+    return result.rowCount === 1;
+  }
+
+  async extendReactionLease(
+    partition: string,
+    idempotencyKey: string,
+    leaseOwner: string,
+    leaseExpiresAtMs: number,
+  ): Promise<boolean> {
+    const result = await this.#exec.query(
+      `UPDATE sync_reactions SET lease_expires_at_ms=$4
+        WHERE partition=$1 AND idempotency_key=$2
+          AND status='leased' AND lease_owner=$3`,
+      [partition, idempotencyKey, leaseOwner, leaseExpiresAtMs],
+    );
+    return result.rowCount === 1;
+  }
+
+  async failReaction(
+    partition: string,
+    idempotencyKey: string,
+    update: ReactionFailureUpdate,
+  ): Promise<boolean> {
+    const result = await this.#exec.query(
+      `UPDATE sync_reactions
+          SET status=$4, available_at_ms=$5, last_failure=$6,
+              lease_owner=NULL, lease_expires_at_ms=NULL
+        WHERE partition=$1 AND idempotency_key=$2
+          AND status='leased' AND lease_owner=$3`,
+      [
+        partition,
+        idempotencyKey,
+        update.leaseOwner,
+        update.retryAtMs === undefined ? 'dead-letter' : 'pending',
+        update.retryAtMs ?? update.failure.atMs,
+        JSON.stringify(update.failure),
+      ],
+    );
+    return result.rowCount === 1;
+  }
+
+  async retryReaction(
+    partition: string,
+    idempotencyKey: string,
+    nowMs: number,
+  ): Promise<boolean> {
+    const result = await this.#exec.query(
+      `UPDATE sync_reactions
+          SET status='pending', attempts=0, available_at_ms=$3,
+              last_failure=NULL, lease_owner=NULL, lease_expires_at_ms=NULL,
+              completed_at_ms=NULL
+        WHERE partition=$1 AND idempotency_key=$2 AND status='dead-letter'`,
+      [partition, idempotencyKey, nowMs],
+    );
+    return result.rowCount === 1;
+  }
+
+  async getReaction(
+    partition: string,
+    idempotencyKey: string,
+  ): Promise<StoredReaction | undefined> {
+    const { rows } = await this.#exec.query<PostgresReactionRecord>(
+      'SELECT * FROM sync_reactions WHERE partition=$1 AND idempotency_key=$2',
+      [partition, idempotencyKey],
+    );
+    return rows[0] === undefined ? undefined : toStoredReaction(rows[0]);
+  }
+
+  async listReactions(
+    partition: string,
+    query: ReactionListQuery,
+  ): Promise<StoredReaction[]> {
+    const where = ['partition=$1'];
+    const params: unknown[] = [partition];
+    if (query.statuses !== undefined && query.statuses.length > 0) {
+      const placeholders = query.statuses.map(
+        (_, index) => `$${params.length + index + 1}`,
+      );
+      where.push(`status IN (${placeholders.join(',')})`);
+      params.push(...query.statuses);
+    }
+    if (query.types !== undefined && query.types.length > 0) {
+      const placeholders = query.types.map(
+        (_, index) => `$${params.length + index + 1}`,
+      );
+      where.push(`type IN (${placeholders.join(',')})`);
+      params.push(...query.types);
+    }
+    params.push(query.limit);
+    const { rows } = await this.#exec.query<PostgresReactionRecord>(
+      `SELECT * FROM sync_reactions WHERE ${where.join(' AND ')}
+        ORDER BY created_at_ms DESC, idempotency_key DESC LIMIT $${params.length}`,
+      params,
+    );
+    return rows.map(toStoredReaction);
+  }
+
+  async pruneReactions(
+    partition: string,
+    query: ReactionPruneQuery,
+  ): Promise<PrunedReactionCounts> {
+    if (query.limit <= 0) return { completed: 0, deadLetter: 0 };
+    const { rows } = await this.#exec.query<{
+      status: 'completed' | 'dead-letter';
+    }>(
+      `WITH targets AS (
+         SELECT partition, idempotency_key
+           FROM sync_reactions
+          WHERE partition=$1
+            AND ((status='completed' AND completed_at_ms IS NOT NULL
+                  AND completed_at_ms<$2)
+              OR (status='dead-letter' AND available_at_ms<$3))
+          ORDER BY CASE WHEN status='completed' THEN completed_at_ms
+                        ELSE available_at_ms END,
+                   idempotency_key
+          FOR UPDATE SKIP LOCKED
+          LIMIT $4
+       )
+       DELETE FROM sync_reactions AS reaction
+        USING targets
+        WHERE reaction.partition=targets.partition
+          AND reaction.idempotency_key=targets.idempotency_key
+          AND ((reaction.status='completed'
+                AND reaction.completed_at_ms IS NOT NULL
+                AND reaction.completed_at_ms<$2)
+            OR (reaction.status='dead-letter'
+                AND reaction.available_at_ms<$3))
+      RETURNING reaction.status`,
+      [
+        partition,
+        query.completedBeforeMs,
+        query.deadLetterBeforeMs,
+        query.limit,
+      ],
+    );
+    return {
+      completed: rows.filter((row) => row.status === 'completed').length,
+      deadLetter: rows.filter((row) => row.status === 'dead-letter').length,
+    };
+  }
+
   async readCommitWindow(
     partition: string,
     query: CommitWindowQuery,

package/src/push.ts

@@ -33,6 +33,12 @@ import type { SyncRequestContext } from './context';
 import { clockOf } from './context';
 import type { CrdtMergerRegistry } from './crdt-merger';
 import { SyncError } from './errors';
+import { emitEvent } from './events';
+import {
+  prepareReactions,
+  type PreparedReaction,
+  toNewReactions,
+} from './reactions';
 import type { CompiledSchema, CompiledTable } from './schema';
 import type { ResolvedScopes } from './scopes';
 import { authorizeWrite, renderScopeValue, storedScopesForRow } from './scopes';
@@ -837,6 +843,31 @@ export async function processPushCommitWithTrace(
   resolved: ResolvedScopes,
   clientId: string,
   frame: PushCommitFrame,
+): Promise<ProcessedPushCommit> {
+  return processPushOperationsWithTrace(
+    ctx,
+    schema,
+    resolved,
+    clientId,
+    frame.clientCommitId,
+    async () => frame.operations,
+  );
+}
+
+/**
+ * Shared serialized apply path for SSP2 commits and authoritative commands.
+ * The builder runs after the partition lock and idempotency re-check, so its
+ * reads and the returned operations share the transaction that is committed.
+ */
+export async function processPushOperationsWithTrace(
+  ctx: SyncRequestContext,
+  schema: CompiledSchema,
+  resolved: ResolvedScopes,
+  clientId: string,
+  clientCommitId: string,
+  buildOperations: (
+    tx: StorageTransaction,
+  ) => Promise<readonly PushOperation[]>,
 ): Promise<ProcessedPushCommit> {
   const { storage, partition } = ctx;
   let persisted: StoredPushResult | undefined;
@@ -844,7 +875,7 @@ export async function processPushCommitWithTrace(
     persisted = await storage.getPushResult(
       partition,
       clientId,
-      frame.clientCommitId,
+      clientCommitId,
     );
   } catch (error) {
     if (
@@ -854,14 +885,14 @@ export async function processPushCommitWithTrace(
       // §6.3: answer the retryable cache-miss for this commit rather than
       // re-applying. Not persisted — a retry may find a readable record.
       return {
-        frame: idempotencyCacheMissFrame(frame.clientCommitId, error),
+        frame: idempotencyCacheMissFrame(clientCommitId, error),
         replayed: false,
       };
     }
     throw error;
   }
   if (persisted !== undefined) {
-    return processedPushCommit(frame.clientCommitId, persisted, true);
+    return processedPushCommit(clientCommitId, persisted, true);
   }
 
   const createdAtMs = clockOf(ctx)();
@@ -869,6 +900,7 @@ export async function processPushCommitWithTrace(
   const crdtMergers = ctx.crdtMergers;
   const validators = ctx.validators;
   const commitValidator = ctx.commitValidator;
+  const reactionPlanner = ctx.reactionPlanner;
   const tx = await storage.begin(partition);
   const lockPartitionForPush =
     tx.lockPartitionForPush?.bind(tx) ??
@@ -877,10 +909,11 @@ export async function processPushCommitWithTrace(
   try {
     if (
       lockPartitionForPush === undefined ||
-      commitRejectedPushResult === undefined
+      commitRejectedPushResult === undefined ||
+      (reactionPlanner !== undefined && tx.enqueueReactions === undefined)
     ) {
       throw new Error(
-        'storage transaction does not support serialized push apply and atomic rejection finalization',
+        'storage transaction does not support serialized push apply, atomic rejection finalization, and configured durable reactions',
       );
     }
     await lockPartitionForPush();
@@ -895,19 +928,11 @@ export async function processPushCommitWithTrace(
     try {
       const serializedPersisted =
         tx.getPushResult !== undefined
-          ? await tx.getPushResult(clientId, frame.clientCommitId)
-          : await storage.getPushResult(
-              partition,
-              clientId,
-              frame.clientCommitId,
-            );
+          ? await tx.getPushResult(clientId, clientCommitId)
+          : await storage.getPushResult(partition, clientId, clientCommitId);
       if (serializedPersisted !== undefined) {
         await tx.rollback();
-        return processedPushCommit(
-          frame.clientCommitId,
-          serializedPersisted,
-          true,
-        );
+        return processedPushCommit(clientCommitId, serializedPersisted, true);
       }
     } catch (error) {
       if (
@@ -916,7 +941,7 @@ export async function processPushCommitWithTrace(
       ) {
         await tx.rollback();
         return {
-          frame: idempotencyCacheMissFrame(frame.clientCommitId, error),
+          frame: idempotencyCacheMissFrame(clientCommitId, error),
           replayed: false,
         };
       }
@@ -926,8 +951,9 @@ export async function processPushCommitWithTrace(
     const changes: NewChange[] = [];
     const validatedOperations: ValidateCommitOperation[] = [];
     let terminated: PushOperationResult | undefined;
-    for (let opIndex = 0; opIndex < frame.operations.length; opIndex++) {
-      const op = frame.operations[opIndex];
+    const operations = await buildOperations(tx);
+    for (let opIndex = 0; opIndex < operations.length; opIndex++) {
+      const op = operations[opIndex];
       if (op === undefined) continue;
       const outcome = await applyOperation(
         tx,
@@ -956,7 +982,7 @@ export async function processPushCommitWithTrace(
         tx,
         schema,
         clientId,
-        frame.clientCommitId,
+        clientCommitId,
         ctx.actorId,
         partition,
         validatedOperations,
@@ -966,6 +992,18 @@ export async function processPushCommitWithTrace(
       }
     }
 
+    let preparedReactions: PreparedReaction[] = [];
+    if (terminated === undefined && reactionPlanner !== undefined) {
+      preparedReactions = await prepareReactions(reactionPlanner, {
+        clientId,
+        clientCommitId,
+        actorId: ctx.actorId,
+        partition,
+        operations: validatedOperations,
+        read: commitValidationReader(tx, schema),
+      });
+    }
+
     if (terminated !== undefined) {
       // §6.3 rejected: only the terminating operation's record; §6.4:
       // every write of the commit rolls back.
@@ -975,11 +1013,11 @@ export async function processPushCommitWithTrace(
       });
       // Discard candidates and persist the rejection while retaining the same
       // partition lock. There is no unlock gap in which a duplicate can rerun.
-      await commitRejectedPushResult(clientId, frame.clientCommitId, stored);
+      await commitRejectedPushResult(clientId, clientCommitId, stored);
       const canonical = await storage.getPushResult(
         partition,
         clientId,
-        frame.clientCommitId,
+        clientCommitId,
       );
       if (canonical === undefined) {
         throw new Error(
@@ -987,7 +1025,7 @@ export async function processPushCommitWithTrace(
         );
       }
       return processedPushCommit(
-        frame.clientCommitId,
+        clientCommitId,
         canonical,
         canonical.cacheIdentity !== stored.cacheIdentity,
       );
@@ -995,18 +1033,48 @@ export async function processPushCommitWithTrace(
 
     const commitSeq = await tx.appendCommit({
       clientId,
-      clientCommitId: frame.clientCommitId,
+      clientCommitId,
       actorId: ctx.actorId,
       createdAtMs,
       changes,
     });
+    const newReactions = toNewReactions(preparedReactions, {
+      clientId,
+      clientCommitId,
+      commitSeq,
+      createdAtMs,
+    });
+    if (newReactions.length > 0) {
+      const enqueueReactions = tx.enqueueReactions;
+      if (enqueueReactions === undefined) {
+        throw new Error('storage lost durable reaction enqueue support');
+      }
+      await enqueueReactions.call(tx, newReactions);
+    }
     const stored = newStoredPushResult(createdAtMs, {
       status: 'applied',
       commitSeq,
       results,
     });
-    await tx.putPushResult(clientId, frame.clientCommitId, stored);
+    await tx.putPushResult(clientId, clientCommitId, stored);
     await tx.commit();
+    if (ctx.events !== undefined) {
+      const atMs = clockOf(ctx)();
+      for (const reaction of newReactions) {
+        emitEvent(ctx.events, {
+          type: 'reaction.queued',
+          atMs,
+          partition,
+          actorId: ctx.actorId,
+          clientId,
+          clientCommitId,
+          commitSeq,
+          idempotencyKey: reaction.idempotencyKey,
+          reactionType: reaction.type,
+          version: reaction.version,
+        });
+      }
+    }
     if (ctx.realtime !== undefined && changes.length > 0) {
       await ctx.realtime.notifyCommit(partition, {
         commitSeq,
@@ -1015,7 +1083,7 @@ export async function processPushCommitWithTrace(
         changes,
       });
     }
-    return processedPushCommit(frame.clientCommitId, stored, false);
+    return processedPushCommit(clientCommitId, stored, false);
   } catch (error) {
     if (error instanceof StorageConstraintError) {
       const stored = newStoredPushResult(createdAtMs, {
@@ -1037,11 +1105,11 @@ export async function processPushCommitWithTrace(
         );
       }
       try {
-        await commitRejectedPushResult(clientId, frame.clientCommitId, stored);
+        await commitRejectedPushResult(clientId, clientCommitId, stored);
         const canonical = await storage.getPushResult(
           partition,
           clientId,
-          frame.clientCommitId,
+          clientCommitId,
         );
         if (canonical === undefined) {
           throw new Error(
@@ -1049,7 +1117,7 @@ export async function processPushCommitWithTrace(
           );
         }
         return processedPushCommit(
-          frame.clientCommitId,
+          clientCommitId,
           canonical,
           canonical.cacheIdentity !== stored.cacheIdentity,
         );