@symbo.ls/sdk 3.2.3 → 3.2.7

package/dist/esm/services/ProjectService.js

@@ -0,0 +1,2526 @@
+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,
+      // Tracking is enabled by default unless overridden per environment
+      trackingEnabled: true
+    }
+  },
+  // 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: "",
+    // For grafana tracing
+    grafanaAppName: "Symbols Localhost",
+    // Environment-specific feature toggles (override common)
+    features: {
+      // Disable tracking by default on localhost/dev machines
+      trackingEnabled: false,
+      // Enable beta features in local dev
+      betaFeatures: true,
+      // Preserve common defaults explicitly for local
+      newUserOnboarding: true
+    },
+    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: "",
+    // 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: "",
+    // 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: "",
+    // For grafana tracing
+    grafanaAppName: "Symbols Staging",
+    typesenseCollectionName: "docs",
+    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
+    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
+    typesensePort: "443",
+    typesenseProtocol: "https"
+  },
+  preview: {
+    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 Preview",
+    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,
+      // Deep-merge feature flags so env-specific overrides don't drop common defaults
+      features: {
+        ...CONFIG.common.features || {},
+        ...CONFIG[env] && CONFIG[env].features || {}
+      },
+      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",
+      isPreview: env === "preview",
+      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;
+  }
+  _getTrackingService() {
+    var _a;
+    const services = (_a = this._context) == null ? void 0 : _a.services;
+    const tracking = services == null ? void 0 : services.tracking;
+    if (!tracking || typeof tracking.trackError !== "function") {
+      return null;
+    }
+    return tracking;
+  }
+  _shouldTrackErrors() {
+    var _a;
+    const name = (_a = this == null ? void 0 : this.constructor) == null ? void 0 : _a.name;
+    return name !== "TrackingService";
+  }
+  _trackServiceError(error, details = {}) {
+    var _a;
+    if (!this._shouldTrackErrors()) {
+      return;
+    }
+    try {
+      const tracking = this._getTrackingService();
+      if (!tracking) {
+        return;
+      }
+      const context = {
+        service: ((_a = this == null ? void 0 : this.constructor) == null ? void 0 : _a.name) || "UnknownService",
+        apiUrl: this._apiUrl || null,
+        ...details
+      };
+      tracking.trackError(error instanceof Error ? error : new Error(String(error)), context);
+    } catch {
+    }
+  }
+  _requireAuth() {
+    if (!this.getAuthToken()) {
+      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 {
+        }
+        this._trackServiceError(
+          new Error(error.message || error.error || `HTTP ${response.status}: ${response.statusText}`),
+          {
+            endpoint,
+            methodName: options.methodName,
+            status: response.status,
+            statusText: response.statusText
+          }
+        );
+        throw new Error(error.message || error.error || "Request failed", { cause: error });
+      }
+      return response.status === 204 ? null : response.json();
+    } catch (error) {
+      this._trackServiceError(error, {
+        endpoint,
+        methodName: options.methodName
+      });
+      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/utils/ordering.js
+function isObjectLike(val) {
+  return val && typeof val === "object" && !Array.isArray(val);
+}
+function normalizePath(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  if (typeof path === "string") {
+    return [path];
+  }
+  return [];
+}
+function getParentPathsFromTuples(tuples = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const parents = [];
+  const META_KEYS = /* @__PURE__ */ new Set([
+    "style",
+    "class",
+    "text",
+    "html",
+    "content",
+    "data",
+    "attr",
+    "state",
+    "scope",
+    "define",
+    "on",
+    "extend",
+    "extends",
+    "childExtend",
+    "childExtends",
+    "children",
+    "component",
+    "context",
+    "tag",
+    "key",
+    "__order",
+    "if"
+  ]);
+  for (let i = 0; i < tuples.length; i++) {
+    const tuple = tuples[i];
+    if (!Array.isArray(tuple) || tuple.length < 2) {
+      continue;
+    }
+    const path = normalizePath(tuple[1]);
+    if (!path.length) {
+      continue;
+    }
+    if (path[0] === "schema") {
+      continue;
+    }
+    const immediateParent = path.slice(0, -1);
+    if (immediateParent.length) {
+      const key = JSON.stringify(immediateParent);
+      if (!seen.has(key)) {
+        seen.add(key);
+        parents.push(immediateParent);
+      }
+    }
+    const last = path[path.length - 1];
+    if (META_KEYS.has(last) && path.length >= 2) {
+      const containerParent = path.slice(0, -2);
+      if (containerParent.length) {
+        const key2 = JSON.stringify(containerParent);
+        if (!seen.has(key2)) {
+          seen.add(key2);
+          parents.push(containerParent);
+        }
+      }
+    }
+    for (let j = 0; j < path.length; j++) {
+      const seg = path[j];
+      if (!META_KEYS.has(seg)) {
+        continue;
+      }
+      const containerParent2 = path.slice(0, j);
+      if (!containerParent2.length) {
+        continue;
+      }
+      const key3 = JSON.stringify(containerParent2);
+      if (!seen.has(key3)) {
+        seen.add(key3);
+        parents.push(containerParent2);
+      }
+    }
+  }
+  return parents;
+}
+function computeOrdersFromState(root, parentPaths = []) {
+  if (!root || typeof root.getByPath !== "function") {
+    return [];
+  }
+  const orders = [];
+  const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+  for (let i = 0; i < parentPaths.length; i++) {
+    const parentPath = parentPaths[i];
+    const obj = (() => {
+      try {
+        return root.getByPath(parentPath);
+      } catch {
+        return null;
+      }
+    })();
+    if (!isObjectLike(obj)) {
+      continue;
+    }
+    const keys = Object.keys(obj).filter((k) => !EXCLUDE_KEYS.has(k));
+    orders.push({ path: parentPath, keys });
+  }
+  return orders;
+}
+function normaliseSchemaCode(code) {
+  if (typeof code !== "string" || !code.length) {
+    return "";
+  }
+  return code.replaceAll("/////n", "\n").replaceAll("/////tilde", "`");
+}
+function parseExportedObject(code) {
+  const src = normaliseSchemaCode(code);
+  if (!src) {
+    return null;
+  }
+  const body = src.replace(/^\s*export\s+default\s*/u, "return ");
+  try {
+    return new Function(body)();
+  } catch {
+    return null;
+  }
+}
+function extractTopLevelKeysFromCode(code) {
+  const obj = parseExportedObject(code);
+  if (!obj || typeof obj !== "object") {
+    return [];
+  }
+  return Object.keys(obj);
+}
+function computeOrdersForTuples(root, tuples = []) {
+  const pendingChildrenByContainer = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t)) {
+      continue;
+    }
+    const [action, path] = t;
+    const p = normalizePath(path);
+    if (!Array.isArray(p) || p.length < 2) {
+      continue;
+    }
+    if (p[0] === "schema") {
+      continue;
+    }
+    const containerPath = p.slice(0, -1);
+    const childKey = p[p.length - 1];
+    const key = JSON.stringify(containerPath);
+    if (!pendingChildrenByContainer.has(key)) {
+      pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
+    }
+    if (action === "update" || action === "set") {
+      pendingChildrenByContainer.get(key).add(childKey);
+    }
+  }
+  const preferredOrderMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t)) {
+      continue;
+    }
+    const [action, path, value] = t;
+    const p = normalizePath(path);
+    if (action !== "update" || !Array.isArray(p) || p.length < 3) {
+      continue;
+    }
+    if (p[0] !== "schema") {
+      continue;
+    }
+    const [, type, key] = p;
+    const containerPath = [type, key];
+    const uses = value && Array.isArray(value.uses) ? value.uses : null;
+    const code = value && value.code;
+    const obj = (() => {
+      try {
+        return root && typeof root.getByPath === "function" ? root.getByPath(containerPath) : null;
+      } catch {
+        return null;
+      }
+    })();
+    if (!obj) {
+      continue;
+    }
+    const present = new Set(Object.keys(obj));
+    const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
+    const codeKeys = extractTopLevelKeysFromCode(code);
+    let resolved = [];
+    const pendingKey = JSON.stringify(containerPath);
+    const pendingChildren = pendingChildrenByContainer.get(pendingKey) || /* @__PURE__ */ new Set();
+    const eligible = /* @__PURE__ */ new Set([...present, ...pendingChildren]);
+    if (Array.isArray(codeKeys) && codeKeys.length) {
+      resolved = codeKeys.filter((k) => eligible.has(k) && !EXCLUDE_KEYS.has(k));
+    }
+    if (Array.isArray(uses) && uses.length) {
+      for (let u = 0; u < uses.length; u++) {
+        const keyName = uses[u];
+        if (eligible.has(keyName) && !EXCLUDE_KEYS.has(keyName) && !resolved.includes(keyName)) {
+          resolved.push(keyName);
+        }
+      }
+    }
+    if (pendingChildren.size) {
+      for (const child of pendingChildren) {
+        if (!EXCLUDE_KEYS.has(child) && !resolved.includes(child)) {
+          resolved.push(child);
+        }
+      }
+    }
+    if (resolved.length) {
+      preferredOrderMap.set(JSON.stringify(containerPath), { path: containerPath, keys: resolved });
+    }
+  }
+  const parents = getParentPathsFromTuples(tuples);
+  const orders = [];
+  const seen = /* @__PURE__ */ new Set();
+  preferredOrderMap.forEach((v) => {
+    const k = JSON.stringify(v.path);
+    if (!seen.has(k)) {
+      seen.add(k);
+      orders.push(v);
+    }
+  });
+  const fallbackOrders = computeOrdersFromState(root, parents);
+  for (let i = 0; i < fallbackOrders.length; i++) {
+    const v = fallbackOrders[i];
+    const k = JSON.stringify(v.path);
+    if (seen.has(k)) {
+      continue;
+    }
+    const pending = pendingChildrenByContainer.get(k);
+    if (pending && pending.size) {
+      const existingKeys = v.keys;
+      const existingSet = new Set(existingKeys);
+      const META_KEYS = /* @__PURE__ */ new Set([
+        "style",
+        "class",
+        "text",
+        "html",
+        "content",
+        "data",
+        "attr",
+        "state",
+        "scope",
+        "define",
+        "on",
+        "extend",
+        "extends",
+        "childExtend",
+        "childExtends",
+        "children",
+        "component",
+        "context",
+        "tag",
+        "key",
+        "__order",
+        "if"
+      ]);
+      let firstMetaIndex = existingKeys.length;
+      for (let j = 0; j < existingKeys.length; j++) {
+        if (META_KEYS.has(existingKeys[j])) {
+          firstMetaIndex = j;
+          break;
+        }
+      }
+      for (const child of pending) {
+        if (existingSet.has(child)) {
+          continue;
+        }
+        const insertIndex = firstMetaIndex;
+        existingKeys.splice(insertIndex, 0, child);
+        existingSet.add(child);
+        firstMetaIndex++;
+      }
+    }
+    seen.add(k);
+    orders.push(v);
+  }
+  return orders;
+}
+
+// src/utils/jsonDiff.js
+function isPlainObject(o) {
+  return o && typeof o === "object" && !Array.isArray(o);
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (typeof a === "function" && typeof b === "function") {
+    try {
+      return a.toString() === b.toString();
+    } catch {
+      return false;
+    }
+  }
+  if (typeof a === "function" || typeof b === "function") {
+    return false;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return String(a) === String(b);
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (let i = 0; i < aKeys.length; i++) {
+      const key = aKeys[i];
+      if (!Object.hasOwn(b, key)) {
+        return false;
+      }
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function diffJson(prev, next, prefix = []) {
+  const ops = [];
+  const _prefix = Array.isArray(prefix) ? prefix : [];
+  for (const key in prev) {
+    if (Object.hasOwn(prev, key) && !(key in next)) {
+      ops.push({ action: "del", path: [..._prefix, key] });
+    }
+  }
+  for (const key in next) {
+    if (Object.hasOwn(next, key)) {
+      const pVal = prev == null ? void 0 : prev[key];
+      const nVal = next[key];
+      if (isPlainObject(pVal) && isPlainObject(nVal)) {
+        ops.push(...diffJson(pVal, nVal, [..._prefix, key]));
+      } else if (!deepEqual(pVal, nVal)) {
+        ops.push({ action: "set", path: [..._prefix, key], value: nVal });
+      }
+    }
+  }
+  return ops;
+}
+
+// src/utils/changePreprocessor.js
+function isPlainObject2(val) {
+  return val && typeof val === "object" && !Array.isArray(val);
+}
+function getByPathSafe(root, path) {
+  if (!root || typeof root.getByPath !== "function") {
+    return null;
+  }
+  try {
+    return root.getByPath(path);
+  } catch {
+    return null;
+  }
+}
+function resolveNextValueFromTuples(tuples, path) {
+  if (!Array.isArray(tuples) || !Array.isArray(path)) {
+    return null;
+  }
+  for (let i = tuples.length - 1; i >= 0; i--) {
+    const t = tuples[i];
+    if (!Array.isArray(t) || t.length < 3) {
+      continue;
+    }
+    const [action, tuplePath, tupleValue] = t;
+    if (action !== "update" && action !== "set" || !Array.isArray(tuplePath)) {
+      continue;
+    }
+    if (tuplePath.length > path.length) {
+      continue;
+    }
+    let isPrefix = true;
+    for (let j = 0; j < tuplePath.length; j++) {
+      if (tuplePath[j] !== path[j]) {
+        isPrefix = false;
+        break;
+      }
+    }
+    if (!isPrefix) {
+      continue;
+    }
+    if (tuplePath.length === path.length) {
+      return tupleValue;
+    }
+    let current = tupleValue;
+    for (let j = tuplePath.length; j < path.length; j++) {
+      if (current == null) {
+        return null;
+      }
+      current = current[path[j]];
+    }
+    if (current !== null) {
+      return current;
+    }
+  }
+  return null;
+}
+function preprocessChanges(root, tuples = [], options = {}) {
+  const expandTuple = (t) => {
+    const [action, path, value] = t || [];
+    const isSchemaPath = Array.isArray(path) && path[0] === "schema";
+    const isFilesPath = Array.isArray(path) && path[0] === "files";
+    if (action === "delete") {
+      return [t];
+    }
+    const canConsiderExpansion = action === "update" && Array.isArray(path) && (path.length === 1 || path.length === 2 || isSchemaPath && path.length === 3) && isPlainObject2(value);
+    if (!canConsiderExpansion || isFilesPath || value && value.type === "files") {
+      return [t];
+    }
+    const prevRaw = getByPathSafe(root, path);
+    const isCreatePath = Array.isArray(path) && action === "update" && // e.g. ['update', ['components', 'NewKey'], {...}]
+    (!isSchemaPath && path.length === 2 || // e.g. ['update', ['schema', 'components', 'NewKey'], {...}]
+    isSchemaPath && path.length === 3) && (prevRaw === null || typeof prevRaw === "undefined");
+    if (isCreatePath) {
+      return [t];
+    }
+    const prev = prevRaw || {};
+    const next = value || {};
+    if (!isPlainObject2(prev) || !isPlainObject2(next)) {
+      return [t];
+    }
+    const ops = diffJson(prev, next, []);
+    if (!ops.length) {
+      return [t];
+    }
+    const out = [];
+    for (let i = 0; i < ops.length; i++) {
+      const op = ops[i];
+      const fullPath = [...path, ...op.path];
+      const last = fullPath[fullPath.length - 1];
+      if (op.action === "set") {
+        out.push(["update", fullPath, op.value]);
+      } else if (op.action === "del") {
+        if (last !== "__order") {
+          out.push(["delete", fullPath]);
+        }
+      }
+    }
+    return out;
+  };
+  const minimizeTuples = (input) => {
+    const out = [];
+    const seen2 = /* @__PURE__ */ new Set();
+    for (let i = 0; i < input.length; i++) {
+      const expanded = expandTuple(input[i]);
+      for (let k = 0; k < expanded.length; k++) {
+        const tuple = expanded[k];
+        const isDelete = Array.isArray(tuple) && tuple[0] === "delete";
+        const isOrderKey = isDelete && Array.isArray(tuple[1]) && tuple[1][tuple[1].length - 1] === "__order";
+        if (!isOrderKey) {
+          const key = JSON.stringify(tuple);
+          if (!seen2.has(key)) {
+            seen2.add(key);
+            out.push(tuple);
+          }
+        }
+      }
+    }
+    return out;
+  };
+  const granularChanges = (() => {
+    try {
+      const res = minimizeTuples(tuples);
+      if (options.append && options.append.length) {
+        res.push(...options.append);
+      }
+      return res;
+    } catch {
+      return Array.isArray(tuples) ? tuples.slice() : [];
+    }
+  })();
+  const hydratedGranularChanges = granularChanges.map((t) => {
+    if (!Array.isArray(t) || t.length < 3) {
+      return t;
+    }
+    const [action, path] = t;
+    if (action !== "update" && action !== "set" || !Array.isArray(path)) {
+      return t;
+    }
+    const nextValue = resolveNextValueFromTuples(tuples, path);
+    if (nextValue === null) {
+      return t;
+    }
+    return [action, path, nextValue];
+  });
+  const baseOrders = computeOrdersForTuples(root, hydratedGranularChanges);
+  const preferOrdersMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t) || t.length < 3) {
+      continue;
+    }
+    const [action, path, value] = t;
+    const isFilesPath = Array.isArray(path) && path[0] === "files";
+    if (action !== "update" || !Array.isArray(path) || path.length !== 1 && path.length !== 2 || !isPlainObject2(value) || isFilesPath || value && value.type === "files") {
+      continue;
+    }
+    const keys = Object.keys(value).filter((k) => k !== "__order");
+    const key = JSON.stringify(path);
+    preferOrdersMap.set(key, { path, keys });
+  }
+  const mergedOrders = [];
+  const seen = /* @__PURE__ */ new Set();
+  preferOrdersMap.forEach((v, k) => {
+    seen.add(k);
+    mergedOrders.push(v);
+  });
+  for (let i = 0; i < baseOrders.length; i++) {
+    const v = baseOrders[i];
+    const k = JSON.stringify(v.path);
+    if (!seen.has(k)) {
+      seen.add(k);
+      mergedOrders.push(v);
+    }
+  }
+  return { granularChanges: hydratedGranularChanges, orders: mergedOrders };
+}
+
+// src/services/ProjectService.js
+import { deepStringifyFunctions } from "@domql/utils";
+var ProjectService = class extends BaseService {
+  // ==================== 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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  /**
+   * 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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  /**
+   * 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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  /**
+   * 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,
+      headers
+    } = 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",
+          ...headers ? { headers } : {}
+        }
+      );
+      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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  async setProjectAccess(projectId, access) {
+    this._requireReady("setProjectAccess");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!access) {
+      throw new Error("Access level is required");
+    }
+    const allowedAccessValues = ["account", "team", "organization", "public"];
+    if (!allowedAccessValues.includes(access)) {
+      throw new Error(
+        `Invalid access value: ${access}. Must be one of: ${allowedAccessValues.join(", ")}`
+      );
+    }
+    try {
+      const response = await this._request(`/projects/${projectId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ access }),
+        methodName: "setProjectAccess"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to set project access: ${error.message}`, { cause: error });
+    }
+  }
+  async setProjectVisibility(projectId, visibility) {
+    this._requireReady("setProjectVisibility");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!visibility) {
+      throw new Error("Visibility is required");
+    }
+    const allowedVisibilityValues = ["public", "private", "password-protected"];
+    if (!allowedVisibilityValues.includes(visibility)) {
+      throw new Error(
+        `Invalid visibility value: ${visibility}. Must be one of: ${allowedVisibilityValues.join(", ")}`
+      );
+    }
+    try {
+      const response = await this._request(`/projects/${projectId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ visibility }),
+        methodName: "setProjectVisibility"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to set project visibility: ${error.message}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`,
+        { cause: error }
+      );
+    }
+  }
+  // ==================== PROJECT PERMISSION CONFIG METHODS ====================
+  /**
+   * Fetch effective role → permissions configuration for a project.
+   * Mirrors ProjectController.getProjectRolePermissionsConfig.
+   */
+  async getProjectRolePermissionsConfig(projectId, options = {}) {
+    this._requireReady("getProjectRolePermissionsConfig");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/permissions`, {
+        method: "GET",
+        ...headers ? { headers } : {},
+        methodName: "getProjectRolePermissionsConfig"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(
+        `Failed to get project role permissions config: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Update project-level role → permissions overrides.
+   * Mirrors ProjectController.updateProjectRolePermissionsConfig.
+   */
+  async updateProjectRolePermissionsConfig(projectId, rolePermissions, options = {}) {
+    this._requireReady("updateProjectRolePermissionsConfig");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!rolePermissions || typeof rolePermissions !== "object") {
+      throw new Error("rolePermissions object is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/permissions`, {
+        method: "PATCH",
+        body: JSON.stringify({ rolePermissions }),
+        ...headers ? { headers } : {},
+        methodName: "updateProjectRolePermissionsConfig"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(
+        `Failed to update project role permissions config: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  // ==================== 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}`, { cause: error });
+    }
+  }
+  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, headers } = 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),
+        ...headers ? { headers } : {},
+        methodName: "inviteMember"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to invite member: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Create a magic invite link for a project.
+   * The backend returns a token and URL that can be shared directly.
+   */
+  async createMagicInviteLink(projectId, options = {}) {
+    this._requireReady("createMagicInviteLink");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/invite-link`, {
+        method: "POST",
+        ...headers ? { headers } : {},
+        methodName: "createMagicInviteLink"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create magic invite link: ${error.message}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  // ==================== 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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to add project libraries: ${error.message}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  // ==================== 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", headers } = options;
+    const state = this._context && this._context.state;
+    const { granularChanges, orders: preprocessorOrders } = preprocessChanges(state, changes, options);
+    const derivedOrders = options.orders || (preprocessorOrders && preprocessorOrders.length ? preprocessorOrders : state ? computeOrdersForTuples(state, granularChanges) : []);
+    const stringify = (val) => deepStringifyFunctions(val, Array.isArray(val) ? [] : {});
+    try {
+      const response = await this._request(`/projects/${projectId}/changes`, {
+        method: "POST",
+        body: JSON.stringify({
+          changes: stringify(changes),
+          granularChanges: stringify(granularChanges),
+          message,
+          branch,
+          type,
+          ...derivedOrders && derivedOrders.length ? { orders: derivedOrders } : {}
+        }),
+        ...headers ? { headers } : {},
+        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}`, { cause: error });
+    }
+  }
+  /**
+   * 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,
+      headers
+    } = 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",
+          ...headers ? { headers } : {}
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get project data: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * 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, headers } = 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",
+          ...headers ? { headers } : {}
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get project versions: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== PROJECT ENVIRONMENT METHODS ====================
+  /**
+   * List all environments for a project along with plan limits and activation state.
+   * Mirrors ProjectController.listEnvironments.
+   */
+  async listEnvironments(projectId, options = {}) {
+    this._requireReady("listEnvironments");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/environments`, {
+        method: "GET",
+        ...headers ? { headers } : {},
+        methodName: "listEnvironments"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list environments: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Activate multi-environment support for a project.
+   * Optional `force` will reconfigure DNS/TLS even if already active.
+   * Mirrors ProjectController.activateMultipleEnvironments.
+   */
+  async activateMultipleEnvironments(projectId, options = {}) {
+    this._requireReady("activateMultipleEnvironments");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { force = false, headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/environments/activate`, {
+        method: "POST",
+        body: JSON.stringify({ ...force ? { force: true } : {} }),
+        ...headers ? { headers } : {},
+        methodName: "activateMultipleEnvironments"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(
+        `Failed to activate multiple environments: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Create or update (upsert) an environment config for a project.
+   * Mirrors ProjectController.upsertEnvironment.
+   */
+  async upsertEnvironment(projectId, envKey, config, options = {}) {
+    this._requireReady("upsertEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    if (!config || typeof config !== "object") {
+      throw new Error("Environment config object is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/environments`, {
+        method: "POST",
+        body: JSON.stringify({ envKey, config }),
+        ...headers ? { headers } : {},
+        methodName: "upsertEnvironment"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to upsert environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update an existing environment config.
+   * Mirrors ProjectController.updateEnvironment.
+   */
+  async updateEnvironment(projectId, envKey, updates, options = {}) {
+    this._requireReady("updateEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    if (!updates || typeof updates !== "object") {
+      throw new Error("Environment updates object is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/environments/${encodeURIComponent(envKey)}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(updates),
+          ...headers ? { headers } : {},
+          methodName: "updateEnvironment"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Publish a project to a specific environment (set its effective mode/version/branch).
+   * Mirrors ProjectController.publishToEnvironment.
+   */
+  async publishToEnvironment(projectId, envKey, payload, options = {}) {
+    this._requireReady("publishToEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    if (!payload || typeof payload !== "object") {
+      throw new Error("Publish payload is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/environments/${encodeURIComponent(envKey)}/publish`,
+        {
+          method: "POST",
+          body: JSON.stringify(payload),
+          ...headers ? { headers } : {},
+          methodName: "publishToEnvironment"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to publish to environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Delete an environment from a project.
+   * Mirrors ProjectController.deleteEnvironment.
+   */
+  async deleteEnvironment(projectId, envKey, options = {}) {
+    this._requireReady("deleteEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/environments/${encodeURIComponent(envKey)}`,
+        {
+          method: "DELETE",
+          ...headers ? { headers } : {},
+          methodName: "deleteEnvironment"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to delete environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Promote content between environments (simple pipeline).
+   * Mirrors ProjectController.promoteEnvironment.
+   */
+  async promoteEnvironment(projectId, fromEnvKey, toEnvKey, options = {}) {
+    this._requireReady("promoteEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!fromEnvKey || !toEnvKey) {
+      throw new Error("Both fromEnvKey and toEnvKey are required");
+    }
+    if (fromEnvKey === toEnvKey) {
+      throw new Error("fromEnvKey and toEnvKey must be different");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/pipeline/promote`, {
+        method: "POST",
+        body: JSON.stringify({ from: fromEnvKey, to: toEnvKey }),
+        ...headers ? { headers } : {},
+        methodName: "promoteEnvironment"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to promote environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * 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", headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/restore`, {
+        method: "POST",
+        body: JSON.stringify({
+          version,
+          message,
+          branch,
+          type
+        }),
+        ...headers ? { headers } : {},
+        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}`, { cause: error });
+    }
+  }
+  /**
+   * 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;
+  }
+  // ==================== 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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  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}`, { cause: error });
+    }
+  }
+  // ==================== RECENT PROJECT METHODS ====================
+  async getRecentProjects(options = {}) {
+    this._requireReady("getRecentProjects");
+    const { limit = 20, headers } = 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",
+        ...headers ? { headers } : {},
+        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}`, { cause: error });
+    }
+  }
+};
+export {
+  ProjectService
+};
+// @preserve-env