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

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @atlaskit/editor-synced-block-provider
 
+## 8.2.0
+
+### Minor Changes
+
+- [`f13db8731461d`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/f13db8731461d) -
+  [EDITOR-7860] Gate synced block reference fetch and subscribe on data-provider readiness so
+  reference blocks no longer attempt to fetch before the (asynchronously wired) provider is ready.
+  This removes spurious "Data provider not set" fetch errors on Jira and keeps reference blocks
+  loading correctly once the provider resolves.
+
+  This also hardens the not-ready / torn-down window: a teardown-aware `hasDataProvider()` (also
+  checks `isDestroyed`), a tagged `ProviderNotReadyError` thrown at the fetch source, and catch-site
+  suppression in the hook, store manager and batch fetcher so an in-flight or queued fetch on an
+  orphaned manager re-queues for retry instead of emitting a false fetch error. All behaviour is
+  behind the `platform_editor_blocks_patch_3` feature gate.
+
+## 8.1.10
+
+### Patch Changes
+
+- [`b4cfc35a62476`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/b4cfc35a62476) -
+  Improve the reliability of synced-block real-time updates. Transient WebSocket drops now recover
+  silently via a more resilient reconnection strategy (more retry attempts, capped exponential
+  backoff with jitter) instead of being reported as failures. A failure is only surfaced once
+  reconnection is genuinely exhausted. Behind a feature gate.
+- Updated dependencies
+
 ## 8.1.9
 
 ### Patch Changes

package/dist/cjs/common/types.js

@@ -1,9 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SyncBlockError = void 0;
+exports.isProviderNotReadyError = exports.SyncBlockError = exports.ProviderNotReadyError = exports.PROVIDER_NOT_READY_MESSAGE = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(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; })(); }
 var SyncBlockError = exports.SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
   SyncBlockError["Errored"] = "errored";
   SyncBlockError["NotFound"] = "not_found";
