@fluid-app/rep-sdk 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,921 +1,36 @@
-export { MessagingScreen, messagingScreenPropertySchema } from './chunk-PJWPO4BJ.js';
-export { ContactsScreen, contactsScreenPropertySchema } from './chunk-WH7WZXT6.js';
-export { OrdersScreen, ordersScreenPropertySchema } from './chunk-PZIHCYDD.js';
-export { CustomersScreen, customersScreenPropertySchema } from './chunk-CXRJSGO6.js';
-export { ProductsScreen, productsScreenPropertySchema } from './chunk-2AWTZV3T.js';
-import { __reExport } from './chunk-LO2HDG6C.js';
-import { createContext, useState, useEffect, useCallback, useMemo, useContext, useRef } from 'react';
-import { QueryClient, QueryClientProvider, useQuery } from '@tanstack/react-query';
+import { themes_exports, useFluidApi, transformManifestToRepAppData, useThemeContext, useFluidAuthContext, MessagingScreen } from './chunk-7JMNKWPN.js';
+export { AUTH_CONSTANTS, ApiError, DEFAULT_AUTH_URL, DEFAULT_SDK_WIDGET_REGISTRY, FluidAuthProvider, FluidProvider, FluidThemeProvider, MessagingScreen, STORAGE_KEYS, URL_PARAMS, USER_TYPES, buildThemeDefinition, cleanTokenFromUrl, clearTokens, createDefaultAuthRedirect, createFluidClient, createFluidFileUploader, decodeToken, extractAllTokensFromUrl, extractCompanyTokenFromUrl, extractTokenFromUrl, getActiveThemeId, getStoredToken, getTokenExpiration, getTokenTimeRemaining, hasStoredToken, hasTokenInUrl, isApiError, isTokenExpired, isUserType, isValidToken, messagingScreenPropertySchema, normalizeComponentTree, storeToken, toNavigationItem, toScreenDefinition, transformManifestToRepAppData, transformThemes, useFluidApi, useFluidAuthContext, useFluidContext, useMessagingAuth, useMessagingConfig, useThemeContext, validateToken } from './chunk-7JMNKWPN.js';
+import { ContactsScreen } from './chunk-CMF2FYTD.js';
+export { ContactsScreen, contactsScreenPropertySchema } from './chunk-CMF2FYTD.js';
+import { OrdersScreen } from './chunk-WFPYEYC7.js';
+export { OrdersScreen, ordersScreenPropertySchema } from './chunk-WFPYEYC7.js';
+import { CustomersScreen } from './chunk-WMBD65GH.js';
+export { CustomersScreen, customersScreenPropertySchema } from './chunk-WMBD65GH.js';
+import { ProductsScreen } from './chunk-QZMWG7EM.js';
+export { ProductsScreen, productsScreenPropertySchema } from './chunk-QZMWG7EM.js';
+import { CoreScreenPlaceholder } from './chunk-RS4OSTES.js';
+import './chunk-424PT5DM.js';
+import { createContext, memo, forwardRef, useContext, useRef, useEffect, useMemo, useState, useCallback } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { decodeJwt, createRemoteJWKSet, jwtVerify } from 'jose';
+import { useQuery } from '@tanstack/react-query';
 export { WIDGET_TYPE_NAMES, assertDefined, assertNever, isWidgetType, isWidgetTypeName, sectionLayoutConfig } from '@fluid-app/rep-core/types';
-import * as theme_star from '@fluid-app/rep-core/theme';
 export { AlertWidget, CalendarWidget, CarouselWidget, CatchUpWidget, ChartWidget, ContainerWidget, EmbedWidget, ImageWidget, LayoutWidget, ListWidget, MySiteWidget, NestedWidget, QuickShareWidget, RecentActivityWidget, SpacerWidget, TableWidget, TextWidget, ToDoWidget, VideoWidget, alertWidgetPropertySchema, calendarWidgetPropertySchema, carouselWidgetPropertySchema, catchUpWidgetPropertySchema, chartWidgetPropertySchema, containerWidgetPropertySchema, embedWidgetPropertySchema, imageWidgetPropertySchema, layoutWidgetPropertySchema, listWidgetPropertySchema, mySiteWidgetPropertySchema, nestedWidgetPropertySchema, quickShareWidgetPropertySchema, recentActivityWidgetPropertySchema, spacerWidgetPropertySchema, tableWidgetPropertySchema, textWidgetPropertySchema, toDoWidgetPropertySchema, videoWidgetPropertySchema, widgetPropertySchemas } from '@fluid-app/rep-widgets/widgets';
 export { createScreen, createWidgetFromShareable, createWidgetRegistry, groupChildrenByColumn } from '@fluid-app/rep-core/widget-utils';
 export { PROPERTY_FIELD_TYPES, gapValues, isPropertyFieldType } from '@fluid-app/rep-core/registries';
