@atlaskit/editor-synced-block-provider 6.6.12 → 6.7.1

package/dist/es2019/store-manager/referenceSyncBlockStoreManager.js

@@ -3,7 +3,7 @@ import isEqual from 'lodash/isEqual';
 import { logException } from '@atlaskit/editor-common/monitoring';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { SyncBlockError } from '../common/types';
-import { fetchErrorPayload, fetchSuccessPayload, getSourceInfoErrorPayload, updateReferenceErrorPayload } from '../utils/errorHandling';
+import { cacheDeletionForcedPayload, fetchErrorPayload, fetchSuccessPayload, getSourceInfoErrorPayload, sourceInfoOrphanedPayload, updateReferenceErrorPayload } from '../utils/errorHandling';
 import { getFetchExperience, getFetchSourceInfoExperience, getSaveReferenceExperience } from '../utils/experienceTracking';
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 import { createSyncBlockNode, getSourceProductFromResourceIdSafe, stripAnnotationMarksFromJSONContent } from '../utils/utils';
@@ -15,6 +15,13 @@ const CACHE_KEY_PREFIX = 'sync-block-data-';
 const ENTITY_NOT_FOUND_MAX_RETRIES = 3;
 const ENTITY_NOT_FOUND_INITIAL_DELAY_MS = 2000;
 
+// Grace period before a cache entry is removed after the last subscriber
+// unsubscribes (gated by `platform_synced_block_patch_14`). Guards are
+// re-checked at fire time; if any are positive, the timer is rescheduled.
+const CACHE_DELETION_GRACE_PERIOD_MS = 30_000;
+// Max reschedules before force-deleting with an analytics event (~5 min).
+const CACHE_DELETION_MAX_RESCHEDULES = 10;
+
 // A store manager responsible for the lifecycle and state management of reference sync blocks in an editor instance.
 // Designed to manage local in-memory state and synchronize with an external data provider.
 // Supports fetch, cache, and subscription for sync block data.
