use-convex 0.0.2

package/dist/runtime/server/authCookies.js

@@ -0,0 +1,86 @@
+import {
+  deleteCookie,
+  getCookie,
+  getRequestHeader,
+  setCookie
+} from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import {
+  AUTH_JWT_COOKIE_MAX_AGE,
+  isHttpOnlyAuth,
+  resolveAuthCookieName,
+  resolveAuthPresentCookieName,
+  resolveAuthRefreshCookieName
+} from "../utils/authStorage.js";
+function readAuthConfig(event) {
+  try {
+    const config = useRuntimeConfig(event);
+    return config.public?.convex?.auth;
+  } catch {
+    return void 0;
+  }
+}
+function isLocalHost(event) {
+  const host = getRequestHeader(event, "host") ?? "";
+  return host.startsWith("localhost") || host.startsWith("127.0.0.1") || host.startsWith("[::1]");
+}
+function httpOnlyCookieOptions(event) {
+  const local = isLocalHost(event);
+  return {
+    httpOnly: true,
+    secure: !local,
+    sameSite: "lax",
+    path: "/",
+    maxAge: AUTH_JWT_COOKIE_MAX_AGE
+  };
+}
+function readableCookieOptions(event) {
+  const local = isLocalHost(event);
+  return {
+    httpOnly: false,
+    secure: !local,
+    sameSite: "lax",
+    path: "/",
+    maxAge: AUTH_JWT_COOKIE_MAX_AGE
+  };
+}
+export function setAuthCookies(event, tokens) {
+  const auth = readAuthConfig(event);
+  if (!isHttpOnlyAuth(auth)) {
+    throw new Error(
+      "[convex-nuxt] setAuthCookies requires convex.auth.httpOnly: true"
+    );
+  }
+  const jwtName = resolveAuthCookieName(auth);
+  const refreshName = resolveAuthRefreshCookieName(auth);
+  const presentName = resolveAuthPresentCookieName(auth);
+  const httpOpts = httpOnlyCookieOptions(event);
+  const presentOpts = readableCookieOptions(event);
+  if (!tokens.token) {
+    deleteCookie(event, jwtName, httpOpts);
+    deleteCookie(event, refreshName, httpOpts);
+    deleteCookie(event, presentName, presentOpts);
+    return;
+  }
+  setCookie(event, jwtName, tokens.token, httpOpts);
+  if (tokens.refreshToken) {
+    setCookie(event, refreshName, tokens.refreshToken, httpOpts);
+  }
+  setCookie(event, presentName, "1", presentOpts);
+}
+export function readHttpOnlyJwt(event) {
+  const auth = readAuthConfig(event);
+  const name = resolveAuthCookieName(auth);
+  if (!name) {
+    return void 0;
+  }
+  return getCookie(event, name) || void 0;
+}
+export function readHttpOnlyRefresh(event) {
+  const auth = readAuthConfig(event);
+  const name = resolveAuthRefreshCookieName(auth);
+  if (!name) {
+    return void 0;
+  }
+  return getCookie(event, name) || void 0;
+}

package/dist/runtime/server/fetch.d.ts

