connectbase-client 0.1.0

package/dist/index.js

@@ -0,0 +1,4577 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  AuthError: () => AuthError,
+  ConnectBase: () => ConnectBase,
+  GameAPI: () => GameAPI,
+  GameRoom: () => GameRoom,
+  GameRoomTransport: () => GameRoomTransport,
+  VideoProcessingError: () => VideoProcessingError,
+  default: () => index_default,
+  isWebTransportSupported: () => isWebTransportSupported
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/error.ts
+var ApiError = class extends Error {
+  constructor(statusCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+
+// src/core/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.config = config;
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setTokens(accessToken, refreshToken) {
+    this.config.accessToken = accessToken;
+    this.config.refreshToken = refreshToken;
+  }
+  clearTokens() {
+    this.config.accessToken = void 0;
+    this.config.refreshToken = void 0;
+  }
+  /**
+   * API Key가 설정되어 있는지 확인
+   */
+  hasApiKey() {
+    return !!this.config.apiKey;
+  }
+  /**
+   * API Key 반환
+   */
+  getApiKey() {
+    return this.config.apiKey;
+  }
+  /**
+   * Access Token 반환
+   */
+  getAccessToken() {
+    return this.config.accessToken;
+  }
+  /**
+   * Base URL 반환
+   */
+  getBaseUrl() {
+    return this.config.baseUrl;
+  }
+  async refreshAccessToken() {
+    if (this.isRefreshing) {
+      return this.refreshPromise;
+    }
+    this.isRefreshing = true;
+    if (!this.config.refreshToken) {
+      this.isRefreshing = false;
+      const error = new AuthError("Refresh token is missing. Please login again.");
+      this.config.onAuthError?.(error);
+      throw error;
+    }
+    this.refreshPromise = (async () => {
+      try {
+        const response = await fetch(`${this.config.baseUrl}/v1/auth/re-issue`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.config.refreshToken}`
+          }
+        });
+        if (!response.ok) {
+          throw new Error("Token refresh failed");
+        }
+        const data = await response.json();
+        this.config.accessToken = data.access_token;
+        this.config.refreshToken = data.refresh_token;
+        this.config.onTokenRefresh?.({
+          accessToken: data.access_token,
+          refreshToken: data.refresh_token
+        });
+        return data.access_token;
+      } catch {
+        this.clearTokens();
+        const error = new AuthError("Token refresh failed. Please login again.");
+        this.config.onAuthError?.(error);
+        throw error;
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  isTokenExpired(token) {
+    try {
+      const payload = JSON.parse(atob(token.split(".")[1]));
+      const currentTime = Date.now() / 1e3;
+      return payload.exp < currentTime + 300;
+    } catch {
+      return true;
+    }
+  }
+  async prepareHeaders(config) {
+    const headers = new Headers();
+    headers.set("Content-Type", "application/json");
+    if (this.config.apiKey) {
+      headers.set("X-API-Key", this.config.apiKey);
+    }
+    if (!config?.skipAuth && this.config.accessToken) {
+      let token = this.config.accessToken;
+      if (this.isTokenExpired(token) && this.config.refreshToken) {
+        const newToken = await this.refreshAccessToken();
+        if (newToken) {
+          token = newToken;
+        }
+      }
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    if (config?.headers) {
+      Object.entries(config.headers).forEach(([key, value]) => {
+        headers.set(key, value);
+      });
+    }
+    return headers;
+  }
+  async handleResponse(response) {
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({
+        message: response.statusText
+      }));
+      throw new ApiError(response.status, errorData.message || errorData.error || "Unknown error");
+    }
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
+      return {};
+    }
+    return response.json();
+  }
+  async get(url, config) {
+    const headers = await this.prepareHeaders(config);
+    const response = await fetch(`${this.config.baseUrl}${url}`, {
+      method: "GET",
+      headers
+    });
+    return this.handleResponse(response);
+  }
+  async post(url, data, config) {
+    const headers = await this.prepareHeaders(config);
+    if (data instanceof FormData) {
+      headers.delete("Content-Type");
+    }
+    const response = await fetch(`${this.config.baseUrl}${url}`, {
+      method: "POST",
+      headers,
+      body: data instanceof FormData ? data : JSON.stringify(data)
+    });
+    return this.handleResponse(response);
+  }
+  async put(url, data, config) {
+    const headers = await this.prepareHeaders(config);
+    const response = await fetch(`${this.config.baseUrl}${url}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(data)
+    });
+    return this.handleResponse(response);
+  }
+  async patch(url, data, config) {
+    const headers = await this.prepareHeaders(config);
+    const response = await fetch(`${this.config.baseUrl}${url}`, {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(data)
+    });
+    return this.handleResponse(response);
+  }
+  async delete(url, config) {
+    const headers = await this.prepareHeaders(config);
+    const response = await fetch(`${this.config.baseUrl}${url}`, {
+      method: "DELETE",
+      headers
+    });
+    return this.handleResponse(response);
+  }
+};
+
+// src/api/auth.ts
+var ANONYMOUS_UID_KEY_PREFIX = "cb_anon_";
+var GUEST_MEMBER_TOKEN_KEY_PREFIX = "cb_guest_";
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+var AuthAPI = class {
+  constructor(http) {
+    this.http = http;
+    this.anonymousLoginPromise = null;
+    this.guestMemberLoginPromise = null;
+    this.cachedAnonymousUIDKey = null;
+    this.cachedGuestMemberTokenKey = null;
+  }
+  /**
+   * 앱의 인증 설정 조회
+   * 어떤 로그인 방식이 허용되는지 확인합니다.
+   *
+   * @example
+   * ```typescript
+   * const settings = await client.auth.getAuthSettings()
+   * if (settings.allow_guest_login) {
+   *     await client.auth.signInAsGuestMember()
+   * } else if (settings.allow_id_password_login) {
+   *     // 로그인 폼 표시
+   * } else if (settings.enabled_oauth_providers.includes('GOOGLE')) {
+   *     // 구글 소셜 로그인 버튼 표시
+   * }
+   * ```
+   */
+  async getAuthSettings() {
+    return this.http.get(
+      "/v1/public/auth-settings",
+      { skipAuth: true }
+    );
+  }
+  /**
+   * 현재 앱의 anonymous_uid 스토리지 키 생성
+   * apiKey를 해시하여 앱별 고유 키 생성 (원본 apiKey 노출 방지)
+   * 성능 최적화: 키를 캐싱하여 반복 해시 계산 방지
+   */
+  getAnonymousUIDKey() {
+    if (this.cachedAnonymousUIDKey) {
+      return this.cachedAnonymousUIDKey;
+    }
+    const apiKey = this.http.getApiKey();
+    if (!apiKey) {
+      this.cachedAnonymousUIDKey = `${ANONYMOUS_UID_KEY_PREFIX}default`;
+    } else {
+      const keyHash = simpleHash(apiKey);
+      this.cachedAnonymousUIDKey = `${ANONYMOUS_UID_KEY_PREFIX}${keyHash}`;
+    }
+    return this.cachedAnonymousUIDKey;
+  }
+  /**
+   * 회원가입
+   */
+  async signUp(data) {
+    const response = await this.http.post(
+      "/v1/auth/signup",
+      data,
+      { skipAuth: true }
+    );
+    this.http.setTokens(response.access_token, response.refresh_token);
+    return response;
+  }
+  /**
+   * 로그인
+   */
+  async signIn(data) {
+    const response = await this.http.post(
+      "/v1/auth/signin",
+      data,
+      { skipAuth: true }
+    );
+    this.http.setTokens(response.access_token, response.refresh_token);
+    return response;
+  }
+  /**
+   * 익명 로그인
+   * 계정 없이 게스트로 앱을 사용할 수 있습니다.
+   * 로컬 스토리지에 저장된 anonymous_uid가 있으면 기존 계정으로 재로그인을 시도합니다.
+   * 동시 호출 시 중복 요청 방지 (race condition 방지)
+   */
+  async signInAnonymously() {
+    if (this.anonymousLoginPromise) {
+      return this.anonymousLoginPromise;
+    }
+    this.anonymousLoginPromise = this.executeAnonymousLogin();
+    try {
+      return await this.anonymousLoginPromise;
+    } finally {
+      this.anonymousLoginPromise = null;
+    }
+  }
+  /**
+   * 실제 익명 로그인 실행 (내부 메서드)
+   */
+  async executeAnonymousLogin() {
+    const storedAnonymousUID = this.getStoredAnonymousUID();
+    const response = await this.http.post(
+      "/v1/auth/signin/anonymous",
+      storedAnonymousUID ? { anonymous_uid: storedAnonymousUID } : {},
+      { skipAuth: true }
+    );
+    this.http.setTokens(response.access_token, response.refresh_token);
+    if (response.anonymous_uid) {
+      this.storeAnonymousUID(response.anonymous_uid);
+    }
+    return response;
+  }
+  /**
+   * 저장된 anonymous_uid 조회
+   */
+  getStoredAnonymousUID() {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage.getItem(this.getAnonymousUIDKey());
+  }
+  /**
+   * anonymous_uid 저장
+   */
+  storeAnonymousUID(uid) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(this.getAnonymousUIDKey(), uid);
+  }
+  /**
+   * 저장된 anonymous_uid 삭제
+   */
+  clearAnonymousUID() {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(this.getAnonymousUIDKey());
+  }
+  /**
+   * 로그아웃
+   */
+  async signOut() {
+    try {
+      await this.http.post("/v1/auth/logout");
+    } finally {
+      this.http.clearTokens();
+    }
+  }
+  /**
+   * 현재 사용자 정보 조회
+   * 토큰이 없거나 유효하지 않으면 자동으로 익명 계정을 생성합니다.
+   * @param autoAnonymous - 자동 익명 로그인 활성화 (기본값: false, 명시적으로 활성화 필요)
+   */
+  async getCurrentUser(autoAnonymous = false) {
+    try {
+      return await this.http.get("/v1/auth");
+    } catch (error) {
+      const isAuthError = error instanceof ApiError && (error.statusCode === 401 || error.statusCode === 403) || error instanceof AuthError;
+      if (autoAnonymous && isAuthError) {
+        await this.signInAnonymously();
+        const userInfo = await this.http.get("/v1/auth");
+        return { ...userInfo, is_anonymous: true };
+      }
+      throw error;
+    }
+  }
+  /**
+   * 이메일 인증 메일 재발송
+   */
+  async resendVerificationEmail() {
+    await this.http.post("/v1/auth/re-send-activate-email");
+  }
+  /**
+   * 앱 멤버 게스트 가입
+   * API Key로 인증된 앱에 게스트 멤버로 가입합니다.
+   * 실시간 채팅 등에서 JWT 토큰 기반 인증이 필요할 때 사용합니다.
+   * 로컬 스토리지에 저장된 토큰이 있으면 기존 계정으로 재로그인을 시도합니다.
+   * 동시 호출 시 중복 요청 방지 (race condition 방지)
+   *
+   * @example
+   * ```typescript
+   * // 게스트로 가입하고 실시간 연결
+   * const guest = await client.auth.signInAsGuestMember()
+   * await client.realtime.connect({ accessToken: guest.access_token })
+   * ```
+   */
+  async signInAsGuestMember() {
+    if (this.guestMemberLoginPromise) {
+      return this.guestMemberLoginPromise;
+    }
+    this.guestMemberLoginPromise = this.executeGuestMemberLogin();
+    try {
+      return await this.guestMemberLoginPromise;
+    } finally {
+      this.guestMemberLoginPromise = null;
+    }
+  }
+  /**
+   * 실제 게스트 멤버 로그인 실행 (내부 메서드)
+   */
+  async executeGuestMemberLogin() {
+    const storedData = this.getStoredGuestMemberTokens();
+    if (storedData) {
+      if (!this.isTokenExpired(storedData.accessToken)) {
+        try {
+          this.http.setTokens(storedData.accessToken, storedData.refreshToken);
+          const memberInfo = await this.http.get(
+            "/v1/public/app-members/me"
+          );
+          if (memberInfo.is_active) {
+            return {
+              member_id: memberInfo.member_id,
+              access_token: storedData.accessToken,
+              refresh_token: storedData.refreshToken
+            };
+          }
+          this.clearGuestMemberTokens();
+        } catch {
+          this.http.clearTokens();
+        }
+      }
+      if (storedData.refreshToken && !this.isTokenExpired(storedData.refreshToken)) {
+        try {
+          const refreshed = await this.http.post(
+            "/v1/auth/re-issue",
+            {},
+            { headers: { "Authorization": `Bearer ${storedData.refreshToken}` }, skipAuth: true }
+          );
+          this.http.setTokens(refreshed.access_token, refreshed.refresh_token);
+          this.storeGuestMemberTokens(refreshed.access_token, refreshed.refresh_token, storedData.memberId);
+          return {
+            member_id: storedData.memberId,
+            access_token: refreshed.access_token,
+            refresh_token: refreshed.refresh_token
+          };
+        } catch {
+          this.clearGuestMemberTokens();
+        }
+      } else {
+        this.clearGuestMemberTokens();
+      }
+    }
+    const response = await this.http.post(
+      "/v1/public/app-members",
+      {},
+      { skipAuth: true }
+    );
+    this.http.setTokens(response.access_token, response.refresh_token);
+    this.storeGuestMemberTokens(response.access_token, response.refresh_token, response.member_id);
+    return response;
+  }
+  /**
+   * JWT 토큰 만료 여부 확인 (로컬 검증)
+   */
+  isTokenExpired(token) {
+    try {
+      const payload = JSON.parse(atob(token.split(".")[1]));
+      const currentTime = Date.now() / 1e3;
+      return payload.exp < currentTime;
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * 현재 앱의 guest_member 토큰 스토리지 키 생성
+   */
+  getGuestMemberTokenKey() {
+    if (this.cachedGuestMemberTokenKey) {
+      return this.cachedGuestMemberTokenKey;
+    }
+    const apiKey = this.http.getApiKey();
+    if (!apiKey) {
+      this.cachedGuestMemberTokenKey = `${GUEST_MEMBER_TOKEN_KEY_PREFIX}default`;
+    } else {
+      const keyHash = simpleHash(apiKey);
+      this.cachedGuestMemberTokenKey = `${GUEST_MEMBER_TOKEN_KEY_PREFIX}${keyHash}`;
+    }
+    return this.cachedGuestMemberTokenKey;
+  }
+  /**
+   * 저장된 게스트 멤버 토큰 조회
+   */
+  getStoredGuestMemberTokens() {
+    if (typeof localStorage === "undefined") return null;
+    const stored = localStorage.getItem(this.getGuestMemberTokenKey());
+    if (!stored) return null;
+    try {
+      return JSON.parse(stored);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 게스트 멤버 토큰 저장
+   */
+  storeGuestMemberTokens(accessToken, refreshToken, memberId) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(this.getGuestMemberTokenKey(), JSON.stringify({ accessToken, refreshToken, memberId }));
+  }
+  /**
+   * 저장된 게스트 멤버 토큰 삭제
+   */
+  clearGuestMemberTokens() {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(this.getGuestMemberTokenKey());
+  }
+  /**
+   * 앱 멤버 회원가입 (이메일/ID 기반)
+   * 앱에 새로운 멤버를 등록합니다.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.auth.signUpMember({
+   *     login_id: 'user@example.com',
+   *     password: 'password123',
+   *     nickname: 'John'
+   * })
+   * console.log('가입 완료:', result.member_id)
+   * ```
+   */
+  async signUpMember(data) {
+    const response = await this.http.post(
+      "/v1/public/app-members/signup",
+      data,
+      { skipAuth: true }
+    );
+    this.http.setTokens(response.access_token, response.refresh_token);
+    return response;
+  }
+  /**
+   * 앱 멤버 로그인 (이메일/ID 기반)
+   * 기존 멤버로 로그인합니다.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.auth.signInMember({
+   *     login_id: 'user@example.com',
+   *     password: 'password123'
+   * })
+   * console.log('로그인 성공:', result.member_id)
+   * ```
+   */
+  async signInMember(data) {
+    const response = await this.http.post(
+      "/v1/public/app-members/signin",
+      data,
+      { skipAuth: true }
+    );
+    this.http.setTokens(response.access_token, response.refresh_token);
+    return response;
+  }
+};
+
+// src/api/database.ts
+var DatabaseAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * API Key 인증 시 /v1/public 접두사 반환
+   */
+  getPublicPrefix() {
+    return this.http.hasApiKey() ? "/v1/public" : "/v1";
+  }
+  // ============ Table Methods ============
+  /**
+   * 테이블 목록 조회
+   */
+  async getTables(databaseId) {
+    const response = await this.http.get(
+      `/v1/databases/json-databases/${databaseId}/tables`
+    );
+    return response.tables;
+  }
+  /**
+   * 테이블 생성
+   */
+  async createTable(databaseId, data) {
+    return this.http.post(
+      `/v1/databases/json-databases/${databaseId}/tables`,
+      data
+    );
+  }
+  /**
+   * 테이블 삭제
+   */
+  async deleteTable(databaseId, tableId) {
+    await this.http.delete(
+      `/v1/databases/json-databases/${databaseId}/tables/${tableId}`
+    );
+  }
+  // ============ Column Methods ============
+  /**
+   * 컬럼 목록 조회
+   */
+  async getColumns(tableId) {
+    const response = await this.http.get(
+      `/v1/tables/${tableId}/columns`
+    );
+    return response.columns;
+  }
+  /**
+   * 컬럼 생성
+   */
+  async createColumn(tableId, data) {
+    return this.http.post(
+      `/v1/tables/${tableId}/columns`,
+      data
+    );
+  }
+  /**
+   * 컬럼 수정
+   */
+  async updateColumn(tableId, columnId, data) {
+    return this.http.patch(
+      `/v1/tables/${tableId}/columns/${columnId}`,
+      data
+    );
+  }
+  /**
+   * 컬럼 삭제
+   */
+  async deleteColumn(tableId, columnId) {
+    await this.http.delete(`/v1/tables/${tableId}/columns/${columnId}`);
+  }
+  // ============ Data Methods ============
+  /**
+   * 데이터 조회 (페이지네이션)
+   */
+  async getData(tableId, options) {
+    const prefix = this.getPublicPrefix();
+    if (options?.where) {
+      return this.queryData(tableId, options);
+    }
+    const params = new URLSearchParams();
+    if (options?.limit) params.append("limit", options.limit.toString());
+    if (options?.offset) params.append("offset", options.offset.toString());
+    const queryString = params.toString();
+    const url = queryString ? `${prefix}/tables/${tableId}/data?${queryString}` : `${prefix}/tables/${tableId}/data`;
+    return this.http.get(url);
+  }
+  /**
+   * 조건부 데이터 조회 (Where, OrderBy)
+   */
+  async queryData(tableId, options) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(
+      `${prefix}/tables/${tableId}/data/query`,
+      {
+        where: options.where,
+        order_by: options.orderBy,
+        order_direction: options.orderDirection,
+        limit: options.limit,
+        offset: options.offset
+      }
+    );
+  }
+  /**
+   * 단일 데이터 조회
+   */
+  async getDataById(tableId, dataId) {
+    const prefix = this.getPublicPrefix();
+    return this.http.get(`${prefix}/tables/${tableId}/data/${dataId}`);
+  }
+  /**
+   * 데이터 생성
+   */
+  async createData(tableId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/tables/${tableId}/data`, data);
+  }
+  /**
+   * 데이터 수정
+   */
+  async updateData(tableId, dataId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.put(`${prefix}/tables/${tableId}/data/${dataId}`, data);
+  }
+  /**
+   * 데이터 삭제
+   */
+  async deleteData(tableId, dataId) {
+    const prefix = this.getPublicPrefix();
+    await this.http.delete(`${prefix}/tables/${tableId}/data/${dataId}`);
+  }
+  /**
+   * 여러 데이터 한번에 생성 (Bulk Create)
+   */
+  async createMany(tableId, items) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(
+      `${prefix}/tables/${tableId}/data/bulk`,
+      { data: items.map((item) => item.data) }
+    );
+  }
+  /**
+   * 조건에 맞는 데이터 삭제
+   */
+  async deleteWhere(tableId, where) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(
+      `${prefix}/tables/${tableId}/data/delete-where`,
+      { where }
+    );
+  }
+};
+
+// src/api/storage.ts
+var StorageAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * API Key 인증 시 /v1/public 접두사 반환
+   */
+  getPublicPrefix() {
+    return this.http.hasApiKey() ? "/v1/public" : "/v1";
+  }
+  /**
+   * 파일 목록 조회
+   */
+  async getFiles(storageId) {
+    const prefix = this.getPublicPrefix();
+    const response = await this.http.get(
+      `${prefix}/storages/files/${storageId}/items`
+    );
+    return response.files;
+  }
+  /**
+   * 파일 업로드
+   */
+  async uploadFile(storageId, file, parentId) {
+    const prefix = this.getPublicPrefix();
+    const formData = new FormData();
+    formData.append("file", file);
+    if (parentId) {
+      formData.append("parent_id", parentId);
+    }
+    return this.http.post(
+      `${prefix}/storages/files/${storageId}/upload`,
+      formData
+    );
+  }
+  /**
+   * 여러 파일 업로드
+   */
+  async uploadFiles(storageId, files, parentId) {
+    const results = [];
+    for (const file of files) {
+      const result = await this.uploadFile(storageId, file, parentId);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * 폴더 생성
+   */
+  async createFolder(storageId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(
+      `${prefix}/storages/files/${storageId}/folders`,
+      data
+    );
+  }
+  /**
+   * 파일/폴더 삭제
+   */
+  async deleteFile(storageId, fileId) {
+    const prefix = this.getPublicPrefix();
+    await this.http.delete(`${prefix}/storages/files/${storageId}/items/${fileId}`);
+  }
+  /**
+   * 파일/폴더 이동
+   */
+  async moveFile(storageId, fileId, data) {
+    const prefix = this.getPublicPrefix();
+    await this.http.post(
+      `${prefix}/storages/files/${storageId}/items/${fileId}/move`,
+      data
+    );
+  }
+  /**
+   * 파일/폴더 이름 변경
+   */
+  async renameFile(storageId, fileId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.patch(
+      `${prefix}/storages/files/${storageId}/items/${fileId}/rename`,
+      data
+    );
+  }
+  /**
+   * 파일 URL 가져오기
+   */
+  getFileUrl(file) {
+    return file.url || null;
+  }
+  /**
+   * 이미지 파일 여부 확인
+   */
+  isImageFile(file) {
+    return file.mime_type?.startsWith("image/") || false;
+  }
+};
+
+// src/api/api-key.ts
+var ApiKeyAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 앱의 API Key 목록을 조회합니다
+   * @param appId 앱 ID
+   */
+  async getApiKeys(appId) {
+    return this.http.get(`/v1/apps/${appId}/api-keys`);
+  }
+  /**
+   * 새 API Key를 생성합니다
+   *
+   * **중요**: 반환되는 `key` 값은 이 응답에서만 볼 수 있습니다.
+   * 안전한 곳에 저장하세요.
+   *
+   * @param appId 앱 ID
+   * @param data 생성할 API Key 정보
+   */
+  async createApiKey(appId, data) {
+    return this.http.post(`/v1/apps/${appId}/api-keys`, data);
+  }
+  /**
+   * API Key를 수정합니다 (이름 변경, 활성화/비활성화)
+   * @param appId 앱 ID
+   * @param keyId API Key ID
+   * @param data 수정할 정보
+   */
+  async updateApiKey(appId, keyId, data) {
+    return this.http.patch(`/v1/apps/${appId}/api-keys/${keyId}`, data);
+  }
+  /**
+   * API Key를 삭제합니다
+   * @param appId 앱 ID
+   * @param keyId API Key ID
+   */
+  async deleteApiKey(appId, keyId) {
+    await this.http.delete(`/v1/apps/${appId}/api-keys/${keyId}`);
+  }
+};
+
+// src/api/functions.ts
+var FunctionsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * API Key 인증 시 /v1/public 접두사 반환
+   */
+  getPublicPrefix() {
+    return this.http.hasApiKey() ? "/v1/public" : "/v1";
+  }
+  /**
+   * 서버리스 함수 실행
+   *
+   * @param functionId - 함수 ID
+   * @param payload - 함수에 전달할 데이터 (선택)
+   * @param timeout - 실행 타임아웃 (초, 선택)
+   * @returns 함수 실행 결과
+   *
+   * @example
+   * ```typescript
+   * // 기본 실행
+   * const result = await cb.functions.invoke('function-id')
+   *
+   * // 데이터와 함께 실행
+   * const result = await cb.functions.invoke('function-id', {
+   *     name: 'John',
+   *     age: 30
+   * })
+   *
+   * // 타임아웃 설정
+   * const result = await cb.functions.invoke('function-id', { data: 'test' }, 60)
+   * ```
+   */
+  async invoke(functionId, payload, timeout) {
+    const prefix = this.getPublicPrefix();
+    const request = {};
+    if (payload !== void 0) {
+      request.payload = payload;
+    }
+    if (timeout !== void 0) {
+      request.timeout = timeout;
+    }
+    return this.http.post(
+      `${prefix}/functions/${functionId}/invoke`,
+      request
+    );
+  }
+  /**
+   * 서버리스 함수 실행 (비동기 래퍼)
+   * 결과만 반환하고 메타데이터는 제외
+   *
+   * @param functionId - 함수 ID
+   * @param payload - 함수에 전달할 데이터 (선택)
+   * @returns 함수 실행 결과 데이터
+   *
+   * @example
+   * ```typescript
+   * const data = await cb.functions.call('function-id', { name: 'John' })
+   * console.log(data) // 함수가 반환한 데이터
+   * ```
+   */
+  async call(functionId, payload) {
+    const response = await this.invoke(functionId, payload);
+    if (!response.success) {
+      throw new Error(response.error || "Function execution failed");
+    }
+    return response.result;
+  }
+};
+
+// src/api/realtime.ts
+var RealtimeAPI = class {
+  constructor(http, socketUrl) {
+    this.ws = null;
+    this.state = "disconnected";
+    this._connectionId = null;
+    this._appId = null;
+    this.options = {
+      maxRetries: 5,
+      retryInterval: 1e3,
+      userId: "",
+      accessToken: ""
+    };
+    this.retryCount = 0;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.stateHandlers = [];
+    this.errorHandlers = [];
+    this.http = http;
+    this.socketUrl = socketUrl;
+    this.clientId = this.generateClientId();
+  }
+  /** 현재 연결 ID */
+  get connectionId() {
+    return this._connectionId;
+  }
+  /** 현재 연결된 앱 ID */
+  get appId() {
+    return this._appId;
+  }
+  /**
+   * WebSocket 연결
+   * @param options 연결 옵션
+   * - accessToken: JWT 토큰으로 인증 (앱 멤버용, API Key보다 우선)
+   * - userId: 사용자 식별자 (표시용)
+   */
+  async connect(options = {}) {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.options = { ...this.options, ...options };
+    if (options.userId) {
+      this.userId = options.userId;
+    }
+    return this.doConnect();
+  }
+  /**
+   * 연결 해제
+   */
+  disconnect() {
+    this.state = "disconnected";
+    this.notifyStateChange();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.pendingRequests.forEach((req) => {
+      clearTimeout(req.timeout);
+      req.reject(new Error("Connection closed"));
+    });
+    this.pendingRequests.clear();
+    this.subscriptions.clear();
+  }
+  /**
+   * 카테고리 구독
+   */
+  async subscribe(category, options = {}) {
+    if (this.state !== "connected") {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    const requestId = this.generateRequestId();
+    const response = await this.sendRequest({
+      category,
+      action: "subscribe",
+      request_id: requestId
+    });
+    const info = {
+      category: response.category,
+      persist: response.persist,
+      historyCount: response.history_count,
+      readReceipt: response.read_receipt
+    };
+    const handlers = [];
+    this.subscriptions.set(category, { info, handlers });
+    const subscription = {
+      info,
+      send: async (data, sendOptions) => {
+        await this.sendMessage(category, data, sendOptions);
+      },
+      getHistory: async (limit) => {
+        return this.getHistory(category, limit ?? options.historyLimit);
+      },
+      unsubscribe: async () => {
+        await this.unsubscribe(category);
+      },
+      onMessage: (handler) => {
+        handlers.push(handler);
+      }
+    };
+    return subscription;
+  }
+  /**
+   * 구독 해제
+   */
+  async unsubscribe(category) {
+    if (this.state !== "connected") {
+      return;
+    }
+    const requestId = this.generateRequestId();
+    await this.sendRequest({
+      category,
+      action: "unsubscribe",
+      request_id: requestId
+    });
+    this.subscriptions.delete(category);
+  }
+  /**
+   * 메시지 전송
+   * @param category 카테고리 이름
+   * @param data 전송할 데이터
+   * @param options 전송 옵션 (includeSelf: 발신자도 메시지 수신 여부, 기본값 true)
+   */
+  async sendMessage(category, data, options = {}) {
+    if (this.state !== "connected") {
+      throw new Error("Not connected");
+    }
+    const includeSelf = options.includeSelf !== false;
+    const broadcast = includeSelf;
+    const requestId = this.generateRequestId();
+    await this.sendRequest({
+      category,
+      action: "send",
+      data: { data, broadcast },
+      request_id: requestId
+    });
+  }
+  /**
+   * 히스토리 조회
+   */
+  async getHistory(category, limit) {
+    if (this.state !== "connected") {
+      throw new Error("Not connected");
+    }
+    const requestId = this.generateRequestId();
+    const response = await this.sendRequest({
+      category,
+      action: "history",
+      data: limit ? { limit } : void 0,
+      request_id: requestId
+    });
+    return {
+      category: response.category,
+      messages: response.messages.map((m) => ({
+        id: m.id,
+        category: m.category,
+        from: m.from,
+        data: m.data,
+        sentAt: m.sent_at
+      })),
+      total: response.total
+    };
+  }
+  /**
+   * 연결 상태
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 상태 변경 핸들러 등록
+   */
+  onStateChange(handler) {
+    this.stateHandlers.push(handler);
+    return () => {
+      const idx = this.stateHandlers.indexOf(handler);
+      if (idx > -1) this.stateHandlers.splice(idx, 1);
+    };
+  }
+  /**
+   * 에러 핸들러 등록
+   */
+  onError(handler) {
+    this.errorHandlers.push(handler);
+    return () => {
+      const idx = this.errorHandlers.indexOf(handler);
+      if (idx > -1) this.errorHandlers.splice(idx, 1);
+    };
+  }
+  // Private methods
+  async doConnect() {
+    return new Promise((resolve, reject) => {
+      this.state = "connecting";
+      this.notifyStateChange();
+      const wsUrl = this.socketUrl.replace(/^http/, "ws");
+      let url;
+      if (this.options.accessToken) {
+        url = `${wsUrl}/v1/realtime/auth?access_token=${encodeURIComponent(this.options.accessToken)}&client_id=${this.clientId}`;
+      } else {
+        const apiKey = this.http.getApiKey();
+        if (!apiKey) {
+          reject(new Error("API Key or accessToken is required for realtime connection"));
+          return;
+        }
+        url = `${wsUrl}/v1/realtime/auth?api_key=${encodeURIComponent(apiKey)}&client_id=${this.clientId}`;
+      }
+      if (this.userId) {
+        url += `&user_id=${encodeURIComponent(this.userId)}`;
+      }
+      try {
+        this.ws = new WebSocket(url);
+        this.ws.onopen = () => {
+        };
+        this.ws.onmessage = (event) => {
+          const messages = event.data.split("\n").filter((line) => line.trim());
+          for (const line of messages) {
+            try {
+              const msg = JSON.parse(line);
+              this.handleServerMessage(msg, resolve);
+            } catch (e) {
+              console.error("[Realtime] Failed to parse message:", line, e);
+            }
+          }
+        };
+        this.ws.onclose = () => {
+          if (this.state === "connected" || this.state === "connecting") {
+            this.handleDisconnect();
+          }
+        };
+        this.ws.onerror = (error) => {
+          console.error("[Realtime] WebSocket error:", error);
+          this.notifyError(new Error("WebSocket connection error"));
+          if (this.state === "connecting") {
+            reject(new Error("Failed to connect"));
+          }
+        };
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  handleServerMessage(msg, connectResolve) {
+    switch (msg.event) {
+      case "connected": {
+        const data = msg.data;
+        this._connectionId = data.connection_id;
+        this._appId = data.app_id;
+        this.state = "connected";
+        this.retryCount = 0;
+        this.notifyStateChange();
+        if (connectResolve) connectResolve();
+        break;
+      }
+      case "subscribed":
+      case "unsubscribed":
+      case "sent":
+      case "result":
+      case "history": {
+        if (msg.request_id) {
+          const pending = this.pendingRequests.get(msg.request_id);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            pending.resolve(msg.data);
+            this.pendingRequests.delete(msg.request_id);
+          }
+        }
+        break;
+      }
+      case "message": {
+        const data = msg.data;
+        const sub = this.subscriptions.get(data.category);
+        if (sub) {
+          const message = {
+            id: data.id,
+            category: data.category,
+            from: data.from,
+            data: data.data,
+            sentAt: data.sent_at
+          };
+          sub.handlers.forEach((h) => h(message));
+        }
+        break;
+      }
+      case "error": {
+        if (msg.request_id) {
+          const pending = this.pendingRequests.get(msg.request_id);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(msg.error || "Unknown error"));
+            this.pendingRequests.delete(msg.request_id);
+          }
+        } else {
+          this.notifyError(new Error(msg.error || "Unknown error"));
+        }
+        break;
+      }
+      case "pong":
+        break;
+    }
+  }
+  handleDisconnect() {
+    this.ws = null;
+    this._connectionId = null;
+    if (this.retryCount < this.options.maxRetries) {
+      this.state = "reconnecting";
+      this.notifyStateChange();
+      this.retryCount++;
+      setTimeout(() => {
+        this.doConnect().catch((e) => {
+          console.error("[Realtime] Reconnect failed:", e);
+        });
+      }, this.options.retryInterval * this.retryCount);
+    } else {
+      this.state = "disconnected";
+      this.notifyStateChange();
+      this.notifyError(new Error("Connection lost. Max retries exceeded."));
+    }
+  }
+  sendRequest(message) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        reject(new Error("Not connected"));
+        return;
+      }
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(message.request_id);
+        reject(new Error("Request timeout"));
+      }, 3e4);
+      this.pendingRequests.set(message.request_id, {
+        resolve,
+        reject,
+        timeout
+      });
+      this.ws.send(JSON.stringify(message));
+    });
+  }
+  notifyStateChange() {
+    this.stateHandlers.forEach((h) => h(this.state));
+  }
+  notifyError(error) {
+    this.errorHandlers.forEach((h) => h(error));
+  }
+  generateClientId() {
+    return "cb_" + Math.random().toString(36).substring(2, 15);
+  }
+  generateRequestId() {
+    return "req_" + Date.now() + "_" + Math.random().toString(36).substring(2, 9);
+  }
+};
+
+// src/api/webrtc.ts
+var WebRTCAPI = class {
+  constructor(http, webrtcUrl) {
+    this.ws = null;
+    this.state = "disconnected";
+    this.stateListeners = [];
+    this.errorListeners = [];
+    this.peerJoinedListeners = [];
+    this.peerLeftListeners = [];
+    this.remoteStreamListeners = [];
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.reconnectTimeout = null;
+    // 현재 연결 정보
+    this.currentRoomId = null;
+    this.currentPeerId = null;
+    this.currentUserId = null;
+    this.isBroadcaster = false;
+    this.localStream = null;
+    this.channelType = "interactive";
+    // 피어 연결 관리
+    this.peerConnections = /* @__PURE__ */ new Map();
+    this.remoteStreams = /* @__PURE__ */ new Map();
+    this.iceServers = [];
+    this.http = http;
+    this.webrtcUrl = webrtcUrl;
+  }
+  /**
+   * ICE 서버 목록 조회
+   */
+  async getICEServers() {
+    const response = await this.http.get("/v1/ice-servers");
+    this.iceServers = response.ice_servers;
+    return response.ice_servers;
+  }
+  /**
+   * WebRTC 시그널링 서버에 연결
+   *
+   * @example
+   * ```typescript
+   * // 로컬 스트림 가져오기
+   * const localStream = await navigator.mediaDevices.getUserMedia({
+   *     video: true,
+   *     audio: true
+   * })
+   *
+   * // WebRTC 연결
+   * await cb.webrtc.connect({
+   *     roomId: 'live:room-123',
+   *     userId: 'user-456',
+   *     isBroadcaster: true,
+   *     localStream
+   * })
+   * ```
+   */
+  async connect(options) {
+    if (this.state === "connected" || this.state === "connecting") {
+      throw new Error("\uC774\uBBF8 \uC5F0\uACB0\uB418\uC5B4 \uC788\uAC70\uB098 \uC5F0\uACB0 \uC911\uC785\uB2C8\uB2E4");
+    }
+    this.setState("connecting");
+    this.currentRoomId = options.roomId;
+    this.currentUserId = options.userId || null;
+    this.isBroadcaster = options.isBroadcaster || false;
+    this.localStream = options.localStream || null;
+    if (this.iceServers.length === 0) {
+      try {
+        await this.getICEServers();
+      } catch {
+        this.iceServers = [{ urls: "stun:stun.l.google.com:19302" }];
+      }
+    }
+    return this.connectWebSocket();
+  }
+  connectWebSocket() {
+    return new Promise((resolve, reject) => {
+      const wsUrl = this.buildWebSocketUrl();
+      this.ws = new WebSocket(wsUrl);
+      const timeout = setTimeout(() => {
+        if (this.state === "connecting") {
+          this.ws?.close();
+          reject(new Error("\uC5F0\uACB0 \uC2DC\uAC04 \uCD08\uACFC"));
+        }
+      }, 1e4);
+      this.ws.onopen = () => {
+        clearTimeout(timeout);
+        this.reconnectAttempts = 0;
+        this.sendSignaling({
+          type: "join",
+          room_id: this.currentRoomId,
+          data: {
+            user_id: this.currentUserId,
+            is_broadcaster: this.isBroadcaster
+          }
+        });
+      };
+      this.ws.onmessage = async (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          await this.handleSignalingMessage(msg, resolve, reject);
+        } catch (error) {
+          console.error("Failed to parse signaling message:", error);
+        }
+      };
+      this.ws.onerror = (event) => {
+        clearTimeout(timeout);
+        console.error("WebSocket error:", event);
+        this.emitError(new Error("WebSocket \uC5F0\uACB0 \uC624\uB958"));
+      };
+      this.ws.onclose = (event) => {
+        clearTimeout(timeout);
+        if (this.state === "connecting") {
+          reject(new Error("\uC5F0\uACB0\uC774 \uC885\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4"));
+        }
+        this.handleDisconnect(event);
+      };
+    });
+  }
+  buildWebSocketUrl() {
+    let wsBase = this.webrtcUrl.replace("https://", "wss://").replace("http://", "ws://");
+    const apiKey = this.http.getApiKey();
+    const accessToken = this.http.getAccessToken();
+    let authParam = "";
+    if (accessToken) {
+      authParam = `access_token=${encodeURIComponent(accessToken)}`;
+    } else if (apiKey) {
+      authParam = `api_key=${encodeURIComponent(apiKey)}`;
+    }
+    return `${wsBase}/v1/signaling?${authParam}`;
+  }
+  async handleSignalingMessage(msg, resolve, reject) {
+    switch (msg.type) {
+      case "joined":
+        this.setState("connected");
+        this.currentPeerId = msg.peer_id || null;
+        if (msg.data && typeof msg.data === "object") {
+          const data = msg.data;
+          if (data.channel_type) {
+            this.channelType = data.channel_type;
+          }
+          const peers = data.peers || [];
+          for (const peer of peers) {
+            if (peer.peer_id !== this.currentPeerId) {
+              await this.createPeerConnection(peer.peer_id, true);
+            }
+          }
+        }
+        resolve?.();
+        break;
+      case "peer_joined":
+        if (msg.peer_id && msg.peer_id !== this.currentPeerId) {
+          const peerInfo = {
+            peer_id: msg.peer_id,
+            ...typeof msg.data === "object" ? msg.data : {}
+          };
+          this.emitPeerJoined(msg.peer_id, peerInfo);
+          await this.createPeerConnection(msg.peer_id, false);
+        }
+        break;
+      case "peer_left":
+        if (msg.peer_id) {
+          this.closePeerConnection(msg.peer_id);
+          this.emitPeerLeft(msg.peer_id);
+        }
+        break;
+      case "offer":
+        if (msg.peer_id && msg.sdp) {
+          await this.handleOffer(msg.peer_id, msg.sdp);
+        }
+        break;
+      case "answer":
+        if (msg.peer_id && msg.sdp) {
+          await this.handleAnswer(msg.peer_id, msg.sdp);
+        }
+        break;
+      case "ice_candidate":
+        if (msg.peer_id && msg.candidate) {
+          await this.handleICECandidate(msg.peer_id, msg.candidate);
+        }
+        break;
+      case "error":
+        const errorMsg = typeof msg.data === "string" ? msg.data : "Unknown error";
+        const error = new Error(errorMsg);
+        this.emitError(error);
+        reject?.(error);
+        break;
+    }
+  }
+  async createPeerConnection(remotePeerId, isInitiator) {
+    this.closePeerConnection(remotePeerId);
+    const config = {
+      iceServers: this.iceServers.map((server) => ({
+        urls: server.urls,
+        username: server.username,
+        credential: server.credential
+      }))
+    };
+    const pc = new RTCPeerConnection(config);
+    this.peerConnections.set(remotePeerId, pc);
+    if (this.localStream) {
+      this.localStream.getTracks().forEach((track) => {
+        pc.addTrack(track, this.localStream);
+      });
+    }
+    pc.onicecandidate = (event) => {
+      if (event.candidate) {
+        this.sendSignaling({
+          type: "ice_candidate",
+          target_id: remotePeerId,
+          candidate: event.candidate.toJSON()
+        });
+      }
+    };
+    pc.ontrack = (event) => {
+      const [stream] = event.streams;
+      if (stream) {
+        this.remoteStreams.set(remotePeerId, stream);
+        this.emitRemoteStream(remotePeerId, stream);
+      }
+    };
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === "failed") {
+        console.warn(`Peer connection failed: ${remotePeerId}`);
+        this.closePeerConnection(remotePeerId);
+      }
+    };
+    if (isInitiator) {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      this.sendSignaling({
+        type: "offer",
+        target_id: remotePeerId,
+        sdp: offer.sdp
+      });
+    }
+    return pc;
+  }
+  async handleOffer(remotePeerId, sdp) {
+    let pc = this.peerConnections.get(remotePeerId);
+    if (!pc) {
+      pc = await this.createPeerConnection(remotePeerId, false);
+    }
+    await pc.setRemoteDescription(new RTCSessionDescription({ type: "offer", sdp }));
+    const answer = await pc.createAnswer();
+    await pc.setLocalDescription(answer);
+    this.sendSignaling({
+      type: "answer",
+      target_id: remotePeerId,
+      sdp: answer.sdp
+    });
+  }
+  async handleAnswer(remotePeerId, sdp) {
+    const pc = this.peerConnections.get(remotePeerId);
+    if (pc) {
+      await pc.setRemoteDescription(new RTCSessionDescription({ type: "answer", sdp }));
+    }
+  }
+  async handleICECandidate(remotePeerId, candidate) {
+    const pc = this.peerConnections.get(remotePeerId);
+    if (pc) {
+      try {
+        await pc.addIceCandidate(new RTCIceCandidate(candidate));
+      } catch (error) {
+        console.warn("Failed to add ICE candidate:", error);
+      }
+    }
+  }
+  closePeerConnection(remotePeerId) {
+    const pc = this.peerConnections.get(remotePeerId);
+    if (pc) {
+      pc.close();
+      this.peerConnections.delete(remotePeerId);
+    }
+    this.remoteStreams.delete(remotePeerId);
+  }
+  sendSignaling(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  handleDisconnect(event) {
+    const wasConnected = this.state === "connected";
+    this.setState("disconnected");
+    this.peerConnections.forEach((pc, peerId) => {
+      pc.close();
+      this.emitPeerLeft(peerId);
+    });
+    this.peerConnections.clear();
+    this.remoteStreams.clear();
+    if (wasConnected && event.code !== 1e3 && this.reconnectAttempts < this.maxReconnectAttempts) {
+      this.attemptReconnect();
+    }
+  }
+  attemptReconnect() {
+    this.reconnectAttempts++;
+    this.setState("reconnecting");
+    const delay = Math.min(5e3 * Math.pow(2, this.reconnectAttempts - 1), 3e4);
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        await this.connectWebSocket();
+      } catch (error) {
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+          this.attemptReconnect();
+        } else {
+          this.setState("failed");
+          this.emitError(new Error("\uC7AC\uC5F0\uACB0 \uC2E4\uD328: \uCD5C\uB300 \uC2DC\uB3C4 \uD69F\uC218 \uCD08\uACFC"));
+        }
+      }
+    }, delay);
+  }
+  /**
+   * WebRTC 연결 해제
+   */
+  disconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.sendSignaling({ type: "leave" });
+      this.ws.close(1e3, "User disconnected");
+    }
+    this.peerConnections.forEach((pc) => pc.close());
+    this.peerConnections.clear();
+    this.remoteStreams.clear();
+    this.ws = null;
+    this.currentRoomId = null;
+    this.currentPeerId = null;
+    this.localStream = null;
+    this.setState("disconnected");
+  }
+  /**
+   * 현재 연결 상태 조회
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 현재 룸 ID 조회
+   */
+  getRoomId() {
+    return this.currentRoomId;
+  }
+  /**
+   * 현재 피어 ID 조회
+   */
+  getPeerId() {
+    return this.currentPeerId;
+  }
+  /**
+   * 현재 채널 타입 조회
+   */
+  getChannelType() {
+    return this.channelType;
+  }
+  /**
+   * 원격 스트림 조회
+   */
+  getRemoteStream(peerId) {
+    return this.remoteStreams.get(peerId);
+  }
+  /**
+   * 모든 원격 스트림 조회
+   */
+  getAllRemoteStreams() {
+    return new Map(this.remoteStreams);
+  }
+  /**
+   * 로컬 스트림 교체
+   */
+  replaceLocalStream(newStream) {
+    this.localStream = newStream;
+    this.peerConnections.forEach((pc) => {
+      const senders = pc.getSenders();
+      newStream.getTracks().forEach((track) => {
+        const sender = senders.find((s) => s.track?.kind === track.kind);
+        if (sender) {
+          sender.replaceTrack(track);
+        } else {
+          pc.addTrack(track, newStream);
+        }
+      });
+    });
+  }
+  /**
+   * 오디오 음소거/해제
+   */
+  setAudioEnabled(enabled) {
+    if (this.localStream) {
+      this.localStream.getAudioTracks().forEach((track) => {
+        track.enabled = enabled;
+      });
+    }
+  }
+  /**
+   * 비디오 켜기/끄기
+   */
+  setVideoEnabled(enabled) {
+    if (this.localStream) {
+      this.localStream.getVideoTracks().forEach((track) => {
+        track.enabled = enabled;
+      });
+    }
+  }
+  // =====================
+  // 이벤트 리스너
+  // =====================
+  /**
+   * 연결 상태 변경 이벤트
+   */
+  onStateChange(callback) {
+    this.stateListeners.push(callback);
+    return () => {
+      this.stateListeners = this.stateListeners.filter((cb) => cb !== callback);
+    };
+  }
+  /**
+   * 에러 이벤트
+   */
+  onError(callback) {
+    this.errorListeners.push(callback);
+    return () => {
+      this.errorListeners = this.errorListeners.filter((cb) => cb !== callback);
+    };
+  }
+  /**
+   * 피어 참가 이벤트
+   */
+  onPeerJoined(callback) {
+    this.peerJoinedListeners.push(callback);
+    return () => {
+      this.peerJoinedListeners = this.peerJoinedListeners.filter((cb) => cb !== callback);
+    };
+  }
+  /**
+   * 피어 퇴장 이벤트
+   */
+  onPeerLeft(callback) {
+    this.peerLeftListeners.push(callback);
+    return () => {
+      this.peerLeftListeners = this.peerLeftListeners.filter((cb) => cb !== callback);
+    };
+  }
+  /**
+   * 원격 스트림 수신 이벤트
+   */
+  onRemoteStream(callback) {
+    this.remoteStreamListeners.push(callback);
+    return () => {
+      this.remoteStreamListeners = this.remoteStreamListeners.filter((cb) => cb !== callback);
+    };
+  }
+  // =====================
+  // Private: 이벤트 발행
+  // =====================
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.stateListeners.forEach((cb) => cb(state));
+    }
+  }
+  emitError(error) {
+    this.errorListeners.forEach((cb) => cb(error));
+  }
+  emitPeerJoined(peerId, info) {
+    this.peerJoinedListeners.forEach((cb) => cb(peerId, info));
+  }
+  emitPeerLeft(peerId) {
+    this.peerLeftListeners.forEach((cb) => cb(peerId));
+  }
+  emitRemoteStream(peerId, stream) {
+    this.remoteStreamListeners.forEach((cb) => cb(peerId, stream));
+  }
+  // =====================
+  // REST API (통계/관리)
+  // =====================
+  /**
+   * 앱의 WebRTC 통계 조회
+   */
+  async getStats(appID) {
+    return this.http.get(`/v1/apps/${appID}/webrtc/stats`);
+  }
+  /**
+   * 앱의 활성 룸 목록 조회
+   */
+  async getRooms(appID) {
+    return this.http.get(`/v1/apps/${appID}/webrtc/rooms`);
+  }
+};
+
+// src/api/error-tracker.ts
+var ErrorTrackerAPI = class {
+  constructor(http, config = {}) {
+    this.storageWebId = null;
+    this.errorQueue = [];
+    this.batchTimer = null;
+    this.isInitialized = false;
+    // 원본 이벤트 핸들러 저장
+    this.originalOnError = null;
+    this.originalOnUnhandledRejection = null;
+    this.http = http;
+    this.config = {
+      autoCapture: config.autoCapture ?? true,
+      captureTypes: config.captureTypes ?? ["error", "unhandledrejection"],
+      batchInterval: config.batchInterval ?? 5e3,
+      maxBatchSize: config.maxBatchSize ?? 10,
+      beforeSend: config.beforeSend ?? ((e) => e),
+      debug: config.debug ?? false
+    };
+  }
+  /**
+   * 에러 트래커 초기화
+   * @param storageWebId 웹 스토리지 ID
+   */
+  init(storageWebId) {
+    if (this.isInitialized) {
+      this.log("ErrorTracker already initialized");
+      return;
+    }
+    if (typeof window === "undefined") {
+      this.log("ErrorTracker only works in browser environment");
+      return;
+    }
+    this.storageWebId = storageWebId;
+    this.isInitialized = true;
+    if (this.config.autoCapture) {
+      this.setupAutoCapture();
+    }
+    this.startBatchTimer();
+    this.log("ErrorTracker initialized", { storageWebId });
+  }
+  /**
+   * 에러 트래커 정리 (언마운트 시 호출)
+   */
+  destroy() {
+    this.stopBatchTimer();
+    this.removeAutoCapture();
+    this.flushQueue();
+    this.isInitialized = false;
+    this.log("ErrorTracker destroyed");
+  }
+  /**
+   * 수동으로 에러 리포트
+   */
+  async captureError(error, extra) {
+    const report = this.createErrorReport(error, extra);
+    if (report) {
+      this.queueError(report);
+    }
+  }
+  /**
+   * 커스텀 에러 리포트
+   */
+  async captureMessage(message, extra) {
+    const report = {
+      message,
+      error_type: "custom",
+      url: typeof window !== "undefined" ? window.location.href : void 0,
+      referrer: typeof document !== "undefined" ? document.referrer : void 0,
+      ...extra
+    };
+    this.queueError(report);
+  }
+  /**
+   * 큐에 있는 에러들 즉시 전송
+   */
+  async flush() {
+    await this.flushQueue();
+  }
+  // Private methods
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[ErrorTracker]", ...args);
+    }
+  }
+  setupAutoCapture() {
+    if (typeof window === "undefined") return;
+    if (this.config.captureTypes.includes("error")) {
+      this.originalOnError = window.onerror;
+      window.onerror = (message, source, lineno, colno, error) => {
+        this.handleGlobalError(message, source, lineno, colno, error);
+        if (this.originalOnError) {
+          return this.originalOnError(message, source, lineno, colno, error);
+        }
+        return false;
+      };
+    }
+    if (this.config.captureTypes.includes("unhandledrejection")) {
+      this.originalOnUnhandledRejection = window.onunhandledrejection;
+      window.onunhandledrejection = (event) => {
+        this.handleUnhandledRejection(event);
+        if (this.originalOnUnhandledRejection) {
+          this.originalOnUnhandledRejection(event);
+        }
+      };
+    }
+    this.log("Auto capture enabled", { types: this.config.captureTypes });
+  }
+  removeAutoCapture() {
+    if (typeof window === "undefined") return;
+    if (this.originalOnError !== null) {
+      window.onerror = this.originalOnError;
+    }
+    if (this.originalOnUnhandledRejection !== null) {
+      window.onunhandledrejection = this.originalOnUnhandledRejection;
+    }
+  }
+  handleGlobalError(message, source, lineno, colno, error) {
+    const report = {
+      message: typeof message === "string" ? message : message.type || "Unknown error",
+      source: source || void 0,
+      lineno: lineno || void 0,
+      colno: colno || void 0,
+      stack: error?.stack,
+      error_type: "error",
+      url: typeof window !== "undefined" ? window.location.href : void 0,
+      referrer: typeof document !== "undefined" ? document.referrer : void 0
+    };
+    this.queueError(report);
+  }
+  handleUnhandledRejection(event) {
+    const reason = event.reason;
+    let message = "Unhandled Promise Rejection";
+    let stack;
+    if (reason instanceof Error) {
+      message = reason.message;
+      stack = reason.stack;
+    } else if (typeof reason === "string") {
+      message = reason;
+    } else if (reason && typeof reason === "object") {
+      message = JSON.stringify(reason);
+    }
+    const report = {
+      message,
+      stack,
+      error_type: "unhandledrejection",
+      url: typeof window !== "undefined" ? window.location.href : void 0,
+      referrer: typeof document !== "undefined" ? document.referrer : void 0
+    };
+    this.queueError(report);
+  }
+  createErrorReport(error, extra) {
+    let report;
+    if (error instanceof Error) {
+      report = {
+        message: error.message,
+        stack: error.stack,
+        error_type: "error",
+        url: typeof window !== "undefined" ? window.location.href : void 0,
+        referrer: typeof document !== "undefined" ? document.referrer : void 0,
+        ...extra
+      };
+    } else {
+      report = {
+        message: error,
+        error_type: "custom",
+        url: typeof window !== "undefined" ? window.location.href : void 0,
+        referrer: typeof document !== "undefined" ? document.referrer : void 0,
+        ...extra
+      };
+    }
+    const filtered = this.config.beforeSend(report);
+    if (filtered === false || filtered === null) {
+      this.log("Error filtered out by beforeSend");
+      return null;
+    }
+    return filtered;
+  }
+  queueError(report) {
+    this.errorQueue.push(report);
+    this.log("Error queued", { message: report.message, queueSize: this.errorQueue.length });
+    if (this.errorQueue.length >= this.config.maxBatchSize) {
+      this.flushQueue();
+    }
+  }
+  startBatchTimer() {
+    if (this.batchTimer) return;
+    this.batchTimer = setInterval(() => {
+      this.flushQueue();
+    }, this.config.batchInterval);
+  }
+  stopBatchTimer() {
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+      this.batchTimer = null;
+    }
+  }
+  async flushQueue() {
+    if (!this.storageWebId || this.errorQueue.length === 0) return;
+    const errors = [...this.errorQueue];
+    this.errorQueue = [];
+    try {
+      if (errors.length === 1) {
+        await this.http.post(
+          `/v1/public/storages/web/${this.storageWebId}/errors/report`,
+          errors[0]
+        );
+      } else {
+        await this.http.post(
+          `/v1/public/storages/web/${this.storageWebId}/errors/batch`,
+          {
+            errors,
+            user_agent: typeof navigator !== "undefined" ? navigator.userAgent : void 0
+          }
+        );
+      }
+      this.log("Errors sent", { count: errors.length });
+    } catch (err) {
+      const remainingCapacity = this.config.maxBatchSize - this.errorQueue.length;
+      if (remainingCapacity > 0) {
+        this.errorQueue.unshift(...errors.slice(0, remainingCapacity));
+      }
+      this.log("Failed to send errors, re-queued", { error: err });
+    }
+  }
+};
+
+// src/api/oauth.ts
+var OAuthAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * 활성화된 OAuth 프로바이더 목록 조회
+   * 콘솔에서 설정된 소셜 로그인 프로바이더 목록을 반환합니다.
+   *
+   * @example
+   * ```typescript
+   * const { providers } = await cb.oauth.getEnabledProviders()
+   * // [{ provider: 'google', client_id: '...' }, { provider: 'kakao', client_id: '...' }]
+   * ```
+   */
+  async getEnabledProviders() {
+    return this.http.get("/v1/public/oauth/providers");
+  }
+  /**
+   * OAuth 인증 URL 조회
+   * 사용자를 소셜 로그인 페이지로 리다이렉트할 URL을 반환합니다.
+   *
+   * @param provider - OAuth 프로바이더 (google, naver, github, discord)
+   * @param options - redirect_uri와 선택적 state 파라미터
+   * @returns 인증 URL
+   *
+   * @example
+   * ```typescript
+   * const { authorization_url } = await cb.oauth.getAuthorizationURL('google', {
+   *     redirect_uri: 'https://myapp.com/auth/callback'
+   * })
+   *
+   * // 사용자를 OAuth 페이지로 리다이렉트
+   * window.location.href = authorization_url
+   * ```
+   */
+  async getAuthorizationURL(provider, options) {
+    const params = new URLSearchParams({
+      redirect_uri: options.redirect_uri
+    });
+    if (options.state) {
+      params.append("state", options.state);
+    }
+    return this.http.get(
+      `/v1/public/oauth/${provider}/authorize?${params.toString()}`
+    );
+  }
+  /**
+   * OAuth 콜백 처리
+   * 소셜 로그인 후 콜백으로 받은 code를 사용하여 로그인을 완료합니다.
+   * 성공 시 자동으로 토큰이 저장됩니다.
+   *
+   * @param provider - OAuth 프로바이더
+   * @param data - code와 redirect_uri
+   * @returns 로그인 결과 (member_id, 토큰, 신규 회원 여부)
+   *
+   * @example
+   * ```typescript
+   * // 콜백 페이지에서 URL 파라미터로 code 추출
+   * const urlParams = new URLSearchParams(window.location.search)
+   * const code = urlParams.get('code')
+   *
+   * const result = await cb.oauth.handleCallback('google', {
+   *     code: code,
+   *     redirect_uri: 'https://myapp.com/auth/callback'
+   * })
+   *
+   * if (result.is_new_member) {
+   *     console.log('신규 회원입니다!')
+   * }
+   * ```
+   */
+  async handleCallback(provider, data) {
+    const response = await this.http.post(
+      `/v1/public/oauth/${provider}/callback`,
+      data
+    );
+    this.http.setTokens(response.access_token, response.refresh_token);
+    return response;
+  }
+  /**
+   * 소셜 로그인 전체 플로우 (팝업 방식)
+   * 새 창에서 소셜 로그인을 처리하고 결과를 Promise로 반환합니다.
+   *
+   * @param provider - OAuth 프로바이더
+   * @param redirectUri - 콜백 URL (이 페이지에서 postMessage로 결과 전달 필요)
+   * @returns 로그인 결과
+   *
+   * @example
+   * ```typescript
+   * // 로그인 버튼 클릭 시
+   * const result = await cb.oauth.signInWithPopup('google', 'https://myapp.com/auth/popup-callback')
+   * console.log('로그인 성공:', result.member_id)
+   * ```
+   *
+   * @example
+   * ```html
+   * <!-- popup-callback.html -->
+   * <script>
+   *   const urlParams = new URLSearchParams(window.location.search)
+   *   const code = urlParams.get('code')
+   *   const error = urlParams.get('error')
+   *
+   *   window.opener.postMessage({
+   *     type: 'oauth-callback',
+   *     code,
+   *     error
+   *   }, '*')
+   *   window.close()
+   * </script>
+   * ```
+   */
+  async signInWithPopup(provider, redirectUri) {
+    const { authorization_url } = await this.getAuthorizationURL(provider, {
+      redirect_uri: redirectUri
+    });
+    const width = 500;
+    const height = 600;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+    const popup = window.open(
+      authorization_url,
+      "oauth-popup",
+      `width=${width},height=${height},left=${left},top=${top}`
+    );
+    if (!popup) {
+      throw new Error("\uD31D\uC5C5\uC774 \uCC28\uB2E8\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uD31D\uC5C5 \uCC28\uB2E8\uC744 \uD574\uC81C\uD574\uC8FC\uC138\uC694.");
+    }
+    return new Promise((resolve, reject) => {
+      const handleMessage = async (event) => {
+        if (event.data?.type !== "oauth-callback") return;
+        window.removeEventListener("message", handleMessage);
+        if (event.data.error) {
+          reject(new Error(event.data.error));
+          return;
+        }
+        if (!event.data.code) {
+          reject(new Error("\uC778\uC99D \uCF54\uB4DC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
+          return;
+        }
+        try {
+          const result = await this.handleCallback(provider, {
+            code: event.data.code,
+            redirect_uri: redirectUri
+          });
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      window.addEventListener("message", handleMessage);
+      const checkClosed = setInterval(() => {
+        if (popup.closed) {
+          clearInterval(checkClosed);
+          window.removeEventListener("message", handleMessage);
+          reject(new Error("\uB85C\uADF8\uC778\uC774 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4."));
+        }
+      }, 500);
+    });
+  }
+  /**
+   * 소셜 로그인 (리다이렉트 방식)
+   * 현재 페이지를 소셜 로그인 페이지로 리다이렉트합니다.
+   * 콜백 URL에서 handleCallback()을 호출하여 로그인을 완료해야 합니다.
+   *
+   * @param provider - OAuth 프로바이더
+   * @param redirectUri - 콜백 URL
+   *
+   * @example
+   * ```typescript
+   * // 로그인 버튼 클릭 시
+   * await cb.oauth.signInWithRedirect('google', 'https://myapp.com/auth/callback')
+   * // 페이지가 Google 로그인으로 리다이렉트됨
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // callback 페이지에서
+   * const urlParams = new URLSearchParams(window.location.search)
+   * const code = urlParams.get('code')
+   *
+   * if (code) {
+   *     const result = await cb.oauth.handleCallback('google', {
+   *         code,
+   *         redirect_uri: 'https://myapp.com/auth/callback'
+   *     })
+   *     // 로그인 완료, 메인 페이지로 이동
+   *     window.location.href = '/'
+   * }
+   * ```
+   */
+  async signInWithRedirect(provider, redirectUri) {
+    const { authorization_url } = await this.getAuthorizationURL(provider, {
+      redirect_uri: redirectUri
+    });
+    window.location.href = authorization_url;
+  }
+};
+
+// src/api/payment.ts
+var PaymentAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * API Key 인증 시 /v1/public 접두사 반환
+   */
+  getPublicPrefix() {
+    return this.http.hasApiKey() ? "/v1/public" : "/v1";
+  }
+  /**
+   * 결제 준비
+   * 토스 결제 위젯에 필요한 정보를 반환합니다.
+   *
+   * @param data - 결제 준비 정보 (금액, 상품명, 고객 정보 등)
+   * @returns 토스 클라이언트 키, 고객 키, 성공/실패 URL 등
+   *
+   * @example
+   * ```typescript
+   * const prepareResult = await client.payment.prepare({
+   *     amount: 10000,
+   *     order_name: '테스트 상품',
+   *     customer_email: 'test@example.com',
+   *     customer_name: '홍길동'
+   * })
+   *
+   * // 토스 결제 위젯 초기화
+   * const tossPayments = TossPayments(prepareResult.toss_client_key)
+   * await tossPayments.requestPayment('카드', {
+   *     amount: prepareResult.amount,
+   *     orderId: prepareResult.order_id,
+   *     orderName: prepareResult.order_name,
+   *     customerKey: prepareResult.customer_key,
+   *     successUrl: prepareResult.success_url,
+   *     failUrl: prepareResult.fail_url
+   * })
+   * ```
+   */
+  async prepare(data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/payments/prepare`, data);
+  }
+  /**
+   * 결제 승인
+   * 토스에서 결제 완료 후 콜백으로 받은 정보로 결제를 최종 승인합니다.
+   *
+   * @param data - 결제 승인 정보 (paymentKey, orderId, amount)
+   * @returns 승인된 결제 정보
+   *
+   * @example
+   * ```typescript
+   * // 토스 결제 성공 콜백에서 호출
+   * const result = await client.payment.confirm({
+   *     payment_key: 'tgen_20230101000000...',
+   *     order_id: 'order_123',
+   *     amount: 10000
+   * })
+   *
+   * if (result.status === 'done') {
+   *     console.log('결제 완료!')
+   * }
+   * ```
+   */
+  async confirm(data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/payments/confirm`, data);
+  }
+  /**
+   * 결제 취소
+   * 완료된 결제를 취소합니다. 부분 취소도 가능합니다.
+   *
+   * @param paymentId - 결제 ID (Connect Base에서 발급한 ID)
+   * @param data - 취소 정보 (사유, 부분 취소 금액)
+   * @returns 취소된 결제 정보
+   *
+   * @example
+   * ```typescript
+   * // 전액 취소
+   * const result = await client.payment.cancel(paymentId, {
+   *     cancel_reason: '고객 요청'
+   * })
+   *
+   * // 부분 취소
+   * const result = await client.payment.cancel(paymentId, {
+   *     cancel_reason: '부분 환불',
+   *     cancel_amount: 5000
+   * })
+   * ```
+   */
+  async cancel(paymentId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/payments/${paymentId}/cancel`, data);
+  }
+  /**
+   * 주문 ID로 결제 조회
+   * 특정 주문의 결제 상태를 조회합니다.
+   *
+   * @param orderId - 주문 ID
+   * @returns 결제 상세 정보
+   *
+   * @example
+   * ```typescript
+   * const payment = await client.payment.getByOrderId('order_123')
+   * console.log(`결제 상태: ${payment.status}`)
+   * console.log(`결제 금액: ${payment.amount}원`)
+   * ```
+   */
+  async getByOrderId(orderId) {
+    const prefix = this.getPublicPrefix();
+    return this.http.get(`${prefix}/payments/orders/${orderId}`);
+  }
+};
+
+// src/api/subscription.ts
+var SubscriptionAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * API Key 인증 시 /v1/public 접두사 반환
+   */
+  getPublicPrefix() {
+    return this.http.hasApiKey() ? "/v1/public" : "/v1";
+  }
+  // =====================
+  // Billing Key APIs
+  // =====================
+  /**
+   * 빌링키 발급 시작
+   * 토스 카드 등록 위젯에 필요한 정보를 반환합니다.
+   *
+   * @returns 토스 클라이언트 키, 고객 키 등
+   *
+   * @example
+   * ```typescript
+   * const result = await client.subscription.issueBillingKey()
+   *
+   * // 토스 카드 등록 위젯
+   * const tossPayments = TossPayments(result.toss_client_key)
+   * await tossPayments.requestBillingAuth('카드', {
+   *     customerKey: result.customer_key,
+   *     successUrl: 'https://mysite.com/billing/success',
+   *     failUrl: 'https://mysite.com/billing/fail'
+   * })
+   * ```
+   */
+  async issueBillingKey() {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/subscriptions/billing-keys/issue`, {});
+  }
+  /**
+   * 빌링키 등록 확인
+   * 토스에서 카드 등록 완료 후 빌링키를 확정합니다.
+   *
+   * @param data - 등록 확인 정보
+   * @returns 등록된 빌링키 정보
+   *
+   * @example
+   * ```typescript
+   * const billingKey = await client.subscription.confirmBillingKey({
+   *     customer_key: 'cust_xxxxx',
+   *     auth_key: 'auth_xxxxx',
+   *     customer_email: 'test@example.com',
+   *     customer_name: '홍길동',
+   *     is_default: true
+   * })
+   * ```
+   */
+  async confirmBillingKey(data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/subscriptions/billing-keys/confirm`, data);
+  }
+  /**
+   * 빌링키 목록 조회
+   *
+   * @param customerId - 특정 고객의 빌링키만 조회 (선택)
+   * @returns 빌링키 목록
+   *
+   * @example
+   * ```typescript
+   * const { billing_keys } = await client.subscription.listBillingKeys()
+   * console.log(`등록된 카드: ${billing_keys.length}개`)
+   * ```
+   */
+  async listBillingKeys(customerId) {
+    const prefix = this.getPublicPrefix();
+    const query = customerId ? `?customer_id=${customerId}` : "";
+    return this.http.get(`${prefix}/subscriptions/billing-keys${query}`);
+  }
+  /**
+   * 빌링키 상세 조회
+   *
+   * @param billingKeyId - 빌링키 ID
+   * @returns 빌링키 상세 정보
+   */
+  async getBillingKey(billingKeyId) {
+    const prefix = this.getPublicPrefix();
+    return this.http.get(`${prefix}/subscriptions/billing-keys/${billingKeyId}`);
+  }
+  /**
+   * 빌링키 수정
+   *
+   * @param billingKeyId - 빌링키 ID
+   * @param data - 수정 정보
+   * @returns 수정된 빌링키 정보
+   *
+   * @example
+   * ```typescript
+   * await client.subscription.updateBillingKey(billingKeyId, {
+   *     card_nickname: '주 결제 카드',
+   *     is_default: true
+   * })
+   * ```
+   */
+  async updateBillingKey(billingKeyId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.patch(`${prefix}/subscriptions/billing-keys/${billingKeyId}`, data);
+  }
+  /**
+   * 빌링키 삭제
+   *
+   * @param billingKeyId - 빌링키 ID
+   */
+  async deleteBillingKey(billingKeyId) {
+    const prefix = this.getPublicPrefix();
+    return this.http.delete(`${prefix}/subscriptions/billing-keys/${billingKeyId}`);
+  }
+  // =====================
+  // Subscription APIs
+  // =====================
+  /**
+   * 구독 생성
+   * 정기결제 구독을 생성합니다.
+   *
+   * @param data - 구독 정보
+   * @returns 생성된 구독 정보
+   *
+   * @example
+   * ```typescript
+   * const subscription = await client.subscription.create({
+   *     billing_key_id: 'bk_xxxxx',
+   *     plan_name: '프리미엄 플랜',
+   *     amount: 9900,
+   *     billing_cycle: 'monthly',
+   *     billing_day: 15,  // 매월 15일 결제
+   *     trial_days: 7     // 7일 무료 체험
+   * })
+   * ```
+   */
+  async create(data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/subscriptions`, data);
+  }
+  /**
+   * 구독 목록 조회
+   *
+   * @param params - 조회 옵션
+   * @returns 구독 목록
+   *
+   * @example
+   * ```typescript
+   * const { subscriptions, total } = await client.subscription.list({
+   *     status: 'active',
+   *     limit: 10
+   * })
+   * ```
+   */
+  async list(params) {
+    const prefix = this.getPublicPrefix();
+    const query = new URLSearchParams();
+    if (params?.status) query.set("status", params.status);
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    const queryString = query.toString();
+    return this.http.get(`${prefix}/subscriptions${queryString ? "?" + queryString : ""}`);
+  }
+  /**
+   * 구독 상세 조회
+   *
+   * @param subscriptionId - 구독 ID
+   * @returns 구독 상세 정보
+   */
+  async get(subscriptionId) {
+    const prefix = this.getPublicPrefix();
+    return this.http.get(`${prefix}/subscriptions/${subscriptionId}`);
+  }
+  /**
+   * 구독 수정
+   *
+   * @param subscriptionId - 구독 ID
+   * @param data - 수정 정보
+   * @returns 수정된 구독 정보
+   *
+   * @example
+   * ```typescript
+   * await client.subscription.update(subscriptionId, {
+   *     plan_name: '엔터프라이즈 플랜',
+   *     amount: 29900
+   * })
+   * ```
+   */
+  async update(subscriptionId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.patch(`${prefix}/subscriptions/${subscriptionId}`, data);
+  }
+  /**
+   * 구독 일시정지
+   *
+   * @param subscriptionId - 구독 ID
+   * @param data - 일시정지 정보
+   * @returns 일시정지된 구독 정보
+   *
+   * @example
+   * ```typescript
+   * await client.subscription.pause(subscriptionId, {
+   *     reason: '고객 요청'
+   * })
+   * ```
+   */
+  async pause(subscriptionId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/subscriptions/${subscriptionId}/pause`, data || {});
+  }
+  /**
+   * 구독 재개
+   *
+   * @param subscriptionId - 구독 ID
+   * @returns 재개된 구독 정보
+   *
+   * @example
+   * ```typescript
+   * await client.subscription.resume(subscriptionId)
+   * ```
+   */
+  async resume(subscriptionId) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/subscriptions/${subscriptionId}/resume`, {});
+  }
+  /**
+   * 구독 취소
+   *
+   * @param subscriptionId - 구독 ID
+   * @param data - 취소 정보
+   * @returns 취소된 구독 정보
+   *
+   * @example
+   * ```typescript
+   * // 현재 기간 종료 후 취소
+   * await client.subscription.cancel(subscriptionId, {
+   *     reason: '서비스 불만족'
+   * })
+   *
+   * // 즉시 취소
+   * await client.subscription.cancel(subscriptionId, {
+   *     reason: '즉시 해지 요청',
+   *     immediate: true
+   * })
+   * ```
+   */
+  async cancel(subscriptionId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/subscriptions/${subscriptionId}/cancel`, data);
+  }
+  // =====================
+  // Subscription Payment APIs
+  // =====================
+  /**
+   * 구독 결제 이력 조회
+   *
+   * @param subscriptionId - 구독 ID
+   * @param params - 조회 옵션
+   * @returns 결제 이력 목록
+   *
+   * @example
+   * ```typescript
+   * const { payments } = await client.subscription.listPayments(subscriptionId, {
+   *     limit: 10
+   * })
+   * ```
+   */
+  async listPayments(subscriptionId, params) {
+    const prefix = this.getPublicPrefix();
+    const query = new URLSearchParams();
+    if (params?.status) query.set("status", params.status);
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    const queryString = query.toString();
+    return this.http.get(
+      `${prefix}/subscriptions/${subscriptionId}/payments${queryString ? "?" + queryString : ""}`
+    );
+  }
+  // =====================
+  // Direct Charge APIs
+  // =====================
+  /**
+   * 빌링키로 즉시 결제
+   * 구독 없이 빌링키로 일회성 결제를 진행합니다.
+   *
+   * @param data - 결제 정보
+   * @returns 결제 결과
+   *
+   * @example
+   * ```typescript
+   * const result = await client.subscription.chargeWithBillingKey({
+   *     billing_key_id: 'bk_xxxxx',
+   *     amount: 15000,
+   *     order_name: '추가 결제'
+   * })
+   *
+   * if (result.status === 'DONE') {
+   *     console.log('결제 완료!')
+   * }
+   * ```
+   */
+  async chargeWithBillingKey(data) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/subscriptions/charge`, data);
+  }
+};
+
+// src/api/push.ts
+var PushAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * API Key 인증 시 /v1/public 접두사 반환
+   */
+  getPublicPrefix() {
+    return this.http.hasApiKey() ? "/v1/public" : "/v1";
+  }
+  // ============ Device Registration ============
+  /**
+   * 디바이스 등록 (APNS/FCM 토큰)
+   *
+   * @param request 디바이스 등록 정보
+   * @returns 등록된 디바이스 정보
+   *
+   * @example
+   * ```typescript
+   * // iOS 디바이스 등록
+   * const device = await cb.push.registerDevice({
+   *     device_token: 'apns-token-here',
+   *     platform: 'ios',
+   *     device_name: 'iPhone 15 Pro',
+   *     device_model: 'iPhone15,2',
+   *     os_version: '17.0',
+   *     app_version: '1.0.0',
+   * })
+   *
+   * // Android 디바이스 등록
+   * const device = await cb.push.registerDevice({
+   *     device_token: 'fcm-token-here',
+   *     platform: 'android',
+   *     device_name: 'Galaxy S24',
+   * })
+   * ```
+   */
+  async registerDevice(request) {
+    const prefix = this.getPublicPrefix();
+    return this.http.post(`${prefix}/push/devices`, request);
+  }
+  /**
+   * 디바이스 등록 해제
+   *
+   * @param deviceId 디바이스 ID
+   *
+   * @example
+   * ```typescript
+   * await cb.push.unregisterDevice('device-id-here')
+   * ```
+   */
+  async unregisterDevice(deviceId) {
+    const prefix = this.getPublicPrefix();
+    await this.http.delete(`${prefix}/push/devices/${deviceId}`);
+  }
+  /**
+   * 현재 등록된 디바이스 목록 조회
+   *
+   * @returns 디바이스 목록
+   */
+  async getDevices() {
+    const prefix = this.getPublicPrefix();
+    const response = await this.http.get(`${prefix}/push/devices`);
+    return response.devices || [];
+  }
+  // ============ Topic Subscription ============
+  /**
+   * 토픽 구독
+   *
+   * @param topicName 토픽 이름
+   *
+   * @example
+   * ```typescript
+   * // 공지사항 토픽 구독
+   * await cb.push.subscribeTopic('announcements')
+   *
+   * // 마케팅 토픽 구독
+   * await cb.push.subscribeTopic('marketing')
+   * ```
+   */
+  async subscribeTopic(topicName) {
+    const prefix = this.getPublicPrefix();
+    const request = { topic_name: topicName };
+    await this.http.post(`${prefix}/push/topics/subscribe`, request);
+  }
+  /**
+   * 토픽 구독 해제
+   *
+   * @param topicName 토픽 이름
+   *
+   * @example
+   * ```typescript
+   * await cb.push.unsubscribeTopic('marketing')
+   * ```
+   */
+  async unsubscribeTopic(topicName) {
+    const prefix = this.getPublicPrefix();
+    const request = { topic_name: topicName };
+    await this.http.post(`${prefix}/push/topics/unsubscribe`, request);
+  }
+  /**
+   * 구독 중인 토픽 목록 조회
+   *
+   * @returns 구독 중인 토픽 이름 목록
+   */
+  async getSubscribedTopics() {
+    const prefix = this.getPublicPrefix();
+    const response = await this.http.get(`${prefix}/push/topics/subscribed`);
+    return response.topics || [];
+  }
+  // ============ Web Push ============
+  /**
+   * VAPID Public Key 조회 (Web Push용)
+   *
+   * @returns VAPID Public Key
+   *
+   * @example
+   * ```typescript
+   * const vapidKey = await cb.push.getVAPIDPublicKey()
+   *
+   * // Service Worker에서 Push 구독
+   * const registration = await navigator.serviceWorker.ready
+   * const subscription = await registration.pushManager.subscribe({
+   *     userVisibleOnly: true,
+   *     applicationServerKey: urlBase64ToUint8Array(vapidKey.public_key)
+   * })
+   *
+   * // 구독 정보 등록
+   * await cb.push.registerWebPush(subscription)
+   * ```
+   */
+  async getVAPIDPublicKey() {
+    const prefix = this.getPublicPrefix();
+    return this.http.get(`${prefix}/push/vapid-key`);
+  }
+  /**
+   * Web Push 구독 등록
+   *
+   * @param subscription PushSubscription 객체 또는 WebPushSubscription
+   *
+   * @example
+   * ```typescript
+   * // 브라우저에서 Push 구독 후 등록
+   * const registration = await navigator.serviceWorker.ready
+   * const subscription = await registration.pushManager.subscribe({
+   *     userVisibleOnly: true,
+   *     applicationServerKey: vapidPublicKey
+   * })
+   *
+   * await cb.push.registerWebPush(subscription)
+   * ```
+   */
+  async registerWebPush(subscription) {
+    const prefix = this.getPublicPrefix();
+    let webPushData;
+    if ("toJSON" in subscription) {
+      const json = subscription.toJSON();
+      webPushData = {
+        endpoint: json.endpoint || "",
+        expirationTime: json.expirationTime,
+        keys: {
+          p256dh: json.keys?.p256dh || "",
+          auth: json.keys?.auth || ""
+        }
+      };
+    } else {
+      webPushData = subscription;
+    }
+    const request = {
+      device_token: webPushData.endpoint,
+      platform: "web",
+      device_id: this.generateDeviceId(),
+      device_name: this.getBrowserName(),
+      os_version: this.getOSInfo()
+    };
+    return this.http.post(`${prefix}/push/devices/web`, {
+      ...request,
+      web_push_subscription: webPushData
+    });
+  }
+  /**
+   * Web Push 구독 해제
+   */
+  async unregisterWebPush() {
+    const prefix = this.getPublicPrefix();
+    await this.http.delete(`${prefix}/push/devices/web`);
+  }
+  // ============ Helper Methods ============
+  /**
+   * 브라우저 고유 ID 생성 (localStorage에 저장)
+   */
+  generateDeviceId() {
+    if (typeof window === "undefined" || typeof localStorage === "undefined") {
+      return `device_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    const storageKey = "cb_push_device_id";
+    let deviceId = localStorage.getItem(storageKey);
+    if (!deviceId) {
+      deviceId = `web_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      localStorage.setItem(storageKey, deviceId);
+    }
+    return deviceId;
+  }
+  /**
+   * 브라우저 이름 감지
+   */
+  getBrowserName() {
+    if (typeof navigator === "undefined") {
+      return "Unknown Browser";
+    }
+    const userAgent = navigator.userAgent;
+    if (userAgent.includes("Chrome") && !userAgent.includes("Edg")) {
+      return "Chrome";
+    } else if (userAgent.includes("Safari") && !userAgent.includes("Chrome")) {
+      return "Safari";
+    } else if (userAgent.includes("Firefox")) {
+      return "Firefox";
+    } else if (userAgent.includes("Edg")) {
+      return "Edge";
+    } else if (userAgent.includes("Opera") || userAgent.includes("OPR")) {
+      return "Opera";
+    }
+    return "Unknown Browser";
+  }
+  /**
+   * OS 정보 감지
+   */
+  getOSInfo() {
+    if (typeof navigator === "undefined") {
+      return "Unknown OS";
+    }
+    const userAgent = navigator.userAgent;
+    if (userAgent.includes("Windows")) {
+      return "Windows";
+    } else if (userAgent.includes("Mac OS")) {
+      return "macOS";
+    } else if (userAgent.includes("Linux")) {
+      return "Linux";
+    } else if (userAgent.includes("Android")) {
+      return "Android";
+    } else if (userAgent.includes("iOS") || userAgent.includes("iPhone") || userAgent.includes("iPad")) {
+      return "iOS";
+    }
+    return "Unknown OS";
+  }
+};
+
+// src/api/video.ts
+var DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+var VideoProcessingError = class extends Error {
+  constructor(message, video) {
+    super(message);
+    this.name = "VideoProcessingError";
+    this.video = video;
+  }
+};
+var VideoAPI = class {
+  constructor(http, videoBaseUrl) {
+    this.http = http;
+    this.videoBaseUrl = videoBaseUrl || this.getDefaultVideoUrl();
+  }
+  getDefaultVideoUrl() {
+    if (typeof window !== "undefined") {
+      const hostname = window.location.hostname;
+      if (hostname === "localhost" || hostname === "127.0.0.1") {
+        return "http://localhost:8089";
+      }
+    }
+    return "https://video.connectbase.world";
+  }
+  getPublicPrefix() {
+    return this.http.hasApiKey() ? "/v1/public" : "/v1";
+  }
+  async videoFetch(method, path, body) {
+    const headers = {};
+    const apiKey = this.http.getApiKey();
+    if (apiKey) {
+      headers["X-API-Key"] = apiKey;
+    }
+    const accessToken = this.http.getAccessToken();
+    if (accessToken) {
+      headers["Authorization"] = `Bearer ${accessToken}`;
+    }
+    if (body && !(body instanceof FormData)) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(`${this.videoBaseUrl}${path}`, {
+      method,
+      headers,
+      body: body instanceof FormData ? body : body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({
+        message: response.statusText
+      }));
+      throw new ApiError(response.status, errorData.message || "Unknown error");
+    }
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
+      return {};
+    }
+    return response.json();
+  }
+  // ========== Video Operations ==========
+  /**
+   * Upload a video file with chunked upload support
+   */
+  async upload(file, options) {
+    const prefix = this.getPublicPrefix();
+    const session = await this.videoFetch("POST", `${prefix}/uploads`, {
+      filename: file.name,
+      size: file.size,
+      mime_type: file.type,
+      title: options.title,
+      description: options.description,
+      visibility: options.visibility || "private",
+      tags: options.tags,
+      channel_id: options.channel_id
+    });
+    const chunkSize = session.chunk_size || DEFAULT_CHUNK_SIZE;
+    const totalChunks = Math.ceil(file.size / chunkSize);
+    let uploadedChunks = 0;
+    const startTime = Date.now();
+    let lastProgressTime = startTime;
+    let lastUploadedBytes = 0;
+    for (let i = 0; i < totalChunks; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, file.size);
+      const chunk = file.slice(start, end);
+      const formData = new FormData();
+      formData.append("chunk", chunk);
+      formData.append("chunk_index", String(i));
+      await this.videoFetch(
+        "POST",
+        `${prefix}/uploads/${session.session_id}/chunks`,
+        formData
+      );
+      uploadedChunks++;
+      const now = Date.now();
+      const timeDiff = (now - lastProgressTime) / 1e3;
+      const uploadedBytes = end;
+      const bytesDiff = uploadedBytes - lastUploadedBytes;
+      const currentSpeed = timeDiff > 0 ? bytesDiff / timeDiff : 0;
+      lastProgressTime = now;
+      lastUploadedBytes = uploadedBytes;
+      if (options.onProgress) {
+        options.onProgress({
+          phase: "uploading",
+          uploadedChunks,
+          totalChunks,
+          percentage: Math.round(uploadedChunks / totalChunks * 100),
+          currentSpeed
+        });
+      }
+    }
+    const result = await this.videoFetch(
+      "POST",
+      `${prefix}/uploads/${session.session_id}/complete`,
+      {}
+    );
+    return result.video;
+  }
+  /**
+   * Wait for video processing to complete
+   */
+  async waitForReady(videoId, options) {
+    const timeout = options?.timeout || 30 * 60 * 1e3;
+    const interval = options?.interval || 5e3;
+    const startTime = Date.now();
+    const prefix = this.getPublicPrefix();
+    while (Date.now() - startTime < timeout) {
+      const video = await this.videoFetch("GET", `${prefix}/videos/${videoId}`);
+      if (video.status === "ready") {
+        return video;
+      }
+      if (video.status === "failed") {
+        throw new VideoProcessingError("Video processing failed", video);
+      }
+      if (options?.onProgress) {
+        const readyQualities = video.qualities.filter((q) => q.status === "ready").length;
+        const totalQualities = video.qualities.length || 1;
+        options.onProgress({
+          phase: "processing",
+          uploadedChunks: 0,
+          totalChunks: 0,
+          percentage: Math.round(readyQualities / totalQualities * 100)
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new VideoProcessingError("Timeout waiting for video to be ready");
+  }
+  /**
+   * List videos
+   */
+  async list(options) {
+    const prefix = this.getPublicPrefix();
+    const params = new URLSearchParams();
+    if (options?.status) params.set("status", options.status);
+    if (options?.visibility) params.set("visibility", options.visibility);
+    if (options?.search) params.set("search", options.search);
+    if (options?.channel_id) params.set("channel_id", options.channel_id);
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.videoFetch("GET", `${prefix}/videos${query ? `?${query}` : ""}`);
+  }
+  /**
+   * Get a single video
+   */
+  async get(videoId) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("GET", `${prefix}/videos/${videoId}`);
+  }
+  /**
+   * Update video details
+   */
+  async update(videoId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("PATCH", `${prefix}/videos/${videoId}`, data);
+  }
+  /**
+   * Delete a video
+   */
+  async delete(videoId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("DELETE", `${prefix}/videos/${videoId}`);
+  }
+  /**
+   * Get streaming URL for a video
+   */
+  async getStreamUrl(videoId, quality) {
+    const prefix = this.getPublicPrefix();
+    const params = quality ? `?quality=${quality}` : "";
+    return this.videoFetch("GET", `${prefix}/videos/${videoId}/stream-url${params}`);
+  }
+  /**
+   * Get available thumbnails for a video
+   */
+  async getThumbnails(videoId) {
+    const prefix = this.getPublicPrefix();
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/videos/${videoId}/thumbnails`
+    );
+    return response.thumbnails;
+  }
+  /**
+   * Get transcode status
+   */
+  async getTranscodeStatus(videoId) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("GET", `${prefix}/videos/${videoId}/transcode/status`);
+  }
+  /**
+   * Retry failed transcoding
+   */
+  async retryTranscode(videoId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("POST", `${prefix}/videos/${videoId}/transcode/retry`, {});
+  }
+  // ========== Channel Operations ==========
+  /**
+   * Create a channel
+   */
+  async createChannel(data) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("POST", `${prefix}/channels`, data);
+  }
+  /**
+   * Get a channel
+   */
+  async getChannel(channelId) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("GET", `${prefix}/channels/${channelId}`);
+  }
+  /**
+   * Get channel by handle
+   */
+  async getChannelByHandle(handle) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("GET", `${prefix}/channels/handle/${handle}`);
+  }
+  /**
+   * Update channel
+   */
+  async updateChannel(channelId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("PATCH", `${prefix}/channels/${channelId}`, data);
+  }
+  /**
+   * Subscribe to a channel
+   */
+  async subscribeChannel(channelId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("POST", `${prefix}/channels/${channelId}/subscribe`, {});
+  }
+  /**
+   * Unsubscribe from a channel
+   */
+  async unsubscribeChannel(channelId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("DELETE", `${prefix}/channels/${channelId}/subscribe`);
+  }
+  // ========== Playlist Operations ==========
+  /**
+   * Create a playlist
+   */
+  async createPlaylist(channelId, data) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("POST", `${prefix}/channels/${channelId}/playlists`, data);
+  }
+  /**
+   * Get playlists for a channel
+   */
+  async getPlaylists(channelId) {
+    const prefix = this.getPublicPrefix();
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/channels/${channelId}/playlists`
+    );
+    return response.playlists;
+  }
+  /**
+   * Get playlist items
+   */
+  async getPlaylistItems(playlistId) {
+    const prefix = this.getPublicPrefix();
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/playlists/${playlistId}/items`
+    );
+    return response.items;
+  }
+  /**
+   * Add video to playlist
+   */
+  async addToPlaylist(playlistId, videoId, position) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("POST", `${prefix}/playlists/${playlistId}/items`, {
+      video_id: videoId,
+      position
+    });
+  }
+  /**
+   * Remove video from playlist
+   */
+  async removeFromPlaylist(playlistId, itemId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("DELETE", `${prefix}/playlists/${playlistId}/items/${itemId}`);
+  }
+  // ========== Shorts Operations ==========
+  /**
+   * Get shorts feed
+   */
+  async getShortsFeed(options) {
+    const prefix = this.getPublicPrefix();
+    const params = new URLSearchParams();
+    if (options?.cursor) params.set("cursor", options.cursor);
+    if (options?.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.videoFetch("GET", `${prefix}/shorts${query ? `?${query}` : ""}`);
+  }
+  /**
+   * Get trending shorts
+   */
+  async getTrendingShorts(limit) {
+    const prefix = this.getPublicPrefix();
+    const params = limit ? `?limit=${limit}` : "";
+    return this.videoFetch("GET", `${prefix}/shorts/trending${params}`);
+  }
+  /**
+   * Get a single shorts
+   */
+  async getShorts(shortsId) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("GET", `${prefix}/shorts/${shortsId}`);
+  }
+  // ========== Comment Operations ==========
+  /**
+   * Get comments for a video
+   */
+  async getComments(videoId, options) {
+    const prefix = this.getPublicPrefix();
+    const params = new URLSearchParams();
+    if (options?.cursor) params.set("cursor", options.cursor);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.sort) params.set("sort", options.sort);
+    const query = params.toString();
+    return this.videoFetch(
+      "GET",
+      `${prefix}/videos/${videoId}/comments${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * Post a comment
+   */
+  async postComment(videoId, content, parentId) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("POST", `${prefix}/videos/${videoId}/comments`, {
+      content,
+      parent_id: parentId
+    });
+  }
+  /**
+   * Delete a comment
+   */
+  async deleteComment(commentId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("DELETE", `${prefix}/comments/${commentId}`);
+  }
+  // ========== Like Operations ==========
+  /**
+   * Like a video
+   */
+  async likeVideo(videoId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("POST", `${prefix}/videos/${videoId}/like`, {});
+  }
+  /**
+   * Unlike a video
+   */
+  async unlikeVideo(videoId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("DELETE", `${prefix}/videos/${videoId}/like`);
+  }
+  // ========== Watch History Operations ==========
+  /**
+   * Get watch history
+   */
+  async getWatchHistory(options) {
+    const prefix = this.getPublicPrefix();
+    const params = new URLSearchParams();
+    if (options?.cursor) params.set("cursor", options.cursor);
+    if (options?.limit) params.set("limit", String(options.limit));
+    const query = params.toString();
+    return this.videoFetch(
+      "GET",
+      `${prefix}/watch-history${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * Clear watch history
+   */
+  async clearWatchHistory() {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("DELETE", `${prefix}/watch-history`);
+  }
+  /**
+   * Report watch progress
+   */
+  async reportWatchProgress(videoId, position, duration) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("POST", `${prefix}/videos/${videoId}/watch-progress`, {
+      position,
+      duration
+    });
+  }
+  // ========== Membership Operations ==========
+  /**
+   * Get membership tiers for a channel
+   */
+  async getMembershipTiers(channelId) {
+    const prefix = this.getPublicPrefix();
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/channels/${channelId}/memberships/tiers`
+    );
+    return response.tiers;
+  }
+  /**
+   * Join a membership tier
+   */
+  async joinMembership(channelId, tierId) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch(
+      "POST",
+      `${prefix}/channels/${channelId}/memberships/${tierId}/join`,
+      {}
+    );
+  }
+  /**
+   * Cancel membership
+   */
+  async cancelMembership(channelId, membershipId) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch(
+      "POST",
+      `${prefix}/channels/${channelId}/memberships/${membershipId}/cancel`,
+      {}
+    );
+  }
+  // ========== Super Chat Operations ==========
+  /**
+   * Send a super chat
+   */
+  async sendSuperChat(videoId, amount, message, currency) {
+    const prefix = this.getPublicPrefix();
+    return this.videoFetch("POST", `${prefix}/videos/${videoId}/super-chats`, {
+      amount,
+      message,
+      currency: currency || "USD"
+    });
+  }
+  /**
+   * Get super chats for a video
+   */
+  async getSuperChats(videoId) {
+    const prefix = this.getPublicPrefix();
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/videos/${videoId}/super-chats`
+    );
+    return response.super_chats;
+  }
+  // ========== Recommendation Operations ==========
+  /**
+   * Get recommended videos
+   */
+  async getRecommendations(limit) {
+    const prefix = this.getPublicPrefix();
+    const params = limit ? `?limit=${limit}` : "";
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/recommendations${params}`
+    );
+    return response.videos;
+  }
+  /**
+   * Get home feed
+   */
+  async getHomeFeed(limit) {
+    const prefix = this.getPublicPrefix();
+    const params = limit ? `?limit=${limit}` : "";
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/recommendations/home${params}`
+    );
+    return response.videos;
+  }
+  /**
+   * Get related videos
+   */
+  async getRelatedVideos(videoId, limit) {
+    const prefix = this.getPublicPrefix();
+    const params = limit ? `?limit=${limit}` : "";
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/recommendations/related/${videoId}${params}`
+    );
+    return response.videos;
+  }
+  /**
+   * Get trending videos
+   */
+  async getTrendingVideos(limit) {
+    const prefix = this.getPublicPrefix();
+    const params = limit ? `?limit=${limit}` : "";
+    const response = await this.videoFetch(
+      "GET",
+      `${prefix}/recommendations/trending${params}`
+    );
+    return response.videos;
+  }
+  /**
+   * Submit recommendation feedback
+   */
+  async submitFeedback(videoId, feedback) {
+    const prefix = this.getPublicPrefix();
+    await this.videoFetch("POST", `${prefix}/recommendations/feedback`, {
+      video_id: videoId,
+      feedback
+    });
+  }
+};
+
+// src/api/game.ts
+var getDefaultGameServerUrl = () => {
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "ws://localhost:8087";
+    }
+  }
+  return "wss://game.connectbase.world";
+};
+var GameRoom = class {
+  constructor(config) {
+    this.ws = null;
+    this.handlers = {};
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.pingInterval = null;
+    this.actionSequence = 0;
+    this._roomId = null;
+    this._state = null;
+    this._isConnected = false;
+    this.config = {
+      gameServerUrl: getDefaultGameServerUrl(),
+      autoReconnect: true,
+      maxReconnectAttempts: 5,
+      reconnectInterval: 1e3,
+      ...config
+    };
+  }
+  /**
+   * 현재 룸 ID
+   */
+  get roomId() {
+    return this._roomId;
+  }
+  /**
+   * 현재 게임 상태
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * 연결 상태
+   */
+  get isConnected() {
+    return this._isConnected;
+  }
+  /**
+   * 이벤트 핸들러 등록
+   */
+  on(event, handler) {
+    this.handlers[event] = handler;
+    return this;
+  }
+  /**
+   * 게임 서버에 연결
+   */
+  connect(roomId) {
+    return new Promise((resolve, reject) => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        resolve();
+        return;
+      }
+      const url = this.buildConnectionUrl(roomId);
+      this.ws = new WebSocket(url);
+      const onOpen = () => {
+        this._isConnected = true;
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+        this.handlers.onConnect?.();
+        resolve();
+      };
+      const onClose = (event) => {
+        this._isConnected = false;
+        this.stopPingInterval();
+        this.handlers.onDisconnect?.(event);
+        if (this.config.autoReconnect && event.code !== 1e3) {
+          this.scheduleReconnect(roomId);
+        }
+      };
+      const onError = (event) => {
+        this.handlers.onError?.(event);
+        reject(new Error("WebSocket connection failed"));
+      };
+      const onMessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      this.ws.addEventListener("open", onOpen, { once: true });
+      this.ws.addEventListener("close", onClose);
+      this.ws.addEventListener("error", onError, { once: true });
+      this.ws.addEventListener("message", onMessage);
+    });
+  }
+  /**
+   * 연결 해제
+   */
+  disconnect() {
+    this.stopPingInterval();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnected");
+      this.ws = null;
+    }
+    this._isConnected = false;
+    this._roomId = null;
+  }
+  /**
+   * 룸 생성
+   */
+  createRoom(config = {}) {
+    return new Promise((resolve, reject) => {
+      const handler = (msg) => {
+        if (msg.type === "room_created") {
+          const data = msg.data;
+          this._roomId = data.room_id;
+          this._state = data.initial_state;
+          resolve(data.initial_state);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("create_room", config, handler);
+    });
+  }
+  /**
+   * 룸 참가
+   */
+  joinRoom(roomId, metadata) {
+    return new Promise((resolve, reject) => {
+      const handler = (msg) => {
+        if (msg.type === "room_joined") {
+          const data = msg.data;
+          this._roomId = data.room_id;
+          this._state = data.initial_state;
+          resolve(data.initial_state);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("join_room", { room_id: roomId, metadata }, handler);
+    });
+  }
+  /**
+   * 룸 퇴장
+   */
+  leaveRoom() {
+    return new Promise((resolve, reject) => {
+      if (!this._roomId) {
+        reject(new Error("Not in a room"));
+        return;
+      }
+      const handler = (msg) => {
+        if (msg.type === "room_left") {
+          this._roomId = null;
+          this._state = null;
+          resolve();
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("leave_room", {}, handler);
+    });
+  }
+  /**
+   * 게임 액션 전송
+   */
+  sendAction(action) {
+    if (!this._roomId) {
+      throw new Error("Not in a room");
+    }
+    this.send("action", {
+      type: action.type,
+      data: action.data,
+      client_timestamp: action.clientTimestamp ?? Date.now(),
+      sequence: this.actionSequence++
+    });
+  }
+  /**
+   * 채팅 메시지 전송
+   */
+  sendChat(message) {
+    if (!this._roomId) {
+      throw new Error("Not in a room");
+    }
+    this.send("chat", { message });
+  }
+  /**
+   * 현재 상태 요청
+   */
+  requestState() {
+    return new Promise((resolve, reject) => {
+      if (!this._roomId) {
+        reject(new Error("Not in a room"));
+        return;
+      }
+      const handler = (msg) => {
+        if (msg.type === "state") {
+          const state = msg.data;
+          this._state = state;
+          resolve(state);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("get_state", {}, handler);
+    });
+  }
+  /**
+   * 룸 목록 조회
+   */
+  listRooms() {
+    return new Promise((resolve, reject) => {
+      const handler = (msg) => {
+        if (msg.type === "room_list") {
+          const data = msg.data;
+          resolve(data.rooms);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("list_rooms", {}, handler);
+    });
+  }
+  /**
+   * Ping 전송 (RTT 측정용)
+   */
+  ping() {
+    return new Promise((resolve, reject) => {
+      const timestamp = Date.now();
+      const handler = (msg) => {
+        if (msg.type === "pong") {
+          const pong = msg.data;
+          const rtt = Date.now() - pong.clientTimestamp;
+          this.handlers.onPong?.(pong);
+          resolve(rtt);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("ping", { timestamp }, handler);
+    });
+  }
+  // Private methods
+  buildConnectionUrl(roomId) {
+    const baseUrl = this.config.gameServerUrl;
+    const wsUrl = baseUrl.replace(/^http/, "ws");
+    const params = new URLSearchParams();
+    params.set("client_id", this.config.clientId);
+    if (roomId) {
+      params.set("room_id", roomId);
+    }
+    if (this.config.apiKey) {
+      params.set("api_key", this.config.apiKey);
+    }
+    if (this.config.accessToken) {
+      params.set("token", this.config.accessToken);
+    }
+    return `${wsUrl}/v1/game/ws?${params.toString()}`;
+  }
+  send(type, data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify({ type, data }));
+  }
+  sendWithHandler(type, data, handler) {
+    const messageHandler = (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        handler(msg);
+        this.ws?.removeEventListener("message", messageHandler);
+      } catch {
+      }
+    };
+    this.ws?.addEventListener("message", messageHandler);
+    this.send(type, data);
+  }
+  handleMessage(data) {
+    try {
+      const msg = JSON.parse(data);
+      switch (msg.type) {
+        case "delta":
+          this.handleDelta(msg.data);
+          break;
+        case "state":
+          this._state = msg.data;
+          this.handlers.onStateUpdate?.(this._state);
+          break;
+        case "player_event":
+          this.handlePlayerEvent(msg.data);
+          break;
+        case "chat":
+          this.handlers.onChat?.(msg.data);
+          break;
+        case "error":
+          this.handlers.onError?.(msg.data);
+          break;
+        default:
+          break;
+      }
+    } catch {
+      console.error("Failed to parse game message:", data);
+    }
+  }
+  handleDelta(data) {
+    const delta = data.delta;
+    if (this._state) {
+      for (const change of delta.changes) {
+        this.applyChange(change);
+      }
+      this._state.version = delta.toVersion;
+    }
+    this.handlers.onDelta?.(delta);
+  }
+  applyChange(change) {
+    if (!this._state) return;
+    const path = change.path.split(".");
+    let current = this._state.state;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = path[path.length - 1];
+    if (change.operation === "delete") {
+      delete current[lastKey];
+    } else {
+      current[lastKey] = change.value;
+    }
+  }
+  handlePlayerEvent(event) {
+    if (event.event === "joined") {
+      this.handlers.onPlayerJoined?.(event.player);
+    } else if (event.event === "left") {
+      this.handlers.onPlayerLeft?.(event.player);
+    }
+  }
+  scheduleReconnect(roomId) {
+    if (this.reconnectAttempts >= (this.config.maxReconnectAttempts ?? 5)) {
+      console.error("Max reconnect attempts reached");
+      return;
+    }
+    const delay = Math.min(
+      (this.config.reconnectInterval ?? 1e3) * Math.pow(2, this.reconnectAttempts),
+      3e4
+      // Max 30초
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      console.log(`Reconnecting... (attempt ${this.reconnectAttempts})`);
+      this.connect(roomId || this._roomId || void 0).catch(() => {
+      });
+    }, delay);
+  }
+  startPingInterval() {
+    this.pingInterval = setInterval(() => {
+      this.ping().catch(() => {
+      });
+    }, 3e4);
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+};
+var GameAPI = class {
+  constructor(http, gameServerUrl) {
+    this.http = http;
+    this.gameServerUrl = gameServerUrl || getDefaultGameServerUrl().replace(/^ws/, "http");
+  }
+  /**
+   * 게임 룸 클라이언트 생성
+   */
+  createClient(config) {
+    return new GameRoom({
+      ...config,
+      gameServerUrl: this.gameServerUrl.replace(/^http/, "ws"),
+      apiKey: this.http.getApiKey(),
+      accessToken: this.http.getAccessToken()
+    });
+  }
+  /**
+   * 룸 목록 조회 (HTTP)
+   */
+  async listRooms(appId) {
+    const response = await fetch(`${this.gameServerUrl}/v1/game/rooms${appId ? `?app_id=${appId}` : ""}`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to list rooms: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.rooms;
+  }
+  /**
+   * 룸 상세 조회 (HTTP)
+   */
+  async getRoom(roomId) {
+    const response = await fetch(`${this.gameServerUrl}/v1/game/rooms/${roomId}`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get room: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * 룸 생성 (HTTP, gRPC 대안)
+   */
+  async createRoom(appId, config = {}) {
+    const response = await fetch(`${this.gameServerUrl}/v1/game/rooms`, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        app_id: appId,
+        category_id: config.categoryId,
+        room_id: config.roomId,
+        tick_rate: config.tickRate,
+        max_players: config.maxPlayers,
+        metadata: config.metadata
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create room: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * 룸 삭제 (HTTP)
+   */
+  async deleteRoom(roomId) {
+    const response = await fetch(`${this.gameServerUrl}/v1/game/rooms/${roomId}`, {
+      method: "DELETE",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete room: ${response.statusText}`);
+    }
+  }
+  getHeaders() {
+    const headers = {};
+    const apiKey = this.http.getApiKey();
+    if (apiKey) {
+      headers["X-API-Key"] = apiKey;
+    }
+    const accessToken = this.http.getAccessToken();
+    if (accessToken) {
+      headers["Authorization"] = `Bearer ${accessToken}`;
+    }
+    return headers;
+  }
+};
+
+// src/api/game-transport.ts
+var WebTransportTransport = class {
+  constructor(config, onMessage, onClose, onError) {
+    this.type = "webtransport";
+    this.transport = null;
+    this.writer = null;
+    this.config = config;
+    this.onMessage = onMessage;
+    this.onClose = onClose;
+    this.onError = onError;
+  }
+  async connect() {
+    const url = this.buildUrl();
+    this.transport = new WebTransport(url);
+    await this.transport.ready;
+    if (this.config.useUnreliableDatagrams !== false) {
+      this.readDatagrams();
+    }
+    const stream = await this.transport.createBidirectionalStream();
+    this.writer = stream.writable.getWriter();
+    this.readStream(stream.readable);
+    this.transport.closed.then(() => {
+      this.onClose();
+    }).catch((error) => {
+      this.onError(error);
+    });
+  }
+  buildUrl() {
+    const baseUrl = this.config.gameServerUrl || "https://game.connectbase.world";
+    const httpsUrl = baseUrl.replace(/^ws/, "http").replace(/^http:/, "https:");
+    const params = new URLSearchParams();
+    params.set("client_id", this.config.clientId);
+    if (this.config.apiKey) {
+      params.set("api_key", this.config.apiKey);
+    }
+    if (this.config.accessToken) {
+      params.set("token", this.config.accessToken);
+    }
+    return `${httpsUrl}/v1/game/webtransport?${params.toString()}`;
+  }
+  async readDatagrams() {
+    if (!this.transport) return;
+    const reader = this.transport.datagrams.readable.getReader();
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        this.onMessage(value);
+      }
+    } catch (error) {
+    }
+  }
+  async readStream(readable) {
+    const reader = readable.getReader();
+    let buffer = new Uint8Array(0);
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        const newBuffer = new Uint8Array(buffer.length + value.length);
+        newBuffer.set(buffer);
+        newBuffer.set(value, buffer.length);
+        buffer = newBuffer;
+        while (buffer.length >= 4) {
+          const length = new DataView(buffer.buffer).getUint32(0, true);
+          if (buffer.length < 4 + length) break;
+          const message = buffer.slice(4, 4 + length);
+          buffer = buffer.slice(4 + length);
+          this.onMessage(message);
+        }
+      }
+    } catch (error) {
+    }
+  }
+  disconnect() {
+    if (this.transport) {
+      this.transport.close();
+      this.transport = null;
+      this.writer = null;
+    }
+  }
+  send(data, reliable = true) {
+    if (!this.transport) {
+      throw new Error("Not connected");
+    }
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    if (reliable) {
+      if (this.writer) {
+        const lengthPrefix = new Uint8Array(4);
+        new DataView(lengthPrefix.buffer).setUint32(0, bytes.length, true);
+        const prefixed = new Uint8Array(4 + bytes.length);
+        prefixed.set(lengthPrefix);
+        prefixed.set(bytes, 4);
+        this.writer.write(prefixed);
+      }
+    } else {
+      const maxSize = this.config.maxDatagramSize || 1200;
+      if (bytes.length <= maxSize) {
+        this.transport.datagrams.writable.getWriter().write(bytes);
+      } else {
+        console.warn("Datagram too large, falling back to reliable stream");
+        this.send(data, true);
+      }
+    }
+  }
+  isConnected() {
+    return this.transport !== null;
+  }
+};
+var WebSocketTransport = class {
+  constructor(config, onMessage, onClose, onError) {
+    this.type = "websocket";
+    this.ws = null;
+    this.config = config;
+    this.onMessage = onMessage;
+    this.onClose = onClose;
+    this.onError = onError;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      const url = this.buildUrl();
+      try {
+        this.ws = new WebSocket(url);
+        this.ws.binaryType = "arraybuffer";
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      const onOpen = () => {
+        resolve();
+      };
+      const onClose = () => {
+        this.onClose();
+      };
+      const onError = (_event) => {
+        const error = new Error("WebSocket error");
+        this.onError(error);
+        reject(error);
+      };
+      const onMessage = (event) => {
+        if (event.data instanceof ArrayBuffer) {
+          this.onMessage(new Uint8Array(event.data));
+        } else if (typeof event.data === "string") {
+          this.onMessage(new TextEncoder().encode(event.data));
+        }
+      };
+      this.ws.addEventListener("open", onOpen, { once: true });
+      this.ws.addEventListener("close", onClose);
+      this.ws.addEventListener("error", onError, { once: true });
+      this.ws.addEventListener("message", onMessage);
+    });
+  }
+  buildUrl() {
+    const baseUrl = this.config.gameServerUrl || "wss://game.connectbase.world";
+    const wsUrl = baseUrl.replace(/^http/, "ws");
+    const params = new URLSearchParams();
+    params.set("client_id", this.config.clientId);
+    if (this.config.apiKey) {
+      params.set("api_key", this.config.apiKey);
+    }
+    if (this.config.accessToken) {
+      params.set("token", this.config.accessToken);
+    }
+    return `${wsUrl}/v1/game/ws?${params.toString()}`;
+  }
+  disconnect() {
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnected");
+      this.ws = null;
+    }
+  }
+  send(data, _reliable) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Not connected");
+    }
+    if (typeof data === "string") {
+      this.ws.send(data);
+    } else {
+      this.ws.send(data);
+    }
+  }
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+};
+function isWebTransportSupported() {
+  return typeof WebTransport !== "undefined";
+}
+var GameRoomTransport = class {
+  constructor(config) {
+    this.transport = null;
+    this.handlers = {};
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.pingInterval = null;
+    this.actionSequence = 0;
+    this._roomId = null;
+    this._state = null;
+    this._isConnected = false;
+    this._connectionStatus = "disconnected";
+    this._lastError = null;
+    this._latency = 0;
+    this._transportType = "websocket";
+    this.decoder = new TextDecoder();
+    this.pendingHandlers = /* @__PURE__ */ new Map();
+    this.messageId = 0;
+    this.config = {
+      gameServerUrl: this.getDefaultGameServerUrl(),
+      autoReconnect: true,
+      maxReconnectAttempts: 5,
+      reconnectInterval: 1e3,
+      connectionTimeout: 1e4,
+      transport: "auto",
+      useUnreliableDatagrams: true,
+      ...config
+    };
+  }
+  getDefaultGameServerUrl() {
+    if (typeof window !== "undefined") {
+      const hostname = window.location.hostname;
+      if (hostname === "localhost" || hostname === "127.0.0.1") {
+        return "ws://localhost:8087";
+      }
+    }
+    return "wss://game.connectbase.world";
+  }
+  /**
+   * Current transport type being used
+   */
+  get transportType() {
+    return this._transportType;
+  }
+  /**
+   * Current room ID
+   */
+  get roomId() {
+    return this._roomId;
+  }
+  /**
+   * Current game state
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Connection status
+   */
+  get isConnected() {
+    return this._isConnected;
+  }
+  /**
+   * Connection state information
+   */
+  get connectionState() {
+    return {
+      status: this._connectionStatus,
+      transport: this._transportType === "auto" ? null : this._transportType,
+      roomId: this._roomId,
+      latency: this._latency,
+      reconnectAttempt: this.reconnectAttempts,
+      lastError: this._lastError || void 0
+    };
+  }
+  /**
+   * Current latency (ms)
+   */
+  get latency() {
+    return this._latency;
+  }
+  /**
+   * Register event handler
+   */
+  on(event, handler) {
+    this.handlers[event] = handler;
+    return this;
+  }
+  /**
+   * Connect to game server
+   */
+  async connect(roomId) {
+    if (this.transport?.isConnected()) {
+      return;
+    }
+    this._connectionStatus = this.reconnectAttempts > 0 ? "reconnecting" : "connecting";
+    const preferredTransport = this.config.transport || "auto";
+    const useWebTransport = (preferredTransport === "webtransport" || preferredTransport === "auto") && isWebTransportSupported();
+    const onMessage = (data) => {
+      this.handleMessage(this.decoder.decode(data));
+    };
+    const onClose = () => {
+      this._isConnected = false;
+      this._connectionStatus = "disconnected";
+      this.stopPingInterval();
+      this.handlers.onDisconnect?.(new CloseEvent("close"));
+      if (this.config.autoReconnect) {
+        this._connectionStatus = "reconnecting";
+        this.scheduleReconnect(roomId);
+      }
+    };
+    const onError = (error) => {
+      this._connectionStatus = "error";
+      this._lastError = error;
+      this.handlers.onError?.(error);
+    };
+    if (useWebTransport) {
+      try {
+        this.transport = new WebTransportTransport(
+          this.config,
+          onMessage,
+          onClose,
+          onError
+        );
+        await this.transport.connect();
+        this._transportType = "webtransport";
+      } catch (error) {
+        console.log("WebTransport failed, falling back to WebSocket");
+        this.transport = new WebSocketTransport(
+          this.config,
+          onMessage,
+          onClose,
+          onError
+        );
+        await this.transport.connect();
+        this._transportType = "websocket";
+      }
+    } else {
+      this.transport = new WebSocketTransport(
+        this.config,
+        onMessage,
+        onClose,
+        onError
+      );
+      await this.transport.connect();
+      this._transportType = "websocket";
+    }
+    this._isConnected = true;
+    this._connectionStatus = "connected";
+    this._lastError = null;
+    this.reconnectAttempts = 0;
+    this.startPingInterval();
+    this.handlers.onConnect?.();
+    if (roomId) {
+      await this.joinRoom(roomId);
+    }
+  }
+  /**
+   * Disconnect from server
+   */
+  disconnect() {
+    this.stopPingInterval();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.transport) {
+      this.transport.disconnect();
+      this.transport = null;
+    }
+    this._isConnected = false;
+    this._connectionStatus = "disconnected";
+    this._roomId = null;
+    this._state = null;
+  }
+  /**
+   * Create a new room
+   */
+  async createRoom(config = {}) {
+    return new Promise((resolve, reject) => {
+      const handler = (msg) => {
+        if (msg.type === "room_created") {
+          const data = msg.data;
+          this._roomId = data.room_id;
+          this._state = data.initial_state;
+          resolve(data.initial_state);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("create_room", config, handler);
+    });
+  }
+  /**
+   * Join an existing room
+   */
+  async joinRoom(roomId, metadata) {
+    return new Promise((resolve, reject) => {
+      const handler = (msg) => {
+        if (msg.type === "room_joined") {
+          const data = msg.data;
+          this._roomId = data.room_id;
+          this._state = data.initial_state;
+          resolve(data.initial_state);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("join_room", { room_id: roomId, metadata }, handler);
+    });
+  }
+  /**
+   * Leave current room
+   */
+  async leaveRoom() {
+    return new Promise((resolve, reject) => {
+      if (!this._roomId) {
+        reject(new Error("Not in a room"));
+        return;
+      }
+      const handler = (msg) => {
+        if (msg.type === "room_left") {
+          this._roomId = null;
+          this._state = null;
+          resolve();
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("leave_room", {}, handler);
+    });
+  }
+  /**
+   * Send game action
+   * Uses unreliable transport (datagrams) when WebTransport is available
+   */
+  sendAction(action, reliable = false) {
+    if (!this._roomId) {
+      throw new Error("Not in a room");
+    }
+    const message = JSON.stringify({
+      type: "action",
+      data: {
+        type: action.type,
+        data: action.data,
+        client_timestamp: action.clientTimestamp ?? Date.now(),
+        sequence: this.actionSequence++
+      }
+    });
+    const useReliable = reliable || this._transportType !== "webtransport";
+    this.transport?.send(message, useReliable);
+  }
+  /**
+   * Send chat message
+   */
+  sendChat(message) {
+    if (!this._roomId) {
+      throw new Error("Not in a room");
+    }
+    this.send("chat", { message });
+  }
+  /**
+   * Request current state
+   */
+  async requestState() {
+    return new Promise((resolve, reject) => {
+      if (!this._roomId) {
+        reject(new Error("Not in a room"));
+        return;
+      }
+      const handler = (msg) => {
+        if (msg.type === "state") {
+          const state = msg.data;
+          this._state = state;
+          resolve(state);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("get_state", {}, handler);
+    });
+  }
+  /**
+   * Ping server for latency measurement
+   */
+  async ping() {
+    return new Promise((resolve, reject) => {
+      const timestamp = Date.now();
+      const handler = (msg) => {
+        if (msg.type === "pong") {
+          const pong = msg.data;
+          const rtt = Date.now() - pong.clientTimestamp;
+          this._latency = rtt;
+          this.handlers.onPong?.(pong);
+          resolve(rtt);
+        } else if (msg.type === "error") {
+          reject(new Error(msg.data.message));
+        }
+      };
+      this.sendWithHandler("ping", { timestamp }, handler);
+    });
+  }
+  // Private methods
+  send(type, data) {
+    if (!this.transport?.isConnected()) {
+      throw new Error("Not connected");
+    }
+    const message = JSON.stringify({ type, data });
+    this.transport.send(message, true);
+  }
+  sendWithHandler(type, data, handler) {
+    const id = `msg_${this.messageId++}`;
+    this.pendingHandlers.set(id, handler);
+    setTimeout(() => {
+      this.pendingHandlers.delete(id);
+    }, 1e4);
+    this.send(type, { ...data, _msg_id: id });
+  }
+  handleMessage(data) {
+    try {
+      const msg = JSON.parse(data);
+      if (msg._msg_id && this.pendingHandlers.has(msg._msg_id)) {
+        const handler = this.pendingHandlers.get(msg._msg_id);
+        this.pendingHandlers.delete(msg._msg_id);
+        handler(msg);
+        return;
+      }
+      switch (msg.type) {
+        case "delta":
+          this.handleDelta(msg.data);
+          break;
+        case "state":
+          this._state = msg.data;
+          this.handlers.onStateUpdate?.(this._state);
+          break;
+        case "player_event":
+          this.handlePlayerEvent(msg.data);
+          break;
+        case "chat":
+          this.handlers.onChat?.(msg.data);
+          break;
+        case "error":
+          this.handlers.onError?.(msg.data);
+          break;
+      }
+    } catch {
+      console.error("Failed to parse game message:", data);
+    }
+  }
+  handleDelta(data) {
+    const delta = data.delta;
+    if (this._state) {
+      for (const change of delta.changes) {
+        this.applyChange(change);
+      }
+      this._state.version = delta.toVersion;
+    }
+    this.handlers.onDelta?.(delta);
+  }
+  applyChange(change) {
+    if (!this._state) return;
+    const path = change.path.split(".");
+    let current = this._state.state;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = path[path.length - 1];
+    if (change.operation === "delete") {
+      delete current[lastKey];
+    } else {
+      current[lastKey] = change.value;
+    }
+  }
+  handlePlayerEvent(event) {
+    if (event.event === "joined") {
+      this.handlers.onPlayerJoined?.(event.player);
+    } else if (event.event === "left") {
+      this.handlers.onPlayerLeft?.(event.player);
+    }
+  }
+  scheduleReconnect(roomId) {
+    if (this.reconnectAttempts >= (this.config.maxReconnectAttempts ?? 5)) {
+      console.error("Max reconnect attempts reached");
+      return;
+    }
+    const delay = Math.min(
+      (this.config.reconnectInterval ?? 1e3) * Math.pow(2, this.reconnectAttempts),
+      3e4
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      console.log(`Reconnecting... (attempt ${this.reconnectAttempts})`);
+      this.connect(roomId || this._roomId || void 0).catch(() => {
+      });
+    }, delay);
+  }
+  startPingInterval() {
+    this.pingInterval = setInterval(() => {
+      this.ping().catch(() => {
+      });
+    }, 3e4);
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+};
+
+// src/index.ts
+var getDefaultVideoUrl = () => {
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "http://localhost:8089";
+    }
+  }
+  return "https://video.connectbase.world";
+};
+var getDefaultBaseUrl = () => {
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "http://localhost:8080";
+    }
+  }
+  return "https://api.connectbase.world";
+};
+var getDefaultSocketUrl = () => {
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "http://localhost:8083";
+    }
+  }
+  return "https://socket.connectbase.world";
+};
+var getDefaultWebRTCUrl = () => {
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "http://localhost:8086";
+    }
+  }
+  return "https://webrtc.connectbase.world";
+};
+var getDefaultGameUrl = () => {
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "http://localhost:8087";
+    }
+  }
+  return "https://game.connectbase.world";
+};
+var DEFAULT_BASE_URL = getDefaultBaseUrl();
+var DEFAULT_SOCKET_URL = getDefaultSocketUrl();
+var DEFAULT_WEBRTC_URL = getDefaultWebRTCUrl();
+var DEFAULT_VIDEO_URL = getDefaultVideoUrl();
+var DEFAULT_GAME_URL = getDefaultGameUrl();
+var ConnectBase = class {
+  constructor(config = {}) {
+    const httpConfig = {
+      baseUrl: config.baseUrl || DEFAULT_BASE_URL,
+      apiKey: config.apiKey,
+      onTokenRefresh: config.onTokenRefresh,
+      onAuthError: config.onAuthError
+    };
+    this.http = new HttpClient(httpConfig);
+    this.auth = new AuthAPI(this.http);
+    this.database = new DatabaseAPI(this.http);
+    this.storage = new StorageAPI(this.http);
+    this.apiKey = new ApiKeyAPI(this.http);
+    this.functions = new FunctionsAPI(this.http);
+    this.realtime = new RealtimeAPI(this.http, config.socketUrl || DEFAULT_SOCKET_URL);
+    this.webrtc = new WebRTCAPI(this.http, config.webrtcUrl || DEFAULT_WEBRTC_URL);
+    this.errorTracker = new ErrorTrackerAPI(this.http, config.errorTracker);
+    this.oauth = new OAuthAPI(this.http);
+    this.payment = new PaymentAPI(this.http);
+    this.subscription = new SubscriptionAPI(this.http);
+    this.push = new PushAPI(this.http);
+    this.video = new VideoAPI(this.http, config.videoUrl || DEFAULT_VIDEO_URL);
+    this.game = new GameAPI(this.http, config.gameUrl || DEFAULT_GAME_URL);
+  }
+  /**
+   * 수동으로 토큰 설정 (기존 토큰으로 세션 복원 시)
+   */
+  setTokens(accessToken, refreshToken) {
+    this.http.setTokens(accessToken, refreshToken);
+  }
+  /**
+   * 토큰 제거
+   */
+  clearTokens() {
+    this.http.clearTokens();
+  }
+  /**
+   * 설정 업데이트
+   */
+  updateConfig(config) {
+    this.http.updateConfig(config);
+  }
+};
+var index_default = ConnectBase;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AuthError,
+  ConnectBase,
+  GameAPI,
+  GameRoom,
+  GameRoomTransport,
+  VideoProcessingError,
+  isWebTransportSupported
+});