@atlaskit/rovo-triggers 10.14.0 → 10.15.0

package/dist/es2019/common/utils/extension-context-bridge/ExtensionContextBridgeHost.js

@@ -0,0 +1,82 @@
+import { useMemo } from 'react';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { useSubscribeAll } from '../../../main';
+import { BRIDGE_MESSAGE_MARKER, BRIDGE_SOURCE, BRIDGE_TO_EXTENSION } from './constants';
+import { getInboundDecision } from './policy';
+import { serializePayload } from './registry';
+import { createWindowTransport } from './transport';
+/**
+ * Stamps the page id onto `editor-context-payload` when the product left it unpopulated, since the
+ * extension chat cannot derive its own `contentId` from `window.location` (that's the side panel, not
+ * the page). `getContentId` is supplied by the consumer rather than read here, to avoid this package
+ * taking a dependency on `conversation-assistant-store` (a cyclic-dependency risk); the consumer
+ * already depends on that store and can resolve the id from it directly.
+ */
+const stampProductContentId = (serialized, targetContentId) => {
+  if (serialized.type !== 'editor-context-payload') {
+    return;
+  }
+  const data = serialized.data;
+  if (!data || data.contentMauiId) {
+    return;
+  }
+  if (targetContentId) {
+    data.contentMauiId = targetContentId;
+  }
+};
+/**
+ * Product-window half of the bridge. Observes the `ai-mate` bus and mirrors allowlisted context out
+ * to the extension via same-window `postMessage` (see `./policy` for the allow/deny rules).
+ *
+ * The reverse direction is handled by the sibling `RovoPostMessagePubsubListener` in
+ * `ChatOpenerSubscriber`, not here. Headless; mounts at product root via `ChatOpenerSubscriber`.
+ */
+export const ExtensionContextBridgeHost = ({
+  transport,
+  getContentId
+}) => {
+  // Self-gated (not taken from the consumer) so this cannot mount by mistake wherever
+  // `ChatOpenerSubscriber` renders. Matches `BRIDGE_FEATURE_GATE` in `./constants`.
+  const active = fg('rovo-ext_context_bridge');
+  const activeTransport = useMemo(() => {
+    if (!active) {
+      return undefined;
+    }
+    if (transport) {
+      return transport;
+    }
+    if (typeof window === 'undefined') {
+      return undefined;
+    }
+    return createWindowTransport({
+      targetWindow: window
+    });
+  }, [active, transport]);
+  useSubscribeAll(payload => {
+    if (!activeTransport) {
+      return;
+    }
+    // Loop guard.
+    if (payload.interactionSource === BRIDGE_SOURCE) {
+      return;
+    }
+    if (getInboundDecision(payload.type) !== 'allow') {
+      return;
+    }
+    const serialized = serializePayload(payload);
+    if (!serialized) {
+      return;
+    }
+    stampProductContentId(serialized, getContentId === null || getContentId === void 0 ? void 0 : getContentId());
+    try {
+      activeTransport.send({
+        [BRIDGE_MESSAGE_MARKER]: true,
+        direction: BRIDGE_TO_EXTENSION,
+        payload: serialized
+      });
+    } catch {
+      // Never let bridging break the host page.
+    }
+  });
+  return null;
+};

package/dist/es2019/common/utils/extension-context-bridge/constants.js

@@ -0,0 +1,16 @@
+/**
+ * Feature gate for the extension context bridge; both Host and Client self-gate on it.
+ * `fg()` requires a static literal, so call sites inline this value rather than importing it;
+ * tests resolve the gate through this constant so the two cannot drift apart.
+ */
+export const BRIDGE_FEATURE_GATE = 'rovo-ext_context_bridge';
+
+/** Marker on every bridge `postMessage`, so listeners can ignore unrelated messages. */
+export const BRIDGE_MESSAGE_MARKER = '__rovoExtContextBridge';
+
+/** Read context flows product -> extension; actions flow extension -> product. */
+export const BRIDGE_TO_EXTENSION = 'to-extension';
+export const BRIDGE_TO_PRODUCT = 'to-product';
+
+/** Loop-guard sentinel stamped on re-published payloads so they never ping-pong. */
+export const BRIDGE_SOURCE = 'rovo-extension-bridge';

