@gears-frontx/react 0.1.0 → 0.2.0-alpha.2

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,174 +17,202 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ACCOUNTS_DOMAIN: () => import_framework6.ACCOUNTS_DOMAIN,
-  ApiPlugin: () => import_framework6.ApiPlugin,
-  ApiPluginBase: () => import_framework6.ApiPluginBase,
-  ApiProtocol: () => import_framework6.ApiProtocol,
-  BaseApiService: () => import_framework6.BaseApiService,
-  ContainerProvider: () => import_framework15.ContainerProvider,
+  ACCOUNTS_DOMAIN: () => import_framework5.ACCOUNTS_DOMAIN,
+  ActionHandler: () => import_framework14.ActionHandler,
+  ApiPlugin: () => import_framework5.ApiPlugin,
+  ApiPluginBase: () => import_framework5.ApiPluginBase,
+  ApiProtocol: () => import_framework5.ApiProtocol,
+  BaseApiService: () => import_framework5.BaseApiService,
+  CanAccess: () => CanAccess,
+  ChildMfeBridge: () => import_framework14.ChildMfeBridge,
+  ConcurrentMountStrategy: () => import_framework14.ConcurrentMountStrategy,
+  ExclusiveMountStrategy: () => import_framework14.ExclusiveMountStrategy,
+  ExtensionDomainImplementation: () => import_framework14.ExtensionDomainImplementation,
+  ExtensionDomainImplementationFactory: () => import_framework14.ExtensionDomainImplementationFactory,
   ExtensionDomainSlot: () => ExtensionDomainSlot,
-  FRONTX_ACTION_LOAD_EXT: () => import_framework13.FRONTX_ACTION_LOAD_EXT,
-  FRONTX_ACTION_MOUNT_EXT: () => import_framework13.FRONTX_ACTION_MOUNT_EXT,
-  FRONTX_ACTION_UNMOUNT_EXT: () => import_framework13.FRONTX_ACTION_UNMOUNT_EXT,
-  FRONTX_MFE_ENTRY_MF: () => import_framework12.FRONTX_MFE_ENTRY_MF,
-  FRONTX_OVERLAY_DOMAIN: () => import_framework11.FRONTX_OVERLAY_DOMAIN,
-  FRONTX_POPUP_DOMAIN: () => import_framework11.FRONTX_POPUP_DOMAIN,
-  FRONTX_SCREEN_DOMAIN: () => import_framework11.FRONTX_SCREEN_DOMAIN,
-  FRONTX_SCREEN_EXTENSION_TYPE: () => import_framework12.FRONTX_SCREEN_EXTENSION_TYPE,
-  FRONTX_SHARED_PROPERTY_LANGUAGE: () => import_framework14.FRONTX_SHARED_PROPERTY_LANGUAGE,
-  FRONTX_SHARED_PROPERTY_THEME: () => import_framework14.FRONTX_SHARED_PROPERTY_THEME,
-  FRONTX_SIDEBAR_DOMAIN: () => import_framework11.FRONTX_SIDEBAR_DOMAIN,
-  HAI3Context: () => HAI3Context,
-  HAI3Provider: () => HAI3Provider,
-  I18nRegistry: () => import_framework6.I18nRegistry,
-  I18nRegistryImpl: () => import_framework6.I18nRegistryImpl,
-  LAYOUT_SLICE_NAME: () => import_framework6.LAYOUT_SLICE_NAME,
-  Language: () => import_framework7.Language,
-  LanguageDisplayMode: () => import_framework7.LanguageDisplayMode,
-  LayoutDomain: () => import_framework6.LayoutDomain,
-  MOCK_PLUGIN: () => import_framework6.MOCK_PLUGIN,
-  MfeBridgeFactory: () => import_framework15.MfeBridgeFactory,
+  ExtensionMounter: () => import_framework14.ExtensionMounter,
+  FRONTX_ACTION_LOAD_EXT: () => import_framework12.FRONTX_ACTION_LOAD_EXT,
+  FRONTX_ACTION_MOUNT_EXT: () => import_framework12.FRONTX_ACTION_MOUNT_EXT,
+  FRONTX_ACTION_UNMOUNT_EXT: () => import_framework12.FRONTX_ACTION_UNMOUNT_EXT,
+  FRONTX_MFE_ENTRY_MF: () => import_framework11.FRONTX_MFE_ENTRY_MF,
+  FRONTX_OVERLAY_DOMAIN: () => import_framework10.FRONTX_OVERLAY_DOMAIN,
+  FRONTX_POPUP_DOMAIN: () => import_framework10.FRONTX_POPUP_DOMAIN,
+  FRONTX_SCREEN_DOMAIN: () => import_framework10.FRONTX_SCREEN_DOMAIN,
+  FRONTX_SCREEN_EXTENSION_TYPE: () => import_framework11.FRONTX_SCREEN_EXTENSION_TYPE,
+  FRONTX_SHARED_PROPERTY_LANGUAGE: () => import_framework13.FRONTX_SHARED_PROPERTY_LANGUAGE,
+  FRONTX_SHARED_PROPERTY_THEME: () => import_framework13.FRONTX_SHARED_PROPERTY_THEME,
+  FRONTX_SIDEBAR_DOMAIN: () => import_framework10.FRONTX_SIDEBAR_DOMAIN,
+  FrontXContext: () => FrontXContext,
+  FrontXProvider: () => FrontXProvider,
+  I18nRegistry: () => import_framework5.I18nRegistry,
+  I18nRegistryImpl: () => import_framework5.I18nRegistryImpl,
+  LAYOUT_SLICE_NAME: () => import_framework5.LAYOUT_SLICE_NAME,
+  Language: () => import_framework6.Language,
+  LanguageDisplayMode: () => import_framework6.LanguageDisplayMode,
+  LayoutDomain: () => import_framework5.LayoutDomain,
+  MOCK_PLUGIN: () => import_framework5.MOCK_PLUGIN,
+  MfeBridgeFactory: () => import_framework14.MfeBridgeFactory,
   MfeContext: () => MfeContext,
-  MfeHandler: () => import_framework15.MfeHandler,
-  MfeHandlerMF: () => import_framework16.MfeHandlerMF,
+  MfeHandler: () => import_framework14.MfeHandler,
+  MfeHandlerMF: () => import_framework15.MfeHandlerMF,
   MfeProvider: () => MfeProvider,
