mailsentry-auth 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2996 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/types/http/http-types.ts
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["GET"] = "GET";
+  HttpMethod2["POST"] = "POST";
+  HttpMethod2["PUT"] = "PUT";
+  HttpMethod2["DELETE"] = "DELETE";
+  HttpMethod2["PATCH"] = "PATCH";
+  return HttpMethod2;
+})(HttpMethod || {});
+
+// src/types/components/profile.ts
+var ProfileUIState = /* @__PURE__ */ ((ProfileUIState2) => {
+  ProfileUIState2["LOADING"] = "LOADING";
+  ProfileUIState2["UNAUTHENTICATED"] = "UNAUTHENTICATED";
+  ProfileUIState2["AUTHENTICATED"] = "AUTHENTICATED";
+  return ProfileUIState2;
+})(ProfileUIState || {});
+
+// src/types/auth/auth-stepper-enums.ts
+var AuthFlowStep = /* @__PURE__ */ ((AuthFlowStep2) => {
+  AuthFlowStep2["EMAIL"] = "email";
+  AuthFlowStep2["PASSWORD"] = "password";
+  AuthFlowStep2["VERIFICATION"] = "verification";
+  return AuthFlowStep2;
+})(AuthFlowStep || {});
+var NextAction = /* @__PURE__ */ ((NextAction2) => {
+  NextAction2["LOGIN"] = "login";
+  NextAction2["SIGNUP"] = "signup";
+  NextAction2["LOGIN_VERIFICATION"] = "login-verification";
+  return NextAction2;
+})(NextAction || {});
+
+// src/types/auth/auth-types.ts
+var RoleType = /* @__PURE__ */ ((RoleType2) => {
+  RoleType2["USER"] = "USER";
+  RoleType2["ADMIN"] = "ADMIN";
+  return RoleType2;
+})(RoleType || {});
+
+// src/types/event-bus/event-bus.interface.ts
+var BaseEventBus = class {
+};
+
+// src/types/event-bus/events.ts
+var AuthEventType = /* @__PURE__ */ ((AuthEventType3) => {
+  AuthEventType3["LoggedIn"] = "auth.logged_in";
+  AuthEventType3["LoggedOut"] = "auth.logged_out";
+  AuthEventType3["EmailVerified"] = "auth.email_verified";
+  AuthEventType3["SignInRequiredModal"] = "auth.signin_required_modal";
+  return AuthEventType3;
+})(AuthEventType || {});
+var PageType = /* @__PURE__ */ ((PageType3) => {
+  PageType3["LOGIN"] = "/login";
+  PageType3["DASHBOARD"] = "/dashboard";
+  PageType3["HOME"] = "/";
+  return PageType3;
+})(PageType || {});
+var NavigationAction = /* @__PURE__ */ ((NavigationAction2) => {
+  NavigationAction2["NONE"] = "none";
+  NavigationAction2["REDIRECT"] = "redirect";
+  NavigationAction2["MODAL"] = "modal";
+  return NavigationAction2;
+})(NavigationAction || {});
+var PageTypePatterns = {
+  ["/login" /* LOGIN */]: "/login" /* LOGIN */,
+  ["/dashboard" /* DASHBOARD */]: "/dashboard" /* DASHBOARD */,
+  ["/" /* HOME */]: "/" /* HOME */
+};
+var CrossTabBehaviorConfig = {
+  ["/login" /* LOGIN */]: {
+    ["auth.logged_in" /* LoggedIn */]: { action: "redirect" /* REDIRECT */, target: "/dashboard" /* DASHBOARD */ },
+    ["auth.logged_out" /* LoggedOut */]: { action: "none" /* NONE */ },
+    ["auth.email_verified" /* EmailVerified */]: { action: "none" /* NONE */ },
+    ["auth.signin_required_modal" /* SignInRequiredModal */]: { action: "none" /* NONE */ }
+  },
+  ["/dashboard" /* DASHBOARD */]: {
+    ["auth.logged_in" /* LoggedIn */]: { action: "modal" /* MODAL */ },
+    ["auth.logged_out" /* LoggedOut */]: { action: "redirect" /* REDIRECT */, target: "/dashboard" /* DASHBOARD */ },
+    ["auth.email_verified" /* EmailVerified */]: { action: "modal" /* MODAL */ },
+    ["auth.signin_required_modal" /* SignInRequiredModal */]: { action: "none" /* NONE */ }
+  },
+  ["/" /* HOME */]: {
+    ["auth.logged_in" /* LoggedIn */]: { action: "modal" /* MODAL */ },
+    ["auth.logged_out" /* LoggedOut */]: { action: "redirect" /* REDIRECT */, target: "/" /* HOME */ },
+    ["auth.email_verified" /* EmailVerified */]: { action: "modal" /* MODAL */ },
+    ["auth.signin_required_modal" /* SignInRequiredModal */]: { action: "none" /* NONE */ }
+  }
+};
+
+// src/config/channels.ts
+var Channel = /* @__PURE__ */ ((Channel2) => {
+  Channel2["AUTH"] = "auth-event-channel";
+  return Channel2;
+})(Channel || {});
+
+// src/config/auth-steps.tsx
+import {
+  MailOutlined,
+  LockOutlined,
+  CheckCircleOutlined
+} from "@ant-design/icons";
+import { jsx } from "react/jsx-runtime";
+var createAuthSteps = (options) => {
+  const { authIntent = "login" /* LOGIN */, nextAction } = options || {};
+  return [
+    {
+      id: "email" /* EMAIL */,
+      title: "Email",
+      description: "Enter your email",
+      icon: /* @__PURE__ */ jsx(MailOutlined, {})
+    },
+    {
+      id: "password" /* PASSWORD */,
+      title: authIntent === "login" /* LOGIN */ ? "Sign In" : "Sign Up",
+      description: authIntent === "login" /* LOGIN */ ? "Enter password" : "Create password",
+      icon: /* @__PURE__ */ jsx(LockOutlined, {})
+    },
+    {
+      id: "verification" /* VERIFICATION */,
+      title: "Verification",
+      description: "Verify email",
+      icon: /* @__PURE__ */ jsx(CheckCircleOutlined, {}),
+      disabled: authIntent === "login" /* LOGIN */ || nextAction === "login" /* LOGIN */
+    }
+  ];
+};
+var getStepProgressMessage = (step) => {
+  const messages = {
+    ["email" /* EMAIL */]: "Starting...",
+    ["password" /* PASSWORD */]: "Authenticating...",
+    ["verification" /* VERIFICATION */]: "Verifying..."
+  };
+  return messages[step] || "Processing...";
+};
+var getAuthPageStepMessage = (step) => {
+  const messages = {
+    ["email" /* EMAIL */]: "Checking...",
+    ["password" /* PASSWORD */]: "Authenticating...",
+    ["verification" /* VERIFICATION */]: "Verifying..."
+  };
+  return messages[step] || "Processing...";
+};
+
+// src/config/step-navigation.ts
+var EMAIL_SUBMISSION_NAVIGATION = {
+  ["login-verification" /* LOGIN_VERIFICATION */]: "verification" /* VERIFICATION */,
+  ["login" /* LOGIN */]: "password" /* PASSWORD */,
+  ["signup" /* SIGNUP */]: "password" /* PASSWORD */
+};
+var PASSWORD_SUBMISSION_NAVIGATION = {
+  VERIFIED: "verification" /* VERIFICATION */,
+  UNVERIFIED: "verification" /* VERIFICATION */
+};
+var VERIFICATION_SUBMISSION_NAVIGATION = {
+  SUCCESS: "verification" /* VERIFICATION */,
+  ERROR: "verification" /* VERIFICATION */
+  // Stay on verification step on error
+};
+var getStepForEmailSubmission = (nextAction) => {
+  return EMAIL_SUBMISSION_NAVIGATION[nextAction] || "password" /* PASSWORD */;
+};
+var getStepForPasswordSubmission = (isVerified) => {
+  return isVerified ? PASSWORD_SUBMISSION_NAVIGATION.VERIFIED : PASSWORD_SUBMISSION_NAVIGATION.UNVERIFIED;
+};
+var getStepForVerificationSubmission = (success) => {
+  return success ? VERIFICATION_SUBMISSION_NAVIGATION.SUCCESS : VERIFICATION_SUBMISSION_NAVIGATION.ERROR;
+};
+
+// src/config/form-fields.tsx
+import { Input } from "antd";
+import { MailOutlined as MailOutlined2, LockOutlined as LockOutlined2, CheckCircleOutlined as CheckCircleOutlined2 } from "@ant-design/icons";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var getEmailField = (options = {}) => ({
+  name: "email",
+  label: "Email",
+  component: /* @__PURE__ */ jsx2(
+    Input,
+    __spreadProps(__spreadValues({}, options), {
+      prefix: /* @__PURE__ */ jsx2(MailOutlined2, {}),
+      placeholder: "Email",
+      size: "large"
+    })
+  ),
+  rules: !options.readOnly ? [
+    { required: true, message: "Please enter your email!" },
+    { type: "email", message: "Please enter a valid email!" }
+  ] : void 0
+});
+var getPasswordField = (isLogin, disabled = false, options = {}) => ({
+  name: "password",
+  label: isLogin ? "Password" : "Create a Password",
+  component: /* @__PURE__ */ jsx2(
+    Input.Password,
+    __spreadProps(__spreadValues({}, options), {
+      prefix: /* @__PURE__ */ jsx2(LockOutlined2, {}),
+      placeholder: isLogin ? "Enter your password" : "Create a password",
+      disabled,
+      size: "large"
+    })
+  ),
+  rules: [
+    { required: true, message: "Please enter your password!" }
+  ]
+});
+var getVerificationField = (codeLength = 5, options = {}) => ({
+  name: "verificationCode",
+  component: /* @__PURE__ */ jsx2(
+    Input,
+    __spreadProps(__spreadValues({}, options), {
+      prefix: /* @__PURE__ */ jsx2(CheckCircleOutlined2, {}),
+      placeholder: "Enter verification code",
+      maxLength: codeLength,
+      size: "large"
+    })
+  ),
+  rules: [
+    { required: true, message: "Please enter the verification code!" },
+    { len: codeLength, message: `Verification code must be ${codeLength} characters!` }
+  ]
+});
+
+// src/config/middleware.ts
+var MiddlewareConfig = class {
+};
+// Protected routes
+MiddlewareConfig.PROTECTED_ROUTES = {
+  DASHBOARD: "/"
+};
+// Auth routes
+MiddlewareConfig.AUTH_ROUTES = {
+  LOGIN: "/login"
+};
+// HTTP methods to process
+MiddlewareConfig.ALLOWED_METHODS = ["GET", "HEAD"];
+// Query parameters
+MiddlewareConfig.QUERY_PARAMS = {
+  LOGIN_REQUIRED: "sign_in_required",
+  AUTH_CHECKED: "auth_checked"
+};
+// Query parameter values
+MiddlewareConfig.QUERY_VALUES = {
+  LOGIN_REQUIRED: "true",
+  AUTH_CHECKED: "1"
+};
+var middlewareMatcher = [
+  "/((?!api|_next/static|_next/image|_next/webpack-hmr|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp|ico|css|js)$).*)",
+  "/login"
+];
+var config = {
+  matcher: middlewareMatcher
+};
+
+// src/store/user-store.ts
+import { create } from "zustand";
+import { devtools, subscribeWithSelector } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import { useShallow } from "zustand/react/shallow";
+
+// node_modules/.pnpm/js-cookie@3.0.5/node_modules/js-cookie/dist/js.cookie.mjs
+function assign(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+var defaultConverter = {
+  read: function(value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+  },
+  write: function(value) {
+    return encodeURIComponent(value).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    );
+  }
+};
+function init(converter, defaultAttributes) {
+  function set(name, value, attributes) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    attributes = assign({}, defaultAttributes, attributes);
+    if (typeof attributes.expires === "number") {
+      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+    }
+    if (attributes.expires) {
+      attributes.expires = attributes.expires.toUTCString();
+    }
+    name = encodeURIComponent(name).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+    var stringifiedAttributes = "";
+    for (var attributeName in attributes) {
+      if (!attributes[attributeName]) {
+        continue;
+      }
+      stringifiedAttributes += "; " + attributeName;
+      if (attributes[attributeName] === true) {
+        continue;
+      }
+      stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
+    }
+    return document.cookie = name + "=" + converter.write(value, name) + stringifiedAttributes;
+  }
+  function get(name) {
+    if (typeof document === "undefined" || arguments.length && !name) {
+      return;
+    }
+    var cookies = document.cookie ? document.cookie.split("; ") : [];
+    var jar = {};
+    for (var i = 0; i < cookies.length; i++) {
+      var parts = cookies[i].split("=");
+      var value = parts.slice(1).join("=");
+      try {
+        var found = decodeURIComponent(parts[0]);
+        jar[found] = converter.read(value, found);
+        if (name === found) {
+          break;
+        }
+      } catch (e) {
+      }
+    }
+    return name ? jar[name] : jar;
+  }
+  return Object.create(
+    {
+      set,
+      get,
+      remove: function(name, attributes) {
+        set(
+          name,
+          "",
+          assign({}, attributes, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function(attributes) {
+        return init(this.converter, assign({}, this.attributes, attributes));
+      },
+      withConverter: function(converter2) {
+        return init(assign({}, this.converter, converter2), this.attributes);
+      }
+    },
+    {
+      attributes: { value: Object.freeze(defaultAttributes) },
+      converter: { value: Object.freeze(converter) }
+    }
+  );
+}
+var api = init(defaultConverter, { path: "/" });
+
+// src/services/utils/cookie-utils.ts
+var _CookieUtils = class _CookieUtils {
+  /**
+   * Get the access token cookie key from environment variables
+   */
+  static getAccessTokenKey() {
+    return process.env.AUTH_ACCESS_TOKEN_KEY || "auth_access_token";
+  }
+  /**
+   * Get the refresh token cookie key from environment variables
+   */
+  static getRefreshTokenKey() {
+    return process.env.AUTH_REFRESH_TOKEN_KEY || "auth_refresh_token";
+  }
+  // Use current domain in development
+  /**
+   * Get root domain for subdomain support
+   */
+  static getRootDomain() {
+    if (typeof window === "undefined") return void 0;
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return void 0;
+    }
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname)) {
+      return void 0;
+    }
+    const parts = hostname.split(".");
+    if (parts.length >= 2) {
+      return `.${parts.slice(-2).join(".")}`;
+    }
+    return void 0;
+  }
+  /**
+   * Get common cookie options
+   */
+  static getCookieOptions() {
+    return {
+      path: "/",
+      sameSite: "strict",
+      secure: process.env.NODE_ENV === "production",
+      // Only secure in production
+      domain: this.COOKIE_DOMAIN
+      // Support subdomains
+    };
+  }
+  /**
+   * Check if running on client side
+   */
+  static isClientSide() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Check if running on server side
+   */
+  static isServerSide() {
+    return typeof window === "undefined";
+  }
+  /**
+   * Dynamically import server action for server-side operations
+   */
+  static async getServerTokens() {
+    try {
+      const { getAuthTokens } = await import("mailsentry-auth/server");
+      return await getAuthTokens();
+    } catch (error) {
+      console.error("Failed to get server tokens:", error);
+      return { accessToken: null, refreshToken: null };
+    }
+  }
+  /**
+   * Set access token in cookie (client-side only)
+   */
+  static setAccessToken(token) {
+    if (this.isServerSide()) {
+      console.warn("setAccessToken called on server side - use server actions instead");
+      return;
+    }
+    const options = this.getCookieOptions();
+    api.set(this.getAccessTokenKey(), token, options);
+  }
+  /**
+   * Set refresh token in cookie (client-side only)
+   */
+  static setRefreshToken(token) {
+    if (this.isServerSide()) {
+      console.warn("setRefreshToken called on server side - use server actions instead");
+      return;
+    }
+    const options = this.getCookieOptions();
+    api.set(this.getRefreshTokenKey(), token, options);
+  }
+  /**
+   * Get access token - automatically handles client/server side
+   */
+  static async getAccessToken() {
+    if (this.isClientSide()) {
+      return api.get(this.getAccessTokenKey()) || null;
+    } else {
+      const { accessToken } = await this.getServerTokens();
+      return accessToken;
+    }
+  }
+  /**
+   * Get refresh token - automatically handles client/server side
+   */
+  static async getRefreshToken() {
+    if (this.isClientSide()) {
+      return api.get(this.getRefreshTokenKey()) || null;
+    } else {
+      const { refreshToken } = await this.getServerTokens();
+      return refreshToken;
+    }
+  }
+  /**
+   * Get both tokens - automatically handles client/server side
+   */
+  static async getTokens() {
+    if (this.isClientSide()) {
+      return {
+        accessToken: api.get(this.getAccessTokenKey()) || null,
+        refreshToken: api.get(this.getRefreshTokenKey()) || null
+      };
+    } else {
+      return await this.getServerTokens();
+    }
+  }
+  /**
+   * Clear all authentication cookies (client-side only)
+   */
+  static clearAuthCookies() {
+    if (this.isServerSide()) {
+      console.warn("clearAuthCookies called on server side - use server actions instead");
+      return;
+    }
+    const removeOptions = {
+      path: "/",
+      domain: this.COOKIE_DOMAIN
+    };
+    api.remove(this.getAccessTokenKey(), removeOptions);
+    api.remove(this.getRefreshTokenKey(), removeOptions);
+  }
+  /**
+   * Check if cookies are supported/enabled (client-side only)
+   */
+  static areCookiesEnabled() {
+    if (this.isServerSide()) {
+      console.warn("areCookiesEnabled called on server side - not applicable");
+      return false;
+    }
+    try {
+      const testKey = "test_cookie_support";
+      const testOptions = this.getCookieOptions();
+      api.set(testKey, "test", testOptions);
+      const value = api.get(testKey);
+      api.remove(testKey, {
+        path: "/",
+        domain: this.COOKIE_DOMAIN
+      });
+      return value === "test";
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Get all authentication cookies - automatically handles client/server side
+   */
+  static async getAllAuthCookies() {
+    if (this.isClientSide()) {
+      return {
+        accessToken: api.get(this.getAccessTokenKey()) || "",
+        refreshToken: api.get(this.getRefreshTokenKey()) || ""
+      };
+    } else {
+      const { accessToken, refreshToken } = await this.getServerTokens();
+      return {
+        accessToken: accessToken || "",
+        refreshToken: refreshToken || ""
+      };
+    }
+  }
+  /**
+   * Set multiple tokens at once (client-side only)
+   */
+  static setTokens(accessToken, refreshToken) {
+    if (this.isServerSide()) {
+      console.warn("setTokens called on server side - use server actions instead");
+      return;
+    }
+    this.setAccessToken(accessToken);
+    this.setRefreshToken(refreshToken);
+  }
+  /**
+   * Check if user has valid tokens - automatically handles client/server side
+   */
+  static async hasValidTokens() {
+    const tokens = await this.getTokens();
+    return !!(tokens.accessToken && tokens.refreshToken);
+  }
+  /**
+   * Get current domain information for debugging
+   */
+  static getDomainInfo() {
+    if (this.isServerSide()) {
+      return {
+        error: "Server-side rendering - no domain info available",
+        environment: process.env.NODE_ENV || "unknown",
+        recommendation: "Use server actions for server-side cookie access"
+      };
+    }
+    return {
+      hostname: window.location.hostname,
+      domain: this.COOKIE_DOMAIN || "current domain",
+      environment: process.env.NODE_ENV || "unknown",
+      protocol: window.location.protocol
+    };
+  }
+};
+// Domain configuration
+_CookieUtils.COOKIE_DOMAIN = process.env.NODE_ENV === "production" ? _CookieUtils.getRootDomain() : void 0;
+var CookieUtils = _CookieUtils;
+
+// src/services/utils/localstorage-utils.ts
+var LocalStorageUtils = class {
+  // 5 minutes
+  /**
+   * Check if localStorage is available
+   */
+  static isAvailable() {
+    try {
+      if (typeof window === "undefined") return false;
+      localStorage.setItem("test", "test");
+      localStorage.removeItem("test");
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Save user profile to localStorage with timestamp
+   */
+  static saveUserProfile(userProfile) {
+    if (!this.isAvailable() || !userProfile) return false;
+    try {
+      localStorage.setItem(this.USER_PROFILE_STORAGE_KEY, JSON.stringify(userProfile));
+      localStorage.setItem(this.USER_PROFILE_TIMESTAMP_KEY, Date.now().toString());
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Get user profile from localStorage with cache validation
+   */
+  static getUserProfile(cacheDuration = this.DEFAULT_CACHE_DURATION) {
+    if (!this.isAvailable()) return null;
+    try {
+      const userProfileData = localStorage.getItem(this.USER_PROFILE_STORAGE_KEY);
+      const timestamp = localStorage.getItem(this.USER_PROFILE_TIMESTAMP_KEY);
+      if (!userProfileData || !timestamp) return null;
+      const cacheAge = Date.now() - parseInt(timestamp);
+      if (cacheAge >= cacheDuration) {
+        this.clearUserProfile();
+        return null;
+      }
+      return JSON.parse(userProfileData);
+    } catch (e) {
+      this.clearUserProfile();
+      return null;
+    }
+  }
+  /**
+   * Clear user profile data from localStorage
+   */
+  static clearUserProfile() {
+    if (!this.isAvailable()) return false;
+    try {
+      localStorage.removeItem(this.USER_PROFILE_STORAGE_KEY);
+      localStorage.removeItem(this.USER_PROFILE_TIMESTAMP_KEY);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Check if cached user profile is still valid
+   */
+  static isCacheValid(cacheDuration = this.DEFAULT_CACHE_DURATION) {
+    if (!this.isAvailable()) return false;
+    try {
+      const timestamp = localStorage.getItem(this.USER_PROFILE_TIMESTAMP_KEY);
+      if (!timestamp) return false;
+      const cacheAge = Date.now() - parseInt(timestamp);
+      return cacheAge < cacheDuration;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+LocalStorageUtils.USER_PROFILE_STORAGE_KEY = "user_profile_data";
+LocalStorageUtils.USER_PROFILE_TIMESTAMP_KEY = "user_profile_timestamp";
+LocalStorageUtils.DEFAULT_CACHE_DURATION = 5 * 60 * 1e3;
+
+// src/services/utils/event-bus.ts
+var REGISTRY_KEY = "__bc_event_buses__";
+function getRegistry() {
+  const g = globalThis;
+  if (!g[REGISTRY_KEY]) {
+    g[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  }
+  return g[REGISTRY_KEY];
+}
+function isBroadcastChannelSupported() {
+  return typeof window !== "undefined" && "BroadcastChannel" in window && typeof BroadcastChannel === "function";
+}
+var BroadcastChannelEventBus = class _BroadcastChannelEventBus {
+  constructor(name) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.name = name;
+    if (isBroadcastChannelSupported()) {
+      try {
+        this.channel = new BroadcastChannel(name);
+        this.channel.onmessage = (ev) => this.emit(ev.data);
+      } catch (error) {
+        console.warn("Failed to create BroadcastChannel:", error);
+      }
+    }
+  }
+  static getInstance(name) {
+    const registry = getRegistry();
+    let bus = registry.get(name);
+    if (!bus) {
+      bus = new _BroadcastChannelEventBus(name);
+      registry.set(name, bus);
+    }
+    return bus;
+  }
+  publish(event) {
+    var _a;
+    this.emit(event);
+    (_a = this.channel) == null ? void 0 : _a.postMessage(event);
+  }
+  subscribe(handler) {
+    this.listeners.add(handler);
+    return { unsubscribe: () => this.listeners.delete(handler) };
+  }
+  emit(e) {
+    for (const h of this.listeners) h(e);
+  }
+  close() {
+    var _a;
+    (_a = this.channel) == null ? void 0 : _a.close();
+    this.listeners.clear();
+    getRegistry().delete(this.name);
+  }
+};
+
+// src/services/utils/cross-tab-behavior-handler.ts
+var CrossTabBehaviorHandler = class {
+  /**
+   * Get current page type based on pathname using pattern matching
+   */
+  static getCurrentPageType() {
+    var _a, _b;
+    if (typeof window === "undefined") return "/" /* HOME */;
+    const pathname = window.location.pathname;
+    return (_b = (_a = Object.entries(PageTypePatterns).find(
+      ([pattern]) => pathname.includes(pattern)
+    )) == null ? void 0 : _a[1]) != null ? _b : "/" /* HOME */;
+  }
+  /**
+   * Get the action configuration for current route and event
+   */
+  static getAction(currentPageType, eventType) {
+    var _a, _b;
+    return (_b = (_a = CrossTabBehaviorConfig[currentPageType]) == null ? void 0 : _a[eventType]) != null ? _b : { action: "none" /* NONE */ };
+  }
+  /**
+   * Check if current route requires redirect for given event
+   */
+  static shouldRedirect(currentPageType, eventType) {
+    const action = this.getAction(currentPageType, eventType);
+    return action.action === "redirect" /* REDIRECT */ ? action.target : null;
+  }
+  /**
+   * Check if current route should show modal for given event
+   */
+  static shouldShowModal(currentPageType, eventType) {
+    const action = this.getAction(currentPageType, eventType);
+    return action.action === "modal" /* MODAL */;
+  }
+};
+
+// src/services/auth/manager/token-manager.ts
+var TokenManager = class {
+  constructor(cookieUtils) {
+    this.cookieUtils = cookieUtils;
+  }
+  saveTokens(accessToken, refreshToken) {
+    if (refreshToken) {
+      this.cookieUtils.setTokens(accessToken, refreshToken);
+    } else {
+      this.cookieUtils.setAccessToken(accessToken);
+    }
+  }
+  clearTokens() {
+    this.cookieUtils.clearAuthCookies();
+  }
+  async getAccessToken() {
+    return await this.cookieUtils.getAccessToken();
+  }
+  async getRefreshToken() {
+    return await this.cookieUtils.getRefreshToken();
+  }
+  /**
+   * Get all stored tokens for debugging or validation
+   */
+  async getAllTokens() {
+    return await this.cookieUtils.getAllAuthCookies();
+  }
+  /**
+   * Check if cookies are supported in the current environment
+   */
+  areCookiesSupported() {
+    return this.cookieUtils.areCookiesEnabled();
+  }
+  /**
+   * Get domain information for debugging
+   */
+  getDomainInfo() {
+    return this.cookieUtils.getDomainInfo();
+  }
+};
+
+// src/services/api/base-service.ts
+var HttpClient = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Execute HTTP request
+   */
+  async request(endpoint, options) {
+    try {
+      const url = `${this.config.baseURL}${endpoint}`;
+      const fetchOptions = {
+        method: options.method,
+        headers: await this.buildHeaders(options.headers),
+        body: options.body ? JSON.stringify(options.body) : void 0
+      };
+      const response = await this.executeWithTimeout(
+        fetch(url, fetchOptions),
+        options.timeout || this.config.timeout || 3e4
+      );
+      const httpResponse = {
+        data: await response.json(),
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        ok: response.ok
+      };
+      return httpResponse;
+    } catch (error) {
+      const httpError = {
+        name: "HttpError",
+        message: error instanceof Error ? error.message : "Unknown error",
+        status: error instanceof Response ? error.status : void 0,
+        statusText: error instanceof Response ? error.statusText : void 0,
+        response: error
+      };
+      throw httpError;
+    }
+  }
+  /**
+   * Build headers with defaults including multiple API keys and Bearer token
+   */
+  async buildHeaders(customHeaders) {
+    var _a, _b;
+    const defaultHeaders = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.origin) {
+      defaultHeaders["Origin"] = this.config.origin;
+    }
+    if (this.config.apiKeys) {
+      Object.assign(defaultHeaders, this.config.apiKeys);
+    }
+    const accessToken = await ((_b = (_a = this.config).getAccessToken) == null ? void 0 : _b.call(_a));
+    if (accessToken) {
+      defaultHeaders["authorization"] = `Bearer ${accessToken}`;
+    }
+    return __spreadValues(__spreadValues({}, defaultHeaders), customHeaders);
+  }
+  /**
+   * Execute request with timeout
+   */
+  async executeWithTimeout(promise, timeoutMs) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Request timeout after ${timeoutMs}ms`)), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+  }
+};
+var ApiError = class extends Error {
+  constructor(message2, status, statusText, apiError) {
+    super(message2);
+    this.name = "ApiError";
+    this.status = status;
+    this.statusText = statusText;
+    this.apiError = apiError;
+  }
+};
+var BaseService = class {
+  constructor(httpClient, tokenManager) {
+    this.tokenManager = tokenManager || new TokenManager(CookieUtils);
+    this.httpClient = httpClient || this.createDefaultHttpClient();
+  }
+  /**
+   * Create default HTTP client with configuration
+   */
+  createDefaultHttpClient() {
+    const config2 = {
+      baseURL: process.env.NEXT_PUBLIC_API_BASE_URL || "",
+      apiKeys: {
+        "x-api-key": process.env.NEXT_PUBLIC_API_KEY || ""
+      },
+      timeout: 3e4,
+      retries: 3,
+      origin: process.env.NEXT_PUBLIC_API_ORIGIN || "",
+      getAccessToken: async () => await this.tokenManager.getAccessToken()
+    };
+    return new HttpClient(config2);
+  }
+  /**
+   * Handle HTTP response and throw structured error if needed
+   */
+  handleResponse(response) {
+    if (response.ok) {
+      return response.data;
+    }
+    const apiError = this.createApiErrorFromResponse(response);
+    throw new ApiError(
+      apiError.message,
+      response.status,
+      response.statusText,
+      apiError
+    );
+  }
+  /**
+   * Create API error from HTTP response following Single Responsibility Principle
+   */
+  createApiErrorFromResponse(response) {
+    const parsedError = this.tryParseApiErrorResponse(response.data);
+    if (parsedError) {
+      return parsedError;
+    }
+    return this.createGenericApiError(response);
+  }
+  /**
+   * Try to parse API error response from response data
+   */
+  tryParseApiErrorResponse(data) {
+    try {
+      const responseData = data;
+      if (this.isValidApiErrorResponse(responseData)) {
+        return __spreadValues({
+          message: String(responseData.message),
+          error: String(responseData.error),
+          statusCode: Number(responseData.statusCode)
+        }, responseData);
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Check if response data has valid API error structure
+   */
+  isValidApiErrorResponse(data) {
+    return data && typeof data === "object" && "message" in data && "error" in data && "statusCode" in data;
+  }
+  /**
+   * Create generic API error as fallback
+   */
+  createGenericApiError(response) {
+    return {
+      message: response.statusText || "Unknown error",
+      error: "HTTP Error",
+      statusCode: response.status
+    };
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, headers) {
+    const response = await this.httpClient.request(endpoint, {
+      method: "GET" /* GET */,
+      url: endpoint,
+      headers
+    });
+    return this.handleResponse(response);
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body, headers) {
+    const response = await this.httpClient.request(endpoint, {
+      method: "POST" /* POST */,
+      url: endpoint,
+      headers,
+      body
+    });
+    return this.handleResponse(response);
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body, headers) {
+    const response = await this.httpClient.request(endpoint, {
+      method: "PUT" /* PUT */,
+      url: endpoint,
+      headers,
+      body
+    });
+    return this.handleResponse(response);
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint, headers) {
+    const response = await this.httpClient.request(endpoint, {
+      method: "DELETE" /* DELETE */,
+      url: endpoint,
+      headers
+    });
+    return this.handleResponse(response);
+  }
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, body, headers) {
+    const response = await this.httpClient.request(endpoint, {
+      method: "PATCH" /* PATCH */,
+      url: endpoint,
+      headers,
+      body
+    });
+    return this.handleResponse(response);
+  }
+};
+
+// src/services/api/endpoints.ts
+var AUTH_ENDPOINTS = {
+  // Email existence check
+  CHECK_EMAIL_EXISTS: (email) => `/auth/user/exist-email/${encodeURIComponent(email)}`,
+  // User authentication
+  LOGIN: "/auth/user/login",
+  VERIFY_EMAIL: "/auth/user/verify",
+  // User profile
+  GET_USER_PROFILE: "/auth/user/profile",
+  // User logout
+  LOGOUT: "/auth/logout"
+};
+var EndpointBuilder = class {
+};
+EndpointBuilder.auth = AUTH_ENDPOINTS;
+
+// src/services/api/auth-service.ts
+var AuthService = class extends BaseService {
+  /**
+   * Check if an email exists in the system
+   */
+  async checkEmailExists(email) {
+    const endpoint = AUTH_ENDPOINTS.CHECK_EMAIL_EXISTS(email);
+    return this.get(endpoint);
+  }
+  /**
+   * Login with email and password
+   */
+  async login(credentials) {
+    const endpoint = AUTH_ENDPOINTS.LOGIN;
+    return this.post(endpoint, credentials);
+  }
+  /**
+   * Verify email with verification code
+   */
+  async verifyEmail(verification) {
+    const endpoint = AUTH_ENDPOINTS.VERIFY_EMAIL;
+    return this.post(endpoint, verification);
+  }
+  /**
+   * Get user profile
+   */
+  async getUserProfile() {
+    const endpoint = AUTH_ENDPOINTS.GET_USER_PROFILE;
+    return this.get(endpoint);
+  }
+  /**
+   * Logout user
+   */
+  async logout() {
+    const endpoint = AUTH_ENDPOINTS.LOGOUT;
+    return this.post(endpoint);
+  }
+};
+
+// src/services/auth/manager/user-storage-manager.ts
+var UserStorageManager = class {
+  constructor(storageUtils) {
+    this.storageUtils = storageUtils;
+  }
+  /**
+   * Save user profile data to storage
+   */
+  saveUserProfile(userProfile) {
+    return this.storageUtils.saveUserProfile(userProfile);
+  }
+  /**
+   * Get user profile data from storage
+   */
+  getUserProfile(cacheDuration) {
+    return this.storageUtils.getUserProfile(cacheDuration);
+  }
+  /**
+   * Clear user profile data from storage
+   */
+  clearUserProfile() {
+    return this.storageUtils.clearUserProfile();
+  }
+  /**
+   * Check if cached user profile is still valid
+   */
+  isCacheValid(cacheDuration) {
+    return this.storageUtils.isCacheValid(cacheDuration);
+  }
+  /**
+   * Get user profile with automatic cache validation
+   * Returns null if cache is expired or invalid
+   */
+  getValidUserProfile(cacheDuration) {
+    if (!this.isCacheValid(cacheDuration)) {
+      return null;
+    }
+    return this.getUserProfile(cacheDuration);
+  }
+};
+
+// src/services/auth/patterns/command/auth-result-factory.ts
+var AuthResultFactory = class {
+  /**
+   * Creates a successful authentication result
+   */
+  static createSuccess(message2, data) {
+    return {
+      success: true,
+      data,
+      message: message2
+    };
+  }
+  /**
+   * Creates a failed authentication result
+   */
+  static createFailure(message2, error) {
+    const errorMessage = error instanceof Error ? error.message : typeof error === "string" ? error : error ? String(error) : "Authentication failed";
+    return {
+      success: false,
+      error: errorMessage,
+      message: message2
+    };
+  }
+};
+
+// src/services/auth/patterns/logger/development-logger.ts
+var DevelopmentLogger = class {
+  log(message2, data) {
+    console.log(message2, data);
+  }
+  warn(message2, data) {
+    console.warn(message2, data);
+  }
+  error(message2, data) {
+    console.error(message2, data);
+  }
+};
+
+// src/services/auth/patterns/logger/production-logger.ts
+var ProductionLogger = class {
+  log(_message, _data) {
+  }
+  warn(_message, _data) {
+  }
+  error(_message, _data) {
+  }
+};
+
+// src/services/auth/patterns/logger/logger-factory.ts
+var LoggerFactory = class {
+  static create(environment) {
+    const env = environment || process.env.NODE_ENV || "development";
+    const loggerFactory = this.loggers.get(env) || this.loggers.get("development");
+    return loggerFactory();
+  }
+};
+LoggerFactory.loggers = /* @__PURE__ */ new Map([
+  ["development", () => new DevelopmentLogger()],
+  ["production", () => new ProductionLogger()],
+  ["test", () => new DevelopmentLogger()]
+]);
+
+// src/services/auth/patterns/strategy/signup-flow-strategy.ts
+var SignupFlowStrategy = class {
+  constructor(authService, tokenManager) {
+    this.authService = authService;
+    this.tokenManager = tokenManager;
+  }
+  async execute(credentials) {
+    const loginResult = await this.authService.login(credentials);
+    if (!loginResult.data.isVerifiedEmail) {
+      return AuthResultFactory.createFailure("Email verification required");
+    }
+    return this.handleSuccessfulAuthentication(loginResult);
+  }
+  async handleSuccessfulAuthentication(loginResult) {
+    if (loginResult.data.accessToken) {
+      this.tokenManager.saveTokens(
+        loginResult.data.accessToken,
+        loginResult.data.refreshToken
+      );
+      LoggerFactory.create("development").log("Tokens saved successfully:", {
+        hasAccessToken: !!loginResult.data.accessToken,
+        hasRefreshToken: !!loginResult.data.refreshToken,
+        domainInfo: this.tokenManager.getDomainInfo()
+      });
+      const profile = await this.authService.getUserProfile();
+      return AuthResultFactory.createSuccess("Login successful", __spreadProps(__spreadValues({}, loginResult.data), {
+        profile: profile.data,
+        tokenInfo: {
+          domain: this.tokenManager.getDomainInfo().domain
+        }
+      }));
+    }
+    return AuthResultFactory.createFailure("Authentication failed - no access token received");
+  }
+};
+
+// src/services/auth/patterns/strategy/existing-user-login-strategy.ts
+var ExistingUserLoginStrategy = class {
+  constructor(authService, tokenManager) {
+    this.authService = authService;
+    this.tokenManager = tokenManager;
+  }
+  async execute(credentials) {
+    const loginResult = await this.authService.login(credentials);
+    return this.handleSuccessfulAuthentication(loginResult);
+  }
+  async handleSuccessfulAuthentication(loginResult) {
+    if (loginResult.data.accessToken) {
+      this.tokenManager.saveTokens(
+        loginResult.data.accessToken,
+        loginResult.data.refreshToken
+      );
+      LoggerFactory.create("development").log("Tokens saved successfully:", {
+        hasAccessToken: !!loginResult.data.accessToken,
+        hasRefreshToken: !!loginResult.data.refreshToken,
+        domainInfo: this.tokenManager.getDomainInfo()
+      });
+      const profile = await this.authService.getUserProfile();
+      return AuthResultFactory.createSuccess("Login successful", __spreadProps(__spreadValues({}, loginResult.data), {
+        profile: profile.data,
+        tokenInfo: {
+          domain: this.tokenManager.getDomainInfo().domain
+        }
+      }));
+    }
+    return AuthResultFactory.createFailure("Authentication failed - no access token received");
+  }
+};
+
+// src/services/auth/patterns/strategy/login-flow-strategy-factory.ts
+var LoginFlowStrategyFactory = class {
+  static createStrategy(action, authService, tokenManager) {
+    const strategyFactory = this.strategies.get(action);
+    if (!strategyFactory) {
+      throw new Error(`No strategy found for action: ${action}`);
+    }
+    return strategyFactory(authService, tokenManager);
+  }
+};
+LoginFlowStrategyFactory.strategies = /* @__PURE__ */ new Map([
+  ["signup" /* SIGNUP */, (authService, tokenManager) => new SignupFlowStrategy(authService, tokenManager)],
+  ["login" /* LOGIN */, (authService, tokenManager) => new ExistingUserLoginStrategy(authService, tokenManager)]
+]);
+
+// src/services/auth/patterns/state/authenticated-state.ts
+var AuthenticatedState = class {
+  async getStatus(tokenManager) {
+    const authStatus = await this.buildAuthStatus(tokenManager, true);
+    return AuthResultFactory.createSuccess("User is authenticated", authStatus);
+  }
+  async buildAuthStatus(tokenManager, isAuthenticated) {
+    return {
+      isAuthenticated,
+      hasAccessToken: !!await tokenManager.getAccessToken(),
+      hasRefreshToken: !!await tokenManager.getRefreshToken(),
+      cookiesSupported: tokenManager.areCookiesSupported(),
+      domainInfo: tokenManager.getDomainInfo()
+    };
+  }
+};
+
+// src/services/auth/patterns/state/unauthenticated-state.ts
+var UnauthenticatedState = class {
+  async getStatus(tokenManager) {
+    const authStatus = await this.buildAuthStatus(tokenManager, false);
+    return AuthResultFactory.createFailure("User is not authenticated", authStatus);
+  }
+  async buildAuthStatus(tokenManager, isAuthenticated) {
+    return {
+      isAuthenticated,
+      hasAccessToken: !!await tokenManager.getAccessToken(),
+      hasRefreshToken: !!await tokenManager.getRefreshToken(),
+      cookiesSupported: tokenManager.areCookiesSupported(),
+      domainInfo: tokenManager.getDomainInfo()
+    };
+  }
+};
+
+// src/services/auth/patterns/state/authentication-status-context.ts
+var AuthenticationStatusContext = class {
+  static async getStatus(tokenManager) {
+    const isAuthenticated = !!await tokenManager.getAccessToken();
+    const state = this.states.get(isAuthenticated) || new UnauthenticatedState();
+    return await state.getStatus(tokenManager);
+  }
+};
+AuthenticationStatusContext.states = /* @__PURE__ */ new Map([
+  [true, new AuthenticatedState()],
+  [false, new UnauthenticatedState()]
+]);
+
+// src/services/auth/patterns/chain/base-error-handler.ts
+var BaseErrorHandler = class {
+  setNext(handler) {
+    this.nextHandler = handler;
+    return handler;
+  }
+  handle(error, context) {
+    if (this.canHandle(error)) {
+      return this.handleError(error, context);
+    }
+    if (this.nextHandler) {
+      return this.nextHandler.handle(error, context);
+    }
+    return AuthResultFactory.createFailure(`${context} failed with unknown error`, error);
+  }
+};
+
+// src/services/auth/patterns/chain/validation-error-handler.ts
+var ValidationErrorHandler = class extends BaseErrorHandler {
+  canHandle(error) {
+    return error instanceof Error && error.message.includes("validation");
+  }
+  handleError(error, context) {
+    console.error(`${context} validation error:`, error);
+    return AuthResultFactory.createFailure(`${context} validation failed`, error);
+  }
+};
+
+// src/services/auth/patterns/chain/network-error-handler.ts
+var NetworkErrorHandler = class extends BaseErrorHandler {
+  canHandle(error) {
+    return error instanceof Error && (error.message.includes("network") || error.message.includes("fetch") || error.message.includes("timeout"));
+  }
+  handleError(error, context) {
+    console.error(`${context} network error:`, error);
+    return AuthResultFactory.createFailure(`${context} network error`, error);
+  }
+};
+
+// src/services/auth/patterns/chain/generic-error-handler.ts
+var GenericErrorHandler = class extends BaseErrorHandler {
+  canHandle(_error) {
+    return true;
+  }
+  handleError(error, context) {
+    console.error(`${context} error:`, error);
+    return AuthResultFactory.createFailure(`${context} failed`, error);
+  }
+};
+
+// src/services/auth/auth-orchestrator.ts
+var AuthOrchestrator = class {
+  constructor(authService, eventBus, tokenManager) {
+    this.authService = authService;
+    this.eventBus = eventBus;
+    this.tokenManager = tokenManager || new TokenManager(CookieUtils);
+    this.userStorageManager = new UserStorageManager(LocalStorageUtils);
+    this.logger = LoggerFactory.create();
+    this.errorHandler = this.setupErrorHandlerChain();
+    this.validateCookieSupport();
+  }
+  /**
+   * Setup Chain of Responsibility for error handling
+   */
+  setupErrorHandlerChain() {
+    const validationHandler = new ValidationErrorHandler();
+    const networkHandler = new NetworkErrorHandler();
+    const genericHandler = new GenericErrorHandler();
+    validationHandler.setNext(networkHandler).setNext(genericHandler);
+    return validationHandler;
+  }
+  /**
+   * Validate that cookies are supported in the current environment
+   */
+  validateCookieSupport() {
+    if (!this.tokenManager.areCookiesSupported()) {
+      this.logger.warn("Cookies are not supported in this environment. Authentication may not work properly.");
+    }
+  }
+  /**
+   * Handle email check to determine if user exists and what action to take
+   */
+  async handleEmailCheck(email) {
+    try {
+      const emailCheck = await this.authService.checkEmailExists(email);
+      const message2 = {
+        ["signup" /* SIGNUP */]: "Welcome! Please create your account.",
+        ["login" /* LOGIN */]: "Welcome back! Please enter your password.",
+        ["login-verification" /* LOGIN_VERIFICATION */]: "Please verify your email."
+      }[emailCheck.next_action];
+      if (!message2) {
+        throw new Error("Invalid next action");
+      }
+      return AuthResultFactory.createSuccess(message2, emailCheck);
+    } catch (error) {
+      return this.errorHandler.handle(error, "Email check");
+    }
+  }
+  /**
+   * Handle complete login flow with proper error handling and token management
+   */
+  async handleLoginFlow(credentials) {
+    try {
+      const emailCheck = await this.authService.checkEmailExists(credentials.email);
+      const strategy = LoginFlowStrategyFactory.createStrategy(
+        emailCheck.next_action,
+        this.authService,
+        this.tokenManager
+      );
+      const result = await strategy.execute(credentials);
+      if (result.success) {
+        const currentPageType = CrossTabBehaviorHandler.getCurrentPageType();
+        this.eventBus.publish({
+          type: "auth.logged_in" /* LoggedIn */,
+          userId: String(result.data.profile.user._id),
+          sourcePageType: currentPageType
+        });
+      }
+      return result;
+    } catch (error) {
+      return this.errorHandler.handle(error, "Login flow");
+    }
+  }
+  /**
+   * Handle email verification flow
+   */
+  async handleEmailVerification(email, code) {
+    var _a;
+    try {
+      const verificationRequest = { email, code };
+      const verificationResult = await this.authService.verifyEmail(verificationRequest);
+      const isVerified = verificationResult === true || ((_a = verificationResult == null ? void 0 : verificationResult.data) == null ? void 0 : _a.isVerified);
+      if (isVerified) {
+        this.eventBus.publish({ type: "auth.email_verified" /* EmailVerified */, email });
+        return AuthResultFactory.createSuccess("Email verified successfully", { isVerified: true });
+      }
+      return AuthResultFactory.createFailure("Email verification failed", "Email verification failed");
+    } catch (error) {
+      return this.errorHandler.handle(error, "Email verification");
+    }
+  }
+  /**
+   * Handle logout flow
+   */
+  async handleLogout() {
+    let tokenInfo = {};
+    try {
+      tokenInfo = await this.tokenManager.getAllTokens();
+      await this.authService.logout();
+      return AuthResultFactory.createSuccess("Logout successful", {
+        clearedTokens: Object.keys(tokenInfo).filter((key) => tokenInfo[key])
+      });
+    } catch (error) {
+      return this.errorHandler.handle(error, "Logout");
+    } finally {
+      this.tokenManager.clearTokens();
+      this.userStorageManager.clearUserProfile();
+      const currentPageType = CrossTabBehaviorHandler.getCurrentPageType();
+      this.eventBus.publish({
+        type: "auth.logged_out" /* LoggedOut */,
+        sourcePageType: currentPageType
+      });
+      this.logger.log("Logout cleanup completed:", {
+        clearedTokens: Object.keys(tokenInfo).filter((key) => tokenInfo[key]),
+        domainInfo: this.tokenManager.getDomainInfo()
+      });
+    }
+  }
+  /**
+   * Check current authentication status using State Pattern
+   */
+  async checkAuthenticationStatus() {
+    try {
+      return AuthenticationStatusContext.getStatus(this.tokenManager);
+    } catch (error) {
+      return this.errorHandler.handle(error, "Authentication status check");
+    }
+  }
+  /**
+   * Get user profile data
+   */
+  async getUserProfileData() {
+    try {
+      const hasAccessToken = !!await this.tokenManager.getAccessToken();
+      if (!hasAccessToken) {
+        return AuthResultFactory.createFailure("User not authenticated");
+      }
+      const profile = await this.authService.getUserProfile();
+      return AuthResultFactory.createSuccess("Profile retrieved successfully", profile.data);
+    } catch (error) {
+      return this.errorHandler.handle(error, "Get user profile");
+    }
+  }
+  /**
+   * Get detailed token information
+   */
+  async getTokenInfo() {
+    try {
+      const accessToken = await this.tokenManager.getAccessToken();
+      const refreshToken = await this.tokenManager.getRefreshToken();
+      const allTokens = await this.tokenManager.getAllTokens();
+      const domainInfo = this.tokenManager.getDomainInfo();
+      const cookiesSupported = this.tokenManager.areCookiesSupported();
+      const tokenInfo = {
+        hasAccessToken: !!accessToken,
+        hasRefreshToken: !!refreshToken,
+        cookiesSupported,
+        domainInfo,
+        tokenCount: Object.keys(allTokens).filter((key) => allTokens[key]).length,
+        environment: process.env.NODE_ENV || "unknown"
+      };
+      return AuthResultFactory.createSuccess("Token information retrieved", tokenInfo);
+    } catch (error) {
+      return this.errorHandler.handle(error, "Get token info");
+    }
+  }
+};
+var AuthOrchestratorFactory = class {
+  /**
+   * Create AuthOrchestrator with default dependencies
+   */
+  static create() {
+    const authService = new AuthService();
+    const eventBus = BroadcastChannelEventBus.getInstance("auth-event-channel" /* AUTH */);
+    return new AuthOrchestrator(authService, eventBus);
+  }
+  /**
+   * Create AuthOrchestrator with custom dependencies
+   */
+  static createWithDependencies(authService, eventBus, tokenManager) {
+    return new AuthOrchestrator(authService, eventBus, tokenManager);
+  }
+};
+
+// src/store/user-store.ts
+var ERROR_MESSAGES = {
+  UNEXPECTED_ERROR: "An unexpected error occurred"
+};
+var useUserStore = create()(
+  devtools(
+    subscribeWithSelector(
+      immer((set, get) => {
+        const authOrchestrator = AuthOrchestratorFactory.create();
+        const userStorageManager = new UserStorageManager(LocalStorageUtils);
+        return {
+          // Initial state
+          user: null,
+          isLoading: false,
+          error: null,
+          isAuthenticated: false,
+          // Dependencies
+          _authOrchestrator: authOrchestrator,
+          _userStorageManager: userStorageManager,
+          // Actions
+          setUser: (user) => {
+            const { _userStorageManager } = get();
+            if (user) {
+              _userStorageManager.saveUserProfile(user);
+            } else {
+              _userStorageManager.clearUserProfile();
+            }
+            set((state) => {
+              state.user = user;
+              state.isAuthenticated = !!user;
+              state.error = null;
+            });
+          },
+          setLoading: (loading) => {
+            set((state) => {
+              state.isLoading = loading;
+            });
+          },
+          setError: (error) => {
+            set((state) => {
+              state.error = error;
+              state.isLoading = false;
+            });
+          },
+          clearUser: async () => {
+            const { _authOrchestrator } = get();
+            set((state) => {
+              state.isLoading = true;
+            });
+            try {
+              await _authOrchestrator.handleLogout();
+            } catch (error) {
+              console.error("Error during logout cleanup:", error);
+            } finally {
+              set((state) => {
+                state.user = null;
+                state.isLoading = false;
+                state.error = null;
+                state.isAuthenticated = false;
+              });
+            }
+          },
+          refreshUser: async (forceRefresh = false) => {
+            const { _authOrchestrator, _userStorageManager } = get();
+            const cachedUser = !forceRefresh ? _userStorageManager.getValidUserProfile() : null;
+            if (cachedUser) {
+              set((state) => {
+                state.user = cachedUser;
+                state.isAuthenticated = true;
+                state.isLoading = false;
+                state.error = null;
+              });
+              return;
+            }
+            set((state) => {
+              state.isLoading = true;
+              state.error = null;
+            });
+            try {
+              const result = await _authOrchestrator.getUserProfileData();
+              if (result.success) {
+                const userProfile = result.data;
+                _userStorageManager.saveUserProfile(userProfile);
+                set((state) => {
+                  state.user = userProfile;
+                  state.isAuthenticated = true;
+                  state.isLoading = false;
+                  state.error = null;
+                });
+              } else {
+                set((state) => {
+                  state.user = null;
+                  state.isAuthenticated = false;
+                  state.isLoading = false;
+                  state.error = result.error;
+                });
+              }
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : ERROR_MESSAGES.UNEXPECTED_ERROR;
+              set((state) => {
+                state.user = null;
+                state.isAuthenticated = false;
+                state.isLoading = false;
+                state.error = errorMessage;
+              });
+            }
+          }
+        };
+      })
+    ),
+    {
+      name: "user-store",
+      // Only serialize state for devtools, not the internal dependencies
+      serialize: {
+        options: {
+          map: (state) => ({
+            user: state.user,
+            isLoading: state.isLoading,
+            error: state.error,
+            isAuthenticated: state.isAuthenticated
+          })
+        }
+      }
+    }
+  )
+);
+var userSelectors = {
+  // User data selectors (single values don't need shallow comparison)
+  useUser: () => useUserStore((state) => state.user),
+  useIsAuthenticated: () => useUserStore((state) => state.isAuthenticated),
+  useIsLoading: () => useUserStore((state) => state.isLoading),
+  useError: () => useUserStore((state) => state.error),
+  // Combined selectors for common use cases (using useShallow to prevent unnecessary re-renders)
+  useUserState: () => useUserStore(
+    useShallow((state) => ({
+      user: state.user,
+      isAuthenticated: state.isAuthenticated,
+      isLoading: state.isLoading,
+      error: state.error
+    }))
+  ),
+  // Actions selectors (using useShallow for stable object reference)
+  useActions: () => useUserStore(
+    useShallow((state) => ({
+      setUser: state.setUser,
+      setLoading: state.setLoading,
+      setError: state.setError,
+      clearUser: state.clearUser,
+      refreshUser: state.refreshUser
+    }))
+  )
+};
+
+// src/components/auth/auth-flow-container.tsx
+import { useState as useState4 } from "react";
+import { Steps, Row, Col, Button as Button5, Image, Typography as Typography2, Spin as Spin2, message, Space as Space2, Flex as Flex3 } from "antd";
+import { ArrowLeftOutlined as ArrowLeftOutlined3 } from "@ant-design/icons";
+
+// src/hooks/useAuthActionHandler.ts
+import { useState, useCallback } from "react";
+var useAuthActionHandler = () => {
+  const [state, setState] = useState({
+    isLoading: false,
+    error: null,
+    success: null
+  });
+  const transformError = useCallback((error) => {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    return "An unexpected error occurred";
+  }, []);
+  const clearError = useCallback(() => {
+    setState((prev) => __spreadProps(__spreadValues({}, prev), { error: null }));
+  }, []);
+  const clearSuccess = useCallback(() => {
+    setState((prev) => __spreadProps(__spreadValues({}, prev), { success: null }));
+  }, []);
+  const clearAll = useCallback(() => {
+    setState((prev) => __spreadProps(__spreadValues({}, prev), { error: null, success: null }));
+  }, []);
+  const setSuccess = useCallback((message2) => {
+    setState((prev) => __spreadProps(__spreadValues({}, prev), { success: message2, error: null }));
+  }, []);
+  const setError = useCallback((error) => {
+    setState((prev) => __spreadProps(__spreadValues({}, prev), { error, success: null }));
+  }, []);
+  const executeAction = useCallback(async (action, options = {}) => {
+    const {
+      clearStatesBeforeAction = true,
+      preserveSuccessOnError = false,
+      onSuccess,
+      onError
+    } = options;
+    if (clearStatesBeforeAction) {
+      setState((prev) => __spreadProps(__spreadValues({}, prev), {
+        isLoading: true,
+        error: null,
+        success: preserveSuccessOnError ? prev.success : null
+      }));
+    } else {
+      setState((prev) => __spreadProps(__spreadValues({}, prev), { isLoading: true }));
+    }
+    try {
+      const result = await action();
+      if (result.success) {
+        const successMessage = result.message || "";
+        setState((prev) => __spreadProps(__spreadValues({}, prev), {
+          isLoading: false,
+          error: null,
+          success: successMessage
+        }));
+        onSuccess == null ? void 0 : onSuccess(result.data, successMessage, result);
+        return result;
+      } else {
+        const errorMessage = result.message || "Action failed";
+        setState((prev) => __spreadProps(__spreadValues({}, prev), {
+          isLoading: false,
+          error: errorMessage,
+          success: preserveSuccessOnError ? prev.success : null
+        }));
+        onError == null ? void 0 : onError(errorMessage);
+        return null;
+      }
+    } catch (error) {
+      const errorMessage = transformError(error);
+      setState((prev) => __spreadProps(__spreadValues({}, prev), {
+        isLoading: false,
+        error: errorMessage,
+        success: preserveSuccessOnError ? prev.success : null
+      }));
+      onError == null ? void 0 : onError(errorMessage);
+      return null;
+    }
+  }, [transformError]);
+  return {
+    state,
+    executeAction,
+    clearError,
+    clearSuccess,
+    clearAll,
+    setSuccess,
+    setError
+  };
+};
+
+// src/hooks/useStepper.ts
+import { useState as useState2, useCallback as useCallback2, useMemo } from "react";
+var useStepper = (config2) => {
+  const { steps, initialStep } = config2;
+  if (!steps || steps.length === 0) {
+    throw new Error("useStepper: steps array cannot be empty");
+  }
+  const firstStepId = initialStep || steps[0].id;
+  const [currentStep, setCurrentStep] = useState2(firstStepId);
+  const currentStepIndex = useMemo(() => {
+    return steps.findIndex((step) => step.id === currentStep);
+  }, [steps, currentStep]);
+  const isFirstStep = useMemo(() => currentStepIndex === 0, [currentStepIndex]);
+  const isLastStep = useMemo(() => currentStepIndex === steps.length - 1, [currentStepIndex, steps.length]);
+  const progress = useMemo(() => {
+    return steps.length > 0 ? (currentStepIndex + 1) / steps.length : 0;
+  }, [currentStepIndex, steps.length]);
+  const getStepIndex = useCallback2((step) => {
+    return steps.findIndex((s) => s.id === step);
+  }, [steps]);
+  const getStepByIndex = useCallback2((index) => {
+    return steps[index];
+  }, [steps]);
+  const isStepValid = useCallback2((step) => {
+    const stepIndex = getStepIndex(step);
+    if (stepIndex === -1) return false;
+    const stepConfig = steps[stepIndex];
+    return !stepConfig.disabled;
+  }, [steps, getStepIndex]);
+  const getProgressPercentage = useCallback2(() => {
+    return Math.round(progress * 100);
+  }, [progress]);
+  const goToStep = useCallback2((step) => {
+    const stepIndex = getStepIndex(step);
+    if (stepIndex === -1) {
+      console.warn(`useStepper: Step not found: ${step}`);
+      return;
+    }
+    setCurrentStep(step);
+  }, [getStepIndex]);
+  const goToNext = useCallback2(() => {
+    if (isLastStep) {
+      console.warn("useStepper: Already at the last step");
+      return;
+    }
+    const nextIndex = currentStepIndex + 1;
+    const nextStep = getStepByIndex(nextIndex);
+    if (nextStep) {
+      setCurrentStep(nextStep.id);
+    }
+  }, [isLastStep, currentStepIndex, getStepByIndex]);
+  const goToPrevious = useCallback2(() => {
+    if (isFirstStep) {
+      console.warn("useStepper: Already at the first step");
+      return;
+    }
+    const prevIndex = currentStepIndex - 1;
+    const prevStep = getStepByIndex(prevIndex);
+    if (prevStep) {
+      setCurrentStep(prevStep.id);
+    }
+  }, [isFirstStep, currentStepIndex, getStepByIndex]);
+  const goToIndex = useCallback2((index) => {
+    const step = getStepByIndex(index);
+    if (step) {
+      goToStep(step.id);
+    } else {
+      console.warn(`useStepper: Invalid step index: ${index}`);
+    }
+  }, [getStepByIndex, goToStep]);
+  const reset = useCallback2(() => {
+    setCurrentStep(firstStepId);
+  }, [firstStepId]);
+  return {
+    state: {
+      currentStep,
+      currentStepIndex,
+      steps,
+      isFirstStep,
+      isLastStep,
+      progress
+    },
+    actions: {
+      goToStep,
+      goToNext,
+      goToPrevious,
+      goToIndex,
+      reset
+    },
+    helpers: {
+      getStepIndex,
+      getStepByIndex,
+      isStepValid,
+      getProgressPercentage
+    }
+  };
+};
+
+// src/hooks/useStepRegistry.ts
+import { useMemo as useMemo2 } from "react";
+
+// src/components/auth/step-renderer.tsx
+import React from "react";
+
+// src/components/auth/email-step.tsx
+import { Button as Button2, Divider, Flex as Flex2 } from "antd";
+import { GoogleOutlined } from "@ant-design/icons";
+
+// src/components/auth/base-form.tsx
+import { Form as Form2, Button, Spin, Space } from "antd";
+
+// src/components/auth/alert-display.tsx
+import { Alert } from "antd";
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var AlertDisplay = ({ error, success }) => {
+  if (!error && !success) return null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    error ? /* @__PURE__ */ jsx3(Alert, { message: error, type: "error", showIcon: true, className: "mb-6" }) : null,
+    success ? /* @__PURE__ */ jsx3(Alert, { message: success, type: "success", showIcon: true, className: "mb-6" }) : null
+  ] });
+};
+
+// src/components/auth/form-header.tsx
+import { Flex, Typography } from "antd";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var { Title, Paragraph } = Typography;
+var FormHeader = ({ title, description }) => /* @__PURE__ */ jsxs2(Flex, { vertical: true, align: "center", className: "mb-6", children: [
+  /* @__PURE__ */ jsx4(Title, { level: 2, className: "mb-2", children: title }),
+  description && /* @__PURE__ */ jsx4(Paragraph, { className: "text-gray-600 text-center", children: description })
+] });
+
+// src/components/auth/form-fields.tsx
+import { Form } from "antd";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var FormFields = ({ fields }) => fields.map((_a) => {
+  var _b = _a, { component } = _b, formItemProps = __objRest(_b, ["component"]);
+  return /* @__PURE__ */ jsx5(Form.Item, __spreadProps(__spreadValues({}, formItemProps), { children: component }), formItemProps.name);
+});
+
+// src/components/auth/base-form.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var BaseForm = ({
+  title,
+  description,
+  fields,
+  submitButtonText,
+  onSubmit,
+  isLoading = false,
+  error,
+  success,
+  form,
+  additionalActions,
+  showAlerts = true,
+  initialValues
+}) => {
+  const [formInstance] = Form2.useForm();
+  const activeForm = form || formInstance;
+  const handleSubmit = async (values) => {
+    try {
+      await onSubmit(values);
+    } catch (error2) {
+      console.error("Form submission error:", error2);
+    }
+  };
+  return /* @__PURE__ */ jsxs3(Space, { direction: "vertical", size: "large", className: "w-full max-w-md", children: [
+    /* @__PURE__ */ jsx6(FormHeader, { title, description }),
+    showAlerts && /* @__PURE__ */ jsx6(AlertDisplay, { error, success }),
+    /* @__PURE__ */ jsx6(Spin, { spinning: isLoading, tip: "Processing...", children: /* @__PURE__ */ jsxs3(
+      Form2,
+      {
+        form: activeForm,
+        onFinish: handleSubmit,
+        layout: "vertical",
+        size: "large",
+        initialValues,
+        className: "w-full",
+        children: [
+          /* @__PURE__ */ jsx6(FormFields, { fields }),
+          /* @__PURE__ */ jsx6(Form2.Item, { children: /* @__PURE__ */ jsx6(
+            Button,
+            {
+              type: "primary",
+              htmlType: "submit",
+              loading: isLoading,
+              block: true,
+              size: "large",
+              children: submitButtonText
+            }
+          ) }),
+          additionalActions
+        ]
+      }
+    ) })
+  ] });
+};
+
+// src/components/auth/email-step.tsx
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var EmailStep = ({
+  title,
+  description,
+  onSubmit,
+  onGoogleSignIn,
+  onForgotPassword,
+  isLoading = false,
+  error,
+  success,
+  showGoogleButton = true,
+  showForgotPassword = true,
+  initialValues
+}) => {
+  const handleSubmit = async (values) => {
+    await onSubmit(values.email);
+  };
+  const fields = [getEmailField({ disabled: isLoading })];
+  const additionalActions = /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    showGoogleButton && /* @__PURE__ */ jsxs4(Fragment2, { children: [
+      /* @__PURE__ */ jsx7(Divider, { children: "OR" }),
+      /* @__PURE__ */ jsx7(
+        Button2,
+        {
+          icon: /* @__PURE__ */ jsx7(GoogleOutlined, {}),
+          onClick: onGoogleSignIn,
+          block: true,
+          size: "large",
+          className: "mb-4",
+          disabled: isLoading,
+          children: "Sign-in with Google"
+        }
+      )
+    ] }),
+    showForgotPassword && /* @__PURE__ */ jsx7(Flex2, { justify: "end", children: /* @__PURE__ */ jsx7(
+      Button2,
+      {
+        type: "link",
+        className: "px-0",
+        onClick: onForgotPassword,
+        disabled: isLoading,
+        children: "Forgot Password ?"
+      }
+    ) })
+  ] });
+  return /* @__PURE__ */ jsx7(
+    BaseForm,
+    {
+      title,
+      description,
+      fields,
+      submitButtonText: "Next",
+      onSubmit: handleSubmit,
+      isLoading,
+      error,
+      success,
+      additionalActions,
+      initialValues
+    }
+  );
+};
+
+// src/components/auth/password-step.tsx
+import { Button as Button3 } from "antd";
+import { ArrowLeftOutlined } from "@ant-design/icons";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var PasswordStep = ({
+  title,
+  description,
+  mode,
+  email,
+  onSubmit,
+  onBack,
+  isLoading = false,
+  error,
+  success,
+  showEmailField = true,
+  showBackButton = true,
+  submitButtonText,
+  initialValues
+}) => {
+  const handleSubmit = async (values) => {
+    await onSubmit(values.password);
+  };
+  const fields = [];
+  if (showEmailField) {
+    fields.push(getEmailField({ readOnly: true, value: email }));
+  }
+  fields.push(getPasswordField(mode === "login" /* LOGIN */, isLoading));
+  const additionalActions = showBackButton ? /* @__PURE__ */ jsx8(
+    Button3,
+    {
+      icon: /* @__PURE__ */ jsx8(ArrowLeftOutlined, {}),
+      onClick: onBack,
+      type: "link",
+      block: true,
+      disabled: isLoading,
+      children: "Use different email"
+    }
+  ) : null;
+  return /* @__PURE__ */ jsx8(
+    BaseForm,
+    {
+      title,
+      description,
+      fields,
+      submitButtonText,
+      onSubmit: handleSubmit,
+      isLoading,
+      error,
+      success,
+      additionalActions,
+      initialValues
+    }
+  );
+};
+
+// src/components/auth/verification-step.tsx
+import { Button as Button4 } from "antd";
+import { ArrowLeftOutlined as ArrowLeftOutlined2 } from "@ant-design/icons";
+import { Fragment as Fragment3, jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var VerificationStep = ({
+  title,
+  description,
+  onSubmit,
+  onBack,
+  onResendCode,
+  submitButtonText,
+  isLoading = false,
+  error,
+  success,
+  codeLength = 5,
+  showBackButton = true,
+  showResendButton = true,
+  initialValues
+}) => {
+  const handleSubmit = async (values) => {
+    await onSubmit(values.verificationCode);
+  };
+  const fields = [
+    getVerificationField(codeLength, { disabled: isLoading })
+  ];
+  const additionalActions = /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    showResendButton && /* @__PURE__ */ jsx9(
+      Button4,
+      {
+        type: "link",
+        onClick: onResendCode,
+        disabled: isLoading,
+        block: true,
+        className: "mb-2",
+        children: "Resend verification code"
+      }
+    ),
+    showBackButton && /* @__PURE__ */ jsx9(
+      Button4,
+      {
+        icon: /* @__PURE__ */ jsx9(ArrowLeftOutlined2, {}),
+        onClick: onBack,
+        type: "link",
+        block: true,
+        disabled: isLoading,
+        children: "Back to password"
+      }
+    )
+  ] });
+  return /* @__PURE__ */ jsx9(
+    BaseForm,
+    {
+      title,
+      description,
+      fields,
+      submitButtonText,
+      onSubmit: handleSubmit,
+      isLoading,
+      error,
+      success,
+      additionalActions,
+      initialValues
+    }
+  );
+};
+
+// src/components/auth/step-renderer.tsx
+var getEmailStepComponent = EmailStep;
+var getPasswordStepComponent = PasswordStep;
+var getVerificationStepComponent = VerificationStep;
+var createStepRegistry = () => ({
+  ["email" /* EMAIL */]: getEmailStepComponent,
+  ["password" /* PASSWORD */]: getPasswordStepComponent,
+  ["verification" /* VERIFICATION */]: getVerificationStepComponent
+});
+var createPropsFactoryRegistry = ({
+  baseProps,
+  handlers,
+  state,
+  configs
+}) => ({
+  ["email" /* EMAIL */]: () => __spreadProps(__spreadValues({}, baseProps), {
+    title: "Sign In/Sign Up",
+    description: "If you are an existing user, you will be signed in to your account. If you are a new user, an account will be created for you.",
+    submitButtonText: "Continue",
+    onSubmit: handlers.handleEmailSubmit,
+    onGoogleSignIn: handlers.onGoogleSignIn,
+    onForgotPassword: handlers.onForgotPassword,
+    showGoogleButton: configs.emailStepConfig.showGoogleButton,
+    showForgotPassword: configs.emailStepConfig.showForgotPassword
+  }),
+  ["password" /* PASSWORD */]: () => __spreadProps(__spreadValues({}, baseProps), {
+    title: state.authIntent === "login" /* LOGIN */ ? "Welcome Back" : "Create Account",
+    description: state.authIntent === "login" /* LOGIN */ ? "Please enter your password to sign in" : "Please create a password for your account",
+    submitButtonText: state.authIntent === "login" /* LOGIN */ ? "Sign In" : "Create Account",
+    mode: state.authIntent,
+    email: state.email,
+    onSubmit: handlers.handlePasswordSubmit,
+    onBack: handlers.goBackToEmail,
+    showEmailField: configs.passwordStepConfig.showEmailField
+  }),
+  ["verification" /* VERIFICATION */]: () => __spreadProps(__spreadValues({}, baseProps), {
+    title: "Email Verification",
+    description: `Please enter the verification code sent to ${state.email}`,
+    submitButtonText: "Verify Email",
+    email: state.email,
+    onSubmit: handlers.handleVerificationSubmit,
+    onBack: handlers.goBackToPassword,
+    onResendCode: handlers.handleResendCode,
+    codeLength: configs.verificationStepConfig.codeLength,
+    showResendButton: configs.verificationStepConfig.showResendButton
+  })
+});
+var useStepRenderer = () => {
+  const registry = React.useMemo(() => createStepRegistry(), []);
+  const getStepComponent = React.useCallback((step) => {
+    return registry[step] || null;
+  }, [registry]);
+  return { getStepComponent };
+};
+
+// src/hooks/useStepRegistry.ts
+function useStepRegistry({
+  baseProps: actionState,
+  handlers,
+  state,
+  configs,
+  getStepComponent,
+  stepperState
+}) {
+  const baseProps = useMemo2(
+    () => ({
+      isLoading: actionState.isLoading,
+      error: actionState.error,
+      success: actionState.success
+    }),
+    [actionState]
+  );
+  const registryParams = useMemo2(
+    () => ({ baseProps, handlers, state, configs }),
+    [baseProps, handlers, state, configs]
+  );
+  const propsFactoryRegistry = useMemo2(
+    () => createPropsFactoryRegistry(registryParams),
+    [registryParams]
+  );
+  const currentStep = stepperState.currentStep;
+  const SelectedComponent = getStepComponent(currentStep);
+  const stepProps = useMemo2(() => {
+    const factory = propsFactoryRegistry[currentStep];
+    if (!factory) {
+      console.warn(`No props factory found for step: ${currentStep}`);
+      return baseProps;
+    }
+    return factory();
+  }, [propsFactoryRegistry, currentStep, baseProps]);
+  return { SelectedComponent, stepProps };
+}
+
+// src/hooks/useAuthEventBus.ts
+import { useEffect } from "react";
+
+// src/hooks/useSharedEventBus.ts
+import { useMemo as useMemo3 } from "react";
+function useSharedEventBus() {
+  return useMemo3(() => BroadcastChannelEventBus.getInstance("auth-event-channel" /* AUTH */), []);
+}
+
+// src/hooks/useAuthEventBus.ts
+var useAuthEventBus = ({ onLoggedOut, onLoggedIn } = {}) => {
+  const eventBus = useSharedEventBus();
+  useEffect(() => {
+    const handleEvent = (e) => {
+      var _a;
+      const currentPageType = CrossTabBehaviorHandler.getCurrentPageType();
+      const eventHandlers = {
+        ["auth.logged_out" /* LoggedOut */]: onLoggedOut,
+        ["auth.logged_in" /* LoggedIn */]: onLoggedIn,
+        ["auth.email_verified" /* EmailVerified */]: void 0,
+        ["auth.signin_required_modal" /* SignInRequiredModal */]: void 0
+      };
+      const handler = eventHandlers[e.type];
+      const action = CrossTabBehaviorHandler.getAction(currentPageType, e.type);
+      const actionHandlers = {
+        ["redirect" /* REDIRECT */]: () => {
+          const target = CrossTabBehaviorHandler.shouldRedirect(currentPageType, e.type);
+          if (target) {
+            window.location.replace(target);
+          }
+        },
+        ["modal" /* MODAL */]: () => {
+          if (e.type === "auth.logged_in" /* LoggedIn */) {
+            window.location.replace(window.location.href);
+          }
+        },
+        ["none" /* NONE */]: () => {
+        }
+      };
+      (_a = actionHandlers[action.action]) == null ? void 0 : _a.call(actionHandlers);
+      handler == null ? void 0 : handler();
+    };
+    const subscription = eventBus.subscribe(handleEvent);
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [eventBus, onLoggedOut, onLoggedIn]);
+};
+
+// src/hooks/useSignInRequiredParams.ts
+import { useEffect as useEffect2 } from "react";
+import { useSearchParams } from "next/navigation";
+function useSignInRequiredParams() {
+  const searchParams = useSearchParams();
+  const eventBus = useSharedEventBus();
+  useEffect2(() => {
+    const signInRequired = searchParams.get(MiddlewareConfig.QUERY_PARAMS.LOGIN_REQUIRED);
+    const authChecked = searchParams.get(MiddlewareConfig.QUERY_PARAMS.AUTH_CHECKED);
+    if (signInRequired === MiddlewareConfig.QUERY_VALUES.LOGIN_REQUIRED && authChecked === MiddlewareConfig.QUERY_VALUES.AUTH_CHECKED) {
+      const currentPageType = CrossTabBehaviorHandler.getCurrentPageType();
+      eventBus.publish({
+        type: "auth.signin_required_modal" /* SignInRequiredModal */,
+        sourcePageType: currentPageType
+      });
+    }
+  }, [eventBus, searchParams]);
+}
+
+// src/hooks/use-user.ts
+import { useEffect as useEffect3 } from "react";
+var useUser = () => {
+  const userState = userSelectors.useUserState();
+  const actions = userSelectors.useActions();
+  return __spreadValues(__spreadValues({}, userState), actions);
+};
+var useUserData = () => {
+  return userSelectors.useUserState();
+};
+var useUserActions = () => {
+  return userSelectors.useActions();
+};
+var useAuth = () => {
+  const isAuthenticated = userSelectors.useIsAuthenticated();
+  const isLoading = userSelectors.useIsLoading();
+  const error = userSelectors.useError();
+  const user = userSelectors.useUser();
+  return {
+    isAuthenticated,
+    isLoading,
+    error,
+    user
+  };
+};
+var useAuthInitializer = () => {
+  const { refreshUser } = useUserActions();
+  const { isLoading } = useUserData();
+  useEffect3(() => {
+    const initializeUser = async () => {
+      if (!isLoading) {
+        try {
+          await refreshUser();
+        } catch (error) {
+          console.error("Failed to initialize user:", error);
+        }
+      }
+    };
+    initializeUser();
+  }, []);
+  useAuthEventBus({
+    onLoggedOut: () => {
+      refreshUser(true).catch(console.error);
+    },
+    onLoggedIn: () => {
+      refreshUser(true).catch(console.error);
+    }
+  });
+  return useUser();
+};
+var useIsAuthenticated = () => {
+  return userSelectors.useIsAuthenticated();
+};
+var useUserLoading = () => {
+  return userSelectors.useIsLoading();
+};
+var useUserError = () => {
+  return userSelectors.useError();
+};
+var useUserProfile = () => {
+  return userSelectors.useUser();
+};
+var useLogout = () => {
+  const { clearUser } = useUserActions();
+  const logout = async () => {
+    try {
+      await clearUser();
+    } catch (error) {
+      console.error("Logout error:", error);
+      throw error;
+    }
+  };
+  return logout;
+};
+var useRefreshUser = () => {
+  const { refreshUser } = useUserActions();
+  const refresh = async (force = false) => {
+    try {
+      await refreshUser(force);
+    } catch (error) {
+      console.error("Refresh user error:", error);
+      throw error;
+    }
+  };
+  return refresh;
+};
+
+// src/hooks/useAuthFlowModal.ts
+import { useState as useState3, useEffect as useEffect4 } from "react";
+var useAuthFlowModal = () => {
+  const [isModalOpen, setIsModalOpen] = useState3(false);
+  const [isInitialLoading, setIsInitialLoading] = useState3(true);
+  const eventBus = useSharedEventBus();
+  const { isLoading: userLoading } = useUserData();
+  useEffect4(() => {
+    const handleAuthEvent = (event) => {
+      if (event.type === "auth.signin_required_modal" /* SignInRequiredModal */) {
+        setIsModalOpen(true);
+        setIsInitialLoading(false);
+      }
+    };
+    const subscription = eventBus.subscribe(handleAuthEvent);
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [eventBus]);
+  useEffect4(() => {
+    if (!userLoading) {
+      const timer = setTimeout(() => {
+        setIsInitialLoading(false);
+      }, 0);
+      return () => clearTimeout(timer);
+    }
+  }, [userLoading]);
+  const openModal = () => {
+    setIsModalOpen(true);
+    setIsInitialLoading(false);
+  };
+  return {
+    isModalOpen,
+    isInitialLoading,
+    openModal
+  };
+};
+
+// src/components/auth/auth-flow-container.tsx
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var { Text } = Typography2;
+var AuthFlowContainer = () => {
+  const authOrchestrator = AuthOrchestratorFactory.create();
+  const { state: actionState, executeAction, clearAll } = useAuthActionHandler();
+  const { getStepComponent } = useStepRenderer();
+  const [email, setEmail] = useState4("");
+  const [authIntent, setAuthIntent] = useState4("login" /* LOGIN */);
+  const [authData, setAuthData] = useState4(null);
+  const config2 = {
+    showSteps: true,
+    showProgressImage: true,
+    showBackToHome: true,
+    backgroundImage: "/api/placeholder/800/600",
+    useAuthPageMessages: true,
+    emailStepConfig: {
+      showGoogleButton: false,
+      showForgotPassword: false
+    },
+    passwordStepConfig: {
+      showEmailField: true
+    },
+    verificationStepConfig: {
+      codeLength: 5,
+      showResendButton: false
+    }
+  };
+  const stepperConfig = {
+    steps: createAuthSteps({ authIntent }),
+    initialStep: "email" /* EMAIL */
+  };
+  const { state: stepperState, actions: stepperActions } = useStepper(stepperConfig);
+  const handleEmailSubmit = async (emailValue) => {
+    await executeAction(
+      async () => {
+        return await authOrchestrator.handleEmailCheck(emailValue);
+      },
+      {
+        onSuccess: (data) => {
+          setEmail(emailValue);
+          setAuthIntent(data.next_action);
+          const nextStep = getStepForEmailSubmission(data.next_action);
+          stepperActions.goToStep(nextStep);
+        },
+        onError: (error) => {
+          message.error(error);
+        }
+      }
+    );
+  };
+  const handlePasswordSubmit = async (password) => {
+    await executeAction(
+      async () => {
+        const loginRequest = { email, password };
+        return await authOrchestrator.handleLoginFlow(loginRequest);
+      },
+      {
+        onSuccess: (data) => {
+          setAuthData(data);
+          if (!data.isVerifiedEmail) {
+            const nextStep = getStepForPasswordSubmission(data.isVerifiedEmail);
+            stepperActions.goToStep(nextStep);
+          }
+        },
+        onError: (error) => {
+          message.error(error);
+        }
+      }
+    );
+  };
+  const handleVerificationSubmit = async (code) => {
+    await executeAction(
+      async () => {
+        return await authOrchestrator.handleEmailVerification(email, code);
+      },
+      {
+        onSuccess: (data) => {
+          setAuthData(data);
+          handleSuccess();
+        },
+        onError: (error) => {
+          message.error(error);
+        }
+      }
+    );
+  };
+  const handleSuccess = () => {
+    message.success("Authentication successful!");
+  };
+  const goBackToEmail = () => {
+    stepperActions.goToStep("email" /* EMAIL */);
+    setEmail("");
+    clearAll();
+  };
+  const goBackToPassword = () => {
+    stepperActions.goToStep("password" /* PASSWORD */);
+    clearAll();
+  };
+  const goBackToHome = () => {
+    window.location.href = "/";
+  };
+  const getCurrentStepMessage = () => {
+    return config2.useAuthPageMessages ? getAuthPageStepMessage(stepperState.currentStep) : getStepProgressMessage(stepperState.currentStep);
+  };
+  const { SelectedComponent, stepProps } = useStepRegistry({
+    baseProps: __spreadProps(__spreadValues({}, actionState), {
+      error: actionState.error || void 0,
+      success: actionState.success || void 0
+    }),
+    handlers: {
+      handleEmailSubmit,
+      handlePasswordSubmit,
+      handleVerificationSubmit,
+      handleResendCode: () => {
+      },
+      goBackToEmail,
+      goBackToPassword,
+      onGoogleSignIn: () => {
+      },
+      onForgotPassword: () => {
+      }
+    },
+    state: { email, authIntent, authData },
+    configs: {
+      emailStepConfig: config2.emailStepConfig,
+      passwordStepConfig: config2.passwordStepConfig,
+      verificationStepConfig: config2.verificationStepConfig
+    },
+    getStepComponent,
+    stepperState
+  });
+  return /* @__PURE__ */ jsx10("div", { className: "min-h-screen bg-gray-50", children: /* @__PURE__ */ jsxs6(Row, { className: "min-h-screen", children: [
+    /* @__PURE__ */ jsx10(
+      Col,
+      {
+        xs: 24,
+        lg: config2.showProgressImage ? 12 : 24,
+        className: "flex items-center justify-center p-8",
+        children: /* @__PURE__ */ jsxs6(Space2, { direction: "vertical", size: "large", className: "w-full max-w-md", children: [
+          config2.showBackToHome && /* @__PURE__ */ jsx10(
+            Button5,
+            {
+              type: "link",
+              icon: /* @__PURE__ */ jsx10(ArrowLeftOutlined3, {}),
+              className: "px-0",
+              onClick: goBackToHome,
+              children: "Back to Home"
+            }
+          ),
+          config2.showSteps && /* @__PURE__ */ jsx10(
+            Steps,
+            {
+              current: stepperState.currentStepIndex,
+              size: "small",
+              responsive: false,
+              items: stepperState.steps.map((step) => ({
+                title: step.title,
+                description: step.description,
+                icon: step.icon,
+                disabled: step.disabled || false
+              }))
+            }
+          ),
+          /* @__PURE__ */ jsx10(
+            Spin2,
+            {
+              spinning: actionState.isLoading,
+              tip: getCurrentStepMessage(),
+              children: /* @__PURE__ */ jsx10(SelectedComponent, __spreadValues({}, stepProps))
+            }
+          )
+        ] })
+      }
+    ),
+    config2.showProgressImage && /* @__PURE__ */ jsxs6(
+      Col,
+      {
+        xs: 0,
+        lg: 12,
+        className: "relative bg-gradient-to-br from-blue-500 to-purple-600 flex items-center justify-center",
+        children: [
+          /* @__PURE__ */ jsx10("div", { className: "absolute inset-0 bg-black bg-opacity-20" }),
+          /* @__PURE__ */ jsx10(
+            Image,
+            {
+              src: config2.backgroundImage,
+              alt: "Authentication",
+              className: "absolute inset-0 object-cover",
+              preview: false,
+              fallback: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iODAwIiBoZWlnaHQ9IjYwMCIgdmlld0JveD0iMCAwIDgwMCA2MDAiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxyZWN0IHdpZHRoPSI4MDAiIGhlaWdodD0iNjAwIiBmaWxsPSIjRjNGNEY2Ii8+CjxwYXRoIGQ9Ik0wIDMwMEg4MDBWNDAwSDBWMzAwWiIgZmlsbD0iI0U1RTdFQiIvPgo8Y2lyY2xlIGN4PSI0MDAiIGN5PSIzMDAiIHI9IjEwMCIgZmlsbD0iI0QxRDVGRiIvPgo8L3N2Zz4K"
+            }
+          ),
+          /* @__PURE__ */ jsx10(Flex3, { vertical: true, align: "center", className: "relative z-10 text-white", children: /* @__PURE__ */ jsxs6("div", { className: "w-32 h-32 mb-4 relative", children: [
+            /* @__PURE__ */ jsxs6("svg", { className: "w-full h-full transform -rotate-90", viewBox: "0 0 120 120", children: [
+              /* @__PURE__ */ jsx10(
+                "circle",
+                {
+                  cx: "60",
+                  cy: "60",
+                  r: "54",
+                  fill: "none",
+                  stroke: "rgba(255,255,255,0.3)",
+                  strokeWidth: "8"
+                }
+              ),
+              /* @__PURE__ */ jsx10(
+                "circle",
+                {
+                  cx: "60",
+                  cy: "60",
+                  r: "54",
+                  fill: "none",
+                  stroke: "white",
+                  strokeWidth: "8",
+                  strokeDasharray: `${2 * Math.PI * 54}`,
+                  strokeDashoffset: `${2 * Math.PI * 54 * (1 - stepperState.progress)}`,
+                  strokeLinecap: "round",
+                  className: "transition-all duration-500"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx10(Flex3, { align: "center", justify: "center", className: "absolute inset-0", children: /* @__PURE__ */ jsxs6(Text, { className: "text-2xl font-bold text-white", children: [
+              Math.round(stepperState.progress * 100),
+              "%"
+            ] }) })
+          ] }) })
+        ]
+      }
+    )
+  ] }) });
+};
+
+// src/components/auth/auth-flow-modal.tsx
+import { Modal, Spin as Spin3 } from "antd";
+import { Fragment as Fragment4, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+var AuthFlowModal = ({ children }) => {
+  const { isModalOpen, isInitialLoading } = useAuthFlowModal();
+  if (isInitialLoading) {
+    return /* @__PURE__ */ jsx11("div", { className: "min-h-screen flex items-center justify-center bg-gray-50", children: /* @__PURE__ */ jsx11(Spin3, { size: "large" }) });
+  }
+  return /* @__PURE__ */ jsxs7(Fragment4, { children: [
+    isModalOpen ? /* @__PURE__ */ jsx11("div", { className: "min-h-screen flex items-center justify-center bg-gray-50", children: /* @__PURE__ */ jsx11(Spin3, { size: "large" }) }) : children,
+    /* @__PURE__ */ jsx11(
+      Modal,
+      {
+        title: "Sign In Required",
+        open: isModalOpen,
+        footer: null,
+        width: 800,
+        centered: true,
+        destroyOnHidden: true,
+        maskClosable: false,
+        className: "auth-flow-modal",
+        children: /* @__PURE__ */ jsx11(AuthFlowContainer, {})
+      }
+    )
+  ] });
+};
+
+// src/components/auth/auth-initializer.tsx
+import { Fragment as Fragment5, jsx as jsx12 } from "react/jsx-runtime";
+var AuthInitializer = ({ children }) => {
+  useAuthInitializer();
+  return /* @__PURE__ */ jsx12(Fragment5, { children });
+};
+
+// src/components/profile/profile-state-renderer.tsx
+import { Dropdown, Button as Button6 } from "antd";
+import { MailOutlined as MailOutlined3, CrownOutlined, LogoutOutlined, UserOutlined } from "@ant-design/icons";
+import Link from "next/link";
+import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+var LoadingState = () => /* @__PURE__ */ jsx13("div", { className: "min-h-screen flex items-center justify-center", children: /* @__PURE__ */ jsx13("div", { className: "text-center", children: /* @__PURE__ */ jsx13("div", { className: "animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600 mx-auto mb-4" }) }) });
+var UnauthenticatedState2 = () => /* @__PURE__ */ jsx13(Link, { href: "/login", children: /* @__PURE__ */ jsx13(Button6, { type: "primary", shape: "circle", size: "large", icon: /* @__PURE__ */ jsx13(UserOutlined, {}) }) });
+var AuthenticatedState2 = ({ user, onLogout }) => {
+  var _a, _b, _c;
+  const userInfoMenu = {
+    items: [
+      {
+        key: "email",
+        icon: /* @__PURE__ */ jsx13(MailOutlined3, {}),
+        label: /* @__PURE__ */ jsxs8("div", { children: [
+          /* @__PURE__ */ jsx13("div", { className: "text-xs text-gray-500", children: "Email" }),
+          /* @__PURE__ */ jsx13("div", { className: "font-medium", children: ((_a = user.user) == null ? void 0 : _a.email) || "N/A" })
+        ] })
+      },
+      {
+        key: "role",
+        icon: /* @__PURE__ */ jsx13(CrownOutlined, {}),
+        label: /* @__PURE__ */ jsxs8("div", { children: [
+          /* @__PURE__ */ jsx13("div", { className: "text-xs text-gray-500", children: "Role" }),
+          /* @__PURE__ */ jsx13("div", { className: "font-medium", children: ((_c = (_b = user.user) == null ? void 0 : _b.role) == null ? void 0 : _c.name) || "N/A" })
+        ] })
+      },
+      {
+        type: "divider"
+      },
+      {
+        key: "logout",
+        icon: /* @__PURE__ */ jsx13(LogoutOutlined, {}),
+        label: "Logout",
+        onClick: onLogout
+      }
+    ]
+  };
+  return /* @__PURE__ */ jsx13(Dropdown, { menu: userInfoMenu, placement: "bottom", trigger: ["click"], children: /* @__PURE__ */ jsx13(Button6, { type: "primary", shape: "circle", size: "large", icon: /* @__PURE__ */ jsx13(UserOutlined, {}) }) });
+};
+var resolveState = (isLoading, isAuthenticated, user) => {
+  if (isLoading) return "LOADING" /* LOADING */;
+  if (!isAuthenticated || !user) return "UNAUTHENTICATED" /* UNAUTHENTICATED */;
+  return "AUTHENTICATED" /* AUTHENTICATED */;
+};
+var getComponentProps = (state, user, callbacks) => {
+  switch (state) {
+    case "AUTHENTICATED" /* AUTHENTICATED */:
+      return {
+        user,
+        onLogout: callbacks.onLogout
+      };
+    default:
+      return {};
+  }
+};
+var ProfileStateRenderer = () => {
+  const { user, isLoading, isAuthenticated } = useAuth();
+  const logout = useLogout();
+  const currentState = resolveState(isLoading, isAuthenticated, user);
+  const componentProps = getComponentProps(currentState, user, {
+    onLogout: logout
+  });
+  switch (currentState) {
+    case "LOADING" /* LOADING */:
+      return /* @__PURE__ */ jsx13(LoadingState, {});
+    case "UNAUTHENTICATED" /* UNAUTHENTICATED */:
+      return /* @__PURE__ */ jsx13(UnauthenticatedState2, {});
+    case "AUTHENTICATED" /* AUTHENTICATED */:
+      return /* @__PURE__ */ jsx13(AuthenticatedState2, __spreadValues({}, componentProps));
+    default:
+      return /* @__PURE__ */ jsx13(LoadingState, {});
+  }
+};
+
+// src/components/demo/cross-tab-demo.tsx
+import { Card, Typography as Typography3, Tag, Space as Space3 } from "antd";
+import { Fragment as Fragment6, jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
+var { Title: Title2, Text: Text2, Paragraph: Paragraph2 } = Typography3;
+var CrossTabDemo = () => {
+  var _a;
+  const { isAuthenticated, user } = useAuth();
+  const currentPageType = CrossTabBehaviorHandler.getCurrentPageType();
+  return /* @__PURE__ */ jsx14(
+    Card,
+    {
+      title: "Cross-Tab Authentication Demo",
+      className: "w-full max-w-2xl",
+      style: { marginTop: "2rem" },
+      children: /* @__PURE__ */ jsxs9(Space3, { direction: "vertical", size: "middle", className: "w-full", children: [
+        /* @__PURE__ */ jsxs9("div", { children: [
+          /* @__PURE__ */ jsx14(Title2, { level: 4, children: "Current Status" }),
+          /* @__PURE__ */ jsxs9(Space3, { children: [
+            /* @__PURE__ */ jsx14(Text2, { strong: true, children: "Authentication:" }),
+            /* @__PURE__ */ jsx14(Tag, { color: isAuthenticated ? "green" : "red", children: isAuthenticated ? "Authenticated" : "Not Authenticated" })
+          ] }),
+          /* @__PURE__ */ jsx14("br", {}),
+          /* @__PURE__ */ jsxs9(Space3, { style: { marginTop: "0.5rem" }, children: [
+            /* @__PURE__ */ jsx14(Text2, { strong: true, children: "Current Page:" }),
+            /* @__PURE__ */ jsx14(Tag, { color: "blue", children: currentPageType })
+          ] }),
+          user && /* @__PURE__ */ jsxs9(Fragment6, { children: [
+            /* @__PURE__ */ jsx14("br", {}),
+            /* @__PURE__ */ jsxs9(Space3, { style: { marginTop: "0.5rem" }, children: [
+              /* @__PURE__ */ jsx14(Text2, { strong: true, children: "User:" }),
+              /* @__PURE__ */ jsx14(Text2, { children: (_a = user.user) == null ? void 0 : _a.email })
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs9("div", { children: [
+          /* @__PURE__ */ jsx14(Title2, { level: 4, children: "How It Works" }),
+          /* @__PURE__ */ jsx14(Paragraph2, { children: "This application now supports enhanced cross-tab authentication handling:" }),
+          /* @__PURE__ */ jsxs9("div", { style: { marginLeft: "1rem" }, children: [
+            /* @__PURE__ */ jsxs9(Paragraph2, { children: [
+              /* @__PURE__ */ jsx14(Text2, { strong: true, children: "Login Scenario:" }),
+              /* @__PURE__ */ jsx14("br", {}),
+              "\u2022 Open multiple tabs with some on the login page and others on different pages",
+              /* @__PURE__ */ jsx14("br", {}),
+              "\u2022 When you log in from one tab, other login tabs will automatically redirect to the dashboard",
+              /* @__PURE__ */ jsx14("br", {}),
+              "\u2022 Non-login pages will receive the login event but won't redirect (they'll just update their state)"
+            ] }),
+            /* @__PURE__ */ jsxs9(Paragraph2, { children: [
+              /* @__PURE__ */ jsx14(Text2, { strong: true, children: "Logout Scenario:" }),
+              /* @__PURE__ */ jsx14("br", {}),
+              "\u2022 When you log out from the dashboard, other dashboard tabs will redirect to the login page",
+              /* @__PURE__ */ jsx14("br", {}),
+              "\u2022 Other pages will receive the logout event and update their authentication state"
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs9("div", { children: [
+          /* @__PURE__ */ jsx14(Title2, { level: 4, children: "Test Instructions" }),
+          /* @__PURE__ */ jsxs9(Paragraph2, { children: [
+            "1. Open this page in multiple browser tabs",
+            /* @__PURE__ */ jsx14("br", {}),
+            "2. Navigate to ",
+            /* @__PURE__ */ jsx14(Text2, { code: true, children: "/login" }),
+            " in some tabs and ",
+            /* @__PURE__ */ jsx14(Text2, { code: true, children: "/dashboard" }),
+            " in others",
+            /* @__PURE__ */ jsx14("br", {}),
+            "3. Log in from one tab and observe the automatic redirects in other tabs",
+            /* @__PURE__ */ jsx14("br", {}),
+            "4. Log out from the dashboard and see how other tabs react"
+          ] })
+        ] })
+      ] })
+    }
+  );
+};
+export {
+  AUTH_ENDPOINTS,
+  AlertDisplay,
+  AuthEventType,
+  AuthFlowContainer,
+  AuthFlowModal,
+  AuthFlowStep,
+  AuthInitializer,
+  AuthOrchestrator,
+  AuthOrchestratorFactory,
+  AuthResultFactory,
+  AuthService,
+  AuthenticatedState,
+  AuthenticationStatusContext,
+  BaseErrorHandler,
+  BaseEventBus,
+  BaseForm,
+  BaseService,
+  BroadcastChannelEventBus,
+  Channel,
+  CookieUtils,
+  CrossTabBehaviorConfig,
+  CrossTabBehaviorHandler,
+  CrossTabDemo,
+  DevelopmentLogger,
+  EMAIL_SUBMISSION_NAVIGATION,
+  EmailStep,
+  EndpointBuilder,
+  ExistingUserLoginStrategy,
+  FormFields,
+  FormHeader,
+  GenericErrorHandler,
+  HttpClient,
+  HttpMethod,
+  LocalStorageUtils,
+  LoggerFactory,
+  LoginFlowStrategyFactory,
+  MiddlewareConfig,
+  NavigationAction,
+  NetworkErrorHandler,
+  NextAction,
+  PASSWORD_SUBMISSION_NAVIGATION,
+  PageType,
+  PageTypePatterns,
+  PasswordStep,
+  ProductionLogger,
+  ProfileStateRenderer,
+  ProfileUIState,
+  RoleType,
+  SignupFlowStrategy,
+  TokenManager,
+  UnauthenticatedState,
+  UserStorageManager,
+  VERIFICATION_SUBMISSION_NAVIGATION,
+  ValidationErrorHandler,
+  VerificationStep,
+  config,
+  createAuthSteps,
+  createPropsFactoryRegistry,
+  createStepRegistry,
+  getAuthPageStepMessage,
+  getEmailField,
+  getEmailStepComponent,
+  getPasswordField,
+  getPasswordStepComponent,
+  getStepForEmailSubmission,
+  getStepForPasswordSubmission,
+  getStepForVerificationSubmission,
+  getStepProgressMessage,
+  getVerificationField,
+  getVerificationStepComponent,
+  middlewareMatcher,
+  useAuth,
+  useAuthActionHandler,
+  useAuthEventBus,
+  useAuthFlowModal,
+  useAuthInitializer,
+  useIsAuthenticated,
+  useLogout,
+  useRefreshUser,
+  useSharedEventBus,
+  useSignInRequiredParams,
+  useStepRegistry,
+  useStepRenderer,
+  useStepper,
+  useUser,
+  useUserActions,
+  useUserData,
+  useUserError,
+  useUserLoading,
+  useUserProfile,
+  useUserStore,
+  userSelectors
+};
+/*! Bundled license information:
+
+js-cookie/dist/js.cookie.mjs:
+  (*! js-cookie v3.0.5 | MIT *)
+*/