@atlaskit/editor-synced-block-provider 8.1.9 → 8.2.0

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

@@ -2,7 +2,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 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 { isProviderNotReadyError, ProviderNotReadyError, SyncBlockError } from '../common/types';
 import { buildErrorAttribution, cacheDeletionForcedPayload, fetchErrorPayload, fetchSuccessPayload, getSourceInfoErrorPayload, sourceInfoOrphanedPayload, updateReferenceErrorPayload } from '../utils/errorHandling';
 import { getFetchExperience, getFetchSourceInfoExperience, getSaveReferenceExperience } from '../utils/experienceTracking';
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
@@ -79,7 +79,9 @@ export class ReferenceSyncBlockStoreManager {
     this._batchFetcher = new SyncBlockBatchFetcher({
       getSubscriptions: () => this._subscriptionManager.getSubscriptions(),
       fetchSyncBlocksData: nodes => this.fetchSyncBlocksData(nodes),
-      getFireAnalyticsEvent: () => this.fireAnalyticsEvent
+      getFireAnalyticsEvent: () => this.fireAnalyticsEvent,
+      // EDITOR-7860: skip + re-queue fetches while not ready / torn down.
+      isProviderReady: () => this.hasDataProvider()
     });
 
     // The provider might have SSR data cache already set, so we need to update the cache in session memory storage
@@ -89,6 +91,17 @@ export class ReferenceSyncBlockStoreManager {
     return node.type.name === 'syncBlock';
   }
 
+  /**
+   * Whether the async data provider is wired and the manager is not torn down.
+   * Consumers gate fetch/subscribe on this to avoid a false `Data provider not
+   * set` fetch error (EDITOR-7860). The `isDestroyed` check covers managers
+   * orphaned mid-flight during an async provider swap, where `dataProvider`
+   * alone is insufficient.
+   */
+  hasDataProvider() {
+    return !this.isDestroyed && !!this.dataProvider;
+  }
+
   /**
    * Enables or disables real-time GraphQL subscriptions for block updates.
    * When enabled, the store manager will subscribe to real-time updates
@@ -412,6 +425,11 @@ export class ReferenceSyncBlockStoreManager {
       return;
     }
     if (!this.dataProvider) {
+      // EDITOR-7860: tag the throw so catch sites can suppress the benign
+      // not-ready/torn-down case. Gate-off keeps the legacy throw + message.
+      if (fg('platform_editor_blocks_patch_3')) {
+        throw new ProviderNotReadyError();
+      }
       throw new Error('Data provider not set');
     }
     nodesToFetch.forEach(node => {
@@ -779,6 +797,12 @@ export class ReferenceSyncBlockStoreManager {
       return this._subscriptionManager.subscribeToSyncBlock(resourceId, localId, callback);
     } catch (error) {
       var _this$fireAnalyticsEv11;
+      // EDITOR-7860: benign not-ready/torn-down case — suppress both the
+      // exception-tracker log and the analytics event (checked first so the
+      // benign case stays fully silent). Gate-off behaviour is unchanged.
+      if (isProviderNotReadyError(error) && fg('platform_editor_blocks_patch_3')) {
+        return () => {};
+      }
       logException(error, {
         location: 'editor-synced-block-provider/referenceSyncBlockStoreManager'
       });

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

@@ -1,6 +1,8 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import rafSchedule from 'raf-schd';
 import { logException } from '@atlaskit/editor-common/monitoring';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { isProviderNotReadyError } from '../common/types';
 import { fetchErrorPayload } from '../utils/errorHandling';
 import { createSyncBlockNode, getSourceProductFromResourceIdSafe } from '../utils/utils';
 /**
@@ -21,6 +23,17 @@ export class SyncBlockBatchFetcher {
       if (this.pendingFetchRequests.size === 0) {
         return;
       }
+
+      // EDITOR-7860: not ready — skip and leave resourceIds queued for the
+      // next batch once the provider resolves. Gate-off is unchanged (the
+      // readiness check is nested under the gate so it is not consulted when
+      // the gate is off, and `fg()` stays a standalone condition so gate
+      // exposure is still tracked — satisfies @atlaskit/platform/no-preconditioning).
+      if (fg('platform_editor_blocks_patch_3')) {
+        if (this.deps.isProviderReady && !this.deps.isProviderReady()) {
+          return;
+        }
+      }
       const resourceIds = Array.from(this.pendingFetchRequests);
       const syncBlockNodes = resourceIds.map(resId => {
         const subscriptions = this.deps.getSubscriptions().get(resId) || {};
@@ -32,6 +45,18 @@ export class SyncBlockBatchFetcher {
       // Track in-flight before the fetch so guards remain positive.
       resourceIds.forEach(resId => this.inFlightFetches.add(resId));
       this.deps.fetchSyncBlocksData(syncBlockNodes).catch(error => {
+        // EDITOR-7860: benign not-ready throw — re-queue for retry and emit
+        // nothing (no analytics, no exception-tracker noise). Checked before
+        // `logException` so the benign case stays silent. Re-schedule so the
+        // re-queued IDs are retried on the next frame even if no further
+        // `queueFetch()` arrives. Gate-off behaviour is unchanged.
+        if (isProviderNotReadyError(error) && fg('platform_editor_blocks_patch_3')) {
+          resourceIds.forEach(resId => this.pendingFetchRequests.add(resId));
+          if (!this.isDestroyed) {
+            this.scheduledBatchFetch();
+          }
+          return;
+        }
         logException(error, {
           location: 'editor-synced-block-provider/syncBlockBatchFetcher/batchedFetchSyncBlocks'
         });

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

@@ -12,6 +12,25 @@ import { getSourceProductFromResourceIdSafe } from '../utils/utils';
  */
 
 export class SyncBlockSubscriptionManager {
+  // EDITOR-7861: higher ceiling lets transient WS-gateway drops self-heal
+  // before a terminal failure is surfaced.
+  getMaxRetryAttempts() {
+    return fg('platform_editor_blocks_patch_3') ? SyncBlockSubscriptionManager.MAX_RETRY_ATTEMPTS_HARDENED : SyncBlockSubscriptionManager.MAX_RETRY_ATTEMPTS;
+  }
+
+  // Backoff delay for the given attempt.
+  // Gate OFF: pure exponential (1s, 2s, 4s, 8s, 16s).
+  // Gate ON (EDITOR-7861): exponential capped at MAX_RETRY_DELAY_MS with equal
+  // jitter (capped/2 + random*capped/2) — de-synchronises simultaneous
+  // reconnects while guaranteeing a non-zero delay (full jitter could hit 0).
+  getReconnectionDelay(attempts) {
+    const exponential = SyncBlockSubscriptionManager.INITIAL_RETRY_DELAY_MS * Math.pow(SyncBlockSubscriptionManager.RETRY_BACKOFF_MULTIPLIER, attempts);
+    if (!fg('platform_editor_blocks_patch_3')) {
+      return exponential;
+    }
+    const half = Math.min(exponential, SyncBlockSubscriptionManager.MAX_RETRY_DELAY_MS) / 2;
+    return Math.round(half + Math.random() * half);
+  }
   constructor(deps) {
     _defineProperty(this, "subscriptions", new Map());
     _defineProperty(this, "titleSubscriptions", new Map());
@@ -23,6 +42,7 @@ export class SyncBlockSubscriptionManager {
     // causing the cache to be deleted prematurely. We delay deletion to allow
     // the new component to subscribe and cancel the pending deletion.
     _defineProperty(this, "pendingCacheDeletions", new Map());
+    // backoff cap (gate ON)
     _defineProperty(this, "retryAttempts", new Map());
     _defineProperty(this, "pendingRetries", new Map());
     this.deps = deps;
@@ -237,11 +257,17 @@ export class SyncBlockSubscriptionManager {
     const unsubscribe = dataProvider.subscribeToBlockUpdates(resourceId, syncBlockInstance => {
       this.handleGraphQLUpdate(syncBlockInstance);
     }, error => {
-      var _this$deps$getFireAna2;
       logException(error, {
         location: 'editor-synced-block-provider/syncBlockSubscriptionManager/graphql-subscription'
       });
-      (_this$deps$getFireAna2 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna2 === void 0 ? void 0 : _this$deps$getFireAna2(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+      // EDITOR-7861: a single socket drop is usually transient and
+      // recovers on reconnect, so under the gate we don't fire a
+      // user-facing error here — it's only surfaced on exhaustion (see
+      // scheduleReconnection). Gate OFF keeps the legacy fire-on-drop.
+      if (!fg('platform_editor_blocks_patch_3')) {
+        var _this$deps$getFireAna2;
+        (_this$deps$getFireAna2 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna2 === void 0 ? void 0 : _this$deps$getFireAna2(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+      }
       this.handleSubscriptionTerminated(resourceId);
     }, () => {
       this.handleSubscriptionTerminated(resourceId);
@@ -270,16 +296,16 @@ export class SyncBlockSubscriptionManager {
     }
   }
 
-  /**
-   * Schedules a reconnection attempt with exponential backoff.
-   * Delay = INITIAL_RETRY_DELAY_MS * (RETRY_BACKOFF_MULTIPLIER ^ attempts)
-   * e.g. 1s, 2s, 4s, 8s, 16s
-   */
+  // Schedules a reconnection with backoff (see getMaxRetryAttempts /
+  // getReconnectionDelay for the gated behaviour).
   scheduleReconnection(resourceId) {
     var _this$retryAttempts$g;
     const attempts = (_this$retryAttempts$g = this.retryAttempts.get(resourceId)) !== null && _this$retryAttempts$g !== void 0 ? _this$retryAttempts$g : 0;
-    if (attempts >= SyncBlockSubscriptionManager.MAX_RETRY_ATTEMPTS) {
+    const maxAttempts = this.getMaxRetryAttempts();
+    if (attempts >= maxAttempts) {
       var _this$deps$getFireAna3;
+      // Exhausted all attempts — the only place a WS drop surfaces as a
+      // fetch error under the gate (EDITOR-7861).
       const errorMessage = `Subscription reconnection failed after ${attempts} attempts`;
       logException(new Error(errorMessage), {
         location: 'editor-synced-block-provider/syncBlockSubscriptionManager/max-retries-exhausted'
@@ -287,7 +313,7 @@ export class SyncBlockSubscriptionManager {
       (_this$deps$getFireAna3 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna3 === void 0 ? void 0 : _this$deps$getFireAna3(fetchErrorPayload(errorMessage, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
       return;
     }
-    const delay = SyncBlockSubscriptionManager.INITIAL_RETRY_DELAY_MS * Math.pow(SyncBlockSubscriptionManager.RETRY_BACKOFF_MULTIPLIER, attempts);
+    const delay = this.getReconnectionDelay(attempts);
     const timer = setTimeout(() => {
       this.pendingRetries.delete(resourceId);
 
@@ -389,7 +415,11 @@ export class SyncBlockSubscriptionManager {
     }
   }
 }
-// Reconnection with exponential backoff
+// Reconnection with exponential backoff.
 _defineProperty(SyncBlockSubscriptionManager, "INITIAL_RETRY_DELAY_MS", 1000);
 _defineProperty(SyncBlockSubscriptionManager, "RETRY_BACKOFF_MULTIPLIER", 2);
-_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS", 5);
+_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS", 5);
+// legacy (gate OFF)
+_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS_HARDENED", 8);
+// gate ON (EDITOR-7861)
+_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_DELAY_MS", 30000);

package/dist/esm/common/types.js

@@ -1,3 +1,13 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 export var SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
   SyncBlockError["Errored"] = "errored";
   SyncBlockError["NotFound"] = "not_found";
@@ -16,4 +26,55 @@ export var SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
   // block does not exist on this site (e.g. cross-site reference or hard deleted)
   SyncBlockError["EntityNotFound"] = "entity_not_found";
   return SyncBlockError;
-}({});
+}({});
+/**
+ * Helpers to distinguish "data provider not ready / torn down" from a genuine
+ * fetch/subscribe failure (EDITOR-7860). On Jira the provider is wired
+ * asynchronously and `destroy()` nulls it on orphaned managers, so queued/
+ * in-flight ops throw `Data provider not set` — previously mis-logged as a real
+ * error. These let throw and catch sites agree on one non-string-matched signal
+ * so the residual false errors are suppressed. Gated by
+ * `platform_editor_blocks_patch_3`.
+ *
+ * NB: these intentionally live here rather than in a dedicated module to avoid
+ * adding a downstream file to consuming Jira packages' Thunderstone complexity.
+ */
+
+/** Legacy message — kept identical for gate-off and historical events. */
+export var PROVIDER_NOT_READY_MESSAGE = 'Data provider not set';
+
+/**
+ * Thrown when a fetch/subscribe runs against a manager whose provider is not
+ * (yet) available or torn down. Keeps the legacy message + name so string
+ * matchers still work, while new code uses {@link isProviderNotReadyError}.
+ */
+export var ProviderNotReadyError = /*#__PURE__*/function (_Error) {
+  function ProviderNotReadyError() {
+    var _this;
+    var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : PROVIDER_NOT_READY_MESSAGE;
+    _classCallCheck(this, ProviderNotReadyError);
+    _this = _callSuper(this, ProviderNotReadyError, [message]);
+    _defineProperty(_this, "isProviderNotReadyError", true);
+    _this.name = 'ProviderNotReadyError';
+    // Restore prototype chain so instanceof works after transpilation.
+    Object.setPrototypeOf(_this, ProviderNotReadyError.prototype);
+    return _this;
+  }
+  _inherits(ProviderNotReadyError, _Error);
+  return _createClass(ProviderNotReadyError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+/**
+ * True when the value is a "provider not ready / torn down" condition, not a
+ * genuine failure. Recognises the tagged {@link ProviderNotReadyError} and the
+ * legacy message (for errors thrown before rollout).
+ */
+export var isProviderNotReadyError = function isProviderNotReadyError(error) {
+  if (error instanceof ProviderNotReadyError) {
+    return true;
+  }
+  if (_typeof(error) === 'object' && error !== null && error.isProviderNotReadyError === true) {
+    return true;
+  }
+  return error instanceof Error && error.message === PROVIDER_NOT_READY_MESSAGE;
+};

package/dist/esm/hooks/useFetchSyncBlockData.js

@@ -7,10 +7,12 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { isSSR } from '@atlaskit/editor-common/core-utils';
 import { logException } from '@atlaskit/editor-common/monitoring';
-import { SyncBlockError } from '../common/types';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { isProviderNotReadyError, SyncBlockError } from '../common/types';
 import { fetchErrorPayload } from '../utils/errorHandling';
 import { createSyncBlockNode, getSourceProductFromResourceIdSafe } from '../utils/utils';
 export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resourceId, localId, fireAnalyticsEvent) {
+  var _manager$referenceMan2, _manager$referenceMan3, _manager$referenceMan4;
   // Initialize both states from a single cache lookup to avoid race conditions.
   // When a block is moved/remounted, the old component's cleanup may clear the cache
   // before or after the new component mounts. By doing a single lookup, we ensure
@@ -34,6 +36,14 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
     syncBlockInstance = _useState2$.syncBlockInstance,
     isLoading = _useState2$.isLoading,
     setFetchState = _useState2[1];
+
+  // On Jira the data provider is wired asynchronously, so the manager can be
+  // constructed with `dataProvider === undefined`. Fetching/subscribing in that
+  // window throws `Data provider not set`, logged as a false fetch error
+  // (EDITOR-7860). Gate on readiness; once the provider resolves a new manager
+  // instance is created so `referenceManager` changes identity and the effect
+  // below re-runs, subscribing exactly once.
+  var isDataProviderReady = fg('platform_editor_blocks_patch_3') ? (_manager$referenceMan2 = (_manager$referenceMan3 = (_manager$referenceMan4 = manager.referenceManager).hasDataProvider) === null || _manager$referenceMan3 === void 0 ? void 0 : _manager$referenceMan3.call(_manager$referenceMan4)) !== null && _manager$referenceMan2 !== void 0 ? _manager$referenceMan2 : false : true;
   var reloadData = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
     var syncBlockNode, _t;
     return _regeneratorRuntime.wrap(function (_context) {
@@ -45,14 +55,20 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
           }
           return _context.abrupt("return");
         case 1:
-          _context.prev = 1;
+          if (isDataProviderReady) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return");
+        case 2:
+          _context.prev = 2;
           syncBlockNode = resourceId && localId ? createSyncBlockNode(localId, resourceId) : null;
           if (syncBlockNode) {
-            _context.next = 2;
+            _context.next = 3;
             break;
           }
           throw new Error('Failed to create sync block node from resourceid and localid');
-        case 2:
+        case 3:
           setFetchState(function (prev) {
             return _objectSpread(_objectSpread({}, prev), {}, {
               isLoading: true
@@ -60,14 +76,25 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
           });
 
           // Fetch sync block data, the `subscribeToSyncBlock` will update the state once data is fetched
-          _context.next = 3;
+          _context.next = 4;
           return manager.referenceManager.fetchSyncBlocksData([syncBlockNode]);
-        case 3:
-          _context.next = 5;
-          break;
         case 4:
-          _context.prev = 4;
-          _t = _context["catch"](1);
+          _context.next = 7;
+          break;
+        case 5:
+          _context.prev = 5;
+          _t = _context["catch"](2);
+          if (!(isProviderNotReadyError(_t) && fg('platform_editor_blocks_patch_3'))) {
+            _context.next = 6;
+            break;
+          }
+          setFetchState(function (prev) {
+            return _objectSpread(_objectSpread({}, prev), {}, {
+              isLoading: true
+            });
+          });
+          return _context.abrupt("return");
+        case 6:
           logException(_t, {
             location: 'editor-synced-block-provider/useFetchSyncBlockData'
           });
@@ -84,24 +111,31 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
             isLoading: false
           });
           return _context.abrupt("return");
-        case 5:
+        case 7:
           setFetchState(function (prev) {
             return _objectSpread(_objectSpread({}, prev), {}, {
               isLoading: false
             });
           });
-        case 6:
+        case 8:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[1, 4]]);
-  })), [isLoading, localId, manager.referenceManager, resourceId, fireAnalyticsEvent]);
+    }, _callee, null, [[2, 5]]);
+  })), [isLoading, isDataProviderReady, localId, manager.referenceManager, resourceId, fireAnalyticsEvent]);
   useEffect(function () {
     if (isSSR()) {
       // in SSR, we don't need to subscribe to updates,
       // instead we rely on pre-fetched data ONLY, see initialization of syncBlockInstance above
       return;
     }
+
+    // Not ready: skip subscribe (it would trigger a batched fetch and a false
+    // error) and keep `isLoading: true`. `isDataProviderReady` is in the deps,
+    // so the effect re-runs and subscribes once the provider resolves.
+    if (!isDataProviderReady) {
+      return;
+    }
     var unsubscribe = manager.referenceManager.subscribeToSyncBlock(resourceId || '', localId || '', function (data) {
       setFetchState({
         syncBlockInstance: data,
@@ -111,7 +145,7 @@ export var useFetchSyncBlockData = function useFetchSyncBlockData(manager, resou
     return function () {
       unsubscribe();
     };
-  }, [localId, manager.referenceManager, resourceId]);
+  }, [isDataProviderReady, localId, manager.referenceManager, resourceId]);
   var ssrProviders = useMemo(function () {
     return resourceId ? manager.referenceManager.getSSRProviders(resourceId) : null;
   }, [resourceId, manager.referenceManager]);

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

@@ -12,7 +12,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 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 { isProviderNotReadyError, ProviderNotReadyError, SyncBlockError } from '../common/types';
 import { buildErrorAttribution, cacheDeletionForcedPayload, fetchErrorPayload, fetchSuccessPayload, getSourceInfoErrorPayload, sourceInfoOrphanedPayload, updateReferenceErrorPayload } from '../utils/errorHandling';
 import { getFetchExperience, getFetchSourceInfoExperience, getSaveReferenceExperience } from '../utils/experienceTracking';
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
@@ -121,6 +121,10 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       },
       getFireAnalyticsEvent: function getFireAnalyticsEvent() {
         return _this.fireAnalyticsEvent;
+      },
+      // EDITOR-7860: skip + re-queue fetches while not ready / torn down.
+      isProviderReady: function isProviderReady() {
+        return _this.hasDataProvider();
       }
     });
 
@@ -133,6 +137,19 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
       return node.type.name === 'syncBlock';
     }
 
+    /**
+     * Whether the async data provider is wired and the manager is not torn down.
+     * Consumers gate fetch/subscribe on this to avoid a false `Data provider not
+     * set` fetch error (EDITOR-7860). The `isDestroyed` check covers managers
+     * orphaned mid-flight during an async provider swap, where `dataProvider`
+     * alone is insufficient.
+     */
+  }, {
+    key: "hasDataProvider",
+    value: function hasDataProvider() {
+      return !this.isDestroyed && !!this.dataProvider;
+    }
+
     /**
      * Enables or disables real-time GraphQL subscriptions for block updates.
      * When enabled, the store manager will subscribe to real-time updates
@@ -524,22 +541,28 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
               return _context2.abrupt("return");
             case 2:
               if (this.dataProvider) {
+                _context2.next = 4;
+                break;
+              }
+              if (!fg('platform_editor_blocks_patch_3')) {
                 _context2.next = 3;
                 break;
               }
-              throw new Error('Data provider not set');
+              throw new ProviderNotReadyError();
             case 3:
+              throw new Error('Data provider not set');
+            case 4:
               nodesToFetch.forEach(function (node) {
                 _this4.syncBlockFetchDataRequests.set(node.attrs.resourceId, true);
               });
               (_this$fetchExperience6 = this.fetchExperience) === null || _this$fetchExperience6 === void 0 || _this$fetchExperience6.start({});
-              _context2.next = 4;
+              _context2.next = 5;
               return this.dataProvider.fetchNodesData(nodesToFetch).finally(function () {
                 nodesToFetch.forEach(function (node) {
                   _this4.syncBlockFetchDataRequests.delete(node.attrs.resourceId);
                 });
               });
-            case 4:
+            case 5:
               data = _context2.sent;
               _this$processFetchedD2 = this.processFetchedData(data), hasUnexpectedError = _this$processFetchedD2.hasUnexpectedError, hasExpectedError = _this$processFetchedD2.hasExpectedError;
               if (hasUnexpectedError) {
@@ -553,7 +576,7 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
               } else {
                 (_this$fetchExperience9 = this.fetchExperience) === null || _this$fetchExperience9 === void 0 || _this$fetchExperience9.success();
               }
-            case 5:
+            case 6:
             case "end":
               return _context2.stop();
           }
@@ -931,6 +954,12 @@ export var ReferenceSyncBlockStoreManager = /*#__PURE__*/function () {
         return this._subscriptionManager.subscribeToSyncBlock(resourceId, localId, callback);
       } catch (error) {
         var _this$fireAnalyticsEv7;
+        // EDITOR-7860: benign not-ready/torn-down case — suppress both the
+        // exception-tracker log and the analytics event (checked first so the
+        // benign case stays fully silent). Gate-off behaviour is unchanged.
+        if (isProviderNotReadyError(error) && fg('platform_editor_blocks_patch_3')) {
+          return function () {};
+        }
         logException(error, {
           location: 'editor-synced-block-provider/referenceSyncBlockStoreManager'
         });

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

@@ -3,6 +3,8 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import rafSchedule from 'raf-schd';
 import { logException } from '@atlaskit/editor-common/monitoring';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { isProviderNotReadyError } from '../common/types';
 import { fetchErrorPayload } from '../utils/errorHandling';
 import { createSyncBlockNode, getSourceProductFromResourceIdSafe } from '../utils/utils';
 /**
@@ -25,6 +27,17 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
       if (_this.pendingFetchRequests.size === 0) {
         return;
       }
+
+      // EDITOR-7860: not ready — skip and leave resourceIds queued for the
+      // next batch once the provider resolves. Gate-off is unchanged (the
+      // readiness check is nested under the gate so it is not consulted when
+      // the gate is off, and `fg()` stays a standalone condition so gate
+      // exposure is still tracked — satisfies @atlaskit/platform/no-preconditioning).
+      if (fg('platform_editor_blocks_patch_3')) {
+        if (_this.deps.isProviderReady && !_this.deps.isProviderReady()) {
+          return;
+        }
+      }
       var resourceIds = Array.from(_this.pendingFetchRequests);
       var syncBlockNodes = resourceIds.map(function (resId) {
         var subscriptions = _this.deps.getSubscriptions().get(resId) || {};
@@ -38,6 +51,20 @@ export var SyncBlockBatchFetcher = /*#__PURE__*/function () {
         return _this.inFlightFetches.add(resId);
       });
       _this.deps.fetchSyncBlocksData(syncBlockNodes).catch(function (error) {
+        // EDITOR-7860: benign not-ready throw — re-queue for retry and emit
+        // nothing (no analytics, no exception-tracker noise). Checked before
+        // `logException` so the benign case stays silent. Re-schedule so the
+        // re-queued IDs are retried on the next frame even if no further
+        // `queueFetch()` arrives. Gate-off behaviour is unchanged.
+        if (isProviderNotReadyError(error) && fg('platform_editor_blocks_patch_3')) {
+          resourceIds.forEach(function (resId) {
+            return _this.pendingFetchRequests.add(resId);
+          });
+          if (!_this.isDestroyed) {
+            _this.scheduledBatchFetch();
+          }
+          return;
+        }
         logException(error, {
           location: 'editor-synced-block-provider/syncBlockBatchFetcher/batchedFetchSyncBlocks'
         });

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

@@ -31,6 +31,7 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
     // causing the cache to be deleted prematurely. We delay deletion to allow
     // the new component to subscribe and cancel the pending deletion.
     _defineProperty(this, "pendingCacheDeletions", new Map());
+    // backoff cap (gate ON)
     _defineProperty(this, "retryAttempts", new Map());
     _defineProperty(this, "pendingRetries", new Map());
     this.deps = deps;
@@ -41,6 +42,30 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
    * that need to read the current subscription state.
    */
   return _createClass(SyncBlockSubscriptionManager, [{
+    key: "getMaxRetryAttempts",
+    value:
+    // EDITOR-7861: higher ceiling lets transient WS-gateway drops self-heal
+    // before a terminal failure is surfaced.
+    function getMaxRetryAttempts() {
+      return fg('platform_editor_blocks_patch_3') ? SyncBlockSubscriptionManager.MAX_RETRY_ATTEMPTS_HARDENED : SyncBlockSubscriptionManager.MAX_RETRY_ATTEMPTS;
+    }
+
+    // Backoff delay for the given attempt.
+    // Gate OFF: pure exponential (1s, 2s, 4s, 8s, 16s).
+    // Gate ON (EDITOR-7861): exponential capped at MAX_RETRY_DELAY_MS with equal
+    // jitter (capped/2 + random*capped/2) — de-synchronises simultaneous
+    // reconnects while guaranteeing a non-zero delay (full jitter could hit 0).
+  }, {
+    key: "getReconnectionDelay",
+    value: function getReconnectionDelay(attempts) {
+      var exponential = SyncBlockSubscriptionManager.INITIAL_RETRY_DELAY_MS * Math.pow(SyncBlockSubscriptionManager.RETRY_BACKOFF_MULTIPLIER, attempts);
+      if (!fg('platform_editor_blocks_patch_3')) {
+        return exponential;
+      }
+      var half = Math.min(exponential, SyncBlockSubscriptionManager.MAX_RETRY_DELAY_MS) / 2;
+      return Math.round(half + Math.random() * half);
+    }
+  }, {
     key: "getSubscriptions",
     value: function getSubscriptions() {
       return this.subscriptions;
@@ -267,11 +292,17 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
       var unsubscribe = dataProvider.subscribeToBlockUpdates(resourceId, function (syncBlockInstance) {
         _this5.handleGraphQLUpdate(syncBlockInstance);
       }, function (error) {
-        var _this5$deps$getFireAn;
         logException(error, {
           location: 'editor-synced-block-provider/syncBlockSubscriptionManager/graphql-subscription'
         });
-        (_this5$deps$getFireAn = _this5.deps.getFireAnalyticsEvent()) === null || _this5$deps$getFireAn === void 0 || _this5$deps$getFireAn(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+        // EDITOR-7861: a single socket drop is usually transient and
+        // recovers on reconnect, so under the gate we don't fire a
+        // user-facing error here — it's only surfaced on exhaustion (see
+        // scheduleReconnection). Gate OFF keeps the legacy fire-on-drop.
+        if (!fg('platform_editor_blocks_patch_3')) {
+          var _this5$deps$getFireAn;
+          (_this5$deps$getFireAn = _this5.deps.getFireAnalyticsEvent()) === null || _this5$deps$getFireAn === void 0 || _this5$deps$getFireAn(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+        }
         _this5.handleSubscriptionTerminated(resourceId);
       }, function () {
         _this5.handleSubscriptionTerminated(resourceId);
@@ -302,19 +333,19 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
       }
     }
 
-    /**
-     * Schedules a reconnection attempt with exponential backoff.
-     * Delay = INITIAL_RETRY_DELAY_MS * (RETRY_BACKOFF_MULTIPLIER ^ attempts)
-     * e.g. 1s, 2s, 4s, 8s, 16s
-     */
+    // Schedules a reconnection with backoff (see getMaxRetryAttempts /
+    // getReconnectionDelay for the gated behaviour).
   }, {
     key: "scheduleReconnection",
     value: function scheduleReconnection(resourceId) {
       var _this$retryAttempts$g,
         _this6 = this;
       var attempts = (_this$retryAttempts$g = this.retryAttempts.get(resourceId)) !== null && _this$retryAttempts$g !== void 0 ? _this$retryAttempts$g : 0;
-      if (attempts >= SyncBlockSubscriptionManager.MAX_RETRY_ATTEMPTS) {
+      var maxAttempts = this.getMaxRetryAttempts();
+      if (attempts >= maxAttempts) {
         var _this$deps$getFireAna;
+        // Exhausted all attempts — the only place a WS drop surfaces as a
+        // fetch error under the gate (EDITOR-7861).
         var errorMessage = "Subscription reconnection failed after ".concat(attempts, " attempts");
         logException(new Error(errorMessage), {
           location: 'editor-synced-block-provider/syncBlockSubscriptionManager/max-retries-exhausted'
@@ -322,7 +353,7 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
         (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(errorMessage, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
         return;
       }
-      var delay = SyncBlockSubscriptionManager.INITIAL_RETRY_DELAY_MS * Math.pow(SyncBlockSubscriptionManager.RETRY_BACKOFF_MULTIPLIER, attempts);
+      var delay = this.getReconnectionDelay(attempts);
       var timer = setTimeout(function () {
         _this6.pendingRetries.delete(resourceId);
 
@@ -480,7 +511,11 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
     }
   }]);
 }();
-// Reconnection with exponential backoff
+// Reconnection with exponential backoff.
 _defineProperty(SyncBlockSubscriptionManager, "INITIAL_RETRY_DELAY_MS", 1000);
 _defineProperty(SyncBlockSubscriptionManager, "RETRY_BACKOFF_MULTIPLIER", 2);
-_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS", 5);
+_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS", 5);
+// legacy (gate OFF)
+_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS_HARDENED", 8);
+// gate ON (EDITOR-7861)
+_defineProperty(SyncBlockSubscriptionManager, "MAX_RETRY_DELAY_MS", 30000);