@atlaskit/rovo-triggers 10.13.1 → 10.15.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/rovo-triggers
 
+## 10.15.0
+
+### Minor Changes
+
+- [`40d6282bf3989`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/40d6282bf3989) -
+  Add the extension-context-bridge module (constants, transport, policy, registry, Host/Client
+  components) with four new subpath exports. Both the Host and the Client are gated behind the
+  `rovo-ext_context_bridge` feature gate and stay inert until it is enabled.
+
+## 10.14.0
+
+### Minor Changes
+
+- [`eb4b573d4260f`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/eb4b573d4260f) -
+  HIX-9934: Jira workflow builder edit status: Implement analytic events
+
 ## 10.13.1
 
 ### Patch Changes

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

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExtensionContextBridgeClient = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = require("react");
+var _fg = require("@atlaskit/platform-feature-flags/fg");
+var _main = require("../../../main");
+var _constants = require("./constants");
+var _policy = require("./policy");
+var _registry = require("./registry");
+var _transport = require("./transport");
+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; }
+/** 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.
+ */
+var ExtensionContextBridgeClient = exports.ExtensionContextBridgeClient = function ExtensionContextBridgeClient(_ref) {
+  var transport = _ref.transport;
+  // Self-gated. Matches `BRIDGE_FEATURE_GATE` in `./constants`.
+  var active = (0, _fg.fg)('rovo-ext_context_bridge');
+  var publish = (0, _main.usePublish)('ai-mate');
+  var lastKnownSelectionRef = (0, _react.useRef)(null);
+  var activeTransport = (0, _react.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 (0, _transport.createWindowTransport)({
+      targetWindow: window.parent,
+      self: window,
+      targetOrigin: '*'
+    });
+  }, [active, transport]);
+
+  // Inbound (READ): product context -> iframe bus.
+  (0, _react.useEffect)(function () {
+    if (!activeTransport) {
+      return;
+    }
+    return activeTransport.subscribe(function (message) {
+      if (message.direction !== _constants.BRIDGE_TO_EXTENSION) {
+        return;
+      }
+      var payloadToPublish = (0, _registry.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 = (0, _registry.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.
+  (0, _main.useSubscribeAll)(function (payload) {
+    if (!activeTransport) {
+      return;
+    }
+    // Loop guard.
+    if (payload.interactionSource === _constants.BRIDGE_SOURCE) {
+      return;
+    }
+    if (!(0, _policy.shouldRelayToProduct)(payload.type)) {
+      return;
+    }
+    var serialized = (0, _registry.serializePayload)(payload);
+    if (!serialized) {
+      return;
+    }
+    try {
+      activeTransport.send((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.BRIDGE_MESSAGE_MARKER, true), "direction", _constants.BRIDGE_TO_PRODUCT), "payload", serialized));
+    } catch (_unused) {
+      // Never let bridging break the chat iframe.
+    }
+  });
+  return null;
+};

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

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExtensionContextBridgeHost = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = require("react");
+var _fg = require("@atlaskit/platform-feature-flags/fg");
+var _main = require("../../../main");
+var _constants = require("./constants");
+var _policy = require("./policy");
+var _registry = require("./registry");
+var _transport = require("./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`.
+ */
+var ExtensionContextBridgeHost = exports.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 = (0, _fg.fg)('rovo-ext_context_bridge');
+  var activeTransport = (0, _react.useMemo)(function () {
+    if (!active) {
+      return undefined;
+    }
+    if (transport) {
+      return transport;
+    }
+    if (typeof window === 'undefined') {
+      return undefined;
+    }
+    return (0, _transport.createWindowTransport)({
+      targetWindow: window
+    });
+  }, [active, transport]);
+  (0, _main.useSubscribeAll)(function (payload) {
+    if (!activeTransport) {
+      return;
+    }
+    // Loop guard.
+    if (payload.interactionSource === _constants.BRIDGE_SOURCE) {
+      return;
+    }
+    if ((0, _policy.getInboundDecision)(payload.type) !== 'allow') {
+      return;
+    }
+    var serialized = (0, _registry.serializePayload)(payload);
+    if (!serialized) {
+      return;
+    }
+    stampProductContentId(serialized, getContentId === null || getContentId === void 0 ? void 0 : getContentId());
+    try {
+      activeTransport.send((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.BRIDGE_MESSAGE_MARKER, true), "direction", _constants.BRIDGE_TO_EXTENSION), "payload", serialized));
+    } catch (_unused) {
+      // Never let bridging break the host page.
+    }
+  });
+  return null;
+};

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

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BRIDGE_TO_PRODUCT = exports.BRIDGE_TO_EXTENSION = exports.BRIDGE_SOURCE = exports.BRIDGE_MESSAGE_MARKER = exports.BRIDGE_FEATURE_GATE = void 0;
+/**
+ * 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.
+ */
+var BRIDGE_FEATURE_GATE = exports.BRIDGE_FEATURE_GATE = 'rovo-ext_context_bridge';
+
+/** Marker on every bridge `postMessage`, so listeners can ignore unrelated messages. */
+var BRIDGE_MESSAGE_MARKER = exports.BRIDGE_MESSAGE_MARKER = '__rovoExtContextBridge';
+
+/** Read context flows product -> extension; actions flow extension -> product. */
+var BRIDGE_TO_EXTENSION = exports.BRIDGE_TO_EXTENSION = 'to-extension';
+var BRIDGE_TO_PRODUCT = exports.BRIDGE_TO_PRODUCT = 'to-product';
+
+/** Loop-guard sentinel stamped on re-published payloads so they never ping-pong. */
+var BRIDGE_SOURCE = exports.BRIDGE_SOURCE = 'rovo-extension-bridge';

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldRelayToProduct = exports.getInboundDecision = void 0;
+/**
+ * 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`. */
+var getInboundDecision = exports.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. */
+var shouldRelayToProduct = exports.shouldRelayToProduct = function shouldRelayToProduct(type) {
+  return OUTBOUND_ACTIONS.has(type);
+};

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

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializePayload = exports.deserializePayload = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("./constants");
+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 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: _constants.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((0, _defineProperty2.default)({}, MERGE_PROBE_KEY, true));
+      } catch (_unused) {
+        return null;
+      }
+      // Sentinel survived: merge-style, cannot be resolved to a standalone value.
+      if ((0, _typeof2.default)(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 : _constants.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. */
+var serializePayload = exports.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. */
+var deserializePayload = exports.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 : _constants.BRIDGE_SOURCE,
+    product: serialized.product,
+    openChat: serialized.openChat,
+    data: serialized.data
+  });
+};

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

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBridgeMessage = exports.createWindowTransport = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _bindEventListener = require("bind-event-listener");
+var _constants = require("./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.
+ */
+
+var isBridgeMessage = exports.isBridgeMessage = function isBridgeMessage(value) {
+  return (0, _typeof2.default)(value) === 'object' && value !== null && value[_constants.BRIDGE_MESSAGE_MARKER] === true && typeof value.direction === 'string' && (0, _typeof2.default)(value.payload) === 'object' && value.payload !== null;
+};
+
+/** `postMessage`-based transport. Callers override `targetWindow`/`self` for the iframe side. */
+var createWindowTransport = exports.createWindowTransport = function createWindowTransport(_ref) {
+  var targetWindow = _ref.targetWindow,
+    _ref$self = _ref.self,
+    selfWindow = _ref$self === void 0 ? window : _ref$self,
+    _ref$targetOrigin = _ref.targetOrigin,
+    targetOrigin = _ref$targetOrigin === void 0 ? selfWindow.location.origin : _ref$targetOrigin;
+  return {
+    send: function send(message) {
+      targetWindow.postMessage(message, targetOrigin);
+    },
+    // `bind` returns its own unbind function, which is exactly the `subscribe` contract.
+    subscribe: function subscribe(handler) {
+      return (0, _bindEventListener.bind)(selfWindow, {
+        type: 'message',
+        listener: function listener(event) {
+          if (isBridgeMessage(event.data)) {
+            handler(event.data);
+          }
+        }
+      });
+    }
+  };
+};

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

@@ -0,0 +1,128 @@
+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.
+ */
+const 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 const ExtensionContextBridgeClient = ({
+  transport
+}) => {
+  // Self-gated. Matches `BRIDGE_FEATURE_GATE` in `./constants`.
+  const active = fg('rovo-ext_context_bridge');
+  const publish = usePublish('ai-mate');
+  const lastKnownSelectionRef = useRef(null);
+  const activeTransport = useMemo(() => {
+    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(() => {
+    if (!activeTransport) {
+      return;
+    }
+    return activeTransport.subscribe(message => {
+      if (message.direction !== BRIDGE_TO_EXTENSION) {
+        return;
+      }
+      let payloadToPublish = deserializePayload(message.payload);
+      if (!payloadToPublish) {
+        return;
+      }
+      const 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({
+            ...message.payload,
+            data: {
+              ...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(payload => {
+    if (!activeTransport) {
+      return;
+    }
+    // Loop guard.
+    if (payload.interactionSource === BRIDGE_SOURCE) {
+      return;
+    }
+    if (!shouldRelayToProduct(payload.type)) {
+      return;
+    }
+    const serialized = serializePayload(payload);
+    if (!serialized) {
+      return;
+    }
+    try {
+      activeTransport.send({
+        [BRIDGE_MESSAGE_MARKER]: true,
+        direction: BRIDGE_TO_PRODUCT,
+        payload: serialized
+      });
+    } catch {
+      // Never let bridging break the chat iframe.
+    }
+  });
+  return null;
+};