@tumbaland/frontend-core 1.14.0 → 1.15.0

package/dist/components/tenant/useTenant.js

@@ -0,0 +1,222 @@
+import { useState, useEffect, useCallback } from 'react';
+import { TenantProvider, useTenantListener, useTenantContext } from './TenantProvider';
+import { getCorrelationId, getSessionId, logger } from '../../monitoring';
+import { TENANT_STORAGE_KEY } from '../../sessionStorage';
+// Re-export for convenience
+export { TenantProvider, useTenantListener, useTenantContext };
+// Owned here, but declared in frontend-core so `logout()` can clear it — see
+// the note on session-scoped storage there.
+const STORAGE_KEY = TENANT_STORAGE_KEY;
+/** The stamp is storage bookkeeping; consumers see a plain TenantOption. */
+const toOption = ({ id, name, type }) => ({ id, name, type });
+// Global cache to prevent multiple simultaneous requests across all hook instances
+let globalGroupsFetchCache = null;
+let globalGroupsCacheTimestamp = 0;
+let globalGroupsCacheKey = '';
+let requestCounter = 0; // Debug counter
+const CACHE_DURATION = 30000; // 30 seconds
+// Global function to fetch groups - shared across all hook instances. Keyed by
+// user as well as URL: the cache outlives a sign-out, and handing the incoming
+// account the previous one's group list is how a stale selection gets
+// "validated" and survives.
+const fetchGroupsGlobally = async (groupApiUrl, userEmail) => {
+    requestCounter++;
+    logger.debug('fetchGroupsGlobally called', { requestNumber: requestCounter, groupApiUrl });
+    // Check if we have a valid cached request for the same API URL and user
+    const now = Date.now();
+    const cacheKey = `${userEmail ?? ''}|${groupApiUrl}`;
+    if (globalGroupsFetchCache &&
+        globalGroupsCacheKey === cacheKey &&
+        now - globalGroupsCacheTimestamp < CACHE_DURATION) {
+        logger.debug('Using cached groups request', { groupApiUrl });
+        return globalGroupsFetchCache;
+    }
+    logger.debug('Making new groups API request', { groupApiUrl });
+    // Create new request and cache it
+    const fetchRequest = async () => {
+        try {
+            // Check if groupApiUrl is provided
+            if (!groupApiUrl) {
+                logger.warn('No GROUP_API_URL provided to useTenant hook');
+                return [];
+            }
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-correlation-id': getCorrelationId(),
+                'x-session-id': getSessionId()
+            };
+            // Use user authentication for fetching groups; the httpOnly access_token
+            // cookie is attached automatically by the browser.
+            const response = await fetch(`${groupApiUrl}/api/groups/mine`, {
+                method: 'GET',
+                credentials: 'include',
+                headers,
+                signal: AbortSignal.timeout(5000) // 5 second timeout
+            });
+            logger.debug('Groups API response', { status: response.status, statusText: response.statusText });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch groups: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (!data.success) {
+                throw new Error('API returned unsuccessful response');
+            }
+            // Transform groups to tenant options
+            return data.data.map((group) => ({
+                id: group._id,
+                name: group.name,
+                type: 'group'
+            }));
+        }
+        catch (err) {
+            logger.error('Error fetching user groups', err);
+            throw err;
+        }
+    };
+    // Cache the request
+    globalGroupsFetchCache = fetchRequest();
+    globalGroupsCacheTimestamp = now;
+    globalGroupsCacheKey = cacheKey;
+    // Clear cache after request completes (success or failure). `.finally()`
+    // returns a new derived promise that rejects if the request did — nothing
+    // else observes that derived promise (callers only await the original
+    // `globalGroupsFetchCache` reference returned below), so without a no-op
+    // `.catch()` here a failed request logs as an unhandled rejection.
+    globalGroupsFetchCache
+        .finally(() => {
+        setTimeout(() => {
+            if (globalGroupsFetchCache && Date.now() - globalGroupsCacheTimestamp >= CACHE_DURATION) {
+                globalGroupsFetchCache = null;
+                globalGroupsCacheKey = '';
+            }
+        }, CACHE_DURATION);
+    })
+        .catch(() => { });
+    return globalGroupsFetchCache;
+};
+/**
+ * Custom hook for managing tenant selection
+ * Handles both personal account and group contexts
+ */
+export const useTenant = (groupApiUrl, userEmail) => {
+    const [selectedTenant, setSelectedTenantState] = useState(null);
+    const [availableTenants, setAvailableTenants] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    // Load saved tenant selection from localStorage
+    const loadSavedTenant = useCallback(() => {
+        try {
+            const saved = localStorage.getItem(STORAGE_KEY);
+            if (saved) {
+                const tenant = JSON.parse(saved);
+                return tenant;
+            }
+        }
+        catch (err) {
+            logger.warn('Failed to load saved tenant selection', { error: err });
+        }
+        return null;
+    }, []);
+    // Save tenant selection to localStorage, stamped with the current account
+    const saveTenant = useCallback((tenant) => {
+        try {
+            const stored = { ...tenant, userEmail };
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+        }
+        catch (err) {
+            logger.warn('Failed to save tenant selection', { error: err });
+        }
+    }, [userEmail]);
+    // Fetch available groups from API using user authentication
+    const fetchGroups = useCallback(async () => {
+        return fetchGroupsGlobally(groupApiUrl, userEmail);
+    }, [groupApiUrl, userEmail]);
+    // Refresh tenants list
+    const refreshTenants = useCallback(async () => {
+        if (!userEmail) {
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            // Always include personal account
+            const personalTenant = {
+                id: 'personal',
+                name: 'Personal',
+                type: 'personal'
+            };
+            // Fetch groups
+            const groupTenants = await fetchGroups();
+            const allTenants = [personalTenant, ...groupTenants];
+            setAvailableTenants(allTenants);
+            // Set default selection if none exists
+            const savedTenant = loadSavedTenant();
+            // A selection made by a different account is not ours to keep, even if
+            // this account happens to belong to that group too — an unstamped one
+            // predates this check and is validated by membership alone.
+            const belongsToThisUser = !savedTenant?.userEmail || savedTenant.userEmail === userEmail;
+            const stillAMember = allTenants.some((t) => t.id === savedTenant?.id);
+            if (savedTenant && belongsToThisUser && stillAMember) {
+                setSelectedTenantState(toOption(savedTenant));
+            }
+            else {
+                // Fall back to personal: the saved tenant is gone, or was someone else's
+                setSelectedTenantState(personalTenant);
+                saveTenant(personalTenant);
+                // Sibling components read the raw storage value synchronously on mount
+                // (useTenantFilter), so by now they have already fired their requests
+                // against the discarded groupId and are showing 403s. Reload for the
+                // same reason switching tenant by hand reloads — it is the only way
+                // this app re-reads the context. Storage now says personal, so the
+                // next pass takes the branch above and this does not loop.
+                if (savedTenant?.type === 'group') {
+                    logger.debug('Discarded a tenant selection this account cannot use; reloading');
+                    window.location.reload();
+                }
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to load contexts';
+            logger.error('Error in refreshTenants', err);
+            setError(errorMessage);
+            // The groups call failed, so we cannot tell a stale selection from a
+            // valid one. Keep showing what storage says rather than claiming
+            // "Personal" while useTenantFilter keeps sending the saved groupId —
+            // that mismatch is what made the UI look like it had switched context
+            // when it had not. TenantSelector renders the error state instead.
+            const personalTenant = {
+                id: 'personal',
+                name: 'Personal',
+                type: 'personal'
+            };
+            setAvailableTenants([personalTenant]);
+            const savedTenant = loadSavedTenant();
+            setSelectedTenantState(savedTenant ? toOption(savedTenant) : personalTenant);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [userEmail, fetchGroups, loadSavedTenant, saveTenant]);
+    // Set selected tenant with page reload
+    const setSelectedTenant = useCallback((tenant) => {
+        logger.debug('Tenant changing', { to: tenant.type === 'personal' ? 'Personal' : tenant.name });
+        // Save the new tenant selection
+        saveTenant(tenant);
+        // Reload the page to refresh all data with the new context
+        logger.debug('Reloading page to apply new tenant context');
+        window.location.reload();
+    }, [saveTenant]);
+    // Initialize on mount and when user changes
+    useEffect(() => {
+        refreshTenants();
+    }, [refreshTenants]);
+    return {
+        selectedTenant,
+        availableTenants,
+        loading,
+        error,
+        setSelectedTenant,
+        refreshTenants
+    };
+};

package/dist/components/tenant/useTenantDataRefresh.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook to get current tenant ID for data filtering
+ * Returns the groupId to be used in API calls, or undefined for personal context
+ * Since we reload the page when tenant changes, this can be a simple read from localStorage
+ */
+export declare const useTenantFilter: () => string | undefined;

package/dist/components/tenant/useTenantDataRefresh.js

@@ -0,0 +1,28 @@
+import { logger } from '../../monitoring';
+import { TENANT_STORAGE_KEY } from '../../sessionStorage';
+/**
+ * Hook to get current tenant ID for data filtering
+ * Returns the groupId to be used in API calls, or undefined for personal context
+ * Since we reload the page when tenant changes, this can be a simple read from localStorage
+ */
+export const useTenantFilter = () => {
+    const selectedTenant = getTenantFromStorage();
+    // Return groupId for group context, undefined for personal context
+    return selectedTenant?.type === 'group' ? selectedTenant.id : undefined;
+};
+/**
+ * Utility to get current tenant from localStorage
+ * Used for getting tenant context without triggering re-renders
+ */
+const getTenantFromStorage = () => {
+    try {
+        const saved = localStorage.getItem(TENANT_STORAGE_KEY);
+        if (saved) {
+            return JSON.parse(saved);
+        }
+    }
+    catch (err) {
+        logger.warn('Failed to load tenant from storage', { error: err });
+    }
+    return null;
+};

package/dist/config/createConfigProvider.d.ts

@@ -0,0 +1,44 @@
+import { ReactNode } from 'react';
+import { ErrorPageProps } from '../components/ErrorPage';
+export interface CreateConfigProviderOptions<TConfig extends {
+    PUBLIC_API_URL?: string;
+}> {
+    /** Passed to initMonitoring as the `service` tag. */
+    serviceName: string;
+    /** Pass `import.meta.env.DEV` from the calling app — reading `import.meta` here would not be reliably
+     *  processed by Vite once compiled into this shared, pre-built package. */
+    isDev: boolean;
+    /** Pass `import.meta.env.MODE` from the calling app, for the same reason as `isDev`. */
+    mode: string;
+    /** Builds the config from `import.meta.env.VITE_*` — must be provided by the calling app so the
+     *  `VITE_` env var reads stay in app source where Vite can statically resolve them. */
+    getDevConfig: () => TConfig;
+    /** Override the default ErrorPage props (e.g. shell-front's custom icon/title). */
+    errorPageProps?: ErrorPageProps;
+    /** Console levels to intercept in dev. Omit to use initMonitoring's own default (error + warn only). */
+    devCaptureConsoleLevels?: ('debug' | 'info' | 'warn' | 'error')[];
+    /**
+     * Where the production config lives. Defaults to `/config.json`, which a
+     * browser resolves against the *page*. A module-federation remote runs inside
+     * shell-front's page, where that is the shell's file and carries none of this
+     * app's service URLs — so remotes pass a URL on their own origin, built as
+     * `new URL('/config.json', import.meta.url).href`.
+     */
+    configUrl?: string;
+}
+/**
+ * Builds a per-front ConfigProvider instance. Each of the 8 frontends previously hand-rolled their
+ * own (8 divergent copies) — this factory keeps the dev/prod config loading, monitoring init, and
+ * loading/error UI in one place. Each app still declares its own `AppConfig` shape and reads its own
+ * `VITE_*` env vars via `getDevConfig`.
+ */
+export declare function createConfigProvider<TConfig extends {
+    PUBLIC_API_URL?: string;
+}>(options: CreateConfigProviderOptions<TConfig>): {
+    ConfigContext: import("react").Context<TConfig | null>;
+    ConfigProvider: ({ children }: {
+        children: ReactNode;
+    }) => import("react").JSX.Element;
+    getGlobalConfig: () => TConfig;
+    useConfig: () => TConfig;
+};

package/dist/config/createConfigProvider.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+import { CssBaseline, ThemeProvider } from '@mui/material';
+import { Loader } from '../components/Loader';
+import { ErrorPage } from '../components/ErrorPage';
+import { initMonitoring, initWebVitals } from '../monitoring';
+import { tumbalandTheme } from '../theme';
+/**
+ * Builds a per-front ConfigProvider instance. Each of the 8 frontends previously hand-rolled their
+ * own (8 divergent copies) — this factory keeps the dev/prod config loading, monitoring init, and
+ * loading/error UI in one place. Each app still declares its own `AppConfig` shape and reads its own
+ * `VITE_*` env vars via `getDevConfig`.
+ */
+export function createConfigProvider(options) {
+    let globalConfig = null;
+    const ConfigContext = createContext(null);
+    function getGlobalConfig() {
+        if (!globalConfig) {
+            if (options.isDev) {
+                const fallbackConfig = options.getDevConfig();
+                console.warn('Using fallback configuration during HMR:', fallbackConfig);
+                return fallbackConfig;
+            }
+            throw new Error('Configuration not initialized. Make sure ConfigProvider is mounted.');
+        }
+        return globalConfig;
+    }
+    function ConfigProvider({ children }) {
+        // Starts from an already-loaded config: the shell mounts a remote's
+        // provider every time the user navigates into that app, and re-fetching
+        // — with a loader in between — on each visit is the reload federation is
+        // here to avoid.
+        const [config, setConfig] = useState(() => globalConfig);
+        const [error, setError] = useState(null);
+        useEffect(() => {
+            if (globalConfig) {
+                return;
+            }
+            if (options.isDev) {
+                const devConfig = options.getDevConfig();
+                console.log('Using development configuration from environment variables:', devConfig);
+                setConfig(devConfig);
+                globalConfig = devConfig;
+                initMonitoring(options.mode, {
+                    service: options.serviceName,
+                    component: 'frontend',
+                    elkUrl: devConfig.PUBLIC_API_URL ? `${devConfig.PUBLIC_API_URL}/logs` : undefined,
+                    captureConsoleLevels: options.devCaptureConsoleLevels
+                });
+                initWebVitals({ isDevelopment: true }).catch(console.error);
+                return;
+            }
+            fetch(options.configUrl ?? '/config.json')
+                .then((res) => {
+                if (!res.ok)
+                    throw new Error('Config fetch failed');
+                return res.json();
+            })
+                .then((loadedConfig) => {
+                console.log('Using production configuration from config.json:', loadedConfig);
+                setConfig(loadedConfig);
+                globalConfig = loadedConfig;
+                initMonitoring('production', {
+                    service: options.serviceName,
+                    component: 'frontend',
+                    elkUrl: loadedConfig.PUBLIC_API_URL ? `${loadedConfig.PUBLIC_API_URL}/logs` : undefined
+                });
+                initWebVitals({ isDevelopment: false }).catch(console.error);
+            })
+                .catch((err) => {
+                console.error('Configuration load error:', err);
+                setError(err.message);
+            });
+        }, []);
+        if (error) {
+            return _jsx(ErrorPage, { ...options.errorPageProps });
+        }
+        if (!config) {
+            return _jsx(Loader, {});
+        }
+        const content = (_jsxs(_Fragment, { children: [_jsx(CssBaseline, {}), children] }));
+        return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(ThemeProvider, { theme: tumbalandTheme, children: content }) }));
+    }
+    function useConfig() {
+        const config = useContext(ConfigContext);
+        if (!config) {
+            throw new Error('useConfig must be used within a ConfigProvider');
+        }
+        return config;
+    }
+    return { ConfigContext, ConfigProvider, getGlobalConfig, useConfig };
+}

