@gears-frontx/react 0.2.0-alpha.0 → 0.2.0-alpha.15

package/dist/index.cjs

@@ -30,172 +30,164 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  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,
+  ACCOUNTS_DOMAIN: () => import_framework4.ACCOUNTS_DOMAIN,
+  ActionHandler: () => import_framework13.ActionHandler,
+  ApiPlugin: () => import_framework4.ApiPlugin,
+  ApiPluginBase: () => import_framework4.ApiPluginBase,
+  ApiProtocol: () => import_framework4.ApiProtocol,
+  AuthEvents: () => import_framework4.AuthEvents,
+  BaseApiService: () => import_framework4.BaseApiService,
   CanAccess: () => CanAccess,
-  ChildMfeBridge: () => import_framework14.ChildMfeBridge,
-  ConcurrentMountStrategy: () => import_framework14.ConcurrentMountStrategy,
-  ExclusiveMountStrategy: () => import_framework14.ExclusiveMountStrategy,
-  ExtensionDomainImplementation: () => import_framework14.ExtensionDomainImplementation,
-  ExtensionDomainImplementationFactory: () => import_framework14.ExtensionDomainImplementationFactory,
+  ChildMfeBridge: () => import_framework13.ChildMfeBridge,
+  ConcurrentMountStrategy: () => import_framework13.ConcurrentMountStrategy,
+  ExclusiveMountStrategy: () => import_framework13.ExclusiveMountStrategy,
+  ExtensionDomainImplementation: () => import_framework13.ExtensionDomainImplementation,
+  ExtensionDomainImplementationFactory: () => import_framework13.ExtensionDomainImplementationFactory,
   ExtensionDomainSlot: () => ExtensionDomainSlot,
-  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,
+  ExtensionMounter: () => import_framework13.ExtensionMounter,
+  FRONTX_ACTION_LOAD_EXT: () => import_framework11.FRONTX_ACTION_LOAD_EXT,
+  FRONTX_ACTION_MOUNT_EXT: () => import_framework11.FRONTX_ACTION_MOUNT_EXT,
+  FRONTX_ACTION_UNMOUNT_EXT: () => import_framework11.FRONTX_ACTION_UNMOUNT_EXT,
+  FRONTX_MFE_ENTRY_MF: () => import_framework10.FRONTX_MFE_ENTRY_MF,
+  FRONTX_OVERLAY_DOMAIN: () => import_framework9.FRONTX_OVERLAY_DOMAIN,
+  FRONTX_POPUP_DOMAIN: () => import_framework9.FRONTX_POPUP_DOMAIN,
+  FRONTX_SCREEN_DOMAIN: () => import_framework9.FRONTX_SCREEN_DOMAIN,
+  FRONTX_SCREEN_EXTENSION_TYPE: () => import_framework10.FRONTX_SCREEN_EXTENSION_TYPE,
+  FRONTX_SHARED_PROPERTY_LANGUAGE: () => import_framework12.FRONTX_SHARED_PROPERTY_LANGUAGE,
+  FRONTX_SHARED_PROPERTY_THEME: () => import_framework12.FRONTX_SHARED_PROPERTY_THEME,
+  FRONTX_SIDEBAR_DOMAIN: () => import_framework9.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,
+  I18nRegistry: () => import_framework4.I18nRegistry,
+  I18nRegistryImpl: () => import_framework4.I18nRegistryImpl,
+  LAYOUT_SLICE_NAME: () => import_framework4.LAYOUT_SLICE_NAME,
+  Language: () => import_framework5.Language,
+  LanguageDisplayMode: () => import_framework5.LanguageDisplayMode,
+  MOCK_PLUGIN: () => import_framework4.MOCK_PLUGIN,
+  MfeBridgeFactory: () => import_framework13.MfeBridgeFactory,
   MfeContext: () => MfeContext,
-  MfeHandler: () => import_framework14.MfeHandler,
-  MfeHandlerMF: () => import_framework15.MfeHandlerMF,
+  MfeHandler: () => import_framework13.MfeHandler,
+  MfeHandlerMF: () => import_framework14.MfeHandlerMF,
   MfeProvider: () => MfeProvider,