-
-// src/client/types.ts
-var HTTP_METHODS = {
-  GET: "GET",
-  POST: "POST",
-  PUT: "PUT",
-  PATCH: "PATCH",
-  DELETE: "DELETE"
-};
-
-// src/auth/auth-redirect.ts
-var DEFAULT_AUTH_URL = "https://auth.fluid.app";
-var AUTH_REDIRECT_TOKEN_KEY = "jwt";
-var REDIRECT_TIMESTAMP_KEY = "__fluid_auth_redirect_ts";
-var REDIRECT_COOLDOWN_S = 10;
-function isRedirectLoop() {
-  try {
-    const ts = sessionStorage.getItem(REDIRECT_TIMESTAMP_KEY);
-    if (!ts) return false;
-    const elapsed = (Date.now() - Number(ts)) / 1e3;
-    return elapsed < REDIRECT_COOLDOWN_S;
-  } catch {
-    return false;
-  }
-}
-function markRedirect() {
-  try {
-    sessionStorage.setItem(REDIRECT_TIMESTAMP_KEY, String(Date.now()));
-  } catch {
-  }
-}
-function createDefaultAuthRedirect(authUrl) {
-  return () => {
-    if (isRedirectLoop()) {
-      console.warn(
-        "[FluidAuth] Auth redirect suppressed \u2014 possible redirect loop. Check that your auth server returns a token accepted by the API."
-      );
-      return;
-    }
-    markRedirect();
-    const base = authUrl ?? DEFAULT_AUTH_URL;
-    const currentUrl = encodeURIComponent(window.location.href);
-    window.location.href = `${base}/?redirect_url=${currentUrl}`;
-  };
-}
-function resolveAuthFailureHandler(onAuthFailure, authUrl) {
-  return onAuthFailure ?? createDefaultAuthRedirect(authUrl);
-}
-
-// src/client/fluid-client.ts
-var ApiError = class _ApiError extends Error {
-  status;
-  data;
-  constructor(message, status, data) {
-    super(message);
-    this.name = "ApiError";
-    this.status = status;
-    this.data = data;
-    const errorWithCapture = Error;
-    if (errorWithCapture.captureStackTrace) {
-      errorWithCapture.captureStackTrace(this, _ApiError);
-    }
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      status: this.status,
-      data: this.data
-    };
-  }
-};
-function isApiError(error) {
-  return error instanceof ApiError;
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function extractErrorMessage(data, fallback) {
-  if ("message" in data && isString(data.message)) {
-    return data.message;
-  }
-  if ("error_message" in data && isString(data.error_message)) {
-    return data.error_message;
-  }
-  if ("error" in data && isString(data.error)) {
-    return data.error;
-  }
-  return fallback;
-}
-function createFluidClient(config) {
-  const { baseUrl, getAuthToken, onAuthError, defaultHeaders = {} } = config;
-  const effectiveOnAuthError = onAuthError ?? createDefaultAuthRedirect();
-  async function buildHeaders(customHeaders) {
-    const headers = {
-      "Content-Type": "application/json",
-      ...defaultHeaders,
-      ...customHeaders
-    };
-    if (getAuthToken) {
-      const token = await getAuthToken();
-      if (token) {
-        headers.Authorization = `Bearer ${token}`;
-      }
-    }
-    return headers;
-  }
-  function buildUrl(endpoint, params) {
-    const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-    const normalizedEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
-    const url = new URL(normalizedBase + normalizedEndpoint);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        if (Array.isArray(value)) {
-          for (const item of value) {
-            url.searchParams.append(`${key}[]`, String(item));
-          }
-        } else if (typeof value === "object") {
-          for (const [subKey, subValue] of Object.entries(
-            value
-          )) {
-            if (subValue === void 0 || subValue === null) {
-              continue;
-            }
-            if (Array.isArray(subValue)) {
-              for (const item of subValue) {
-                url.searchParams.append(`${key}[${subKey}][]`, String(item));
-              }
-            } else {
-              url.searchParams.append(`${key}[${subKey}]`, String(subValue));
-            }
-          }
-        } else {
-          url.searchParams.append(key, String(value));
-        }
-      }
-    }
-    return url.toString();
-  }
-  const defaultRequestOptions = {
-    method: HTTP_METHODS.GET
-  };
-  async function request(endpoint, options = {}) {
-    const {
-      method = defaultRequestOptions.method,
-      headers: customHeaders,
-      params,
-      body,
-      signal
-    } = options;
-    const url = buildUrl(
-      endpoint,
-      method === HTTP_METHODS.GET ? params : void 0
-    );
-    const headers = await buildHeaders(customHeaders);
-    let response;
-    try {
-      const fetchOptions = {
-        method,
-        headers
-      };
-      if (signal !== void 0) {
-        fetchOptions.signal = signal;
-      }
-      if (body && method !== HTTP_METHODS.GET) {
-        fetchOptions.body = JSON.stringify(body);
-      }
-      response = await fetch(url, fetchOptions);
-    } catch (networkError) {
-      throw new ApiError(
-        `Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`,
-        0,
-        null
-      );
-    }
-    if (response.status === 401) {
-      effectiveOnAuthError();
-    }
-    if (!response.ok) {
-      try {
-        const contentType = response.headers.get("content-type");
-        if (contentType?.includes("application/json")) {
-          const data = await response.json();
-          const errorMessage = extractErrorMessage(
-            data,
-            `${method} request failed`
-          );
-          throw new ApiError(
-            errorMessage,
-            response.status,
-            "errors" in data ? data.errors : data
-          );
-        } else {
-          throw new ApiError(
-            `${method} request failed with status ${response.status}`,
-            response.status,
-            null
-          );
-        }
-      } catch (error) {
-        if (isApiError(error)) {
-          throw error;
-        }
-        throw new ApiError(
-          `${method} request failed with status ${response.status}`,
-          response.status,
-          null
-        );
-      }
-    }
-    if (response.status === 204 || response.headers.get("content-length") === "0") {
-      return null;
-    }
-    try {
-      const data = await response.json();
-      if (data === null || data === void 0) {
-        throw new ApiError(
-          "Unexpected null/undefined in JSON response",
-          response.status,
-          null
-        );
-      }
-      return data;
-    } catch (parseError) {
-      if (isApiError(parseError)) {
-        throw parseError;
-      }
-      throw new ApiError(
-        "Failed to parse response as JSON",
-        response.status,
-        null
-      );
-    }
-  }
-  async function requestNullable(endpoint, options = {}) {
-    return request(endpoint, options);
-  }
-  async function safeRequest(endpoint, options = {}) {
-    try {
-      const data = await request(endpoint, options);
-      return { success: true, data };
-    } catch (error) {
-      if (isApiError(error)) {
-        return { success: false, error };
-      }
-      return {
-        success: false,
-        error: new ApiError(
-          error instanceof Error ? error.message : "Unknown error",
-          0,
-          null
-        )
-      };
-    }
-  }
-  function toParams(params) {
-    return params;
-  }
-  const get = (endpoint, params, options) => {
-    const baseOptions = {
-      ...options,
-      method: HTTP_METHODS.GET
-    };
-    const convertedParams = toParams(params);
-    const requestOptions = convertedParams !== void 0 ? { ...baseOptions, params: convertedParams } : baseOptions;
-    return request(endpoint, requestOptions);
-  };
-  const post = (endpoint, body, options) => request(endpoint, {
-    ...options,
-    method: HTTP_METHODS.POST,
-    body
-  });
-  const put = (endpoint, body, options) => request(endpoint, {
-    ...options,
-    method: HTTP_METHODS.PUT,
-    body
-  });
-  const patch = (endpoint, body, options) => request(endpoint, {
-    ...options,
-    method: HTTP_METHODS.PATCH,
-    body
-  });
-  const del = (endpoint, options) => request(endpoint, {
-    ...options,
-    method: HTTP_METHODS.DELETE
-  });
-  return {
-    // Low-level methods for custom endpoints
-    request,
-    requestNullable,
-    safeRequest,
-    get,
-    post,
-    put,
-    patch,
-    delete: del,
-    // Products API - matches fluid-admin's /company/v1/products
-    products: {
-      list: (params) => get(
-        "/company/v1/products",
-        params
-      ),
-      get: (id) => get(`/company/v1/products/${id}`),
-      search: (query, params) => get("/company/v1/products", {
-        search_query: query,
-        ...params
-      })
-    },
-    // Orders API
-    orders: {
-      list: (params) => get("/orders", params),
-      get: (id) => get(`/orders/${id}`),
-      create: (data) => post("/orders", data)
-    },
-    // Reps API
-    reps: {
-      current: () => get("/reps/me"),
-      updateProfile: (data) => patch("/reps/me", data)
-    },
-    // Profile API (themes, navigation, screens)
-    profile: {
-      get: () => get("/rep_app/manifest")
-    },
-    // Permissions API
-    permissions: {
-      get: () => get("/company/roles/my_permissions")
-    },
-    // Analytics API
-    analytics: {
-      dashboard: () => get("/analytics/dashboard"),
-      sales: (params) => get("/analytics/sales", params)
-    }
-  };
-}
-var ThemeContext = createContext(null);
-function applyThemeVariables(theme, container) {
-  const target = container ?? document.documentElement;
-  for (const [key, value] of Object.entries(theme.config)) {
-    target.style.setProperty(`--fluid-${key}`, value);
-  }
-  if (theme.mode) {
-    target.dataset.fluidThemeMode = theme.mode;
-  }
-}
-function FluidThemeProvider({
-  children,
-  initialTheme,
-  container
-}) {
-  const [currentTheme, setCurrentTheme] = useState(
-    initialTheme ?? null
-  );
-  useEffect(() => {
-    if (currentTheme) {
-      applyThemeVariables(currentTheme, container ?? null);
-    }
-  }, [currentTheme, container]);
-  const setTheme = useCallback((theme) => {
-    setCurrentTheme(theme);
-  }, []);
-  const setThemeMode = useCallback((mode) => {
-    setCurrentTheme((prev) => prev ? { ...prev, mode } : null);
-  }, []);
-  const value = useMemo(
-    () => ({
-      currentTheme,
-      setTheme,
-      setThemeMode
-    }),
-    [currentTheme, setTheme, setThemeMode]
-  );
-  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value, children });
-}
-function useThemeContext() {
-  const context = useContext(ThemeContext);
-  if (!context) {
-    throw new Error("useThemeContext must be used within a FluidThemeProvider");
-  }
-  return context;
-}
-var FluidContext = createContext(null);
-function FluidProvider({
-  config,
-  children,
-  queryClient,
-  initialTheme,
-  themeContainer
-}) {
-  const defaultQueryClient = useMemo(
-    () => new QueryClient({
-      defaultOptions: {
-        queries: {
-          staleTime: 1e3 * 60,
-          // 1 minute
-          retry: 1
-        }
-      }
-    }),
-    []
-  );
-  const configRef = useRef(config);
-  configRef.current = config;
-  const client = useMemo(
-    () => createFluidClient(configRef.current),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [config.baseUrl]
-  );
-  const contextValue = useMemo(
-    () => ({ client, config: configRef.current }),
-    [client]
-  );
-  const themeProviderProps = {
-    ...initialTheme !== void 0 && { initialTheme },
-    ...themeContainer !== void 0 && { container: themeContainer }
-  };
-  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient ?? defaultQueryClient, children: /* @__PURE__ */ jsx(FluidContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(FluidThemeProvider, { ...themeProviderProps, children }) }) });
-}
-function useFluidContext() {
-  const context = useContext(FluidContext);
-  if (!context) {
-    throw new Error("useFluidContext must be used within a FluidProvider");
-  }
-  return context;
-}
-
-// src/auth/constants.ts
-var AUTH_CONSTANTS = {
-  /**
-   * Grace period in milliseconds to account for clock skew
-   * when checking token expiration. Tokens are considered valid
-   * if they expire within this period.
-   */
-  TOKEN_GRACE_PERIOD_MS: 30 * 1e3,
-  // 30 seconds
-  /**
-   * Default cookie max age in seconds (9 days).
-   * This matches the typical JWT token lifetime from the Fluid API.
-   */
-  COOKIE_MAX_AGE: 9 * 24 * 60 * 60
-  // 9 days = 777600 seconds
-};
-var STORAGE_KEYS = {
-  /** localStorage key for user token */
-  USER_TOKEN: "fluidUserToken",
-  /** localStorage key for company token (legacy) */
-  COMPANY_TOKEN: "fluidCompanyToken",
-  /** Cookie name for auth token */
-  AUTH_COOKIE: "auth_token"
-};
-var URL_PARAMS = {
-  /** URL parameter name for user token */
-  USER_TOKEN: "fluidUserToken",
-  /** URL parameter name for company token (legacy) */
-  COMPANY_TOKEN: "fluidCompanyToken"
-};
-
-// src/auth/url-token.ts
-function isBrowser() {
-  return typeof window !== "undefined";
-}
-function extractTokenFromUrl(tokenKey = URL_PARAMS.USER_TOKEN) {
-  if (!isBrowser()) {
-    return null;
-  }
-  try {
-    const searchParams = new URLSearchParams(window.location.search);
-    return searchParams.get(tokenKey);
-  } catch {
-    return null;
-  }
-}
-function extractCompanyTokenFromUrl(tokenKey = URL_PARAMS.COMPANY_TOKEN) {
-  if (!isBrowser()) {
-    return null;
-  }
-  try {
-    const searchParams = new URLSearchParams(window.location.search);
-    return searchParams.get(tokenKey);
-  } catch {
-    return null;
-  }
-}
-function cleanTokenFromUrl(tokenKey = URL_PARAMS.USER_TOKEN) {
-  if (!isBrowser()) {
-    return;
-  }
-  try {
-    const url = new URL(window.location.href);
-    const hadToken = url.searchParams.has(tokenKey);
-    const hadCompanyToken = url.searchParams.has(URL_PARAMS.COMPANY_TOKEN);
-    url.searchParams.delete(tokenKey);
-    url.searchParams.delete(URL_PARAMS.COMPANY_TOKEN);
-    if (hadToken || hadCompanyToken) {
-      window.history.replaceState(
-        window.history.state,
-        document.title,
-        url.toString()
-      );
-    }
-  } catch (error) {
-    console.warn("[FluidAuth] Failed to clean token from URL:", error);
-  }
-}
-function hasTokenInUrl(tokenKey = URL_PARAMS.USER_TOKEN) {
-  if (!isBrowser()) {
-    return false;
-  }
-  try {
-    const searchParams = new URLSearchParams(window.location.search);
-    return searchParams.has(tokenKey);
-  } catch {
-    return false;
-  }
-}
-function extractAllTokensFromUrl(userTokenKey = URL_PARAMS.USER_TOKEN, companyTokenKey = URL_PARAMS.COMPANY_TOKEN) {
-  if (!isBrowser()) {
-    return { userToken: null, companyToken: null };
-  }
-  try {
-    const searchParams = new URLSearchParams(window.location.search);
-    return {
-      userToken: searchParams.get(userTokenKey),
-      companyToken: searchParams.get(companyTokenKey)
-    };
-  } catch {
-    return { userToken: null, companyToken: null };
-  }
-}
-
-// src/auth/token-storage.ts
-function isBrowser2() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-function parseCookies() {
-  if (!isBrowser2()) {
-    return {};
-  }
-  const cookies = {};
-  const cookieString = document.cookie;
-  if (!cookieString) {
-    return cookies;
-  }
-  cookieString.split(";").forEach((cookie) => {
-    const [name, ...valueParts] = cookie.trim().split("=");
-    if (name) {
-      cookies[name] = decodeURIComponent(valueParts.join("="));
-    }
-  });
-  return cookies;
-}
-function setCookie(name, value, options = {}) {
-  if (!isBrowser2()) {
-    return;
-  }
-  const {
-    maxAge = AUTH_CONSTANTS.COOKIE_MAX_AGE,
-    path = "/",
-    sameSite = "lax",
-    secure = window.location.protocol === "https:"
-  } = options;
-  let cookieString = `${name}=${encodeURIComponent(value)}`;
-  cookieString += `; path=${path}`;
-  cookieString += `; max-age=${maxAge}`;
-  cookieString += `; samesite=${sameSite}`;
-  if (secure) {
-    cookieString += "; secure";
-  }
-  document.cookie = cookieString;
-}
-function deleteCookie(name, path = "/") {
-  if (!isBrowser2()) {
-    return;
-  }
-  document.cookie = `${name}=; path=${path}; max-age=0`;
-}
-function getStoredToken(config) {
-  if (!isBrowser2()) {
-    return null;
-  }
-  const cookieKey = config?.cookieKey ?? STORAGE_KEYS.AUTH_COOKIE;
-  const localStorageKey = STORAGE_KEYS.USER_TOKEN;
-  const cookies = parseCookies();
-  const cookieToken = cookies[cookieKey];
-  if (cookieToken) {
-    return cookieToken;
-  }
-  try {
-    return localStorage.getItem(localStorageKey);
-  } catch {
-    return null;
-  }
-}
-function storeToken(token, config) {
-  if (!isBrowser2()) {
-    return;
-  }
-  const cookieKey = config?.cookieKey ?? STORAGE_KEYS.AUTH_COOKIE;
-  const maxAge = config?.cookieMaxAge ?? AUTH_CONSTANTS.COOKIE_MAX_AGE;
-  try {
-    setCookie(cookieKey, token, {
-      maxAge,
-      path: "/",
-      // Use 'none' with secure for cross-origin iframe scenarios
-      sameSite: window.self !== window.top ? "none" : "lax",
-      secure: window.location.protocol === "https:"
-    });
-  } catch (error) {
-    console.warn("[FluidAuth] Failed to store token in cookie:", error);
-  }
-  try {
-    localStorage.setItem(STORAGE_KEYS.USER_TOKEN, token);
-  } catch (error) {
-    console.warn("[FluidAuth] Failed to store token in localStorage:", error);
-  }
-}
-function clearTokens(config) {
-  if (!isBrowser2()) {
-    return;
-  }
-  const cookieKey = config?.cookieKey ?? STORAGE_KEYS.AUTH_COOKIE;
-  try {
-    deleteCookie(cookieKey);
-  } catch {
-  }
-  try {
-    localStorage.removeItem(STORAGE_KEYS.USER_TOKEN);
-    localStorage.removeItem(STORAGE_KEYS.COMPANY_TOKEN);
-  } catch {
-  }
-}
-function hasStoredToken(config) {
-  return getStoredToken(config) !== null;
-}
-function extractPayloadFromJose(decoded) {
-  return {
-    id: decoded.id,
-    email: decoded.email,
-    full_name: decoded.full_name,
-    user_type: decoded.user_type ?? "rep",
-    og_user_type: decoded.og_user_type,
-    company_id: decoded.company_id,
-    exp: decoded.exp,
-    auth_type: decoded.auth_type
-  };
-}
-function decodeToken(token) {
-  try {
-    const decoded = decodeJwt(token);
-    return extractPayloadFromJose(decoded);
-  } catch (error) {
-    console.error("[FluidAuth] Failed to decode JWT token:", error);
-    return null;
-  }
-}
-function isTokenExpired(token, gracePeriodMs = AUTH_CONSTANTS.TOKEN_GRACE_PERIOD_MS) {
-  try {
-    const decoded = decodeJwt(token);
-    if (!decoded.exp) {
-      return false;
-    }
-    const expirationTime = decoded.exp * 1e3;
-    const currentTime = Date.now();
-    return currentTime > expirationTime + gracePeriodMs;
-  } catch {
-    return true;
-  }
-}
-function validateToken(token, gracePeriodMs = AUTH_CONSTANTS.TOKEN_GRACE_PERIOD_MS) {
-  if (!token || token.trim() === "") {
-    return {
-      isValid: false,
-      error: "Token is empty or not provided"
-    };
-  }
-  const payload = decodeToken(token);
-  if (!payload) {
-    return {
-      isValid: false,
-      error: "Token has invalid format"
-    };
-  }
-  if (isTokenExpired(token, gracePeriodMs)) {
-    return {
-      isValid: false,
-      payload,
-      error: "Token has expired"
-    };
-  }
-  return {
-    isValid: true,
-    payload
-  };
-}
-function isValidToken(result) {
-  return result.isValid === true;
-}
-function getTokenExpiration(token) {
-  try {
-    const decoded = decodeJwt(token);
-    if (!decoded.exp) {
-      return null;
-    }
-    return new Date(decoded.exp * 1e3);
-  } catch {
-    return null;
-  }
-}
-function getTokenTimeRemaining(token) {
-  try {
-    const decoded = decodeJwt(token);
-    if (!decoded.exp) {
-      return Infinity;
-    }
-    const expirationTime = decoded.exp * 1e3;
-    const remaining = expirationTime - Date.now();
-    return Math.max(0, remaining);
-  } catch {
-    return 0;
-  }
-}
-async function verifyToken(token, jwksUrl) {
-  try {
-    const JWKS = createRemoteJWKSet(new URL(jwksUrl));
-    const { payload } = await jwtVerify(token, JWKS);
-    const decoded = payload;
-    return extractPayloadFromJose(decoded);
-  } catch (error) {
-    console.error("[FluidAuth] JWT signature verification failed:", error);
-    return null;
-  }
-}
-
-// src/auth/types.ts
-var USER_TYPES = {
-  admin: "admin",
-  rep: "rep",
-  root_admin: "root_admin",
-  customer: "customer"
-};
-function isUserType(value) {
-  return Object.values(USER_TYPES).includes(value);
-}
-
-// src/auth/dev-utils.ts
-function isDevBypassActive(devBypass) {
-  if (!devBypass) return false;
-  try {
-    return import.meta.env.DEV === true;
-  } catch {
-    return false;
-  }
-}
-function createDevUser() {
-  return {
-    id: 0,
-    email: "dev@localhost",
-    full_name: "Dev User",
-    user_type: USER_TYPES.rep,
-    og_user_type: void 0,
-    company_id: 0,
-    exp: void 0,
-    // Never expires
-    auth_type: "dev_bypass"
-  };
-}
-var FluidAuthContext = createContext(null);
-function FluidAuthProvider({
-  children,
-  config
-}) {
-  const configRef = useRef(config);
-  configRef.current = config;
-  const [isLoading2, setIsLoading] = useState(true);
-  const [token, setToken] = useState(null);
-  const [user, setUser] = useState(null);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    const initializeAuth = async () => {
-      const handleAuthFailure = resolveAuthFailureHandler(config?.onAuthFailure, config?.authUrl);
-      try {
-        if (isDevBypassActive(config?.devBypass)) {
-          const envToken = import.meta.env.VITE_DEV_TOKEN;
-          if (envToken) {
-            const validation = validateToken(envToken, config?.gracePeriodMs);
-            if (validation.isValid && validation.payload) {
-              storeToken(envToken, config);
-              setToken(envToken);
-              setUser(validation.payload);
-              setError(null);
-              return;
-            }
-            console.warn(
-              "[FluidAuth] VITE_DEV_TOKEN is invalid or expired, falling back to mock user"
-            );
-          }
-          console.warn(
-            "[FluidAuth] Dev bypass active - using mock user. API calls will fail without a real token."
-          );
-          const devUser = createDevUser();
-          setToken(null);
-          setUser(devUser);
-          setError(null);
-          return;
-        }
-        const tokenKey = config?.tokenKey ?? "fluidUserToken";
-        let candidateToken = extractTokenFromUrl(tokenKey);
-        if (!candidateToken && tokenKey !== AUTH_REDIRECT_TOKEN_KEY) {
-          candidateToken = extractTokenFromUrl(AUTH_REDIRECT_TOKEN_KEY);
-        }
-        cleanTokenFromUrl(tokenKey);
-        cleanTokenFromUrl(AUTH_REDIRECT_TOKEN_KEY);
-        if (!candidateToken) {
-          candidateToken = getStoredToken(config);
-        }
-        if (candidateToken) {
-          let payload = null;
-          if (config?.jwksUrl) {
-            payload = await verifyToken(candidateToken, config.jwksUrl);
-            if (!payload) {
-              clearTokens(config);
-              setToken(null);
-              setUser(null);
-              setError(new Error("JWT signature verification failed"));
-              handleAuthFailure();
-              return;
-            }
-            if (isTokenExpired(candidateToken, config?.gracePeriodMs)) {
-              clearTokens(config);
-              setToken(null);
-              setUser(null);
-              setError(new Error("Token has expired"));
-              handleAuthFailure();
-              return;
-            }
-          } else {
-            const validation = validateToken(
-              candidateToken,
-              config?.gracePeriodMs
-            );
-            if (validation.isValid && validation.payload) {
-              payload = validation.payload;
-            } else {
-              clearTokens(config);
-              setToken(null);
-              setUser(null);
-              setError(new Error(validation.error ?? "Invalid token"));
-              handleAuthFailure();
-              return;
-            }
-          }
-          storeToken(candidateToken, config);
-          setToken(candidateToken);
-          setUser(payload);
-          setError(null);
-        } else {
-          setToken(null);
-          setUser(null);
-          setError(new Error("No authentication token found"));
-          handleAuthFailure();
-        }
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("Authentication error");
-        setError(error2);
-        setToken(null);
-        setUser(null);
-        handleAuthFailure();
-      } finally {
-        setIsLoading(false);
-      }
-    };
-    void initializeAuth();
-  }, []);
-  const clearAuth = useCallback(() => {
-    clearTokens(configRef.current);
-    setToken(null);
-    setUser(null);
-    setError(null);
-  }, []);
-  const contextValue = useMemo(
-    () => ({
-      isAuthenticated: user !== null,
-      isLoading: isLoading2,
-      user,
-      token,
-      clearAuth,
-      error
-    }),
-    [token, isLoading2, user, clearAuth, error]
-  );
-  return /* @__PURE__ */ jsx(FluidAuthContext.Provider, { value: contextValue, children });
-}
-function useFluidAuthContext() {
-  const context = useContext(FluidAuthContext);
-  if (!context) {
-    throw new Error(
-      "useFluidAuthContext must be used within a FluidAuthProvider. Wrap your app with <FluidAuthProvider> to use authentication features."
-    );
-  }
-  return context;
-}
+import { AppShellLayout } from '@fluid-app/rep-core/shell/AppShellLayout';
+import { useThemeMode, ThemeModeProvider } from '@fluid-app/rep-core/shell/ThemeModeContext';
+export { ThemeModeProvider, getThemeModeAttribute, useThemeMode } from '@fluid-app/rep-core/shell/ThemeModeContext';
+import { normalizeSlug, getSystemNavigationBySection, isSystemNavigationItem } from '@fluid-app/rep-core/navigation/system-navigation-items';
+import { resolveTheme, applyTheme, removeAllThemes } from '@fluid-app/rep-core/theme';
+import { SidebarMenu, SidebarGroupLabel, SidebarMenuItem, SidebarMenuButton, useSidebar } from '@fluid-app/rep-core/shell/sidebar';
+import { RepIcon } from '@fluid-app/rep-core/components/RepIcon';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { faBars } from '@fortawesome/pro-regular-svg-icons/faBars';
+import { faSun } from '@fortawesome/pro-regular-svg-icons/faSun';
+import { faMoon } from '@fortawesome/pro-regular-svg-icons/faMoon';
+import { faTableCellsLarge } from '@fortawesome/pro-regular-svg-icons/faTableCellsLarge';
+import { DataAwareWidget } from '@fluid-app/rep-core/data-sources/DataAwareWidget';
+import { useRegistry } from '@fluid-app/rep-widgets/contexts';
 
 // src/types/page-template.ts
 var PAGE_CATEGORIES = {
@@ -1157,50 +272,600 @@ function PageTemplateProvider({
         }
       }
     }
