@sylphx/sdk 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3058 @@
+// src/constants.ts
+var DEFAULT_PLATFORM_URL = "https://sylphx.com";
+var SDK_API_PATH = `/api/app/v1`;
+var SDK_API_PATH_NEW = `/v1`;
+var DEFAULT_SDK_API_HOST = "api.sylphx.com";
+var SDK_VERSION = "0.1.0";
+var SDK_PLATFORM = typeof window !== "undefined" ? "browser" : typeof process !== "undefined" && process.versions?.node ? "node" : "unknown";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SESSION_TOKEN_LIFETIME_SECONDS = 5 * 60;
+var SESSION_TOKEN_LIFETIME_MS = SESSION_TOKEN_LIFETIME_SECONDS * 1e3;
+var REFRESH_TOKEN_LIFETIME_SECONDS = 30 * 24 * 60 * 60;
+var FLAGS_CACHE_TTL_MS = 5 * 60 * 1e3;
+var FLAGS_STALE_WHILE_REVALIDATE_MS = 60 * 1e3;
+var MAX_RETRY_DELAY_MS = 3e4;
+var BASE_RETRY_DELAY_MS = 1e3;
+var ANALYTICS_SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var WEBHOOK_MAX_AGE_MS = 5 * 60 * 1e3;
+var WEBHOOK_CLOCK_SKEW_MS = 30 * 1e3;
+var PKCE_CODE_TTL_MS = 10 * 60 * 1e3;
+var JOBS_DLQ_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var SESSION_REPLAY_MAX_DURATION_MS = 60 * 60 * 1e3;
+var FLAGS_EXPOSURE_DEDUPE_WINDOW_MS = 60 * 60 * 1e3;
+var CLICK_ID_EXPIRY_MS = 90 * 24 * 60 * 60 * 1e3;
+var STALE_TIME_FREQUENT_MS = 60 * 1e3;
+var STALE_TIME_MODERATE_MS = 2 * 60 * 1e3;
+var STALE_TIME_STABLE_MS = 5 * 60 * 1e3;
+var STALE_TIME_STATS_MS = 30 * 1e3;
+var NEW_USER_THRESHOLD_MS = 60 * 1e3;
+var STORAGE_MULTIPART_THRESHOLD_BYTES = 5 * 1024 * 1024;
+var STORAGE_DEFAULT_MAX_SIZE_BYTES = 5 * 1024 * 1024;
+var STORAGE_AVATAR_MAX_SIZE_BYTES = 2 * 1024 * 1024;
+var STORAGE_LARGE_MAX_SIZE_BYTES = 10 * 1024 * 1024;
+var JWK_CACHE_TTL_MS = 60 * 60 * 1e3;
+var CIRCUIT_BREAKER_FAILURE_THRESHOLD = 5;
+var CIRCUIT_BREAKER_WINDOW_MS = 1e4;
+var CIRCUIT_BREAKER_OPEN_DURATION_MS = 3e4;
+var ETAG_CACHE_MAX_ENTRIES = 100;
+var ETAG_CACHE_TTL_MS = 5 * 60 * 1e3;
+
+// src/errors.ts
+var ERROR_CODE_STATUS = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  PAYLOAD_TOO_LARGE: 413,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  NETWORK_ERROR: 0,
+  TIMEOUT: 0,
+  ABORTED: 0,
+  PARSE_ERROR: 0,
+  UNKNOWN: 0
+};
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "NETWORK_ERROR",
+  "TIMEOUT",
+  "BAD_GATEWAY",
+  "SERVICE_UNAVAILABLE",
+  "GATEWAY_TIMEOUT",
+  "TOO_MANY_REQUESTS",
+  // With backoff
+  "INTERNAL_SERVER_ERROR"
+  // Sometimes transient
+]);
+var SylphxError = class _SylphxError extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** HTTP status code */
+  status;
+  /** Additional context data */
+  data;
+  /** Whether this error is safe to retry */
+  isRetryable;
+  /** Retry-After value in seconds (for rate limiting) */
+  retryAfter;
+  /** Timestamp when error occurred */
+  timestamp;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "SylphxError";
+    this.code = options.code ?? "UNKNOWN";
+    this.status = options.status ?? ERROR_CODE_STATUS[this.code];
+    this.data = options.data;
+    this.isRetryable = RETRYABLE_CODES.has(this.code);
+    this.retryAfter = options.retryAfter;
+    this.timestamp = /* @__PURE__ */ new Date();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SylphxError);
+    }
+  }
+  /**
+   * Convert to JSON-serializable object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      data: this.data,
+      isRetryable: this.isRetryable,
+      retryAfter: this.retryAfter,
+      timestamp: this.timestamp.toISOString()
+    };
+  }
+};
+var NetworkError = class extends SylphxError {
+  constructor(message = "Network request failed", options) {
+    super(message, { ...options, code: "NETWORK_ERROR" });
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends SylphxError {
+  /** Timeout duration in milliseconds */
+  timeout;
+  constructor(timeout, options) {
+    super(`Request timed out after ${timeout}ms`, {
+      ...options,
+      code: "TIMEOUT"
+    });
+    this.name = "TimeoutError";
+    this.timeout = timeout;
+  }
+};
+var AuthenticationError = class extends SylphxError {
+  constructor(message = "Authentication required", options) {
+    super(message, { ...options, code: "UNAUTHORIZED" });
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends SylphxError {
+  constructor(message = "Permission denied", options) {
+    super(message, { ...options, code: "FORBIDDEN" });
+    this.name = "AuthorizationError";
+  }
+};
+var ValidationError = class extends SylphxError {
+  /** Field-specific errors */
+  fieldErrors;
+  constructor(message, options) {
+    super(message, { ...options, code: "UNPROCESSABLE_ENTITY" });
+    this.name = "ValidationError";
+    this.fieldErrors = options?.fieldErrors;
+  }
+  /**
+   * Get error message for a specific field
+   */
+  getFieldError(field) {
+    return this.fieldErrors?.[field]?.[0];
+  }
+};
+var RateLimitError = class extends SylphxError {
+  /** Maximum requests allowed in window */
+  limit;
+  /** Remaining requests in current window */
+  remaining;
+  /** Unix timestamp (seconds) when limit resets */
+  resetAt;
+  constructor(message = "Too many requests", options) {
+    super(message, { ...options, code: "TOO_MANY_REQUESTS" });
+    this.name = "RateLimitError";
+    this.limit = options?.limit;
+    this.remaining = options?.remaining;
+    this.resetAt = options?.resetAt;
+  }
+  /**
+   * Get Date when rate limit resets
+   */
+  getResetDate() {
+    return this.resetAt ? new Date(this.resetAt * 1e3) : void 0;
+  }
+  /**
+   * Get human-readable retry message
+   */
+  getRetryMessage() {
+    if (this.retryAfter) {
+      return `Please retry after ${this.retryAfter} seconds`;
+    }
+    if (this.resetAt) {
+      const seconds = Math.max(0, this.resetAt - Math.floor(Date.now() / 1e3));
+      return `Rate limit resets in ${seconds} seconds`;
+    }
+    return "Please wait before retrying";
+  }
+};
+var NotFoundError = class extends SylphxError {
+  /** Type of resource that wasn't found */
+  resourceType;
+  /** ID of the resource that wasn't found */
+  resourceId;
+  constructor(message = "Resource not found", options) {
+    super(message, { ...options, code: "NOT_FOUND" });
+    this.name = "NotFoundError";
+    this.resourceType = options?.resourceType;
+    this.resourceId = options?.resourceId;
+  }
+};
+function isSylphxError(error) {
+  return error instanceof SylphxError;
+}
+function isRetryableError(error) {
+  if (error instanceof SylphxError) {
+    return error.isRetryable;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    const name = error.name.toLowerCase();
+    if (name === "typeerror" && message.includes("fetch")) return true;
+    if (name === "networkerror") return true;
+    if (message.includes("timeout")) return true;
+    if (message.includes("timed out")) return true;
+    if (message.includes("econnrefused")) return true;
+    if (message.includes("econnreset")) return true;
+    if (message.includes("socket")) return true;
+    if (message.includes("502")) return true;
+    if (message.includes("503")) return true;
+    if (message.includes("504")) return true;
+  }
+  return false;
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "An unknown error occurred";
+}
+function getErrorCode(error) {
+  if (error instanceof SylphxError) {
+    return error.code;
+  }
+  return "UNKNOWN";
+}
+function toSylphxError(error) {
+  if (error instanceof SylphxError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    const name = error.name.toLowerCase();
+    if (name === "typeerror" && message.includes("fetch")) {
+      return new NetworkError(error.message, { cause: error });
+    }
+    if (name === "aborterror" || message.includes("aborted")) {
+      return new SylphxError(error.message, { code: "ABORTED", cause: error });
+    }
+    if (message.includes("timeout")) {
+      return new TimeoutError(DEFAULT_TIMEOUT_MS, { cause: error });
+    }
+    if (message.includes("401") || message.includes("unauthorized")) {
+      return new AuthenticationError(error.message, { cause: error });
+    }
+    if (message.includes("403") || message.includes("forbidden")) {
+      return new AuthorizationError(error.message, { cause: error });
+    }
+    if (message.includes("404") || message.includes("not found")) {
+      return new NotFoundError(error.message, { cause: error });
+    }
+    if (message.includes("429") || message.includes("rate limit")) {
+      return new RateLimitError(error.message, { cause: error });
+    }
+    return new SylphxError(error.message, { cause: error });
+  }
+  return new SylphxError(getErrorMessage(error));
+}
+function exponentialBackoff(attempt, baseDelay = BASE_RETRY_DELAY_MS, maxDelay = MAX_RETRY_DELAY_MS) {
+  const exponentialDelay = baseDelay * Math.pow(2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, maxDelay);
+  const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);
+  return Math.round(cappedDelay + jitter);
+}
+
+// src/key-validation.ts
+var APP_ID_PATTERN = /^app_(dev|stg|prod)_[a-z0-9_-]+$/;
+var SECRET_KEY_PATTERN = /^sk_(dev|stg|prod)_[a-z0-9_-]+$/;
+var ENV_PREFIX_MAP = {
+  dev: "development",
+  stg: "staging",
+  prod: "production"
+};
+function detectKeyIssues(key) {
+  const issues = [];
+  if (key !== key.trim()) issues.push("whitespace");
+  if (key.includes("\n")) issues.push("newline");
+  if (key.includes("\r")) issues.push("carriage-return");
+  if (key.includes(" ")) issues.push("space");
+  if (key !== key.toLowerCase()) issues.push("uppercase-chars");
+  return issues;
+}
+function createSanitizationWarning(keyType, issues, envVarName) {
+  const keyTypeName = keyType === "appId" ? "App ID" : "Secret Key";
+  return `[Sylphx] ${keyTypeName} contains ${issues.join(", ")}. This is commonly caused by Vercel CLI's 'env pull' command.
+
+To fix permanently:
+1. Go to Vercel Dashboard \u2192 Your Project \u2192 Settings \u2192 Environment Variables
+2. Edit ${envVarName}
+3. Remove any trailing whitespace or newline characters
+4. Redeploy your application
+
+The SDK will automatically sanitize the key, but fixing the source is recommended.`;
+}
+function createInvalidKeyError(keyType, key, envVarName) {
+  const prefix = keyType === "appId" ? "app" : "sk";
+  const maskedKey = key.length > 20 ? `${key.slice(0, 20)}...` : key;
+  const formatHint = `${prefix}_(dev|stg|prod)_[identifier]`;
+  const keyTypeName = keyType === "appId" ? "App ID" : "Secret Key";
+  return `[Sylphx] Invalid ${keyTypeName} format.
+
+Expected format: ${formatHint}
+Received: "${maskedKey}"
+
+Please check your ${envVarName} environment variable.
+You can find your keys in the Sylphx Console \u2192 API Keys.
+
+Common issues:
+\u2022 Key has uppercase characters (must be lowercase)
+\u2022 Key has wrong prefix (App ID: app_, Secret Key: sk_)
+\u2022 Key has invalid environment (must be dev, stg, or prod)
+\u2022 Key was copied with extra whitespace`;
+}
+function extractEnvironment(key) {
+  const match = key.match(/^(?:app|sk)_(dev|stg|prod)_/);
+  if (!match) return void 0;
+  return ENV_PREFIX_MAP[match[1]];
+}
+function validateKeyForType(key, keyType, pattern, envVarName) {
+  const keyTypeName = keyType === "appId" ? "App ID" : "Secret Key";
+  if (!key) {
+    return {
+      valid: false,
+      sanitizedKey: "",
+      error: `[Sylphx] ${keyTypeName} is required. Set ${envVarName} in your environment variables.`,
+      issues: ["missing"]
+    };
+  }
+  const issues = detectKeyIssues(key);
+  if (pattern.test(key)) {
+    return {
+      valid: true,
+      sanitizedKey: key,
+      keyType,
+      environment: extractEnvironment(key),
+      issues: []
+    };
+  }
+  const sanitized = key.trim().toLowerCase();
+  if (pattern.test(sanitized)) {
+    return {
+      valid: true,
+      sanitizedKey: sanitized,
+      keyType,
+      environment: extractEnvironment(sanitized),
+      warning: createSanitizationWarning(keyType, issues, envVarName),
+      issues
+    };
+  }
+  return {
+    valid: false,
+    sanitizedKey: "",
+    error: createInvalidKeyError(keyType, key, envVarName),
+    issues: [...issues, "invalid-format"]
+  };
+}
+function validateAppId(key) {
+  return validateKeyForType(
+    key,
+    "appId",
+    APP_ID_PATTERN,
+    "NEXT_PUBLIC_SYLPHX_APP_ID"
+  );
+}
+function validateSecretKey(key) {
+  return validateKeyForType(
+    key,
+    "secret",
+    SECRET_KEY_PATTERN,
+    "SYLPHX_SECRET_KEY"
+  );
+}
+function validateAndSanitizeSecretKey(key) {
+  const result = validateSecretKey(key);
+  if (!result.valid) {
+    throw new Error(result.error);
+  }
+  if (result.warning) {
+    console.warn(result.warning);
+  }
+  return result.sanitizedKey;
+}
+function detectKeyType(key) {
+  const sanitized = key.trim().toLowerCase();
+  if (sanitized.startsWith("app_")) return "appId";
+  if (sanitized.startsWith("sk_")) return "secret";
+  return null;
+}
+function validateKey(key) {
+  const keyType = key ? detectKeyType(key) : null;
+  if (keyType === "appId") {
+    return validateAppId(key);
+  }
+  if (keyType === "secret") {
+    return validateSecretKey(key);
+  }
+  return {
+    valid: false,
+    sanitizedKey: "",
+    error: key ? `Invalid key format. Keys must start with 'app_' (App ID) or 'sk_' (Secret Key), followed by environment (dev/stg/prod) and identifier. Got: ${key.slice(0, 20)}...` : "API key is required but was not provided.",
+    issues: key ? ["invalid_format"] : ["missing"]
+  };
+}
+
+// src/config.ts
+function httpStatusToErrorCode(status) {
+  switch (status) {
+    case 400:
+      return "BAD_REQUEST";
+    case 401:
+      return "UNAUTHORIZED";
+    case 403:
+      return "FORBIDDEN";
+    case 404:
+      return "NOT_FOUND";
+    case 409:
+      return "CONFLICT";
+    case 413:
+      return "PAYLOAD_TOO_LARGE";
+    case 422:
+      return "UNPROCESSABLE_ENTITY";
+    case 429:
+      return "TOO_MANY_REQUESTS";
+    case 500:
+      return "INTERNAL_SERVER_ERROR";
+    case 501:
+      return "NOT_IMPLEMENTED";
+    case 502:
+      return "BAD_GATEWAY";
+    case 503:
+      return "SERVICE_UNAVAILABLE";
+    case 504:
+      return "GATEWAY_TIMEOUT";
+    default:
+      return status >= 500 ? "INTERNAL_SERVER_ERROR" : "BAD_REQUEST";
+  }
+}
+function createConfig(input) {
+  let secretKey;
+  if (input.secretKey) {
+    const result = validateKey(input.secretKey);
+    if (!result.valid) {
+      throw new SylphxError(result.error || "Invalid API key", {
+        code: "BAD_REQUEST",
+        data: { issues: result.issues }
+      });
+    }
+    if (result.warning) {
+      console.warn(`[Sylphx] ${result.warning}`);
+    }
+    secretKey = result.sanitizedKey;
+  }
+  let platformUrl;
+  let apiBasePath;
+  if (input.platformUrl) {
+    platformUrl = input.platformUrl.trim();
+    apiBasePath = SDK_API_PATH;
+  } else if (input.ref) {
+    platformUrl = `https://${input.ref}.${DEFAULT_SDK_API_HOST}`;
+    apiBasePath = SDK_API_PATH_NEW;
+  } else {
+    platformUrl = DEFAULT_PLATFORM_URL;
+    apiBasePath = SDK_API_PATH;
+  }
+  return Object.freeze({
+    secretKey,
+    platformUrl,
+    ref: input.ref,
+    apiBasePath,
+    accessToken: input.accessToken
+  });
+}
+function withToken(config, accessToken) {
+  return Object.freeze({
+    ...config,
+    accessToken
+    // Preserve apiBasePath and ref from original config
+  });
+}
+function buildHeaders(config) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.secretKey) {
+    headers["x-app-secret"] = config.secretKey;
+  }
+  if (config.accessToken) {
+    headers["Authorization"] = `Bearer ${config.accessToken}`;
+  }
+  return headers;
+}
+function buildApiUrl(config, path) {
+  const base = config.platformUrl.replace(/\/$/, "");
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${config.apiBasePath ?? SDK_API_PATH}${cleanPath}`;
+}
+async function callApi(config, path, options = {}) {
+  const {
+    method = "GET",
+    body,
+    query,
+    timeout = DEFAULT_TIMEOUT_MS,
+    signal,
+    idempotencyKey
+  } = options;
+  let url = buildApiUrl(config, path);
+  if (query) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        params.set(key, String(value));
+      }
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const combinedSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+  const headers = buildHeaders(config);
+  if (idempotencyKey) {
+    headers["Idempotency-Key"] = idempotencyKey;
+  }
+  const fetchOptions = {
+    method,
+    headers,
+    signal: combinedSignal
+  };
+  if (body) {
+    fetchOptions.body = JSON.stringify(body);
+  }
+  let response;
+  try {
+    response = await fetch(url, fetchOptions);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        if (controller.signal.aborted && !signal?.aborted) {
+          throw new TimeoutError(timeout);
+        }
+        throw new SylphxError("Request aborted", {
+          code: "ABORTED",
+          cause: error
+        });
+      }
+      throw new NetworkError(error.message, { cause: error });
+    }
+    throw new NetworkError("Network request failed");
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    let errorMessage = "Request failed";
+    let errorData;
+    if (errorBody) {
+      try {
+        const parsed = JSON.parse(errorBody);
+        errorMessage = parsed.error?.message ?? parsed.message ?? errorMessage;
+        errorData = parsed.error;
+      } catch {
+        errorMessage = response.statusText || errorMessage;
+      }
+    }
+    const errorCode = httpStatusToErrorCode(response.status);
+    const retryAfterHeader = response.headers.get("Retry-After");
+    const rateLimitLimit = response.headers.get("X-RateLimit-Limit");
+    const rateLimitRemaining = response.headers.get("X-RateLimit-Remaining");
+    const rateLimitReset = response.headers.get("X-RateLimit-Reset");
+    const retryAfter = retryAfterHeader ? Number.parseInt(retryAfterHeader, 10) : void 0;
+    if (response.status === 429) {
+      throw new RateLimitError(errorMessage || "Too many requests", {
+        status: response.status,
+        data: errorData,
+        retryAfter,
+        limit: rateLimitLimit ? Number.parseInt(rateLimitLimit, 10) : void 0,
+        remaining: rateLimitRemaining ? Number.parseInt(rateLimitRemaining, 10) : void 0,
+        resetAt: rateLimitReset ? Number.parseInt(rateLimitReset, 10) : void 0
+      });
+    }
+    throw new SylphxError(errorMessage, {
+      code: errorCode,
+      status: response.status,
+      data: errorData,
+      retryAfter
+    });
+  }
+  const text = await response.text();
+  if (!text) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new SylphxError("Failed to parse response", {
+      code: "PARSE_ERROR",
+      cause: error instanceof Error ? error : void 0,
+      data: { body: text.slice(0, 200) }
+      // Include snippet for debugging
+    });
+  }
+}
+
+// src/debug.ts
+var DEBUG_STORAGE_KEY = "sylphx_debug";
+function isDebugEnabled() {
+  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+    try {
+      return localStorage.getItem(DEBUG_STORAGE_KEY) === "true";
+    } catch {
+      return false;
+    }
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.SYLPHX_DEBUG === "true";
+  }
+  return false;
+}
+var debugModeCache = null;
+function getDebugMode() {
+  if (debugModeCache === null) {
+    debugModeCache = isDebugEnabled();
+  }
+  return debugModeCache;
+}
+function resetDebugModeCache() {
+  debugModeCache = null;
+}
+function debugLog(category, message, data) {
+  if (!getDebugMode()) return;
+  const prefix = `[Sylphx ${category}]`;
+  if (data !== void 0) {
+    console.log(prefix, message, data);
+  } else {
+    console.log(prefix, message);
+  }
+}
+function debugWarn(category, message, data) {
+  if (!getDebugMode()) return;
+  const prefix = `[Sylphx ${category}]`;
+  if (data !== void 0) {
+    console.warn(prefix, message, data);
+  } else {
+    console.warn(prefix, message);
+  }
+}
+function debugError(category, message, error) {
+  if (!getDebugMode()) return;
+  const prefix = `[Sylphx ${category}]`;
+  if (error !== void 0) {
+    console.error(prefix, message, error);
+  } else {
+    console.error(prefix, message);
+  }
+}
+function debugTimer(category, operation) {
+  if (!getDebugMode()) {
+    return { end: () => {
+    } };
+  }
+  const start = performance.now();
+  return {
+    end() {
+      const duration = performance.now() - start;
+      debugLog(category, `${operation} completed`, {
+        durationMs: Math.round(duration)
+      });
+    }
+  };
+}
+function enableDebug() {
+  if (typeof localStorage === "undefined") {
+    console.warn(
+      "[Sylphx] Debug mode can only be enabled in browser environments"
+    );
+    return;
+  }
+  try {
+    localStorage.setItem(DEBUG_STORAGE_KEY, "true");
+    debugModeCache = true;
+    console.log(
+      "[Sylphx] Debug mode enabled. Refresh the page to see debug logs."
+    );
+  } catch (e) {
+    console.warn("[Sylphx] Failed to enable debug mode:", e);
+  }
+}
+function disableDebug() {
+  if (typeof localStorage === "undefined") {
+    console.warn(
+      "[Sylphx] Debug mode can only be disabled in browser environments"
+    );
+    return;
+  }
+  try {
+    localStorage.removeItem(DEBUG_STORAGE_KEY);
+    debugModeCache = false;
+    console.log("[Sylphx] Debug mode disabled.");
+  } catch (e) {
+    console.warn("[Sylphx] Failed to disable debug mode:", e);
+  }
+}
+function installGlobalDebugHelpers() {
+  if (typeof window === "undefined") return;
+  const w = window;
+  w.__sylphx = {
+    enableDebug,
+    disableDebug,
+    isDebugEnabled: getDebugMode
+  };
+}
+
+// src/rest-client.ts
+import createClient from "openapi-fetch";
+function createAuthMiddleware(config) {
+  return {
+    async onRequest({ request }) {
+      request.headers.set("X-SDK-Version", SDK_VERSION);
+      request.headers.set("X-SDK-Platform", SDK_PLATFORM);
+      if (config.secretKey) {
+        request.headers.set("x-app-secret", config.secretKey);
+      }
+      const token = config.getAccessToken?.();
+      if (token) {
+        request.headers.set("Authorization", `Bearer ${token}`);
+      }
+      return request;
+    }
+  };
+}
+function isRetryableStatus(status) {
+  return status >= 500 || status === 429;
+}
+var inFlightRequests = /* @__PURE__ */ new Map();
+async function getRequestKey(request) {
+  const body = request.body ? await request.clone().text() : "";
+  return `${request.method}:${request.url}:${body}`;
+}
+function createDeduplicationMiddleware(config = {}) {
+  const { enabled = true, methods = ["GET"] } = config;
+  if (!enabled) {
+    return {
+      async onRequest({ request }) {
+        return request;
+      }
+    };
+  }
+  return {
+    async onRequest({ request }) {
+      if (!methods.includes(request.method)) {
+        return request;
+      }
+      const key = await getRequestKey(request);
+      const existing = inFlightRequests.get(key);
+      if (existing) {
+        const deduped = request.clone();
+        deduped._dedupKey = key;
+        return deduped;
+      }
+      request._dedupKey = key;
+      return request;
+    },
+    async onResponse({ request, response }) {
+      const key = request._dedupKey;
+      if (!key) return response;
+      const existing = inFlightRequests.get(key);
+      if (existing && inFlightRequests.get(key) !== void 0) {
+        const cachedResponse = await existing;
+        return cachedResponse.clone();
+      }
+      const responsePromise = Promise.resolve(response.clone());
+      inFlightRequests.set(key, responsePromise);
+      responsePromise.finally(() => {
+        setTimeout(() => inFlightRequests.delete(key), 100);
+      });
+      return response;
+    }
+  };
+}
+var CircuitBreakerOpenError = class extends Error {
+  remainingMs;
+  constructor(remainingMs) {
+    super(
+      `Circuit breaker is open. Retry after ${Math.ceil(remainingMs / 1e3)}s`
+    );
+    this.name = "CircuitBreakerOpenError";
+    this.remainingMs = remainingMs;
+  }
+};
+var circuitBreaker = null;
+function getCircuitBreaker(config = {}) {
+  if (!circuitBreaker) {
+    circuitBreaker = {
+      state: "CLOSED",
+      failures: [],
+      openedAt: null,
+      config: {
+        enabled: config.enabled ?? true,
+        failureThreshold: config.failureThreshold ?? CIRCUIT_BREAKER_FAILURE_THRESHOLD,
+        windowMs: config.windowMs ?? CIRCUIT_BREAKER_WINDOW_MS,
+        openDurationMs: config.openDurationMs ?? CIRCUIT_BREAKER_OPEN_DURATION_MS,
+        isFailure: config.isFailure ?? ((status) => status >= 500 || status === 429)
+      }
+    };
+  }
+  return circuitBreaker;
+}
+function recordFailure(cb) {
+  const now = Date.now();
+  cb.failures = cb.failures.filter((t) => now - t < cb.config.windowMs);
+  cb.failures.push(now);
+  if (cb.failures.length >= cb.config.failureThreshold) {
+    cb.state = "OPEN";
+    cb.openedAt = now;
+  }
+}
+function recordSuccess(cb) {
+  if (cb.state === "HALF_OPEN") {
+    cb.state = "CLOSED";
+    cb.failures = [];
+    cb.openedAt = null;
+  }
+}
+function shouldAllowRequest(cb) {
+  const now = Date.now();
+  switch (cb.state) {
+    case "CLOSED":
+      return { allowed: true };
+    case "OPEN": {
+      const elapsed = now - (cb.openedAt ?? now);
+      if (elapsed >= cb.config.openDurationMs) {
+        cb.state = "HALF_OPEN";
+        return { allowed: true };
+      }
+      return {
+        allowed: false,
+        remainingMs: cb.config.openDurationMs - elapsed
+      };
+    }
+    case "HALF_OPEN":
+      return { allowed: true };
+    default:
+      return { allowed: true };
+  }
+}
+function createCircuitBreakerMiddleware(config) {
+  if (config === false) {
+    return {
+      async onRequest({ request }) {
+        return request;
+      }
+    };
+  }
+  const cb = getCircuitBreaker(config ?? {});
+  return {
+    async onRequest({ request }) {
+      if (!cb.config.enabled) {
+        return request;
+      }
+      const check = shouldAllowRequest(cb);
+      if (!check.allowed) {
+        throw new CircuitBreakerOpenError(check.remainingMs);
+      }
+      return request;
+    },
+    async onResponse({ response }) {
+      if (!cb.config.enabled) {
+        return response;
+      }
+      if (cb.config.isFailure(response.status)) {
+        recordFailure(cb);
+      } else {
+        recordSuccess(cb);
+      }
+      return response;
+    }
+  };
+}
+function resetCircuitBreaker() {
+  circuitBreaker = null;
+}
+function getCircuitBreakerState() {
+  if (!circuitBreaker) return null;
+  return {
+    state: circuitBreaker.state,
+    failures: circuitBreaker.failures.length,
+    openedAt: circuitBreaker.openedAt
+  };
+}
+var etagCache = /* @__PURE__ */ new Map();
+function getETagCacheKey(request) {
+  return `${request.method}:${request.url}`;
+}
+function evictOldEntries(maxEntries, ttlMs) {
+  const now = Date.now();
+  for (const [key, entry] of etagCache) {
+    if (now - entry.timestamp > ttlMs) {
+      etagCache.delete(key);
+    }
+  }
+  if (etagCache.size > maxEntries) {
+    const entries = Array.from(etagCache.entries());
+    entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+    const toRemove = entries.slice(0, entries.length - maxEntries);
+    for (const [key] of toRemove) {
+      etagCache.delete(key);
+    }
+  }
+}
+function createETagMiddleware(config) {
+  if (config === false) {
+    return {
+      async onRequest({ request }) {
+        return request;
+      }
+    };
+  }
+  const {
+    enabled = true,
+    maxEntries = ETAG_CACHE_MAX_ENTRIES,
+    ttlMs = ETAG_CACHE_TTL_MS
+  } = config ?? {};
+  if (!enabled) {
+    return {
+      async onRequest({ request }) {
+        return request;
+      }
+    };
+  }
+  return {
+    async onRequest({ request }) {
+      if (request.method !== "GET") {
+        return request;
+      }
+      const cacheKey = getETagCacheKey(request);
+      const cached = etagCache.get(cacheKey);
+      if (cached) {
+        if (Date.now() - cached.timestamp > ttlMs) {
+          etagCache.delete(cacheKey);
+        } else {
+          request.headers.set("If-None-Match", cached.etag);
+        }
+      }
+      return request;
+    },
+    async onResponse({ request, response }) {
+      if (request.method !== "GET") {
+        return response;
+      }
+      const cacheKey = getETagCacheKey(request);
+      if (response.status === 304) {
+        const cached = etagCache.get(cacheKey);
+        if (cached) {
+          cached.timestamp = Date.now();
+          return new Response(cached.body, {
+            status: 200,
+            headers: response.headers
+          });
+        }
+        return response;
+      }
+      if (response.ok) {
+        const etag = response.headers.get("ETag");
+        if (etag) {
+          const cloned = response.clone();
+          const body = await cloned.text();
+          evictOldEntries(maxEntries, ttlMs);
+          etagCache.set(cacheKey, {
+            etag,
+            body,
+            timestamp: Date.now()
+          });
+        }
+      }
+      return response;
+    }
+  };
+}
+function createRetryMiddleware(retryConfig) {
+  if (retryConfig === false) {
+    return {
+      async onResponse({ response }) {
+        return response;
+      }
+    };
+  }
+  const {
+    maxRetries = 3,
+    baseDelay = BASE_RETRY_DELAY_MS,
+    maxDelay = MAX_RETRY_DELAY_MS,
+    shouldRetry = isRetryableStatus,
+    timeout = DEFAULT_TIMEOUT_MS
+  } = retryConfig ?? {};
+  let originalBody = null;
+  return {
+    async onRequest({ request }) {
+      if (request.body) {
+        originalBody = await request.clone().text();
+      } else {
+        originalBody = null;
+      }
+      if (!request.signal) {
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(), timeout);
+        return new Request(request.url, {
+          method: request.method,
+          headers: request.headers,
+          body: originalBody,
+          signal: controller.signal
+        });
+      }
+      return request;
+    },
+    async onResponse({ response, request }) {
+      let attempt = 0;
+      let currentResponse = response;
+      while (attempt < maxRetries && shouldRetry(currentResponse.status, attempt)) {
+        const retryAfter = currentResponse.headers.get("Retry-After");
+        const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1e3 : exponentialBackoff(attempt, baseDelay, maxDelay);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        attempt++;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+          const retryRequest = new Request(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: originalBody,
+            signal: controller.signal
+          });
+          const newResponse = await fetch(retryRequest);
+          clearTimeout(timeoutId);
+          if (newResponse.ok || !shouldRetry(newResponse.status, attempt)) {
+            return newResponse;
+          }
+          currentResponse = newResponse;
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (attempt >= maxRetries) {
+            throw error;
+          }
+        }
+      }
+      return currentResponse;
+    }
+  };
+}
+function validateClientConfig(config) {
+  return {
+    secretKey: validateAndSanitizeSecretKey(config.secretKey),
+    baseUrl: (config.platformUrl || DEFAULT_PLATFORM_URL).trim()
+  };
+}
+function createRestClient(config) {
+  const { secretKey, baseUrl } = validateClientConfig(config);
+  const client = createClient({
+    baseUrl: `${baseUrl}${SDK_API_PATH}`,
+    headers: {
+      "Content-Type": "application/json",
+      "x-app-secret": secretKey
+    }
+  });
+  if (config.deduplication !== false) {
+    client.use(createDeduplicationMiddleware(config.deduplication));
+  }
+  if (config.circuitBreaker !== false) {
+    client.use(createCircuitBreakerMiddleware(config.circuitBreaker));
+  }
+  if (config.etag !== false) {
+    client.use(createETagMiddleware(config.etag));
+  }
+  client.use(createRetryMiddleware(config.retry));
+  return client;
+}
+function createDynamicRestClient(config) {
+  const { secretKey, baseUrl } = validateClientConfig(config);
+  const validatedConfig = {
+    ...config,
+    secretKey,
+    platformUrl: baseUrl
+  };
+  const client = createClient({
+    baseUrl: `${baseUrl}${SDK_API_PATH}`,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (config.deduplication !== false) {
+    client.use(createDeduplicationMiddleware(config.deduplication));
+  }
+  client.use(createAuthMiddleware(validatedConfig));
+  if (config.circuitBreaker !== false) {
+    client.use(createCircuitBreakerMiddleware(config.circuitBreaker));
+  }
+  if (config.etag !== false) {
+    client.use(createETagMiddleware(config.etag));
+  }
+  client.use(createRetryMiddleware(config.retry));
+  return client;
+}
+function hasError(response) {
+  return response.error !== void 0;
+}
+function getRestErrorMessage(error) {
+  if (error && typeof error === "object" && "error" in error) {
+    const err = error;
+    return err.error?.message ?? "An unknown error occurred";
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "An unknown error occurred";
+}
+
+// src/auth.ts
+async function signIn(config, input) {
+  return callApi(config, "/auth/login", {
+    method: "POST",
+    body: input
+  });
+}
+async function signUp(config, input) {
+  return callApi(config, "/auth/register", {
+    method: "POST",
+    body: input
+  });
+}
+async function signOut(config) {
+  await callApi(config, "/auth/logout", { method: "POST" });
+}
+async function refreshToken(config, token) {
+  const response = await fetch(`${config.platformUrl}/api/v1/auth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      refresh_token: token,
+      client_secret: config.secretKey
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: "Token refresh failed" }));
+    throw new SylphxError(error.message ?? "Token refresh failed", {
+      code: "UNAUTHORIZED"
+    });
+  }
+  return response.json();
+}
+async function verifyEmail(config, token) {
+  const response = await fetch(`${config.platformUrl}/api/v1/auth/verify-email`, {
+    method: "POST",
+    headers: buildHeaders(config),
+    body: JSON.stringify({ token })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: "Email verification failed" }));
+    throw new SylphxError(error.message ?? "Email verification failed", {
+      code: "BAD_REQUEST"
+    });
+  }
+}
+async function forgotPassword(config, email) {
+  await callApi(config, "/auth/forgot-password", {
+    method: "POST",
+    body: { email }
+  });
+}
+async function resetPassword(config, input) {
+  await callApi(config, "/auth/reset-password", {
+    method: "POST",
+    body: { token: input.token, newPassword: input.password }
+  });
+}
+async function getSession(config) {
+  if (!config.accessToken) {
+    return { user: null };
+  }
+  try {
+    const user = await callApi(config, "/auth/me");
+    return { user };
+  } catch {
+    return { user: null };
+  }
+}
+async function verifyTwoFactor(config, userId, code) {
+  return callApi(config, "/auth/verify-2fa", {
+    method: "POST",
+    body: { userId, code }
+  });
+}
+async function introspectToken(config, token, tokenTypeHint) {
+  const response = await fetch(`${config.platformUrl}/api/v1/auth/introspect`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      token,
+      token_type_hint: tokenTypeHint,
+      client_secret: config.secretKey
+    })
+  });
+  if (!response.ok) {
+    return { active: false };
+  }
+  return response.json();
+}
+async function revokeToken(config, token, options) {
+  await fetch(`${config.platformUrl}/api/v1/auth/revoke`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      token: options?.revokeAll ? void 0 : token,
+      client_secret: config.secretKey,
+      user_id: options?.userId,
+      revoke_all: options?.revokeAll
+    })
+  });
+}
+async function revokeAllTokens(config, userId) {
+  await revokeToken(config, "", { revokeAll: true, userId });
+}
+
+// src/analytics.ts
+async function track(config, input) {
+  await callApi(config, "/analytics/track", {
+    method: "POST",
+    body: {
+      event: input.event,
+      properties: input.properties ?? {},
+      userId: input.userId,
+      anonymousId: input.anonymousId,
+      timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+}
+async function page(config, input) {
+  await callApi(config, "/analytics/page", {
+    method: "POST",
+    body: {
+      name: input.name,
+      properties: input.properties ?? {},
+      userId: input.userId,
+      anonymousId: input.anonymousId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+}
+async function identify(config, input) {
+  await callApi(config, "/analytics/identify", {
+    method: "POST",
+    body: {
+      userId: input.userId,
+      traits: input.traits ?? {},
+      anonymousId: input.anonymousId
+    }
+  });
+}
+async function trackBatch(config, events) {
+  await callApi(config, "/analytics/batch", {
+    method: "POST",
+    body: {
+      events: events.map((e) => ({
+        event: e.type === "track" ? e.event : e.type === "page" ? `$pageview` : "$identify",
+        properties: {
+          ...e.properties,
+          ...e.type === "page" && e.name ? { name: e.name } : {},
+          ...e.type === "identify" && e.traits ? { traits: e.traits } : {}
+        },
+        userId: e.userId,
+        anonymousId: e.anonymousId,
+        timestamp: e.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+      }))
+    }
+  });
+}
+function generateAnonymousId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function createTracker(config, defaultAnonymousId) {
+  const anonymousId = defaultAnonymousId ?? generateAnonymousId();
+  return {
+    track: (event, properties, userId) => track(config, { event, properties, userId, anonymousId }),
+    page: (name, properties, userId) => page(config, { name, properties, userId, anonymousId }),
+    identify: (userId, traits) => identify(config, { userId, traits, anonymousId }),
+    batch: (events) => trackBatch(
+      config,
+      events.map((e) => ({
+        ...e,
+        anonymousId: e.anonymousId ?? anonymousId
+      }))
+    ),
+    /** Get the anonymous ID for this tracker */
+    getAnonymousId: () => anonymousId
+  };
+}
+
+// src/ai.ts
+async function chat(config, input) {
+  const response = await fetch(
+    `${config.platformUrl}/api/v1/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        ...buildHeaders(config),
+        Authorization: `Bearer ${config.secretKey}`
+      },
+      body: JSON.stringify({
+        model: input.model,
+        messages: input.messages,
+        temperature: input.temperature,
+        max_tokens: input.maxTokens,
+        top_p: input.topP,
+        frequency_penalty: input.frequencyPenalty,
+        presence_penalty: input.presencePenalty,
+        stop: input.stop,
+        tools: input.tools,
+        tool_choice: input.toolChoice
+      })
+    }
+  );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: { message: "Chat request failed" } }));
+    throw new SylphxError(error?.error?.message ?? "Chat request failed", {
+      code: "BAD_REQUEST"
+    });
+  }
+  const data = await response.json();
+  return {
+    id: data.id,
+    model: data.model,
+    choices: data.choices.map((c) => ({
+      index: c.index,
+      message: {
+        role: "assistant",
+        content: c.message?.content,
+        tool_calls: c.message?.tool_calls
+      },
+      finishReason: c.finish_reason
+    })),
+    usage: {
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: data.usage.completion_tokens,
+      totalTokens: data.usage.total_tokens
+    }
+  };
+}
+function chatStream(config, input) {
+  return {
+    [Symbol.asyncIterator]: async function* () {
+      const response = await fetch(
+        `${config.platformUrl}/api/v1/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            ...buildHeaders(config),
+            Authorization: `Bearer ${config.secretKey}`
+          },
+          body: JSON.stringify({
+            model: input.model,
+            messages: input.messages,
+            temperature: input.temperature,
+            max_tokens: input.maxTokens,
+            top_p: input.topP,
+            frequency_penalty: input.frequencyPenalty,
+            presence_penalty: input.presencePenalty,
+            stop: input.stop,
+            tools: input.tools,
+            tool_choice: input.toolChoice,
+            stream: true
+          })
+        }
+      );
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: { message: "Stream request failed" } }));
+        throw new SylphxError(error?.error?.message ?? "Stream request failed", {
+          code: "BAD_REQUEST"
+        });
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new SylphxError("No response body", {
+          code: "INTERNAL_SERVER_ERROR"
+        });
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6).trim();
+              if (data === "[DONE]") return;
+              try {
+                const chunk = JSON.parse(data);
+                yield {
+                  id: chunk.id ?? "",
+                  model: chunk.model ?? input.model,
+                  choices: (chunk.choices ?? []).map(
+                    (c) => ({
+                      index: typeof c.index === "number" ? c.index : 0,
+                      delta: {
+                        role: c.delta?.role,
+                        content: c.delta?.content,
+                        tool_calls: c.delta?.tool_calls
+                      },
+                      finishReason: c.finish_reason ?? null
+                    })
+                  )
+                };
+              } catch {
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  };
+}
+async function embed(config, input) {
+  const response = await fetch(`${config.platformUrl}/api/v1/embeddings`, {
+    method: "POST",
+    headers: {
+      ...buildHeaders(config),
+      Authorization: `Bearer ${config.secretKey}`
+    },
+    body: JSON.stringify({
+      model: input.model,
+      input: input.input,
+      dimensions: input.dimensions
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: { message: "Embedding request failed" } }));
+    throw new SylphxError(error?.error?.message ?? "Embedding request failed", {
+      code: "BAD_REQUEST"
+    });
+  }
+  const data = await response.json();
+  return {
+    model: data.model,
+    data: data.data,
+    usage: {
+      promptTokens: data.usage.prompt_tokens,
+      totalTokens: data.usage.total_tokens
+    }
+  };
+}
+async function complete(config, model, prompt, options) {
+  const response = await chat(config, {
+    model,
+    messages: [{ role: "user", content: prompt }],
+    ...options
+  });
+  return response.choices[0]?.message.content ?? "";
+}
+async function streamToString(config, input) {
+  let result = "";
+  for await (const chunk of chatStream(config, input)) {
+    result += chunk.choices[0]?.delta.content ?? "";
+  }
+  return result;
+}
+
+// src/billing.ts
+async function getPlans(config) {
+  return callApi(config, "/billing/plans");
+}
+async function getSubscription(config, userId) {
+  return callApi(config, "/billing/subscription", {
+    query: { userId }
+  });
+}
+async function createCheckout(config, input) {
+  return callApi(config, "/billing/checkout", {
+    method: "POST",
+    body: input
+  });
+}
+async function createPortalSession(config, input) {
+  return callApi(config, "/billing/portal", {
+    method: "POST",
+    body: input
+  });
+}
+async function getBillingBalance(config) {
+  return callApi(config, "/billing/balance");
+}
+async function getBillingUsage(config, options) {
+  return callApi(config, "/billing/usage", {
+    query: options?.month ? { month: options.month } : void 0
+  });
+}
+
+// src/storage.ts
+var UPLOAD_RETRY_CONFIG = {
+  /** Maximum number of retry attempts (AWS S3 pattern) */
+  maxRetries: 5,
+  /** Base delay in milliseconds */
+  baseDelayMs: BASE_RETRY_DELAY_MS,
+  /** Maximum delay cap in milliseconds */
+  maxDelayMs: MAX_RETRY_DELAY_MS,
+  /** Jitter type: 'full' for full jitter (AWS recommended) */
+  jitter: "full"
+};
+function calculateBackoffDelay(attempt) {
+  const { baseDelayMs, maxDelayMs } = UPLOAD_RETRY_CONFIG;
+  const exponentialDelay = baseDelayMs * 2 ** attempt;
+  const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+  return Math.random() * cappedDelay;
+}
+async function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Upload aborted", "AbortError"));
+      return;
+    }
+    const timeoutId = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timeoutId);
+        reject(new DOMException("Upload aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+function isRetryableError3(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return false;
+  }
+  if (error instanceof TypeError) {
+    return true;
+  }
+  if (error instanceof Error && "status" in error) {
+    const status = error.status;
+    return status >= 500 || status === 429;
+  }
+  return false;
+}
+async function uploadFile(config, file, options) {
+  const { signal } = options ?? {};
+  if (signal?.aborted) {
+    throw new DOMException("Upload aborted", "AbortError");
+  }
+  let tokenResponse = null;
+  let lastError = null;
+  for (let attempt = 0; attempt <= UPLOAD_RETRY_CONFIG.maxRetries; attempt++) {
+    try {
+      tokenResponse = await fetch(`${config.platformUrl}/api/v1/storage/upload`, {
+        method: "POST",
+        headers: buildHeaders(config),
+        body: JSON.stringify({
+          filename: file.name,
+          contentType: file.type,
+          size: file.size,
+          path: options?.path,
+          type: options?.type ?? "file",
+          userId: options?.userId
+        }),
+        signal
+      });
+      if (tokenResponse.ok) {
+        break;
+      }
+      if (tokenResponse.status >= 500 || tokenResponse.status === 429) {
+        if (attempt < UPLOAD_RETRY_CONFIG.maxRetries) {
+          const delay = calculateBackoffDelay(attempt);
+          await sleep(delay, signal);
+          continue;
+        }
+      }
+      const error = await tokenResponse.json().catch(() => ({ message: "Failed to get upload token" }));
+      throw new SylphxError(error.message ?? "Failed to get upload token", {
+        code: "BAD_REQUEST"
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw error;
+      }
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (isRetryableError3(error) && attempt < UPLOAD_RETRY_CONFIG.maxRetries) {
+        const delay = calculateBackoffDelay(attempt);
+        await sleep(delay, signal);
+        continue;
+      }
+      throw lastError;
+    }
+  }
+  if (!tokenResponse?.ok) {
+    throw lastError ?? new SylphxError("Failed to get upload token after retries", {
+      code: "BAD_REQUEST"
+    });
+  }
+  const { uploadUrl, publicUrl } = await tokenResponse.json();
+  return executeUploadWithRetry(file, uploadUrl, publicUrl, options);
+}
+async function executeUploadWithRetry(file, uploadUrl, publicUrl, options) {
+  const { signal } = options ?? {};
+  let lastError = null;
+  for (let attempt = 0; attempt <= UPLOAD_RETRY_CONFIG.maxRetries; attempt++) {
+    try {
+      return await executeUpload(file, uploadUrl, publicUrl, options);
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw error;
+      }
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (isRetryableError3(error) && attempt < UPLOAD_RETRY_CONFIG.maxRetries) {
+        const delay = calculateBackoffDelay(attempt);
+        await sleep(delay, signal);
+        continue;
+      }
+      throw lastError;
+    }
+  }
+  throw lastError ?? new Error("Upload failed after retries");
+}
+function executeUpload(file, uploadUrl, publicUrl, options) {
+  const { signal, onProgress } = options ?? {};
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    const handleAbort = () => {
+      xhr.abort();
+      reject(new DOMException("Upload aborted", "AbortError"));
+    };
+    if (signal?.aborted) {
+      reject(new DOMException("Upload aborted", "AbortError"));
+      return;
+    }
+    signal?.addEventListener("abort", handleAbort, { once: true });
+    xhr.upload.addEventListener("progress", (event) => {
+      if (event.lengthComputable && onProgress) {
+        onProgress({
+          loaded: event.loaded,
+          total: event.total,
+          progress: Math.round(event.loaded / event.total * 100)
+        });
+      }
+    });
+    xhr.addEventListener("load", () => {
+      signal?.removeEventListener("abort", handleAbort);
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve({
+          url: publicUrl,
+          pathname: options?.path ? `${options.path}/${file.name}` : file.name,
+          contentType: file.type,
+          size: file.size
+        });
+      } else {
+        const error = new Error(`Upload failed with status ${xhr.status}`);
+        error.status = xhr.status;
+        reject(error);
+      }
+    });
+    xhr.addEventListener("error", () => {
+      signal?.removeEventListener("abort", handleAbort);
+      reject(new TypeError("Network error during upload"));
+    });
+    xhr.addEventListener("abort", () => {
+      signal?.removeEventListener("abort", handleAbort);
+      reject(new DOMException("Upload aborted", "AbortError"));
+    });
+    xhr.open("PUT", uploadUrl);
+    xhr.setRequestHeader("Content-Type", file.type);
+    xhr.send(file);
+  });
+}
+async function uploadAvatar(config, file, userId, options) {
+  return uploadFile(config, file, {
+    ...options,
+    type: "avatar",
+    userId
+  });
+}
+async function deleteFile(config, fileId) {
+  await callApi(config, `/storage/files/${fileId}`, { method: "DELETE" });
+}
+async function getFileUrl(config, fileId) {
+  const data = await callApi(config, `/storage/files/${fileId}`, { method: "GET" });
+  return data.url;
+}
+async function getFileInfo(config, fileId) {
+  return callApi(config, `/storage/files/${fileId}`, {
+    method: "GET"
+  });
+}
+async function getSignedUrl(config, fileId, options) {
+  return callApi(config, "/storage/signed-url", {
+    method: "POST",
+    body: {
+      fileId,
+      ...options
+    }
+  });
+}
+
+// src/notifications.ts
+async function registerPush(config, subscription) {
+  await callApi(config, "/notifications/register", {
+    method: "POST",
+    body: { subscription }
+  });
+}
+async function unregisterPush(config, endpoint) {
+  await callApi(config, "/notifications/unregister", {
+    method: "POST",
+    body: { endpoint }
+  });
+}
+async function sendPush(config, userId, notification) {
+  return callApi(config, "/notifications/send", {
+    method: "POST",
+    body: { userId, ...notification }
+  });
+}
+async function getPushPreferences(config) {
+  return callApi(config, "/notifications/preferences", { method: "GET" });
+}
+async function updatePushPreferences(config, preferences) {
+  await callApi(config, "/notifications/preferences", {
+    method: "PUT",
+    body: preferences
+  });
+}
+
+// src/lib/notifications/service-worker.ts
+function initPushServiceWorker(config = {}) {
+  const {
+    defaultIcon,
+    defaultBadge,
+    onNotificationClick,
+    onNotificationClose
+  } = config;
+  self.addEventListener("push", (event) => {
+    if (!event.data) {
+      console.warn("[Sylphx SW] Push event received without data");
+      return;
+    }
+    let payload;
+    try {
+      payload = event.data.json();
+    } catch {
+      payload = {
+        title: "Notification",
+        body: event.data.text()
+      };
+    }
+    const notificationOptions = {
+      body: payload.body,
+      icon: payload.icon || defaultIcon,
+      badge: payload.badge || defaultBadge,
+      image: payload.image,
+      data: {
+        ...payload.data,
+        url: payload.url,
+        _sylphxPayload: payload
+      },
+      tag: payload.tag,
+      requireInteraction: payload.requireInteraction ?? false,
+      vibrate: payload.vibrate,
+      silent: payload.silent ?? false,
+      actions: payload.actions
+    };
+    event.waitUntil(
+      self.registration.showNotification(payload.title, notificationOptions)
+    );
+  });
+  self.addEventListener("notificationclick", (event) => {
+    event.notification.close();
+    const data = event.notification.data;
+    const payload = data?._sylphxPayload;
+    const url = data?.url;
+    if (onNotificationClick && payload) {
+      onNotificationClick(payload);
+    }
+    if (event.action) {
+      console.log("[Sylphx SW] Action clicked:", event.action);
+    }
+    if (url) {
+      event.waitUntil(
+        self.clients.matchAll({ type: "window", includeUncontrolled: true }).then((clientList) => {
+          for (const client of clientList) {
+            if (client.url === url && "focus" in client) {
+              return client.focus();
+            }
+          }
+          return self.clients.openWindow(url);
+        })
+      );
+    }
+  });
+  self.addEventListener("notificationclose", (event) => {
+    const data = event.notification.data;
+    const payload = data?._sylphxPayload;
+    if (onNotificationClose && payload) {
+      onNotificationClose(payload);
+    }
+  });
+  self.addEventListener("activate", (event) => {
+    event.waitUntil(
+      // Claim all clients immediately
+      self.clients.claim()
+    );
+  });
+  console.log("[Sylphx SW] Push notification service worker initialized");
+}
+function createServiceWorkerScript(config = {}) {
+  const { defaultIcon = "/icon-192.png", defaultBadge = "/badge-72.png" } = config;
+  return `
+// Sylphx Push Notification Service Worker
+// Auto-generated - do not edit directly
+
+const DEFAULT_ICON = '${defaultIcon}';
+const DEFAULT_BADGE = '${defaultBadge}';
+
+self.addEventListener('push', (event) => {
+  if (!event.data) return;
+
+  let payload;
+  try {
+    payload = event.data.json();
+  } catch {
+    payload = { title: 'Notification', body: event.data.text() };
+  }
+
+  const options = {
+    body: payload.body,
+    icon: payload.icon || DEFAULT_ICON,
+    badge: payload.badge || DEFAULT_BADGE,
+    image: payload.image,
+    data: { ...payload.data, url: payload.url },
+    tag: payload.tag,
+    requireInteraction: payload.requireInteraction || false,
+    vibrate: payload.vibrate,
+    silent: payload.silent || false,
+    actions: payload.actions,
+  };
+
+  event.waitUntil(
+    self.registration.showNotification(payload.title, options)
+  );
+});
+
+self.addEventListener('notificationclick', (event) => {
+  event.notification.close();
+  const url = event.notification.data?.url;
+
+  if (url) {
+    event.waitUntil(
+      clients.matchAll({ type: 'window', includeUncontrolled: true }).then((clientList) => {
+        for (const client of clientList) {
+          if (client.url === url && 'focus' in client) {
+            return client.focus();
+          }
+        }
+        if (clients.openWindow) {
+          return clients.openWindow(url);
+        }
+      })
+    );
+  }
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(clients.claim());
+});
+
+console.log('[Sylphx SW] Push notification service worker active');
+`.trim();
+}
+async function registerPushServiceWorker(swPath = "/sw.js") {
+  if (typeof window === "undefined") return null;
+  if (!("serviceWorker" in navigator)) {
+    console.warn("[Sylphx] Service workers not supported");
+    return null;
+  }
+  try {
+    const registration = await navigator.serviceWorker.register(swPath);
+    console.log("[Sylphx] Service worker registered:", registration.scope);
+    return registration;
+  } catch (error) {
+    console.error("[Sylphx] Service worker registration failed:", error);
+    return null;
+  }
+}
+
+// src/jobs.ts
+async function scheduleJob(config, input) {
+  return callApi(config, "/jobs/schedule", {
+    method: "POST",
+    body: input
+  });
+}
+async function getJob(config, jobId) {
+  return callApi(config, `/jobs/${jobId}`, { method: "GET" });
+}
+async function cancelJob(config, jobId) {
+  const result = await callApi(
+    config,
+    `/jobs/${jobId}/cancel`,
+    {
+      method: "POST"
+    }
+  );
+  return result.success;
+}
+async function listJobs(config, options) {
+  return callApi(config, "/jobs", {
+    method: "GET",
+    query: options
+  });
+}
+async function createCron(config, input) {
+  return callApi(config, "/jobs/cron", {
+    method: "POST",
+    body: input
+  });
+}
+async function pauseCron(config, scheduleId) {
+  const result = await callApi(
+    config,
+    `/jobs/cron/${scheduleId}/pause`,
+    {
+      method: "POST"
+    }
+  );
+  return result.success;
+}
+async function resumeCron(config, scheduleId) {
+  const result = await callApi(
+    config,
+    `/jobs/cron/${scheduleId}/resume`,
+    {
+      method: "POST"
+    }
+  );
+  return result.success;
+}
+async function deleteCron(config, scheduleId) {
+  const result = await callApi(
+    config,
+    `/jobs/cron/${scheduleId}`,
+    {
+      method: "DELETE"
+    }
+  );
+  return result.success;
+}
+
+// src/flags.ts
+async function checkFlag(config, flagKey, context) {
+  const response = await callApi(
+    config,
+    "/flags/evaluate",
+    {
+      method: "POST",
+      body: {
+        context: {
+          userId: context?.userId,
+          anonymousId: context?.anonymousId,
+          properties: context?.properties
+        },
+        keys: [flagKey]
+      }
+    }
+  );
+  return response.data[flagKey] ?? {
+    key: flagKey,
+    enabled: false,
+    reason: "flag_not_found"
+  };
+}
+async function getFlags(config, flagKeys, context) {
+  const response = await callApi(
+    config,
+    "/flags/evaluate",
+    {
+      method: "POST",
+      body: {
+        context: {
+          userId: context?.userId,
+          anonymousId: context?.anonymousId,
+          properties: context?.properties
+        },
+        keys: flagKeys
+      }
+    }
+  );
+  return response.data;
+}
+async function getAllFlags(config, context) {
+  const response = await callApi(
+    config,
+    "/flags/evaluate",
+    {
+      method: "POST",
+      body: {
+        context: {
+          userId: context?.userId,
+          anonymousId: context?.anonymousId,
+          properties: context?.properties
+        }
+        // Omit keys to get all flags
+      }
+    }
+  );
+  return response.data;
+}
+async function isEnabled(config, flagKey, context) {
+  const flag = await checkFlag(config, flagKey, context);
+  return flag.enabled;
+}
+async function getVariant(config, flagKey, context) {
+  const flag = await checkFlag(config, flagKey, context);
+  return flag.variant;
+}
+async function getFlagPayload(config, flagKey, context) {
+  const flag = await checkFlag(config, flagKey, context);
+  return flag.payload;
+}
+
+// src/webhooks.ts
+async function getWebhookConfig(config) {
+  return callApi(config, "/webhooks/config", { method: "GET" });
+}
+async function updateWebhookConfig(config, data) {
+  return callApi(config, "/webhooks/config", { method: "PUT", body: data });
+}
+async function getWebhookDeliveries(config, options) {
+  return callApi(config, "/webhooks/deliveries", {
+    method: "GET",
+    query: options
+  });
+}
+async function getWebhookDelivery(config, deliveryId) {
+  return callApi(config, `/webhooks/deliveries/${deliveryId}`, {
+    method: "GET"
+  });
+}
+async function replayWebhookDelivery(config, deliveryId) {
+  return callApi(config, `/webhooks/deliveries/${deliveryId}/replay`, {
+    method: "POST"
+  });
+}
+async function getWebhookStats(config, environmentId) {
+  return callApi(config, "/webhooks/stats", {
+    method: "GET",
+    query: environmentId ? { environmentId } : void 0
+  });
+}
+
+// src/email.ts
+async function isEmailConfigured(config) {
+  return callApi(config, "/email/configured", { method: "GET" });
+}
+async function sendEmail(config, options) {
+  const { idempotencyKey, ...body } = options;
+  return callApi(config, "/email/send", {
+    method: "POST",
+    body,
+    idempotencyKey
+  });
+}
+async function sendTemplatedEmail(config, options) {
+  const { idempotencyKey, ...body } = options;
+  return callApi(config, "/email/send-templated", {
+    method: "POST",
+    body,
+    idempotencyKey
+  });
+}
+async function sendEmailToUser(config, options) {
+  const { idempotencyKey, ...body } = options;
+  return callApi(config, "/email/send-to-user", {
+    method: "POST",
+    body,
+    idempotencyKey
+  });
+}
+async function scheduleEmail(config, options) {
+  return callApi(config, "/email/schedule", { method: "POST", body: options });
+}
+async function listScheduledEmails(config, options) {
+  return callApi(config, "/email/scheduled", {
+    method: "GET",
+    query: options
+  });
+}
+async function getScheduledEmail(config, emailId) {
+  return callApi(config, `/email/scheduled/${emailId}`, { method: "GET" });
+}
+async function cancelScheduledEmail(config, emailId) {
+  return callApi(config, `/email/scheduled/${emailId}/cancel`, {
+    method: "POST"
+  });
+}
+async function rescheduleEmail(config, emailId, scheduledFor) {
+  return callApi(config, `/email/scheduled/${emailId}/reschedule`, {
+    method: "POST",
+    body: { scheduledFor }
+  });
+}
+async function getScheduledEmailStats(config) {
+  return callApi(config, "/email/scheduled/stats", { method: "GET" });
+}
+
+// src/consent.ts
+async function getConsentTypes(config) {
+  return callApi(config, "/consent/types", { method: "GET" });
+}
+async function hasConsent(config, purposeSlug, input, defaults) {
+  return callApi(config, "/consent/check", {
+    method: "POST",
+    body: { purposeSlug, ...input, defaults }
+  });
+}
+async function getUserConsents(config, input) {
+  return callApi(config, "/consent/user", {
+    method: "GET",
+    query: input
+  });
+}
+async function setConsents(config, input) {
+  return callApi(config, "/consent/set", { method: "POST", body: input });
+}
+async function acceptAllConsents(config, input) {
+  return callApi(config, "/consent/accept-all", {
+    method: "POST",
+    body: input
+  });
+}
+async function declineOptionalConsents(config, input) {
+  return callApi(config, "/consent/decline-optional", {
+    method: "POST",
+    body: input
+  });
+}
+async function linkAnonymousConsents(config, input) {
+  return callApi(config, "/consent/link-anonymous", {
+    method: "POST",
+    body: input
+  });
+}
+async function getConsentHistory(config, input) {
+  return callApi(config, "/consent/history", {
+    method: "GET",
+    query: {
+      userId: input.userId,
+      anonymousId: input.anonymousId,
+      limit: input.limit?.toString(),
+      offset: input.offset?.toString()
+    }
+  });
+}
+
+// src/referrals.ts
+async function getMyReferralCode(config, userId) {
+  return callApi(config, "/referrals/code", {
+    method: "GET",
+    query: { userId }
+  });
+}
+async function getReferralStats(config, userId) {
+  return callApi(config, "/referrals/stats", {
+    method: "GET",
+    query: { userId }
+  });
+}
+async function redeemReferralCode(config, input, defaults) {
+  return callApi(config, "/referrals/redeem", {
+    method: "POST",
+    body: { ...input, defaults }
+  });
+}
+async function getReferralLeaderboard(config, userId, options) {
+  return callApi(config, "/referrals/leaderboard", {
+    method: "GET",
+    query: { userId, ...options }
+  });
+}
+async function regenerateReferralCode(config, userId) {
+  return callApi(config, "/referrals/code/regenerate", {
+    method: "POST",
+    body: { userId }
+  });
+}
+
+// src/lib/engagement/types.ts
+var ACHIEVEMENT_TIER_CONFIG = {
+  bronze: { color: "#CD7F32", points: 10 },
+  silver: { color: "#C0C0C0", points: 25 },
+  gold: { color: "#FFD700", points: 50 },
+  platinum: { color: "#00CED1", points: 100 },
+  diamond: { color: "#B9F2FF", points: 200 }
+};
+
+// src/engagement.ts
+async function getStreak(config, streakId, userId) {
+  return callApi(config, "/engagement/streaks/get", {
+    method: "GET",
+    query: { streakId, userId }
+  });
+}
+async function getAllStreaks(config, userId) {
+  return callApi(config, "/engagement/streaks", {
+    method: "GET",
+    query: { userId }
+  });
+}
+async function recordStreakActivity(config, input, userId, defaults) {
+  const { idempotencyKey, ...inputBody } = input;
+  return callApi(config, "/engagement/streaks/record", {
+    method: "POST",
+    body: { ...inputBody, userId, defaults },
+    idempotencyKey
+  });
+}
+async function recoverStreak(config, streakId, userId) {
+  return callApi(config, "/engagement/streaks/recover", {
+    method: "POST",
+    body: { streakId, userId }
+  });
+}
+async function getLeaderboard(config, leaderboardId, userId, options) {
+  return callApi(config, "/engagement/leaderboards/get", {
+    method: "GET",
+    query: { leaderboardId, userId: userId ?? void 0, ...options }
+  });
+}
+async function submitScore(config, input, userId, defaults) {
+  return callApi(config, "/engagement/leaderboards/submit", {
+    method: "POST",
+    body: { ...input, userId, defaults }
+  });
+}
+async function getUserLeaderboardRank(config, leaderboardId, userId) {
+  return callApi(config, "/engagement/leaderboards/rank", {
+    method: "GET",
+    query: { leaderboardId, userId }
+  });
+}
+async function getAchievements(config, userId) {
+  return callApi(config, "/engagement/achievements", {
+    method: "GET",
+    query: { userId }
+  });
+}
+async function getAchievement(config, achievementId, userId) {
+  return callApi(config, "/engagement/achievements/get", {
+    method: "GET",
+    query: { achievementId, userId }
+  });
+}
+async function unlockAchievement(config, achievementId, userId, defaults) {
+  return callApi(config, "/engagement/achievements/unlock", {
+    method: "POST",
+    body: { achievementId, userId, defaults }
+  });
+}
+async function incrementAchievementProgress(config, achievementId, amount, userId, defaults) {
+  return callApi(config, "/engagement/achievements/progress", {
+    method: "POST",
+    body: { achievementId, amount, userId, defaults }
+  });
+}
+async function getAchievementPoints(config, userId) {
+  return callApi(config, "/engagement/achievements/points", {
+    method: "GET",
+    query: { userId }
+  });
+}
+
+// src/orgs.ts
+async function getOrganizations(config) {
+  return callApi(config, "/orgs");
+}
+async function getOrganization(config, orgIdOrSlug) {
+  return callApi(config, `/orgs/${orgIdOrSlug}`);
+}
+async function createOrganization(config, input) {
+  return callApi(config, "/orgs", {
+    method: "POST",
+    body: input
+  });
+}
+async function updateOrganization(config, orgIdOrSlug, input) {
+  return callApi(
+    config,
+    `/orgs/${orgIdOrSlug}`,
+    {
+      method: "PUT",
+      body: input
+    }
+  );
+}
+async function deleteOrganization(config, orgIdOrSlug) {
+  return callApi(config, `/orgs/${orgIdOrSlug}`, {
+    method: "DELETE"
+  });
+}
+async function getOrganizationMembers(config, orgIdOrSlug) {
+  return callApi(
+    config,
+    `/orgs/${orgIdOrSlug}/members`
+  );
+}
+async function inviteOrganizationMember(config, orgIdOrSlug, input) {
+  return callApi(
+    config,
+    `/orgs/${orgIdOrSlug}/members/invite`,
+    {
+      method: "POST",
+      body: input
+    }
+  );
+}
+async function updateOrganizationMemberRole(config, orgIdOrSlug, memberId, role) {
+  return callApi(
+    config,
+    `/orgs/${orgIdOrSlug}/members/${memberId}/role`,
+    {
+      method: "PUT",
+      body: { role }
+    }
+  );
+}
+async function removeOrganizationMember(config, orgIdOrSlug, memberId) {
+  return callApi(
+    config,
+    `/orgs/${orgIdOrSlug}/members/${memberId}`,
+    {
+      method: "DELETE"
+    }
+  );
+}
+async function leaveOrganization(config, orgIdOrSlug) {
+  return callApi(config, `/orgs/${orgIdOrSlug}/leave`, {
+    method: "POST"
+  });
+}
+async function getOrganizationInvitations(config, orgIdOrSlug) {
+  return callApi(
+    config,
+    `/orgs/${orgIdOrSlug}/invitations`
+  );
+}
+async function acceptOrganizationInvitation(config, token) {
+  return callApi(
+    config,
+    "/orgs/invitations/accept",
+    {
+      method: "POST",
+      body: { token }
+    }
+  );
+}
+async function revokeOrganizationInvitation(config, orgIdOrSlug, invitationId) {
+  return callApi(
+    config,
+    `/orgs/${orgIdOrSlug}/invitations/${invitationId}`,
+    {
+      method: "DELETE"
+    }
+  );
+}
+function hasRole(membership, minimumRole) {
+  if (!membership) return false;
+  const roleHierarchy = [
+    "viewer",
+    "analytics",
+    "developer",
+    "billing",
+    "admin",
+    "super_admin"
+  ];
+  const userRoleIndex = roleHierarchy.indexOf(membership.role);
+  const requiredRoleIndex = roleHierarchy.indexOf(minimumRole);
+  return userRoleIndex >= requiredRoleIndex;
+}
+function canManageMembers(membership) {
+  return hasRole(membership, "admin");
+}
+function canManageSettings(membership) {
+  return hasRole(membership, "admin");
+}
+function canDeleteOrganization(membership) {
+  return hasRole(membership, "super_admin");
+}
+
+// src/secrets.ts
+async function getSecret(config, input) {
+  return callApi(config, "/secrets/get", {
+    method: "POST",
+    body: {
+      key: input.key,
+      environmentId: input.environmentId
+    }
+  });
+}
+async function getSecrets(config, input) {
+  return callApi(config, "/secrets/getMany", {
+    method: "POST",
+    body: {
+      keys: input.keys,
+      environmentId: input.environmentId
+    }
+  });
+}
+async function listSecretKeys(config, input = {}) {
+  return callApi(config, "/secrets/listKeys", {
+    method: "GET",
+    query: input.environmentId ? { environmentId: input.environmentId } : void 0
+  });
+}
+async function hasSecret(config, key) {
+  try {
+    const keys = await listSecretKeys(config);
+    return keys.some((k) => k.key === key);
+  } catch {
+    return false;
+  }
+}
+async function getAllSecrets(config, environmentId) {
+  const keys = await listSecretKeys(config, { environmentId });
+  if (keys.length === 0) {
+    return {};
+  }
+  return getSecrets(config, { keys: keys.map((k) => k.key), environmentId });
+}
+
+// src/search.ts
+async function indexDocument(config, input) {
+  return callApi(config, "/search/index", {
+    method: "POST",
+    body: {
+      title: input.title,
+      content: input.content,
+      namespace: input.namespace ?? "default",
+      externalId: input.externalId,
+      url: input.url,
+      metadata: input.metadata,
+      category: input.category,
+      type: input.type,
+      tags: input.tags,
+      language: input.language ?? "english",
+      skipEmbedding: input.skipEmbedding ?? false,
+      embeddingModel: input.embeddingModel ?? "openai/text-embedding-3-small"
+    }
+  });
+}
+async function batchIndex(config, input) {
+  return callApi(config, "/search/batchIndex", {
+    method: "POST",
+    body: {
+      documents: input.documents,
+      namespace: input.namespace ?? "default",
+      language: input.language ?? "english",
+      skipEmbedding: input.skipEmbedding ?? false,
+      embeddingModel: input.embeddingModel ?? "openai/text-embedding-3-small"
+    }
+  });
+}
+async function search(config, input) {
+  return callApi(config, "/search/search", {
+    method: "POST",
+    body: {
+      query: input.query,
+      namespace: input.namespace ?? "default",
+      searchType: input.searchType ?? "hybrid",
+      limit: input.limit ?? 10,
+      offset: input.offset ?? 0,
+      minSimilarity: input.minSimilarity,
+      typoTolerance: input.typoTolerance ?? true,
+      language: input.language ?? "english",
+      filters: input.filters,
+      highlight: input.highlight ?? true,
+      embeddingModel: input.embeddingModel ?? "openai/text-embedding-3-small",
+      trackQuery: input.trackQuery ?? true,
+      sessionId: input.sessionId,
+      userId: input.userId
+    }
+  });
+}
+async function getFacets(config, input = {}) {
+  return callApi(config, "/search/getFacets", {
+    method: "POST",
+    body: {
+      namespace: input.namespace ?? "default",
+      facets: input.facets ?? ["category", "type"],
+      filters: input.filters
+    }
+  });
+}
+async function deleteDocument(config, input) {
+  return callApi(config, "/search/delete", {
+    method: "POST",
+    body: {
+      id: input.id,
+      externalId: input.externalId,
+      namespace: input.namespace ?? "default"
+    }
+  });
+}
+async function upsertDocument(config, input) {
+  return callApi(config, "/search/upsert", {
+    method: "POST",
+    body: {
+      title: input.title,
+      content: input.content,
+      namespace: input.namespace ?? "default",
+      externalId: input.externalId,
+      url: input.url,
+      metadata: input.metadata,
+      category: input.category,
+      type: input.type,
+      tags: input.tags,
+      language: input.language ?? "english",
+      skipEmbedding: input.skipEmbedding ?? false,
+      embeddingModel: input.embeddingModel ?? "openai/text-embedding-3-small"
+    }
+  });
+}
+async function getSearchStats(config, namespace) {
+  return callApi(config, "/search/getStats", {
+    method: "POST",
+    body: { namespace }
+  });
+}
+async function trackClick(config, input) {
+  return callApi(config, "/search/trackClick", {
+    method: "POST",
+    body: input
+  });
+}
+
+// src/database.ts
+async function getDatabaseConnectionString(config) {
+  return callApi(
+    config,
+    "/sdk/database/connection-string",
+    { method: "GET" }
+  );
+}
+async function getDatabaseStatus(config) {
+  return callApi(config, "/sdk/database/status", {
+    method: "GET"
+  });
+}
+
+// src/kv.ts
+async function kvSet(config, request) {
+  return callApi(config, "/sdk/kv/set", {
+    method: "POST",
+    body: request
+  });
+}
+async function kvGet(config, key) {
+  const result = await callApi(
+    config,
+    `/sdk/kv/get/${encodeURIComponent(key)}`,
+    { method: "GET" }
+  );
+  return result.value;
+}
+async function kvDelete(config, key) {
+  return callApi(
+    config,
+    `/sdk/kv/delete/${encodeURIComponent(key)}`,
+    { method: "DELETE" }
+  );
+}
+async function kvExists(config, key) {
+  return callApi(
+    config,
+    `/sdk/kv/exists/${encodeURIComponent(key)}`,
+    { method: "GET" }
+  );
+}
+async function kvExpire(config, request) {
+  return callApi(config, "/sdk/kv/expire", {
+    method: "POST",
+    body: request
+  });
+}
+async function kvIncr(config, request) {
+  return callApi(config, "/sdk/kv/incr", {
+    method: "POST",
+    body: request
+  });
+}
+async function kvMset(config, request) {
+  return callApi(config, "/sdk/kv/mset", {
+    method: "POST",
+    body: request
+  });
+}
+async function kvMget(config, request) {
+  const result = await callApi(
+    config,
+    "/sdk/kv/mget",
+    { method: "POST", body: request }
+  );
+  return result.values;
+}
+async function kvHset(config, request) {
+  return callApi(config, "/sdk/kv/hset", {
+    method: "POST",
+    body: request
+  });
+}
+async function kvHget(config, request) {
+  const result = await callApi(config, "/sdk/kv/hget", {
+    method: "POST",
+    body: request
+  });
+  return result.value;
+}
+async function kvHgetall(config, request) {
+  const result = await callApi(config, "/sdk/kv/hgetall", {
+    method: "POST",
+    body: request
+  });
+  return result.value;
+}
+async function kvLpush(config, request) {
+  return callApi(config, "/sdk/kv/lpush", {
+    method: "POST",
+    body: request
+  });
+}
+async function kvLrange(config, request) {
+  const result = await callApi(config, "/sdk/kv/lrange", {
+    method: "POST",
+    body: request
+  });
+  return result.items;
+}
+async function kvZadd(config, request) {
+  return callApi(config, "/sdk/kv/zadd", {
+    method: "POST",
+    body: request
+  });
+}
+async function kvZrange(config, request) {
+  const result = await callApi(config, "/sdk/kv/zrange", {
+    method: "POST",
+    body: request
+  });
+  return result.members;
+}
+async function kvRateLimit(config, request) {
+  return callApi(config, "/sdk/kv/ratelimit", {
+    method: "POST",
+    body: request
+  });
+}
+
+// src/realtime.ts
+async function realtimeEmit(config, request) {
+  return callApi(config, "/sdk/realtime/emit", {
+    method: "POST",
+    body: request
+  });
+}
+async function getRealtimeHistory(config, request) {
+  const params = new URLSearchParams();
+  params.set("channel", request.channel);
+  if (request.limit !== void 0) params.set("limit", String(request.limit));
+  if (request.after !== void 0) params.set("after", request.after);
+  return callApi(
+    config,
+    `/sdk/realtime/history?${params.toString()}`,
+    { method: "GET" }
+  );
+}
+
+// src/deploy.ts
+async function triggerDeploy(config, request) {
+  return callApi(
+    config,
+    `/sdk/deploy/trigger/${encodeURIComponent(request.envId)}`,
+    {
+      method: "POST",
+      body: request.forceRebuild !== void 0 ? { forceRebuild: request.forceRebuild } : void 0
+    }
+  );
+}
+async function getDeployStatus(config, envId) {
+  return callApi(
+    config,
+    `/sdk/deploy/status/${encodeURIComponent(envId)}`,
+    { method: "GET" }
+  );
+}
+async function getDeployHistory(config, envId) {
+  return callApi(
+    config,
+    `/sdk/deploy/history/${encodeURIComponent(envId)}`,
+    { method: "GET" }
+  );
+}
+async function rollbackDeploy(config, request) {
+  return callApi(
+    config,
+    `/sdk/deploy/rollback/${encodeURIComponent(request.envId)}`,
+    {
+      method: "POST",
+      body: { deploymentId: request.deploymentId }
+    }
+  );
+}
+async function getBuildLogHistory(config, envId) {
+  return callApi(
+    config,
+    `/sdk/deploy/logs/${encodeURIComponent(envId)}/history`,
+    { method: "GET" }
+  );
+}
+async function listEnvVars(config, envId) {
+  const result = await callApi(
+    config,
+    `/sdk/deploy/envvars/${encodeURIComponent(envId)}`,
+    { method: "GET" }
+  );
+  return result.envVars;
+}
+async function setEnvVar(config, envId, request) {
+  return callApi(
+    config,
+    `/sdk/deploy/envvars/${encodeURIComponent(envId)}`,
+    {
+      method: "POST",
+      body: request
+    }
+  );
+}
+async function deleteEnvVar(config, envId, key) {
+  return callApi(
+    config,
+    `/sdk/deploy/envvars/${encodeURIComponent(envId)}/${encodeURIComponent(key)}`,
+    { method: "DELETE" }
+  );
+}
+async function listCustomDomains(config, envId) {
+  const result = await callApi(
+    config,
+    `/sdk/deploy/domains/${encodeURIComponent(envId)}`,
+    { method: "GET" }
+  );
+  return result.domains;
+}
+async function addCustomDomain(config, envId, request) {
+  return callApi(
+    config,
+    `/sdk/deploy/domains/${encodeURIComponent(envId)}`,
+    {
+      method: "POST",
+      body: request
+    }
+  );
+}
+async function removeCustomDomain(config, envId, domain) {
+  return callApi(
+    config,
+    `/sdk/deploy/domains/${encodeURIComponent(envId)}/${encodeURIComponent(domain)}`,
+    { method: "DELETE" }
+  );
+}
+
+// src/monitoring.ts
+function errorToExceptionValue(error) {
+  const frames = [];
+  if (error.stack) {
+    const lines = error.stack.split("\n").slice(1);
+    for (const line of lines) {
+      const v8Match = line.match(/^\s+at\s+(.+?)\s+\((.+):(\d+):(\d+)\)$/);
+      if (v8Match) {
+        frames.push({
+          function: v8Match[1],
+          filename: v8Match[2],
+          lineno: Number(v8Match[3]),
+          colno: Number(v8Match[4])
+        });
+        continue;
+      }
+      const v8AnonMatch = line.match(/^\s+at\s+(.+):(\d+):(\d+)$/);
+      if (v8AnonMatch) {
+        frames.push({
+          filename: v8AnonMatch[1],
+          lineno: Number(v8AnonMatch[2]),
+          colno: Number(v8AnonMatch[3])
+        });
+      }
+    }
+  }
+  return {
+    type: error.name || "Error",
+    value: error.message,
+    stacktrace: frames.length > 0 ? { frames } : void 0
+  };
+}
+async function captureException(config, error, options = {}) {
+  const exceptionValue = errorToExceptionValue(error);
+  const request = {
+    ...options,
+    exception: { values: [exceptionValue] }
+  };
+  return callApi(config, "/sdk/monitoring/exception", {
+    method: "POST",
+    body: request
+  });
+}
+async function captureExceptionRaw(config, request) {
+  return callApi(config, "/sdk/monitoring/exception", {
+    method: "POST",
+    body: request
+  });
+}
+async function captureMessage(config, message, options = {}) {
+  const request = { ...options, message };
+  return callApi(config, "/sdk/monitoring/message", {
+    method: "POST",
+    body: request
+  });
+}
+export {
+  ACHIEVEMENT_TIER_CONFIG,
+  AuthenticationError,
+  AuthorizationError,
+  CircuitBreakerOpenError,
+  ERROR_CODE_STATUS,
+  NetworkError,
+  NotFoundError,
+  RETRYABLE_CODES,
+  RateLimitError,
+  SylphxError,
+  TimeoutError,
+  ValidationError,
+  acceptAllConsents,
+  acceptOrganizationInvitation,
+  addCustomDomain,
+  batchIndex,
+  canDeleteOrganization,
+  canManageMembers,
+  canManageSettings,
+  cancelJob,
+  cancelScheduledEmail,
+  captureException,
+  captureExceptionRaw,
+  captureMessage,
+  chat,
+  chatStream,
+  checkFlag,
+  complete,
+  createCheckout,
+  createConfig,
+  createCron,
+  createDynamicRestClient,
+  createOrganization,
+  createPortalSession,
+  createRestClient,
+  createServiceWorkerScript,
+  createTracker,
+  debugError,
+  debugLog,
+  debugTimer,
+  debugWarn,
+  declineOptionalConsents,
+  deleteCron,
+  deleteDocument,
+  deleteEnvVar,
+  deleteFile,
+  deleteOrganization,
+  disableDebug,
+  embed,
+  enableDebug,
+  exponentialBackoff,
+  forgotPassword,
+  generateAnonymousId,
+  getAchievement,
+  getAchievementPoints,
+  getAchievements,
+  getAllFlags,
+  getAllSecrets,
+  getAllStreaks,
+  getBillingBalance,
+  getBillingUsage,
+  getBuildLogHistory,
+  getCircuitBreakerState,
+  getConsentHistory,
+  getConsentTypes,
+  getDatabaseConnectionString,
+  getDatabaseStatus,
+  getDebugMode,
+  getDeployHistory,
+  getDeployStatus,
+  getErrorCode,
+  getErrorMessage,
+  getFacets,
+  getFileInfo,
+  getFileUrl,
+  getFlagPayload,
+  getFlags,
+  getJob,
+  getLeaderboard,
+  getMyReferralCode,
+  getOrganization,
+  getOrganizationInvitations,
+  getOrganizationMembers,
+  getOrganizations,
+  getPlans,
+  getPushPreferences,
+  getRealtimeHistory,
+  getReferralLeaderboard,
+  getReferralStats,
+  getRestErrorMessage,
+  getScheduledEmail,
+  getScheduledEmailStats,
+  getSearchStats,
+  getSecret,
+  getSecrets,
+  getSession,
+  getSignedUrl,
+  getStreak,
+  getSubscription,
+  getUserConsents,
+  getUserLeaderboardRank,
+  getVariant,
+  getWebhookConfig,
+  getWebhookDeliveries,
+  getWebhookDelivery,
+  getWebhookStats,
+  hasConsent,
+  hasError,
+  hasRole,
+  hasSecret,
+  identify,
+  incrementAchievementProgress,
+  indexDocument,
+  initPushServiceWorker,
+  installGlobalDebugHelpers,
+  introspectToken,
+  inviteOrganizationMember,
+  isEmailConfigured,
+  isEnabled,
+  isRetryableError,
+  isSylphxError,
+  kvDelete,
+  kvExists,
+  kvExpire,
+  kvGet,
+  kvHget,
+  kvHgetall,
+  kvHset,
+  kvIncr,
+  kvLpush,
+  kvLrange,
+  kvMget,
+  kvMset,
+  kvRateLimit,
+  kvSet,
+  kvZadd,
+  kvZrange,
+  leaveOrganization,
+  linkAnonymousConsents,
+  listCustomDomains,
+  listEnvVars,
+  listJobs,
+  listScheduledEmails,
+  listSecretKeys,
+  page,
+  pauseCron,
+  realtimeEmit,
+  recordStreakActivity,
+  recoverStreak,
+  redeemReferralCode,
+  refreshToken,
+  regenerateReferralCode,
+  registerPush,
+  registerPushServiceWorker,
+  removeCustomDomain,
+  removeOrganizationMember,
+  replayWebhookDelivery,
+  rescheduleEmail,
+  resetCircuitBreaker,
+  resetDebugModeCache,
+  resetPassword,
+  resumeCron,
+  revokeAllTokens,
+  revokeOrganizationInvitation,
+  revokeToken,
+  rollbackDeploy,
+  scheduleEmail,
+  scheduleJob,
+  search,
+  sendEmail,
+  sendEmailToUser,
+  sendPush,
+  sendTemplatedEmail,
+  setConsents,
+  setEnvVar,
+  signIn,
+  signOut,
+  signUp,
+  streamToString,
+  submitScore,
+  toSylphxError,
+  track,
+  trackBatch,
+  trackClick,
+  triggerDeploy,
+  unlockAchievement,
+  unregisterPush,
+  updateOrganization,
+  updateOrganizationMemberRole,
+  updatePushPreferences,
+  updateWebhookConfig,
+  uploadAvatar,
+  uploadFile,
+  upsertDocument,
+  verifyEmail,
+  verifyTwoFactor,
+  withToken
+};
+//# sourceMappingURL=index.mjs.map