@gooddata/sdk-ui-pluggable-host 11.40.0-alpha.3

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 GoodData Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# GoodData.UI SDK - Pluggable Host Runtime
+
+This package is a part of the [GoodData.UI SDK](https://sdk.gooddata.com/gooddata-ui/docs/about_gooddataui.html).
+To learn more, check [the source monorepo](https://github.com/gooddata/gooddata-ui-sdk).
+
+This package provides the runtime for hosting GoodData pluggable applications: the application registry, the Module Federation loader, route resolution, platform context loading, and the default host UI chrome.
+
+## Stability
+
+The API surface is marked `@alpha` and may change between minor releases.
+
+## Backend support
+
+Currently only the GoodData Cloud (Tiger) backend is supported. The package depends on `@gooddata/sdk-backend-tiger` directly; running against a different backend is not supported. Lifting this behind the backend SPI is tracked as future work.
+
+## License
+
+(C) 2026 GoodData Corporation
+
+This project is under MIT License. See [LICENSE](https://github.com/gooddata/gooddata-ui-sdk/blob/master/libs/sdk-ui-pluggable-host/LICENSE).

package/esm/assets/logo-white.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="26" viewBox="0 0 24 26" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M23.4402 16.3133C23.3661 13.0781 21.62 10.5101 18.9543 9.50636V3.87563C18.2812 3.43554 17.5648 3.07169 16.8171 2.79197V14.9057C16.8171 17.3055 15.7287 18.377 13.9795 18.377C12.2766 18.377 10.8522 17.0615 10.8522 14.8616C10.8522 12.4061 12.7233 10.9066 15.1734 10.9066C15.4004 10.9023 15.6314 10.9144 15.8584 10.9507V8.80705C15.6314 8.76709 15.4045 8.74711 15.1734 8.75131C11.5371 8.75131 8.68771 11.0312 8.68771 14.8663C8.68771 18.5537 11.2592 20.5212 14.1246 20.5212C15.4827 20.5212 16.6571 20.0491 17.4676 19.2372C18.2776 18.4254 18.9631 17.2534 18.9631 15.1939V11.8383C20.4426 12.5943 21.3349 14.4257 21.339 16.5215C21.3313 20.4686 17.7496 23.8043 13.5498 23.8043C13.452 23.8043 13.3774 23.8043 13.2796 23.8001C10.3988 23.7964 7.86638 22.7322 5.81512 20.6327C4.3392 19.121 3.32952 17.1972 2.92246 15.1055C2.5154 13.0097 2.72279 10.8424 3.52508 8.86647C4.32376 6.89474 5.67772 5.20694 7.41558 4.01917C9.15344 2.8314 11.197 2.1994 13.2868 2.1994V0C11.6154 0 9.95984 0.335981 8.41754 0.987966C6.87523 1.63995 5.47033 2.59952 4.28825 3.80359C1.90043 6.23907 0.5578 9.54632 0.5578 12.9939C0.5578 16.4411 1.89632 19.7488 4.28002 22.1885C6.66372 24.6282 9.90066 26 13.275 26H13.5452C14.5826 26 15.616 25.836 16.6102 25.52C16.6143 25.52 16.6179 25.5157 16.6221 25.5157C18.0584 25.0599 19.3737 24.2838 20.4776 23.2443C22.3837 21.4445 23.433 19.0653 23.4407 16.5336C23.4443 16.5252 23.4402 16.3175 23.4402 16.3133Z" fill="white"/>
+</svg>

package/esm/components/FullScreenLoader.d.ts

@@ -0,0 +1 @@
+export declare function FullScreenLoader(): import("react/jsx-runtime").JSX.Element;

package/esm/components/FullScreenLoader.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { LoadingComponent } from "@gooddata/sdk-ui";
+import { bemFactory } from "@gooddata/sdk-ui-kit";
+const { e } = bemFactory("gd-host-root");
+export function FullScreenLoader() {
+    return (_jsx("div", { className: e("loading"), children: _jsx(LoadingComponent, { height: 40 }) }));
+}

package/esm/components/HostUiContainer.d.ts

@@ -0,0 +1,16 @@
+import { type NavigateFunction } from "react-router";
+import { type PluggableApplicationRegistryItem } from "@gooddata/sdk-model";
+import { type IPlatformContext } from "@gooddata/sdk-pluggable-application-model";
+import "./HostUiContainer.scss";
+export interface IHostUiContainerProps {
+    ctx: IPlatformContext;
+    apps: PluggableApplicationRegistryItem[];
+    pathname: string;
+    routerNavigate: NavigateFunction;
+}
+/**
+ * Mounts the host UI module into a container div, then renders the active
+ * pluggable application into the host's app slot. Handles all lifecycle
+ * updates (context, apps, pathname) via the host mount handle.
+ */
+export declare function HostUiContainer({ ctx, apps, pathname, routerNavigate }: IHostUiContainerProps): import("react/jsx-runtime").JSX.Element;

package/esm/components/HostUiContainer.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createRoot } from "react-dom/client";
+import { resolveLocale, useAutoupdateRef } from "@gooddata/sdk-ui";
+import { now } from "../debug.js";
+import { setActiveHostHandle } from "../lib/hostNotifications.js";
+import { getAppLifecycleCallbacks } from "../loader/pluggableApplicationsLoader.js";
+import { getActiveInternalApplication } from "../loader/routing.js";
+import { HostIntlProvider } from "../ui/HostIntlProvider.js";
+import { PluggableApplicationRenderer } from "../ui/PluggableApplicationRenderer.js";
+import { resolveHostUiModule } from "../ui/resolveHostUiModule.js";
+import "./HostUiContainer.scss";
+/**
+ * Mounts the host UI module into a container div, then renders the active
+ * pluggable application into the host's app slot. Handles all lifecycle
+ * updates (context, apps, pathname) via the host mount handle.
+ */
+export function HostUiContainer({ ctx, apps, pathname, routerNavigate }) {
+    const activeInternalApplication = useMemo(() => getActiveInternalApplication(apps, ctx, pathname), [apps, ctx, pathname]);
+    const containerRef = useRef(null);
+    const handleRef = useRef(undefined);
+    const appRootRef = useRef(undefined);
+    const [hostReady, setHostReady] = useState(false);
+    const latestMountStateRef = useAutoupdateRef({ ctx, apps, pathname });
+    const [headerOptions, setHeaderOptions] = useState(undefined);
+    const activeAppRef = useAutoupdateRef(activeInternalApplication);
+    const onHeaderChange = useCallback((appId, header) => {
+        if (activeAppRef.current?.id === appId) {
+            setHeaderOptions(header);
+        }
+    }, [activeAppRef]);
+    // Stable navigation callbacks that always use the latest router navigate
+    const navigateRef = useAutoupdateRef(routerNavigate);
+    const navigate = useCallback((url) => {
+        void navigateRef.current(url);
+    }, [navigateRef]);
+    const replace = useCallback((url) => {
+        void navigateRef.current(url, { replace: true });
+    }, [navigateRef]);
+    const navigationMountRef = useAutoupdateRef({ navigate, replace });
+    // Mount the host UI once; obtain the app container for rendering active apps
+    useEffect(() => {
+        const container = containerRef.current;
+        if (!container) {
+            return;
+        }
+        let mounted = true;
+        const mountStart = now();
+        void resolveHostUiModule(latestMountStateRef.current.ctx).then((hostUiModule) => {
+            if (!mounted) {
+                return;
+            }
+            const latestState = latestMountStateRef.current;
+            const handle = hostUiModule.mount({
+                container,
+                ctx: latestState.ctx,
+                resolvedApplications: latestState.apps,
+                pathname: latestState.pathname,
+                navigate: navigationMountRef.current.navigate,
+                replace: navigationMountRef.current.replace,
+            });
+            handleRef.current = handle;
+            appRootRef.current = createRoot(handle.getAppContainer());
+            setHostReady(true);
+            getAppLifecycleCallbacks()?.onHostUiMounted?.(now() - mountStart);
+            // Replay the latest values in case they changed while the async host UI module was resolving.
+            handle.updateContext?.(latestState.ctx);
+            handle.updateApplications?.(latestState.apps);
+            handle.updatePathname?.(latestState.pathname);
+            // Route runtime notifications (e.g. new-deployment-available) to this UI;
+            // any notifications queued during mount are flushed inside setActiveHostHandle.
+            setActiveHostHandle(handle);
+        });
+        return () => {
+            mounted = false;
+            setActiveHostHandle(undefined);
+            const appRoot = appRootRef.current;
+            appRootRef.current = undefined;
+            const handle = handleRef.current;
+            handleRef.current = undefined;
+            appRoot?.unmount();
+            handle?.unmount();
+        };
+        // Mount only once; updates are pushed via handle
+    }, [latestMountStateRef, navigationMountRef]);
+    // Push updates when context, apps, or pathname change after initial mount
+    useEffect(() => {
+        if (!hostReady) {
+            return;
+        }
+        handleRef.current?.updateContext?.(ctx);
+    }, [hostReady, ctx]);
+    useEffect(() => {
+        if (!hostReady) {
+            return;
+        }
+        handleRef.current?.updateApplications?.(apps);
+    }, [hostReady, apps]);
+    useEffect(() => {
+        if (!hostReady) {
+            return;
+        }
+        handleRef.current?.updatePathname?.(pathname);
+    }, [hostReady, pathname]);
+    // Push header options to the host UI whenever they change
+    useEffect(() => {
+        if (!hostReady) {
+            return;
+        }
+        handleRef.current?.updateHeader?.(headerOptions);
+    }, [hostReady, headerOptions]);
+    // Track app navigation and page views when the active application changes.
+    // Also clear header options on app switch so stale customizations don't leak.
+    const prevAppIdRef = useRef(undefined);
+    useEffect(() => {
+        const lifecycle = getAppLifecycleCallbacks();
+        const activeId = activeInternalApplication?.id;
+        if (activeId !== prevAppIdRef.current) {
+            if (activeId) {
+                lifecycle?.onAppNavigation?.(activeId, pathname);
+                lifecycle?.onPageVisited?.(activeId);
+            }
+            prevAppIdRef.current = activeId;
+            setHeaderOptions(undefined);
+        }
+    }, [activeInternalApplication, pathname]);
+    // Render the active pluggable application into the host UI's app container
+    useEffect(() => {
+        if (!hostReady || !appRootRef.current) {
+            return;
+        }
+        if (activeInternalApplication) {
+            appRootRef.current.render(_jsx(HostIntlProvider, { locale: resolveLocale(ctx.preferredLocale), children: _jsx(PluggableApplicationRenderer, { app: activeInternalApplication, ctx: ctx, pathname: pathname, onHeaderChange: onHeaderChange }, activeInternalApplication.id) }));
+        }
+        else {
+            appRootRef.current.render(null);
+        }
+    }, [hostReady, activeInternalApplication, ctx, onHeaderChange, pathname]);
+    return _jsx("div", { ref: containerRef, className: "gd-host-ui-container" });
+}

package/esm/components/HostUiContainer.scss

@@ -0,0 +1,5 @@
+// (C) 2026 GoodData Corporation
+
+.gd-host-ui-container {
+    height: 100%;
+}

package/esm/components/Root.d.ts

@@ -0,0 +1,16 @@
+import { type IPlatformContext } from "@gooddata/sdk-pluggable-application-model";
+import "../styles/global.css";
+import "./Root.scss";
+/**
+ * @alpha
+ */
+export interface IRootCallbacks {
+    onReady?: (ctx: IPlatformContext) => void;
+    onError?: (error: string, context: string) => void;
+}
+/**
+ * @alpha
+ */
+export declare function Root({ callbacks }: {
+    callbacks?: IRootCallbacks;
+}): import("react/jsx-runtime").JSX.Element;

package/esm/components/Root.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useEffect } from "react";
+import { FormattedMessage } from "react-intl";
+import { useLocation, useNavigate } from "react-router";
+import { DEFAULT_LANGUAGE, resolveLocale } from "@gooddata/sdk-ui";
+import { bemFactory } from "@gooddata/sdk-ui-kit";
+import { useLoadPlatformContext } from "../platformContext/useLoadPlatformContext.js";
+import { usePluggableApplications } from "../registry/pluggableApplicationsRegistry.js";
+import { HostIntlProvider } from "../ui/HostIntlProvider.js";
+import { FullScreenLoader } from "./FullScreenLoader.js";
+import { HostUiContainer } from "./HostUiContainer.js";
+import { useRedirectNavigation } from "./useRedirectNavigation.js";
+import { useRedirectTarget } from "./useRedirectTarget.js";
+import "../styles/global.css";
+import "./Root.scss";
+const { e } = bemFactory("gd-host-root");
+/**
+ * @alpha
+ */
+export function Root({ callbacks }) {
+    const platformContext = useLoadPlatformContext();
+    if (platformContext.state === "loading") {
+        return _jsx(FullScreenLoader, {});
+    }
+    if (platformContext.state === "error") {
+        return (_jsx(HostIntlProvider, { locale: DEFAULT_LANGUAGE, children: _jsxs("main", { className: e("error"), children: [
+                    _jsx("h1", { children: _jsx(FormattedMessage, { id: "gs.host.error.failedToLoad" }) }), _jsx("p", { children: platformContext.error })
+                ] }) }));
+    }
+    return _jsx(ReadyRoot, { ctx: platformContext.ctx, callbacks: callbacks });
+}
+function ReadyRoot({ ctx, callbacks }) {
+    useEffect(() => {
+        callbacks?.onReady?.(ctx);
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps -- run once on mount
+    const { pathname } = useLocation();
+    const routerNavigate = useNavigate();
+    const apps = usePluggableApplications(ctx);
+    const redirect = useRedirectTarget(apps, ctx, pathname);
+    useRedirectNavigation(redirect, routerNavigate);
+    useEffect(() => {
+        if (redirect.state === "not-found") {
+            callbacks?.onError?.("Page not found", pathname);
+        }
+        else if (redirect.state === "error") {
+            callbacks?.onError?.(redirect.error, "redirect");
+        }
+    }, [redirect]); // eslint-disable-line react-hooks/exhaustive-deps -- pathname is intentionally omitted; redirect already encapsulates path evaluation
+    if (redirect.state === "loading" || redirect.state === "redirect") {
+        return _jsx(FullScreenLoader, {});
+    }
+    if (redirect.state === "not-found") {
+        return (_jsx(HostIntlProvider, { locale: resolveLocale(ctx.preferredLocale), children: _jsxs("main", { className: e("error"), children: [
+                    _jsx("h1", { children: _jsx(FormattedMessage, { id: "gs.host.error.pageNotFound" }) }), _jsx("p", { children: _jsx(FormattedMessage, { id: "gs.host.error.pageNotFoundDescription" }) })
+                ] }) }));
+    }
+    if (redirect.state === "error") {
+        return (_jsx(HostIntlProvider, { locale: resolveLocale(ctx.preferredLocale), children: _jsxs("main", { className: e("error"), children: [
+                    _jsx("h1", { children: _jsx(FormattedMessage, { id: "gs.host.error.somethingWentWrong" }) }), _jsx("p", { children: redirect.error })
+                ] }) }));
+    }
+    return _jsx(HostUiContainer, { ctx: ctx, apps: apps, pathname: pathname, routerNavigate: routerNavigate });
+}

package/esm/components/Root.scss

@@ -0,0 +1,14 @@
+// (C) 2026 GoodData Corporation
+
+.gd-host-root {
+    &__loading {
+        min-height: 100vh;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+    }
+
+    &__error {
+        padding: 2rem;
+    }
+}

package/esm/components/lib/translations.d.ts

@@ -0,0 +1,7 @@
+import { type ITranslations } from "@gooddata/sdk-ui";
+export declare const DEFAULT_MESSAGES: Record<string, ITranslations>;
+/**
+ * Resolves translation messages for the given locale.
+ * Memoized to cache promises and prevent duplicate async imports.
+ */
+export declare const resolveMessages: (locale: string) => Promise<ITranslations>;

package/esm/components/lib/translations.js

@@ -0,0 +1,64 @@
+// (C) 2026 GoodData Corporation
+import { memoize } from "lodash-es";
+import { DEFAULT_LANGUAGE, DEFAULT_MESSAGES as DEFAULT_MESSAGES_SDK_UI, resolveLocale, resolveMessages as resolveMessagesSdkUi, } from "@gooddata/sdk-ui";
+import { removeMetadata } from "@gooddata/util";
+import enUS from "../../translations/en-US.json" with { type: "json" };
+const asyncMessagesMap = {
+    "en-US": () => Promise.resolve(removeMetadata(enUS)),
+    "en-US-x-24h": () => Promise.resolve(removeMetadata(enUS)),
+    "de-DE": () => import("../../translations/de-DE.json").then((module) => module.default),
+    "es-ES": () => import("../../translations/es-ES.json").then((module) => module.default),
+    "fr-FR": () => import("../../translations/fr-FR.json").then((module) => module.default),
+    "ja-JP": () => import("../../translations/ja-JP.json").then((module) => module.default),
+    "nl-NL": () => import("../../translations/nl-NL.json").then((module) => module.default),
+    "pt-BR": () => import("../../translations/pt-BR.json").then((module) => module.default),
+    "pt-PT": () => import("../../translations/pt-PT.json").then((module) => module.default),
+    "zh-Hans": () => import("../../translations/zh-Hans.json").then((module) => module.default),
+    "sl-SI": () => import("../../translations/sl-SI.json").then((module) => module.default),
+    "en-AU": () => import("../../translations/en-AU.json").then((module) => module.default),
+    "en-GB": () => import("../../translations/en-GB.json").then((module) => module.default),
+    "es-419": () => import("../../translations/es-419.json").then((module) => module.default),
+    "fi-FI": () => import("../../translations/fi-FI.json").then((module) => module.default),
+    "fr-CA": () => import("../../translations/fr-CA.json").then((module) => module.default),
+    "it-IT": () => import("../../translations/it-IT.json").then((module) => module.default),
+    "ko-KR": () => import("../../translations/ko-KR.json").then((module) => module.default),
+    "pl-PL": () => import("../../translations/pl-PL.json").then((module) => module.default),
+    "ru-RU": () => import("../../translations/ru-RU.json").then((module) => module.default),
+    "tr-TR": () => import("../../translations/tr-TR.json").then((module) => module.default),
+    "zh-HK": () => import("../../translations/zh-HK.json").then((module) => module.default),
+    "zh-Hant": () => import("../../translations/zh-Hant.json").then((module) => module.default),
+    "id-ID": () => import("../../translations/id-ID.json").then((module) => module.default),
+    "th-TH": () => import("../../translations/th-TH.json").then((module) => module.default),
+    "vi-VN": () => import("../../translations/vi-VN.json").then((module) => module.default),
+    "uk-UA": () => import("../../translations/uk-UA.json").then((module) => module.default),
+};
+const defaultSdkUiMessages = DEFAULT_MESSAGES_SDK_UI[DEFAULT_LANGUAGE];
+export const DEFAULT_MESSAGES = {
+    [DEFAULT_LANGUAGE]: {
+        ...defaultSdkUiMessages,
+        ...removeMetadata(enUS), // app messages should override sdk messages
+    },
+};
+async function resolveMessagesInternal(locale) {
+    const validatedLocale = resolveLocale(locale);
+    try {
+        const [hostAppMessages, sdkUiMessages] = await Promise.all([
+            asyncMessagesMap[validatedLocale](),
+            resolveMessagesSdkUi(validatedLocale),
+        ]);
+        // app messages should override sdk messages
+        return { ...sdkUiMessages, ...hostAppMessages };
+    }
+    catch (error) {
+        // Translation chunks are content-hashed and may have been removed by a redeploy
+        // while the tab was open. Fall back to bundled en-US so the chrome still renders;
+        // the global `vite:preloadError` handler will reload the page shortly after.
+        console.warn(`[host-runtime/translations] Failed to load locale "${validatedLocale}", falling back to ${DEFAULT_LANGUAGE}.`, error);
+        return DEFAULT_MESSAGES[DEFAULT_LANGUAGE];
+    }
+}
+/**
+ * Resolves translation messages for the given locale.
+ * Memoized to cache promises and prevent duplicate async imports.
+ */
+export const resolveMessages = memoize(resolveMessagesInternal);

package/esm/components/useRedirectNavigation.d.ts

@@ -0,0 +1,7 @@
+import { type NavigateFunction } from "react-router";
+import { type RedirectTargetState } from "./useRedirectTarget.js";
+/**
+ * Performs a single `replace` navigation when the redirect state transitions to "redirect".
+ * Deduplicates consecutive redirects to the same URL by tracking the last navigated path.
+ */
+export declare function useRedirectNavigation(redirect: RedirectTargetState, navigate: NavigateFunction): void;

package/esm/components/useRedirectNavigation.js

@@ -0,0 +1,23 @@
+// (C) 2026 GoodData Corporation
+import { useEffect, useRef } from "react";
+import { debugLog } from "../debug.js";
+/**
+ * Performs a single `replace` navigation when the redirect state transitions to "redirect".
+ * Deduplicates consecutive redirects to the same URL by tracking the last navigated path.
+ */
+export function useRedirectNavigation(redirect, navigate) {
+    const lastNavigatedUrl = useRef(null);
+    useEffect(() => {
+        if (redirect.state === "redirect" && redirect.url !== lastNavigatedUrl.current) {
+            lastNavigatedUrl.current = redirect.url;
+            debugLog(`[host-app/redirect] Root: navigating (replace) → ${redirect.url}`);
+            void navigate(redirect.url, { replace: true });
+            return;
+        }
+        if (redirect.state !== "redirect") {
+            // Reset when a new resolution cycle begins so that revisiting the same redirect
+            // target (e.g. navigating back to a workspace root) isn't silently swallowed.
+            lastNavigatedUrl.current = null;
+        }
+    }, [redirect, navigate]);
+}

package/esm/components/useRedirectTarget.d.ts

@@ -0,0 +1,19 @@
+import { type PluggableApplicationRegistryItem } from "@gooddata/sdk-model";
+import { type IPlatformContext } from "@gooddata/sdk-pluggable-application-model";
+export type RedirectTargetState = {
+    state: "loading";
+} | {
+    state: "render";
+} | {
+    state: "redirect";
+    url: string;
+} | {
+    state: "not-found";
+} | {
+    state: "error";
+    error: string;
+};
+/**
+ * Resolves the redirect target for the current URL and permission context.
+ */
+export declare function useRedirectTarget(apps: PluggableApplicationRegistryItem[], ctx: IPlatformContext, pathname: string): RedirectTargetState;

package/esm/components/useRedirectTarget.js

@@ -0,0 +1,62 @@
+// (C) 2026 GoodData Corporation
+import { useEffect, useState } from "react";
+import { debugLog } from "../debug.js";
+import { AppNotFoundError, resolveRedirectTarget } from "../loader/redirectLogic.js";
+import { getBackend } from "../platformContext/backend.js";
+/**
+ * Resolves the redirect target for the current URL and permission context.
+ */
+export function useRedirectTarget(apps, ctx, pathname) {
+    const [redirectState, setRedirectState] = useState({ state: "loading" });
+    useEffect(() => {
+        let cancelled = false;
+        // Preserve "render" state during re-resolution so that HostUiContainer stays mounted
+        // while the async redirect check runs. Other states (loading, error, not-found) reset to loading.
+        setRedirectState((prev) => (prev.state === "render" ? prev : { state: "loading" }));
+        debugLog(`[host-app/redirect] useRedirectTarget: starting resolution for pathname → ${pathname}`);
+        const fetchFirstWorkspaceId = () => getBackend()
+            .workspaces()
+            .forCurrentUser()
+            .withLimit(1)
+            .queryDescriptors()
+            .then((result) => result.items[0]?.id);
+        resolveRedirectTarget({
+            apps,
+            ctx: ctx,
+            pathname,
+            fetchFirstWorkspaceId,
+        })
+            .then((url) => {
+            if (cancelled) {
+                debugLog(`[host-app/redirect] useRedirectTarget: resolution cancelled (stale effect) for pathname → ${pathname}`);
+                return;
+            }
+            if (url === null) {
+                debugLog("[host-app/redirect] useRedirectTarget: current URL is valid → render");
+                setRedirectState({ state: "render" });
+            }
+            else {
+                debugLog(`[host-app/redirect] useRedirectTarget: redirect needed → ${url}`);
+                setRedirectState({ state: "redirect", url });
+            }
+        })
+            .catch((e) => {
+            if (cancelled) {
+                return;
+            }
+            if (e instanceof AppNotFoundError) {
+                debugLog(`[host-app/redirect] useRedirectTarget: AppNotFoundError → ${e.message}`);
+                setRedirectState({ state: "not-found" });
+            }
+            else {
+                const error = e instanceof Error ? e.message : "Unknown redirect error.";
+                debugLog(`[host-app/redirect] useRedirectTarget: unexpected error → ${error}`);
+                setRedirectState({ state: "error", error });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [apps, pathname, ctx]);
+    return redirectState;
+}

package/esm/debug.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Logs a debug message to the console, but only in non-production builds.
+ */
+export declare function debugLog(message: string, ...args: unknown[]): void;
+/**
+ * Returns a high-resolution timestamp in milliseconds, using the Performance API
+ * when available and falling back to Date.now().
+ */
+export declare function now(): number;

package/esm/debug.js

@@ -0,0 +1,18 @@
+// (C) 2026 GoodData Corporation
+import { isProduction } from "./lib/isProduction.js";
+/**
+ * Logs a debug message to the console, but only in non-production builds.
+ */
+export function debugLog(message, ...args) {
+    if (!isProduction) {
+        // eslint-disable-next-line no-console
+        console.debug(message, ...args);
+    }
+}
+/**
+ * Returns a high-resolution timestamp in milliseconds, using the Performance API
+ * when available and falling back to Date.now().
+ */
+export function now() {
+    return typeof performance === "undefined" ? Date.now() : performance.now();
+}

package/esm/index.d.ts

@@ -0,0 +1,11 @@
+export { getBackend, setRuntimePackageName } from "./platformContext/backend.js";
+export { registerPlatformContextCallbacks } from "./platformContext/useLoadPlatformContext.js";
+export { type ILoadPlatformContextCallbacks } from "./platformContext/loadPlatformContext.js";
+export { registerLocalApplicationLoaders, type LocalPluggableApplicationLoader, } from "./loader/localLoader.js";
+export { registerLocalApplications } from "./registry/pluggableApplicationsRegistry.js";
+export { registerAppLifecycleCallbacks } from "./loader/pluggableApplicationsLoader.js";
+export { Root, type IRootCallbacks } from "./components/Root.js";
+export { type IAppLifecycleCallbacks } from "./types/lifecycle.js";
+export { STALE_CHUNK_RELOAD_PARAM, installPreloadErrorHandler, installVersionWatcher, reloadForStaleChunks, setStaleChunkReloadListener, type IStaleChunkReloadInfo, type IVersionWatcherOptions, type StaleChunkReloadListener, } from "./lib/chunkReloadGuard.js";
+export { dispatchHostNotification } from "./lib/hostNotifications.js";
+export { setHostPricingExtension, type UseHostPricingExtension, type IHostChromePricing, } from "./ui/useHostChromePricing.js";

package/esm/index.js

@@ -0,0 +1,10 @@
+// (C) 2026 GoodData Corporation
+export { getBackend, setRuntimePackageName } from "./platformContext/backend.js";
+export { registerPlatformContextCallbacks } from "./platformContext/useLoadPlatformContext.js";
+export { registerLocalApplicationLoaders, } from "./loader/localLoader.js";
+export { registerLocalApplications } from "./registry/pluggableApplicationsRegistry.js";
+export { registerAppLifecycleCallbacks } from "./loader/pluggableApplicationsLoader.js";
+export { Root } from "./components/Root.js";
+export { STALE_CHUNK_RELOAD_PARAM, installPreloadErrorHandler, installVersionWatcher, reloadForStaleChunks, setStaleChunkReloadListener, } from "./lib/chunkReloadGuard.js";
+export { dispatchHostNotification } from "./lib/hostNotifications.js";
+export { setHostPricingExtension, } from "./ui/useHostChromePricing.js";