@kerne/react 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,208 +1,862 @@
-// src/index.tsx
-import { createContext, useContext, useEffect, useState, useMemo } from "react";
+// 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;
-  currentUser = null;
-  currentToken = null;
+  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: config.baseUrl,
-      appId: config.appId,
-      timeout: config.timeout
+      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) return;
+    if (!this.storage) {
+      this._isLoading = false;
+      this.notify();
+      return;
+    }
     try {
       const data = this.storage.getItem(this.storageKey);
       if (data) {
-        const { user, token, expires_at } = JSON.parse(data);
-        if (new Date(expires_at) > /* @__PURE__ */ new Date()) {
-          this.currentUser = user;
-          this.currentToken = token;
+        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 {
-      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();
   }
-  saveSession(response) {
-    this.currentUser = response.user;
-    this.currentToken = response.token;
+  /**
+   * `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(response));
+      this.storage.setItem(
+        this.storageKey,
+        JSON.stringify({
+          user: this._user,
+          token: response.token,
+          refresh_token: response.refresh_token,
+          expires_at: response.expires_at
+        })
+      );
     }
-    this.onAuthChange?.(response.user);
+    this.scheduleRefresh();
+    this.onAuthChange?.(this._user);
+    this.notify();
   }
   clearSession() {
-    this.currentUser = null;
-    this.currentToken = null;
+    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();
   }
-  get user() {
-    return this.currentUser;
-  }
-  get token() {
-    return this.currentToken;
-  }
-  get isAuthenticated() {
-    return this.currentToken !== null;
+  // ============================================================================
+  // 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);
+    }
   }
-  get client() {
-    return this.kerne;
+  cancelRefresh() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
   }
-  get projects() {
-    return this.kerne.projects;
+  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 lastName = lastNameParts.join(" ");
     const response = await this.kerne.auth.signup({
       email: params.email,
       password: params.password,
-      first_name: firstName,
-      last_name: lastName || void 0
+      first_name: firstName || void 0,
+      last_name: lastNameParts.join(" ") || void 0,
+      invitationToken: params.invitationToken,
+      invitationCode: params.invitationCode
     });
-    this.saveSession(response);
+    await this.saveSession(response);
     return response;
   }
   async login(params) {
-    const response = await this.kerne.auth.login({
-      email: params.email,
-      password: params.password
-    });
-    this.saveSession(response);
+    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.currentToken) return null;
-    const response = await this.kerne.auth.refreshToken({
-      refresh_token: this.currentToken
-    });
-    this.saveSession(response);
+    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.currentToken) return null;
+    if (!this._token) return null;
     try {
       const user = await this.kerne.users.me();
-      this.currentUser = user;
+      this._user = user;
       this.onAuthChange?.(user);
+      this.notify();
       return user;
     } catch {
       this.clearSession();
       return null;
     }
   }
-  async checkEntitlement(featureKey, requested) {
-    try {
-      const check = await this.kerne.billing.checkEntitlement(featureKey, requested);
-      return check.has_access;
-    } catch {
-      return false;
+  // 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 createCheckout(planId, options) {
-    const { url } = await this.kerne.billing.createCheckout(planId, {
-      success_url: options?.successUrl,
-      cancel_url: options?.cancelUrl
-    });
+  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(planId, options) {
-    const url = await this.createCheckout(planId, options);
-    if (typeof window !== "undefined") {
-      window.location.href = 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.createPortal({ return_url: 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;
-    }
+    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();
   }
 };
-function createKerneClient(config) {
-  return new KerneClient(config);
-}
 var KerneContext = createContext(null);
 function KerneProvider({ children, ...config }) {
-  const [user, setUser] = useState(null);
+  const clientRef = useRef(null);
   const client = useMemo(() => {
-    return new KerneClient({
-      ...config,
-      onAuthChange: (u) => {
-        setUser(u);
-        config.onAuthChange?.(u);
-      }
-    });
+    if (!clientRef.current) {
+      clientRef.current = new KerneClient(config);
+    }
+    return clientRef.current;
   }, [config.appId, config.baseUrl]);
   useEffect(() => {
-    setUser(client.user);
+    return () => {
+      client.cancelRefresh?.();
+    };
   }, [client]);
   return /* @__PURE__ */ jsx(KerneContext.Provider, { value: client, children });
 }
-function useKerne() {
+
+// src/hooks.ts
+import { useContext, useSyncExternalStore, useCallback, useEffect as useEffect2, useState } from "react";
+function useClient() {
   const context = useContext(KerneContext);
   if (!context) {
-    throw new Error("useKerne must be used within a KerneProvider");
+    throw new Error("useClient must be used within a KerneProvider");
   }
   return context;
 }
 function useAuth() {
-  const client = useKerne();
-  const [user, setUser] = useState(client.user);
-  useEffect(() => {
-    setUser(client.user);
-  }, [client.user]);
+  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,
-    isAuthenticated: client.isAuthenticated,
-    login: client.login.bind(client),
-    register: client.register.bind(client),
-    logout: client.logout.bind(client),
-    refreshUser: client.refreshUser.bind(client)
+    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
   };
 }
-function useBilling() {
-  const client = useKerne();
+
+// src/components.tsx
+import React2 from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Authenticated({ children, fallback = null }) {
+  const { isAuthenticated } = useAuth();
+  return isAuthenticated ? children : fallback;
+}
+function Unauthenticated({ children, fallback = null }) {
+  const { isAuthenticated } = useAuth();
+  return !isAuthenticated ? children : fallback;
+}
+function AuthLoading({ children }) {
+  const client = useClient();
+  return client.isLoading ? children : null;
+}
+function HasSubscription({ children, fallback = null }) {
+  const client = useClient();
+  const [hasSubscription, setHasSubscription] = React2.useState(null);
+  React2.useEffect(() => {
+    client.getSubscription().then((sub) => {
+      setHasSubscription(sub !== null && ["ACTIVE", "TRIALING"].includes(sub.status));
+    }).catch(() => {
+      setHasSubscription(false);
+    });
+  }, [client]);
+  if (hasSubscription === null) return null;
+  return hasSubscription ? children : fallback;
+}
+function Allows({
+  children,
+  key,
+  minimum,
+  fallback = null
+}) {
+  const client = useClient();
+  const [allowed, setAllowed] = React2.useState(null);
+  React2.useEffect(() => {
+    client.allows(key, minimum).then((result) => {
+      setAllowed(result);
+    }).catch(() => {
+      setAllowed(false);
+    });
+  }, [client, key, minimum]);
+  if (allowed === null) return null;
+  return allowed ? children : fallback;
+}
+function Protected({
+  children,
+  auth = true,
+  key,
+  authFallback = null,
+  billingFallback = null
+}) {
+  const { isAuthenticated } = useAuth();
+  if (auth && !isAuthenticated) {
+    return authFallback;
+  }
+  if (key) {
+    return /* @__PURE__ */ jsx2(Allows, { fallback: billingFallback, children }, key);
+  }
+  return children;
+}
+
+// src/error-boundary.tsx
+import React3, { Component } from "react";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var KerneErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { error: null, hasError: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { error, hasError: true };
+  }
+  componentDidCatch(error, errorInfo) {
+    const kerneError = error;
+    this.props.onError?.(kerneError, errorInfo);
+    if (process.env.NODE_ENV === "development") {
+      console.error("[KerneSDK] Error caught by boundary:", kerneError);
+      console.error("[KerneSDK] Component stack:", errorInfo.componentStack);
+    }
+  }
+  reset = () => {
+    this.props.onReset?.();
+    this.setState({ error: null, hasError: false });
+  };
+  render() {
+    if (this.state.hasError && this.state.error) {
+      const { fallback } = this.props;
+      const { error } = this.state;
+      if (fallback) {
+        if (typeof fallback === "function") {
+          return fallback(error, this.reset);
+        }
+        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" }),
+        error.code && /* @__PURE__ */ jsxs("p", { style: { color: "#9ca3af", fontSize: "12px", marginBottom: "20px" }, children: [
+          "Error code: ",
+          error.code
+        ] }),
+        /* @__PURE__ */ jsx3(
+          "button",
+          {
+            onClick: this.reset,
+            style: {
+              padding: "10px 20px",
+              backgroundColor: "#3b82f6",
+              color: "white",
+              border: "none",
+              borderRadius: "6px",
+              cursor: "pointer"
+            },
+            children: "Try again"
+          }
+        )
+      ] });
+    }
+    return this.props.children;
+  }
+};
+function useKerneError() {
+  const [error, setError] = React3.useState(null);
+  const handleError = React3.useCallback((err) => {
+    setError(err);
+  }, []);
+  const clearError = React3.useCallback(() => {
+    setError(null);
+  }, []);
   return {
-    checkEntitlement: client.checkEntitlement.bind(client),
-    createCheckout: client.createCheckout.bind(client),
-    openCheckout: client.openCheckout.bind(client),
-    createPortal: client.createPortal.bind(client),
-    openPortal: client.openPortal.bind(client)
+    error,
+    hasError: error !== null,
+    handleError,
+    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,
+  Authenticated,
+  HasSubscription,
   KerneClient,
+  KerneContext,
+  KerneErrorBoundary,
   KerneProvider,
-  createKerneClient,
+  KerneStore,
+  Protected,
+  Unauthenticated,
+  useAllows,
   useAuth,
-  useBilling,
-  useKerne
+  useCheck,
+  useCheckout,
+  useClient,
+  useEntitlements,
+  useInvitation,
+  useKerneError,
+  usePlans,
+  usePortal,
+  useSubscription,
+  useUsage,
+  useUser,
+  useWaitlist
 };