@@ -0,0 +1,43 @@
+import type { FunctionArgs, FunctionReference, FunctionReturnType } from 'convex/server';
+import type { H3Event } from 'h3';
+import { resolveFetchToken } from '../utils/fetchToken.js';
+export { resolveFetchToken };
+export interface ConvexFetchOptions {
+    /**
+     * Deployment URL. Defaults to `NUXT_PUBLIC_CONVEX_URL` / runtimeConfig.
+     */
+    url?: string;
+    /**
+     * JWT for this call. Prefer per-request tokens — never put JWTs in public config.
+     * When omitted and `event` is passed, falls back to `convex.auth.cookie` if set.
+     */
+    token?: string;
+    /**
+     * Nitro/H3 event. Used to resolve runtimeConfig and the optional auth cookie.
+     */
+    event?: H3Event;
+    skipConvexDeploymentUrlCheck?: boolean;
+}
+/** @internal Exported for unit tests. */
+export declare function resolveUrl(options: ConvexFetchOptions): string;
+/** @internal Exported for unit tests. */
+export declare function resolveToken(options: ConvexFetchOptions): string | undefined;
+/**
+ * One-shot query via ConvexHttpClient. Use in Nitro routes / server middleware.
+ *
+ * @example
+ * ```ts
+ * export default defineEventHandler(async (event) => {
+ *   return await fetchQuery(api.tasks.list, {}, { event })
+ * })
+ * ```
+ */
+export declare function fetchQuery<Query extends FunctionReference<'query'>>(query: Query, args?: FunctionArgs<Query>, options?: ConvexFetchOptions): Promise<FunctionReturnType<Query>>;
+/**
+ * One-shot mutation via ConvexHttpClient. Use in Nitro routes / server middleware.
+ */
+export declare function fetchMutation<Mutation extends FunctionReference<'mutation'>>(mutation: Mutation, args?: FunctionArgs<Mutation>, options?: ConvexFetchOptions): Promise<FunctionReturnType<Mutation>>;
+/**
+ * One-shot action via ConvexHttpClient. Use in Nitro routes / server middleware.
+ */
+export declare function fetchAction<Action extends FunctionReference<'action'>>(action: Action, args?: FunctionArgs<Action>, options?: ConvexFetchOptions): Promise<FunctionReturnType<Action>>;

package/dist/runtime/server/fetch.js

@@ -0,0 +1,63 @@
+import { getCookie } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { createHttpClient } from "../utils/http.js";
+import { resolveAuthCookieName } from "../utils/authStorage.js";
+import { resolveFetchToken } from "../utils/fetchToken.js";
+export { resolveFetchToken };
+function readConvexConfig(event) {
+  try {
+    const config = useRuntimeConfig(event);
+    return config.public?.convex;
+  } catch {
+    return void 0;
+  }
+}
+export function resolveUrl(options) {
+  if (options.url) {
+    return options.url;
+  }
+  const fromConfig = readConvexConfig(options.event)?.url;
+  if (fromConfig) {
+    return fromConfig;
+  }
+  const fromEnv = process.env.NUXT_PUBLIC_CONVEX_URL;
+  if (fromEnv) {
+    return fromEnv;
+  }
+  throw new Error(
+    "[convex-nuxt] No Convex URL. Pass { url } or set NUXT_PUBLIC_CONVEX_URL."
+  );
+}
+export function resolveToken(options) {
+  if (options.token !== void 0) {
+    return resolveFetchToken({ token: options.token });
+  }
+  const cookieName = resolveAuthCookieName(readConvexConfig(options.event)?.auth);
+  if (!cookieName || !options.event) {
+    return void 0;
+  }
+  return resolveFetchToken({
+    cookieName,
+    cookieValue: getCookie(options.event, cookieName)
+  });
+}
+function setupClient(options = {}) {
+  return createHttpClient(resolveUrl(options), {
+    token: resolveToken(options),
+    skipConvexDeploymentUrlCheck: options.skipConvexDeploymentUrlCheck
+  });
+}
+export async function fetchQuery(query, args, options) {
+  const client = setupClient(options);
+  return await client.query(query, args ?? {});
+}
+export async function fetchMutation(mutation, args, options) {
+  const client = setupClient(options);
+  return await client.mutation(mutation, args ?? {}, {
+    skipQueue: true
+  });
+}
+export async function fetchAction(action, args, options) {
+  const client = setupClient(options);
+  return await client.action(action, args ?? {});
+}

package/dist/runtime/server/routes/__convex_devtools.get.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Minimal DevTools iframe — shows public Convex runtime config.
+ * Connection state is available in-app via `useConvexConnectionState()`.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, string>;
+export default _default;

package/dist/runtime/server/routes/__convex_devtools.get.js