package/dist/federation.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Module-federation settings every Tumbaland front has to agree on.
+ *
+ * shell-front is the host; journal, album, money, account, groups and billing
+ * are remotes it loads at runtime from their own origins. This replaces the
+ * iframe-per-module shell: an iframe meant each module switch threw away a
+ * whole JS context and booted a new one, which is why opening a module
+ * re-checked the session, re-fetched its data and lost whatever the previous
+ * one had on screen.
+ *
+ * The shared singletons are the libraries that hold React context or global
+ * state. A remote running its own copy of React breaks hooks outright, and its
+ * own copy of the router, Emotion or React Query reads an empty context instead
+ * of the one the host's providers filled — so every app must take the single
+ * copy the host loaded. The list lives here rather than in seven vite configs
+ * because drift between those copies is precisely that failure.
+ *
+ * Plain data with no React imports: each `vite.config.mts` loads it in Node.
+ */
+export declare const TUMBALAND_FEDERATION_SHARED: {
+    react: {
+        singleton: boolean;
+    };
+    'react-dom': {
+        singleton: boolean;
+    };
+    'react-router': {
+        singleton: boolean;
+    };
+    '@emotion/react': {
+        singleton: boolean;
+    };
+    '@emotion/styled': {
+        singleton: boolean;
+    };
+    '@mui/material': {
+        singleton: boolean;
+    };
+    '@tanstack/react-query': {
+        singleton: boolean;
+    };
+};
+/** File each remote serves its federation entry as, at the root of its origin. */
+export declare const TUMBALAND_REMOTE_ENTRY = "remoteEntry.js";
+/** The module every remote exposes: its routes wrapped in its own providers. */
+export declare const TUMBALAND_REMOTE_MODULE = "./App";

