@fluid-app/rep-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2446 @@
+'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 react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var jsxRuntime = require('react/jsx-runtime');
+var jose = require('jose');
+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/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;
+  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 && onAuthError) {
+      onAuthError();
+    }
+    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;
+  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),
+    // 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/url-token.ts
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function extractTokenFromUrl(tokenKey = URL_PARAMS.USER_TOKEN) {
+  if (!isBrowser()) {
+    return null;
+  }
+  try {
+    const searchParams = new URLSearchParams(window.location.search);
+    return searchParams.get(tokenKey);
+  } catch {
+    return null;
+  }
+}
+function extractCompanyTokenFromUrl(tokenKey = URL_PARAMS.COMPANY_TOKEN) {
+  if (!isBrowser()) {
+    return null;
+  }
+  try {
+    const searchParams = new URLSearchParams(window.location.search);
+    return searchParams.get(tokenKey);
+  } catch {
+    return null;
+  }
+}
+function cleanTokenFromUrl(tokenKey = URL_PARAMS.USER_TOKEN) {
+  if (!isBrowser()) {
+    return;
+  }
+  try {
+    const url = new URL(window.location.href);
+    const hadToken = url.searchParams.has(tokenKey);
+    const hadCompanyToken = url.searchParams.has(URL_PARAMS.COMPANY_TOKEN);
+    url.searchParams.delete(tokenKey);
+    url.searchParams.delete(URL_PARAMS.COMPANY_TOKEN);
+    if (hadToken || hadCompanyToken) {
+      window.history.replaceState(
+        window.history.state,
+        document.title,
+        url.toString()
+      );
+    }
+  } catch (error) {
+    console.warn("[FluidAuth] Failed to clean token from URL:", error);
+  }
+}
+function hasTokenInUrl(tokenKey = URL_PARAMS.USER_TOKEN) {
+  if (!isBrowser()) {
+    return false;
+  }
+  try {
+    const searchParams = new URLSearchParams(window.location.search);
+    return searchParams.has(tokenKey);
+  } catch {
+    return false;
+  }
+}
+function extractAllTokensFromUrl(userTokenKey = URL_PARAMS.USER_TOKEN, companyTokenKey = URL_PARAMS.COMPANY_TOKEN) {
+  if (!isBrowser()) {
+    return { userToken: null, companyToken: null };
+  }
+  try {
+    const searchParams = new URLSearchParams(window.location.search);
+    return {
+      userToken: searchParams.get(userTokenKey),
+      companyToken: searchParams.get(companyTokenKey)
+    };
+  } catch {
+    return { userToken: null, companyToken: null };
+  }
+}
+
+// src/auth/token-storage.ts
+function isBrowser2() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function parseCookies() {
+  if (!isBrowser2()) {
+    return {};
+  }
+  const cookies = {};
+  const cookieString = document.cookie;
+  if (!cookieString) {
+    return cookies;
+  }
+  cookieString.split(";").forEach((cookie) => {
+    const [name, ...valueParts] = cookie.trim().split("=");
+    if (name) {
+      cookies[name] = decodeURIComponent(valueParts.join("="));
+    }
+  });
+  return cookies;
+}
+function setCookie(name, value, options = {}) {
+  if (!isBrowser2()) {
+    return;
+  }
+  const {
+    maxAge = AUTH_CONSTANTS.COOKIE_MAX_AGE,
+    path = "/",
+    sameSite = "lax",
+    secure = window.location.protocol === "https:"
+  } = options;
+  let cookieString = `${name}=${encodeURIComponent(value)}`;
+  cookieString += `; path=${path}`;
+  cookieString += `; max-age=${maxAge}`;
+  cookieString += `; samesite=${sameSite}`;
+  if (secure) {
+    cookieString += "; secure";
+  }
+  document.cookie = cookieString;
+}
+function deleteCookie(name, path = "/") {
+  if (!isBrowser2()) {
+    return;
+  }
+  document.cookie = `${name}=; path=${path}; max-age=0`;
+}
+function getStoredToken(config) {
+  if (!isBrowser2()) {
+    return null;
+  }
+  const cookieKey = config?.cookieKey ?? STORAGE_KEYS.AUTH_COOKIE;
+  const localStorageKey = STORAGE_KEYS.USER_TOKEN;
+  const cookies = parseCookies();
+  const cookieToken = cookies[cookieKey];
+  if (cookieToken) {
+    return cookieToken;
+  }
+  try {
+    return localStorage.getItem(localStorageKey);
+  } catch {
+    return null;
+  }
+}
+function storeToken(token, config) {
+  if (!isBrowser2()) {
+    return;
+  }
+  const cookieKey = config?.cookieKey ?? STORAGE_KEYS.AUTH_COOKIE;
+  const maxAge = config?.cookieMaxAge ?? AUTH_CONSTANTS.COOKIE_MAX_AGE;
+  try {
+    setCookie(cookieKey, token, {
+      maxAge,
+      path: "/",
+      // Use 'none' with secure for cross-origin iframe scenarios
+      sameSite: window.self !== window.top ? "none" : "lax",
+      secure: window.location.protocol === "https:"
+    });
+  } catch (error) {
+    console.warn("[FluidAuth] Failed to store token in cookie:", error);
+  }
+  try {
+    localStorage.setItem(STORAGE_KEYS.USER_TOKEN, token);
+  } catch (error) {
+    console.warn("[FluidAuth] Failed to store token in localStorage:", error);
+  }
+}
+function clearTokens(config) {
+  if (!isBrowser2()) {
+    return;
+  }
+  const cookieKey = config?.cookieKey ?? STORAGE_KEYS.AUTH_COOKIE;
+  try {
+    deleteCookie(cookieKey);
+  } catch {
+  }
+  try {
+    localStorage.removeItem(STORAGE_KEYS.USER_TOKEN);
+    localStorage.removeItem(STORAGE_KEYS.COMPANY_TOKEN);
+  } catch {
+  }
+}
+function hasStoredToken(config) {
+  return getStoredToken(config) !== null;
+}
+function extractPayloadFromJose(decoded) {
+  return {
+    id: decoded.id,
+    email: decoded.email,
+    full_name: decoded.full_name,
+    user_type: decoded.user_type ?? "rep",
+    og_user_type: decoded.og_user_type,
+    company_id: decoded.company_id,
+    exp: decoded.exp,
+    auth_type: decoded.auth_type
+  };
+}
+function decodeToken(token) {
+  try {
+    const decoded = 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/types.ts
+var USER_TYPES = {
+  admin: "admin",
+  rep: "rep",
+  root_admin: "root_admin",
+  customer: "customer"
+};
+function isUserType(value) {
+  return Object.values(USER_TYPES).includes(value);
+}
+
+// src/auth/dev-utils.ts
+function isDevBypassActive(devBypass) {
+  if (!devBypass) return false;
+  try {
+    return undefined.DEV === true;
+  } catch {
+    return false;
+  }
+}
+function createDevUser() {
+  return {
+    id: 0,
+    email: "dev@localhost",
+    full_name: "Dev User",
+    user_type: USER_TYPES.rep,
+    og_user_type: void 0,
+    company_id: 0,
+    exp: void 0,
+    // Never expires
+    auth_type: "dev_bypass"
+  };
+}
+var FluidAuthContext = 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 () => {
+      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);
+        cleanTokenFromUrl(tokenKey);
+        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"));
+              config?.onAuthFailure?.();
+              return;
+            }
+            if (isTokenExpired(candidateToken, config?.gracePeriodMs)) {
+              clearTokens(config);
+              setToken(null);
+              setUser(null);
+              setError(new Error("Token has expired"));
+              config?.onAuthFailure?.();
+              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"));
+              config?.onAuthFailure?.();
+              return;
+            }
+          }
+          storeToken(candidateToken, config);
+          setToken(candidateToken);
+          setUser(payload);
+          setError(null);
+        } else {
+          setToken(null);
+          setUser(null);
+          setError(new Error("No authentication token found"));
+          config?.onAuthFailure?.();
+        }
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Authentication error");
+        setError(error2);
+        setToken(null);
+        setUser(null);
+        config?.onAuthFailure?.();
+      } 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;
+}
+
+// src/types/page-template.ts
+var PAGE_CATEGORIES = {
+  CORE: "core",
+  COMMERCE: "commerce",
+  COMMUNICATION: "communication",
+  DATA: "data",
+  CUSTOM: "custom"
+};
+
+// src/registries/page-template-registry.ts
+var PageTemplateRegistryImpl = class {
+  templates = /* @__PURE__ */ new Map();
+  categories = [];
+  constructor() {
+    this.categories = [
+      { id: PAGE_CATEGORIES.CORE, label: "Core Features", icon: "star" },
+      {
+        id: PAGE_CATEGORIES.COMMERCE,
+        label: "Commerce",
+        icon: "shopping-cart"
+      },
+      {
+        id: PAGE_CATEGORIES.COMMUNICATION,
+        label: "Communication",
+        icon: "message-circle"
+      },
+      {
+        id: PAGE_CATEGORIES.DATA,
+        label: "Data & Analytics",
+        icon: "bar-chart"
+      },
+      { id: PAGE_CATEGORIES.CUSTOM, label: "Custom", icon: "puzzle" }
+    ];
+  }
+  /**
+   * Register a new page template.
+   * @throws Error if a template with the same ID already exists
+   */
+  register(template) {
+    if (this.templates.has(template.id)) {
+      throw new Error(
+        `Page template with ID "${template.id}" is already registered`
+      );
+    }
+    this.templates.set(template.id, template);
+  }
+  /**
+   * Unregister a page template by ID.
+   * Core templates cannot be unregistered.
+   * @returns true if the template was removed, false if it didn't exist or is a core template
+   */
+  unregister(id) {
+    const template = this.templates.get(id);
+    if (!template) {
+      return false;
+    }
+    if (template.isCore) {
+      console.warn(
+        `Cannot unregister core page template "${id}". Core templates are required.`
+      );
+      return false;
+    }
+    return this.templates.delete(id);
+  }
+  /**
+   * Get a page template by ID.
+   */
+  get(id) {
+    return this.templates.get(id);
+  }
+  /**
+   * Get all page templates in a specific category.
+   */
+  getByCategory(category) {
+    return Array.from(this.templates.values()).filter(
+      (t) => t.category === category
+    );
+  }
+  /**
+   * List all registered page templates.
+   */
+  listAll() {
+    return Array.from(this.templates.values());
+  }
+  /**
+   * List all core page templates (isCore: true).
+   */
+  listCore() {
+    return Array.from(this.templates.values()).filter((t) => t.isCore);
+  }
+  /**
+   * List all non-core page templates.
+   */
+  listOptional() {
+    return Array.from(this.templates.values()).filter((t) => !t.isCore);
+  }
+  /**
+   * List all registered categories.
+   */
+  listCategories() {
+    return [...this.categories];
+  }
+  /**
+   * Add a custom category.
+   */
+  addCategory(category) {
+    if (this.categories.some((c) => c.id === category.id)) {
+      console.warn(`Category with ID "${category.id}" already exists`);
+      return;
+    }
+    this.categories.push(category);
+  }
+  /**
+   * Check if a template exists by ID.
+   */
+  has(id) {
+    return this.templates.has(id);
+  }
+  /**
+   * Get the count of registered templates.
+   */
+  get size() {
+    return this.templates.size;
+  }
+  /**
+   * Clear all non-core templates.
+   * Useful for testing or resetting the registry.
+   */
+  clearNonCore() {
+    for (const [id, template] of this.templates) {
+      if (!template.isCore) {
+        this.templates.delete(id);
+      }
+    }
+  }
+};
+var PageTemplateRegistry = new PageTemplateRegistryImpl();
+
+// src/core/resolve-pages.ts
+function applyOverrides(componentTree, overrides) {
+  if (!overrides.length) {
+    return [...componentTree];
+  }
+  const overrideMap = new Map(overrides.map((o) => [o.widget_id, o.props]));
+  return componentTree.map(
+    (widget) => applyWidgetOverrides(widget, overrideMap)
+  );
+}
+function applyWidgetOverrides(widget, overrideMap) {
+  const override = widget.id ? overrideMap.get(widget.id) : void 0;
+  const children = widget.props.children;
+  const hasChildren = Array.isArray(children) && children.length > 0;
+  if (!override && !hasChildren) {
+    return widget;
+  }
+  const newProps = override ? { ...widget.props, ...override } : { ...widget.props };
+  if (hasChildren) {
+    newProps.children = children.map(
+      (child) => applyWidgetOverrides(child, overrideMap)
+    );
+  }
+  return { ...widget, props: newProps };
+}
+function resolvePageReference(ref) {
+  const template = PageTemplateRegistry.get(ref.page_template_id);
+  if (!template) {
+    console.warn(
+      `Page template "${ref.page_template_id}" not found in registry`
+    );
+    return void 0;
+  }
+  const componentTree = ref.overrides ? applyOverrides(template.component_tree, ref.overrides) : [...template.component_tree];
+  return {
+    id: ref.screen_id,
+    slug: template.slug,
+    name: template.name,
+    component_tree: componentTree
+  };
+}
+function resolveNavigationPages(navigation) {
+  const localScreenIds = new Set(navigation.screens.map((s) => s.id));
+  const result = [...navigation.screens];
+  if (navigation.page_refs) {
+    for (const ref of navigation.page_refs) {
+      if (localScreenIds.has(ref.screen_id)) {
+        continue;
+      }
+      const screen = resolvePageReference(ref);
+      if (screen) {
+        result.push(screen);
+      }
+    }
+  }
+  return result;
+}
+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]);
+}
+
+// src/hooks/use-fluid-api.ts
+function useFluidApi() {
+  const { client } = useFluidContext();
+  return client;
+}
+var PROFILE_QUERY_KEY = ["fluid", "profile"];
+function useFluidProfile() {
+  const api = useFluidApi();
+  return reactQuery.useQuery({
+    queryKey: PROFILE_QUERY_KEY,
+    queryFn: () => api.profile.get()
+  });
+}
+var PERMISSIONS_QUERY_KEY = ["fluid", "permissions"];
+function useFluidPermissions() {
+  const api = useFluidApi();
+  const query = reactQuery.useQuery({
+    queryKey: PERMISSIONS_QUERY_KEY,
+    queryFn: () => api.permissions.get()
+  });
+  const permissions = query.data;
+  const can = react.useMemo(() => {
+    return (resource, action = "view") => {
+      if (!permissions) {
+        return false;
+      }
+      if (permissions.is_super_admin) {
+        return true;
+      }
+      const resourcePermissions = permissions.permissions[resource];
+      if (!resourcePermissions) {
+        return false;
+      }
+      return resourcePermissions[action] ?? false;
+    };
+  }, [permissions]);
+  const isSuperAdmin = permissions?.is_super_admin ?? false;
+  return {
+    query,
+    permissions,
+    can,
+    isSuperAdmin
+  };
+}
+
+// src/hooks/use-fluid-theme.ts
+function useFluidTheme() {
+  const { currentTheme, setTheme, setThemeMode } = useThemeContext();
+  return {
+    currentTheme,
+    setTheme,
+    setThemeMode,
+    mode: currentTheme?.mode
+  };
+}
+var CURRENT_REP_QUERY_KEY = ["fluid", "currentRep"];
+function useCurrentRep() {
+  const api = useFluidApi();
+  return reactQuery.useQuery({
+    queryKey: CURRENT_REP_QUERY_KEY,
+    queryFn: () => api.reps.current()
+  });
+}
+
+// src/hooks/use-fluid-auth.ts
+function useFluidAuth() {
+  return useFluidAuthContext();
+}
+
+// src/hooks/demo-data/calendar-events.ts
+var now = /* @__PURE__ */ new Date();
+function daysFromNow(days, hour, minute = 0) {
+  const d = new Date(now);
+  d.setDate(d.getDate() + days);
+  d.setHours(hour, minute, 0, 0);
+  return d;
+}
+var DEMO_CALENDAR_EVENTS = [
+  {
+    id: 1,
+    title: "Team Standup",
+    description: { body: "Daily sync with the sales team" },
+    color: "#4f46e5",
+    start: daysFromNow(0, 9, 0).toISOString(),
+    end: daysFromNow(0, 9, 30).toISOString(),
+    active: true,
+    status: "confirmed"
+  },
+  {
+    id: 2,
+    title: "Client Review - Acme Corp",
+    description: { body: "Quarterly business review with key accounts" },
+    color: "#059669",
+    start: daysFromNow(2, 14, 0).toISOString(),
+    end: daysFromNow(2, 15, 0).toISOString(),
+    active: true,
+    status: "confirmed",
+    venue: "Conference Room B"
+  },
+  {
+    id: 3,
+    title: "Product Training Webinar",
+    description: { body: "New product line training for the field" },
+    color: "#d97706",
+    start: daysFromNow(4, 11, 0).toISOString(),
+    end: daysFromNow(4, 12, 30).toISOString(),
+    active: true,
+    status: "confirmed",
+    url: "https://example.com/webinar"
+  },
+  {
+    id: 4,
+    title: "Regional Conference",
+    description: { body: "Annual West Coast regional conference" },
+    color: "#dc2626",
+    start: daysFromNow(10, 8, 0).toISOString(),
+    end: daysFromNow(12, 17, 0).toISOString(),
+    active: true,
+    status: "confirmed",
+    venue: "San Diego Convention Center",
+    isAllDay: true
+  }
+];
+
+// src/hooks/use-calendar-events.ts
+function useCalendarEvents() {
+  return {
+    data: [...DEMO_CALENDAR_EVENTS],
+    isLoading: false,
+    isError: false
+  };
+}
+
+// src/hooks/demo-data/todos.ts
+var now2 = /* @__PURE__ */ new Date();
+function daysFromNow2(days) {
+  const d = new Date(now2);
+  d.setDate(d.getDate() + days);
+  return d.toISOString();
+}
+var DEMO_TODOS = [
+  {
+    id: 1,
+    body: "Follow up with Sarah about Q2 order",
+    dueAt: daysFromNow2(1),
+    completedAt: null,
+    createdAt: daysFromNow2(-2),
+    contactName: "Sarah Johnson"
+  },
+  {
+    id: 2,
+    body: "Send pricing proposal to Acme Corp",
+    dueAt: daysFromNow2(7),
+    completedAt: null,
+    createdAt: daysFromNow2(-1),
+    contactName: "Mike Chen"
+  },
+  {
+    id: 3,
+    body: "Schedule onboarding call with new team member",
+    dueAt: daysFromNow2(3),
+    completedAt: null,
+    createdAt: daysFromNow2(0),
+    contactName: "Emily Rodriguez"
+  },
+  {
+    id: 4,
+    body: "Review and approve Q1 expense report",
+    dueAt: daysFromNow2(-1),
+    completedAt: daysFromNow2(-1),
+    createdAt: daysFromNow2(-5),
+    contactName: null
+  },
+  {
+    id: 5,
+    body: "Prepare presentation for Friday team meeting",
+    dueAt: daysFromNow2(4),
+    completedAt: daysFromNow2(0),
+    createdAt: daysFromNow2(-3),
+    contactName: null
+  }
+];
+
+// src/hooks/use-todos.ts
+function useTodos() {
+  return {
+    data: [...DEMO_TODOS],
+    isLoading: false,
+    isError: false
+  };
+}
+
+// src/hooks/hook-types.ts
+function hasData(result) {
+  return result.data != null && !result.isLoading && !result.isError;
+}
+function isLoading(result) {
+  return result.isLoading;
+}
+function isErrorResult(result) {
+  return result.isError && result.error !== void 0;
+}
+function isIdle(result) {
+  return !result.isLoading && !result.isError;
+}
+function selectProperty(items, key) {
+  return items.map((item) => item[key]);
+}
+function getProperty(item, key) {
+  return item?.[key];
+}
+var ACTIVITY_SLUGS = {
+  abandonedCart: "abandoned_cart",
+  announcements: "announcements",
+  cartItemsAdded: "cart_items_added",
+  commentReply: "comment_reply",
+  directMessage: "direct_message",
+  fantasyPoint: "fantasy_point",
+  newLead: "new_lead",
+  orderPlaced: "order_placed",
+  pageViews: "page_views",
+  pageViewsContact: "page_views_contact",
+  tasks: "tasks",
+  upcomingEvent: "upcoming_event",
+  video: "video",
+  videoComplete: "video_complete",
+  videoCompleteContact: "video_complete_contact",
+  videoContact: "video_contact",
+  messageReceived: "message_received",
+  messageSent: "message_sent",
+  newCartItemsAdded: "new_cart_items_added",
+  smartLinkClicked: "smart_link_clicked",
+  reviewLeft: "review_left"
+};
+function isActivitySlug(value) {
+  return Object.values(ACTIVITY_SLUGS).includes(value);
+}
+
+// src/hooks/demo-data/activities.ts
+var now3 = /* @__PURE__ */ new Date();
+function hoursAgo(hours) {
+  const d = new Date(now3);
+  d.setHours(d.getHours() - hours);
+  return d.toISOString();
+}
+var DEMO_ACTIVITIES = [
+  {
+    id: 1,
+    userName: "Sarah Johnson",
+    avatarUrl: null,
+    activityType: "New Order",
+    targetName: "Wellness Starter Kit",
+    timestamp: hoursAgo(1),
+    slug: "order_placed"
+  },
+  {
+    id: 2,
+    userName: "Mike Chen",
+    avatarUrl: null,
+    activityType: "New Lead",
+    targetName: "Referral from LinkedIn campaign",
+    timestamp: hoursAgo(3),
+    slug: "new_lead"
+  },
+  {
+    id: 3,
+    userName: "Emily Rodriguez",
+    avatarUrl: null,
+    activityType: "Page View",
+    targetName: "Product Catalog",
+    timestamp: hoursAgo(5),
+    slug: "page_views"
+  },
+  {
+    id: 4,
+    userName: "David Park",
+    avatarUrl: null,
+    activityType: "Cart Items Added",
+    targetName: "Premium Bundle (3 items)",
+    timestamp: hoursAgo(8),
+    slug: "cart_items_added"
+  },
+  {
+    id: 5,
+    userName: "Lisa Thompson",
+    avatarUrl: null,
+    activityType: "Video Watched",
+    targetName: "Getting Started Tutorial",
+    timestamp: hoursAgo(12),
+    slug: "video_complete"
+  },
+  {
+    id: 6,
+    userName: "James Wilson",
+    avatarUrl: null,
+    activityType: "Message Received",
+    targetName: "Question about shipping",
+    timestamp: hoursAgo(18),
+    slug: "message_received"
+  },
+  {
+    id: 7,
+    userName: "Rachel Kim",
+    avatarUrl: null,
+    activityType: "Smart Link Clicked",
+    targetName: "Holiday Promo Link",
+    timestamp: hoursAgo(24),
+    slug: "smart_link_clicked"
+  },
+  {
+    id: 8,
+    userName: "Tom Martinez",
+    avatarUrl: null,
+    activityType: "Review Left",
+    targetName: "Essential Oil Set - 5 stars",
+    timestamp: hoursAgo(36),
+    slug: "review_left"
+  }
+];
+
+// src/hooks/use-activities.ts
+function useActivities() {
+  return {
+    data: [...DEMO_ACTIVITIES],
+    isLoading: false,
+    isError: false
+  };
+}
+
+// src/hooks/demo-data/catchups.ts
+var DEMO_CATCHUPS = [
+  {
+    id: 1,
+    suggestion_title: "Sarah Johnson hasn't ordered in 30 days"
+  },
+  {
+    id: 2,
+    suggestion_title: "Mike Chen's subscription is expiring soon"
+  },
+  {
+    id: 3,
+    suggestion_title: "Emily Rodriguez left a cart with 3 items"
+  }
+];
+
+// src/hooks/use-catchups.ts
+function useCatchUps() {
+  return {
+    data: [...DEMO_CATCHUPS],
+    isLoading: false,
+    isError: false
+  };
+}
+
+// src/hooks/demo-data/mysite.ts
+var DEMO_MYSITE = {
+  url: "https://my-portal.example.com",
+  views: 1243,
+  leads: 37,
+  userName: "Demo User"
+};
+
+// src/hooks/use-mysite.ts
+function useMySite() {
+  return {
+    data: DEMO_MYSITE,
+    isLoading: false,
+    isError: false
+  };
+}
+
+// src/hooks/demo-data/conversations.ts
+var now4 = /* @__PURE__ */ new Date();
+function hoursAgo2(hours) {
+  const d = new Date(now4);
+  d.setHours(d.getHours() - hours);
+  return d.toISOString();
+}
+function daysAgo(days) {
+  const d = new Date(now4);
+  d.setDate(d.getDate() - days);
+  return d.toISOString();
+}
+var DEMO_CONVERSATIONS = [
+  {
+    id: "conv-1",
+    title: "Sarah Johnson",
+    participants: [
+      { id: "user-1", name: "You", email: "me@example.com", isOnline: true },
+      {
+        id: "user-2",
+        name: "Sarah Johnson",
+        email: "sarah.johnson@example.com",
+        isOnline: true
+      }
+    ],
+    lastMessage: {
+      id: "msg-1-3",
+      conversationId: "conv-1",
+      senderId: "user-2",
+      senderName: "Sarah Johnson",
+      type: "text",
+      content: "Sounds great! I'll place the order by end of day.",
+      timestamp: hoursAgo2(1),
+      isRead: false
+    },
+    unreadCount: 1,
+    status: "active",
+    createdAt: daysAgo(30),
+    updatedAt: hoursAgo2(1)
+  },
+  {
+    id: "conv-2",
+    title: "Mike Chen",
+    participants: [
+      { id: "user-1", name: "You", email: "me@example.com", isOnline: true },
+      {
+        id: "user-3",
+        name: "Mike Chen",
+        email: "mike.chen@acmecorp.com",
+        isOnline: false
+      }
+    ],
+    lastMessage: {
+      id: "msg-2-2",
+      conversationId: "conv-2",
+      senderId: "user-1",
+      senderName: "You",
+      type: "text",
+      content: "I've attached the updated pricing sheet. Let me know if you have any questions!",
+      timestamp: hoursAgo2(5),
+      isRead: true
+    },
+    unreadCount: 0,
+    status: "active",
+    createdAt: daysAgo(14),
+    updatedAt: hoursAgo2(5)
+  },
+  {
+    id: "conv-3",
+    title: "Team Updates",
+    participants: [
+      { id: "user-1", name: "You", email: "me@example.com", isOnline: true },
+      {
+        id: "user-4",
+        name: "Emily Rodriguez",
+        email: "emily.r@healthfirst.io"
+      },
+      { id: "user-5", name: "David Park", email: "david.park@email.com" }
+    ],
+    lastMessage: {
+      id: "msg-3-4",
+      conversationId: "conv-3",
+      senderId: "user-4",
+      senderName: "Emily Rodriguez",
+      type: "text",
+      content: "The new product samples arrived today. Will distribute to the team tomorrow.",
+      timestamp: daysAgo(1),
+      isRead: true
+    },
+    unreadCount: 0,
+    status: "active",
+    createdAt: daysAgo(60),
+    updatedAt: daysAgo(1)
+  }
+];
+var DEMO_MESSAGES = [
+  {
+    id: "msg-1-1",
+    conversationId: "conv-1",
+    senderId: "user-1",
+    senderName: "You",
+    type: "text",
+    content: "Hi Sarah! I wanted to follow up on the Wellness Starter Kit. We have a special promotion running this month.",
+    timestamp: hoursAgo2(3),
+    isRead: true
+  },
+  {
+    id: "msg-1-2",
+    conversationId: "conv-1",
+    senderId: "user-2",
+    senderName: "Sarah Johnson",
+    type: "text",
+    content: "That's perfect timing! I was just thinking about reordering. What's the promo?",
+    timestamp: hoursAgo2(2),
+    isRead: true
+  },
+  {
+    id: "msg-1-3",
+    conversationId: "conv-1",
+    senderId: "user-2",
+    senderName: "Sarah Johnson",
+    type: "text",
+    content: "Sounds great! I'll place the order by end of day.",
+    timestamp: hoursAgo2(1),
+    isRead: false
+  }
+];
+
+// src/hooks/use-conversations.ts
+function useConversations() {
+  return {
+    data: [...DEMO_CONVERSATIONS],
+    isLoading: false,
+    isError: false
+  };
+}
+function useConversationMessages(_conversationId) {
+  return {
+    data: [...DEMO_MESSAGES],
+    isLoading: false,
+    isError: false
+  };
+}
+
+// src/types/screen-types.ts
+var CONTACT_STATUSES = {
+  active: "active",
+  inactive: "inactive",
+  lead: "lead",
+  prospect: "prospect"
+};
+
+// src/hooks/demo-data/contacts.ts
+var now5 = /* @__PURE__ */ new Date();
+function daysAgo2(days) {
+  const d = new Date(now5);
+  d.setDate(d.getDate() - days);
+  return d.toISOString();
+}
+var DEMO_CONTACTS = [
+  {
+    id: "contact-1",
+    firstName: "Sarah",
+    lastName: "Johnson",
+    email: "sarah.johnson@example.com",
+    phone: "+1 (555) 123-4567",
+    company: "Wellness Works Inc.",
+    jobTitle: "Purchasing Manager",
+    status: "active",
+    type: "individual",
+    tags: ["VIP", "Repeat Buyer"],
+    createdAt: daysAgo2(90),
+    updatedAt: daysAgo2(2)
+  },
+  {
+    id: "contact-2",
+    firstName: "Mike",
+    lastName: "Chen",
+    email: "mike.chen@acmecorp.com",
+    phone: "+1 (555) 234-5678",
+    company: "Acme Corp",
+    jobTitle: "Director of Operations",
+    status: "active",
+    type: "individual",
+    tags: ["Enterprise"],
+    createdAt: daysAgo2(60),
+    updatedAt: daysAgo2(5)
+  },
+  {
+    id: "contact-3",
+    firstName: "Emily",
+    lastName: "Rodriguez",
+    email: "emily.r@healthfirst.io",
+    company: "HealthFirst",
+    status: "lead",
+    type: "individual",
+    notes: "Interested in bulk pricing for team orders",
+    createdAt: daysAgo2(7),
+    updatedAt: daysAgo2(1)
+  },
+  {
+    id: "contact-4",
+    firstName: "David",
+    lastName: "Park",
+    email: "david.park@email.com",
+    phone: "+1 (555) 345-6789",
+    status: "prospect",
+    type: "individual",
+    tags: ["Referral"],
+    createdAt: daysAgo2(14),
+    updatedAt: daysAgo2(10)
+  },
+  {
+    id: "contact-5",
+    firstName: "Lisa",
+    lastName: "Thompson",
+    email: "lisa.t@globalfit.com",
+    company: "Global Fitness",
+    jobTitle: "CEO",
+    status: "active",
+    type: "individual",
+    address: {
+      city: "Los Angeles",
+      state: "CA",
+      country: "US"
+    },
+    createdAt: daysAgo2(120),
+    updatedAt: daysAgo2(15)
+  },
+  {
+    id: "contact-6",
+    firstName: "James",
+    lastName: "Wilson",
+    email: "jwilson@retired.net",
+    status: "inactive",
+    type: "individual",
+    notes: "Moved out of area, no longer purchasing",
+    createdAt: daysAgo2(200),
+    updatedAt: daysAgo2(45)
+  }
+];
+var DEMO_CONTACT = DEMO_CONTACTS[0];
+
+// src/hooks/use-contacts.ts
+function isContactStatus(value) {
+  return Object.values(CONTACT_STATUSES).includes(value);
+}
+function useContacts(_params) {
+  return {
+    data: [...DEMO_CONTACTS],
+    isLoading: false,
+    isError: false,
+    totalCount: DEMO_CONTACTS.length
+  };
+}
+function useContact(_contactId) {
+  return {
+    data: DEMO_CONTACT,
+    isLoading: false,
+    isError: false
+  };
+}
+function AuthError({
+  message = "You need to be authenticated to view this content.",
+  title = "Authentication Required",
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        minHeight: "100vh",
+        padding: "2rem",
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+        backgroundColor: "#f9fafb",
+        color: "#111827"
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          style: {
+            maxWidth: "400px",
+            textAlign: "center",
+            padding: "2rem",
+            backgroundColor: "#ffffff",
+            borderRadius: "0.75rem",
+            boxShadow: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06)"
+          },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                style: {
+                  width: "64px",
+                  height: "64px",
+                  margin: "0 auto 1.5rem",
+                  backgroundColor: "#fee2e2",
+                  borderRadius: "50%",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center"
+                },
+                children: /* @__PURE__ */ jsxRuntime.jsxs(
+                  "svg",
+                  {
+                    width: "32",
+                    height: "32",
+                    viewBox: "0 0 24 24",
+                    fill: "none",
+                    stroke: "#dc2626",
+                    strokeWidth: "2",
+                    strokeLinecap: "round",
+                    strokeLinejoin: "round",
+                    children: [
+                      /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "11", width: "18", height: "11", rx: "2", ry: "2" }),
+                      /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M7 11V7a5 5 0 0 1 10 0v4" })
+                    ]
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "h1",
+              {
+                style: {
+                  fontSize: "1.5rem",
+                  fontWeight: "600",
+                  marginBottom: "0.75rem",
+                  color: "#111827"
+                },
+                children: title
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "p",
+              {
+                style: {
+                  fontSize: "1rem",
+                  color: "#6b7280",
+                  marginBottom: children ? "1.5rem" : "0",
+                  lineHeight: "1.5"
+                },
+                children: message
+              }
+            ),
+            children
+          ]
+        }
+      )
+    }
+  );
+}
+function AuthLoading() {
+  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: "Authenticating..."
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
+        @keyframes spin {
+          to { transform: rotate(360deg); }
+        }
+      ` })
+      ]
+    }
+  );
+}
+function RequireAuth({
+  children,
+  fallback = /* @__PURE__ */ jsxRuntime.jsx(AuthLoading, {}),
+  errorComponent = /* @__PURE__ */ jsxRuntime.jsx(AuthError, {})
+}) {
+  const { isAuthenticated, isLoading: isLoading2, error } = useFluidAuth();
+  if (isLoading2) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
+  }
+  if (!isAuthenticated || error) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: errorComponent });
+  }
+  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)
+};
+var CORE_PAGE_IDS = {
+  MESSAGING: "core-messaging",
+  CONTACTS: "core-contacts",
+  ORDERS: "core-orders",
+  CUSTOMERS: "core-customers",
+  PRODUCTS: "core-products"
+};
+function registerCorePageTemplates() {
+  PageTemplateRegistry.register({
+    id: CORE_PAGE_IDS.MESSAGING,
+    slug: "messaging",
+    name: "Messaging",
+    description: "Messaging interface provided by Fluid Commerce",
+    category: PAGE_CATEGORIES.COMMUNICATION,
+    tags: ["messaging", "chat", "conversations", "communication"],
+    version: "1.0.0",
+    isCore: true,
+    component_tree: [
+      {
+        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 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;
+
+Object.defineProperty(exports, "MessagingScreen", {
+  enumerable: true,
+  get: function () { return chunkJZRNKSKT_cjs.MessagingScreen; }
+});
+Object.defineProperty(exports, "messagingScreenPropertySchema", {
+  enumerable: true,
+  get: function () { return chunkJZRNKSKT_cjs.messagingScreenPropertySchema; }
+});
+Object.defineProperty(exports, "ContactsScreen", {
+  enumerable: true,
+  get: function () { return chunkMEOOAMH2_cjs.ContactsScreen; }
+});
+Object.defineProperty(exports, "contactsScreenPropertySchema", {
+  enumerable: true,
+  get: function () { return chunkMEOOAMH2_cjs.contactsScreenPropertySchema; }
+});
+Object.defineProperty(exports, "OrdersScreen", {
+  enumerable: true,
+  get: function () { return chunkYII3IXF4_cjs.OrdersScreen; }
+});
+Object.defineProperty(exports, "ordersScreenPropertySchema", {
+  enumerable: true,
+  get: function () { return chunkYII3IXF4_cjs.ordersScreenPropertySchema; }
+});
+Object.defineProperty(exports, "CustomersScreen", {
+  enumerable: true,
+  get: function () { return chunkMBUCXIUN_cjs.CustomersScreen; }
+});
+Object.defineProperty(exports, "customersScreenPropertySchema", {
+  enumerable: true,
+  get: function () { return chunkMBUCXIUN_cjs.customersScreenPropertySchema; }
+});
+Object.defineProperty(exports, "ProductsScreen", {
+  enumerable: true,
+  get: function () { return chunkQUVJ3R4T_cjs.ProductsScreen; }
+});
+Object.defineProperty(exports, "productsScreenPropertySchema", {
+  enumerable: true,
+  get: function () { return chunkQUVJ3R4T_cjs.productsScreenPropertySchema; }
+});
+Object.defineProperty(exports, "WIDGET_TYPE_NAMES", {
+  enumerable: true,
+  get: function () { return types.WIDGET_TYPE_NAMES; }
+});
+Object.defineProperty(exports, "assertDefined", {
+  enumerable: true,
+  get: function () { return types.assertDefined; }
+});
+Object.defineProperty(exports, "assertNever", {
+  enumerable: true,
+  get: function () { return types.assertNever; }
+});
+Object.defineProperty(exports, "isWidgetType", {
+  enumerable: true,
+  get: function () { return types.isWidgetType; }
+});
+Object.defineProperty(exports, "isWidgetTypeName", {
+  enumerable: true,
+  get: function () { return types.isWidgetTypeName; }
+});
+Object.defineProperty(exports, "sectionLayoutConfig", {
+  enumerable: true,
+  get: function () { return types.sectionLayoutConfig; }
+});
+Object.defineProperty(exports, "AlertWidget", {
+  enumerable: true,
+  get: function () { return widgets.AlertWidget; }
+});
+Object.defineProperty(exports, "CalendarWidget", {
+  enumerable: true,
+  get: function () { return widgets.CalendarWidget; }
+});
+Object.defineProperty(exports, "CarouselWidget", {
+  enumerable: true,
+  get: function () { return widgets.CarouselWidget; }
+});
+Object.defineProperty(exports, "CatchUpWidget", {
+  enumerable: true,
+  get: function () { return widgets.CatchUpWidget; }
+});
+Object.defineProperty(exports, "ChartWidget", {
+  enumerable: true,
+  get: function () { return widgets.ChartWidget; }
+});
+Object.defineProperty(exports, "ContainerWidget", {
+  enumerable: true,
+  get: function () { return widgets.ContainerWidget; }
+});
+Object.defineProperty(exports, "EmbedWidget", {
+  enumerable: true,
+  get: function () { return widgets.EmbedWidget; }
+});
+Object.defineProperty(exports, "ImageWidget", {
+  enumerable: true,
+  get: function () { return widgets.ImageWidget; }
+});
+Object.defineProperty(exports, "LayoutWidget", {
+  enumerable: true,
+  get: function () { return widgets.LayoutWidget; }
+});
+Object.defineProperty(exports, "ListWidget", {
+  enumerable: true,
+  get: function () { return widgets.ListWidget; }
+});
+Object.defineProperty(exports, "MySiteWidget", {
+  enumerable: true,
+  get: function () { return widgets.MySiteWidget; }
+});
+Object.defineProperty(exports, "NestedWidget", {
+  enumerable: true,
+  get: function () { return widgets.NestedWidget; }
+});
+Object.defineProperty(exports, "QuickShareWidget", {
+  enumerable: true,
+  get: function () { return widgets.QuickShareWidget; }
+});
+Object.defineProperty(exports, "RecentActivityWidget", {
+  enumerable: true,
+  get: function () { return widgets.RecentActivityWidget; }
+});
+Object.defineProperty(exports, "SpacerWidget", {
+  enumerable: true,
+  get: function () { return widgets.SpacerWidget; }
+});
+Object.defineProperty(exports, "TableWidget", {
+  enumerable: true,
+  get: function () { return widgets.TableWidget; }
+});
+Object.defineProperty(exports, "TextWidget", {
+  enumerable: true,
+  get: function () { return widgets.TextWidget; }
+});
+Object.defineProperty(exports, "ToDoWidget", {
+  enumerable: true,
+  get: function () { return widgets.ToDoWidget; }
+});
+Object.defineProperty(exports, "VideoWidget", {
+  enumerable: true,
+  get: function () { return widgets.VideoWidget; }
+});
+Object.defineProperty(exports, "alertWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.alertWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "calendarWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.calendarWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "carouselWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.carouselWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "catchUpWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.catchUpWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "chartWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.chartWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "containerWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.containerWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "embedWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.embedWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "imageWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.imageWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "layoutWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.layoutWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "listWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.listWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "mySiteWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.mySiteWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "nestedWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.nestedWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "quickShareWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.quickShareWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "recentActivityWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.recentActivityWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "spacerWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.spacerWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "tableWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.tableWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "textWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.textWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "toDoWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.toDoWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "videoWidgetPropertySchema", {
+  enumerable: true,
+  get: function () { return widgets.videoWidgetPropertySchema; }
+});
+Object.defineProperty(exports, "widgetPropertySchemas", {
+  enumerable: true,
+  get: function () { return widgets.widgetPropertySchemas; }
+});
+Object.defineProperty(exports, "createScreen", {
+  enumerable: true,
+  get: function () { return widgetUtils.createScreen; }
+});
+Object.defineProperty(exports, "createWidgetFromShareable", {
+  enumerable: true,
+  get: function () { return widgetUtils.createWidgetFromShareable; }
+});
+Object.defineProperty(exports, "createWidgetRegistry", {
+  enumerable: true,
+  get: function () { return widgetUtils.createWidgetRegistry; }
+});
+Object.defineProperty(exports, "groupChildrenByColumn", {
+  enumerable: true,
+  get: function () { return widgetUtils.groupChildrenByColumn; }
+});
+Object.defineProperty(exports, "PROPERTY_FIELD_TYPES", {
+  enumerable: true,
+  get: function () { return registries.PROPERTY_FIELD_TYPES; }
+});
+Object.defineProperty(exports, "gapValues", {
+  enumerable: true,
+  get: function () { return registries.gapValues; }
+});
+Object.defineProperty(exports, "isPropertyFieldType", {
+  enumerable: true,
+  get: function () { return registries.isPropertyFieldType; }
+});
+exports.ACTIVITY_SLUGS = ACTIVITY_SLUGS;
+exports.AUTH_CONSTANTS = AUTH_CONSTANTS;
+exports.ApiError = ApiError;
+exports.AuthError = AuthError;
+exports.AuthLoading = AuthLoading;
+exports.BUILT_IN_THEMES = export_BUILT_IN_THEMES;
+exports.CORE_COLOR_KEYS = export_CORE_COLOR_KEYS;
+exports.CORE_PAGE_IDS = CORE_PAGE_IDS;
+exports.CURRENT_REP_QUERY_KEY = CURRENT_REP_QUERY_KEY;
+exports.DEFAULT_CORE_COLORS = export_DEFAULT_CORE_COLORS;
+exports.FluidAuthProvider = FluidAuthProvider;
+exports.FluidProvider = FluidProvider;
+exports.FluidThemeProvider = FluidThemeProvider;
+exports.PAGE_CATEGORIES = PAGE_CATEGORIES;
+exports.PERMISSIONS_QUERY_KEY = PERMISSIONS_QUERY_KEY;
+exports.PROFILE_QUERY_KEY = PROFILE_QUERY_KEY;
+exports.PageTemplateProvider = PageTemplateProvider;
+exports.PageTemplateRegistry = PageTemplateRegistry;
+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.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.getAvailablePageTemplates = getAvailablePageTemplates;
+exports.getCorePageTemplates = getCorePageTemplates;
+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.resolveNavigationPages = resolveNavigationPages;
+exports.rosePine = export_rosePine;
+exports.rotateHue = export_rotateHue;
+exports.rotateSoft = export_rotateSoft;
+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.useActivities = useActivities;
+exports.useCalendarEvents = useCalendarEvents;
+exports.useCatchUps = useCatchUps;
+exports.useContact = useContact;
+exports.useContacts = useContacts;
+exports.useConversationMessages = useConversationMessages;
+exports.useConversations = useConversations;
+exports.useCurrentRep = useCurrentRep;
+exports.useFluidApi = useFluidApi;
+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