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

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

@@ -3,7 +3,8 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { logException } from '@atlaskit/editor-common/monitoring';
 import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
-import { fetchErrorPayload } from '../utils/errorHandling';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { buildFetchErrorAttribution, fetchErrorPayload } from '../utils/errorHandling';
 import { parseResourceId } from '../utils/resourceId';
 import { getSourceProductFromResourceIdSafe } from '../utils/utils';
 /**
@@ -26,7 +27,7 @@ export var SyncBlockProviderFactoryManager = /*#__PURE__*/function () {
         logException(error, {
           location: 'editor-synced-block-provider/syncBlockProviderFactoryManager'
         });
-        (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+        (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId), buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), error.message)));
         return undefined;
       }
       var _dataProvider$getSync = dataProvider.getSyncedBlockRendererProviderOptions(),
@@ -59,7 +60,7 @@ export var SyncBlockProviderFactoryManager = /*#__PURE__*/function () {
           logException(error, {
             location: 'editor-synced-block-provider/syncBlockProviderFactoryManager'
           });
-          (_this$deps$getFireAna2 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna2 === void 0 || _this$deps$getFireAna2(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+          (_this$deps$getFireAna2 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna2 === void 0 || _this$deps$getFireAna2(fetchErrorPayload(error.message, resourceId, getSourceProductFromResourceIdSafe(resourceId), buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), error.message)));
         }
       }
       return providerFactory;
@@ -144,7 +145,7 @@ export var SyncBlockProviderFactoryManager = /*#__PURE__*/function () {
       if (!syncBlock.data.sourceAri || !syncBlock.data.product) {
         var _this$deps$getFireAna3, _syncBlock$data$produ;
         (_this$deps$getFireAna3 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna3 === void 0 || _this$deps$getFireAna3(fetchErrorPayload('Sync block source ari or product not found', resourceId, // Prefer cached product when available; fall back to parsing resourceId.
-        (_syncBlock$data$produ = syncBlock.data.product) !== null && _syncBlock$data$produ !== void 0 ? _syncBlock$data$produ : getSourceProductFromResourceIdSafe(resourceId)));
+        (_syncBlock$data$produ = syncBlock.data.product) !== null && _syncBlock$data$produ !== void 0 ? _syncBlock$data$produ : getSourceProductFromResourceIdSafe(resourceId), buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), 'Sync block source ari or product not found')));
         return;
       }
       var parentInfo = dataProvider.retrieveSyncBlockParentInfo(syncBlock.data.sourceAri, syncBlock.data.product);

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

@@ -8,7 +8,7 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { logException } from '@atlaskit/editor-common/monitoring';
 import { fg } from '@atlaskit/platform-feature-flags';
