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

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @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

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/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]);

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/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/types/common/types.d.ts

@@ -80,3 +80,32 @@ export type SyncBlockPrefetchData = {
     prefetchPromise: Promise<SyncBlockInstance[] | undefined>;
     resourceIds: string[];
 };
+/**
+ * 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 declare 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 declare class ProviderNotReadyError extends Error {
+    readonly isProviderNotReadyError = true;
+    constructor(message?: string);
+}
+/**
+ * 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 declare const isProviderNotReadyError: (error: unknown) => boolean;

package/dist/types/store-manager/referenceSyncBlockStoreManager.d.ts

@@ -31,6 +31,14 @@ export declare class ReferenceSyncBlockStoreManager {
     private _batchFetcher;
     constructor(dataProvider?: SyncBlockDataProviderInterface, viewMode?: ViewMode);
     isReferenceBlock(node: PMNode): boolean;
+    /**
+     * 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(): boolean;
     /**
      * Enables or disables real-time GraphQL subscriptions for block updates.
      * When enabled, the store manager will subscribe to real-time updates

package/dist/types/store-manager/syncBlockBatchFetcher.d.ts

@@ -7,6 +7,13 @@ export interface SyncBlockBatchFetcherDeps {
     getSubscriptions: () => Map<ResourceId, {
         [localId: BlockInstanceId]: SubscriptionCallback;
     }>;
+    /**
+     * Returns true when the data provider is wired and not torn down. When false,
+     * the fetcher skips and re-queues so the IDs are fetched once ready, avoiding
+     * the false `Data provider not set` errors (EDITOR-7860). Optional; when
+     * omitted, behaviour is unchanged.
+     */
+    isProviderReady?: () => boolean;
 }
 /**
  * Handles debounced batch-fetching of sync block data via `raf-schd`.

package/package.json

@@ -30,7 +30,7 @@
 		"uuid": "^3.1.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^116.14.0",
+		"@atlaskit/editor-common": "^116.15.0",
 		"react": "^18.2.0"
 	},
 	"devDependencies": {
@@ -74,7 +74,7 @@
 		}
 	},
 	"name": "@atlaskit/editor-synced-block-provider",
-	"version": "8.1.10",
+	"version": "8.2.0",
 	"description": "Synced Block Provider for @atlaskit/editor-plugin-synced-block",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",