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

package/dist/index.d.cts

@@ -1,61 +1,203 @@
 import * as React from 'react';
-import React__default, { RefObject } from 'react';
-import { H as HAI3ProviderProps, U as UseTranslationReturn, a as UseScreenTranslationsReturn, b as UseFormattersReturn, c as UseThemeReturn, M as MfeContextValue } from './types-Cp8Zm5s0.cjs';
-export { d as MfeContext, e as UseAppDispatchReturn, f as UseAppSelector, g as UseHAI3Return, u as useMfeContext } from './types-Cp8Zm5s0.cjs';
-import { HAI3App, AppDispatch, RootState, TranslationMap, TranslationLoader, ChildMfeBridge, Extension, ContainerProvider, ScreensetsRegistry, ParentMfeBridge, EventPayloadMap as EventPayloadMap$1, EventBus } from '@gears-frontx/framework';
-export { ACCOUNTS_DOMAIN, Action, ActionsChain, ApiPlugin, ApiPluginBase, ApiPluginErrorContext, ApiProtocol, ApiRequestContext, ApiResponseContext, ApiServiceConfig, AppDispatch, BaseApiService, BasePluginHooks, ChangeThemePayload, ChildMfeBridge, ContainerProvider, EventHandler, EventSourceLike, Extension, ExtensionDomain, ExtensionPresentation, ExtensionRegistrationState, FRONTX_ACTION_LOAD_EXT, FRONTX_ACTION_MOUNT_EXT, FRONTX_ACTION_UNMOUNT_EXT, FRONTX_MFE_ENTRY_MF, FRONTX_OVERLAY_DOMAIN, FRONTX_POPUP_DOMAIN, FRONTX_SCREEN_DOMAIN, FRONTX_SCREEN_EXTENSION_TYPE, FRONTX_SHARED_PROPERTY_LANGUAGE, FRONTX_SHARED_PROPERTY_THEME, FRONTX_SIDEBAR_DOMAIN, FooterConfig, FooterState, HAI3App, HAI3AppBuilder, HAI3Config, HAI3Plugin, HAI3Store, HeaderConfig, HeaderState, HeaderUser, I18nConfig, I18nRegistry, I18nRegistryImpl, I18nRegistryType, JSONSchema, JsonCompatible, JsonObject, JsonPrimitive, JsonValue, LAYOUT_SLICE_NAME, Language, LanguageDisplayMode, LanguageMetadata, LayoutDomain, LayoutDomainReducers, LayoutDomainState, LayoutState, LifecycleHook, LifecycleStage, LoadExtPayload, MOCK_PLUGIN, MenuItem, MenuState, MfeBridgeFactory, MfeEntry, MfeEntryLifecycle, MfeEntryMF, MfeHandler, MfeHandlerMF, MfeState, MockEventSource, MockEvents, MockMap, MockState, MockTogglePayload, MountExtPayload, OverlayConfig, OverlayState, ParentMfeBridge, PluginClass, PluginFactory, PluginLifecycle, PluginProvides, PopupConfig, PopupSliceState, PopupState, Preset, Presets, ProtocolClass, ProtocolPluginType, ReducerPayload, RegisterExtensionPayload, RestMockConfig, RestMockPlugin, RestPlugin, RestPluginHooks, RestPluginWithConfig, RestProtocol, RestProtocolConfig, RestRequestContext, RestResponseContext, RestShortCircuitResponse, RootState, RootStateWithLayout, SUPPORTED_LANGUAGES, ScreenExtension, ScreenState, ScreensetsConfig, ScreensetsRegistry, ScreensetsRegistryConfig, ScreensetsRegistryFactory, SetLanguagePayload, SharedProperty, ShortCircuitResponse, ShowPopupPayload, SidebarPosition, SidebarState, SliceObject, SseConnectContext, SseMockConfig, SseMockEvent, SseMockPlugin, SsePlugin, SsePluginHooks, SsePluginWithConfig, SseProtocol, SseProtocolConfig, SseShortCircuitResponse, Subscription, TENANT_SLICE_NAME, Tenant, TenantChangedPayload, TenantClearedPayload, TenantEvents, TenantState, TextDirection, ThemeConfig, ThemeRegistry, TranslationDictionary, TranslationLoader, TranslationMap, TypeSystemPlugin, UnmountExtPayload, UnregisterExtensionPayload, ValidationError, ValidationResult, apiRegistry, changeTenant, clearActiveScreen, clearTenant, clearTenantAction, clearUser, closeAllPopups, closePopup, closeTopPopup, createHAI3, createHAI3App, createI18nRegistry, createShadowRoot, createSlice, createStore, createThemeRegistry, effects, extensionScreenSchema, extractGtsPackage, footerActions, footerSlice, getLanguageMetadata, getStore, gtsPlugin, hasSlice, headerActions, headerSlice, hideOverlay, i18n, i18nRegistry, initMockEffects, initTenantEffects, injectCssVariables, isMockPlugin, isRestShortCircuit, isShortCircuit, isSseShortCircuit, languageSchema, layout, layoutDomainReducers, layoutReducer, loadExtension, menuActions, menuSlice, microfrontends, mock, mockActions, mockSlice, mountExtension, navigateTo, openPopup, overlayActions, overlayDomain, overlaySlice, popupActions, popupDomain, popupSlice, presets, registerExtension, registerSlice, screenActions, screenDomain, screenSlice, screensets, screensetsRegistryFactory, selectExtensionError, selectExtensionState, selectRegisteredExtensions, setActiveScreen, setFooterConfig, setFooterVisible, setHeaderLoading, setMenuCollapsed, setMenuConfig, setMenuItems, setMenuVisible, setMockEnabled, setOverlayVisible, setScreenLoading, setSidebarCollapsed, setSidebarConfig, setSidebarContent, setSidebarPosition, setSidebarTitle, setSidebarVisible, setSidebarWidth, setTenant, setTenantLoading, setTenantLoadingState, setUser, showOverlay, sidebarActions, sidebarDomain, sidebarSlice, tenantActions, tenantReducer, tenantSlice, themeSchema, themes, toggleMenu, toggleMockMode, toggleSidebar, unmountExtension, unregisterExtension } from '@gears-frontx/framework';
+import React__default, { ReactElement } from 'react';
+import { F as FrontXProviderProps, A as ApiQueryResult, a as ApiInfiniteQueryResult, b as ApiMutationResult, C as CanAccessProps, U as UseTranslationReturn, c as UseScreenTranslationsReturn, d as UseFormattersReturn, e as UseThemeReturn, f as ApiSuspenseQueryResult, g as ApiSuspenseInfiniteQueryResult, h as UseCanAccessResult, M as MfeContextValue } from './types-JtpziA_B.cjs';
+export { i as MfeContext, j as UseAppDispatchReturn, k as UseAppSelector, l as UseFrontXReturn, u as useMfeContext } from './types-JtpziA_B.cjs';
+import { FrontXApp, EndpointDescriptor, MutationDescriptor, AccessRecord, AppDispatch, RootState, TranslationMap, TranslationLoader, StreamStatus, StreamDescriptor, AccessQuery, ChildMfeBridge, MfeRegistry, Extension, MfeEntryLifecycle, MfeMountContext, EventPayloadMap as EventPayloadMap$1, EventBus } from '@gears-frontx/framework';
+export { ACCOUNTS_DOMAIN, AccessDecision, AccessQuery, Action, ActionHandler, ActionPayload, ActionsChain, ApiPlugin, ApiPluginBase, ApiPluginErrorContext, ApiProtocol, ApiRequestContext, ApiResponseContext, ApiServiceConfig, AppDispatch, AuthCallbackInput, AuthCapabilities, AuthCheckResult, AuthContext, AuthEvents, AuthLoggedInPayload, AuthLoggedOutPayload, AuthLoginInput, AuthPermissions, AuthPluginConfig, AuthProvider, AuthRuntime, AuthSession, AuthState, AuthStateEvent, AuthStateListener, AuthTransition, AuthUnsubscribe, BaseApiService, BasePluginHooks, ChangeThemePayload, ChildMfeBridge, ConcurrentMountStrategy, ContainerHooks, DomainContext, EndpointDescriptor, EndpointOptions, EventHandler, EventSourceLike, ExclusiveMountStrategy, Extension, ExtensionDomain, ExtensionDomainImplementation, ExtensionDomainImplementationFactory, ExtensionMounter, ExtensionPresentation, ExtensionRegistrationState, FRONTX_ACTION_LOAD_EXT, FRONTX_ACTION_MOUNT_EXT, FRONTX_ACTION_UNMOUNT_EXT, FRONTX_MFE_ENTRY_MF, FRONTX_OVERLAY_DOMAIN, FRONTX_POPUP_DOMAIN, FRONTX_SCREEN_DOMAIN, FRONTX_SCREEN_EXTENSION_TYPE, FRONTX_SHARED_PROPERTY_LANGUAGE, FRONTX_SHARED_PROPERTY_THEME, FRONTX_SIDEBAR_DOMAIN, FooterConfig, FooterState, FrontXApp, FrontXAppBuilder, FrontXConfig, FrontXPlugin, FrontXStore, HeaderConfig, HeaderState, HeaderUser, I18nConfig, I18nRegistry, I18nRegistryImpl, I18nRegistryType, JSONSchema, JsonCompatible, JsonObject, JsonPrimitive, JsonValue, LAYOUT_SLICE_NAME, Language, LanguageDisplayMode, LanguageMetadata, LayoutDomainReducers, LayoutDomainState, LayoutState, LifecycleHook, LifecycleStage, LoadExtPayload, MOCK_PLUGIN, MenuItem, MenuState, MfManifest, MfManifestAssets, MfManifestBuildInfo, MfManifestMetaData, MfManifestRemoteEntry, MfManifestShared, MfeBridgeFactory, MfeEntry, MfeEntryLifecycle, MfeEntryMF, MfeHandler, MfeHandlerMF, MfeMountContext, MfeRegistry, MfeRegistryConfig, MfeRegistryFactory, MfeState, MockEvents, MockMap, MockState, MockTogglePayload, MountExtPayload, MountStrategy, MutationDescriptor, OptionalMountStrategy, OverlayConfig, OverlayState, ParameterizedEndpointDescriptor, ParentMfeBridge, PluginClass, PluginFactory, PluginLifecycle, PluginProvides, PopupConfig, PopupSliceState, PopupState, Preset, Presets, ProtocolClass, ProtocolPluginType, ReducerPayload, RegisterExtensionPayload, RestEndpointProtocol, RestPlugin, RestPluginHooks, RestPluginWithConfig, RestProtocol, RestProtocolConfig, RestRequestContext, RestResponseContext, RestShortCircuitResponse, RootState, RootStateWithLayout, SUPPORTED_LANGUAGES, ScreenExtension, SetLanguagePayload, SharedProperty, ShortCircuitResponse, ShowPopupPayload, SidebarPosition, SidebarState, SliceObject, SseConnectContext, SsePlugin, SsePluginHooks, SsePluginWithConfig, SseProtocol, SseProtocolConfig, SseShortCircuitResponse, SseStreamProtocol, StreamDescriptor, StreamStatus, Subscription, TENANT_SLICE_NAME, Tenant, TenantChangedPayload, TenantClearedPayload, TenantEvents, TenantState, TextDirection, ThemeConfig, ThemeRegistry, TranslationDictionary, TranslationLoader, TranslationMap, TypeSystemPlugin, UnmountExtPayload, UnregisterExtensionPayload, apiRegistry, auth, changeTenant, clearTenant, clearTenantAction, clearUser, closeAllPopups, closePopup, closeTopPopup, createFrontX, createI18nRegistry, createShadowRoot, createSlice, createStore, createThemeRegistry, effects, extractGtsPackage, footerActions, footerSlice, frontxApiTransport, getLanguageMetadata, getStore, gtsPlugin, hasSlice, headerActions, headerSlice, hideOverlay, i18n, i18nRegistry, initMockEffects, initTenantEffects, injectCssVariables, isMockPlugin, isRestShortCircuit, isShortCircuit, isSseShortCircuit, layout, layoutDomainReducers, layoutReducer, loadExtension, menuActions, menuSlice, mfeRegistryFactory, microfrontends, mock, mockActions, mockSlice, mountExtension, openPopup, overlayActions, overlayDomain, overlaySlice, popupActions, popupDomain, popupSlice, presets, queryCache, queryCacheShared, registerExtension, registerSlice, screenDomain, selectExtensionError, selectExtensionState, selectRegisteredExtensions, setFooterConfig, setFooterVisible, setHeaderLoading, setMenuCollapsed, setMenuConfig, setMenuItems, setMenuVisible, setMockEnabled, setOverlayVisible, setSidebarCollapsed, setSidebarConfig, setSidebarContent, setSidebarPosition, setSidebarTitle, setSidebarVisible, setSidebarWidth, setTenant, setTenantLoading, setTenantLoadingState, setUser, showOverlay, sidebarActions, sidebarDomain, sidebarSlice, subscribeQueryCacheRuntimeChanged, tenantActions, tenantReducer, tenantSlice, themes, toggleMenu, toggleMockMode, toggleSidebar, unmountExtension, unregisterExtension } from '@gears-frontx/framework';
+import { M as MutationCallbackContext, Q as QueryCache } from './testing-Dlmfu6tE.cjs';
+export { a as QueryCacheInvalidateFilters, b as QueryCacheState, i as invalidateQueryCacheForApp } from './testing-Dlmfu6tE.cjs';
 import { TypedUseSelectorHook } from 'react-redux';