package/dist/federation.js

@@ -0,0 +1,37 @@
+/**
+ * Module-federation settings every Tumbaland front has to agree on.
+ *
+ * shell-front is the host; journal, album, money, account, groups and billing
+ * are remotes it loads at runtime from their own origins. This replaces the
+ * iframe-per-module shell: an iframe meant each module switch threw away a
+ * whole JS context and booted a new one, which is why opening a module
+ * re-checked the session, re-fetched its data and lost whatever the previous
+ * one had on screen.
+ *
+ * The shared singletons are the libraries that hold React context or global
+ * state. A remote running its own copy of React breaks hooks outright, and its
+ * own copy of the router, Emotion or React Query reads an empty context instead
+ * of the one the host's providers filled — so every app must take the single
+ * copy the host loaded. The list lives here rather than in seven vite configs
+ * because drift between those copies is precisely that failure.
+ *
+ * Plain data with no React imports: each `vite.config.mts` loads it in Node.
+ */
+export const TUMBALAND_FEDERATION_SHARED = {
+    react: { singleton: true },
+    'react-dom': { singleton: true },
+    // Tumbaland is on `react-router` v8, which is the package that holds the
+    // router context — there is no `react-router-dom` to share.
+    'react-router': { singleton: true },
+    '@emotion/react': { singleton: true },
+    '@emotion/styled': { singleton: true },
+    '@mui/material': { singleton: true },
+    // Only album and money use it today. Shared anyway: a second copy in one of
+    // them would read an empty cache rather than fail loudly, which is the
+    // harder bug to find.
+    '@tanstack/react-query': { singleton: true }
+};
+/** File each remote serves its federation entry as, at the root of its origin. */
+export const TUMBALAND_REMOTE_ENTRY = 'remoteEntry.js';
+/** The module every remote exposes: its routes wrapped in its own providers. */
+export const TUMBALAND_REMOTE_MODULE = './App';

