@kasuvia/sdk 0.0.8 → 0.0.9

package/src/hooks/use-service-booking.ts

@@ -11,170 +11,147 @@ import {
   getAppointments,
   getAppointment,
   cancelAppointment,
-  getDeliverables,
-  approveDeliverable,
-  requestRevision,
+  rescheduleAppointment,
+  disputeAppointment,
+  confirmAppointmentCompletion,
+  getMilestones,
+  approveMilestone,
 } from '../services/service-booking.service'
 import type { SdkConfig } from '../config'
 import type {
+  ServiceAppointment,
   ServiceAppointmentCreatePayload,
+  CancelAppointmentPayload,
+  RescheduleAppointmentPayload,
+  DisputeAppointmentPayload,
+  ConfirmAppointmentPayload,
+  ApproveMilestonePayload,
 } from '../types/services'
-import { logger } from '../utils'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
 
 export function useAvailableSlots(
-  arg1?: SdkConfig | string,
-  arg2?: string,
-  arg3?: string,
-  arg4?: string
+  config: SdkConfig | undefined,
+  productId: string | undefined,
+  date: string | undefined,
+  params?: { staffId?: string; locationId?: string; customerLatitude?: number; customerLongitude?: number }
 ) {
   const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const product_id = isArg1Config ? arg2 : (typeof arg1 === 'string' ? arg1 : undefined)
-  const date_from = isArg1Config ? arg3 : (typeof arg2 === 'string' ? arg2 : undefined)
-  const date_to = isArg1Config ? arg4 : (typeof arg3 === 'string' ? arg3 : undefined)
-
-  try {
-    const { config: cfg } = resolveHookArgs(explicitConfig, undefined, ctx)
-    return useQuery({
-      queryKey: ["available-slots", product_id, date_from, date_to],
-      queryFn: () => getAvailableSlots(cfg, product_id!, date_from!, date_to!),
-      enabled: !!product_id && !!date_from && !!date_to,
-    })
-  } catch (error) {
-    logger.warn('[useAvailableSlots] Called outside QueryClientProvider, returning undefined')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ["available-slots", productId, date, params?.staffId, params?.locationId],
+    queryFn: () => getAvailableSlots(cfg, productId!, date!, params),
+    enabled: !!productId && !!date,
+  })
 }
 
 export function useBookAppointment(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (payload: ServiceAppointmentCreatePayload) =>
-        token ? bookAppointment(cfg, token, payload) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ["appointments"] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useBookAppointment] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (payload: ServiceAppointmentCreatePayload) =>
+      token ? bookAppointment(cfg, token, payload) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+    },
+  })
 }
 
-export function useAppointments(config?: SdkConfig, accessToken?: string | null) {
+export function useAppointments(
+  config?: SdkConfig,
+  accessToken?: string | null,
+  params?: { status?: ServiceAppointment['status']; page?: number; page_size?: number }
+) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    return useQuery({
-      queryKey: ["appointments"],
-      queryFn: () => token ? getAppointments(cfg, token) : Promise.resolve([]),
-      enabled: !!token,
-    })
-  } catch (error) {
-    logger.warn('[useAppointments] Called outside QueryClientProvider, returning empty list')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  return useQuery({
+    queryKey: ["appointments", params?.status, params?.page, params?.page_size],
+    queryFn: () => token ? getAppointments(cfg, token, params) : Promise.reject(new Error('No access token available')),
+    enabled: !!token,
+  })
 }
 
-export function useAppointment(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
+export function useAppointment(config: SdkConfig | undefined, accessToken: string | null | undefined, id: string | undefined) {
   const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
-  const id = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
-
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    return useQuery({
-      queryKey: ["appointment", id],
-      queryFn: () => token && id ? getAppointment(cfg, token, id) : Promise.resolve(undefined),
-      enabled: !!id && !!token,
-    })
-  } catch (error) {
-    logger.warn('[useAppointment] Called outside QueryClientProvider, returning undefined')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  return useQuery({
+    queryKey: ["appointment", id],
+    queryFn: () => token && id ? getAppointment(cfg, token, id) : Promise.reject(new Error('Missing appointment ID or access token')),
+    enabled: !!id && !!token,
+  })
 }
 
 export function useCancelAppointment(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (id: string) =>
-        token ? cancelAppointment(cfg, token, id) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ["appointments"] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useCancelAppointment] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload?: CancelAppointmentPayload }) =>
+      token ? cancelAppointment(cfg, token, id, payload) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+    },
+  })
+}
+
+export function useRescheduleAppointment(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload: RescheduleAppointmentPayload }) =>
+      token ? rescheduleAppointment(cfg, token, id, payload) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+    },
+  })
 }
 
