@fluid-app/rep-sdk 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -1,967 +1,32 @@
 'use strict';
 
-var chunkJZRNKSKT_cjs = require('./chunk-JZRNKSKT.cjs');
-var chunkMEOOAMH2_cjs = require('./chunk-MEOOAMH2.cjs');
-var chunkYII3IXF4_cjs = require('./chunk-YII3IXF4.cjs');
-var chunkMBUCXIUN_cjs = require('./chunk-MBUCXIUN.cjs');
-var chunkQUVJ3R4T_cjs = require('./chunk-QUVJ3R4T.cjs');
-var chunkDEQ3PBVX_cjs = require('./chunk-DEQ3PBVX.cjs');
+var chunkV3IMQZIG_cjs = require('./chunk-V3IMQZIG.cjs');
+var chunkEOXYOOWS_cjs = require('./chunk-EOXYOOWS.cjs');
+var chunkFG2CI6HA_cjs = require('./chunk-FG2CI6HA.cjs');
+var chunkMHPK7YQ2_cjs = require('./chunk-MHPK7YQ2.cjs');
+var chunk5UBEM3AX_cjs = require('./chunk-5UBEM3AX.cjs');
+var chunkB6S6BEPL_cjs = require('./chunk-B6S6BEPL.cjs');
+require('./chunk-HDQ2JUQT.cjs');
 var react = require('react');
-var reactQuery = require('@tanstack/react-query');
 var jsxRuntime = require('react/jsx-runtime');
-var jose = require('jose');
+var reactQuery = require('@tanstack/react-query');
 var types = require('@fluid-app/rep-core/types');
-var theme_star = require('@fluid-app/rep-core/theme');
 var widgets = require('@fluid-app/rep-widgets/widgets');
 var widgetUtils = require('@fluid-app/rep-core/widget-utils');
 var registries = require('@fluid-app/rep-core/registries');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var theme_star__namespace = /*#__PURE__*/_interopNamespace(theme_star);