package/dist/index.d.ts

@@ -12,3 +12,29 @@ export type { User, AuthResponse, Group, ApiResponse } from './types';
 export { TENANT_STORAGE_KEY, clearSessionScopedStorage } from './sessionStorage';
 export { initMonitoring, captureException, captureMessage, setUser, setTag, startTransaction, recordMetric, initWebVitals, flushLogs, initConsoleInterception, generateCorrelationId, getCorrelationId, getSessionId, logger } from './monitoring';
 export type { MonitoringConfig } from './monitoring';
+export { Loader } from './components/Loader';
+export { ErrorPage } from './components/ErrorPage';
+export { AppErrorBoundary } from './components/AppErrorBoundary';
+export { UnauthorizedPage } from './components/UnauthorizedPage';
+export { ProtectedRoute } from './components/ProtectedRoute';
+export { LoginButton } from './components/LoginButton';
+export { NotificationsMenu } from './components/NotificationsMenu/NotificationsMenu';
+export { AuthHeader } from './components/AuthHeader';
+export { AppLayout } from './components/AppLayout';
+export { UsageMeter, formatBytes, useEntitlements } from './components/UsageMeter';
+export { TenantSelector, TenantProvider, useTenant, useTenantListener, useTenantContext, useTenantFilter } from './components/tenant';
+export type { LoaderProps } from './components/Loader';
+export type { ErrorPageProps } from './components/ErrorPage';
+export type { AppErrorBoundaryProps } from './components/AppErrorBoundary';
+export type { AppLayoutProps } from './components/AppLayout';
+export type { UnauthorizedPageProps } from './components/UnauthorizedPage';
+export type { ProtectedRouteProps, ProtectedRouteAuthService } from './components/ProtectedRoute';
+export type { LoginButtonProps } from './components/LoginButton';
+export type { NotificationsMenuProps } from './components/NotificationsMenu/NotificationsMenu';
+export type { AuthHeaderProps, AuthHeaderUser, AuthHeaderNavigationItem, AuthHeaderTenantOption, AuthHeaderTenantSelectorProps } from './components/AuthHeader';
+export type { TenantOption, TenantSelectorProps, UseTenantResult } from './components/tenant';
+export type { UsageMeterProps, UseEntitlementsResult } from './components/UsageMeter';
+export { createConfigProvider } from './config/createConfigProvider';
+export type { CreateConfigProviderOptions } from './config/createConfigProvider';
+export { toOrigin } from './routing';
+export { brand, ink, surface, gradient, moduleAccent, wordmark, glass, glassInteractive, brandButton, section, gutter, gutterSx, TOUCH_TARGET, PHONE, createTumbalandTheme, tumbalandTheme, TUMBALAND_COLORS } from './theme';