-import { fetchErrorPayload, fetchSuccessPayload } from '../utils/errorHandling';
+import { buildFetchErrorAttribution, fetchErrorPayload, fetchSuccessPayload } from '../utils/errorHandling';
 import { resolveSyncBlockInstance } from '../utils/resolveSyncBlockInstance';
 import { getSourceProductFromResourceIdSafe } from '../utils/utils';
 /**
@@ -114,7 +114,7 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
           logException(error, {
             location: 'editor-synced-block-provider/syncBlockSubscriptionManager/notifySubscriptionChangeListeners'
           });
-          (_this2$deps$getFireAn = _this2.deps.getFireAnalyticsEvent()) === null || _this2$deps$getFireAn === void 0 || _this2$deps$getFireAn(fetchErrorPayload(error.message));
+          (_this2$deps$getFireAn = _this2.deps.getFireAnalyticsEvent()) === null || _this2$deps$getFireAn === void 0 || _this2$deps$getFireAn(fetchErrorPayload(error.message, undefined, undefined, buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), error.message)));
         }
       });
     }
@@ -299,6 +299,9 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
         // 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.
+        // This branch only runs when the gate is OFF, so buildFetchErrorAttribution
+        // would return undefined; the structured attribution (EDITOR-7862) is therefore
+        // applied at the gate-ON exhaustion site in scheduleReconnection instead.
         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)));
@@ -350,7 +353,7 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
         logException(new Error(errorMessage), {
           location: 'editor-synced-block-provider/syncBlockSubscriptionManager/max-retries-exhausted'
         });
-        (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(errorMessage, resourceId, getSourceProductFromResourceIdSafe(resourceId)));
+        (_this$deps$getFireAna = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna === void 0 || _this$deps$getFireAna(fetchErrorPayload(errorMessage, resourceId, getSourceProductFromResourceIdSafe(resourceId), buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), errorMessage)));
         return;
       }
       var delay = this.getReconnectionDelay(attempts);
@@ -504,9 +507,13 @@ export var SyncBlockSubscriptionManager = /*#__PURE__*/function () {
         });
         this.deps.fetchSyncBlockSourceInfo(resolved.resourceId);
       } else {
-        var _syncBlockInstance$er, _syncBlockInstance$er2, _this$deps$getFireAna2, _syncBlockInstance$da3, _syncBlockInstance$da4;
+        var _syncBlockInstance$er, _syncBlockInstance$er2, _this$deps$getFireAna2, _syncBlockInstance$da3, _syncBlockInstance$da4, _syncBlockInstance$er3, _syncBlockInstance$er4, _syncBlockInstance$er5;
         var errorMessage = ((_syncBlockInstance$er = syncBlockInstance.error) === null || _syncBlockInstance$er === void 0 ? void 0 : _syncBlockInstance$er.reason) || ((_syncBlockInstance$er2 = syncBlockInstance.error) === null || _syncBlockInstance$er2 === void 0 ? void 0 : _syncBlockInstance$er2.type);
-        (_this$deps$getFireAna2 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna2 === void 0 || _this$deps$getFireAna2(fetchErrorPayload(errorMessage, syncBlockInstance.resourceId, (_syncBlockInstance$da3 = (_syncBlockInstance$da4 = syncBlockInstance.data) === null || _syncBlockInstance$da4 === void 0 ? void 0 : _syncBlockInstance$da4.product) !== null && _syncBlockInstance$da3 !== void 0 ? _syncBlockInstance$da3 : getSourceProductFromResourceIdSafe(syncBlockInstance.resourceId)));
+
+        // Prefer the structured `type` (a `SyncBlockError` enum value) for classification
+        // and fall back to the free-text `reason` so source-state/permission strings are
+        // still bucketed (EDITOR-7862). The emitted free-text `error` attribute is unchanged.
+        (_this$deps$getFireAna2 = this.deps.getFireAnalyticsEvent()) === null || _this$deps$getFireAna2 === void 0 || _this$deps$getFireAna2(fetchErrorPayload(errorMessage, syncBlockInstance.resourceId, (_syncBlockInstance$da3 = (_syncBlockInstance$da4 = syncBlockInstance.data) === null || _syncBlockInstance$da4 === void 0 ? void 0 : _syncBlockInstance$da4.product) !== null && _syncBlockInstance$da3 !== void 0 ? _syncBlockInstance$da3 : getSourceProductFromResourceIdSafe(syncBlockInstance.resourceId), buildFetchErrorAttribution(fg('platform_editor_blocks_patch_3'), ((_syncBlockInstance$er3 = syncBlockInstance.error) === null || _syncBlockInstance$er3 === void 0 ? void 0 : _syncBlockInstance$er3.type) || ((_syncBlockInstance$er4 = syncBlockInstance.error) === null || _syncBlockInstance$er4 === void 0 ? void 0 : _syncBlockInstance$er4.reason), (_syncBlockInstance$er5 = syncBlockInstance.error) === null || _syncBlockInstance$er5 === void 0 ? void 0 : _syncBlockInstance$er5.statusCode)));
       }
     }
   }]);

package/dist/esm/utils/errorHandling.js

