@fluixi/auth 1.0.0-alpha.100

package/dist/client.js

@@ -0,0 +1,291 @@
+/**
+ * @fluixi/auth/client: the reactive client hooks.
+ *
+ * The session is an isomorphic store: resolved on the server from `locals.auth`
+ * (serialized into the page) and seeded synchronously on the client → no auth flash, no
+ * post-hydration refetch. Two ways to drive it:
+ *   • `{ client }`: a Better Auth client.
+ *   • `{ session }`: an existing reactive session (e.g. @fluixi/session's createSession or
+ *     any `{ user(), login?, logout? }`). The framework OWNS the reactive sync, so apps stop
+ *     hand-writing a `createEffect` to mirror their store into the auth hooks.
+ *
+ * Client-only deps: fluixi + @fluixi/dom's pure `getLocals`, never @fluixi/server.
+ */
+import { createIsomorphicStore, createEffect, createRoot, env } from '@fluixi/core';
+import { getLocals } from '@fluixi/dom';
+import { AUTH_LOCALS_KEY, } from './types.js';
+export function createAuthHooks(options) {
+    const sess = options.session;
+    const store = createIsomorphicStore('auth', {
+        // Server: read what authMiddleware put on locals → serialized for the client to seed.
+        server: () => getLocals()[AUTH_LOCALS_KEY] ?? { user: null, session: null },
+        // SPA cold load: from the provided session, else the Better Auth client.
+        client: async () => sess
+            ? { user: sess.user(), session: null }
+            : normalize(await options.client.getSession()),
+        fallback: { user: null, session: null },
+    });
+    // `{ session }` path: the framework owns the reactive bridge (no app-level effect).
+    if (sess) {
+        const apply = () => {
+            if (options.ready && !options.ready())
+                return;
+            store.set({ user: sess.user(), session: null });
+        };
+        apply(); // immediate, so a first protectedRoute read isn't stale
+        createRoot(() => createEffect(apply, undefined, { name: 'auth ← session' }));
+    }
+    const refresh = async () => {
+        store.set(sess ? { user: sess.user(), session: null } : normalize(await options.client.getSession()));
+    };
+    const signIn = sess
+        ? ((...args) => sess.login?.(...args) ?? Promise.resolve())
+        : async (creds) => {
+            await options.client.signIn.email(creds);
+            await refresh();
+        };
+    const signOut = sess
+        ? () => sess.logout?.() ?? Promise.resolve()
+        : async () => {
+            await options.client.signOut();
+            store.set({ user: null, session: null });
+        };
+    /**
+     * Send the visitor somewhere else.
+     *
+     * The route's own `navigator` wins, then the one given to `createAuthHooks`, then a
+     * document load. A handler is a factory rather than a function: `useNavigate` has to
+     * run inside the component being rendered, so it is called here, at the redirect,
+     * instead of when the hooks were built.
+     *
+     * Without a handler this assigns `location`, which loads a document and rebuilds the
+     * whole app. That is right for an app with no client router and wrong for one that
+     * has it, which is what the option exists to fix.
+     */
+    const go = (to, opts) => {
+        const fromRoute = typeof opts?.handler === 'function' ? opts.handler() : undefined;
+        const fromHooks = typeof options.navigate === 'function'
+            ? options.navigate
+            : typeof options.navigate?.handler === 'function'
+                ? // Called, not passed along. Handing back the factory made `fn(to)` build a
+                    // navigate function and return it, so the redirect silently did nothing.
+                    options.navigate.handler()
+                : undefined;
+        const fn = fromRoute ?? fromHooks;
+        if (fn) {
+            const navigateOptions = opts?.options ??
+                (typeof options.navigate === 'object' ? options.navigate?.options : undefined);
+            // Only when there are some. Deciding on the handler's arity instead dropped them
+            // for anything declaring the parameter optional, which `useNavigate` does; passing
+            // `undefined` regardless would change the call every handler sees.
+            if (navigateOptions)
+                fn(to, navigateOptions);
+            else
+                fn(to);
+            return;
+        }
+        env.window?.location.assign(to);
+    };
+    // ── RBAC surface (driven by the bound session's access config) ────────────────
+    const permissions = () => sess?.permissions?.();
+    const can = (query) => sess?.can?.(query) ?? false;
+    const roleList = () => {
+        if (sess?.roles)
+            return sess.roles();
+        const r = store.fields.user()?.role;
+        return r ? [r] : [];
+    };
+    const passesRole = (opts) => {
+        if (opts?.role && !roleList().includes(opts.role))
+            return false;
+        if (opts?.roles && !opts.roles.some((r) => roleList().includes(r)))
+            return false;
+        if (opts?.permission !== undefined && !can(opts.permission))
+            return false;
+        return true;
+    };
+    /**
+     * Show something only when the access matcher allows it.
+     *
+     * Asks a permission question, which is the finer of the two: `Protect` asks who
+     * someone is, this asks what they may do. Reactive, so it follows a role change
+     * without a reload.
+     *
+     * @example
+     * ```tsx
+     * <Can perform={(p) => p.invoices.refund} fallback={<Tooltip>Ask an admin</Tooltip>}>
+     *   <button onClick={refund}>Refund</button>
+     * </Can>
+     * ```
+     */
+    function Can(props) {
+        return () => (can(props.perform) ? props.children : (props.fallback ?? null));
+    }
+    /**
+     * Show a section of a page to some people and not others.
+     *
+     * Renders `fallback` for a signed-out visitor, and for a signed-in one who lacks the
+     * role. Nothing navigates: the rest of the page stays exactly as it is, which is the
+     * difference from `protectedRoute`.
+     *
+     * Reach for it inside a page. Reach for `protectedRoute` when the whole page should
+     * not have been reachable.
+     *
+     * @example
+     * ```tsx
+     * <Protect roles={['admin', 'support']} fallback={null}>
+     *   <DangerZone />
+     * </Protect>
+     * ```
+     */
+    function Protect(props) {
+        return () => {
+            if (!store.fields.user())
+                return props.fallback ?? null;
+            return passesRole(props) ? props.children : (props.fallback ?? null);
+        };
+    }
+    /**
+     * Wrap a page so the wrong visitor never reaches it.
+     *
+     * Unlike `Protect`, this **navigates**: a signed-out visitor goes to `loginPath`, one
+     * lacking the role goes to `forbiddenPath`, and with `guestOnly` a signed-in visitor
+     * goes to `homePath`. The component never runs, so a page that loads data on mount
+     * does not load it for someone who should not see it.
+     *
+     * This is a client-side guard and a rendering decision. It is not authorization: the
+     * server has to refuse the request as well, because a client can be made to skip this.
+     *
+     * @example
+     * ```tsx
+     * // the whole page, behind a role
+     * export default protectedRoute(AdminPage, { role: 'admin' });
+     *
+     * // a login page, which a signed-in visitor has no use for
+     * export default protectedRoute(LoginPage, { guestOnly: true });
+     * ```
+     */
+    function protectedRoute(Comp, opts) {
+        return (props) => {
+            const user = store.fields.user();
+            if (opts?.guestOnly) {
+                if (user)
+                    return go(options.homePath ?? '/', opts?.navigator), null;
+            }
+            else {
+                if (!user)
+                    return go(options.loginPath ?? '/login', opts?.navigator), null;
+                if (!passesRole(opts))
+                    return go(options.forbiddenPath ?? '/403'), null;
+            }
+            return Comp(props);
+        };
+    }
+    return {
+        /**
+         * The signed-in user, or null.
+         *
+         * Returns the accessor rather than the value, so a component reads it where it
+         * renders and re-renders when it changes.
+         *
+         * @example
+         * ```tsx
+         * const user = useUser();
+         * <span>{() => user()?.email ?? 'Signed out'}</span>
+         * ```
+         */
+        useUser: () => store.fields.user,
+        /**
+         * The session record beside the user: when it expires, and whatever else the
+         * backend attached. Null when signed out.
+         */
+        useSession: () => store.fields.session,
+        /**
+         * Everything at once, for a component that needs more than one of them.
+         *
+         * @example
+         * ```tsx
+         * const { user, isAuthenticated, can, signOut } = useAuth();
+         * ```
+         */
+        useAuth: () => ({
+            user: store.fields.user,
+            session: store.fields.session,
+            isAuthenticated: () => store.fields.user() !== null,
+            roles: roleList,
+            can,
+            signIn,
+            signOut,
+        }),
+        /**
+         * Start a sign-in.
+         *
+         * What it takes depends on what the hooks were given: credentials for a Better Auth
+         * client, and for a redirect flow whatever that session's `login` expects.
+         *
+         * @example
+         * ```tsx
+         * const signIn = useSignIn();
+         * <button onClick={() => signIn({ email, password })}>Sign in</button>
+         * ```
+         */
+        useSignIn: () => signIn,
+        /**
+         * End the session.
+         *
+         * @example
+         * ```tsx
+         * const signOut = useSignOut();
+         * <button onClick={() => signOut()}>Sign out</button>
+         * ```
+         */
+        useSignOut: () => signOut,
+        /**
+         * The permission set for the current roles, reactively.
+         *
+         * A rendering hint and nothing more: a client can claim any permission, so the
+         * server decides what is allowed on every request.
+         */
+        usePermissions: () => permissions,
+        /**
+         * Ask whether the current user may do something.
+         *
+         * `false` when the session supplies no RBAC, so a missing `access` config hides a
+         * control rather than revealing it.
+         *
+         * @example
+         * ```tsx
+         * const can = useCan();
+         * <button disabled={() => !can((p) => p.users.delete)}>Delete</button>
+         * ```
+         */
+        useCan: () => can,
+        Can,
+        Protect,
+        /**
+         * Re-read the session from the backend.
+         *
+         * For after something changed outside this tab: a role granted elsewhere, or a
+         * return from a flow that altered the account.
+         *
+         * @example
+         * ```ts
+         * await refresh();
+         * ```
+         */
+        refresh,
+        protectedRoute,
+        /**
+         * The underlying isomorphic store.
+         *
+         * Escape hatch. It is here for a test that wants to seed a user, and for the rare
+         * caller that needs to write what the hooks read. Prefer the accessors above:
+         * writing to the store directly puts the interface out of step with the session
+         * that owns it.
+         */
+        store,
+    };
+}
+function normalize(r) {
+    return { user: r.data?.user ?? null, session: r.data?.session ?? null };
+}