package/dist/index.js

@@ -1,4 +1,16 @@
-// @tumbaland/frontend-core - Shared frontend auth/group/API-client logic
+// @tumbaland/frontend-core — everything the Tumbaland frontends share:
+// the headless auth/group/API-client logic, and the React components and theme
+// built on top of it.
+//
+// These were two packages, @tumbaland/frontend-core and @tumbaland/frontend-core,
+// and every one of the eight frontends depended on both. Splitting them bought
+// nothing a consumer could use and cost a release ordering problem: components
+// pinned frontend-core exactly, so the two had to publish in dependency order
+// or the published tarball pinned a version that was about to be replaced.
+//
+// The one thing the split did guarantee is kept by `./federation`: that entry
+// point imports nothing, so the seven vite configs that read it in Node at
+// build time never pull React in.
 export { createApiClient, ApiError } from './apiClient';
 export { createAuthService, createAppAuthService } from './authService';
 export { createGroupService } from './groupService';
@@ -7,3 +19,24 @@ export { createPlansService } from './plansService';
 export { TENANT_STORAGE_KEY, clearSessionScopedStorage } from './sessionStorage';
 // Monitoring: headless logging, error capture, correlation IDs, and web-vitals
 export { initMonitoring, captureException, captureMessage, setUser, setTag, startTransaction, recordMetric, initWebVitals, flushLogs, initConsoleInterception, generateCorrelationId, getCorrelationId, getSessionId, logger } from './monitoring';
