@scalemule/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,4666 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/upload-resume.ts
+var upload_resume_exports = {};
+__export(upload_resume_exports, {
+  UploadResumeStore: () => UploadResumeStore
+});
+var DB_NAME, STORE_NAME, DB_VERSION, MAX_AGE_MS, UploadResumeStore;
+var init_upload_resume = __esm({
+  "src/services/upload-resume.ts"() {
+    "use strict";
+    DB_NAME = "sm_upload_sessions_v1";
+    STORE_NAME = "sessions";
+    DB_VERSION = 1;
+    MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+    UploadResumeStore = class {
+      constructor() {
+        this.db = null;
+      }
+      /** Generate a deterministic resume key from upload identity */
+      static async generateResumeKey(appId, userId, filename, size, lastModified) {
+        const raw = `${appId}:${userId}:${filename}:${size}:${lastModified ?? 0}`;
+        if (typeof crypto !== "undefined" && crypto.subtle) {
+          const buffer = new TextEncoder().encode(raw);
+          const hash2 = await crypto.subtle.digest("SHA-256", buffer);
+          return Array.from(new Uint8Array(hash2)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        }
+        let hash = 0;
+        for (let i = 0; i < raw.length; i++) {
+          const chr = raw.charCodeAt(i);
+          hash = (hash << 5) - hash + chr;
+          hash |= 0;
+        }
+        return `fallback_${Math.abs(hash).toString(36)}`;
+      }
+      /** Open the IndexedDB store. No-ops if IndexedDB is unavailable. */
+      async open() {
+        if (typeof indexedDB === "undefined") return;
+        return new Promise((resolve, reject) => {
+          const request = indexedDB.open(DB_NAME, DB_VERSION);
+          request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+              const store = db.createObjectStore(STORE_NAME, { keyPath: "key" });
+              store.createIndex("updated_at", "updated_at");
+            }
+          };
+          request.onsuccess = () => {
+            this.db = request.result;
+            resolve();
+          };
+          request.onerror = () => {
+            reject(request.error);
+          };
+        });
+      }
+      /** Get a resume session by key. Returns null if not found or stale. */
+      async get(key) {
+        if (!this.db) return null;
+        return new Promise((resolve) => {
+          const tx = this.db.transaction(STORE_NAME, "readonly");
+          const store = tx.objectStore(STORE_NAME);
+          const request = store.get(key);
+          request.onsuccess = () => {
+            const entry = request.result;
+            if (!entry) {
+              resolve(null);
+              return;
+            }
+            if (Date.now() - entry.updated_at > MAX_AGE_MS) {
+              this.remove(key).catch(() => {
+              });
+              resolve(null);
+              return;
+            }
+            resolve(entry.session);
+          };
+          request.onerror = () => resolve(null);
+        });
+      }
+      /** Save a new resume session. */
+      async save(key, session) {
+        if (!this.db) return;
+        return new Promise((resolve, reject) => {
+          const tx = this.db.transaction(STORE_NAME, "readwrite");
+          const store = tx.objectStore(STORE_NAME);
+          const entry = {
+            key,
+            session: { ...session, created_at: Date.now() },
+            updated_at: Date.now()
+          };
+          const request = store.put(entry);
+          request.onsuccess = () => resolve();
+          request.onerror = () => reject(request.error);
+        });
+      }
+      /** Update a single completed part in an existing session. */
+      async updatePart(key, partNumber, etag) {
+        if (!this.db) return;
+        return new Promise((resolve) => {
+          const tx = this.db.transaction(STORE_NAME, "readwrite");
+          const store = tx.objectStore(STORE_NAME);
+          const getRequest = store.get(key);
+          getRequest.onsuccess = () => {
+            const entry = getRequest.result;
+            if (!entry) {
+              resolve();
+              return;
+            }
+            const existing = entry.session.completed_parts.find((p) => p.part_number === partNumber);
+            if (!existing) {
+              entry.session.completed_parts.push({ part_number: partNumber, etag });
+            }
+            entry.updated_at = Date.now();
+            const putRequest = store.put(entry);
+            putRequest.onsuccess = () => resolve();
+            putRequest.onerror = () => resolve();
+          };
+          getRequest.onerror = () => resolve();
+        });
+      }
+      /** Remove a resume session (e.g., after successful completion). */
+      async remove(key) {
+        if (!this.db) return;
+        return new Promise((resolve) => {
+          const tx = this.db.transaction(STORE_NAME, "readwrite");
+          const store = tx.objectStore(STORE_NAME);
+          const request = store.delete(key);
+          request.onsuccess = () => resolve();
+          request.onerror = () => resolve();
+        });
+      }
+      /** Purge all stale entries (older than MAX_AGE_MS). */
+      async purgeStale() {
+        if (!this.db) return 0;
+        return new Promise((resolve) => {
+          const cutoff = Date.now() - MAX_AGE_MS;
+          const tx = this.db.transaction(STORE_NAME, "readwrite");
+          const store = tx.objectStore(STORE_NAME);
+          const index = store.index("updated_at");
+          const range = IDBKeyRange.upperBound(cutoff);
+          const request = index.openCursor(range);
+          let count = 0;
+          request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor) {
+              cursor.delete();
+              count++;
+              cursor.continue();
+            } else {
+              resolve(count);
+            }
+          };
+          request.onerror = () => resolve(0);
+        });
+      }
+      /** Close the database connection. */
+      close() {
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+        }
+      }
+    };
+  }
+});
+
+// src/services/upload-compression.ts
+var upload_compression_exports = {};
+__export(upload_compression_exports, {
+  maybeCompressImage: () => maybeCompressImage
+});
+async function maybeCompressImage(file, userConfig, sessionId, telemetry) {
+  const type = file.type?.toLowerCase() || "";
+  if (!type.startsWith("image/")) return null;
+  if (SKIP_TYPES.has(type)) {
+    telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "format", type });
+    return null;
+  }
+  if (!COMPRESSIBLE_TYPES.has(type)) {
+    telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "unsupported_type", type });
+    return null;
+  }
+  if (file.size < MIN_COMPRESS_SIZE) {
+    telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "too_small", size: file.size });
+    return null;
+  }
+  const networkType = getNetworkEffectiveType();
+  const defaultProfile = { maxWidth: 3840, maxHeight: 3840, quality: 0.85, maxSizeMB: 5 };
+  const networkProfile = NETWORK_PROFILES[networkType] ?? defaultProfile;
+  const config = {
+    maxWidth: userConfig?.maxWidth ?? networkProfile.maxWidth,
+    maxHeight: userConfig?.maxHeight ?? networkProfile.maxHeight,
+    quality: userConfig?.quality ?? networkProfile.quality,
+    maxSizeMB: userConfig?.maxSizeMB ?? networkProfile.maxSizeMB
+  };
+  telemetry?.emit(sessionId, "upload.compression.started", {
+    original_size: file.size,
+    network: networkType,
+    target_quality: config.quality
+  });
+  try {
+    const imageCompression = await loadImageCompression();
+    if (!imageCompression) {
+      telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "library_unavailable" });
+      return null;
+    }
+    const compressed = await imageCompression(file, {
+      maxSizeMB: config.maxSizeMB,
+      maxWidthOrHeight: Math.max(config.maxWidth, config.maxHeight),
+      initialQuality: config.quality,
+      useWebWorker: true,
+      fileType: type === "image/png" ? "image/webp" : void 0
+    });
+    if (compressed.size >= file.size * 0.95) {
+      telemetry?.emit(sessionId, "upload.compression.skipped", {
+        reason: "no_size_reduction",
+        original_size: file.size,
+        compressed_size: compressed.size
+      });
+      return null;
+    }
+    telemetry?.emit(sessionId, "upload.compression.completed", {
+      original_size: file.size,
+      compressed_size: compressed.size,
+      ratio: (compressed.size / file.size).toFixed(2)
+    });
+    return compressed;
+  } catch (err) {
+    telemetry?.emit(sessionId, "upload.compression.skipped", {
+      reason: "error",
+      error: err instanceof Error ? err.message : "Unknown compression error"
+    });
+    return null;
+  }
+}
+async function loadImageCompression() {
+  if (cachedImport === false) return null;
+  if (cachedImport) return cachedImport;
+  try {
+    const mod = await Function('return import("browser-image-compression")')();
+    cachedImport = mod.default || mod;
+    return cachedImport;
+  } catch {
+    cachedImport = false;
+    return null;
+  }
+}
+function getNetworkEffectiveType() {
+  if (typeof navigator !== "undefined" && "connection" in navigator) {
+    const conn = navigator.connection;
+    return conn?.effectiveType || "4g";
+  }
+  return "4g";
+}
+var MIN_COMPRESS_SIZE, COMPRESSIBLE_TYPES, SKIP_TYPES, NETWORK_PROFILES, cachedImport;
+var init_upload_compression = __esm({
+  "src/services/upload-compression.ts"() {
+    "use strict";
+    MIN_COMPRESS_SIZE = 100 * 1024;
+    COMPRESSIBLE_TYPES = /* @__PURE__ */ new Set([
+      "image/jpeg",
+      "image/jpg",
+      "image/png",
+      "image/bmp",
+      "image/tiff"
+    ]);
+    SKIP_TYPES = /* @__PURE__ */ new Set([
+      "image/gif",
+      "image/svg+xml",
+      "image/webp",
+      "image/avif"
+    ]);
+    NETWORK_PROFILES = {
+      "slow-2g": { maxWidth: 1280, maxHeight: 1280, quality: 0.6, maxSizeMB: 0.5 },
+      "2g": { maxWidth: 1600, maxHeight: 1600, quality: 0.65, maxSizeMB: 1 },
+      "3g": { maxWidth: 2048, maxHeight: 2048, quality: 0.75, maxSizeMB: 2 },
+      "4g": { maxWidth: 3840, maxHeight: 3840, quality: 0.85, maxSizeMB: 5 }
+    };
+    cachedImport = null;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccountsService: () => AccountsService,
+  AnalyticsService: () => AnalyticsService,
+  AuthService: () => AuthService,
+  BillingService: () => BillingService,
+  CacheService: () => CacheService,
+  CatalogService: () => CatalogService,
+  ChatService: () => ChatService,
+  CommunicationService: () => CommunicationService,
+  ComplianceService: () => ComplianceService,
+  DataService: () => DataService,
+  ErrorCodes: () => ErrorCodes,
+  EventsService: () => EventsService,
+  FlagContentService: () => FlagContentService,
+  FunctionsService: () => FunctionsService,
+  GraphService: () => GraphService,
+  IdentityService: () => IdentityService,
+  LeaderboardService: () => LeaderboardService,
+  ListingsService: () => ListingsService,
+  LoggerService: () => LoggerService,
+  OrchestratorService: () => OrchestratorService,
+  PHONE_COUNTRIES: () => import_phone.PHONE_COUNTRIES,
+  PHOTO_BREAKPOINTS: () => PHOTO_BREAKPOINTS,
+  PermissionsService: () => PermissionsService,
+  PhotoService: () => PhotoService,
+  QueueService: () => QueueService,
+  RealtimeService: () => RealtimeService,
+  ScaleMule: () => ScaleMule,
+  ScaleMuleClient: () => ScaleMuleClient,
+  SchedulerService: () => SchedulerService,
+  SearchService: () => SearchService,
+  ServiceModule: () => ServiceModule,
+  SocialService: () => SocialService,
+  StorageService: () => StorageService,
+  TeamsService: () => TeamsService,
+  UploadResumeStore: () => UploadResumeStore,
+  UploadTelemetry: () => UploadTelemetry,
+  VideoService: () => VideoService,
+  WebhooksService: () => WebhooksService,
+  buildClientContextHeaders: () => buildClientContextHeaders,
+  calculateTotalParts: () => calculateTotalParts,
+  canPerform: () => canPerform,
+  composePhoneNumber: () => import_phone.composePhoneNumber,
+  countryFlag: () => import_phone.countryFlag,
+  createUploadPlan: () => createUploadPlan,
+  default: () => index_default,
+  detectCountryFromE164: () => import_phone.detectCountryFromE164,
+  detectNetworkClass: () => detectNetworkClass,
+  extractClientContext: () => extractClientContext,
+  findPhoneCountryByCode: () => import_phone.findPhoneCountryByCode,
+  findPhoneCountryByDialCode: () => import_phone.findPhoneCountryByDialCode,
+  generateUploadSessionId: () => generateUploadSessionId,
+  getMeasuredBandwidthMbps: () => getMeasuredBandwidthMbps,
+  getPartRange: () => getPartRange,
+  hasMinRoleLevel: () => hasMinRoleLevel,
+  isValidE164Phone: () => import_phone.isValidE164Phone,
+  normalizeAndValidatePhone: () => import_phone.normalizeAndValidatePhone,
+  normalizePhoneNumber: () => import_phone.normalizePhoneNumber,
+  resolveStrategy: () => resolveStrategy,
+  validateIP: () => validateIP
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var ErrorCodes = {
+  // Auth & access
+  UNAUTHORIZED: "unauthorized",
+  FORBIDDEN: "forbidden",
+  // Resources
+  NOT_FOUND: "not_found",
+  CONFLICT: "conflict",
+  // Input
+  VALIDATION_ERROR: "validation_error",
+  // Rate limiting & quotas
+  RATE_LIMITED: "rate_limited",
+  QUOTA_EXCEEDED: "quota_exceeded",
+  // Server
+  INTERNAL_ERROR: "internal_error",
+  // Network (SDK-generated, not from server)
+  NETWORK_ERROR: "network_error",
+  TIMEOUT: "timeout",
+  ABORTED: "aborted",
+  // Storage-specific
+  FILE_SCANNING: "file_scanning",
+  FILE_THREAT: "file_threat",
+  FILE_QUARANTINED: "file_quarantined",
+  // Upload
+  UPLOAD_ERROR: "upload_error"
+};
+
+// src/context.ts
+function validateIP(ip) {
+  if (!ip) return void 0;
+  const trimmed = ip.trim();
+  if (!trimmed) return void 0;
+  const ipv4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+  const ipv6 = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,7}:$|^(?:[0-9a-fA-F]{1,4}:){0,6}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$/;
+  const mapped = /^::ffff:(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/i;
+  if (ipv4.test(trimmed) || ipv6.test(trimmed) || mapped.test(trimmed)) {
+    return trimmed;
+  }
+  return void 0;
+}
+function extractClientContext(request) {
+  const h = request.headers;
+  const getHeader = (name) => {
+    const v = h[name] ?? h[name.toLowerCase()];
+    return Array.isArray(v) ? v[0] : v;
+  };
+  let ip;
+  const cfIp = getHeader("cf-connecting-ip");
+  if (cfIp) ip = validateIP(cfIp);
+  if (!ip) {
+    const doIp = getHeader("do-connecting-ip");
+    if (doIp) ip = validateIP(doIp);
+  }
+  if (!ip) {
+    const realIp = getHeader("x-real-ip");
+    if (realIp) ip = validateIP(realIp);
+  }
+  if (!ip) {
+    const xff = getHeader("x-forwarded-for");
+    if (xff) ip = validateIP(xff.split(",")[0]?.trim());
+  }
+  if (!ip) {
+    const vercel = getHeader("x-vercel-forwarded-for");
+    if (vercel) ip = validateIP(vercel.split(",")[0]?.trim());
+  }
+  if (!ip) {
+    const akamai = getHeader("true-client-ip");
+    if (akamai) ip = validateIP(akamai);
+  }
+  if (!ip && request.socket?.remoteAddress) {
+    ip = validateIP(request.socket.remoteAddress);
+  }
+  return {
+    ip,
+    userAgent: getHeader("user-agent") || void 0,
+    deviceFingerprint: getHeader("x-device-fingerprint") || void 0,
+    referrer: getHeader("referer") || void 0
+  };
+}
+function buildClientContextHeaders(context) {
+  if (!context) return {};
+  const headers = {};
+  if (context.ip) {
+    headers["x-sm-forwarded-client-ip"] = context.ip;
+    headers["X-Client-IP"] = context.ip;
+  }
+  if (context.userAgent) headers["X-Client-User-Agent"] = context.userAgent;
+  if (context.deviceFingerprint) headers["X-Client-Device-Fingerprint"] = context.deviceFingerprint;
+  if (context.referrer) headers["X-Client-Referrer"] = context.referrer;
+  return headers;
+}
+
+// src/client.ts
+var SDK_VERSION = "0.0.1";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_BACKOFF_MS = 300;
+var MAX_BACKOFF_MS = 3e4;
+var SESSION_STORAGE_KEY = "scalemule_session";
+var USER_ID_STORAGE_KEY = "scalemule_user_id";
+var OFFLINE_QUEUE_KEY = "scalemule_offline_queue";
+var GATEWAY_URLS = {
+  dev: "https://api-dev.scalemule.com",
+  prod: "https://api.scalemule.com"
+};
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getBackoffDelay(attempt, baseDelay) {
+  const exponential = baseDelay * Math.pow(2, attempt);
+  const jitter = Math.random() * 0.3 * exponential;
+  return Math.min(exponential + jitter, MAX_BACKOFF_MS);
+}
+function generateIdempotencyKey() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function sanitizeFilename(filename) {
+  let sanitized = filename.replace(/[\x00-\x1f\x7f]/g, "");
+  sanitized = sanitized.replace(/["\\/\n\r]/g, "_").normalize("NFC").replace(/[\u200b-\u200f\ufeff\u2028\u2029]/g, "");
+  if (!sanitized || sanitized.trim() === "") {
+    sanitized = "unnamed";
+  }
+  if (sanitized.length > 200) {
+    const ext = sanitized.split(".").pop();
+    const base = sanitized.substring(0, 190);
+    sanitized = ext ? `${base}.${ext}` : base;
+  }
+  return sanitized.trim();
+}
+function statusToErrorCode(status) {
+  switch (status) {
+    case 400:
+      return "validation_error";
+    case 401:
+      return "unauthorized";
+    case 403:
+      return "forbidden";
+    case 404:
+      return "not_found";
+    case 409:
+      return "conflict";
+    case 422:
+      return "validation_error";
+    case 429:
+      return "rate_limited";
+    default:
+      return status >= 500 ? "internal_error" : `http_${status}`;
+  }
+}
+function createDefaultStorage() {
+  if (typeof window !== "undefined" && window.localStorage) {
+    return {
+      getItem: (key) => window.localStorage.getItem(key),
+      setItem: (key, value) => window.localStorage.setItem(key, value),
+      removeItem: (key) => window.localStorage.removeItem(key)
+    };
+  }
+  const memory = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => memory.get(key) ?? null,
+    setItem: (key, value) => {
+      memory.set(key, value);
+    },
+    removeItem: (key) => {
+      memory.delete(key);
+    }
+  };
+}
+var RateLimitQueue = class {
+  constructor() {
+    this.queue = [];
+    this.processing = false;
+    this.rateLimitedUntil = 0;
+  }
+  enqueue(execute, priority = 0) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        execute,
+        resolve,
+        reject,
+        priority
+      });
+      this.queue.sort((a, b) => b.priority - a.priority);
+      this.processQueue();
+    });
+  }
+  async processQueue() {
+    if (this.processing || this.queue.length === 0) return;
+    this.processing = true;
+    while (this.queue.length > 0) {
+      const now = Date.now();
+      if (now < this.rateLimitedUntil) {
+        await sleep(this.rateLimitedUntil - now);
+      }
+      const request = this.queue.shift();
+      if (!request) continue;
+      try {
+        const result = await request.execute();
+        if (result.error?.code === "rate_limited") {
+          this.queue.unshift(request);
+          const retryAfter = result.error.details?.retryAfter || 60;
+          this.rateLimitedUntil = Date.now() + retryAfter * 1e3;
+        } else {
+          request.resolve(result);
+        }
+      } catch (error) {
+        request.reject(error);
+      }
+    }
+    this.processing = false;
+  }
+  updateFromHeaders(headers) {
+    const retryAfter = headers.get("Retry-After");
+    if (retryAfter) {
+      const seconds = parseInt(retryAfter, 10);
+      if (!isNaN(seconds)) {
+        this.rateLimitedUntil = Date.now() + seconds * 1e3;
+      }
+    }
+  }
+  get length() {
+    return this.queue.length;
+  }
+  get isRateLimited() {
+    return Date.now() < this.rateLimitedUntil;
+  }
+};
+var OfflineQueue = class {
+  constructor(storage) {
+    this.queue = [];
+    this.onOnlineCallback = null;
+    this.storage = storage;
+    this.loadFromStorage();
+    this.setupListeners();
+  }
+  setupListeners() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("online", () => {
+      if (this.onOnlineCallback) this.onOnlineCallback();
+    });
+  }
+  async loadFromStorage() {
+    try {
+      const data = await this.storage.getItem(OFFLINE_QUEUE_KEY);
+      if (data) this.queue = JSON.parse(data);
+    } catch {
+    }
+  }
+  async save() {
+    try {
+      await this.storage.setItem(OFFLINE_QUEUE_KEY, JSON.stringify(this.queue));
+    } catch {
+    }
+  }
+  async add(method, path, body) {
+    this.queue.push({
+      id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      method,
+      path,
+      body: body ? JSON.stringify(body) : void 0,
+      timestamp: Date.now()
+    });
+    await this.save();
+  }
+  getAll() {
+    return [...this.queue];
+  }
+  async remove(id) {
+    this.queue = this.queue.filter((item) => item.id !== id);
+    await this.save();
+  }
+  async clear() {
+    this.queue = [];
+    await this.save();
+  }
+  setOnlineCallback(cb) {
+    this.onOnlineCallback = cb;
+  }
+  get length() {
+    return this.queue.length;
+  }
+  get online() {
+    return typeof navigator === "undefined" || navigator.onLine;
+  }
+};
+var ScaleMuleClient = class {
+  constructor(config) {
+    this.sessionToken = null;
+    this.userId = null;
+    this.rateLimitQueue = null;
+    this.offlineQueue = null;
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || GATEWAY_URLS[config.environment || "prod"];
+    this.debug = config.debug || false;
+    this.storage = config.storage || createDefaultStorage();
+    this.defaultTimeout = config.timeout || DEFAULT_TIMEOUT;
+    this.maxRetries = config.retry?.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.backoffMs = config.retry?.backoffMs ?? DEFAULT_BACKOFF_MS;
+    if (config.enableRateLimitQueue) {
+      this.rateLimitQueue = new RateLimitQueue();
+    }
+    if (config.enableOfflineQueue) {
+      this.offlineQueue = new OfflineQueue(this.storage);
+      this.offlineQueue.setOnlineCallback(() => this.syncOfflineQueue());
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Session Management
+  // --------------------------------------------------------------------------
+  async initialize() {
+    const token = await this.storage.getItem(SESSION_STORAGE_KEY);
+    const userId = await this.storage.getItem(USER_ID_STORAGE_KEY);
+    if (token) this.sessionToken = token;
+    if (userId) this.userId = userId;
+    if (this.debug) console.log("[ScaleMule] Initialized, session:", !!token);
+  }
+  async setSession(token, userId) {
+    this.sessionToken = token;
+    this.userId = userId;
+    await this.storage.setItem(SESSION_STORAGE_KEY, token);
+    await this.storage.setItem(USER_ID_STORAGE_KEY, userId);
+  }
+  async clearSession() {
+    this.sessionToken = null;
+    this.userId = null;
+    await this.storage.removeItem(SESSION_STORAGE_KEY);
+    await this.storage.removeItem(USER_ID_STORAGE_KEY);
+  }
+  setAccessToken(token) {
+    this.sessionToken = token;
+  }
+  clearAccessToken() {
+    this.sessionToken = null;
+  }
+  getSessionToken() {
+    return this.sessionToken;
+  }
+  getUserId() {
+    return this.userId;
+  }
+  isAuthenticated() {
+    return this.sessionToken !== null;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+  isOnline() {
+    if (this.offlineQueue) return this.offlineQueue.online;
+    return typeof navigator === "undefined" || navigator.onLine;
+  }
+  getOfflineQueueLength() {
+    return this.offlineQueue?.length || 0;
+  }
+  getRateLimitQueueLength() {
+    return this.rateLimitQueue?.length || 0;
+  }
+  isRateLimited() {
+    return this.rateLimitQueue?.isRateLimited || false;
+  }
+  // --------------------------------------------------------------------------
+  // Core Request Method
+  // --------------------------------------------------------------------------
+  async request(path, init = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const method = (init.method || "GET").toUpperCase();
+    const timeout = init.timeout || this.defaultTimeout;
+    const maxRetries = init.skipRetry ? 0 : init.retries ?? this.maxRetries;
+    const headers = {
+      "x-api-key": this.apiKey,
+      "User-Agent": `ScaleMule-SDK-TypeScript/${SDK_VERSION}`,
+      ...init.headers
+    };
+    if (!init.skipAuth && this.sessionToken) {
+      headers["Authorization"] = `Bearer ${this.sessionToken}`;
+    }
+    let bodyStr;
+    if (init.body !== void 0 && init.body !== null) {
+      bodyStr = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
+      if (!headers["Content-Type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+    if (this.debug) {
+      console.log(`[ScaleMule] ${method} ${path}`);
+    }
+    const idempotencyKey = method === "POST" ? generateIdempotencyKey() : void 0;
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (attempt > 0 && idempotencyKey) {
+        headers["x-idempotency-key"] = idempotencyKey;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      if (init.signal) {
+        if (init.signal.aborted) {
+          clearTimeout(timeoutId);
+          return { data: null, error: { code: "aborted", message: "Request aborted", status: 0 } };
+        }
+        init.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: bodyStr,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (this.rateLimitQueue) {
+          this.rateLimitQueue.updateFromHeaders(response.headers);
+        }
+        let responseData;
+        const contentType = response.headers.get("Content-Type") || "";
+        if (contentType.includes("application/json")) {
+          responseData = await response.json();
+        } else {
+          const text = await response.text();
+          try {
+            responseData = JSON.parse(text);
+          } catch {
+            responseData = { message: text };
+          }
+        }
+        if (!response.ok) {
+          const error = {
+            code: responseData?.error?.code || responseData?.code || statusToErrorCode(response.status),
+            message: responseData?.error?.message || responseData?.message || response.statusText,
+            status: response.status,
+            details: responseData?.error?.details || responseData?.details
+          };
+          if (response.status === 429) {
+            const retryAfter = response.headers.get("Retry-After");
+            if (retryAfter) {
+              error.details = { ...error.details, retryAfter: parseInt(retryAfter, 10) };
+            }
+          }
+          if (attempt < maxRetries && RETRYABLE_STATUS_CODES.has(response.status)) {
+            lastError = error;
+            const delay = getBackoffDelay(attempt, this.backoffMs);
+            if (this.debug) {
+              console.log(`[ScaleMule] Retry ${attempt + 1}/${maxRetries} in ${Math.round(delay)}ms`);
+            }
+            await sleep(delay);
+            continue;
+          }
+          return { data: null, error };
+        }
+        const data = responseData?.data !== void 0 ? responseData.data : responseData;
+        return { data, error: null };
+      } catch (err) {
+        clearTimeout(timeoutId);
+        const isAbort = err instanceof Error && err.name === "AbortError";
+        const error = {
+          code: isAbort ? init.signal?.aborted ? "aborted" : "timeout" : "network_error",
+          message: err instanceof Error ? err.message : "Network request failed",
+          status: 0
+        };
+        if (attempt < maxRetries && !init.signal?.aborted) {
+          lastError = error;
+          const delay = getBackoffDelay(attempt, this.backoffMs);
+          if (this.debug) {
+            console.log(`[ScaleMule] Retry ${attempt + 1}/${maxRetries} in ${Math.round(delay)}ms (${error.code})`);
+          }
+          await sleep(delay);
+          continue;
+        }
+        return { data: null, error };
+      }
+    }
+    return { data: null, error: lastError || { code: "internal_error", message: "Request failed", status: 0 } };
+  }
+  // --------------------------------------------------------------------------
+  // HTTP Verb Shortcuts
+  // --------------------------------------------------------------------------
+  async get(path, options) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  async post(path, body, options) {
+    return this.request(path, { ...options, method: "POST", body });
+  }
+  async put(path, body, options) {
+    return this.request(path, { ...options, method: "PUT", body });
+  }
+  async patch(path, body, options) {
+    return this.request(path, { ...options, method: "PATCH", body });
+  }
+  async del(path, options) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+  // --------------------------------------------------------------------------
+  // File Upload
+  // --------------------------------------------------------------------------
+  /**
+   * Upload a file using multipart/form-data.
+   *
+   * Supports progress tracking via XMLHttpRequest (browser only).
+   * Supports cancellation via AbortController signal.
+   * Retries with exponential backoff on transient failures.
+   */
+  async upload(path, file, additionalFields, options) {
+    const fileName = file.name || "file";
+    const sanitizedName = sanitizeFilename(fileName);
+    const sanitizedFile = sanitizedName !== fileName ? new File([file], sanitizedName, { type: file.type }) : file;
+    const buildFormData = () => {
+      const fd = new FormData();
+      fd.append("file", sanitizedFile);
+      if (additionalFields) {
+        for (const [key, value] of Object.entries(additionalFields)) {
+          fd.append(key, value);
+        }
+      }
+      return fd;
+    };
+    const url = `${this.baseUrl}${path}`;
+    if (this.debug) console.log(`[ScaleMule] UPLOAD ${path}`);
+    if (options?.signal?.aborted) {
+      return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+    }
+    if (options?.onProgress && typeof XMLHttpRequest !== "undefined") {
+      return this.uploadWithXHR(url, buildFormData, options.onProgress, options?.signal);
+    }
+    const maxRetries = options?.retries ?? this.maxRetries;
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const headers = { "x-api-key": this.apiKey };
+      if (this.sessionToken) headers["Authorization"] = `Bearer ${this.sessionToken}`;
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: buildFormData(),
+          signal: options?.signal
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          const error = {
+            code: data?.error?.code || statusToErrorCode(response.status),
+            message: data?.error?.message || data?.message || response.statusText,
+            status: response.status,
+            details: data?.error?.details
+          };
+          if (attempt < maxRetries && RETRYABLE_STATUS_CODES.has(response.status)) {
+            lastError = error;
+            await sleep(getBackoffDelay(attempt, this.backoffMs));
+            continue;
+          }
+          return { data: null, error };
+        }
+        const result = data?.data !== void 0 ? data.data : data;
+        return { data: result, error: null };
+      } catch (err) {
+        if (options?.signal?.aborted) {
+          return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+        }
+        lastError = {
+          code: "upload_error",
+          message: err instanceof Error ? err.message : "Upload failed",
+          status: 0
+        };
+        if (attempt < maxRetries) {
+          await sleep(getBackoffDelay(attempt, this.backoffMs));
+          continue;
+        }
+      }
+    }
+    return { data: null, error: lastError || { code: "upload_error", message: "Upload failed", status: 0 } };
+  }
+  /**
+   * Single upload with XMLHttpRequest for progress tracking.
+   * Supports abort via AbortSignal.
+   */
+  uploadWithXHR(url, buildFormData, onProgress, signal, maxRetries = this.maxRetries) {
+    return new Promise(async (resolve) => {
+      let lastError = null;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const result = await new Promise((res) => {
+          const xhr = new XMLHttpRequest();
+          if (signal) {
+            if (signal.aborted) {
+              res({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
+              return;
+            }
+            signal.addEventListener("abort", () => xhr.abort(), { once: true });
+          }
+          xhr.upload.addEventListener("progress", (event) => {
+            if (event.lengthComputable) {
+              onProgress(Math.round(event.loaded / event.total * 100));
+            }
+          });
+          xhr.addEventListener("load", () => {
+            try {
+              const data = JSON.parse(xhr.responseText);
+              if (xhr.status >= 200 && xhr.status < 300) {
+                const result2 = data?.data !== void 0 ? data.data : data;
+                res({ data: result2, error: null });
+              } else {
+                res({
+                  data: null,
+                  error: {
+                    code: data?.error?.code || statusToErrorCode(xhr.status),
+                    message: data?.error?.message || data?.message || "Upload failed",
+                    status: xhr.status,
+                    details: data?.error?.details
+                  }
+                });
+              }
+            } catch {
+              res({ data: null, error: { code: "internal_error", message: "Failed to parse response", status: 0 } });
+            }
+          });
+          xhr.addEventListener("error", () => {
+            res({ data: null, error: { code: "upload_error", message: "Upload failed", status: 0 } });
+          });
+          xhr.addEventListener("abort", () => {
+            res({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
+          });
+          xhr.open("POST", url);
+          xhr.setRequestHeader("x-api-key", this.apiKey);
+          if (this.sessionToken) {
+            xhr.setRequestHeader("Authorization", `Bearer ${this.sessionToken}`);
+          }
+          xhr.send(buildFormData());
+        });
+        if (result.error === null) {
+          resolve(result);
+          return;
+        }
+        const isRetryable = result.error.code === "upload_error" || result.error.code === "network_error" || RETRYABLE_STATUS_CODES.has(result.error.status);
+        if (result.error.code === "aborted") {
+          resolve(result);
+          return;
+        }
+        if (attempt < maxRetries && isRetryable) {
+          lastError = result.error;
+          onProgress(0);
+          await sleep(getBackoffDelay(attempt, this.backoffMs));
+          continue;
+        }
+        resolve(result);
+        return;
+      }
+      resolve({
+        data: null,
+        error: lastError || { code: "upload_error", message: "Upload failed", status: 0 }
+      });
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Offline Queue Sync
+  // --------------------------------------------------------------------------
+  async syncOfflineQueue() {
+    if (!this.offlineQueue) return;
+    const items = this.offlineQueue.getAll();
+    if (this.debug && items.length > 0) {
+      console.log(`[ScaleMule] Syncing ${items.length} offline requests`);
+    }
+    for (const item of items) {
+      try {
+        await this.request(item.path, {
+          method: item.method,
+          body: item.body ? JSON.parse(item.body) : void 0,
+          skipRetry: true
+        });
+        await this.offlineQueue.remove(item.id);
+      } catch {
+        break;
+      }
+    }
+  }
+};
+
+// src/service.ts
+var ServiceModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // Client context → headers resolution
+  // --------------------------------------------------------------------------
+  /**
+   * Merge `clientContext` from RequestOptions into `headers`.
+   * Explicit headers take precedence over context-derived ones.
+   */
+  resolveOptions(options) {
+    if (!options?.clientContext) return options;
+    const contextHeaders = buildClientContextHeaders(options.clientContext);
+    const { clientContext: _, ...rest } = options;
+    return { ...rest, headers: { ...contextHeaders, ...rest.headers } };
+  }
+  // --------------------------------------------------------------------------
+  // HTTP verb shortcuts (path relative to basePath)
+  // --------------------------------------------------------------------------
+  _get(path, options) {
+    return this.client.get(`${this.basePath}${path}`, this.resolveOptions(options));
+  }
+  post(path, body, options) {
+    return this.client.post(`${this.basePath}${path}`, body, this.resolveOptions(options));
+  }
+  put(path, body, options) {
+    return this.client.put(`${this.basePath}${path}`, body, this.resolveOptions(options));
+  }
+  patch(path, body, options) {
+    return this.client.patch(`${this.basePath}${path}`, body, this.resolveOptions(options));
+  }
+  del(path, options) {
+    return this.client.del(`${this.basePath}${path}`, this.resolveOptions(options));
+  }
+  // --------------------------------------------------------------------------
+  // Paginated list
+  // --------------------------------------------------------------------------
+  /**
+   * Fetch a paginated list from the backend.
+   *
+   * Normalizes varying backend pagination shapes into the standard
+   * PaginatedResponse<T> envelope. Supports backends that return:
+   *   - { data: T[], metadata: { total, ... } }           (preferred)
+   *   - { items: T[], total, page, per_page }              (legacy)
+   *   - T[]                                                (bare array)
+   *
+   * Extra params beyond page/perPage are forwarded as query string parameters.
+   */
+  async _list(path, params, options) {
+    const qs = buildQueryString(params);
+    const fullPath = qs ? `${this.basePath}${path}?${qs}` : `${this.basePath}${path}`;
+    const response = await this.client.get(fullPath, this.resolveOptions(options));
+    if (response.error) {
+      return {
+        data: [],
+        metadata: { total: 0, totalPages: 0, page: asNum(params?.page) ?? 1, perPage: asNum(params?.perPage) ?? 20 },
+        error: response.error
+      };
+    }
+    return normalizePaginatedResponse(response.data, params);
+  }
+  // --------------------------------------------------------------------------
+  // File upload (delegates to client.upload)
+  // --------------------------------------------------------------------------
+  _upload(path, file, additionalFields, options) {
+    return this.client.upload(`${this.basePath}${path}`, file, additionalFields, this.resolveOptions(options));
+  }
+  // --------------------------------------------------------------------------
+  // Query string helper (available to subclasses)
+  // --------------------------------------------------------------------------
+  /**
+   * Append query parameters to a relative path.
+   * Use with verb methods: `this.get(this.withQuery('/items', { status: 'active' }))`
+   * Does NOT add basePath — the verb methods handle that.
+   */
+  withQuery(path, params) {
+    const qs = buildQueryString(params);
+    return qs ? `${path}?${qs}` : path;
+  }
+};
+function buildQueryString(params) {
+  if (!params) return "";
+  const pairs = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return pairs.join("&");
+}
+function normalizePaginatedResponse(raw, params) {
+  if (raw === null || raw === void 0) {
+    return {
+      data: [],
+      metadata: { total: 0, totalPages: 0, page: 1, perPage: 20 },
+      error: null
+    };
+  }
+  if (Array.isArray(raw)) {
+    return {
+      data: raw,
+      metadata: {
+        total: raw.length,
+        totalPages: 1,
+        page: 1,
+        perPage: raw.length
+      },
+      error: null
+    };
+  }
+  const obj = raw;
+  const dataArray = obj.data ?? obj.items ?? [];
+  const metadata = {
+    total: asNumber(obj.metadata, "total") ?? asNumber(obj, "total") ?? dataArray.length,
+    totalPages: asNumber(obj.metadata, "totalPages") ?? asNumber(obj.metadata, "total_pages") ?? asNumber(obj, "total_pages") ?? asNumber(obj, "totalPages") ?? 0,
+    page: asNumber(obj.metadata, "page") ?? asNumber(obj, "page") ?? asNum(params?.page) ?? 1,
+    perPage: asNumber(obj.metadata, "perPage") ?? asNumber(obj.metadata, "per_page") ?? asNumber(obj, "per_page") ?? asNumber(obj, "perPage") ?? asNum(params?.perPage) ?? 20
+  };
+  if (metadata.totalPages === 0 && metadata.total > 0 && metadata.perPage > 0) {
+    metadata.totalPages = Math.ceil(metadata.total / metadata.perPage);
+  }
+  const nextCursor = asString(obj.metadata, "nextCursor") ?? asString(obj.metadata, "next_cursor") ?? asString(obj, "next_cursor") ?? asString(obj, "nextCursor");
+  if (nextCursor) {
+    metadata.nextCursor = nextCursor;
+  }
+  return { data: dataArray, metadata, error: null };
+}
+function asNumber(parent, key) {
+  if (parent === null || parent === void 0 || typeof parent !== "object") return void 0;
+  const value = parent[key];
+  return typeof value === "number" ? value : void 0;
+}
+function asNum(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function asString(parent, key) {
+  if (parent === null || parent === void 0 || typeof parent !== "object") return void 0;
+  const value = parent[key];
+  return typeof value === "string" ? value : void 0;
+}
+
+// src/utils/phone.ts
+var import_phone = require("@scalemule/ui/phone");
+
+// src/services/auth.ts
+var AuthMfaApi = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/auth/mfa";
+  }
+  async getStatus() {
+    return this._get("/status");
+  }
+  async setupTotp() {
+    return this.post("/totp/setup");
+  }
+  async verifySetup(data) {
+    return this.post("/totp/verify-setup", data);
+  }
+  async enableSms() {
+    return this.post("/sms/enable");
+  }
+  async enableEmail() {
+    return this.post("/email/enable");
+  }
+  async disable(data) {
+    return this.post("/disable", data);
+  }
+  async regenerateBackupCodes() {
+    return this.post("/backup-codes/regenerate");
+  }
+  async sendCode(data) {
+    return this.post("/send-code", data);
+  }
+  async verify(data) {
+    return this.post("/verify", data);
+  }
+};
+var AuthSessionsApi = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/auth/sessions";
+  }
+  async list() {
+    return this._get("");
+  }
+  async revoke(sessionId) {
+    return this.del(`/${sessionId}`);
+  }
+  async revokeAll() {
+    return this.del("/others");
+  }
+};
+var AuthDevicesApi = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/auth/devices";
+  }
+  async list() {
+    return this._get("");
+  }
+  async trust(deviceId) {
+    return this.post(`/${deviceId}/trust`);
+  }
+  async block(deviceId) {
+    return this.post(`/${deviceId}/block`);
+  }
+  async delete(deviceId) {
+    return this.del(`/${deviceId}`);
+  }
+};
+var AuthLoginHistoryApi = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/auth";
+  }
+  async list(params) {
+    return this._get(this.withQuery("/login-history", params));
+  }
+  async getSummary() {
+    return this._get("/login-activity");
+  }
+};
+var AuthService = class extends ServiceModule {
+  constructor(client) {
+    super(client);
+    this.basePath = "/v1/auth";
+    this.mfa = new AuthMfaApi(client);
+    this.sessions = new AuthSessionsApi(client);
+    this.devices = new AuthDevicesApi(client);
+    this.loginHistory = new AuthLoginHistoryApi(client);
+  }
+  sanitizePhoneField(value) {
+    if (typeof value !== "string") return value;
+    const normalized = (0, import_phone.normalizePhoneNumber)(value);
+    return normalized || void 0;
+  }
+  // --------------------------------------------------------------------------
+  // Core Auth
+  // --------------------------------------------------------------------------
+  async register(data, options) {
+    const payload = {
+      ...data,
+      phone: this.sanitizePhoneField(data.phone)
+    };
+    return this.post("/register", payload, options);
+  }
+  async login(data, options) {
+    return this.post("/login", data, options);
+  }
+  async logout(options) {
+    return this.post("/logout", void 0, options);
+  }
+  async me(options) {
+    return this._get("/me", options);
+  }
+  /** Refresh the session. Alias: refreshToken() */
+  async refreshSession(data, options) {
+    return this.post("/refresh", data ?? {}, options);
+  }
+  /** @deprecated Use refreshSession() */
+  async refreshToken(data) {
+    return this.refreshSession(data);
+  }
+  // --------------------------------------------------------------------------
+  // Passwordless Auth
+  // --------------------------------------------------------------------------
+  /**
+   * Send a one-time password for passwordless sign-in.
+   * @experimental Endpoint availability depends on backend deployment.
+   */
+  async signInWithOtp(data, options) {
+    const payload = {
+      ...data,
+      phone: this.sanitizePhoneField(data.phone)
+    };
+    return this.post("/otp/send", payload, options);
+  }
+  /**
+   * Verify OTP code and create a session.
+   * @experimental Endpoint availability depends on backend deployment.
+   */
+  async verifyOtp(data, options) {
+    const payload = {
+      ...data,
+      phone: this.sanitizePhoneField(data.phone)
+    };
+    return this.post("/otp/verify", payload, options);
+  }
+  /**
+   * Send a magic link for passwordless sign-in.
+   * @experimental Endpoint availability depends on backend deployment.
+   */
+  async signInWithMagicLink(data, options) {
+    return this.post("/magic-link/send", data, options);
+  }
+  /**
+   * Verify a magic link token and create a session.
+   * @experimental Endpoint availability depends on backend deployment.
+   */
+  async verifyMagicLink(data, options) {
+    return this.post("/magic-link/verify", data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Phone OTP (existing backend endpoints)
+  // --------------------------------------------------------------------------
+  async sendPhoneOtp(data, options) {
+    const payload = {
+      ...data,
+      phone: this.sanitizePhoneField(data.phone) ?? ""
+    };
+    return this.post("/phone/send-otp", payload, options);
+  }
+  async verifyPhoneOtp(data, options) {
+    const payload = {
+      ...data,
+      phone: this.sanitizePhoneField(data.phone) ?? ""
+    };
+    return this.post("/phone/verify-otp", payload, options);
+  }
+  async resendPhoneOtp(data, options) {
+    const payload = {
+      ...data,
+      phone: this.sanitizePhoneField(data.phone) ?? ""
+    };
+    return this.post("/phone/resend-otp", payload, options);
+  }
+  /** Login with phone OTP (sends + verifies in one flow) */
+  async loginWithPhone(data, options) {
+    const payload = {
+      ...data,
+      phone: this.sanitizePhoneField(data.phone) ?? "",
+      purpose: "login"
+    };
+    return this.post("/phone/verify-otp", payload, options);
+  }
+  // --------------------------------------------------------------------------
+  // Password Management
+  // --------------------------------------------------------------------------
+  async forgotPassword(data, options) {
+    return this.post("/forgot-password", data, options);
+  }
+  async resetPassword(data, options) {
+    return this.post("/reset-password", data, options);
+  }
+  async changePassword(data, options) {
+    return this.post("/password/change", data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Email & Phone Management
+  // --------------------------------------------------------------------------
+  async verifyEmail(data, options) {
+    return this.post("/verify-email", data, options);
+  }
+  /** Resend email verification. Alias: resendEmailVerification() */
+  async resendVerification(data, options) {
+    return this.post("/resend-verification", data ?? {}, options);
+  }
+  /** @deprecated Use resendVerification() */
+  async resendEmailVerification(data) {
+    return this.resendVerification(data);
+  }
+  async changeEmail(data, options) {
+    return this.post("/email/change", data, options);
+  }
+  async changePhone(data, options) {
+    const payload = {
+      ...data,
+      new_phone: this.sanitizePhoneField(data.new_phone) ?? ""
+    };
+    return this.post("/phone/change", payload, options);
+  }
+  // --------------------------------------------------------------------------
+  // Account
+  // --------------------------------------------------------------------------
+  async deleteAccount(options) {
+    return this.del("/me", options);
+  }
+  async exportData(options) {
+    return this._get("/me/export", options);
+  }
+  // --------------------------------------------------------------------------
+  // OAuth
+  // --------------------------------------------------------------------------
+  async getOAuthUrl(provider, redirectUri, options) {
+    return this._get(this.withQuery(`/oauth/${provider}/authorize`, { redirect_uri: redirectUri }), options);
+  }
+  async handleOAuthCallback(data, options) {
+    const { provider, ...rest } = data;
+    return this._get(this.withQuery(`/oauth/${provider}/callback`, rest), options);
+  }
+  async listOAuthProviders(options) {
+    return this._get("/oauth/providers", options);
+  }
+  async unlinkOAuthProvider(provider, options) {
+    return this.del(`/oauth/providers/${provider}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Token Management
+  // --------------------------------------------------------------------------
+  async refreshAccessToken(data, options) {
+    return this.post("/token/refresh", data ?? {}, options);
+  }
+  async revokeRefreshToken(data, options) {
+    return this.post("/token/revoke", data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Flat methods for backward compatibility (delegate to sub-APIs)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use auth.sessions.list() */
+  async listSessions() {
+    return this.sessions.list();
+  }
+  /** @deprecated Use auth.sessions.revoke() */
+  async revokeSession(sessionId) {
+    return this.sessions.revoke(sessionId);
+  }
+  /** @deprecated Use auth.sessions.revokeAll() */
+  async revokeOtherSessions() {
+    return this.sessions.revokeAll();
+  }
+  /** @deprecated Use auth.devices.list() */
+  async listDevices() {
+    return this.devices.list();
+  }
+  /** @deprecated Use auth.devices.trust() */
+  async trustDevice(deviceId) {
+    return this.devices.trust(deviceId);
+  }
+  /** @deprecated Use auth.devices.block() */
+  async blockDevice(deviceId) {
+    return this.devices.block(deviceId);
+  }
+  /** @deprecated Use auth.devices.delete() */
+  async deleteDevice(deviceId) {
+    return this.devices.delete(deviceId);
+  }
+  /** @deprecated Use auth.loginHistory.list() */
+  async getLoginHistory(params) {
+    return this.loginHistory.list(params);
+  }
+  /** @deprecated Use auth.loginHistory.getSummary() */
+  async getLoginActivitySummary() {
+    return this.loginHistory.getSummary();
+  }
+  /** @deprecated Use auth.mfa.getStatus() */
+  async getMfaStatus() {
+    return this.mfa.getStatus();
+  }
+  /** @deprecated Use auth.mfa.setupTotp() */
+  async setupTotp() {
+    return this.mfa.setupTotp();
+  }
+  /** @deprecated Use auth.mfa.verifySetup() */
+  async verifyTotpSetup(data) {
+    return this.mfa.verifySetup(data);
+  }
+  /** @deprecated Use auth.mfa.enableSms() */
+  async enableSmsMfa() {
+    return this.mfa.enableSms();
+  }
+  /** @deprecated Use auth.mfa.enableEmail() */
+  async enableEmailMfa() {
+    return this.mfa.enableEmail();
+  }
+  /** @deprecated Use auth.mfa.disable() */
+  async disableMfa(data) {
+    return this.mfa.disable(data);
+  }
+  /** @deprecated Use auth.mfa.regenerateBackupCodes() */
+  async regenerateBackupCodes() {
+    return this.mfa.regenerateBackupCodes();
+  }
+  /** @deprecated Use auth.mfa.sendCode() */
+  async sendMfaCode(data) {
+    return this.mfa.sendCode(data);
+  }
+  /** @deprecated Use auth.mfa.verify() */
+  async verifyMfa(data) {
+    return this.mfa.verify(data);
+  }
+};
+
+// src/services/logger.ts
+var BATCH_MAX_SIZE = 100;
+var LoggerService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/logger";
+  }
+  /**
+   * Write a single log entry.
+   * Accepts both new schema (LogInput) and legacy shape ({ level, message }) for backward compatibility.
+   */
+  async log(data, options) {
+    const body = this.normalizeLogInput(data);
+    return this.post("/logs", body, options);
+  }
+  /**
+   * Write log entries in batch.
+   * Auto-chunks into groups of 100 (backend hard limit) and sends sequentially.
+   * Returns total ingested count across all chunks.
+   */
+  async logBatch(logs, options) {
+    if (logs.length === 0) {
+      return { data: { ingested: 0 }, error: null };
+    }
+    let totalIngested = 0;
+    for (let i = 0; i < logs.length; i += BATCH_MAX_SIZE) {
+      const chunk = logs.slice(i, i + BATCH_MAX_SIZE);
+      const result = await this.post("/logs/batch", { logs: chunk }, options);
+      if (result.error) {
+        return {
+          data: { ingested: totalIngested },
+          error: result.error
+        };
+      }
+      totalIngested += result.data?.ingested ?? chunk.length;
+    }
+    return { data: { ingested: totalIngested }, error: null };
+  }
+  /**
+   * Query logs with filters. Returns paginated response.
+   */
+  async queryLogs(filters, requestOptions) {
+    return this._get(this.withQuery("/logs", filters), requestOptions);
+  }
+  // Convenience methods
+  async debug(service, message, meta, options) {
+    return this.log({ service, severity: "debug", message, metadata: meta }, options);
+  }
+  async info(service, message, meta, options) {
+    return this.log({ service, severity: "info", message, metadata: meta }, options);
+  }
+  async warn(service, message, meta, options) {
+    return this.log({ service, severity: "warn", message, metadata: meta }, options);
+  }
+  async error(service, message, meta, options) {
+    return this.log({ service, severity: "error", message, metadata: meta }, options);
+  }
+  // --------------------------------------------------------------------------
+  // Internal
+  // --------------------------------------------------------------------------
+  /** Normalize legacy { level, message } to { severity, service, message } */
+  normalizeLogInput(data) {
+    if ("severity" in data && "service" in data) {
+      return data;
+    }
+    const legacy = data;
+    return {
+      service: "sdk",
+      severity: legacy.level || "info",
+      message: legacy.message,
+      metadata: legacy.metadata
+    };
+  }
+};
+
+// src/services/upload-telemetry.ts
+var EVENT_SEVERITY = {
+  "upload.failed": "error",
+  "upload.stalled": "error",
+  "upload.multipart.aborted": "error",
+  "upload.retried": "warn",
+  "upload.aborted": "warn",
+  "upload.multipart.part_failed": "warn",
+  "upload.multipart.url_refreshed": "warn",
+  "upload.compression.skipped": "warn",
+  "upload.started": "info",
+  "upload.completed": "info",
+  "upload.resumed": "info",
+  "upload.multipart.started": "info",
+  "upload.multipart.completed": "info",
+  "upload.compression.completed": "info",
+  "upload.progress": "debug",
+  "upload.multipart.part_completed": "debug",
+  "upload.compression.started": "debug"
+};
+var UploadTelemetry = class {
+  constructor(client, config) {
+    this.buffer = [];
+    this.debugLogBuffer = [];
+    this.flushTimer = null;
+    this.flushing = false;
+    this.client = client;
+    this.logger = new LoggerService(client);
+    this.config = {
+      enabled: config?.enabled ?? true,
+      flushIntervalMs: config?.flushIntervalMs ?? 2e3,
+      maxBufferSize: config?.maxBufferSize ?? 50
+    };
+    if (this.config.enabled) {
+      this.startFlushTimer();
+    }
+  }
+  /** Emit a telemetry event. Never throws. */
+  emit(sessionId, event, metadata = {}) {
+    if (!this.config.enabled) return;
+    const payload = {
+      upload_session_id: sessionId,
+      event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata
+    };
+    const severity = EVENT_SEVERITY[event] || "info";
+    if (severity !== "debug") {
+      this.sendToLogger(payload, severity);
+    } else {
+      this.debugLogBuffer.push({
+        service: "storage.upload",
+        severity,
+        message: `Upload ${event}: session=${sessionId}`,
+        metadata: { upload_session_id: sessionId, event, ...metadata },
+        trace_id: sessionId
+      });
+    }
+    this.buffer.push(payload);
+    if (this.buffer.length >= this.config.maxBufferSize) {
+      this.flush();
+    }
+  }
+  /** Flush buffered events immediately. Never throws. */
+  async flush() {
+    if (!this.config.enabled || this.buffer.length === 0 && this.debugLogBuffer.length === 0 || this.flushing) return;
+    this.flushing = true;
+    const batch = this.buffer.splice(0);
+    const debugLogs = this.debugLogBuffer.splice(0);
+    try {
+      if (batch.length > 0) {
+        const events = batch.map((p) => ({
+          event: p.event,
+          properties: {
+            upload_session_id: p.upload_session_id,
+            ...p.metadata
+          },
+          timestamp: p.timestamp
+        }));
+        await this.client.post("/v1/analytics/v2/events/batch", { events }).catch(() => {
+        });
+      }
+      if (debugLogs.length > 0) {
+        await this.logger.logBatch(debugLogs).catch(() => {
+        });
+      }
+    } catch {
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Stop the flush timer and drain remaining events. */
+  async destroy() {
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  startFlushTimer() {
+    if (typeof setInterval !== "undefined") {
+      this.flushTimer = setInterval(() => {
+        this.flush();
+      }, this.config.flushIntervalMs);
+      if (this.flushTimer && typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
+        this.flushTimer.unref();
+      }
+    }
+  }
+  /** Send a log entry to the logger service (fire-and-forget) */
+  sendToLogger(payload, severity) {
+    this.logger.log({
+      service: "storage.upload",
+      severity,
+      message: `Upload ${payload.event}: session=${payload.upload_session_id}`,
+      metadata: {
+        upload_session_id: payload.upload_session_id,
+        event: payload.event,
+        ...payload.metadata
+      },
+      trace_id: payload.upload_session_id
+    }).catch(() => {
+    });
+  }
+};
+function generateUploadSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 10);
+  return `us_${timestamp}_${random}`;
+}
+
+// src/services/storage.ts
+var RETRY_DELAYS = [0, 1e3, 3e3];
+var RETRYABLE_STATUS_CODES2 = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var NON_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([400, 403, 404, 413]);
+var DEFAULT_STALL_TIMEOUT_MS = 45e3;
+var SLOW_NETWORK_STALL_TIMEOUT_MS = 9e4;
+var MULTIPART_THRESHOLD = 8 * 1024 * 1024;
+var MULTIPART_THRESHOLD_SLOW = 4 * 1024 * 1024;
+var StorageService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/storage";
+    this.telemetry = null;
+  }
+  // --------------------------------------------------------------------------
+  // Upload (unified: direct PUT or multipart, transparent to caller)
+  // --------------------------------------------------------------------------
+  /**
+   * Upload a file using the optimal strategy.
+   *
+   * Small files (< 8MB): 3-step presigned URL flow with retry + stall guard.
+   * Large files (>= 8MB): Multipart with windowed presigns, resumable.
+   *
+   * @returns The completed file record with id, url, etc.
+   */
+  async upload(file, options) {
+    if (options?.signal?.aborted) {
+      return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+    }
+    const sessionId = generateUploadSessionId();
+    const telemetryEnabled = options?.telemetry !== false;
+    const telemetry = telemetryEnabled ? this.getOrCreateTelemetry() : null;
+    const startTime = Date.now();
+    telemetry?.emit(sessionId, "upload.started", {
+      size_bytes: file.size,
+      content_type: file.type,
+      strategy: this.shouldUseMultipart(file, options) ? "multipart" : "direct",
+      network_type: getNetworkEffectiveType2()
+    });
+    try {
+      let uploadFile = file;
+      if (!options?.skipCompression && typeof window !== "undefined") {
+        const compressed = await this.maybeCompress(file, options?.compression, sessionId, telemetry);
+        if (compressed) uploadFile = compressed;
+      }
+      if (this.shouldUseMultipart(uploadFile, options)) {
+        return await this.uploadMultipart(uploadFile, options, sessionId, telemetry);
+      }
+      return await this.uploadDirect(uploadFile, options, sessionId, telemetry);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Upload failed";
+      telemetry?.emit(sessionId, "upload.failed", { error: message, duration_ms: Date.now() - startTime });
+      return { data: null, error: { code: "upload_error", message, status: 0 } };
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Direct Upload (3-step with retry + stall)
+  // --------------------------------------------------------------------------
+  async uploadDirect(file, options, sessionId, telemetry) {
+    const directStart = Date.now();
+    const requestOpts = this.withSessionHeader(sessionId, options);
+    const filename = options?.filename || file.name || "file";
+    const initResult = await this.post("/signed-url/upload", {
+      filename,
+      content_type: file.type || "application/octet-stream",
+      size_bytes: file.size,
+      is_public: options?.isPublic ?? true,
+      metadata: options?.metadata
+    }, requestOpts);
+    if (initResult.error) {
+      telemetry?.emit(sessionId, "upload.failed", { step: "presign", error: initResult.error.message });
+      return { data: null, error: initResult.error };
+    }
+    const { file_id, upload_url, completion_token } = initResult.data;
+    const uploadResult = await this.uploadToPresignedUrlWithRetry(
+      upload_url,
+      file,
+      options?.onProgress,
+      options?.signal,
+      sessionId,
+      telemetry
+    );
+    if (uploadResult.error) {
+      if (uploadResult.error.code === "upload_stalled") {
+        telemetry?.emit(sessionId, "upload.stalled", { step: "s3_put", file_id });
+      }
+      telemetry?.emit(sessionId, "upload.failed", {
+        step: "s3_put",
+        error: uploadResult.error.message,
+        file_id,
+        reason: uploadResult.error.code
+      });
+      return { data: null, error: uploadResult.error };
+    }
+    const completeResult = await this.post("/signed-url/complete", {
+      file_id,
+      completion_token
+    }, requestOpts);
+    if (completeResult.error) {
+      telemetry?.emit(sessionId, "upload.failed", { step: "complete", error: completeResult.error.message, file_id, duration_ms: Date.now() - directStart });
+    } else {
+      telemetry?.emit(sessionId, "upload.completed", { file_id, size_bytes: file.size, duration_ms: Date.now() - directStart });
+    }
+    return completeResult;
+  }
+  // --------------------------------------------------------------------------
+  // Multipart Upload
+  // --------------------------------------------------------------------------
+  async uploadMultipart(file, options, sessionId, telemetry) {
+    const multipartStart = Date.now();
+    const requestOpts = this.withSessionHeader(sessionId, options);
+    const filename = options?.filename || file.name || "file";
+    telemetry?.emit(sessionId, "upload.multipart.started", { size_bytes: file.size });
+    let resumeStore = null;
+    let resumeData = null;
+    if (options?.resume !== "off" && typeof window !== "undefined") {
+      try {
+        const { UploadResumeStore: UploadResumeStore2 } = await Promise.resolve().then(() => (init_upload_resume(), upload_resume_exports));
+        resumeStore = new UploadResumeStore2();
+        await resumeStore.open();
+        const resumeKey = await UploadResumeStore2.generateResumeKey(
+          this.client.getApiKey?.() || "",
+          this.client.getUserId?.() || "",
+          filename,
+          file.size,
+          file.lastModified
+        );
+        resumeData = await resumeStore.get(resumeKey);
+        if (resumeData) {
+          telemetry?.emit(sessionId, "upload.resumed", {
+            original_session_id: resumeData.upload_session_id,
+            completed_parts: resumeData.completed_parts.length,
+            total_parts: resumeData.total_parts
+          });
+        }
+      } catch (err) {
+        telemetry?.emit(sessionId, "upload.retried", { step: "resume_load", error: err instanceof Error ? err.message : "Resume store unavailable" });
+        resumeStore = null;
+        resumeData = null;
+      }
+    }
+    let startData;
+    let completionToken;
+    let completedParts = /* @__PURE__ */ new Map();
+    if (resumeData) {
+      startData = {
+        upload_session_id: resumeData.upload_session_id,
+        file_id: resumeData.file_id,
+        completion_token: "",
+        // will request part URLs separately
+        part_size_bytes: resumeData.part_size_bytes || this.defaultChunkSize(file.size),
+        total_parts: resumeData.total_parts,
+        part_urls: [],
+        expires_at: ""
+      };
+      completionToken = resumeData.completion_token;
+      for (const part of resumeData.completed_parts) {
+        completedParts.set(part.part_number, part.etag);
+      }
+    } else {
+      let clientUploadKey;
+      try {
+        const { UploadResumeStore: UploadResumeStore2 } = await Promise.resolve().then(() => (init_upload_resume(), upload_resume_exports));
+        clientUploadKey = await UploadResumeStore2.generateResumeKey(
+          this.client.getApiKey?.() || "",
+          this.client.getUserId?.() || "",
+          filename,
+          file.size,
+          file.lastModified
+        );
+      } catch {
+      }
+      const startResult = await this.post("/signed-url/multipart/start", {
+        filename,
+        content_type: file.type || "application/octet-stream",
+        size_bytes: file.size,
+        is_public: options?.isPublic ?? true,
+        metadata: options?.metadata,
+        chunk_size: options?.chunkSize,
+        ...clientUploadKey ? { client_upload_key: clientUploadKey } : {}
+      }, requestOpts);
+      if (startResult.error) {
+        telemetry?.emit(sessionId, "upload.multipart.aborted", { error: startResult.error.message });
+        return { data: null, error: startResult.error };
+      }
+      startData = startResult.data;
+      completionToken = startData.completion_token;
+    }
+    const { upload_session_id, file_id, part_size_bytes, total_parts } = startData;
+    if (resumeStore && !resumeData) {
+      try {
+        const { UploadResumeStore: UploadResumeStore2 } = await Promise.resolve().then(() => (init_upload_resume(), upload_resume_exports));
+        const resumeKey = await UploadResumeStore2.generateResumeKey(
+          this.client.getApiKey?.() || "",
+          this.client.getUserId?.() || "",
+          filename,
+          file.size,
+          file.lastModified
+        );
+        await resumeStore.save(resumeKey, {
+          upload_session_id,
+          file_id,
+          completion_token: completionToken,
+          total_parts,
+          part_size_bytes,
+          completed_parts: [],
+          created_at: Date.now()
+        });
+      } catch (err) {
+        telemetry?.emit(sessionId, "upload.retried", { step: "resume_save", error: err instanceof Error ? err.message : "Resume save failed" });
+      }
+    }
+    const maxConcurrency = options?.maxConcurrency || this.defaultConcurrency();
+    let availableUrls = /* @__PURE__ */ new Map();
+    if (startData.part_urls.length > 0) {
+      for (const pu of startData.part_urls) {
+        availableUrls.set(pu.part_number, pu);
+      }
+    }
+    const pendingParts = [];
+    for (let i = 1; i <= total_parts; i++) {
+      if (!completedParts.has(i)) {
+        pendingParts.push(i);
+      }
+    }
+    let uploadedCount = completedParts.size;
+    let lastProgressMilestone = 0;
+    const reportProgress = () => {
+      const percent = Math.round(uploadedCount / total_parts * 100);
+      if (options?.onProgress) {
+        options.onProgress(percent);
+      }
+      const milestone = Math.floor(percent / 25) * 25;
+      if (milestone > lastProgressMilestone && milestone < 100) {
+        telemetry?.emit(sessionId, "upload.progress", { percent: milestone, uploaded_parts: uploadedCount, total_parts });
+        lastProgressMilestone = milestone;
+      }
+    };
+    reportProgress();
+    let partIndex = 0;
+    while (partIndex < pendingParts.length) {
+      if (options?.signal?.aborted) {
+        await this.abortMultipart(upload_session_id, completionToken, requestOpts);
+        telemetry?.emit(sessionId, "upload.aborted", { file_id });
+        return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+      }
+      const remainingUrlCount = pendingParts.slice(partIndex).filter((p) => availableUrls.has(p)).length;
+      if (remainingUrlCount <= 4) {
+        const neededParts = pendingParts.slice(partIndex, partIndex + 16).filter((p) => !availableUrls.has(p));
+        if (neededParts.length > 0) {
+          const urlResult = await this.post(
+            "/signed-url/multipart/part-urls",
+            { upload_session_id, part_numbers: neededParts, completion_token: completionToken },
+            requestOpts
+          );
+          if (urlResult.data) {
+            for (const pu of urlResult.data.part_urls) {
+              availableUrls.set(pu.part_number, pu);
+            }
+          }
+        }
+      }
+      const batch = pendingParts.slice(partIndex, partIndex + maxConcurrency);
+      const batchPromises = batch.map(async (partNum) => {
+        const partUrl = availableUrls.get(partNum);
+        if (!partUrl) {
+          const urlResult = await this.post(
+            "/signed-url/multipart/part-urls",
+            { upload_session_id, part_numbers: [partNum], completion_token: completionToken },
+            requestOpts
+          );
+          if (!urlResult.data?.part_urls?.[0]) {
+            return { partNum, error: "Failed to get part URL" };
+          }
+          availableUrls.set(partNum, urlResult.data.part_urls[0]);
+        }
+        const url = availableUrls.get(partNum).url;
+        const start = (partNum - 1) * part_size_bytes;
+        const end = Math.min(start + part_size_bytes, file.size);
+        const partBlob = file.slice(start, end);
+        const result = await this.uploadPartWithRetry(url, partBlob, options?.signal, partNum, sessionId, telemetry);
+        if (result.error) {
+          if (result.code === "upload_stalled") {
+            telemetry?.emit(sessionId, "upload.stalled", { step: "multipart_part", part_number: partNum });
+          }
+          telemetry?.emit(sessionId, "upload.multipart.part_failed", {
+            part_number: partNum,
+            error: result.error,
+            code: result.code
+          });
+          if (result.status === 403) {
+            telemetry?.emit(sessionId, "upload.multipart.url_refreshed", { part_number: partNum });
+            const refreshResult = await this.post(
+              "/signed-url/multipart/part-urls",
+              { upload_session_id, part_numbers: [partNum], completion_token: completionToken },
+              requestOpts
+            );
+            if (refreshResult.data?.part_urls?.[0]) {
+              availableUrls.set(partNum, refreshResult.data.part_urls[0]);
+              const retryResult = await this.uploadPartWithRetry(
+                refreshResult.data.part_urls[0].url,
+                partBlob,
+                options?.signal,
+                partNum,
+                sessionId,
+                telemetry
+              );
+              if (retryResult.etag) {
+                return { partNum, etag: retryResult.etag };
+              }
+            }
+          }
+          return { partNum, error: result.error };
+        }
+        return { partNum, etag: result.etag };
+      });
+      const results = await Promise.all(batchPromises);
+      for (const result of results) {
+        if (result.etag) {
+          completedParts.set(result.partNum, result.etag);
+          uploadedCount++;
+          telemetry?.emit(sessionId, "upload.multipart.part_completed", { part_number: result.partNum });
+          if (resumeStore) {
+            try {
+              const { UploadResumeStore: UploadResumeStore2 } = await Promise.resolve().then(() => (init_upload_resume(), upload_resume_exports));
+              const resumeKey = await UploadResumeStore2.generateResumeKey(
+                this.client.getApiKey?.() || "",
+                this.client.getUserId?.() || "",
+                filename,
+                file.size,
+                file.lastModified
+              );
+              await resumeStore.updatePart(resumeKey, result.partNum, result.etag);
+            } catch (err) {
+              telemetry?.emit(sessionId, "upload.retried", { step: "resume_update", part_number: result.partNum, error: err instanceof Error ? err.message : "Resume update failed" });
+            }
+          }
+        } else {
+          const errorMsg = result.error || "Part upload returned no ETag";
+          await this.abortMultipart(upload_session_id, completionToken, requestOpts);
+          telemetry?.emit(sessionId, "upload.multipart.aborted", { file_id, error: errorMsg });
+          return {
+            data: null,
+            error: { code: "upload_error", message: `Part ${result.partNum} failed: ${errorMsg}`, status: 0 }
+          };
+        }
+      }
+      reportProgress();
+      partIndex += batch.length;
+    }
+    const parts = Array.from(completedParts.entries()).sort(([a], [b]) => a - b).map(([part_number, etag]) => ({ part_number, etag }));
+    const completeResult = await this.post(
+      "/signed-url/multipart/complete",
+      { upload_session_id, file_id, completion_token: completionToken, parts },
+      requestOpts
+    );
+    if (resumeStore) {
+      try {
+        const { UploadResumeStore: UploadResumeStore2 } = await Promise.resolve().then(() => (init_upload_resume(), upload_resume_exports));
+        const resumeKey = await UploadResumeStore2.generateResumeKey(
+          this.client.getApiKey?.() || "",
+          this.client.getUserId?.() || "",
+          filename,
+          file.size,
+          file.lastModified
+        );
+        await resumeStore.remove(resumeKey);
+      } catch (err) {
+        telemetry?.emit(sessionId, "upload.retried", { step: "resume_cleanup", error: err instanceof Error ? err.message : "Resume cleanup failed" });
+      }
+    }
+    if (completeResult.error) {
+      telemetry?.emit(sessionId, "upload.multipart.aborted", { file_id, error: completeResult.error.message, duration_ms: Date.now() - multipartStart });
+      return { data: null, error: completeResult.error };
+    }
+    telemetry?.emit(sessionId, "upload.multipart.completed", { file_id, size_bytes: file.size, duration_ms: Date.now() - multipartStart });
+    telemetry?.emit(sessionId, "upload.completed", { file_id, size_bytes: file.size, duration_ms: Date.now() - multipartStart });
+    options?.onProgress?.(100);
+    const d = completeResult.data;
+    return {
+      data: {
+        id: d.file_id,
+        filename: d.filename,
+        content_type: d.content_type,
+        size_bytes: d.size_bytes,
+        url: d.url,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      error: null
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Multipart Abort
+  // --------------------------------------------------------------------------
+  async abortMultipart(uploadSessionId, completionToken, requestOpts) {
+    try {
+      await this.post("/signed-url/multipart/abort", {
+        upload_session_id: uploadSessionId,
+        ...completionToken ? { completion_token: completionToken } : {}
+      }, requestOpts);
+    } catch {
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Split Upload (server-side: presigned URL → client S3 upload → complete)
+  // --------------------------------------------------------------------------
+  /**
+   * Get a presigned URL for direct upload to S3.
+   * Use this when the browser uploads directly (with progress tracking)
+   * and the server only brokers the URLs.
+   *
+   * Flow: server calls getUploadUrl() → returns URL to client → client PUTs to S3 → server calls completeUpload()
+   */
+  async getUploadUrl(filename, contentType, options, requestOptions) {
+    return this.post("/signed-url/upload", {
+      filename,
+      content_type: contentType,
+      is_public: options?.isPublic ?? true,
+      expires_in: options?.expiresIn ?? 3600,
+      metadata: options?.metadata
+    }, requestOptions);
+  }
+  /**
+   * Complete a presigned upload after the file has been uploaded to S3.
+   * Triggers scan and makes the file available.
+   */
+  async completeUpload(fileId, completionToken, options, requestOptions) {
+    return this.post("/signed-url/complete", {
+      file_id: fileId,
+      completion_token: completionToken,
+      size_bytes: options?.sizeBytes,
+      checksum: options?.checksum
+    }, requestOptions);
+  }
+  // --------------------------------------------------------------------------
+  // Multipart Public API (for advanced/server-side usage)
+  // --------------------------------------------------------------------------
+  /** Start a multipart upload session. */
+  async startMultipartUpload(params, requestOptions) {
+    return this.post("/signed-url/multipart/start", params, requestOptions);
+  }
+  /** Get presigned URLs for specific part numbers. */
+  async getMultipartPartUrls(uploadSessionId, partNumbers, completionToken, requestOptions) {
+    return this.post("/signed-url/multipart/part-urls", {
+      upload_session_id: uploadSessionId,
+      part_numbers: partNumbers,
+      ...completionToken ? { completion_token: completionToken } : {}
+    }, requestOptions);
+  }
+  /** Complete a multipart upload. */
+  async completeMultipartUpload(params, requestOptions) {
+    return this.post("/signed-url/multipart/complete", params, requestOptions);
+  }
+  /** Abort a multipart upload. */
+  async abortMultipartUpload(uploadSessionId, completionToken, requestOptions) {
+    return this.post("/signed-url/multipart/abort", {
+      upload_session_id: uploadSessionId,
+      ...completionToken ? { completion_token: completionToken } : {}
+    }, requestOptions);
+  }
+  // --------------------------------------------------------------------------
+  // File Operations
+  // --------------------------------------------------------------------------
+  /** Get file metadata (no signed URL). */
+  async getInfo(fileId, options) {
+    return this._get(`/files/${fileId}/info`, options);
+  }
+  /**
+   * Get a signed view URL for inline display (img src, thumbnails).
+   * Returns CloudFront signed URL (fast, ~1us) or S3 presigned fallback.
+   */
+  async getViewUrl(fileId, options) {
+    return this.post(`/signed-url/view/${fileId}`, {}, options);
+  }
+  /**
+   * Get signed view URLs for multiple files (batch, up to 100).
+   * Single network call, returns all URLs.
+   * The shared `expires_at` is a conservative lower bound — reflects the shortest-lived
+   * URL in the batch. Individual URLs may remain valid longer if their files are public.
+   */
+  async getViewUrls(fileIds, options) {
+    return this.post("/signed-url/view-batch", { file_ids: fileIds }, options);
+  }
+  /**
+   * Get a signed download URL (Content-Disposition: attachment).
+   */
+  async getDownloadUrl(fileId, options) {
+    return this.post(`/signed-url/download/${fileId}`, void 0, options);
+  }
+  /** Delete a file (soft delete). */
+  async delete(fileId, options) {
+    return this.del(`/files/${fileId}`, options);
+  }
+  /** List the current user's files (paginated). */
+  async list(params, options) {
+    return this.listMethod("/my-files", params, options);
+  }
+  /** Check file view/access status. */
+  async getViewStatus(fileId, options) {
+    return this._get(`/files/${fileId}/view-status`, options);
+  }
+  /**
+   * Update a file's visibility (public/private).
+   * Only the file owner can toggle this. Changes URL TTL — does not move the S3 object.
+   * Public files get 7-day signed URLs; private files get 1-hour signed URLs.
+   */
+  async updateVisibility(fileId, isPublic, options) {
+    return this.patch(`/files/${fileId}/visibility`, { is_public: isPublic }, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use upload() instead */
+  async uploadFile(file, options) {
+    return this.upload(file, {
+      isPublic: options?.is_public,
+      metadata: options?.metadata,
+      onProgress: options?.onProgress,
+      signal: options?.signal
+    });
+  }
+  /** @deprecated Use getInfo() instead */
+  async getFile(id) {
+    return this.getInfo(id);
+  }
+  /** @deprecated Use delete() instead */
+  async deleteFile(id) {
+    return this.delete(id);
+  }
+  /** @deprecated Use list() instead */
+  async listFiles(params) {
+    return this.list(params);
+  }
+  // --------------------------------------------------------------------------
+  // Private: Upload to presigned URL with retry + stall guard
+  // --------------------------------------------------------------------------
+  async uploadToPresignedUrlWithRetry(url, file, onProgress, signal, sessionId, telemetry) {
+    for (let attempt = 0; attempt < RETRY_DELAYS.length; attempt++) {
+      if (signal?.aborted) {
+        return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+      }
+      if (attempt > 0) {
+        const delay = RETRY_DELAYS[attempt] ?? 0;
+        if (delay > 0) await sleep2(delay);
+        telemetry?.emit(sessionId || "", "upload.retried", { attempt });
+      }
+      const result = await this.uploadToPresignedUrl(url, file, onProgress, signal);
+      if (!result.error) return result;
+      if (result.error.code === "aborted") return result;
+      if (result.error.status && NON_RETRYABLE_STATUS_CODES.has(result.error.status)) {
+        return result;
+      }
+      const isRetryable = result.error.status === 0 || RETRYABLE_STATUS_CODES2.has(result.error.status);
+      if (!isRetryable || attempt === RETRY_DELAYS.length - 1) {
+        return result;
+      }
+    }
+    return { data: null, error: { code: "upload_error", message: "Upload failed after retries", status: 0 } };
+  }
+  /**
+   * Upload file directly to S3 presigned URL.
+   * Uses XHR for progress tracking in browser, fetch otherwise.
+   * Includes stall detection.
+   */
+  async uploadToPresignedUrl(url, file, onProgress, signal) {
+    if (signal?.aborted) {
+      return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+    }
+    if (typeof XMLHttpRequest !== "undefined") {
+      return this.uploadWithXHR(url, file, onProgress, signal);
+    }
+    const stallTimeout = DEFAULT_STALL_TIMEOUT_MS;
+    const controller = new AbortController();
+    let parentSignalCleanup;
+    const combinedSignal = signal ? AbortSignal.any?.([signal, controller.signal]) ?? (() => {
+      const onAbort = () => controller.abort();
+      signal.addEventListener("abort", onAbort, { once: true });
+      parentSignalCleanup = () => signal.removeEventListener("abort", onAbort);
+      return controller.signal;
+    })() : controller.signal;
+    const timer = setTimeout(() => controller.abort(), stallTimeout);
+    try {
+      const response = await fetch(url, {
+        method: "PUT",
+        body: file,
+        headers: {
+          "Content-Type": file.type || "application/octet-stream"
+        },
+        signal: combinedSignal
+      });
+      clearTimeout(timer);
+      parentSignalCleanup?.();
+      if (!response.ok) {
+        return {
+          data: null,
+          error: {
+            code: "upload_error",
+            message: `S3 upload failed: ${response.status} ${response.statusText}`,
+            status: response.status
+          }
+        };
+      }
+      onProgress?.(100);
+      return { data: null, error: null };
+    } catch (err) {
+      clearTimeout(timer);
+      parentSignalCleanup?.();
+      if (signal?.aborted) {
+        return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+      }
+      const isStall = controller.signal.aborted && !signal?.aborted;
+      return {
+        data: null,
+        error: {
+          code: isStall ? "upload_stalled" : "upload_error",
+          message: isStall ? `Upload stalled (no progress for ${stallTimeout / 1e3}s)` : err instanceof Error ? err.message : "S3 upload failed",
+          status: 0
+        }
+      };
+    }
+  }
+  uploadWithXHR(url, file, onProgress, signal) {
+    return new Promise((resolve) => {
+      const xhr = new XMLHttpRequest();
+      const stallTimeout = getStallTimeout();
+      let stallTimer = null;
+      const resetStallTimer = () => {
+        if (stallTimer !== null) clearTimeout(stallTimer);
+        stallTimer = setTimeout(() => {
+          xhr.abort();
+          resolve({
+            data: null,
+            error: {
+              code: "upload_stalled",
+              message: `Upload stalled (no progress for ${stallTimeout / 1e3}s)`,
+              status: 0
+            }
+          });
+        }, stallTimeout);
+      };
+      const clearStallTimer = () => {
+        if (stallTimer !== null) {
+          clearTimeout(stallTimer);
+          stallTimer = null;
+        }
+      };
+      if (signal) {
+        if (signal.aborted) {
+          resolve({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
+          return;
+        }
+        signal.addEventListener("abort", () => {
+          clearStallTimer();
+          xhr.abort();
+        }, { once: true });
+      }
+      xhr.upload.addEventListener("progress", (event) => {
+        resetStallTimer();
+        if (event.lengthComputable && onProgress) {
+          onProgress(Math.round(event.loaded / event.total * 100));
+        }
+      });
+      xhr.addEventListener("load", () => {
+        clearStallTimer();
+        if (xhr.status >= 200 && xhr.status < 300) {
+          onProgress?.(100);
+          resolve({ data: null, error: null });
+        } else {
+          resolve({
+            data: null,
+            error: {
+              code: "upload_error",
+              message: `S3 upload failed: ${xhr.status}`,
+              status: xhr.status
+            }
+          });
+        }
+      });
+      xhr.addEventListener("error", () => {
+        clearStallTimer();
+        resolve({
+          data: null,
+          error: { code: "upload_error", message: "S3 upload failed", status: 0 }
+        });
+      });
+      xhr.addEventListener("abort", () => {
+        clearStallTimer();
+        if (!signal?.aborted) return;
+        resolve({
+          data: null,
+          error: { code: "aborted", message: "Upload aborted", status: 0 }
+        });
+      });
+      xhr.open("PUT", url);
+      xhr.setRequestHeader("Content-Type", file.type || "application/octet-stream");
+      xhr.send(file);
+      resetStallTimer();
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Private: Part upload with retry
+  // --------------------------------------------------------------------------
+  async uploadPartWithRetry(url, blob, signal, partNumber, sessionId, telemetry) {
+    for (let attempt = 0; attempt < RETRY_DELAYS.length; attempt++) {
+      if (signal?.aborted) return { error: "Upload aborted", code: "aborted" };
+      if (attempt > 0) {
+        const delay = RETRY_DELAYS[attempt] ?? 0;
+        if (delay > 0) await sleep2(delay);
+        telemetry?.emit(sessionId || "", "upload.retried", { attempt, part_number: partNumber });
+      }
+      const controller = new AbortController();
+      let partSignalCleanup;
+      const combinedSignal = signal ? AbortSignal.any?.([signal, controller.signal]) ?? (() => {
+        const onAbort = () => controller.abort();
+        signal.addEventListener("abort", onAbort, { once: true });
+        partSignalCleanup = () => signal.removeEventListener("abort", onAbort);
+        return controller.signal;
+      })() : controller.signal;
+      const timer = setTimeout(() => controller.abort(), DEFAULT_STALL_TIMEOUT_MS);
+      try {
+        const response = await fetch(url, {
+          method: "PUT",
+          body: blob,
+          signal: combinedSignal
+        });
+        clearTimeout(timer);
+        partSignalCleanup?.();
+        if (response.ok) {
+          const etag = response.headers.get("etag");
+          if (!etag) {
+            if (attempt === RETRY_DELAYS.length - 1) {
+              return { error: "Part upload succeeded but ETag missing \u2014 cannot verify integrity", code: "s3_error" };
+            }
+            continue;
+          }
+          return { etag };
+        }
+        if (NON_RETRYABLE_STATUS_CODES.has(response.status)) {
+          return { error: `Part upload failed: ${response.status}`, status: response.status, code: "s3_error" };
+        }
+        if (attempt === RETRY_DELAYS.length - 1) {
+          return { error: `Part upload failed after retries: ${response.status}`, status: response.status, code: "s3_error" };
+        }
+      } catch (err) {
+        clearTimeout(timer);
+        partSignalCleanup?.();
+        if (signal?.aborted) return { error: "Upload aborted", code: "aborted" };
+        const isStall = controller.signal.aborted && !signal?.aborted;
+        if (attempt === RETRY_DELAYS.length - 1) {
+          return {
+            error: isStall ? `Part upload stalled (no progress for ${DEFAULT_STALL_TIMEOUT_MS / 1e3}s)` : err instanceof Error ? err.message : "Part upload failed",
+            code: isStall ? "upload_stalled" : "network_error"
+          };
+        }
+      }
+    }
+    return { error: "Part upload failed after retries", code: "network_error" };
+  }
+  // --------------------------------------------------------------------------
+  // Private: Helpers
+  // --------------------------------------------------------------------------
+  shouldUseMultipart(file, options) {
+    if (options?.forceMultipart) return true;
+    const threshold = isSlowNetwork() ? MULTIPART_THRESHOLD_SLOW : MULTIPART_THRESHOLD;
+    return file.size >= threshold;
+  }
+  defaultChunkSize(fileSize) {
+    if (fileSize > 512 * 1024 * 1024) return 16 * 1024 * 1024;
+    const effectiveType = getNetworkEffectiveType2();
+    if (effectiveType === "slow-2g" || effectiveType === "2g") return 5 * 1024 * 1024;
+    if (effectiveType === "3g") return 5 * 1024 * 1024;
+    return 8 * 1024 * 1024;
+  }
+  defaultConcurrency() {
+    const effectiveType = getNetworkEffectiveType2();
+    if (effectiveType === "slow-2g" || effectiveType === "2g") return 1;
+    if (effectiveType === "3g") return 2;
+    return 4;
+  }
+  async maybeCompress(file, config, sessionId, telemetry) {
+    try {
+      const { maybeCompressImage: maybeCompressImage2 } = await Promise.resolve().then(() => (init_upload_compression(), upload_compression_exports));
+      return await maybeCompressImage2(file, config, sessionId, telemetry);
+    } catch {
+      return null;
+    }
+  }
+  getOrCreateTelemetry() {
+    if (!this.telemetry) {
+      this.telemetry = new UploadTelemetry(this.client);
+    }
+    return this.telemetry;
+  }
+  /** Build RequestOptions with X-Upload-Session-Id header for cross-boundary correlation */
+  withSessionHeader(sessionId, options) {
+    const headers = { "X-Upload-Session-Id": sessionId };
+    if (options?.clientContext) {
+      return { clientContext: options.clientContext, headers };
+    }
+    return { headers };
+  }
+  /**
+   * Use ServiceModule's list method but with a cleaner name internally
+   * (can't call protected `list` from public method with same name).
+   */
+  listMethod(path, params, options) {
+    return super._list(path, params, options);
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getStallTimeout() {
+  return isSlowNetwork() ? SLOW_NETWORK_STALL_TIMEOUT_MS : DEFAULT_STALL_TIMEOUT_MS;
+}
+function isSlowNetwork() {
+  const effectiveType = getNetworkEffectiveType2();
+  return effectiveType === "slow-2g" || effectiveType === "2g" || effectiveType === "3g";
+}
+function getNetworkEffectiveType2() {
+  if (typeof navigator !== "undefined" && "connection" in navigator) {
+    const conn = navigator.connection;
+    return conn?.effectiveType || "4g";
+  }
+  return "4g";
+}
+
+// src/index.ts
+init_upload_resume();
+
+// src/services/upload-strategy.ts
+var MULTIPART_THRESHOLD2 = 8 * 1024 * 1024;
+var MULTIPART_THRESHOLD_SLOW2 = 4 * 1024 * 1024;
+var DEFAULT_STALL_TIMEOUT_MS2 = 45e3;
+var SLOW_STALL_TIMEOUT_MS = 9e4;
+var CHUNK_SIZES = {
+  "slow-2g": 5 * 1024 * 1024,
+  "2g": 5 * 1024 * 1024,
+  "3g": 5 * 1024 * 1024,
+  "4g": 8 * 1024 * 1024,
+  unknown: 8 * 1024 * 1024
+};
+var LARGE_FILE_CHUNK_SIZE = 16 * 1024 * 1024;
+var CONCURRENCY = {
+  "slow-2g": 1,
+  "2g": 1,
+  "3g": 2,
+  "4g": 4,
+  unknown: 4
+};
+function resolveStrategy(fileSize, overrides) {
+  const network = detectNetworkClass();
+  const isSlowNetwork2 = network === "slow-2g" || network === "2g" || network === "3g";
+  const threshold = isSlowNetwork2 ? MULTIPART_THRESHOLD_SLOW2 : MULTIPART_THRESHOLD2;
+  const strategy = overrides?.forceMultipart || fileSize >= threshold ? "multipart" : "direct";
+  const chunkSize = overrides?.chunkSize || (fileSize > 512 * 1024 * 1024 ? LARGE_FILE_CHUNK_SIZE : CHUNK_SIZES[network]);
+  const concurrency = overrides?.concurrency || adaptConcurrency(network);
+  const stallTimeoutMs = isSlowNetwork2 ? SLOW_STALL_TIMEOUT_MS : DEFAULT_STALL_TIMEOUT_MS2;
+  return { strategy, chunkSize, concurrency, stallTimeoutMs };
+}
+function detectNetworkClass() {
+  if (typeof navigator === "undefined") return "unknown";
+  const conn = navigator.connection;
+  if (!conn) return "unknown";
+  const effectiveType = conn.effectiveType;
+  if (effectiveType === "slow-2g") return "slow-2g";
+  if (effectiveType === "2g") return "2g";
+  if (effectiveType === "3g") return "3g";
+  if (effectiveType === "4g") return "4g";
+  return "unknown";
+}
+function getMeasuredBandwidthMbps() {
+  if (typeof navigator === "undefined") return null;
+  const conn = navigator.connection;
+  return conn?.downlink ?? null;
+}
+function adaptConcurrency(network) {
+  const bandwidth = getMeasuredBandwidthMbps();
+  if (bandwidth === null) return CONCURRENCY[network];
+  if (bandwidth < 0.5) return 1;
+  if (bandwidth < 2) return 2;
+  if (bandwidth < 10) return 3;
+  return 5;
+}
+
+// src/services/upload-engine.ts
+var DEFAULT_CONFIG = {
+  multipartEnabled: true,
+  multipartAllowlist: [],
+  telemetry: {}
+};
+function createUploadPlan(fileSize, contentType, options = {}, engineConfig = {}) {
+  const config = { ...DEFAULT_CONFIG, ...engineConfig };
+  const multipartAllowed = config.multipartEnabled && (config.multipartAllowlist.length === 0 || options.appId != null && config.multipartAllowlist.includes(options.appId));
+  const resolved = resolveStrategy(fileSize, {
+    forceMultipart: multipartAllowed && options.forceMultipart,
+    chunkSize: options.chunkSize,
+    concurrency: options.maxConcurrency
+  });
+  const strategy = resolved.strategy === "multipart" && !multipartAllowed ? "direct" : resolved.strategy;
+  const isBrowser = typeof window !== "undefined";
+  const isCompressibleType = contentType.startsWith("image/") && !contentType.includes("gif") && !contentType.includes("svg") && !contentType.includes("webp") && !contentType.includes("avif");
+  const shouldCompress = isBrowser && !options.skipCompression && isCompressibleType && fileSize >= 100 * 1024;
+  const shouldResume = isBrowser && strategy === "multipart" && options.resume !== "off";
+  const totalParts = strategy === "multipart" ? Math.ceil(fileSize / resolved.chunkSize) : 1;
+  return {
+    strategy,
+    chunkSize: resolved.chunkSize,
+    concurrency: resolved.concurrency,
+    stallTimeoutMs: resolved.stallTimeoutMs,
+    shouldCompress,
+    shouldResume,
+    totalParts
+  };
+}
+function calculateTotalParts(fileSize, chunkSize) {
+  return Math.ceil(fileSize / chunkSize);
+}
+function getPartRange(partNumber, chunkSize, totalSize) {
+  const start = (partNumber - 1) * chunkSize;
+  const end = Math.min(start + chunkSize, totalSize);
+  return { start, end, size: end - start };
+}
+
+// src/services/realtime.ts
+var DEFAULT_RECONNECT_BASE_MS = 1e3;
+var MAX_RECONNECT_MS = 3e4;
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var RealtimeService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/realtime";
+    this.ws = null;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.presenceCallbacks = /* @__PURE__ */ new Map();
+    this.statusCallbacks = /* @__PURE__ */ new Set();
+    this._status = "disconnected";
+    this.reconnectAttempt = 0;
+    this.reconnectTimer = null;
+    this.heartbeatTimer = null;
+    this.authenticated = false;
+  }
+  /** Current connection status */
+  get status() {
+    return this._status;
+  }
+  // --------------------------------------------------------------------------
+  // Subscribe / Unsubscribe
+  // --------------------------------------------------------------------------
+  /**
+   * Subscribe to a channel. Connects WebSocket on first call.
+   * Returns an unsubscribe function.
+   */
+  subscribe(channel, callback) {
+    if (!this.subscriptions.has(channel)) {
+      this.subscriptions.set(channel, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(channel).add(callback);
+    if (this._status === "disconnected") {
+      this.connect();
+    } else if (this.authenticated) {
+      this.sendWs({ type: "subscribe", channel });
+    }
+    return () => {
+      const subs = this.subscriptions.get(channel);
+      if (subs) {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          this.subscriptions.delete(channel);
+          if (this.ws?.readyState === WebSocket.OPEN) {
+            this.sendWs({ type: "unsubscribe", channel });
+          }
+        }
+      }
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Publish
+  // --------------------------------------------------------------------------
+  /** Publish data to a channel via WebSocket. */
+  publish(channel, data) {
+    if (this._status !== "connected" || !this.authenticated) {
+      throw new Error("Cannot publish: not connected");
+    }
+    this.sendWs({ type: "publish", channel, data });
+  }
+  // --------------------------------------------------------------------------
+  // Presence
+  // --------------------------------------------------------------------------
+  /** Join a presence channel with optional user data. */
+  joinPresence(channel, userData) {
+    if (this._status !== "connected") {
+      throw new Error("Cannot join presence: not connected");
+    }
+    this.sendWs({ type: "presence_join", channel, user_data: userData });
+  }
+  /** Leave a presence channel. */
+  leavePresence(channel) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.sendWs({ type: "presence_leave", channel });
+    }
+  }
+  /** Listen for presence events on a channel. Returns unsubscribe function. */
+  onPresence(channel, callback) {
+    if (!this.presenceCallbacks.has(channel)) {
+      this.presenceCallbacks.set(channel, /* @__PURE__ */ new Set());
+    }
+    this.presenceCallbacks.get(channel).add(callback);
+    return () => {
+      const cbs = this.presenceCallbacks.get(channel);
+      if (cbs) {
+        cbs.delete(callback);
+        if (cbs.size === 0) this.presenceCallbacks.delete(channel);
+      }
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Server-side broadcast (HTTP endpoints)
+  // --------------------------------------------------------------------------
+  /** Broadcast to all connections for this application. */
+  async broadcast(event, data, options) {
+    return this.post("/broadcast", { event, data }, options);
+  }
+  /** Broadcast to a specific channel. */
+  async broadcastToChannel(channel, event, data, options) {
+    return this.post(`/broadcast/channel/${channel}`, { event, data }, options);
+  }
+  /** Send to a specific user's connections. */
+  async sendToUser(userId, event, data, options) {
+    return this.post(`/broadcast/user/${userId}`, { event, data }, options);
+  }
+  // --------------------------------------------------------------------------
+  // Connection Lifecycle
+  // --------------------------------------------------------------------------
+  /** Listen for connection status changes. */
+  onStatusChange(callback) {
+    this.statusCallbacks.add(callback);
+    return () => {
+      this.statusCallbacks.delete(callback);
+    };
+  }
+  /** Disconnect and clean up all subscriptions. */
+  disconnect() {
+    this.clearTimers();
+    this.subscriptions.clear();
+    this.presenceCallbacks.clear();
+    this.statusCallbacks.clear();
+    this.authenticated = false;
+    this.reconnectAttempt = 0;
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setStatus("disconnected");
+  }
+  // --------------------------------------------------------------------------
+  // Private: WebSocket management
+  // --------------------------------------------------------------------------
+  connect() {
+    if (this._status === "connecting" || this._status === "connected") return;
+    const baseUrl = this.client.getBaseUrl();
+    const wsUrl = baseUrl.replace(/^http/, "ws") + "/v1/realtime/ws";
+    this.setStatus(this.reconnectAttempt > 0 ? "reconnecting" : "connecting");
+    try {
+      this.ws = new WebSocket(wsUrl);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      this.reconnectAttempt = 0;
+      this.authenticate();
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        this.handleMessage(msg);
+      } catch {
+      }
+    };
+    this.ws.onclose = () => {
+      this.authenticated = false;
+      this.clearHeartbeat();
+      this.scheduleReconnect();
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  authenticate() {
+    const token = this.client.getSessionToken();
+    this.sendWs({
+      type: "auth",
+      token: token || void 0
+    });
+  }
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "auth_success":
+        this.authenticated = true;
+        this.setStatus("connected");
+        for (const channel of this.subscriptions.keys()) {
+          this.sendWs({ type: "subscribe", channel });
+        }
+        break;
+      case "subscribed":
+        break;
+      case "message":
+        this.dispatchMessage(msg.channel, msg.data);
+        break;
+      case "error":
+        break;
+      case "presence_state":
+        this.dispatchPresence({
+          type: "state",
+          channel: msg.channel,
+          members: msg.members
+        });
+        break;
+      case "presence_join":
+        this.dispatchPresence({
+          type: "join",
+          channel: msg.channel,
+          user: msg.user
+        });
+        break;
+      case "presence_leave":
+        this.dispatchPresence({
+          type: "leave",
+          channel: msg.channel,
+          user_id: msg.user_id
+        });
+        break;
+    }
+  }
+  dispatchMessage(channel, data) {
+    const subs = this.subscriptions.get(channel);
+    if (subs) {
+      for (const cb of subs) {
+        try {
+          cb(data, channel);
+        } catch {
+        }
+      }
+    }
+  }
+  dispatchPresence(event) {
+    const cbs = this.presenceCallbacks.get(event.channel);
+    if (cbs) {
+      for (const cb of cbs) {
+        try {
+          cb(event);
+        } catch {
+        }
+      }
+    }
+  }
+  sendWs(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Private: Reconnection
+  // --------------------------------------------------------------------------
+  scheduleReconnect() {
+    if (this.subscriptions.size === 0 && this.presenceCallbacks.size === 0) {
+      this.setStatus("disconnected");
+      return;
+    }
+    this.setStatus("reconnecting");
+    const delay = this.getReconnectDelay();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectAttempt++;
+      this.connect();
+    }, delay);
+  }
+  getReconnectDelay() {
+    const exponential = DEFAULT_RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempt);
+    const jitter = Math.random() * 0.3 * exponential;
+    return Math.min(exponential + jitter, MAX_RECONNECT_MS);
+  }
+  // --------------------------------------------------------------------------
+  // Private: Heartbeat
+  // --------------------------------------------------------------------------
+  startHeartbeat() {
+    this.clearHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send("ping");
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  clearTimers() {
+    this.clearHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Private: Status
+  // --------------------------------------------------------------------------
+  setStatus(status) {
+    if (this._status === status) return;
+    this._status = status;
+    for (const cb of this.statusCallbacks) {
+      try {
+        cb(status);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/services/video.ts
+var DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+var MIN_CHUNK_SIZE = 5 * 1024 * 1024;
+var VideoService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/videos";
+  }
+  // --------------------------------------------------------------------------
+  // Upload (3-step chunked flow)
+  // --------------------------------------------------------------------------
+  /**
+   * Upload a video file using chunked multipart upload.
+   *
+   * Internally:
+   *   1. Starts a multipart upload session
+   *   2. Uploads chunks sequentially with progress tracking
+   *   3. Completes the upload, triggering transcoding
+   *
+   * @returns The video record with id, status, etc.
+   */
+  async upload(file, options, requestOptions) {
+    if (options?.signal?.aborted) {
+      return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+    }
+    const chunkSize = Math.max(options?.chunkSize ?? DEFAULT_CHUNK_SIZE, MIN_CHUNK_SIZE);
+    const totalChunks = Math.ceil(file.size / chunkSize);
+    const filename = options?.filename || file.name || "video";
+    const startResult = await this.post("/upload-start", {
+      filename,
+      content_type: file.type || "video/mp4",
+      size_bytes: file.size,
+      title: options?.title,
+      description: options?.description,
+      metadata: options?.metadata
+    }, requestOptions);
+    if (startResult.error) return { data: null, error: startResult.error };
+    const { video_id, upload_id } = startResult.data;
+    const parts = [];
+    for (let i = 0; i < totalChunks; i++) {
+      if (options?.signal?.aborted) {
+        return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+      }
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, file.size);
+      const chunk = file.slice(start, end);
+      const partNumber = i + 1;
+      const partResult = await this.uploadPart(
+        video_id,
+        upload_id,
+        partNumber,
+        chunk,
+        options?.signal
+      );
+      if (partResult.error) return { data: null, error: partResult.error };
+      parts.push({
+        part_number: partNumber,
+        etag: partResult.data.etag
+      });
+      if (options?.onProgress) {
+        const progress = Math.round(partNumber / totalChunks * 100);
+        options.onProgress(progress);
+      }
+    }
+    const completeResult = await this.post(`/${video_id}/upload-complete`, {
+      upload_id,
+      parts
+    }, requestOptions);
+    return completeResult;
+  }
+  // --------------------------------------------------------------------------
+  // Video Operations
+  // --------------------------------------------------------------------------
+  /** Get video metadata and status. */
+  async get(videoId, options) {
+    return super._get(`/${videoId}`, options);
+  }
+  /**
+   * Get the HLS master playlist URL for streaming.
+   * Returns the playlist URL that can be passed to a video player.
+   */
+  async getStreamUrl(videoId) {
+    const baseUrl = this.client.getBaseUrl();
+    return {
+      data: { url: `${baseUrl}${this.basePath}/${videoId}/playlist.m3u8` },
+      error: null
+    };
+  }
+  /**
+   * Track a playback event (view, play, pause, seek, complete, etc.).
+   */
+  async trackPlayback(videoId, event, options) {
+    return this.post(`/${videoId}/track`, event, options);
+  }
+  /** Get video analytics (views, watch time, etc.). */
+  async getAnalytics(videoId, options) {
+    return super._get(`/${videoId}/analytics`, options);
+  }
+  /**
+   * Update a video's access mode (public/private).
+   * Public videos get 7-day signed URLs; private get 1-hour signed URLs.
+   */
+  async updateAccessMode(videoId, accessMode, options) {
+    return this.patch(`/${videoId}`, { access_mode: accessMode }, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use upload() instead */
+  async uploadVideo(file, options) {
+    return this.upload(file, {
+      metadata: options?.metadata,
+      onProgress: options?.onProgress,
+      signal: options?.signal
+    });
+  }
+  /** @deprecated Use get() instead */
+  async getVideo(id) {
+    return this.get(id);
+  }
+  // --------------------------------------------------------------------------
+  // Private: Chunk upload
+  // --------------------------------------------------------------------------
+  async uploadPart(videoId, uploadId, partNumber, chunk, signal) {
+    const formData = new FormData();
+    formData.append("file", chunk);
+    const path = `${this.basePath}/${videoId}/upload-part?upload_id=${encodeURIComponent(uploadId)}&part_number=${partNumber}`;
+    const headers = {
+      "x-api-key": this.client.getApiKey()
+    };
+    const token = this.client.getSessionToken();
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    try {
+      const response = await fetch(`${this.client.getBaseUrl()}${path}`, {
+        method: "POST",
+        headers,
+        body: formData,
+        signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          data: null,
+          error: {
+            code: data?.error?.code || "upload_error",
+            message: data?.error?.message || data?.message || "Part upload failed",
+            status: response.status
+          }
+        };
+      }
+      const result = data?.data !== void 0 ? data.data : data;
+      return { data: result, error: null };
+    } catch (err) {
+      if (signal?.aborted) {
+        return { data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } };
+      }
+      return {
+        data: null,
+        error: {
+          code: "upload_error",
+          message: err instanceof Error ? err.message : "Part upload failed",
+          status: 0
+        }
+      };
+    }
+  }
+};
+
+// src/services/data.ts
+var DataService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/data";
+  }
+  // --------------------------------------------------------------------------
+  // Collections
+  // --------------------------------------------------------------------------
+  async createCollection(name, schema, options) {
+    return this.post("/collections", { name, schema }, options);
+  }
+  async listCollections(options) {
+    return this._get("/collections", options);
+  }
+  async deleteCollection(name, options) {
+    return this.del(`/collections/${name}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Documents — CRUD
+  // --------------------------------------------------------------------------
+  async create(collection, data, options) {
+    return this.post(`/${collection}/documents`, { data }, options);
+  }
+  async get(collection, docId, options) {
+    return this._get(`/${collection}/documents/${docId}`, options);
+  }
+  async update(collection, docId, data, options) {
+    return this.patch(`/${collection}/documents/${docId}`, { data }, options);
+  }
+  async delete(collection, docId, options) {
+    return this.del(`/${collection}/documents/${docId}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Documents — Query & Aggregate
+  // --------------------------------------------------------------------------
+  async query(collection, options, requestOptions) {
+    const body = {
+      filters: options?.filters ?? [],
+      sort: options?.sort ?? [],
+      page: options?.page ?? 1,
+      per_page: options?.perPage ?? 20
+    };
+    const response = await this.post(`/${collection}/query`, body, requestOptions);
+    if (response.error) {
+      return {
+        data: [],
+        metadata: { total: 0, totalPages: 0, page: body.page, perPage: body.per_page },
+        error: response.error
+      };
+    }
+    const raw = response.data;
+    const documents = raw?.documents ?? raw?.data ?? [];
+    const total = raw?.total ?? documents.length;
+    const totalPages = raw?.total_pages ?? (total > 0 ? Math.ceil(total / body.per_page) : 0);
+    return {
+      data: documents,
+      metadata: {
+        total,
+        totalPages,
+        page: raw?.page ?? body.page,
+        perPage: raw?.per_page ?? body.per_page
+      },
+      error: null
+    };
+  }
+  async aggregate(collection, options, requestOptions) {
+    return this.post(`/${collection}/aggregate`, options, requestOptions);
+  }
+  async myDocuments(collection, options, requestOptions) {
+    return this._list(`/${collection}/my-documents`, options, requestOptions);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use create() instead */
+  async createDocument(collection, data) {
+    return this.create(collection, data);
+  }
+  /** @deprecated Use get() instead */
+  async getDocument(collection, id) {
+    return this.get(collection, id);
+  }
+  /** @deprecated Use update() instead */
+  async updateDocument(collection, id, data) {
+    return this.update(collection, id, data);
+  }
+  /** @deprecated Use delete() instead */
+  async deleteDocument(collection, id) {
+    return this.delete(collection, id);
+  }
+  /** @deprecated Use query() instead */
+  async queryDocuments(collection, options) {
+    return this.query(collection, options);
+  }
+};
+
+// src/services/chat.ts
+var ChatService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/chat";
+  }
+  // --------------------------------------------------------------------------
+  // Conversations
+  // --------------------------------------------------------------------------
+  async createConversation(data, options) {
+    return this.post("/conversations", data, options);
+  }
+  async listConversations(params, requestOptions) {
+    return this._list("/conversations", params, requestOptions);
+  }
+  async getConversation(id, options) {
+    return this._get(`/conversations/${id}`, options);
+  }
+  async addParticipant(conversationId, userId, options) {
+    return this.post(`/conversations/${conversationId}/participants`, { user_id: userId }, options);
+  }
+  async removeParticipant(conversationId, userId, options) {
+    return this.del(`/conversations/${conversationId}/participants/${userId}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Messages
+  // --------------------------------------------------------------------------
+  async sendMessage(conversationId, data, options) {
+    return this.post(`/conversations/${conversationId}/messages`, data, options);
+  }
+  async getMessages(conversationId, options, requestOptions) {
+    return this._get(this.withQuery(`/conversations/${conversationId}/messages`, options), requestOptions);
+  }
+  async editMessage(messageId, data, options) {
+    return this.patch(`/messages/${messageId}`, data, options);
+  }
+  async deleteMessage(messageId, options) {
+    return this.del(`/messages/${messageId}`, options);
+  }
+  async addReaction(messageId, data, options) {
+    return this.post(`/messages/${messageId}/reactions`, data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Typing & Read Receipts
+  // --------------------------------------------------------------------------
+  async sendTyping(conversationId, options) {
+    return this.post(`/conversations/${conversationId}/typing`, void 0, options);
+  }
+  async markRead(conversationId, options) {
+    return this.post(`/conversations/${conversationId}/read`, void 0, options);
+  }
+  async getReadStatus(conversationId, options) {
+    return this._get(`/conversations/${conversationId}/read-status`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use createConversation() instead */
+  async createChat(data) {
+    return this.createConversation(data);
+  }
+};
+
+// src/services/social.ts
+var SocialService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/social";
+  }
+  // --------------------------------------------------------------------------
+  // Follow / Unfollow
+  // --------------------------------------------------------------------------
+  async follow(userId, options) {
+    return this.post(`/users/${userId}/follow`, void 0, options);
+  }
+  async unfollow(userId, options) {
+    return this.del(`/users/${userId}/follow`, options);
+  }
+  async getFollowers(userId, params, requestOptions) {
+    return this._list(`/users/${userId}/followers`, params, requestOptions);
+  }
+  async getFollowing(userId, params, requestOptions) {
+    return this._list(`/users/${userId}/following`, params, requestOptions);
+  }
+  async getFollowStatus(userId, options) {
+    return this._get(`/users/${userId}/follow-status`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Posts
+  // --------------------------------------------------------------------------
+  async createPost(data, options) {
+    return this.post("/posts", data, options);
+  }
+  async getPost(postId, options) {
+    return this._get(`/posts/${postId}`, options);
+  }
+  async deletePost(postId, options) {
+    return this.del(`/posts/${postId}`, options);
+  }
+  async getUserPosts(userId, params, requestOptions) {
+    return this._list(`/users/${userId}/posts`, params, requestOptions);
+  }
+  async getFeed(options, requestOptions) {
+    return this._list("/feed", options, requestOptions);
+  }
+  // --------------------------------------------------------------------------
+  // Likes
+  // --------------------------------------------------------------------------
+  async like(targetType, targetId, options) {
+    return this.post(`/${targetType}/${targetId}/like`, void 0, options);
+  }
+  async unlike(targetType, targetId, options) {
+    return this.del(`/${targetType}/${targetId}/like`, options);
+  }
+  async getLikes(targetType, targetId, params, requestOptions) {
+    return this._list(`/${targetType}/${targetId}/likes`, params, requestOptions);
+  }
+  // --------------------------------------------------------------------------
+  // Comments
+  // --------------------------------------------------------------------------
+  async comment(postId, data, options) {
+    return this.post(`/posts/${postId}/comments`, data, options);
+  }
+  async getComments(postId, params, requestOptions) {
+    return this._list(`/posts/${postId}/comments`, params, requestOptions);
+  }
+  // --------------------------------------------------------------------------
+  // Activity Feed
+  // --------------------------------------------------------------------------
+  async getActivity(params, requestOptions) {
+    return this._list("/activity", params, requestOptions);
+  }
+  async markActivityRead(activityId, options) {
+    return this.patch(`/activity/${activityId}/read`, {}, options);
+  }
+  async markAllRead(options) {
+    return this.patch("/activity/read-all", {}, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use comment() instead */
+  async addComment(postId, data) {
+    return this.comment(postId, data);
+  }
+};
+
+// src/services/billing.ts
+var BillingService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/billing";
+  }
+  // --------------------------------------------------------------------------
+  // Customers
+  // --------------------------------------------------------------------------
+  async createCustomer(data, options) {
+    return this.post("/customers", data, options);
+  }
+  async addPaymentMethod(data, options) {
+    return this.post("/payment-methods", data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Subscriptions
+  // --------------------------------------------------------------------------
+  async subscribe(data, options) {
+    return this.post("/subscriptions", data, options);
+  }
+  async listSubscriptions(params, options) {
+    return this._list("/subscriptions", params, options);
+  }
+  async cancelSubscription(id, options) {
+    return this.post(`/subscriptions/${id}/cancel`, void 0, options);
+  }
+  async resumeSubscription(id, options) {
+    return this.post(`/subscriptions/${id}/resume`, void 0, options);
+  }
+  async upgradeSubscription(id, data, options) {
+    return this.patch(`/subscriptions/${id}/upgrade`, data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Usage
+  // --------------------------------------------------------------------------
+  async reportUsage(data, options) {
+    return this.post("/usage", data, options);
+  }
+  async getUsageSummary(options) {
+    return this._get("/usage/summary", options);
+  }
+  // --------------------------------------------------------------------------
+  // Invoices
+  // --------------------------------------------------------------------------
+  async listInvoices(params, options) {
+    return this._list("/invoices", params, options);
+  }
+  async getInvoice(id, options) {
+    return this._get(`/invoices/${id}`, options);
+  }
+  async payInvoice(id, options) {
+    return this.post(`/invoices/${id}/pay`, void 0, options);
+  }
+  async getInvoicePdf(id, options) {
+    return this._get(`/invoices/${id}/pdf`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Connected Accounts (Marketplace)
+  // --------------------------------------------------------------------------
+  async createConnectedAccount(data, options) {
+    return this.post("/connected-accounts", data, options);
+  }
+  async getConnectedAccount(id, options) {
+    return this._get(`/connected-accounts/${id}`, options);
+  }
+  async getMyConnectedAccount(options) {
+    return this._get("/connected-accounts/me", options);
+  }
+  async createOnboardingLink(id, data, options) {
+    return this.post(`/connected-accounts/${id}/onboarding-link`, data, options);
+  }
+  async getAccountBalance(id, options) {
+    return this._get(`/connected-accounts/${id}/balance`, options);
+  }
+  async createAccountSession(id, options) {
+    return this.post(`/connected-accounts/${id}/account-session`, void 0, options);
+  }
+  // --------------------------------------------------------------------------
+  // Config
+  // --------------------------------------------------------------------------
+  async getPublishableKey(options) {
+    return this._get("/config/publishable-key", options);
+  }
+  // --------------------------------------------------------------------------
+  // Payments (Marketplace)
+  // --------------------------------------------------------------------------
+  async createPayment(data, options) {
+    return this.post("/payments", data, options);
+  }
+  async getPayment(id, options) {
+    return this._get(`/payments/${id}`, options);
+  }
+  async listPayments(params, options) {
+    return this._list("/payments", params, options);
+  }
+  // --------------------------------------------------------------------------
+  // Refunds
+  // --------------------------------------------------------------------------
+  async refundPayment(id, data, options) {
+    return this.post(`/payments/${id}/refund`, data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Payouts
+  // --------------------------------------------------------------------------
+  async getPayoutHistory(accountId, params, options) {
+    return this._list(`/connected-accounts/${accountId}/payouts`, params, options);
+  }
+  async getPayoutSchedule(accountId, options) {
+    return this._get(`/connected-accounts/${accountId}/payout-schedule`, options);
+  }
+  async setPayoutSchedule(accountId, data, options) {
+    return this.put(`/connected-accounts/${accountId}/payout-schedule`, data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Ledger
+  // --------------------------------------------------------------------------
+  async getTransactions(params, options) {
+    return this._list("/transactions", params, options);
+  }
+  async getTransactionSummary(params, options) {
+    return this._get(this.withQuery("/transactions/summary", params), options);
+  }
+  // --------------------------------------------------------------------------
+  // Setup Sessions
+  // --------------------------------------------------------------------------
+  async createSetupSession(data, options) {
+    return this.post("/setup-sessions", data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Connected Account Operations: Products, Prices, Subscriptions, Transfers
+  // --------------------------------------------------------------------------
+  async createProduct(data, options) {
+    return this.post("/products", data, options);
+  }
+  async createPrice(data, options) {
+    return this.post("/prices", data, options);
+  }
+  async deactivatePrice(id, options) {
+    return this.post(`/prices/${id}/deactivate`, void 0, options);
+  }
+  async createConnectedSubscription(data, options) {
+    return this.post("/connected-subscriptions", data, options);
+  }
+  async cancelConnectedSubscription(id, data, options) {
+    return this.post(`/connected-subscriptions/${id}/cancel`, data, options);
+  }
+  async listConnectedSubscriptions(params, options) {
+    return this._list("/connected-subscriptions", params, options);
+  }
+  async createConnectedSetupIntent(data, options) {
+    return this.post("/connected-setup-intents", data, options);
+  }
+  async createTransfer(data, options) {
+    return this.post("/transfers", data, options);
+  }
+  async syncPaymentStatus(id, options) {
+    return this.post(`/payments/${id}/sync`, void 0, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use subscribe() instead */
+  async createSubscription(data) {
+    return this.subscribe(data);
+  }
+  /** @deprecated Use listInvoices() instead */
+  async getInvoices(params) {
+    return this.listInvoices(params);
+  }
+};
+
+// src/services/analytics.ts
+var AnalyticsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/analytics";
+  }
+  // --------------------------------------------------------------------------
+  // Event Tracking (v2 — JetStream buffered)
+  // --------------------------------------------------------------------------
+  async track(event, properties, userId, options) {
+    return this.post("/v2/events", { event, properties, user_id: userId }, options);
+  }
+  async trackBatch(events, options) {
+    return this.post("/v2/events/batch", { events }, options);
+  }
+  async trackPageView(data, options) {
+    return this.post("/page-view", data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Identity
+  // --------------------------------------------------------------------------
+  async identify(userId, traits, anonymousId, options) {
+    return this.post("/identify", { user_id: userId, traits, anonymous_id: anonymousId }, options);
+  }
+  async alias(userId, anonymousId, options) {
+    return this.post("/alias", { user_id: userId, anonymous_id: anonymousId }, options);
+  }
+  // --------------------------------------------------------------------------
+  // Query & Aggregations
+  // --------------------------------------------------------------------------
+  async queryEvents(filters) {
+    return this._list("/events", filters);
+  }
+  async getAggregations(filters) {
+    return this._get(this.withQuery("/aggregations", filters));
+  }
+  async getTopEvents(filters) {
+    return this._get(this.withQuery("/top-events", filters));
+  }
+  async getActiveUsers() {
+    return this._get("/users/active");
+  }
+  // --------------------------------------------------------------------------
+  // Funnels
+  // --------------------------------------------------------------------------
+  async createFunnel(data) {
+    return this.post("/funnels", data);
+  }
+  async listFunnels() {
+    return this._get("/funnels");
+  }
+  async getFunnelConversions(id) {
+    return this._get(`/funnels/${id}/conversions`);
+  }
+  // --------------------------------------------------------------------------
+  // Custom Metrics
+  // --------------------------------------------------------------------------
+  async trackMetric(data, options) {
+    return this.post("/metrics", data, options);
+  }
+  async queryMetrics(filters) {
+    return this._get(this.withQuery("/metrics/query", filters));
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use queryEvents() instead */
+  async query(filters) {
+    return this._get(this.withQuery("/events", filters));
+  }
+};
+
+// src/services/communication.ts
+var CommunicationService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/communication";
+  }
+  // --------------------------------------------------------------------------
+  // Email
+  // --------------------------------------------------------------------------
+  async sendEmail(data, options) {
+    return this.post("/email/send", data, options);
+  }
+  async sendEmailTemplate(template, data, options) {
+    return this.post(`/email/templates/${template}/send`, data, options);
+  }
+  // --------------------------------------------------------------------------
+  // SMS
+  // --------------------------------------------------------------------------
+  async sendSms(data, options) {
+    return this.post("/sms/send", data, options);
+  }
+  async sendSmsTemplate(template, data, options) {
+    return this.post(`/sms/templates/${template}/send`, data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Push Notifications
+  // --------------------------------------------------------------------------
+  async sendPush(data, options) {
+    return this.post("/push/send", data, options);
+  }
+  async registerPushToken(data, options) {
+    return this.post("/push/register", data, options);
+  }
+  async unregisterPushToken(token, options) {
+    return this.del(`/push/tokens/${token}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Message Status
+  // --------------------------------------------------------------------------
+  async getMessageStatus(id, options) {
+    return this._get(`/messages/${id}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use sendSms() instead */
+  async sendSMS(data) {
+    return this.sendSms(data);
+  }
+  /** @deprecated Use sendPush() instead */
+  async sendPushNotification(data) {
+    return this.sendPush(data);
+  }
+};
+
+// src/services/scheduler.ts
+var SchedulerService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/scheduler";
+  }
+  // --------------------------------------------------------------------------
+  // Job CRUD
+  // --------------------------------------------------------------------------
+  async createJob(data, options) {
+    return this.post("/jobs", data, options);
+  }
+  async listJobs(params, requestOptions) {
+    return this._list("/jobs", params, requestOptions);
+  }
+  async getJob(id, options) {
+    return this._get(`/jobs/${id}`, options);
+  }
+  async updateJob(id, data, options) {
+    return this.patch(`/jobs/${id}`, data, options);
+  }
+  async deleteJob(id, options) {
+    return this.del(`/jobs/${id}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Job Control
+  // --------------------------------------------------------------------------
+  async pauseJob(id, options) {
+    return this.post(`/jobs/${id}/pause`, void 0, options);
+  }
+  async resumeJob(id, options) {
+    return this.post(`/jobs/${id}/resume`, void 0, options);
+  }
+  async runNow(id, options) {
+    return this.post(`/jobs/${id}/run-now`, void 0, options);
+  }
+  // --------------------------------------------------------------------------
+  // Execution History & Stats
+  // --------------------------------------------------------------------------
+  async getExecutions(jobId, params, requestOptions) {
+    return this._list(`/jobs/${jobId}/executions`, params, requestOptions);
+  }
+  async getStats(jobId, options) {
+    return this._get(`/jobs/${jobId}/stats`, options);
+  }
+};
+
+// src/services/permissions.ts
+function canPerform(matrix, resource, action) {
+  if (!matrix) return false;
+  const resourcePerms = matrix.permissions[resource];
+  if (!resourcePerms) return false;
+  return resourcePerms[action] === "allow";
+}
+function hasMinRoleLevel(matrix, minLevel) {
+  if (!matrix) return false;
+  if (matrix.roleLevel === void 0) return false;
+  return matrix.roleLevel >= minLevel;
+}
+var PermissionsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/permissions";
+  }
+  // --------------------------------------------------------------------------
+  // Roles
+  // --------------------------------------------------------------------------
+  async createRole(data, options) {
+    return this.post("/roles", data, options);
+  }
+  async listRoles(options) {
+    return this._get("/roles", options);
+  }
+  async assignPermissions(roleId, permissions, options) {
+    return this.post(`/roles/${roleId}/permissions`, { permissions }, options);
+  }
+  async assignRole(userId, roleId, options) {
+    return this.post(`/users/${userId}/roles`, { role_id: roleId }, options);
+  }
+  // --------------------------------------------------------------------------
+  // Permission Checks (unified — supports both member and user identity types)
+  // --------------------------------------------------------------------------
+  /** Check a single permission. Supports identity_type for unified model. */
+  async check(identityId, permission, options) {
+    const { identityType, resourceType, resourceId, ...reqOptions } = options || {};
+    return this.post("/check", {
+      identity_id: identityId,
+      identity_type: identityType || "user",
+      permission,
+      resource_type: resourceType,
+      resource_id: resourceId
+    }, reqOptions);
+  }
+  /** Batch check multiple permissions for an identity. */
+  async batchCheck(identityId, permissions, options) {
+    const { identityType, ...reqOptions } = options || {};
+    return this.post("/batch-check", {
+      identity_id: identityId,
+      identity_type: identityType || "user",
+      permissions
+    }, reqOptions);
+  }
+  /** Fetch the full permission matrix for an identity (single request, no N+1). */
+  async getMatrix(identityId, identityType = "user", options) {
+    const params = new URLSearchParams({ identity_id: identityId, identity_type: identityType });
+    return this._get(`/matrix?${params.toString()}`, options);
+  }
+  async getUserPermissions(userId, options) {
+    return this._get(`/users/${userId}/permissions`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Policies
+  // --------------------------------------------------------------------------
+  async createPolicy(data, options) {
+    return this.post("/policies", data, options);
+  }
+  async listPolicies(options) {
+    return this._get("/policies", options);
+  }
+  async evaluate(data, options) {
+    return this.post("/evaluate", data, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use assignPermissions() instead */
+  async assignPermission(roleId, permission) {
+    return this.assignPermissions(roleId, [permission]);
+  }
+  /** @deprecated Use check() instead */
+  async checkPermission(userId, permission) {
+    return this.check(userId, permission);
+  }
+};
+
+// src/services/teams.ts
+var TeamsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/teams";
+  }
+  // --------------------------------------------------------------------------
+  // Team CRUD
+  // --------------------------------------------------------------------------
+  async create(data, options) {
+    return this.post("", data, options);
+  }
+  async list(params, requestOptions) {
+    return this._list("", params, requestOptions);
+  }
+  async get(id, options) {
+    return this._get(`/${id}`, options);
+  }
+  async update(id, data, options) {
+    return this.patch(`/${id}`, data, options);
+  }
+  async delete(id, options) {
+    return this.del(`/${id}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Members
+  // --------------------------------------------------------------------------
+  async listMembers(teamId, params, requestOptions) {
+    return this._list(`/${teamId}/members`, params, requestOptions);
+  }
+  async addMember(teamId, data, options) {
+    return this.post(`/${teamId}/members`, data, options);
+  }
+  async updateMember(teamId, userId, data, options) {
+    return this.patch(`/${teamId}/members/${userId}`, data, options);
+  }
+  async removeMember(teamId, userId, options) {
+    return this.del(`/${teamId}/members/${userId}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Invitations
+  // --------------------------------------------------------------------------
+  async invite(teamId, data, options) {
+    return this.post(`/${teamId}/invitations`, data, options);
+  }
+  async listInvitations(teamId, options) {
+    return this._get(`/${teamId}/invitations`, options);
+  }
+  async acceptInvitation(token, options) {
+    return this.post(`/invitations/${token}/accept`, void 0, options);
+  }
+  async cancelInvitation(id, options) {
+    return this.del(`/invitations/${id}`, options);
+  }
+  // --------------------------------------------------------------------------
+  // SSO
+  // --------------------------------------------------------------------------
+  async configureSso(teamId, data, options) {
+    return this.post(`/${teamId}/sso/configure`, data, options);
+  }
+  async getSso(teamId, options) {
+    return this._get(`/${teamId}/sso`, options);
+  }
+  // --------------------------------------------------------------------------
+  // Legacy methods (backward compat)
+  // --------------------------------------------------------------------------
+  /** @deprecated Use create() instead */
+  async createTeam(data) {
+    return this.create(data);
+  }
+  /** @deprecated Use invite() instead */
+  async inviteMember(teamId, email, role) {
+    return this.invite(teamId, { email, role });
+  }
+};
+
+// src/services/graph.ts
+var GraphService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/graph";
+  }
+  async createNode(data, requestOptions) {
+    return this.post("/nodes", data, requestOptions);
+  }
+  async updateNode(nodeId, data, requestOptions) {
+    return this.patch(`/nodes/${nodeId}`, data, requestOptions);
+  }
+  async createEdge(data, requestOptions) {
+    return this.post("/edges", data, requestOptions);
+  }
+  async getEdges(nodeId, options, requestOptions) {
+    return this._get(this.withQuery(`/nodes/${nodeId}/edges`, options), requestOptions);
+  }
+  async traverse(nodeId, options, requestOptions) {
+    return this._get(this.withQuery(`/nodes/${nodeId}/traverse`, options), requestOptions);
+  }
+  async shortestPath(options, requestOptions) {
+    return this.post("/shortest-path", options, requestOptions);
+  }
+  async neighbors(nodeId, options, requestOptions) {
+    return this._get(this.withQuery(`/nodes/${nodeId}/neighbors`, options), requestOptions);
+  }
+  async pageRank(options, requestOptions) {
+    return this.post("/algorithms/pagerank", options, requestOptions);
+  }
+  async centrality(options, requestOptions) {
+    return this.post("/algorithms/centrality", options, requestOptions);
+  }
+  async connectedComponents(options) {
+    return this.post("/algorithms/connected-components", void 0, options);
+  }
+};
+
+// src/services/functions.ts
+var FunctionsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/functions";
+  }
+  async deploy(data, options) {
+    return this.post("", data, options);
+  }
+  async list(options) {
+    return this._get("", options);
+  }
+  async get(name, options) {
+    return this._get(`/${name}`, options);
+  }
+  async update(name, data, options) {
+    return this.patch(`/${name}`, data, options);
+  }
+  async delete(name, options) {
+    return this.del(`/${name}`, options);
+  }
+  async invoke(name, payload, options) {
+    return this.post(`/${name}/invoke`, payload, options);
+  }
+  async invokeAsync(name, payload, options) {
+    return this.post(`/${name}/invoke-async`, payload, options);
+  }
+  async getLogs(name, options) {
+    return this._get(`/${name}/logs`, options);
+  }
+  async getExecutions(name, params, requestOptions) {
+    return this._list(`/${name}/executions`, params, requestOptions);
+  }
+  async getMetrics(name, options) {
+    return this._get(`/${name}/metrics`, options);
+  }
+  /** @deprecated Use deploy() instead */
+  async deployFunction(data) {
+    return this.deploy(data);
+  }
+  /** @deprecated Use invoke() instead */
+  async invokeFunction(name, payload) {
+    return this.invoke(name, payload);
+  }
+};
+
+// src/services/listings.ts
+var ListingsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/listings";
+  }
+  async create(data, options) {
+    return this.post("", data, options);
+  }
+  async get(id, options) {
+    return this._get(`/${id}`, options);
+  }
+  async update(id, data, options) {
+    return this.patch(`/${id}`, data, options);
+  }
+  async delete(id, options) {
+    return this.del(`/${id}`, options);
+  }
+  async search(query, filters, options) {
+    return this._get(this.withQuery("/search", { query, ...filters }), options);
+  }
+  async nearby(nearbyOptions, options) {
+    return this._get(this.withQuery("/nearby", nearbyOptions), options);
+  }
+  async getByCategory(category, params, requestOptions) {
+    return this._list(`/categories/${category}`, params, requestOptions);
+  }
+  async favorite(listingId, options) {
+    return this.post(`/${listingId}/favorite`, void 0, options);
+  }
+  async unfavorite(listingId, options) {
+    return this.del(`/${listingId}/favorite`, options);
+  }
+  async getFavorites(params, requestOptions) {
+    return this._list("/favorites", params, requestOptions);
+  }
+  async trackView(listingId, options) {
+    return this.post(`/${listingId}/view`, void 0, options);
+  }
+  /** @deprecated Use create() instead */
+  async createListing(data) {
+    return this.create(data);
+  }
+  /** @deprecated Use search() instead */
+  async searchListings(query, filters) {
+    return this.search(query, filters);
+  }
+  /** @deprecated Use get() instead */
+  async getListing(id) {
+    return this.get(id);
+  }
+};
+
+// src/services/events.ts
+var EventsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/events";
+  }
+  async create(data, options) {
+    return this.post("", data, options);
+  }
+  async get(eventId, options) {
+    return this._get(`/${eventId}`, options);
+  }
+  async update(eventId, data, options) {
+    return this.patch(`/${eventId}`, data, options);
+  }
+  async delete(eventId, options) {
+    return this.del(`/${eventId}`, options);
+  }
+  async list(filters, requestOptions) {
+    return this._list("", filters, requestOptions);
+  }
+  async register(eventId, options) {
+    return this.post(`/${eventId}/register`, void 0, options);
+  }
+  async unregister(eventId, options) {
+    return this.del(`/${eventId}/register`, options);
+  }
+  async getAttendees(eventId, params, requestOptions) {
+    return this._list(`/${eventId}/attendees`, params, requestOptions);
+  }
+  async checkIn(eventId, options) {
+    return this.post(`/${eventId}/check-in`, void 0, options);
+  }
+  /** @deprecated Use create() instead */
+  async createEvent(data) {
+    return this.create(data);
+  }
+  /** @deprecated Use list() instead */
+  async listEvents(filters) {
+    return this.list(filters);
+  }
+};
+
+// src/services/leaderboard.ts
+var LeaderboardService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/leaderboard";
+  }
+  async create(data, options) {
+    return this.post("", data, options);
+  }
+  async submitScore(boardId, data, options) {
+    return this.post(`/${boardId}/scores`, data, options);
+  }
+  async getRankings(boardId, rankingOptions, requestOptions) {
+    return this._get(this.withQuery(`/${boardId}/rankings`, rankingOptions), requestOptions);
+  }
+  async getUserRank(boardId, userId, options) {
+    return this._get(`/${boardId}/users/${userId}/rank`, options);
+  }
+  async getUserHistory(boardId, userId, options) {
+    return this._get(`/${boardId}/users/${userId}/history`, options);
+  }
+  async updateScore(boardId, userId, data, options) {
+    return this.patch(`/${boardId}/users/${userId}/score`, data, options);
+  }
+  async deleteScore(boardId, userId, options) {
+    return this.del(`/${boardId}/users/${userId}/score`, options);
+  }
+};
+
+// src/services/webhooks.ts
+var WebhooksService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/webhooks";
+  }
+  async create(data, options) {
+    return this.post("", data, options);
+  }
+  async list(options) {
+    return this._get("", options);
+  }
+  async get(id, options) {
+    return this._get(`/${id}`, options);
+  }
+  async update(id, data, options) {
+    return this.patch(`/${id}`, data, options);
+  }
+  async delete(id, options) {
+    return this.del(`/${id}`, options);
+  }
+  async listEvents(options) {
+    return this._get("/events", options);
+  }
+  /** @deprecated Use create() instead */
+  async createWebhook(data) {
+    return this.create(data);
+  }
+  /** @deprecated Use list() instead */
+  async listWebhooks() {
+    return this.list();
+  }
+  /** @deprecated Use delete() instead */
+  async deleteWebhook(id) {
+    return this.delete(id);
+  }
+};
+
+// src/services/search.ts
+var SearchService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/search";
+  }
+  async query(queryStr, queryOptions, requestOptions) {
+    return this.post("", { query: queryStr, ...queryOptions }, requestOptions);
+  }
+  async index(indexName, document, options) {
+    return this.post("/documents", { index: indexName, ...document }, options);
+  }
+  async removeDocument(indexName, docId, options) {
+    return this.del(`/documents/${indexName}/${docId}`, options);
+  }
+  /** @deprecated Use query() instead */
+  async search(queryStr, options) {
+    return this.query(queryStr, options);
+  }
+  /** @deprecated Use index() instead */
+  async indexDocument(data) {
+    return this.post("/documents", data);
+  }
+};
+
+// src/services/photo.ts
+var PHOTO_BREAKPOINTS = [150, 320, 640, 1080];
+var PhotoService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/photos";
+  }
+  async upload(file, uploadOptions, requestOptions) {
+    const fields = {};
+    if (uploadOptions?.metadata) fields["metadata"] = JSON.stringify(uploadOptions.metadata);
+    return this._upload("", file, fields, {
+      ...requestOptions,
+      onProgress: uploadOptions?.onProgress,
+      signal: uploadOptions?.signal
+    });
+  }
+  async transform(photoId, transformations, options) {
+    return this.post(`/${photoId}/transform`, transformations, options);
+  }
+  async get(id, options) {
+    return this._get(`/${id}`, options);
+  }
+  async delete(id, options) {
+    return this.del(`/${id}`, options);
+  }
+  /**
+   * Build an absolute URL for the on-demand transform endpoint.
+   *
+   * Use in `<img src>` or `srcset` — the server negotiates the best format
+   * (AVIF > WebP > JPEG) from the browser's Accept header automatically.
+   * Transformed images are cached server-side on first request.
+   */
+  getTransformUrl(photoId, options) {
+    const params = new URLSearchParams();
+    if (options?.width) params.set("width", String(options.width));
+    if (options?.height) params.set("height", String(options.height));
+    if (options?.fit) params.set("fit", options.fit);
+    if (options?.format) params.set("format", options.format);
+    if (options?.quality) params.set("quality", String(options.quality));
+    const qs = params.toString();
+    return `${this.client.getBaseUrl()}${this.basePath}/${photoId}/transform${qs ? `?${qs}` : ""}`;
+  }
+  /**
+   * Get a transform URL optimized for the given display area.
+   *
+   * Snaps UP to the nearest pre-generated square breakpoint (150, 320, 640, 1080)
+   * so the response is served instantly from cache. Format is auto-negotiated
+   * by the browser's Accept header (WebP in modern browsers, JPEG fallback).
+   *
+   * @param photoId  Photo ID
+   * @param displayWidth  CSS pixel width of the display area
+   * @param options.dpr  Device pixel ratio (default: 1). Pass `window.devicePixelRatio` in browsers.
+   *
+   * @example
+   * ```typescript
+   * // 280px card on 2x Retina -> snaps to 640px (280×2=560, next breakpoint up)
+   * const url = sm.photo.getOptimalUrl(photoId, 280, { dpr: 2 })
+   *
+   * // Profile avatar at 48px -> snaps to 150px
+   * const url = sm.photo.getOptimalUrl(photoId, 48)
+   * ```
+  */
+  getOptimalUrl(photoId, displayWidth, options) {
+    const requestedDpr = options?.dpr ?? 1;
+    const dpr = Number.isFinite(requestedDpr) && requestedDpr > 0 ? requestedDpr : 1;
+    const cssWidth = Number.isFinite(displayWidth) && displayWidth > 0 ? displayWidth : PHOTO_BREAKPOINTS[0];
+    const physicalWidth = Math.ceil(cssWidth * dpr);
+    const size = PHOTO_BREAKPOINTS.find((bp) => bp >= physicalWidth) ?? PHOTO_BREAKPOINTS[PHOTO_BREAKPOINTS.length - 1];
+    return this.getTransformUrl(photoId, { width: size, height: size, fit: "cover" });
+  }
+  /**
+   * Generate an HTML srcset string for responsive square photo display.
+   *
+   * Returns all pre-generated breakpoints as width descriptors. Pair with
+   * the `sizes` attribute so the browser picks the optimal variant automatically.
+   *
+   * @example
+   * ```tsx
+   * const srcset = sm.photo.getSrcSet(photoId)
+   * // -> ".../transform?width=150&height=150&fit=cover 150w, .../transform?width=320..."
+   *
+   * <img
+   *   src={sm.photo.getOptimalUrl(photoId, 320)}
+   *   srcSet={srcset}
+   *   sizes="(max-width: 640px) 100vw, 640px"
+   *   alt="Photo"
+   * />
+   * ```
+   */
+  getSrcSet(photoId) {
+    return PHOTO_BREAKPOINTS.map((size) => `${this.getTransformUrl(photoId, { width: size, height: size, fit: "cover" })} ${size}w`).join(", ");
+  }
+  /**
+   * Register a photo from an already-uploaded storage file.
+   *
+   * Creates a photo record so the optimization pipeline can process it.
+   * Use this when files are uploaded via the storage service (presigned URL)
+   * instead of the photo service's upload endpoint.
+   *
+   * Returns the photo record with `id` that can be used with `getTransformUrl()`.
+   */
+  async register(registerOptions, requestOptions) {
+    return this.post("/register", {
+      file_id: registerOptions.fileId,
+      sm_user_id: registerOptions.userId
+    }, requestOptions);
+  }
+  /** @deprecated Use upload() instead */
+  async uploadPhoto(file, options) {
+    return this.upload(file, options);
+  }
+  /** @deprecated Use transform() instead */
+  async transformPhoto(photoId, transformations) {
+    return this.transform(photoId, transformations);
+  }
+  /** @deprecated Use get() instead */
+  async getPhoto(id) {
+    return this.get(id);
+  }
+};
+
+// src/services/queue.ts
+var DeadLetterApi = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/queue/dead-letter";
+  }
+  async list(options) {
+    return this._get("", options);
+  }
+  async get(id, options) {
+    return this._get(`/${id}`, options);
+  }
+  async retry(id, options) {
+    return this.post(`/${id}/retry`, void 0, options);
+  }
+  async delete(id, options) {
+    return this.del(`/${id}`, options);
+  }
+};
+var QueueService = class extends ServiceModule {
+  constructor(client) {
+    super(client);
+    this.basePath = "/v1/queue";
+    this.deadLetter = new DeadLetterApi(client);
+  }
+  async enqueue(data, options) {
+    return this.post("/jobs", data, options);
+  }
+  async getJob(id, options) {
+    return this._get(`/jobs/${id}`, options);
+  }
+};
+
+// src/services/cache.ts
+var CacheService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/cache";
+  }
+  async get(key, options) {
+    return this._get(`/${key}`, options);
+  }
+  async set(key, value, ttl, options) {
+    return this.post("", { key, value, ttl }, options);
+  }
+  async delete(key, options) {
+    return this.del(`/${key}`, options);
+  }
+  async flush(options) {
+    return this.del("", options);
+  }
+};
+
+// src/services/compliance.ts
+var ComplianceService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/compliance";
+  }
+  /** Build query string from params object */
+  qs(params) {
+    if (!params) return "";
+    const entries = Object.entries(params).filter(([, v]) => v !== void 0 && v !== null);
+    if (entries.length === 0) return "";
+    return "?" + entries.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+  }
+  // --- Audit Logs ---
+  async log(data, options) {
+    return this.post("/audit-logs", data, options);
+  }
+  async queryAuditLogs(params, requestOptions) {
+    return this._get(`/audit-logs${this.qs(params)}`, requestOptions);
+  }
+  // --- Legacy GDPR (deprecated) ---
+  /** @deprecated Use createDataSubjectRequest({ request_type: 'access', ... }) instead */
+  async requestDataExport(userId) {
+    return this.post("/gdpr/access-request", { user_id: userId });
+  }
+  /** @deprecated Use createDataSubjectRequest({ request_type: 'deletion', ... }) instead */
+  async requestDataDeletion(userId) {
+    return this.post("/gdpr/deletion-request", { user_id: userId });
+  }
+  /** @deprecated Use log() instead */
+  async createAuditLog(data) {
+    return this.log(data);
+  }
+  // --- Consent Purposes ---
+  async listConsentPurposes(options) {
+    return this._get("/consent-purposes", options);
+  }
+  async createConsentPurpose(data, options) {
+    return this.post("/consent-purposes", data, options);
+  }
+  // --- Consent v2 ---
+  async recordConsent(data, options) {
+    return this.post("/consent/v2", data, options);
+  }
+  async getUserConsents(userId, options) {
+    return this._get(`/consent/v2/${userId}`, options);
+  }
+  async withdrawConsent(consentId, data, options) {
+    return this.put(`/consent/v2/${consentId}/withdraw`, data || {}, options);
+  }
+  // --- Data Subject Requests ---
+  async createDataSubjectRequest(data, options) {
+    return this.post("/dsr", data, options);
+  }
+  async listDataSubjectRequests(params, requestOptions) {
+    return this._get(`/dsr${this.qs(params)}`, requestOptions);
+  }
+  async getDataSubjectRequest(id, options) {
+    return this._get(`/dsr/${id}`, options);
+  }
+  async updateDsrStatus(id, data, options) {
+    return this.put(`/dsr/${id}/status`, data, options);
+  }
+  async createDsrAction(dsrId, data, options) {
+    return this.post(`/dsr/${dsrId}/actions`, data, options);
+  }
+  async listDsrActions(dsrId, options) {
+    return this._get(`/dsr/${dsrId}/actions`, options);
+  }
+  // --- Data Breaches ---
+  async reportBreach(data, options) {
+    return this.post("/breaches", data, options);
+  }
+  async listBreaches(params, requestOptions) {
+    return this._get(`/breaches${this.qs(params)}`, requestOptions);
+  }
+  async getBreach(id, options) {
+    return this._get(`/breaches/${id}`, options);
+  }
+  async updateBreach(id, data, options) {
+    return this.put(`/breaches/${id}`, data, options);
+  }
+  // --- Retention Policies ---
+  async listRetentionPolicies(options) {
+    return this._get("/retention/policies", options);
+  }
+  async createRetentionPolicy(data, options) {
+    return this.post("/retention/policies", data, options);
+  }
+  // --- Processing Activities ---
+  async createProcessingActivity(data, options) {
+    return this.post("/processing-activities", data, options);
+  }
+  async listProcessingActivities(params, requestOptions) {
+    return this._get(`/processing-activities${this.qs(params)}`, requestOptions);
+  }
+  async getProcessingActivity(id, options) {
+    return this._get(`/processing-activities/${id}`, options);
+  }
+  async updateProcessingActivity(id, data, options) {
+    return this.put(`/processing-activities/${id}`, data, options);
+  }
+};
+
+// src/services/orchestrator.ts
+var OrchestratorService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/orchestrator";
+  }
+  async createWorkflow(data, options) {
+    return this.post("/workflows", data, options);
+  }
+  async execute(workflowId, input, options) {
+    return this.post(`/workflows/${workflowId}/execute`, input, options);
+  }
+  async getExecution(executionId, options) {
+    return this._get(`/executions/${executionId}`, options);
+  }
+  /** @deprecated Use execute() instead */
+  async executeWorkflow(workflowId, input) {
+    return this.execute(workflowId, input);
+  }
+};
+
+// src/services/accounts.ts
+var AccountsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/accounts";
+  }
+  async createClient(data, options) {
+    return this.post("/clients", data, options);
+  }
+  async getClients(options) {
+    return this._get("/clients", options);
+  }
+  async createApplication(data, options) {
+    return this.post("/applications", data, options);
+  }
+  async getApplications(options) {
+    return this._get("/applications", options);
+  }
+};
+
+// src/services/identity.ts
+var IdentityService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/identity";
+  }
+  async createApiKey(data, options) {
+    return this.post("/api-keys", data, options);
+  }
+  async listApiKeys(options) {
+    return this._get("/api-keys", options);
+  }
+  async revokeApiKey(id, options) {
+    return this.del(`/api-keys/${id}`, options);
+  }
+};
+
+// src/services/catalog.ts
+var CatalogService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/catalog";
+  }
+  async listServices(options) {
+    return this._get("/services", options);
+  }
+  async getServiceHealth(name, options) {
+    return this._get(`/services/${name}/health`, options);
+  }
+};
+
+// src/services/flagcontent.ts
+var FlagContentService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/flagcontent";
+  }
+  async createFlag(data, options) {
+    return this.post("/flags", data, options);
+  }
+  async checkFlag(params, requestOptions) {
+    return this._get(this.withQuery("/flags/check", params), requestOptions);
+  }
+  async getFlag(id, options) {
+    return this._get(`/flags/${id}`, options);
+  }
+  async submitAppeal(data, options) {
+    return this.post("/appeals", data, options);
+  }
+  async getAppeal(id, options) {
+    return this._get(`/appeals/${id}`, options);
+  }
+};
+
+// src/index.ts
+var ScaleMule = class {
+  constructor(config) {
+    this._client = new ScaleMuleClient(config);
+    this.auth = new AuthService(this._client);
+    this.storage = new StorageService(this._client);
+    this.realtime = new RealtimeService(this._client);
+    this.video = new VideoService(this._client);
+    this.data = new DataService(this._client);
+    this.chat = new ChatService(this._client);
+    this.social = new SocialService(this._client);
+    this.billing = new BillingService(this._client);
+    this.analytics = new AnalyticsService(this._client);
+    this.communication = new CommunicationService(this._client);
+    this.scheduler = new SchedulerService(this._client);
+    this.permissions = new PermissionsService(this._client);
+    this.teams = new TeamsService(this._client);
+    this.accounts = new AccountsService(this._client);
+    this.identity = new IdentityService(this._client);
+    this.catalog = new CatalogService(this._client);
+    this.cache = new CacheService(this._client);
+    this.queue = new QueueService(this._client);
+    this.search = new SearchService(this._client);
+    this.logger = new LoggerService(this._client);
+    this.webhooks = new WebhooksService(this._client);
+    this.leaderboard = new LeaderboardService(this._client);
+    this.listings = new ListingsService(this._client);
+    this.events = new EventsService(this._client);
+    this.graph = new GraphService(this._client);
+    this.functions = new FunctionsService(this._client);
+    this.photo = new PhotoService(this._client);
+    this.flagContent = new FlagContentService(this._client);
+    this.compliance = new ComplianceService(this._client);
+    this.orchestrator = new OrchestratorService(this._client);
+  }
+  /**
+   * Initialize the client — loads persisted session from storage.
+   * Call this once after construction, before making authenticated requests.
+   */
+  async initialize() {
+    return this._client.initialize();
+  }
+  /**
+   * Set authentication session (token + userId).
+   * Persisted to storage for cross-session continuity.
+   */
+  async setSession(token, userId) {
+    return this._client.setSession(token, userId);
+  }
+  /** Clear the current session and remove from storage. */
+  async clearSession() {
+    return this._client.clearSession();
+  }
+  /** Set access token (in-memory only, not persisted). */
+  setAccessToken(token) {
+    this._client.setAccessToken(token);
+  }
+  /** Clear access token. */
+  clearAccessToken() {
+    this._client.clearAccessToken();
+  }
+  /** Current session token, or null. */
+  getSessionToken() {
+    return this._client.getSessionToken();
+  }
+  /** Current user ID, or null. */
+  getUserId() {
+    return this._client.getUserId();
+  }
+  /** Whether a session token is set. */
+  isAuthenticated() {
+    return this._client.isAuthenticated();
+  }
+  /** The base URL being used for API requests. */
+  getBaseUrl() {
+    return this._client.getBaseUrl();
+  }
+  /** Access the underlying ScaleMuleClient for advanced usage. */
+  getClient() {
+    return this._client;
+  }
+};
+var index_default = ScaleMule;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountsService,
+  AnalyticsService,
+  AuthService,
+  BillingService,
+  CacheService,
+  CatalogService,
+  ChatService,
+  CommunicationService,
+  ComplianceService,
+  DataService,
+  ErrorCodes,
+  EventsService,
+  FlagContentService,
+  FunctionsService,
+  GraphService,
+  IdentityService,
+  LeaderboardService,
+  ListingsService,
+  LoggerService,
+  OrchestratorService,
+  PHONE_COUNTRIES,
+  PHOTO_BREAKPOINTS,
+  PermissionsService,
+  PhotoService,
+  QueueService,
+  RealtimeService,
+  ScaleMule,
+  ScaleMuleClient,
+  SchedulerService,
+  SearchService,
+  ServiceModule,
+  SocialService,
+  StorageService,
+  TeamsService,
+  UploadResumeStore,
+  UploadTelemetry,
+  VideoService,
+  WebhooksService,
+  buildClientContextHeaders,
+  calculateTotalParts,
+  canPerform,
+  composePhoneNumber,
+  countryFlag,
+  createUploadPlan,
+  detectCountryFromE164,
+  detectNetworkClass,
+  extractClientContext,
+  findPhoneCountryByCode,
+  findPhoneCountryByDialCode,
+  generateUploadSessionId,
+  getMeasuredBandwidthMbps,
+  getPartRange,
+  hasMinRoleLevel,
+  isValidE164Phone,
+  normalizeAndValidatePhone,
+  normalizePhoneNumber,
+  resolveStrategy,
+  validateIP
+});