@fluid-app/rep-sdk 0.1.2 → 0.1.3

package/dist/chunk-V3IMQZIG.cjs

@@ -0,0 +1,1942 @@
+'use strict';
+
+var chunkHDQ2JUQT_cjs = require('./chunk-HDQ2JUQT.cjs');
+var react = require('react');
+var app = require('@fluid-app/fluid-messaging-ui/app');
+var fluidMessagingUi = require('@fluid-app/fluid-messaging-ui');
+var fluidMessagingApiClient = require('@fluid-app/fluid-messaging-api-client');
+var reactQuery = require('@tanstack/react-query');
+var jose = require('jose');
+var jsxRuntime = require('react/jsx-runtime');
+var theme_star = require('@fluid-app/rep-core/theme');
+var registryContext = require('@fluid-app/rep-core/data-sources/registry-context');
+var contexts = require('@fluid-app/rep-widgets/contexts');
+var widgetUtils = require('@fluid-app/rep-core/widget-utils');
+var widgets = require('@fluid-app/rep-widgets/widgets');
+var fluidMessagingCore = require('@fluid-app/fluid-messaging-core');
+
+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/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 {
+    const inIframe = window.self !== window.top;
+    const sameSite = inIframe ? "none" : "lax";
+    setCookie(cookieKey, token, {
+      maxAge,
+      path: "/",
+      sameSite,
+      // SameSite=None requires Secure per RFC 6265bis; browsers silently
+      // reject the cookie otherwise (e.g. HTTP localhost in an iframe).
+      secure: sameSite === "none" || 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"
+  };
+}
+
+// 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);
+}
+var FluidAuthContext = react.createContext(null);
+function FluidAuthProvider({
+  children,
+  config
+}) {
+  const configRef = react.useRef(config);
+  configRef.current = config;
+  const [isLoading, 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,
+      user,
+      token,
+      clearAuth,
+      error
+    }),
+    [token, isLoading, 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;
+}
+function useFluidAuthOptional() {
+  return react.useContext(FluidAuthContext);
+}
+
+// ../../platform/api-client-core/src/fetch-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;
+    if ("captureStackTrace" in Error) {
+      Error.captureStackTrace(this, _ApiError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      data: this.data
+    };
+  }
+};
+function createFetchClient(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 joinUrl(endpoint) {
+    return `${baseUrl}${endpoint}`;
+  }
+  function buildUrl(endpoint, params) {
+    const fullUrl = joinUrl(endpoint);
+    if (!params || Object.keys(params).length === 0) {
+      return fullUrl;
+    }
+    const queryString = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value === void 0 || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((item) => queryString.append(`${key}[]`, String(item)));
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([subKey, subValue]) => {
+          if (subValue === void 0 || subValue === null) {
+            return;
+          }
+          if (Array.isArray(subValue)) {
+            subValue.forEach(
+              (item) => queryString.append(`${key}[${subKey}][]`, String(item))
+            );
+          } else {
+            queryString.append(`${key}[${subKey}]`, String(subValue));
+          }
+        });
+      } else {
+        queryString.append(key, String(value));
+      }
+    });
+    const qs = queryString.toString();
+    return qs ? `${fullUrl}?${qs}` : fullUrl;
+  }
+  async function handleResponse(response, method, _url) {
+    if (response.status === 401 && onAuthError) {
+      onAuthError();
+    }
+    if (!response.ok) {
+      try {
+        const contentType2 = response.headers.get("content-type");
+        if (contentType2?.includes("application/json")) {
+          const data = await response.json();
+          throw new ApiError(
+            data.message || data.error_message || `${method} request failed`,
+            response.status,
+            data.errors || data
+          );
+        } else {
+          throw new ApiError(
+            `${method} request failed with status ${response.status}`,
+            response.status,
+            null
+          );
+        }
+      } catch (error) {
+        if (error instanceof ApiError) {
+          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;
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      try {
+        const data = await response.json();
+        return data;
+      } catch {
+        try {
+          const text = await response.text();
+          return text;
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  async function request(endpoint, options = {}) {
+    const {
+      method = "GET",
+      headers: customHeaders,
+      params,
+      body,
+      signal
+    } = options;
+    const url = params ? buildUrl(endpoint, params) : joinUrl(endpoint);
+    const headers = await buildHeaders(customHeaders);
+    let response;
+    try {
+      const fetchOptions = { method, headers };
+      const serializedBody = body && method !== "GET" ? JSON.stringify(body) : null;
+      if (serializedBody) fetchOptions.body = serializedBody;
+      if (signal) fetchOptions.signal = signal;
+      response = await fetch(url, fetchOptions);
+    } catch (networkError) {
+      throw new ApiError(
+        `Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`,
+        0,
+        null
+      );
+    }
+    return handleResponse(response, method);
+  }
+  async function requestWithFormData(endpoint, formData, options = {}) {
+    const { method = "POST", headers: customHeaders, signal } = options;
+    const url = joinUrl(endpoint);
+    const headers = await buildHeaders(customHeaders);
+    delete headers["Content-Type"];
+    let response;
+    try {
+      const fetchOptions = { method, headers, body: formData };
+      if (signal) fetchOptions.signal = signal;
+      response = await fetch(url, fetchOptions);
+    } catch (networkError) {
+      throw new ApiError(
+        `Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`,
+        0,
+        null
+      );
+    }
+    return handleResponse(response, method);
+  }
+  return {
+    request,
+    requestWithFormData,
+    // Convenience methods for common HTTP verbs
+    get: (endpoint, params, options) => request(endpoint, {
+      ...options,
+      method: "GET",
+      ...params && { params }
+    }),
+    post: (endpoint, body, options) => request(endpoint, {
+      ...options,
+      method: "POST",
+      body
+    }),
+    put: (endpoint, body, options) => request(endpoint, {
+      ...options,
+      method: "PUT",
+      body
+    }),
+    patch: (endpoint, body, options) => request(endpoint, {
+      ...options,
+      method: "PATCH",
+      body
+    }),
+    delete: (endpoint, options) => request(endpoint, {
+      ...options,
+      method: "DELETE"
+    })
+  };
+}
+
+// ../../fluidos/api-client/src/namespaces/fluid_os.ts
+var fluid_os_exports = {};
+chunkHDQ2JUQT_cjs.__export(fluid_os_exports, {
+  createFluidOSDefinition: () => createFluidOSDefinition,
+  createFluidOSNavigation: () => createFluidOSNavigation,
+  createFluidOSNavigationItem: () => createFluidOSNavigationItem,
+  createFluidOSProfile: () => createFluidOSProfile,
+  createFluidOSScreen: () => createFluidOSScreen,
+  createFluidOSTheme: () => createFluidOSTheme,
+  createFluidOSVersion: () => createFluidOSVersion,
+  deleteFluidOSDefinition: () => deleteFluidOSDefinition,
+  deleteFluidOSNavigation: () => deleteFluidOSNavigation,
+  deleteFluidOSNavigationItem: () => deleteFluidOSNavigationItem,
+  deleteFluidOSProfile: () => deleteFluidOSProfile,
+  deleteFluidOSScreen: () => deleteFluidOSScreen,
+  deleteFluidOSTheme: () => deleteFluidOSTheme,
+  getDefaultFluidOSProfile: () => getDefaultFluidOSProfile,
+  getFluidOSDefinition: () => getFluidOSDefinition,
+  getFluidOSManifest: () => getFluidOSManifest,
+  getFluidOSNavigation: () => getFluidOSNavigation,
+  getFluidOSNavigationItem: () => getFluidOSNavigationItem,
+  getFluidOSProfile: () => getFluidOSProfile,
+  getFluidOSScreen: () => getFluidOSScreen,
+  getFluidOSTheme: () => getFluidOSTheme,
+  getFluidOSVersion: () => getFluidOSVersion,
+  listFluidOSDefinitions: () => listFluidOSDefinitions,
+  listFluidOSNavigationItems: () => listFluidOSNavigationItems,
+  listFluidOSNavigations: () => listFluidOSNavigations,
+  listFluidOSProfiles: () => listFluidOSProfiles,
+  listFluidOSScreens: () => listFluidOSScreens,
+  listFluidOSThemes: () => listFluidOSThemes,
+  listFluidOSVersions: () => listFluidOSVersions,
+  updateFluidOSDefinition: () => updateFluidOSDefinition,
+  updateFluidOSNavigation: () => updateFluidOSNavigation,
+  updateFluidOSNavigationItem: () => updateFluidOSNavigationItem,
+  updateFluidOSProfile: () => updateFluidOSProfile,
+  updateFluidOSScreen: () => updateFluidOSScreen,
+  updateFluidOSTheme: () => updateFluidOSTheme,
+  updateFluidOSVersion: () => updateFluidOSVersion
+});
+async function listFluidOSDefinitions(client, params) {
+  return client.get(`/api/company/fluid_os/definitions`, params);
+}
+async function createFluidOSDefinition(client, body) {
+  return client.post(`/api/company/fluid_os/definitions`, body);
+}
+async function getFluidOSDefinition(client, id) {
+  return client.get(`/api/company/fluid_os/definitions/${id}`);
+}
+async function updateFluidOSDefinition(client, id, body) {
+  return client.put(`/api/company/fluid_os/definitions/${id}`, body);
+}
+async function deleteFluidOSDefinition(client, id) {
+  return client.delete(`/api/company/fluid_os/definitions/${id}`);
+}
+async function listFluidOSNavigationItems(client, definition_id, navigation_id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items`
+  );
+}
+async function createFluidOSNavigationItem(client, definition_id, navigation_id, body) {
+  return client.post(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items`,
+    body
+  );
+}
+async function getFluidOSNavigationItem(client, definition_id, navigation_id, id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items/${id}`
+  );
+}
+async function updateFluidOSNavigationItem(client, definition_id, navigation_id, id, body) {
+  return client.put(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items/${id}`,
+    body
+  );
+}
+async function deleteFluidOSNavigationItem(client, definition_id, navigation_id, id) {
+  return client.delete(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items/${id}`
+  );
+}
+async function listFluidOSNavigations(client, definition_id, params) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations`,
+    params
+  );
+}
+async function createFluidOSNavigation(client, definition_id, body) {
+  return client.post(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations`,
+    body
+  );
+}
+async function getFluidOSNavigation(client, definition_id, id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${id}`
+  );
+}
+async function updateFluidOSNavigation(client, definition_id, id, body) {
+  return client.put(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${id}`,
+    body
+  );
+}
+async function deleteFluidOSNavigation(client, definition_id, id) {
+  return client.delete(
+    `/api/company/fluid_os/definitions/${definition_id}/navigations/${id}`
+  );
+}
+async function listFluidOSProfiles(client, definition_id, params) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/profiles`,
+    params
+  );
+}
+async function createFluidOSProfile(client, definition_id, body) {
+  return client.post(
+    `/api/company/fluid_os/definitions/${definition_id}/profiles`,
+    body
+  );
+}
+async function getDefaultFluidOSProfile(client, definition_id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/profiles/default`
+  );
+}
+async function getFluidOSProfile(client, definition_id, id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/profiles/${id}`
+  );
+}
+async function updateFluidOSProfile(client, definition_id, id, body) {
+  return client.put(
+    `/api/company/fluid_os/definitions/${definition_id}/profiles/${id}`,
+    body
+  );
+}
+async function deleteFluidOSProfile(client, definition_id, id) {
+  return client.delete(
+    `/api/company/fluid_os/definitions/${definition_id}/profiles/${id}`
+  );
+}
+async function getFluidOSManifest(client, params) {
+  return client.get(`/api/fluid_os/definitions/active`, params);
+}
+async function listFluidOSScreens(client, definition_id, params) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/screens`,
+    params
+  );
+}
+async function createFluidOSScreen(client, definition_id, body) {
+  return client.post(
+    `/api/company/fluid_os/definitions/${definition_id}/screens`,
+    body
+  );
+}
+async function getFluidOSScreen(client, definition_id, id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/screens/${id}`
+  );
+}
+async function updateFluidOSScreen(client, definition_id, id, body) {
+  return client.put(
+    `/api/company/fluid_os/definitions/${definition_id}/screens/${id}`,
+    body
+  );
+}
+async function deleteFluidOSScreen(client, definition_id, id) {
+  return client.delete(
+    `/api/company/fluid_os/definitions/${definition_id}/screens/${id}`
+  );
+}
+async function listFluidOSThemes(client, definition_id, params) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/themes`,
+    params
+  );
+}
+async function createFluidOSTheme(client, definition_id, body) {
+  return client.post(
+    `/api/company/fluid_os/definitions/${definition_id}/themes`,
+    body
+  );
+}
+async function getFluidOSTheme(client, definition_id, id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/themes/${id}`
+  );
+}
+async function updateFluidOSTheme(client, definition_id, id, body) {
+  return client.put(
+    `/api/company/fluid_os/definitions/${definition_id}/themes/${id}`,
+    body
+  );
+}
+async function deleteFluidOSTheme(client, definition_id, id) {
+  return client.delete(
+    `/api/company/fluid_os/definitions/${definition_id}/themes/${id}`
+  );
+}
+async function listFluidOSVersions(client, definition_id, params) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/versions`,
+    params
+  );
+}
+async function createFluidOSVersion(client, definition_id) {
+  return client.post(
+    `/api/company/fluid_os/definitions/${definition_id}/versions`
+  );
+}
+async function getFluidOSVersion(client, definition_id, id) {
+  return client.get(
+    `/api/company/fluid_os/definitions/${definition_id}/versions/${id}`
+  );
+}
+async function updateFluidOSVersion(client, definition_id, id, body) {
+  return client.put(
+    `/api/company/fluid_os/definitions/${definition_id}/versions/${id}`,
+    body
+  );
+}
+
+// src/client/types.ts
+var HTTP_METHODS = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  PATCH: "PATCH",
+  DELETE: "DELETE"
+};
+
+// src/transforms/screen-transforms.ts
+function normalizeComponentTree(componentTree) {
+  if (!componentTree) return [];
+  if (Array.isArray(componentTree)) return componentTree;
+  if (typeof componentTree === "object") {
+    return [componentTree];
+  }
+  return [];
+}
+function toScreenDefinition(screen) {
+  return {
+    id: Number(screen.id),
+    slug: screen.slug ?? "",
+    name: screen.name ?? "",
+    component_tree: normalizeComponentTree(screen.component_tree)
+  };
+}
+
+// src/transforms/navigation-transforms.ts
+function toNavigationItem(item) {
+  const children = (item.children ?? []).map(toNavigationItem).sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+  return {
+    id: Number(item.id),
+    label: item.label ?? "Untitled",
+    // Use conditional spread for optional properties (exactOptionalPropertyTypes)
+    ...item.slug != null ? { slug: String(item.slug) } : {},
+    ...item.icon != null ? { icon: String(item.icon) } : {},
+    ...item.screen_id != null ? { screen_id: Number(item.screen_id) } : {},
+    ...item.parent_id != null ? { parent_id: Number(item.parent_id) } : {},
+    position: item.position ?? 0,
+    children
+  };
+}
+function transformManifestToRepAppData(response) {
+  const manifest = response.manifest;
+  const rawProfile = manifest.profile;
+  const rawThemes = Array.isArray(rawProfile?.themes) ? rawProfile.themes : [];
+  const screens = (manifest.screens ?? []).map(
+    (screen) => toScreenDefinition(screen)
+  );
+  const navigationItems = (rawProfile?.navigation?.navigation_items ?? []).map(
+    toNavigationItem
+  );
+  const nav = rawProfile?.navigation;
+  const activeThemeId = theme_star.getActiveThemeId(rawThemes);
+  return {
+    definition_id: manifest.definition_id,
+    published_version: manifest.published_version ?? 0,
+    screens,
+    profile: {
+      name: rawProfile?.name ?? "Default",
+      definition_id: rawProfile?.definition_id ?? manifest.definition_id,
+      themes: theme_star.transformThemes(rawThemes),
+      // Conditional spread for exactOptionalPropertyTypes compliance
+      ...activeThemeId !== void 0 ? { activeThemeId } : {},
+      navigation: {
+        definition_id: nav?.definition_id ?? manifest.definition_id,
+        id: nav?.id ?? 0,
+        name: nav?.name ?? "Main Navigation",
+        navigation_items: navigationItems,
+        screens
+      }
+    }
+  };
+}
+
+// src/client/fluid-client.ts
+var ApiError2 = 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 isApiError2(error) {
+  return error instanceof ApiError2;
+}
+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();
+  const fetchClient = createFetchClient({
+    baseUrl,
+    ...getAuthToken ? { getAuthToken } : {},
+    onAuthError: effectiveOnAuthError,
+    defaultHeaders
+  });
+  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 ApiError2(
+        `Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`,
+        0,
+        null
+      );
+    }
+    if (response.status === 401) {
+      effectiveOnAuthError();
+      throw new ApiError2("Authentication required", 401, 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 ApiError2(
+            errorMessage,
+            response.status,
+            "errors" in data ? data.errors : data
+          );
+        } else {
+          throw new ApiError2(
+            `${method} request failed with status ${response.status}`,
+            response.status,
+            null
+          );
+        }
+      } catch (error) {
+        if (isApiError2(error)) {
+          throw error;
+        }
+        throw new ApiError2(
+          `${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 ApiError2(
+          "Unexpected null/undefined in JSON response",
+          response.status,
+          null
+        );
+      }
+      return data;
+    } catch (parseError) {
+      if (isApiError2(parseError)) {
+        throw parseError;
+      }
+      throw new ApiError2(
+        "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 (isApiError2(error)) {
+        return { success: false, error };
+      }
+      return {
+        success: false,
+        error: new ApiError2(
+          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 {
+    // Fluidos FetchClient for structured API calls
+    fetchClient,
+    // 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)
+    },
+    // Users API
+    users: {
+      me: () => get("/api/me")
+    },
+    // Reps API
+    reps: {
+      current: () => get("/reps/me"),
+      updateProfile: (data) => patch("/reps/me", data)
+    },
+    // Profile API (themes, navigation, screens) — legacy endpoint
+    profile: {
+      get: () => get("/rep_app/manifest")
+    },
+    // App API — fluidos endpoint (full manifest with transforms)
+    app: {
+      /** Fetch the raw manifest (plain JSON, no Color objects). Cache-safe. */
+      getRaw: async () => {
+        const raw = await fluid_os_exports.getFluidOSManifest(fetchClient, {
+          platform: "browser"
+        });
+        return raw;
+      },
+      /** Fetch the active app definition with full theme/screen/navigation transforms */
+      get: async () => {
+        const raw = await fluid_os_exports.getFluidOSManifest(fetchClient, {
+          platform: "browser"
+        });
+        return transformManifestToRepAppData(
+          raw
+        );
+      }
+    },
+    // Permissions API
+    permissions: {
+      get: () => get("/company/roles/my_permissions")
+    },
+    // Analytics API
+    analytics: {
+      dashboard: () => get("/analytics/dashboard"),
+      sales: (params) => get("/analytics/sales", params)
+    }
+  };
+}
+
+// src/themes/index.ts
+var themes_exports = {};
+chunkHDQ2JUQT_cjs.__reExport(themes_exports, theme_star__namespace);
+var ThemeContext = react.createContext(null);
+function applyThemeToDOM(theme, mode, container) {
+  const target = container ?? document.documentElement;
+  const resolved = (0, themes_exports.resolveTheme)(theme);
+  (0, themes_exports.applyTheme)(resolved);
+  target.dataset.theme = theme.id;
+  if (mode) {
+    target.dataset.themeMode = mode;
+  } else {
+    delete target.dataset.themeMode;
+  }
+}
+function FluidThemeProvider({
+  children,
+  initialTheme,
+  container
+}) {
+  const [currentTheme, setCurrentTheme] = react.useState(
+    initialTheme ?? null
+  );
+  const [mode, setMode] = react.useState(void 0);
+  react.useEffect(() => {
+    if (currentTheme) {
+      applyThemeToDOM(currentTheme, mode, container ?? null);
+    }
+    return () => {
+      (0, themes_exports.removeAllThemes)();
+    };
+  }, [currentTheme, mode, container]);
+  const setTheme = react.useCallback((theme) => {
+    setCurrentTheme(theme);
+  }, []);
+  const setThemeMode = react.useCallback((newMode) => {
+    setMode(newMode);
+  }, []);
+  const value = react.useMemo(
+    () => ({
+      currentTheme,
+      setTheme,
+      setThemeMode,
+      mode
+    }),
+    [currentTheme, setTheme, setThemeMode, mode]
+  );
+  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 DEFAULT_SDK_WIDGET_REGISTRY = widgetUtils.createWidgetRegistry({
+  AlertWidget: widgets.AlertWidget,
+  CalendarWidget: widgets.CalendarWidget,
+  CarouselWidget: widgets.CarouselWidget,
+  CatchUpWidget: widgets.CatchUpWidget,
+  ChartWidget: widgets.ChartWidget,
+  ContainerWidget: widgets.ContainerWidget,
+  EmbedWidget: widgets.EmbedWidget,
+  ImageWidget: widgets.ImageWidget,
+  LayoutWidget: widgets.LayoutWidget,
+  ListWidget: widgets.ListWidget,
+  MySiteWidget: widgets.MySiteWidget,
+  NestedWidget: widgets.NestedWidget,
+  QuickShareWidget: widgets.QuickShareWidget,
+  RecentActivityWidget: widgets.RecentActivityWidget,
+  SpacerWidget: widgets.SpacerWidget,
+  TableWidget: widgets.TableWidget,
+  TextWidget: widgets.TextWidget,
+  ToDoWidget: widgets.ToDoWidget,
+  VideoWidget: widgets.VideoWidget
+});
+var FluidContext = react.createContext(null);
+function FluidProvider({
+  config,
+  children,
+  queryClient,
+  initialTheme,
+  themeContainer,
+  widgetRegistry,
+  variables
+}) {
+  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 getApiHeaders = react.useCallback(() => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const getAuthToken = configRef.current.getAuthToken;
+    if (typeof getAuthToken === "function") {
+      const tokenOrPromise = getAuthToken();
+      if (typeof tokenOrPromise === "string") {
+        headers.Authorization = `Bearer ${tokenOrPromise}`;
+      }
+    }
+    return headers;
+  }, []);
+  const dataSourceBaseUrl = react.useMemo(() => {
+    const base = config.baseUrl.replace(/\/+$/, "");
+    return base.endsWith("/api") ? base : `${base}/api`;
+  }, [config.baseUrl]);
+  const authContext = useFluidAuthOptional();
+  const autoVariables = react.useMemo(() => {
+    if (authContext?.user?.id != null) {
+      return { rep_id: String(authContext.user.id) };
+    }
+    return void 0;
+  }, [authContext?.user?.id]);
+  const effectiveVariables = variables ?? autoVariables;
+  const themeProviderProps = {
+    ...initialTheme !== void 0 && { initialTheme },
+    ...themeContainer !== void 0 && { container: themeContainer }
+  };
+  const registry = widgetRegistry ?? DEFAULT_SDK_WIDGET_REGISTRY;
+  return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClient ?? defaultQueryClient, children: /* @__PURE__ */ jsxRuntime.jsx(FluidContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(
+    registryContext.DataSourceRegistryProvider,
+    {
+      baseUrl: dataSourceBaseUrl,
+      getApiHeaders,
+      variables: effectiveVariables,
+      children: /* @__PURE__ */ jsxRuntime.jsx(contexts.RegistryProvider, { registry, 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/hooks/use-fluid-api.ts
+function useFluidApi() {
+  const { client } = useFluidContext();
+  return client;
+}
+
+// src/messaging/use-messaging-auth.ts
+var USERS_ME_QUERY_KEY = ["fluid", "users", "me"];
+function useMessagingAuth() {
+  const auth = useFluidAuthContext();
+  const api = useFluidApi();
+  const {
+    data: userMe,
+    isLoading: isUserMeLoading,
+    isError
+  } = reactQuery.useQuery({
+    queryKey: USERS_ME_QUERY_KEY,
+    queryFn: () => api.users.me(),
+    enabled: auth.isAuthenticated,
+    staleTime: Infinity,
+    retry: 1
+  });
+  if (auth.isLoading || auth.isAuthenticated && isUserMeLoading) {
+    return {
+      recipientId: null,
+      companyId: null,
+      currentUser: null,
+      isLoading: true
+    };
+  }
+  if (!auth.isAuthenticated || isError || !userMe) {
+    return {
+      recipientId: null,
+      companyId: null,
+      currentUser: null,
+      isLoading: false
+    };
+  }
+  const currentUser = userMe.recipient_id ? {
+    id: userMe.id,
+    recipientId: userMe.recipient_id,
+    firstName: userMe.first_name ?? "",
+    lastName: userMe.last_name ?? "",
+    email: userMe.email,
+    ...userMe.image_url != null && { imageUrl: userMe.image_url },
+    ...userMe.affiliate_id != null && {
+      affiliateId: userMe.affiliate_id
+    }
+  } : null;
+  return {
+    recipientId: userMe.recipient_id,
+    companyId: userMe.company_id ?? null,
+    currentUser,
+    isLoading: false
+  };
+}
+function deriveWebsocketUrl(baseUrl) {
+  const base = baseUrl.replace(/\/+$/, "").replace(/\/api$/, "");
+  return `${base}/cable`;
+}
+function useMessagingConfig() {
+  const { config } = useFluidContext();
+  const auth = useFluidAuthContext();
+  const getHeaders = react.useCallback(async () => {
+    const headers = {
+      "Content-Type": "application/json",
+      ...config.defaultHeaders
+    };
+    if (config.getAuthToken) {
+      const token = await config.getAuthToken();
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+    }
+    return headers;
+  }, [config]);
+  const apiBaseUrl = react.useMemo(() => {
+    const base = config.baseUrl.replace(/\/+$/, "");
+    return base.endsWith("/api") ? base : `${base}/api`;
+  }, [config.baseUrl]);
+  const apiConfig = react.useMemo(
+    () => ({
+      baseUrl: apiBaseUrl,
+      getHeaders,
+      ...config.onAuthError != null && { onAuthError: config.onAuthError }
+    }),
+    [apiBaseUrl, config.onAuthError, getHeaders]
+  );
+  const websocketUrl = react.useMemo(
+    () => config.websocketUrl ?? deriveWebsocketUrl(config.baseUrl),
+    [config.websocketUrl, config.baseUrl]
+  );
+  return {
+    apiConfig,
+    websocketUrl,
+    token: auth.token
+  };
+}
+var FILESTACK_UPLOAD_URL = "https://www.filestackapi.com/api/store/S3";
+function getImageDimensions(file) {
+  if (!file.type.startsWith("image/")) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const img = new Image();
+    const url = URL.createObjectURL(file);
+    img.onload = () => {
+      URL.revokeObjectURL(url);
+      resolve({ width: img.naturalWidth, height: img.naturalHeight });
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      resolve(null);
+    };
+    img.src = url;
+  });
+}
+function uploadToFilestack(file, apiKey, callbacks) {
+  const xhr = new XMLHttpRequest();
+  let aborted = false;
+  getImageDimensions(file).then((metadata) => {
+    if (aborted) return;
+    const url = `${FILESTACK_UPLOAD_URL}?key=${encodeURIComponent(apiKey)}`;
+    xhr.open("POST", url);
+    xhr.setRequestHeader("Content-Type", file.type);
+    xhr.upload.onprogress = (event) => {
+      if (event.lengthComputable) {
+        const progress = Math.round(event.loaded / event.total * 100);
+        callbacks.onProgress(progress);
+      }
+    };
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try {
+          const response = JSON.parse(xhr.responseText);
+          const result = {
+            url: response.url,
+            size: file.size,
+            mimetype: file.type,
+            kind: fluidMessagingCore.getFileTypeFromMimetype(file.type),
+            metadata
+          };
+          callbacks.onSuccess(result);
+        } catch {
+          callbacks.onError(new Error("Failed to parse upload response"));
+        }
+      } else {
+        callbacks.onError(
+          new Error(`Upload failed with status ${xhr.status}`)
+        );
+      }
+    };
+    xhr.onerror = () => {
+      if (!aborted) {
+        callbacks.onError(new Error("Upload failed due to a network error"));
+      }
+    };
+    xhr.onabort = () => {
+    };
+    xhr.send(file);
+  }).catch((error) => {
+    if (!aborted) {
+      callbacks.onError(
+        error instanceof Error ? error : new Error("Upload preparation failed")
+      );
+    }
+  });
+  return {
+    abort: () => {
+      aborted = true;
+      xhr.abort();
+    }
+  };
+}
+function createFluidFileUploader(apiKey) {
+  if (!apiKey) {
+    return {
+      uploadFile: (_file, callbacks) => {
+        callbacks.onError(
+          new Error(
+            "File uploads are not configured. Set filestackApiKey in your SDK config to enable attachments."
+          )
+        );
+        return { abort: () => {
+        } };
+      }
+    };
+  }
+  return {
+    uploadFile: (file, callbacks) => uploadToFilestack(file, apiKey, callbacks)
+  };
+}
+function renderImage(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "img",
+    {
+      src: props.src,
+      alt: props.alt,
+      width: props.width,
+      height: props.height,
+      className: props.className
+    }
+  );
+}
+function defaultToast(message, type) {
+  if (type === "error") {
+    console.warn("[Messaging]", message);
+  }
+}
+function MessagingScreen({
+  onToast,
+  filestackApiKey,
+  websocketUrl: websocketUrlOverride,
+  /* eslint-disable @typescript-eslint/no-unused-vars -- destructured to exclude from divProps spread */
+  background,
+  textColor,
+  accentColor,
+  padding,
+  borderRadius,
+  /* eslint-enable @typescript-eslint/no-unused-vars */
+  ...divProps
+}) {
+  const { config } = useFluidContext();
+  const { apiConfig, websocketUrl, token } = useMessagingConfig();
+  const messagingAuth = useMessagingAuth();
+  const effectiveApiKey = filestackApiKey ?? config.filestackApiKey;
+  const uploader = react.useMemo(
+    () => createFluidFileUploader(effectiveApiKey),
+    [effectiveApiKey]
+  );
+  const effectiveWsUrl = websocketUrlOverride ?? websocketUrl;
+  const effectiveToast = onToast ?? defaultToast;
+  const searchUsers = react.useCallback(
+    async (query) => {
+      const result = await fluidMessagingApiClient.listConnectedRecipients(apiConfig, {
+        filterrific: { search_query: query },
+        per_page: 10,
+        page: 1
+      });
+      const recipients = result?.[1]?.items ?? [];
+      return recipients.map((user) => {
+        const hasName = [user.first_name, user.last_name].filter(Boolean).length > 0;
+        const name = hasName ? [user.first_name, user.last_name].filter(Boolean).join(" ") : `User ${user.id}`;
+        return {
+          id: String(user.id),
+          label: name,
+          imageType: "user",
+          userData: {
+            first_name: user.first_name,
+            last_name: user.last_name,
+            image_url: user.avatar_url,
+            phone: user.phone || void 0,
+            email: user.email || void 0
+          },
+          conversationName: name
+        };
+      });
+    },
+    [apiConfig]
+  );
+  const searchChannels = react.useCallback(
+    async (query) => {
+      const channels = await fluidMessagingApiClient.searchConversations(apiConfig, {
+        filterrific: { search_query: query }
+      }) ?? [];
+      return channels.map((channel) => {
+        const { text: nameWithoutEmoji } = fluidMessagingUi.extractEmoji(channel.name);
+        return {
+          id: `channel-${channel.id}`,
+          label: fluidMessagingUi.formatMessageChannelName(nameWithoutEmoji),
+          imageType: "channel",
+          userData: {
+            first_name: channel.name,
+            last_name: null,
+            image_url: channel.avatar_url
+          },
+          conversationName: channel.name
+        };
+      });
+    },
+    [apiConfig]
+  );
+  if (messagingAuth.isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ...divProps,
+        className: `flex h-full items-center justify-center ${divProps.className ?? ""}`,
+        children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-muted-foreground", children: "Loading messaging..." })
+      }
+    );
+  }
+  if (!messagingAuth.recipientId) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ...divProps,
+        className: `flex h-full items-center justify-center ${divProps.className ?? ""}`,
+        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "max-w-sm rounded-lg border border-dashed border-border p-8 text-center", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "text-xl font-semibold text-foreground", children: "Messaging" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-2 text-muted-foreground", children: "Messaging is not available for your account" })
+        ] })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ...divProps, className: `h-full ${divProps.className ?? ""}`, children: /* @__PURE__ */ jsxRuntime.jsx(
+    app.MessagingApp,
+    {
+      config: apiConfig,
+      auth: messagingAuth,
+      websocketUrl: effectiveWsUrl,
+      token,
+      renderImage,
+      showAdminFeatures: false,
+      onToast: effectiveToast,
+      messagesViewProps: {
+        uploader,
+        saveDrafts: true,
+        onToast: effectiveToast
+      },
+      newMessageViewProps: {
+        searchUsers,
+        searchChannels
+      }
+    }
+  ) });
+}
+var messagingScreenPropertySchema = {
+  widgetType: "MessagingScreen",
+  displayName: "Messaging Screen",
+  tabsConfig: [{ id: "styling", label: "Styling" }],
+  fields: []
+};
+
+Object.defineProperty(exports, "buildThemeDefinition", {
+  enumerable: true,
+  get: function () { return theme_star.buildThemeDefinition; }
+});
+Object.defineProperty(exports, "getActiveThemeId", {
+  enumerable: true,
+  get: function () { return theme_star.getActiveThemeId; }
+});
+Object.defineProperty(exports, "transformThemes", {
+  enumerable: true,
+  get: function () { return theme_star.transformThemes; }
+});
+exports.AUTH_CONSTANTS = AUTH_CONSTANTS;
+exports.ApiError = ApiError2;
+exports.DEFAULT_AUTH_URL = DEFAULT_AUTH_URL;
+exports.DEFAULT_SDK_WIDGET_REGISTRY = DEFAULT_SDK_WIDGET_REGISTRY;
+exports.FluidAuthProvider = FluidAuthProvider;
+exports.FluidProvider = FluidProvider;
+exports.FluidThemeProvider = FluidThemeProvider;
+exports.MessagingScreen = MessagingScreen;
+exports.STORAGE_KEYS = STORAGE_KEYS;
+exports.URL_PARAMS = URL_PARAMS;
+exports.USER_TYPES = USER_TYPES;
+exports.cleanTokenFromUrl = cleanTokenFromUrl;
+exports.clearTokens = clearTokens;
+exports.createDefaultAuthRedirect = createDefaultAuthRedirect;
+exports.createFluidClient = createFluidClient;
+exports.createFluidFileUploader = createFluidFileUploader;
+exports.decodeToken = decodeToken;
+exports.extractAllTokensFromUrl = extractAllTokensFromUrl;
+exports.extractCompanyTokenFromUrl = extractCompanyTokenFromUrl;
+exports.extractTokenFromUrl = extractTokenFromUrl;
+exports.getStoredToken = getStoredToken;
+exports.getTokenExpiration = getTokenExpiration;
+exports.getTokenTimeRemaining = getTokenTimeRemaining;
+exports.hasStoredToken = hasStoredToken;
+exports.hasTokenInUrl = hasTokenInUrl;
+exports.isApiError = isApiError2;
+exports.isTokenExpired = isTokenExpired;
+exports.isUserType = isUserType;
+exports.isValidToken = isValidToken;
+exports.messagingScreenPropertySchema = messagingScreenPropertySchema;
+exports.normalizeComponentTree = normalizeComponentTree;
+exports.storeToken = storeToken;
+exports.themes_exports = themes_exports;
+exports.toNavigationItem = toNavigationItem;
+exports.toScreenDefinition = toScreenDefinition;
+exports.transformManifestToRepAppData = transformManifestToRepAppData;
+exports.useFluidApi = useFluidApi;
+exports.useFluidAuthContext = useFluidAuthContext;
+exports.useFluidContext = useFluidContext;
+exports.useMessagingAuth = useMessagingAuth;
+exports.useMessagingConfig = useMessagingConfig;
+exports.useThemeContext = useThemeContext;
+exports.validateToken = validateToken;
+//# sourceMappingURL=chunk-V3IMQZIG.cjs.map
+//# sourceMappingURL=chunk-V3IMQZIG.cjs.map