+import '@tanstack/react-query';
+import '@gears-frontx/framework/testing';
 
 /**
- * HAI3 Provider - Main provider component for HAI3 applications
+ * FrontX Provider - Main provider component for FrontX applications
  *
  * React Layer: L3 (Depends on @gears-frontx/framework)
+ *
+ * Query cache lifecycle is owned by the queryCache() framework plugin (L2).
+ * FrontXProvider reads the plugin-owned QueryClient from the app and mounts the
+ * internal React provider around the tree when it is available.
  */
 
 /**
- * HAI3 Provider Component
+ * FrontX Provider Component
  *
- * Provides the HAI3 application context to all child components.
- * Creates the HAI3 app instance with the full preset by default.
+ * Provides the FrontX application context to all child components. The app
+ * is built once per runtime by the caller (`createFrontX(...).build()`); the
+ * provider never creates or destroys one.
  *
  * @example
  * ```tsx
- * // Default - creates app with full preset
- * <HAI3Provider>
- *   <App />
- * </HAI3Provider>
- *
- * // With configuration
- * <HAI3Provider config={{ devMode: true }}>
- *   <App />
- * </HAI3Provider>
- *
- * // With pre-built app
- * const app = createHAI3().use(screensets()).use(microfrontends()).build();
- * <HAI3Provider app={app}>
+ * const app = createFrontX().use(queryCache()).build();
+ * <FrontXProvider app={app}>
  *   <App />
- * </HAI3Provider>
+ * </FrontXProvider>
  *
  * // With MFE bridge (for MFE components)
- * <HAI3Provider mfeBridge={{ bridge, extensionId, domainId }}>
+ * <FrontXProvider app={app} mfeBridge={{ bridge, extensionId, domainId }}>
  *   <MyMfeApp />
- * </HAI3Provider>
+ * </FrontXProvider>
+ *
+ * // QueryCache is resolved from the app's plugin composition
+ * <FrontXProvider app={app}>
+ *   <MyMfeApp />
+ * </FrontXProvider>
  * ```
  */