+// --- Components, theme and providers (formerly @tumbaland/frontend-core) ---
+export { Loader } from './components/Loader';
+export { ErrorPage } from './components/ErrorPage';
+export { AppErrorBoundary } from './components/AppErrorBoundary';
+export { UnauthorizedPage } from './components/UnauthorizedPage';
+export { ProtectedRoute } from './components/ProtectedRoute';
+export { LoginButton } from './components/LoginButton';
+export { NotificationsMenu } from './components/NotificationsMenu/NotificationsMenu';
+export { AuthHeader } from './components/AuthHeader';
+export { AppLayout } from './components/AppLayout';
+// Entitlements: the usage bar and the hook that feeds it
+export { UsageMeter, formatBytes, useEntitlements } from './components/UsageMeter';
+// Tenant selection: provider, selector, and hooks shared across domain frontends
+export { TenantSelector, TenantProvider, useTenant, useTenantListener, useTenantContext, useTenantFilter } from './components/tenant';
+// Config provider factory
+export { createConfigProvider } from './config/createConfigProvider';
+// A plain URL helper; the iframe bridge it belonged to is gone (see routing/index).
+export { toOrigin } from './routing';
+// Theme: the palette, the MUI theme built from it, and the raw tokens for the
+// places that have to name a colour outside a `sx` prop.
+export { brand, ink, surface, gradient, moduleAccent, wordmark, glass, glassInteractive, brandButton, section, gutter, gutterSx, TOUCH_TARGET, PHONE, createTumbalandTheme, tumbalandTheme, TUMBALAND_COLORS } from './theme';