-    registeredIds.current = registered;
-    return () => {
-      for (const id of registeredIds.current) {
-        PageTemplateRegistry.unregister(id);
+    registeredIds.current = registered;
+    return () => {
+      for (const id of registeredIds.current) {
+        PageTemplateRegistry.unregister(id);
+      }
+      registeredIds.current = [];
+    };
+  }, [templateKey]);
+  const contextValue = useMemo(
+    () => ({
+      resolvePages: resolveNavigationPages,
+      listTemplates: () => PageTemplateRegistry.listAll(),
+      getTemplate: (id) => PageTemplateRegistry.get(id),
+      hasTemplate: (id) => PageTemplateRegistry.has(id)
+    }),
+    []
+  );
+  return /* @__PURE__ */ jsx(PageTemplateContext.Provider, { value: contextValue, children });
+}
+function usePageTemplates() {
+  const context = useContext(PageTemplateContext);
+  if (!context) {
+    throw new Error(
+      "usePageTemplates must be used within a PageTemplateProvider"
+    );
+  }
+  return context;
+}
+function useResolvedPages(navigation) {
+  const { resolvePages } = usePageTemplates();
+  return useMemo(() => resolvePages(navigation), [resolvePages, navigation]);
+}
+var PROFILE_QUERY_KEY = ["fluid", "profile"];
+function useFluidProfile() {
+  const api = useFluidApi();
+  return useQuery({
+    queryKey: PROFILE_QUERY_KEY,
+    queryFn: () => api.profile.get()
+  });
+}
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}
+function matchQuery(filters, query) {
+  const {
+    type = "all",
+    exact,
+    fetchStatus,
+    predicate,
+    queryKey,
+    stale
+  } = filters;
+  if (queryKey) {
+    if (exact) {
+      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
+        return false;
+      }
+    } else if (!partialMatchKey(query.queryKey, queryKey)) {
+      return false;
+    }
+  }
+  if (type !== "all") {
+    const isActive = query.isActive();
+    if (type === "active" && !isActive) {
+      return false;
+    }
+    if (type === "inactive" && isActive) {
+      return false;
+    }
+  }
+  if (typeof stale === "boolean" && query.isStale() !== stale) {
+    return false;
+  }
+  if (fetchStatus && fetchStatus !== query.state.fetchStatus) {
+    return false;
+  }
+  if (predicate && !predicate(query)) {
+    return false;
+  }
+  return true;
+}
+function hashQueryKeyByOptions(queryKey, options) {
+  const hashFn = options?.queryKeyHashFn || hashKey;
+  return hashFn(queryKey);
+}
+function hashKey(queryKey) {
+  return JSON.stringify(
+    queryKey,
+    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+      result[key] = val[key];
+      return result;
+    }, {}) : val
+  );
+}
+function partialMatchKey(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]));
+  }
+  return false;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  }
+  if (!prot.hasOwnProperty("isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(o) !== Object.prototype) {
+    return false;
+  }
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+
+// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.12/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+  let notifyFn = (callback) => {
+    callback();
+  };
+  let batchNotifyFn = (callback) => {
+    callback();
+  };
+  let scheduleFn = defaultScheduler;
+  const schedule = (callback) => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleFn(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+    if (originalQueue.length) {
+      scheduleFn(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach((callback) => {
+            notifyFn(callback);
+          });
+        });
+      });
+    }
+  };
+  return {
+    batch: (callback) => {
+      let result;
+      transactions++;
+      try {
+        result = callback();
+      } finally {
+        transactions--;
+        if (!transactions) {
+          flush();
+        }
+      }
+      return result;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (callback) => {
+      return (...args) => {
+        schedule(() => {
+          callback(...args);
+        });
+      };
+    },
+    schedule,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (fn) => {
+      notifyFn = fn;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (fn) => {
+      batchNotifyFn = fn;
+    },
+    setScheduler: (fn) => {
+      scheduleFn = fn;
+    }
+  };
+}
+var notifyManager = createNotifyManager();
+
+// ../../../node_modules/.pnpm/@tanstack+query-persist-client-core@5.91.11/node_modules/@tanstack/query-persist-client-core/build/modern/createPersister.js
+var PERSISTER_KEY_PREFIX = "tanstack-query";
+function experimental_createQueryPersister({
+  storage: storage2,
+  buster = "",
+  maxAge = 1e3 * 60 * 60 * 24,
+  serialize = JSON.stringify,
+  deserialize = JSON.parse,
+  prefix = PERSISTER_KEY_PREFIX,
+  refetchOnRestore = true,
+  filters
+}) {
+  function isExpiredOrBusted(persistedQuery) {
+    if (persistedQuery.state.dataUpdatedAt) {
+      const queryAge = Date.now() - persistedQuery.state.dataUpdatedAt;
+      const expired = queryAge > maxAge;
+      const busted = persistedQuery.buster !== buster;
+      if (expired || busted) {
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async function retrieveQuery(queryHash, afterRestoreMacroTask) {
+    if (storage2 != null) {
+      const storageKey = `${prefix}-${queryHash}`;
+      try {
+        const storedData = await storage2.getItem(storageKey);
+        if (storedData) {
+          const persistedQuery = await deserialize(storedData);
+          if (isExpiredOrBusted(persistedQuery)) {
+            await storage2.removeItem(storageKey);
+          } else {
+            if (afterRestoreMacroTask) {
+              notifyManager.schedule(
+                () => afterRestoreMacroTask(persistedQuery)
+              );
+            }
+            return persistedQuery.state.data;
+          }
+        }
+      } catch (err) {
+        if (process.env.NODE_ENV === "development") {
+          console.error(err);
+          console.warn(
+            "Encountered an error attempting to restore query cache from persisted location."
+          );
+        }
+        await storage2.removeItem(storageKey);
+      }
+    }
+    return;
+  }
+  async function persistQueryByKey(queryKey, queryClient) {
+    if (storage2 != null) {
+      const query = queryClient.getQueryCache().find({ queryKey });
+      if (query) {
+        await persistQuery(query);
+      } else {
+        if (process.env.NODE_ENV === "development") {
+          console.warn(
+            "Could not find query to be persisted. QueryKey:",
+            JSON.stringify(queryKey)
+          );
+        }
+      }
+    }
+  }
+  async function persistQuery(query) {
+    if (storage2 != null) {
+      const storageKey = `${prefix}-${query.queryHash}`;
+      storage2.setItem(
+        storageKey,
+        await serialize({
+          state: query.state,
+          queryKey: query.queryKey,
+          queryHash: query.queryHash,
+          buster
+        })
+      );
+    }
+  }
+  async function persisterFn(queryFn, ctx, query) {
+    const matchesFilter = filters ? matchQuery(filters, query) : true;
+    if (matchesFilter && query.state.data === void 0 && storage2 != null) {
+      const restoredData = await retrieveQuery(
+        query.queryHash,
+        (persistedQuery) => {
+          query.setState({
+            dataUpdatedAt: persistedQuery.state.dataUpdatedAt,
+            errorUpdatedAt: persistedQuery.state.errorUpdatedAt
+          });
+          if (refetchOnRestore === "always" || refetchOnRestore === true && query.isStale()) {
+            query.fetch();
+          }
+        }
+      );
+      if (restoredData !== void 0) {
+        return Promise.resolve(restoredData);
+      }
+    }
+    const queryFnResult = await queryFn(ctx);
+    if (matchesFilter && storage2 != null) {
+      notifyManager.schedule(() => {
+        persistQuery(query);
+      });
+    }
+    return Promise.resolve(queryFnResult);
+  }
+  async function persisterGc() {
+    if (storage2?.entries) {
+      const entries = await storage2.entries();
+      for (const [key, value] of entries) {
+        if (key.startsWith(prefix)) {
+          const persistedQuery = await deserialize(value);
+          if (isExpiredOrBusted(persistedQuery)) {
+            await storage2.removeItem(key);
+          }
+        }
+      }
+    } else if (process.env.NODE_ENV === "development") {
+      throw new Error(
+        "Provided storage does not implement `entries` method. Garbage collection is not possible without ability to iterate over storage items."
+      );
+    }
+  }
+  async function restoreQueries(queryClient, filters2 = {}) {
+    const { exact, queryKey } = filters2;
+    if (storage2?.entries) {
+      const entries = await storage2.entries();
+      for (const [key, value] of entries) {
+        if (key.startsWith(prefix)) {
+          const persistedQuery = await deserialize(value);
+          if (isExpiredOrBusted(persistedQuery)) {
+            await storage2.removeItem(key);
+            continue;
+          }
+          if (queryKey) {
+            if (exact) {
+              if (persistedQuery.queryHash !== hashKey(queryKey)) {
+                continue;
+              }
+            } else if (!partialMatchKey(persistedQuery.queryKey, queryKey)) {
+              continue;
+            }
+          }
+          queryClient.setQueryData(
+            persistedQuery.queryKey,
+            persistedQuery.state.data,
+            {
+              updatedAt: persistedQuery.state.dataUpdatedAt
+            }
+          );
+        }
+      }
+    } else if (process.env.NODE_ENV === "development") {
+      throw new Error(
+        "Provided storage does not implement `entries` method. Restoration of all stored entries is not possible without ability to iterate over storage items."
+      );
+    }
+  }
+  return {
+    persisterFn,
+    persistQuery,
+    persistQueryByKey,
+    retrieveQuery,
+    persisterGc,
+    restoreQueries
+  };
+}
+
+// ../../platform/query-persister/src/persister.ts
+var DB_NAME = "fluid_tanstack_query_cache";
+var STORE_NAME = "fluid_queries";
+var VERSION = 1;
+var dbPromise = null;
+async function deleteDatabase() {
+  return new Promise((resolve, reject) => {
+    console.warn("[IDB] Deleting database due to error");
+    const req = indexedDB.deleteDatabase(DB_NAME);
+    req.onsuccess = () => {
+      console.log("[IDB] Database deleted successfully");
+      resolve();
+    };
+    req.onerror = () => {
+      console.error("[IDB] Failed to delete database:", req.error);
+      reject(req.error ?? new Error("deleteDatabase failed"));
+    };
+    req.onblocked = () => {
+      console.warn("[IDB] Delete blocked: close all tabs using this database");
+    };
+  });
+}
+function openDatabase() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, VERSION);
+    req.onupgradeneeded = () => {
+      const upgradeDb = req.result;
+      if (!upgradeDb.objectStoreNames.contains(STORE_NAME)) {
+        upgradeDb.createObjectStore(STORE_NAME);
       }
-      registeredIds.current = [];
     };
-  }, [templateKey]);
-  const contextValue = useMemo(
-    () => ({
-      resolvePages: resolveNavigationPages,
-      listTemplates: () => PageTemplateRegistry.listAll(),
-      getTemplate: (id) => PageTemplateRegistry.get(id),
-      hasTemplate: (id) => PageTemplateRegistry.has(id)
-    }),
-    []
-  );
-  return /* @__PURE__ */ jsx(PageTemplateContext.Provider, { value: contextValue, children });
+    req.onsuccess = () => {
+      const conn = req.result;
+      conn.onversionchange = () => {
+        console.trace("[IDB] version change \u2013 closing connection");
+        conn.close();
+        dbPromise = null;
+      };
+      resolve(conn);
+    };
+    req.onblocked = () => {
+      console.warn("[IDB] open blocked: another connection is holding the DB");
+    };
+    req.onerror = () => {
+      reject(
+        req.error instanceof Error ? req.error : new Error(`IndexedDB open failed: ${String(req.error)}`)
+      );
+    };
+  });
 }