-declare const HAI3Provider: React__default.FC<HAI3ProviderProps>;
+declare const FrontXProvider: React__default.FC<FrontXProviderProps>;
+
+/**
+ * FrontX Context
+ * Holds the FrontX app instance for the application.
+ */
+declare const FrontXContext: React.Context<FrontXApp | null>;
+/**
+ * Use the FrontX context.
+ * Throws if used outside of FrontXProvider.
+ *
+ * @returns The FrontX app instance
+ */
+declare function useFrontX(): FrontXApp;
+
+/**
+ * useApiQuery - Declarative data fetching hook
+ *
+ * Accepts an EndpointDescriptor from @gears-frontx/api and returns a Gears FrontX-owned
+ * ApiQueryResult. AbortSignal for request cancellation is threaded automatically
+ * through the shared QueryClient integration.
+ *
+ * Cache config cascade: component overrides > descriptor defaults > plugin defaults.
+ * Omit overrides to rely on the descriptor's staleTime/gcTime, which in turn
+ * fall back to the plugin-level query-cache defaults, so a screen that remounts
+ * within staleTime paints from cache without refetching.
+ *
+ * Pass `enabled: false` to hold a query whose input is not known yet.
+ */
 
 /**
- * HAI3 Context
- * Holds the HAI3 app instance for the application.
+ * Per-call cache overrides shared by every read hook.
+ * Cascade: these > descriptor > plugin defaults.
  */