-  MockEventSource: () => import_framework6.MockEventSource,
-  MockEvents: () => import_framework6.MockEvents,
-  RefContainerProvider: () => RefContainerProvider,
-  RestMockPlugin: () => import_framework6.RestMockPlugin,
-  RestPlugin: () => import_framework6.RestPlugin,
-  RestPluginWithConfig: () => import_framework6.RestPluginWithConfig,
-  RestProtocol: () => import_framework6.RestProtocol,
-  SUPPORTED_LANGUAGES: () => import_framework6.SUPPORTED_LANGUAGES,
-  ScreensetsRegistry: () => import_framework15.ScreensetsRegistry,
-  ScreensetsRegistryFactory: () => import_framework15.ScreensetsRegistryFactory,
-  SseMockPlugin: () => import_framework6.SseMockPlugin,
-  SsePlugin: () => import_framework6.SsePlugin,
-  SsePluginWithConfig: () => import_framework6.SsePluginWithConfig,
-  SseProtocol: () => import_framework6.SseProtocol,
-  TENANT_SLICE_NAME: () => import_framework6.TENANT_SLICE_NAME,
-  TenantEvents: () => import_framework6.TenantEvents,
-  TextDirection: () => import_framework7.TextDirection,
-  apiRegistry: () => import_framework6.apiRegistry,
-  changeTenant: () => import_framework6.changeTenant,
-  clearActiveScreen: () => import_framework6.clearActiveScreen,
-  clearTenant: () => import_framework6.clearTenant,
-  clearTenantAction: () => import_framework6.clearTenantAction,
-  clearUser: () => import_framework6.clearUser,
-  closeAllPopups: () => import_framework6.closeAllPopups,
-  closePopup: () => import_framework6.closePopup,
-  closeTopPopup: () => import_framework6.closeTopPopup,
-  createHAI3: () => import_framework6.createHAI3,
-  createHAI3App: () => import_framework6.createHAI3App,
-  createI18nRegistry: () => import_framework6.createI18nRegistry,
-  createShadowRoot: () => import_framework18.createShadowRoot,
-  createSlice: () => import_framework6.createSlice,
-  createStore: () => import_framework6.createStore,
-  createThemeRegistry: () => import_framework6.createThemeRegistry,
-  effects: () => import_framework6.effects,
-  eventBus: () => eventBus,
-  extensionScreenSchema: () => import_framework17.extensionScreenSchema,
-  extractGtsPackage: () => import_framework18.extractGtsPackage,
-  footerActions: () => import_framework6.footerActions,
-  footerSlice: () => import_framework6.footerSlice,
-  getLanguageMetadata: () => import_framework6.getLanguageMetadata,
-  getStore: () => import_framework6.getStore,
-  gtsPlugin: () => import_framework16.gtsPlugin,
-  hasSlice: () => import_framework6.hasSlice,
-  headerActions: () => import_framework6.headerActions,
-  headerSlice: () => import_framework6.headerSlice,
-  hideOverlay: () => import_framework6.hideOverlay,
-  i18n: () => import_framework6.i18n,
-  i18nRegistry: () => import_framework6.i18nRegistry,
-  initMockEffects: () => import_framework6.initMockEffects,
-  initTenantEffects: () => import_framework6.initTenantEffects,
-  injectCssVariables: () => import_framework18.injectCssVariables,
-  isMockPlugin: () => import_framework6.isMockPlugin,
-  isRestShortCircuit: () => import_framework6.isRestShortCircuit,
-  isShortCircuit: () => import_framework6.isShortCircuit,
-  isSseShortCircuit: () => import_framework6.isSseShortCircuit,
-  languageSchema: () => import_framework17.languageSchema,
-  layout: () => import_framework6.layout,
-  layoutDomainReducers: () => import_framework6.layoutDomainReducers,
-  layoutReducer: () => import_framework6.layoutReducer,
-  loadExtension: () => import_framework9.loadExtension,
-  menuActions: () => import_framework6.menuActions,
-  menuSlice: () => import_framework6.menuSlice,
-  microfrontends: () => import_framework8.microfrontends,
-  mock: () => import_framework8.mock,
-  mockActions: () => import_framework6.mockActions,
-  mockSlice: () => import_framework6.mockSlice,
-  mountExtension: () => import_framework9.mountExtension,
-  navigateTo: () => import_framework6.navigateTo,
-  openPopup: () => import_framework6.openPopup,
-  overlayActions: () => import_framework6.overlayActions,
-  overlayDomain: () => import_framework11.overlayDomain,
-  overlaySlice: () => import_framework6.overlaySlice,
-  popupActions: () => import_framework6.popupActions,
-  popupDomain: () => import_framework11.popupDomain,
-  popupSlice: () => import_framework6.popupSlice,
-  presets: () => import_framework6.presets,
-  registerExtension: () => import_framework9.registerExtension,
-  registerSlice: () => import_framework6.registerSlice,
-  screenActions: () => import_framework6.screenActions,
-  screenDomain: () => import_framework11.screenDomain,
-  screenSlice: () => import_framework6.screenSlice,
-  screensets: () => import_framework6.screensets,
-  screensetsRegistryFactory: () => import_framework15.screensetsRegistryFactory,
-  selectExtensionError: () => import_framework10.selectExtensionError,
-  selectExtensionState: () => import_framework10.selectExtensionState,
-  selectRegisteredExtensions: () => import_framework10.selectRegisteredExtensions,
-  setActiveScreen: () => import_framework6.setActiveScreen,
-  setFooterConfig: () => import_framework6.setFooterConfig,
-  setFooterVisible: () => import_framework6.setFooterVisible,
-  setHeaderLoading: () => import_framework6.setHeaderLoading,
-  setMenuCollapsed: () => import_framework6.setMenuCollapsed,
-  setMenuConfig: () => import_framework6.setMenuConfig,
-  setMenuItems: () => import_framework6.setMenuItems,
-  setMenuVisible: () => import_framework6.setMenuVisible,
-  setMockEnabled: () => import_framework6.setMockEnabled,
-  setOverlayVisible: () => import_framework6.setOverlayVisible,
-  setScreenLoading: () => import_framework6.setScreenLoading,
-  setSidebarCollapsed: () => import_framework6.setSidebarCollapsed,
-  setSidebarConfig: () => import_framework6.setSidebarConfig,
-  setSidebarContent: () => import_framework6.setSidebarContent,
-  setSidebarPosition: () => import_framework6.setSidebarPosition,
-  setSidebarTitle: () => import_framework6.setSidebarTitle,
-  setSidebarVisible: () => import_framework6.setSidebarVisible,
-  setSidebarWidth: () => import_framework6.setSidebarWidth,
-  setTenant: () => import_framework6.setTenant,
-  setTenantLoading: () => import_framework6.setTenantLoading,
-  setTenantLoadingState: () => import_framework6.setTenantLoadingState,
-  setUser: () => import_framework6.setUser,
-  showOverlay: () => import_framework6.showOverlay,
-  sidebarActions: () => import_framework6.sidebarActions,
-  sidebarDomain: () => import_framework11.sidebarDomain,
-  sidebarSlice: () => import_framework6.sidebarSlice,
-  tenantActions: () => import_framework6.tenantActions,
-  tenantReducer: () => import_framework6.tenantReducer,
-  tenantSlice: () => import_framework6.tenantSlice,
-  themeSchema: () => import_framework17.themeSchema,
-  themes: () => import_framework6.themes,
-  toggleMenu: () => import_framework6.toggleMenu,
-  toggleMockMode: () => import_framework6.toggleMockMode,
-  toggleSidebar: () => import_framework6.toggleSidebar,
-  unmountExtension: () => import_framework9.unmountExtension,
-  unregisterExtension: () => import_framework9.unregisterExtension,
-  useActivePackage: () => useActivePackage,
+  MfeRegistry: () => import_framework14.MfeRegistry,
+  MfeRegistryFactory: () => import_framework14.MfeRegistryFactory,
+  MockEventSource: () => import_framework5.MockEventSource,
+  MockEvents: () => import_framework5.MockEvents,
+  MountStrategy: () => import_framework14.MountStrategy,
+  OptionalMountStrategy: () => import_framework14.OptionalMountStrategy,
+  ParentMfeBridge: () => import_framework14.ParentMfeBridge,
+  RestEndpointProtocol: () => import_framework5.RestEndpointProtocol,
+  RestMockPlugin: () => import_framework5.RestMockPlugin,
+  RestPlugin: () => import_framework5.RestPlugin,
+  RestPluginWithConfig: () => import_framework5.RestPluginWithConfig,
+  RestProtocol: () => import_framework5.RestProtocol,
+  SUPPORTED_LANGUAGES: () => import_framework5.SUPPORTED_LANGUAGES,
+  SseMockPlugin: () => import_framework5.SseMockPlugin,
+  SsePlugin: () => import_framework5.SsePlugin,
+  SsePluginWithConfig: () => import_framework5.SsePluginWithConfig,
+  SseProtocol: () => import_framework5.SseProtocol,
+  SseStreamProtocol: () => import_framework5.SseStreamProtocol,
+  TENANT_SLICE_NAME: () => import_framework5.TENANT_SLICE_NAME,
+  TenantEvents: () => import_framework5.TenantEvents,
+  TextDirection: () => import_framework6.TextDirection,
+  ThemeAwareReactLifecycle: () => ThemeAwareReactLifecycle,
+  apiRegistry: () => import_framework5.apiRegistry,
+  auth: () => import_framework5.auth,
+  changeTenant: () => import_framework5.changeTenant,
+  clearTenant: () => import_framework5.clearTenant,
+  clearTenantAction: () => import_framework5.clearTenantAction,
+  clearUser: () => import_framework5.clearUser,
+  closeAllPopups: () => import_framework5.closeAllPopups,
+  closePopup: () => import_framework5.closePopup,
+  closeTopPopup: () => import_framework5.closeTopPopup,
+  createFrontX: () => import_framework5.createFrontX,
+  createFrontXApp: () => import_framework5.createFrontXApp,
+  createI18nRegistry: () => import_framework5.createI18nRegistry,
+  createShadowRoot: () => import_framework17.createShadowRoot,
+  createSlice: () => import_framework5.createSlice,
+  createStore: () => import_framework5.createStore,
+  createThemeRegistry: () => import_framework5.createThemeRegistry,
+  effects: () => import_framework5.effects,
+  eventBus: () => eventBus2,
+  extensionScreenSchema: () => import_framework16.extensionScreenSchema,
+  extractGtsPackage: () => import_framework17.extractGtsPackage,
+  footerActions: () => import_framework5.footerActions,
+  footerSlice: () => import_framework5.footerSlice,
+  frontxApiTransport: () => import_framework5.frontxApiTransport,
+  getLanguageMetadata: () => import_framework5.getLanguageMetadata,
+  getStore: () => import_framework5.getStore,
+  gtsPlugin: () => import_framework15.gtsPlugin,
+  hasSlice: () => import_framework5.hasSlice,
+  headerActions: () => import_framework5.headerActions,
+  headerSlice: () => import_framework5.headerSlice,
+  hideOverlay: () => import_framework5.hideOverlay,
+  i18n: () => import_framework5.i18n,
+  i18nRegistry: () => import_framework5.i18nRegistry,
+  initMockEffects: () => import_framework5.initMockEffects,
+  initTenantEffects: () => import_framework5.initTenantEffects,
+  injectCssVariables: () => import_framework17.injectCssVariables,
+  invalidateQueryCacheForApp: () => invalidateQueryCacheForApp,
+  isMockPlugin: () => import_framework5.isMockPlugin,
+  isRestShortCircuit: () => import_framework5.isRestShortCircuit,
+  isShortCircuit: () => import_framework5.isShortCircuit,
+  isSseShortCircuit: () => import_framework5.isSseShortCircuit,
+  languageSchema: () => import_framework16.languageSchema,
+  layout: () => import_framework5.layout,
+  layoutDomainReducers: () => import_framework5.layoutDomainReducers,
+  layoutReducer: () => import_framework5.layoutReducer,
+  loadExtension: () => import_framework8.loadExtension,
+  menuActions: () => import_framework5.menuActions,
+  menuSlice: () => import_framework5.menuSlice,
+  mfeRegistryFactory: () => import_framework14.mfeRegistryFactory,
+  microfrontends: () => import_framework7.microfrontends,
+  mock: () => import_framework7.mock,
+  mockActions: () => import_framework5.mockActions,
+  mockSlice: () => import_framework5.mockSlice,
+  mountExtension: () => import_framework8.mountExtension,
+  openPopup: () => import_framework5.openPopup,
+  overlayActions: () => import_framework5.overlayActions,
+  overlayDomain: () => import_framework10.overlayDomain,
+  overlaySlice: () => import_framework5.overlaySlice,
+  popupActions: () => import_framework5.popupActions,
+  popupDomain: () => import_framework10.popupDomain,
+  popupSlice: () => import_framework5.popupSlice,
+  presets: () => import_framework5.presets,
+  queryCache: () => import_framework5.queryCache,
+  queryCacheShared: () => import_framework5.queryCacheShared,
+  registerExtension: () => import_framework8.registerExtension,
+  registerSlice: () => import_framework5.registerSlice,
+  screenDomain: () => import_framework10.screenDomain,
+  selectExtensionError: () => import_framework9.selectExtensionError,
+  selectExtensionState: () => import_framework9.selectExtensionState,
+  selectMountedExtensions: () => import_framework9.selectMountedExtensions,
+  selectRegisteredExtensions: () => import_framework9.selectRegisteredExtensions,
+  setFooterConfig: () => import_framework5.setFooterConfig,
+  setFooterVisible: () => import_framework5.setFooterVisible,
+  setHeaderLoading: () => import_framework5.setHeaderLoading,
+  setMenuCollapsed: () => import_framework5.setMenuCollapsed,
+  setMenuConfig: () => import_framework5.setMenuConfig,
+  setMenuItems: () => import_framework5.setMenuItems,
+  setMenuVisible: () => import_framework5.setMenuVisible,
+  setMockEnabled: () => import_framework5.setMockEnabled,
+  setOverlayVisible: () => import_framework5.setOverlayVisible,
+  setSidebarCollapsed: () => import_framework5.setSidebarCollapsed,
+  setSidebarConfig: () => import_framework5.setSidebarConfig,
+  setSidebarContent: () => import_framework5.setSidebarContent,
+  setSidebarPosition: () => import_framework5.setSidebarPosition,
+  setSidebarTitle: () => import_framework5.setSidebarTitle,
+  setSidebarVisible: () => import_framework5.setSidebarVisible,
+  setSidebarWidth: () => import_framework5.setSidebarWidth,
+  setTenant: () => import_framework5.setTenant,
+  setTenantLoading: () => import_framework5.setTenantLoading,
+  setTenantLoadingState: () => import_framework5.setTenantLoadingState,
+  setUser: () => import_framework5.setUser,
+  showOverlay: () => import_framework5.showOverlay,
+  sidebarActions: () => import_framework5.sidebarActions,
+  sidebarDomain: () => import_framework10.sidebarDomain,
+  sidebarSlice: () => import_framework5.sidebarSlice,
+  subscribeQueryCacheRuntimeChanged: () => import_framework5.subscribeQueryCacheRuntimeChanged,
+  tenantActions: () => import_framework5.tenantActions,
+  tenantReducer: () => import_framework5.tenantReducer,
+  tenantSlice: () => import_framework5.tenantSlice,
+  themeSchema: () => import_framework16.themeSchema,
+  themes: () => import_framework5.themes,
+  toggleMenu: () => import_framework5.toggleMenu,
+  toggleMockMode: () => import_framework5.toggleMockMode,
+  toggleSidebar: () => import_framework5.toggleSidebar,
+  unmountExtension: () => import_framework8.unmountExtension,
+  unregisterExtension: () => import_framework8.unregisterExtension,
+  useApiInfiniteQuery: () => useApiInfiniteQuery,
+  useApiMutation: () => useApiMutation,
+  useApiQuery: () => useApiQuery,
+  useApiStream: () => useApiStream,
+  useApiSuspenseInfiniteQuery: () => useApiSuspenseInfiniteQuery,
+  useApiSuspenseQuery: () => useApiSuspenseQuery,
   useAppDispatch: () => useAppDispatch,
   useAppSelector: () => useAppSelector,
