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

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

@@ -13,7 +13,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';
@@ -25,6 +25,13 @@ var CACHE_KEY_PREFIX = 'sync-block-data-';
 var ENTITY_NOT_FOUND_MAX_RETRIES = 3;
 var 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.
+var CACHE_DELETION_GRACE_PERIOD_MS = 30000;
+// Max reschedules before force-deleting with an analytics event (~5 min).
+var 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.
@@ -48,6 +55,13 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
     // 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();
@@ -77,6 +91,14 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       },
       markCacheDirty: function 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: function scheduleCacheDeletion(rid) {
+        return _this.scheduleCacheDeletion(rid);
+      },
+      cancelPendingCacheDeletion: function cancelPendingCacheDeletion(rid) {
+        return _this.cancelPendingCacheDeletion(rid);
       }
     });
     this._providerFactoryManager = new SyncBlockProviderFactoryManager({
@@ -630,6 +652,19 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
     key: "updateCacheWithSourceInfo",
     value: function updateCacheWithSourceInfo(resourceId, sourceInfo) {
       var 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$fireAnalyticsEv5;
+        (_this$fireAnalyticsEv5 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv5 === void 0 || _this$fireAnalyticsEv5.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 = _objectSpread(_objectSpread({}, existingSyncBlock.data), {}, {
@@ -670,6 +705,136 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       var _this$dataProvider5;
       (_this$dataProvider5 = this.dataProvider) === null || _this$dataProvider5 === 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`).
+     */
+  }, {
+    key: "canDeleteCache",
+    value: function 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.
+     */
+  }, {
+    key: "scheduleCacheDeletion",
+    value: function scheduleCacheDeletion(resourceId) {
+      var _this6 = this;
+      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.
+      var existing = this.pendingCacheDeletions.get(resourceId);
+      if (existing) {
+        clearTimeout(existing);
+        this.pendingCacheDeletions.delete(resourceId);
+      }
+      var timer = setTimeout(function () {
+        // Guard against timer callback running after destroy. clearTimeout
+        // is synchronous so this should be unreachable in practice, but
+        // belt-and-braces.
+        if (_this6.isDestroyed) {
+          return;
+        }
+        _this6.pendingCacheDeletions.delete(resourceId);
+        _this6.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.
+     */
+  }, {
+    key: "cancelPendingCacheDeletion",
+    value: function cancelPendingCacheDeletion(resourceId) {
+      if (!fg('platform_synced_block_patch_14')) {
+        return;
+      }
+      var 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`. */
+  }, {
+    key: "hasPendingCacheDeletion",
+    value: function hasPendingCacheDeletion(resourceId) {
+      return this.pendingCacheDeletions.has(resourceId);
+    }
+  }, {
+    key: "onCacheDeletionTimerFire",
+    value: function onCacheDeletionTimerFire(resourceId) {
+      var _this$cacheDeletionRe;
+      if (this.canDeleteCache(resourceId)) {
+        // `deleteFromCache` resets the reschedule counter under the flag.
+        this.deleteFromCache(resourceId);
+        return;
+      }
+      var currentCount = (_this$cacheDeletionRe = this.cacheDeletionRescheduleCounts.get(resourceId)) !== null && _this$cacheDeletionRe !== void 0 ? _this$cacheDeletionRe : 0;
+      if (currentCount >= CACHE_DELETION_MAX_RESCHEDULES) {
+        var _this$fireAnalyticsEv6;
+        // 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$fireAnalyticsEv6 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv6 === void 0 || _this$fireAnalyticsEv6.call(this, cacheDeletionForcedPayload(currentCount, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+        logException(new Error("Cache deletion forced after ".concat(currentCount, " reschedules \u2014 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);
     }
 
     /**
@@ -682,7 +847,7 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
     key: "scheduleEntityNotFoundRetry",
     value: function scheduleEntityNotFoundRetry(resourceId) {
       var _this$entityNotFoundR,
-        _this6 = this;
+        _this7 = this;
       var currentRetries = (_this$entityNotFoundR = this.entityNotFoundRetryCount.get(resourceId)) !== null && _this$entityNotFoundR !== void 0 ? _this$entityNotFoundR : 0;
       if (currentRetries >= ENTITY_NOT_FOUND_MAX_RETRIES) {
         // Max retries exceeded — keep count at max so future calls immediately exit
@@ -700,26 +865,26 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       var delay = ENTITY_NOT_FOUND_INITIAL_DELAY_MS * Math.pow(2, currentRetries);
       var timer = setTimeout(function () {
         var _cached$error;
-        _this6.entityNotFoundRetryTimers.delete(resourceId);
+        _this7.entityNotFoundRetryTimers.delete(resourceId);
 
         // If no active subscriptions remain for this block, clean up and skip
-        var subscriptions = _this6._subscriptionManager.getSubscriptions().get(resourceId);
+        var subscriptions = _this7._subscriptionManager.getSubscriptions().get(resourceId);
         if (!subscriptions || Object.keys(subscriptions).length === 0) {
-          _this6.entityNotFoundRetryCount.delete(resourceId);
+          _this7.entityNotFoundRetryCount.delete(resourceId);
           return;
         }
 
         // Increment count only when the timer fires, not when scheduled
-        _this6.entityNotFoundRetryCount.set(resourceId, currentRetries + 1);
+        _this7.entityNotFoundRetryCount.set(resourceId, currentRetries + 1);
 
         // Clear the error from cache so fetchSyncBlocksData doesn't skip it
-        var cached = _this6.getFromCache(resourceId);
+        var cached = _this7.getFromCache(resourceId);
         if ((cached === null || cached === void 0 || (_cached$error = cached.error) === null || _cached$error === void 0 ? void 0 : _cached$error.type) === SyncBlockError.EntityNotFound) {
-          _this6.deleteFromCache(resourceId);
+          _this7.deleteFromCache(resourceId);
         }
 
         // Trigger a re-fetch via the batch fetcher
-        _this6.debouncedBatchedFetchSyncBlocks(resourceId);
+        _this7.debouncedBatchedFetchSyncBlocks(resourceId);
       }, delay);
       this.entityNotFoundRetryTimers.set(resourceId, timer);
     }
@@ -731,12 +896,12 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
   }, {
     key: "setSSRDataInSessionCache",
     value: function setSSRDataInSessionCache(resourceIds) {
-      var _this7 = this;
+      var _this8 = this;
       if (!resourceIds || resourceIds.length === 0) {
         return;
       }
       resourceIds.forEach(function (resourceId) {
-        _this7.updateSessionCache(resourceId);
+        _this8.updateSessionCache(resourceId);
       });
     }
   }, {
@@ -765,11 +930,11 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
         }
         return this._subscriptionManager.subscribeToSyncBlock(resourceId, localId, callback);
       } catch (error) {
-        var _this$fireAnalyticsEv5;
+        var _this$fireAnalyticsEv7;
         logException(error, {
           location: 'editor-synced-block-provider/referenceSyncBlockStoreManager'
         });
-        (_this$fireAnalyticsEv5 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv5 === void 0 || _this$fireAnalyticsEv5.call(this, fetchErrorPayload(error.message));
+        (_this$fireAnalyticsEv7 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv7 === void 0 || _this$fireAnalyticsEv7.call(this, fetchErrorPayload(error.message));
         return function () {};
       }
     }
@@ -782,12 +947,8 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
   }, {
     key: "getSyncBlockURL",
     value: function getSyncBlockURL(resourceId) {
-      var _syncBlock$data2;
-      var 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;
+      return (_this$getFromCache = this.getFromCache(resourceId)) === null || _this$getFromCache === void 0 || (_this$getFromCache = _this$getFromCache.data) === null || _this$getFromCache === void 0 ? void 0 : _this$getFromCache.sourceURL;
     }
   }, {
     key: "getProviderFactory",
@@ -809,8 +970,8 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
     key: "flush",
     value: (function () {
       var _flush = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-        var _this8 = this;
-        var success, syncedBlocksToFlush, _this$saveExperience, blocks, _iterator, _step, _loop, updateResult, _this$saveExperience2, _this$fireAnalyticsEv6, _this$saveExperience3, _this$fireAnalyticsEv7, _this$saveExperience4, _t2, _t3;
+        var _this9 = this;
+        var success, syncedBlocksToFlush, _this$saveExperience, blocks, _iterator, _step, _loop, updateResult, _this$saveExperience2, _this$fireAnalyticsEv8, _this$saveExperience3, _this$fireAnalyticsEv9, _this$saveExperience4, _t2, _t3;
         return _regeneratorRuntime.wrap(function (_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
@@ -916,7 +1077,7 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
                 (_this$saveExperience2 = this.saveExperience) === null || _this$saveExperience2 === void 0 || _this$saveExperience2.failure({
                   reason: updateResult.error || 'Failed to update reference synced blocks on the document'
                 });
-                (_this$fireAnalyticsEv6 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv6 === void 0 || _this$fireAnalyticsEv6.call(this, updateReferenceErrorPayload(updateResult.error || 'Failed to update reference synced blocks on the document'));
+                (_this$fireAnalyticsEv8 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv8 === void 0 || _this$fireAnalyticsEv8.call(this, updateReferenceErrorPayload(updateResult.error || 'Failed to update reference synced blocks on the document'));
               }
               _context4.next = 17;
               break;
@@ -931,7 +1092,7 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
                 reason: _t3.message
               });
               // No `resourceId` available in this catch — sourceProduct is intentionally omitted.
-              (_this$fireAnalyticsEv7 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv7 === void 0 || _this$fireAnalyticsEv7.call(this, updateReferenceErrorPayload(_t3.message));
+              (_this$fireAnalyticsEv9 = this.fireAnalyticsEvent) === null || _this$fireAnalyticsEv9 === void 0 || _this$fireAnalyticsEv9.call(this, updateReferenceErrorPayload(_t3.message));
             case 17:
               _context4.prev = 17;
               if (!success) {
@@ -951,8 +1112,8 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
                 // Use setTimeout to avoid deep recursion and run queued flush asynchronously
                 // Note: flush() handles all exceptions internally and never rejects
                 this.queuedFlushTimeout = setTimeout(function () {
-                  _this8.queuedFlushTimeout = undefined;
-                  void _this8.flush();
+                  _this9.queuedFlushTimeout = undefined;
+                  void _this9.flush();
                 }, 0);
               }
               return _context4.finish(17);
@@ -973,6 +1134,9 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
     key: "destroy",
     value: function destroy() {
       var _this$dataProvider6, _this$saveExperience5, _this$fetchExperience0, _this$fetchSourceInfo2;
+      // 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);
@@ -985,6 +1149,13 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       });
       this.entityNotFoundRetryTimers.clear();
       this.entityNotFoundRetryCount.clear();
+
+      // Cancel pending cache deletion timers.
+      this.pendingCacheDeletions.forEach(function (timer) {
+        return clearTimeout(timer);
+      });
+      this.pendingCacheDeletions.clear();
+      this.cacheDeletionRescheduleCounts.clear();
       this._subscriptionManager.destroy();
       this._providerFactoryManager.destroy();
       this._batchFetcher.destroy();
@@ -1002,7 +1173,18 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
         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/esm/store-manager/syncBlockBatchFetcher.js

@@ -15,6 +15,11 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
     var _this = this;
     _classCallCheck(this, SyncBlockBatchFetcher);
     _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(function () {
       if (_this.pendingFetchRequests.size === 0) {
@@ -27,6 +32,11 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
         return createSyncBlockNode(firstLocalId, resId);
       });
       _this.pendingFetchRequests.clear();
+
+      // Track in-flight before the fetch so guards remain positive.
+      resourceIds.forEach(function (resId) {
+        return _this.inFlightFetches.add(resId);
+      });
       _this.deps.fetchSyncBlocksData(syncBlockNodes).catch(function (error) {
         logException(error, {
           location: 'editor-synced-block-provider/syncBlockBatchFetcher/batchedFetchSyncBlocks'
@@ -35,6 +45,17 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
           var _this$deps$getFireAna;
           (_this$deps$getFireAna = _this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(error.message, resId, getSourceProductFromResourceIdSafe(resId)));
         });
+      }).finally(function () {
+        // 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(function (resId) {
+          return _this.inFlightFetches.delete(resId);
+        });
       });
     });
   }
@@ -49,6 +70,17 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
         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.
+     */
+  }, {
+    key: "hasPendingFetch",
+    value: function hasPendingFetch(resourceId) {
+      return this.pendingFetchRequests.has(resourceId) || this.inFlightFetches.has(resourceId);
+    }
   }, {
     key: "cancel",
     value: function cancel() {
@@ -62,8 +94,11 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
   }, {
     key: "destroy",
     value: function destroy() {
+      this.isDestroyed = true;
       this.cancel();
       this.clearPending();
+      // Clear in-flight tracking to prevent stale entries after teardown.
+      this.inFlightFetches.clear();
     }
   }]);
 }();

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

@@ -5,8 +5,9 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-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';
@@ -20,6 +21,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 var SyncBlockStoreManager = /*#__PURE__*/function () {
   function SyncBlockStoreManager(dataProvider, viewMode, isLivePage) {
     _classCallCheck(this, SyncBlockStoreManager);
@@ -300,5 +302,23 @@ export var useMemoizedSyncBlockStoreManager = function useMemoizedSyncBlockStore
     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(function () {
+    return function () {
+      if (fg('platform_synced_block_patch_14')) {
+        syncBlockStoreManager.destroy();
+      }
+    };
+  }, [syncBlockStoreManager]);
   return syncBlockStoreManager;
 };

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

@@ -7,6 +7,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 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';
@@ -16,6 +17,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 var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
   function SyncBlockSubscriptionManager(deps) {
     _classCallCheck(this, SyncBlockSubscriptionManager);
@@ -112,8 +114,13 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
       // 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.
       var 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);
       }
@@ -147,7 +154,8 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
           // Unsubscription means a reference synced block is removed from the document
           _this3.deps.markCacheDirty();
           delete resourceSubscriptions[localId];
-          if (Object.keys(resourceSubscriptions).length === 0) {
+          var remainingIds = Object.keys(resourceSubscriptions);
+          if (remainingIds.length === 0) {
             _this3.subscriptions.delete(resourceId);
 
             // Clean up GraphQL subscription when no more local subscribers
@@ -156,19 +164,30 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
             // Notify listeners that subscription was removed
             _this3.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
-            var deletionTimeout = setTimeout(function () {
-              // Only delete if still no subscribers (wasn't re-subscribed)
-              if (!_this3.subscriptions.has(resourceId)) {
-                _this3.deps.deleteFromCache(resourceId);
-              }
-              _this3.pendingCacheDeletions.delete(resourceId);
-            }, 1000);
-            _this3.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')) {
+              _this3.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`).
+              var deletionTimeout = setTimeout(function () {
+                var hasSubscribers = _this3.subscriptions.has(resourceId);
+
+                // Only delete if still no subscribers (wasn't re-subscribed)
+                if (!hasSubscribers) {
+                  _this3.deps.deleteFromCache(resourceId);
+                }
+                _this3.pendingCacheDeletions.delete(resourceId);
+              }, 1000);
+              _this3.pendingCacheDeletions.set(resourceId, deletionTimeout);
+            }
           } else {
             _this3.subscriptions.set(resourceId, resourceSubscriptions);
           }

package/dist/esm/utils/errorHandling.js

@@ -52,6 +52,49 @@ export var deleteErrorPayload = function deleteErrorPayload(error, resourceId, s
 export var updateCacheErrorPayload = function updateCacheErrorPayload(error, resourceId, sourceProduct) {
   return 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 var sourceInfoOrphanedPayload = function sourceInfoOrphanedPayload(resourceId, sourceProduct, context) {
+  return {
+    action: ACTION.ERROR,
+    actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
+    actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_SOURCE_INFO_ORPHANED,
+    eventType: EVENT_TYPE.OPERATIONAL,
+    attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, resourceId && {
+      resourceId: resourceId
+    }), sourceProduct && {
+      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 var cacheDeletionForcedPayload = function cacheDeletionForcedPayload(rescheduleCount, resourceId, sourceProduct) {
+  return {
+    action: ACTION.ERROR,
+    actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
+    actionSubjectId: ACTION_SUBJECT_ID.SYNCED_BLOCK_CACHE_DELETION_FORCED,
+    eventType: EVENT_TYPE.OPERATIONAL,
+    attributes: _objectSpread(_objectSpread({
+      rescheduleCount: rescheduleCount
+    }, resourceId && {
+      resourceId: resourceId
+    }), sourceProduct && {
+      sourceProduct: sourceProduct
+    })
+  };
+};
 export var fetchReferencesErrorPayload = function fetchReferencesErrorPayload(error, resourceId, sourceProduct) {
   return getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH_REFERENCES, error, resourceId, sourceProduct);
 };