-
-// 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();
-      return null;
-    }
-    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 = react.createContext(null);
-function applyThemeVariables(theme, container) {
-  const target = container ?? document.documentElement;
-  const toRemove = [];
-  for (let i = 0; i < target.style.length; i++) {
-    const prop = target.style[i];
-    if (prop.startsWith("--fluid-")) {
-      toRemove.push(prop);
-    }
-  }
-  for (const prop of toRemove) {
-    target.style.removeProperty(prop);
-  }
-  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] = react.useState(
-    initialTheme ?? null
-  );
-  react.useEffect(() => {
-    if (currentTheme) {
-      applyThemeVariables(currentTheme, container ?? null);
-    }
-  }, [currentTheme, container]);
-  const setTheme = react.useCallback((theme) => {
-    setCurrentTheme(theme);
-  }, []);
-  const setThemeMode = react.useCallback((mode) => {
-    setCurrentTheme((prev) => prev ? { ...prev, mode } : null);
-  }, []);
-  const value = react.useMemo(
-    () => ({
-      currentTheme,
-      setTheme,
-      setThemeMode
-    }),
-    [currentTheme, setTheme, setThemeMode]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(ThemeContext.Provider, { value, children });
-}
-function useThemeContext() {
-  const context = react.useContext(ThemeContext);
-  if (!context) {
-    throw new Error("useThemeContext must be used within a FluidThemeProvider");
-  }
-  return context;
-}
-var FluidContext = react.createContext(null);
-function FluidProvider({
-  config,
-  children,
-  queryClient,
-  initialTheme,
-  themeContainer
-}) {
-  const defaultQueryClient = react.useMemo(
-    () => new reactQuery.QueryClient({
-      defaultOptions: {
-        queries: {
-          staleTime: 1e3 * 60,
-          // 1 minute
-          retry: 1
-        }
-      }
-    }),
-    []
-  );
-  const configRef = react.useRef(config);
-  configRef.current = config;
-  const client = react.useMemo(
-    () => createFluidClient({
-      ...configRef.current,
-      getAuthToken: () => configRef.current.getAuthToken?.() ?? null,
-      onAuthError: () => configRef.current.onAuthError?.()
-    }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [config.baseUrl]
-  );
-  const contextValue = react.useMemo(
-    () => ({ client, config: configRef.current }),
-    [client]
-  );
-  const themeProviderProps = {
-    ...initialTheme !== void 0 && { initialTheme },
-    ...themeContainer !== void 0 && { container: themeContainer }
-  };
-  return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClient ?? defaultQueryClient, children: /* @__PURE__ */ jsxRuntime.jsx(FluidContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(FluidThemeProvider, { ...themeProviderProps, children }) }) });
-}
-function useFluidContext() {
-  const context = react.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/browser-utils.ts
-function isBrowser() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-
-// src/auth/url-token.ts
-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 parseCookies() {
-  if (!isBrowser()) {
-    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 (!isBrowser()) {
-    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 (!isBrowser()) {
-    return;
-  }
-  document.cookie = `${name}=; path=${path}; max-age=0`;
-}
-function getStoredToken(config) {
-  if (!isBrowser()) {
-    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 (!isBrowser()) {
-    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 (!isBrowser()) {
-    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;
-}
-
-// 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/token-utils.ts
-function extractPayloadFromJose(decoded) {
-  const rawUserType = decoded.user_type;
-  const rawOgUserType = decoded.og_user_type;
-  return {
-    id: typeof decoded.id === "number" ? decoded.id : void 0,
-    email: typeof decoded.email === "string" ? decoded.email : void 0,
-    full_name: typeof decoded.full_name === "string" ? decoded.full_name : void 0,
-    user_type: typeof rawUserType === "string" && isUserType(rawUserType) ? rawUserType : "rep",
-    og_user_type: typeof rawOgUserType === "string" && isUserType(rawOgUserType) ? rawOgUserType : void 0,
-    company_id: typeof decoded.company_id === "number" ? decoded.company_id : void 0,
-    exp: decoded.exp,
-    auth_type: typeof decoded.auth_type === "string" ? decoded.auth_type : void 0
-  };
-}
-function decodeToken(token) {
-  try {
-    const decoded = jose.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 = jose.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 = jose.decodeJwt(token);
-    if (!decoded.exp) {
-      return null;
-    }
-    return new Date(decoded.exp * 1e3);
-  } catch {
-    return null;
-  }
-}
-function getTokenTimeRemaining(token) {
-  try {
-    const decoded = jose.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 = jose.createRemoteJWKSet(new URL(jwksUrl));
-    const { payload } = await jose.jwtVerify(token, JWKS);
-    const decoded = payload;
-    return extractPayloadFromJose(decoded);
-  } catch (error) {
-    console.error("[FluidAuth] JWT signature verification failed:", error);
-    return null;
-  }
-}
-
-// src/auth/dev-utils.ts
-function isDevBypassActive(devBypass) {
-  if (!devBypass) return false;
-  try {
-    return undefined.DEV === true;
-  } catch {
-    return false;
-  }
-}
-function createDevUser() {
-  return {
-    id: 99999,
-    // Dev placeholder — avoids falsy 0
-    email: "dev@localhost",
-    full_name: "Dev User",
-    user_type: USER_TYPES.rep,
-    og_user_type: void 0,
-    company_id: 99999,
-    // Dev placeholder — avoids falsy 0
-    exp: void 0,
-    // Never expires
-    auth_type: "dev_bypass"
-  };
-}
-var FluidAuthContext = react.createContext(null);
-function FluidAuthProvider({
-  children,
-  config
-}) {
-  const configRef = react.useRef(config);
-  configRef.current = config;
-  const [isLoading2, setIsLoading] = react.useState(true);
-  const [token, setToken] = react.useState(null);
-  const [user, setUser] = react.useState(null);
-  const [error, setError] = react.useState(null);
-  react.useEffect(() => {
-    const initializeAuth = async () => {
-      const handleAuthFailure = () => {
-        const current = configRef.current;
-        const handler = resolveAuthFailureHandler(current?.onAuthFailure, current?.authUrl);
-        handler();
-      };
-      try {
-        if (isDevBypassActive(config?.devBypass)) {
-          const envToken = undefined.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 = react.useCallback(() => {
-    clearTokens(configRef.current);
-    setToken(null);
-    setUser(null);
-    setError(null);
-  }, []);
-  const contextValue = react.useMemo(
-    () => ({
-      isAuthenticated: user !== null,
-      isLoading: isLoading2,
-      user,
-      token,
-      clearAuth,
-      error
-    }),
-    [token, isLoading2, user, clearAuth, error]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(FluidAuthContext.Provider, { value: contextValue, children });
-}
-function useFluidAuthContext() {
-  const context = react.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;
-}
+var AppShellLayout = require('@fluid-app/rep-core/shell/AppShellLayout');
+var ThemeModeContext = require('@fluid-app/rep-core/shell/ThemeModeContext');
+var systemNavigationItems = require('@fluid-app/rep-core/navigation/system-navigation-items');
+var theme = require('@fluid-app/rep-core/theme');
+var sidebar = require('@fluid-app/rep-core/shell/sidebar');
+var RepIcon = require('@fluid-app/rep-core/components/RepIcon');
+var reactFontawesome = require('@fortawesome/react-fontawesome');
+var faBars = require('@fortawesome/pro-regular-svg-icons/faBars');
+var faSun = require('@fortawesome/pro-regular-svg-icons/faSun');
+var faMoon = require('@fortawesome/pro-regular-svg-icons/faMoon');
+var faTableCellsLarge = require('@fortawesome/pro-regular-svg-icons/faTableCellsLarge');
+var DataAwareWidget = require('@fluid-app/rep-core/data-sources/DataAwareWidget');
+var contexts = require('@fluid-app/rep-widgets/contexts');
 
 // src/types/page-template.ts
 var PAGE_CATEGORIES = {
@@ -1158,100 +223,650 @@ function resolveNavigationPages(navigation) {
   }
   return result;
 }
-function getAvailablePageTemplates() {
-  return PageTemplateRegistry.listAll();
+function getAvailablePageTemplates() {
+  return PageTemplateRegistry.listAll();
+}
+function getCorePageTemplates() {
+  return PageTemplateRegistry.listCore();
+}
+function getOptionalPageTemplates() {
+  return PageTemplateRegistry.listOptional();
+}
+function validateNavigationPages(navigation) {
+  const corePages = PageTemplateRegistry.listCore();
+  const referencedTemplateIds = new Set(
+    navigation.page_refs?.map((ref) => ref.page_template_id) ?? []
+  );
+  const missingCorePages = corePages.filter((page) => !referencedTemplateIds.has(page.id)).map((page) => page.id);
+  return {
+    valid: missingCorePages.length === 0,
+    missingCorePages
+  };
+}
+var EMPTY_TEMPLATES = [];
+var PageTemplateContext = react.createContext(
+  null
+);
+function PageTemplateProvider({
+  children,
+  templates = EMPTY_TEMPLATES
+}) {
+  const registeredIds = react.useRef([]);
+  const templateKey = templates.map((t) => t.id).join(",");
+  react.useEffect(() => {
+    const registered = [];
+    for (const template of templates) {
+      if (!PageTemplateRegistry.has(template.id)) {
+        try {
+          PageTemplateRegistry.register(template);
+          registered.push(template.id);
+        } catch (error) {
+          console.warn(
+            `Failed to register page template "${template.id}":`,
+            error
+          );
+        }
+      }
+    }
+    registeredIds.current = registered;
+    return () => {
+      for (const id of registeredIds.current) {
+        PageTemplateRegistry.unregister(id);
+      }
+      registeredIds.current = [];
+    };
+  }, [templateKey]);
+  const contextValue = react.useMemo(
+    () => ({
+      resolvePages: resolveNavigationPages,
+      listTemplates: () => PageTemplateRegistry.listAll(),
+      getTemplate: (id) => PageTemplateRegistry.get(id),
+      hasTemplate: (id) => PageTemplateRegistry.has(id)
+    }),
+    []
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(PageTemplateContext.Provider, { value: contextValue, children });
+}
+function usePageTemplates() {
+  const context = react.useContext(PageTemplateContext);
+  if (!context) {
+    throw new Error(
+      "usePageTemplates must be used within a PageTemplateProvider"
+    );
+  }
+  return context;
+}
+function useResolvedPages(navigation) {
+  const { resolvePages } = usePageTemplates();
+  return react.useMemo(() => resolvePages(navigation), [resolvePages, navigation]);
+}
+var PROFILE_QUERY_KEY = ["fluid", "profile"];
+function useFluidProfile() {
+  const api = chunkV3IMQZIG_cjs.useFluidApi();
+  return reactQuery.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 getCorePageTemplates() {
-  return PageTemplateRegistry.listCore();
+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);
+      }
+    };
+    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 getOptionalPageTemplates() {
-  return PageTemplateRegistry.listOptional();
+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;
+    }
+  }
 }
-function validateNavigationPages(navigation) {
-  const corePages = PageTemplateRegistry.listCore();
-  const referencedTemplateIds = new Set(
-    navigation.page_refs?.map((ref) => ref.page_template_id) ?? []
-  );
-  const missingCorePages = corePages.filter((page) => !referencedTemplateIds.has(page.id)).map((page) => page.id);
-  return {
-    valid: missingCorePages.length === 0,
-    missingCorePages
-  };
+function getDb() {
+  if (dbPromise) return dbPromise;
+  dbPromise = getDbWithRecovery().catch((err) => {
+    dbPromise = null;
+    throw err;
+  });
+  return dbPromise;
 }
-var EMPTY_TEMPLATES = [];
-var PageTemplateContext = react.createContext(
-  null
-);
-function PageTemplateProvider({
-  children,
-  templates = EMPTY_TEMPLATES
-}) {
-  const registeredIds = react.useRef([]);
-  const templateKey = templates.map((t) => t.id).join(",");
-  react.useEffect(() => {
-    const registered = [];
-    for (const template of templates) {
-      if (!PageTemplateRegistry.has(template.id)) {
+var storage = {
+  async getItem(key) {
+    try {
+      const db = await getDb();
+      return new Promise((res) => {
         try {
-          PageTemplateRegistry.register(template);
-          registered.push(template.id);
-        } catch (error) {
-          console.warn(
-            `Failed to register page template "${template.id}":`,
-            error
-          );
+          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;
     }
-    registeredIds.current = registered;
-    return () => {
-      for (const id of registeredIds.current) {
-        PageTemplateRegistry.unregister(id);
+  },
+  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);
       }
-      registeredIds.current = [];
-    };
-  }, [templateKey]);
-  const contextValue = react.useMemo(
-    () => ({
-      resolvePages: resolveNavigationPages,
-      listTemplates: () => PageTemplateRegistry.listAll(),
-      getTemplate: (id) => PageTemplateRegistry.get(id),
-      hasTemplate: (id) => PageTemplateRegistry.has(id)
-    }),
-    []
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(PageTemplateContext.Provider, { value: contextValue, children });
-}
-function usePageTemplates() {
-  const context = react.useContext(PageTemplateContext);
-  if (!context) {
-    throw new Error(
-      "usePageTemplates must be used within a PageTemplateProvider"
-    );
+    }
+  },
+  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);
+      }
+    }
   }
-  return context;
-}
-function useResolvedPages(navigation) {
-  const { resolvePages } = usePageTemplates();
-  return react.useMemo(() => resolvePages(navigation), [resolvePages, navigation]);
+};
+function createPersister() {
+  return experimental_createQueryPersister({
+    storage,
+    serialize: (persistedQuery) => persistedQuery,
+    deserialize: (cached) => cached
+  });
 }
 
-// src/hooks/use-fluid-api.ts
-function useFluidApi() {
-  const { client } = useFluidContext();
-  return client;
-}
-var PROFILE_QUERY_KEY = ["fluid", "profile"];
-function useFluidProfile() {
-  const api = useFluidApi();
+// 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 = chunkV3IMQZIG_cjs.useFluidApi();
   return reactQuery.useQuery({
-    queryKey: PROFILE_QUERY_KEY,
-    queryFn: () => api.profile.get()
+    queryKey: APP_DATA_QUERY_KEY,
+    queryFn: () => api.app.getRaw(),
+    select: chunkV3IMQZIG_cjs.transformManifestToRepAppData,
+    ...appDataPersister && { persister: appDataPersister.persisterFn },
+    ...options?.enabled !== void 0 && { enabled: options.enabled }
   });
 }
 var PERMISSIONS_QUERY_KEY = ["fluid", "permissions"];
 function useFluidPermissions() {
-  const api = useFluidApi();
+  const api = chunkV3IMQZIG_cjs.useFluidApi();
   const query = reactQuery.useQuery({
     queryKey: PERMISSIONS_QUERY_KEY,
     queryFn: () => api.permissions.get()
@@ -1283,17 +898,17 @@ function useFluidPermissions() {
 
 // src/hooks/use-fluid-theme.ts
 function useFluidTheme() {
-  const { currentTheme, setTheme, setThemeMode } = useThemeContext();
+  const { currentTheme, setTheme, setThemeMode, mode } = chunkV3IMQZIG_cjs.useThemeContext();
   return {
     currentTheme,
     setTheme,
     setThemeMode,
-    mode: currentTheme?.mode
+    mode
   };
 }
 var CURRENT_REP_QUERY_KEY = ["fluid", "currentRep"];
 function useCurrentRep() {
-  const api = useFluidApi();
+  const api = chunkV3IMQZIG_cjs.useFluidApi();
   return reactQuery.useQuery({
     queryKey: CURRENT_REP_QUERY_KEY,
     queryFn: () => api.reps.current()
@@ -1302,7 +917,7 @@ function useCurrentRep() {
 
 // src/hooks/use-fluid-auth.ts
 function useFluidAuth() {
-  return useFluidAuthContext();
+  return chunkV3IMQZIG_cjs.useFluidAuthContext();
 }
 
 // src/hooks/demo-data/calendar-events.ts
@@ -2032,17 +1647,13 @@ function RequireAuth({
   return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
 }
 
-// src/themes/index.ts
-var themes_exports = {};
-chunkDEQ3PBVX_cjs.__reExport(themes_exports, theme_star__namespace);
-
 // src/screens/index.ts
 var screenPropertySchemas = {
-  MessagingScreen: () => import('./MessagingScreen-UCVLYWZB.cjs').then((m) => m.messagingScreenPropertySchema),
-  ContactsScreen: () => import('./ContactsScreen-XZOQJVFE.cjs').then((m) => m.contactsScreenPropertySchema),
-  OrdersScreen: () => import('./OrdersScreen-WNT2WDLI.cjs').then((m) => m.ordersScreenPropertySchema),
-  CustomersScreen: () => import('./CustomersScreen-53SXRDDK.cjs').then((m) => m.customersScreenPropertySchema),
-  ProductsScreen: () => import('./ProductsScreen-CTIAKS3Z.cjs').then((m) => m.productsScreenPropertySchema)
+  MessagingScreen: () => import('./MessagingScreen-UPFXQZV3.cjs').then((m) => m.messagingScreenPropertySchema),
+  ContactsScreen: () => import('./ContactsScreen-ATASCZO2.cjs').then((m) => m.contactsScreenPropertySchema),
+  OrdersScreen: () => import('./OrdersScreen-X7FYUROL.cjs').then((m) => m.ordersScreenPropertySchema),
+  CustomersScreen: () => import('./CustomersScreen-XMPMKSQA.cjs').then((m) => m.customersScreenPropertySchema),
+  ProductsScreen: () => import('./ProductsScreen-4ZIUQNUU.cjs').then((m) => m.productsScreenPropertySchema)
 };
 var CORE_PAGE_IDS = {
   MESSAGING: "core-messaging",
@@ -2063,154 +1674,934 @@ function registerCorePageTemplates() {
     isCore: true,
     component_tree: [
       {
-        type: "MessagingScreen",
-        id: "messaging-screen-root",
-        props: {}
+        type: "MessagingScreen",
+        id: "messaging-screen-root",
+        props: {}
+      }
+    ],
+    defaultProps: {}
+  });
+  PageTemplateRegistry.register({
+    id: CORE_PAGE_IDS.CONTACTS,
+    slug: "contacts",
+    name: "Contacts",
+    description: "Contact management provided by Fluid Commerce",
+    category: PAGE_CATEGORIES.CORE,
+    tags: ["contacts", "people", "address-book"],
+    version: "1.0.0",
+    isCore: true,
+    component_tree: [
+      {
+        type: "ContactsScreen",
+        id: "contacts-screen-root",
+        props: {}
+      }
+    ],
+    defaultProps: {}
+  });
+  PageTemplateRegistry.register({
+    id: CORE_PAGE_IDS.ORDERS,
+    slug: "orders",
+    name: "Orders",
+    description: "Order management provided by Fluid Commerce",
+    category: PAGE_CATEGORIES.CORE,
+    tags: ["orders", "commerce", "sales"],
+    version: "1.0.0",
+    isCore: true,
+    component_tree: [
+      {
+        type: "OrdersScreen",
+        id: "orders-screen-root",
+        props: {}
+      }
+    ],
+    defaultProps: {}
+  });
+  PageTemplateRegistry.register({
+    id: CORE_PAGE_IDS.CUSTOMERS,
+    slug: "customers",
+    name: "Customers",
+    description: "Customer management provided by Fluid Commerce",
+    category: PAGE_CATEGORIES.CORE,
+    tags: ["customers", "people", "commerce"],
+    version: "1.0.0",
+    isCore: true,
+    component_tree: [
+      {
+        type: "CustomersScreen",
+        id: "customers-screen-root",
+        props: {}
+      }
+    ],
+    defaultProps: {}
+  });
+  PageTemplateRegistry.register({
+    id: CORE_PAGE_IDS.PRODUCTS,
+    slug: "products",
+    name: "Products",
+    description: "Product catalog provided by Fluid Commerce",
+    category: PAGE_CATEGORIES.CORE,
+    tags: ["products", "catalog", "commerce"],
+    version: "1.0.0",
+    isCore: true,
+    component_tree: [
+      {
+        type: "ProductsScreen",
+        id: "products-screen-root",
+        props: {}
+      }
+    ],
+    defaultProps: {}
+  });
+}
+registerCorePageTemplates();
+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() {
+  react.useEffect(() => {
+    ensureSpinStyle2();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              width: "40px",
+              height: "40px",
+              border: "3px solid #e5e7eb",
+              borderTopColor: "#3b82f6",
+              borderRadius: "50%",
+              animation: "spin 1s linear infinite"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.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(systemNavigationItems.normalizeSlug(item.slug));
+    for (const child of item.children ?? []) {
+      if (child.slug) slugs.push(systemNavigationItems.normalizeSlug(child.slug));
+    }
+  }
+  return [...slugs].sort((a, b) => b.split("/").length - a.split("/").length);
+}
+function matchSlugPrefix(fullSlug, navSlugs) {
+  const normalized = systemNavigationItems.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 ?? systemNavigationItems.normalizeSlug(currentSlug);
+  if (systemNavigationItems.normalizeSlug(item.slug) === baseSlug) return true;
+  return item.children?.some((child) => systemNavigationItems.normalizeSlug(child.slug) === baseSlug) ?? false;
+}
+function SdkNavigation({
+  navItems,
+  currentSlug,
+  onNavigate,
+  navSlugs
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(sidebar.SidebarMenu, { children: navItems.map((item, index) => {
+    if (!item.slug && !item.label) return null;
+    if (!item.slug) {
+      return /* @__PURE__ */ jsxRuntime.jsx(sidebar.SidebarGroupLabel, { children: item.label }, item.id ?? `section-${index}`);
+    }
+    const itemSlug = systemNavigationItems.normalizeSlug(item.slug);
+    const isActive = isSlugInSection(item, currentSlug, navSlugs);
+    return /* @__PURE__ */ jsxRuntime.jsx(sidebar.SidebarMenuItem, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+      sidebar.SidebarMenuButton,
+      {
+        isActive,
+        onClick: () => onNavigate(itemSlug),
+        children: [
+          item.icon && /* @__PURE__ */ jsxRuntime.jsx(RepIcon.RepIcon, { name: item.icon }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: item.label })
+        ]
       }
-    ],
-    defaultProps: {}
-  });
-  PageTemplateRegistry.register({
-    id: CORE_PAGE_IDS.CONTACTS,
-    slug: "contacts",
-    name: "Contacts",
-    description: "Contact management provided by Fluid Commerce",
-    category: PAGE_CATEGORIES.CORE,
-    tags: ["contacts", "people", "address-book"],
-    version: "1.0.0",
-    isCore: true,
-    component_tree: [
+    ) }, item.id ?? itemSlug);
+  }) });
+}
+function QuickLinksDropdown({ onNavigate }) {
+  const [open, setOpen] = react.useState(false);
+  const panelRef = react.useRef(null);
+  const buttonRef = react.useRef(null);
+  const close = react.useCallback(() => setOpen(false), []);
+  react.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 = systemNavigationItems.getSystemNavigationBySection();
+  const handleItemClick = (slug) => {
+    onNavigate(slug);
+    close();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
       {
-        type: "ContactsScreen",
-        id: "contacts-screen-root",
-        props: {}
+        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__ */ jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, { icon: faTableCellsLarge.faTableCellsLarge, className: "h-4 w-4" })
       }
-    ],
-    defaultProps: {}
-  });
-  PageTemplateRegistry.register({
-    id: CORE_PAGE_IDS.ORDERS,
-    slug: "orders",
-    name: "Orders",
-    description: "Order management provided by Fluid Commerce",
-    category: PAGE_CATEGORIES.CORE,
-    tags: ["orders", "commerce", "sales"],
-    version: "1.0.0",
-    isCore: true,
-    component_tree: [
+    ),
+    open && /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
       {
-        type: "OrdersScreen",
-        id: "orders-screen-root",
-        props: {}
+        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__ */ jsxRuntime.jsxs("div", { className: "flex flex-col", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 border-b bg-background p-4", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              reactFontawesome.FontAwesomeIcon,
+              {
+                icon: faTableCellsLarge.faTableCellsLarge,
+                className: "h-5 w-5 text-muted-foreground"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-sm font-semibold text-foreground", children: "Shortcuts" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-6 bg-muted p-6", children: Object.entries(sections).map(([sectionName, items]) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-sm font-semibold text-foreground", children: sectionName }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid grid-cols-4 gap-2", children: items.map((item) => /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
+                    RepIcon.RepIcon,
+                    {
+                      name: item.icon,
+                      className: "h-4 w-4 shrink-0 text-muted-foreground"
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: item.label })
+                ]
+              },
+              item.slug
+            )) })
+          ] }, sectionName)) })
+        ] })
       }
-    ],
-    defaultProps: {}
-  });
-  PageTemplateRegistry.register({
-    id: CORE_PAGE_IDS.CUSTOMERS,
-    slug: "customers",
-    name: "Customers",
-    description: "Customer management provided by Fluid Commerce",
-    category: PAGE_CATEGORIES.CORE,
-    tags: ["customers", "people", "commerce"],
-    version: "1.0.0",
-    isCore: true,
-    component_tree: [
+    )
+  ] });
+}
+function SdkHeader({
+  tabs,
+  currentSlug,
+  onNavigate,
+  navSlugs
+}) {
+  const sidebar$1 = sidebar.useSidebar();
+  const themeMode = ThemeModeContext.useThemeMode();
+  const match = matchSlugPrefix(currentSlug, navSlugs);
+  const baseSlug = match?.matchedSlug ?? systemNavigationItems.normalizeSlug(currentSlug);
+  const themeIcon = themeMode.mode === "dark" ? faMoon.faMoon : faSun.faSun;
+  return /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "flex h-[52px] shrink-0 items-center gap-2 bg-sidebar px-6", children: [
+    sidebar$1.isMobile && /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
       {
-        type: "CustomersScreen",
-        id: "customers-screen-root",
-        props: {}
+        type: "button",
+        onClick: sidebar$1.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__ */ jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, { icon: faBars.faBars, className: "size-5" })
       }
-    ],
-    defaultProps: {}
-  });
-  PageTemplateRegistry.register({
-    id: CORE_PAGE_IDS.PRODUCTS,
-    slug: "products",
-    name: "Products",
-    description: "Product catalog provided by Fluid Commerce",
-    category: PAGE_CATEGORIES.CORE,
-    tags: ["products", "catalog", "commerce"],
-    version: "1.0.0",
-    isCore: true,
-    component_tree: [
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("nav", { className: "scrollbar-none flex flex-1 items-center gap-1 overflow-x-auto", children: tabs.map((tab) => {
+      const tabSlug = systemNavigationItems.normalizeSlug(tab.slug);
+      if (!tabSlug) return null;
+      const isActive = tabSlug === baseSlug;
+      return /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(QuickLinksDropdown, { onNavigate }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
       {
-        type: "ProductsScreen",
-        id: "products-screen-root",
-        props: {}
+        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__ */ jsxRuntime.jsx(reactFontawesome.FontAwesomeIcon, { icon: themeIcon, className: "size-3" })
       }
-    ],
-    defaultProps: {}
+    )
+  ] });
+}
+function WidgetRenderer({ widget, index }) {
+  const registry = contexts.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__ */ jsxRuntime.jsx("div", { className: "h-full w-full overflow-x-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(DataAwareWidget.DataAwareWidget, { widget, Component }) }, widget.id ?? index);
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-full w-full overflow-x-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(Component, { ...widget.props }) }, widget.id ?? index);
+}
+function BuilderScreenViewImpl({ screen, className }) {
+  const widgets = screen.component_tree;
+  if (!widgets || widgets.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className ?? "h-full w-full", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex h-full items-center justify-center text-muted-foreground", children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: "This screen has no content yet." }) }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: className ?? "h-full w-full", children: widgets.map((widget, index) => {
+    if (!widget) return null;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      WidgetRenderer,
+      {
+        widget,
+        index
+      },
+      widget.id ?? index
+    );
+  }) });
+}
+var BuilderScreenView = react.memo(BuilderScreenViewImpl);
+var SYSTEM_SLUG_SCREEN_MAP = {
+  messages: chunkV3IMQZIG_cjs.MessagingScreen,
+  contacts: chunkEOXYOOWS_cjs.ContactsScreen,
+  shop: chunkFG2CI6HA_cjs.OrdersScreen,
+  customers: chunkMHPK7YQ2_cjs.CustomersScreen,
+  products: chunk5UBEM3AX_cjs.ProductsScreen
+};
+function PageRouter({
+  currentSlug,
+  currentNavItem,
+  customPages,
+  screens,
+  baseSlug,
+  restParams
+}) {
+  const screenById = react.useMemo(() => {
+    if (!screens || screens.length === 0) return void 0;
+    return new Map(screens.map((s) => [s.id, s]));
+  }, [screens]);
+  const screenBySlug = react.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 = react.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__ */ jsxRuntime.jsx(SystemScreen, {});
+  }
+  if (systemNavigationItems.isSystemNavigationItem(baseSlug)) {
+    return /* @__PURE__ */ jsxRuntime.jsx(chunkB6S6BEPL_cjs.CoreScreenPlaceholder, { name: currentNavItem?.label ?? baseSlug });
+  }
+  const ExactCustomPage = customPages?.[currentSlug];
+  if (ExactCustomPage) {
+    return /* @__PURE__ */ jsxRuntime.jsx(ExactCustomPage, { slug: currentSlug, params: restParams });
+  }
+  if (baseSlug !== currentSlug) {
+    const PrefixCustomPage = customPages?.[baseSlug];
+    if (PrefixCustomPage) {
+      return /* @__PURE__ */ jsxRuntime.jsx(PrefixCustomPage, { slug: currentSlug, params: restParams });
+    }
+  }
+  if (builderScreen) {
+    return /* @__PURE__ */ jsxRuntime.jsx(BuilderScreenView, { screen: builderScreen });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(chunkB6S6BEPL_cjs.CoreScreenPlaceholder, { name: currentNavItem?.label ?? currentSlug });
+}
+var AppNavigationContext = react.createContext(
+  null
+);
+function AppNavigationProvider({
+  currentSlug,
+  basePath,
+  navigate,
+  children
+}) {
+  const buildHref = react.useMemo(() => {
+    return (slug) => {
+      if (basePath === "/") return `/${slug}`;
+      return `${basePath}/${slug}`;
+    };
+  }, [basePath]);
+  const value = react.useMemo(
+    () => ({ currentSlug, basePath, navigate, buildHref }),
+    [currentSlug, basePath, navigate, buildHref]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(AppNavigationContext.Provider, { value, children });
+}
+function useAppNavigation() {
+  const ctx = react.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 systemNavigationItems.normalizeSlug(item.slug);
+    for (const child of item.children ?? []) {
+      if (child.slug) return systemNavigationItems.normalizeSlug(child.slug);
+    }
+  }
+  return "";
+}
+function findCurrentSection(items, slug) {
+  const normalized = systemNavigationItems.normalizeSlug(slug);
+  for (const item of items) {
+    if (systemNavigationItems.normalizeSlug(item.slug) === normalized) return item;
+    if (item.children?.some((child) => systemNavigationItems.normalizeSlug(child.slug) === normalized)) {
+      return item;
+    }
+  }
+  return void 0;
+}
+function findNavItem(items, slug) {
+  const normalized = systemNavigationItems.normalizeSlug(slug);
+  for (const item of items) {
+    if (systemNavigationItems.normalizeSlug(item.slug) === normalized) return item;
+    for (const child of item.children ?? []) {
+      if (systemNavigationItems.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 = react.useMemo(() => {
+    const stripped = basePath.replace(/^\/|\/$/g, "");
+    return stripped ? `/${stripped}` : "/";
+  }, [basePath]);
+  const { data: fetchedAppData, isLoading: isLoading2 } = useFluidApp({
+    enabled: !appDataProp
+  });
+  const appData = appDataProp ?? fetchedAppData;
+  const activeTheme = react.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]);
+  react.useEffect(() => {
+    if (!activeTheme) return;
+    const resolved = theme.resolveTheme(activeTheme);
+    theme.applyTheme(resolved);
+    return () => {
+      theme.removeAllThemes();
+    };
+  }, [activeTheme]);
+  const navItems = react.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 = react.useMemo(() => collectNavSlugs(navItems), [navItems]);
+  const [themeMode, setThemeMode] = react.useState(getInitialThemeMode);
+  const handleThemeModeChange = react.useCallback((mode) => {
+    setThemeMode(mode);
+    if (typeof window !== "undefined") {
+      localStorage.setItem(THEME_STORAGE_KEY, mode);
+    }
+  }, []);
+  const [pathSlug, setPathSlug] = react.useState(() => {
+    if (typeof window === "undefined") return "";
+    return extractSlugFromPathname(
+      window.location.pathname,
+      normalizedBasePath
+    );
   });
+  react.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]);
+  react.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 = react.useCallback(
+    (slug) => {
+      if (onNavigateProp) {
+        onNavigateProp(slug);
+        return;
+      }
+      const targetPath = normalizedBasePath === "/" ? `/${slug}` : `${normalizedBasePath}/${slug}`;
+      history.pushState(null, "", targetPath);
+      setPathSlug(slug);
+    },
+    [onNavigateProp, normalizedBasePath]
+  );
+  const slugMatch = react.useMemo(
+    () => matchSlugPrefix(activeSlug, navSlugs),
+    [activeSlug, navSlugs]
+  );
+  const baseSlug = slugMatch?.matchedSlug ?? systemNavigationItems.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__ */ jsxRuntime.jsx(
+    PageRouter,
+    {
+      currentSlug: activeSlug,
+      currentNavItem,
+      customPages,
+      screens,
+      baseSlug,
+      restParams
+    }
+  );
+  if (isLoading2 && !appData) {
+    return /* @__PURE__ */ jsxRuntime.jsx(AppShellLoading, {});
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ThemeModeContext.ThemeModeProvider,
+    {
+      mode: themeMode,
+      onModeChange: handleThemeModeChange,
+      autoModeEnabled: false,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        AppNavigationProvider,
+        {
+          currentSlug: activeSlug,
+          basePath: normalizedBasePath,
+          navigate: handleNavigate,
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              "data-theme": activeTheme?.id,
+              "data-theme-mode": themeMode === "auto" ? void 0 : themeMode,
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                AppShellLayout.AppShellLayout,
+                {
+                  sidebarContent: /* @__PURE__ */ jsxRuntime.jsx(
+                    SdkNavigation,
+                    {
+                      navItems,
+                      currentSlug: activeSlug,
+                      onNavigate: handleNavigate,
+                      navSlugs
+                    }
+                  ),
+                  headerContent: /* @__PURE__ */ jsxRuntime.jsx(
+                    SdkHeader,
+                    {
+                      tabs: secondLevelTabs,
+                      currentSlug: activeSlug,
+                      onNavigate: handleNavigate,
+                      navSlugs
+                    }
+                  ),
+                  sidebarHeader,
+                  sidebarFooter,
+                  children: content
+                }
+              )
+            }
+          )
+        }
+      )
+    }
+  );
 }