-export function useDeliverables(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
+export function useDisputeAppointment(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  const isArg1Config = typeof arg1 === 'object' && arg1 !== null && 'businessId' in arg1
-  const explicitConfig = isArg1Config ? (arg1 as SdkConfig) : undefined
-  const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
-  const order_id = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload: DisputeAppointmentPayload }) =>
+      token ? disputeAppointment(cfg, token, id, payload) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+    },
+  })
+}
 
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    return useQuery({
-      queryKey: ["deliverables", order_id],
-      queryFn: () => token && order_id ? getDeliverables(cfg, token, order_id) : Promise.resolve([]),
-      enabled: !!order_id && !!token,
-    })
-  } catch (error) {
-    logger.warn('[useDeliverables] Called outside QueryClientProvider, returning empty list')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+export function useConfirmAppointmentCompletion(config?: SdkConfig, accessToken?: string | null) {
+  const ctx = useSdkContext()
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, payload }: { id: string; payload?: ConfirmAppointmentPayload }) =>
+      token ? confirmAppointmentCompletion(cfg, token, id, payload) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+    },
+  })
 }
 
-export function useApproveDeliverable(config?: SdkConfig, accessToken?: string | null, order_id?: string, deliverable_id?: string) {
+export function useMilestones(config: SdkConfig | undefined, accessToken: string | null | undefined, bookingId: string | undefined) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: () =>
-        token && order_id && deliverable_id
-          ? approveDeliverable(cfg, token, order_id, deliverable_id)
-          : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useApproveDeliverable] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  return useQuery({
+    queryKey: ["milestones", bookingId],
+    queryFn: () => token && bookingId ? getMilestones(cfg, token, bookingId) : Promise.reject(new Error('Missing booking ID or access token')),
+    enabled: !!bookingId && !!token,
+  })
 }
 
-export function useRequestRevision(config?: SdkConfig, accessToken?: string | null, order_id?: string, deliverable_id?: string) {
+export function useApproveMilestone(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (feedback: string) =>
-        token && order_id && deliverable_id
-          ? requestRevision(cfg, token, order_id, deliverable_id, feedback)
-          : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] })
-      },
-    })
-  } catch (error) {
-    logger.warn('[useRequestRevision] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ bookingId, milestoneId, payload }: { bookingId: string; milestoneId: string; payload?: ApproveMilestonePayload }) =>
+      token ? approveMilestone(cfg, token, bookingId, milestoneId, payload) : Promise.reject(new Error('No access token available')),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["milestones", variables.bookingId] })
+    },
+  })
 }

package/src/hooks/use-states.ts

@@ -7,42 +7,28 @@
 import { useQuery } from '@tanstack/react-query'
 import type { SdkConfig } from '../config'
 import type { State } from '../types/ui'
-import { logger } from '../utils'
 import { useSdkContext, resolveHookArgs } from '../context/sdk-context'
+import { apiRequest, storefrontHeaders } from '../utils/http-client'
 
+/** Raw fetch() -> apiRequest, same fix as use-countries.ts. */
 export async function getStates(config: SdkConfig, countryIso: string): Promise<State[]> {
-  if (!countryIso) return []
-  const response = await fetch(`${config.backendUrls.auth}/auth/countries/?iso=${countryIso}`, {
-    headers: {
-      "X-Storefront-Key": config.storefrontApiKey,
-      "X-Business-ID": config.businessId,
-    },
+  if (!countryIso) throw new Error('Country ISO is required to fetch states')
+  return apiRequest<State[]>(`${config.backendUrls.auth}/auth/countries/${encodeURIComponent(countryIso)}/states/`, {
+    headers: storefrontHeaders(config),
+    fallbackErrorMessage: 'Failed to fetch states',
   })
-  if (!response.ok) throw new Error('Failed to fetch states')
-  return response.json()
 }
 
 export function useStates(countryIso: string, config?: SdkConfig) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg } = resolveHookArgs(config, undefined, ctx)
-    return useQuery({
-      queryKey: ['states', countryIso],
-      queryFn: () => getStates(cfg, countryIso),
-      enabled: !!countryIso,
-      retry: 1,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      staleTime: 24 * 60 * 60 * 1000,
-    })
-  } catch (error) {
-    logger.warn('[useStates] Called outside QueryClientProvider, returning empty list')
-    return {
-      data: [],
-      isLoading: false,
-      error: null,
-      isFetching: false,
-      refetch: () => Promise.resolve({ data: [] }),
-    } as any
-  }
+  const { config: cfg } = resolveHookArgs(config, undefined, ctx)
+  return useQuery({
+    queryKey: ['states', countryIso],
+    queryFn: () => getStates(cfg, countryIso),
+    enabled: !!countryIso,
+    retry: 1,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    staleTime: 24 * 60 * 60 * 1000,
+  })
 }

package/src/hooks/use-wishlist.ts

