@kerne/react 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -1,731 +1,43 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Allows: () => Allows,
-  AuthLoading: () => AuthLoading,
-  Authenticated: () => Authenticated,
-  HasSubscription: () => HasSubscription,
-  KerneClient: () => KerneClient,
-  KerneContext: () => KerneContext,
-  KerneErrorBoundary: () => KerneErrorBoundary,
-  KerneProvider: () => KerneProvider,
-  KerneStore: () => KerneStore,
-  Protected: () => Protected,
-  Unauthenticated: () => Unauthenticated,
-  useAllows: () => useAllows,
-  useAuth: () => useAuth,
-  useCheck: () => useCheck,
-  useCheckout: () => useCheckout,
-  useClient: () => useClient,
-  useEntitlements: () => useEntitlements,
-  useInvitation: () => useInvitation,
-  useKerneError: () => useKerneError,
-  usePlans: () => usePlans,
-  usePortal: () => usePortal,
-  useSubscription: () => useSubscription,
-  useUsage: () => useUsage,
-  useUser: () => useUser,
-  useWaitlist: () => useWaitlist
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/provider.tsx
-var import_react = require("react");
-var import_server = require("@kerne/server");
-var import_jsx_runtime = require("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 import_server.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 = (0, import_react.createContext)(null);
-function KerneProvider({ children, ...config }) {
-  const clientRef = (0, import_react.useRef)(null);
-  const client = (0, import_react.useMemo)(() => {
-    if (!clientRef.current) {
-      clientRef.current = new KerneClient(config);
-    }
-    return clientRef.current;
-  }, [config.appId, config.baseUrl]);
-  (0, import_react.useEffect)(() => {
-    return () => {
-      client.cancelRefresh?.();
-    };
-  }, [client]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(KerneContext.Provider, { value: client, children });
-}
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;"use client";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-// src/hooks.ts
-var import_react2 = require("react");
-function useClient() {
-  const context = (0, import_react2.useContext)(KerneContext);
-  if (!context) {
-    throw new Error("useClient must be used within a KerneProvider");
-  }
-  return context;
-}
-function useAuth() {
-  const client = useClient();
-  const user = (0, import_react2.useSyncExternalStore)(
-    (callback) => client.subscribe(callback),
-    () => client.user,
-    () => client.user
-    // Server snapshot
-  );
-  const token = (0, import_react2.useSyncExternalStore)(
-    (callback) => client.subscribe(callback),
-    () => client.token,
-    () => null
-    // Server always null
-  );
-  const isAuthenticated = (0, import_react2.useSyncExternalStore)(
-    (callback) => client.subscribe(callback),
-    () => client.isAuthenticated,
-    () => false
-    // Server always unauthenticated
-  );
-  const isLoading = (0, import_react2.useSyncExternalStore)(
-    (callback) => client.subscribe(callback),
-    () => client.isLoading,
-    () => true
-    // Server always loading
-  );
-  return {
-    user,
-    token,
-    isAuthenticated,
-    isLoading,
-    login: (0, import_react2.useCallback)(
-      (params) => client.login(params),
-      [client]
-    ),
-    register: (0, import_react2.useCallback)(
-      (params) => client.register(params),
-      [client]
-    ),
-    logout: (0, import_react2.useCallback)(() => client.logout(), [client]),
-    refreshUser: (0, import_react2.useCallback)(() => client.refreshUser(), [client]),
-    refreshToken: (0, import_react2.useCallback)(() => client.refreshToken(), [client]),
-    updateProfile: (0, import_react2.useCallback)(
-      (params) => client.updateProfile(params),
-      [client]
-    ),
-    updatePassword: (0, import_react2.useCallback)(
-      (params) => client.updatePassword(params),
-      [client]
-    ),
-    requestPasswordReset: (0, import_react2.useCallback)(
-      (email) => client.requestPasswordReset(email),
-      [client]
-    ),
-    confirmPasswordReset: (0, import_react2.useCallback)(
-      (token2, password) => client.confirmPasswordReset(token2, password),
-      [client]
-    ),
-    // Email verification
-    sendVerificationEmail: (0, import_react2.useCallback)(
-      (verificationType = "code") => client.sendVerificationEmail(verificationType),
-      [client]
-    ),
-    verifyEmailWithCode: (0, import_react2.useCallback)((code) => client.verifyEmailWithCode(code), [client]),
-    verifyEmailWithLink: (0, import_react2.useCallback)(
-      (token2) => client.verifyEmailWithLink(token2),
-      [client]
-    ),
-    getVerificationStatus: (0, import_react2.useCallback)(() => client.getVerificationStatus(), [client])
-  };
-}
-function useCheckout() {
-  const client = useClient();
-  return {
-    createCheckout: (0, import_react2.useCallback)(
-      (planPriceId, options) => client.createCheckout(planPriceId, options),
-      [client]
-    ),
-    openCheckout: (0, import_react2.useCallback)(
-      (planPriceId, options) => client.openCheckout(planPriceId, options),
-      [client]
-    )
-  };
-}
-function usePortal() {
-  const client = useClient();
-  return {
-    createPortal: (0, import_react2.useCallback)((returnUrl) => client.createPortal(returnUrl), [client]),
-    openPortal: (0, import_react2.useCallback)((returnUrl) => client.openPortal(returnUrl), [client])
-  };
-}
-function useAllows(featureKey, requested) {
-  const client = useClient();
-  const [state, setState] = (0, import_react2.useState)({
-    allowed: false,
-    isLoading: true,
-    error: null
-  });
-  (0, import_react2.useEffect)(() => {
-    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] = (0, import_react2.useState)({
-    check: null,
-    isLoading: true,
-    error: null
-  });
-  (0, import_react2.useEffect)(() => {
-    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] = (0, import_react2.useState)({
-    subscription: null,
-    isLoading: true,
-    error: null
-  });
-  (0, import_react2.useEffect)(() => {
-    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] = (0, import_react2.useState)({
-    plans: [],
-    isLoading: true,
-    error: null
-  });
-  (0, import_react2.useEffect)(() => {
-    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] = (0, import_react2.useState)({
-    entitlements: null,
-    isLoading: true,
-    error: null
-  });
-  (0, import_react2.useEffect)(() => {
-    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] = (0, import_react2.useState)({
-    usage: [],
-    isLoading: true,
-    error: null
-  });
-  (0, import_react2.useEffect)(() => {
-    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: (0, import_react2.useCallback)((params) => client.joinWaitlist(params), [client])
-  };
-}
-function useInvitation(params) {
-  const client = useClient();
-  const { token, code } = params;
-  const [state, setState] = (0, import_react2.useState)({
-    result: null,
-    isLoading: !!(token || code),
-    error: null
-  });
-  (0, import_react2.useEffect)(() => {
-    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
-  };
-}
+
+
+
+var _chunk3PROPZWWcjs = require('./chunk-3PROPZWW.cjs');
 
 // src/components.tsx
-var import_react3 = __toESM(require("react"), 1);
-var import_jsx_runtime2 = require("react/jsx-runtime");
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+var _jsxruntime = require('react/jsx-runtime');
 function Authenticated({ children, fallback = null }) {
-  const { isAuthenticated } = useAuth();
+  const { isAuthenticated } = _chunk3PROPZWWcjs.useAuth.call(void 0, );
   return isAuthenticated ? children : fallback;
 }
 function Unauthenticated({ children, fallback = null }) {
-  const { isAuthenticated } = useAuth();
+  const { isAuthenticated } = _chunk3PROPZWWcjs.useAuth.call(void 0, );
   return !isAuthenticated ? children : fallback;
 }
 function AuthLoading({ children }) {
-  const client = useClient();
+  const client = _chunk3PROPZWWcjs.useClient.call(void 0, );
   return client.isLoading ? children : null;
 }
 function HasSubscription({ children, fallback = null }) {
-  const client = useClient();
-  const [hasSubscription, setHasSubscription] = import_react3.default.useState(null);
-  import_react3.default.useEffect(() => {
+  const client = _chunk3PROPZWWcjs.useClient.call(void 0, );
+  const [hasSubscription, setHasSubscription] = _react2.default.useState(null);
+  _react2.default.useEffect(() => {
     client.getSubscription().then((sub) => {
       setHasSubscription(sub !== null && ["ACTIVE", "TRIALING"].includes(sub.status));
     }).catch(() => {
@@ -737,45 +49,45 @@ function HasSubscription({ children, fallback = null }) {
 }
 function Allows({
   children,
-  key,
+  featureKey,
   minimum,
   fallback = null
 }) {
-  const client = useClient();
-  const [allowed, setAllowed] = import_react3.default.useState(null);
-  import_react3.default.useEffect(() => {
-    client.allows(key, minimum).then((result) => {
+  const client = _chunk3PROPZWWcjs.useClient.call(void 0, );
+  const [allowed, setAllowed] = _react2.default.useState(null);
+  _react2.default.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
 }) {
-  const { isAuthenticated } = useAuth();
+  const { isAuthenticated } = _chunk3PROPZWWcjs.useAuth.call(void 0, );
   if (auth && !isAuthenticated) {
     return authFallback;
   }
-  if (key) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Allows, { fallback: billingFallback, children }, key);
+  if (featureKey) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Allows, { featureKey, fallback: billingFallback, children });
   }
   return children;
 }
 
 // src/error-boundary.tsx
-var import_react4 = __toESM(require("react"), 1);
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var KerneErrorBoundary = class extends import_react4.Component {
+
+
+var KerneErrorBoundary = (_class = class extends _react.Component {
   constructor(props) {
-    super(props);
+    super(props);_class.prototype.__init.call(this);;
     this.state = { error: null, hasError: false };
   }
   static getDerivedStateFromError(error) {
@@ -783,16 +95,16 @@ var KerneErrorBoundary = class extends import_react4.Component {
   }
   componentDidCatch(error, errorInfo) {
     const kerneError = error;
-    this.props.onError?.(kerneError, errorInfo);
+    _optionalChain([this, 'access', _4 => _4.props, 'access', _5 => _5.onError, 'optionalCall', _6 => _6(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?.();
+  __init() {this.reset = () => {
+    _optionalChain([this, 'access', _7 => _7.props, 'access', _8 => _8.onReset, 'optionalCall', _9 => _9()]);
     this.setState({ error: null, hasError: false });
-  };
+  }}
   render() {
     if (this.state.hasError && this.state.error) {
       const { fallback } = this.props;
@@ -803,14 +115,14 @@ var KerneErrorBoundary = class extends import_react4.Component {
         }
         return fallback;
       }
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { padding: "20px", textAlign: "center" }, children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h2", { style: { color: "#dc2626", marginBottom: "10px" }, children: "Something went wrong" }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: { color: "#6b7280", marginBottom: "20px" }, children: error.message || "An unexpected error occurred" }),
-        error.code && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("p", { style: { color: "#9ca3af", fontSize: "12px", marginBottom: "20px" }, children: [
+      return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { style: { padding: "20px", textAlign: "center" }, children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "h2", { style: { color: "#dc2626", marginBottom: "10px" }, children: "Something went wrong" }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { style: { color: "#6b7280", marginBottom: "20px" }, children: error.message || "An unexpected error occurred" }),
+        error.code && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "p", { style: { color: "#9ca3af", fontSize: "12px", marginBottom: "20px" }, children: [
           "Error code: ",
           error.code
         ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "button",
           {
             onClick: this.reset,
@@ -829,13 +141,13 @@ var KerneErrorBoundary = class extends import_react4.Component {
     }
     return this.props.children;
   }
-};
+}, _class);
 function useKerneError() {
-  const [error, setError] = import_react4.default.useState(null);
-  const handleError = import_react4.default.useCallback((err) => {
+  const [error, setError] = _react2.default.useState(null);
+  const handleError = _react2.default.useCallback((err) => {
     setError(err);
   }, []);
-  const clearError = import_react4.default.useCallback(() => {
+  const clearError = _react2.default.useCallback(() => {
     setError(null);
   }, []);
   return {
@@ -846,78 +158,29 @@ function useKerneError() {
   };
 }
 
-// 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);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Allows,
-  AuthLoading,
-  Authenticated,
-  HasSubscription,
-  KerneClient,
-  KerneContext,
-  KerneErrorBoundary,
-  KerneProvider,
-  KerneStore,
-  Protected,
-  Unauthenticated,
-  useAllows,
-  useAuth,
-  useCheck,
-  useCheckout,
-  useClient,
-  useEntitlements,
-  useInvitation,
-  useKerneError,
-  usePlans,
-  usePortal,
-  useSubscription,
-  useUsage,
-  useUser,
-  useWaitlist
-});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Allows = Allows; exports.AuthLoading = AuthLoading; exports.Authenticated = Authenticated; exports.HasSubscription = HasSubscription; exports.KerneClient = _chunk3PROPZWWcjs.KerneClient; exports.KerneContext = _chunk3PROPZWWcjs.KerneContext; exports.KerneErrorBoundary = KerneErrorBoundary; exports.KerneProvider = _chunk3PROPZWWcjs.KerneProvider; exports.Protected = Protected; exports.Unauthenticated = Unauthenticated; exports.defaultLocalization = _chunk3PROPZWWcjs.defaultLocalization; exports.useAccess = _chunk3PROPZWWcjs.useAccess; exports.useAuth = _chunk3PROPZWWcjs.useAuth; exports.useAuthConfig = _chunk3PROPZWWcjs.useAuthConfig; exports.useCheckout = _chunk3PROPZWWcjs.useCheckout; exports.useClient = _chunk3PROPZWWcjs.useClient; exports.useEntitlements = _chunk3PROPZWWcjs.useEntitlements; exports.useInvitation = _chunk3PROPZWWcjs.useInvitation; exports.useKerneError = useKerneError; exports.usePlans = _chunk3PROPZWWcjs.usePlans; exports.usePortal = _chunk3PROPZWWcjs.usePortal; exports.useSubscription = _chunk3PROPZWWcjs.useSubscription; exports.useUsage = _chunk3PROPZWWcjs.useUsage; exports.useUser = _chunk3PROPZWWcjs.useUser; exports.useWaitlist = _chunk3PROPZWWcjs.useWaitlist;