package/dist/client.mjs

@@ -0,0 +1,199 @@
+/*! @fluixi/auth v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/client.ts
+import { createIsomorphicStore, createEffect, createRoot, env } from "@fluixi/core";
+import { getLocals } from "@fluixi/dom";
+
+// src/types.ts
+var AUTH_LOCALS_KEY = "auth";
+
+// src/client.ts
+function createAuthHooks(options) {
+  const sess = options.session;
+  const store = createIsomorphicStore("auth", {
+    // Server: read what authMiddleware put on locals → serialized for the client to seed.
+    server: () => getLocals()[AUTH_LOCALS_KEY] ?? { user: null, session: null },
+    // SPA cold load: from the provided session, else the Better Auth client.
+    client: async () => sess ? { user: sess.user(), session: null } : normalize(await options.client.getSession()),
+    fallback: { user: null, session: null }
+  });
+  if (sess) {
+    const apply = () => {
+      if (options.ready && !options.ready()) return;
+      store.set({ user: sess.user(), session: null });
+    };
+    apply();
+    createRoot(() => createEffect(apply, void 0, { name: "auth ← session" }));
+  }
+  const refresh = async () => {
+    store.set(sess ? { user: sess.user(), session: null } : normalize(await options.client.getSession()));
+  };
+  const signIn = sess ? ((...args) => sess.login?.(...args) ?? Promise.resolve()) : async (creds) => {
+    await options.client.signIn.email(creds);
+    await refresh();
+  };
+  const signOut = sess ? () => sess.logout?.() ?? Promise.resolve() : async () => {
+    await options.client.signOut();
+    store.set({ user: null, session: null });
+  };
+  const go = (to, opts) => {
+    const fromRoute = typeof opts?.handler === "function" ? opts.handler() : void 0;
+    const fromHooks = typeof options.navigate === "function" ? options.navigate : typeof options.navigate?.handler === "function" ? (
+      // Called, not passed along. Handing back the factory made `fn(to)` build a
+      // navigate function and return it, so the redirect silently did nothing.
+      options.navigate.handler()
+    ) : void 0;
+    const fn = fromRoute ?? fromHooks;
+    if (fn) {
+      const navigateOptions = opts?.options ?? (typeof options.navigate === "object" ? options.navigate?.options : void 0);
+      if (navigateOptions) fn(to, navigateOptions);
+      else fn(to);
+      return;
+    }
+    env.window?.location.assign(to);
+  };
+  const permissions = () => sess?.permissions?.();
+  const can = (query) => sess?.can?.(query) ?? false;
+  const roleList = () => {
+    if (sess?.roles) return sess.roles();
+    const r = store.fields.user()?.role;
+    return r ? [r] : [];
+  };
+  const passesRole = (opts) => {
+    if (opts?.role && !roleList().includes(opts.role)) return false;
+    if (opts?.roles && !opts.roles.some((r) => roleList().includes(r))) return false;
+    if (opts?.permission !== void 0 && !can(opts.permission)) return false;
+    return true;
+  };
+  function Can(props) {
+    return () => can(props.perform) ? props.children : props.fallback ?? null;
+  }
+  function Protect(props) {
+    return () => {
+      if (!store.fields.user()) return props.fallback ?? null;
+      return passesRole(props) ? props.children : props.fallback ?? null;
+    };
+  }
+  function protectedRoute(Comp, opts) {
+    return (props) => {
+      const user = store.fields.user();
+      if (opts?.guestOnly) {
+        if (user) return go(options.homePath ?? "/", opts?.navigator), null;
+      } else {
+        if (!user) return go(options.loginPath ?? "/login", opts?.navigator), null;
+        if (!passesRole(opts)) return go(options.forbiddenPath ?? "/403"), null;
+      }
+      return Comp(props);
+    };
+  }
+  return {
+    /**
+     * The signed-in user, or null.
+     *
+     * Returns the accessor rather than the value, so a component reads it where it
+     * renders and re-renders when it changes.
+     *
+     * @example
+     * ```tsx
+     * const user = useUser();
+     * <span>{() => user()?.email ?? 'Signed out'}</span>
+     * ```
+     */
+    useUser: () => store.fields.user,
+    /**
+     * The session record beside the user: when it expires, and whatever else the
+     * backend attached. Null when signed out.
+     */
+    useSession: () => store.fields.session,
+    /**
+     * Everything at once, for a component that needs more than one of them.
+     *
+     * @example
+     * ```tsx
+     * const { user, isAuthenticated, can, signOut } = useAuth();
+     * ```
+     */
+    useAuth: () => ({
+      user: store.fields.user,
+      session: store.fields.session,
+      isAuthenticated: () => store.fields.user() !== null,
+      roles: roleList,
+      can,
+      signIn,
+      signOut
+    }),
+    /**
+     * Start a sign-in.
+     *
+     * What it takes depends on what the hooks were given: credentials for a Better Auth
+     * client, and for a redirect flow whatever that session's `login` expects.
+     *
+     * @example
+     * ```tsx
+     * const signIn = useSignIn();
+     * <button onClick={() => signIn({ email, password })}>Sign in</button>
+     * ```
+     */
+    useSignIn: () => signIn,
+    /**
+     * End the session.
+     *
+     * @example
+     * ```tsx
+     * const signOut = useSignOut();
+     * <button onClick={() => signOut()}>Sign out</button>
+     * ```
+     */
+    useSignOut: () => signOut,
+    /**
+     * The permission set for the current roles, reactively.
+     *
+     * A rendering hint and nothing more: a client can claim any permission, so the
+     * server decides what is allowed on every request.
+     */
+    usePermissions: () => permissions,
+    /**
+     * Ask whether the current user may do something.
+     *
+     * `false` when the session supplies no RBAC, so a missing `access` config hides a
+     * control rather than revealing it.
+     *
+     * @example
+     * ```tsx
+     * const can = useCan();
+     * <button disabled={() => !can((p) => p.users.delete)}>Delete</button>
+     * ```
+     */
+    useCan: () => can,
+    Can,
+    Protect,
+    /**
+     * Re-read the session from the backend.
+     *
+     * For after something changed outside this tab: a role granted elsewhere, or a
+     * return from a flow that altered the account.
+     *
+     * @example
+     * ```ts
+     * await refresh();
+     * ```
+     */
+    refresh,
+    protectedRoute,
+    /**
+     * The underlying isomorphic store.
+     *
+     * Escape hatch. It is here for a test that wants to seed a user, and for the rare
+     * caller that needs to write what the hooks read. Prefer the accessors above:
+     * writing to the store directly puts the interface out of step with the session
+     * that owns it.
+     */
+    store
+  };
+}
+function normalize(r) {
+  return { user: r.data?.user ?? null, session: r.data?.session ?? null };
+}
+export {
+  createAuthHooks
+};