package/dist/es2019/common/utils/extension-context-bridge/policy.js

@@ -0,0 +1,32 @@
+/**
+ * Bridge relay policy, asymmetric by direction:
+ * - Product → extension (context): relayed iff allowlisted and not denylisted. The denylist is a
+ *   backstop for control-plane/auth events that must never cross.
+ * - Extension → product (actions): allowlist only, so the chat's internal state never drives the
+ *   product.
+ *
+ * Independent of both lists: the loop guard (`BRIDGE_SOURCE`) and auto-drop of non-serialisable
+ * payloads.
+ */
+
+/** Inbound allowlist — payload types the bridge supports. Widen only as a feature needs it. */
+const INBOUND_ALLOWLIST = new Set(['editor-context-payload', 'set-message-context']);
+
+/** Inbound denylist — control-plane/auth events that must never reach the extension chat. */
+const INBOUND_DENYLIST = new Set(['message-send', 'chat-new', 'chat-open', 'chat-close', 'open-smart-creation-modal', 'open-browse-agent-modal', 'open-browse-agent-sidebar', 'open-chat-debug-modal', 'open-chat-feedback-modal', 'forge-auth-success', 'forge-auth-failure', 'chat-smartlink-3p-post-auth-launch']);
+
+/** Outbound allowlist — chat-originated events allowed to cross back to the product. */
+const OUTBOUND_ACTIONS = new Set(['editor-suggestion']);
+
+/** Why a product-bus payload was or was not relayed. */
+
+/** Classify a product-bus payload. Relay iff `allow`. */
+export const getInboundDecision = type => {
+  if (INBOUND_DENYLIST.has(type)) {
+    return 'denylisted';
+  }
+  return INBOUND_ALLOWLIST.has(type) ? 'allow' : 'not-allowlisted';
+};
+
+/** True if a chat-bus payload of this type may be relayed back to the product. */
+export const shouldRelayToProduct = type => OUTBOUND_ACTIONS.has(type);

package/dist/es2019/common/utils/extension-context-bridge/registry.js

