@djangocfg/api 2.1.582 → 2.1.584

package/dist/auth.cjs

@@ -129,8 +129,7 @@ var init_OTPVerifyResponse = __esm({
       refresh: import_zod5.z.string().nullable().optional(),
       access: import_zod5.z.string().nullable().optional(),
       user: UserSchema.nullable().optional(),
-      should_prompt_2fa: import_zod5.z.boolean().optional(),
-      persistent_session: import_zod5.z.boolean().optional()
+      should_prompt_2fa: import_zod5.z.boolean().optional()
     });
   }
 });
@@ -152,8 +151,7 @@ var init_PasswordLoginResponse = __esm({
       refresh: import_zod6.z.string().nullable().optional(),
       access: import_zod6.z.string().nullable().optional(),
       user: UserSchema.nullable().optional(),
-      should_prompt_2fa: import_zod6.z.boolean().optional(),
-      persistent_session: import_zod6.z.boolean().optional()
+      should_prompt_2fa: import_zod6.z.boolean().optional()
     });
   }
 });
@@ -297,77 +295,263 @@ var APIError = class extends Error {
   }
 };
 
-// src/_api/generated/helpers/auth.ts
-var ACCESS_KEY = "cfg.access_token";
-var REFRESH_KEY = "cfg.refresh_token";
-var API_KEY_KEY = "cfg.api_key";
-var isBrowser = typeof window !== "undefined";
-var localStorageBackend = {
-  get(key) {
-    if (!isBrowser) return null;
-    try {
-      return window.localStorage.getItem(key);
-    } catch {
-      return null;
+// src/_api/generated/helpers/keys.ts
+var k = /* @__PURE__ */ __name((key, store, personal) => ({ key, store, personal }), "k");
+var f = /* @__PURE__ */ __name((prefix, store, personal) => ({ prefix, store, personal }), "f");
+var CFG_KEYS = {
+  accessToken: k("cfg.auth.access_token", "local", true),
+  refreshToken: k("cfg.auth.refresh_token", "local", true),
+  apiKey: k("cfg.auth.api_key", "local", true),
+  email: k("cfg.auth.email", "local", false),
+  emailTs: k("cfg.auth.email_ts", "local", false),
+  redirectUrl: k("cfg.auth.redirect_url", "session", true),
+  redirectUrlTs: k("cfg.auth.redirect_url_ts", "session", true),
+  oauthState: k("cfg.auth.oauth_state", "session", true),
+  oauthProvider: k("cfg.auth.oauth_provider", "session", true),
+  profileCache: k("cfg.profile.cache", "local", true),
+  monitorSessionId: k("cfg.monitor.session_id", "local", false),
+  monitorSessionCookie: k("cfg.monitor.session_id", "cookie", false),
+  monitorDebug: k("cfg.monitor.debug", "local", false),
+  uiTabId: k("cfg.ui.tab_id", "session", false),
+  uiRouterSerial: k("cfg.ui.router_serial", "session", false),
+  uiState: k("cfg.ui.state", "local", false),
+  chatSpeechLanguage: k("cfg.chat.speech_language", "local", false),
+  chatRecentTools: k("cfg.chat.recent_tools", "local", false),
+  formsSpeechDebug: k("cfg.forms.speech_debug", "local", false),
+  formsSpeechPrefs: k("cfg.forms.speech_prefs", "local", false),
+  agentPlaygroundApiKeyId: k("cfg.agent.playground_api_key_id", "session", true),
+  agentPlaygroundBearer: k("cfg.agent.playground_bearer", "session", true),
+  agentEndpointDoc: k("cfg.agent.endpoint_doc", "session", false)
+};
+var CFG_FAMILIES = {
+  chatDraft: f("cfg.chat.draft.", "session", true),
+  dataTree: f("cfg.data.tree.", "local", false),
+  agentEndpointDraft: f("cfg.agent.endpoint_draft.", "local", false)
+};
+var OWNER_RE = /^[a-z][a-z0-9_]*$/;
+function normalizeSegment(raw) {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+}
+__name(normalizeSegment, "normalizeSegment");
+var hasWindow = /* @__PURE__ */ __name(() => typeof window !== "undefined", "hasWindow");
+function nativeStorage(store) {
+  if (!hasWindow()) return null;
+  try {
+    return store === "session" ? window.sessionStorage : window.localStorage;
+  } catch {
+    return null;
+  }
+}
+__name(nativeStorage, "nativeStorage");
+function cookieNames() {
+  if (!hasWindow()) return [];
+  try {
+    return document.cookie.split("; ").map((part) => decodeURIComponent(part.split("=")[0] ?? "")).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+__name(cookieNames, "cookieNames");
+function createStorage(owner, options = {}) {
+  if (!OWNER_RE.test(owner)) {
+    throw new TypeError(`createStorage: owner "${owner}" must match ${OWNER_RE}`);
+  }
+  const prefix = `${owner}.`;
+  const pattern = owner === "cfg" ? /^cfg(\.[a-z0-9_]+)+$/ : new RegExp(`^(cfg|${owner})(\\.[a-z0-9_]+)+$`);
+  const cookieMaxAge = options.cookieMaxAgeSeconds ?? 60 * 60 * 24 * 30;
+  const specs = Object.values(options.keys ?? {});
+  const families = Object.values(options.families ?? {});
+  const specByKey = /* @__PURE__ */ new Map();
+  for (const spec of specs) specByKey.set(spec.key, [...specByKey.get(spec.key) ?? [], spec]);
+  const memory = {
+    local: /* @__PURE__ */ new Map(),
+    session: /* @__PURE__ */ new Map(),
+    cookie: /* @__PURE__ */ new Map()
+  };
+  const isValid = /* @__PURE__ */ __name((key) => pattern.test(key), "isValid");
+  const assertValid = /* @__PURE__ */ __name((key) => {
+    if (!isValid(key)) throw new TypeError(`storage key "${key}" must match ${pattern}`);
+  }, "assertValid");
+  const assertOwned = /* @__PURE__ */ __name((key) => {
+    assertValid(key);
+    if (!key.startsWith(prefix)) throw new TypeError(`storage key "${key}" is not owned by "${owner}"`);
+  }, "assertOwned");
+  function rawGet(store, key) {
+    if (!hasWindow()) return null;
+    if (store === "cookie") {
+      try {
+        const escaped = encodeURIComponent(key).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const match = document.cookie.match(new RegExp(`(?:^|;\\s*)${escaped}=([^;]*)`));
+        if (match?.[1] !== void 0) return decodeURIComponent(match[1]);
+      } catch {
+      }
+      return memory.cookie.get(key) ?? null;
     }
-  },
-  set(key, value) {
-    if (!isBrowser) return;
     try {
-      if (value === null) window.localStorage.removeItem(key);
-      else window.localStorage.setItem(key, value);
+      const value = nativeStorage(store)?.getItem(key) ?? null;
+      if (value !== null) return value;
     } catch {
     }
+    return memory[store].get(key) ?? null;
   }
-};
-var sessionStorageBackend = {
-  get(key) {
-    if (!isBrowser) return null;
+  __name(rawGet, "rawGet");
+  function rawSet(store, key, value) {
+    if (!hasWindow()) return false;
     try {
-      return window.sessionStorage.getItem(key);
+      if (store === "cookie") {
+        const secure = window.location.protocol === "https:" ? "; Secure" : "";
+        document.cookie = `${encodeURIComponent(key)}=${encodeURIComponent(value)}; Path=/; Max-Age=${cookieMaxAge}; SameSite=Lax${secure}`;
+        if (rawGet("cookie", key) === value && !memory.cookie.has(key)) return true;
+        memory.cookie.set(key, value);
+        return false;
+      }
+      const native = nativeStorage(store);
+      if (!native) throw new Error("storage unavailable");
+      native.setItem(key, value);
+      memory[store].delete(key);
+      return true;
     } catch {
-      return null;
+      memory[store].set(key, value);
+      return false;
     }
-  },
-  set(key, value) {
-    if (!isBrowser) return;
+  }
+  __name(rawSet, "rawSet");
+  function rawRemove(store, key) {
+    memory[store].delete(key);
+    if (!hasWindow()) return;
     try {
-      if (value === null) window.sessionStorage.removeItem(key);
-      else window.sessionStorage.setItem(key, value);
+      if (store === "cookie") {
+        const secure = window.location.protocol === "https:" ? "; Secure" : "";
+        document.cookie = `${encodeURIComponent(key)}=; Path=/; Max-Age=0; SameSite=Lax${secure}`;
+      } else {
+        nativeStorage(store)?.removeItem(key);
+      }
     } catch {
     }
   }
-};
-var COOKIE_MAX_AGE = 60 * 60 * 24 * 30;
-var cookieBackend = {
-  get(key) {
-    if (!isBrowser) return null;
+  __name(rawRemove, "rawRemove");
+  function resolveStore(key, store) {
+    return store ?? specByKey.get(key)?.[0]?.store ?? "local";
+  }
+  __name(resolveStore, "resolveStore");
+  function listKeys(store, startsWith) {
+    const out = [];
     try {
-      const re = new RegExp(`(?:^|;\\s*)${encodeURIComponent(key)}=([^;]*)`);
-      const m = document.cookie.match(re);
-      const value = m?.[1];
-      return value === void 0 ? null : decodeURIComponent(value);
+      const native = nativeStorage(store);
+      if (native) {
+        for (let i = 0; i < native.length; i += 1) {
+          const name = native.key(i);
+          if (name?.startsWith(startsWith)) out.push(name);
+        }
+      }
     } catch {
-      return null;
     }
-  },
-  set(key, value) {
-    if (!isBrowser) return;
-    try {
-      const k = encodeURIComponent(key);
-      const secure = window.location.protocol === "https:" ? "; Secure" : "";
-      if (value === null) {
-        document.cookie = `${k}=; Path=/; Max-Age=0; SameSite=Lax${secure}`;
-      } else {
-        const v = encodeURIComponent(value);
-        document.cookie = `${k}=${v}; Path=/; Max-Age=${COOKIE_MAX_AGE}; SameSite=Lax${secure}`;
+    for (const name of memory[store].keys()) if (name.startsWith(startsWith) && !out.includes(name)) out.push(name);
+    return out;
+  }
+  __name(listKeys, "listKeys");
+  const familyKey = /* @__PURE__ */ __name((family, id) => {
+    const part = normalizeSegment(id);
+    if (!part) throw new TypeError("storage family id is empty after normalisation");
+    return family.prefix + part;
+  }, "familyKey");
+  const api = {
+    owner,
+    key(...parts) {
+      const segments = parts.map(normalizeSegment);
+      if (segments.length === 0 || segments.some((segment) => !segment)) {
+        throw new TypeError(`storage key parts must be non-empty: ${JSON.stringify(parts)}`);
       }
-    } catch {
+      return `${prefix}${segments.join(".")}`;
+    },
+    familyKey,
+    isValid,
+    read(key, store) {
+      assertValid(key);
+      const target = resolveStore(key, store);
+      return rawGet(target, key);
+    },
+    write(key, value, store) {
+      assertOwned(key);
+      const target = resolveStore(key, store);
+      return rawSet(target, key, value);
+    },
+    remove(key, store) {
+      assertOwned(key);
+      const target = resolveStore(key, store);
+      rawRemove(target, key);
+    },
+    readJSON(key, store) {
+      const raw = api.read(key, store);
+      if (raw === null) return null;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    },
+    writeJSON(key, value, store) {
+      return api.write(key, JSON.stringify(value), store);
+    },
+    keys(store = "local") {
+      return listKeys(store, prefix);
+    },
+    clearAll({ all = false } = {}) {
+      for (const spec of specs) {
+        if (!all && !spec.personal) continue;
+        rawRemove(spec.store, spec.key);
+      }
+      for (const family of families) {
+        if (!all && !family.personal) continue;
+        for (const name of listKeys(family.store, family.prefix)) rawRemove(family.store, name);
+      }
+      if (all) {
+        for (const store of ["local", "session"]) {
+          for (const name of listKeys(store, prefix)) rawRemove(store, name);
+        }
+        for (const name of cookieNames()) if (name.startsWith(prefix)) rawRemove("cookie", name);
+      }
+    },
+    onChange(key, listener, store = "local") {
+      assertValid(key);
+      if (!hasWindow()) return () => {
+      };
+      const handler = /* @__PURE__ */ __name((event) => {
+        if (event.storageArea !== nativeStorage(store)) return;
+        if (event.key === null || event.key === key) listener(event.key === null ? null : event.newValue);
+      }, "handler");
+      window.addEventListener("storage", handler);
+      return () => window.removeEventListener("storage", handler);
     }
-  }
+  };
+  return api;
+}
+__name(createStorage, "createStorage");
+var cfgStorage = createStorage("cfg", {
+  keys: CFG_KEYS,
+  families: CFG_FAMILIES
+});
+
+// src/_api/generated/helpers/auth.ts
+var ACCESS_KEY = "cfg.auth.access_token";
+var REFRESH_KEY = "cfg.auth.refresh_token";
+var API_KEY_KEY = "cfg.auth.api_key";
+var storage = true ? cfgStorage : createStorage2("cfg");
+var isBrowser = typeof window !== "undefined";
+var STORE_OF = {
+  localStorage: "local",
+  sessionStorage: "session",
+  cookie: "cookie"
 };
 function backendFor(mode) {
-  return mode === "cookie" ? cookieBackend : mode === "sessionStorage" ? sessionStorageBackend : localStorageBackend;
+  const store = STORE_OF[mode];
+  return {
+    get: /* @__PURE__ */ __name((key) => storage.read(key, store), "get"),
+    set(key, value) {
+      if (value === null) storage.remove(key, store);
+      else storage.write(key, value, store);
+    }
+  };
 }
 __name(backendFor, "backendFor");
 var _storageMode = "localStorage";
@@ -556,10 +740,12 @@ var auth = {
     notifySessionChanged();
   },
   clearTokens() {
-    for (const backend of [localStorageBackend, sessionStorageBackend, cookieBackend]) {
+    for (const mode of ["localStorage", "sessionStorage", "cookie"]) {
+      const backend = backendFor(mode);
       backend.set(ACCESS_KEY, null);
       backend.set(REFRESH_KEY, null);
     }
+    storage.clearAll();
     notifySessionChanged();
   },
   /** Session-aware: token PRESENT and not past its `exp` (or a live refresh
@@ -751,7 +937,7 @@ function dpopEnabled() {
   }
 }
 __name(dpopEnabled, "dpopEnabled");
-var _DPOP_DB = "cfg-auth";
+var _DPOP_DB = "cfg.auth.dpop";
 var _DPOP_STORE = "keys";
 var _DPOP_KEY_ID = "dpop-ec-p256";
 function _idbOpen() {
@@ -1214,7 +1400,6 @@ var useAuthFormState = /* @__PURE__ */ __name((initialIdentifier = "") => {
   const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
   const [acceptedTerms, setAcceptedTerms] = (0, import_react4.useState)(true);
   const [marketingConsent, setMarketingConsent] = (0, import_react4.useState)(null);
-  const [rememberMe, setRememberMe] = (0, import_react4.useState)(true);
   const [step, setStep] = (0, import_react4.useState)("identifier");
   const [error, setError] = (0, import_react4.useState)("");
   const [webmail, setWebmail] = (0, import_react4.useState)(null);
@@ -1229,7 +1414,6 @@ var useAuthFormState = /* @__PURE__ */ __name((initialIdentifier = "") => {
     isLoading,
     acceptedTerms,
     marketingConsent,
-    rememberMe,
     step,
     error,
     rateLimitSeconds: rateLimit.seconds,
@@ -1244,7 +1428,6 @@ var useAuthFormState = /* @__PURE__ */ __name((initialIdentifier = "") => {
     setPassword,
     setAcceptedTerms,
     setMarketingConsent,
-    setRememberMe,
     setError,
     clearError,
     setStep,
@@ -1379,7 +1562,6 @@ var useAuthForm = /* @__PURE__ */ __name((options) => {
     password,
     acceptedTerms,
     marketingConsent,
-    rememberMe,
     setIdentifier,
     setOtp,
     setStep,
@@ -1476,7 +1658,7 @@ var useAuthForm = /* @__PURE__ */ __name((options) => {
     setIsLoading(true);
     clearError();
     try {
-      const result = await verifyOTP(submitIdentifier, submitOtp, sourceUrl, redirectUrl, true, rememberMe);
+      const result = await verifyOTP(submitIdentifier, submitOtp, sourceUrl, redirectUrl, true);
       if (result.requires_2fa && result.session_id) {
         authLogger.info("2FA required after OTP verification");
         beginTwoFactorChallenge({ sessionId: result.session_id });
@@ -1502,7 +1684,7 @@ var useAuthForm = /* @__PURE__ */ __name((options) => {
     } finally {
       setIsLoading(false);
     }
-  }, [verifyOTP, saveIdentifierToStorage, setError, setIsLoading, clearError, onOTPSuccess, onError, sourceUrl, redirectUrl, rememberMe, setStep]);
+  }, [verifyOTP, saveIdentifierToStorage, setError, setIsLoading, clearError, onOTPSuccess, onError, sourceUrl, redirectUrl, setStep]);
   const handleOTPSubmit = (0, import_react8.useCallback)(async (e) => {
     e.preventDefault();
     await submitOTP(identifier, otp);
@@ -1525,8 +1707,7 @@ var useAuthForm = /* @__PURE__ */ __name((options) => {
     try {
       const result = await login(submitIdentifier, submitPassword_, {
         redirectUrl,
-        skipRedirect: true,
-        rememberMe
+        skipRedirect: true
       });
       if (result.requires_2fa && result.session_id) {
         authLogger.info("2FA required after password login");
@@ -1568,7 +1749,6 @@ var useAuthForm = /* @__PURE__ */ __name((options) => {
     onOTPSuccess,
     onError,
     redirectUrl,
-    rememberMe,
     setStep
   ]);
   const handlePasswordSubmit = (0, import_react8.useCallback)(async (e) => {
@@ -3086,8 +3266,10 @@ var logAuthFailure = /* @__PURE__ */ __name((log, message, error) => {
 }, "logAuthFailure");
 
 // src/auth/hooks/useGithubAuth.ts
+var OAUTH_STATE_KEY = CFG_KEYS.oauthState.key;
+var OAUTH_PROVIDER_KEY = CFG_KEYS.oauthProvider.key;
 var useGithubAuth = /* @__PURE__ */ __name((options = {}) => {
-  const { sourceUrl, rememberMe = false, onSuccess, onError, onRequires2FA, redirectUrl, skipRedirect = false } = options;
+  const { sourceUrl, onSuccess, onError, onRequires2FA, redirectUrl, skipRedirect = false } = options;
   const router = useCfgRouter();
   const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
   const [error, setError] = (0, import_react9.useState)(null);
@@ -3113,9 +3295,8 @@ var useGithubAuth = /* @__PURE__ */ __name((options = {}) => {
       }
       authLogger.info("Redirecting to GitHub...", response.authorization_url);
       if (typeof window !== "undefined") {
-        sessionStorage.setItem("oauth_state", response.state);
-        sessionStorage.setItem("oauth_provider", "github");
-        sessionStorage.setItem("cfg.oauth.remember_me", String(rememberMe));
+        sessionStorage.setItem(OAUTH_STATE_KEY, response.state);
+        sessionStorage.setItem(OAUTH_PROVIDER_KEY, "github");
       }
       window.location.href = response.authorization_url;
     } catch (err) {
@@ -3130,25 +3311,22 @@ var useGithubAuth = /* @__PURE__ */ __name((options = {}) => {
     } finally {
       setIsLoading(false);
     }
-  }, [sourceUrl, rememberMe, onError]);
+  }, [sourceUrl, onError]);
   const handleGithubCallback = (0, import_react9.useCallback)(async (code, state) => {
     setIsLoading(true);
     setError(null);
     try {
       authLogger.info("Processing GitHub OAuth callback...");
-      let rememberMeForSession = false;
       if (typeof window !== "undefined") {
-        const storedState = sessionStorage.getItem("oauth_state");
+        const storedState = sessionStorage.getItem(OAUTH_STATE_KEY);
         if (storedState && storedState !== state) {
           throw new Error("Invalid OAuth state - possible CSRF attack");
         }
-        rememberMeForSession = sessionStorage.getItem("cfg.oauth.remember_me") === "true";
-        sessionStorage.removeItem("oauth_state");
-        sessionStorage.removeItem("oauth_provider");
-        sessionStorage.removeItem("cfg.oauth.remember_me");
+        sessionStorage.removeItem(OAUTH_STATE_KEY);
+        sessionStorage.removeItem(OAUTH_PROVIDER_KEY);
       }
       const result = await CfgAccountsOauth.cfgAccountsOauthGithubCallbackCreate({
-        body: { code, state, remember_me: rememberMeForSession },
+        body: { code, state },
         throwOnError: true
       });
       const response = result.data;
@@ -3257,7 +3435,7 @@ function useSessionStorage(key, initialValue) {
             const key2 = keys[i];
             if (key2) {
               sessionStorage.removeItem(key2);
-              sessionStorage.removeItem(`${key2}_timestamp`);
+              sessionStorage.removeItem(`${key2}_ts`);
             }
           } catch {
           }
@@ -3287,7 +3465,7 @@ function useSessionStorage(key, initialValue) {
         authLogger.warn(`Data size too large for key "${key}", removing key`);
         try {
           window.sessionStorage.removeItem(key);
-          window.sessionStorage.removeItem(`${key}_timestamp`);
+          window.sessionStorage.removeItem(`${key}_ts`);
         } catch {
         }
         setStoredValue(valueToStore);
@@ -3297,20 +3475,20 @@ function useSessionStorage(key, initialValue) {
       if (typeof window !== "undefined") {
         try {
           window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
-          window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+          window.sessionStorage.setItem(`${key}_ts`, Date.now().toString());
         } catch (storageError) {
           if (isQuotaExceededError(storageError)) {
             authLogger.warn("sessionStorage quota exceeded, clearing old data...");
             clearOldData();
             try {
               window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
-              window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+              window.sessionStorage.setItem(`${key}_ts`, Date.now().toString());
             } catch (retryError) {
               authLogger.error(`Failed to set sessionStorage key "${key}" after clearing old data:`, retryError);
               try {
                 forceClearAll();
                 window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
-                window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+                window.sessionStorage.setItem(`${key}_ts`, Date.now().toString());
               } catch (finalError) {
                 authLogger.error(`Failed to set sessionStorage key "${key}" after force clearing:`, finalError);
                 setStoredValue(valueToStore);
@@ -3333,14 +3511,14 @@ function useSessionStorage(key, initialValue) {
       if (typeof window !== "undefined") {
         try {
           window.sessionStorage.removeItem(key);
-          window.sessionStorage.removeItem(`${key}_timestamp`);
+          window.sessionStorage.removeItem(`${key}_ts`);
         } catch (removeError) {
           if (isQuotaExceededError(removeError)) {
             authLogger.warn("sessionStorage quota exceeded during removal, clearing old data...");
             clearOldData();
             try {
               window.sessionStorage.removeItem(key);
-              window.sessionStorage.removeItem(`${key}_timestamp`);
+              window.sessionStorage.removeItem(`${key}_ts`);
             } catch (retryError) {
               authLogger.error(`Failed to remove sessionStorage key "${key}" after clearing:`, retryError);
               forceClearAll();
@@ -3359,7 +3537,7 @@ function useSessionStorage(key, initialValue) {
 __name(useSessionStorage, "useSessionStorage");
 
 // src/auth/hooks/useAuthRedirect.ts
-var AUTH_REDIRECT_KEY = "auth_redirect_url";
+var AUTH_REDIRECT_KEY = CFG_KEYS.redirectUrl.key;
 var getRedirectFromStorage = /* @__PURE__ */ __name(() => {
   if (typeof window === "undefined") return "";
   try {
@@ -3373,7 +3551,7 @@ var clearRedirectFromStorage = /* @__PURE__ */ __name(() => {
   if (typeof window === "undefined") return;
   try {
     window.sessionStorage.removeItem(AUTH_REDIRECT_KEY);
-    window.sessionStorage.removeItem(`${AUTH_REDIRECT_KEY}_timestamp`);
+    window.sessionStorage.removeItem(`${AUTH_REDIRECT_KEY}_ts`);
   } catch {
   }
 }, "clearRedirectFromStorage");
@@ -3789,7 +3967,7 @@ function useLocalStorage(key, initialValue) {
             const key2 = keys[i];
             if (key2) {
               localStorage.removeItem(key2);
-              localStorage.removeItem(`${key2}_timestamp`);
+              localStorage.removeItem(`${key2}_ts`);
             }
           } catch {
           }
@@ -3819,7 +3997,7 @@ function useLocalStorage(key, initialValue) {
         authLogger.warn(`Data size too large for key "${key}", removing key`);
         try {
           window.localStorage.removeItem(key);
-          window.localStorage.removeItem(`${key}_timestamp`);
+          window.localStorage.removeItem(`${key}_ts`);
         } catch {
         }
         setStoredValue(valueToStore);
@@ -3833,7 +4011,7 @@ function useLocalStorage(key, initialValue) {
           } else {
             window.localStorage.setItem(key, JSON.stringify(valueToStore));
           }
-          window.localStorage.setItem(`${key}_timestamp`, Date.now().toString());
+          window.localStorage.setItem(`${key}_ts`, Date.now().toString());
         } catch (storageError) {
           if (isQuotaExceededError(storageError)) {
             authLogger.warn("localStorage quota exceeded, clearing old data...");
@@ -3844,7 +4022,7 @@ function useLocalStorage(key, initialValue) {
               } else {
                 window.localStorage.setItem(key, JSON.stringify(valueToStore));
               }
-              window.localStorage.setItem(`${key}_timestamp`, Date.now().toString());
+              window.localStorage.setItem(`${key}_ts`, Date.now().toString());
             } catch (retryError) {
               authLogger.error(`Failed to set localStorage key "${key}" after clearing old data:`, retryError);
               try {
@@ -3854,7 +4032,7 @@ function useLocalStorage(key, initialValue) {
                 } else {
                   window.localStorage.setItem(key, JSON.stringify(valueToStore));
                 }
-                window.localStorage.setItem(`${key}_timestamp`, Date.now().toString());
+                window.localStorage.setItem(`${key}_ts`, Date.now().toString());
               } catch (finalError) {
                 authLogger.error(`Failed to set localStorage key "${key}" after force clearing:`, finalError);
                 setStoredValue(valueToStore);
@@ -3877,14 +4055,14 @@ function useLocalStorage(key, initialValue) {
       if (typeof window !== "undefined") {
         try {
           window.localStorage.removeItem(key);
-          window.localStorage.removeItem(`${key}_timestamp`);
+          window.localStorage.removeItem(`${key}_ts`);
         } catch (removeError) {
           if (isQuotaExceededError(removeError)) {
             authLogger.warn("localStorage quota exceeded during removal, clearing old data...");
             clearOldData();
             try {
               window.localStorage.removeItem(key);
-              window.localStorage.removeItem(`${key}_timestamp`);
+              window.localStorage.removeItem(`${key}_ts`);
             } catch (retryError) {
               authLogger.error(`Failed to remove localStorage key "${key}" after clearing:`, retryError);
               forceClearAll();
@@ -3952,7 +4130,7 @@ function useBase64() {
 __name(useBase64, "useBase64");
 
 // src/auth/hooks/useProfileCache.ts
-var CACHE_KEY = "user_profile_cache";
+var CACHE_KEY = CFG_KEYS.profileCache.key;
 var CACHE_VERSION = 1;
 var DEFAULT_TTL = 144e5;
 function getCachedProfile() {
@@ -4597,7 +4775,7 @@ var resolveAuthRoutes = /* @__PURE__ */ __name((routes) => ({
   defaultCallback: routes?.defaultCallback || defaultRoutes.defaultCallback,
   defaultAuthCallback: routes?.defaultAuthCallback || routes?.auth || defaultRoutes.defaultAuthCallback
 }), "resolveAuthRoutes");
-var EMAIL_STORAGE_KEY = "auth_email";
+var EMAIL_STORAGE_KEY = CFG_KEYS.email.key;
 var AuthContext = (0, import_react17.createContext)(void 0);
 var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
   const accounts = useAccountsContext();
@@ -4744,14 +4922,13 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
     []
   );
   const verifyOTP = (0, import_react17.useCallback)(
-    async (identifier, otpCode, sourceUrl, redirectUrl, skipRedirect, rememberMe = false) => {
+    async (identifier, otpCode, sourceUrl, redirectUrl, skipRedirect) => {
       try {
         pendingManualNavRef.current = Boolean(skipRedirect);
         const result = await accountsRef.current.verifyOTP({
           identifier,
           otp: otpCode,
-          source_url: sourceUrl,
-          remember_me: rememberMe
+          source_url: sourceUrl
         });
         if (result.requires_2fa && result.session_id) {
           authLogger.info("2FA required, session:", result.session_id);
@@ -4806,13 +4983,12 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
   );
   const login = (0, import_react17.useCallback)(
     async (email, password, options) => {
-      const { redirectUrl, skipRedirect, rememberMe = false } = options || {};
+      const { redirectUrl, skipRedirect } = options || {};
       try {
         pendingManualNavRef.current = Boolean(skipRedirect);
         const result = await accountsRef.current.loginWithPassword({
           email,
-          password,
-          remember_me: rememberMe
+          password
         });
         if (result.requires_2fa && result.session_id) {
           authLogger.info("2FA required, session:", result.session_id);