@wildo-ai/saas-frontend-lib 1.0.1 → 1.1.0

package/dist/esm/core/i18n/I18nContext.js

@@ -11,7 +11,7 @@ import { useEventBus } from '../../core/events/useEventBus.js';
 import { FrontendEvents } from '../../core/events/events.frontend.schemas.js';
 import { LoadingTier, AppLoadingIdentifier } from '../../core/loading/loading-types.frontend.schemas.js';
 import { envLoader } from '../../core/runtime/env-variable-loader.frontend.service.js';
-import { ActivationCriterionType } from '@wildo-ai/saas-models';
+import { ActivationCriterionType, interpolateLabelParams, } from '@wildo-ai/saas-models';
 import { AutomatedLayoutFrontendUtils } from '../../core/automated-layout/automated-layout.frontend.utils.js';
 export { TextDirection } from '@wildo-ai/presets-components-models';
 /**
@@ -38,24 +38,21 @@ export const I18nProvider = ({ children }) => {
     const errorContext = useContext(ErrorContext);
     const { on, emit } = useEventBus();
     // Extract language configuration from appConfig
-    // Note: allowOrganizationOverride is not consumed here because I18nProvider sits above
-    // UserOrgsProvider in the component tree. Org-level language enforcement would need to be
-    // handled via the USER_PREFERENCES_CHANGED event listener below.
     const languageConfig = appConfig?.appPreferences?.languages;
     const configDefaultLanguage = languageConfig?.defaultLanguage ?? AvailableLanguage.EN;
     const configEnabledLanguages = languageConfig?.enabledLanguages ?? allAvailableLanguages;
+    const configFallbackLanguage = languageConfig?.fallbackLanguage ?? configDefaultLanguage;
     const configAutoDetect = languageConfig?.autoDetectFromBrowser ?? true;
     const configAllowUserOverride = languageConfig?.allowUserOverride ?? true;
+    const configAllowOrganizationOverride = languageConfig?.allowOrganizationOverride ?? true;
     const configEnableLanguageSwitcher = languageConfig?.enableLanguageSwitcher ?? true;
-    // TODO: implement fallback language loading — when a key is missing from the primary language,
-    // load translations from fallbackLanguage and merge them as a base layer.
-    // const configFallbackLanguage = languageConfig?.fallbackLanguage ?? AvailableLanguage.EN;
     const [currentLanguage, setCurrentLanguage] = useState(configDefaultLanguage);
     const currentLanguageRef = useRef(configDefaultLanguage);
     const [translations, setTranslations] = useState({});
     const [isLoading, setIsLoading] = useState(false);
     // Preferences state (synced from UserOrgsContext via events)
     const [languagePreferences, setLanguagePreferences] = useState(null);
+    const [organizationLanguagePreferences, setOrganizationLanguagePreferences] = useState(null);
     const [regionalPreferences, setRegionalPreferences] = useState(null);
     const logDebug = logger.debugByType('I18nContext');
     logger.setDebugTypeLogging('I18nContext', isDebugging);
@@ -69,6 +66,82 @@ export const I18nProvider = ({ children }) => {
             ...additionalContext,
         });
     }, [errorContext, logger]);
+    const getPolicyAvailableLanguages = useCallback((orgPreferences = organizationLanguagePreferences) => {
+        if (!configAllowOrganizationOverride || !orgPreferences) {
+            return configEnabledLanguages;
+        }
+        const scopedLanguages = orgPreferences.supportedLanguages
+            .filter((language) => configEnabledLanguages.includes(language));
+        if (configEnabledLanguages.includes(orgPreferences.primaryLanguage) && !scopedLanguages.includes(orgPreferences.primaryLanguage)) {
+            scopedLanguages.unshift(orgPreferences.primaryLanguage);
+        }
+        return scopedLanguages.length > 0 ? [...new Set(scopedLanguages)] : configEnabledLanguages;
+    }, [configAllowOrganizationOverride, configEnabledLanguages, organizationLanguagePreferences]);
+    const resolveEffectiveLanguage = useCallback((options) => {
+        const userPreferences = options?.userPreferences ?? languagePreferences;
+        const organizationPreferences = configAllowOrganizationOverride
+            ? (options?.organizationPreferences ?? organizationLanguagePreferences)
+            : null;
+        const availableLanguages = getPolicyAvailableLanguages(organizationPreferences);
+        const supportsLanguage = (language) => !!language && availableLanguages.includes(language);
+        const resolvedOrganizationPrimary = supportsLanguage(organizationPreferences?.primaryLanguage)
+            ? organizationPreferences.primaryLanguage
+            : null;
+        if (resolvedOrganizationPrimary
+            && (organizationPreferences?.enforceForAllMembers
+                || organizationPreferences?.allowUserOverride === false
+                || userPreferences?.useOrganizationDefault === true)) {
+            return resolvedOrganizationPrimary;
+        }
+        if (configAllowUserOverride && supportsLanguage(userPreferences?.primaryLanguage)) {
+            return userPreferences.primaryLanguage;
+        }
+        if (configAllowUserOverride && supportsLanguage(options?.savedLanguage)) {
+            return options.savedLanguage;
+        }
+        const shouldAutoDetect = configAllowUserOverride && (userPreferences?.autoDetect ?? configAutoDetect);
+        if (shouldAutoDetect && supportsLanguage(options?.browserLanguage)) {
+            return options.browserLanguage;
+        }
+        if (resolvedOrganizationPrimary) {
+            return resolvedOrganizationPrimary;
+        }
+        if (supportsLanguage(configDefaultLanguage)) {
+            return configDefaultLanguage;
+        }
+        return availableLanguages[0] ?? configDefaultLanguage;
+    }, [
+        configAllowOrganizationOverride,
+        configAllowUserOverride,
+        configAutoDetect,
+        configDefaultLanguage,
+        getPolicyAvailableLanguages,
+        languagePreferences,
+        organizationLanguagePreferences,
+    ]);
+    const effectiveAllowUserOverride = useMemo(() => {
+        if (!configAllowUserOverride) {
+            return false;
+        }
+        if (!configAllowOrganizationOverride || !organizationLanguagePreferences) {
+            return true;
+        }
+        if (organizationLanguagePreferences.enforceForAllMembers) {
+            return false;
+        }
+        if (!organizationLanguagePreferences.allowUserOverride) {
+            return false;
+        }
+        if (languagePreferences?.useOrganizationDefault) {
+            return false;
+        }
+        return true;
+    }, [
+        configAllowOrganizationOverride,
+        configAllowUserOverride,
+        languagePreferences?.useOrganizationDefault,
+        organizationLanguagePreferences,
+    ]);
     // Guards to prevent duplicate API calls
     const loadingLanguageRef = useRef(null);
     const loadedLanguagesRef = useRef(new Set());
@@ -96,27 +169,42 @@ export const I18nProvider = ({ children }) => {
      * Reset on language change.
      */
     const fullLoadCompletedRef = useRef(false);