-declare const HAI3Context: React.Context<HAI3App | null>;
+interface ApiQueryCacheOverrides {
+    /** Override staleTime for this specific call site. */
+    staleTime?: number;
+    /** Override gcTime for this specific call site. */
+    gcTime?: number;
+}
+/** Per-call overrides for useApiSuspenseQuery. */
+interface ApiSuspenseQueryOverrides extends ApiQueryCacheOverrides {
+    /** A suspense query always runs; use useApiQuery to hold one back. */
+    enabled?: never;
+}
+/** Per-call overrides for useApiQuery. */
+interface ApiQueryOverrides extends ApiQueryCacheOverrides {
+    /**
+     * `false` keeps the query idle: it is not fetched automatically and
+     * `isLoading` stays false until it turns `true`. An explicit `refetch`
+     * still fetches. Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+declare function useApiQuery<TData = unknown, TError = Error>(descriptor: EndpointDescriptor<TData>, overrides?: ApiQueryOverrides): ApiQueryResult<TData, TError>;
+
 /**
- * Use the HAI3 context.
- * Throws if used outside of HAI3Provider.
+ * useApiInfiniteQuery - Declarative paginated data fetching hook
  *
- * @returns The HAI3 app instance
+ * Accepts an initial EndpointDescriptor plus descriptor resolvers for adjacent
+ * pages. Each page remains a standard service descriptor so MFE code does not
+ * need raw TanStack query keys or query functions.
  */
-declare function useHAI3(): HAI3App;
+
+interface ApiInfiniteQueryPageContext<TPage> {
+    page: TPage;
+    pages: readonly TPage[];
+    descriptor: EndpointDescriptor<TPage>;
+    descriptors: readonly EndpointDescriptor<TPage>[];
+}
+/** Options shared by useApiInfiniteQuery and useApiSuspenseInfiniteQuery. */
+interface ApiInfiniteQueryBaseOptions<TPage> extends ApiQueryCacheOverrides {
+    /** Descriptor for the first page in the sequence. */
+    initialPage: EndpointDescriptor<TPage>;
+    /**
+     * Resolve the next page descriptor from the current page payload.
+     * Return undefined when there is no next page.
+     */
+    getNextPage: (context: ApiInfiniteQueryPageContext<TPage>) => EndpointDescriptor<TPage> | undefined;
+    /**
+     * Resolve the previous page descriptor from the current first page payload.
+     * Return undefined when backward pagination is not available.
+     */
+    getPreviousPage?: (context: ApiInfiniteQueryPageContext<TPage>) => EndpointDescriptor<TPage> | undefined;
+    /** Optional TanStack maxPages passthrough for bounded page windows. */
+    maxPages?: number;
+}
+/** Options for useApiSuspenseInfiniteQuery. */
+interface ApiSuspenseInfiniteQueryOptions<TPage> extends ApiInfiniteQueryBaseOptions<TPage> {
+    /** A suspense query always runs; use useApiInfiniteQuery to hold one back. */
+    enabled?: never;
+}
+interface ApiInfiniteQueryOptions<TPage> extends ApiInfiniteQueryBaseOptions<TPage> {
+    /**
+     * `false` keeps the query idle: no page is fetched until it turns `true`.
+     * Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+declare function useApiInfiniteQuery<TPage = unknown, TError = Error>(options: ApiInfiniteQueryOptions<TPage>): ApiInfiniteQueryResult<TPage, TError>;
+
+/**
+ * useApiMutation - Declarative mutation hook with restricted QueryCache injection
+ *
+ * Accepts { endpoint: MutationDescriptor, callbacks } and returns a Gears FrontX-owned
+ * ApiMutationResult. Supports optimistic updates, rollback, and cache invalidation
+ * through the QueryCache interface injected into each callback.
+ *
+ * Optimistic update pattern:
+ *   onMutate  -> cancel outgoing refetches, snapshot via queryCache.get,
+ *                apply optimistic data via queryCache.set, return snapshot
+ *   onError   -> restore snapshot via queryCache.set(key, context.snapshot)
+ *   onSettled -> invalidate to refetch authoritative state
+ *
+ * TanStack Query is used internally only and is NOT re-exported.
+ * MFEs interact with the cache through QueryCache, not the raw QueryClient.
+ */
+
+/**
+ * Options for useApiMutation.
+ *
+ * Each callback receives { queryCache } as an additional final parameter,
+ * providing controlled access to the shared cache without exposing the
+ * raw QueryClient. TContext is the return type of onMutate, passed as
+ * context to onSuccess, onError, and onSettled.
+ */
+type UseApiMutationOptions<TData = unknown, TError = Error, TVariables = void, TContext = unknown> = {
+    endpoint: MutationDescriptor<TData, TVariables>;
+    cancelOnSupersede?: boolean;
+    abortOnUnmount?: boolean;
+    onMutate?: (variables: TVariables, ctx: MutationCallbackContext) => Promise<TContext> | TContext;
+    onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined, ctx: MutationCallbackContext) => unknown;
+    onError?: (error: TError, variables: TVariables, context: TContext | undefined, ctx: MutationCallbackContext) => unknown;
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: TContext | undefined, ctx: MutationCallbackContext) => unknown;
+};
+declare function useApiMutation<TData = unknown, TError = Error, TVariables = void, TContext = unknown>(options: UseApiMutationOptions<TData, TError, TVariables, TContext>): ApiMutationResult<TData, TError, TVariables>;
+
+/**
+ * Declarative RBAC guard component.
+ *
+ * Pessimistic: renders `denied` (or `loading` if provided) until an explicit
+ * 'allow' decision arrives from app.auth.canAccess. Only renders `allowed`
+ * after a confirmed allow.
+ *
+ * Example:
+ *   <CanAccess
+ *     query={{ action: AppAction.InvoicesRead, resource: ResourceKind.Invoice }}
+ *     allowed={<InvoiceList />}
+ *     denied={<AccessDenied />}
+ *     loading={<Spinner />}
+ *   />
+ */
+declare function CanAccess<TRecord extends AccessRecord = AccessRecord>({ query, allowed, denied, loading, }: CanAccessProps<TRecord>): ReactElement | null;
 
 /**
  * useAppDispatch Hook - Type-safe dispatch hook
@@ -225,12 +367,192 @@ declare function useFormatters(): UseFormattersReturn;
  */
 declare function useTheme(): UseThemeReturn;
 