@@ -0,0 +1,120 @@
+import { BRIDGE_SOURCE } from './constants';
+const base = payload => ({
+  type: payload.type,
+  source: payload.source,
+  product: payload.product,
+  openChat: payload.openChat
+});
+
+/**
+ * Boundary cast: the `Payload` union cannot be expressed structurally at this seam.
+ * Always stamps the loop-guard sentinel so the mirroring side skips it.
+ */
+const toPayload = value => (
+// eslint-disable-next-line @atlaskit/platform/no-double-type-assertions -- serialization boundary reconstruction
+{
+  ...value,
+  interactionSource: BRIDGE_SOURCE
+});
+
+/**
+ * Per-type overrides for payloads carrying non-cloneable data (functions). Anything not listed
+ * uses the generic JSON (de)serializer.
+ */
+
+/** Sentinel used to detect merge-style `setContext` implementations. */
+const MERGE_PROBE_KEY = '__rovoExtBridgeMergeProbe__';
+const SHIMS = {
+  /**
+   * `set-message-context` carries a `setContext` function, which cannot be structured-cloned.
+   * Resolves REPLACE-style publishers (return a fixed value) to their value and rebuilds a
+   * trivial `setContext` on the far side; merge-style publishers are dropped (detected via a
+   * probe object, since a throw-based check would silently ship a truncated context).
+   */
+  'set-message-context': {
+    serialize: payload => {
+      const data = payload.data;
+      if (!data || typeof data.setContext !== 'function') {
+        return null;
+      }
+      let value;
+      try {
+        value = data.setContext({
+          [MERGE_PROBE_KEY]: true
+        });
+      } catch {
+        return null;
+      }
+      // Sentinel survived: merge-style, cannot be resolved to a standalone value.
+      if (typeof value === 'object' && value !== null && MERGE_PROBE_KEY in value) {
+        return null;
+      }
+      try {
+        JSON.stringify(value);
+      } catch {
+        return null;
+      }
+      return {
+        ...base(payload),
+        data: {
+          contextKey: data.contextKey,
+          value
+        }
+      };
+    },
+    deserialize: serialized => {
+      var _serialized$source;
+      const data = serialized.data;
+      if (!data) {
+        return null;
+      }
+      const rebuilt = {
+        contextKey: data.contextKey,
+        setContext: () => data.value
+      };
+      return toPayload({
+        type: 'set-message-context',
+        source: (_serialized$source = serialized.source) !== null && _serialized$source !== void 0 ? _serialized$source : BRIDGE_SOURCE,
+        product: serialized.product,
+        openChat: serialized.openChat,
+        data: rebuilt
+      });
+    }
+  }
+};
+const getShim = type => SHIMS[type];
+
+/** Serialise a payload for the wire, using a shim if one exists, else a generic JSON round-trip. */
+export const serializePayload = payload => {
+  const shim = getShim(payload.type);
+  if (shim) {
+    return shim.serialize(payload);
+  }
+  const rawData = payload.data;
+  let data;
+  try {
+    data = rawData === undefined ? undefined : JSON.parse(JSON.stringify(rawData));
+  } catch {
+    return null;
+  }
+  return {
+    ...base(payload),
+    data
+  };
+};
+
+/** Reconstruct a payload from the wire, stamping the loop-guard sentinel. */
+export const deserializePayload = serialized => {
+  var _serialized$source2;
+  const shim = getShim(serialized.type);
+  if (shim) {
+    return shim.deserialize(serialized);
+  }
+  return toPayload({
+    type: serialized.type,
+    source: (_serialized$source2 = serialized.source) !== null && _serialized$source2 !== void 0 ? _serialized$source2 : BRIDGE_SOURCE,
+    product: serialized.product,
+    openChat: serialized.openChat,
+    data: serialized.data
+  });
+};

package/dist/es2019/common/utils/extension-context-bridge/transport.js

@@ -0,0 +1,35 @@
+import { bind } from 'bind-event-listener';
+import { BRIDGE_MESSAGE_MARKER } from './constants';
+
+/**
+ * A `rovo-triggers` payload reduced to a structured-clone-safe shape. Functions (e.g.
+ * `set-message-context`'s `setContext`) are resolved to values by `./registry` first.
+ */
+
+/**
+ * Transport abstraction so Host/Client work over any carrier: same-window `postMessage` on the
+ * product side, iframe/side-panel `postMessage` in the chat iframe. Carries `BridgeMessage` only;
+ * `rovo-content-bridge-api` commands travel separately, relayed verbatim by the extension.
+ */
+
+export const isBridgeMessage = value => typeof value === 'object' && value !== null && value[BRIDGE_MESSAGE_MARKER] === true && typeof value.direction === 'string' && typeof value.payload === 'object' && value.payload !== null;
+
+/** `postMessage`-based transport. Callers override `targetWindow`/`self` for the iframe side. */
+export const createWindowTransport = ({
+  targetWindow,
+  self: selfWindow = window,
+  targetOrigin = selfWindow.location.origin
+}) => ({
+  send: message => {
+    targetWindow.postMessage(message, targetOrigin);
+  },
+  // `bind` returns its own unbind function, which is exactly the `subscribe` contract.
+  subscribe: handler => bind(selfWindow, {
+    type: 'message',
+    listener: event => {
+      if (isBridgeMessage(event.data)) {
+        handler(event.data);
+      }
+    }
+  })
+});

package/dist/esm/common/utils/extension-context-bridge/ExtensionContextBridgeClient.js

