@access-dlsu/leapify 0.260505.5 → 0.260506.1

package/dist/client/index.js

@@ -1,6 +1,798 @@
-import '../chunk-PZ5AY32C.js';
-import { createAuthClient } from 'better-auth/client';
+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';
 
+// 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({
@@ -55,7 +847,7 @@ async function solvePowChallenge(baseUrl) {
   const base = baseUrl?.replace(/\/$/, "") ?? "";
   let html;
   try {
-    const res = await fetch(`${base}/events`, { credentials: "include" });
+    const res = await fetch(`${base}/api/events`, { credentials: "include" });
     const ct = res.headers.get("content-type") || "";
     if (!ct.includes("text/html")) {
       return false;
@@ -96,7 +888,7 @@ async function initializeSession(baseUrl, getToken) {
   const token = await getToken();
   if (!token) return null;
   const base = baseUrl.replace(/\/$/, "");
-  const res = await fetch(`${base}/users/me`, {
+  const res = await fetch(`${base}/api/users/me`, {
     headers: { Authorization: `Bearer ${token}` }
   });
   if (!res.ok) return null;
@@ -105,7 +897,7 @@ async function initializeSession(baseUrl, getToken) {
 }
 
 // src/client/index.ts
-function getClientConfig() {
+function getClientConfig2() {
   if (typeof window === "undefined") return null;
   const config = window.__CONFIG__;
   if (!config || typeof config !== "object") return null;
@@ -205,163 +997,163 @@ function createLeapifyClient(baseUrl, getToken) {
      * Use `now` (server unix epoch) for timestamp comparisons.
      */
     getConfig() {
-      return get("/config");
+      return get("/api/config");
     },
     /**
-     * PATCH /config/:key — admin only.
+     * PATCH /api/config/:key — admin only.
      * Upserts a site config value. Requires admin or super_admin role.
      */
     updateConfig(key, value) {
-      return patch(`/config/${encodeURIComponent(key)}`, { value });
+      return patch(`/api/config/${encodeURIComponent(key)}`, { value });
     },
     // ── Events ─────────────────────────────────────────────────────────────
     /**
-     * GET /events
+     * GET /api/events
      * Returns all published events. Response is ETag-cached for 7 days.
      */
     getEvents() {
-      return get("/events");
+      return get("/api/events");
     },
     /**
-     * GET /events/:slug
+     * GET /api/events/:slug
      * Returns a single published event by slug.
      */
     getEvent(slug) {
-      return get(`/events/${encodeURIComponent(slug)}`);
+      return get(`/api/events/${encodeURIComponent(slug)}`);
     },
     /**
-     * GET /events/:slug/slots
+     * GET /api/events/:slug/slots
      * Returns real-time slot availability. CF edge caches this for 5 seconds.
      * Poll every 8–10 seconds on event detail pages.
      */
     getSlots(slug) {
-      return get(`/events/${encodeURIComponent(slug)}/slots`);
+      return get(`/api/events/${encodeURIComponent(slug)}/slots`);
     },
     /**
-     * POST /events — admin only.
+     * POST /api/events — admin only.
      * Creates a new event. Auto-generates slug from title.
      */
     createEvent(data) {
-      return post("/events", data);
+      return post("/api/events", data);
     },
     /**
-     * PATCH /events/:slug — admin only.
+     * PATCH /api/events/:slug — admin only.
      * Updates an existing event by slug.
      */
     updateEvent(slug, data) {
-      return patch(`/events/${encodeURIComponent(slug)}`, data);
+      return patch(`/api/events/${encodeURIComponent(slug)}`, data);
     },
     // ── Themes ─────────────────────────────────────────────────────────────
     /**
-     * GET /themes
+     * GET /api/themes
      * Returns all themes.
      */
     getThemes() {
-      return get("/themes");
+      return get("/api/themes");
     },
     /**
-     * POST /themes — admin only.
+     * POST /api/themes — admin only.
      */
     createTheme(data) {
-      return post("/themes", data);
+      return post("/api/themes", data);
     },
     /**
-     * PATCH /themes/:id — admin only.
+     * PATCH /api/themes/:id — admin only.
      */
     updateTheme(id, data) {
-      return patch(`/themes/${encodeURIComponent(id)}`, data);
+      return patch(`/api/themes/${encodeURIComponent(id)}`, data);
     },
     /**
-     * DELETE /themes/:id — admin only.
+     * DELETE /api/themes/:id — admin only.
      */
     deleteTheme(id) {
-      return del(`/themes/${encodeURIComponent(id)}`);
+      return del(`/api/themes/${encodeURIComponent(id)}`);
     },
     // ── Users ──────────────────────────────────────────────────────────────
     /**
-     * GET /users/me
+     * GET /api/users/me
      * Returns the authenticated user's profile, or null for guests.
      * Use `profile.role` to gate admin UI.
      */
     getMe() {
-      return get("/users/me");
+      return get("/api/users/me");
     },
     // ── Bookmarks ──────────────────────────────────────────────────────────
     /**
-     * GET /users/me/bookmarks
+     * GET /api/users/me/bookmarks
      * Returns the authenticated user's bookmarked events.
      * Returns an empty array for unauthenticated users.
      */
     getBookmarks() {
-      return get("/users/me/bookmarks");
+      return get("/api/users/me/bookmarks");
     },
     /**
-     * POST /users/me/bookmarks/:eventId
+     * POST /api/users/me/bookmarks/:eventId
      * Toggles a bookmark on/off. Requires authentication.
      * Returns `{ bookmarked: true }` (201) on add, `{ bookmarked: false }` (200) on remove.
      */
     toggleBookmark(eventId) {
       return post(
-        `/users/me/bookmarks/${encodeURIComponent(eventId)}`
+        `/api/users/me/bookmarks/${encodeURIComponent(eventId)}`
       );
     },
     /**
-     * DELETE /users/me/bookmarks/:eventId
+     * DELETE /api/users/me/bookmarks/:eventId
      * Removes a bookmark. Requires authentication.
      */
     deleteBookmark(eventId) {
       return del(
-        `/users/me/bookmarks/${encodeURIComponent(eventId)}`
+        `/api/users/me/bookmarks/${encodeURIComponent(eventId)}`
       );
     },
     // ── FAQs ───────────────────────────────────────────────────────────────
     /**
-     * GET /faqs
+     * GET /api/faqs
      * Returns all active FAQs. Cached in KV for 10 minutes.
      * The `answer` field is markdown — render with a markdown library.
      */
     getFaqs() {
-      return get("/faqs");
+      return get("/api/faqs");
     },
     /**
-     * POST /faqs — admin only.
+     * POST /api/faqs — admin only.
      * Creates a new FAQ item.
      */
     createFaq(data) {
-      return post("/faqs", data);
+      return post("/api/faqs", data);
     },
     /**
-     * PATCH /faqs/:id — admin only.
+     * PATCH /api/faqs/:id — admin only.
      * Updates an existing FAQ item.
      */
     updateFaq(id, data) {
-      return patch(`/faqs/${encodeURIComponent(id)}`, data);
+      return patch(`/api/faqs/${encodeURIComponent(id)}`, data);
     },
     /**
-     * DELETE /faqs/:id — admin only.
+     * DELETE /api/faqs/:id — admin only.
      * Soft-deletes a FAQ (sets isActive: false).
      */
     deleteFaq(id) {
-      return del(`/faqs/${encodeURIComponent(id)}`);
+      return del(`/api/faqs/${encodeURIComponent(id)}`);
     },
     // ── Uploads ────────────────────────────────────────────────────────────
     /**
-     * POST /uploads/images — admin only.
+     * POST /api/uploads/images — admin only.
      * Uploads an image file to R2. Accepts multipart/form-data.
      * Returns the public URL, storage key, size, and content type.
      */
     uploadImage(file) {
       const formData = new FormData();
       formData.append("file", file);
-      return postFormData("/uploads/images", formData);
+      return postFormData("/api/uploads/images", formData);
     },
     // ── Content Sync ───────────────────────────────────────────────────────
     /**
-     * POST /config/sync-content — admin only.
+     * POST /api/config/sync-content — admin only.
      * Pushes all D1 content to Contentful. Auto-generates content types if missing.
      */
     syncContent() {
-      return post("/config/sync-content");
+      return post("/api/config/sync-content");
     },
     // ── Health ─────────────────────────────────────────────────────────────
     /**
@@ -374,6 +1166,6 @@ function createLeapifyClient(baseUrl, getToken) {
   };
 }
 
-export { LEAPIFY_ERROR_CODES, LeapifyApiError, createLeapifyAuthClient, createLeapifyClient, getClientConfig, getLeapifyToken, initializeSession, signInWithGoogleRedirect, signOut, solvePowChallenge, syncCookieSessionToStorage };
+export { LEAPIFY_ERROR_CODES, LeapifyApiError, createLeapifyAuthClient, createLeapifyClient, getClientConfig2 as getClientConfig, getLeapifyToken, initializeSession, signInWithGoogleRedirect, signOut, solvePowChallenge, syncCookieSessionToStorage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map