+/**
+ * useApiSuspenseQuery - Suspense declarative data fetching hook
+ *
+ * Mirrors useApiQuery but integrates with React Suspense so the initial load is
+ * handled by a Suspense boundary. A suspense query always runs, so there is no
+ * `enabled` override.
+ */
+
+declare function useApiSuspenseQuery<TData = unknown, TError = Error>(descriptor: EndpointDescriptor<TData>, overrides?: ApiSuspenseQueryOverrides): ApiSuspenseQueryResult<TData, TError>;
+
+/**
+ * useApiSuspenseInfiniteQuery - Suspense paginated data fetching hook
+ *
+ * Mirrors useApiInfiniteQuery but integrates with React Suspense so the initial
+ * page load is handled by a Suspense boundary while pagination stays
+ * descriptor-driven.
+ */
+
+declare function useApiSuspenseInfiniteQuery<TPage = unknown, TError = Error>(options: ApiSuspenseInfiniteQueryOptions<TPage>): ApiSuspenseInfiniteQueryResult<TPage, TError>;
+
+/**
+ * useApiStream - Declarative SSE streaming hook
+ *
+ * Accepts a StreamDescriptor from @gears-frontx/api and returns the latest
+ * event, accumulated events, connection status, and a manual disconnect
+ * function.
+ *
+ * @example
+ * ```tsx
+ * const { data, events, status, error } = useApiStream(
+ *   service.messageStream,
+ *   { mode: 'latest' }   // default — data holds last event
+ * );
+ *
+ * // Accumulate all events
+ * const { events, status } = useApiStream(service.messageStream, { mode: 'accumulate' });
+ * ```
+ */
+
+/** Configuration options for useApiStream. */
+interface ApiStreamOptions {
+    /**
+     * `'latest'` (default) — `data` holds the most recent event.
+     * `'accumulate'` — `events` holds all received events in order.
+     */
+    mode?: 'latest' | 'accumulate';
+    /** When false the connection is deferred (no connect on mount). Default true. */
+    enabled?: boolean;
+}
+/** Return type of useApiStream. */
+interface ApiStreamResult<TEvent> {
+    /** Latest event payload, set in both modes — `undefined` until the first event and after each connect attempt resets it. */
+    data: TEvent | undefined;
+    /** All received events when `mode: 'accumulate'`; empty array in `'latest'` mode. */
+    events: TEvent[];
+    /** Connection lifecycle status. */
+    status: StreamStatus;
+    /** Last connect error — set when a connect attempt rejects, cleared when the next attempt starts. */
+    error: Error | null;
+    /** Manually close the connection. */
+    disconnect: () => void;
+}
+/**
+ * Manages the status lifecycle for a single SSE stream connection.
+ *
+ * **Status values**
+ * - `'idle'` — no connection is being attempted. This is the status whenever
+ *   `enabled` is `false`, including on mount: a hook that mounts disabled
+ *   never reports anything but `'idle'` until `enabled` flips to `true`. A
+ *   hook that mounts enabled skips `'idle'` entirely — the status is set
+ *   during render, so its very first render already reports `'connecting'`.
+ *   Consumers must not assume `'idle'` means "never
+ *   connected" — a stream that is disabled after having connected returns to
+ *   `'idle'` too, and `data`/`events` from the earlier connection are not
+ *   cleared by that transition alone (they are cleared by mode/key changes,
+ *   see below).
+ * - `'connecting'` — a connection attempt is committed to but has not settled.
+ *   It is published during the render that turns the stream on, which is
+ *   before `descriptor.connect()` runs: the call is made from an effect after
+ *   that render commits. So `'connecting'` means "this stream is being
+ *   opened", not "the connect promise is pending" — for one render the two
+ *   differ, and a consumer that reads the status as proof a request is already
+ *   in flight is reading it too strongly.
+ * - `'connected'` — set both when `connect()` resolves (unless a disconnect
+ *   was requested while it was pending) and, independently, whenever the
+ *   `onEvent` callback delivers a new event. Because every event re-asserts
+ *   `'connected'`, this status also serves as "still receiving events."
+ * - `'disconnected'` — reached via any of: the descriptor's `onComplete`
+ *   callback firing (the stream ended normally), `connect()` rejecting while
+ *   a disconnect was requested concurrently, or the manual `disconnect()`
+ *   function being called. `disconnect()` has no `enabled` guard, but calling
+ *   it while the stream is disabled is not observable: the stored status moves
+ *   to `'disconnected'` while the published one stays `'idle'`, and flipping
+ *   `enabled` back to `true` sets `'connecting'` during that render, so the
+ *   stored `'disconnected'` is overwritten before it is ever returned.
+ * - `'error'` — `connect()` rejected and no disconnect was requested while it
+ *   was pending. `error` holds the rejection, coerced to an `Error` if it
+ *   wasn't one already.
+ *
+ * **Transitions**
+ * - Mounting enabled, `enabled` becoming `true`, or `descriptor.key` / `mode`
+ *   changing while `enabled` is `true`: `data`, `events`, and `error` are reset
+ *   and status is set to `'connecting'` synchronously during render (not from
+ *   an effect); `connect()` is then called from an effect that runs after that
+ *   render commits.
+ * - `descriptor.key` or `mode` changing while `enabled` is `false`: `data`,
+ *   `events`, and `error` are reset all the same, since that reset is not gated
+ *   on `enabled`, but the status write is - so no `'connecting'` is written and
+ *   the published status stays `'idle'`; `connect()` is not called. The skipped
+ *   `'connecting'` is not owed later either: the change counts as handled when
+ *   it happens, so what publishes `'connecting'` is the subsequent flip of
+ *   `enabled` to `true`, once, for whichever key and mode are in force by then.
+ * - `enabled` becomes `false` (or starts `false`): the published status is
+ *   `'idle'` for as long as `enabled` stays `false` — it is derived from
+ *   `enabled` rather than written, so nothing a prior connection stored can
+ *   surface through it — and `connect()` is never called; no other field is
+ *   reset by this transition alone.
+ * - Unmount, `descriptor.key` change, `mode` change, or `enabled` flipping to
+ *   `false` while connected or connecting: the previous connection is torn
+ *   down via `descriptor.disconnect()` once its `connect()` promise settles
+ *   (or immediately skipped if it rejected). All four share the same cleanup
+ *   path: the effect's cleanup runs on every dependency change and on unmount.
+ * - Calling `disconnect()`: if a connection id is already resolved, it is
+ *   disconnected immediately and status becomes `'disconnected'`. If
+ *   `connect()` is still pending, the request is recorded and honored when
+ *   the promise settles — the newly resolved connection is torn down instead
+ *   of being adopted, and status is `'disconnected'`. One caveat:
+ *   `disconnect()` does not cancel the event callback, so a buffered or
+ *   in-flight event landing after the call re-asserts `'connected'` — and in
+ *   the pending-connect case the settle handler tears the connection down
+ *   without touching status, so that stray `'connected'` persists.
+ * - Stream completion while `connect()` is still pending: the current
+ *   implementation lets `onComplete` set `'disconnected'`, then the settle
+ *   handler adopts the connection id and re-asserts `'connected'` anyway.
+ *   This is known current behavior, not a durable guarantee: a pending
+ *   upstream derived-status rewrite is expected to remove this transition.
+ *
+ * `enabled` (default `true`) is the only way to defer connecting past mount;
+ * flipping it back to `true` re-runs the same connect sequence as a fresh
+ * mount would.
+ */
+declare function useApiStream<TEvent>(descriptor: StreamDescriptor<TEvent>, options?: ApiStreamOptions): ApiStreamResult<TEvent>;
+
+/**
+ * Exposes the sanctioned imperative cache API for app and MFE code without
+ * leaking the raw QueryClient.
+ *
+ * Preferred usage:
+ * - useApiQuery() for declarative reads
+ * - useApiMutation() for writes
+ * - useQueryCache() for controlled imperative cache inspection and invalidation
+ *
+ * The returned handle is not bound to the cache scope (mock mode, tenant,
+ * session): it writes to whatever scope is current. A write after an await or
+ * inside a mutation callback must use the `queryCache` that callback receives,
+ * which drops writes once the scope changed since the mutation started.
+ */
+declare function useQueryCache(): QueryCache;
+
+/**
+ * Declarative RBAC guard hook.
+ *
+ * Pessimistic: `allow` is false until an explicit 'allow' decision arrives.
+ * Aborts the in-flight canAccess call on unmount and on query change.
+ *
+ * State machine:
+ *   mount               -> Pending (allow=false, isResolving=true)
+ *   Pending -> 'allow'  -> Allowed (allow=true,  isResolving=false)
+ *   Pending -> 'deny'   -> Denied  (allow=false, isResolving=false)
+ *   Pending -> error    -> Denied  (allow=false, isResolving=false)
+ *   Allowed -> query-change -> Pending  (re-pessimize)
+ *   Denied  -> query-change -> Pending  (re-pessimize)
+ */
+declare function useCanAccess<TRecord extends AccessRecord = AccessRecord>(query: AccessQuery<TRecord>): UseCanAccessResult;
+
 /**
  * MFE Provider - Provides MFE context to child components
  *
  * Wraps MFE components with bridge and metadata.
  * Used by the MFE mounting system.
  *
+ * MfeProvider does not create or own the shared QueryClient. When the host uses
+ * queryCache() and the child app uses queryCacheShared(), overlapping queries
+ * (same query key) are deduplicated and cached once across MFE boundaries.
+ * Each MFE still uses its own apiRegistry and service instances in queryFn.
+ *
  * React Layer: L3 (Depends on @gears-frontx/framework)
  */
 