@@ -1,3 +1,4 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -60,19 +61,155 @@ export var buildErrorAttribution = function buildErrorAttribution(gateEnabled, e
   });
 };
 
+/**
+ * The set of categorical failure reasons emitted on synced-block fetch/subscribe
+ * operational error events (EDITOR-7862). Extends the write-path
+ * {@link SyncBlockErrorReason} set with read-path-specific buckets so the analytics
+ * dashboard can break fetch failures down by cause instead of regex-matching the
+ * free-text `error` blob.
+ *
+ * The read path surfaces several causes the write-path `SyncBlockError` enum does not
+ * model (benign source-state transitions, permission denials, WebSocket lifecycle, and
+ * client-side readiness errors), so those are added here. Known `SyncBlockError` enum
+ * values (`not_found`, `forbidden`, ...) still pass through unchanged.
+ */
+
+/**
+ * Fetch reasons that represent benign (working-as-designed) outcomes rather than genuine
+ * system failures. The dashboard uses this to compute a "true error rate" by excluding
+ * benign reasons via the structured `reason` attribute instead of brittle free-text regex
+ * (EDITOR-7862).
+ */
+export var FETCH_BENIGN_REASONS = new Set(['source_deleted', 'source_unpublished', 'source_unsynced', 'source_not_found', 'permission_denied', 'unauthenticated',
+// Mirror the benign write-path enum equivalents so already-classified errors are
+// treated consistently.
+'not_found', 'forbidden', 'unpublished'
+// NOTE: `entity_not_found` and `offline` are intentionally NOT benign.
+// - `entity_not_found` is retried up to ENTITY_NOT_FOUND_MAX_RETRIES (analytics are
+//   suppressed during retries); by the time the error event fires, retries are
+//   exhausted and it is a genuine failure.
+// - `offline` is genuine client connectivity loss, not a working-as-designed outcome.
+// Both still emit `reason` (so they can be inspected) but are counted as true errors.
+]);
+
+/**
+ * Ordered list of substring matchers mapping known free-text fetch/subscribe error
+ * strings to a categorical {@link SyncBlockFetchErrorReason}. Each entry is a list of
+ * lowercase needles; if ANY needle is found (case-insensitively) in the raw `error`
+ * string, the entry's reason is used. Order matters: more specific entries must precede
+ * more general ones.
+ *
+ * Plain `String.includes` substring matching is used deliberately instead of `RegExp`:
+ * it sidesteps the `require-unicode-regexp` lint rule AND the declaration build's lower
+ * compile target (which rejects the regex `u` flag with TS1501), while being faster and
+ * easier to read. Doing this classification in code (rather than in dashboard SQL) keeps
+ * the buckets versioned with the source strings that produce them (EDITOR-7862).
+ */
+var FETCH_REASON_MATCHERS = [
+// Benign: source-state transitions (deletionReason values + free text).
+[['source-document-deleted'], 'source_deleted'], [['source-block-deleted'], 'source_deleted'], [['source-block-unpublished'], 'source_unpublished'], [['source-block-unsynced'], 'source_unsynced'], [['does not exist'], 'source_not_found'], [['unpublished'], 'source_unpublished'],
+// Working-as-designed permission outcomes.
+[['unauthenticated'], 'unauthenticated'], [['not permitted to read synced block'], 'permission_denied'], [['bulk permission check failed'], 'permission_denied'], [['permission denied'], 'permission_denied'],
+// Genuine system failures.
+[['reconnection failed after'], 'websocket_exhausted'],
+// `reconnect to the subscription` (not a bare `reconnect`) avoids false positives on
+// unrelated DB/GraphQL "reconnect" messages while still matching the WS-drop string.
+[['websocket', 'reconnect to the subscription', 'subscription terminated'], 'websocket_drop'], [['429', 'rate limit', 'rate-limit', 'ratelimit'], 'rate_limited'],
+// `econnrefused`/`econnreset` (not a bare `econn`, which would also match `reconnect`).
+[['network', 'failed to fetch', 'econnrefused', 'econnreset', 'timed out', 'timeout'], 'network'], [['data provider not set'], 'data_provider_not_ready']];
+
+/**
+ * Maps a fetch/subscribe `error` field — which may be a {@link SyncBlockError} enum
+ * value, a {@link DeletionReason} value, or an arbitrary free-text/JSON blob — to a
+ * stable categorical {@link SyncBlockFetchErrorReason} for analytics grouping.
+ *
+ * Resolution order:
+ * 1. Known `SyncBlockError` enum value → passed through (via {@link classifyErrorReason}).
+ * 2. Known free-text substring → mapped to a fetch-specific bucket.
+ * 3. Anything else (including opaque blobs like `errored`-only payloads or
+ *    `ErrorEvent: "undefined"`) → `'unknown'`, so the dashboard never groups on free text.
+ *
+ * Note: the bare string `'errored'` IS a `SyncBlockError` enum value and therefore
+ * classifies as `'errored'` (not `'unknown'`); only genuinely unrecognised strings
+ * collapse to `'unknown'`.
+ */
+export var classifyFetchErrorReason = function classifyFetchErrorReason(error) {
+  var enumReason = classifyErrorReason(error);
+  if (enumReason !== 'unknown') {
+    return enumReason;
+  }
+  if (error) {
+    var haystack = error.toLowerCase();
+    for (var _i = 0, _FETCH_REASON_MATCHER = FETCH_REASON_MATCHERS; _i < _FETCH_REASON_MATCHER.length; _i++) {
+      var _FETCH_REASON_MATCHER2 = _slicedToArray(_FETCH_REASON_MATCHER[_i], 2),
+        needles = _FETCH_REASON_MATCHER2[0],
+        reason = _FETCH_REASON_MATCHER2[1];
+      if (needles.some(function (needle) {
+        return haystack.includes(needle);
+      })) {
+        return reason;
+      }
+    }
+  }
+  return 'unknown';
+};
+
+/**
+ * Extra, optional analytics attributes describing WHY a fetch/subscribe synced-block
+ * action failed. Spread conditionally so we never emit `undefined` keys (EDITOR-7862).
+ *
+ * Adds `benign` on top of the shared {@link ErrorAttributionAttributes} so the dashboard
+ * can compute a true error rate (`genuine / total`) without any free-text regex.
+ */
+
+/**
+ * Builds the {@link FetchErrorAttributionAttributes} for a failed fetch/subscribe
+ * synced-block operation from the raw `error` field and optional backend `statusCode`.
+ * Returns `undefined` when the `platform_editor_blocks_patch_3` gate is OFF, so the new
+ * `reason`/`statusCode`/`benign` attributes are only emitted once the gate is rolled out
+ * (EDITOR-7862). The existing free-text `error` attribute is always left unchanged.
+ *
+ * `gateEnabled` is injected by the caller (the store managers evaluate `fg(...)`) so this
+ * helper stays pure and trivially unit-testable for both gate states.
+ */
+export var buildFetchErrorAttribution = function buildFetchErrorAttribution(gateEnabled, error, statusCode) {
+  if (!gateEnabled) {
+    return undefined;
+  }
+  var reason = classifyFetchErrorReason(error);
+  return _objectSpread({
+    reason: reason,
+    benign: FETCH_BENIGN_REASONS.has(reason)
+  }, statusCode !== undefined && {
+    statusCode: statusCode
+  });
+};
+
 // `sourceProduct` is threaded through every helper so analytics
 // events can be attributed to the source product (`confluence-page` vs `jira-work-item`).
 // All helpers accept it as an optional trailing argument; the spread-only-when-truthy
 // pattern below ensures we never emit `sourceProduct: undefined` (which would dirty the
 // event schema with empty keys).
 
