Collaborative Editing: Fix race condition and optimize cache invalidation in sync storage

Fixes a race condition in `get_updates_after_cursor` where updates inserted during the fetch window could be skipped by the next poll. The method now snapshots `max_meta_id` before fetching to ensure a consistent cursor.

Optimizes `remove_updates_before_cursor` to use a single atomic `DELETE` query instead of the previous read-delete-write approach.

Cleanup now uses direct SQL deletion to bypass `clean_post_cache`. This prevents sync operations from updating the global `posts_last_changed` salt, avoiding site-wide cache invalidation storms during high-frequency editing sessions.

Includes a regression test using a WPDB proxy to deterministically reproduce the race condition.

Author: mindctrl

src/wp-includes/collaboration/class-wp-sync-post-meta-storage.php

@@ -79,50 +79,16 @@ public function add_update( string $room, $update ): bool {
 			return false;
 		}
 
-		// Create an envelope and stamp each update to enable cursor-based filtering.
-		$envelope = array(
-			'timestamp' => $this->get_time_marker(),
-			'value'     => $update,
+		$meta_id = $this->with_suspended_posts_last_changed_update(
+			fn() => add_post_meta( $post_id, self::SYNC_UPDATE_META_KEY, $update, false )
 		);
 
-		return $this->with_suspended_posts_last_changed_update(
-			fn() => (bool) add_post_meta( $post_id, self::SYNC_UPDATE_META_KEY, $envelope, false )
-		);
-	}
-
-	/**
-	 * Retrieves all sync updates for a given room.
-	 *
-	 * @since 7.0.0
-	 *
-	 * @param string $room Room identifier.
-	 * @return array<int, array{ timestamp: int, value: mixed }> Sync updates.
-	 */
-	private function get_all_updates( string $room ): array {
-		$this->room_cursors[ $room ] = $this->get_time_marker() - 100; // Small buffer to ensure consistency.
-
-		$post_id = $this->get_storage_post_id( $room );
-		if ( null === $post_id ) {
-			return array();
+		if ( $meta_id ) {
+			$room_hash = md5( $room );
+			wp_cache_delete( "sync_room_state_{$room_hash}", 'sync' );
 		}
 
-		$updates = get_post_meta( $post_id, self::SYNC_UPDATE_META_KEY, false );
-
-		if ( ! is_array( $updates ) ) {
-			$updates = array();
-		}
-
-		// Filter out any updates that don't have the expected structure.
-		$updates = array_filter(
-			$updates,
-			static function ( $update ): bool {
-				return is_array( $update ) && isset( $update['timestamp'], $update['value'] ) && is_int( $update['timestamp'] );
-			}
-		);
-
-		$this->room_update_counts[ $room ] = count( $updates );
-
-		return $updates;
+		return (bool) $meta_id;
 	}
 
 	/**
@@ -134,6 +100,14 @@ static function ( $update ): bool {
 	 * @return array<int, mixed> Awareness state.
 	 */
 	public function get_awareness_state( string $room ): array {
+		$room_hash = md5( $room );
+		$cache_key = "sync_awareness_{$room_hash}";
+		$cached    = wp_cache_get( $cache_key, 'sync' );
+
+		if ( is_array( $cached ) ) {
+			return array_values( $cached );
+		}
+
 		$post_id = $this->get_storage_post_id( $room );
 		if ( null === $post_id ) {
 			return array();
@@ -145,6 +119,8 @@ public function get_awareness_state( string $room ): array {
 			return array();
 		}
 
+		wp_cache_set( $cache_key, $awareness, 'sync', MINUTE_IN_SECONDS );
+
 		return array_values( $awareness );
 	}
 
@@ -158,7 +134,25 @@ public function get_awareness_state( string $room ): array {
 	 * @return bool True on success, false on failure.
 	 */
 	public function set_awareness_state( string $room, array $awareness ): bool {
+		$room_hash = md5( $room );
+		$cache_key = "sync_awareness_{$room_hash}";
+
+		/**
+		 * Cache the awareness state to reduce post meta reads and writes.
+		 *
+		 * Awareness is inherently ephemeral and is not critical for
+		 * content consistency, so it's acceptable for it to be stale
+		 * or missing for a short period of time.
+		 *
+		 * For sites without object caching, fall back to post meta.
+		 */
+		wp_cache_set( $cache_key, $awareness, 'sync', MINUTE_IN_SECONDS );
+		if ( wp_using_ext_object_cache() ) {
+			return true;
+		}
+
 		$post_id = $this->get_storage_post_id( $room );
+
 		if ( null === $post_id ) {
 			return false;
 		}
@@ -174,8 +168,7 @@ public function set_awareness_state( string $room, array $awareness ): bool {
 	 * Gets the current cursor for a given room.
 	 *
 	 * The cursor is set during get_updates_after_cursor() and represents the
-	 * point in time just before the updates were retrieved, with a small buffer
-	 * to ensure consistency.
+	 * highest meta_id seen for the room's sync updates.
 	 *
 	 * @since 7.0.0
 	 *
@@ -239,17 +232,6 @@ private function get_storage_post_id( string $room ): ?int {
 		return null;
 	}
 
-	/**
-	 * Gets the current time in milliseconds as a comparable time marker.
-	 *
-	 * @since 7.0.0
-	 *
-	 * @return int Current time in milliseconds.
-	 */
-	private function get_time_marker(): int {
-		return (int) floor( microtime( true ) * 1000 );
-	}
-
 	/**
 	 * Gets the number of updates stored for a given room.
 	 *
@@ -263,32 +245,83 @@ public function get_update_count( string $room ): int {
 	}
 
 	/**
-	 * Retrieves sync updates from a room for a given client and cursor. Updates
-	 * from the specified client should be excluded.
+	 * Retrieves sync updates from a room after the given cursor.
 	 *
 	 * @since 7.0.0
 	 *
 	 * @param string $room   Room identifier.
-	 * @param int    $cursor Return updates after this cursor.
+	 * @param int    $cursor Return updates after this cursor (meta_id).
 	 * @return array<int, mixed> Sync updates.
 	 */
 	public function get_updates_after_cursor( string $room, int $cursor ): array {
-		$all_updates = $this->get_all_updates( $room );
-		$updates     = array();
+		global $wpdb;
 
-		foreach ( $all_updates as $update ) {
-			if ( $update['timestamp'] > $cursor ) {
-				$updates[] = $update;
-			}
+		$room_hash       = md5( $room );
+		$state_cache_key = "sync_room_state_{$room_hash}";
+		$cached          = wp_cache_get( $state_cache_key, 'sync' );
+
+		if ( is_array( $cached ) && $cached['cursor'] <= $cursor ) {
+			$this->room_cursors[ $room ]       = $cached['cursor'];
+			$this->room_update_counts[ $room ] = $cached['count'];
+			return array();
+		}
+
+		$post_id = $this->get_storage_post_id( $room );
+		if ( null === $post_id ) {
+			$this->room_cursors[ $room ]       = 0;
+			$this->room_update_counts[ $room ] = 0;
+			return array();
+		}
+
+		// Capture the current room state first so the returned cursor is race-safe.
+		$stats = $wpdb->get_row(
+			$wpdb->prepare(
+				"SELECT COUNT(*) AS total_updates, COALESCE( MAX(meta_id), 0 ) AS max_meta_id FROM {$wpdb->postmeta} WHERE post_id = %d AND meta_key = %s",
+				$post_id,
+				self::SYNC_UPDATE_META_KEY
+			)
+		);
+
+		$total_updates = $stats ? (int) $stats->total_updates : 0;
+		$max_meta_id   = $stats ? (int) $stats->max_meta_id : 0;
+
+		$this->room_update_counts[ $room ] = $total_updates;
+		$this->room_cursors[ $room ]       = $max_meta_id;
+
+		wp_cache_set(
+			$state_cache_key,
+			array(
+				'cursor' => $max_meta_id,
+				'count'  => $total_updates,
+			),
+			'sync'
+		);
+
+		if ( $max_meta_id <= $cursor ) {
+			return array();
 		}
 
-		// Sort by timestamp to ensure order.
-		usort(
-			$updates,
-			fn ( $a, $b ) => $a['timestamp'] <=> $b['timestamp']
+		$rows = $wpdb->get_results(
+			$wpdb->prepare(
+				"SELECT meta_value FROM {$wpdb->postmeta} WHERE post_id = %d AND meta_key = %s AND meta_id > %d AND meta_id <= %d ORDER BY meta_id ASC",
+				$post_id,
+				self::SYNC_UPDATE_META_KEY,
+				$cursor,
+				$max_meta_id
+			)
 		);
 
-		return wp_list_pluck( $updates, 'value' );
+		if ( ! $rows ) {
+			return array();
+		}
+
+		$updates = array();
+		foreach ( $rows as $row ) {
+			$update = maybe_unserialize( $row->meta_value );
+			$updates[] = $update;
+		}
+
+		return $updates;
 	}
 
 	/**
@@ -297,33 +330,37 @@ public function get_updates_after_cursor( string $room, int $cursor ): array {
 	 * @since 7.0.0
 	 *
 	 * @param string $room   Room identifier.
-	 * @param int    $cursor Remove updates with markers < this cursor.
+	 * @param int    $cursor Remove updates with meta_id < this cursor.
 	 * @return bool True on success, false on failure.
 	 */
 	public function remove_updates_before_cursor( string $room, int $cursor ): bool {
+		global $wpdb;
+
 		$post_id = $this->get_storage_post_id( $room );
 		if ( null === $post_id ) {
 			return false;
 		}
 
-		$all_updates = $this->get_all_updates( $room );
+		$deleted_rows = $wpdb->query(
+			$wpdb->prepare(
+				"DELETE FROM {$wpdb->postmeta} WHERE post_id = %d AND meta_key = %s AND meta_id < %d",
+				$post_id,
+				self::SYNC_UPDATE_META_KEY,
+				$cursor
+			)
+		);
 
-		// Remove all updates for the room and re-store only those that are newer than the cursor.
-		if ( ! $this->with_suspended_posts_last_changed_update( fn() => delete_post_meta( $post_id, self::SYNC_UPDATE_META_KEY ) ) ) {
+		if ( false === $deleted_rows ) {
 			return false;
 		}
 
-		// Re-store envelopes directly to avoid double-wrapping by add_update().
-		$add_result = true;
-		foreach ( $all_updates as $envelope ) {
-			if ( $add_result && $envelope['timestamp'] >= $cursor ) {
-				$add_result = $this->with_suspended_posts_last_changed_update(
-					fn() => (bool) add_post_meta( $post_id, self::SYNC_UPDATE_META_KEY, $envelope, false )
-				);
-			}
+		if ( $deleted_rows > 0 ) {
+			wp_cache_delete( $post_id, 'post_meta' );
+			$room_hash = md5( $room );
+			wp_cache_delete( "sync_room_state_{$room_hash}", 'sync' );
 		}
 
-		return $add_result;
+		return true;
 	}
 
 	/**