-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 AppLink = react.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__ */ jsxRuntime.jsx("a", { ref, href: buildHref(to), onClick: handleClick, ...rest, children });
+  }
+);
+var export_DEFAULT_COLORS = chunkV3IMQZIG_cjs.themes_exports.DEFAULT_COLORS;
+var export_DEFAULT_FONT_FAMILIES = chunkV3IMQZIG_cjs.themes_exports.DEFAULT_FONT_FAMILIES;
+var export_DEFAULT_FONT_SIZES = chunkV3IMQZIG_cjs.themes_exports.DEFAULT_FONT_SIZES;
+var export_DEFAULT_RADII = chunkV3IMQZIG_cjs.themes_exports.DEFAULT_RADII;
+var export_DEFAULT_SPACING = chunkV3IMQZIG_cjs.themes_exports.DEFAULT_SPACING;
+var export_DEFAULT_THEME_ID = chunkV3IMQZIG_cjs.themes_exports.DEFAULT_THEME_ID;
+var export_DEFAULT_THEME_NAME = chunkV3IMQZIG_cjs.themes_exports.DEFAULT_THEME_NAME;
+var export_FONT_FAMILY_KEYS = chunkV3IMQZIG_cjs.themes_exports.FONT_FAMILY_KEYS;
+var export_FONT_SIZE_KEYS = chunkV3IMQZIG_cjs.themes_exports.FONT_SIZE_KEYS;
+var export_RADIUS_KEYS = chunkV3IMQZIG_cjs.themes_exports.RADIUS_KEYS;
+var export_SEMANTIC_COLOR_NAMES = chunkV3IMQZIG_cjs.themes_exports.SEMANTIC_COLOR_NAMES;
+var export_SHADE_STEPS = chunkV3IMQZIG_cjs.themes_exports.SHADE_STEPS;
+var export_applyTheme = chunkV3IMQZIG_cjs.themes_exports.applyTheme;
+var export_deriveDarkVariant = chunkV3IMQZIG_cjs.themes_exports.deriveDarkVariant;
+var export_deserialiseTheme = chunkV3IMQZIG_cjs.themes_exports.deserialiseTheme;
+var export_generateShades = chunkV3IMQZIG_cjs.themes_exports.generateShades;
+var export_generateThemeCSS = chunkV3IMQZIG_cjs.themes_exports.generateThemeCSS;
+var export_getDefaultThemeDefinition = chunkV3IMQZIG_cjs.themes_exports.getDefaultThemeDefinition;
+var export_getForegroundColor = chunkV3IMQZIG_cjs.themes_exports.getForegroundColor;
+var export_mergeDarkOverrides = chunkV3IMQZIG_cjs.themes_exports.mergeDarkOverrides;
+var export_parseColor = chunkV3IMQZIG_cjs.themes_exports.parseColor;
+var export_removeAllThemes = chunkV3IMQZIG_cjs.themes_exports.removeAllThemes;
+var export_removeTheme = chunkV3IMQZIG_cjs.themes_exports.removeTheme;
+var export_resolveTheme = chunkV3IMQZIG_cjs.themes_exports.resolveTheme;
+var export_serialiseTheme = chunkV3IMQZIG_cjs.themes_exports.serialiseTheme;
 