@@ -0,0 +1,124 @@
+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; }
+import { useEffect, useMemo, useRef } from 'react';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { usePublish, useSubscribeAll } from '../../../main';
+import { BRIDGE_MESSAGE_MARKER, BRIDGE_SOURCE, BRIDGE_TO_EXTENSION, BRIDGE_TO_PRODUCT } from './constants';
+import { shouldRelayToProduct } from './policy';
+import { deserializePayload, serializePayload } from './registry';
+import { createWindowTransport } from './transport';
+
+/** Selection shape preserved across editor focus loss. */
+
+/**
+ * Whether focus currently sits inside the chat. Confluence clears `selection` on
+ * `editor-context-payload` both when the user clicks into chat and when they genuinely deselect;
+ * this distinguishes the two so the former can preserve the selection and the latter can drop it.
+ */
+var isChatFocused = function isChatFocused() {
+  // eslint-disable-next-line @atlaskit/platform/no-direct-document-usage -- reading focus of the chat iframe's own document is the point
+  return typeof document !== 'undefined' && document.hasFocus();
+};
+
+/**
+ * Chat-iframe half of the bridge.
+ * - Inbound: deserializes context from the extension transport and re-publishes it onto the
+ *   iframe's own `ai-mate` bus for the existing `ChatContextSubscriber` to consume unchanged.
+ * - Outbound: forwards allowlisted action payloads (e.g. `editor-suggestion`) back to the product,
+ *   via the extension's content script.
+ *
+ * Content writes (`rovo-content-bridge-api` commands) are not handled here — that API already
+ * crosses this boundary on its own, so the extension only relays envelopes for it.
+ *
+ * Headless.
+ */
+export var ExtensionContextBridgeClient = function ExtensionContextBridgeClient(_ref) {
+  var transport = _ref.transport;
+  // Self-gated. Matches `BRIDGE_FEATURE_GATE` in `./constants`.
+  var active = fg('rovo-ext_context_bridge');
+  var publish = usePublish('ai-mate');
+  var lastKnownSelectionRef = useRef(null);
+  var activeTransport = useMemo(function () {
+    if (!active) {
+      return undefined;
+    }
+    if (transport) {
+      return transport;
+    }
+    if (typeof window === 'undefined') {
+      return undefined;
+    }
+    // `targetOrigin: '*'`: the receiving window (the side panel) is a different origin, so the
+    // default (`selfWindow.location.origin`) would not match.
+    return createWindowTransport({
+      targetWindow: window.parent,
+      self: window,
+      targetOrigin: '*'
+    });
+  }, [active, transport]);
+
+  // Inbound (READ): product context -> iframe bus.
+  useEffect(function () {
+    if (!activeTransport) {
+      return;
+    }
+    return activeTransport.subscribe(function (message) {
+      if (message.direction !== BRIDGE_TO_EXTENSION) {
+        return;
+      }
+      var payloadToPublish = deserializePayload(message.payload);
+      if (!payloadToPublish) {
+        return;
+      }
+      var editorData = message.payload.data;
+      if (message.payload.type === 'editor-context-payload') {
+        var _editorData$selection;
+        if (!(editorData !== null && editorData !== void 0 && editorData.document) || editorData !== null && editorData !== void 0 && editorData.isViewMode) {
+          // Editor closed or switched to view mode.
+          lastKnownSelectionRef.current = null;
+        } else if ((_editorData$selection = editorData.selection) !== null && _editorData$selection !== void 0 && _editorData$selection.content) {
+          // New selection.
+          lastKnownSelectionRef.current = editorData.selection;
+        } else if (lastKnownSelectionRef.current && isChatFocused()) {
+          // Focus moved into the chat; re-inject the selection so Insert/Replace still resolves.
+          payloadToPublish = deserializePayload(_objectSpread(_objectSpread({}, message.payload), {}, {
+            data: _objectSpread(_objectSpread({}, editorData), {}, {
+              selection: lastKnownSelectionRef.current
+            })
+          }));
+        } else {
+          // Real deselection; drop it so context falls back to the page.
+          lastKnownSelectionRef.current = null;
+        }
+      }
+      if (payloadToPublish) {
+        publish(payloadToPublish);
+      }
+    });
+  }, [activeTransport, publish]);
+
+  // Outbound (WRITE, payloads): allowlisted chat actions -> product.
+  useSubscribeAll(function (payload) {
+    if (!activeTransport) {
+      return;
+    }
+    // Loop guard.
+    if (payload.interactionSource === BRIDGE_SOURCE) {
+      return;
+    }
+    if (!shouldRelayToProduct(payload.type)) {
+      return;
+    }
+    var serialized = serializePayload(payload);
+    if (!serialized) {
+      return;
+    }
+    try {
+      activeTransport.send(_defineProperty(_defineProperty(_defineProperty({}, BRIDGE_MESSAGE_MARKER, true), "direction", BRIDGE_TO_PRODUCT), "payload", serialized));
+    } catch (_unused) {
+      // Never let bridging break the chat iframe.
+    }
+  });
+  return null;
+};