-export var getErrorPayload = function getErrorPayload(actionSubjectId, error, resourceId, sourceProduct, attribution) {
+/**
+ * Shared operational ERROR payload builder for synced-block events.
+ *
+ * Overloaded so the emitted `reason` type stays accurate per path (raised in review on
+ * EDITOR-7862): fetch/subscribe callers pass a {@link FetchErrorAttributionAttributes}
+ * (discriminated by its required `benign` field) and get the wider
+ * {@link SyncBlockFetchErrorReason}; write-path callers pass an
+ * {@link ErrorAttributionAttributes} (or nothing) and keep the narrower
+ * {@link SyncBlockErrorReason}, so write-path payloads never claim to carry fetch-only
+ * buckets like `source_deleted` they never emit.
+ */
+
+export function getErrorPayload(actionSubjectId, error, resourceId, sourceProduct, attribution) {
   return {
     action: ACTION.ERROR,
     actionSubject: ACTION_SUBJECT.SYNCED_BLOCK,
     actionSubjectId: actionSubjectId,
     eventType: EVENT_TYPE.OPERATIONAL,
-    attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+    attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({
       error: error
     }, resourceId && {
       resourceId: resourceId
@@ -82,11 +219,18 @@ export var getErrorPayload = function getErrorPayload(actionSubjectId, error, re
       reason: attribution.reason
     }), (attribution === null || attribution === void 0 ? void 0 : attribution.statusCode) !== undefined && {
       statusCode: attribution.statusCode
+    }), attribution && 'benign' in attribution && {
+      benign: attribution.benign
     })
   };
-};
-export var fetchErrorPayload = function fetchErrorPayload(error, resourceId, sourceProduct) {
-  return getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH, error, resourceId, sourceProduct);
+}
+export var fetchErrorPayload = function fetchErrorPayload(error, resourceId, sourceProduct, attribution) {
+  return (
+    // Branch on attribution presence so each call resolves to a concrete overload: with
+    // attribution it hits the fetch overload (wider `reason`); without it (gate OFF) it
+    // hits the no-attribution overload. Both produce a fetch event regardless.
+    attribution ? getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH, error, resourceId, sourceProduct, attribution) : getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_FETCH, error, resourceId, sourceProduct)
+  );
 };
 export var getSourceInfoErrorPayload = function getSourceInfoErrorPayload(error, resourceId, sourceProduct) {
   return getErrorPayload(ACTION_SUBJECT_ID.SYNCED_BLOCK_GET_SOURCE_INFO, error, resourceId, sourceProduct);

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

@@ -7,6 +7,14 @@ import type { SyncBlockData, SyncBlockStatus, ResourceId, SyncBlockError, SyncBl
 type SyncBlockErrorInfo = {
     reason?: string;
     sourceAri?: string;
+    /**
+     * HTTP status code from the backend (Block Service) when a fetch/subscribe failure
+     * originated from a `BlockError`. Surfaced so fetch failure analytics can break down
+     * read-path failures by status code (EDITOR-7862). Undefined for non-HTTP failures
+     * (e.g. JSON parse errors, missing-content NotFound, or backend error responses that
+     * only carry a string `code`).
+     */
+    statusCode?: number;
     type: SyncBlockError;
 };
 /**

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/dist/types/utils/errorHandling.d.ts

@@ -38,14 +38,106 @@ export type ErrorAttributionAttributes = {
  * helper stays pure and trivially unit-testable for both gate states.
  */
 export declare const buildErrorAttribution: (gateEnabled: boolean, error?: string, statusCode?: number) => ErrorAttributionAttributes | undefined;
-export declare const getErrorPayload: <T extends ACTION_SUBJECT_ID>(actionSubjectId: T, error: string, resourceId?: string, sourceProduct?: string, attribution?: ErrorAttributionAttributes) => OperationalAEP<ACTION.ERROR, ACTION_SUBJECT.SYNCED_BLOCK, T, {
+/**
+ * The set of categorical failure reasons emitted on synced-block fetch/subscribe
+ * operational error events (EDITOR-7862). Extends the write-path
+ * {@link SyncBlockErrorReason} set with read-path-specific buckets so the analytics
+ * dashboard can break fetch failures down by cause instead of regex-matching the
+ * free-text `error` blob.
+ *
+ * The read path surfaces several causes the write-path `SyncBlockError` enum does not
+ * model (benign source-state transitions, permission denials, WebSocket lifecycle, and
+ * client-side readiness errors), so those are added here. Known `SyncBlockError` enum
+ * values (`not_found`, `forbidden`, ...) still pass through unchanged.
+ */
+export type SyncBlockFetchErrorReason = SyncBlockErrorReason | 'source_deleted' | 'source_unpublished' | 'source_unsynced' | 'source_not_found' | 'permission_denied' | 'unauthenticated' | 'websocket_drop' | 'websocket_exhausted' | 'network' | 'data_provider_not_ready';
+/**
+ * Fetch reasons that represent benign (working-as-designed) outcomes rather than genuine
+ * system failures. The dashboard uses this to compute a "true error rate" by excluding
+ * benign reasons via the structured `reason` attribute instead of brittle free-text regex
+ * (EDITOR-7862).
+ */
+export declare const FETCH_BENIGN_REASONS: ReadonlySet<SyncBlockFetchErrorReason>;
+/**
+ * Maps a fetch/subscribe `error` field — which may be a {@link SyncBlockError} enum
+ * value, a {@link DeletionReason} value, or an arbitrary free-text/JSON blob — to a
+ * stable categorical {@link SyncBlockFetchErrorReason} for analytics grouping.
+ *
+ * Resolution order:
+ * 1. Known `SyncBlockError` enum value → passed through (via {@link classifyErrorReason}).
+ * 2. Known free-text substring → mapped to a fetch-specific bucket.
+ * 3. Anything else (including opaque blobs like `errored`-only payloads or
+ *    `ErrorEvent: "undefined"`) → `'unknown'`, so the dashboard never groups on free text.
+ *
+ * Note: the bare string `'errored'` IS a `SyncBlockError` enum value and therefore
+ * classifies as `'errored'` (not `'unknown'`); only genuinely unrecognised strings
+ * collapse to `'unknown'`.
+ */
+export declare const classifyFetchErrorReason: (error?: string) => SyncBlockFetchErrorReason;
+/**
+ * Extra, optional analytics attributes describing WHY a fetch/subscribe synced-block
+ * action failed. Spread conditionally so we never emit `undefined` keys (EDITOR-7862).
+ *
+ * Adds `benign` on top of the shared {@link ErrorAttributionAttributes} so the dashboard
+ * can compute a true error rate (`genuine / total`) without any free-text regex.
+ */
+export type FetchErrorAttributionAttributes = {
+    /**
+     * Categorical fetch failure cause for dashboard grouping. Declared standalone (not via
+     * `ErrorAttributionAttributes & ...`) because intersecting two `reason?` properties
+     * narrows the type to the write-path {@link SyncBlockErrorReason}; we need the wider
+     * {@link SyncBlockFetchErrorReason} here (EDITOR-7862).
+     */
+    reason?: SyncBlockFetchErrorReason;
+    /** Backend HTTP status code when the failure came from a `BlockError`. */
+    statusCode?: number;
+    /**
+     * Whether the reason is a benign/working-as-designed outcome (not a true failure).
+     * Required (not optional) so this type structurally discriminates fetch attribution
+     * from the write-path {@link ErrorAttributionAttributes}; this lets {@link getErrorPayload}
+     * overload-resolve the correct (wider) `reason` type per path. `buildFetchErrorAttribution`
+     * always sets it, so requiring it costs nothing.
+     */
+    benign: boolean;
+};
+/**
+ * Builds the {@link FetchErrorAttributionAttributes} for a failed fetch/subscribe
+ * synced-block operation from the raw `error` field and optional backend `statusCode`.
+ * Returns `undefined` when the `platform_editor_blocks_patch_3` gate is OFF, so the new
+ * `reason`/`statusCode`/`benign` attributes are only emitted once the gate is rolled out
+ * (EDITOR-7862). The existing free-text `error` attribute is always left unchanged.
+ *
+ * `gateEnabled` is injected by the caller (the store managers evaluate `fg(...)`) so this
+ * helper stays pure and trivially unit-testable for both gate states.
+ */
+export declare const buildFetchErrorAttribution: (gateEnabled: boolean, error?: string, statusCode?: number) => FetchErrorAttributionAttributes | undefined;
+/**
+ * Shared operational ERROR payload builder for synced-block events.
+ *
+ * Overloaded so the emitted `reason` type stays accurate per path (raised in review on
+ * EDITOR-7862): fetch/subscribe callers pass a {@link FetchErrorAttributionAttributes}
+ * (discriminated by its required `benign` field) and get the wider
+ * {@link SyncBlockFetchErrorReason}; write-path callers pass an
+ * {@link ErrorAttributionAttributes} (or nothing) and keep the narrower
+ * {@link SyncBlockErrorReason}, so write-path payloads never claim to carry fetch-only
+ * buckets like `source_deleted` they never emit.
+ */
+export declare function getErrorPayload<T extends ACTION_SUBJECT_ID>(actionSubjectId: T, error: string, resourceId: string | undefined, sourceProduct: string | undefined, attribution: FetchErrorAttributionAttributes): OperationalAEP<ACTION.ERROR, ACTION_SUBJECT.SYNCED_BLOCK, T, {
+    error: string;
+    resourceId?: string;
+    sourceProduct?: string;
+    reason?: SyncBlockFetchErrorReason;
+    statusCode?: number;
+    benign?: boolean;
+}>;
+export declare function getErrorPayload<T extends ACTION_SUBJECT_ID>(actionSubjectId: T, error: string, resourceId?: string, sourceProduct?: string, attribution?: ErrorAttributionAttributes): OperationalAEP<ACTION.ERROR, ACTION_SUBJECT.SYNCED_BLOCK, T, {
     error: string;
     resourceId?: string;
     sourceProduct?: string;
     reason?: SyncBlockErrorReason;
     statusCode?: number;
 }>;
-export declare const fetchErrorPayload: (error: string, resourceId?: string, sourceProduct?: string) => RendererSyncBlockEventPayload;
+export declare const fetchErrorPayload: (error: string, resourceId?: string, sourceProduct?: string, attribution?: FetchErrorAttributionAttributes) => RendererSyncBlockEventPayload;
 export declare const getSourceInfoErrorPayload: (error: string, resourceId?: string, sourceProduct?: string) => RendererSyncBlockEventPayload;
 export declare const updateErrorPayload: (error: string, resourceId?: string, sourceProduct?: string, attribution?: ErrorAttributionAttributes) => SyncBlockEventPayload;
 export declare const updateReferenceErrorPayload: (error: string, resourceId?: string, sourceProduct?: string, attribution?: ErrorAttributionAttributes) => RendererSyncBlockEventPayload;

package/package.json

@@ -21,7 +21,7 @@
 		"@atlaskit/editor-prosemirror": "^8.0.0",
 		"@atlaskit/node-data-provider": "^13.0.0",
 		"@atlaskit/platform-feature-flags": "^2.0.0",
-		"@atlaskit/tmp-editor-statsig": "^114.0.0",
+		"@atlaskit/tmp-editor-statsig": "^114.4.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^0.20.0",
 		"graphql-ws": "^5.14.2",
@@ -30,7 +30,7 @@
 		"uuid": "^3.1.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^116.14.0",
+		"@atlaskit/editor-common": "^116.17.0",
 		"react": "^18.2.0"
 	},
 	"devDependencies": {
@@ -74,7 +74,7 @@
 		}
 	},
 	"name": "@atlaskit/editor-synced-block-provider",
-	"version": "8.1.10",
+	"version": "8.3.0",
 	"description": "Synced Block Provider for @atlaskit/editor-plugin-synced-block",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",