@access-dlsu/leapify 0.260507.4 → 0.260524.1

package/dist/client/index.js

@@ -1,798 +1,6 @@
-import { getBaseURL, createFetch, defu } from '../chunk-IQEWVHLM.js';
-import { capitalizeFirstLetter } from '../chunk-HHNEB7YR.js';
-import '../chunk-EGRHWZRV.js';
-import '../chunk-MNEW2V4T.js';
-import '../chunk-G3PMV62Z.js';
+import '../chunk-PZ5AY32C.js';
+import { createAuthClient } from 'better-auth/client';
 
-// node_modules/better-auth/dist/client/broadcast-channel.mjs
-var kBroadcastChannel = Symbol.for("better-auth:broadcast-channel");
-var now = () => Math.floor(Date.now() / 1e3);
-var WindowBroadcastChannel = class {
-  listeners = /* @__PURE__ */ new Set();
-  name;
-  constructor(name = "better-auth.message") {
-    this.name = name;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  post(message) {
-    if (typeof window === "undefined") return;
-    try {
-      localStorage.setItem(this.name, JSON.stringify({
-        ...message,
-        timestamp: now()
-      }));
-    } catch {
-    }
-  }
-  setup() {
-    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") return () => {
-    };
-    const handler = (event) => {
-      if (event.key !== this.name) return;
-      const message = JSON.parse(event.newValue ?? "{}");
-      if (message?.event !== "session" || !message?.data) return;
-      this.listeners.forEach((listener) => listener(message));
-    };
-    window.addEventListener("storage", handler);
-    return () => {
-      window.removeEventListener("storage", handler);
-    };
-  }
-};
-function getGlobalBroadcastChannel(name = "better-auth.message") {
-  if (!globalThis[kBroadcastChannel]) globalThis[kBroadcastChannel] = new WindowBroadcastChannel(name);
-  return globalThis[kBroadcastChannel];
-}
-
-// node_modules/better-auth/dist/client/focus-manager.mjs
-var kFocusManager = Symbol.for("better-auth:focus-manager");
-var WindowFocusManager = class {
-  listeners = /* @__PURE__ */ new Set();
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  setFocused(focused) {
-    this.listeners.forEach((listener) => listener(focused));
-  }
-  setup() {
-    if (typeof window === "undefined" || typeof document === "undefined" || typeof window.addEventListener === "undefined") return () => {
-    };
-    const visibilityHandler = () => {
-      if (document.visibilityState === "visible") this.setFocused(true);
-    };
-    document.addEventListener("visibilitychange", visibilityHandler, false);
-    return () => {
-      document.removeEventListener("visibilitychange", visibilityHandler, false);
-    };
-  }
-};
-function getGlobalFocusManager() {
-  if (!globalThis[kFocusManager]) globalThis[kFocusManager] = new WindowFocusManager();
-  return globalThis[kFocusManager];
-}
-
-// node_modules/better-auth/dist/client/online-manager.mjs
-var kOnlineManager = Symbol.for("better-auth:online-manager");
-var WindowOnlineManager = class {
-  listeners = /* @__PURE__ */ new Set();
-  isOnline = typeof navigator !== "undefined" ? navigator.onLine : true;
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  setOnline(online) {
-    this.isOnline = online;
-    this.listeners.forEach((listener) => listener(online));
-  }
-  setup() {
-    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") return () => {
-    };
-    const onOnline = () => this.setOnline(true);
-    const onOffline = () => this.setOnline(false);
-    window.addEventListener("online", onOnline, false);
-    window.addEventListener("offline", onOffline, false);
-    return () => {
-      window.removeEventListener("online", onOnline, false);
-      window.removeEventListener("offline", onOffline, false);
-    };
-  }
-};
-function getGlobalOnlineManager() {
-  if (!globalThis[kOnlineManager]) globalThis[kOnlineManager] = new WindowOnlineManager();
-  return globalThis[kOnlineManager];
-}
-
-// node_modules/better-auth/dist/client/parser.mjs
-var PROTO_POLLUTION_PATTERNS = {
-  proto: /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/,
-  constructor: /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/,
-  protoShort: /"__proto__"\s*:/,
-  constructorShort: /"constructor"\s*:/
-};
-var JSON_SIGNATURE = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
-var SPECIAL_VALUES = {
-  true: true,
-  false: false,
-  null: null,
-  undefined: void 0,
-  nan: NaN,
-  infinity: Number.POSITIVE_INFINITY,
-  "-infinity": Number.NEGATIVE_INFINITY
-};
-var ISO_DATE_REGEX = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,7}))?(?:Z|([+-])(\d{2}):(\d{2}))$/;
-function isValidDate(date) {
-  return date instanceof Date && !isNaN(date.getTime());
-}
-function parseISODate(value) {
-  const match = ISO_DATE_REGEX.exec(value);
-  if (!match) return null;
-  const [, year, month, day, hour, minute, second, ms, offsetSign, offsetHour, offsetMinute] = match;
-  const date = new Date(Date.UTC(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10), parseInt(hour, 10), parseInt(minute, 10), parseInt(second, 10), ms ? parseInt(ms.padEnd(3, "0"), 10) : 0));
-  if (offsetSign) {
-    const offset = (parseInt(offsetHour, 10) * 60 + parseInt(offsetMinute, 10)) * (offsetSign === "+" ? -1 : 1);
-    date.setUTCMinutes(date.getUTCMinutes() + offset);
-  }
-  return isValidDate(date) ? date : null;
-}
-function betterJSONParse(value, options = {}) {
-  const { strict = false, warnings = false, reviver, parseDates = true } = options;
-  if (typeof value !== "string") return value;
-  const trimmed = value.trim();
-  if (trimmed.length > 0 && trimmed[0] === '"' && trimmed.endsWith('"') && !trimmed.slice(1, -1).includes('"')) return trimmed.slice(1, -1);
-  const lowerValue = trimmed.toLowerCase();
-  if (lowerValue.length <= 9 && lowerValue in SPECIAL_VALUES) return SPECIAL_VALUES[lowerValue];
-  if (!JSON_SIGNATURE.test(trimmed)) {
-    if (strict) throw new SyntaxError("[better-json] Invalid JSON");
-    return value;
-  }
-  if (Object.entries(PROTO_POLLUTION_PATTERNS).some(([key, pattern]) => {
-    const matches = pattern.test(trimmed);
-    if (matches && warnings) console.warn(`[better-json] Detected potential prototype pollution attempt using ${key} pattern`);
-    return matches;
-  }) && strict) throw new Error("[better-json] Potential prototype pollution attempt detected");
-  try {
-    const secureReviver = (key, value2) => {
-      if (key === "__proto__" || key === "constructor" && value2 && typeof value2 === "object" && "prototype" in value2) {
-        if (warnings) console.warn(`[better-json] Dropping "${key}" key to prevent prototype pollution`);
-        return;
-      }
-      if (parseDates && typeof value2 === "string") {
-        const date = parseISODate(value2);
-        if (date) return date;
-      }
-      return reviver ? reviver(key, value2) : value2;
-    };
-    return JSON.parse(trimmed, secureReviver);
-  } catch (error) {
-    if (strict) throw error;
-    return value;
-  }
-}
-function parseJSON(value, options = { strict: true }) {
-  return betterJSONParse(value, options);
-}
-
-// node_modules/nanostores/clean-stores/index.js
-var clean = Symbol("clean");
-
-// node_modules/nanostores/atom/index.js
-var listenerQueue = [];
-var lqIndex = 0;
-var QUEUE_ITEMS_PER_LISTENER = 4;
-var nanostoresGlobal = globalThis.nanostoresGlobal ||= { epoch: 0 };
-var atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
-  let listeners = [];
-  let $atom = {
-    get() {
-      if (!$atom.lc) {
-        $atom.listen(() => {
-        })();
-      }
-      return $atom.value;
-    },
-    init: initialValue,
-    lc: 0,
-    listen(listener) {
-      $atom.lc = listeners.push(listener);
-      return () => {
-        for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length; ) {
-          if (listenerQueue[i] === listener) {
-            listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
-          } else {
-            i += QUEUE_ITEMS_PER_LISTENER;
-          }
-        }
-        let index = listeners.indexOf(listener);
-        if (~index) {
-          listeners.splice(index, 1);
-          if (!--$atom.lc) $atom.off();
-        }
-      };
-    },
-    notify(oldValue, changedKey) {
-      nanostoresGlobal.epoch++;
-      let runListenerQueue = !listenerQueue.length;
-      for (let listener of listeners) {
-        listenerQueue.push(listener, $atom.value, oldValue, changedKey);
-      }
-      if (runListenerQueue) {
-        for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) {
-          listenerQueue[lqIndex](
-            listenerQueue[lqIndex + 1],
-            listenerQueue[lqIndex + 2],
-            listenerQueue[lqIndex + 3]
-          );
-        }
-        listenerQueue.length = 0;
-      }
-    },
-    /* It will be called on last listener unsubscribing.
-       We will redefine it in onMount and onStop. */
-    off() {
-    },
-    set(newValue) {
-      let oldValue = $atom.value;
-      if (oldValue !== newValue) {
-        $atom.value = newValue;
-        $atom.notify(oldValue);
-      }
-    },
-    subscribe(listener) {
-      let unbind = $atom.listen(listener);
-      listener($atom.value);
-      return unbind;
-    },
-    value: initialValue
-  };
-  {
-    $atom[clean] = () => {
-      listeners = [];
-      $atom.lc = 0;
-      $atom.off();
-    };
-  }
-  return $atom;
-};
-
-// node_modules/nanostores/lifecycle/index.js
-var MOUNT = 5;
-var UNMOUNT = 6;
-var REVERT_MUTATION = 10;
-var on = (object, listener, eventKey, mutateStore) => {
-  object.events = object.events || {};
-  if (!object.events[eventKey + REVERT_MUTATION]) {
-    object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
-      object.events[eventKey].reduceRight((event, l) => (l(event), event), {
-        shared: {},
-        ...eventProps
-      });
-    });
-  }
-  object.events[eventKey] = object.events[eventKey] || [];
-  object.events[eventKey].push(listener);
-  return () => {
-    let currentListeners = object.events[eventKey];
-    let index = currentListeners.indexOf(listener);
-    currentListeners.splice(index, 1);
-    if (!currentListeners.length) {
-      delete object.events[eventKey];
-      object.events[eventKey + REVERT_MUTATION]();
-      delete object.events[eventKey + REVERT_MUTATION];
-    }
-  };
-};
-var STORE_UNMOUNT_DELAY = 1e3;
-var onMount = ($store, initialize) => {
-  let listener = (payload) => {
-    let destroy = initialize(payload);
-    if (destroy) $store.events[UNMOUNT].push(destroy);
-  };
-  return on($store, listener, MOUNT, (runListeners) => {
-    let originListen = $store.listen;
-    $store.listen = (...args) => {
-      if (!$store.lc && !$store.active) {
-        $store.active = true;
-        runListeners();
-      }
-      return originListen(...args);
-    };
-    let originOff = $store.off;
-    $store.events[UNMOUNT] = [];
-    $store.off = () => {
-      originOff();
-      setTimeout(() => {
-        if ($store.active && !$store.lc) {
-          $store.active = false;
-          for (let destroy of $store.events[UNMOUNT]) destroy();
-          $store.events[UNMOUNT] = [];
-        }
-      }, STORE_UNMOUNT_DELAY);
-    };
-    {
-      let originClean = $store[clean];
-      $store[clean] = () => {
-        for (let destroy of $store.events[UNMOUNT]) destroy();
-        $store.events[UNMOUNT] = [];
-        $store.active = false;
-        originClean();
-      };
-    }
-    return () => {
-      $store.listen = originListen;
-      $store.off = originOff;
-    };
-  });
-};
-
-// node_modules/better-auth/dist/client/query.mjs
-var isServer = () => typeof window === "undefined";
-var useAuthQuery = (initializedAtom, path, $fetch, options) => {
-  const value = atom({
-    data: null,
-    error: null,
-    isPending: true,
-    isRefetching: false,
-    refetch: (queryParams) => fn(queryParams)
-  });
-  const fn = async (queryParams) => {
-    return new Promise((resolve) => {
-      const opts = typeof options === "function" ? options({
-        data: value.get().data,
-        error: value.get().error,
-        isPending: value.get().isPending
-      }) : options;
-      $fetch(path, {
-        ...opts,
-        query: {
-          ...opts?.query,
-          ...queryParams?.query
-        },
-        async onSuccess(context) {
-          value.set({
-            data: context.data,
-            error: null,
-            isPending: false,
-            isRefetching: false,
-            refetch: value.value.refetch
-          });
-          await opts?.onSuccess?.(context);
-        },
-        async onError(context) {
-          const { request } = context;
-          const retryAttempts = typeof request.retry === "number" ? request.retry : request.retry?.attempts;
-          const retryAttempt = request.retryAttempt || 0;
-          if (retryAttempts && retryAttempt < retryAttempts) return;
-          const isUnauthorized = context.error.status === 401;
-          value.set({
-            error: context.error,
-            data: isUnauthorized ? null : value.get().data,
-            isPending: false,
-            isRefetching: false,
-            refetch: value.value.refetch
-          });
-          await opts?.onError?.(context);
-        },
-        async onRequest(context) {
-          const currentValue = value.get();
-          value.set({
-            isPending: currentValue.data === null,
-            data: currentValue.data,
-            error: null,
-            isRefetching: true,
-            refetch: value.value.refetch
-          });
-          await opts?.onRequest?.(context);
-        }
-      }).catch((error) => {
-        value.set({
-          error,
-          data: value.get().data,
-          isPending: false,
-          isRefetching: false,
-          refetch: value.value.refetch
-        });
-      }).finally(() => {
-        resolve(void 0);
-      });
-    });
-  };
-  initializedAtom = Array.isArray(initializedAtom) ? initializedAtom : [initializedAtom];
-  let isInitialized = false;
-  for (const initAtom of initializedAtom) initAtom.subscribe(async () => {
-    if (isServer()) return;
-    if (isInitialized) await fn();
-    else onMount(value, () => {
-      const timeoutId = setTimeout(async () => {
-        if (!isInitialized) {
-          isInitialized = true;
-          await fn();
-        }
-      }, 0);
-      return () => {
-        value.off();
-        initAtom.off();
-        clearTimeout(timeoutId);
-      };
-    });
-  });
-  return value;
-};
-
-// node_modules/better-auth/dist/client/session-refresh.mjs
-var now2 = () => Math.floor(Date.now() / 1e3);
-function normalizeSessionResponse(res) {
-  if (typeof res === "object" && res !== null && "data" in res && "error" in res) return res;
-  return {
-    data: res,
-    error: null
-  };
-}
-var FOCUS_REFETCH_RATE_LIMIT_SECONDS = 5;
-function createSessionRefreshManager(opts) {
-  const { sessionAtom, sessionSignal, $fetch, options = {} } = opts;
-  const refetchInterval = options.sessionOptions?.refetchInterval ?? 0;
-  const refetchOnWindowFocus = options.sessionOptions?.refetchOnWindowFocus ?? true;
-  const refetchWhenOffline = options.sessionOptions?.refetchWhenOffline ?? false;
-  const state = {
-    lastSync: 0,
-    lastSessionRequest: 0,
-    cachedSession: void 0
-  };
-  const shouldRefetch = () => {
-    return refetchWhenOffline || getGlobalOnlineManager().isOnline;
-  };
-  const triggerRefetch = (event) => {
-    if (!shouldRefetch()) return;
-    if (event?.event === "storage") {
-      state.lastSync = now2();
-      sessionSignal.set(!sessionSignal.get());
-      return;
-    }
-    const currentSession = sessionAtom.get();
-    const fetchSessionWithRefresh = () => {
-      state.lastSessionRequest = now2();
-      $fetch("/get-session").then(async (res) => {
-        let { data, error } = normalizeSessionResponse(res);
-        if (data?.needsRefresh) try {
-          const refreshRes = await $fetch("/get-session", { method: "POST" });
-          ({ data, error } = normalizeSessionResponse(refreshRes));
-        } catch {
-        }
-        const sessionData = data?.session && data?.user ? data : null;
-        sessionAtom.set({
-          ...currentSession,
-          data: sessionData,
-          error
-        });
-        state.lastSync = now2();
-        sessionSignal.set(!sessionSignal.get());
-      }).catch(() => {
-      });
-    };
-    if (event?.event === "poll") {
-      fetchSessionWithRefresh();
-      return;
-    }
-    if (event?.event === "visibilitychange") {
-      if (now2() - state.lastSessionRequest < FOCUS_REFETCH_RATE_LIMIT_SECONDS) return;
-      state.lastSessionRequest = now2();
-    }
-    if (event?.event === "visibilitychange") {
-      fetchSessionWithRefresh();
-      return;
-    }
-    if (currentSession?.data === null || currentSession?.data === void 0) {
-      state.lastSync = now2();
-      sessionSignal.set(!sessionSignal.get());
-    }
-  };
-  const broadcastSessionUpdate = (trigger) => {
-    getGlobalBroadcastChannel().post({
-      event: "session",
-      data: { trigger },
-      clientId: Math.random().toString(36).substring(7)
-    });
-  };
-  const setupPolling = () => {
-    if (refetchInterval && refetchInterval > 0) state.pollInterval = setInterval(() => {
-      if (sessionAtom.get()?.data) triggerRefetch({ event: "poll" });
-    }, refetchInterval * 1e3);
-  };
-  const setupBroadcast = () => {
-    state.unsubscribeBroadcast = getGlobalBroadcastChannel().subscribe(() => {
-      triggerRefetch({ event: "storage" });
-    });
-  };
-  const setupFocusRefetch = () => {
-    if (!refetchOnWindowFocus) return;
-    state.unsubscribeFocus = getGlobalFocusManager().subscribe(() => {
-      triggerRefetch({ event: "visibilitychange" });
-    });
-  };
-  const setupOnlineRefetch = () => {
-    state.unsubscribeOnline = getGlobalOnlineManager().subscribe((online) => {
-      if (online) triggerRefetch({ event: "visibilitychange" });
-    });
-  };
-  const init = () => {
-    setupPolling();
-    setupBroadcast();
-    setupFocusRefetch();
-    setupOnlineRefetch();
-    getGlobalBroadcastChannel().setup();
-    getGlobalFocusManager().setup();
-    getGlobalOnlineManager().setup();
-  };
-  const cleanup = () => {
-    if (state.pollInterval) {
-      clearInterval(state.pollInterval);
-      state.pollInterval = void 0;
-    }
-    if (state.unsubscribeBroadcast) {
-      state.unsubscribeBroadcast();
-      state.unsubscribeBroadcast = void 0;
-    }
-    if (state.unsubscribeFocus) {
-      state.unsubscribeFocus();
-      state.unsubscribeFocus = void 0;
-    }
-    if (state.unsubscribeOnline) {
-      state.unsubscribeOnline();
-      state.unsubscribeOnline = void 0;
-    }
-    state.lastSync = 0;
-    state.lastSessionRequest = 0;
-    state.cachedSession = void 0;
-  };
-  return {
-    init,
-    cleanup,
-    triggerRefetch,
-    broadcastSessionUpdate
-  };
-}
-
-// node_modules/better-auth/dist/client/fetch-plugins.mjs
-var redirectPlugin = {
-  id: "redirect",
-  name: "Redirect",
-  hooks: { onSuccess(context) {
-    if (context.data?.url && context.data?.redirect) {
-      if (typeof window !== "undefined" && window.location) {
-        if (window.location) try {
-          window.location.href = context.data.url;
-        } catch {
-        }
-      }
-    }
-  } }
-};
-
-// node_modules/better-auth/dist/client/session-atom.mjs
-function getSessionAtom($fetch, options) {
-  const $signal = atom(false);
-  const session = useAuthQuery($signal, "/get-session", $fetch, { method: "GET" });
-  let broadcastSessionUpdate = () => {
-  };
-  onMount(session, () => {
-    const refreshManager = createSessionRefreshManager({
-      sessionAtom: session,
-      sessionSignal: $signal,
-      $fetch,
-      options
-    });
-    refreshManager.init();
-    broadcastSessionUpdate = refreshManager.broadcastSessionUpdate;
-    return () => {
-      refreshManager.cleanup();
-    };
-  });
-  return {
-    session,
-    $sessionSignal: $signal,
-    broadcastSessionUpdate: (trigger) => broadcastSessionUpdate(trigger)
-  };
-}
-
-// node_modules/better-auth/dist/client/config.mjs
-var resolvePublicAuthUrl = (basePath) => {
-  if (typeof process === "undefined") return void 0;
-  const path = basePath ?? "/api/auth";
-  if (process.env.NEXT_PUBLIC_AUTH_URL) return process.env.NEXT_PUBLIC_AUTH_URL;
-  if (typeof window === "undefined") {
-    if (process.env.NEXTAUTH_URL) try {
-      return process.env.NEXTAUTH_URL;
-    } catch {
-    }
-    if (process.env.VERCEL_URL) try {
-      const protocol = process.env.VERCEL_URL.startsWith("http") ? "" : "https://";
-      return `${new URL(`${protocol}${process.env.VERCEL_URL}`).origin}${path}`;
-    } catch {
-    }
-  }
-};
-var getClientConfig = (options, loadEnv) => {
-  const isCredentialsSupported = "credentials" in Request.prototype;
-  const baseURL = getBaseURL(options?.baseURL, options?.basePath, void 0, loadEnv) ?? resolvePublicAuthUrl(options?.basePath) ?? "/api/auth";
-  const pluginsFetchPlugins = options?.plugins?.flatMap((plugin) => plugin.fetchPlugins).filter((pl) => pl !== void 0) || [];
-  const lifeCyclePlugin = {
-    id: "lifecycle-hooks",
-    name: "lifecycle-hooks",
-    hooks: {
-      onSuccess: options?.fetchOptions?.onSuccess,
-      onError: options?.fetchOptions?.onError,
-      onRequest: options?.fetchOptions?.onRequest,
-      onResponse: options?.fetchOptions?.onResponse
-    }
-  };
-  const { onSuccess: _onSuccess, onError: _onError, onRequest: _onRequest, onResponse: _onResponse, ...restOfFetchOptions } = options?.fetchOptions || {};
-  const $fetch = createFetch({
-    baseURL,
-    ...isCredentialsSupported ? { credentials: "include" } : {},
-    method: "GET",
-    jsonParser(text) {
-      if (!text) return null;
-      return parseJSON(text, { strict: false });
-    },
-    customFetchImpl: fetch,
-    ...restOfFetchOptions,
-    plugins: [
-      lifeCyclePlugin,
-      ...restOfFetchOptions.plugins || [],
-      ...options?.disableDefaultFetchPlugins ? [] : [redirectPlugin],
-      ...pluginsFetchPlugins
-    ]
-  });
-  const { $sessionSignal, session, broadcastSessionUpdate } = getSessionAtom($fetch, options);
-  const plugins = options?.plugins || [];
-  let pluginsActions = {};
-  const pluginsAtoms = {
-    $sessionSignal,
-    session
-  };
-  const pluginPathMethods = {
-    "/sign-out": "POST",
-    "/revoke-sessions": "POST",
-    "/revoke-other-sessions": "POST",
-    "/delete-user": "POST"
-  };
-  const atomListeners = [{
-    signal: "$sessionSignal",
-    matcher(path) {
-      return path === "/sign-out" || path === "/update-user" || path === "/update-session" || path === "/sign-up/email" || path === "/sign-in/email" || path === "/delete-user" || path === "/verify-email" || path === "/revoke-sessions" || path === "/revoke-session" || path === "/revoke-other-sessions" || path === "/change-email" || path === "/change-password";
-    },
-    callback(path) {
-      if (path === "/sign-out") broadcastSessionUpdate("signout");
-      else if (path === "/update-user" || path === "/update-session") broadcastSessionUpdate("updateUser");
-    }
-  }];
-  for (const plugin of plugins) {
-    if (plugin.getAtoms) Object.assign(pluginsAtoms, plugin.getAtoms?.($fetch));
-    if (plugin.pathMethods) Object.assign(pluginPathMethods, plugin.pathMethods);
-    if (plugin.atomListeners) atomListeners.push(...plugin.atomListeners);
-  }
-  const $store = {
-    notify: (signal) => {
-      pluginsAtoms[signal].set(!pluginsAtoms[signal].get());
-    },
-    listen: (signal, listener) => {
-      pluginsAtoms[signal].subscribe(listener);
-    },
-    atoms: pluginsAtoms
-  };
-  for (const plugin of plugins) if (plugin.getActions) pluginsActions = defu(plugin.getActions?.($fetch, $store, options) ?? {}, pluginsActions);
-  return {
-    get baseURL() {
-      return baseURL;
-    },
-    pluginsActions,
-    pluginsAtoms,
-    pluginPathMethods,
-    atomListeners,
-    $fetch,
-    $store
-  };
-};
-
-// node_modules/better-auth/dist/utils/is-atom.mjs
-function isAtom(value) {
-  return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
-}
-
-// node_modules/better-auth/dist/client/proxy.mjs
-function getMethod(path, knownPathMethods, args) {
-  const method = knownPathMethods[path];
-  const { fetchOptions, query: _query, ...body } = args || {};
-  if (method) return method;
-  if (fetchOptions?.method) return fetchOptions.method;
-  if (body && Object.keys(body).length > 0) return "POST";
-  return "GET";
-}
-function createDynamicPathProxy(routes, client, knownPathMethods, atoms, atomListeners) {
-  function createProxy(path = []) {
-    return new Proxy(function() {
-    }, {
-      get(_, prop) {
-        if (typeof prop !== "string") return;
-        if (prop === "then" || prop === "catch" || prop === "finally") return;
-        const fullPath = [...path, prop];
-        let current = routes;
-        for (const segment of fullPath) if (current && typeof current === "object" && segment in current) current = current[segment];
-        else {
-          current = void 0;
-          break;
-        }
-        if (typeof current === "function") return current;
-        if (isAtom(current)) return current;
-        return createProxy(fullPath);
-      },
-      apply: async (_, __, args) => {
-        const routePath = "/" + path.map((segment) => segment.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)).join("/");
-        const arg = args[0] || {};
-        const fetchOptions = args[1] || {};
-        const { query, fetchOptions: argFetchOptions, ...body } = arg;
-        const options = {
-          ...fetchOptions,
-          ...argFetchOptions
-        };
-        const method = getMethod(routePath, knownPathMethods, arg);
-        return await client(routePath, {
-          ...options,
-          body: method === "GET" ? void 0 : {
-            ...body,
-            ...options?.body || {}
-          },
-          query: query || options?.query,
-          method,
-          async onSuccess(context) {
-            await options?.onSuccess?.(context);
-            if (!atomListeners || options.disableSignal) return;
-            const matches = atomListeners.filter((s) => s.matcher(routePath));
-            if (!matches.length) return;
-            const visited = /* @__PURE__ */ new Set();
-            for (const match of matches) {
-              const signal = atoms[match.signal];
-              if (!signal) return;
-              if (visited.has(match.signal)) continue;
-              visited.add(match.signal);
-              const val = signal.get();
-              setTimeout(() => {
-                signal.set(!val);
-              }, 10);
-              match.callback?.(routePath);
-            }
-          }
-        });
-      }
-    });
-  }
-  return createProxy();
-}
-
-// node_modules/better-auth/dist/client/vanilla.mjs
-function createAuthClient(options) {
-  const { pluginPathMethods, pluginsActions, pluginsAtoms, $fetch, atomListeners, $store } = getClientConfig(options);
-  const resolvedHooks = {};
-  for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[`use${capitalizeFirstLetter(key)}`] = value;
-  return createDynamicPathProxy({
-    ...pluginsActions,
-    ...resolvedHooks,
-    $fetch,
-    $store
-  }, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
-}
-
-// src/client/auth.ts
 var AUTH_TOKEN_KEY = "better-auth.session_token";
 function createLeapifyAuthClient(baseUrl) {
   return createAuthClient({
@@ -841,50 +49,64 @@ async function signOut(authClient) {
   return result;
 }
 
-// src/client/pow.ts
-var POW_VERIFY_PATH = "/.well-known/leapify/pow/verify";
-async function solvePowChallenge(baseUrl) {
+// src/client/turnstile.ts
+var TURNSTILE_VERIFY_PATH = "/.well-known/leapify/turnstile/verify";
+function getTurnstileSiteKey() {
+  const config = window.__CONFIG__;
+  return config?.turnstileSiteKey;
+}
+function loadTurnstileScript() {
+  return new Promise((resolve, reject) => {
+    if (typeof window.turnstile !== "undefined") {
+      resolve();
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit";
+    script.async = true;
+    script.defer = true;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error("Failed to load Turnstile script"));
+    document.head.appendChild(script);
+  });
+}
+function executeTurnstile(siteKey) {
+  return new Promise((resolve) => {
+    const container = document.createElement("div");
+    container.id = "leapify-turnstile-container";
+    container.style.display = "none";
+    document.body.appendChild(container);
+    window.turnstile.render(`#${container.id}`, {
+      sitekey: siteKey,
+      callback: (token) => {
+        container.remove();
+        resolve(token);
+      }
+    });
+  });
+}
+async function solveTurnstileChallenge(baseUrl, siteKey) {
+  siteKey = siteKey ?? getTurnstileSiteKey();
+  if (!siteKey) return false;
   const base = baseUrl?.replace(/\/$/, "") ?? "";
-  let html;
   try {
-    const res = await fetch(`${base}/api/classes`, { credentials: "include" });
-    const ct = res.headers.get("content-type") || "";
-    if (!ct.includes("text/html")) {
-      return false;
-    }
-    html = await res.text();
+    await loadTurnstileScript();
+    const token = await executeTurnstile(siteKey);
+    const res = await fetch(`${base}${TURNSTILE_VERIFY_PATH}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token }),
+      credentials: "include"
+    });
+    return res.ok;
   } catch {
     return false;
   }
-  const idMatch = html.match(/challengeId\s*=\s*"([^"]+)"/);
-  const diffMatch = html.match(/difficulty\s*=\s*(\d+)/);
-  if (!idMatch || !diffMatch) {
-    return false;
-  }
-  const challengeId = idMatch[1];
-  const difficulty = Number(diffMatch[1]);
-  const prefix = "0".repeat(Math.ceil(difficulty / 4));
-  let nonce = 0;
-  while (true) {
-    const input = new TextEncoder().encode(`${challengeId}:${nonce}`);
-    const hash = await crypto.subtle.digest("SHA-256", input);
-    const hex = Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
-    if (hex.startsWith(prefix)) {
-      await fetch(`${base}${POW_VERIFY_PATH}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ id: challengeId, nonce, elapsed: 0 }),
-        credentials: "include"
-      });
-      return true;
-    }
-    nonce++;
-  }
 }
 
 // src/client/session.ts
 async function initializeSession(baseUrl, getToken) {
-  await solvePowChallenge(baseUrl);
+  await solveTurnstileChallenge(baseUrl);
   const token = await getToken();
   if (!token) return null;
   const base = baseUrl.replace(/\/$/, "");
@@ -897,7 +119,7 @@ async function initializeSession(baseUrl, getToken) {
 }
 
 // src/client/index.ts
-function getClientConfig2() {
+function getClientConfig() {
   if (typeof window === "undefined") return null;
   const config = window.__CONFIG__;
   if (!config || typeof config !== "object") return null;
@@ -1216,14 +438,6 @@ function createLeapifyClient(baseUrl, getToken) {
       formData.append("file", file);
       return postFormData("/api/uploads/images", formData);
     },
-    // ── Content Sync ───────────────────────────────────────────────────────
-    /**
-     * POST /api/config/sync-content — admin only.
-     * Pushes all D1 content to Contentful. Auto-generates content types if missing.
-     */
-    syncContent() {
-      return post("/api/config/sync-content");
-    },
     // ── Health ─────────────────────────────────────────────────────────────
     /**
      * GET /health
@@ -1235,6 +449,6 @@ function createLeapifyClient(baseUrl, getToken) {
   };
 }
 
-export { LEAPIFY_ERROR_CODES, LeapifyApiError, createLeapifyAuthClient, createLeapifyClient, getClientConfig2 as getClientConfig, getLeapifyToken, initializeSession, signInWithGoogleRedirect, signOut, solvePowChallenge, syncCookieSessionToStorage };
+export { LEAPIFY_ERROR_CODES, LeapifyApiError, createLeapifyAuthClient, createLeapifyClient, getClientConfig, getLeapifyToken, initializeSession, signInWithGoogleRedirect, signOut, solveTurnstileChallenge, syncCookieSessionToStorage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map