-  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,
+  MfeRegistry: () => import_framework13.MfeRegistry,
+  MfeRegistryFactory: () => import_framework13.MfeRegistryFactory,
+  MockEvents: () => import_framework4.MockEvents,
+  MountStrategy: () => import_framework13.MountStrategy,
+  OptionalMountStrategy: () => import_framework13.OptionalMountStrategy,
+  ParentMfeBridge: () => import_framework13.ParentMfeBridge,
+  RestEndpointProtocol: () => import_framework4.RestEndpointProtocol,
+  RestPlugin: () => import_framework4.RestPlugin,
+  RestPluginWithConfig: () => import_framework4.RestPluginWithConfig,
+  RestProtocol: () => import_framework4.RestProtocol,
+  SUPPORTED_LANGUAGES: () => import_framework4.SUPPORTED_LANGUAGES,
+  SsePlugin: () => import_framework4.SsePlugin,
+  SsePluginWithConfig: () => import_framework4.SsePluginWithConfig,
+  SseProtocol: () => import_framework4.SseProtocol,
+  SseStreamProtocol: () => import_framework4.SseStreamProtocol,
+  TENANT_SLICE_NAME: () => import_framework4.TENANT_SLICE_NAME,
+  TenantEvents: () => import_framework4.TenantEvents,
+  TextDirection: () => import_framework5.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,
+  apiRegistry: () => import_framework4.apiRegistry,
+  auth: () => import_framework4.auth,
+  changeTenant: () => import_framework4.changeTenant,
+  clearTenant: () => import_framework4.clearTenant,
+  clearTenantAction: () => import_framework4.clearTenantAction,
+  clearUser: () => import_framework4.clearUser,
+  closeAllPopups: () => import_framework4.closeAllPopups,
+  closePopup: () => import_framework4.closePopup,
+  closeTopPopup: () => import_framework4.closeTopPopup,
+  createFrontX: () => import_framework4.createFrontX,
+  createI18nRegistry: () => import_framework4.createI18nRegistry,
+  createShadowRoot: () => import_framework15.createShadowRoot,
+  createSlice: () => import_framework4.createSlice,
+  createStore: () => import_framework4.createStore,
+  createThemeRegistry: () => import_framework4.createThemeRegistry,
+  effects: () => import_framework4.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,
+  extractGtsPackage: () => import_framework15.extractGtsPackage,
+  footerActions: () => import_framework4.footerActions,
+  footerSlice: () => import_framework4.footerSlice,
+  frontxApiTransport: () => import_framework4.frontxApiTransport,
+  getLanguageMetadata: () => import_framework4.getLanguageMetadata,
+  getStore: () => import_framework4.getStore,
+  gtsPlugin: () => import_framework14.gtsPlugin,
+  hasSlice: () => import_framework4.hasSlice,
+  headerActions: () => import_framework4.headerActions,
+  headerSlice: () => import_framework4.headerSlice,
+  hideOverlay: () => import_framework4.hideOverlay,
+  i18n: () => import_framework4.i18n,
+  i18nRegistry: () => import_framework4.i18nRegistry,
+  initMockEffects: () => import_framework4.initMockEffects,
+  initTenantEffects: () => import_framework4.initTenantEffects,
+  injectCssVariables: () => import_framework15.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,
+  isMockPlugin: () => import_framework4.isMockPlugin,
+  isRestShortCircuit: () => import_framework4.isRestShortCircuit,
+  isShortCircuit: () => import_framework4.isShortCircuit,
+  isSseShortCircuit: () => import_framework4.isSseShortCircuit,
+  layout: () => import_framework4.layout,
+  layoutDomainReducers: () => import_framework4.layoutDomainReducers,
+  layoutReducer: () => import_framework4.layoutReducer,
+  loadExtension: () => import_framework7.loadExtension,
+  menuActions: () => import_framework4.menuActions,
+  menuSlice: () => import_framework4.menuSlice,
+  mfeRegistryFactory: () => import_framework13.mfeRegistryFactory,
+  microfrontends: () => import_framework6.microfrontends,
+  mock: () => import_framework6.mock,
+  mockActions: () => import_framework4.mockActions,
+  mockSlice: () => import_framework4.mockSlice,
+  mountExtension: () => import_framework7.mountExtension,
+  openPopup: () => import_framework4.openPopup,
+  overlayActions: () => import_framework4.overlayActions,
+  overlayDomain: () => import_framework9.overlayDomain,
+  overlaySlice: () => import_framework4.overlaySlice,
+  popupActions: () => import_framework4.popupActions,
+  popupDomain: () => import_framework9.popupDomain,
+  popupSlice: () => import_framework4.popupSlice,
+  presets: () => import_framework4.presets,
+  queryCache: () => import_framework4.queryCache,
+  queryCacheShared: () => import_framework4.queryCacheShared,
+  registerExtension: () => import_framework7.registerExtension,
+  registerSlice: () => import_framework4.registerSlice,
+  screenDomain: () => import_framework9.screenDomain,
+  selectExtensionError: () => import_framework8.selectExtensionError,
+  selectExtensionState: () => import_framework8.selectExtensionState,
+  selectRegisteredExtensions: () => import_framework8.selectRegisteredExtensions,
+  setFooterConfig: () => import_framework4.setFooterConfig,
+  setFooterVisible: () => import_framework4.setFooterVisible,
+  setHeaderLoading: () => import_framework4.setHeaderLoading,
+  setMenuCollapsed: () => import_framework4.setMenuCollapsed,
+  setMenuConfig: () => import_framework4.setMenuConfig,
+  setMenuItems: () => import_framework4.setMenuItems,
+  setMenuVisible: () => import_framework4.setMenuVisible,
+  setMockEnabled: () => import_framework4.setMockEnabled,
+  setOverlayVisible: () => import_framework4.setOverlayVisible,
+  setSidebarCollapsed: () => import_framework4.setSidebarCollapsed,
+  setSidebarConfig: () => import_framework4.setSidebarConfig,
+  setSidebarContent: () => import_framework4.setSidebarContent,
+  setSidebarPosition: () => import_framework4.setSidebarPosition,
+  setSidebarTitle: () => import_framework4.setSidebarTitle,
+  setSidebarVisible: () => import_framework4.setSidebarVisible,
+  setSidebarWidth: () => import_framework4.setSidebarWidth,
+  setTenant: () => import_framework4.setTenant,
+  setTenantLoading: () => import_framework4.setTenantLoading,
+  setTenantLoadingState: () => import_framework4.setTenantLoadingState,
+  setUser: () => import_framework4.setUser,
+  showOverlay: () => import_framework4.showOverlay,
+  sidebarActions: () => import_framework4.sidebarActions,
+  sidebarDomain: () => import_framework9.sidebarDomain,
+  sidebarSlice: () => import_framework4.sidebarSlice,
+  subscribeQueryCacheRuntimeChanged: () => import_framework4.subscribeQueryCacheRuntimeChanged,
+  tenantActions: () => import_framework4.tenantActions,
+  tenantReducer: () => import_framework4.tenantReducer,
+  tenantSlice: () => import_framework4.tenantSlice,
+  themes: () => import_framework4.themes,
+  toggleMenu: () => import_framework4.toggleMenu,
+  toggleMockMode: () => import_framework4.toggleMockMode,
+  toggleSidebar: () => import_framework4.toggleSidebar,
+  unmountExtension: () => import_framework7.unmountExtension,
+  unregisterExtension: () => import_framework7.unregisterExtension,
   useApiInfiniteQuery: () => useApiInfiniteQuery,
   useApiMutation: () => useApiMutation,
   useApiQuery: () => useApiQuery,
