@kerne/react 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,655 +1,27 @@
-// src/provider.tsx
-import { createContext, useEffect, useMemo, useRef } from "react";
-import { Kerne } from "@kerne/server";
-import { jsx } from "react/jsx-runtime";
-var DEFAULT_STORAGE_KEY = "kerne_auth";
-var DEFAULT_REFRESH_BUFFER = 60;
-var KerneClient = class {
-  kerne;
-  storage;
-  storageKey;
-  onAuthChange;
-  autoRefresh;
-  refreshBuffer;
-  refreshTimer = null;
-  listeners = /* @__PURE__ */ new Set();
-  _user = null;
-  _token = null;
-  _refreshToken = null;
-  _expiresAt = null;
-  _isLoading = true;
-  // Public config properties
-  baseUrl;
-  appId;
-  constructor(config) {
-    this.baseUrl = config.baseUrl ?? "https://api.kerne.io";
-    this.appId = config.appId;
-    this.storage = config.storage ?? (typeof window !== "undefined" ? localStorage : null);
-    this.storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
-    this.onAuthChange = config.onAuthChange;
-    this.autoRefresh = config.autoRefresh ?? true;
-    this.refreshBuffer = config.refreshBuffer ?? DEFAULT_REFRESH_BUFFER;
-    this.kerne = new Kerne({
-      baseUrl: this.baseUrl,
-      appId: this.appId,
-      timeout: config.timeout,
-      onUnauthorized: () => {
-        if (process.env.NODE_ENV === "development") {
-          console.warn("[Kerne] 401 received. Auto-logout disabled in dev.");
-          return;
-        }
-        this.clearSession();
-      }
-    });
-    this.loadSession();
-  }
-  // ============================================================================
-  // Reactive State (useSyncExternalStore compatible)
-  // ============================================================================
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  notify() {
-    this.listeners.forEach((l) => l());
-  }
-  get user() {
-    return this._user;
-  }
-  get token() {
-    return this._token;
-  }
-  get isAuthenticated() {
-    return this._token !== null;
-  }
-  get isLoading() {
-    return this._isLoading;
-  }
-  // ============================================================================
-  // Session Management
-  // ============================================================================
-  loadSession() {
-    if (!this.storage) {
-      this._isLoading = false;
-      this.notify();
-      return;
-    }
-    try {
-      const data = this.storage.getItem(this.storageKey);
-      if (data) {
-        const { user, token, refresh_token, expires_at } = JSON.parse(data);
-        const expiresAt = expires_at ? new Date(expires_at) : null;
-        if (!expiresAt || expiresAt > /* @__PURE__ */ new Date()) {
-          this._user = user;
-          this._token = token;
-          this._refreshToken = refresh_token ?? null;
-          this._expiresAt = expiresAt;
-          this.kerne = this.kerne.withToken(token);
-          this.scheduleRefresh();
-        } else {
-          this.storage.removeItem(this.storageKey);
-        }
-      }
-    } catch (e) {
-      console.error("[Kerne] Failed to load session:", e);
-      this.storage?.removeItem(this.storageKey);
-    }
-    this._isLoading = false;
-    this.notify();
-  }
-  /**
-   * `AuthResponse.user` is the minimal `{id, email, role}` claim set the
-   * token endpoint returns, not the full profile (`User`) - so this always
-   * follows up with `users.me()` rather than assigning it directly (that
-   * used to leave `_user` looking like a `User` while actually missing
-   * `email_verified`/`first_name`/`avatar`/etc).
-   */
-  async saveSession(response) {
-    this._token = response.token;
-    this._refreshToken = response.refresh_token;
-    this._expiresAt = response.expires_at ? new Date(response.expires_at) : null;
-    this.kerne = this.kerne.withToken(response.token);
-    this._user = await this.kerne.users.me();
-    if (this.storage) {
-      this.storage.setItem(
-        this.storageKey,
-        JSON.stringify({
-          user: this._user,
-          token: response.token,
-          refresh_token: response.refresh_token,
-          expires_at: response.expires_at
-        })
-      );
-    }
-    this.scheduleRefresh();
-    this.onAuthChange?.(this._user);
-    this.notify();
-  }
-  clearSession() {
-    this._user = null;
-    this._token = null;
-    this._refreshToken = null;
-    this._expiresAt = null;
-    this.cancelRefresh();
-    if (this.storage) {
-      this.storage.removeItem(this.storageKey);
-    }
-    this.onAuthChange?.(null);
-    this.notify();
-  }
-  // ============================================================================
-  // Auto-Refresh
-  // ============================================================================
-  scheduleRefresh() {
-    if (!this.autoRefresh || !this._expiresAt) return;
-    this.cancelRefresh();
-    const now = Date.now();
-    const expiry = this._expiresAt.getTime();
-    const refreshAt = expiry - this.refreshBuffer * 1e3;
-    const delay = Math.max(0, refreshAt - now);
-    if (delay > 0) {
-      this.refreshTimer = setTimeout(() => this.silentRefresh(), delay);
-    }
-  }
-  cancelRefresh() {
-    if (this.refreshTimer) {
-      clearTimeout(this.refreshTimer);
-      this.refreshTimer = null;
-    }
-  }
-  async silentRefresh() {
-    if (!this._refreshToken) return;
-    try {
-      const response = await this.kerne.auth.refreshToken({ refresh_token: this._refreshToken });
-      await this.saveSession(response);
-      console.debug("[Kerne] Session refreshed silently");
-    } catch (e) {
-      console.warn("[Kerne] Silent refresh failed:", e);
-    }
-  }
-  // ============================================================================
-  // Auth Methods
-  // ============================================================================
-  async register(params) {
-    const [firstName, ...lastNameParts] = (params.name || "").split(" ");
-    const response = await this.kerne.auth.signup({
-      email: params.email,
-      password: params.password,
-      first_name: firstName || void 0,
-      last_name: lastNameParts.join(" ") || void 0,
-      invitationToken: params.invitationToken,
-      invitationCode: params.invitationCode
-    });
-    await this.saveSession(response);
-    return response;
-  }
-  async login(params) {
-    const response = await this.kerne.auth.login(params);
-    await this.saveSession(response);
-    return response;
-  }
-  /** Manually trigger a token refresh - normally handled automatically by `autoRefresh`. */
-  async refreshToken() {
-    if (!this._refreshToken) return null;
-    const response = await this.kerne.auth.refreshToken({ refresh_token: this._refreshToken });
-    await this.saveSession(response);
-    return response;
-  }
-  logout() {
-    this.clearSession();
-  }
-  async refreshUser() {
-    if (!this._token) return null;
-    try {
-      const user = await this.kerne.users.me();
-      this._user = user;
-      this.onAuthChange?.(user);
-      this.notify();
-      return user;
-    } catch {
-      this.clearSession();
-      return null;
-    }
-  }
-  // No `avatar` here - UpdateUserDto doesn't accept it server-side
-  // (`forbidNonWhitelisted` rejects the field with a 400).
-  async updateProfile(params) {
-    if (!this._user) throw new Error("User not authenticated");
-    const updated = await this.kerne.users.update(this._user.id, params);
-    this._user = updated;
-    if (this.storage && this._token) {
-      try {
-        const data = this.storage.getItem(this.storageKey);
-        if (data) {
-          const session = JSON.parse(data);
-          session.user = updated;
-          this.storage.setItem(this.storageKey, JSON.stringify(session));
-        }
-      } catch (e) {
-      }
-    }
-    this.onAuthChange?.(updated);
-    this.notify();
-    return updated;
-  }
-  async updatePassword(params) {
-    await this.kerne.auth.changePassword(params);
-  }
-  /** Forgot-password flow (logged out) - sends the reset email. */
-  async requestPasswordReset(email) {
-    await this.kerne.auth.requestPasswordReset(email);
-  }
-  /** Confirms a password reset with the token from the email. */
-  async confirmPasswordReset(token, password) {
-    await this.kerne.auth.confirmPasswordReset(token, password);
-  }
-  // ============================================================================
-  // Billing Methods
-  // ============================================================================
-  /**
-   * Errors are not swallowed here (unlike the old implementation, which
-   * caught everything and returned `false`) - a 401/500 must not be
-   * indistinguishable from a real denial, that's exactly what let the
-   * `has_access`/`allowed` mismatch below ship unnoticed. Callers that want
-   * a fail-closed boolean regardless of the reason (e.g. `<Allows>`)
-   * catch around this themselves.
-   */
-  async allows(featureKey, requested) {
-    const check = await this.kerne.check(featureKey, { requested });
-    return check.allowed;
-  }
-  /** Full entitlement detail (limit/used/remaining/overage) - use `allows()` for a plain boolean. */
-  async check(featureKey, requested) {
-    return this.kerne.check(featureKey, { requested });
-  }
-  async createCheckout(planPriceId, options) {
-    const { url } = await this.kerne.billing.checkout(planPriceId, options);
-    return url;
-  }
-  async openCheckout(planPriceId, options) {
-    const url = await this.createCheckout(planPriceId, options);
-    if (typeof window !== "undefined") window.location.href = url;
-  }
-  async createPortal(returnUrl) {
-    const { url } = await this.kerne.billing.portal({ returnUrl });
-    return url;
-  }
-  async openPortal(returnUrl) {
-    const url = await this.createPortal(returnUrl);
-    if (typeof window !== "undefined") window.location.href = url;
-  }
-  async getSubscription(productSlug) {
-    const subs = await this.kerne.billing.subscriptions.list({
-      productSlug,
-      scopeType: "USER"
-    });
-    const active = subs.find(
-      (s) => s.status === "ACTIVE" || s.status === "TRIALING" || s.status === "PAST_DUE"
-    );
-    return active ?? null;
-  }
-  /** Public pricing data - omit `productIdOrSlug` for the tenant's default product. */
-  async getPlans(productIdOrSlug) {
-    return this.kerne.billing.plans(productIdOrSlug);
-  }
-  /** Every entitlement for the current user in one call - for a "your plan" screen. */
-  async getEntitlements() {
-    return this.kerne.entitlements();
-  }
-  /** Usage for the current user - all QUOTA features, or one via `featureKey`. */
-  async getUsage(featureKey) {
-    return this.kerne.usage({ featureKey });
-  }
-  // ============================================================================
-  // Growth Methods (waitlist, invitations)
-  // ============================================================================
-  async joinWaitlist(params) {
-    return this.kerne.waitlist.join(params);
-  }
-  /** Validate an invitation token before showing the registration form. */
-  async validateInvitationToken(token) {
-    return this.kerne.invitations.validateToken(token);
-  }
-  /** Validate an invitation code before showing the registration form. */
-  async validateInvitationCode(code) {
-    return this.kerne.invitations.validateCode(code);
-  }
-  // ============================================================================
-  // Email Verification Methods
-  // ============================================================================
-  async sendVerificationEmail(verificationType = "code") {
-    await this.kerne.auth.sendVerificationEmail(verificationType);
-  }
-  async verifyEmailWithCode(code) {
-    return await this.kerne.auth.verifyEmailWithCode(code);
-  }
-  async verifyEmailWithLink(token) {
-    return await this.kerne.auth.verifyEmailWithLink(token);
-  }
-  async getVerificationStatus() {
-    return await this.kerne.auth.getVerificationStatus();
-  }
-};
-var KerneContext = createContext(null);
-function KerneProvider({ children, ...config }) {
-  const clientRef = useRef(null);
-  const client = useMemo(() => {
-    if (!clientRef.current) {
-      clientRef.current = new KerneClient(config);
-    }
-    return clientRef.current;
-  }, [config.appId, config.baseUrl]);
-  useEffect(() => {
-    return () => {
-      client.cancelRefresh?.();
-    };
-  }, [client]);
-  return /* @__PURE__ */ jsx(KerneContext.Provider, { value: client, children });
-}
-
-// src/hooks.ts
-import { useContext, useSyncExternalStore, useCallback, useEffect as useEffect2, useState } from "react";
-function useClient() {
-  const context = useContext(KerneContext);
-  if (!context) {
-    throw new Error("useClient must be used within a KerneProvider");
-  }
-  return context;
-}
-function useAuth() {
-  const client = useClient();
-  const user = useSyncExternalStore(
-    (callback) => client.subscribe(callback),
-    () => client.user,
-    () => client.user
-    // Server snapshot
-  );
-  const token = useSyncExternalStore(
-    (callback) => client.subscribe(callback),
-    () => client.token,
-    () => null
-    // Server always null
-  );
-  const isAuthenticated = useSyncExternalStore(
-    (callback) => client.subscribe(callback),
-    () => client.isAuthenticated,
-    () => false
-    // Server always unauthenticated
-  );
-  const isLoading = useSyncExternalStore(
-    (callback) => client.subscribe(callback),
-    () => client.isLoading,
-    () => true
-    // Server always loading
-  );
-  return {
-    user,
-    token,
-    isAuthenticated,
-    isLoading,
-    login: useCallback(
-      (params) => client.login(params),
-      [client]
-    ),
-    register: useCallback(
-      (params) => client.register(params),
-      [client]
-    ),
-    logout: useCallback(() => client.logout(), [client]),
-    refreshUser: useCallback(() => client.refreshUser(), [client]),
-    refreshToken: useCallback(() => client.refreshToken(), [client]),
-    updateProfile: useCallback(
-      (params) => client.updateProfile(params),
-      [client]
-    ),
-    updatePassword: useCallback(
-      (params) => client.updatePassword(params),
-      [client]
-    ),
-    requestPasswordReset: useCallback(
-      (email) => client.requestPasswordReset(email),
-      [client]
-    ),
-    confirmPasswordReset: useCallback(
-      (token2, password) => client.confirmPasswordReset(token2, password),
-      [client]
-    ),
-    // Email verification
-    sendVerificationEmail: useCallback(
-      (verificationType = "code") => client.sendVerificationEmail(verificationType),
-      [client]
-    ),
-    verifyEmailWithCode: useCallback((code) => client.verifyEmailWithCode(code), [client]),
-    verifyEmailWithLink: useCallback(
-      (token2) => client.verifyEmailWithLink(token2),
-      [client]
-    ),
-    getVerificationStatus: useCallback(() => client.getVerificationStatus(), [client])
-  };
-}
-function useCheckout() {
-  const client = useClient();
-  return {
-    createCheckout: useCallback(
-      (planPriceId, options) => client.createCheckout(planPriceId, options),
-      [client]
-    ),
-    openCheckout: useCallback(
-      (planPriceId, options) => client.openCheckout(planPriceId, options),
-      [client]
-    )
-  };
-}
-function usePortal() {
-  const client = useClient();
-  return {
-    createPortal: useCallback((returnUrl) => client.createPortal(returnUrl), [client]),
-    openPortal: useCallback((returnUrl) => client.openPortal(returnUrl), [client])
-  };
-}
-function useAllows(featureKey, requested) {
-  const client = useClient();
-  const [state, setState] = useState({
-    allowed: false,
-    isLoading: true,
-    error: null
-  });
-  useEffect2(() => {
-    let mounted = true;
-    client.allows(featureKey, requested).then((allowed) => {
-      if (mounted) {
-        setState({ allowed, isLoading: false, error: null });
-      }
-    }).catch((error) => {
-      if (mounted) {
-        setState({ allowed: false, isLoading: false, error });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [client, featureKey, requested]);
-  return state;
-}
-function useCheck(featureKey, requested) {
-  const client = useClient();
-  const [state, setState] = useState({
-    check: null,
-    isLoading: true,
-    error: null
-  });
-  useEffect2(() => {
-    let mounted = true;
-    client.check(featureKey, requested).then((check) => {
-      if (mounted) {
-        setState({ check, isLoading: false, error: null });
-      }
-    }).catch((error) => {
-      if (mounted) {
-        setState({ check: null, isLoading: false, error });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [client, featureKey, requested]);
-  return state;
-}
-function useSubscription(productSlug) {
-  const client = useClient();
-  const [state, setState] = useState({
-    subscription: null,
-    isLoading: true,
-    error: null
-  });
-  useEffect2(() => {
-    let mounted = true;
-    client.getSubscription(productSlug).then((subscription) => {
-      if (mounted) {
-        setState({ subscription, isLoading: false, error: null });
-      }
-    }).catch((error) => {
-      if (mounted) {
-        setState({ subscription: null, isLoading: false, error });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [client, productSlug]);
-  const isActive = state.subscription?.status === "ACTIVE" || state.subscription?.status === "TRIALING";
-  const planSlug = state.subscription?.plan?.slug;
-  return {
-    ...state,
-    isActive,
-    planSlug
-  };
-}
-function usePlans(productIdOrSlug) {
-  const client = useClient();
-  const [state, setState] = useState({
-    plans: [],
-    isLoading: true,
-    error: null
-  });
-  useEffect2(() => {
-    let mounted = true;
-    client.getPlans(productIdOrSlug).then((plans) => {
-      if (mounted) {
-        setState({ plans, isLoading: false, error: null });
-      }
-    }).catch((error) => {
-      if (mounted) {
-        setState({ plans: [], isLoading: false, error });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [client, productIdOrSlug]);
-  return state;
-}
-function useEntitlements() {
-  const client = useClient();
-  const [state, setState] = useState({
-    entitlements: null,
-    isLoading: true,
-    error: null
-  });
-  useEffect2(() => {
-    let mounted = true;
-    client.getEntitlements().then((entitlements) => {
-      if (mounted) {
-        setState({ entitlements, isLoading: false, error: null });
-      }
-    }).catch((error) => {
-      if (mounted) {
-        setState({ entitlements: null, isLoading: false, error });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [client]);
-  return state;
-}
-function useUsage(featureKey) {
-  const client = useClient();
-  const [state, setState] = useState({
-    usage: [],
-    isLoading: true,
-    error: null
-  });
-  useEffect2(() => {
-    let mounted = true;
-    client.getUsage(featureKey).then((usage) => {
-      if (mounted) {
-        setState({ usage, isLoading: false, error: null });
-      }
-    }).catch((error) => {
-      if (mounted) {
-        setState({ usage: [], isLoading: false, error });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [client, featureKey]);
-  return state;
-}
-function useWaitlist() {
-  const client = useClient();
-  return {
-    join: useCallback((params) => client.joinWaitlist(params), [client])
-  };
-}
-function useInvitation(params) {
-  const client = useClient();
-  const { token, code } = params;
-  const [state, setState] = useState({
-    result: null,
-    isLoading: !!(token || code),
-    error: null
-  });
-  useEffect2(() => {
-    if (!token && !code) {
-      setState({ result: null, isLoading: false, error: null });
-      return;
-    }
-    let mounted = true;
-    const validate = token ? client.validateInvitationToken(token) : client.validateInvitationCode(code);
-    validate.then((result) => {
-      if (mounted) {
-        setState({ result, isLoading: false, error: null });
-      }
-    }).catch((error) => {
-      if (mounted) {
-        setState({ result: null, isLoading: false, error });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [client, token, code]);
-  return state;
-}
-function useUser() {
-  const { user, isLoading, updateProfile } = useAuth();
-  return {
-    user,
-    isLoading,
-    update: updateProfile,
-    // Computed properties
-    fullName: user ? `${user.first_name || ""} ${user.last_name || ""}`.trim() : null,
-    initials: user ? `${user.first_name?.[0] || ""}${user.last_name?.[0] || ""}`.toUpperCase() : null,
-    email: user?.email || null,
-    emailVerified: user?.email_verified || false
-  };
-}
+"use client";
+import {
+  KerneClient,
+  KerneContext,
+  KerneProvider,
+  defaultLocalization,
+  useAccess,
+  useAuth,
+  useAuthConfig,
+  useCheckout,
+  useClient,
+  useEntitlements,
+  useInvitation,
+  usePlans,
+  usePortal,
+  useSubscription,
+  useUsage,
+  useUser,
+  useWaitlist
+} from "./chunk-F6NV76OR.js";
 
 // src/components.tsx
-import React2 from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
+import React from "react";
+import { jsx } from "react/jsx-runtime";
 function Authenticated({ children, fallback = null }) {
   const { isAuthenticated } = useAuth();
   return isAuthenticated ? children : fallback;
@@ -664,8 +36,8 @@ function AuthLoading({ children }) {
 }
 function HasSubscription({ children, fallback = null }) {
   const client = useClient();
-  const [hasSubscription, setHasSubscription] = React2.useState(null);
-  React2.useEffect(() => {
+  const [hasSubscription, setHasSubscription] = React.useState(null);
+  React.useEffect(() => {
     client.getSubscription().then((sub) => {
       setHasSubscription(sub !== null && ["ACTIVE", "TRIALING"].includes(sub.status));
     }).catch(() => {
@@ -677,26 +49,26 @@ function HasSubscription({ children, fallback = null }) {
 }
 function Allows({
   children,
-  key,
+  featureKey,
   minimum,
   fallback = null
 }) {
   const client = useClient();
-  const [allowed, setAllowed] = React2.useState(null);
-  React2.useEffect(() => {
-    client.allows(key, minimum).then((result) => {
+  const [allowed, setAllowed] = React.useState(null);
+  React.useEffect(() => {
+    client.allows(featureKey, minimum).then((result) => {
       setAllowed(result);
     }).catch(() => {
       setAllowed(false);
     });
-  }, [client, key, minimum]);
+  }, [client, featureKey, minimum]);
   if (allowed === null) return null;
   return allowed ? children : fallback;
 }
 function Protected({
   children,
   auth = true,
-  key,
+  featureKey,
   authFallback = null,
   billingFallback = null
 }) {
@@ -704,15 +76,15 @@ function Protected({
   if (auth && !isAuthenticated) {
     return authFallback;
   }
-  if (key) {
-    return /* @__PURE__ */ jsx2(Allows, { fallback: billingFallback, children }, key);
+  if (featureKey) {
+    return /* @__PURE__ */ jsx(Allows, { featureKey, fallback: billingFallback, children });
   }
   return children;
 }
 
 // src/error-boundary.tsx
-import React3, { Component } from "react";
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+import React2, { Component } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 var KerneErrorBoundary = class extends Component {
   constructor(props) {
     super(props);
@@ -744,13 +116,13 @@ var KerneErrorBoundary = class extends Component {
         return fallback;
       }
       return /* @__PURE__ */ jsxs("div", { style: { padding: "20px", textAlign: "center" }, children: [
-        /* @__PURE__ */ jsx3("h2", { style: { color: "#dc2626", marginBottom: "10px" }, children: "Something went wrong" }),
-        /* @__PURE__ */ jsx3("p", { style: { color: "#6b7280", marginBottom: "20px" }, children: error.message || "An unexpected error occurred" }),
+        /* @__PURE__ */ jsx2("h2", { style: { color: "#dc2626", marginBottom: "10px" }, children: "Something went wrong" }),
+        /* @__PURE__ */ jsx2("p", { style: { color: "#6b7280", marginBottom: "20px" }, children: error.message || "An unexpected error occurred" }),
         error.code && /* @__PURE__ */ jsxs("p", { style: { color: "#9ca3af", fontSize: "12px", marginBottom: "20px" }, children: [
           "Error code: ",
           error.code
         ] }),
-        /* @__PURE__ */ jsx3(
+        /* @__PURE__ */ jsx2(
           "button",
           {
             onClick: this.reset,
@@ -771,11 +143,11 @@ var KerneErrorBoundary = class extends Component {
   }
 };
 function useKerneError() {
-  const [error, setError] = React3.useState(null);
-  const handleError = React3.useCallback((err) => {
+  const [error, setError] = React2.useState(null);
+  const handleError = React2.useCallback((err) => {
     setError(err);
   }, []);
-  const clearError = React3.useCallback(() => {
+  const clearError = React2.useCallback(() => {
     setError(null);
   }, []);
   return {
@@ -785,54 +157,6 @@ function useKerneError() {
     clearError
   };
 }
-
-// src/store.ts
-var KerneStore = class {
-  state;
-  listeners = /* @__PURE__ */ new Set();
-  constructor(initialState) {
-    this.state = {
-      user: null,
-      isAuthenticated: false,
-      isLoading: true,
-      subscription: null,
-      error: null,
-      ...initialState
-    };
-  }
-  getState() {
-    return this.state;
-  }
-  getSnapshot() {
-    return this.state;
-  }
-  getServerSnapshot() {
-    return this.state;
-  }
-  setState(partial) {
-    const prevState = this.state;
-    this.state = { ...this.state, ...partial };
-    if (this.hasChanged(prevState, this.state)) {
-      this.notify();
-    }
-  }
-  hasChanged(prev, next) {
-    return prev.user !== next.user || prev.isAuthenticated !== next.isAuthenticated || prev.isLoading !== next.isLoading || prev.subscription !== next.subscription || prev.error !== next.error;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  notify() {
-    this.listeners.forEach((listener) => listener());
-  }
-  // Selector-based subscription for optimized re-renders
-  select(selector) {
-    return selector(this.state);
-  }
-};
 export {
   Allows,
   AuthLoading,
@@ -842,12 +166,12 @@ export {
   KerneContext,
   KerneErrorBoundary,
   KerneProvider,
-  KerneStore,
   Protected,
   Unauthenticated,
-  useAllows,
+  defaultLocalization,
+  useAccess,
   useAuth,
-  useCheck,
+  useAuthConfig,
   useCheckout,
   useClient,
   useEntitlements,