@@ -283,7 +605,7 @@ declare const MfeProvider: React__default.FC<MfeProviderProps>;
  *   // bridge.executeActionsChain(chain);
  *   // bridge.subscribeToProperty(propertyTypeId, callback);
  *
- *   return <div>Domain: {bridge.domainId}</div>;
+ *   return <div>Domain: {bridge.extDomainId}</div>;
  * }
  * ```
  */
@@ -292,32 +614,94 @@ declare function useMfeBridge(): ChildMfeBridge;
 /**
  * useSharedProperty Hook - Shared property subscription
  *
- * Subscribes to shared property updates from the host.
+ * Subscribes to shared property updates from the host, either through the
+ * ambient MfeProvider context or through an explicitly supplied bridge.
  *
  * React Layer: L3
  */
+
 /**
- * Hook for subscribing to a shared property.
- *
- * Subscribes to property updates from the host and returns the current value.
- * Must be used within a MfeProvider (i.e., inside an MFE component).
- *
- * NOTE: This hook provides the interface and uses useSyncExternalStore with a stub subscription.
- * Full bridge subscription should be implemented when bridge methods are available.
- *
- * @param _propertyTypeId - Type ID of the shared property to subscribe to (currently unused)
- * @returns Current property value
- *
- * @example
+ * Options for {@link useSharedProperty}.
+ */
+interface UseSharedPropertyOptions<T> {
+    /**
+     * Bridge to read the property from, bypassing `MfeContext`.
+     *
+     * Pass this when the calling component never mounts `MfeProvider` (for
+     * example, a component that receives its bridge directly as a prop or from
+     * a non-React entry point). When omitted, the hook falls back to the
+     * bridge from `MfeContext` and throws if no `MfeProvider` is mounted,
+     * matching the zero-argument form.
+     *
+     * `bridge` and `propertyTypeId` identify the subscription: changing either
+     * one unsubscribes from the old source and subscribes to the new one, and
+     * the returned value reflects the new source on the same render.
+     */
+    bridge?: ChildMfeBridge;
+    /**
+     * Value returned while the host has not published the property yet
+     * (`bridge.getProperty()` returns `undefined`).
+     *
+     * Only the `undefined` sentinel is substituted: a published `null` is a
+     * real value and is returned as-is. The host validates every published
+     * value against the property's schema before it reaches any MFE
+     * (`TypeSystemPlugin.register()` throws on a schema mismatch and the
+     * update is never stored or delivered), so no consumer-side filtering is
+     * needed -- `T` is simply the caller's declaration of that schema.
+     *
+     * `fallback` may be passed inline on every render; it does not affect the
+     * host subscription.
+     */
+    fallback?: T;
+}
+/**
+ * Subscribe to a shared property from the host.
+ *
+ * Two forms:
+ *
+ * 1. **Context form** -- `useSharedProperty(propertyTypeId)`. Reads the
+ *    bridge from `MfeContext` and throws if no `MfeProvider` is mounted.
+ * 2. **Options form** -- `useSharedProperty(propertyTypeId, options)`. Pass
+ *    `options.bridge` for components that never mount `MfeProvider`, and/or
+ *    `options.fallback` for a value to show until the host publishes one.
+ *    `options.bridge` may be omitted, in which case the hook still falls
+ *    back to `MfeContext`.
+ *
+ * Both forms read through `useSyncExternalStore`: the bridge is the store,
+ * `bridge.getProperty()` is the snapshot, so the first render already shows
+ * the host's current value, a publish between render and commit is picked
+ * up when React re-reads the snapshot after subscribing, and the value is
+ * tearing-protected under concurrent rendering.
+ *
+ * @param propertyTypeId - GTS type ID of the shared property to subscribe to
+ * @param options - Optional bridge override and fallback
+ * @returns The current property value; `T` when `options.fallback` is set,
+ *   otherwise `T | undefined`
+ *
+ * @example Context form (inside MfeProvider)
  * ```tsx
