@scalemule/nextjs 0.0.36 → 0.0.37

package/dist/index.js

@@ -290,78 +290,6 @@ var init_upload_compression_VOUJRAIM = __esm({
 
 // node_modules/@scalemule/sdk/dist/index.mjs
 init_chunk_3FTGBRLU();
-
-// node_modules/@scalemule/ui/dist/phone/index.mjs
-var PHONE_COUNTRIES = [
-  { code: "US", name: "United States", dialCode: "+1" },
-  { code: "CA", name: "Canada", dialCode: "+1" },
-  { code: "GB", name: "United Kingdom", dialCode: "+44" },
-  { code: "AU", name: "Australia", dialCode: "+61" },
-  { code: "DE", name: "Germany", dialCode: "+49" },
-  { code: "FR", name: "France", dialCode: "+33" },
-  { code: "IT", name: "Italy", dialCode: "+39" },
-  { code: "ES", name: "Spain", dialCode: "+34" },
-  { code: "NL", name: "Netherlands", dialCode: "+31" },
-  { code: "BE", name: "Belgium", dialCode: "+32" },
-  { code: "CH", name: "Switzerland", dialCode: "+41" },
-  { code: "AT", name: "Austria", dialCode: "+43" },
-  { code: "SE", name: "Sweden", dialCode: "+46" },
-  { code: "NO", name: "Norway", dialCode: "+47" },
-  { code: "DK", name: "Denmark", dialCode: "+45" },
-  { code: "FI", name: "Finland", dialCode: "+358" },
-  { code: "IE", name: "Ireland", dialCode: "+353" },
-  { code: "PT", name: "Portugal", dialCode: "+351" },
-  { code: "PL", name: "Poland", dialCode: "+48" },
-  { code: "CZ", name: "Czech Republic", dialCode: "+420" },
-  { code: "GR", name: "Greece", dialCode: "+30" },
-  { code: "RU", name: "Russia", dialCode: "+7" },
-  { code: "JP", name: "Japan", dialCode: "+81" },
-  { code: "KR", name: "South Korea", dialCode: "+82" },
-  { code: "CN", name: "China", dialCode: "+86" },
-  { code: "HK", name: "Hong Kong", dialCode: "+852" },
-  { code: "TW", name: "Taiwan", dialCode: "+886" },
-  { code: "SG", name: "Singapore", dialCode: "+65" },
-  { code: "MY", name: "Malaysia", dialCode: "+60" },
-  { code: "TH", name: "Thailand", dialCode: "+66" },
-  { code: "VN", name: "Vietnam", dialCode: "+84" },
-  { code: "PH", name: "Philippines", dialCode: "+63" },
-  { code: "ID", name: "Indonesia", dialCode: "+62" },
-  { code: "IN", name: "India", dialCode: "+91" },
-  { code: "PK", name: "Pakistan", dialCode: "+92" },
-  { code: "BD", name: "Bangladesh", dialCode: "+880" },
-  { code: "AE", name: "UAE", dialCode: "+971" },
-  { code: "SA", name: "Saudi Arabia", dialCode: "+966" },
-  { code: "IL", name: "Israel", dialCode: "+972" },
-  { code: "TR", name: "Turkey", dialCode: "+90" },
-  { code: "EG", name: "Egypt", dialCode: "+20" },
-  { code: "ZA", name: "South Africa", dialCode: "+27" },
-  { code: "NG", name: "Nigeria", dialCode: "+234" },
-  { code: "KE", name: "Kenya", dialCode: "+254" },
-  { code: "BR", name: "Brazil", dialCode: "+55" },
-  { code: "MX", name: "Mexico", dialCode: "+52" },
-  { code: "AR", name: "Argentina", dialCode: "+54" },
-  { code: "CL", name: "Chile", dialCode: "+56" },
-  { code: "CO", name: "Colombia", dialCode: "+57" },
-  { code: "PE", name: "Peru", dialCode: "+51" },
-  { code: "NZ", name: "New Zealand", dialCode: "+64" }
-];
-function normalizePhoneNumber(input) {
-  if (typeof input !== "string") return "";
-  const trimmed = input.trim();
-  if (!trimmed) return "";
-  const digitsOnly = trimmed.replace(/\D/g, "");
-  if (!digitsOnly) return "";
-  if (trimmed.startsWith("+")) {
-    return `+${digitsOnly}`;
-  }
-  if (trimmed.startsWith("00") && digitsOnly.length > 2) {
-    return `+${digitsOnly.slice(2)}`;
-  }
-  return `+${digitsOnly}`;
-}
-[...PHONE_COUNTRIES].sort((a, b) => b.dialCode.length - a.dialCode.length);
-
-// node_modules/@scalemule/sdk/dist/index.mjs
 function buildClientContextHeaders(context) {
   if (!context) return {};
   const headers = {};
@@ -386,6 +314,7 @@ var WORKSPACE_STORAGE_KEY = "scalemule_workspace_id";
 var ANONYMOUS_ID_STORAGE_KEY = "scalemule_anonymous_id";
 var SESSION_POOL_KEY = "scalemule_session_pool";
 var ACTIVE_ACCOUNT_KEY = "scalemule_active_account";
+var KNOWN_ACCOUNTS_KEY = "scalemule_known_accounts";
 var GATEWAY_URLS = {
   dev: "https://api-dev.scalemule.com",
   prod: "https://api.scalemule.com"
@@ -435,6 +364,54 @@ function statusToErrorCode(status) {
       return status >= 500 ? "internal_error" : `http_${status}`;
   }
 }
+var MAX_KNOWN_ACCOUNTS = 10;
+function maskEmail(email) {
+  const parts = email.split("@");
+  const local = parts[0] ?? "";
+  const domain = parts[1];
+  if (!domain) return "***@***.***";
+  const tldDot = domain.lastIndexOf(".");
+  const tld = tldDot > 0 ? domain.slice(tldDot) : "";
+  const domainBase = tldDot > 0 ? domain.slice(0, tldDot) : domain;
+  return `${local[0] || "*"}***@${domainBase[0] || "*"}***${tld}`;
+}
+function stableColorIndex(userId) {
+  let hash = 0;
+  for (let i = 0; i < userId.length; i++) {
+    hash = (hash << 5) - hash + userId.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash) % 8;
+}
+function applyPrivacy(account, privacy) {
+  switch (privacy) {
+    case "full":
+      return {
+        userId: account.userId,
+        email: account.email,
+        fullName: account.fullName,
+        avatarUrl: account.avatarUrl,
+        provider: account.provider,
+        lastActiveAt: account.lastActiveAt
+      };
+    case "masked":
+      return {
+        userId: account.userId,
+        email: account.email ? maskEmail(account.email) : void 0,
+        fullName: account.fullName && account.fullName.length > 0 ? `${account.fullName[0].toUpperCase()}.` : void 0,
+        provider: account.provider,
+        lastActiveAt: account.lastActiveAt,
+        colorIndex: stableColorIndex(account.userId)
+      };
+    case "minimal":
+      return {
+        userId: account.userId,
+        provider: account.provider,
+        lastActiveAt: account.lastActiveAt,
+        displayLabel: "Account",
+        colorIndex: stableColorIndex(account.userId)
+      };
+  }
+}
 function createDefaultStorage() {
   if (typeof window !== "undefined" && window.localStorage) {
     return {
@@ -581,6 +558,7 @@ var ScaleMuleClient = class {
     this.workspaceId = null;
     this.anonymousId = null;
     this.sessionPool = /* @__PURE__ */ new Map();
+    this.knownAccounts = /* @__PURE__ */ new Map();
     this.apiKey = config.apiKey;
     this.applicationId = config.applicationId || null;
     this.baseUrl = config.baseUrl || GATEWAY_URLS[config.environment || "prod"];
@@ -597,6 +575,8 @@ var ScaleMuleClient = class {
       this.offlineQueue.setOnlineCallback(() => this.syncOfflineQueue());
     }
     this.multiSessionEnabled = config.enableMultiSession || false;
+    this.accountSwitcherEnabled = config.enableAccountSwitcher || false;
+    this.accountSwitcherPrivacy = config.accountSwitcherPrivacy || "full";
   }
   // --------------------------------------------------------------------------
   // Session Management
@@ -639,6 +619,27 @@ var ScaleMuleClient = class {
         this.userId = activeId;
       }
     }
+    if (this.accountSwitcherEnabled) {
+      const knownJson = await this.storage.getItem(KNOWN_ACCOUNTS_KEY);
+      if (knownJson) {
+        try {
+          const entries = JSON.parse(knownJson);
+          this.knownAccounts = new Map(Object.entries(entries));
+          let changed = false;
+          for (const [userId2, entry] of this.knownAccounts) {
+            const normalized = applyPrivacy(entry, this.accountSwitcherPrivacy);
+            if (JSON.stringify(normalized) !== JSON.stringify(entry)) {
+              this.knownAccounts.set(userId2, normalized);
+              changed = true;
+            }
+          }
+          if (changed) {
+            await this.persistKnownAccounts();
+          }
+        } catch {
+        }
+      }
+    }
     if (this.debug)
       console.log(
         "[ScaleMule] Initialized, session:",
@@ -646,7 +647,9 @@ var ScaleMuleClient = class {
         "anonymousId:",
         anonId,
         "poolSize:",
-        this.sessionPool.size
+        this.sessionPool.size,
+        "knownAccounts:",
+        this.knownAccounts.size
       );
   }
   async setSession(token, userId) {
@@ -770,6 +773,57 @@ var ScaleMuleClient = class {
     }
     await this.storage.setItem(SESSION_POOL_KEY, JSON.stringify(obj));
   }
+  // --------------------------------------------------------------------------
+  // Account Switcher (Secure — metadata only, no tokens)
+  // --------------------------------------------------------------------------
+  isAccountSwitcherEnabled() {
+    return this.accountSwitcherEnabled;
+  }
+  getAccountSwitcherPrivacy() {
+    return this.accountSwitcherPrivacy;
+  }
+  /** Get all known accounts that have logged in on this device (privacy-transformed) */
+  getKnownAccounts() {
+    return Array.from(this.knownAccounts.values());
+  }
+  /**
+   * Record an account as "known" on this device.
+   * Applies privacy transforms before storing — full email is never persisted
+   * in masked/minimal modes. Evicts oldest accounts if over the cap.
+   * Called automatically after successful login/register when account switcher is enabled.
+   */
+  async addKnownAccount(account) {
+    const display = applyPrivacy(account, this.accountSwitcherPrivacy);
+    this.knownAccounts.set(account.userId, display);
+    if (this.knownAccounts.size > MAX_KNOWN_ACCOUNTS) {
+      const sorted = Array.from(this.knownAccounts.entries()).sort(
+        (a, b) => (a[1].lastActiveAt || "").localeCompare(b[1].lastActiveAt || "")
+      );
+      while (this.knownAccounts.size > MAX_KNOWN_ACCOUNTS && sorted.length > 0) {
+        const oldest = sorted.shift();
+        this.knownAccounts.delete(oldest[0]);
+      }
+    }
+    await this.persistKnownAccounts();
+  }
+  /** Remove a specific account from the known accounts list ("forget this account") */
+  async removeKnownAccount(userId) {
+    this.knownAccounts.delete(userId);
+    await this.persistKnownAccounts();
+  }
+  /** Clear all known accounts ("forget all accounts on this device") */
+  async clearKnownAccounts() {
+    this.knownAccounts.clear();
+    await this.storage.removeItem(KNOWN_ACCOUNTS_KEY);
+  }
+  /** Persist known accounts to storage */
+  async persistKnownAccounts() {
+    const obj = {};
+    for (const [k, v] of this.knownAccounts) {
+      obj[k] = v;
+    }
+    await this.storage.setItem(KNOWN_ACCOUNTS_KEY, JSON.stringify(obj));
+  }
   getBaseUrl() {
     return this.baseUrl;
   }
@@ -1261,6 +1315,74 @@ function asString(parent, key) {
   const value = parent[key];
   return typeof value === "string" ? value : void 0;
 }
+var PHONE_COUNTRIES = [
+  { code: "US", name: "United States", dialCode: "+1" },
+  { code: "CA", name: "Canada", dialCode: "+1" },
+  { code: "GB", name: "United Kingdom", dialCode: "+44" },
+  { code: "AU", name: "Australia", dialCode: "+61" },
+  { code: "DE", name: "Germany", dialCode: "+49" },
+  { code: "FR", name: "France", dialCode: "+33" },
+  { code: "IT", name: "Italy", dialCode: "+39" },
+  { code: "ES", name: "Spain", dialCode: "+34" },
+  { code: "NL", name: "Netherlands", dialCode: "+31" },
+  { code: "BE", name: "Belgium", dialCode: "+32" },
+  { code: "CH", name: "Switzerland", dialCode: "+41" },
+  { code: "AT", name: "Austria", dialCode: "+43" },
+  { code: "SE", name: "Sweden", dialCode: "+46" },
+  { code: "NO", name: "Norway", dialCode: "+47" },
+  { code: "DK", name: "Denmark", dialCode: "+45" },
+  { code: "FI", name: "Finland", dialCode: "+358" },
+  { code: "IE", name: "Ireland", dialCode: "+353" },
+  { code: "PT", name: "Portugal", dialCode: "+351" },
+  { code: "PL", name: "Poland", dialCode: "+48" },
+  { code: "CZ", name: "Czech Republic", dialCode: "+420" },
+  { code: "GR", name: "Greece", dialCode: "+30" },
+  { code: "RU", name: "Russia", dialCode: "+7" },
+  { code: "JP", name: "Japan", dialCode: "+81" },
+  { code: "KR", name: "South Korea", dialCode: "+82" },
+  { code: "CN", name: "China", dialCode: "+86" },
+  { code: "HK", name: "Hong Kong", dialCode: "+852" },
+  { code: "TW", name: "Taiwan", dialCode: "+886" },
+  { code: "SG", name: "Singapore", dialCode: "+65" },
+  { code: "MY", name: "Malaysia", dialCode: "+60" },
+  { code: "TH", name: "Thailand", dialCode: "+66" },
+  { code: "VN", name: "Vietnam", dialCode: "+84" },
+  { code: "PH", name: "Philippines", dialCode: "+63" },
+  { code: "ID", name: "Indonesia", dialCode: "+62" },
+  { code: "IN", name: "India", dialCode: "+91" },
+  { code: "PK", name: "Pakistan", dialCode: "+92" },
+  { code: "BD", name: "Bangladesh", dialCode: "+880" },
+  { code: "AE", name: "UAE", dialCode: "+971" },
+  { code: "SA", name: "Saudi Arabia", dialCode: "+966" },
+  { code: "IL", name: "Israel", dialCode: "+972" },
+  { code: "TR", name: "Turkey", dialCode: "+90" },
+  { code: "EG", name: "Egypt", dialCode: "+20" },
+  { code: "ZA", name: "South Africa", dialCode: "+27" },
+  { code: "NG", name: "Nigeria", dialCode: "+234" },
+  { code: "KE", name: "Kenya", dialCode: "+254" },
+  { code: "BR", name: "Brazil", dialCode: "+55" },
+  { code: "MX", name: "Mexico", dialCode: "+52" },
+  { code: "AR", name: "Argentina", dialCode: "+54" },
+  { code: "CL", name: "Chile", dialCode: "+56" },
+  { code: "CO", name: "Colombia", dialCode: "+57" },
+  { code: "PE", name: "Peru", dialCode: "+51" },
+  { code: "NZ", name: "New Zealand", dialCode: "+64" }
+];
+function normalizePhoneNumber(input) {
+  if (typeof input !== "string") return "";
+  const trimmed = input.trim();
+  if (!trimmed) return "";
+  const digitsOnly = trimmed.replace(/\D/g, "");
+  if (!digitsOnly) return "";
+  if (trimmed.startsWith("+")) {
+    return `+${digitsOnly}`;
+  }
+  if (trimmed.startsWith("00") && digitsOnly.length > 2) {
+    return `+${digitsOnly.slice(2)}`;
+  }
+  return `+${digitsOnly}`;
+}
+[...PHONE_COUNTRIES].sort((a, b) => b.dialCode.length - a.dialCode.length);
 function collectDeviceFingerprint() {
   if (typeof window === "undefined" || typeof navigator === "undefined") return void 0;
   try {
@@ -1389,6 +1511,16 @@ var AuthService = class extends ServiceModule {
         addedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
+    if (result.data && this.client.isAccountSwitcherEnabled()) {
+      await this.client.addKnownAccount({
+        userId: result.data.user.id,
+        email: result.data.user.email,
+        fullName: result.data.user.full_name,
+        avatarUrl: result.data.user.avatar_url,
+        provider: "email",
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
     return result;
   }
   async login(data, options) {
@@ -1409,6 +1541,16 @@ var AuthService = class extends ServiceModule {
         addedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
+    if (result.data && this.client.isAccountSwitcherEnabled()) {
+      await this.client.addKnownAccount({
+        userId: result.data.user.id,
+        email: result.data.user.email,
+        fullName: result.data.user.full_name,
+        avatarUrl: result.data.user.avatar_url,
+        provider: "email",
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
     return result;
   }
   async logout(options) {
@@ -1550,7 +1692,18 @@ var AuthService = class extends ServiceModule {
   }
   async handleOAuthCallback(data, options) {
     const { provider, ...rest } = data;
-    return this._get(this.withQuery(`/oauth/${provider}/callback`, rest), options);
+    const result = await this._get(this.withQuery(`/oauth/${provider}/callback`, rest), options);
+    if (result.data && this.client.isAccountSwitcherEnabled()) {
+      await this.client.addKnownAccount({
+        userId: result.data.user.id,
+        email: result.data.user.email,
+        fullName: result.data.user.full_name,
+        avatarUrl: result.data.user.avatar_url,
+        provider,
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return result;
   }
   async listOAuthProviders(options) {
     return this._get("/oauth/providers", options);
@@ -5251,6 +5404,71 @@ var FlagContentService = class extends ServiceModule {
     return this._get(`/appeals/${id}`, options);
   }
 };
+var CreatorMakerService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/creator-maker";
+  }
+  /** Submit a generation job. */
+  async generate(data, options) {
+    return this.post("/jobs", data, options);
+  }
+  /** Get a generation job by ID. */
+  async getJob(jobId, options) {
+    return this._get(`/jobs/${jobId}`, options);
+  }
+  /** Long-poll for job completion (server holds up to 30s). */
+  async pollJob(jobId, options) {
+    return this._get(`/jobs/${jobId}/poll`, {
+      ...options,
+      timeout: 35e3
+    });
+  }
+  /** List the current user's generation jobs. */
+  async listJobs(params, options) {
+    return this._list("/jobs", params, options);
+  }
+  /** Cancel a pending or queued job. */
+  async cancelJob(jobId, options) {
+    return this.post(`/jobs/${jobId}/cancel`, void 0, options);
+  }
+  /** Retry a failed job. */
+  async retryJob(jobId, options) {
+    return this.post(`/jobs/${jobId}/retry`, void 0, options);
+  }
+  /** Generate variations of a completed job. */
+  async generateVariations(jobId, options) {
+    return this.post(`/jobs/${jobId}/variations`, void 0, options);
+  }
+  /** List available style presets, optionally filtered by mode. */
+  async listPresets(params, options) {
+    return this._get(this.withQuery("/presets", params), options);
+  }
+  /** Get a style preset by slug. */
+  async getPreset(slug, options) {
+    return this._get(`/presets/${slug}`, options);
+  }
+  /** Create a project. */
+  async createProject(data, options) {
+    return this.post("/projects", data, options);
+  }
+  /** List the current user's projects. */
+  async listProjects(params, options) {
+    return this._list("/projects", params, options);
+  }
+  /** Get generation usage and credit balance. */
+  async getUsage(options) {
+    return this._get("/usage", options);
+  }
+  /** Get a generation output by ID. */
+  async getOutput(outputId, options) {
+    return this._get(`/outputs/${outputId}`, options);
+  }
+  /** Get a download URL for a generation output. */
+  async getDownloadUrl(outputId, options) {
+    return this._get(`/outputs/${outputId}/download`, options);
+  }
+};
 var AgentAuthService = class extends ServiceModule {
   constructor() {
     super(...arguments);
@@ -5452,6 +5670,13 @@ var AgentProjectsService = class extends ServiceModule {
       options
     );
   }
+  async startTask(taskId, agentId, applicationId, options) {
+    return this.post(
+      this.withAppId(`/tasks/${taskId}/start`, applicationId),
+      { agent_id: agentId },
+      options
+    );
+  }
   async submit(taskId, data, applicationId, options) {
     return this.post(this.withAppId(`/tasks/${taskId}/submit`, applicationId), data, options);
   }
@@ -5750,6 +5975,7 @@ var ScaleMule = class {
     this.functions = new FunctionsService(this._client);
     this.photo = new PhotoService(this._client);
     this.flagContent = new FlagContentService(this._client);
+    this.creatorMaker = new CreatorMakerService(this._client);
     this.compliance = new ComplianceService(this._client);
     this.orchestrator = new OrchestratorService(this._client);
     this.agentAuth = new AgentAuthService(this._client);
@@ -5829,6 +6055,36 @@ var ScaleMule = class {
   async clearAllAccounts() {
     return this._client.clearAllAccounts();
   }
+  // --------------------------------------------------------------------------
+  // Account Switcher (Secure — metadata only, re-auth required)
+  // --------------------------------------------------------------------------
+  /** Whether the account switcher is enabled */
+  isAccountSwitcherEnabled() {
+    return this._client.isAccountSwitcherEnabled();
+  }
+  /** The configured privacy level for the account switcher */
+  getAccountSwitcherPrivacy() {
+    return this._client.getAccountSwitcherPrivacy();
+  }
+  /**
+   * Get all accounts that have previously logged in on this device.
+   * Returns privacy-transformed display data — no raw PII in masked/minimal modes.
+   * Requires `enableAccountSwitcher: true` in config.
+   */
+  getKnownAccounts() {
+    return this._client.getKnownAccounts();
+  }
+  /**
+   * Forget a specific account — removes it from the known accounts list.
+   * Does NOT affect any active session.
+   */
+  async removeKnownAccount(userId) {
+    return this._client.removeKnownAccount(userId);
+  }
+  /** Forget all known accounts on this device. */
+  async clearKnownAccounts() {
+    return this._client.clearKnownAccounts();
+  }
   /** The base URL being used for API requests. */
   getBaseUrl() {
     return this._client.getBaseUrl();
@@ -6660,6 +6916,8 @@ function ScaleMuleProvider({
   analyticsProxyUrl,
   authProxyUrl,
   publishableKey,
+  enableAccountSwitcher,
+  accountSwitcherPrivacy,
   children,
   onLogin,
   onLogout,
@@ -6797,9 +7055,11 @@ function ScaleMuleProvider({
       publishableKey,
       gatewayUrl: gatewayUrl || (environment === "dev" ? "https://api-dev.scalemule.com" : "https://api.scalemule.com"),
       environment: environment || void 0,
+      enableAccountSwitcher,
+      accountSwitcherPrivacy,
       bootstrapFlags
     }),
-    [client, baseClient, user, handleSetUser, initializing, error, analyticsProxyUrl, authProxyUrl, publishableKey, gatewayUrl, environment, bootstrapFlags]
+    [client, baseClient, user, handleSetUser, initializing, error, analyticsProxyUrl, authProxyUrl, publishableKey, gatewayUrl, environment, enableAccountSwitcher, accountSwitcherPrivacy, bootstrapFlags]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(ScaleMuleContext.Provider, { value, children });
 }
@@ -6816,6 +7076,41 @@ function useScaleMuleClient() {
   const { client } = useScaleMule();
   return client;
 }
+function maskEmail2(email) {
+  const [local, domain] = email.split("@");
+  if (!domain) return "***@***.***";
+  const tldDot = domain.lastIndexOf(".");
+  const tld = tldDot > 0 ? domain.slice(tldDot) : "";
+  const domainBase = tldDot > 0 ? domain.slice(0, tldDot) : domain;
+  return `${local[0] || "*"}***@${domainBase[0] || "*"}***${tld}`;
+}
+function stableColorIndex2(userId) {
+  let hash = 0;
+  for (let i = 0; i < userId.length; i++) {
+    hash = (hash << 5) - hash + userId.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash) % 8;
+}
+function applyClientPrivacy(entry, privacy) {
+  if (!privacy || privacy === "full") return entry;
+  if (privacy === "masked") {
+    return {
+      userId: entry.userId,
+      email: entry.email ? maskEmail2(entry.email) : void 0,
+      fullName: entry.fullName ? `${entry.fullName[0].toUpperCase()}.` : void 0,
+      provider: entry.provider,
+      lastActiveAt: entry.lastActiveAt,
+      colorIndex: stableColorIndex2(entry.userId)
+    };
+  }
+  return {
+    userId: entry.userId,
+    provider: entry.provider,
+    lastActiveAt: entry.lastActiveAt,
+    displayLabel: "Account",
+    colorIndex: stableColorIndex2(entry.userId)
+  };
+}
 function getCookie(name) {
   if (typeof document === "undefined") return void 0;
   const match = document.cookie.match(new RegExp(`(?:^|; )${name}=([^;]*)`));
@@ -6844,7 +7139,7 @@ async function proxyFetch(proxyUrl, path, options = {}) {
   return data;
 }
 function useAuth() {
-  const { client, user, setUser, initializing, error, setError, authProxyUrl } = useScaleMule();
+  const { client, user, setUser, initializing, error, setError, authProxyUrl, enableAccountSwitcher, accountSwitcherPrivacy } = useScaleMule();
   const register = react.useCallback(
     async (data) => {
       setError(null);
@@ -7452,6 +7747,63 @@ function useAuth() {
     },
     [client, setUser, setError, authProxyUrl]
   );
+  const readKnownAccountsCookie = react.useCallback(() => {
+    if (!enableAccountSwitcher) return [];
+    if (typeof document === "undefined") return [];
+    const match = document.cookie.match(/(?:^|; )sm_known_accounts=([^;]*)/);
+    if (!match) return [];
+    try {
+      const decoded = decodeURIComponent(match[1]);
+      const accounts = JSON.parse(decoded);
+      let entries = Object.values(accounts);
+      if (accountSwitcherPrivacy && accountSwitcherPrivacy !== "full") {
+        entries = entries.map((e) => applyClientPrivacy(e, accountSwitcherPrivacy));
+      }
+      return entries;
+    } catch {
+      return [];
+    }
+  }, [enableAccountSwitcher, accountSwitcherPrivacy]);
+  const [knownAccounts, setKnownAccounts] = react.useState([]);
+  react.useEffect(() => {
+    setKnownAccounts(readKnownAccountsCookie());
+  }, [readKnownAccountsCookie, user]);
+  const switchAccount = react.useCallback(
+    async (userId) => {
+      const target = knownAccounts.find((a) => a.userId === userId) || null;
+      if (!target) return null;
+      if (authProxyUrl) {
+        await proxyFetch(authProxyUrl, "switch-account");
+      } else {
+        const sessionToken = client.getSessionToken();
+        if (sessionToken) {
+          try {
+            await client.post("/v1/auth/logout", { session_token: sessionToken });
+          } catch {
+          }
+        }
+        await client.clearSession();
+      }
+      setUser(null);
+      return target;
+    },
+    [client, setUser, knownAccounts, authProxyUrl]
+  );
+  const removeKnownAccount = react.useCallback(
+    async (userId) => {
+      if (authProxyUrl) {
+        await proxyFetch(authProxyUrl, "forget-account", { body: { user_id: userId } });
+      }
+      setKnownAccounts((prev) => prev.filter((a) => a.userId !== userId));
+    },
+    [authProxyUrl]
+  );
+  const clearKnownAccounts = react.useCallback(async () => {
+    if (authProxyUrl) {
+      await proxyFetch(authProxyUrl, "forget-all-accounts");
+    }
+    setKnownAccounts([]);
+  }, [authProxyUrl]);
   return react.useMemo(
     () => ({
       user,
@@ -7483,7 +7835,12 @@ function useAuth() {
       // Phone auth
       sendPhoneCode,
       verifyPhone,
-      loginWithPhone
+      loginWithPhone,
+      // Account switcher
+      knownAccounts,
+      switchAccount,
+      removeKnownAccount,
+      clearKnownAccounts
     }),
     [
       user,
@@ -7510,7 +7867,11 @@ function useAuth() {
       regenerateBackupCodes,
       sendPhoneCode,
       verifyPhone,
-      loginWithPhone
+      loginWithPhone,
+      knownAccounts,
+      switchAccount,
+      removeKnownAccount,
+      clearKnownAccounts
     ]
   );
 }