@atlaskit/smart-card 44.24.2 → 44.25.0

package/dist/esm/state/actions/index.js

@@ -100,6 +100,8 @@ export var useSmartCardActions = function useSmartCardActions(id, url) {
       url: url
     }, undefined, undefined, metadataStatus));
   }, [dispatch, url]);
+
+  // Original resolve function — signature kept intact for maximum safety when FG is off.
   var resolve = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
     var resourceUrl,
       isReloading,
@@ -111,45 +113,131 @@ export var useSmartCardActions = function useSmartCardActions(id, url) {
           resourceUrl = _args.length > 0 && _args[0] !== undefined ? _args[0] : url;
           isReloading = _args.length > 1 && _args[1] !== undefined ? _args[1] : false;
           isMetadataRequest = _args.length > 2 && _args[2] !== undefined ? _args[2] : false;
-          return _context.abrupt("return", resolveUrl(resourceUrl, isReloading, isMetadataRequest, id));
+          return _context.abrupt("return", resolveUrl({
+            url: resourceUrl,
+            isReloading: isReloading,
+            isMetadataRequest: isMetadataRequest,
+            id: id
+          }));
         case 1:
         case "end":
           return _context.stop();
       }
     }, _callee);
   })), [id, resolveUrl, url]);
-  var register = useCallback(function () {
+
+  // New resolve function accepting ResolveUrlParams (minus 'id' which is closed over).
+  // Used when FG is enabled to pass appearance to ORS.
+  var resolveNew = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var params,
+      _params$url,
+      resourceUrl,
+      _params$isReloading,
+      isReloading,
+      _params$isMetadataReq,
+      isMetadataRequest,
+      appearance,
+      _args2 = arguments;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          params = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : {};
+          _params$url = params.url, resourceUrl = _params$url === void 0 ? url : _params$url, _params$isReloading = params.isReloading, isReloading = _params$isReloading === void 0 ? false : _params$isReloading, _params$isMetadataReq = params.isMetadataRequest, isMetadataRequest = _params$isMetadataReq === void 0 ? false : _params$isMetadataReq, appearance = params.appearance;
+          return _context2.abrupt("return", resolveUrl({
+            url: resourceUrl,
+            isReloading: isReloading,
+            isMetadataRequest: isMetadataRequest,
+            id: id,
+            appearance: appearance
+          }));
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })), [id, resolveUrl, url]);
+
+  /**
+   * Register a smart link for resolution.
+   * @param appearance - Card appearance hint for ORS to optimize response payload.
+   *                     When 'inline', ORS returns minimal data (title, status).
+   *                     When 'block' or 'embed', ORS returns full data including summary.
+   */
+  var register = useCallback(function (appearance) {
     var _getSmartLinkState = getSmartLinkState(),
       details = _getSmartLinkState.details;
     if (!details) {
       dispatch(cardAction(ACTION_RESOLVING, {
         url: url
       }));
+      // Always set metadataStatus to 'pending' during registration to prevent
+      // loadMetadata from firing a duplicate concurrent fetch if a hover card
+      // mounts while registration is in-flight. This matches pre-PR behaviour.
       setMetadataStatus('pending');
     }
-    return resolve();
-  }, [getSmartLinkState, resolve, dispatch, url, setMetadataStatus]);
-  var reload = useCallback(function () {
+    if (fg('platform_smartlink_inline_resolve_optimization')) {
+      return resolveNew({
+        url: url,
+        appearance: appearance
+      });
+    }
+    return resolve(url);
+  }, [getSmartLinkState, resolve, resolveNew, dispatch, url, setMetadataStatus]);
+  var reload = useCallback(function (appearance) {
     var _getSmartLinkState2 = getSmartLinkState(),
       details = _getSmartLinkState2.details;
     var definitionId = getDefinitionId(details);
-    if (definitionId) {
-      getByDefinitionId(definitionId, getState()).map(function (url) {
-        return resolve(url, true);
-      });
+    if (fg('platform_smartlink_inline_resolve_optimization')) {
+      if (definitionId) {
+        getByDefinitionId(definitionId, getState()).map(function (reloadUrl) {
+          return resolveNew({
+            url: reloadUrl,
+            isReloading: true,
+            appearance: appearance
+          });
+        });
+      } else {
+        resolveNew({
+          url: url,
+          isReloading: true,
+          appearance: appearance
+        });
+      }
     } else {
-      resolve(url, true);
+      if (definitionId) {
+        getByDefinitionId(definitionId, getState()).map(function (reloadUrl) {
+          return resolve(reloadUrl, true);
+        });
+      } else {
+        resolve(url, true);
+      }
     }
-  }, [getSmartLinkState, url, getState, resolve]);
+  }, [getSmartLinkState, url, getState, resolve, resolveNew]);
+
+  /**
+   * Load metadata for hover card preview.
+   * This always requests 'block' appearance to get full data including summary.
+   *
+   * Inline optimized and SSR-resolved links keep metadataStatus pending until hover
+   * requests the full block response.
+   */
   var loadMetadata = useCallback(function () {
     var _getSmartLinkState3 = getSmartLinkState(),
       metadataStatus = _getSmartLinkState3.metadataStatus;
-    //metadataStatus will be undefined for SSR links only
-    if (metadataStatus === undefined) {
+    var needsBlockData = metadataStatus === undefined || metadataStatus === 'pending' && fg('platform_smartlink_inline_resolve_optimization');
+    if (needsBlockData) {
       setMetadataStatus('pending');
+      if (fg('platform_smartlink_inline_resolve_optimization')) {
+        // Always request 'block' appearance for hover card metadata to get full data
+        return resolveNew({
+          url: url,
+          isMetadataRequest: true,
+          appearance: 'block'
+        });
+      }
       return resolve(url, false, true);
     }
-  }, [getSmartLinkState, resolve, setMetadataStatus, url]);
+  }, [getSmartLinkState, resolve, resolveNew, setMetadataStatus, url]);
   var authorize = useCallback(function (appearance) {
     var _getSmartLinkState4 = getSmartLinkState(),
       details = _getSmartLinkState4.details,
@@ -230,18 +318,18 @@ export var useSmartCardActions = function useSmartCardActions(id, url) {
     }
   }, [getSmartLinkState, id, reload, fireEvent, flags, url]);
   var invoke = useCallback( /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(opts, appearance) {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(opts, appearance) {
       var key, action, source;
-      return _regeneratorRuntime.wrap(function (_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
           case 0:
             key = opts.key, action = opts.action;
             source = opts.source || appearance;
             if (!(opts.type === 'client')) {
-              _context2.next = 2;
+              _context3.next = 2;
               break;
             }
-            _context2.next = 1;
+            _context3.next = 1;
             return invokeClientAction({
               actionFn: opts.action.promise,
               actionType: action.type,
@@ -249,15 +337,15 @@ export var useSmartCardActions = function useSmartCardActions(id, url) {
               extensionKey: key
             });
           case 1:
-            return _context2.abrupt("return", _context2.sent);
+            return _context3.abrupt("return", _context3.sent);
           case 2:
           case "end":
-            return _context2.stop();
+            return _context3.stop();
         }
-      }, _callee2);
+      }, _callee3);
     }));
     return function (_x, _x2) {
-      return _ref3.apply(this, arguments);
+      return _ref4.apply(this, arguments);
     };
   }(), [invokeClientAction]);
   return useMemo(function () {

package/dist/esm/state/hooks/use-resolve/index.js

@@ -3,6 +3,7 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { useCallback } from 'react';
 import { isEntityPresent } from '@atlaskit/link-extractors';
 import { useSmartLinkContext } from '@atlaskit/link-provider';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { SmartLinkStatus } from '../../../constants';
 import { addMetadataToExperience } from '../../analytics';
 import useResponse from '../use-response';
@@ -19,20 +20,12 @@ var useResolve = function useResolve() {
     handleResolvedLinkResponse = _useResponse.handleResolvedLinkResponse,
     handleResolvedLinkError = _useResponse.handleResolvedLinkError;
   return useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
-      var isReloading,
-        isMetadataRequest,
-        id,
-        _ref2,
-        details,
-        hasData,
-        _args = arguments;
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(params) {
+      var url, _params$isReloading, isReloading, _params$isMetadataReq, isMetadataRequest, _params$id, id, appearance, _ref2, details, hasData, metadataStatus;
       return _regeneratorRuntime.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            isReloading = _args.length > 1 && _args[1] !== undefined ? _args[1] : false;
-            isMetadataRequest = _args.length > 2 && _args[2] !== undefined ? _args[2] : false;
-            id = _args.length > 3 && _args[3] !== undefined ? _args[3] : '';
+            url = params.url, _params$isReloading = params.isReloading, isReloading = _params$isReloading === void 0 ? false : _params$isReloading, _params$isMetadataReq = params.isMetadataRequest, isMetadataRequest = _params$isMetadataReq === void 0 ? false : _params$isMetadataReq, _params$id = params.id, id = _params$id === void 0 ? '' : _params$id, appearance = params.appearance;
             _ref2 = getState()[url] || {
               status: SmartLinkStatus.Pending,
               details: undefined
@@ -42,8 +35,9 @@ var useResolve = function useResolve() {
               _context.next = 1;
               break;
             }
-            return _context.abrupt("return", connections.client.fetchData(url, isReloading).then(function (response) {
-              return handleResolvedLinkResponse(url, response, isReloading, isMetadataRequest);
+            metadataStatus = appearance === 'inline' && !isMetadataRequest && fg('platform_smartlink_inline_resolve_optimization') ? 'pending' : undefined;
+            return _context.abrupt("return", connections.client.fetchData(url, isReloading, appearance).then(function (response) {
+              return handleResolvedLinkResponse(url, response, isReloading, isMetadataRequest, metadataStatus);
             }).catch(function (error) {
               return handleResolvedLinkError(url, error, undefined, isMetadataRequest);
             }));

package/dist/esm/state/hooks/use-response/index.js

@@ -2,6 +2,7 @@ import { useCallback, useMemo } from 'react';
 import { unstable_batchedUpdates } from 'react-dom';
 import { useSmartLinkContext } from '@atlaskit/link-provider';
 import { ACTION_ERROR, ACTION_ERROR_FALLBACK, ACTION_RELOADING, ACTION_RESOLVED, ACTION_UPDATE_METADATA_STATUS, APIError, cardAction, getStatus } from '@atlaskit/linking-common';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { SmartLinkStatus } from '../../../constants';
 import { getUnauthorizedJsonLd } from '../../../utils/jsonld';
 import { ERROR_MESSAGE_FATAL, ERROR_MESSAGE_METADATA, ERROR_MESSAGE_OAUTH } from '../../actions/constants';
@@ -71,8 +72,9 @@ var useResponse = function useResponse() {
     }
   }, [getState, setMetadataStatus, dispatch]);
   var handleResolvedLinkSuccess = useCallback(function (resourceUrl, response, isReloading, isMetadataRequest) {
-    //if a link resolves normally, metadata will also always be resolved
-    setMetadataStatus(resourceUrl, 'resolved');
+    var metadataStatus = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'resolved';
+    // Some optimized resolves intentionally leave metadata pending so hover can fetch it.
+    setMetadataStatus(resourceUrl, fg('platform_smartlink_inline_resolve_optimization') ? metadataStatus : 'resolved');
     // Dispatch Analytics and resolved card action - including unauthorized states.
     if (isReloading) {
       dispatch(cardAction(ACTION_RELOADING, {
@@ -87,6 +89,10 @@ var useResponse = function useResponse() {
   var handleResolvedLinkResponse = useCallback(function (resourceUrl, response) {
     var isReloading = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     var isMetadataRequest = arguments.length > 3 ? arguments[3] : undefined;
+    var metadataStatus = arguments.length > 4 ? arguments[4] : undefined;
+    if (!resourceUrl) {
+      return;
+    }
     var hostname = new URL(resourceUrl).hostname;
     var nextStatus = response ? getStatus(response) : 'fatal';
 
@@ -116,7 +122,7 @@ var useResponse = function useResponse() {
      * https://react-redux.js.org/api/batch
      */
     unstable_batchedUpdates(function () {
-      handleResolvedLinkSuccess(resourceUrl, response, isReloading, isMetadataRequest);
+      handleResolvedLinkSuccess(resourceUrl, response, isReloading, isMetadataRequest, metadataStatus);
     });
   }, [handleResolvedLinkError, handleResolvedLinkSuccess, hasAuthFlowSupported]);
   return useMemo(function () {

package/dist/esm/state/hooks/usePrefetch.js

@@ -3,7 +3,8 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { useCallback } from 'react';
 import { useSmartLinkContext } from '@atlaskit/link-provider';
 import { ACTION_UPDATE_METADATA_STATUS, cardAction } from '@atlaskit/linking-common';
-export function usePrefetch(url) {
+import { fg } from '@atlaskit/platform-feature-flags';
+export function usePrefetch(url, appearance) {
   var _useSmartLinkContext = useSmartLinkContext(),
     store = _useSmartLinkContext.store,
     prefetchStore = _useSmartLinkContext.prefetchStore,
@@ -47,7 +48,7 @@ export function usePrefetch(url) {
           // we create between browser -> ORS when making network requests.
           _context.prev = 2;
           _context.next = 3;
-          return client.prefetchData(url);
+          return client.prefetchData(url, appearance);
         case 3:
           response = _context.sent;
           // Once the data comes back, we put the link in the `resolved` status. This ensures
@@ -59,11 +60,11 @@ export function usePrefetch(url) {
               url: url,
               payload: response
             });
-            // Put the metadata in resolved state, theres no need for a pending or errored state as
-            // we are following the same render flow as described by the comments above and below.
+            // Put the metadata status: 'pending' for inline appearance when FG is on, so HoverCard
+            // can upgrade to full block data. Otherwise 'resolved' preserves existing behaviour.
             dispatch(cardAction(ACTION_UPDATE_METADATA_STATUS, {
               url: url
-            }, undefined, undefined, 'resolved'));
+            }, undefined, undefined, appearance === 'inline' && fg('platform_smartlink_inline_resolve_optimization') ? 'pending' : 'resolved'));
           }
           _context.next = 5;
           break;
@@ -75,5 +76,5 @@ export function usePrefetch(url) {
           return _context.stop();
       }
     }, _callee, null, [[2, 4]]);
-  })), [store, prefetchStore, connections, url, getState, client, dispatch]);
+  })), [store, prefetchStore, connections, url, getState, client, dispatch, appearance]);
 }

package/dist/esm/state/hooks/useSmartLink.js

@@ -1,11 +1,21 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { useEffect, useState } from 'react';
 import { useSmartLinkContext } from '@atlaskit/link-provider';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { useSmartCardActions as useSmartLinkActions } from '../actions';
 import { useSmartLinkConfig } from '../config';
 import { useSmartLinkRenderers } from '../renderers';
 import { useSmartCardState as useSmartLinkState } from '../store';
-export function useSmartLink(id, url) {
+
+/**
+ * Hook for smart link state and actions.
+ * @param id - Unique identifier for the smart link
+ * @param url - The URL to resolve
+ * @param appearance - Card appearance hint for ORS to optimize response payload.
+ *                     When 'inline', ORS returns minimal data (title, status).
+ *                     When 'block' or 'embed', ORS returns full data including summary.
+ */
+export function useSmartLink(id, url, appearance) {
   var state = useSmartLinkState(url);
   var _useSmartLinkContext = useSmartLinkContext(),
     store = _useSmartLinkContext.store,
@@ -20,9 +30,9 @@ export function useSmartLink(id, url) {
     _useState2 = _slicedToArray(_useState, 2),
     error = _useState2[0],
     setError = _useState2[1];
-  // Register the current card.
+  // Register the current card with appearance hint for optimized ORS response.
   var register = function register() {
-    actions.register().catch(function (err) {
+    actions.register(fg('platform_smartlink_inline_resolve_optimization') ? appearance : undefined).catch(function (err) {
       return setError(err);
     });
   };

package/dist/esm/state/hooks-external/useSmartLinkActions.js

@@ -42,7 +42,9 @@ export function useSmartLinkActions(_ref) {
     details: linkState.details
   });
   if (expValEquals('platform_hover_card_preview_panel', 'cohort', 'test') && prefetch && !linkState.details) {
-    resolve(url);
+    resolve({
+      url: url
+    });
   }
   if (linkState.details && !(actionOptions !== null && actionOptions !== void 0 && actionOptions.hide)) {
     var actions = [];

package/dist/esm/utils/analytics/analytics.js

@@ -4,7 +4,7 @@ export var ANALYTICS_CHANNEL = 'media';
 export var context = {
   componentName: 'smart-cards',
   packageName: "@atlaskit/smart-card" || '',
-  packageVersion: "44.24.1" || ''
+  packageVersion: "44.24.2" || ''
 };
 export var TrackQuickActionType = /*#__PURE__*/function (TrackQuickActionType) {
   TrackQuickActionType["StatusUpdate"] = "StatusUpdate";

package/dist/esm/view/CardWithUrl/component-lazy/LazyIntersectionObserverCard.js

@@ -28,7 +28,7 @@ function LazyIntersectionObserverCardOld(props) {
   var appearance = props.appearance,
     url = props.url,
     id = props.id;
-  var prefetch = usePrefetch(url);
+  var prefetch = usePrefetch(url, appearance);
   var Component = appearance === 'inline' ? 'span' : 'div';
   var ComponentObserver = Component;
   var onIntersection = useCallback(function (entries, observer) {

package/dist/esm/view/CardWithUrl/component.js

@@ -1,7 +1,7 @@
 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 React, { useCallback, useEffect, useMemo } from 'react';
+import React, { useCallback, useEffect, useMemo, useRef } from 'react';
 import { useAnalyticsEvents as useAnalyticsEventsNext } from '@atlaskit/analytics-next';
 import { extractSmartLinkEmbed } from '@atlaskit/link-extractors';
 import { fg } from '@atlaskit/platform-feature-flags';
@@ -68,7 +68,10 @@ function Component(_ref) {
   }, [children, ui]);
 
   // Get state, actions for this card.
-  var _useSmartLink = useSmartLink(id, url),
+  // appearance is pre-resolved by the caller (loader.tsx for Card, ssr.tsx for CardSSR):
+  // FlexibleCards are always passed appearance='block' when FG is on, so component.tsx
+  // simply consumes whatever appearance it receives.
+  var _useSmartLink = useSmartLink(id, url, appearance),
     state = _useSmartLink.state,
     actions = _useSmartLink.actions,
     config = _useSmartLink.config,
@@ -261,12 +264,31 @@ function Component(_ref) {
       });
     }
   }, [fire3PClickEvent, shouldFire3PClickEvent]);
+  var reload = actions.reload;
   var handleAuthorize = useCallback(function () {
     return actions.authorize(appearance);
   }, [actions, appearance]);
   var handleRetry = useCallback(function () {
-    actions.reload();
-  }, [actions]);
+    reload();
+  }, [reload]);
+  var hasMounted = useRef(false);
+  var prevAppearance = useRef(appearance);
+
+  // When appearance changes from inline to non-inline on a mounted card
+  // (e.g. direct consumer changes inline → block/embed), reload with the new appearance
+  // so ORS can return the appropriate full data. We intentionally do NOT reload on
+  // block → embed or embed → block transitions since both already have full ORS data.
+  useEffect(function () {
+    if (!hasMounted.current) {
+      hasMounted.current = true;
+      prevAppearance.current = appearance;
+      return;
+    }
+    if (prevAppearance.current === 'inline' && appearance !== 'inline' && fg('platform_smartlink_inline_resolve_optimization')) {
+      reload(appearance);
+    }
+    prevAppearance.current = appearance;
+  }, [appearance, reload]);
   var handleInvoke = useCallback(function (opts) {
     return actions.invoke(opts, appearance);
   }, [actions, appearance]);

package/dist/esm/view/CardWithUrl/loader.js

@@ -7,6 +7,7 @@ import { ErrorBoundary } from 'react-error-boundary';
 import { di } from 'react-magnetic-di';
 // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 import uuid from 'uuid';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { useAnalyticsEvents } from '../../common/analytics/generated/use-analytics-events';
 import { failUfoExperience, startUfoExperience } from '../../state/analytics';
 import { importWithRetry } from '../../utils';
@@ -112,10 +113,15 @@ export function CardWithURLRenderer(props) {
   var ErrorFallback = function ErrorFallback() {
     return /*#__PURE__*/React.createElement(FallbackComponent, null);
   };
+
+  // FlexibleCards always need full ORS data regardless of appearance prop,
+  // because they render custom blocks (TitleBlock etc.) requiring complete response.
+  // Override appearance to 'block' for all FlexibleCards when FG is enabled.
+  var effectiveAppearance = isFlexibleUi && fg('platform_smartlink_inline_resolve_optimization') ? 'block' : appearance;
   var cardWithUrlProps = {
     id: id,
     url: url,
-    appearance: appearance,
+    appearance: effectiveAppearance,
     onClick: onClick,
     isSelected: isSelected,
     isHovered: isHovered,

package/dist/esm/view/EmbedCard/useEmbedResolvePostMessageListener.js

@@ -12,7 +12,10 @@ export var useEmbedResolvePostMessageListener = function useEmbedResolvePostMess
       }
       var isFromExpectedIframe = embedIframeRef && event.source === ((_embedIframeRef$curre = embedIframeRef.current) === null || _embedIframeRef$curre === void 0 ? void 0 : _embedIframeRef$curre.contentWindow);
       if (event.data === 'force-resolve-smart-link' && isFromExpectedIframe) {
-        resolve(url, true);
+        resolve({
+          url: url,
+          isReloading: true
+        });
       }
     };
     window.addEventListener('message', messageCallback);

package/dist/esm/view/FlexibleCard/components/actions/action/server-action/index.js

@@ -56,7 +56,11 @@ var ServerAction = function ServerAction(_ref) {
             break;
           }
           _context.next = 3;
-          return reload(action.reload.url, true, undefined, action.reload.id);
+          return reload({
+            url: action.reload.url,
+            isReloading: true,
+            id: action.reload.id
+          });
         case 3:
           setIsLoading(false);
           if (onClick) {

package/dist/esm/view/FlexibleCard/components/elements/common/base-lozenge-element/lozenge-action/index.js

@@ -183,7 +183,11 @@ var LozengeAction = function LozengeAction(_ref) {
               break;
             }
             _context2.next = 2;
-            return reload(url, true, undefined, linkId);
+            return reload({
+              url: url,
+              isReloading: true,
+              id: linkId
+            });
           case 2:
             _context2.next = 4;
             break;

package/dist/esm/view/HoverCard/components/HoverCardComponent.js

@@ -3,6 +3,7 @@ import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProper
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 var _excluded = ["aria-haspopup", "aria-expanded"];
 import React, { useCallback, useEffect, useMemo, useRef } from 'react';
+import { fg } from '@atlaskit/platform-feature-flags';
 import Popup from '@atlaskit/popup';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
 import { ActionName, CardDisplay } from '../../../constants';
@@ -135,7 +136,7 @@ export var HoverCardComponent = function HoverCardComponent(_ref) {
   // to minimize the loading state
   var initResolve = useCallback(function () {
     // this check covers both non-SSR (status) & SSR case (metadataStatus)
-    var isLinkUnresolved = linkState.status === 'pending' || !linkState.metadataStatus;
+    var isLinkUnresolved = linkState.status === 'pending' || !linkState.metadataStatus || linkState.status === 'resolved' && linkState.metadataStatus === 'pending' && fg('platform_smartlink_inline_resolve_optimization');
     if (!resolveTimeOutId.current && isLinkUnresolved) {
       resolveTimeOutId.current = setTimeout(function () {
         if (linkState.status === 'pending') {

package/dist/esm/view/LinkUrl/index.js

@@ -12,7 +12,7 @@ import LinkWarningModal from './LinkWarningModal';
 import { useLinkWarningModal } from './LinkWarningModal/hooks/use-link-warning-modal';
 var PACKAGE_DATA = {
   packageName: "@atlaskit/smart-card",
-  packageVersion: "44.24.1",
+  packageVersion: "44.24.2",
   componentName: 'linkUrl'
 };
 var LinkUrl = function LinkUrl(_ref) {

package/dist/types/state/actions/index.d.ts

@@ -1,10 +1,11 @@
 import { type JsonLd } from '@atlaskit/json-ld-types';
+import { type CardAppearance } from '@atlaskit/linking-common';
 import { type InvokeClientOpts, type InvokeServerOpts } from '../../model/invoke-opts';
 import { type CardInnerAppearance } from '../../view/Card/types';
 export declare const useSmartCardActions: (id: string, url: string) => {
     authorize: (appearance: CardInnerAppearance) => void;
     invoke: (opts: InvokeClientOpts | InvokeServerOpts, appearance: CardInnerAppearance) => Promise<JsonLd.Response | void>;
     loadMetadata: () => Promise<void> | undefined;
-    register: () => Promise<void>;
-    reload: () => void;
+    register: (appearance?: CardAppearance) => Promise<void>;
+    reload: (appearance?: CardAppearance) => void;
 };

package/dist/types/state/hooks/use-resolve/index.d.ts

@@ -1,3 +1,11 @@
-declare const useResolve: () => ((url: string, isReloading?: boolean, isMetadataRequest?: boolean, id?: string) => Promise<void>);
+import type { CardAppearance } from '@atlaskit/linking-common';
+export interface ResolveUrlParams {
+    appearance?: CardAppearance;
+    id?: string;
+    isMetadataRequest?: boolean;
+    isReloading?: boolean;
+    url: string;
+}
+declare const useResolve: () => ((params: ResolveUrlParams) => Promise<void>);
 export default useResolve;
 export type ResolveFunction = ReturnType<typeof useResolve>;

package/dist/types/state/hooks/use-response/index.d.ts

@@ -1,7 +1,7 @@
 import { type JsonLd } from '@atlaskit/json-ld-types';
-import { APIError } from '@atlaskit/linking-common';
+import { APIError, type MetadataStatus } from '@atlaskit/linking-common';
 declare const useResponse: () => {
     handleResolvedLinkError: (url: string, error: APIError, response?: JsonLd.Response, isMetadataRequest?: boolean) => void;
-    handleResolvedLinkResponse: (resourceUrl: string, response: JsonLd.Response | undefined, isReloading?: boolean, isMetadataRequest?: boolean) => void;
+    handleResolvedLinkResponse: (resourceUrl: string, response: JsonLd.Response | undefined, isReloading?: boolean, isMetadataRequest?: boolean, metadataStatus?: MetadataStatus) => void;
 };
 export default useResponse;

package/dist/types/state/hooks/usePrefetch.d.ts

@@ -1 +1,2 @@
-export declare function usePrefetch(url: string): () => Promise<void>;
+import { type CardAppearance } from '@atlaskit/linking-common';
+export declare function usePrefetch(url: string, appearance?: CardAppearance): () => Promise<void>;

package/dist/types/state/hooks/useSmartLink.d.ts

@@ -1,19 +1,25 @@
 import type { JsonLd } from '@atlaskit/json-ld-types';
 import { type CardAuthFlowOpts, type CardProviderRenderers } from '@atlaskit/link-provider';
-import type { CardState } from '@atlaskit/linking-common';
+import type { CardAppearance, CardState } from '@atlaskit/linking-common';
 import type { InvokeClientOpts, InvokeServerOpts } from '../../model/invoke-opts';
 import type { CardInnerAppearance } from '../../view/Card/types';
-export declare function useSmartLink(id: string, url: string): {
-    state: CardState;
+/**
+ * Hook for smart link state and actions.
+ * @param id - Unique identifier for the smart link
+ * @param url - The URL to resolve
+ * @param appearance - Card appearance hint for ORS to optimize response payload.
+ *                     When 'inline', ORS returns minimal data (title, status).
+ *                     When 'block' or 'embed', ORS returns full data including summary.
+ */
+export declare function useSmartLink(id: string, url: string, appearance?: CardAppearance): {
     actions: {
-        register: () => Promise<void>;
-        reload: () => void;
         authorize: (appearance: CardInnerAppearance) => void;
         invoke: (opts: InvokeClientOpts | InvokeServerOpts, appearance: CardInnerAppearance) => Promise<JsonLd.Response | void>;
         loadMetadata: () => Promise<void> | undefined;
+        register: () => Promise<void>;
+        reload: (appearance?: CardAppearance) => void;
     };
     config: CardAuthFlowOpts | undefined;
-    renderers: CardProviderRenderers | undefined;
     error: Error | null;
     isPreviewPanelAvailable: ((props: {
         ari: string;
@@ -27,4 +33,6 @@ export declare function useSmartLink(id: string, url: string): {
         };
         url: string;
     }) => void) | undefined;
+    renderers: CardProviderRenderers | undefined;
+    state: CardState;
 };

package/dist/types-ts4.5/state/actions/index.d.ts

@@ -1,10 +1,11 @@
 import { type JsonLd } from '@atlaskit/json-ld-types';
+import { type CardAppearance } from '@atlaskit/linking-common';
 import { type InvokeClientOpts, type InvokeServerOpts } from '../../model/invoke-opts';
 import { type CardInnerAppearance } from '../../view/Card/types';
 export declare const useSmartCardActions: (id: string, url: string) => {
     authorize: (appearance: CardInnerAppearance) => void;
     invoke: (opts: InvokeClientOpts | InvokeServerOpts, appearance: CardInnerAppearance) => Promise<JsonLd.Response | void>;
     loadMetadata: () => Promise<void> | undefined;
-    register: () => Promise<void>;
-    reload: () => void;
+    register: (appearance?: CardAppearance) => Promise<void>;
+    reload: (appearance?: CardAppearance) => void;
 };