- * function MyMfeComponent() {
- *   const userData = useSharedProperty('gts.frontx.mfes.comm.shared_property.v1~myapp.user_data.v1');
+ * function ThemedComponent() {
+ *   const theme = useSharedProperty<{ primaryColor: string }>(THEME_PROPERTY_ID);
+ *   return <div style={{ color: theme?.primaryColor }} />;
+ * }
+ * ```
  *
- *   return <div>User: {userData?.name}</div>;
+ * @example Explicit bridge with fallback (no MfeProvider)
+ * ```tsx
+ * function StandaloneComponent({ bridge }: { bridge: ChildMfeBridge }) {
+ *   const label = useSharedProperty<string>(LABEL_PROPERTY_ID, {
+ *     bridge,
+ *     fallback: 'Untitled',
+ *   });
+ *   return <span>{label}</span>;
  * }
  * ```
  */
 declare function useSharedProperty<T = unknown>(propertyTypeId: string): T | undefined;
+declare function useSharedProperty<T>(propertyTypeId: string, options: UseSharedPropertyOptions<T> & {
+    fallback: T;
+}): T;
+declare function useSharedProperty<T = unknown>(propertyTypeId: string, options?: UseSharedPropertyOptions<T>): T | undefined;
 
 /**
  * useHostAction Hook - Host action requests
@@ -352,6 +736,31 @@ declare function useSharedProperty<T = unknown>(propertyTypeId: string): T | und
  */
 declare function useHostAction<TPayload extends Record<string, unknown> = Record<string, unknown>>(actionTypeId: string): (payload?: TPayload) => void;
 
+/**
+ * useMfeRegistry Hook - Shared MfeRegistry access guard
+ *
+ * Resolves the MFE-enabled registry off the FrontX app instance and throws a
+ * descriptive error when the `microfrontends()` plugin was not installed.
+ * Extracted so every registry-consuming hook shares one guard implementation
+ * instead of hand-rolling the same `if (!app.mfeRegistry)` check.
+ *
+ * React Layer: L3
+ */
+
+/**
+ * Hook for accessing the MFE-enabled registry off the current FrontX app.
+ *
+ * Throws if the app was built without the `microfrontends()` plugin.
+ *
+ * @returns The MFE-enabled registry
+ *
+ * @example
+ * ```ts
+ * const registry = useMfeRegistry();
+ * ```
+ */
+declare function useMfeRegistry(): MfeRegistry;
+
 /**
  * useDomainExtensions Hook - Domain extension list subscription
  *
@@ -364,7 +773,7 @@ declare function useHostAction<TPayload extends Record<string, unknown> = Record
 /**
  * Hook for observing extensions registered for a domain.
  *
- * Subscribes to the HAI3 store to detect registration state changes,
+ * Subscribes to the FrontX store to detect registration state changes,
  * and returns the current list of extensions for the specified domain.
  *
  * @param domainId - Domain ID to query extensions for
@@ -385,7 +794,7 @@ declare function useHostAction<TPayload extends Record<string, unknown> = Record
  * }
  * ```
  */
-declare function useDomainExtensions(domainId: string): Extension[];
+declare function useDomainExtensions(domainId: string): Array<Omit<Extension, 'route'>>;
 
 /**
  * useRegisteredPackages Hook - Registered GTS packages subscription
@@ -398,7 +807,7 @@ declare function useDomainExtensions(domainId: string): Extension[];
 /**
  * Hook for observing registered GTS packages.
  *
- * Subscribes to the HAI3 store to detect registration state changes,
+ * Subscribes to the FrontX store to detect registration state changes,
  * and returns the current list of GTS packages extracted from registered
  * extensions.
  *
@@ -406,7 +815,7 @@ declare function useDomainExtensions(domainId: string): Extension[];
  * This hook uses `useSyncExternalStore` with `app.store.subscribe`, which
  * fires on any Redux dispatch. Since `registerExtension()` dispatches to
  * the mfe store slice, the subscription WILL trigger when packages change.
- * The `getSnapshot` function calls `screensetsRegistry.getRegisteredPackages()`
+ * The `getSnapshot` function calls `mfeRegistry.getRegisteredPackages()`
  * which reads the private `packages` Map. This works because every package
  * map mutation (in registerExtension/unregisterExtension) is always
  * accompanied by a store dispatch in the same serializer callback.
@@ -434,74 +843,182 @@ declare function useDomainExtensions(domainId: string): Extension[];
 declare function useRegisteredPackages(): string[];
 
 /**
- * useActivePackage Hook - Active GTS package subscription
- *
- * Subscribes to store changes and returns the GTS package of the currently
- * mounted screen extension.
- *
- * React Layer: L3
+ * Abstract base class for React-based MFE lifecycle implementations.
+ *
+ * Styling strategy:
+ * 1. adoptHostStylesIntoShadowRoot() clones all host <style> and <link> into the
+ *    front of the shadow root, bringing the full compiled Tailwind CSS (including
+ *    MFE utilities, since the host's content paths cover src-app/mfe_packages/**) and
+ *    the ui-kit component CSS (the host entry side-effect-imports
+ *    @gears-frontx/ui-kit so that CSS exists in the host document; the kit's
+ *    CSS-module class names are stable per kit version, so they match the
+ *    classes MFE bundles reference only while host and MFE install the same
+ *    kit version - the template-pin-drift policy check is what guarantees
+ *    that; a drifted MFE renders its kit components unstyled with no error).
+ *    Front, not back, so the MFE's own stylesheets
+ *    outrank them - see the method. Design tokens must therefore be full CSS
+ *    colors - both Tailwind utilities (var(--x)) and ui-kit component CSS
+ *    consume them directly.
+ * 2. injectBaseResets() adds box-model resets and :host defaults that aren't part
+ *    of Tailwind's compiled output but are needed for consistent rendering, and
+ *    positions them at the end of the shell-owned head - after the adopted block
+ *    and the isolation style, ahead of the MFE's own CSS.
+ * 3. Subclasses may override initializeStyles() to inject additional CSS that is
+ *    not covered by the host stylesheet (e.g., MFE-specific @font-face rules).
+ *
+ * Every mount therefore leaves the same sequence - adopted host block, shadow
+ * isolation, base resets, then the MFE's stylesheets - so the shell's CSS is
+ * context and the MFE wins every specificity tie against all three shell blocks.
+ * Steps 1 and 2 both position what they own rather than appending beside it,
+ * because a remounted container arrives with its shadow root intact and the MFE's
+ * own stylesheet removed and re-appended around the remount - see each method.
+ *
+ * Theme CSS variables are delivered via CSS inheritance from :root (Shadow DOM)
+ * or via MountManager injection (iframe). MFE lifecycles do NOT need to subscribe
+ * to theme changes or call applyThemeToShadowRoot.
+ *
+ * Concrete subclasses must provide:
+ * - `renderContent(bridge)` - screen component rendering
  */
-/**
- * Hook for observing the active GTS package (the package of the currently
- * mounted screen extension).
- *
- * Subscribes to the HAI3 store to detect mount state changes, and returns
- * the GTS package extracted from the currently mounted screen extension's ID.
- *
- * Returns `undefined` if no screen extension is currently mounted.
- *
- * @returns GTS package string of the active screen extension, or undefined
- *
- * @example
- * ```tsx
- * function ActivePackageIndicator() {
- *   const activePackage = useActivePackage();
- *
- *   if (!activePackage) {
- *     return <div>No active screen</div>;
- *   }
- *
- *   return <div>Active package: {activePackage}</div>;
- * }
- * ```
- */
-declare function useActivePackage(): string | undefined;
-
-/**
- * Ref Container Provider
- *
- * Concrete ContainerProvider that wraps a React ref.
- * Created by React components (like ExtensionDomainSlot) for use
- * by framework-level domain registration code.
- *
- * @packageDocumentation
- */
-
-/**
- * Concrete ContainerProvider that wraps a React ref.
- *
- * This provider reads the container element from a React ref at mount time.
- * It is designed to be created by React components but passed to domain
- * registration code (framework-level).
- *
- * Usage pattern:
- * 1. React component creates a ref via `useRef<HTMLDivElement>(null)`
- * 2. Framework-level code creates `RefContainerProvider` wrapping the ref
- * 3. Framework-level code passes the provider to `registerDomain(domain, provider)`
- * 4. When mount_ext is dispatched, the provider returns `ref.current`
- */
-declare class RefContainerProvider extends ContainerProvider {
-    private readonly containerRef;
-    constructor(containerRef: RefObject<HTMLDivElement>);
-    getContainer(_extensionId: string): Element;
-    releaseContainer(_extensionId: string): void;
+declare abstract class ThemeAwareReactLifecycle implements MfeEntryLifecycle<ChildMfeBridge> {
+    private readonly app;
+    private root;
+    constructor(app: FrontXApp);
+    mount(container: Element | ShadowRoot, bridge: ChildMfeBridge, mountContext?: MfeMountContext): void;
+    /**
+     * `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).
+     */
+    unmount(_container: Element | ShadowRoot): Promise<void>;
+    /**
+     * 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.
+     */
+    protected adoptHostStylesIntoShadowRoot(shadowRoot: ShadowRoot): void;
+    /**
+     * 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.
+     */
+    private injectBaseResets;
+    /**
+     * 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.
+     */
+    protected initializeStyles(_container: Element | ShadowRoot): void;
+    /**
+     * Return the screen-specific React component tree.
+     */
+    protected abstract renderContent(bridge: ChildMfeBridge): React__default.ReactNode;
 }
 
 /**
  * Extension Domain Slot Component
  *
- * React component that renders extensions within a domain slot.
- * Manages extension lifecycle (mount/unmount) and provides rendering context.
+ * Per-domain React component that provides the DOM root for a registered domain.
+ * Delegates root attachment to the per-domain ExtensionMounter obtained from the
+ * registry. What extensions live inside the root is a domain-policy concern (the
+ * active MountStrategy plus the domain implementation's ContainerHooks), not a
+ * slot-API concern.
+ *
+ * The slot is uniform across all cardinalities (Exclusive / Optional / Concurrent).
+ * Mount and unmount actions are dispatched by the host application via
+ * registry.executeActionsChain — NOT by this component.
  *
  * @packageDocumentation
  */
@@ -511,57 +1028,47 @@ declare class RefContainerProvider extends ContainerProvider {
  */
 interface ExtensionDomainSlotProps {
     /**
-     * The screensets registry instance
+     * The MFE registry instance.
      */
-    registry: ScreensetsRegistry;
+    registry: MfeRegistry;
     /**
-     * The domain ID for this slot
+     * The domain ID for this slot.
      */
     domainId: string;
     /**
-     * The extension ID to render in this slot
-     */
-    extensionId: string;
-    /**
-     * Optional CSS class name for the container
+     * Optional CSS class name for the root container div.
      */
     className?: string;
     /**
-     * Optional callback when extension is mounted
+     * Optional callback invoked after mounter.attach(element) returns.
+     * Receives the root element that was attached.
      */
-    onMounted?: (bridge: ParentMfeBridge) => void;
+    onAttached?: (root: Element) => void;
     /**
-     * Optional callback when extension is unmounted
+     * Optional callback invoked after mounter.detach() returns on cleanup.
      */
-    onUnmounted?: () => void;
+    onDetached?: () => void;
     /**
-     * Optional error callback
-     */
-    onError?: (error: Error) => void;
-    /**
-     * Optional loading component
+     * Optional loading placeholder rendered before the mounter has been attached.
+     * Defaults to null (no visual placeholder).
      */
     loadingComponent?: React__default.ReactNode;
-    /**
-     * Optional error component renderer
-     */
-    errorComponent?: (error: Error) => React__default.ReactNode;
 }
 /**
  * Extension Domain Slot Component
  *
- * Renders an extension within a domain slot. Manages the extension lifecycle:
- * - Mounts the extension on component mount
- * - Unmounts the extension on component unmount
- * - Handles loading and error states
+ * Renders a single root `<div>` per domain instance. On ref-attach, resolves the
+ * per-domain mounter via registry.getMounter(domainId) and calls mounter.attach(element).
+ * On cleanup, calls mounter.detach() which mass-unmounts every currently-mounted
+ * extension in the domain so no orphan DOM trees or slice/registry desync remain.
  *
  * @example
  * ```tsx
  * <ExtensionDomainSlot
  *   registry={registry}
- *   domainId="gts.frontx.mfes.ext.domain.v1~frontx.screensets.layout.sidebar.v1"
- *   extensionId="gts.frontx.mfes.ext.extension.v1~myapp.sidebar.widget.v1"
- *   className="sidebar-slot"
+ *   domainId={FRONTX_SCREEN_DOMAIN}
+ *   loadingComponent={<Loading />}
+ *   onAttached={(root) => console.log('Root attached:', root)}
  * />
  * ```
  */
@@ -571,7 +1078,7 @@ declare function ExtensionDomainSlot(props: ExtensionDomainSlotProps): React__de
  * @gears-frontx/react - React Bindings
  *
  * This package provides:
- * - HAI3Provider context provider
+ * - FrontXProvider context provider
  * - Type-safe hooks for state and actions
  * - MFE context, hooks, and components
  *
@@ -587,4 +1094,4 @@ interface EventPayloadMap extends EventPayloadMap$1 {
  */
 declare const eventBus: EventBus<EventPayloadMap>;
 
-export { type EventPayloadMap, ExtensionDomainSlot, type ExtensionDomainSlotProps, HAI3Context, HAI3Provider, HAI3ProviderProps, MfeContextValue, MfeProvider, type MfeProviderProps, RefContainerProvider, UseFormattersReturn, UseScreenTranslationsReturn, UseThemeReturn, UseTranslationReturn, eventBus, useActivePackage, useAppDispatch, useAppSelector, useDomainExtensions, useFormatters, useHAI3, useHostAction, useMfeBridge, useRegisteredPackages, useScreenTranslations, useSharedProperty, useTheme, useTranslation };
+export { type ApiInfiniteQueryOptions, type ApiInfiniteQueryPageContext, ApiInfiniteQueryResult, ApiMutationResult, type ApiQueryOverrides, ApiQueryResult, type ApiStreamOptions, type ApiStreamResult, type ApiSuspenseInfiniteQueryOptions, ApiSuspenseInfiniteQueryResult, type ApiSuspenseQueryOverrides, ApiSuspenseQueryResult, CanAccess, CanAccessProps, type EventPayloadMap, ExtensionDomainSlot, type ExtensionDomainSlotProps, FrontXContext, FrontXProvider, FrontXProviderProps, MfeContextValue, MfeProvider, type MfeProviderProps, MutationCallbackContext, QueryCache, ThemeAwareReactLifecycle, type UseApiMutationOptions, UseCanAccessResult, UseFormattersReturn, UseScreenTranslationsReturn, type UseSharedPropertyOptions, UseThemeReturn, UseTranslationReturn, eventBus, useApiInfiniteQuery, useApiMutation, useApiQuery, useApiStream, useApiSuspenseInfiniteQuery, useApiSuspenseQuery, useAppDispatch, useAppSelector, useCanAccess, useDomainExtensions, useFormatters, useFrontX, useHostAction, useMfeBridge, useMfeRegistry, useQueryCache, useRegisteredPackages, useScreenTranslations, useSharedProperty, useTheme, useTranslation };