@@ -0,0 +1,32 @@
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+export default defineEventHandler((event) => {
+  const config = useRuntimeConfig(event);
+  const convex = config.public?.convex ?? {};
+  const body = JSON.stringify(
+    {
+      url: convex.url ?? null,
+      server: convex.server ?? true,
+      auth: convex.auth ?? null,
+      tip: "useConvexConnectionState() for live WebSocket status in the app"
+    },
+    null,
+    2
+  );
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Convex \xB7 Nuxt DevTools</title>
+  <style>
+    body { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; margin: 1rem; color: #e5e7eb; background: #0b1220; }
+    h1 { font-size: 0.95rem; font-weight: 600; margin: 0 0 0.75rem; color: #93c5fd; }
+    pre { margin: 0; white-space: pre-wrap; word-break: break-word; font-size: 0.8rem; line-height: 1.45; }
+  </style>
+</head>
+<body>
+  <h1>use-convex</h1>
+  <pre>${body.replace(/</g, "&lt;")}</pre>
+</body>
+</html>`;
+});

package/dist/runtime/server/sameOrigin.d.ts

@@ -0,0 +1,14 @@
+import { type H3Event } from 'h3';
+/**
+ * Fail-closed same-origin guard for cookie-bearing auth routes.
+ *
+ * Accepts the request when:
+ * - `Sec-Fetch-Site` is `same-origin` or `none` (user-initiated / same origin), or
+ * - `Origin` matches the trusted request origin (scheme + host), using
+ *   `Host` and `getRequestProtocol` (honors `X-Forwarded-Proto` behind proxies).
+ *
+ * Rejects when `Sec-Fetch-Site` is `cross-site` / `same-site`, or when neither
+ * signal can confirm same-origin. Missing both headers is rejected.
+ * Scheme-mismatched Origins (e.g. `http://` vs HTTPS request) are rejected.
+ */
+export declare function assertSameOrigin(event: H3Event): void;

package/dist/runtime/server/sameOrigin.js

@@ -0,0 +1,33 @@
+import {
+  createError,
+  getRequestHeader,
+  getRequestProtocol
+} from "h3";
+export function assertSameOrigin(event) {
+  const secFetchSite = getRequestHeader(event, "sec-fetch-site");
+  if (secFetchSite === "same-origin" || secFetchSite === "none") {
+    return;
+  }
+  if (secFetchSite === "cross-site" || secFetchSite === "same-site") {
+    throw createError({
+      statusCode: 403,
+      message: "Forbidden"
+    });
+  }
+  const origin = getRequestHeader(event, "origin");
+  const host = getRequestHeader(event, "host");
+  if (origin && host) {
+    try {
+      const originUrl = new URL(origin);
+      const protocol = getRequestProtocol(event, { xForwardedProto: true });
+      if (originUrl.protocol === `${protocol}:` && originUrl.host === host) {
+        return;
+      }
+    } catch {
+    }
+  }
+  throw createError({
+    statusCode: 403,
+    message: "Forbidden"
+  });
+}

package/dist/runtime/utils/authCookie.d.ts

@@ -0,0 +1,21 @@
+import { type ComputedRef } from 'vue';
+import { AUTH_JWT_COOKIE_MAX_AGE } from './authStorage.js';
+export { AUTH_JWT_COOKIE_MAX_AGE };
+/**
+ * Shared JWT cookie for SSR snapshots. Same name + options as persistTokens
+ * so plugin reads and sign-in/out writes share one Nuxt cookie ref.
+ *
+ * When `auth.httpOnly` is set, this cookie is HttpOnly (server-readable only).
+ */
+export declare function useAuthJwtCookie(): import("nuxt/app").CookieRef<string | null> | undefined;
+/**
+ * Readable presence marker used when JWT is HttpOnly so the client can still
+ * compute `hasSsrSession` / `showAuthedUi` without reading the token.
+ */
+export declare function useAuthPresentCookie(): import("nuxt/app").CookieRef<string | null> | undefined;
+/** Reactive JWT for HttpClient + SSR. Empty on the client when HttpOnly. */
+export declare function useSsrTokenRef(): ComputedRef<string | undefined>;
+/**
+ * Session hint for UI gating: JWT readable, or HttpOnly presence cookie.
+ */
+export declare function useHasSsrSessionRef(): ComputedRef<boolean>;

package/dist/runtime/utils/authCookie.js

@@ -0,0 +1,47 @@
+import { computed } from "vue";
+import { useCookie, useRuntimeConfig } from "nuxt/app";
+import {
+  AUTH_JWT_COOKIE_MAX_AGE,
+  cookieValueToSsrToken,
+  isHttpOnlyAuth,
+  resolveAuthCookieName,
+  resolveAuthPresentCookieName
+} from "./authStorage.js";
+export { AUTH_JWT_COOKIE_MAX_AGE };
+function cookieOptions(httpOnly) {
+  return {
+    sameSite: "lax",
+    secure: process.env.NODE_ENV === "production",
+    maxAge: AUTH_JWT_COOKIE_MAX_AGE,
+    path: "/",
+    httpOnly
+  };
+}
+export function useAuthJwtCookie() {
+  const config = useRuntimeConfig();
+  const convexConfig = config.public.convex;
+  const name = resolveAuthCookieName(convexConfig?.auth);
+  if (!name) {
+    return void 0;
+  }
+  const httpOnly = isHttpOnlyAuth(convexConfig?.auth);
+  return useCookie(name, cookieOptions(httpOnly));
+}
+export function useAuthPresentCookie() {
+  const config = useRuntimeConfig();
+  const convexConfig = config.public.convex;
+  const name = resolveAuthPresentCookieName(convexConfig?.auth);
+  if (!name) {
+    return void 0;
+  }
+  return useCookie(name, cookieOptions(false));
+}
+export function useSsrTokenRef() {
+  const cookie = useAuthJwtCookie();
+  return computed(() => cookieValueToSsrToken(cookie?.value));
+}
+export function useHasSsrSessionRef() {
+  const token = useSsrTokenRef();
+  const present = useAuthPresentCookie();
+  return computed(() => !!token.value || present?.value === "1");
+}

package/dist/runtime/utils/authGate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Apply `{ authenticated: true }` on top of caller args.
+ *
+ * Caller `'skip'` always wins (unrelated gates). Auth skip is applied after,
+ * so payload keys can still be derived from the raw args (non-empty args must
+ * not remap to `{}` while internally skipped).
+ */
+export declare function resolveAuthGatedArgs<T>(raw: T | 'skip', options: {
+    authenticated?: boolean;
+    isAuthenticated: boolean;
+}): T | 'skip';

package/dist/runtime/utils/authGate.js

@@ -0,0 +1,9 @@
+export function resolveAuthGatedArgs(raw, options) {
+  if (raw === "skip") {
+    return "skip";
+  }
+  if (options.authenticated && !options.isAuthenticated) {
+    return "skip";
+  }
+  return raw;
+}

package/dist/runtime/utils/authMutex.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Single-flight mutex for token refresh (mirrors @convex-dev/auth/react).
+ * Prefers `navigator.locks` when available; falls back to an in-memory queue.
+ */
+type MutexState = {
+    currentlyRunning: Promise<void> | null;
+    waiting: Array<() => Promise<void>>;
+};
+declare global {
+    var __convexNuxtAuthMutexes: Record<string, MutexState> | undefined;
+}
+export declare function withRefreshMutex<T>(key: string, callback: () => Promise<T>): Promise<T>;
+/** Test helper — clear in-memory mutex state between tests. */
+export declare function resetAuthMutexesForTests(): void;
+export {};

package/dist/runtime/utils/authMutex.js

@@ -0,0 +1,47 @@
+export async function withRefreshMutex(key, callback) {
+  const lockManager = typeof navigator !== "undefined" ? navigator.locks : void 0;
+  if (lockManager !== void 0) {
+    return await lockManager.request(key, callback);
+  }
+  return await manualMutex(key, callback);
+}
+async function manualMutex(key, callback) {
+  return await new Promise((resolve, reject) => {
+    const wrapped = () => callback().then(resolve).catch(reject).then(() => void 0);
+    void enqueueCallbackForMutex(key, wrapped);
+  });
+}
+function getMutexValue(key) {
+  if (globalThis.__convexNuxtAuthMutexes === void 0) {
+    globalThis.__convexNuxtAuthMutexes = {};
+  }
+  let mutex = globalThis.__convexNuxtAuthMutexes[key];
+  if (mutex === void 0) {
+    mutex = { currentlyRunning: null, waiting: [] };
+    globalThis.__convexNuxtAuthMutexes[key] = mutex;
+  }
+  return mutex;
+}
+async function enqueueCallbackForMutex(key, callback) {
+  const mutex = getMutexValue(key);
+  if (mutex.currentlyRunning === null) {
+    globalThis.__convexNuxtAuthMutexes[key] = {
+      currentlyRunning: callback().finally(() => {
+        const next = getMutexValue(key).waiting.shift();
+        getMutexValue(key).currentlyRunning = null;
+        if (next !== void 0) {
+          void enqueueCallbackForMutex(key, next);
+        }
+      }),
+      waiting: []
+    };
+  } else {
+    globalThis.__convexNuxtAuthMutexes[key] = {
+      ...mutex,
+      waiting: [...mutex.waiting, callback]
+    };
+  }
+}
+export function resetAuthMutexesForTests() {
+  globalThis.__convexNuxtAuthMutexes = void 0;
+}

package/dist/runtime/utils/authState.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Derive Convex auth UI state from provider + backend confirmation.
+ * Mirrors convex/react ConvexAuthState.
+ */
+export interface ConvexAuthFlags {
+    /**
+     * Whether the auth provider is still resolving its initial session.
+     * When true, Convex confirmation is ignored and we stay loading.
+     */
+    authProviderLoading: boolean;
+    /**
+     * Whether the auth provider believes a user is signed in.
+     */
+    authProviderAuthenticated: boolean;
+    /**
+     * Backend confirmation from ConvexClient.setAuth onChange.
+     * `null` means we have not heard from Convex yet.
+     */
+    isConvexAuthenticated: boolean | null;
+    /**
+     * Whether the socket is paused while fetching a replacement token
+     * after a server rejection. Routine background rotation does not set this.
+     */
+    isRefreshing: boolean;
+}
+export interface ConvexAuthState {
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    isRefreshing: boolean;
+}
+export declare function resolveConvexAuthState(flags: ConvexAuthFlags): ConvexAuthState;

package/dist/runtime/utils/authState.js

@@ -0,0 +1,35 @@
+export function resolveConvexAuthState(flags) {
+  const {
+    authProviderLoading,
+    authProviderAuthenticated,
+    isConvexAuthenticated,
+    isRefreshing
+  } = flags;
+  if (authProviderLoading) {
+    return {
+      isLoading: true,
+      isAuthenticated: false,
+      isRefreshing: false
+    };
+  }
+  if (!authProviderAuthenticated) {
+    return {
+      isLoading: false,
+      isAuthenticated: false,
+      isRefreshing: false
+    };
+  }
+  if (isConvexAuthenticated === null) {
+    return {
+      isLoading: true,
+      isAuthenticated: false,
+      isRefreshing: false
+    };
+  }
+  const isAuthenticated = isConvexAuthenticated;
+  return {
+    isLoading: false,
+    isAuthenticated,
+    isRefreshing: isRefreshing && isAuthenticated
+  };
+}

package/dist/runtime/utils/authStorage.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Convex Auth client storage helpers (mirrors @convex-dev/auth/react).
+ */
+export declare const JWT_STORAGE_KEY = "__convexAuthJWT";
+export declare const REFRESH_TOKEN_STORAGE_KEY = "__convexAuthRefreshToken";
+export declare const VERIFIER_STORAGE_KEY = "__convexAuthOAuthVerifier";
+export declare const AUTH_JWT_COOKIE_MAX_AGE: number;
+export declare const DEFAULT_CONVEX_AUTH_COOKIE = "convex_jwt";
+/** Readable marker so the client knows an HttpOnly session exists. */
+export declare const DEFAULT_AUTH_PRESENT_COOKIE = "convex_auth_present";
+/** HttpOnly JWT cookie (Next.js Convex Auth naming). */
+export declare const HTTPONLY_JWT_COOKIE = "__convexAuthJWT";
+/** HttpOnly refresh cookie. */
+export declare const HTTPONLY_REFRESH_COOKIE = "__convexAuthRefreshToken";
+export type ConvexAuthConfig = {
+    provider?: string;
+    cookie?: string;
+    /**
+     * Store JWT + refresh in HttpOnly cookies via Nitro (Next.js parity).
+     * When true, JS cannot read tokens from `document.cookie`; `fetchToken`
+     * uses same-origin POST `/api/convex/auth/session` with `{ getToken: true }`.
+     * Prefer `true` in production. Does not make sessions XSS-proof.
+     */
+    httpOnly?: boolean;
+    /** Readable presence cookie when `httpOnly` is set (UI only). */
+    presentCookie?: string;
+};
+export declare function storageNamespace(url: string): string;
+export declare function storageKey(base: string, url: string): string;
+/**
+ * Flatten FormData (or pass through a plain record) the same way the React
+ * Convex Auth client does before calling `auth:signIn`.
+ */
+export declare function flattenSignInParams(params?: FormData | Record<string, string>): Record<string, string>;
+/**
+ * Resolve the auth cookie name for runtime config / SSR JWT reads.
+ * When `provider === 'convex-auth'` and cookie is omitted, default to `convex_jwt`
+ * (or the HttpOnly JWT name when `httpOnly` is enabled).
+ */
+export declare function resolveAuthCookieName(auth?: ConvexAuthConfig): string | undefined;
+export declare function resolveAuthPresentCookieName(auth?: ConvexAuthConfig): string | undefined;
+export declare function resolveAuthRefreshCookieName(auth?: ConvexAuthConfig): string | undefined;
+export declare function isHttpOnlyAuth(auth?: ConvexAuthConfig): boolean;
+/** Empty / missing cookies are not a session. */
+export declare function cookieValueToSsrToken(value: string | null | undefined): string | undefined;
+export declare function readLocal(key: string): string | null;
+export declare function writeLocal(key: string, value: string | null): void;
+/**
+ * Whether the current URL's `?code=` should be treated as an OAuth callback.
+ * Only true when we previously stored a verifier (we started the flow).
+ */
+export declare function shouldConsumeOAuthCode(options: {
+    code: string | null;
+    verifier: string | null;
+}): boolean;

package/dist/runtime/utils/authStorage.js

@@ -0,0 +1,85 @@
+export const JWT_STORAGE_KEY = "__convexAuthJWT";
+export const REFRESH_TOKEN_STORAGE_KEY = "__convexAuthRefreshToken";
+export const VERIFIER_STORAGE_KEY = "__convexAuthOAuthVerifier";
+export const AUTH_JWT_COOKIE_MAX_AGE = 60 * 60 * 24 * 30;
+export const DEFAULT_CONVEX_AUTH_COOKIE = "convex_jwt";
+export const DEFAULT_AUTH_PRESENT_COOKIE = "convex_auth_present";
+export const HTTPONLY_JWT_COOKIE = "__convexAuthJWT";
+export const HTTPONLY_REFRESH_COOKIE = "__convexAuthRefreshToken";
+export function storageNamespace(url) {
+  return url.replace(/[^a-zA-Z0-9]/g, "");
+}
+export function storageKey(base, url) {
+  return `${base}_${storageNamespace(url)}`;
+}
+export function flattenSignInParams(params) {
+  if (params === void 0) {
+    return {};
+  }
+  if (typeof FormData !== "undefined" && params instanceof FormData) {
+    const out = {};
+    params.forEach((value, key) => {
+      if (typeof value === "string") {
+        out[key] = value;
+      }
+    });
+    return out;
+  }
+  return { ...params };
+}
+export function resolveAuthCookieName(auth) {
+  if (auth?.httpOnly) {
+    return auth.cookie ?? HTTPONLY_JWT_COOKIE;
+  }
+  if (auth?.cookie) {
+    return auth.cookie;
+  }
+  if (auth?.provider === "convex-auth") {
+    return DEFAULT_CONVEX_AUTH_COOKIE;
+  }
+  return void 0;
+}
+export function resolveAuthPresentCookieName(auth) {
+  if (!auth?.httpOnly) {
+    return void 0;
+  }
+  return auth.presentCookie ?? DEFAULT_AUTH_PRESENT_COOKIE;
+}
+export function resolveAuthRefreshCookieName(auth) {
+  if (!auth?.httpOnly) {
+    return void 0;
+  }
+  return HTTPONLY_REFRESH_COOKIE;
+}
+export function isHttpOnlyAuth(auth) {
+  return auth?.httpOnly === true;
+}
+export function cookieValueToSsrToken(value) {
+  return value || void 0;
+}
+export function readLocal(key) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+export function writeLocal(key, value) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    if (value === null) {
+      window.localStorage.removeItem(key);
+    } else {
+      window.localStorage.setItem(key, value);
+    }
+  } catch {
+  }
+}
+export function shouldConsumeOAuthCode(options) {
+  return options.code !== null && options.verifier !== null;
+}