+  useCanAccess: () => useCanAccess,
   useDomainExtensions: () => useDomainExtensions,
   useFormatters: () => useFormatters,
-  useHAI3: () => useHAI3,
+  useFrontX: () => useFrontX,
   useHostAction: () => useHostAction,
   useMfeBridge: () => useMfeBridge,
   useMfeContext: () => useMfeContext,
+  useMountedExtensions: () => useMountedExtensions,
+  useQueryCache: () => useQueryCache,
   useRegisteredPackages: () => useRegisteredPackages,
   useScreenTranslations: () => useScreenTranslations,
   useSharedProperty: () => useSharedProperty,
@@ -191,19 +221,19 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/HAI3Provider.tsx
-var import_react3 = require("react");
+// src/FrontXProvider.tsx
+var import_react5 = require("react");
 var import_react_redux = require("react-redux");
-var import_framework = require("@gears-frontx/framework");
+var import_framework3 = require("@gears-frontx/framework");
 
-// src/HAI3Context.tsx
+// src/FrontXContext.tsx
 var import_react = require("react");
-var HAI3Context = (0, import_react.createContext)(null);
-function useHAI3() {
-  const context = (0, import_react.useContext)(HAI3Context);
+var FrontXContext = (0, import_react.createContext)(null);
+function useFrontX() {
+  const context = (0, import_react.useContext)(FrontXContext);
   if (!context) {
     throw new Error(
-      "useHAI3 must be used within a HAI3Provider. Wrap your application with <HAI3Provider> to access HAI3 features."
+      "useFrontX must be used within a FrontXProvider. Wrap your application with <FrontXProvider> to access Gears FrontX features."
     );
   }
   return context;
@@ -228,34 +258,573 @@ var MfeProvider = ({ value, children }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MfeContext.Provider, { value, children });
 };
 
-// src/HAI3Provider.tsx
+// src/queryClient.tsx
+var import_react4 = __toESM(require("react"), 1);
+var import_react_query = require("@tanstack/react-query");
+var import_framework2 = require("@gears-frontx/framework");
+
+// src/hooks/QueryCache.ts
+var import_framework = require("@gears-frontx/framework");
+var QUERY_CLIENT_BROADCAST_TARGET = /* @__PURE__ */ Symbol.for("frontx:query-cache:broadcast-target");
+var QUERY_CLIENT_BROADCAST_COUNTER = /* @__PURE__ */ Symbol.for("frontx:query-cache:broadcast-counter");
+function emitCacheEvent(event, payload) {
+  import_framework.eventBus.emit(event, payload);
+}
+function ensureBroadcastSource(queryClient) {
+  const clientWithMetadata = queryClient;
+  const existingSource = clientWithMetadata[QUERY_CLIENT_BROADCAST_TARGET];
+  if (typeof existingSource === "string" && existingSource.length > 0) {
+    return existingSource;
+  }
+  const host = globalThis;
+  const nextCounter = (host[QUERY_CLIENT_BROADCAST_COUNTER] ?? 0) + 1;
+  host[QUERY_CLIENT_BROADCAST_COUNTER] = nextCounter;
+  const source = `query-cache-${nextCounter}`;
+  clientWithMetadata[QUERY_CLIENT_BROADCAST_TARGET] = source;
+  return source;
+}
+function resolveKey(target) {
+  if (target !== null && typeof target === "object" && !Array.isArray(target) && "key" in target && "fetch" in target && Array.isArray(target.key) && typeof target.fetch === "function") {
+    return target.key;
+  }
+  return target;
+}
+function toQueryUpdater(dataOrUpdater) {
+  if (typeof dataOrUpdater === "function") {
+    return dataOrUpdater;
+  }
+  return () => dataOrUpdater;
+}
+function mapQueryState(state) {
+  return {
+    data: state.data,
+    dataUpdatedAt: state.dataUpdatedAt,
+    error: state.error,
+    errorUpdatedAt: state.errorUpdatedAt,
+    fetchFailureCount: state.fetchFailureCount,
+    fetchFailureReason: state.fetchFailureReason,
+    fetchStatus: state.fetchStatus,
+    isInvalidated: state.isInvalidated,
+    status: state.status
+  };
+}
+function createQueryCache(queryClient) {
+  return {
+    get: (key) => {
+      return queryClient.getQueryData(resolveKey(key));
+    },
+    getState: (key) => {
+      const state = queryClient.getQueryState(resolveKey(key));
+      return state ? mapQueryState(state) : void 0;
+    },
+    set: (key, dataOrUpdater) => {
+      const resolvedKey = resolveKey(key);
+      queryClient.setQueryData(resolvedKey, toQueryUpdater(dataOrUpdater));
+      emitCacheEvent("cache/set", {
+        queryKey: resolvedKey,
+        dataOrUpdater,
+        source: ensureBroadcastSource(queryClient)
+      });
+    },
+    cancel: (key) => {
+      return queryClient.cancelQueries({ queryKey: resolveKey(key) });
+    },
+    invalidate: (key) => {
+      const resolvedKey = resolveKey(key);
+      const result = queryClient.invalidateQueries({ queryKey: resolvedKey });
+      emitCacheEvent("cache/invalidate", {
+        queryKey: resolvedKey,
+        source: ensureBroadcastSource(queryClient)
+      });
+      return result;
+    },
+    invalidateMany: (filters) => {
+      if (filters?.queryKey == null) {
+        return Promise.resolve();
+      }
+      const resolvedKey = resolveKey(filters.queryKey);
+      if (!Array.isArray(resolvedKey) || resolvedKey.length === 0) {
+        return Promise.resolve();
+      }
+      const payload = {
+        ...filters,
+        queryKey: resolvedKey
+      };
+      const result = queryClient.invalidateQueries(payload);
+      emitCacheEvent("cache/invalidate", {
+        ...payload,
+        source: ensureBroadcastSource(queryClient)
+      });
+      return result;
+    },
+    remove: (key) => {
+      const resolvedKey = resolveKey(key);
+      queryClient.removeQueries({ queryKey: resolvedKey });
+      emitCacheEvent("cache/remove", {
+        queryKey: resolvedKey,
+        source: ensureBroadcastSource(queryClient)
+      });
+    }
+  };
+}
+
+// src/hooks/useLatest.ts
+var import_react3 = require("react");
+function useLatest(value) {
+  const ref = (0, import_react3.useRef)(value);
+  (0, import_react3.useEffect)(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+
+// src/queryClient.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
-var HAI3Provider = ({
+var APP_QUERY_CLIENT_SYMBOL = /* @__PURE__ */ Symbol.for("frontx:query-cache:app-client");
+var APP_QUERY_CLIENT_RESOLVER_SYMBOL = /* @__PURE__ */ Symbol.for("frontx:query-cache:app-client-resolver");
+var APP_QUERY_CLIENT_ACTIVATOR_SYMBOL = /* @__PURE__ */ Symbol.for("frontx:query-cache:app-client-activator");
+var FrontXQueryClientContext = (0, import_react4.createContext)(void 0);
+var useCommitEffect = typeof globalThis.window === "undefined" ? import_react4.useEffect : import_react4.useLayoutEffect;
+function resolveFrontXQueryClient(app) {
+  const clientApp = app;
+  return clientApp[APP_QUERY_CLIENT_SYMBOL] ?? clientApp[APP_QUERY_CLIENT_RESOLVER_SYMBOL]?.();
+}
+function hasFrontXQueryClientActivator(app) {
+  return typeof app[APP_QUERY_CLIENT_ACTIVATOR_SYMBOL] === "function";
+}
+function activateFrontXQueryClient(app) {
+  const clientApp = app;
+  return clientApp[APP_QUERY_CLIENT_SYMBOL] ?? clientApp[APP_QUERY_CLIENT_ACTIVATOR_SYMBOL]?.();
+}
+async function invalidateQueryCacheForApp(app, target) {
+  const queryClient = resolveFrontXQueryClient(app) ?? activateFrontXQueryClient(app);
+  if (!queryClient) {
+    throw new Error(
+      "[invalidateQueryCacheForApp] No QueryClient on app. Ensure queryCache() or queryCacheShared() is in the plugin chain."
+    );
+  }
+  await createQueryCache(queryClient).invalidate(target);
+}
+function bootstrapFrontXQueryClient(app) {
+  return resolveFrontXQueryClient(app);
+}
+function useBootstrappedFrontXQueryClient(app) {
+  const fromApp = (0, import_react4.useMemo)(() => bootstrapFrontXQueryClient(app), [app]);
+  const [eventResolvedClient, setEventResolvedClient] = (0, import_react4.useState)(
+    void 0
+  );
+  const queryClient = fromApp ?? (eventResolvedClient?.app === app ? eventResolvedClient.queryClient : void 0);
+  useCommitEffect(() => {
+    if (fromApp || !hasFrontXQueryClientActivator(app)) {
+      return;
+    }
+    const tryResolveQueryClient = () => {
+      const nextQueryClient = resolveFrontXQueryClient(app) ?? activateFrontXQueryClient(app);
+      if (nextQueryClient) {
+        setEventResolvedClient((current) => {
+          if (current?.app === app && current.queryClient === nextQueryClient) {
+            return current;
+          }
+          return {
+            app,
+            queryClient: nextQueryClient
+          };
+        });
+      }
+    };
+    tryResolveQueryClient();
+    const subscription = (0, import_framework2.subscribeQueryCacheRuntimeChanged)(() => {
+      tryResolveQueryClient();
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [app, fromApp]);
+  return queryClient;
+}
+function FrontXQueryClientProvider({
+  queryClient,
+  children
+}) {
+  if (!queryClient) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(FrontXQueryClientContext.Provider, { value: void 0, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_query.QueryClientContext.Provider, { value: void 0, children }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(FrontXQueryClientContext.Provider, { value: queryClient, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_query.QueryClientProvider, { client: queryClient, children }) });
+}
+function useOptionalFrontXQueryClient() {
+  return (0, import_react4.useContext)(FrontXQueryClientContext);
+}
+function useRequiredFrontXQueryClient() {
+  const queryClient = useOptionalFrontXQueryClient();
+  if (!queryClient) {
+    throw new Error(
+      "[FrontXProvider] No query cache available. Add queryCache() or queryCacheShared() to your plugin composition."
+    );
+  }
+  return queryClient;
+}
+function buildPageContext(page, pages, descriptor, descriptors) {
+  return {
+    page,
+    pages,
+    descriptor,
+    descriptors
+  };
+}
+function normalizeFetchStaleTime(staleTime) {
+  if (staleTime === "static") {
+    return Number.POSITIVE_INFINITY;
+  }
+  return typeof staleTime === "number" ? staleTime : void 0;
+}
+function resolveFetchStaleTime(queryClient, descriptor, overrideStaleTime) {
+  return normalizeFetchStaleTime(
+    overrideStaleTime ?? descriptor.staleTime ?? queryClient.getDefaultOptions().queries?.staleTime
+  );
+}
+function fetchDescriptor(descriptor, options) {
+  return descriptor.fetch(options);
+}
+function useFrontXQuery(descriptor, overrides) {
+  const queryClient = useRequiredFrontXQueryClient();
+  const staleTime = resolveFetchStaleTime(queryClient, descriptor, overrides?.staleTime);
+  const result = (0, import_react_query.useQuery)({
+    queryKey: descriptor.key,
+    queryFn: ({ signal }) => fetchDescriptor(descriptor, { signal, staleTime }),
+    staleTime: overrides?.staleTime ?? descriptor.staleTime,
+    gcTime: overrides?.gcTime ?? descriptor.gcTime
+  });
+  return {
+    data: result.data,
+    error: result.error,
+    isLoading: result.isLoading,
+    isFetching: result.isFetching,
+    isError: result.isError,
+    refetch: result.refetch
+  };
+}
+function useFrontXSuspenseQuery(descriptor, overrides) {
+  const queryClient = useRequiredFrontXQueryClient();
+  const staleTime = resolveFetchStaleTime(queryClient, descriptor, overrides?.staleTime);
+  const result = (0, import_react_query.useSuspenseQuery)({
+    queryKey: descriptor.key,
+    queryFn: ({ signal }) => fetchDescriptor(descriptor, { signal, staleTime }),
+    staleTime: overrides?.staleTime ?? descriptor.staleTime,
+    gcTime: overrides?.gcTime ?? descriptor.gcTime
+  });
+  return {
+    data: result.data,
+    error: result.error,
+    isFetching: result.isFetching,
+    refetch: async () => {
+      await result.refetch();
+    }
+  };
+}
+function useFrontXInfiniteQuery(options) {
+  const queryClient = useRequiredFrontXQueryClient();
+  const result = (0, import_react_query.useInfiniteQuery)({
+    queryKey: options.initialPage.key,
+    initialPageParam: options.initialPage,
+    queryFn: ({ pageParam, signal }) => fetchDescriptor(pageParam, {
+      signal,
+      staleTime: resolveFetchStaleTime(queryClient, pageParam, options.staleTime)
+    }),
+    getNextPageParam: (lastPage, allPages, lastPageDescriptor, allPageDescriptors) => options.getNextPage(
+      buildPageContext(
+        lastPage,
+        allPages,
+        lastPageDescriptor,
+        allPageDescriptors
+      )
+    ),
+    getPreviousPageParam: options.getPreviousPage ? (firstPage, allPages, firstPageDescriptor, allPageDescriptors) => options.getPreviousPage?.(
+      buildPageContext(
+        firstPage,
+        allPages,
+        firstPageDescriptor,
+        allPageDescriptors
+      )
+    ) : void 0,
+    select: (data) => data.pages,
+    staleTime: options.staleTime ?? options.initialPage.staleTime,
+    gcTime: options.gcTime ?? options.initialPage.gcTime,
+    maxPages: options.maxPages
+  });
+  return {
+    data: result.data,
+    error: result.error,
+    isLoading: result.isLoading,
+    isFetching: result.isFetching,
+    isError: result.isError,
+    hasNextPage: result.hasNextPage ?? false,
+    hasPreviousPage: result.hasPreviousPage ?? false,
+    isFetchingNextPage: result.isFetchingNextPage,
+    isFetchingPreviousPage: result.isFetchingPreviousPage,
+    fetchNextPage: async () => {
+      await result.fetchNextPage();
+    },
+    fetchPreviousPage: async () => {
+      await result.fetchPreviousPage();
+    },
+    refetch: async () => {
+      await result.refetch();
+    }
+  };
+}
+function useFrontXSuspenseInfiniteQuery(options) {
+  const queryClient = useRequiredFrontXQueryClient();
+  const result = (0, import_react_query.useSuspenseInfiniteQuery)({
+    queryKey: options.initialPage.key,
+    initialPageParam: options.initialPage,
+    queryFn: ({ pageParam, signal }) => fetchDescriptor(pageParam, {
+      signal,
+      staleTime: resolveFetchStaleTime(queryClient, pageParam, options.staleTime)
+    }),
+    getNextPageParam: (lastPage, allPages, lastPageDescriptor, allPageDescriptors) => options.getNextPage(
+      buildPageContext(
+        lastPage,
+        allPages,
+        lastPageDescriptor,
+        allPageDescriptors
+      )
+    ),
+    getPreviousPageParam: options.getPreviousPage ? (firstPage, allPages, firstPageDescriptor, allPageDescriptors) => options.getPreviousPage?.(
+      buildPageContext(
+        firstPage,
+        allPages,
+        firstPageDescriptor,
+        allPageDescriptors
+      )
+    ) : void 0,
+    select: (data) => data.pages,
+    staleTime: options.staleTime ?? options.initialPage.staleTime,
+    gcTime: options.gcTime ?? options.initialPage.gcTime,
+    maxPages: options.maxPages
+  });
+  return {
+    data: result.data,
+    error: result.error,
+    isFetching: result.isFetching,
+    hasNextPage: result.hasNextPage ?? false,
+    hasPreviousPage: result.hasPreviousPage ?? false,
+    isFetchingNextPage: result.isFetchingNextPage,
+    isFetchingPreviousPage: result.isFetchingPreviousPage,
+    fetchNextPage: async () => {
+      await result.fetchNextPage();
+    },
+    fetchPreviousPage: async () => {
+      await result.fetchPreviousPage();
+    },
+    refetch: async () => {
+      await result.refetch();
+    }
+  };
+}
+function useFrontXMutation(options, callbackCtx) {
+  useRequiredFrontXQueryClient();
+  const latestRef = useLatest({ options, callbackCtx });
+  const fetchAbortControllersRef = import_react4.default.useRef(/* @__PURE__ */ new Set());
+  const abortFetchesOnUnmount = import_react4.default.useEffectEvent(() => {
+    if (options.abortOnUnmount) {
+      for (const controller of fetchAbortControllersRef.current) {
+        controller.abort();
+      }
+      fetchAbortControllersRef.current.clear();
+    }
+  });
+  import_react4.default.useEffect(() => {
+    return () => {
+      abortFetchesOnUnmount();
+    };
+  }, []);
+  const mutationFn = import_react4.default.useCallback((variables, context) => {
+    const cancelOnSupersede = latestRef.current.options.cancelOnSupersede;
+    if (cancelOnSupersede) {
+      for (const controller2 of fetchAbortControllersRef.current) {
+        controller2.abort();
+      }
+      fetchAbortControllersRef.current.clear();
+    }
+    const controller = new AbortController();
+    fetchAbortControllersRef.current.add(controller);
+    const librarySignal = context.signal;
+    if (cancelOnSupersede && librarySignal) {
+      if (librarySignal.aborted) {
+        controller.abort();
+      } else {
+        librarySignal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+    }
+    return latestRef.current.options.endpoint.fetch(variables, { signal: controller.signal }).finally(() => {
+      fetchAbortControllersRef.current.delete(controller);
+    });
+  }, [latestRef]);
+  const onMutate = import_react4.default.useCallback((variables, _context) => {
+    const current = latestRef.current;
+    if (!current.options.onMutate) {
+      return void 0;
+    }
+    return current.options.onMutate(variables, current.callbackCtx);
+  }, [latestRef]);
+  const onSuccess = import_react4.default.useCallback((data, variables, context) => {
+    const current = latestRef.current;
+    return current.options.onSuccess?.(data, variables, context, current.callbackCtx);
+  }, [latestRef]);
+  const onError = import_react4.default.useCallback((error, variables, context) => {
+    const current = latestRef.current;
+    return current.options.onError?.(error, variables, context, current.callbackCtx);
+  }, [latestRef]);
+  const onSettled = import_react4.default.useCallback((data, error, variables, context) => {
+    const current = latestRef.current;
+    return current.options.onSettled?.(
+      data,
+      error,
+      variables,
+      context,
+      current.callbackCtx
+    );
+  }, [latestRef]);
+  const mutation = (0, import_react_query.useMutation)({
+    mutationFn,
+    onMutate: options.onMutate ? onMutate : void 0,
+    onSuccess: options.onSuccess ? onSuccess : void 0,
+    onError: options.onError ? onError : void 0,
+    onSettled: options.onSettled ? onSettled : void 0
+  });
+  return {
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    error: mutation.error,
+    data: mutation.data,
+    reset: mutation.reset
+  };
+}
+
+// src/FrontXProvider.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function shallowEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) return false;
+  return keysA.every((k) => Object.is(a[k], b[k]));
+}
+function createProviderOwnedApp(config) {
+  return (0, import_framework3.createFrontXApp)(config);
+}
+var FrontXProvider = ({
   children,
   config,
   app: providedApp,
   mfeBridge
 }) => {
-  const app = (0, import_react3.useMemo)(() => {
+  const [stableConfig, setStableConfig] = (0, import_react5.useState)(config);
+  if (!shallowEqual(
+    stableConfig,
+    config
+  )) {
+    setStableConfig(config);
+  }
+  const app = (0, import_react5.useMemo)(() => {
     if (providedApp) {
       return providedApp;
     }
-    return (0, import_framework.createHAI3App)(config);
-  }, [providedApp, config]);
-  (0, import_react3.useEffect)(() => {
+    return createProviderOwnedApp(stableConfig);
+  }, [providedApp, stableConfig]);
+  const queryClient = useBootstrappedFrontXQueryClient(app);
+  const deferQuerySubtree = hasFrontXQueryClientActivator(app) && queryClient === void 0;
+  (0, import_react5.useEffect)(() => {
+    if (queryClient || hasFrontXQueryClientActivator(app) || process.env.NODE_ENV === "production" || process.env.NODE_ENV === "test" || process.env.VITEST === "true") {
+      return;
+    }
+    console.warn(
+      "[FrontXProvider] No query cache available. Add queryCache() or queryCacheShared() to your plugin composition. useApiQuery/useApiMutation will fail without it."
+    );
+  }, [app, queryClient]);
+  (0, import_react5.useEffect)(() => {
     return () => {
       if (!providedApp) {
         app.destroy();
       }
     };
   }, [app, providedApp]);
-  const content = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(HAI3Context.Provider, { value: app, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_redux.Provider, { store: app.store, children }) });
+  const content = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(FrontXContext.Provider, { value: app, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_redux.Provider, { store: app.store, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(FrontXQueryClientProvider, { queryClient, children: deferQuerySubtree ? null : children }) }) });
   if (mfeBridge) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MfeProvider, { value: mfeBridge, children: content });
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MfeProvider, { value: mfeBridge, children: content });
   }
   return content;
 };
 
+// src/hooks/useCanAccess.ts
+var import_react6 = require("react");
+function serializeRecordValue(value) {
+  if (value === null) return "n:";
+  if (typeof value === "string") return `s:${value}`;
+  if (typeof value === "number") {
+    return `d:${Object.is(value, -0) ? "-0" : String(value)}`;
+  }
+  return value ? "b:1" : "b:0";
+}
+function accessQueryKey(query) {
+  const { action, resource, record } = query;
+  const normalizedRecord = record ? Object.entries(record).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, serializeRecordValue(v)]) : null;
+  return JSON.stringify([action, resource, normalizedRecord]);
+}
+function getAuthRuntime(app) {
+  return app.auth ?? null;
+}
+var DENIED_NO_AUTH = { allow: false, isResolving: false };
+function useCanAccess(query) {
+  const app = useFrontX();
+  const auth2 = getAuthRuntime(app);
+  const stableKey = accessQueryKey(query);
+  const [stableQuery, setStableQuery] = (0, import_react6.useState)(() => query);
+  const [runState, setRunState] = (0, import_react6.useState)({ auth: auth2, stableKey });
+  const [result, setResult] = (0, import_react6.useState)({ allow: false, isResolving: true });
+  if (runState.auth !== auth2 || runState.stableKey !== stableKey) {
+    setRunState({ auth: auth2, stableKey });
+    setStableQuery(query);
+    setResult({ allow: false, isResolving: true });
+  }
+  (0, import_react6.useEffect)(() => {
+    if (!auth2) {
+      return;
+    }
+    let alive = true;
+    const controller = new AbortController();
+    void auth2.canAccess(stableQuery, { signal: controller.signal }).then((decision) => {
+      if (alive) {
+        setResult({ allow: decision === "allow", isResolving: false });
+      }
+    }).catch(() => {
+      if (alive) {
+        setResult({ allow: false, isResolving: false });
+      }
+    });
+    return () => {
+      alive = false;
+      controller.abort();
+    };
+  }, [auth2, stableQuery]);
+  return auth2 ? result : DENIED_NO_AUTH;
+}
+
+// src/components/CanAccess.tsx
+function CanAccess({
+  query,
+  allowed,
+  denied = null,
+  loading
+}) {
+  const { allow, isResolving } = useCanAccess(query);
+  if (isResolving) {
+    return loading !== void 0 ? loading : denied;
+  }
+  return allow ? allowed : denied;
+}
+
 // src/hooks/useAppDispatch.ts
 var import_react_redux2 = require("react-redux");
 function useAppDispatch() {
@@ -267,12 +836,12 @@ var import_react_redux3 = require("react-redux");
 var useAppSelector = import_react_redux3.useSelector;
 
 // src/hooks/useTranslation.ts
-var import_react4 = require("react");
+var import_react7 = require("react");
 function useTranslation() {
-  const app = useHAI3();
+  const app = useFrontX();
   const { i18nRegistry: i18nRegistry2 } = app;
-  const version = (0, import_react4.useSyncExternalStore)(
-    (0, import_react4.useCallback)(
+  const version = (0, import_react7.useSyncExternalStore)(
+    (0, import_react7.useCallback)(
       (callback) => {
         return i18nRegistry2.subscribe(callback);
       },
@@ -281,17 +850,17 @@ function useTranslation() {
     () => i18nRegistry2.getVersion(),
     () => i18nRegistry2.getVersion()
   );
-  const language = (0, import_react4.useMemo)(() => {
+  const language = (0, import_react7.useMemo)(() => {
     void version;
     return i18nRegistry2.getLanguage();
   }, [i18nRegistry2, version]);
-  const t = (0, import_react4.useCallback)(
+  const t = (0, import_react7.useCallback)(
     (key, params) => {
       return i18nRegistry2.t(key, params);
     },
     [i18nRegistry2]
   );
-  const setLanguage = (0, import_react4.useCallback)(
+  const setLanguage = (0, import_react7.useCallback)(
     (lang) => {
       if (app.actions.setLanguage) {
         app.actions.setLanguage({ language: lang });
@@ -299,7 +868,7 @@ function useTranslation() {
     },
     [app.actions]
   );
-  const isRTL = (0, import_react4.useMemo)(() => {
+  const isRTL = (0, import_react7.useMemo)(() => {
     void language;
     return i18nRegistry2.isRTL();
   }, [i18nRegistry2, language]);
@@ -312,29 +881,28 @@ function useTranslation() {
 }
 
 // src/hooks/useScreenTranslations.ts
-var import_react5 = require("react");
+var import_react8 = require("react");
 function isTranslationLoader(input) {
   return typeof input === "function";
 }
 function useScreenTranslations(screensetId, screenId, translations) {
-  const app = useHAI3();
+  const app = useFrontX();
   const { i18nRegistry: i18nRegistry2 } = app;
-  const [loadedLanguage, setLoadedLanguage] = (0, import_react5.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react5.useState)(false);
-  const [error, setError] = (0, import_react5.useState)(null);
-  const version = (0, import_react5.useSyncExternalStore)(
-    (0, import_react5.useCallback)(
+  const [loadedLanguage, setLoadedLanguage] = (0, import_react8.useState)(null);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const version = (0, import_react8.useSyncExternalStore)(
+    (0, import_react8.useCallback)(
       (callback) => i18nRegistry2.subscribe(callback),
       [i18nRegistry2]
     ),
     () => i18nRegistry2.getVersion(),
     () => i18nRegistry2.getVersion()
   );
-  const currentLanguage = (0, import_react5.useMemo)(() => {
+  const currentLanguage = (0, import_react8.useMemo)(() => {
     void version;
     return i18nRegistry2.getLanguage();
   }, [i18nRegistry2, version]);
-  const loader = (0, import_react5.useMemo)(() => {
+  const loader = (0, import_react8.useMemo)(() => {
     if (isTranslationLoader(translations)) {
       return translations;
     }
@@ -347,12 +915,11 @@ function useScreenTranslations(screensetId, screenId, translations) {
       return module2.default;
     };
   }, [translations]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (!currentLanguage || currentLanguage === loadedLanguage) {
       return;
     }
     let cancelled = false;
-    setIsLoading(true);
     const loadTranslations = async () => {
       try {
         const namespace = `screen.${screensetId}.${screenId}`;
@@ -361,13 +928,11 @@ function useScreenTranslations(screensetId, screenId, translations) {
         i18nRegistry2.register(namespace, currentLanguage, loadedTranslations);
         if (!cancelled) {
           setLoadedLanguage(currentLanguage);
-          setIsLoading(false);
           setError(null);
         }
       } catch (err) {
         if (!cancelled) {
           setError(err instanceof Error ? err : new Error(String(err)));
-          setIsLoading(false);
         }
       }
     };
@@ -376,29 +941,29 @@ function useScreenTranslations(screensetId, screenId, translations) {
       cancelled = true;
     };
   }, [screensetId, screenId, loader, i18nRegistry2, currentLanguage, loadedLanguage]);
-  const isLoaded = currentLanguage !== null && currentLanguage === loadedLanguage && !isLoading;
+  const isLoaded = currentLanguage !== null && currentLanguage === loadedLanguage;
   return { isLoaded, error };
 }
 
 // src/hooks/useFormatters.ts
-var import_react6 = require("react");
-var import_framework2 = require("@gears-frontx/framework");
+var import_react9 = require("react");
+var import_framework4 = require("@gears-frontx/framework");
 function useFormatters() {
   const { language } = useTranslation();
-  return (0, import_react6.useMemo)(
+  return (0, import_react9.useMemo)(
     () => {
       void language;
       return {
-        formatDate: import_framework2.formatDate,
-        formatTime: import_framework2.formatTime,
-        formatDateTime: import_framework2.formatDateTime,
-        formatRelative: import_framework2.formatRelative,
-        formatNumber: import_framework2.formatNumber,
-        formatPercent: import_framework2.formatPercent,
-        formatCompact: import_framework2.formatCompact,
-        formatCurrency: import_framework2.formatCurrency,
-        compareStrings: import_framework2.compareStrings,
-        createCollator: import_framework2.createCollator
+        formatDate: import_framework4.formatDate,
+        formatTime: import_framework4.formatTime,
+        formatDateTime: import_framework4.formatDateTime,
+        formatRelative: import_framework4.formatRelative,
+        formatNumber: import_framework4.formatNumber,
+        formatPercent: import_framework4.formatPercent,
+        formatCompact: import_framework4.formatCompact,
+        formatCurrency: import_framework4.formatCurrency,
+        compareStrings: import_framework4.compareStrings,
+        createCollator: import_framework4.createCollator
       };
     },
     [language]
@@ -406,12 +971,12 @@ function useFormatters() {
 }
 
 // src/hooks/useTheme.ts
-var import_react7 = require("react");
+var import_react10 = require("react");
 function useTheme() {
-  const app = useHAI3();
+  const app = useFrontX();
   const { themeRegistry } = app;
-  const version = (0, import_react7.useSyncExternalStore)(
-    (0, import_react7.useCallback)(
+  const version = (0, import_react10.useSyncExternalStore)(
+    (0, import_react10.useCallback)(
       (callback) => {
         return themeRegistry.subscribe(callback);
       },
@@ -420,18 +985,18 @@ function useTheme() {
     () => themeRegistry.getVersion(),
     () => themeRegistry.getVersion()
   );
-  const currentTheme = (0, import_react7.useMemo)(() => {
+  const currentTheme = (0, import_react10.useMemo)(() => {
     void version;
     const theme = themeRegistry.getCurrent();
     return theme?.id;
   }, [themeRegistry, version]);
-  const themes2 = (0, import_react7.useMemo)(() => {
+  const themes2 = (0, import_react10.useMemo)(() => {
     return themeRegistry.getAll().map((theme) => ({
       id: theme.id,
       name: theme.name
     }));
   }, [themeRegistry]);
-  const setTheme = (0, import_react7.useCallback)(
+  const setTheme = (0, import_react10.useCallback)(
     (themeId) => {
       if (app.actions.changeTheme) {
         app.actions.changeTheme({ themeId });
@@ -446,6 +1011,145 @@ function useTheme() {
   };
 }
 
+// src/hooks/useApiQuery.ts
+function useApiQuery(descriptor, overrides) {
+  return useFrontXQuery(descriptor, overrides);
+}
+
+// src/hooks/useApiSuspenseQuery.ts
+function useApiSuspenseQuery(descriptor, overrides) {
+  return useFrontXSuspenseQuery(descriptor, overrides);
+}
+
+// src/hooks/useApiInfiniteQuery.ts
+function useApiInfiniteQuery(options) {
+  return useFrontXInfiniteQuery(options);
+}
+
+// src/hooks/useApiSuspenseInfiniteQuery.ts
+function useApiSuspenseInfiniteQuery(options) {
+  return useFrontXSuspenseInfiniteQuery(options);
+}
+
+// src/hooks/useApiMutation.ts
+var import_react11 = require("react");
+function useApiMutation(options) {
+  const queryClient = useRequiredFrontXQueryClient();
+  const queryCache2 = (0, import_react11.useMemo)(() => createQueryCache(queryClient), [queryClient]);
+  const callbackCtx = (0, import_react11.useMemo)(() => ({ queryCache: queryCache2 }), [queryCache2]);
+  return useFrontXMutation(options, callbackCtx);
+}
+
+// src/hooks/useApiStream.ts
+var import_react12 = require("react");
+function useApiStream(descriptor, options) {
+  const mode = options?.mode ?? "latest";
+  const enabled = options?.enabled ?? true;
+  const [data, setData] = (0, import_react12.useState)(void 0);
+  const [events, setEvents] = (0, import_react12.useState)([]);
+  const [status, setStatus] = (0, import_react12.useState)(() => enabled ? "connecting" : "idle");
+  const [error, setError] = (0, import_react12.useState)(null);
+  const connectPromiseRef = (0, import_react12.useRef)(null);
+  const connectionIdRef = (0, import_react12.useRef)(null);
+  const disconnectRequestedRef = (0, import_react12.useRef)(false);
+  const descriptorRef = useLatest(descriptor);
+  const descriptorKey = (0, import_react12.useMemo)(() => JSON.stringify(descriptor.key), [descriptor.key]);
+  const resetKey = `${descriptorKey}:${mode}`;
+  const [prevResetKey, setPrevResetKey] = (0, import_react12.useState)(resetKey);
+  if (resetKey !== prevResetKey) {
+    setPrevResetKey(resetKey);
+    setData(void 0);
+    setEvents([]);
+    setError(null);
+  }
+  const connectKey = `${resetKey}:${enabled}`;
+  const [prevConnectKey, setPrevConnectKey] = (0, import_react12.useState)(connectKey);
+  if (connectKey !== prevConnectKey) {
+    setPrevConnectKey(connectKey);
+    if (enabled) {
+      setData(void 0);
+      setEvents([]);
+      setStatus("connecting");
+      setError(null);
+    }
+  }
+  const disconnect = (0, import_react12.useCallback)(() => {
+    disconnectRequestedRef.current = true;
+    if (connectionIdRef.current) {
+      descriptorRef.current.disconnect(connectionIdRef.current);
+      connectionIdRef.current = null;
+      disconnectRequestedRef.current = false;
+    }
+    setStatus("disconnected");
+  }, [descriptorRef]);
+  (0, import_react12.useEffect)(() => {
+    if (!enabled) {
+      return;
+    }
+    let cancelled = false;
+    disconnectRequestedRef.current = false;
+    const d = descriptorRef.current;
+    const connectPromise = d.connect(
+      (event) => {
+        if (cancelled) return;
+        setData(event);
+        setStatus("connected");
+        if (mode === "accumulate") {
+          setEvents((prev) => [...prev, event]);
+        }
+      },
+      () => {
+        if (cancelled) return;
+        setStatus("disconnected");
+        connectionIdRef.current = null;
+      }
+    );
+    connectPromiseRef.current = connectPromise;
+    connectPromise.then((id) => {
+      if (cancelled) return;
+      if (disconnectRequestedRef.current) {
+        d.disconnect(id);
+        disconnectRequestedRef.current = false;
+        return;
+      }
+      connectionIdRef.current = id;
+      setStatus("connected");
+    }).catch((err) => {
+      if (cancelled) return;
+      if (disconnectRequestedRef.current) {
+        disconnectRequestedRef.current = false;
+        setStatus("disconnected");
+        return;
+      }
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    });
+    return () => {
+      cancelled = true;
+      connectPromise.then(
+        (id) => d.disconnect(id),
+        () => {
+        }
+      );
+      connectPromiseRef.current = null;
+      connectionIdRef.current = null;
+    };
+  }, [descriptorKey, enabled, mode, descriptorRef]);
+  return { data, events, status: enabled ? status : "idle", error, disconnect };
+}
+
+// src/hooks/useQueryCache.ts
+var import_react13 = require("react");
+function useQueryCache() {
+  const queryClient = useOptionalFrontXQueryClient();
+  if (!queryClient) {
+    throw new Error(
+      "[FrontXProvider] No query cache available. Add queryCache() or queryCacheShared() to your plugin composition."
+    );
+  }
+  return (0, import_react13.useMemo)(() => createQueryCache(queryClient), [queryClient]);
+}
+
 // src/mfe/hooks/useMfeBridge.ts
 function useMfeBridge() {
   const { bridge } = useMfeContext();
@@ -453,31 +1157,31 @@ function useMfeBridge() {
 }
 
 // src/mfe/hooks/useSharedProperty.ts
-var import_react8 = require("react");
+var import_react14 = require("react");
 function useSharedProperty(propertyTypeId) {
   const { bridge } = useMfeContext();
-  const subscribe = (0, import_react8.useCallback)((callback) => {
+  const subscribe = (0, import_react14.useCallback)((callback) => {
     return bridge.subscribeToProperty(propertyTypeId, () => {
       callback();
     });
   }, [bridge, propertyTypeId]);
-  const getSnapshot = (0, import_react8.useCallback)(() => {
+  const getSnapshot = (0, import_react14.useCallback)(() => {
     const property = bridge.getProperty(propertyTypeId);
     return property?.value;
   }, [bridge, propertyTypeId]);
-  const value = (0, import_react8.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  const value = (0, import_react14.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
   return value;
 }
 
 // src/mfe/hooks/useHostAction.ts
-var import_react9 = require("react");
+var import_react15 = require("react");
 function useHostAction(actionTypeId) {
   const { bridge } = useMfeContext();
-  return (0, import_react9.useCallback)((payload) => {
+  return (0, import_react15.useCallback)((payload) => {
     const chain = {
       action: {
         type: actionTypeId,
-        target: bridge.domainId,
+        target: bridge.extDomainId,
         payload
       }
     };
@@ -491,23 +1195,23 @@ function useHostAction(actionTypeId) {
 }
 
 // src/mfe/hooks/useDomainExtensions.ts
-var import_react10 = require("react");
+var import_react16 = require("react");
 function useDomainExtensions(domainId) {
-  const app = useHAI3();
-  const registry = app.screensetsRegistry;
+  const app = useFrontX();
+  const registry = app.mfeRegistry;
   if (!registry) {
     throw new Error(
-      "useDomainExtensions requires the microfrontends plugin. Add microfrontends() to your HAI3 app configuration."
+      "useDomainExtensions requires the microfrontends plugin. Add microfrontends() to your Gears FrontX app configuration."
     );
   }
-  const subscribe = (0, import_react10.useCallback)(
+  const subscribe = (0, import_react16.useCallback)(
     (onStoreChange) => {
       return app.store.subscribe(onStoreChange);
     },
     [app.store]
   );
-  const cacheRef = (0, import_react10.useRef)({ ids: "", extensions: [] });
-  const getSnapshot = (0, import_react10.useCallback)(() => {
+  const cacheRef = (0, import_react16.useRef)({ ids: "", extensions: [] });
+  const getSnapshot = (0, import_react16.useCallback)(() => {
     const extensions = registry.getExtensionsForDomain(domainId);
     const ids = extensions.map((e) => e.id).join(",");
     if (ids !== cacheRef.current.ids) {
@@ -515,205 +1219,221 @@ function useDomainExtensions(domainId) {
     }
     return cacheRef.current.extensions;
   }, [registry, domainId]);
-  return (0, import_react10.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  return (0, import_react16.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
 }
 
-// src/mfe/hooks/useRegisteredPackages.ts
-var import_react11 = require("react");
-function useRegisteredPackages() {
-  const app = useHAI3();
-  const registry = app.screensetsRegistry;
+// src/mfe/hooks/useMountedExtensions.ts
+var import_react17 = require("react");
+function useMountedExtensions(domainId) {
+  const app = useFrontX();
+  const registry = app.mfeRegistry;
   if (!registry) {
     throw new Error(
-      "useRegisteredPackages requires the microfrontends plugin. Add microfrontends() to your HAI3 app configuration."
+      "useMountedExtensions requires the microfrontends plugin. Add microfrontends() to your Gears FrontX app configuration."
     );
   }
-  const subscribe = (0, import_react11.useCallback)(
+  const subscribe = (0, import_react17.useCallback)(
     (onStoreChange) => {
       return app.store.subscribe(onStoreChange);
     },
     [app.store]
   );
-  const cacheRef = (0, import_react11.useRef)({ packages: "", list: [] });
-  const getSnapshot = (0, import_react11.useCallback)(() => {
-    const list = registry.getRegisteredPackages();
-    const packages = list.join(",");
-    if (packages !== cacheRef.current.packages) {
-      cacheRef.current = { packages, list };
+  const cacheRef = (0, import_react17.useRef)({ key: "", extensions: [] });
+  const getSnapshot = (0, import_react17.useCallback)(() => {
+    const ids = registry.getMountedExtensions(domainId);
+    const resolved = ids.map((id) => registry.getExtension(id)).filter((ext) => ext !== void 0);
+    const key = ids.join(",");
+    if (key !== cacheRef.current.key) {
+      cacheRef.current = { key, extensions: resolved };
     }
-    return cacheRef.current.list;
-  }, [registry]);
-  return (0, import_react11.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+    return cacheRef.current.extensions;
+  }, [registry, domainId]);
+  return (0, import_react17.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
 }
 
-// src/mfe/hooks/useActivePackage.ts
-var import_react12 = require("react");
-var import_framework3 = require("@gears-frontx/framework");
-function useActivePackage() {
-  const app = useHAI3();
-  const registry = app.screensetsRegistry;
+// src/mfe/hooks/useRegisteredPackages.ts
+var import_react18 = require("react");
+function useRegisteredPackages() {
+  const app = useFrontX();
+  const registry = app.mfeRegistry;
   if (!registry) {
     throw new Error(
-      "useActivePackage requires the microfrontends plugin. Add microfrontends() to your HAI3 app configuration."
+      "useRegisteredPackages requires the microfrontends plugin. Add microfrontends() to your Gears FrontX app configuration."
     );
   }
-  const subscribe = (0, import_react12.useCallback)(
+  const subscribe = (0, import_react18.useCallback)(
     (onStoreChange) => {
       return app.store.subscribe(onStoreChange);
     },
     [app.store]
   );
-  const cacheRef = (0, import_react12.useRef)({ activePackage: void 0 });
-  const getSnapshot = (0, import_react12.useCallback)(() => {
-    const mountedExtensionId = registry.getMountedExtension(import_framework3.FRONTX_SCREEN_DOMAIN);
-    if (!mountedExtensionId) {
-      const result = void 0;
-      if (result !== cacheRef.current.activePackage) {
-        cacheRef.current = { activePackage: result };
-      }
-      return cacheRef.current.activePackage;
-    }
-    const activePackage = (0, import_framework3.extractGtsPackage)(mountedExtensionId);
-    if (activePackage !== cacheRef.current.activePackage) {
-      cacheRef.current = { activePackage };
+  const cacheRef = (0, import_react18.useRef)({ packages: "", list: [] });
+  const getSnapshot = (0, import_react18.useCallback)(() => {
+    const list = registry.getRegisteredPackages();
+    const packages = list.join(",");
+    if (packages !== cacheRef.current.packages) {
+      cacheRef.current = { packages, list };
     }
-    return cacheRef.current.activePackage;
+    return cacheRef.current.list;
   }, [registry]);
-  return (0, import_react12.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  return (0, import_react18.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
 }
 
-// src/mfe/components/RefContainerProvider.ts
-var import_framework4 = require("@gears-frontx/framework");
-var RefContainerProvider = class extends import_framework4.ContainerProvider {
-  constructor(containerRef) {
-    super();
-    this.containerRef = containerRef;
+// src/mfe/ThemeAwareReactLifecycle.tsx
+var import_client = require("react-dom/client");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function resolveProviderMountOptions(app, bridge, mountContext) {
+  const extensionId = mountContext?.extensionId;
+  const domainId = mountContext?.domainId;
+  const isMountedMfe = typeof extensionId === "string" && typeof domainId === "string";
+  if (isMountedMfe && !resolveFrontXQueryClient(app) && !hasFrontXQueryClientActivator(app)) {
+    throw new Error(
+      "[FrontXProvider] Mounted MFEs require queryCacheShared() in the child app and queryCache() in the host app before loading the MFE app."
+    );
   }
-  getContainer(_extensionId) {
-    if (!this.containerRef.current) {
-      throw new Error("Container ref is not attached -- component may not be mounted yet");
+  return {
+    mfeBridge: isMountedMfe ? { bridge, extensionId, domainId } : void 0
+  };
+}
+function MountRuntimeAwareProvider({
+  app,
+  mfeBridge,
+  children
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FrontXProvider, { app, mfeBridge, children });
+}
+var ThemeAwareReactLifecycle = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  root = null;
+  mount(container, bridge, mountContext) {
+    if (container instanceof ShadowRoot) {
+      this.adoptHostStylesIntoShadowRoot(container);
     }
-    return this.containerRef.current;
+    this.injectBaseResets(container);
+    this.initializeStyles(container);
+    const providerMountOptions = resolveProviderMountOptions(this.app, bridge, mountContext);
+    this.root = (0, import_client.createRoot)(container);
+    this.root.render(
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        MountRuntimeAwareProvider,
+        {
+          app: this.app,
+          mfeBridge: providerMountOptions.mfeBridge,
+          children: this.renderContent(bridge)
+        }
+      )
+    );
   }
-  releaseContainer(_extensionId) {
+  unmount(_container) {
+    if (this.root) {
+      this.root.unmount();
+      this.root = null;
+    }
+  }
+  /**
+   * Copy all inline <style> and <link rel="stylesheet"> from the host document
+   * into the shadow root so that Tailwind and component styles apply inside the MFE.
+   */
+  adoptHostStylesIntoShadowRoot(shadowRoot) {
+    const styleElements = document.head.querySelectorAll("style");
+    styleElements.forEach((el) => {
+      const clone = document.createElement("style");
+      clone.textContent = el.textContent ?? "";
+      shadowRoot.appendChild(clone);
+    });
+    const linkElements = document.head.querySelectorAll('link[rel="stylesheet"]');
+    linkElements.forEach((el) => {
+      const clone = el.cloneNode(true);
+      shadowRoot.appendChild(clone);
+    });
+  }
+  /**
+   * Box-model resets and :host defaults needed inside every shadow root.
+   * These aren't part of Tailwind's compiled output but are required for
+   * consistent rendering across browsers.
+   */
+  injectBaseResets(container) {
+    const style = document.createElement("style");
+    style.textContent = `
+      *, *::before, *::after {
+        box-sizing: border-box;
+        border-width: 0;
+        border-style: solid;
+        border-color: currentColor;
+      }
+      * { margin: 0; padding: 0; }
+      :host {
+        font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+        line-height: 1.5;
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+        color: hsl(var(--foreground));
+        background-color: hsl(var(--background));
+      }
+    `;
+    container.appendChild(style);
+  }
+  /**
+   * Hook for subclasses to inject additional CSS not covered by the adopted host
+   * stylesheet (e.g., MFE-specific @font-face rules or custom animations).
+   * No-op by default: host styles adopted in adoptHostStylesIntoShadowRoot()
+   * already include all Tailwind utilities compiled from MFE source files.
+   */
+  initializeStyles(_container) {
   }
 };
 
 // src/mfe/components/ExtensionDomainSlot.tsx
-var import_react13 = require("react");
-var import_framework5 = require("@gears-frontx/framework");
-var import_jsx_runtime3 = require("react/jsx-runtime");
+var import_react19 = require("react");
+var import_jsx_runtime5 = require("react/jsx-runtime");
 function ExtensionDomainSlot(props) {
   const {
     registry,
     domainId,
-    extensionId,
     className,
-    onMounted,
-    onUnmounted,
-    onError,
-    loadingComponent,
-    errorComponent
+    onAttached,
+    onDetached,
+    loadingComponent = null
   } = props;
-  const containerRef = (0, import_react13.useRef)(null);
-  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
-  const [error, setError] = (0, import_react13.useState)(null);
-  const [bridge, setBridge] = (0, import_react13.useState)(null);
-  (0, import_react13.useEffect)(() => {
-    let mounted = true;
-    let currentBridge = null;
-    async function mountExtension2() {
-      if (!containerRef.current) {
-        return;
-      }
-      try {
-        setIsLoading(true);
-        setError(null);
-        await registry.executeActionsChain({
-          action: {
-            type: import_framework5.FRONTX_ACTION_MOUNT_EXT,
-            target: domainId,
-            payload: {
-              extensionId
-            }
-          }
-        });
-        if (!mounted) {
-          await registry.executeActionsChain({
-            action: {
-              type: import_framework5.FRONTX_ACTION_UNMOUNT_EXT,
-              target: domainId,
-              payload: {
-                extensionId
-              }
-            }
-          });
-          return;
-        }
-        const newBridge = registry.getParentBridge(extensionId);
-        if (!newBridge) {
-          throw new Error(`Failed to obtain bridge for extension ${extensionId} after mount`);
-        }
-        currentBridge = newBridge;
-        setBridge(newBridge);
-        setIsLoading(false);
-        if (onMounted) {
-          onMounted(newBridge);
-        }
-      } catch (err) {
-        if (!mounted) {
-          return;
-        }
-        const errorObj = err instanceof Error ? err : new Error(String(err));
-        setError(errorObj);
-        setIsLoading(false);
-        if (onError) {
-          onError(errorObj);
-        }
-      }
+  const rootRef = (0, import_react19.useRef)(null);
+  const emitAttached = (0, import_react19.useEffectEvent)((root) => {
+    onAttached?.(root);
+  });
+  const emitDetached = (0, import_react19.useEffectEvent)(() => {
+    onDetached?.();
+  });
+  const [attached, setAttached] = (0, import_react19.useState)(false);
+  (0, import_react19.useEffect)(() => {
+    const root = rootRef.current;
+    if (!root) {
+      return;
     }
-    void mountExtension2();
+    const mounter = registry.getMounter(domainId);
+    mounter.attach(root);
+    setAttached(true);
+    emitAttached(root);
     return () => {
-      mounted = false;
-      if (currentBridge) {
-        void registry.executeActionsChain({
-          action: {
-            type: import_framework5.FRONTX_ACTION_UNMOUNT_EXT,
-            target: domainId,
-            payload: {
-              extensionId
-            }
-          }
-        }).then(() => {
-          if (onUnmounted) {
-            onUnmounted();
-          }
-        });
-      }
+      void mounter.detach();
+      setAttached(false);
+      emitDetached();
     };
-  }, [registry, domainId, extensionId, onMounted, onUnmounted, onError]);
-  if (isLoading) {
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className, "data-domain-id": domainId, "data-extension-id": extensionId, children: loadingComponent ?? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { children: "Loading extension..." }) });
-  }
-  if (error) {
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className, "data-domain-id": domainId, "data-extension-id": extensionId, children: errorComponent ? errorComponent(error) : /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("strong", { children: "Error loading extension:" }),
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("pre", { children: error.message })
-    ] }) });
-  }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+  }, [registry, domainId]);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
     "div",
     {
-      ref: containerRef,
+      ref: rootRef,
       className,
       "data-domain-id": domainId,
-      "data-extension-id": extensionId,
-      "data-bridge-active": bridge !== null
+      children: !attached ? loadingComponent : null
     }
   );
 }
 
 // src/index.ts
+var import_framework5 = require("@gears-frontx/framework");
 var import_framework6 = require("@gears-frontx/framework");
 var import_framework7 = require("@gears-frontx/framework");
 var import_framework8 = require("@gears-frontx/framework");
@@ -727,17 +1447,23 @@ var import_framework15 = require("@gears-frontx/framework");
 var import_framework16 = require("@gears-frontx/framework");
 var import_framework17 = require("@gears-frontx/framework");
 var import_framework18 = require("@gears-frontx/framework");
-var import_framework19 = require("@gears-frontx/framework");
-var eventBus = import_framework19.eventBus;
+var eventBus2 = import_framework18.eventBus;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNTS_DOMAIN,
+  ActionHandler,
   ApiPlugin,
   ApiPluginBase,
   ApiProtocol,
   BaseApiService,
-  ContainerProvider,
+  CanAccess,
+  ChildMfeBridge,
+  ConcurrentMountStrategy,
+  ExclusiveMountStrategy,
+  ExtensionDomainImplementation,
+  ExtensionDomainImplementationFactory,
   ExtensionDomainSlot,
+  ExtensionMounter,
   FRONTX_ACTION_LOAD_EXT,
   FRONTX_ACTION_MOUNT_EXT,
   FRONTX_ACTION_UNMOUNT_EXT,
@@ -749,8 +1475,8 @@ var eventBus = import_framework19.eventBus;
   FRONTX_SHARED_PROPERTY_LANGUAGE,
   FRONTX_SHARED_PROPERTY_THEME,
   FRONTX_SIDEBAR_DOMAIN,
-  HAI3Context,
-  HAI3Provider,
+  FrontXContext,
+  FrontXProvider,
   I18nRegistry,
   I18nRegistryImpl,
   LAYOUT_SLICE_NAME,
@@ -763,34 +1489,39 @@ var eventBus = import_framework19.eventBus;
   MfeHandler,
   MfeHandlerMF,
   MfeProvider,
+  MfeRegistry,
+  MfeRegistryFactory,
   MockEventSource,
   MockEvents,
-  RefContainerProvider,
+  MountStrategy,
+  OptionalMountStrategy,
+  ParentMfeBridge,
+  RestEndpointProtocol,
   RestMockPlugin,
   RestPlugin,
   RestPluginWithConfig,
   RestProtocol,
   SUPPORTED_LANGUAGES,
-  ScreensetsRegistry,
-  ScreensetsRegistryFactory,
   SseMockPlugin,
   SsePlugin,
   SsePluginWithConfig,
   SseProtocol,
+  SseStreamProtocol,
   TENANT_SLICE_NAME,
   TenantEvents,
   TextDirection,
+  ThemeAwareReactLifecycle,
   apiRegistry,
+  auth,
   changeTenant,
-  clearActiveScreen,
   clearTenant,
   clearTenantAction,
   clearUser,
   closeAllPopups,
   closePopup,
   closeTopPopup,
-  createHAI3,
-  createHAI3App,
+  createFrontX,
+  createFrontXApp,
   createI18nRegistry,
   createShadowRoot,
   createSlice,
@@ -802,6 +1533,7 @@ var eventBus = import_framework19.eventBus;
   extractGtsPackage,
   footerActions,
   footerSlice,
+  frontxApiTransport,
   getLanguageMetadata,
   getStore,
   gtsPlugin,
@@ -814,6 +1546,7 @@ var eventBus = import_framework19.eventBus;
   initMockEffects,
   initTenantEffects,
   injectCssVariables,
+  invalidateQueryCacheForApp,
   isMockPlugin,
   isRestShortCircuit,
   isShortCircuit,
@@ -825,12 +1558,12 @@ var eventBus = import_framework19.eventBus;
   loadExtension,
   menuActions,
   menuSlice,
+  mfeRegistryFactory,
   microfrontends,
   mock,
   mockActions,
   mockSlice,
   mountExtension,
-  navigateTo,
   openPopup,
   overlayActions,
   overlayDomain,
@@ -839,17 +1572,15 @@ var eventBus = import_framework19.eventBus;
   popupDomain,
   popupSlice,
   presets,
+  queryCache,
+  queryCacheShared,
   registerExtension,
   registerSlice,
-  screenActions,
   screenDomain,
-  screenSlice,
-  screensets,
-  screensetsRegistryFactory,
   selectExtensionError,
   selectExtensionState,
+  selectMountedExtensions,
   selectRegisteredExtensions,
-  setActiveScreen,
   setFooterConfig,
   setFooterVisible,
   setHeaderLoading,
@@ -859,7 +1590,6 @@ var eventBus = import_framework19.eventBus;
   setMenuVisible,
   setMockEnabled,
   setOverlayVisible,
-  setScreenLoading,
   setSidebarCollapsed,
   setSidebarConfig,
   setSidebarContent,
@@ -875,6 +1605,7 @@ var eventBus = import_framework19.eventBus;
   sidebarActions,
   sidebarDomain,
   sidebarSlice,
+  subscribeQueryCacheRuntimeChanged,
   tenantActions,
   tenantReducer,
   tenantSlice,
@@ -885,15 +1616,23 @@ var eventBus = import_framework19.eventBus;
   toggleSidebar,
   unmountExtension,
   unregisterExtension,
-  useActivePackage,
+  useApiInfiniteQuery,
+  useApiMutation,
+  useApiQuery,
+  useApiStream,
+  useApiSuspenseInfiniteQuery,
+  useApiSuspenseQuery,
   useAppDispatch,
   useAppSelector,
+  useCanAccess,
   useDomainExtensions,
   useFormatters,
-  useHAI3,
+  useFrontX,
   useHostAction,
   useMfeBridge,
   useMfeContext,
+  useMountedExtensions,
+  useQueryCache,
   useRegisteredPackages,
   useScreenTranslations,
   useSharedProperty,