@symbo.ls/sdk 2.32.11 → 2.32.13

package/dist/esm/services/CoreService.js

@@ -1,3513 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/config/environment.js
-import { isDevelopment } from "@domql/utils";
-var CONFIG = {
-  // Common defaults for all environments
-  common: {
-    // NOTE: Google client id for google auth, need to configure URLs for each environment in Google console
-    googleClientId: "686286207466-bvd2fqs31rlm64fgich7rtpnc8ns2tqg.apps.googleusercontent.com",
-    // Feature toggles that apply across all environments by default
-    features: {
-      newUserOnboarding: true,
-      betaFeatures: false
-    }
-  },
-  // Environment-specific configurations
-  local: {
-    // local
-    socketUrl: "http://localhost:8080",
-    // For socket api
-    apiUrl: "http://localhost:8080",
-    // For server api
-    basedEnv: "development",
-    // For based api
-    basedProject: "platform-v2-sm",
-    // For based api
-    basedOrg: "symbols",
-    // For based api
-    githubClientId: "Ov23liAFrsR0StbAO6PO",
-    // For github api
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/aef64330db80bdfeaac084317bf72f99",
-    // For grafana tracing
-    grafanaAppName: "Localhost Symbols",
-    // Environment-specific feature toggles (override common)
-    features: {
-      betaFeatures: true
-      // Enable beta features in local dev
-    },
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "vZya3L2zpq8L6iI5WWMUZJZABvT63VDb",
-    typesenseHost: "localhost",
-    typesensePort: "8108",
-    typesenseProtocol: "http"
-  },
-  development: {
-    socketUrl: "https://dev.api.symbols.app",
-    apiUrl: "https://dev.api.symbols.app",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8",
-    // For grafana tracing
-    grafanaAppName: "Symbols Dev",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  testing: {
-    socketUrl: "https://test.api.symbols.app",
-    apiUrl: "https://test.api.symbols.app",
-    basedEnv: "testing",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8",
-    // For grafana tracing
-    grafanaAppName: "Symbols Test",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  upcoming: {
-    socketUrl: "https://upcoming.api.symbols.app",
-    apiUrl: "https://upcoming.api.symbols.app",
-    githubClientId: "Ov23liWF7NvdZ056RV5J",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8",
-    // For grafana tracing
-    grafanaAppName: "Symbols Upcoming",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  staging: {
-    socketUrl: "https://staging.api.symbols.app",
-    apiUrl: "https://staging.api.symbols.app",
-    basedEnv: "staging",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23ligwZDQVD0VfuWNa",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8",
-    // For grafana tracing
-    grafanaAppName: "Symbols Staging",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  production: {
-    socketUrl: "https://api.symbols.app",
-    apiUrl: "https://api.symbols.app",
-    basedEnv: "production",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae",
-    // For grafana tracing
-    grafanaAppName: "Symbols",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  }
-};
-var getEnvironment = () => {
-  const env = process.env.SYMBOLS_APP_ENV || process.env.NODE_ENV;
-  if (!CONFIG[env]) {
-    throw new Error(`Unknown environment "${env}"`);
-  }
-  return env;
-};
-var getConfig = () => {
-  try {
-    const env = getEnvironment();
-    const envConfig = { ...CONFIG.common, ...CONFIG[env] };
-    const finalConfig = {
-      ...envConfig,
-      socketUrl: process.env.SYMBOLS_APP_SOCKET_URL || envConfig.socketUrl,
-      apiUrl: process.env.SYMBOLS_APP_API_URL || envConfig.apiUrl,
-      basedEnv: process.env.SYMBOLS_APP_BASED_ENV || envConfig.basedEnv,
-      basedProject: process.env.SYMBOLS_APP_BASED_PROJECT || envConfig.basedProject,
-      basedOrg: process.env.SYMBOLS_APP_BASED_ORG || envConfig.basedOrg,
-      githubClientId: process.env.SYMBOLS_APP_GITHUB_CLIENT_ID || envConfig.githubClientId,
-      grafanaUrl: process.env.SYMBOLS_APP_GRAFANA_URL || envConfig.grafanaUrl,
-      typesenseCollectionName: process.env.TYPESENSE_COLLECTION_NAME || envConfig.typesenseCollectionName,
-      typesenseApiKey: process.env.TYPESENSE_API_KEY || envConfig.typesenseApiKey,
-      typesenseHost: process.env.TYPESENSE_HOST || envConfig.typesenseHost,
-      typesensePort: process.env.TYPESENSE_PORT || envConfig.typesensePort,
-      typesenseProtocol: process.env.TYPESENSE_PROTOCOL || envConfig.typesenseProtocol,
-      isDevelopment: isDevelopment(env),
-      isTesting: env === "testing",
-      isStaging: env === "staging",
-      isProduction: env === "production"
-      // Store all environment variables for potential future use
-    };
-    const requiredFields = [
-      "socketUrl",
-      "apiUrl",
-      "githubClientId",
-      "googleClientId"
-    ];
-    const missingFields = requiredFields.filter((field) => !finalConfig[field]);
-    if (missingFields.length > 0) {
-      console.error(
-        `Missing required configuration: ${missingFields.join(", ")}`
-      );
-    }
-    if (finalConfig.isDevelopment) {
-      console.warn(
-        "environment in SDK:",
-        env || process.env.NODE_ENV || process.env.NODE_ENV
-      );
-      console.log(finalConfig);
-    } else if (global.window) {
-      global.window.finalConfig = finalConfig;
-    }
-    return finalConfig;
-  } catch (error) {
-    console.error("Failed to load environment configuration:", error);
-    return {
-      ...CONFIG.development
-    };
-  }
-};
-var environment_default = getConfig();
-
-// src/utils/TokenManager.js
-var TokenManager = class {
-  constructor(options = {}) {
-    /**
-     * Memory storage fallback for server-side rendering
-     */
-    __publicField(this, "_memoryStorage", {
-      _data: {},
-      getItem: (key) => this._memoryStorage._data[key] || null,
-      setItem: (key, value) => {
-        this._memoryStorage._data[key] = value;
-      },
-      removeItem: (key) => {
-        delete this._memoryStorage._data[key];
-      },
-      clear: () => {
-        this._memoryStorage._data = {};
-      }
-    });
-    this.config = {
-      storagePrefix: "symbols_",
-      storageType: typeof window === "undefined" || process.env.NODE_ENV === "test" || process.env.NODE_ENV === "testing" ? "memory" : "localStorage",
-      // 'localStorage' | 'sessionStorage' | 'memory'
-      refreshBuffer: 60 * 1e3,
-      // Refresh 1 minute before expiry
-      maxRetries: 3,
-      apiUrl: options.apiUrl || "/api",
-      onTokenRefresh: options.onTokenRefresh || null,
-      onTokenExpired: options.onTokenExpired || null,
-      onTokenError: options.onTokenError || null,
-      ...options
-    };
-    this.tokens = {
-      accessToken: null,
-      refreshToken: null,
-      expiresAt: null,
-      expiresIn: null
-    };
-    this.refreshPromise = null;
-    this.refreshTimeout = null;
-    this.retryCount = 0;
-    this.loadTokens();
-  }
-  /**
-   * Storage keys
-   */
-  get storageKeys() {
-    return {
-      accessToken: `${this.config.storagePrefix}access_token`,
-      refreshToken: `${this.config.storagePrefix}refresh_token`,
-      expiresAt: `${this.config.storagePrefix}expires_at`,
-      expiresIn: `${this.config.storagePrefix}expires_in`
-    };
-  }
-  /**
-   * Get storage instance based on configuration
-   */
-  get storage() {
-    if (typeof window === "undefined") {
-      return this._memoryStorage;
-    }
-    const safeGetStorage = (provider) => {
-      try {
-        const storage = provider();
-        const testKey = `${this.config.storagePrefix}__tm_test__`;
-        storage.setItem(testKey, "1");
-        storage.removeItem(testKey);
-        return storage;
-      } catch {
-        return null;
-      }
-    };
-    const localStorageInstance = safeGetStorage(() => window.localStorage);
-    const sessionStorageInstance = safeGetStorage(() => window.sessionStorage);
-    switch (this.config.storageType) {
-      case "sessionStorage":
-        return sessionStorageInstance || this._memoryStorage;
-      case "memory":
-        return this._memoryStorage;
-      default:
-        return localStorageInstance || this._memoryStorage;
-    }
-  }
-  /**
-   * Set tokens and persist to storage
-   */
-  setTokens(tokenData) {
-    const {
-      access_token: accessToken,
-      refresh_token: refreshToken,
-      expires_in: expiresIn,
-      token_type: tokenType = "Bearer"
-    } = tokenData;
-    if (!accessToken) {
-      throw new Error("Access token is required");
-    }
-    const now = Date.now();
-    const expiresAt = expiresIn ? now + expiresIn * 1e3 : null;
-    this.tokens = {
-      accessToken,
-      refreshToken: refreshToken || this.tokens.refreshToken,
-      expiresAt,
-      expiresIn,
-      tokenType
-    };
-    this.saveTokens();
-    this.scheduleRefresh();
-    if (this.config.onTokenRefresh) {
-      this.config.onTokenRefresh(this.tokens);
-    }
-    return this.tokens;
-  }
-  /**
-   * Get current access token
-   */
-  getAccessToken() {
-    return this.tokens.accessToken;
-  }
-  /**
-   * Get current refresh token
-   */
-  getRefreshToken() {
-    return this.tokens.refreshToken;
-  }
-  /**
-   * Get authorization header value
-   */
-  getAuthHeader() {
-    const token = this.getAccessToken();
-    if (!token) {
-      return null;
-    }
-    return `${this.tokens.tokenType || "Bearer"} ${token}`;
-  }
-  /**
-   * Check if access token is valid and not expired
-   */
-  isAccessTokenValid() {
-    if (!this.tokens.accessToken) {
-      return false;
-    }
-    if (!this.tokens.expiresAt) {
-      return true;
-    }
-    const now = Date.now();
-    const isValid = now < this.tokens.expiresAt - this.config.refreshBuffer;
-    if (!isValid) {
-      console.log("[TokenManager] Access token is expired or near expiry:", {
-        now: new Date(now).toISOString(),
-        expiresAt: new Date(this.tokens.expiresAt).toISOString(),
-        refreshBuffer: this.config.refreshBuffer
-      });
-    }
-    return isValid;
-  }
-  /**
-   * Check if access token exists and is not expired (without refresh buffer)
-   */
-  isAccessTokenActuallyValid() {
-    if (!this.tokens.accessToken) {
-      return false;
-    }
-    if (!this.tokens.expiresAt) {
-      return true;
-    }
-    const now = Date.now();
-    return now < this.tokens.expiresAt;
-  }
-  /**
-   * Check if tokens exist (regardless of expiry)
-   */
-  hasTokens() {
-    return Boolean(this.tokens.accessToken);
-  }
-  /**
-   * Check if refresh token exists
-   */
-  hasRefreshToken() {
-    return Boolean(this.tokens.refreshToken);
-  }
-  /**
-   * Automatically refresh tokens if needed
-   */
-  async ensureValidToken() {
-    if (!this.hasTokens()) {
-      return null;
-    }
-    if (this.isAccessTokenValid()) {
-      return this.getAccessToken();
-    }
-    if (!this.hasRefreshToken()) {
-      this.clearTokens();
-      if (this.config.onTokenExpired) {
-        this.config.onTokenExpired();
-      }
-      return null;
-    }
-    try {
-      await this.refreshTokens();
-      return this.getAccessToken();
-    } catch (error) {
-      this.clearTokens();
-      if (this.config.onTokenError) {
-        this.config.onTokenError(error);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Refresh access token using refresh token
-   */
-  async refreshTokens() {
-    if (this.refreshPromise) {
-      return this.refreshPromise;
-    }
-    if (!this.hasRefreshToken()) {
-      throw new Error("No refresh token available");
-    }
-    if (this.retryCount >= this.config.maxRetries) {
-      throw new Error("Max refresh retries exceeded");
-    }
-    this.refreshPromise = this._performRefresh();
-    try {
-      const result = await this.refreshPromise;
-      this.retryCount = 0;
-      return result;
-    } catch (error) {
-      this.retryCount++;
-      throw error;
-    } finally {
-      this.refreshPromise = null;
-    }
-  }
-  /**
-   * Perform the actual token refresh request
-   */
-  async _performRefresh() {
-    var _a;
-    const refreshToken = this.getRefreshToken();
-    const response = await fetch(`${this.config.apiUrl}/core/auth/refresh`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ refreshToken })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.message || `Token refresh failed: ${response.status}`);
-    }
-    const responseData = await response.json();
-    if (responseData.success && responseData.data && responseData.data.tokens) {
-      const { tokens } = responseData.data;
-      const tokenData = {
-        access_token: tokens.accessToken,
-        refresh_token: tokens.refreshToken,
-        expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
-        token_type: "Bearer"
-      };
-      return this.setTokens(tokenData);
-    }
-    return this.setTokens(responseData);
-  }
-  /**
-   * Schedule automatic token refresh
-   */
-  scheduleRefresh() {
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    if (!this.tokens.expiresAt || !this.hasRefreshToken()) {
-      return;
-    }
-    const now = Date.now();
-    const refreshTime = this.tokens.expiresAt - this.config.refreshBuffer;
-    const delay = Math.max(0, refreshTime - now);
-    this.refreshTimeout = setTimeout(async () => {
-      try {
-        await this.refreshTokens();
-      } catch (error) {
-        console.error("Automatic token refresh failed:", error);
-        if (this.config.onTokenError) {
-          this.config.onTokenError(error);
-        }
-      }
-    }, delay);
-  }
-  /**
-   * Save tokens to storage
-   */
-  saveTokens() {
-    try {
-      const { storage } = this;
-      const keys = this.storageKeys;
-      if (this.tokens.accessToken) {
-        storage.setItem(keys.accessToken, this.tokens.accessToken);
-      }
-      if (this.tokens.refreshToken) {
-        storage.setItem(keys.refreshToken, this.tokens.refreshToken);
-      }
-      if (this.tokens.expiresAt) {
-        storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
-      }
-      if (this.tokens.expiresIn) {
-        storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
-      }
-    } catch (error) {
-      console.error("[TokenManager] Error saving tokens to storage:", error);
-    }
-  }
-  /**
-   * Load tokens from storage
-   */
-  loadTokens() {
-    try {
-      const { storage } = this;
-      const keys = this.storageKeys;
-      const accessToken = storage.getItem(keys.accessToken);
-      const refreshToken = storage.getItem(keys.refreshToken);
-      const expiresAt = storage.getItem(keys.expiresAt);
-      const expiresIn = storage.getItem(keys.expiresIn);
-      if (accessToken) {
-        this.tokens = {
-          accessToken,
-          refreshToken,
-          expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
-          expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
-          tokenType: "Bearer"
-        };
-        this.scheduleRefresh();
-      }
-    } catch (error) {
-      console.error("[TokenManager] Error loading tokens from storage:", error);
-      this.tokens = {
-        accessToken: null,
-        refreshToken: null,
-        expiresAt: null,
-        expiresIn: null
-      };
-    }
-  }
-  /**
-   * Clear all tokens
-   */
-  clearTokens() {
-    this.tokens = {
-      accessToken: null,
-      refreshToken: null,
-      expiresAt: null,
-      expiresIn: null
-    };
-    const { storage } = this;
-    const keys = this.storageKeys;
-    Object.values(keys).forEach((key) => {
-      storage.removeItem(key);
-    });
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    this.retryCount = 0;
-  }
-  /**
-   * Get token status information
-   */
-  getTokenStatus() {
-    const hasTokens = this.hasTokens();
-    const isValid = this.isAccessTokenValid();
-    const { expiresAt } = this.tokens;
-    const timeToExpiry = expiresAt ? expiresAt - Date.now() : null;
-    return {
-      hasTokens,
-      isValid,
-      hasRefreshToken: this.hasRefreshToken(),
-      expiresAt,
-      timeToExpiry,
-      willExpireSoon: timeToExpiry ? timeToExpiry < this.config.refreshBuffer : false
-    };
-  }
-  /**
-   * Cleanup resources
-   */
-  destroy() {
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    this.refreshPromise = null;
-  }
-};
-var defaultTokenManager = null;
-var getTokenManager = (options) => {
-  if (!defaultTokenManager) {
-    defaultTokenManager = new TokenManager(options);
-  }
-  return defaultTokenManager;
-};
-
-// src/services/BaseService.js
-var BaseService = class {
-  constructor({ context, options } = {}) {
-    this._context = context || {};
-    this._options = options || {};
-    this._ready = false;
-    this._error = null;
-    this._apiUrl = null;
-    this._tokenManager = null;
-  }
-  // Initialize service
-  init({ context }) {
-    try {
-      const { apiUrl } = context || this._context;
-      this._apiUrl = apiUrl || environment_default.apiUrl;
-      if (!this._apiUrl) {
-        throw new Error("Service base URL not configured");
-      }
-      this._tokenManager = getTokenManager({
-        apiUrl: this._apiUrl,
-        onTokenError: (error) => {
-          console.error("Token management error:", error);
-        }
-      });
-      this._setReady();
-    } catch (error) {
-      this._setError(error);
-      throw error;
-    }
-  }
-  // Update context
-  updateContext(context) {
-    if (context && typeof context === "object") {
-      Object.assign(this._context, context);
-    }
-  }
-  // Get service status
-  getStatus() {
-    return {
-      ready: this._ready,
-      error: this._error,
-      context: { ...this._context }
-    };
-  }
-  // Check if service is ready
-  isReady() {
-    return this._ready;
-  }
-  // Protected helper methods
-  _setReady(ready = true) {
-    this._ready = ready;
-    this._error = null;
-  }
-  _setError(error) {
-    this._ready = false;
-    this._error = error;
-  }
-  _requireAuth() {
-    if (!this._context.authToken) {
-      throw new Error("Authentication required");
-    }
-  }
-  _requireReady(methodName = "unknown") {
-    if (!this.isReady()) {
-      throw new Error(`Service not initialized for method: ${methodName}`);
-    }
-  }
-  // Shared HTTP request method
-  async _request(endpoint, options = {}) {
-    const url = `${this._apiUrl}/core${endpoint}`;
-    const defaultHeaders = {};
-    if (!(options.body instanceof FormData)) {
-      defaultHeaders["Content-Type"] = "application/json";
-    }
-    if (this._requiresInit(options.methodName) && this._tokenManager) {
-      try {
-        const validToken = await this._tokenManager.ensureValidToken();
-        if (validToken) {
-          const authHeader = this._tokenManager.getAuthHeader();
-          if (authHeader) {
-            defaultHeaders.Authorization = authHeader;
-          }
-        }
-      } catch (error) {
-        console.warn(
-          "Token management failed, proceeding without authentication:",
-          error
-        );
-      }
-    }
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers: {
-          ...defaultHeaders,
-          ...options.headers
-        }
-      });
-      if (!response.ok) {
-        let error = {
-          message: `HTTP ${response.status}: ${response.statusText}`
-        };
-        try {
-          error = await response.json();
-        } catch {
-        }
-        throw new Error(error.message || error.error || "Request failed", { cause: error });
-      }
-      return response.status === 204 ? null : response.json();
-    } catch (error) {
-      throw new Error(`Request failed: ${error.message}`, { cause: error });
-    }
-  }
-  // Helper method to determine if a method requires initialization
-  _requiresInit(methodName) {
-    const noInitMethods = /* @__PURE__ */ new Set([
-      "register",
-      "login",
-      "googleAuth",
-      "googleAuthCallback",
-      "githubAuth",
-      "requestPasswordReset",
-      "confirmPasswordReset",
-      "confirmRegistration",
-      "verifyEmail",
-      "getPlans",
-      "getPlan",
-      "listPublicProjects",
-      "getPublicProject"
-    ]);
-    return !noInitMethods.has(methodName);
-  }
-  // Cleanup method
-  destroy() {
-    if (this._tokenManager) {
-      this._tokenManager.destroy();
-      this._tokenManager = null;
-    }
-    this._ready = false;
-    this._setReady(false);
-  }
-};
-
-// src/services/CoreService.js
-var CoreService = class extends BaseService {
-  constructor(config) {
-    super(config);
-    this._client = null;
-    this._initialized = false;
-    this._apiUrl = null;
-    this._tokenManager = null;
-  }
-  init({ context }) {
-    try {
-      const { appKey, authToken } = context || this._context;
-      this._apiUrl = environment_default.apiUrl;
-      if (!this._apiUrl) {
-        throw new Error("Core service base URL not configured");
-      }
-      this._tokenManager = getTokenManager({
-        apiUrl: this._apiUrl,
-        onTokenRefresh: (tokens) => {
-          this.updateContext({ authToken: tokens.accessToken });
-        },
-        onTokenExpired: () => {
-          this.updateContext({ authToken: null });
-        },
-        onTokenError: (error) => {
-          console.error("Token management error:", error);
-        }
-      });
-      if (authToken && !this._tokenManager.hasTokens()) {
-        this._tokenManager.setTokens({ access_token: authToken });
-      }
-      this._info = {
-        config: {
-          apiUrl: this._apiUrl,
-          appKey: appKey ? `${appKey.substr(0, 4)}...${appKey.substr(-4)}` : null,
-          hasToken: Boolean(authToken)
-        }
-      };
-      this._initialized = true;
-      this._setReady();
-    } catch (error) {
-      this._setError(error);
-      throw error;
-    }
-  }
-  // Helper to check if method requires initialization
-  _requiresInit(methodName) {
-    const noInitMethods = /* @__PURE__ */ new Set([
-      "register",
-      "login",
-      "googleAuth",
-      "googleAuthCallback",
-      "githubAuth",
-      "requestPasswordReset",
-      "confirmPasswordReset",
-      "confirmRegistration",
-      "verifyEmail",
-      "listPublicProjects",
-      "getPublicProject",
-      "getHealthStatus"
-    ]);
-    return !noInitMethods.has(methodName);
-  }
-  // Override _requireReady to be more flexible
-  _requireReady(methodName) {
-    if (this._requiresInit(methodName) && !this._initialized) {
-      throw new Error("Core service not initialized");
-    }
-  }
-  // Debug method to check token status
-  getTokenDebugInfo() {
-    if (!this._tokenManager) {
-      return {
-        tokenManagerExists: false,
-        error: "TokenManager not initialized"
-      };
-    }
-    const tokenStatus = this._tokenManager.getTokenStatus();
-    const { tokens } = this._tokenManager;
-    return {
-      tokenManagerExists: true,
-      tokenStatus,
-      hasAccessToken: Boolean(tokens.accessToken),
-      hasRefreshToken: Boolean(tokens.refreshToken),
-      accessTokenPreview: tokens.accessToken ? `${tokens.accessToken.substring(0, 20)}...` : null,
-      expiresAt: tokens.expiresAt,
-      timeToExpiry: tokenStatus.timeToExpiry,
-      authHeader: this._tokenManager.getAuthHeader()
-    };
-  }
-  // Helper method to check if user is authenticated
-  isAuthenticated() {
-    if (!this._tokenManager) {
-      return false;
-    }
-    return this._tokenManager.hasTokens();
-  }
-  // Helper method to check if user has valid tokens
-  hasValidTokens() {
-    if (!this._tokenManager) {
-      return false;
-    }
-    return this._tokenManager.hasTokens() && this._tokenManager.isAccessTokenValid();
-  }
-  // Helper method to make HTTP requests
-  async _request(endpoint, options = {}) {
-    const url = `${this._apiUrl}/core${endpoint}`;
-    const defaultHeaders = {};
-    if (!(options.body instanceof FormData)) {
-      defaultHeaders["Content-Type"] = "application/json";
-    }
-    if (this._requiresInit(options.methodName) && this._tokenManager) {
-      try {
-        const validToken = await this._tokenManager.ensureValidToken();
-        if (validToken) {
-          const authHeader = this._tokenManager.getAuthHeader();
-          if (authHeader) {
-            defaultHeaders.Authorization = authHeader;
-          }
-        }
-      } catch (error) {
-        console.warn(
-          "Token management failed, proceeding without authentication:",
-          error
-        );
-      }
-    } else if (this._requiresInit(options.methodName)) {
-      const { authToken } = this._context;
-      if (authToken) {
-        defaultHeaders.Authorization = `Bearer ${authToken}`;
-      }
-    }
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers: {
-          ...defaultHeaders,
-          ...options.headers
-        }
-      });
-      if (!response.ok) {
-        let error = {
-          message: `HTTP ${response.status}: ${response.statusText}`
-        };
-        try {
-          error = await response.json();
-        } catch {
-        }
-        throw new Error(error.message || error.error || "Request failed", { cause: error });
-      }
-      return response.status === 204 ? null : response.json();
-    } catch (error) {
-      throw new Error(`Request failed: ${error.message}`, { cause: error });
-    }
-  }
-  // ==================== AUTH METHODS ====================
-  async register(userData) {
-    try {
-      const response = await this._request("/auth/register", {
-        method: "POST",
-        body: JSON.stringify(userData),
-        methodName: "register"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Registration failed: ${error.message}`, { cause: error });
-    }
-  }
-  async login(email, password) {
-    var _a;
-    try {
-      const response = await this._request("/auth/login", {
-        method: "POST",
-        body: JSON.stringify({ email, password }),
-        methodName: "login"
-      });
-      if (response.success && response.data && response.data.tokens) {
-        const { tokens } = response.data;
-        const tokenData = {
-          access_token: tokens.accessToken,
-          refresh_token: tokens.refreshToken,
-          expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
-          token_type: "Bearer"
-        };
-        if (this._tokenManager) {
-          this._tokenManager.setTokens(tokenData);
-        }
-        this.updateContext({ authToken: tokens.accessToken });
-      }
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Login failed: ${error.message}`, { cause: error });
-    }
-  }
-  async logout() {
-    this._requireReady("logout");
-    try {
-      await this._request("/auth/logout", {
-        method: "POST",
-        methodName: "logout"
-      });
-      if (this._tokenManager) {
-        this._tokenManager.clearTokens();
-      }
-      this.updateContext({ authToken: null });
-    } catch (error) {
-      if (this._tokenManager) {
-        this._tokenManager.clearTokens();
-      }
-      this.updateContext({ authToken: null });
-      throw new Error(`Logout failed: ${error.message}`, { cause: error });
-    }
-  }
-  async refreshToken(refreshToken) {
-    try {
-      const response = await this._request("/auth/refresh", {
-        method: "POST",
-        body: JSON.stringify({ refreshToken }),
-        methodName: "refreshToken"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Token refresh failed: ${error.message}`, { cause: error });
-    }
-  }
-  async googleAuth(idToken, inviteToken = null) {
-    var _a;
-    try {
-      const payload = { idToken };
-      if (inviteToken) {
-        payload.inviteToken = inviteToken;
-      }
-      const response = await this._request("/auth/google", {
-        method: "POST",
-        body: JSON.stringify(payload),
-        methodName: "googleAuth"
-      });
-      if (response.success && response.data && response.data.tokens) {
-        const { tokens } = response.data;
-        const tokenData = {
-          access_token: tokens.accessToken,
-          refresh_token: tokens.refreshToken,
-          expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
-          token_type: "Bearer"
-        };
-        if (this._tokenManager) {
-          this._tokenManager.setTokens(tokenData);
-        }
-        this.updateContext({ authToken: tokens.accessToken });
-      }
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Google auth failed: ${error.message}`, { cause: error });
-    }
-  }
-  async githubAuth(code, inviteToken = null) {
-    var _a;
-    try {
-      const payload = { code };
-      if (inviteToken) {
-        payload.inviteToken = inviteToken;
-      }
-      const response = await this._request("/auth/github", {
-        method: "POST",
-        body: JSON.stringify(payload),
-        methodName: "githubAuth"
-      });
-      if (response.success && response.data && response.data.tokens) {
-        const { tokens } = response.data;
-        const tokenData = {
-          access_token: tokens.accessToken,
-          refresh_token: tokens.refreshToken,
-          expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
-          token_type: "Bearer"
-        };
-        if (this._tokenManager) {
-          this._tokenManager.setTokens(tokenData);
-        }
-        this.updateContext({ authToken: tokens.accessToken });
-      }
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`GitHub auth failed: ${error.message}`, { cause: error });
-    }
-  }
-  async googleAuthCallback(code, redirectUri, inviteToken = null) {
-    var _a;
-    try {
-      const body = { code, redirectUri };
-      if (inviteToken) {
-        body.inviteToken = inviteToken;
-      }
-      const response = await this._request("/auth/google/callback", {
-        method: "POST",
-        body: JSON.stringify(body),
-        methodName: "googleAuthCallback"
-      });
-      if (response.success && response.data && response.data.tokens) {
-        const { tokens } = response.data;
-        const tokenData = {
-          access_token: tokens.accessToken,
-          refresh_token: tokens.refreshToken,
-          expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
-          token_type: "Bearer"
-        };
-        if (this._tokenManager) {
-          this._tokenManager.setTokens(tokenData);
-        }
-        this.updateContext({ authToken: tokens.accessToken });
-      }
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Google auth callback failed: ${error.message}`, { cause: error });
-    }
-  }
-  async requestPasswordReset(email) {
-    try {
-      const response = await this._request("/auth/request-password-reset", {
-        method: "POST",
-        body: JSON.stringify({ email }),
-        methodName: "requestPasswordReset"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Password reset request failed: ${error.message}`, { cause: error });
-    }
-  }
-  async confirmPasswordReset(token, password) {
-    try {
-      const response = await this._request("/auth/reset-password-confirm", {
-        method: "POST",
-        body: JSON.stringify({ token, password }),
-        methodName: "confirmPasswordReset"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Password reset confirmation failed: ${error.message}`, { cause: error });
-    }
-  }
-  async confirmRegistration(token) {
-    try {
-      const response = await this._request("/auth/register-confirmation", {
-        method: "POST",
-        body: JSON.stringify({ token }),
-        methodName: "confirmRegistration"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Registration confirmation failed: ${error.message}`, { cause: error });
-    }
-  }
-  async requestPasswordChange() {
-    this._requireReady("requestPasswordChange");
-    try {
-      const response = await this._request("/auth/request-password-change", {
-        method: "POST",
-        methodName: "requestPasswordChange"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Password change request failed: ${error.message}`, { cause: error });
-    }
-  }
-  async confirmPasswordChange(currentPassword, newPassword, code) {
-    this._requireReady("confirmPasswordChange");
-    try {
-      const response = await this._request("/auth/confirm-password-change", {
-        method: "POST",
-        body: JSON.stringify({ currentPassword, newPassword, code }),
-        methodName: "confirmPasswordChange"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Password change confirmation failed: ${error.message}`, { cause: error });
-    }
-  }
-  async getMe() {
-    this._requireReady("getMe");
-    try {
-      const response = await this._request("/auth/me", {
-        method: "GET",
-        methodName: "getMe"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get user profile: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Get stored authentication state (backward compatibility method)
-   * Replaces AuthService.getStoredAuthState()
-   */
-  async getStoredAuthState() {
-    try {
-      if (!this._tokenManager) {
-        return {
-          userId: false,
-          authToken: false
-        };
-      }
-      const tokenStatus = this._tokenManager.getTokenStatus();
-      if (!tokenStatus.hasTokens) {
-        return {
-          userId: false,
-          authToken: false
-        };
-      }
-      if (!tokenStatus.isValid && tokenStatus.hasRefreshToken) {
-        try {
-          await this._tokenManager.ensureValidToken();
-        } catch (error) {
-          console.warn("[CoreService] Token refresh failed:", error.message);
-          if (error.message.includes("401") || error.message.includes("403") || error.message.includes("invalid") || error.message.includes("expired")) {
-            this._tokenManager.clearTokens();
-            return {
-              userId: false,
-              authToken: false,
-              error: `Authentication failed: ${error.message}`
-            };
-          }
-          return {
-            userId: false,
-            authToken: this._tokenManager.getAccessToken(),
-            error: `Network error during token refresh: ${error.message}`,
-            hasTokens: true
-          };
-        }
-      }
-      const currentAccessToken = this._tokenManager.getAccessToken();
-      if (!currentAccessToken) {
-        return {
-          userId: false,
-          authToken: false
-        };
-      }
-      try {
-        const currentUser = await this.getMe();
-        return {
-          userId: currentUser.user.id,
-          authToken: currentAccessToken,
-          ...currentUser,
-          error: null
-        };
-      } catch (error) {
-        console.warn("[CoreService] Failed to get user data:", error.message);
-        if (error.message.includes("401") || error.message.includes("403")) {
-          this._tokenManager.clearTokens();
-          return {
-            userId: false,
-            authToken: false,
-            error: `Authentication failed: ${error.message}`
-          };
-        }
-        return {
-          userId: false,
-          authToken: currentAccessToken,
-          error: `Failed to get user data: ${error.message}`,
-          hasTokens: true
-        };
-      }
-    } catch (error) {
-      console.error(
-        "[CoreService] Unexpected error in getStoredAuthState:",
-        error
-      );
-      return {
-        userId: false,
-        authToken: false,
-        error: `Failed to get stored auth state: ${error.message}`
-      };
-    }
-  }
-  // ==================== USER METHODS ====================
-  async getUserProfile() {
-    this._requireReady("getUserProfile");
-    try {
-      const response = await this._request("/users/profile", {
-        method: "GET",
-        methodName: "getUserProfile"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get user profile: ${error.message}`);
-    }
-  }
-  async updateUserProfile(profileData) {
-    this._requireReady("updateUserProfile");
-    try {
-      const response = await this._request("/users/profile", {
-        method: "PATCH",
-        body: JSON.stringify(profileData),
-        methodName: "updateUserProfile"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update user profile: ${error.message}`, { cause: error });
-    }
-  }
-  async getUserProjects() {
-    this._requireReady("getUserProjects");
-    try {
-      const response = await this._request("/users/projects", {
-        method: "GET",
-        methodName: "getUserProjects"
-      });
-      if (response.success) {
-        return response.data.map((project) => ({
-          ...project,
-          ...project.icon && {
-            icon: {
-              src: `${this._apiUrl}/core/files/public/${project.icon.id}/download`,
-              ...project.icon
-            }
-          }
-        }));
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get user projects: ${error.message}`, { cause: error });
-    }
-  }
-  async getUser(userId) {
-    this._requireReady("getUser");
-    if (!userId) {
-      throw new Error("User ID is required");
-    }
-    try {
-      const response = await this._request(`/users/${userId}`, {
-        method: "GET",
-        methodName: "getUser"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get user: ${error.message}`, { cause: error });
-    }
-  }
-  async getUserByEmail(email) {
-    this._requireReady("getUserByEmail");
-    if (!email) {
-      throw new Error("Email is required");
-    }
-    try {
-      const response = await this._request(`/auth/user?email=${email}`, {
-        method: "GET",
-        methodName: "getUserByEmail"
-      });
-      if (response.success) {
-        return response.data.user;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get user by email: ${error.message}`, { cause: error });
-    }
-  }
-  // ==================== PROJECT METHODS ====================
-  async createProject(projectData) {
-    this._requireReady("createProject");
-    try {
-      const response = await this._request("/projects", {
-        method: "POST",
-        body: JSON.stringify(projectData),
-        methodName: "createProject"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create project: ${error.message}`);
-    }
-  }
-  async getProjects(params = {}) {
-    this._requireReady("getProjects");
-    try {
-      const queryParams = new URLSearchParams();
-      Object.keys(params).forEach((key) => {
-        if (params[key] != null) {
-          queryParams.append(key, params[key]);
-        }
-      });
-      const queryString = queryParams.toString();
-      const url = `/projects${queryString ? `?${queryString}` : ""}`;
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "getProjects"
-      });
-      if (response.success) {
-        return response;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get projects: ${error.message}`);
-    }
-  }
-  /**
-   * Alias for getProjects for consistency with API naming
-   */
-  async listProjects(params = {}) {
-    return await this.getProjects(params);
-  }
-  /**
-   * List only public projects (no authentication required)
-   */
-  async listPublicProjects(params = {}) {
-    try {
-      const queryParams = new URLSearchParams();
-      Object.keys(params).forEach((key) => {
-        if (params[key] != null) {
-          queryParams.append(key, params[key]);
-        }
-      });
-      const queryString = queryParams.toString();
-      const url = `/projects/public${queryString ? `?${queryString}` : ""}`;
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "listPublicProjects"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list public projects: ${error.message}`);
-    }
-  }
-  async getProject(projectId) {
-    this._requireReady("getProject");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}`, {
-        method: "GET",
-        methodName: "getProject"
-      });
-      if (response.success) {
-        const iconSrc = response.data.icon ? `${this._apiUrl}/core/files/public/${response.data.icon.id}/download` : null;
-        return {
-          ...response.data,
-          icon: { src: iconSrc, ...response.data.icon }
-        };
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get project: ${error.message}`);
-    }
-  }
-  /**
-   * Get a public project by ID (no authentication required)
-   * Corresponds to router.get('/public/:projectId', ProjectController.getPublicProject)
-   */
-  async getPublicProject(projectId) {
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/public/${projectId}`, {
-        method: "GET",
-        methodName: "getPublicProject"
-      });
-      if (response.success) {
-        const iconSrc = response.data.icon ? `${this._apiUrl}/core/files/public/${response.data.icon.id}/download` : null;
-        return {
-          ...response.data,
-          icon: { src: iconSrc, ...response.data.icon }
-        };
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get public project: ${error.message}`);
-    }
-  }
-  async getProjectByKey(key) {
-    this._requireReady("getProjectByKey");
-    if (!key) {
-      throw new Error("Project key is required");
-    }
-    try {
-      const response = await this._request(`/projects/key/${key}`, {
-        method: "GET",
-        methodName: "getProjectByKey"
-      });
-      if (response.success) {
-        const iconSrc = response.data.icon ? `${this._apiUrl}/core/files/public/${response.data.icon.id}/download` : null;
-        return {
-          ...response.data,
-          icon: { src: iconSrc, ...response.data.icon }
-        };
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get project by key: ${error.message}`);
-    }
-  }
-  /**
-   * Get current project data by key (no project ID required)
-   */
-  async getProjectDataByKey(key, options = {}) {
-    this._requireReady("getProjectDataByKey");
-    if (!key) {
-      throw new Error("Project key is required");
-    }
-    const {
-      branch = "main",
-      version = "latest",
-      includeHistory = false
-    } = options;
-    const queryParams = new URLSearchParams({
-      branch,
-      version,
-      includeHistory: includeHistory.toString()
-    }).toString();
-    try {
-      const response = await this._request(
-        `/projects/key/${key}/data?${queryParams}`,
-        {
-          method: "GET",
-          methodName: "getProjectDataByKey"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get project data by key: ${error.message}`);
-    }
-  }
-  async updateProject(projectId, data) {
-    this._requireReady("updateProject");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}`, {
-        method: "PATCH",
-        body: JSON.stringify(data),
-        methodName: "updateProject"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update project: ${error.message}`);
-    }
-  }
-  async updateProjectComponents(projectId, components) {
-    this._requireReady("updateProjectComponents");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/components`,
-        {
-          method: "PATCH",
-          body: JSON.stringify({ components }),
-          methodName: "updateProjectComponents"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update project components: ${error.message}`);
-    }
-  }
-  async updateProjectSettings(projectId, settings) {
-    this._requireReady("updateProjectSettings");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/settings`, {
-        method: "PATCH",
-        body: JSON.stringify({ settings }),
-        methodName: "updateProjectSettings"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update project settings: ${error.message}`);
-    }
-  }
-  async updateProjectName(projectId, name) {
-    this._requireReady("updateProjectName");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}`, {
-        method: "PATCH",
-        body: JSON.stringify({ name }),
-        methodName: "updateProjectName"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update project name: ${error.message}`);
-    }
-  }
-  async updateProjectPackage(projectId, pkg) {
-    this._requireReady("updateProjectPackage");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/package`, {
-        method: "PATCH",
-        body: JSON.stringify({ package: pkg }),
-        methodName: "updateProjectPackage"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update project package: ${error.message}`);
-    }
-  }
-  async duplicateProject(projectId, newName, newKey, targetUserId) {
-    this._requireReady("duplicateProject");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/duplicate`, {
-        method: "POST",
-        body: JSON.stringify({ name: newName, key: newKey, targetUserId }),
-        methodName: "duplicateProject"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to duplicate project: ${error.message}`);
-    }
-  }
-  async removeProject(projectId) {
-    this._requireReady("removeProject");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}`, {
-        method: "DELETE",
-        methodName: "removeProject"
-      });
-      if (response.success) {
-        return response;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to remove project: ${error.message}`);
-    }
-  }
-  async checkProjectKeyAvailability(key) {
-    this._requireReady("checkProjectKeyAvailability");
-    if (!key) {
-      throw new Error("Project key is required");
-    }
-    try {
-      const response = await this._request(`/projects/check-key/${key}`, {
-        method: "GET",
-        methodName: "checkProjectKeyAvailability"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(
-        `Failed to check project key availability: ${error.message}`
-      );
-    }
-  }
-  // ==================== PROJECT MEMBER METHODS ====================
-  async getProjectMembers(projectId) {
-    this._requireReady("getProjectMembers");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/members`, {
-        method: "GET",
-        methodName: "getProjectMembers"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get project members: ${error.message}`);
-    }
-  }
-  async inviteMember(projectId, email, role = "guest", options = {}) {
-    this._requireReady("inviteMember");
-    if (!projectId || !email || !role) {
-      throw new Error("Project ID, email, and role are required");
-    }
-    const { name, callbackUrl } = options;
-    const defaultCallbackUrl = typeof window === "undefined" ? "https://app.symbols.com/accept-invite" : `${window.location.origin}/accept-invite`;
-    try {
-      const requestBody = {
-        email,
-        role,
-        callbackUrl: callbackUrl || defaultCallbackUrl
-      };
-      if (name) {
-        requestBody.name = name;
-      }
-      const response = await this._request(`/projects/${projectId}/invite`, {
-        method: "POST",
-        body: JSON.stringify(requestBody),
-        methodName: "inviteMember"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to invite member: ${error.message}`);
-    }
-  }
-  async acceptInvite(token) {
-    this._requireReady("acceptInvite");
-    if (!token) {
-      throw new Error("Invitation token is required");
-    }
-    try {
-      const response = await this._request("/projects/accept-invite", {
-        method: "POST",
-        body: JSON.stringify({ token }),
-        methodName: "acceptInvite"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to accept invite: ${error.message}`);
-    }
-  }
-  async updateMemberRole(projectId, memberId, role) {
-    this._requireReady("updateMemberRole");
-    if (!projectId || !memberId || !role) {
-      throw new Error("Project ID, member ID, and role are required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/members/${memberId}`,
-        {
-          method: "PATCH",
-          body: JSON.stringify({ role }),
-          methodName: "updateMemberRole"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update member role: ${error.message}`);
-    }
-  }
-  async removeMember(projectId, memberId) {
-    this._requireReady("removeMember");
-    if (!projectId || !memberId) {
-      throw new Error("Project ID and member ID are required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/members/${memberId}`,
-        {
-          method: "DELETE",
-          methodName: "removeMember"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to remove member: ${error.message}`);
-    }
-  }
-  // ==================== PROJECT LIBRARY METHODS ====================
-  async getAvailableLibraries(params = {}) {
-    this._requireReady("getAvailableLibraries");
-    const queryParams = new URLSearchParams(params).toString();
-    try {
-      const response = await this._request(
-        `/projects/libraries/available?${queryParams}`,
-        {
-          method: "GET",
-          methodName: "getAvailableLibraries"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get available libraries: ${error.message}`);
-    }
-  }
-  async getProjectLibraries(projectId) {
-    this._requireReady("getProjectLibraries");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/libraries`, {
-        method: "GET",
-        methodName: "getProjectLibraries"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get project libraries: ${error.message}`);
-    }
-  }
-  async addProjectLibraries(projectId, libraryIds) {
-    this._requireReady("addProjectLibraries");
-    if (!projectId || !libraryIds) {
-      throw new Error("Project ID and library IDs are required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/libraries`, {
-        method: "POST",
-        body: JSON.stringify({ libraryIds }),
-        methodName: "addProjectLibraries"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to add project libraries: ${error.message}`);
-    }
-  }
-  async removeProjectLibraries(projectId, libraryIds) {
-    this._requireReady("removeProjectLibraries");
-    if (!projectId || !libraryIds) {
-      throw new Error("Project ID and library IDs are required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/libraries`, {
-        method: "DELETE",
-        body: JSON.stringify({ libraryIds }),
-        methodName: "removeProjectLibraries"
-      });
-      if (response.success) {
-        return response;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to remove project libraries: ${error.message}`);
-    }
-  }
-  // ==================== FILE METHODS ====================
-  async uploadFile(file, options = {}) {
-    this._requireReady("uploadFile");
-    if (!file) {
-      throw new Error("File is required for upload");
-    }
-    const formData = new FormData();
-    formData.append("file", file);
-    if (options.projectId) {
-      formData.append("projectId", options.projectId);
-    }
-    if (options.tags) {
-      formData.append("tags", JSON.stringify(options.tags));
-    }
-    if (options.visibility) {
-      formData.append("visibility", options.visibility || "public");
-    }
-    if (options.metadata) {
-      formData.append("metadata", JSON.stringify(options.metadata));
-    }
-    try {
-      const response = await this._request("/files/upload", {
-        method: "POST",
-        body: formData,
-        headers: {},
-        // Let browser set Content-Type for FormData
-        methodName: "uploadFile"
-      });
-      if (!response.success) {
-        throw new Error(response.message);
-      }
-      return {
-        id: response.data.id,
-        src: `${this._apiUrl}/core/files/public/${response.data.id}/download`,
-        success: true,
-        message: response.message
-      };
-    } catch (error) {
-      throw new Error(`File upload failed: ${error.message}`);
-    }
-  }
-  async updateProjectIcon(projectId, iconFile) {
-    this._requireReady("updateProjectIcon");
-    if (!projectId || !iconFile) {
-      throw new Error("Project ID and icon file are required");
-    }
-    const formData = new FormData();
-    formData.append("icon", iconFile);
-    formData.append("projectId", projectId);
-    try {
-      const response = await this._request("/files/upload-project-icon", {
-        method: "POST",
-        body: formData,
-        headers: {},
-        // Let browser set Content-Type for FormData
-        methodName: "updateProjectIcon"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update project icon: ${error.message}`);
-    }
-  }
-  // ==================== PAYMENT METHODS ====================
-  async checkout(options = {}) {
-    this._requireReady("checkout");
-    const {
-      projectId,
-      seats = 1,
-      price = "starter_monthly",
-      successUrl = `${window.location.origin}/success`,
-      cancelUrl = `${window.location.origin}/pricing`
-    } = options;
-    if (!projectId) {
-      throw new Error("Project ID is required for checkout");
-    }
-    try {
-      const response = await this._request("/payments/checkout", {
-        method: "POST",
-        body: JSON.stringify({
-          projectId,
-          seats,
-          price,
-          successUrl,
-          cancelUrl
-        }),
-        methodName: "checkout"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to checkout: ${error.message}`);
-    }
-  }
-  async getSubscriptionStatus(projectId) {
-    this._requireReady("getSubscriptionStatus");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/payments/subscription/${projectId}`,
-        {
-          method: "GET",
-          methodName: "getSubscriptionStatus"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get subscription status: ${error.message}`);
-    }
-  }
-  // ==================== DNS METHODS ====================
-  async createDnsRecord(domain, options = {}) {
-    this._requireReady("createDnsRecord");
-    if (!domain) {
-      throw new Error("Domain is required");
-    }
-    try {
-      const response = await this._request("/dns/records", {
-        method: "POST",
-        body: JSON.stringify({ domain, ...options }),
-        methodName: "createDnsRecord"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create DNS record: ${error.message}`);
-    }
-  }
-  async getDnsRecord(domain) {
-    this._requireReady("getDnsRecord");
-    if (!domain) {
-      throw new Error("Domain is required");
-    }
-    try {
-      const response = await this._request(`/dns/records/${domain}`, {
-        method: "GET",
-        methodName: "getDnsRecord"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get DNS record: ${error.message}`);
-    }
-  }
-  async removeDnsRecord(domain) {
-    this._requireReady("removeDnsRecord");
-    if (!domain) {
-      throw new Error("Domain is required");
-    }
-    try {
-      const response = await this._request(`/dns/records/${domain}`, {
-        method: "DELETE",
-        methodName: "removeDnsRecord"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to remove DNS record: ${error.message}`);
-    }
-  }
-  async setProjectDomains(projectKey, customDomain, hasCustomDomainAccess = false) {
-    this._requireReady("setProjectDomains");
-    if (!projectKey) {
-      throw new Error("Project key is required");
-    }
-    try {
-      const response = await this._request("/dns/project-domains", {
-        method: "POST",
-        body: JSON.stringify({
-          projectKey,
-          customDomain,
-          hasCustomDomainAccess
-        }),
-        methodName: "setProjectDomains"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to set project domains: ${error.message}`);
-    }
-  }
-  async addProjectCustomDomains(projectId, customDomains) {
-    this._requireReady("addProjectCustomDomains");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!customDomains || Array.isArray(customDomains) && !customDomains.length) {
-      throw new Error(
-        "customDomains is required and must be a non-empty string or array"
-      );
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/domains`, {
-        method: "PATCH",
-        body: JSON.stringify({ customDomains }),
-        methodName: "addProjectCustomDomains"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(
-        `Failed to update project custom domains: ${error.message}`
-      );
-    }
-  }
-  // ==================== UTILITY METHODS ====================
-  async getHealthStatus() {
-    try {
-      const response = await this._request("/health", {
-        method: "GET",
-        methodName: "getHealthStatus"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get health status: ${error.message}`);
-    }
-  }
-  // ==================== PROJECT DATA METHODS (SYMSTORY REPLACEMENT) ====================
-  /**
-   * Apply changes to a project, creating a new version
-   * Replaces: SymstoryService.updateData()
-   */
-  async applyProjectChanges(projectId, changes, options = {}) {
-    this._requireReady("applyProjectChanges");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!Array.isArray(changes)) {
-      throw new Error("Changes must be an array");
-    }
-    const { message, branch = "main", type = "patch" } = options;
-    try {
-      const response = await this._request(`/projects/${projectId}/changes`, {
-        method: "POST",
-        body: JSON.stringify({
-          changes,
-          message,
-          branch,
-          type
-        }),
-        methodName: "applyProjectChanges"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to apply project changes: ${error.message}`);
-    }
-  }
-  /**
-   * Get current project data for a specific branch
-   * Replaces: SymstoryService.getData()
-   */
-  async getProjectData(projectId, options = {}) {
-    this._requireReady("getProjectData");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    const {
-      branch = "main",
-      version = "latest",
-      includeHistory = false
-    } = options;
-    const queryParams = new URLSearchParams({
-      branch,
-      version,
-      includeHistory: includeHistory.toString()
-    }).toString();
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/data?${queryParams}`,
-        {
-          method: "GET",
-          methodName: "getProjectData"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get project data: ${error.message}`);
-    }
-  }
-  /**
-   * Get project versions with pagination
-   */
-  async getProjectVersions(projectId, options = {}) {
-    this._requireReady("getProjectVersions");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    const { branch = "main", page = 1, limit = 50 } = options;
-    const queryParams = new URLSearchParams({
-      branch,
-      page: page.toString(),
-      limit: limit.toString()
-    }).toString();
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/versions?${queryParams}`,
-        {
-          method: "GET",
-          methodName: "getProjectVersions"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get project versions: ${error.message}`);
-    }
-  }
-  /**
-   * Restore project to a previous version
-   * Replaces: SymstoryService.restoreVersion()
-   */
-  async restoreProjectVersion(projectId, version, options = {}) {
-    this._requireReady("restoreProjectVersion");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!version) {
-      throw new Error("Version is required");
-    }
-    const { message, branch = "main", type = "patch" } = options;
-    try {
-      const response = await this._request(`/projects/${projectId}/restore`, {
-        method: "POST",
-        body: JSON.stringify({
-          version,
-          message,
-          branch,
-          type
-        }),
-        methodName: "restoreProjectVersion"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to restore project version: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to update a single item in the project
-   * Convenience wrapper around applyProjectChanges
-   */
-  async updateProjectItem(projectId, path, value, options = {}) {
-    const changes = [["update", path, value]];
-    const message = options.message || `Updated ${Array.isArray(path) ? path.join(".") : path}`;
-    return await this.applyProjectChanges(projectId, changes, {
-      ...options,
-      message
-    });
-  }
-  /**
-   * Helper method to delete an item from the project
-   * Convenience wrapper around applyProjectChanges
-   */
-  async deleteProjectItem(projectId, path, options = {}) {
-    const changes = [["delete", path]];
-    const message = options.message || `Deleted ${Array.isArray(path) ? path.join(".") : path}`;
-    return await this.applyProjectChanges(projectId, changes, {
-      ...options,
-      message
-    });
-  }
-  /**
-   * Helper method to set a value in the project (alias for update)
-   * Convenience wrapper around applyProjectChanges
-   */
-  async setProjectValue(projectId, path, value, options = {}) {
-    const changes = [["set", path, value]];
-    const message = options.message || `Set ${Array.isArray(path) ? path.join(".") : path}`;
-    return await this.applyProjectChanges(projectId, changes, {
-      ...options,
-      message
-    });
-  }
-  /**
-   * Helper method to add multiple items to the project
-   * Convenience wrapper around applyProjectChanges
-   */
-  async addProjectItems(projectId, items, options = {}) {
-    const changes = items.map((item) => {
-      const [type, data] = item;
-      const { value, ...schema } = data;
-      return [
-        ["update", [type, data.key], value],
-        ["update", ["schema", type, data.key], schema]
-      ];
-    }).flat();
-    const message = options.message || `Added ${items.length} items`;
-    return await this.applyProjectChanges(projectId, changes, {
-      ...options,
-      message
-    });
-  }
-  /**
-   * Helper method to get specific data from project by path
-   * Convenience wrapper that gets project data and extracts specific path
-   */
-  async getProjectItemByPath(projectId, path, options = {}) {
-    const projectData = await this.getProjectData(projectId, options);
-    if (!(projectData == null ? void 0 : projectData.data)) {
-      return null;
-    }
-    let current = projectData.data;
-    const pathArray = Array.isArray(path) ? path : [path];
-    for (const segment of pathArray) {
-      if (current && typeof current === "object" && segment in current) {
-        current = current[segment];
-      } else {
-        return null;
-      }
-    }
-    return current;
-  }
-  // ==================== PULL REQUEST METHODS ====================
-  /**
-   * Create a new pull request
-   */
-  async createPullRequest(projectId, pullRequestData) {
-    this._requireReady("createPullRequest");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!pullRequestData.source || !pullRequestData.target || !pullRequestData.title) {
-      throw new Error("Source branch, target branch, and title are required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/pull-requests`,
-        {
-          method: "POST",
-          body: JSON.stringify(pullRequestData),
-          methodName: "createPullRequest"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create pull request: ${error.message}`);
-    }
-  }
-  /**
-   * List pull requests for a project with filtering options
-   */
-  async listPullRequests(projectId, options = {}) {
-    this._requireReady("listPullRequests");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    const { status = "open", source, target, page = 1, limit = 20 } = options;
-    const queryParams = new URLSearchParams({
-      status,
-      page: page.toString(),
-      limit: limit.toString()
-    });
-    if (source) {
-      queryParams.append("source", source);
-    }
-    if (target) {
-      queryParams.append("target", target);
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/pull-requests?${queryParams.toString()}`,
-        {
-          method: "GET",
-          methodName: "listPullRequests"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list pull requests: ${error.message}`);
-    }
-  }
-  /**
-   * Get detailed information about a specific pull request
-   */
-  async getPullRequest(projectId, prId) {
-    this._requireReady("getPullRequest");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!prId) {
-      throw new Error("Pull request ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/pull-requests/${prId}`,
-        {
-          method: "GET",
-          methodName: "getPullRequest"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get pull request: ${error.message}`);
-    }
-  }
-  /**
-   * Submit a review for a pull request
-   */
-  async reviewPullRequest(projectId, prId, reviewData) {
-    this._requireReady("reviewPullRequest");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!prId) {
-      throw new Error("Pull request ID is required");
-    }
-    const validStatuses = ["approved", "requested_changes", "feedback"];
-    if (reviewData.status && !validStatuses.includes(reviewData.status)) {
-      throw new Error(
-        `Invalid review status. Must be one of: ${validStatuses.join(", ")}`
-      );
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/pull-requests/${prId}/review`,
-        {
-          method: "POST",
-          body: JSON.stringify(reviewData),
-          methodName: "reviewPullRequest"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to review pull request: ${error.message}`);
-    }
-  }
-  /**
-   * Add a comment to an existing review thread
-   */
-  async addPullRequestComment(projectId, prId, commentData) {
-    this._requireReady("addPullRequestComment");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!prId) {
-      throw new Error("Pull request ID is required");
-    }
-    if (!commentData.value) {
-      throw new Error("Comment value is required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/pull-requests/${prId}/comment`,
-        {
-          method: "POST",
-          body: JSON.stringify(commentData),
-          methodName: "addPullRequestComment"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to add pull request comment: ${error.message}`);
-    }
-  }
-  /**
-   * Merge an approved pull request
-   */
-  async mergePullRequest(projectId, prId) {
-    this._requireReady("mergePullRequest");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!prId) {
-      throw new Error("Pull request ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/pull-requests/${prId}/merge`,
-        {
-          method: "POST",
-          methodName: "mergePullRequest"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      if (error.message.includes("conflicts") || error.message.includes("409")) {
-        throw new Error(`Pull request has merge conflicts: ${error.message}`);
-      }
-      throw new Error(`Failed to merge pull request: ${error.message}`);
-    }
-  }
-  /**
-   * Get the diff/changes for a pull request
-   */
-  async getPullRequestDiff(projectId, prId) {
-    this._requireReady("getPullRequestDiff");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!prId) {
-      throw new Error("Pull request ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/pull-requests/${prId}/diff`,
-        {
-          method: "GET",
-          methodName: "getPullRequestDiff"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get pull request diff: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to create a pull request with validation
-   */
-  async createPullRequestWithValidation(projectId, data) {
-    const { source, target, title, description, changes } = data;
-    if (source === target) {
-      throw new Error("Source and target branches cannot be the same");
-    }
-    if (!title || title.trim().length === 0) {
-      throw new Error("Pull request title cannot be empty");
-    }
-    if (title.length > 200) {
-      throw new Error("Pull request title cannot exceed 200 characters");
-    }
-    const pullRequestData = {
-      source: source.trim(),
-      target: target.trim(),
-      title: title.trim(),
-      ...description && { description: description.trim() },
-      ...changes && { changes }
-    };
-    return await this.createPullRequest(projectId, pullRequestData);
-  }
-  /**
-   * Helper method to approve a pull request
-   */
-  async approvePullRequest(projectId, prId, comment = "") {
-    const reviewData = {
-      status: "approved",
-      ...comment && {
-        threads: [
-          {
-            comment,
-            type: "praise"
-          }
-        ]
-      }
-    };
-    return await this.reviewPullRequest(projectId, prId, reviewData);
-  }
-  /**
-   * Helper method to request changes on a pull request
-   */
-  async requestPullRequestChanges(projectId, prId, threads = []) {
-    if (!threads || threads.length === 0) {
-      throw new Error("Must provide specific feedback when requesting changes");
-    }
-    const reviewData = {
-      status: "requested_changes",
-      threads
-    };
-    return await this.reviewPullRequest(projectId, prId, reviewData);
-  }
-  /**
-   * Helper method to get pull requests by status
-   */
-  async getOpenPullRequests(projectId, options = {}) {
-    return await this.listPullRequests(projectId, {
-      ...options,
-      status: "open"
-    });
-  }
-  async getClosedPullRequests(projectId, options = {}) {
-    return await this.listPullRequests(projectId, {
-      ...options,
-      status: "closed"
-    });
-  }
-  async getMergedPullRequests(projectId, options = {}) {
-    return await this.listPullRequests(projectId, {
-      ...options,
-      status: "merged"
-    });
-  }
-  /**
-   * Helper method to check if a pull request is canMerge
-   */
-  async isPullRequestMergeable(projectId, prId) {
-    var _a;
-    try {
-      const prData = await this.getPullRequest(projectId, prId);
-      return ((_a = prData == null ? void 0 : prData.data) == null ? void 0 : _a.canMerge) || false;
-    } catch (error) {
-      throw new Error(
-        `Failed to check pull request mergeability: ${error.message}`
-      );
-    }
-  }
-  /**
-   * Helper method to get pull request status summary
-   */
-  async getPullRequestStatusSummary(projectId, prId) {
-    var _a, _b, _c;
-    try {
-      const prData = await this.getPullRequest(projectId, prId);
-      const pr = prData == null ? void 0 : prData.data;
-      if (!pr) {
-        throw new Error("Pull request not found");
-      }
-      return {
-        status: pr.status,
-        reviewStatus: pr.reviewStatus,
-        canMerge: pr.canMerge,
-        hasConflicts: !pr.canMerge,
-        reviewCount: ((_a = pr.reviews) == null ? void 0 : _a.length) || 0,
-        approvedReviews: ((_b = pr.reviews) == null ? void 0 : _b.filter((r) => r.status === "approved").length) || 0,
-        changesRequested: ((_c = pr.reviews) == null ? void 0 : _c.filter((r) => r.status === "requested_changes").length) || 0
-      };
-    } catch (error) {
-      throw new Error(
-        `Failed to get pull request status summary: ${error.message}`
-      );
-    }
-  }
-  // ==================== BRANCH MANAGEMENT METHODS ====================
-  /**
-   * Get all branches for a project
-   */
-  async listBranches(projectId) {
-    this._requireReady("listBranches");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/projects/${projectId}/branches`, {
-        method: "GET",
-        methodName: "listBranches"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list branches: ${error.message}`);
-    }
-  }
-  /**
-   * Create a new branch from an existing branch
-   */
-  async createBranch(projectId, branchData) {
-    this._requireReady("createBranch");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!branchData.name) {
-      throw new Error("Branch name is required");
-    }
-    const { name, source = "main" } = branchData;
-    try {
-      const response = await this._request(`/projects/${projectId}/branches`, {
-        method: "POST",
-        body: JSON.stringify({ name, source }),
-        methodName: "createBranch"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create branch: ${error.message}`);
-    }
-  }
-  /**
-   * Delete a branch (cannot delete main branch)
-   */
-  async deleteBranch(projectId, branchName) {
-    this._requireReady("deleteBranch");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!branchName) {
-      throw new Error("Branch name is required");
-    }
-    if (branchName === "main") {
-      throw new Error("Cannot delete main branch");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/branches/${encodeURIComponent(branchName)}`,
-        {
-          method: "DELETE",
-          methodName: "deleteBranch"
-        }
-      );
-      if (response.success) {
-        return response;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to delete branch: ${error.message}`);
-    }
-  }
-  /**
-   * Rename a branch (cannot rename main branch)
-   */
-  async renameBranch(projectId, branchName, newName) {
-    this._requireReady("renameBranch");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!branchName) {
-      throw new Error("Current branch name is required");
-    }
-    if (!newName) {
-      throw new Error("New branch name is required");
-    }
-    if (branchName === "main") {
-      throw new Error("Cannot rename main branch");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/branches/${encodeURIComponent(
-          branchName
-        )}/rename`,
-        {
-          method: "POST",
-          body: JSON.stringify({ newName }),
-          methodName: "renameBranch"
-        }
-      );
-      if (response.success) {
-        return response;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to rename branch: ${error.message}`);
-    }
-  }
-  /**
-   * Get changes/diff for a branch compared to another version
-   */
-  async getBranchChanges(projectId, branchName = "main", options = {}) {
-    this._requireReady("getBranchChanges");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!branchName) {
-      throw new Error("Branch name is required");
-    }
-    const { versionId, versionValue, target } = options;
-    const queryParams = new URLSearchParams();
-    if (versionId) {
-      queryParams.append("versionId", versionId);
-    }
-    if (versionValue) {
-      queryParams.append("versionValue", versionValue);
-    }
-    if (target) {
-      queryParams.append("target", target);
-    }
-    const queryString = queryParams.toString();
-    const url = `/projects/${projectId}/branches/${encodeURIComponent(
-      branchName
-    )}/changes${queryString ? `?${queryString}` : ""}`;
-    try {
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "getBranchChanges"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get branch changes: ${error.message}`);
-    }
-  }
-  /**
-   * Merge changes between branches (preview or commit)
-   */
-  async mergeBranch(projectId, branchName, mergeData = {}) {
-    this._requireReady("mergeBranch");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!branchName) {
-      throw new Error("Source branch name is required");
-    }
-    const {
-      target = "main",
-      message,
-      type = "patch",
-      commit = false,
-      changes
-    } = mergeData;
-    const requestBody = {
-      target,
-      type,
-      commit,
-      ...message && { message },
-      ...changes && { changes }
-    };
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/branches/${encodeURIComponent(
-          branchName
-        )}/merge`,
-        {
-          method: "POST",
-          body: JSON.stringify(requestBody),
-          methodName: "mergeBranch"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      if (error.message.includes("conflicts") || error.message.includes("409")) {
-        throw new Error(`Merge conflicts detected: ${error.message}`);
-      }
-      throw new Error(`Failed to merge branch: ${error.message}`);
-    }
-  }
-  /**
-   * Reset a branch to a clean state
-   */
-  async resetBranch(projectId, branchName) {
-    this._requireReady("resetBranch");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!branchName) {
-      throw new Error("Branch name is required");
-    }
-    try {
-      const response = await this._request(
-        `/projects/${projectId}/branches/${encodeURIComponent(
-          branchName
-        )}/reset`,
-        {
-          method: "POST",
-          methodName: "resetBranch"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to reset branch: ${error.message}`);
-    }
-  }
-  /**
-   * Publish a specific version as the live version
-   */
-  async publishVersion(projectId, publishData) {
-    this._requireReady("publishVersion");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    if (!publishData.version) {
-      throw new Error("Version is required");
-    }
-    const { version, branch = "main" } = publishData;
-    try {
-      const response = await this._request(`/projects/${projectId}/publish`, {
-        method: "POST",
-        body: JSON.stringify({ version, branch }),
-        methodName: "publishVersion"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to publish version: ${error.message}`);
-    }
-  }
-  // ==================== BRANCH HELPER METHODS ====================
-  /**
-   * Helper method to create a branch with validation
-   */
-  async createBranchWithValidation(projectId, name, source = "main") {
-    if (!name || name.trim().length === 0) {
-      throw new Error("Branch name cannot be empty");
-    }
-    if (name.includes(" ")) {
-      throw new Error("Branch name cannot contain spaces");
-    }
-    if (name === "main") {
-      throw new Error('Cannot create a branch named "main"');
-    }
-    const sanitizedName = name.trim().toLowerCase().replace(/[^a-z0-9-_]/gu, "-");
-    return await this.createBranch(projectId, {
-      name: sanitizedName,
-      source
-    });
-  }
-  /**
-   * Helper method to check if a branch exists
-   */
-  async branchExists(projectId, branchName) {
-    var _a;
-    try {
-      const branches = await this.listBranches(projectId);
-      return ((_a = branches == null ? void 0 : branches.data) == null ? void 0 : _a.includes(branchName)) || false;
-    } catch (error) {
-      throw new Error(`Failed to check if branch exists: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to preview merge without committing
-   */
-  async previewMerge(projectId, sourceBranch, targetBranch = "main") {
-    return await this.mergeBranch(projectId, sourceBranch, {
-      target: targetBranch,
-      commit: false
-    });
-  }
-  /**
-   * Helper method to commit merge after preview
-   */
-  async commitMerge(projectId, sourceBranch, options = {}) {
-    const {
-      target = "main",
-      message = `Merge ${sourceBranch} into ${target}`,
-      type = "patch",
-      changes
-    } = options;
-    return await this.mergeBranch(projectId, sourceBranch, {
-      target,
-      message,
-      type,
-      commit: true,
-      changes
-    });
-  }
-  /**
-   * Helper method to create a feature branch from main
-   */
-  async createFeatureBranch(projectId, featureName) {
-    const branchName = `feature/${featureName.toLowerCase().replace(/[^a-z0-9-]/gu, "-")}`;
-    return await this.createBranch(projectId, {
-      name: branchName,
-      source: "main"
-    });
-  }
-  /**
-   * Helper method to create a hotfix branch from main
-   */
-  async createHotfixBranch(projectId, hotfixName) {
-    const branchName = `hotfix/${hotfixName.toLowerCase().replace(/[^a-z0-9-]/gu, "-")}`;
-    return await this.createBranch(projectId, {
-      name: branchName,
-      source: "main"
-    });
-  }
-  /**
-   * Helper method to get branch status summary
-   */
-  async getBranchStatus(projectId, branchName) {
-    var _a, _b, _c;
-    try {
-      const [branches, changes] = await Promise.all([
-        this.listBranches(projectId),
-        this.getBranchChanges(projectId, branchName).catch(() => null)
-      ]);
-      const exists = ((_a = branches == null ? void 0 : branches.data) == null ? void 0 : _a.includes(branchName)) || false;
-      const hasChanges = ((_b = changes == null ? void 0 : changes.data) == null ? void 0 : _b.length) > 0;
-      return {
-        exists,
-        hasChanges,
-        changeCount: ((_c = changes == null ? void 0 : changes.data) == null ? void 0 : _c.length) || 0,
-        canDelete: exists && branchName !== "main",
-        canRename: exists && branchName !== "main"
-      };
-    } catch (error) {
-      throw new Error(`Failed to get branch status: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to safely delete a branch with confirmation
-   */
-  async deleteBranchSafely(projectId, branchName, options = {}) {
-    const { force = false } = options;
-    if (!force) {
-      const status = await this.getBranchStatus(projectId, branchName);
-      if (!status.exists) {
-        throw new Error(`Branch '${branchName}' does not exist`);
-      }
-      if (!status.canDelete) {
-        throw new Error(`Branch '${branchName}' cannot be deleted`);
-      }
-      if (status.hasChanges) {
-        throw new Error(
-          `Branch '${branchName}' has uncommitted changes. Use force option to delete anyway.`
-        );
-      }
-    }
-    return await this.deleteBranch(projectId, branchName);
-  }
-  // ==================== ADMIN METHODS ====================
-  /**
-   * Get admin users list with comprehensive filtering and search capabilities
-   * Requires admin or super_admin global role
-   */
-  async getAdminUsers(params = {}) {
-    this._requireReady("getAdminUsers");
-    const {
-      emails,
-      ids,
-      query,
-      status,
-      page = 1,
-      limit = 50,
-      sort = { field: "createdAt", order: "desc" }
-    } = params;
-    const queryParams = new URLSearchParams();
-    if (emails) {
-      queryParams.append("emails", emails);
-    }
-    if (ids) {
-      queryParams.append("ids", ids);
-    }
-    if (query) {
-      queryParams.append("query", query);
-    }
-    if (status) {
-      queryParams.append("status", status);
-    }
-    if (page) {
-      queryParams.append("page", page.toString());
-    }
-    if (limit) {
-      queryParams.append("limit", limit.toString());
-    }
-    if (sort && sort.field) {
-      queryParams.append("sort[field]", sort.field);
-      queryParams.append("sort[order]", sort.order || "desc");
-    }
-    const queryString = queryParams.toString();
-    const url = `/users/admin/users${queryString ? `?${queryString}` : ""}`;
-    try {
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "getAdminUsers"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get admin users: ${error.message}`);
-    }
-  }
-  /**
-   * Assign projects to a specific user
-   * Requires admin or super_admin global role
-   */
-  async assignProjectsToUser(userId, options = {}) {
-    this._requireReady("assignProjectsToUser");
-    if (!userId) {
-      throw new Error("User ID is required");
-    }
-    const { projectIds, role = "guest" } = options;
-    const requestBody = {
-      userId,
-      role
-    };
-    if (projectIds && Array.isArray(projectIds)) {
-      requestBody.projectIds = projectIds;
-    }
-    try {
-      const response = await this._request("/assign-projects", {
-        method: "POST",
-        body: JSON.stringify(requestBody),
-        methodName: "assignProjectsToUser"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to assign projects to user: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method for admin users search
-   */
-  async searchAdminUsers(searchQuery, options = {}) {
-    return await this.getAdminUsers({
-      query: searchQuery,
-      ...options
-    });
-  }
-  /**
-   * Helper method to get admin users by email list
-   */
-  async getAdminUsersByEmails(emails, options = {}) {
-    const emailList = Array.isArray(emails) ? emails.join(",") : emails;
-    return await this.getAdminUsers({
-      emails: emailList,
-      ...options
-    });
-  }
-  /**
-   * Helper method to get admin users by ID list
-   */
-  async getAdminUsersByIds(ids, options = {}) {
-    const idList = Array.isArray(ids) ? ids.join(",") : ids;
-    return await this.getAdminUsers({
-      ids: idList,
-      ...options
-    });
-  }
-  /**
-   * Helper method to assign specific projects to a user with a specific role
-   */
-  async assignSpecificProjectsToUser(userId, projectIds, role = "guest") {
-    if (!Array.isArray(projectIds) || projectIds.length === 0) {
-      throw new Error("Project IDs must be a non-empty array");
-    }
-    return await this.assignProjectsToUser(userId, {
-      projectIds,
-      role
-    });
-  }
-  /**
-   * Helper method to assign all projects to a user with a specific role
-   */
-  async assignAllProjectsToUser(userId, role = "guest") {
-    return await this.assignProjectsToUser(userId, {
-      role
-    });
-  }
-  async updateUser(userId, userData) {
-    var _a;
-    this._requireReady("updateUser");
-    if (!userId) {
-      throw new Error("User ID is required");
-    }
-    if (!userData || typeof userData !== "object" || Object.keys(userData).length === 0) {
-      throw new Error("userData must be a non-empty object");
-    }
-    try {
-      const response = await this._request(`/users/${userId}`, {
-        method: "PATCH",
-        body: JSON.stringify(userData),
-        methodName: "updateUser"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      if ((_a = error.message) == null ? void 0 : _a.includes("Duplicate")) {
-        throw new Error("Username already exists");
-      }
-      throw new Error(`Failed to update user: ${error.message}`);
-    }
-  }
-  // Cleanup
-  destroy() {
-    if (this._tokenManager) {
-      this._tokenManager.destroy();
-      this._tokenManager = null;
-    }
-    this._client = null;
-    this._initialized = false;
-    this._setReady(false);
-  }
-  // ==================== FAVORITE PROJECT METHODS ====================
-  async getFavoriteProjects() {
-    this._requireReady("getFavoriteProjects");
-    try {
-      const response = await this._request("/users/favorites", {
-        method: "GET",
-        methodName: "getFavoriteProjects"
-      });
-      if (response.success) {
-        return (response.data || []).map((project) => ({
-          isFavorite: true,
-          ...project,
-          ...project.icon && {
-            icon: {
-              src: `${this._apiUrl}/core/files/public/${project.icon.id}/download`,
-              ...project.icon
-            }
-          }
-        }));
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get favorite projects: ${error.message}`);
-    }
-  }
-  async addFavoriteProject(projectId) {
-    this._requireReady("addFavoriteProject");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/users/favorites/${projectId}`, {
-        method: "POST",
-        methodName: "addFavoriteProject"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to add favorite project: ${error.message}`);
-    }
-  }
-  async removeFavoriteProject(projectId) {
-    this._requireReady("removeFavoriteProject");
-    if (!projectId) {
-      throw new Error("Project ID is required");
-    }
-    try {
-      const response = await this._request(`/users/favorites/${projectId}`, {
-        method: "DELETE",
-        methodName: "removeFavoriteProject"
-      });
-      if (response.success) {
-        return response.message || "Project removed from favorites";
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to remove favorite project: ${error.message}`);
-    }
-  }
-  // ==================== RECENT PROJECT METHODS ====================
-  async getRecentProjects(options = {}) {
-    this._requireReady("getRecentProjects");
-    const { limit = 20 } = options;
-    const queryString = new URLSearchParams({
-      limit: limit.toString()
-    }).toString();
-    const url = `/users/projects/recent${queryString ? `?${queryString}` : ""}`;
-    try {
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "getRecentProjects"
-      });
-      if (response.success) {
-        return (response.data || []).map((item) => ({
-          ...item.project,
-          ...item.project && item.project.icon && {
-            icon: {
-              src: `${this._apiUrl}/core/files/public/${item.project.icon.id}/download`,
-              ...item.project.icon
-            }
-          }
-        }));
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get recent projects: ${error.message}`);
-    }
-  }
-  // ==================== PLAN METHODS ====================
-  /**
-   * Get list of public plans (no authentication required)
-   */
-  async getPlans() {
-    try {
-      const response = await this._request("/plans", {
-        method: "GET",
-        methodName: "getPlans"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get plans: ${error.message}`);
-    }
-  }
-  /**
-   * Get a specific plan by ID (no authentication required)
-   */
-  async getPlan(planId) {
-    if (!planId) {
-      throw new Error("Plan ID is required");
-    }
-    try {
-      const response = await this._request(`/plans/${planId}`, {
-        method: "GET",
-        methodName: "getPlan"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get plan: ${error.message}`);
-    }
-  }
-  // ==================== ADMIN PLAN METHODS ====================
-  /**
-   * Get all plans including inactive ones (admin only)
-   */
-  async getAdminPlans() {
-    this._requireReady("getAdminPlans");
-    try {
-      const response = await this._request("/admin/plans", {
-        method: "GET",
-        methodName: "getAdminPlans"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to get admin plans: ${error.message}`);
-    }
-  }
-  /**
-   * Create a new plan (admin only)
-   */
-  async createPlan(planData) {
-    this._requireReady("createPlan");
-    if (!planData || typeof planData !== "object") {
-      throw new Error("Plan data is required");
-    }
-    try {
-      const response = await this._request("/admin/plans", {
-        method: "POST",
-        body: JSON.stringify(planData),
-        methodName: "createPlan"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create plan: ${error.message}`);
-    }
-  }
-  /**
-   * Update an existing plan (admin only)
-   */
-  async updatePlan(planId, planData) {
-    this._requireReady("updatePlan");
-    if (!planId) {
-      throw new Error("Plan ID is required");
-    }
-    if (!planData || typeof planData !== "object") {
-      throw new Error("Plan data is required");
-    }
-    try {
-      const response = await this._request(`/admin/plans/${planId}`, {
-        method: "PATCH",
-        body: JSON.stringify(planData),
-        methodName: "updatePlan"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update plan: ${error.message}`);
-    }
-  }
-  /**
-   * Delete a plan (soft delete + archive Stripe product) (admin only)
-   */
-  async deletePlan(planId) {
-    this._requireReady("deletePlan");
-    if (!planId) {
-      throw new Error("Plan ID is required");
-    }
-    try {
-      const response = await this._request(`/admin/plans/${planId}`, {
-        method: "DELETE",
-        methodName: "deletePlan"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to delete plan: ${error.message}`);
-    }
-  }
-  /**
-   * Initialize default plans (admin only)
-   */
-  async initializePlans() {
-    this._requireReady("initializePlans");
-    try {
-      const response = await this._request("/admin/plans/initialize", {
-        method: "POST",
-        methodName: "initializePlans"
-      });
-      if (response.success) {
-        return response;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to initialize plans: ${error.message}`);
-    }
-  }
-  // ==================== PLAN HELPER METHODS ====================
-  /**
-   * Helper method to get plans with validation
-   */
-  async getPlansWithValidation() {
-    try {
-      const plans = await this.getPlans();
-      if (!Array.isArray(plans)) {
-        throw new Error("Invalid response format: plans should be an array");
-      }
-      return plans;
-    } catch (error) {
-      throw new Error(`Failed to get plans with validation: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to get a plan by ID with validation
-   */
-  async getPlanWithValidation(planId) {
-    if (!planId || typeof planId !== "string") {
-      throw new Error("Plan ID must be a valid string");
-    }
-    try {
-      const plan = await this.getPlan(planId);
-      if (!plan || typeof plan !== "object") {
-        throw new Error("Invalid plan data received");
-      }
-      return plan;
-    } catch (error) {
-      throw new Error(`Failed to get plan with validation: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to create a plan with validation (admin only)
-   */
-  async createPlanWithValidation(planData) {
-    if (!planData || typeof planData !== "object") {
-      throw new Error("Plan data must be a valid object");
-    }
-    const requiredFields = ["name", "key", "price"];
-    for (const field of requiredFields) {
-      if (!planData[field]) {
-        throw new Error(`Required field '${field}' is missing`);
-      }
-    }
-    if (typeof planData.price !== "number" || planData.price < 0) {
-      throw new Error("Price must be a positive number");
-    }
-    if (!/^[a-z0-9-]+$/u.test(planData.key)) {
-      throw new Error("Plan key must contain only lowercase letters, numbers, and hyphens");
-    }
-    return await this.createPlan(planData);
-  }
-  /**
-   * Helper method to update a plan with validation (admin only)
-   */
-  async updatePlanWithValidation(planId, planData) {
-    if (!planId || typeof planId !== "string") {
-      throw new Error("Plan ID must be a valid string");
-    }
-    if (!planData || typeof planData !== "object") {
-      throw new Error("Plan data must be a valid object");
-    }
-    if (planData.price != null) {
-      if (typeof planData.price !== "number" || planData.price < 0) {
-        throw new Error("Price must be a positive number");
-      }
-    }
-    if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
-      throw new Error("Plan key must contain only lowercase letters, numbers, and hyphens");
-    }
-    return await this.updatePlan(planId, planData);
-  }
-  /**
-   * Helper method to get active plans only
-   */
-  async getActivePlans() {
-    try {
-      const plans = await this.getPlans();
-      return plans.filter((plan) => plan.active !== false);
-    } catch (error) {
-      throw new Error(`Failed to get active plans: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to get plans by price range
-   */
-  async getPlansByPriceRange(minPrice = 0, maxPrice = Infinity) {
-    try {
-      const plans = await this.getPlans();
-      return plans.filter((plan) => {
-        const price = plan.price || 0;
-        return price >= minPrice && price <= maxPrice;
-      });
-    } catch (error) {
-      throw new Error(`Failed to get plans by price range: ${error.message}`);
-    }
-  }
-  /**
-   * Helper method to find plan by key
-   */
-  async getPlanByKey(key) {
-    if (!key) {
-      throw new Error("Plan key is required");
-    }
-    try {
-      const plans = await this.getPlans();
-      const plan = plans.find((p) => p.key === key);
-      if (!plan) {
-        throw new Error(`Plan with key '${key}' not found`);
-      }
-      return plan;
-    } catch (error) {
-      throw new Error(`Failed to get plan by key: ${error.message}`);
-    }
-  }
-};
-export {
-  CoreService
-};
-// @preserve-env