@@ -22,4 +33,54 @@ var SyncBlockError = exports.SyncBlockError = /*#__PURE__*/function (SyncBlockEr
   // 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. */
+var PROVIDER_NOT_READY_MESSAGE = exports.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}.
+ */
+var ProviderNotReadyError = exports.ProviderNotReadyError = /*#__PURE__*/function (_Error) {
+  function ProviderNotReadyError() {
+    var _this;
+    var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : PROVIDER_NOT_READY_MESSAGE;
+    (0, _classCallCheck2.default)(this, ProviderNotReadyError);
+    _this = _callSuper(this, ProviderNotReadyError, [message]);
+    (0, _defineProperty2.default)(_this, "isProviderNotReadyError", true);
+    _this.name = 'ProviderNotReadyError';
+    // Restore prototype chain so instanceof works after transpilation.
+    Object.setPrototypeOf(_this, ProviderNotReadyError.prototype);
+    return _this;
+  }
+  (0, _inherits2.default)(ProviderNotReadyError, _Error);
+  return (0, _createClass2.default)(ProviderNotReadyError);
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(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).
+ */
+var isProviderNotReadyError = exports.isProviderNotReadyError = function isProviderNotReadyError(error) {
+  if (error instanceof ProviderNotReadyError) {
+    return true;
+  }
+  if ((0, _typeof2.default)(error) === 'object' && error !== null && error.isProviderNotReadyError === true) {
+    return true;
+  }
+  return error instanceof Error && error.message === PROVIDER_NOT_READY_MESSAGE;
+};

package/dist/cjs/hooks/useFetchSyncBlockData.js

@@ -12,12 +12,14 @@ var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/sli
 var _react = require("react");
 var _coreUtils = require("@atlaskit/editor-common/core-utils");
 var _monitoring = require("@atlaskit/editor-common/monitoring");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _types = require("../common/types");
 var _errorHandling = require("../utils/errorHandling");
 var _utils = require("../utils/utils");
 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) { (0, _defineProperty2.default)(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; }
 var useFetchSyncBlockData = exports.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
@@ -41,6 +43,14 @@ var useFetchSyncBlockData = exports.useFetchSyncBlockData = function useFetchSyn
     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 = (0, _platformFeatureFlags.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 = (0, _react.useCallback)( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
     var syncBlockNode, _t;
     return _regenerator.default.wrap(function (_context) {
@@ -52,14 +62,20 @@ var useFetchSyncBlockData = exports.useFetchSyncBlockData = function useFetchSyn
           }
           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 ? (0, _utils.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
@@ -67,14 +83,25 @@ var useFetchSyncBlockData = exports.useFetchSyncBlockData = function useFetchSyn
           });
 
           // 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 (!((0, _types.isProviderNotReadyError)(_t) && (0, _platformFeatureFlags.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:
           (0, _monitoring.logException)(_t, {
             location: 'editor-synced-block-provider/useFetchSyncBlockData'
           });
@@ -91,24 +118,31 @@ var useFetchSyncBlockData = exports.useFetchSyncBlockData = function useFetchSyn
             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]);
   (0, _react.useEffect)(function () {
     if ((0, _coreUtils.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,
@@ -118,7 +152,7 @@ var useFetchSyncBlockData = exports.useFetchSyncBlockData = function useFetchSyn
     return function () {
       unsubscribe();
     };
-  }, [localId, manager.referenceManager, resourceId]);
+  }, [isDataProviderReady, localId, manager.referenceManager, resourceId]);
   var ssrProviders = (0, _react.useMemo)(function () {
     return resourceId ? manager.referenceManager.getSSRProviders(resourceId) : null;
   }, [resourceId, manager.referenceManager]);

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

@@ -128,6 +128,10 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
       },
       getFireAnalyticsEvent: function getFireAnalyticsEvent() {
         return _this.fireAnalyticsEvent;
+      },
+      // EDITOR-7860: skip + re-queue fetches while not ready / torn down.
+      isProviderReady: function isProviderReady() {
+        return _this.hasDataProvider();
       }
     });
 
@@ -140,6 +144,19 @@ var ReferenceSyncBlockStoreManager = exports.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.
+     */
+  }, {
+    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
@@ -531,22 +548,28 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
               return _context2.abrupt("return");
             case 2:
               if (this.dataProvider) {
+                _context2.next = 4;
+                break;
+              }
+              if (!(0, _platformFeatureFlags.fg)('platform_editor_blocks_patch_3')) {
                 _context2.next = 3;
                 break;
               }
-              throw new Error('Data provider not set');
+              throw new _types.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) {
@@ -560,7 +583,7 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
               } else {
                 (_this$fetchExperience9 = this.fetchExperience) === null || _this$fetchExperience9 === void 0 || _this$fetchExperience9.success();
               }
-            case 5:
+            case 6:
             case "end":
               return _context2.stop();
           }