package/dist/esm/common/utils/extension-context-bridge/ExtensionContextBridgeHost.js

@@ -0,0 +1,78 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { useMemo } from 'react';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { useSubscribeAll } from '../../../main';
+import { BRIDGE_MESSAGE_MARKER, BRIDGE_SOURCE, BRIDGE_TO_EXTENSION } from './constants';
+import { getInboundDecision } from './policy';
+import { serializePayload } from './registry';
+import { createWindowTransport } from './transport';
+/**
+ * Stamps the page id onto `editor-context-payload` when the product left it unpopulated, since the
+ * extension chat cannot derive its own `contentId` from `window.location` (that's the side panel, not
+ * the page). `getContentId` is supplied by the consumer rather than read here, to avoid this package
+ * taking a dependency on `conversation-assistant-store` (a cyclic-dependency risk); the consumer
+ * already depends on that store and can resolve the id from it directly.
+ */
+var stampProductContentId = function stampProductContentId(serialized, targetContentId) {
+  if (serialized.type !== 'editor-context-payload') {
+    return;
+  }
+  var data = serialized.data;
+  if (!data || data.contentMauiId) {
+    return;
+  }
+  if (targetContentId) {
+    data.contentMauiId = targetContentId;
+  }
+};
+/**
+ * Product-window half of the bridge. Observes the `ai-mate` bus and mirrors allowlisted context out
+ * to the extension via same-window `postMessage` (see `./policy` for the allow/deny rules).
+ *
+ * The reverse direction is handled by the sibling `RovoPostMessagePubsubListener` in
+ * `ChatOpenerSubscriber`, not here. Headless; mounts at product root via `ChatOpenerSubscriber`.
+ */
+export var ExtensionContextBridgeHost = function ExtensionContextBridgeHost(_ref) {
+  var transport = _ref.transport,
+    getContentId = _ref.getContentId;
+  // Self-gated (not taken from the consumer) so this cannot mount by mistake wherever
+  // `ChatOpenerSubscriber` renders. Matches `BRIDGE_FEATURE_GATE` in `./constants`.
+  var active = fg('rovo-ext_context_bridge');
+  var activeTransport = useMemo(function () {
+    if (!active) {
+      return undefined;
+    }
+    if (transport) {
+      return transport;
+    }
+    if (typeof window === 'undefined') {
+      return undefined;
+    }
+    return createWindowTransport({
+      targetWindow: window
+    });
+  }, [active, transport]);
+  useSubscribeAll(function (payload) {
+    if (!activeTransport) {
+      return;
+    }
+    // Loop guard.
+    if (payload.interactionSource === BRIDGE_SOURCE) {
+      return;
+    }
+    if (getInboundDecision(payload.type) !== 'allow') {
+      return;
+    }
+    var serialized = serializePayload(payload);
+    if (!serialized) {
+      return;
+    }
+    stampProductContentId(serialized, getContentId === null || getContentId === void 0 ? void 0 : getContentId());
+    try {
+      activeTransport.send(_defineProperty(_defineProperty(_defineProperty({}, BRIDGE_MESSAGE_MARKER, true), "direction", BRIDGE_TO_EXTENSION), "payload", serialized));
+    } catch (_unused) {
+      // Never let bridging break the host page.
+    }
+  });
+  return null;
+};