@@ -36,6 +43,13 @@ export class ReferenceSyncBlockStoreManager {
     // Track retry attempts for EntityNotFound errors (block may be in the process of being created)
     _defineProperty(this, "entityNotFoundRetryCount", new Map());
     _defineProperty(this, "entityNotFoundRetryTimers", new Map());
+    // Pending cache deletion timers keyed by resourceId (gated by
+    // `platform_synced_block_patch_14`). Cancelled when a subscriber re-attaches.
+    _defineProperty(this, "pendingCacheDeletions", new Map());
+    // Reschedule counter per resource — reset on actual deletion or re-subscribe.
+    _defineProperty(this, "cacheDeletionRescheduleCounts", new Map());
+    // Set by destroy() so in-flight timer callbacks can early-return.
+    _defineProperty(this, "isDestroyed", false);
     this.dataProvider = dataProvider;
     this.viewMode = viewMode;
     this.syncBlockFetchDataRequests = new Map();
@@ -51,7 +65,11 @@ export class ReferenceSyncBlockStoreManager {
       getFireAnalyticsEvent: () => this.fireAnalyticsEvent,
       markCacheDirty: () => {
         this.isCacheDirty = true;
-      }
+      },
+      // Delegate cache lifecycle to the store manager so guards can be
+      // checked atomically (gated by `platform_synced_block_patch_14`).
+      scheduleCacheDeletion: rid => this.scheduleCacheDeletion(rid),
+      cancelPendingCacheDeletion: rid => this.cancelPendingCacheDeletion(rid)
     });
     this._providerFactoryManager = new SyncBlockProviderFactoryManager({
       getDataProvider: () => this.dataProvider,
@@ -507,6 +525,19 @@ export class ReferenceSyncBlockStoreManager {
   }
   updateCacheWithSourceInfo(resourceId, sourceInfo) {
     const existingSyncBlock = this.getFromCache(resourceId);
+    // If the cache entry was deleted while the source-info request was
+    // in flight, fire an analytics event so the race is observable.
+    if (!existingSyncBlock && fg('platform_synced_block_patch_14')) {
+      var _this$fireAnalyticsEv1;
+      (_this$fireAnalyticsEv1 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv1 === void 0 ? void 0 : _this$fireAnalyticsEv1.call(this, sourceInfoOrphanedPayload(resourceId, getSourceProductFromResourceIdSafe(resourceId), {
+        hasPendingDeletion: this.pendingCacheDeletions.has(resourceId),
+        hasSubscribers: this._subscriptionManager.getSubscriptions().has(resourceId)
+      }));
+      logException(new Error('updateCacheWithSourceInfo: cache entry missing for resource'), {
+        location: 'editor-synced-block-provider/referenceSyncBlockStoreManager/orphaned-source-info'
+      });
+      return;
+    }
     if (existingSyncBlock && existingSyncBlock.data) {
       existingSyncBlock.data.sourceURL = sourceInfo === null || sourceInfo === void 0 ? void 0 : sourceInfo.url;
       existingSyncBlock.data = {
@@ -546,6 +577,125 @@ export class ReferenceSyncBlockStoreManager {
     var _this$dataProvider5;
     (_this$dataProvider5 = this.dataProvider) === null || _this$dataProvider5 === void 0 ? void 0 : _this$dataProvider5.removeFromCache([resourceId]);
     this._providerFactoryManager.deleteFactory(resourceId);
+    // Evict in-flight source-info promise and reset reschedule counter
+    // so a stale resolution can't silently merge into a re-fetched entry.
+    if (fg('platform_synced_block_patch_14')) {
+      this.syncBlockSourceInfoRequests.delete(resourceId);
+      this.cacheDeletionRescheduleCounts.delete(resourceId);
+    }
+  }
+
+  /**
+   * Returns true if the cache entry for `resourceId` is safe to delete:
+   * no active subscribers, no in-flight source-info request, and no
+   * queued/in-flight batch fetch (gated by `platform_synced_block_patch_14`).
+   */
+  canDeleteCache(resourceId) {
+    if (this._subscriptionManager.getSubscriptions().has(resourceId)) {
+      return false;
+    }
+    if (this.syncBlockSourceInfoRequests.has(resourceId)) {
+      return false;
+    }
+    if (this._batchFetcher.hasPendingFetch(resourceId)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Schedules cache deletion for `resourceId` after the grace period
+   * (gated by `platform_synced_block_patch_14`). Called when the last
+   * subscriber unsubscribes. Guards are re-checked at fire time; if any
+   * are positive the timer is rescheduled up to MAX_RESCHEDULES times.
+   */
+  scheduleCacheDeletion(resourceId) {
+    if (!fg('platform_synced_block_patch_14')) {
+      return;
+    }
+    if (this.isDestroyed) {
+      return;
+    }
+    // Cancel any existing timer \u2014 restart the grace period \u2014 but DO NOT
+    // reset the reschedule counter. The counter is reset only by
+    // `cancelPendingCacheDeletion` (called when a real subscriber returns)
+    // or when the cache is actually deleted.
+    const existing = this.pendingCacheDeletions.get(resourceId);
+    if (existing) {
+      clearTimeout(existing);
+      this.pendingCacheDeletions.delete(resourceId);
+    }
+    const timer = setTimeout(() => {
+      // Guard against timer callback running after destroy. clearTimeout
+      // is synchronous so this should be unreachable in practice, but
+      // belt-and-braces.
+      if (this.isDestroyed) {
+        return;
+      }
+      this.pendingCacheDeletions.delete(resourceId);
+      this.onCacheDeletionTimerFire(resourceId);
+    }, CACHE_DELETION_GRACE_PERIOD_MS);
+    this.pendingCacheDeletions.set(resourceId, timer);
+  }
+
+  /**
+   * Cancels any pending cache deletion timer for `resourceId` and resets the
+   * reschedule counter (gated by `platform_synced_block_patch_14`). Called
+   * when a new subscriber arrives.
+   */
+  cancelPendingCacheDeletion(resourceId) {
+    if (!fg('platform_synced_block_patch_14')) {
+      return;
+    }
+    const existing = this.pendingCacheDeletions.get(resourceId);
+    if (existing) {
+      clearTimeout(existing);
+      this.pendingCacheDeletions.delete(resourceId);
+    }
+    // Subscribers returning resets the reschedule counter \u2014 the resource is
+    // active again.
+    this.cacheDeletionRescheduleCounts.delete(resourceId);
+  }
+
+  /** Returns whether a cache deletion timer is pending for `resourceId`. */
+  hasPendingCacheDeletion(resourceId) {
+    return this.pendingCacheDeletions.has(resourceId);
+  }
+  onCacheDeletionTimerFire(resourceId) {
+    var _this$cacheDeletionRe;
+    if (this.canDeleteCache(resourceId)) {
+      // `deleteFromCache` resets the reschedule counter under the flag.
+      this.deleteFromCache(resourceId);
+      return;
+    }
+    const currentCount = (_this$cacheDeletionRe = this.cacheDeletionRescheduleCounts.get(resourceId)) !== null && _this$cacheDeletionRe !== void 0 ? _this$cacheDeletionRe : 0;
+    if (currentCount >= CACHE_DELETION_MAX_RESCHEDULES) {
+      var _this$fireAnalyticsEv10;
+      // Stuck guard — force deletion to prevent unbounded memory growth and
+      // fire analytics so the stuck state is visible in production telemetry.
+      //
+      // NOTE: If active React subscribers still exist at force-delete time
+      // (e.g. an in-flight batch fetch never settled), the cache entry is
+      // removed without notifying subscribers. Those components will
+      // continue to render with stale data until their next re-render
+      // triggers a new batch fetch — typically within ~1 frame. We accept
+      // this brief stale window in exchange for bounded memory growth.
+      (_this$fireAnalyticsEv10 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv10 === void 0 ? void 0 : _this$fireAnalyticsEv10.call(this, cacheDeletionForcedPayload(currentCount, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+      logException(new Error(`Cache deletion forced after ${currentCount} reschedules — stuck in-flight guard`), {
+        location: 'editor-synced-block-provider/referenceSyncBlockStoreManager/cache-deletion-forced'
+      });
+      // `deleteFromCache` resets the reschedule counter under the flag.
+      this.deleteFromCache(resourceId);
+      // If subscribers still exist, kick off a fresh fetch so they get
+      // fresh data on the next batch tick instead of holding stale data
+      // indefinitely.
+      if (this._subscriptionManager.getSubscriptions().has(resourceId)) {
+        this.debouncedBatchedFetchSyncBlocks(resourceId);
+      }
+      return;
+    }
+    this.cacheDeletionRescheduleCounts.set(resourceId, currentCount + 1);
+    this.scheduleCacheDeletion(resourceId);
   }
 
   /**
@@ -628,11 +778,11 @@ export class ReferenceSyncBlockStoreManager {
       }
       return this._subscriptionManager.subscribeToSyncBlock(resourceId, localId, callback);
     } catch (error) {
-      var _this$fireAnalyticsEv1;
+      var _this$fireAnalyticsEv11;
       logException(error, {
         location: 'editor-synced-block-provider/referenceSyncBlockStoreManager'
       });
-      (_this$fireAnalyticsEv1 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv1 === void 0 ? void 0 : _this$fireAnalyticsEv1.call(this, fetchErrorPayload(error.message));
+      (_this$fireAnalyticsEv11 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv11 === void 0 ? void 0 : _this$fireAnalyticsEv11.call(this, fetchErrorPayload(error.message));
       return () => {};
     }
   }
@@ -643,12 +793,8 @@ export class ReferenceSyncBlockStoreManager {
    * @returns
    */
   getSyncBlockURL(resourceId) {
-    var _syncBlock$data2;
-    const syncBlock = this.getFromCache(resourceId);
-    if (!syncBlock) {
-      return undefined;
-    }
-    return (_syncBlock$data2 = syncBlock.data) === null || _syncBlock$data2 === void 0 ? void 0 : _syncBlock$data2.sourceURL;
+    var _this$getFromCache, _this$getFromCache$da;
+    return (_this$getFromCache = this.getFromCache(resourceId)) === null || _this$getFromCache === void 0 ? void 0 : (_this$getFromCache$da = _this$getFromCache.data) === null || _this$getFromCache$da === void 0 ? void 0 : _this$getFromCache$da.sourceURL;
   }
   getProviderFactory(resourceId) {
     return this._providerFactoryManager.getProviderFactory(resourceId);
@@ -722,15 +868,15 @@ export class ReferenceSyncBlockStoreManager {
       (_this$saveExperience = this.saveExperience) === null || _this$saveExperience === void 0 ? void 0 : _this$saveExperience.start();
       const updateResult = await this.dataProvider.updateReferenceData(blocks);
       if (!updateResult.success) {
-        var _this$saveExperience2, _this$fireAnalyticsEv10;
+        var _this$saveExperience2, _this$fireAnalyticsEv12;
         success = false;
         (_this$saveExperience2 = this.saveExperience) === null || _this$saveExperience2 === void 0 ? void 0 : _this$saveExperience2.failure({
           reason: updateResult.error || 'Failed to update reference synced blocks on the document'
         });
-        (_this$fireAnalyticsEv10 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv10 === void 0 ? void 0 : _this$fireAnalyticsEv10.call(this, updateReferenceErrorPayload(updateResult.error || 'Failed to update reference synced blocks on the document'));
+        (_this$fireAnalyticsEv12 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv12 === void 0 ? void 0 : _this$fireAnalyticsEv12.call(this, updateReferenceErrorPayload(updateResult.error || 'Failed to update reference synced blocks on the document'));
       }
     } catch (error) {
-      var _this$saveExperience3, _this$fireAnalyticsEv11;
+      var _this$saveExperience3, _this$fireAnalyticsEv13;
       success = false;
       logException(error, {
         location: 'editor-synced-block-provider/referenceSyncBlockStoreManager'
@@ -739,7 +885,7 @@ export class ReferenceSyncBlockStoreManager {
         reason: error.message
       });
       // No `resourceId` available in this catch — sourceProduct is intentionally omitted.
-      (_this$fireAnalyticsEv11 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv11 === void 0 ? void 0 : _this$fireAnalyticsEv11.call(this, updateReferenceErrorPayload(error.message));
+      (_this$fireAnalyticsEv13 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv13 === void 0 ? void 0 : _this$fireAnalyticsEv13.call(this, updateReferenceErrorPayload(error.message));
     } finally {
       if (!success) {
         // set isCacheDirty back to true for cases where it failed to update the reference synced blocks on the BE
@@ -768,6 +914,9 @@ export class ReferenceSyncBlockStoreManager {
   }
   destroy() {
     var _this$dataProvider6, _this$saveExperience5, _this$fetchExperience0, _this$fetchSourceInfo6;
+    // Mark destroyed first so in-flight timer callbacks can early-return.
+    this.isDestroyed = true;
+
     // Cancel any queued flush to prevent it from running after destroy
     if (this.queuedFlushTimeout) {
       clearTimeout(this.queuedFlushTimeout);
@@ -778,6 +927,11 @@ export class ReferenceSyncBlockStoreManager {
     this.entityNotFoundRetryTimers.forEach(timer => clearTimeout(timer));
     this.entityNotFoundRetryTimers.clear();
     this.entityNotFoundRetryCount.clear();
+
+    // Cancel pending cache deletion timers.
+    this.pendingCacheDeletions.forEach(timer => clearTimeout(timer));
+    this.pendingCacheDeletions.clear();
+    this.cacheDeletionRescheduleCounts.clear();
     this._subscriptionManager.destroy();
     this._providerFactoryManager.destroy();
     this._batchFetcher.destroy();
@@ -795,6 +949,17 @@ export class ReferenceSyncBlockStoreManager {
       reason: 'editorDestroyed'
     });
     this.fireAnalyticsEvent = undefined;
-    syncBlockInMemorySessionCache.clear();
+
+    // Under `platform_synced_block_patch_14`, `destroy()` is now wired to
+    // React component unmount via `useMemoizedSyncBlockStoreManager`.
+    // Clearing the module-level singleton on unmount would wipe SSR session
+    // cache data that a sibling/successor manager (e.g. the editor
+    // instance that mounts immediately after the renderer unmounts during
+    // the view-mode transition) is about to read.
+    // Let entries age out naturally instead — the in-memory cache is
+    // naturally bounded by `maxSize` (LRU) and cleared on hard navigation.
+    if (!fg('platform_synced_block_patch_14')) {
+      syncBlockInMemorySessionCache.clear();
+    }
   }
 }

package/dist/es2019/store-manager/syncBlockBatchFetcher.js

@@ -11,6 +11,11 @@ import { createSyncBlockNode, getSourceProductFromResourceIdSafe } from '../util
 export class SyncBlockBatchFetcher {
   constructor(deps) {
     _defineProperty(this, "pendingFetchRequests", new Set());
+    // Tracks resourceIds whose batched fetch is in flight (after RAF drains
+    // pendingFetchRequests, before the promise settles). Ensures
+    // `hasPendingFetch` remains true during the network window.
+    _defineProperty(this, "inFlightFetches", new Set());
+    _defineProperty(this, "isDestroyed", false);
     this.deps = deps;
     this.scheduledBatchFetch = rafSchedule(() => {
       if (this.pendingFetchRequests.size === 0) {
@@ -23,6 +28,9 @@ export class SyncBlockBatchFetcher {
         return createSyncBlockNode(firstLocalId, resId);
       });
       this.pendingFetchRequests.clear();
+
+      // Track in-flight before the fetch so guards remain positive.
+      resourceIds.forEach(resId => this.inFlightFetches.add(resId));
       this.deps.fetchSyncBlocksData(syncBlockNodes).catch(error => {
         logException(error, {
           location: 'editor-synced-block-provider/syncBlockBatchFetcher/batchedFetchSyncBlocks'
@@ -31,6 +39,15 @@ export class SyncBlockBatchFetcher {
           var _this$deps$getFireAna;
           (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 ? void 0 : _this$deps$getFireAna(fetchErrorPayload(error.message, resId, getSourceProductFromResourceIdSafe(resId)));
         });
+      }).finally(() => {
+        // If the fetcher was destroyed while the request was in flight,
+        // skip cleanup — `destroy()` already cleared `inFlightFetches`
+        // and there's nothing observable to update.
+        if (this.isDestroyed) {
+          return;
+        }
+        // Clear in-flight tracking once the fetch settles.
+        resourceIds.forEach(resId => this.inFlightFetches.delete(resId));
       });
     });
   }
@@ -43,6 +60,15 @@ export class SyncBlockBatchFetcher {
       this.pendingFetchRequests.delete(resourceId);
     }
   }
+
+  /**
+   * Returns true if a batched fetch is queued or in flight for `resourceId`.
+   * Used by cache deletion guards to prevent deleting while a fetch is
+   * about to populate the entry.
+   */
+  hasPendingFetch(resourceId) {
+    return this.pendingFetchRequests.has(resourceId) || this.inFlightFetches.has(resourceId);
+  }
   cancel() {
     this.scheduledBatchFetch.cancel();
   }
@@ -50,7 +76,10 @@ export class SyncBlockBatchFetcher {
     this.pendingFetchRequests.clear();
   }
   destroy() {
+    this.isDestroyed = true;
     this.cancel();
     this.clearPending();
+    // Clear in-flight tracking to prevent stale entries after teardown.
+    this.inFlightFetches.clear();
   }
 }

package/dist/es2019/store-manager/syncBlockStoreManager.js

@@ -1,5 +1,6 @@
-import { useMemo, useRef } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 import { logException } from '@atlaskit/editor-common/monitoring';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { getProductFromSourceAri } from '../clients/block-service/ari';
 import { SyncBlockError } from '../common/types';
 import { fetchReferencesErrorPayload } from '../utils/errorHandling';
@@ -13,6 +14,7 @@ import { SourceSyncBlockStoreManager } from './sourceSyncBlockStoreManager';
 // ReferenceSyncBlockStoreManager is responsible for the lifecycle and state management of reference sync blocks in an editor instance.
 // SourceSyncBlockStoreManager is responsible for the lifecycle and state management of source sync blocks in an editor instance.
 // Can be used in both editor and renderer contexts.
+
 export class SyncBlockStoreManager {
   constructor(dataProvider, viewMode, isLivePage) {
     // In future, if reference manager needs to reach to source manager and read its current in memory cache
@@ -206,5 +208,23 @@ export const useMemoizedSyncBlockStoreManager = (dataProvider, fireAnalyticsEven
     prevFireAnalyticsEventRef.current = fireAnalyticsEvent;
     syncBlockStoreManager.setFireAnalyticsEvent(fireAnalyticsEvent);
   }
+
+  // Gated by platform_synced_block_patch_14:
+  // Destroy the SyncBlockStoreManager when:
+  //   (a) the component unmounts — manager is fully cleaned up, or
+  //   (b) dataProvider changes — the old manager (now orphaned by the
+  //       useMemo recalculation) is destroyed before the new one takes over.
+  //
+  // Without this, orphaned managers leak timers, GQL subscriptions, and
+  // in-flight fetches indefinitely. The effect dep is `syncBlockStoreManager`
+  // (the useMemo result) — it changes identity precisely when dataProvider
+  // changes, triggering the cleanup for the old instance.
+  useEffect(() => {
+    return () => {
+      if (fg('platform_synced_block_patch_14')) {
+        syncBlockStoreManager.destroy();
+      }
+    };
+  }, [syncBlockStoreManager]);
   return syncBlockStoreManager;
 };

package/dist/es2019/store-manager/syncBlockSubscriptionManager.js

@@ -1,5 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { logException } from '@atlaskit/editor-common/monitoring';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { fetchErrorPayload, fetchSuccessPayload } from '../utils/errorHandling';
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 import { getSourceProductFromResourceIdSafe } from '../utils/utils';
@@ -9,6 +10,7 @@ import { getSourceProductFromResourceIdSafe } from '../utils/utils';
  * and provides a listener API so React components can react when the set
  * of subscribed resource IDs changes.
  */
+
 export class SyncBlockSubscriptionManager {
   constructor(deps) {
     _defineProperty(this, "subscriptions", new Map());
@@ -85,8 +87,13 @@ export class SyncBlockSubscriptionManager {
     // This handles the case where a block is moved - the old component unmounts
     // (scheduling deletion) but the new component mounts and subscribes before
     // the deletion timeout fires.
+    //
+    // Under the flag, cache deletion is owned by the store manager.
+    // With the flag off, the legacy 1s timer path is preserved.
     const pendingDeletion = this.pendingCacheDeletions.get(resourceId);
-    if (pendingDeletion) {
+    if (fg('platform_synced_block_patch_14')) {
+      this.deps.cancelPendingCacheDeletion(resourceId);
+    } else if (pendingDeletion) {
       clearTimeout(pendingDeletion);
       this.pendingCacheDeletions.delete(resourceId);
     }
@@ -123,7 +130,8 @@ export class SyncBlockSubscriptionManager {
         // Unsubscription means a reference synced block is removed from the document
         this.deps.markCacheDirty();
         delete resourceSubscriptions[localId];
-        if (Object.keys(resourceSubscriptions).length === 0) {
+        const remainingIds = Object.keys(resourceSubscriptions);
+        if (remainingIds.length === 0) {
           this.subscriptions.delete(resourceId);
 
           // Clean up GraphQL subscription when no more local subscribers
@@ -132,19 +140,30 @@ export class SyncBlockSubscriptionManager {
           // Notify listeners that subscription was removed
           this.notifySubscriptionChangeListeners();
 
-          // Delay cache deletion to handle block moves (unmount/remount).
-          // When a block is moved, the old component unmounts before the new one mounts.
-          // By delaying deletion, we give the new component time to subscribe and
-          // cancel this pending deletion, preserving the cached data.
-          // TODO: EDITOR-4152 - Rework this logic
-          const deletionTimeout = setTimeout(() => {
-            // Only delete if still no subscribers (wasn't re-subscribed)
-            if (!this.subscriptions.has(resourceId)) {
-              this.deps.deleteFromCache(resourceId);
-            }
-            this.pendingCacheDeletions.delete(resourceId);
-          }, 1000);
-          this.pendingCacheDeletions.set(resourceId, deletionTimeout);
+          // Under the flag, delegate cache deletion to the store manager
+          // which uses a 30s grace period with guard re-checks.
+          if (fg('platform_synced_block_patch_14')) {
+            this.deps.scheduleCacheDeletion(resourceId);
+          } else {
+            // Legacy path (unchanged): delay cache deletion to handle
+            // block moves (unmount/remount). When a block is moved, the
+            // old component unmounts before the new one mounts. By
+            // delaying deletion, we give the new component time to
+            // subscribe and cancel this pending deletion, preserving
+            // the cached data.
+            // TODO: EDITOR-4152 - Rework this logic (superseded by
+            // `platform_synced_block_patch_14`).
+            const deletionTimeout = setTimeout(() => {
+              const hasSubscribers = this.subscriptions.has(resourceId);
+
+              // Only delete if still no subscribers (wasn't re-subscribed)
+              if (!hasSubscribers) {
+                this.deps.deleteFromCache(resourceId);
+              }
+              this.pendingCacheDeletions.delete(resourceId);
+            }, 1000);
+            this.pendingCacheDeletions.set(resourceId, deletionTimeout);
+          }
         } else {
           this.subscriptions.set(resourceId, resourceSubscriptions);
         }

package/dist/es2019/utils/errorHandling.js

@@ -35,6 +35,52 @@ export const updateReferenceErrorPayload = (error, resourceId, sourceProduct) =>
 export const createErrorPayload = (error, resourceId, sourceProduct) => getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_CREATE, error, resourceId, sourceProduct);
 export const deleteErrorPayload = (error, resourceId, sourceProduct) => getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_DELETE, error, resourceId, sourceProduct);
 export const updateCacheErrorPayload = (error, resourceId, sourceProduct) => getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_UPDATE_CACHE, error, resourceId, sourceProduct);
+/**
+ * Payload for `SYNCED_BLOCK_SOURCE_INFO_ORPHANED`. Fired when source-info
+ * resolves into a cache that has already been deleted — should be unreachable
+ * under `platform_synced_block_patch_14`.
+ */
+export const sourceInfoOrphanedPayload = (resourceId, sourceProduct, context) => ({
+  action: ACTION.ERROR,
+  actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
+  actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_SOURCE_INFO_ORPHANED,
+  eventType: EVENT_TYPE.OPERATIONAL,
+  attributes: {
+    ...(resourceId && {
+      resourceId
+    }),
+    ...(sourceProduct && {
+      sourceProduct
+    }),
+    ...((context === null || context === void 0 ? void 0 : context.hasPendingDeletion) !== undefined && {
+      hasPendingDeletion: context.hasPendingDeletion
+    }),
+    ...((context === null || context === void 0 ? void 0 : context.hasSubscribers) !== undefined && {
+      hasSubscribers: context.hasSubscribers
+    })
+  }
+});
+
+/**
+ * Payload for `SYNCED_BLOCK_CACHE_DELETION_FORCED`. Fired when the cache
+ * deletion timer has been rescheduled `MAX_RESCHEDULE_COUNT` times and we force
+ * the deletion to avoid leaking memory. Indicates a stuck in-flight flag.
+ */
+export const cacheDeletionForcedPayload = (rescheduleCount, resourceId, sourceProduct) => ({
+  action: ACTION.ERROR,
+  actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
+  actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_CACHE_DELETION_FORCED,
+  eventType: EVENT_TYPE.OPERATIONAL,
+  attributes: {
+    rescheduleCount,
+    ...(resourceId && {
+      resourceId
+    }),
+    ...(sourceProduct && {
+      sourceProduct
+    })
+  }
+});
 export const fetchReferencesErrorPayload = (error, resourceId, sourceProduct) => getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH_REFERENCES, error, resourceId, sourceProduct);
 
 // Success payloads