-    // Initialize language on mount (respects appConfig language preferences)
-    useEffect(() => {
-        const savedLanguage = localStorage.getItem(LOCAL_STORAGE_KEYS.LANGUAGE);
-        // Priority: saved preference → browser detection (if enabled) → config default → config fallback
-        let initialLanguage;
-        if (savedLanguage && isLanguageSupported(savedLanguage)) {
-            initialLanguage = savedLanguage;
-        }
-        else if (configAutoDetect) {
-            const browserLanguage = navigator.language.split('-')[0];
-            initialLanguage = isLanguageSupported(browserLanguage) ? browserLanguage : configDefaultLanguage;
+    const applyResolvedLanguage = useCallback((language, options) => {
+        if (language === currentLanguageRef.current) {
+            if (options?.persist !== false) {
+                localStorage.setItem(LOCAL_STORAGE_KEYS.LANGUAGE, language);
+            }
+            document.documentElement.lang = language;
+            return;
         }
-        else {
-            initialLanguage = configDefaultLanguage;
+        if (batchTimerRef.current !== null) {
+            clearTimeout(batchTimerRef.current);
+            batchTimerRef.current = null;
         }
-        if (initialLanguage !== currentLanguage) {
-            setCurrentLanguage(initialLanguage);
-            currentLanguageRef.current = initialLanguage;
+        batchQueueRef.current.forEach(b => b.resolve());
+        batchQueueRef.current = [];
+        loadedKeysRef.current.clear();
+        pendingKeysRef.current.clear();
+        fullLoadCompletedRef.current = false;
+        loadedLanguagesRef.current.clear();
+        setTranslations({});
+        currentLanguageRef.current = language;
+        setCurrentLanguage(language);
+        if (options?.persist !== false) {
+            localStorage.setItem(LOCAL_STORAGE_KEYS.LANGUAGE, language);
         }
-        document.documentElement.lang = initialLanguage;
-    }, [configAutoDetect, configDefaultLanguage]);
+        document.documentElement.lang = language;
+    }, []);
+    // Initialize language on mount (respects appConfig language preferences)
+    useEffect(() => {
+        const savedLanguage = localStorage.getItem(LOCAL_STORAGE_KEYS.LANGUAGE);
+        const browserLanguage = navigator.language.split('-')[0];
+        const initialLanguage = resolveEffectiveLanguage({
+            savedLanguage,
+            browserLanguage,
+        });
+        applyResolvedLanguage(initialLanguage);
+    }, [applyResolvedLanguage, resolveEffectiveLanguage]);
     // Load translations when app config is ready and language is set
     useEffect(() => {
         logDebug('useEffect triggered', { appIsInitialized, currentLanguage, isCurrentlyLoading: loadingLanguageRef.current, alreadyLoaded: loadedLanguagesRef.current.has(currentLanguage), isInitialized: isInitializedRef.current });
@@ -145,13 +233,18 @@ export const I18nProvider = ({ children }) => {
             : languageInfo.name;
     };
     const isLanguageSupported = (language) => {
-        return configEnabledLanguages.includes(language);
+        return getPolicyAvailableLanguages().includes(language);
     };
     const changeLanguage = async (language) => {
-        if (language === currentLanguage)
+        if (language === currentLanguageRef.current)
             return;
-        if (!configAllowUserOverride) {
-            logDebug(`Language change blocked — allowUserOverride is disabled`);
+        if (!effectiveAllowUserOverride) {
+            logDebug('Language change blocked — effective user override is disabled', {
+                configAllowUserOverride,
+                configAllowOrganizationOverride,
+                useOrganizationDefault: languagePreferences?.useOrganizationDefault,
+                organizationLanguagePreferences,
+            });
             return;
         }
         if (!isLanguageSupported(language)) {
@@ -159,48 +252,91 @@ export const I18nProvider = ({ children }) => {
             return;
         }
         logDebug(`Language change requested: ${currentLanguage} → ${language}`);
-        if (batchTimerRef.current !== null) {
-            clearTimeout(batchTimerRef.current);
-            batchTimerRef.current = null;
+        applyResolvedLanguage(language);
+    };
+    const mergeLabelPayloads = (payloads) => {
+        return payloads.reduce((merged, payload) => deepMergeTranslations(merged, payload), {});
+    };
+    const shouldLoadFallbackLayer = (language) => {
+        return configFallbackLanguage !== language;
+    };
+    const fetchEagerLabelsWithFallback = async (language, sections) => {
+        const httpClient = getManualCallsHttpClient();
+        if (!shouldLoadFallbackLayer(language)) {
+            const response = await httpClient.getI18nLabels(language, sections);
+            return response.labels;
         }
-        batchQueueRef.current.forEach(b => b.resolve());
-        batchQueueRef.current = [];
-        loadedKeysRef.current.clear();
-        pendingKeysRef.current.clear();
-        fullLoadCompletedRef.current = false;
-        loadedLanguagesRef.current.clear();
-        setTranslations({});
-        currentLanguageRef.current = language;
-        setCurrentLanguage(language);
-        localStorage.setItem(LOCAL_STORAGE_KEYS.LANGUAGE, language);
-        document.documentElement.lang = language;
+        const [fallbackResponse, response] = await Promise.all([
+            httpClient.getI18nLabels(configFallbackLanguage, sections),
+            httpClient.getI18nLabels(language, sections),
+        ]);
+        return deepMergeTranslations(fallbackResponse.labels, response.labels);
+    };
+    const fetchLazyLabelsWithFallback = async (language, chunks) => {
+        const httpClient = getManualCallsHttpClient();
+        if (!shouldLoadFallbackLayer(language)) {
+            const responses = await Promise.all(chunks.map(chunk => httpClient.getI18nLabelsByKeys(language, chunk)));
+            return mergeLabelPayloads(responses.map((response) => response.labels));
+        }
+        const [fallbackResponses, responses] = await Promise.all([
+            Promise.all(chunks.map(chunk => httpClient.getI18nLabelsByKeys(configFallbackLanguage, chunk))),
+            Promise.all(chunks.map(chunk => httpClient.getI18nLabelsByKeys(language, chunk))),
+        ]);
+        return deepMergeTranslations(mergeLabelPayloads(fallbackResponses.map((response) => response.labels)), mergeLabelPayloads(responses.map((response) => response.labels)));
     };
     // Listen to preference changes from UserOrgsContext
     useEffect(() => {
         const unsubscribe = on(FrontendEvents.USER_PREFERENCES_CHANGED, (payload) => {
-            // Store language preferences
-            if (payload.languagePreferences) {
-                setLanguagePreferences(payload.languagePreferences);
-                // Apply language preference
-                if (payload.languagePreferences.primaryLanguage) {
-                    const preferredLanguage = payload.languagePreferences.primaryLanguage;
-                    logDebug('Applying language preference from UserOrgsContext event', { preferredLanguage });
-                    changeLanguage(preferredLanguage).catch((error) => {
-                        logger.warn('Failed to apply language preference from event', { preferredLanguage, error });
-                    });
-                }
+            const includesLanguagePreferences = Object.prototype.hasOwnProperty.call(payload, 'languagePreferences');
+            const includesOrganizationLanguagePreferences = Object.prototype.hasOwnProperty.call(payload, 'organizationLanguagePreferences');
+            const nextLanguagePreferences = includesLanguagePreferences
+                ? (payload.languagePreferences ?? null)
+                : languagePreferences;
+            const nextOrganizationLanguagePreferences = includesOrganizationLanguagePreferences
+                ? (payload.organizationLanguagePreferences ?? null)
+                : organizationLanguagePreferences;
+            if (includesLanguagePreferences) {
+                setLanguagePreferences(nextLanguagePreferences);
+            }
+            if (includesOrganizationLanguagePreferences) {
+                setOrganizationLanguagePreferences(nextOrganizationLanguagePreferences);
+            }
+            if (includesLanguagePreferences || includesOrganizationLanguagePreferences) {
+                const savedLanguage = localStorage.getItem(LOCAL_STORAGE_KEYS.LANGUAGE);
+                const browserLanguage = navigator.language.split('-')[0];
+                const resolvedLanguage = resolveEffectiveLanguage({
+                    userPreferences: nextLanguagePreferences,
+                    organizationPreferences: nextOrganizationLanguagePreferences,
+                    savedLanguage,
+                    browserLanguage,
+                });
+                logDebug('Applying effective language from UserOrgsContext event', {
+                    resolvedLanguage,
+                    userPrimaryLanguage: nextLanguagePreferences?.primaryLanguage,
+                    useOrganizationDefault: nextLanguagePreferences?.useOrganizationDefault,
+                    organizationPrimaryLanguage: nextOrganizationLanguagePreferences?.primaryLanguage,
+                    organizationEnforced: nextOrganizationLanguagePreferences?.enforceForAllMembers,
+                });
+                applyResolvedLanguage(resolvedLanguage);
             }
             // Store regional preferences
-            if (payload.regionalPreferences) {
-                setRegionalPreferences(payload.regionalPreferences);
+            if (Object.prototype.hasOwnProperty.call(payload, 'regionalPreferences')) {
+                setRegionalPreferences(payload.regionalPreferences ?? null);
                 logDebug('Regional preferences updated from UserOrgsContext event', {
-                    locale: payload.regionalPreferences.locale,
-                    timezone: payload.regionalPreferences.timezone,
+                    locale: payload.regionalPreferences?.locale,
+                    timezone: payload.regionalPreferences?.timezone,
                 });
             }
         });
         return unsubscribe;
-    }, [on, changeLanguage, logDebug, logger]);
+    }, [
+        applyResolvedLanguage,
+        languagePreferences,
+        logDebug,
+        on,
+        organizationLanguagePreferences,
+        resolveEffectiveLanguage,
+    ]);
     // Preference getters
     const getLanguagePreferences = useCallback(() => {
         return languagePreferences;
@@ -289,18 +425,13 @@ export const I18nProvider = ({ children }) => {
             chunks.push(missing.slice(i, i + MAX_KEYS_PER_REQUEST));
         }
         try {
-            const httpClient = getManualCallsHttpClient();
             logDebug(`getI18nLabelsByKeys language=${language} chunks=${chunks.map(chunk => `[${chunk.join(', ')}]`).join(', ')}`);
-            const responses = await Promise.all(chunks.map(chunk => httpClient.getI18nLabelsByKeys(language, chunk)));
+            const merged = await fetchLazyLabelsWithFallback(language, chunks);
             if (language !== currentLanguageRef.current) {
                 logDebug('Discarding stale lazy i18n response', { fetchedFor: language, currentLanguage: currentLanguageRef.current });
                 batch.forEach(b => b.resolve());
                 return;
             }
-            let merged = {};
-            for (const response of responses) {
-                merged = deepMergeTranslations(merged, response.labels);
-            }
             setTranslations(prev => deepMergeTranslations(prev, merged));
             for (const key of missing) {
                 loadedKeysRef.current.add(key);
@@ -421,7 +552,7 @@ export const I18nProvider = ({ children }) => {
             tier: LoadingTier.APPLICATION,
         });
         try {
-            const response = await getManualCallsHttpClient().getI18nLabels(language, EAGER_I18N_SECTIONS);
+            const responseLabels = await fetchEagerLabelsWithFallback(language, EAGER_I18N_SECTIONS);
             if (language !== currentLanguageRef.current) {
                 logDebug('Discarding stale translation response', { fetchedFor: language, currentLanguage: currentLanguageRef.current });
                 return;
@@ -429,7 +560,7 @@ export const I18nProvider = ({ children }) => {
             // Deep-merge, not replace. During language change, lazy batch requests
             // (via useI18n deps effects) may resolve concurrently with this eager
             // load. Using replace would wipe lazy data that arrived first.
-            setTranslations(prev => deepMergeTranslations(prev, response.labels));
+            setTranslations(prev => deepMergeTranslations(prev, responseLabels));
             loadedLanguagesRef.current.add(language);
             for (const section of EAGER_I18N_SECTIONS) {
                 loadedKeysRef.current.add(section);
@@ -438,7 +569,11 @@ export const I18nProvider = ({ children }) => {
             // With fullLoadCompleted = false, requestKeys no longer short-circuits,
             // isKeyLoaded returns false for unloaded sections, and the microbatch
             // system becomes the primary loader for per-component translations.
-            logDebug('Eager i18n sections loaded', { language: response.language, sections: EAGER_I18N_SECTIONS });
+            logDebug('Eager i18n sections loaded', {
+                language,
+                sections: EAGER_I18N_SECTIONS,
+                fallbackLanguage: shouldLoadFallbackLayer(language) ? configFallbackLanguage : undefined,
+            });
             if (!isInitializedRef.current) {
                 isInitializedRef.current = true;
                 markComponentInitialized(MainContextInitComponents.I18N);
@@ -469,14 +604,14 @@ export const I18nProvider = ({ children }) => {
             if (value === undefined)
                 break;
         }
-        let result = typeof value === 'string' ? value : key;
-        // Replace parameters if provided
-        if (params) {
-            Object.entries(params).forEach(([paramKey, paramValue]) => {
-                result = result.replace(new RegExp(`{{${paramKey}}}`, 'g'), String(paramValue));
-            });
-        }
-        return result;
+        const result = typeof value === 'string' ? value : key;
+        // Canonical single-brace `{param}` substitution shared with the backend
+        // label/email interpolator. NOTE: this previously matched DOUBLE braces
+        // (`{{param}}`), which never matched any content (every locale file and the
+        // generator emit single braces) — so no frontend param ever interpolated.
+        // Do NOT reintroduce a local replace loop here; the one contract lives in
+        // `interpolateLabelParams`.
+        return interpolateLabelParams(result, params);
     };
     // ------------------------------
     // Labelling-based helper builders
@@ -494,8 +629,9 @@ export const I18nProvider = ({ children }) => {
         return result;
     };
     const tResourceOperation = (resource, operation, key, params) => {
-        const base = `${LabellingTypes.RESOURCES}.${resource}.${operation}.${key}`;
-        return t(base, params);
+        const base = `${LabellingTypes.RESOURCES}.${resource}.operations.${operation}.${key}`;
+        const result = t(base, params);
+        return result === base ? '' : result;
     };
     const tResourceFieldDisplay = (resource, fieldPath, key, params) => {
         const base = `${LabellingTypes.RESOURCES}.${resource}.fields.${fieldPath}.display.${key}`;
@@ -564,19 +700,17 @@ export const I18nProvider = ({ children }) => {
         // If translation not found, fallback to enum value
         return result === base ? enumValue : result;
     };
-    // Form section labels (for AutomatedForm)
-    // Path: resources.{resourceType}.operations.{operationId}.sections.{index}.{title|description}
-    const tResourceSection = (resource, operation, index, key, params) => {
-        const base = `${LabellingTypes.RESOURCES}.${resource}.operations.${operation}.sections.${index}.${key}`;
+    // Resource layout labels.
+    // Path: resources.{resourceType}.sections.{sectionRef}.{title|description}
+    const tResourceSection = (resource, sectionRef, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.sections.${sectionRef}.${key}`;
         const result = t(base, params);
-        // Fallback: if translation not found, return empty string (section renders without title)
         return result === base ? '' : result;
     };
-    // Path: resources.{resourceType}.operations.{operationId}.wizardsteps.{index}.{title|description}
-    const tResourceWizardStep = (resource, operation, index, key, params) => {
-        const base = `${LabellingTypes.RESOURCES}.${resource}.operations.${operation}.wizardsteps.${index}.${key}`;
+    // Path: resources.{resourceType}.wizardSteps.{stepRef}.{title|description}
+    const tResourceWizardStep = (resource, stepRef, key, params) => {
+        const base = `${LabellingTypes.RESOURCES}.${resource}.wizardSteps.${stepRef}.${key}`;
         const result = t(base, params);
-        // Fallback: if translation not found, return empty string (step renders without title)
         return result === base ? '' : result;
     };
     // Path: sidebar_sections.{sectionRef}.{title|description}
@@ -587,6 +721,40 @@ export const I18nProvider = ({ children }) => {
         // If translation not found, fallback to humanized section ref
         return result === base ? sectionRef.charAt(0).toUpperCase() + sectionRef.slice(1).replace(/_/g, ' ') : result;
     };
+    // Path: settings_hub.categories.{categoryRef}.label — falls back to the
+    // authored label (the registry's own string) when no translation exists, so
+    // the rail reads correctly before the companion generates the bundle.
+    const tSettingsHubCategory = (categoryRef, fallbackLabel) => {
+        const base = `${LabellingTypes.SETTINGS_HUB}.categories.${categoryRef}.label`;
+        const result = t(base);
+        return result === base ? fallbackLabel : result;
+    };
+    // Path: settings_hub.sections.{sectionRef}.label — same authored-label fallback.
+    const tSettingsHubSection = (sectionRef, fallbackLabel) => {
+        const base = `${LabellingTypes.SETTINGS_HUB}.sections.${sectionRef}.label`;
+        const result = t(base);
+        return result === base ? fallbackLabel : result;
+    };
+    const tCompositeView = (translationRef, key, params) => {
+        const base = `${LabellingTypes.COMPOSITE_VIEWS}.${translationRef}.${key}`;
+        const result = t(base, params);
+        return result === base ? '' : result;
+    };
+    const tCompositeViewSection = (translationRef, sectionRef, key, params) => {
+        const base = `${LabellingTypes.COMPOSITE_VIEWS}.${translationRef}.sections.${sectionRef}.${key}`;
+        const result = t(base, params);
+        return result === base ? '' : result;
+    };
+    // `key` accepts ANY view-local label ref, not just 'title' | 'description'.
+    // Framework chrome resolves title/description; custom views (e.g. a resource-
+    // owned EXECUTION view) declare their own refs that the labelling pipeline
+    // generates under `views.{family}.{translationRef}.{ref}`. Missing keys return
+    // '' (caller decides the fallback), same contract as before.
+    const tView = (family, translationRef, key, params) => {
+        const base = `${LabellingTypes.VIEWS}.${family}.${translationRef}.${key}`;
+        const result = t(base, params);
+        return result === base ? '' : result;
+    };
     // ------------------------------
     // Guidance helpers
     // ------------------------------
@@ -655,6 +823,14 @@ export const I18nProvider = ({ children }) => {
         return result === base ? (subKey === 'name' ? humanizeKey(poolKey) : '') : result;
     };
     // ------------------------------
+    // Role helpers
+    // ------------------------------
+    const tRole = (roleKey, subKey) => {
+        const base = `${LabellingTypes.ROLES}.${roleKey}.${subKey}`;
+        const result = t(base);
+        return result === base ? (subKey === 'label' ? humanizeKey(roleKey) : '') : result;
+    };
+    // ------------------------------
     // Curried resource helpers
     // ------------------------------
     const makeTrResourceHeader = (resource) => (key = 'title', params) => {
@@ -709,7 +885,10 @@ export const I18nProvider = ({ children }) => {
     const resolvedRegionalPreferences = useMemo(() => ({
         locale: regionalPreferences?.locale ?? currentLanguage ?? 'en',
         timezone: regionalPreferences?.timezone ?? 'UTC',
-        dateFormat: regionalPreferences?.dateFormat ?? DateFormat.ISO_8601,
+        // LOCALE_DEFAULT, not ISO_8601: a user with no expressed date-format
+        // preference gets locale-driven medium dates ("Aug 18, 2026") instead of
+        // machine-shaped "2026-08-18". An explicit preference always wins.
+        dateFormat: regionalPreferences?.dateFormat ?? DateFormat.LOCALE_DEFAULT,
         timeFormat: regionalPreferences?.timeFormat ?? TimeFormat.TWENTY_FOUR_HOUR,
     }), [regionalPreferences, currentLanguage]);
     const formatDate = useCallback((value) => RegionalFormattingUtils.formatDate(value, resolvedRegionalPreferences), [resolvedRegionalPreferences]);
@@ -744,10 +923,10 @@ export const I18nProvider = ({ children }) => {
         dir,
         translations,
         isLoading,
-        availableLanguages: configEnabledLanguages,
+        availableLanguages: getPolicyAvailableLanguages(),
         // Language config flags
         enableLanguageSwitcher: configEnableLanguageSwitcher,
-        allowUserOverride: configAllowUserOverride,
+        allowUserOverride: effectiveAllowUserOverride,
         // Preferences
         languagePreferences,
         regionalPreferences,
@@ -776,6 +955,11 @@ export const I18nProvider = ({ children }) => {
         tResourceSection,
         tResourceWizardStep,
         tSidebarSection,
+        tSettingsHubCategory,
+        tSettingsHubSection,
+        tCompositeView,
+        tCompositeViewSection,
+        tView,
         makeTrResourceHeader,
         makeTrResourceEmptyState,
         makeTrResourceOperation,
@@ -804,6 +988,7 @@ export const I18nProvider = ({ children }) => {
         tBillingFeature,
         tBillingLimit,
         tBillingCreditPool,
+        tRole,
         resolvedRegionalPreferences,
         formatDate,
         formatTime,
@@ -819,4 +1004,4 @@ export const I18nProvider = ({ children }) => {
     };
     return (_jsx(DirectionProvider, { dir: dir, children: _jsx(I18nContext.Provider, { value: value, children: children }) }));
 };
-//# sourceMappingURL=I18nContext.js.map
+//# sourceMappingURL=I18nContext.js.map