package/dist/esm/common/utils/extension-context-bridge/constants.js

@@ -0,0 +1,16 @@
+/**
+ * Feature gate for the extension context bridge; both Host and Client self-gate on it.
+ * `fg()` requires a static literal, so call sites inline this value rather than importing it;
+ * tests resolve the gate through this constant so the two cannot drift apart.
+ */
+export var BRIDGE_FEATURE_GATE = 'rovo-ext_context_bridge';
+
+/** Marker on every bridge `postMessage`, so listeners can ignore unrelated messages. */
+export var BRIDGE_MESSAGE_MARKER = '__rovoExtContextBridge';
+
+/** Read context flows product -> extension; actions flow extension -> product. */
+export var BRIDGE_TO_EXTENSION = 'to-extension';
+export var BRIDGE_TO_PRODUCT = 'to-product';
+
+/** Loop-guard sentinel stamped on re-published payloads so they never ping-pong. */
+export var BRIDGE_SOURCE = 'rovo-extension-bridge';

package/dist/esm/common/utils/extension-context-bridge/policy.js

@@ -0,0 +1,34 @@
+/**
+ * Bridge relay policy, asymmetric by direction:
+ * - Product → extension (context): relayed iff allowlisted and not denylisted. The denylist is a
+ *   backstop for control-plane/auth events that must never cross.
+ * - Extension → product (actions): allowlist only, so the chat's internal state never drives the
+ *   product.
+ *
+ * Independent of both lists: the loop guard (`BRIDGE_SOURCE`) and auto-drop of non-serialisable
+ * payloads.
+ */
+
+/** Inbound allowlist — payload types the bridge supports. Widen only as a feature needs it. */
+var INBOUND_ALLOWLIST = new Set(['editor-context-payload', 'set-message-context']);
+
+/** Inbound denylist — control-plane/auth events that must never reach the extension chat. */
+var INBOUND_DENYLIST = new Set(['message-send', 'chat-new', 'chat-open', 'chat-close', 'open-smart-creation-modal', 'open-browse-agent-modal', 'open-browse-agent-sidebar', 'open-chat-debug-modal', 'open-chat-feedback-modal', 'forge-auth-success', 'forge-auth-failure', 'chat-smartlink-3p-post-auth-launch']);
+
+/** Outbound allowlist — chat-originated events allowed to cross back to the product. */
+var OUTBOUND_ACTIONS = new Set(['editor-suggestion']);
+
+/** Why a product-bus payload was or was not relayed. */
+
+/** Classify a product-bus payload. Relay iff `allow`. */
+export var getInboundDecision = function getInboundDecision(type) {
+  if (INBOUND_DENYLIST.has(type)) {
+    return 'denylisted';
+  }
+  return INBOUND_ALLOWLIST.has(type) ? 'allow' : 'not-allowlisted';
+};
+
+/** True if a chat-bus payload of this type may be relayed back to the product. */
+export var shouldRelayToProduct = function shouldRelayToProduct(type) {
+  return OUTBOUND_ACTIONS.has(type);
+};

package/dist/esm/common/utils/extension-context-bridge/registry.js