package/dist/monitoring/batch.js

@@ -18,9 +18,9 @@ const sendBatch = async () => {
         const response = await fetch(config.elkUrl, {
             method: 'POST',
             headers: {
-                'Content-Type': 'application/json',
+                'Content-Type': 'application/json'
             },
-            body: JSON.stringify(batchToSend),
+            body: JSON.stringify(batchToSend)
         });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -39,7 +39,7 @@ const sendBatch = async () => {
         try {
             console.warn('Failed to send log batch, dropping logs:', error);
             if (config.isDevelopment) {
-                batchToSend.forEach(log => {
+                batchToSend.forEach((log) => {
                     console.warn('📝 [DROPPED LOG]:', JSON.stringify(log));
                 });
             }

package/dist/monitoring/config.js

@@ -30,10 +30,7 @@ export const initMonitoring = (environment = 'development', options = {}) => {
         console.log(`📝 Console interception enabled for levels: ${captureConsoleLevels.join(', ')}`);
     }
     // Initialize console interception and error handlers after modules are loaded
-    Promise.all([
-        import('./console'),
-        import('./errors')
-    ]).then(([{ initConsoleInterception }, { captureException, captureMessage }]) => {
+    Promise.all([import('./console'), import('./errors')]).then(([{ initConsoleInterception }, { captureException, captureMessage }]) => {
         // Initialize console interception with capture function
         initConsoleInterception(captureConsoleLevels, captureMessage);
         // Set up global error handlers

package/dist/monitoring/console.js

@@ -18,7 +18,7 @@ export const initConsoleInterception = (captureConsoleLevels = ['error', 'warn']
                 return;
             // Send to logging API with recursion protection
             try {
-                const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+                const message = args.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg))).join(' ');
                 // Set interception flag to prevent recursion during capture
                 window._monitoringInterceptingConsole = true;
                 captureMessageFn(message, level, {

package/dist/plansService.js

@@ -19,7 +19,7 @@ export function createPlansService(config) {
             const plans = body?.plans ?? [];
             // A plan without resolved limits cannot be rendered honestly — every line
             // on its card is a limit — so drop it rather than draw a card with holes.
-            return plans.filter(plan => Boolean(plan?.effectiveLimits?.meters));
+            return plans.filter((plan) => Boolean(plan?.effectiveLimits?.meters));
         }
     };
 }

package/dist/routing/embedContext.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Helpers shared by both sides of the shell/child iframe bridge.
+ *
+ * The child's initial path travels in the iframe `src` rather than over
+ * postMessage so the app boots straight into the deep-linked page instead of
+ * flashing its default route first. Every later navigation goes over
+ * postMessage — the `src` must stay stable or the child remounts.
+ */
+export declare const EMBED_FLAG = "embedded";
+export declare const EMBED_PATH = "embedPath";
+export interface EmbedContext {
+    embedded: boolean;
+    initialPath: string;
+}
+/** Path the child router starts on: always absolute, defaults to the root. */
+export declare const normalizeEmbedPath: (path?: string | null) => string;
+/** `/album` + `/albums/1?x=2` -> `/album/albums/1?x=2` (root path -> `/album`). */
+export declare const joinShellPath: (appRoute: string, childPath: string) => string;
+/** Everything after the app prefix, e.g. `/album/albums/1` -> `/albums/1`. */
+export declare const extractChildPath: (appRoute: string, shellPath: string, search?: string) => string;
+/** Config values are full URLs; postMessage needs a bare origin. */
+export declare const toOrigin: (url?: string) => string | undefined;
+export declare const safeUrl: (url: string, base?: string) => URL | undefined;
+/** Iframe `src` for an app, carrying the embed flag and the deep-linked path. */
+export declare const buildEmbeddedUrl: (appUrl: string, childPath: string) => string;
+/**
+ * Read on the child side. Embedded only when actually framed *and* flagged, so
+ * a direct visit to album.tumbaland.eu always gets a real BrowserRouter even if
+ * someone pastes the query params.
+ */
+export declare const readEmbedContext: (search?: string, isFramed?: boolean) => EmbedContext;