package/dist/cookies.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cookies.ts
+var cookies_exports = {};
+__export(cookies_exports, {
+  deleteCookie: () => import_cookie2.deleteCookie,
+  getCookie: () => getCookie,
+  getCookies: () => getCookies,
+  isValidCookieName: () => import_cookie2.isValidCookieName,
+  parseCookies: () => import_cookie2.parseCookies,
+  serializeCookie: () => import_cookie2.serializeCookie
+});
+module.exports = __toCommonJS(cookies_exports);
+var import_server = require("@fluixi/server");
+var import_cookie = require("@fluixi/utils/cookie");
+var import_cookie2 = require("@fluixi/utils/cookie");
+function requestHeaders() {
+  const req = (0, import_server.getRequestEvent)()?.request;
+  return req?.headers ?? null;
+}
+function getCookie(name) {
+  return (0, import_cookie.parseCookies)(requestHeaders()?.get("cookie"))[name] ?? null;
+}
+function getCookies() {
+  return (0, import_cookie.parseCookies)(requestHeaders()?.get("cookie"));
+}

package/dist/cookies.d.ts

@@ -0,0 +1,7 @@
+export { parseCookies, serializeCookie, deleteCookie, isValidCookieName } from '@fluixi/utils/cookie';
+export type { CookieOptions } from '@fluixi/utils/cookie';
+/** Read one cookie from the CURRENT request (request-scoped). */
+export declare function getCookie(name: string): string | null;
+/** All cookies on the current request. */
+export declare function getCookies(): Record<string, string>;
+//# sourceMappingURL=cookies.d.ts.map