@@ -938,6 +961,12 @@ var ReferenceSyncBlockStoreManager = exports.ReferenceSyncBlockStoreManager = /*
         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 ((0, _types.isProviderNotReadyError)(error) && (0, _platformFeatureFlags.fg)('platform_editor_blocks_patch_3')) {
+          return function () {};
+        }
         (0, _monitoring.logException)(error, {
           location: 'editor-synced-block-provider/referenceSyncBlockStoreManager'
         });

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

@@ -10,6 +10,8 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _rafSchd = _interopRequireDefault(require("raf-schd"));
 var _monitoring = require("@atlaskit/editor-common/monitoring");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _types = require("../common/types");
 var _errorHandling = require("../utils/errorHandling");
 var _utils = require("../utils/utils");
 /**
@@ -32,6 +34,17 @@ var SyncBlockBatchFetcher = exports.SyncBlockBatchFetcher = /*#__PURE__*/functio
       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 ((0, _platformFeatureFlags.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) || {};
@@ -45,6 +58,20 @@ var SyncBlockBatchFetcher = exports.SyncBlockBatchFetcher = /*#__PURE__*/functio
         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 ((0, _types.isProviderNotReadyError)(error) && (0, _platformFeatureFlags.fg)('platform_editor_blocks_patch_3')) {
+          resourceIds.forEach(function (resId) {
+            return _this.pendingFetchRequests.add(resId);
+          });
+          if (!_this.isDestroyed) {
+            _this.scheduledBatchFetch();
+          }
+          return;
+        }
         (0, _monitoring.logException)(error, {
           location: 'editor-synced-block-provider/syncBlockBatchFetcher/batchedFetchSyncBlocks'
         });

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

@@ -37,6 +37,7 @@ var SyncBlockSubscriptionManager = exports.SyncBlockSubscriptionManager = /*#__P
     // causing the cache to be deleted prematurely. We delay deletion to allow
     // the new component to subscribe and cancel the pending deletion.
     (0, _defineProperty2.default)(this, "pendingCacheDeletions", new Map());
+    // backoff cap (gate ON)
     (0, _defineProperty2.default)(this, "retryAttempts", new Map());
     (0, _defineProperty2.default)(this, "pendingRetries", new Map());
     this.deps = deps;
@@ -47,6 +48,30 @@ var SyncBlockSubscriptionManager = exports.SyncBlockSubscriptionManager = /*#__P
    * that need to read the current subscription state.
    */
   return (0, _createClass2.default)(SyncBlockSubscriptionManager, [{
+    key: "getMaxRetryAttempts",
+    value:
+    // EDITOR-7861: higher ceiling lets transient WS-gateway drops self-heal
+    // before a terminal failure is surfaced.
+    function getMaxRetryAttempts() {
+      return (0, _platformFeatureFlags.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 (!(0, _platformFeatureFlags.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;
@@ -273,11 +298,17 @@ var SyncBlockSubscriptionManager = exports.SyncBlockSubscriptionManager = /*#__P
       var unsubscribe = dataProvider.subscribeToBlockUpdates(resourceId, function (syncBlockInstance) {
         _this5.handleGraphQLUpdate(syncBlockInstance);
       }, function (error) {
-        var _this5$deps$getFireAn;
         (0, _monitoring.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((0, _errorHandling.fetchErrorPayload)(error.message, resourceId, (0, _utils.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 (!(0, _platformFeatureFlags.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((0, _errorHandling.fetchErrorPayload)(error.message, resourceId, (0, _utils.getSourceProductFromResourceIdSafe)(resourceId)));
+        }
         _this5.handleSubscriptionTerminated(resourceId);
       }, function () {
         _this5.handleSubscriptionTerminated(resourceId);
@@ -308,19 +339,19 @@ var SyncBlockSubscriptionManager = exports.SyncBlockSubscriptionManager = /*#__P
       }
     }
 
-    /**
-     * 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");
         (0, _monitoring.logException)(new Error(errorMessage), {
           location: 'editor-synced-block-provider/syncBlockSubscriptionManager/max-retries-exhausted'
@@ -328,7 +359,7 @@ var SyncBlockSubscriptionManager = exports.SyncBlockSubscriptionManager = /*#__P
         (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna((0, _errorHandling.fetchErrorPayload)(errorMessage, resourceId, (0, _utils.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);
 
@@ -486,7 +517,11 @@ var SyncBlockSubscriptionManager = exports.SyncBlockSubscriptionManager = /*#__P
     }
   }]);
 }();
-// Reconnection with exponential backoff
+// Reconnection with exponential backoff.
 (0, _defineProperty2.default)(SyncBlockSubscriptionManager, "INITIAL_RETRY_DELAY_MS", 1000);
 (0, _defineProperty2.default)(SyncBlockSubscriptionManager, "RETRY_BACKOFF_MULTIPLIER", 2);
-(0, _defineProperty2.default)(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS", 5);
+(0, _defineProperty2.default)(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS", 5);
+// legacy (gate OFF)
+(0, _defineProperty2.default)(SyncBlockSubscriptionManager, "MAX_RETRY_ATTEMPTS_HARDENED", 8);
+// gate ON (EDITOR-7861)
+(0, _defineProperty2.default)(SyncBlockSubscriptionManager, "MAX_RETRY_DELAY_MS", 30000);

package/dist/es2019/common/types.js

@@ -1,3 +1,4 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 export let SyncBlockError = /*#__PURE__*/function (SyncBlockError) {
   SyncBlockError["Errored"] = "errored";
   SyncBlockError["NotFound"] = "not_found";
@@ -16,4 +17,49 @@ export let 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 const 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 class ProviderNotReadyError extends Error {
+  constructor(message = PROVIDER_NOT_READY_MESSAGE) {
+    super(message);
+    _defineProperty(this, "isProviderNotReadyError", true);
+    this.name = 'ProviderNotReadyError';
+    // Restore prototype chain so instanceof works after transpilation.
+    Object.setPrototypeOf(this, ProviderNotReadyError.prototype);
+  }
+}
+
+/**
+ * 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 const 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/es2019/hooks/useFetchSyncBlockData.js

@@ -1,10 +1,12 @@
 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 const 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
@@ -26,10 +28,23 @@ export const useFetchSyncBlockData = (manager, resourceId, localId, fireAnalytic
       isLoading: true
     };
   });
+
+  // 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.
+  const 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;
   const reloadData = useCallback(async () => {
     if (isLoading) {
       return;
     }
+
+    // Not ready: skip fetch, emit no error (see readiness note above).
+    if (!isDataProviderReady) {
+      return;
+    }
     try {
       const syncBlockNode = resourceId && localId ? createSyncBlockNode(localId, resourceId) : null;
       if (!syncBlockNode) {
@@ -43,6 +58,17 @@ export const useFetchSyncBlockData = (manager, resourceId, localId, fireAnalytic
       // Fetch sync block data, the `subscribeToSyncBlock` will update the state once data is fetched
       await manager.referenceManager.fetchSyncBlocksData([syncBlockNode]);
     } catch (error) {
+      // EDITOR-7860: benign not-ready throw — emit no error and stay loading
+      // so it resolves on retry once the provider is wired. Checked before
+      // `logException` so the benign case produces no exception-tracker noise.
+      // Gate-off behaviour is unchanged.
+      if (isProviderNotReadyError(error) && fg('platform_editor_blocks_patch_3')) {
+        setFetchState(prev => ({
+          ...prev,
+          isLoading: true
+        }));
+        return;
+      }
       logException(error, {
         location: 'editor-synced-block-provider/useFetchSyncBlockData'
       });
@@ -64,13 +90,20 @@ export const useFetchSyncBlockData = (manager, resourceId, localId, fireAnalytic
       ...prev,
       isLoading: false
     }));
-  }, [isLoading, localId, manager.referenceManager, resourceId, fireAnalyticsEvent]);
+  }, [isLoading, isDataProviderReady, localId, manager.referenceManager, resourceId, fireAnalyticsEvent]);
   useEffect(() => {
     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;
+    }
     const unsubscribe = manager.referenceManager.subscribeToSyncBlock(resourceId || '', localId || '', data => {
       setFetchState({
         syncBlockInstance: data,
@@ -80,7 +113,7 @@ export const useFetchSyncBlockData = (manager, resourceId, localId, fireAnalytic
     return () => {
       unsubscribe();
     };
-  }, [localId, manager.referenceManager, resourceId]);
+  }, [isDataProviderReady, localId, manager.referenceManager, resourceId]);
   const ssrProviders = useMemo(() => {
     return resourceId ? manager.referenceManager.getSSRProviders(resourceId) : null;
   }, [resourceId, manager.referenceManager]);