+Object.defineProperty(exports, "AUTH_CONSTANTS", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.AUTH_CONSTANTS; }
+});
+Object.defineProperty(exports, "ApiError", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.ApiError; }
+});
+Object.defineProperty(exports, "DEFAULT_AUTH_URL", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.DEFAULT_AUTH_URL; }
+});
+Object.defineProperty(exports, "DEFAULT_SDK_WIDGET_REGISTRY", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.DEFAULT_SDK_WIDGET_REGISTRY; }
+});
+Object.defineProperty(exports, "FluidAuthProvider", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.FluidAuthProvider; }
+});
+Object.defineProperty(exports, "FluidProvider", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.FluidProvider; }
+});
+Object.defineProperty(exports, "FluidThemeProvider", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.FluidThemeProvider; }
+});
 Object.defineProperty(exports, "MessagingScreen", {
   enumerable: true,
-  get: function () { return chunkJZRNKSKT_cjs.MessagingScreen; }
+  get: function () { return chunkV3IMQZIG_cjs.MessagingScreen; }
+});
+Object.defineProperty(exports, "STORAGE_KEYS", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.STORAGE_KEYS; }
+});
+Object.defineProperty(exports, "URL_PARAMS", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.URL_PARAMS; }
+});
+Object.defineProperty(exports, "USER_TYPES", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.USER_TYPES; }
+});
+Object.defineProperty(exports, "buildThemeDefinition", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.buildThemeDefinition; }
+});
+Object.defineProperty(exports, "cleanTokenFromUrl", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.cleanTokenFromUrl; }
+});
+Object.defineProperty(exports, "clearTokens", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.clearTokens; }
+});
+Object.defineProperty(exports, "createDefaultAuthRedirect", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.createDefaultAuthRedirect; }
+});
+Object.defineProperty(exports, "createFluidClient", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.createFluidClient; }
+});
+Object.defineProperty(exports, "createFluidFileUploader", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.createFluidFileUploader; }
+});
+Object.defineProperty(exports, "decodeToken", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.decodeToken; }
+});
+Object.defineProperty(exports, "extractAllTokensFromUrl", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.extractAllTokensFromUrl; }
+});
+Object.defineProperty(exports, "extractCompanyTokenFromUrl", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.extractCompanyTokenFromUrl; }
+});
+Object.defineProperty(exports, "extractTokenFromUrl", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.extractTokenFromUrl; }
+});
+Object.defineProperty(exports, "getActiveThemeId", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.getActiveThemeId; }
+});
+Object.defineProperty(exports, "getStoredToken", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.getStoredToken; }
+});
+Object.defineProperty(exports, "getTokenExpiration", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.getTokenExpiration; }
+});
+Object.defineProperty(exports, "getTokenTimeRemaining", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.getTokenTimeRemaining; }
+});
+Object.defineProperty(exports, "hasStoredToken", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.hasStoredToken; }
+});
+Object.defineProperty(exports, "hasTokenInUrl", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.hasTokenInUrl; }
+});
+Object.defineProperty(exports, "isApiError", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.isApiError; }
+});
+Object.defineProperty(exports, "isTokenExpired", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.isTokenExpired; }
+});
+Object.defineProperty(exports, "isUserType", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.isUserType; }
+});
+Object.defineProperty(exports, "isValidToken", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.isValidToken; }
 });
 Object.defineProperty(exports, "messagingScreenPropertySchema", {
   enumerable: true,
-  get: function () { return chunkJZRNKSKT_cjs.messagingScreenPropertySchema; }
+  get: function () { return chunkV3IMQZIG_cjs.messagingScreenPropertySchema; }
+});
+Object.defineProperty(exports, "normalizeComponentTree", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.normalizeComponentTree; }
+});
+Object.defineProperty(exports, "storeToken", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.storeToken; }
+});
+Object.defineProperty(exports, "toNavigationItem", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.toNavigationItem; }
+});
+Object.defineProperty(exports, "toScreenDefinition", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.toScreenDefinition; }
+});
+Object.defineProperty(exports, "transformManifestToRepAppData", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.transformManifestToRepAppData; }
+});
+Object.defineProperty(exports, "transformThemes", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.transformThemes; }
+});
+Object.defineProperty(exports, "useFluidApi", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.useFluidApi; }
+});
+Object.defineProperty(exports, "useFluidAuthContext", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.useFluidAuthContext; }
+});
+Object.defineProperty(exports, "useFluidContext", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.useFluidContext; }
+});
+Object.defineProperty(exports, "useMessagingAuth", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.useMessagingAuth; }
+});
+Object.defineProperty(exports, "useMessagingConfig", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.useMessagingConfig; }
+});
+Object.defineProperty(exports, "useThemeContext", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.useThemeContext; }
+});
+Object.defineProperty(exports, "validateToken", {
+  enumerable: true,
+  get: function () { return chunkV3IMQZIG_cjs.validateToken; }
 });
 Object.defineProperty(exports, "ContactsScreen", {
   enumerable: true,
-  get: function () { return chunkMEOOAMH2_cjs.ContactsScreen; }
+  get: function () { return chunkEOXYOOWS_cjs.ContactsScreen; }
 });
 Object.defineProperty(exports, "contactsScreenPropertySchema", {
   enumerable: true,
-  get: function () { return chunkMEOOAMH2_cjs.contactsScreenPropertySchema; }
+  get: function () { return chunkEOXYOOWS_cjs.contactsScreenPropertySchema; }
 });
 Object.defineProperty(exports, "OrdersScreen", {
   enumerable: true,
-  get: function () { return chunkYII3IXF4_cjs.OrdersScreen; }
+  get: function () { return chunkFG2CI6HA_cjs.OrdersScreen; }
 });
 Object.defineProperty(exports, "ordersScreenPropertySchema", {
   enumerable: true,
-  get: function () { return chunkYII3IXF4_cjs.ordersScreenPropertySchema; }
+  get: function () { return chunkFG2CI6HA_cjs.ordersScreenPropertySchema; }
 });
 Object.defineProperty(exports, "CustomersScreen", {
   enumerable: true,
-  get: function () { return chunkMBUCXIUN_cjs.CustomersScreen; }
+  get: function () { return chunkMHPK7YQ2_cjs.CustomersScreen; }
 });
 Object.defineProperty(exports, "customersScreenPropertySchema", {
   enumerable: true,
-  get: function () { return chunkMBUCXIUN_cjs.customersScreenPropertySchema; }
+  get: function () { return chunkMHPK7YQ2_cjs.customersScreenPropertySchema; }
 });
 Object.defineProperty(exports, "ProductsScreen", {
   enumerable: true,
-  get: function () { return chunkQUVJ3R4T_cjs.ProductsScreen; }
+  get: function () { return chunk5UBEM3AX_cjs.ProductsScreen; }
 });
 Object.defineProperty(exports, "productsScreenPropertySchema", {
   enumerable: true,
-  get: function () { return chunkQUVJ3R4T_cjs.productsScreenPropertySchema; }
+  get: function () { return chunk5UBEM3AX_cjs.productsScreenPropertySchema; }
 });
 Object.defineProperty(exports, "WIDGET_TYPE_NAMES", {
   enumerable: true,
@@ -2420,85 +2811,82 @@ Object.defineProperty(exports, "isPropertyFieldType", {
   enumerable: true,
   get: function () { return registries.isPropertyFieldType; }
 });
+Object.defineProperty(exports, "ThemeModeProvider", {
+  enumerable: true,
+  get: function () { return ThemeModeContext.ThemeModeProvider; }
+});
+Object.defineProperty(exports, "getThemeModeAttribute", {
+  enumerable: true,
+  get: function () { return ThemeModeContext.getThemeModeAttribute; }
+});
+Object.defineProperty(exports, "useThemeMode", {
+  enumerable: true,
+  get: function () { return ThemeModeContext.useThemeMode; }
+});
 exports.ACTIVITY_SLUGS = ACTIVITY_SLUGS;
-exports.AUTH_CONSTANTS = AUTH_CONSTANTS;
-exports.ApiError = ApiError;
+exports.APP_DATA_QUERY_KEY = APP_DATA_QUERY_KEY;
+exports.AppLink = AppLink;
+exports.AppNavigationProvider = AppNavigationProvider;
+exports.AppShell = AppShell;
 exports.AuthError = AuthError;
 exports.AuthLoading = AuthLoading;
-exports.BUILT_IN_THEMES = export_BUILT_IN_THEMES;
-exports.CORE_COLOR_KEYS = export_CORE_COLOR_KEYS;
+exports.BuilderScreenView = BuilderScreenView;
 exports.CORE_PAGE_IDS = CORE_PAGE_IDS;
 exports.CURRENT_REP_QUERY_KEY = CURRENT_REP_QUERY_KEY;
-exports.DEFAULT_AUTH_URL = DEFAULT_AUTH_URL;
-exports.DEFAULT_CORE_COLORS = export_DEFAULT_CORE_COLORS;
-exports.FluidAuthProvider = FluidAuthProvider;
-exports.FluidProvider = FluidProvider;
-exports.FluidThemeProvider = FluidThemeProvider;
+exports.DEFAULT_COLORS = export_DEFAULT_COLORS;
+exports.DEFAULT_FONT_FAMILIES = export_DEFAULT_FONT_FAMILIES;
+exports.DEFAULT_FONT_SIZES = export_DEFAULT_FONT_SIZES;
+exports.DEFAULT_RADII = export_DEFAULT_RADII;
+exports.DEFAULT_SPACING = export_DEFAULT_SPACING;
+exports.DEFAULT_THEME_ID = export_DEFAULT_THEME_ID;
+exports.DEFAULT_THEME_NAME = export_DEFAULT_THEME_NAME;
+exports.FONT_FAMILY_KEYS = export_FONT_FAMILY_KEYS;
+exports.FONT_SIZE_KEYS = export_FONT_SIZE_KEYS;
 exports.PAGE_CATEGORIES = PAGE_CATEGORIES;
 exports.PERMISSIONS_QUERY_KEY = PERMISSIONS_QUERY_KEY;
 exports.PROFILE_QUERY_KEY = PROFILE_QUERY_KEY;
+exports.PageRouter = PageRouter;
 exports.PageTemplateProvider = PageTemplateProvider;
 exports.PageTemplateRegistry = PageTemplateRegistry;
+exports.QuickLinksDropdown = QuickLinksDropdown;
+exports.RADIUS_KEYS = export_RADIUS_KEYS;
 exports.RequireAuth = RequireAuth;
-exports.STORAGE_KEYS = STORAGE_KEYS;
-exports.URL_PARAMS = URL_PARAMS;
-exports.USER_TYPES = USER_TYPES;
-exports.catppuccinMocha = export_catppuccinMocha;
-exports.clampChroma = export_clampChroma;
-exports.cleanTokenFromUrl = cleanTokenFromUrl;
-exports.clearTokens = clearTokens;
-exports.createDefaultAuthRedirect = createDefaultAuthRedirect;
-exports.createFluidClient = createFluidClient;
-exports.decodeToken = decodeToken;
-exports.defaultTheme = export_defaultTheme;
-exports.detectThemeMode = export_detectThemeMode;
-exports.dracula = export_dracula;
-exports.everforest = export_everforest;
-exports.extractAllTokensFromUrl = extractAllTokensFromUrl;
-exports.extractCompanyTokenFromUrl = extractCompanyTokenFromUrl;
-exports.extractTokenFromUrl = extractTokenFromUrl;
-exports.generateColorSwatches = export_generateColorSwatches;
-exports.generateDualTheme = export_generateDualTheme;
-exports.generateSmartDualTheme = export_generateSmartDualTheme;
-exports.generateTheme = export_generateTheme;
-exports.generateThemeCssVars = export_generateThemeCssVars;
+exports.SEMANTIC_COLOR_NAMES = export_SEMANTIC_COLOR_NAMES;
+exports.SHADE_STEPS = export_SHADE_STEPS;
+exports.SdkHeader = SdkHeader;
+exports.SdkNavigation = SdkNavigation;
+exports.applyTheme = export_applyTheme;
+exports.collectNavSlugs = collectNavSlugs;
+exports.deriveDarkVariant = export_deriveDarkVariant;
+exports.deserialiseTheme = export_deserialiseTheme;
+exports.extractSlugFromPathname = extractSlugFromPathname;
+exports.generateShades = export_generateShades;
+exports.generateThemeCSS = export_generateThemeCSS;
 exports.getAvailablePageTemplates = getAvailablePageTemplates;
 exports.getCorePageTemplates = getCorePageTemplates;
+exports.getDefaultThemeDefinition = export_getDefaultThemeDefinition;
+exports.getForegroundColor = export_getForegroundColor;
 exports.getOptionalPageTemplates = getOptionalPageTemplates;
 exports.getProperty = getProperty;
-exports.getStoredToken = getStoredToken;
-exports.getTokenExpiration = getTokenExpiration;
-exports.getTokenTimeRemaining = getTokenTimeRemaining;
-exports.gruvbox = export_gruvbox;
 exports.hasData = hasData;
-exports.hasStoredToken = hasStoredToken;
-exports.hasTokenInUrl = hasTokenInUrl;
 exports.isActivitySlug = isActivitySlug;
-exports.isApiError = isApiError;
 exports.isContactStatus = isContactStatus;
 exports.isErrorResult = isErrorResult;
 exports.isIdle = isIdle;
 exports.isLoading = isLoading;
-exports.isTokenExpired = isTokenExpired;
-exports.isUserType = isUserType;
-exports.isValidToken = isValidToken;
-exports.mod = export_mod;
-exports.monokai = export_monokai;
-exports.nord = export_nord;
-exports.oklchString = export_oklchString;
-exports.parseOklch = export_parseOklch;
+exports.isSlugInSection = isSlugInSection;
+exports.matchSlugPrefix = matchSlugPrefix;
+exports.mergeDarkOverrides = export_mergeDarkOverrides;
+exports.parseColor = export_parseColor;
+exports.removeAllThemes = export_removeAllThemes;
+exports.removeTheme = export_removeTheme;
 exports.resolveNavigationPages = resolveNavigationPages;
-exports.rosePine = export_rosePine;
-exports.rotateHue = export_rotateHue;
-exports.rotateSoft = export_rotateSoft;
+exports.resolveTheme = export_resolveTheme;
 exports.screenPropertySchemas = screenPropertySchemas;
 exports.selectProperty = selectProperty;
-exports.solarized = export_solarized;
-exports.storeToken = storeToken;
-exports.toDarkMode = export_toDarkMode;
-exports.toLightMode = export_toLightMode;
-exports.tokyoNight = export_tokyoNight;
+exports.serialiseTheme = export_serialiseTheme;
 exports.useActivities = useActivities;
+exports.useAppNavigation = useAppNavigation;
 exports.useCalendarEvents = useCalendarEvents;
 exports.useCatchUps = useCatchUps;
 exports.useContact = useContact;
@@ -2506,19 +2894,15 @@ exports.useContacts = useContacts;
 exports.useConversationMessages = useConversationMessages;
 exports.useConversations = useConversations;
 exports.useCurrentRep = useCurrentRep;
-exports.useFluidApi = useFluidApi;
+exports.useFluidApp = useFluidApp;
 exports.useFluidAuth = useFluidAuth;
-exports.useFluidAuthContext = useFluidAuthContext;
-exports.useFluidContext = useFluidContext;
 exports.useFluidPermissions = useFluidPermissions;
 exports.useFluidProfile = useFluidProfile;
 exports.useFluidTheme = useFluidTheme;
 exports.useMySite = useMySite;
 exports.usePageTemplates = usePageTemplates;
 exports.useResolvedPages = useResolvedPages;
-exports.useThemeContext = useThemeContext;
 exports.useTodos = useTodos;
 exports.validateNavigationPages = validateNavigationPages;
-exports.validateToken = validateToken;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map