package/dist/cookies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookies.d.ts","sourceRoot":"","sources":["../src/cookies.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACtG,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAO1D,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAErD;AAED,0CAA0C;AAC1C,wBAAgB,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEnD"}

package/dist/cookies.js

@@ -0,0 +1,19 @@
+/**
+ * Request-scoped cookie reads. The codec lives in `@fluixi/utils/cookie` and is re-exported
+ * here; middleware appends `serializeCookie` output to its Response's `set-cookie` header.
+ */
+import { getRequestEvent } from '@fluixi/server';
+import { parseCookies } from '@fluixi/utils/cookie';
+export { parseCookies, serializeCookie, deleteCookie, isValidCookieName } from '@fluixi/utils/cookie';
+function requestHeaders() {
+    const req = getRequestEvent()?.request;
+    return req?.headers ?? null;
+}
+/** Read one cookie from the CURRENT request (request-scoped). */
+export function getCookie(name) {
+    return parseCookies(requestHeaders()?.get('cookie'))[name] ?? null;
+}
+/** All cookies on the current request. */
+export function getCookies() {
+    return parseCookies(requestHeaders()?.get('cookie'));
+}

package/dist/cookies.mjs

@@ -0,0 +1,22 @@
+// src/cookies.ts
+import { getRequestEvent } from "@fluixi/server";
+import { parseCookies } from "@fluixi/utils/cookie";
+import { parseCookies as parseCookies2, serializeCookie, deleteCookie, isValidCookieName } from "@fluixi/utils/cookie";
+function requestHeaders() {
+  const req = getRequestEvent()?.request;
+  return req?.headers ?? null;
+}
+function getCookie(name) {
+  return parseCookies(requestHeaders()?.get("cookie"))[name] ?? null;
+}
+function getCookies() {
+  return parseCookies(requestHeaders()?.get("cookie"));
+}
+export {
+  deleteCookie,
+  getCookie,
+  getCookies,
+  isValidCookieName,
+  parseCookies2 as parseCookies,
+  serializeCookie
+};