@@ -211,7 +203,7 @@ __export(src_exports, {
   useHostAction: () => useHostAction,
   useMfeBridge: () => useMfeBridge,
   useMfeContext: () => useMfeContext,
-  useMountedExtensions: () => useMountedExtensions,
+  useMfeRegistry: () => useMfeRegistry,
   useQueryCache: () => useQueryCache,
   useRegisteredPackages: () => useRegisteredPackages,
   useScreenTranslations: () => useScreenTranslations,
@@ -222,9 +214,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/FrontXProvider.tsx
-var import_react4 = require("react");
+var import_react5 = require("react");
 var import_react_redux = require("react-redux");
-var import_framework3 = require("@gears-frontx/framework");
 
 // src/FrontXContext.tsx
 var import_react = require("react");
@@ -259,7 +250,7 @@ var MfeProvider = ({ value, children }) => {
 };
 
 // src/queryClient.tsx
-var import_react3 = __toESM(require("react"), 1);
+var import_react4 = __toESM(require("react"), 1);
 var import_react_query = require("@tanstack/react-query");
 var import_framework2 = require("@gears-frontx/framework");
 
@@ -368,13 +359,23 @@ function createQueryCache(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 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_react3.createContext)(void 0);
-var useCommitEffect = typeof globalThis.window === "undefined" ? import_react3.useEffect : import_react3.useLayoutEffect;
+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]?.();
@@ -399,8 +400,8 @@ function bootstrapFrontXQueryClient(app) {
   return resolveFrontXQueryClient(app);
 }
 function useBootstrappedFrontXQueryClient(app) {
-  const fromApp = (0, import_react3.useMemo)(() => bootstrapFrontXQueryClient(app), [app]);
-  const [eventResolvedClient, setEventResolvedClient] = (0, import_react3.useState)(
+  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);
@@ -442,7 +443,7 @@ function FrontXQueryClientProvider({
   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_react3.useContext)(FrontXQueryClientContext);
+  return (0, import_react4.useContext)(FrontXQueryClientContext);
 }
 function useRequiredFrontXQueryClient() {
   const queryClient = useOptionalFrontXQueryClient();
@@ -465,24 +466,45 @@ function normalizeFetchStaleTime(staleTime) {
   if (staleTime === "static") {
     return Number.POSITIVE_INFINITY;
   }
+  if (typeof staleTime === "function") {
+    return 0;
+  }
   return typeof staleTime === "number" ? staleTime : void 0;
 }
-function resolveFetchStaleTime(queryClient, descriptor, overrideStaleTime) {
+function resolveFetchStaleTime(queryClient, queryKey, descriptor, overrideStaleTime) {
+  const clientDefaults = {
+    ...queryClient.getDefaultOptions().queries,
+    ...queryClient.getQueryDefaults(queryKey)
+  };
   return normalizeFetchStaleTime(
-    overrideStaleTime ?? descriptor.staleTime ?? queryClient.getDefaultOptions().queries?.staleTime
+    overrideStaleTime ?? descriptor.staleTime ?? clientDefaults.staleTime
   );
 }
+function cacheTimeOptions(staleTime, gcTime) {
+  return {
+    ...staleTime === void 0 ? {} : { staleTime },
+    ...gcTime === void 0 ? {} : { gcTime }
+  };
+}
 function fetchDescriptor(descriptor, options) {
   return descriptor.fetch(options);
 }
 function useFrontXQuery(descriptor, overrides) {
   const queryClient = useRequiredFrontXQueryClient();
-  const staleTime = resolveFetchStaleTime(queryClient, descriptor, overrides?.staleTime);
+  const staleTime = resolveFetchStaleTime(
+    queryClient,
+    descriptor.key,
+    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
+    ...cacheTimeOptions(
+      overrides?.staleTime ?? descriptor.staleTime,
+      overrides?.gcTime ?? descriptor.gcTime
+    ),
+    ...overrides?.enabled === void 0 ? {} : { enabled: overrides.enabled }
   });
   return {
     data: result.data,
@@ -495,12 +517,19 @@ function useFrontXQuery(descriptor, overrides) {
 }
 function useFrontXSuspenseQuery(descriptor, overrides) {
   const queryClient = useRequiredFrontXQueryClient();
-  const staleTime = resolveFetchStaleTime(queryClient, descriptor, overrides?.staleTime);
+  const staleTime = resolveFetchStaleTime(
+    queryClient,
+    descriptor.key,
+    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
+    ...cacheTimeOptions(
+      overrides?.staleTime ?? descriptor.staleTime,
+      overrides?.gcTime ?? descriptor.gcTime
+    )
   });
   return {
     data: result.data,
@@ -518,7 +547,12 @@ function useFrontXInfiniteQuery(options) {
     initialPageParam: options.initialPage,
     queryFn: ({ pageParam, signal }) => fetchDescriptor(pageParam, {
       signal,
-      staleTime: resolveFetchStaleTime(queryClient, pageParam, options.staleTime)
+      staleTime: resolveFetchStaleTime(
+        queryClient,
+        options.initialPage.key,
+        pageParam,
+        options.staleTime
+      )
     }),
     getNextPageParam: (lastPage, allPages, lastPageDescriptor, allPageDescriptors) => options.getNextPage(
       buildPageContext(
@@ -537,9 +571,12 @@ function useFrontXInfiniteQuery(options) {
       )
     ) : void 0,
     select: (data) => data.pages,
-    staleTime: options.staleTime ?? options.initialPage.staleTime,
-    gcTime: options.gcTime ?? options.initialPage.gcTime,
-    maxPages: options.maxPages
+    ...cacheTimeOptions(
+      options.staleTime ?? options.initialPage.staleTime,
+      options.gcTime ?? options.initialPage.gcTime
+    ),
+    maxPages: options.maxPages,
+    ...options.enabled === void 0 ? {} : { enabled: options.enabled }
   });
   return {
     data: result.data,
@@ -569,7 +606,12 @@ function useFrontXSuspenseInfiniteQuery(options) {
     initialPageParam: options.initialPage,
     queryFn: ({ pageParam, signal }) => fetchDescriptor(pageParam, {
       signal,
-      staleTime: resolveFetchStaleTime(queryClient, pageParam, options.staleTime)
+      staleTime: resolveFetchStaleTime(
+        queryClient,
+        options.initialPage.key,
+        pageParam,
+        options.staleTime
+      )
     }),
     getNextPageParam: (lastPage, allPages, lastPageDescriptor, allPageDescriptors) => options.getNextPage(
       buildPageContext(
@@ -588,8 +630,10 @@ function useFrontXSuspenseInfiniteQuery(options) {
       )
     ) : void 0,
     select: (data) => data.pages,
-    staleTime: options.staleTime ?? options.initialPage.staleTime,
-    gcTime: options.gcTime ?? options.initialPage.gcTime,
+    ...cacheTimeOptions(
+      options.staleTime ?? options.initialPage.staleTime,
+      options.gcTime ?? options.initialPage.gcTime
+    ),
     maxPages: options.maxPages
   });
   return {
@@ -611,23 +655,49 @@ function useFrontXSuspenseInfiniteQuery(options) {
     }
   };
 }
+var mutationScopes = /* @__PURE__ */ new WeakMap();
+function scopeBoundQueryCache(queryCache2, scope) {
+  const scopeChanged = () => (0, import_framework2.readQueryCacheScopeGeneration)(scope.queryClient) !== scope.generation;
+  const dropped = () => {
+    if (!scopeChanged()) return false;
+    (0, import_framework2.recordQueryCacheScopeWriteDropped)(scope.queryClient, scope.generation);
+    return true;
+  };
+  return {
+    get: queryCache2.get,
+    getState: queryCache2.getState,
+    set: (key, dataOrUpdater) => {
+      if (!dropped()) queryCache2.set(key, dataOrUpdater);
+    },
+    cancel: (key) => scopeChanged() ? Promise.resolve() : queryCache2.cancel(key),
+    invalidate: (key) => dropped() ? Promise.resolve() : queryCache2.invalidate(key),
+    invalidateMany: (filters) => dropped() ? Promise.resolve() : queryCache2.invalidateMany(filters),
+    remove: (key) => {
+      if (!dropped()) queryCache2.remove(key);
+    }
+  };
+}
+function scopeBoundCallbackCtx(callbackCtx, scope) {
+  return scope ? { queryCache: scopeBoundQueryCache(createQueryCache(scope.queryClient), scope) } : callbackCtx;
+}
 function useFrontXMutation(options, callbackCtx) {
-  useRequiredFrontXQueryClient();
-  const latestRef = import_react3.default.useRef({ options, callbackCtx });
-  latestRef.current = { options, callbackCtx };
-  const fetchAbortControllersRef = import_react3.default.useRef(/* @__PURE__ */ new Set());
-  import_react3.default.useEffect(() => {
-    const fetchAbortControllers = fetchAbortControllersRef.current;
-    return () => {
-      if (latestRef.current.options.abortOnUnmount) {
-        for (const controller of fetchAbortControllers) {
-          controller.abort();
-        }
-        fetchAbortControllers.clear();
+  const queryClient = useRequiredFrontXQueryClient();
+  const latestRef = useLatest({ options, callbackCtx, queryClient });
+  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_react3.default.useCallback((variables, context) => {
+  const mutationFn = import_react4.default.useCallback((variables, context) => {
     const cancelOnSupersede = latestRef.current.options.cancelOnSupersede;
     if (cancelOnSupersede) {
       for (const controller2 of fetchAbortControllersRef.current) {
@@ -648,35 +718,50 @@ function useFrontXMutation(options, callbackCtx) {
     return latestRef.current.options.endpoint.fetch(variables, { signal: controller.signal }).finally(() => {
       fetchAbortControllersRef.current.delete(controller);
     });
-  }, []);
-  const onMutate = import_react3.default.useCallback((variables, _context) => {
+  }, [latestRef]);
+  const onMutate = import_react4.default.useCallback(async (variables, mutationFnContext) => {
     const current = latestRef.current;
-    if (!current.options.onMutate) {
-      return void 0;
-    }
-    return current.options.onMutate(variables, current.callbackCtx);
-  }, []);
-  const onSuccess = import_react3.default.useCallback((data, variables, context) => {
+    const scope = {
+      queryClient: current.queryClient,
+      generation: (0, import_framework2.readQueryCacheScopeGeneration)(current.queryClient)
+    };
+    mutationScopes.set(mutationFnContext, scope);
+    return current.options.onMutate?.(
+      variables,
+      scopeBoundCallbackCtx(current.callbackCtx, scope)
+    );
+  }, [latestRef]);
+  const onSuccess = import_react4.default.useCallback((data, variables, context, mutationFnContext) => {
     const current = latestRef.current;
-    return current.options.onSuccess?.(data, variables, context, current.callbackCtx);
-  }, []);
-  const onError = import_react3.default.useCallback((error, variables, context) => {
+    return current.options.onSuccess?.(
+      data,
+      variables,
+      context,
+      scopeBoundCallbackCtx(current.callbackCtx, mutationScopes.get(mutationFnContext))
+    );
+  }, [latestRef]);
+  const onError = import_react4.default.useCallback((error, variables, context, mutationFnContext) => {
     const current = latestRef.current;
-    return current.options.onError?.(error, variables, context, current.callbackCtx);
-  }, []);
-  const onSettled = import_react3.default.useCallback((data, error, variables, context) => {
+    return current.options.onError?.(
+      error,
+      variables,
+      context,
+      scopeBoundCallbackCtx(current.callbackCtx, mutationScopes.get(mutationFnContext))
+    );
+  }, [latestRef]);
+  const onSettled = import_react4.default.useCallback((data, error, variables, context, mutationFnContext) => {
     const current = latestRef.current;
     return current.options.onSettled?.(
       data,
       error,
       variables,
       context,
-      current.callbackCtx
+      scopeBoundCallbackCtx(current.callbackCtx, mutationScopes.get(mutationFnContext))
     );
-  }, []);
+  }, [latestRef]);
   const mutation = (0, import_react_query.useMutation)({
     mutationFn,
-    onMutate: options.onMutate ? onMutate : void 0,
+    onMutate,
     onSuccess: options.onSuccess ? onSuccess : void 0,
     onError: options.onError ? onError : void 0,
     onSettled: options.onSettled ? onSettled : void 0
@@ -693,38 +778,14 @@ function useFrontXMutation(options, callbackCtx) {
 
 // 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,
+  app,
   mfeBridge
 }) => {
-  const [stableConfig, setStableConfig] = (0, import_react4.useState)(config);
-  if (!shallowEqual(
-    stableConfig,
-    config
-  )) {
-    setStableConfig(config);
-  }
-  const app = (0, import_react4.useMemo)(() => {
-    if (providedApp) {
-      return providedApp;
-    }
-    return createProviderOwnedApp(stableConfig);
-  }, [providedApp, stableConfig]);
   const queryClient = useBootstrappedFrontXQueryClient(app);
   const deferQuerySubtree = hasFrontXQueryClientActivator(app) && queryClient === void 0;
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (queryClient || hasFrontXQueryClientActivator(app) || process.env.NODE_ENV === "production" || process.env.NODE_ENV === "test" || process.env.VITEST === "true") {
       return;
     }
@@ -732,13 +793,6 @@ var FrontXProvider = ({
       "[FrontXProvider] No query cache available. Add queryCache() or queryCacheShared() to your plugin composition. useApiQuery/useApiMutation will fail without it."
     );
   }, [app, queryClient]);
-  (0, import_react4.useEffect)(() => {
-    return () => {
-      if (!providedApp) {
-        app.destroy();
-      }
-    };
-  }, [app, providedApp]);
   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_runtime3.jsx)(MfeProvider, { value: mfeBridge, children: content });
@@ -747,7 +801,7 @@ var FrontXProvider = ({
 };
 
 // src/hooks/useCanAccess.ts
-var import_react5 = require("react");
+var import_react6 = require("react");
 function serializeRecordValue(value) {
   if (value === null) return "n:";
   if (typeof value === "string") return `s:${value}`;
@@ -764,24 +818,23 @@ function accessQueryKey(query) {
 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_react5.useState)(() => query);
-  const [storedKey, setStoredKey] = (0, import_react5.useState)(stableKey);
-  const [result, setResult] = (0, import_react5.useState)({ allow: false, isResolving: true });
-  if (storedKey !== stableKey) {
-    setStoredKey(stableKey);
+  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_react5.useEffect)(() => {
-    const auth2 = getAuthRuntime(app);
+  (0, import_react6.useEffect)(() => {
     if (!auth2) {
-      setResult({ allow: false, isResolving: false });
       return;
     }
-    setResult({ allow: false, isResolving: true });
     let alive = true;
     const controller = new AbortController();
     void auth2.canAccess(stableQuery, { signal: controller.signal }).then((decision) => {
@@ -797,8 +850,8 @@ function useCanAccess(query) {
       alive = false;
       controller.abort();
     };
-  }, [app, stableQuery]);
-  return result;
+  }, [auth2, stableQuery]);
+  return auth2 ? result : DENIED_NO_AUTH;
 }
 
 // src/components/CanAccess.tsx
@@ -826,12 +879,12 @@ var import_react_redux3 = require("react-redux");
 var useAppSelector = import_react_redux3.useSelector;
 
 // src/hooks/useTranslation.ts
-var import_react6 = require("react");
+var import_react7 = require("react");
 function useTranslation() {
   const app = useFrontX();
   const { i18nRegistry: i18nRegistry2 } = app;
-  const version = (0, import_react6.useSyncExternalStore)(
-    (0, import_react6.useCallback)(
+  const version = (0, import_react7.useSyncExternalStore)(
+    (0, import_react7.useCallback)(
       (callback) => {
         return i18nRegistry2.subscribe(callback);
       },
@@ -840,17 +893,17 @@ function useTranslation() {
     () => i18nRegistry2.getVersion(),
     () => i18nRegistry2.getVersion()
   );
-  const language = (0, import_react6.useMemo)(() => {
+  const language = (0, import_react7.useMemo)(() => {
     void version;
     return i18nRegistry2.getLanguage();
   }, [i18nRegistry2, version]);
-  const t = (0, import_react6.useCallback)(
+  const t = (0, import_react7.useCallback)(
     (key, params) => {
       return i18nRegistry2.t(key, params);
     },
     [i18nRegistry2]
   );
-  const setLanguage = (0, import_react6.useCallback)(
+  const setLanguage = (0, import_react7.useCallback)(
     (lang) => {
       if (app.actions.setLanguage) {
         app.actions.setLanguage({ language: lang });
@@ -858,7 +911,7 @@ function useTranslation() {
     },
     [app.actions]
   );
-  const isRTL = (0, import_react6.useMemo)(() => {
+  const isRTL = (0, import_react7.useMemo)(() => {
     void language;
     return i18nRegistry2.isRTL();
   }, [i18nRegistry2, language]);
@@ -871,29 +924,28 @@ function useTranslation() {
 }
 
 // src/hooks/useScreenTranslations.ts
-var import_react7 = require("react");
+var import_react8 = require("react");
 function isTranslationLoader(input) {
   return typeof input === "function";
 }
 function useScreenTranslations(screensetId, screenId, translations) {
   const app = useFrontX();
   const { i18nRegistry: i18nRegistry2 } = app;
-  const [loadedLanguage, setLoadedLanguage] = (0, import_react7.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react7.useState)(false);
-  const [error, setError] = (0, import_react7.useState)(null);
-  const version = (0, import_react7.useSyncExternalStore)(
-    (0, import_react7.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_react7.useMemo)(() => {
+  const currentLanguage = (0, import_react8.useMemo)(() => {
     void version;
     return i18nRegistry2.getLanguage();
   }, [i18nRegistry2, version]);
-  const loader = (0, import_react7.useMemo)(() => {
+  const loader = (0, import_react8.useMemo)(() => {
     if (isTranslationLoader(translations)) {
       return translations;
     }
@@ -906,12 +958,11 @@ function useScreenTranslations(screensetId, screenId, translations) {
       return module2.default;
     };
   }, [translations]);
-  (0, import_react7.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (!currentLanguage || currentLanguage === loadedLanguage) {
       return;
     }
     let cancelled = false;
-    setIsLoading(true);
     const loadTranslations = async () => {
       try {
         const namespace = `screen.${screensetId}.${screenId}`;
@@ -920,13 +971,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);
         }
       }
     };
@@ -935,29 +984,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_react8 = require("react");
-var import_framework4 = require("@gears-frontx/framework");
+var import_react9 = require("react");
+var import_framework3 = require("@gears-frontx/framework");
 function useFormatters() {
   const { language } = useTranslation();
-  return (0, import_react8.useMemo)(
+  return (0, import_react9.useMemo)(
     () => {
       void language;
       return {
-        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
+        formatDate: import_framework3.formatDate,
+        formatTime: import_framework3.formatTime,
+        formatDateTime: import_framework3.formatDateTime,
+        formatRelative: import_framework3.formatRelative,
+        formatNumber: import_framework3.formatNumber,
+        formatPercent: import_framework3.formatPercent,
+        formatCompact: import_framework3.formatCompact,
+        formatCurrency: import_framework3.formatCurrency,
+        compareStrings: import_framework3.compareStrings,
+        createCollator: import_framework3.createCollator
       };
     },
     [language]
@@ -965,12 +1014,12 @@ function useFormatters() {
 }
 
 // src/hooks/useTheme.ts
-var import_react9 = require("react");
+var import_react10 = require("react");
 function useTheme() {
   const app = useFrontX();
   const { themeRegistry } = app;
-  const version = (0, import_react9.useSyncExternalStore)(
-    (0, import_react9.useCallback)(
+  const version = (0, import_react10.useSyncExternalStore)(
+    (0, import_react10.useCallback)(
       (callback) => {
         return themeRegistry.subscribe(callback);
       },
@@ -979,18 +1028,18 @@ function useTheme() {
     () => themeRegistry.getVersion(),
     () => themeRegistry.getVersion()
   );
-  const currentTheme = (0, import_react9.useMemo)(() => {
+  const currentTheme = (0, import_react10.useMemo)(() => {
     void version;
     const theme = themeRegistry.getCurrent();
     return theme?.id;
   }, [themeRegistry, version]);
-  const themes2 = (0, import_react9.useMemo)(() => {
+  const themes2 = (0, import_react10.useMemo)(() => {
     return themeRegistry.getAll().map((theme) => ({
       id: theme.id,
       name: theme.name
     }));
   }, [themeRegistry]);
-  const setTheme = (0, import_react9.useCallback)(
+  const setTheme = (0, import_react10.useCallback)(
     (themeId) => {
       if (app.actions.changeTheme) {
         app.actions.changeTheme({ themeId });
@@ -1026,35 +1075,48 @@ function useApiSuspenseInfiniteQuery(options) {
 }
 
 // src/hooks/useApiMutation.ts
-var import_react10 = require("react");
+var import_react11 = require("react");
 function useApiMutation(options) {
   const queryClient = useRequiredFrontXQueryClient();
-  const queryCache2 = (0, import_react10.useMemo)(() => createQueryCache(queryClient), [queryClient]);
-  const callbackCtx = (0, import_react10.useMemo)(() => ({ queryCache: queryCache2 }), [queryCache2]);
+  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_react11 = require("react");
+var import_react12 = require("react");
 function useApiStream(descriptor, options) {
   const mode = options?.mode ?? "latest";
   const enabled = options?.enabled ?? true;
-  const [data, setData] = (0, import_react11.useState)(void 0);
-  const [events, setEvents] = (0, import_react11.useState)([]);
-  const [status, setStatus] = (0, import_react11.useState)("idle");
-  const [error, setError] = (0, import_react11.useState)(null);
-  const connectPromiseRef = (0, import_react11.useRef)(null);
-  const connectionIdRef = (0, import_react11.useRef)(null);
-  const disconnectRequestedRef = (0, import_react11.useRef)(false);
-  const descriptorRef = (0, import_react11.useRef)(descriptor);
-  descriptorRef.current = descriptor;
-  const descriptorKey = (0, import_react11.useMemo)(() => JSON.stringify(descriptor.key), [descriptor.key]);
-  (0, import_react11.useEffect)(() => {
+  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);
-  }, [descriptorKey, mode]);
-  const disconnect = (0, import_react11.useCallback)(() => {
+  }
+  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);
@@ -1062,19 +1124,14 @@ function useApiStream(descriptor, options) {
       disconnectRequestedRef.current = false;
     }
     setStatus("disconnected");
-  }, []);
-  (0, import_react11.useEffect)(() => {
+  }, [descriptorRef]);
+  (0, import_react12.useEffect)(() => {
     if (!enabled) {
-      setStatus("idle");
       return;
     }
     let cancelled = false;
     disconnectRequestedRef.current = false;
     const d = descriptorRef.current;
-    setData(void 0);
-    setEvents([]);
-    setStatus("connecting");
-    setError(null);
     const connectPromise = d.connect(
       (event) => {
         if (cancelled) return;
@@ -1120,12 +1177,12 @@ function useApiStream(descriptor, options) {
       connectPromiseRef.current = null;
       connectionIdRef.current = null;
     };
-  }, [descriptorKey, enabled, mode]);
-  return { data, events, status, error, disconnect };
+  }, [descriptorKey, enabled, mode, descriptorRef]);
+  return { data, events, status: enabled ? status : "idle", error, disconnect };
 }
 
 // src/hooks/useQueryCache.ts
-var import_react12 = require("react");
+var import_react13 = require("react");
 function useQueryCache() {
   const queryClient = useOptionalFrontXQueryClient();
   if (!queryClient) {
@@ -1133,7 +1190,7 @@ function useQueryCache() {
       "[FrontXProvider] No query cache available. Add queryCache() or queryCacheShared() to your plugin composition."
     );
   }
-  return (0, import_react12.useMemo)(() => createQueryCache(queryClient), [queryClient]);
+  return (0, import_react13.useMemo)(() => createQueryCache(queryClient), [queryClient]);
 }
 
 // src/mfe/hooks/useMfeBridge.ts
@@ -1143,94 +1200,77 @@ function useMfeBridge() {
 }
 
 // src/mfe/hooks/useSharedProperty.ts
-var import_react13 = require("react");
-function useSharedProperty(propertyTypeId) {
-  const { bridge } = useMfeContext();
-  const subscribe = (0, import_react13.useCallback)((callback) => {
-    return bridge.subscribeToProperty(propertyTypeId, () => {
-      callback();
-    });
-  }, [bridge, propertyTypeId]);
-  const getSnapshot = (0, import_react13.useCallback)(() => {
-    const property = bridge.getProperty(propertyTypeId);
-    return property?.value;
-  }, [bridge, propertyTypeId]);
-  const value = (0, import_react13.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return value;
+var import_react14 = require("react");
+function useSharedProperty(propertyTypeId, options) {
+  const contextValue = (0, import_react14.useContext)(MfeContext);
+  const bridge = options?.bridge ?? contextValue?.bridge;
+  const fallback = options?.fallback;
+  if (!bridge) {
+    throw new Error(
+      "useSharedProperty must be used within a MfeProvider, or given an explicit `bridge` option, for components that never mount MfeProvider."
+    );
+  }
+  const subscribe = (0, import_react14.useCallback)(
+    (onStoreChange) => bridge.subscribeToProperty(propertyTypeId, () => {
+      onStoreChange();
+    }),
+    [bridge, propertyTypeId]
+  );
+  const getSnapshot = (0, import_react14.useCallback)(() => {
+    const raw = bridge.getProperty(propertyTypeId)?.value;
+    return raw === void 0 ? fallback : raw;
+  }, [bridge, propertyTypeId, fallback]);
+  return (0, import_react14.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
 }
 
 // src/mfe/hooks/useHostAction.ts
-var import_react14 = require("react");
+var import_react15 = require("react");
 function useHostAction(actionTypeId) {
   const { bridge } = useMfeContext();
-  return (0, import_react14.useCallback)((payload) => {
+  return (0, import_react15.useCallback)((payload) => {
     const chain = {
       action: {
         type: actionTypeId,
-        target: bridge.domainId,
+        target: bridge.extDomainId,
         payload
       }
     };
-    bridge.executeActionsChain(chain).catch((error) => {
-      console.error(
-        `[useHostAction] Failed to send action '${actionTypeId}':`,
-        error
-      );
-    });
+    bridge.executeActionsChain(chain);
   }, [actionTypeId, bridge]);
 }
 
-// src/mfe/hooks/useDomainExtensions.ts
-var import_react15 = require("react");
-function useDomainExtensions(domainId) {
-  const app = useFrontX();
+// src/mfe/hooks/useMfeRegistry.ts
+function resolveMfeRegistry(app, callerName) {
   const registry = app.mfeRegistry;
   if (!registry) {
     throw new Error(
-      "useDomainExtensions requires the microfrontends plugin. Add microfrontends() to your Gears FrontX app configuration."
+      `${callerName} requires the microfrontends plugin. Add microfrontends() to your Gears FrontX app configuration.`
     );
   }
-  const subscribe = (0, import_react15.useCallback)(
-    (onStoreChange) => {
-      return app.store.subscribe(onStoreChange);
-    },
-    [app.store]
-  );
-  const cacheRef = (0, import_react15.useRef)({ ids: "", extensions: [] });
-  const getSnapshot = (0, import_react15.useCallback)(() => {
-    const extensions = registry.getExtensionsForDomain(domainId);
-    const ids = extensions.map((e) => e.id).join(",");
-    if (ids !== cacheRef.current.ids) {
-      cacheRef.current = { ids, extensions };
-    }
-    return cacheRef.current.extensions;
-  }, [registry, domainId]);
-  return (0, import_react15.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  return registry;
+}
+function useMfeRegistry() {
+  const app = useFrontX();
+  return resolveMfeRegistry(app, "useMfeRegistry");
 }
 
-// src/mfe/hooks/useMountedExtensions.ts
+// src/mfe/hooks/useDomainExtensions.ts
 var import_react16 = require("react");
-function useMountedExtensions(domainId) {
+function useDomainExtensions(domainId) {
   const app = useFrontX();
-  const registry = app.mfeRegistry;
-  if (!registry) {
-    throw new Error(
-      "useMountedExtensions requires the microfrontends plugin. Add microfrontends() to your Gears FrontX app configuration."
-    );
-  }
+  const registry = resolveMfeRegistry(app, "useDomainExtensions");
   const subscribe = (0, import_react16.useCallback)(
     (onStoreChange) => {
       return app.store.subscribe(onStoreChange);
     },
     [app.store]
   );
-  const cacheRef = (0, import_react16.useRef)({ key: "", extensions: [] });
+  const cacheRef = (0, import_react16.useRef)({ ids: "", extensions: [] });
   const getSnapshot = (0, import_react16.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 };
+    const extensions = registry.getExtensionsForDomain(domainId);
+    const ids = extensions.map((e) => e.id).join(",");
+    if (ids !== cacheRef.current.ids) {
+      cacheRef.current = { ids, extensions };
     }
     return cacheRef.current.extensions;
   }, [registry, domainId]);
@@ -1241,12 +1281,7 @@ function useMountedExtensions(domainId) {
 var import_react17 = require("react");
 function useRegisteredPackages() {
   const app = useFrontX();
-  const registry = app.mfeRegistry;
-  if (!registry) {
-    throw new Error(
-      "useRegisteredPackages requires the microfrontends plugin. Add microfrontends() to your Gears FrontX app configuration."
-    );
-  }
+  const registry = resolveMfeRegistry(app, "useRegisteredPackages");
   const subscribe = (0, import_react17.useCallback)(
     (onStoreChange) => {
       return app.store.subscribe(onStoreChange);
@@ -1267,7 +1302,35 @@ function useRegisteredPackages() {
 
 // src/mfe/ThemeAwareReactLifecycle.tsx
 var import_client = require("react-dom/client");
+
+// src/mfe/domainTeardownCollector.ts
+var activeCollector;
+function collectDomainTeardowns(fn) {
+  const previousCollector = activeCollector;
+  const collector = [];
+  activeCollector = collector;
+  try {
+    fn();
+  } finally {
+    activeCollector = previousCollector;
+  }
+  return collector;
+}
+function registerDomainTeardown(promise) {
+  activeCollector?.push(promise);
+}
+
+// src/mfe/ThemeAwareReactLifecycle.tsx
 var import_jsx_runtime4 = require("react/jsx-runtime");
+var ADOPTED_HOST_STYLE_ATTR = "data-frontx-adopted-host-style";
+var BASE_RESETS_STYLE_ID = "__frontx-base-resets__";
+var SHELL_OWNED_SHADOW_STYLE_IDS = ["__frontx-shadow-isolation__", "__frontx-css-variables__"];
+function cssToCopy(style) {
+  const text = style.textContent ?? "";
+  const sheet = style.sheet;
+  if (text.trim() || !sheet) return text;
+  return Array.from(sheet.cssRules, (rule) => rule.cssText).join("\n");
+}
 function resolveProviderMountOptions(app, bridge, mountContext) {
   const extensionId = mountContext?.extensionId;
   const domainId = mountContext?.domainId;
@@ -1295,6 +1358,7 @@ var ThemeAwareReactLifecycle = class {
   app;
   root = null;
   mount(container, bridge, mountContext) {
+    void this.app.mfeRegistry;
     if (container instanceof ShadowRoot) {
       this.adoptHostStylesIntoShadowRoot(container);
     }
@@ -1313,36 +1377,149 @@ var ThemeAwareReactLifecycle = class {
       )
     );
   }
-  unmount(_container) {
-    if (this.root) {
-      this.root.unmount();
-      this.root = null;
-    }
+  /**
+   * `Root.unmount()` itself is synchronous, but a nested `ExtensionDomainSlot`
+   * mounted anywhere in this root's own tree cannot make ITS cleanup
+   * synchronous too — its mounter's own `detach()` awaits per-extension
+   * unmounts. Collecting whatever that cleanup fire-and-forgets (through
+   * `domainTeardownCollector`, scoped to this one `Root.unmount()` call) and
+   * awaiting it here is what makes this method's own returned promise settle
+   * only once every nested domain this root owns has actually finished
+   * tearing down — never before. A root with no routed nested domain
+   * collects nothing, and this resolves exactly as before (a microtask after
+   * the synchronous unmount, same observable timing `void | Promise<void>`
+   * already allows).
+   */
+  async unmount(_container) {
+    if (!this.root) return;
+    const root = this.root;
+    this.root = null;
+    const pendingTeardowns = collectDomainTeardowns(() => root.unmount());
+    const settled = await Promise.allSettled(pendingTeardowns);
+    const failed = settled.find((result) => result.status === "rejected");
+    if (failed) throw failed.reason;
   }
   /**
    * 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.
+   *
+   * The clones are inserted ahead of everything already in the shadow root, never
+   * appended, because adopted host styles are context rather than authority: where
+   * they and the MFE's own CSS declare the same property at equal specificity, the
+   * MFE has to win. Appending inverted that. `MfeHandlerMF` injects the MFE's
+   * compiled stylesheet into the shadow root before it calls mount, so an appended
+   * clone of the shell's Tailwind preflight - whose
+   * `button, [type='button'], [type='reset'], [type='submit']` rule sets
+   * `background-color: transparent` at specificity (0,1,0) - tied with
+   * `@gears-frontx/ui-kit`'s single-class button rule and won on document order,
+   * leaving every kit Button transparent until it was hovered.
+   *
+   * Inserting at the front rather than pushing MFE styles to the back is what makes
+   * the invariant hold for stylesheets that appear after mount too - a lazily
+   * imported component's CSS module, or whatever initializeStyles() adds - since
+   * those land behind the adopted block by construction.
+   *
+   * A cascade layer around the adopted CSS was the alternative and is rejected:
+   * layered rules lose to unlayered ones at *any* specificity, so a host utility
+   * class would stop overriding an MFE element selector. Document order keeps
+   * specificity in charge and only settles the ties.
+   *
+   * The block replaces its predecessor instead of stacking on it, the same
+   * upsert shape `injectStylesheet` and `injectCssVariables` use in
+   * `@gears-frontx/mfes`' shadow utilities, widened from one id-keyed node to a
+   * marked block. Replacement is required rather than tidy: `createShadowRoot`
+   * hands back an existing `element.shadowRoot` instead of attaching a new one,
+   * so remounting the same container runs this method again on a shadow root
+   * that already holds a full adopted block, and appending would grow it once
+   * per mount with no bound. It does not save re-resolving the cloned `<link>`s -
+   * every mount clones them afresh and the browser resolves each clone; what
+   * replacement buys is that the count stays at one block instead of one per
+   * mount.
+   *
+   * The block is rebuilt from the host head rather than left in place, because
+   * the head is not fixed: a lazily imported chunk adds stylesheets to it after
+   * the first mount, and the second mount has to pick those up.
+   *
+   * A `<style>` is copied into a new element that holds the host's CSS - see
+   * `cssToCopy` - and takes three things from the host element: `media`,
+   * without which a print-only host style applies on screen inside the MFE;
+   * `type`, which keeps the copy of a non-CSS element as inert as the original;
+   * and the nonce, without which a nonce-based CSP blocks the copy. The nonce is read from the `nonce` property, because
+   * browsers blank the attribute in a document served with a CSP header.
+   * Nothing else is carried over, because libraries look for their own
+   * attributes inside the shadow root: styled-components, rendering into it,
+   * puts its tag right after the last `style[data-styled]` there, so a copy of
+   * the host's tag would pull the MFE's rules ahead of the base resets and the
+   * MFE's own CSS. A `<link>` is a deep clone and is loaded from its `href`
+   * again.
+   *
+   * The fresh block goes in before the previous one comes out. Removing first
+   * leaves the shadow root with no host CSS at all, and everything between that
+   * removal and the insertion is synchronous work in this same task - so the gap
+   * never reaches a paint, but any code that reads computed styles from the tree
+   * in between sees an unstyled one. Inserting first costs one moment with two
+   * blocks present, which changes nothing: the old block is a clone of the same
+   * host head and loses every tie to the new one on document order anyway.
    */
   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);
+    const supersededStyles = Array.from(shadowRoot.querySelectorAll(`[${ADOPTED_HOST_STYLE_ATTR}]`));
+    const adoptedStyles = document.createDocumentFragment();
+    const hostStyleNodes = document.head.querySelectorAll('style, link[rel="stylesheet"]');
+    hostStyleNodes.forEach((el) => {
+      if (el instanceof HTMLStyleElement) {
+        const copy = document.createElement("style");
+        if (el.media) copy.media = el.media;
+        if (el.type) copy.type = el.type;
+        if (el.nonce) copy.nonce = el.nonce;
+        copy.textContent = cssToCopy(el);
+        copy.setAttribute(ADOPTED_HOST_STYLE_ATTR, "");
+        adoptedStyles.appendChild(copy);
+        return;
+      }
+      const linkClone = el.cloneNode(true);
+      linkClone.setAttribute(ADOPTED_HOST_STYLE_ATTR, "");
+      adoptedStyles.appendChild(linkClone);
     });
+    shadowRoot.insertBefore(adoptedStyles, shadowRoot.firstChild);
+    supersededStyles.forEach((el) => el.remove());
   }
   /**
    * 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.
+   *
+   * Reuses the node a previous mount left behind, exactly as `injectStylesheet`
+   * does in `@gears-frontx/mfes`' shadow utilities: a remount runs against a
+   * shadow root that `createShadowRoot` handed back intact, and appending a
+   * second copy would add one node per mount forever.
+   *
+   * Reuse alone is not enough, which is why the node is also positioned on every
+   * mount rather than left where the previous one sat. These resets are context
+   * like the adopted block is - `border-color: currentColor` on `*` is a 0-0-0
+   * declaration that beats an MFE preflight's own 0-0-0 reset purely on document
+   * order - so they have to stay ahead of the MFE's CSS, and where they land is
+   * not stable on its own. `MfeHandlerMF.wrapLifecycleWithStylesheets` removes the
+   * MFE's stylesheet on unmount and appends a fresh one before the next mount, so
+   * a node merely left in place ends up ahead of that stylesheet on a remount and
+   * behind it on the first mount: two different cascades for one component.
+   * Anchoring it to the end of the shell-owned head gives every mount the same
+   * order - adopted block, isolation, resets, MFE - which is also the order the
+   * adoption method's invariant is written against.
+   *
+   * With no shell-owned node to anchor to, the resets go to the front. That is the
+   * plain-`Element` container: no adopted block, no isolation style, and the MFE
+   * stylesheet already appended by the handler, so the front is again the only
+   * position that leaves the MFE winning ties.
+   *
+   * Looked up by attribute-selector form rather than `getElementById`, which
+   * `ShadowRoot` has but `Element` does not, and this hook takes either.
    */
   injectBaseResets(container) {
-    const style = document.createElement("style");
+    const existing = container.querySelector(
+      `style[id="${BASE_RESETS_STYLE_ID}"]`
+    );
+    const style = existing ?? document.createElement("style");
+    style.id = BASE_RESETS_STYLE_ID;
     style.textContent = `
       *, *::before, *::after {
         box-sizing: border-box;
@@ -1356,11 +1533,21 @@ var ThemeAwareReactLifecycle = class {
         line-height: 1.5;
         -webkit-font-smoothing: antialiased;
         -moz-osx-font-smoothing: grayscale;
-        color: hsl(var(--foreground));
-        background-color: hsl(var(--background));
+        color: var(--foreground);
+        background-color: var(--background);
       }
     `;
-    container.appendChild(style);
+    const shellOwnedHead = container.querySelectorAll(
+      [
+        `[${ADOPTED_HOST_STYLE_ATTR}]`,
+        ...SHELL_OWNED_SHADOW_STYLE_IDS.map((id) => `[id="${id}"]`)
+      ].join(", ")
+    );
+    const lastShellOwnedNode = shellOwnedHead[shellOwnedHead.length - 1];
+    container.insertBefore(
+      style,
+      lastShellOwnedNode ? lastShellOwnedNode.nextSibling : container.firstChild
+    );
   }
   /**
    * Hook for subclasses to inject additional CSS not covered by the adopted host
@@ -1385,10 +1572,12 @@ function ExtensionDomainSlot(props) {
     loadingComponent = null
   } = props;
   const rootRef = (0, import_react18.useRef)(null);
-  const onAttachedRef = (0, import_react18.useRef)(onAttached);
-  const onDetachedRef = (0, import_react18.useRef)(onDetached);
-  onAttachedRef.current = onAttached;
-  onDetachedRef.current = onDetached;
+  const emitAttached = (0, import_react18.useEffectEvent)((root) => {
+    onAttached?.(root);
+  });
+  const emitDetached = (0, import_react18.useEffectEvent)(() => {
+    onDetached?.();
+  });
   const [attached, setAttached] = (0, import_react18.useState)(false);
   (0, import_react18.useEffect)(() => {
     const root = rootRef.current;
@@ -1398,11 +1587,12 @@ function ExtensionDomainSlot(props) {
     const mounter = registry.getMounter(domainId);
     mounter.attach(root);
     setAttached(true);
-    onAttachedRef.current?.(root);
+    emitAttached(root);
     return () => {
-      void mounter.detach();
+      const detachPromise = mounter.detach();
+      registerDomainTeardown(detachPromise);
       setAttached(false);
-      onDetachedRef.current?.();
+      emitDetached();
     };
   }, [registry, domainId]);
   return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
@@ -1417,6 +1607,7 @@ function ExtensionDomainSlot(props) {
 }
 
 // src/index.ts
+var import_framework4 = require("@gears-frontx/framework");
 var import_framework5 = require("@gears-frontx/framework");
 var import_framework6 = require("@gears-frontx/framework");
 var import_framework7 = require("@gears-frontx/framework");
@@ -1429,9 +1620,7 @@ var import_framework13 = require("@gears-frontx/framework");
 var import_framework14 = require("@gears-frontx/framework");
 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 eventBus2 = import_framework18.eventBus;
+var eventBus2 = import_framework16.eventBus;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNTS_DOMAIN,
@@ -1439,6 +1628,7 @@ var eventBus2 = import_framework18.eventBus;
   ApiPlugin,
   ApiPluginBase,
   ApiProtocol,
+  AuthEvents,
   BaseApiService,
   CanAccess,
   ChildMfeBridge,
@@ -1466,7 +1656,6 @@ var eventBus2 = import_framework18.eventBus;
   LAYOUT_SLICE_NAME,
   Language,
   LanguageDisplayMode,
-  LayoutDomain,
   MOCK_PLUGIN,
   MfeBridgeFactory,
   MfeContext,
@@ -1475,18 +1664,15 @@ var eventBus2 = import_framework18.eventBus;
   MfeProvider,
   MfeRegistry,
   MfeRegistryFactory,
-  MockEventSource,
   MockEvents,
   MountStrategy,
   OptionalMountStrategy,
   ParentMfeBridge,
   RestEndpointProtocol,
-  RestMockPlugin,
   RestPlugin,
   RestPluginWithConfig,
   RestProtocol,
   SUPPORTED_LANGUAGES,
-  SseMockPlugin,
   SsePlugin,
   SsePluginWithConfig,
   SseProtocol,
@@ -1505,7 +1691,6 @@ var eventBus2 = import_framework18.eventBus;
   closePopup,
   closeTopPopup,
   createFrontX,
-  createFrontXApp,
   createI18nRegistry,
   createShadowRoot,
   createSlice,
@@ -1513,7 +1698,6 @@ var eventBus2 = import_framework18.eventBus;
   createThemeRegistry,
   effects,
   eventBus,
-  extensionScreenSchema,
   extractGtsPackage,
   footerActions,
   footerSlice,
@@ -1535,7 +1719,6 @@ var eventBus2 = import_framework18.eventBus;
   isRestShortCircuit,
   isShortCircuit,
   isSseShortCircuit,
-  languageSchema,
   layout,
   layoutDomainReducers,
   layoutReducer,
@@ -1563,7 +1746,6 @@ var eventBus2 = import_framework18.eventBus;
   screenDomain,
   selectExtensionError,
   selectExtensionState,
-  selectMountedExtensions,
   selectRegisteredExtensions,
   setFooterConfig,
   setFooterVisible,
@@ -1593,7 +1775,6 @@ var eventBus2 = import_framework18.eventBus;
   tenantActions,
   tenantReducer,
   tenantSlice,
-  themeSchema,
   themes,
   toggleMenu,
   toggleMockMode,
@@ -1615,7 +1796,7 @@ var eventBus2 = import_framework18.eventBus;
   useHostAction,
   useMfeBridge,
   useMfeContext,
-  useMountedExtensions,
+  useMfeRegistry,
   useQueryCache,
   useRegisteredPackages,
   useScreenTranslations,