@@ -29,18 +29,13 @@ export function useWishlist(arg1?: SdkConfig | { page?: number; pageSize?: numbe
   const explicitToken = isArg1Config ? arg2 : undefined
   const params = isArg1Config ? arg3 : (arg1 as { page?: number; pageSize?: number } | undefined)
 
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    return useQuery({
-      queryKey: [...wishlistKeys.list(), params],
-      queryFn: () => token ? getWishlist(cfg, token, params) : Promise.resolve(undefined),
-      enabled: !!token,
-      ...getCacheTier('medium'),
-    })
-  } catch (error) {
-    console.warn('[useWishlist] Called outside QueryClientProvider, returning empty wishlist')
-    return { data: undefined, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: undefined }) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
+  return useQuery({
+    queryKey: [...wishlistKeys.list(), params],
+    queryFn: () => token ? getWishlist(cfg, token, params) : Promise.reject(new Error('No access token available')),
+    enabled: !!token,
+    ...getCacheTier('medium'),
+  })
 }
 
 export function useCheckInWishlist(arg1?: SdkConfig | string, arg2?: string | null, arg3?: string) {
@@ -50,73 +45,53 @@ export function useCheckInWishlist(arg1?: SdkConfig | string, arg2?: string | nu
   const explicitToken = isArg1Config ? (arg2 as string | null) : undefined
   const productId = isArg1Config ? arg3 : (typeof arg1 === 'string' ? arg1 : undefined)
 
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
-    return useQuery({
-      queryKey: wishlistKeys.check(productId ?? ''),
-      queryFn: () => token && productId ? checkInWishlist(cfg, token, productId) : Promise.resolve({ in_wishlist: false }),
-      ...getCacheTier('low'),
-      enabled: !!productId && !!token,
-    })
-  } catch (error) {
-    console.warn('[useCheckInWishlist] Called outside QueryClientProvider, returning false')
-    return { data: false, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: false }) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx)
+  return useQuery({
+    queryKey: wishlistKeys.check(productId ?? ''),
+    queryFn: () => token && productId ? checkInWishlist(cfg, token, productId) : Promise.resolve({ in_wishlist: false }),
+    ...getCacheTier('low'),
+    enabled: !!productId && !!token,
+  })
 }
 
 export function useAddToWishlist(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: ({ productId, notes }: { productId: string; notes?: string }) =>
-        token ? addToWishlist(cfg, token, productId, notes) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
-        queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
-      },
-    })
-  } catch (error) {
-    console.warn('[useAddToWishlist] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ productId, notes }: { productId: string; notes?: string }) =>
+      token ? addToWishlist(cfg, token, productId, notes) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
+      queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
+    },
+  })
 }
 
 export function useRemoveFromWishlist(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (itemId: string) =>
-        token ? removeFromWishlist(cfg, token, itemId) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
-        queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
-      },
-    })
-  } catch (error) {
-    console.warn('[useRemoveFromWishlist] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (itemId: string) =>
+      token ? removeFromWishlist(cfg, token, itemId) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
+      queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
+    },
+  })
 }
 
 export function useRemoveProductFromWishlist(config?: SdkConfig, accessToken?: string | null) {
   const ctx = useSdkContext()
-  try {
-    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
-    const queryClient = useQueryClient()
-    return useMutation({
-      mutationFn: (productId: string) =>
-        token ? removeProductFromWishlist(cfg, token, productId) : Promise.reject('No access token'),
-      onSuccess: () => {
-        queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
-        queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
-      },
-    })
-  } catch (error) {
-    console.warn('[useRemoveProductFromWishlist] Called outside QueryClientProvider, returning no-op mutation')
-    return { mutate: () => {}, mutateAsync: () => Promise.resolve(undefined) } as any
-  }
+  const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx)
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (productId: string) =>
+      token ? removeProductFromWishlist(cfg, token, productId) : Promise.reject(new Error('No access token available')),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: wishlistKeys.all })
+      queryClient.invalidateQueries({ queryKey: ['wishlist', 'check'] })
+    },
+  })
 }

package/src/index.ts

@@ -40,23 +40,27 @@ export { STORAGE_KEYS, PAYMENT_URLS } from './constants'
 
 // Types
 export * from './types'
+export * from './generated'
 
 // Services (for server components)
 export * from './services'
 
 // Utils
-export { getCacheTier, setEnvironmentMode } from './utils/cache'
-export { logger, setLoggerEnvironmentMode } from './utils/logger'
-export * from './utils/sanitize-url'
-export * from './utils/customer'
-export * from './utils/checkout'
-export * from './utils/error-handler'
-export { sessionStore, localStore } from './utils/storage'
-export * from './utils/validators'
+// REAL DUPLICATION FIXED (2026-09-22): this used to hand-list every utils
+// submodule a second time, separately from utils/index.ts's own barrel —
+// two lists to keep in sync by hand, and they'd already drifted:
+// http-client.ts and graphql-url.ts (both touched/built this session) were
+// missing from this file entirely, meaning `apiRequest`/`ApiError`/
+// `createGraphQLClient` etc. were never actually reachable from the public
+// `@kasuvia/sdk` package a consumer imports, despite being real, complete,
+// consistency-critical pieces of the SDK. Delegates to the one real barrel
+// (utils/index.ts) instead of re-declaring the same list twice.
+export * from './utils'
 
 // App service functions
 export { googleTranslate } from './services/app.service'
 
-// Note: React Context providers and hooks are exported separately via '@kasuvia/sdk/hooks'
-// to avoid importing them in server components. Use:
-// import { SdkProvider, useSdkContext } from '@kasuvia/sdk/hooks'
+// Note: React components are exported separately via '@kasuvia/sdk/components'
+// and React Context providers & hooks are exported via '@kasuvia/sdk/hooks'
+// to maintain clear separation for server/client modules.
+