package/dist/remote.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/remote.ts
+var remote_exports = {};
+__export(remote_exports, {
+  remoteAuth: () => remoteAuth
+});
+module.exports = __toCommonJS(remote_exports);
+function remoteAuth(options) {
+  const base = new URL((options.basePath ?? "/api/auth").replace(/\/$/, "") + "/", options.url);
+  const call = (input, init) => (options.fetch ?? globalThis.fetch)(input, init);
+  return {
+    async handler(request) {
+      const url = new URL(request.url);
+      const hasBody = request.method !== "GET" && request.method !== "HEAD";
+      return call(new URL(url.pathname + url.search, base), {
+        method: request.method,
+        headers: request.headers,
+        body: hasBody ? request.body : void 0,
+        redirect: "manual",
+        ...hasBody ? { duplex: "half" } : {}
+      });
+    },
+    api: {
+      async getSession({ headers }) {
+        const cookie = headers.get("cookie");
+        if (!cookie) return null;
+        const response = await call(new URL("get-session", base), { headers: { cookie, accept: "application/json" } });
+        if (!response.ok) return null;
+        const body = await response.json().catch(() => null);
+        return body && body.user ? { user: body.user, session: body.session ?? null } : null;
+      }
+    }
+  };
+}

package/dist/remote.d.ts

@@ -0,0 +1,20 @@
+/**
+ * An auth engine that lives in another service. A web app whose Better Auth runs in its API
+ * registers this with `defineAuth(remoteAuth({ url }))`; `authMiddleware()`, `requireUser()` and
+ * the client hooks then work as they would with the engine in-process, each session read being
+ * one request to the API with the visitor's cookie.
+ *
+ * The API's guards (`member()`, `hasPermission`) call the engine directly and stay there: a web
+ * app reads the session, the API decides what it may do.
+ */
+import type { BetterAuthServer } from './types.js';
+export interface RemoteAuthOptions {
+    /** The API's origin, `http://localhost:3301`. */
+    url: string;
+    /** Where the API mounts its auth routes. `/api/auth` by default. */
+    basePath?: string;
+    /** `globalThis.fetch` by default. */
+    fetch?: typeof fetch;
+}
+export declare function remoteAuth(options: RemoteAuthOptions): BetterAuthServer;
+//# sourceMappingURL=remote.d.ts.map

package/dist/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../src/remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,WAAW,iBAAiB;IAChC,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CA4BvE"}