-function usePageTemplates() {
-  const context = useContext(PageTemplateContext);
-  if (!context) {
-    throw new Error(
-      "usePageTemplates must be used within a PageTemplateProvider"
-    );
+async function getDbWithRecovery() {
+  try {
+    return await openDatabase();
+  } catch (err) {
+    console.warn("[IDB] Initial open failed, attempting recovery:", err);
+    try {
+      await deleteDatabase();
+      console.log("[IDB] Retrying database open after deletion");
+      return await openDatabase();
+    } catch (retryErr) {
+      console.error("[IDB] Recovery failed:", retryErr);
+      throw retryErr;
+    }
   }
-  return context;
 }
-function useResolvedPages(navigation) {
-  const { resolvePages } = usePageTemplates();
-  return useMemo(() => resolvePages(navigation), [resolvePages, navigation]);
+function getDb() {
+  if (dbPromise) return dbPromise;
+  dbPromise = getDbWithRecovery().catch((err) => {
+    dbPromise = null;
+    throw err;
+  });
+  return dbPromise;
 }
-
-// src/hooks/use-fluid-api.ts
-function useFluidApi() {
-  const { client } = useFluidContext();
-  return client;
+var storage = {
+  async getItem(key) {
+    try {
+      const db = await getDb();
+      return new Promise((res) => {
+        try {
+          const r = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(key);
+          r.onsuccess = () => res(r.result);
+          r.onerror = () => {
+            console.trace("[IDB] getItem error:", r.error);
+            res(void 0);
+          };
+        } catch (txErr) {
+          console.trace("[IDB] getItem transaction error:", txErr);
+          res(void 0);
+        }
+      });
+    } catch (err) {
+      console.trace("[IDB] getItem getDb error:", err);
+      try {
+        const db = await getDb();
+        return new Promise((res) => {
+          try {
+            const r = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(key);
+            r.onsuccess = () => res(r.result);
+            r.onerror = () => {
+              console.trace("[IDB] getItem retry error:", r.error);
+              res(void 0);
+            };
+          } catch (txErr) {
+            console.trace("[IDB] getItem retry transaction error:", txErr);
+            res(void 0);
+          }
+        });
+      } catch (recoveryErr) {
+        console.trace("[IDB] getItem recovery failed:", recoveryErr);
+      }
+      return void 0;
+    }
+  },
+  async setItem(key, value) {
+    const cloneableValue = JSON.parse(JSON.stringify(value));
+    try {
+      const db = await getDb();
+      if (!db) return;
+      await new Promise((resolve) => {
+        try {
+          const req = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(cloneableValue, key);
+          req.onsuccess = () => resolve();
+          req.onerror = () => {
+            console.trace("[IDB] setItem error:", req.error);
+            resolve();
+          };
+        } catch (txErr) {
+          console.trace("[IDB] setItem transaction error:", txErr);
+          resolve();
+        }
+      });
+    } catch (err) {
+      console.trace("[IDB] setItem getDb error:", err);
+      try {
+        const db = await getDb();
+        await new Promise((resolve) => {
+          try {
+            const req = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(cloneableValue, key);
+            req.onsuccess = () => resolve();
+            req.onerror = () => {
+              console.trace("[IDB] setItem retry error:", req.error);
+              resolve();
+            };
+          } catch (txErr) {
+            console.trace("[IDB] setItem retry transaction error:", txErr);
+            resolve();
+          }
+        });
+      } catch (recoveryErr) {
+        console.trace("[IDB] setItem recovery failed:", recoveryErr);
+      }
+    }
+  },
+  async removeItem(key) {
+    try {
+      const db = await getDb();
+      if (!db) return;
+      await new Promise((resolve) => {
+        try {
+          const req = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(key);
+          req.onsuccess = () => resolve();
+          req.onerror = () => {
+            console.trace("[IDB] removeItem error:", req.error);
+            resolve();
+          };
+        } catch (txErr) {
+          console.trace("[IDB] removeItem transaction error:", txErr);
+          resolve();
+        }
+      });
+    } catch (err) {
+      console.trace("[IDB] removeItem getDb error:", err);
+      try {
+        const db = await getDb();
+        await new Promise((resolve) => {
+          try {
+            const req = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(key);
+            req.onsuccess = () => resolve();
+            req.onerror = () => {
+              console.trace("[IDB] removeItem retry error:", req.error);
+              resolve();
+            };
+          } catch (txErr) {
+            console.trace("[IDB] removeItem retry transaction error:", txErr);
+            resolve();
+          }
+        });
+      } catch (recoveryErr) {
+        console.trace("[IDB] removeItem recovery failed:", recoveryErr);
+      }
+    }
+  }
+};
+function createPersister() {
+  return experimental_createQueryPersister({
+    storage,
+    serialize: (persistedQuery) => persistedQuery,
+    deserialize: (cached) => cached
+  });
 }
-var PROFILE_QUERY_KEY = ["fluid", "profile"];
-function useFluidProfile() {
+
+// src/hooks/use-fluid-app.ts
+var APP_DATA_QUERY_KEY = ["fluid", "app"];
+var appDataPersister = typeof window !== "undefined" ? createPersister() : void 0;
+function useFluidApp(options) {
   const api = useFluidApi();
   return useQuery({
-    queryKey: PROFILE_QUERY_KEY,
-    queryFn: () => api.profile.get()
+    queryKey: APP_DATA_QUERY_KEY,
+    queryFn: () => api.app.getRaw(),
+    select: transformManifestToRepAppData,
+    ...appDataPersister && { persister: appDataPersister.persisterFn },
+    ...options?.enabled !== void 0 && { enabled: options.enabled }
   });
 }
 var PERMISSIONS_QUERY_KEY = ["fluid", "permissions"];
@@ -1237,12 +902,12 @@ function useFluidPermissions() {
 
 // src/hooks/use-fluid-theme.ts
 function useFluidTheme() {
-  const { currentTheme, setTheme, setThemeMode } = useThemeContext();
+  const { currentTheme, setTheme, setThemeMode, mode } = useThemeContext();
   return {
     currentTheme,
     setTheme,
     setThemeMode,
-    mode: currentTheme?.mode
+    mode
   };
 }
 var CURRENT_REP_QUERY_KEY = ["fluid", "currentRep"];
@@ -1917,7 +1582,19 @@ function AuthError({
     }
   );
 }
+var SPIN_STYLE_ID = "fluid-auth-loading-spin";
+function ensureSpinStyle() {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(SPIN_STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = SPIN_STYLE_ID;
+  style.textContent = `@keyframes spin { to { transform: rotate(360deg); } }`;
+  document.head.appendChild(style);
+}
 function AuthLoading() {
+  useEffect(() => {
+    ensureSpinStyle();
+  }, []);
   return /* @__PURE__ */ jsxs(
     "div",
     {
@@ -1954,12 +1631,7 @@ function AuthLoading() {
             },
             children: "Authenticating..."
           }
-        ),
-        /* @__PURE__ */ jsx("style", { children: `
-        @keyframes spin {
-          to { transform: rotate(360deg); }
-        }
-      ` })
+        )
       ]
     }
   );
@@ -1979,17 +1651,13 @@ function RequireAuth({
   return /* @__PURE__ */ jsx(Fragment, { children });
 }
 
-// src/themes/index.ts
-var themes_exports = {};
-__reExport(themes_exports, theme_star);
-
 // src/screens/index.ts
 var screenPropertySchemas = {
-  MessagingScreen: () => import('./MessagingScreen-O42JEJMW.js').then((m) => m.messagingScreenPropertySchema),
-  ContactsScreen: () => import('./ContactsScreen-BYXF74BO.js').then((m) => m.contactsScreenPropertySchema),
-  OrdersScreen: () => import('./OrdersScreen-QQJFTTSS.js').then((m) => m.ordersScreenPropertySchema),
-  CustomersScreen: () => import('./CustomersScreen-VS6LGULO.js').then((m) => m.customersScreenPropertySchema),
-  ProductsScreen: () => import('./ProductsScreen-TRIT2FE3.js').then((m) => m.productsScreenPropertySchema)
+  MessagingScreen: () => import('./MessagingScreen-4H7ZBO3V.js').then((m) => m.messagingScreenPropertySchema),
+  ContactsScreen: () => import('./ContactsScreen-33AJ5XUB.js').then((m) => m.contactsScreenPropertySchema),
+  OrdersScreen: () => import('./OrdersScreen-IPPZLEYF.js').then((m) => m.ordersScreenPropertySchema),
+  CustomersScreen: () => import('./CustomersScreen-E4HXBKV7.js').then((m) => m.customersScreenPropertySchema),
+  ProductsScreen: () => import('./ProductsScreen-YTSOZW7B.js').then((m) => m.productsScreenPropertySchema)
 };
 var CORE_PAGE_IDS = {
   MESSAGING: "core-messaging",
@@ -2091,34 +1759,642 @@ function registerCorePageTemplates() {
   });
 }
 registerCorePageTemplates();
-var export_BUILT_IN_THEMES = themes_exports.BUILT_IN_THEMES;
-var export_CORE_COLOR_KEYS = themes_exports.CORE_COLOR_KEYS;
-var export_DEFAULT_CORE_COLORS = themes_exports.DEFAULT_CORE_COLORS;
-var export_catppuccinMocha = themes_exports.catppuccinMocha;
-var export_clampChroma = themes_exports.clampChroma;
-var export_defaultTheme = themes_exports.defaultTheme;
-var export_detectThemeMode = themes_exports.detectThemeMode;
-var export_dracula = themes_exports.dracula;
-var export_everforest = themes_exports.everforest;
-var export_generateColorSwatches = themes_exports.generateColorSwatches;
-var export_generateDualTheme = themes_exports.generateDualTheme;
-var export_generateSmartDualTheme = themes_exports.generateSmartDualTheme;
-var export_generateTheme = themes_exports.generateTheme;
-var export_generateThemeCssVars = themes_exports.generateThemeCssVars;
-var export_gruvbox = themes_exports.gruvbox;
-var export_mod = themes_exports.mod;
-var export_monokai = themes_exports.monokai;
-var export_nord = themes_exports.nord;
-var export_oklchString = themes_exports.oklchString;
-var export_parseOklch = themes_exports.parseOklch;
-var export_rosePine = themes_exports.rosePine;
-var export_rotateHue = themes_exports.rotateHue;
-var export_rotateSoft = themes_exports.rotateSoft;
-var export_solarized = themes_exports.solarized;
-var export_toDarkMode = themes_exports.toDarkMode;
-var export_toLightMode = themes_exports.toLightMode;
-var export_tokyoNight = themes_exports.tokyoNight;
+var SPIN_STYLE_ID2 = "fluid-app-shell-loading-spin";
+function ensureSpinStyle2() {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(SPIN_STYLE_ID2)) return;
+  const style = document.createElement("style");
+  style.id = SPIN_STYLE_ID2;
+  style.textContent = `@keyframes spin { to { transform: rotate(360deg); } }`;
+  document.head.appendChild(style);
+}
+function AppShellLoading() {
+  useEffect(() => {
+    ensureSpinStyle2();
+  }, []);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        minHeight: "100vh",
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+        backgroundColor: "#f9fafb"
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              width: "40px",
+              height: "40px",
+              border: "3px solid #e5e7eb",
+              borderTopColor: "#3b82f6",
+              borderRadius: "50%",
+              animation: "spin 1s linear infinite"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "p",
+          {
+            style: {
+              marginTop: "1rem",
+              color: "#6b7280",
+              fontSize: "0.875rem"
+            },
+            children: "Loading..."
+          }
+        )
+      ]
+    }
+  );
+}
+function collectNavSlugs(items) {
+  const slugs = [];
+  for (const item of items) {
+    if (item.slug) slugs.push(normalizeSlug(item.slug));
+    for (const child of item.children ?? []) {
+      if (child.slug) slugs.push(normalizeSlug(child.slug));
+    }
+  }
+  return [...slugs].sort((a, b) => b.split("/").length - a.split("/").length);
+}
+function matchSlugPrefix(fullSlug, navSlugs) {
+  const normalized = normalizeSlug(fullSlug);
+  if (!normalized) return void 0;
+  for (const navSlug of navSlugs) {
+    if (normalized === navSlug) {
+      return { matchedSlug: navSlug, rest: "" };
+    }
+    if (normalized.startsWith(navSlug + "/")) {
+      return {
+        matchedSlug: navSlug,
+        rest: normalized.slice(navSlug.length + 1)
+      };
+    }
+  }
+  return void 0;
+}
+function extractSlugFromPathname(pathname, basePath) {
+  if (basePath === "/") {
+    return pathname.replace(/^\//, "");
+  }
+  if (pathname.startsWith(basePath)) {
+    return pathname.slice(basePath.length).replace(/^\//, "");
+  }
+  return pathname.replace(/^\//, "");
+}
+function isSlugInSection(item, currentSlug, navSlugs) {
+  const match = matchSlugPrefix(currentSlug, navSlugs);
+  const baseSlug = match?.matchedSlug ?? normalizeSlug(currentSlug);
+  if (normalizeSlug(item.slug) === baseSlug) return true;
+  return item.children?.some((child) => normalizeSlug(child.slug) === baseSlug) ?? false;
+}
+function SdkNavigation({
+  navItems,
+  currentSlug,
+  onNavigate,
+  navSlugs
+}) {
+  return /* @__PURE__ */ jsx(SidebarMenu, { children: navItems.map((item, index) => {
+    if (!item.slug && !item.label) return null;
+    if (!item.slug) {
+      return /* @__PURE__ */ jsx(SidebarGroupLabel, { children: item.label }, item.id ?? `section-${index}`);
+    }
+    const itemSlug = normalizeSlug(item.slug);
+    const isActive = isSlugInSection(item, currentSlug, navSlugs);
+    return /* @__PURE__ */ jsx(SidebarMenuItem, { children: /* @__PURE__ */ jsxs(
+      SidebarMenuButton,
+      {
+        isActive,
+        onClick: () => onNavigate(itemSlug),
+        children: [
+          item.icon && /* @__PURE__ */ jsx(RepIcon, { name: item.icon }),
+          /* @__PURE__ */ jsx("span", { className: "truncate", children: item.label })
+        ]
+      }
+    ) }, item.id ?? itemSlug);
+  }) });
+}
+function QuickLinksDropdown({ onNavigate }) {
+  const [open, setOpen] = useState(false);
+  const panelRef = useRef(null);
+  const buttonRef = useRef(null);
+  const close = useCallback(() => setOpen(false), []);
+  useEffect(() => {
+    if (!open) return;
+    const handleMouseDown = (e) => {
+      if (panelRef.current && !panelRef.current.contains(e.target) && buttonRef.current && !buttonRef.current.contains(e.target)) {
+        close();
+      }
+    };
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape") close();
+    };
+    document.addEventListener("mousedown", handleMouseDown);
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("mousedown", handleMouseDown);
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [open, close]);
+  const sections = getSystemNavigationBySection();
+  const handleItemClick = (slug) => {
+    onNavigate(slug);
+    close();
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref: buttonRef,
+        type: "button",
+        onClick: () => setOpen((prev) => !prev),
+        className: "flex shrink-0 items-center justify-center rounded-md p-2 text-sidebar-foreground hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
+        "aria-label": "Quick links",
+        "aria-expanded": open,
+        children: /* @__PURE__ */ jsx(FontAwesomeIcon, { icon: faTableCellsLarge, className: "h-4 w-4" })
+      }
+    ),
+    open && /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: panelRef,
+        className: "absolute top-full right-0 z-50 mt-1 w-[700px] max-w-[90vw] overflow-hidden rounded-lg border border-border bg-background shadow-lg",
+        children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 border-b bg-background p-4", children: [
+            /* @__PURE__ */ jsx(
+              FontAwesomeIcon,
+              {
+                icon: faTableCellsLarge,
+                className: "h-5 w-5 text-muted-foreground"
+              }
+            ),
+            /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-foreground", children: "Shortcuts" })
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "space-y-6 bg-muted p-6", children: Object.entries(sections).map(([sectionName, items]) => /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+            /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-foreground", children: sectionName }),
+            /* @__PURE__ */ jsx("div", { className: "grid grid-cols-4 gap-2", children: items.map((item) => /* @__PURE__ */ jsxs(
+              "button",
+              {
+                type: "button",
+                onClick: () => handleItemClick(item.slug),
+                className: "flex items-center gap-2 rounded-lg px-3 py-2 text-sm text-sidebar-foreground transition-colors hover:bg-sidebar-primary hover:text-sidebar-primary-foreground",
+                children: [
+                  item.icon && /* @__PURE__ */ jsx(
+                    RepIcon,
+                    {
+                      name: item.icon,
+                      className: "h-4 w-4 shrink-0 text-muted-foreground"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx("span", { className: "truncate", children: item.label })
+                ]
+              },
+              item.slug
+            )) })
+          ] }, sectionName)) })
+        ] })
+      }
+    )
+  ] });
+}
+function SdkHeader({
+  tabs,
+  currentSlug,
+  onNavigate,
+  navSlugs
+}) {
+  const sidebar = useSidebar();
+  const themeMode = useThemeMode();
+  const match = matchSlugPrefix(currentSlug, navSlugs);
+  const baseSlug = match?.matchedSlug ?? normalizeSlug(currentSlug);
+  const themeIcon = themeMode.mode === "dark" ? faMoon : faSun;
+  return /* @__PURE__ */ jsxs("header", { className: "flex h-[52px] shrink-0 items-center gap-2 bg-sidebar px-6", children: [
+    sidebar.isMobile && /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: sidebar.toggleSidebar,
+        className: "mr-2 flex shrink-0 items-center justify-center rounded-md p-2 text-sidebar-foreground hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
+        "aria-label": "Toggle sidebar",
+        children: /* @__PURE__ */ jsx(FontAwesomeIcon, { icon: faBars, className: "size-5" })
+      }
+    ),
+    /* @__PURE__ */ jsx("nav", { className: "scrollbar-none flex flex-1 items-center gap-1 overflow-x-auto", children: tabs.map((tab) => {
+      const tabSlug = normalizeSlug(tab.slug);
+      if (!tabSlug) return null;
+      const isActive = tabSlug === baseSlug;
+      return /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => onNavigate(tabSlug),
+          className: `border-b-2 px-4 py-3 text-sm font-medium whitespace-nowrap transition-colors ${isActive ? "border-primary text-foreground" : "border-transparent text-muted-foreground hover:border-border hover:text-foreground"}`,
+          children: tab.label
+        },
+        tab.id ?? tabSlug
+      );
+    }) }),
+    /* @__PURE__ */ jsx(QuickLinksDropdown, { onNavigate }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: themeMode.cycleMode,
+        className: "ml-2 flex shrink-0 items-center justify-center rounded-md p-2 text-sidebar-foreground hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
+        "aria-label": `Switch theme (current: ${themeMode.mode})`,
+        children: /* @__PURE__ */ jsx(FontAwesomeIcon, { icon: themeIcon, className: "size-3" })
+      }
+    )
+  ] });
+}
+function WidgetRenderer({ widget, index }) {
+  const registry = useRegistry();
+  const Component = registry[widget.type];
+  if (!Component) {
+    console.warn(
+      `[BuilderScreenView] Widget type "${String(widget.type)}" not found in registry`
+    );
+    return null;
+  }
+  if (widget.dataSource) {
+    return /* @__PURE__ */ jsx("div", { className: "h-full w-full overflow-x-hidden", children: /* @__PURE__ */ jsx(DataAwareWidget, { widget, Component }) }, widget.id ?? index);
+  }
+  return /* @__PURE__ */ jsx("div", { className: "h-full w-full overflow-x-hidden", children: /* @__PURE__ */ jsx(Component, { ...widget.props }) }, widget.id ?? index);
+}
+function BuilderScreenViewImpl({ screen, className }) {
+  const widgets = screen.component_tree;
+  if (!widgets || widgets.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: className ?? "h-full w-full", children: /* @__PURE__ */ jsx("div", { className: "flex h-full items-center justify-center text-muted-foreground", children: /* @__PURE__ */ jsx("p", { children: "This screen has no content yet." }) }) });
+  }
+  return /* @__PURE__ */ jsx("div", { className: className ?? "h-full w-full", children: widgets.map((widget, index) => {
+    if (!widget) return null;
+    return /* @__PURE__ */ jsx(
+      WidgetRenderer,
+      {
+        widget,
+        index
+      },
+      widget.id ?? index
+    );
+  }) });
+}
+var BuilderScreenView = memo(BuilderScreenViewImpl);
+var SYSTEM_SLUG_SCREEN_MAP = {
+  messages: MessagingScreen,
+  contacts: ContactsScreen,
+  shop: OrdersScreen,
+  customers: CustomersScreen,
+  products: ProductsScreen
+};
+function PageRouter({
+  currentSlug,
+  currentNavItem,
+  customPages,
+  screens,
+  baseSlug,
+  restParams
+}) {
+  const screenById = useMemo(() => {
+    if (!screens || screens.length === 0) return void 0;
+    return new Map(screens.map((s) => [s.id, s]));
+  }, [screens]);
+  const screenBySlug = useMemo(() => {
+    if (!screens || screens.length === 0) return void 0;
+    return new Map(screens.filter((s) => s.slug).map((s) => [s.slug, s]));
+  }, [screens]);
+  const builderScreen = useMemo(() => {
+    if (currentNavItem?.screen_id && screenById) {
+      const byId = screenById.get(currentNavItem.screen_id);
+      if (byId) return byId;
+    }
+    if (screenBySlug) {
+      return screenBySlug.get(currentSlug) ?? screenBySlug.get(baseSlug) ?? void 0;
+    }
+    return void 0;
+  }, [
+    currentNavItem?.screen_id,
+    screenById,
+    screenBySlug,
+    currentSlug,
+    baseSlug
+  ]);
+  const SystemScreen = SYSTEM_SLUG_SCREEN_MAP[baseSlug];
+  if (SystemScreen) {
+    return /* @__PURE__ */ jsx(SystemScreen, {});
+  }
+  if (isSystemNavigationItem(baseSlug)) {
+    return /* @__PURE__ */ jsx(CoreScreenPlaceholder, { name: currentNavItem?.label ?? baseSlug });
+  }
+  const ExactCustomPage = customPages?.[currentSlug];
+  if (ExactCustomPage) {
+    return /* @__PURE__ */ jsx(ExactCustomPage, { slug: currentSlug, params: restParams });
+  }
+  if (baseSlug !== currentSlug) {
+    const PrefixCustomPage = customPages?.[baseSlug];
+    if (PrefixCustomPage) {
+      return /* @__PURE__ */ jsx(PrefixCustomPage, { slug: currentSlug, params: restParams });
+    }
+  }
+  if (builderScreen) {
+    return /* @__PURE__ */ jsx(BuilderScreenView, { screen: builderScreen });
+  }
+  return /* @__PURE__ */ jsx(CoreScreenPlaceholder, { name: currentNavItem?.label ?? currentSlug });
+}
+var AppNavigationContext = createContext(
+  null
+);
+function AppNavigationProvider({
+  currentSlug,
+  basePath,
+  navigate,
+  children
+}) {
+  const buildHref = useMemo(() => {
+    return (slug) => {
+      if (basePath === "/") return `/${slug}`;
+      return `${basePath}/${slug}`;
+    };
+  }, [basePath]);
+  const value = useMemo(
+    () => ({ currentSlug, basePath, navigate, buildHref }),
+    [currentSlug, basePath, navigate, buildHref]
+  );
+  return /* @__PURE__ */ jsx(AppNavigationContext.Provider, { value, children });
+}
+function useAppNavigation() {
+  const ctx = useContext(AppNavigationContext);
+  if (!ctx) {
+    throw new Error(
+      "useAppNavigation must be used within an <AppShell> or <AppNavigationProvider>"
+    );
+  }
+  return ctx;
+}
+var THEME_STORAGE_KEY = "rep-theme-mode";
+var DEFAULT_NAVIGATION = [
+  { label: "We Commerce", children: [] },
+  { slug: "shop", label: "Shop", icon: "store", children: [] },
+  { slug: "account", label: "Account", icon: "user-gear", children: [] },
+  { slug: "messages", label: "Messaging", icon: "comment", children: [] },
+  { label: "Marketing Assets", children: [] },
+  {
+    slug: "share/products",
+    label: "Products",
+    icon: "boxes-stacked",
+    children: []
+  }
+];
+function getInitialThemeMode() {
+  if (typeof window === "undefined") return "light";
+  const stored = localStorage.getItem(THEME_STORAGE_KEY);
+  if (stored === "light" || stored === "dark") return stored;
+  return "light";
+}
+function findFirstNavigableSlug(items) {
+  for (const item of items) {
+    if (item.slug) return normalizeSlug(item.slug);
+    for (const child of item.children ?? []) {
+      if (child.slug) return normalizeSlug(child.slug);
+    }
+  }
+  return "";
+}
+function findCurrentSection(items, slug) {
+  const normalized = normalizeSlug(slug);
+  for (const item of items) {
+    if (normalizeSlug(item.slug) === normalized) return item;
+    if (item.children?.some((child) => normalizeSlug(child.slug) === normalized)) {
+      return item;
+    }
+  }
+  return void 0;
+}
+function findNavItem(items, slug) {
+  const normalized = normalizeSlug(slug);
+  for (const item of items) {
+    if (normalizeSlug(item.slug) === normalized) return item;
+    for (const child of item.children ?? []) {
+      if (normalizeSlug(child.slug) === normalized) return child;
+    }
+  }
+  return void 0;
+}
+function AppShell({
+  appData: appDataProp,
+  navigation: navigationProp,
+  customPages,
+  basePath = "/",
+  currentSlug: controlledSlug,
+  onNavigate: onNavigateProp,
+  sidebarHeader,
+  sidebarFooter,
+  children
+}) {
+  const normalizedBasePath = useMemo(() => {
+    const stripped = basePath.replace(/^\/|\/$/g, "");
+    return stripped ? `/${stripped}` : "/";
+  }, [basePath]);
+  const { data: fetchedAppData, isLoading: isLoading2 } = useFluidApp({
+    enabled: !appDataProp
+  });
+  const appData = appDataProp ?? fetchedAppData;
+  const activeTheme = useMemo(() => {
+    if (!appData?.profile?.themes?.length) return void 0;
+    const themes = appData.profile.themes;
+    const activeId = appData.profile.activeThemeId;
+    return activeId ? themes.find((t) => t.id === activeId) ?? themes[0] : themes[0];
+  }, [appData?.profile?.themes, appData?.profile?.activeThemeId]);
+  useEffect(() => {
+    if (!activeTheme) return;
+    const resolved = resolveTheme(activeTheme);
+    applyTheme(resolved);
+    return () => {
+      removeAllThemes();
+    };
+  }, [activeTheme]);
+  const navItems = useMemo(() => {
+    if (navigationProp) return navigationProp;
+    const profileNav = appData?.profile?.navigation?.navigation_items;
+    if (profileNav && profileNav.length > 0) return profileNav;
+    return DEFAULT_NAVIGATION;
+  }, [navigationProp, appData?.profile?.navigation?.navigation_items]);
+  const screens = appData?.screens;
+  const navSlugs = useMemo(() => collectNavSlugs(navItems), [navItems]);
+  const [themeMode, setThemeMode] = useState(getInitialThemeMode);
+  const handleThemeModeChange = useCallback((mode) => {
+    setThemeMode(mode);
+    if (typeof window !== "undefined") {
+      localStorage.setItem(THEME_STORAGE_KEY, mode);
+    }
+  }, []);
+  const [pathSlug, setPathSlug] = useState(() => {
+    if (typeof window === "undefined") return "";
+    return extractSlugFromPathname(
+      window.location.pathname,
+      normalizedBasePath
+    );
+  });
+  useEffect(() => {
+    if (controlledSlug !== void 0) return;
+    if (typeof window === "undefined") return;
+    const currentPath = extractSlugFromPathname(
+      window.location.pathname,
+      normalizedBasePath
+    );
+    if (!currentPath) {
+      const firstSlug = findFirstNavigableSlug(navItems);
+      if (firstSlug) {
+        const targetPath = normalizedBasePath === "/" ? `/${firstSlug}` : `${normalizedBasePath}/${firstSlug}`;
+        history.replaceState(null, "", targetPath);
+        setPathSlug(firstSlug);
+      }
+    }
+  }, [navItems, controlledSlug, normalizedBasePath]);
+  useEffect(() => {
+    if (controlledSlug !== void 0) return;
+    const handlePopState = () => {
+      const slug = extractSlugFromPathname(
+        window.location.pathname,
+        normalizedBasePath
+      );
+      setPathSlug(slug);
+    };
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, [controlledSlug, normalizedBasePath]);
+  const activeSlug = controlledSlug ?? pathSlug;
+  const handleNavigate = useCallback(
+    (slug) => {
+      if (onNavigateProp) {
+        onNavigateProp(slug);
+        return;
+      }
+      const targetPath = normalizedBasePath === "/" ? `/${slug}` : `${normalizedBasePath}/${slug}`;
+      history.pushState(null, "", targetPath);
+      setPathSlug(slug);
+    },
+    [onNavigateProp, normalizedBasePath]
+  );
+  const slugMatch = useMemo(
+    () => matchSlugPrefix(activeSlug, navSlugs),
+    [activeSlug, navSlugs]
+  );
+  const baseSlug = slugMatch?.matchedSlug ?? normalizeSlug(activeSlug);
+  const restParams = slugMatch?.rest ?? "";
+  const currentSection = findCurrentSection(navItems, baseSlug);
+  const secondLevelTabs = currentSection?.children ?? [];
+  const currentNavItem = findNavItem(navItems, baseSlug);
+  const content = typeof children === "function" ? children({ currentSlug: activeSlug, currentNavItem }) : children ?? /* @__PURE__ */ jsx(
+    PageRouter,
+    {
+      currentSlug: activeSlug,
+      currentNavItem,
+      customPages,
+      screens,
+      baseSlug,
+      restParams
+    }
+  );
+  if (isLoading2 && !appData) {
+    return /* @__PURE__ */ jsx(AppShellLoading, {});
+  }
+  return /* @__PURE__ */ jsx(
+    ThemeModeProvider,
+    {
+      mode: themeMode,
+      onModeChange: handleThemeModeChange,
+      autoModeEnabled: false,
+      children: /* @__PURE__ */ jsx(
+        AppNavigationProvider,
+        {
+          currentSlug: activeSlug,
+          basePath: normalizedBasePath,
+          navigate: handleNavigate,
+          children: /* @__PURE__ */ jsx(
+            "div",
+            {
+              "data-theme": activeTheme?.id,
+              "data-theme-mode": themeMode === "auto" ? void 0 : themeMode,
+              children: /* @__PURE__ */ jsx(
+                AppShellLayout,
+                {
+                  sidebarContent: /* @__PURE__ */ jsx(
+                    SdkNavigation,
+                    {
+                      navItems,
+                      currentSlug: activeSlug,
+                      onNavigate: handleNavigate,
+                      navSlugs
+                    }
+                  ),
+                  headerContent: /* @__PURE__ */ jsx(
+                    SdkHeader,
+                    {
+                      tabs: secondLevelTabs,
+                      currentSlug: activeSlug,
+                      onNavigate: handleNavigate,
+                      navSlugs
+                    }
+                  ),
+                  sidebarHeader,
+                  sidebarFooter,
+                  children: content
+                }
+              )
+            }
+          )
+        }
+      )
+    }
+  );
+}
+var AppLink = forwardRef(
+  function AppLink2({ to, onClick, children, ...rest }, ref) {
+    const { navigate, buildHref } = useAppNavigation();
+    const handleClick = (e) => {
+      onClick?.(e);
+      if (e.defaultPrevented) return;
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      if (e.button !== 0) return;
+      if (rest.target && rest.target !== "_self") return;
+      e.preventDefault();
+      navigate(to);
+    };
+    return /* @__PURE__ */ jsx("a", { ref, href: buildHref(to), onClick: handleClick, ...rest, children });
+  }
+);
+var export_DEFAULT_COLORS = themes_exports.DEFAULT_COLORS;
+var export_DEFAULT_FONT_FAMILIES = themes_exports.DEFAULT_FONT_FAMILIES;
+var export_DEFAULT_FONT_SIZES = themes_exports.DEFAULT_FONT_SIZES;
+var export_DEFAULT_RADII = themes_exports.DEFAULT_RADII;
+var export_DEFAULT_SPACING = themes_exports.DEFAULT_SPACING;
+var export_DEFAULT_THEME_ID = themes_exports.DEFAULT_THEME_ID;
+var export_DEFAULT_THEME_NAME = themes_exports.DEFAULT_THEME_NAME;
+var export_FONT_FAMILY_KEYS = themes_exports.FONT_FAMILY_KEYS;
+var export_FONT_SIZE_KEYS = themes_exports.FONT_SIZE_KEYS;
+var export_RADIUS_KEYS = themes_exports.RADIUS_KEYS;
+var export_SEMANTIC_COLOR_NAMES = themes_exports.SEMANTIC_COLOR_NAMES;
+var export_SHADE_STEPS = themes_exports.SHADE_STEPS;
+var export_applyTheme = themes_exports.applyTheme;
+var export_deriveDarkVariant = themes_exports.deriveDarkVariant;
+var export_deserialiseTheme = themes_exports.deserialiseTheme;
+var export_generateShades = themes_exports.generateShades;
+var export_generateThemeCSS = themes_exports.generateThemeCSS;
+var export_getDefaultThemeDefinition = themes_exports.getDefaultThemeDefinition;
+var export_getForegroundColor = themes_exports.getForegroundColor;
+var export_mergeDarkOverrides = themes_exports.mergeDarkOverrides;
+var export_parseColor = themes_exports.parseColor;
+var export_removeAllThemes = themes_exports.removeAllThemes;
+var export_removeTheme = themes_exports.removeTheme;
+var export_resolveTheme = themes_exports.resolveTheme;
+var export_serialiseTheme = themes_exports.serialiseTheme;
 
-export { ACTIVITY_SLUGS, AUTH_CONSTANTS, ApiError, AuthError, AuthLoading, export_BUILT_IN_THEMES as BUILT_IN_THEMES, export_CORE_COLOR_KEYS as CORE_COLOR_KEYS, CORE_PAGE_IDS, CURRENT_REP_QUERY_KEY, DEFAULT_AUTH_URL, export_DEFAULT_CORE_COLORS as DEFAULT_CORE_COLORS, FluidAuthProvider, FluidProvider, FluidThemeProvider, PAGE_CATEGORIES, PERMISSIONS_QUERY_KEY, PROFILE_QUERY_KEY, PageTemplateProvider, PageTemplateRegistry, RequireAuth, STORAGE_KEYS, URL_PARAMS, USER_TYPES, export_catppuccinMocha as catppuccinMocha, export_clampChroma as clampChroma, cleanTokenFromUrl, clearTokens, createDefaultAuthRedirect, createFluidClient, decodeToken, export_defaultTheme as defaultTheme, export_detectThemeMode as detectThemeMode, export_dracula as dracula, export_everforest as everforest, extractAllTokensFromUrl, extractCompanyTokenFromUrl, extractTokenFromUrl, export_generateColorSwatches as generateColorSwatches, export_generateDualTheme as generateDualTheme, export_generateSmartDualTheme as generateSmartDualTheme, export_generateTheme as generateTheme, export_generateThemeCssVars as generateThemeCssVars, getAvailablePageTemplates, getCorePageTemplates, getOptionalPageTemplates, getProperty, getStoredToken, getTokenExpiration, getTokenTimeRemaining, export_gruvbox as gruvbox, hasData, hasStoredToken, hasTokenInUrl, isActivitySlug, isApiError, isContactStatus, isErrorResult, isIdle, isLoading, isTokenExpired, isUserType, isValidToken, export_mod as mod, export_monokai as monokai, export_nord as nord, export_oklchString as oklchString, export_parseOklch as parseOklch, resolveNavigationPages, export_rosePine as rosePine, export_rotateHue as rotateHue, export_rotateSoft as rotateSoft, screenPropertySchemas, selectProperty, export_solarized as solarized, storeToken, export_toDarkMode as toDarkMode, export_toLightMode as toLightMode, export_tokyoNight as tokyoNight, useActivities, useCalendarEvents, useCatchUps, useContact, useContacts, useConversationMessages, useConversations, useCurrentRep, useFluidApi, useFluidAuth, useFluidAuthContext, useFluidContext, useFluidPermissions, useFluidProfile, useFluidTheme, useMySite, usePageTemplates, useResolvedPages, useThemeContext, useTodos, validateNavigationPages, validateToken };
+export { ACTIVITY_SLUGS, APP_DATA_QUERY_KEY, AppLink, AppNavigationProvider, AppShell, AuthError, AuthLoading, BuilderScreenView, CORE_PAGE_IDS, CURRENT_REP_QUERY_KEY, export_DEFAULT_COLORS as DEFAULT_COLORS, export_DEFAULT_FONT_FAMILIES as DEFAULT_FONT_FAMILIES, export_DEFAULT_FONT_SIZES as DEFAULT_FONT_SIZES, export_DEFAULT_RADII as DEFAULT_RADII, export_DEFAULT_SPACING as DEFAULT_SPACING, export_DEFAULT_THEME_ID as DEFAULT_THEME_ID, export_DEFAULT_THEME_NAME as DEFAULT_THEME_NAME, export_FONT_FAMILY_KEYS as FONT_FAMILY_KEYS, export_FONT_SIZE_KEYS as FONT_SIZE_KEYS, PAGE_CATEGORIES, PERMISSIONS_QUERY_KEY, PROFILE_QUERY_KEY, PageRouter, PageTemplateProvider, PageTemplateRegistry, QuickLinksDropdown, export_RADIUS_KEYS as RADIUS_KEYS, RequireAuth, export_SEMANTIC_COLOR_NAMES as SEMANTIC_COLOR_NAMES, export_SHADE_STEPS as SHADE_STEPS, SdkHeader, SdkNavigation, export_applyTheme as applyTheme, collectNavSlugs, export_deriveDarkVariant as deriveDarkVariant, export_deserialiseTheme as deserialiseTheme, extractSlugFromPathname, export_generateShades as generateShades, export_generateThemeCSS as generateThemeCSS, getAvailablePageTemplates, getCorePageTemplates, export_getDefaultThemeDefinition as getDefaultThemeDefinition, export_getForegroundColor as getForegroundColor, getOptionalPageTemplates, getProperty, hasData, isActivitySlug, isContactStatus, isErrorResult, isIdle, isLoading, isSlugInSection, matchSlugPrefix, export_mergeDarkOverrides as mergeDarkOverrides, export_parseColor as parseColor, export_removeAllThemes as removeAllThemes, export_removeTheme as removeTheme, resolveNavigationPages, export_resolveTheme as resolveTheme, screenPropertySchemas, selectProperty, export_serialiseTheme as serialiseTheme, useActivities, useAppNavigation, useCalendarEvents, useCatchUps, useContact, useContacts, useConversationMessages, useConversations, useCurrentRep, useFluidApp, useFluidAuth, useFluidPermissions, useFluidProfile, useFluidTheme, useMySite, usePageTemplates, useResolvedPages, useTodos, validateNavigationPages };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map