@@ -0,0 +1,127 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+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; }
+import { BRIDGE_SOURCE } from './constants';
+var base = function base(payload) {
+  return {
+    type: payload.type,
+    source: payload.source,
+    product: payload.product,
+    openChat: payload.openChat
+  };
+};
+
+/**
+ * Boundary cast: the `Payload` union cannot be expressed structurally at this seam.
+ * Always stamps the loop-guard sentinel so the mirroring side skips it.
+ */
+var toPayload = function toPayload(value) {
+  return (// eslint-disable-next-line @atlaskit/platform/no-double-type-assertions -- serialization boundary reconstruction
+    _objectSpread(_objectSpread({}, value), {}, {
+      interactionSource: BRIDGE_SOURCE
+    })
+  );
+};
+
+/**
+ * Per-type overrides for payloads carrying non-cloneable data (functions). Anything not listed
+ * uses the generic JSON (de)serializer.
+ */
+
+/** Sentinel used to detect merge-style `setContext` implementations. */
+var MERGE_PROBE_KEY = '__rovoExtBridgeMergeProbe__';
+var SHIMS = {
+  /**
+   * `set-message-context` carries a `setContext` function, which cannot be structured-cloned.
+   * Resolves REPLACE-style publishers (return a fixed value) to their value and rebuilds a
+   * trivial `setContext` on the far side; merge-style publishers are dropped (detected via a
+   * probe object, since a throw-based check would silently ship a truncated context).
+   */
+  'set-message-context': {
+    serialize: function serialize(payload) {
+      var data = payload.data;
+      if (!data || typeof data.setContext !== 'function') {
+        return null;
+      }
+      var value;
+      try {
+        value = data.setContext(_defineProperty({}, MERGE_PROBE_KEY, true));
+      } catch (_unused) {
+        return null;
+      }
+      // Sentinel survived: merge-style, cannot be resolved to a standalone value.
+      if (_typeof(value) === 'object' && value !== null && MERGE_PROBE_KEY in value) {
+        return null;
+      }
+      try {
+        JSON.stringify(value);
+      } catch (_unused2) {
+        return null;
+      }
+      return _objectSpread(_objectSpread({}, base(payload)), {}, {
+        data: {
+          contextKey: data.contextKey,
+          value: value
+        }
+      });
+    },
+    deserialize: function deserialize(serialized) {
+      var _serialized$source;
+      var data = serialized.data;
+      if (!data) {
+        return null;
+      }
+      var rebuilt = {
+        contextKey: data.contextKey,
+        setContext: function setContext() {
+          return data.value;
+        }
+      };
+      return toPayload({
+        type: 'set-message-context',
+        source: (_serialized$source = serialized.source) !== null && _serialized$source !== void 0 ? _serialized$source : BRIDGE_SOURCE,
+        product: serialized.product,
+        openChat: serialized.openChat,
+        data: rebuilt
+      });
+    }
+  }
+};
+var getShim = function getShim(type) {
+  return SHIMS[type];
+};
+
+/** Serialise a payload for the wire, using a shim if one exists, else a generic JSON round-trip. */
+export var serializePayload = function serializePayload(payload) {
+  var shim = getShim(payload.type);
+  if (shim) {
+    return shim.serialize(payload);
+  }
+  var rawData = payload.data;
+  var data;
+  try {
+    data = rawData === undefined ? undefined : JSON.parse(JSON.stringify(rawData));
+  } catch (_unused3) {
+    return null;
+  }
+  return _objectSpread(_objectSpread({}, base(payload)), {}, {
+    data: data
+  });
+};
+
+/** Reconstruct a payload from the wire, stamping the loop-guard sentinel. */
+export var deserializePayload = function deserializePayload(serialized) {
+  var _serialized$source2;
+  var shim = getShim(serialized.type);
+  if (shim) {
+    return shim.deserialize(serialized);
+  }
+  return toPayload({
+    type: serialized.type,
+    source: (_serialized$source2 = serialized.source) !== null && _serialized$source2 !== void 0 ? _serialized$source2 : BRIDGE_SOURCE,
+    product: serialized.product,
+    openChat: serialized.openChat,
+    data: serialized.data
+  });
+};