Referência da API do SDK Combos

SDK 1.1.0 · Verificado em 2026-10-13. Esta é a API JavaScript usada pelos jogos por meio de window.combos. Ela documenta os 10 métodos globais e os 4 métodos do cliente TikTok, com entradas, resultado, comportamento em caso de falha e exemplo. Para um jogo completo, siga o tutorial TikTok; para integrar a interface, veja contas e localização.

As chamadas passam pelo host Combos. São métodos JavaScript, não endpoints REST: o jogo não precisa de URL base, chave de API, envelope de status HTTP nem mensagens postMessage construídas manualmente. O valor resolvido é o próprio resultado, sem uma propriedade externa data.

Ambiente de execução e configuração TypeScript

O player compatível do Combos injeta o SDK. Não instale um segundo script de execução nem sobrescreva window.combos. Uma página independente ou prévia local pode não ter esse objeto; verifique no código do navegador e mantenha a jogabilidade básica disponível. Não acesse window durante renderização no servidor.

Para autocompletar no editor, salve a declaração pública  como combos-host-sdk.d.ts junto ao código do jogo e inclua esse diretório no projeto TypeScript. O arquivo fornece apenas tipos. Os exemplos de TTLiveClient usam import type, sem acrescentar dependência de execução.

curl --fail --location https://combos.converge.ai/host-sdk.d.ts --output ./combos-host-sdk.d.ts

async function readCapabilities() {
  const sdk = window.combos;
  if (!sdk) return [];
  const { methods } = await sdk.init();
  return methods;
}

Cada bloco TypeScript é uma função auxiliar independente: chame-a pela sua interface e trate as rejeições de promessas. Funções terminadas em AfterClick devem partir de uma ação do jogador. O null de uma função auxiliar indica indisponibilidade ou cancelamento conforme o código; não é um retorno adicional do SDK. Os blocos JSON ilustram solicitações e resultados diretos, com identidades e horários fictícios. Adapte os textos de interface ao idioma do jogo.

Índice de métodos

A primeira chamada ao host também pode gastar até 3 segundos descobrindo capacidades. Esses são limites de espera do SDK, não garantias de serviço. Os métodos públicos não aceitam timeout, AbortSignal, callbacks de sucesso nem parâmetros extras de identidade.

Verifique o suporte antes de chamar

Use init().methods; a existência da função não basta. O host Web atual oferece checkSession e login; getUserInfo depende de um contexto de jogo confiável, requestI18n do suporte de tradução do host Play e TikTok da capacidade do host e de um contexto de inicialização registrado. Hosts Web e App antigos podem diferir.

O host Web atual não anuncia getSetting, authorize, openSetting nem getCloudAbilitySession. O contrato é documentado para hosts que os anunciem explicitamente. Publicar um jogo não habilita Cloud Ability ou TikTok automaticamente. Um método ausente da lista rejeita com unsupported antes de enviar sua solicitação ao host.

getTTLiveSession é o nome de uma capacidade interna. Verifique sua presença antes de usar getTTLiveClient(); não existe combos.getTTLiveSession() público. A API global também não oferece logout, request genérico, salvamento em nuvem, pagamento, ranking ou registro de presentes.

Inicialização e contas

combos.init()

combos.init(): Promise<ICombosHostInitResult>

Parâmetros: nenhum. Exige login: não. Retorna: uma promessa com methods, array de nomes de capacidades suportadas. Não autentica o jogador, abre interface nem inicia uma conexão TikTok.

Chamadas simultâneas compartilham a descoberta; o resultado fica em cache no documento atual do jogo. Outros métodos do host fazem essa descoberta automaticamente. Nomes desconhecidos e duplicados são removidos de uma lista válida. Se a descoberta falhar, o conteúdo for inválido ou o host não responder em 3 segundos, resolve com ['checkSession', 'login']. Uma lista vazia válida permanece vazia. Esse fallback serve à compatibilidade, mas não prova que uma página independente tenha um host funcionando. Chamadas posteriores ainda podem expirar. Não existe opção pública para forçar atualização.

A resposta abaixo é ilustrativa; não considere esses métodos universalmente disponíveis.

interface ICombosHostInitResult {
  methods: Array<
    | 'checkSession' | 'login' | 'getUserInfo' | 'requestI18n'
    | 'getSetting' | 'authorize' | 'openSetting'
    | 'getCloudAbilitySession' | 'getTTLiveSession'
  >;
}

{
  "methods": ["checkSession", "login", "getUserInfo", "requestI18n", "getTTLiveSession"]
}

combos.checkSession()

combos.checkSession(): Promise<boolean>

Parâmetros: nenhum. Exige login: não. Retorna: true quando o host informa uma sessão autenticada; caso contrário, false. Lê o estado sem abrir login. Só o booleano exato true indica autenticação; strings e objetos considerados verdadeiros não são aceitos.

Consulte imediatamente antes de cada ação independente de conta. Não armazene o resultado como garantia permanente: a sessão pode mudar depois. Erro de transporte ou tempo esgotado rejeita a promessa e não equivale a um false normal nem prova logout. Se receber false, deixe o jogador escolher entrar. Após login() bem-sucedido para a mesma ação, prossiga sem uma segunda verificação.

async function readSession() {
  const sdk = window.combos;
  if (!sdk) return null;
  const { methods } = await sdk.init();
  if (!methods.includes('checkSession')) return null;
  return sdk.checkSession();
}

combos.login()

combos.login(): Promise<ICombosHostLoginResult>

Parâmetros: nenhum; nunca envie ID de conta, senha ou token. Exige login: não. Efeito: abre o fluxo de login do host quando necessário. Inicie por uma ação do jogador e desabilite o controle enquanto aguarda.

Cancelar resolve normalmente. Popup bloqueado, falha de transporte ou sincronização de login e tempo esgotado rejeitam. Resultado malformado ou status desconhecido vira request_failed. No host Web atual, quem já está autenticado recebe success sem novo login. O resultado não inclui credenciais nem perfil; obtenha o perfil separadamente.

interface ICombosHostLoginResult {
  status: 'success' | 'cancelled';
}

async function loginAfterClick() {
  const sdk = window.combos;
  if (!sdk) return null;
  const { methods } = await sdk.init();
  if (!methods.includes('checkSession') || !methods.includes('login')) return null;
  if (await sdk.checkSession()) return { status: 'success' as const };
  return sdk.login();
}

{ "status": "success" }

combos.getUserInfo()

combos.getUserInfo(): Promise<ICombosHostUserInfo>

Parâmetros: nenhum. Pré-condições: getUserInfo anunciado, contexto de jogo confiável no host e sessão existente. Sem login, rejeita com session_required. Uma verificação de sessão bem-sucedida não elimina a necessidade de tratar uma expiração posterior.

Não há email, telefone, ID de usuário da plataforma, token de login ou sessão Cloud Ability. Não deduza identidade entre aplicativos usando openId, nem use essa resposta do navegador como prova de autenticação para seu servidor. Trate nomes como texto, não HTML. Identidades ausentes, campos de exibição que não sejam strings ou outro resultado inválido causam request_failed; erros do host/backend podem trazer outros códigos.

interface ICombosHostUserInfo {
  appId: string;
  openId: string;
  nickName: string;
  avatarUrl: string;
  locale: string;
}

async function readPlayerAfterClick() {
  const sdk = window.combos;
  if (!sdk) return null;
  const { methods } = await sdk.init();
  if (!methods.includes('checkSession') || !methods.includes('login') || !methods.includes('getUserInfo')) return null;
  if (!(await sdk.checkSession())) {
    const login = await sdk.login();
    if (login.status === 'cancelled') return null;
  }
  return sdk.getUserInfo();
}

{
  "appId": "app_example",
  "openId": "player_example",
  "nickName": "Alex",
  "avatarUrl": "",
  "locale": "en"
}

Localização do jogo

combos.requestI18n(params)

combos.requestI18n(params: ICombosHostRequestI18nParams): Promise<ICombosHostI18nResult>

Exige login: a ponte Web atual de tradução não exige autenticação. O host deve anunciar requestI18n. Exiba primeiro o texto original; tradução é uma melhoria assíncrona opcional, não uma condição para carregar o jogo.

Não existe targetLocale. O host escolhe o idioma atual do produto. O tratamento Web atual remove espaços externos do locale, ignora textos vazios ou não textuais, elimina duplicatas e solicita traduções em lotes de 50. O tamanho do lote não é um limite público de entrada do SDK. Prefira grupos pequenos de textos estáveis que possam terminar em 30 segundos; não traduza a cada quadro de animação.

interface ICombosHostRequestI18nParams {
  sourceLocale: string;
  sourceTexts: string[];
}
 
type ICombosHostI18nResult =
  | { needed: false }
  | { needed: true; locale: string; translations: Record<string, string> };

{
  "sourceLocale": "en",
  "sourceTexts": ["Play", "Score: {score}"]
}

{
  "needed": true,
  "locale": "zh-CN",
  "translations": { "Play": "开始", "Score: {score}": "得分：{score}" }
}

Idiomas equivalentes, ausência de texto utilizável, tradução indisponível e falhas atuais do backend Web podem resolver com { needed: false }. O SDK também converte respostas malformadas nesse ramo. Falta de suporte e tempo de transporte esgotado ainda podem rejeitar. Para cada tradução ausente ou vazia, mantenha o original. Aplique com textContent, nunca innerHTML.

Traduza modelos como Score: {score} antes de inserir valores; o SDK não interpola marcadores. Verifique se os marcadores necessários permanecem na tradução. Preserve os textos originais entre chamadas em vez de retraduzir textos já traduzidos com sourceLocale desatualizado.

async function translateVisibleLabels(nodes: HTMLElement[]) {
  const sourceTexts = nodes.map(node => node.textContent ?? '');
  const sdk = window.combos;
  if (!sdk) return;
  try {
    const { methods } = await sdk.init();
    if (!methods.includes('requestI18n')) return;
    const result = await sdk.requestI18n({ sourceLocale: 'en', sourceTexts });
    if (!result.needed) return;
    nodes.forEach((node, index) => {
      node.textContent = result.translations[sourceTexts[index]] || sourceTexts[index];
    });
  } catch {
    // Source text stays visible.
  }
}

APIs opcionais de Cloud Ability

Esses quatro métodos não são anunciados pelo host Web atual. Detecte cada um individualmente. Os exemplos são integração condicional para hosts compatíveis, não uma forma de habilitar a função. Uma autorização concedida também não prova que o dono do jogo ativou a capacidade correspondente.

type CombosHostPermissionScope = 'ai_model';
type CombosHostAuthorizationDecision =
  | 'AUTHORIZATION_DECISION_UNSPECIFIED'
  | 'AUTHORIZATION_DECISION_GRANTED'
  | 'AUTHORIZATION_DECISION_DENIED';
 
interface ICombosHostPlayableAuthorization {
  decision: CombosHostAuthorizationDecision;
  decidedAtMs: number;
}
type ICombosHostAuthSetting = Readonly<
  Partial<Record<CombosHostPermissionScope, ICombosHostPlayableAuthorization>>
>;
interface ICombosHostAuthorizeParams { scope: CombosHostPermissionScope }
interface ICombosHostCloudAbilitySession { session: string; expiresAtMs: number }

Essas APIs não recebem IDs de usuário, dispositivo, projeto, Post ou instância de partida. O host fornece o contexto confiável e controla as interfaces de login e permissão. Cumpra os requisitos de sessão antes de ações protegidas. Não repita solicitações automaticamente após uma negativa.

combos.getSetting()

combos.getSetting(): Promise<ICombosHostAuthSetting>

Parâmetros: nenhum. Espera máxima: 10 segundos. Lê as decisões do jogador atual para o jogo atual sem abrir ajustes. Resolve com ICombosHostAuthSetting; {} é válido quando não há decisão ai_model.

O SDK mantém apenas o escopo conhecido ai_model. Se existir, exige decisão concedida ou negada e decidedAtMs finito; registro inválido rejeita com request_failed. Não trate escopo ausente como negativa nem mantenha uma decisão antiga depois que o jogador alterar os ajustes.

{
  "ai_model": {
    "decision": "AUTHORIZATION_DECISION_GRANTED",
    "decidedAtMs": 1791800000000
  }
}

async function readPermissionSettings() {
  const sdk = window.combos;
  if (!sdk) return null;
  const { methods } = await sdk.init();
  if (!methods.includes('getSetting')) return null;
  return sdk.getSetting();
}

combos.authorize(params)

combos.authorize(params: ICombosHostAuthorizeParams): Promise<ICombosHostPlayableAuthorization>

Parâmetros: objeto obrigatório com scope: 'ai_model'; sem padrão, curinga, array de escopos ou decisão fornecida pelo chamador. Espera máxima: 5 minutos. Solicitação interativa de permissão controlada pelo host; inicie por uma ação do jogador.

Retorna um registro de autorização, não o objeto completo de ajustes. AUTHORIZATION_DECISION_DENIED é um resultado resolvido normal. Prossiga apenas após GRANTED; negar não justifica abrir outra solicitação automaticamente. Não há resultado cancelled. Interprete o fechamento da interface pelo registro ou rejeição real, não pelos status de login. Host incompatível, registro inválido, erro de transporte ou tempo esgotado rejeitam.

async function requestAiPermissionAfterClick() {
  const sdk = window.combos;
  if (!sdk) return null;
  const { methods } = await sdk.init();
  if (!methods.includes('authorize')) return null;
  return sdk.authorize({ scope: 'ai_model' });
}

{ "decision": "AUTHORIZATION_DECISION_DENIED", "decidedAtMs": 1791800000000 }

combos.openSetting()

combos.openSetting(): Promise<ICombosHostAuthSetting>

Parâmetros: nenhum. Espera máxima: 5 minutos. Abre os ajustes de permissão do host por uma ação do jogador e resolve com o ICombosHostAuthSetting resultante. Não aceita um objeto para conceder permissões silenciosamente.

Atualize a interface com os ajustes recebidos, incluindo escopos ausentes ou negados. O retorno não é booleano, registro individual nem status de login. Aplica a mesma validação de registros de getSetting(). Métodos incompatíveis, resultados inválidos e falhas do host/transporte rejeitam. O SDK não define um status de cancelamento separado.

async function openPermissionsAfterClick() {
  const sdk = window.combos;
  if (!sdk) return null;
  const { methods } = await sdk.init();
  if (!methods.includes('openSetting')) return null;
  return sdk.openSetting();
}

combos.getCloudAbilitySession()

combos.getCloudAbilitySession(): Promise<ICombosHostCloudAbilitySession>

Parâmetros: nenhum. Espera máxima: 10 segundos. Em um host compatível, resolve com { session, expiresAtMs } para a partida atual. A chamada não abre autorização nem prova acesso a todos os modelos de IA. Trate os erros de sessão, permissão e disponibilidade do host.

Mantenha a credencial em memória e use-a somente na integração Cloud Ability documentada por esse host. Nunca a coloque em logs, capturas, URLs, armazenamento local ou código-fonte. Verifique a expiração antes de usar, obtenha uma nova sessão quando necessário e descarte a antiga ao trocar de jogador ou partida. Não há refreshToken, parâmetro TTL ou garantia de autenticação genérica para backend. Resultado malformado rejeita com request_failed.

async function obtainCloudSession() {
  const sdk = window.combos;
  if (!sdk) return null;
  const { methods } = await sdk.init();
  if (!methods.includes('getCloudAbilitySession')) return null;
  const value = await sdk.getCloudAbilitySession();
  if (value.expiresAtMs <= Date.now()) throw new Error('Session already expired');
  return value; // Keep in memory only; never log or persist this value.
}

Referência do cliente TikTok

Atualmente não há um processo disponível para ativar a integração real com TikTok. O contrato abaixo não significa que um jogo recém-publicado possa receber presentes reais. Você pode criar o jogo, rodar o simulador e publicá-lo no Combos; a integração real precisa aguardar um processo de ativação oferecido pela plataforma.

O cliente gerencia a sessão de interação TikTok deste jogo, não o estado global da LIVE do streamer. Ele controla transporte, heartbeats, renovação de sessão e reconexões. O jogo controla instruções, execução dos efeitos, deduplicação persistente e resultados verdadeiros. O tutorial completo reúne mapeamento de presentes, publicação, materiais de preparação e o projeto executável.

combos.getTTLiveClient()

combos.getTTLiveClient(): TTLiveClient

Parâmetros: nenhum. Retorna: TTLiveClient de forma síncrona, sem requisição de rede nesse acesso. Chamadas repetidas retornam a mesma instância neste documento do SDK/jogo; não crie controladores concorrentes para componentes diferentes.

Verifique getTTLiveSession na lista de capacidades, como abaixo. Ter o objeto não prova suporte do host, login, início registrado ou conexão. Complete o fluxo de conta antes de uma conexão real. Chaves do provedor, credenciais CAS, launchData e URLs WebSocket são gerenciadas internamente; não há parâmetros para fornecê-las aqui.

async function getTikTokClient() {
  const sdk = window.combos;
  if (!sdk || typeof sdk.getTTLiveClient !== 'function') return null;
  const { methods } = await sdk.init();
  if (!methods.includes('getTTLiveSession')) return null;
  return sdk.getTTLiveClient();
}

client.connect(options)

client.connect(options: TTLiveConnectOptions): Promise<void>

Parâmetros: objeto options obrigatório. Seu onCommand obrigatório deve ser uma função que retorne boolean ou Promise<boolean>. A assinatura pública não inclui sala, streamer, token, reconexão ou tempo de espera.

Retorna Promise<void> após o quadro que confirma a prontidão do fluxo. Isso não prova efeito de presente nem conexão permanente; acompanhe o estado separadamente. A recuperação pode deixar a promessa pendente indefinidamente. Ofereça uma ação de parada antes de aguardar. Chamar connect novamente com conexão já solicitada reutiliza a promessa pendente ou resolve imediatamente; não substitui o manipulador original. Desconecte antes de trocar o manipulador.

Sem onCommand, rejeita com Error comum. Desconexão explícita ou estado terminal antes da prontidão também rejeita a promessa pendente. Falhas transitórias de transporte/sessão normalmente entram em recuperação, em vez de rejeitar imediatamente. IDs de comando distintos podem acionar manipuladores assíncronos simultâneos; serialize mudanças compartilhadas ou use transações.

interface TTLiveConnectOptions {
  onCommand: (command: TTLiveCommand) => boolean | Promise<boolean>;
}
interface TTLiveCommand {
  messageId: string;
  instruction: string;
  count: string;
  timestamp: string;
}

O exemplo ilustra um comando, não uma API de registro de presentes. O callback não contém IDs de espectadores, nomes, preços ou IDs de presentes reais. count é a quantidade da instrução mapeada, não necessariamente a quantidade de presentes ou seu valor em moedas.

{
  "messageId": "example-command-001",
  "instruction": "gift_flash",
  "count": "3",
  "timestamp": "1791800000"
}

A deduplicação em memória é limitada e se perde na desconexão explícita ou recarga do documento. Não garante execução persistente exatamente uma vez. Salve messageId, efeito e resultado atomicamente; reutilize o resultado salvo nas duplicatas. Não retorne false após um efeito parcial de resultado incerto. O exemplo Gift Arena implementa isso com uma transação.

Esta função auxiliar disponibiliza cancelamento imediatamente e registra o tratamento de rejeições. Forneça seu manipulador real e callbacks de interface que não lancem erros; ainda é possível aguardar connected. Guarde stop para conexões pendentes e estabelecidas.

import type { TTLiveClient, TTLiveConnectOptions, TTLiveStatus } from './combos-host-sdk';
 
function attachTikTok(
  client: TTLiveClient,
  onCommand: TTLiveConnectOptions['onCommand'],
  onStatus: (status: TTLiveStatus) => void,
  onConnectionError: (error: unknown) => void,
) {
  const unsubscribe = client.onStatusChange(onStatus);
  const connected = client.connect({ onCommand });
  void connected.catch(onConnectionError);
  return {
    connected,
    stop() {
      unsubscribe();
      client.disconnect();
    },
  };
}

client.getLiveStatus()

client.getLiveStatus(): Promise<TTLiveStatus>

Parâmetros: nenhum. Consulta o estado atual, publica-o aos assinantes e resolve com TTLiveStatus. Não inicia o fluxo de comandos. Internamente obtém a sessão do host (10 segundos de espera, mais descoberta inicial se necessária) e aplica um limite de 5 segundos à solicitação HTTP de estado.

Falhas de rede, HTTP, interpretação da sessão e conteúdo de estado inválido viram resultados de estado, normalmente unknown, não prova de ended. Um tt_not_launched do host vira ended com relaunch_game. Um estado terminal também para um cliente ativo. Durante o jogo, prefira assinaturas a consultas repetidas deste método.

interface TTLiveStatus {
  state: 'connecting' | 'connected' | 'recovering' | 'ended' | 'unknown';
  reason: string;
  action: 'none' | 'wait' | 'relaunch_game';
  confirmedAtMs: number;
}

Motivos conhecidos incluem platform_unconfirmed, transport_unavailable, client_disconnected, tt_not_launched e session_required. Oriente a recuperação por state e action; a lista não é exaustiva e motivos brutos não são mensagens prontas para jogadores.

import type { TTLiveClient } from './combos-host-sdk';
 
async function checkTikTokStatus(client: TTLiveClient) {
  const status = await client.getLiveStatus();
  return status;
}

{ "state": "unknown", "reason": "transport_unavailable", "action": "wait", "confirmedAtMs": 0 }

client.onStatusChange(listener)

client.onStatusChange(listener: (status: TTLiveStatus) => void): () => void

Parâmetros: listener síncrono obrigatório que recebe TTLiveStatus. Retorna: função de cancelamento da assinatura. O listener executa imediatamente com o estado atual e depois quando campos mudam; atualizações de confirmação do heartbeat podem ocorrer sem mudança de state.

Cancele a assinatura ao remover a interface responsável. Remover listener não desconecta o cliente; desconectar não remove listeners. Não lance erros no listener: a chamada imediata pode propagar um erro do consumidor. O exemplo imprime valores de protocolo para depuração; traduza as mensagens de produção.

import type { TTLiveClient } from './combos-host-sdk';
 
function showTikTokStatus(client: TTLiveClient, output: HTMLElement) {
  const unsubscribe = client.onStatusChange(status => {
    output.textContent = `${status.state} · ${status.action}`;
  });
  return unsubscribe; // Call when the UI is removed.
}

client.disconnect()

client.disconnect(): void

Parâmetros: nenhum. Retorna: undefined (void). Para temporizadores, tentativas pendentes e socket; limpa o cache de execução/resultados em memória; rejeita uma promessa de conexão ainda pendente. Publica unknown / client_disconnected / wait com confirmedAtMs: 0.

Não é uma API síncrona para encerrar a transmissão nem prova de ACK de encerramento no servidor. Não apaga seus registros persistidos nem desfaz um manipulador em execução. Remova assinaturas separadamente, proteja trabalho tardio e preserve os registros. O mesmo cliente pode conectar novamente; repetir a desconexão é seguro na limpeza.

import type { TTLiveClient } from './combos-host-sdk';
 
function stopTikTok(client: TTLiveClient, unsubscribe: () => void) {
  unsubscribe();
  client.disconnect();
}

Erros e recuperação

Falhas dos métodos do host rejeitam com Error contendo code e message como strings. Compare code, não a mensagem para humanos. A lista não é exaustiva: códigos do host/backend podem passar adiante. Falhas do ciclo TikTok podem ser Error sem code; getLiveStatus representa muitas falhas como valores de estado intencionalmente.

Separe decisões normais de falhas: checkSession() === false, login cancelled, autorização DENIED e tradução needed: false são resultados resolvidos. A função abaixo preserva essa distinção sem assumir uma classe específica nem registrar credenciais.

function readErrorCode(error: unknown): string | null {
  if (error && typeof error === 'object' && 'code' in error && typeof error.code === 'string') {
    return error.code;
  }
  return null;
}
 
async function checkAccountSafely() {
  const sdk = window.combos;
  if (!sdk) return { kind: 'unavailable' as const };
  try {
    return { kind: 'success' as const, signedIn: await sdk.checkSession() };
  } catch (error) {
    return { kind: 'error' as const, code: readErrorCode(error) };
  }
}

Os números são códigos conhecidos do host/backend, não garantia de Cloud Ability no host Web atual. Primeiro aplique as regras de disponibilidade de cada método. Para códigos desconhecidos, mostre um erro recuperável e registre apenas diagnósticos não sensíveis.

reason e action do TikTok são campos de estado, não códigos de erro do host. Rejeitar um manipulador não gera automaticamente um ACK de falha. Não envolva efeitos possivelmente já executados em catch(() => false). Um timeout do host só encerra a espera do SDK; não há cancelamento público de login, autorização ou tradução. Evite tentativas automáticas que reabram interfaces ou repitam ações de resultado incerto.

Ciclo de vida e limites de integração

1. Leia capacidades uma vez por documento e consulte a conta atual antes de cada nova ação de conta.
2. Vincule login e permissões a ações do jogador. Trate cancelamento/negativa sem reabrir a mesma solicitação.
3. Mantenha tradução opcional e texto original visível. Descarte resultados assíncronos obsoletos quando uma cena sair.
4. Defina um único responsável pelo cliente TikTok do documento. Assine o estado, conecte um manipulador persistente e permita cancelar enquanto aguarda.
5. Remova assinaturas e desconecte ao sair da interação. Preserve registros de execução e descarte sessões sensíveis quando a partida/conta terminar.

window.combos não oferece dispose() global, evento de mudança de conta, controle para cancelar login ou configuração global de timeout. Não use classes internas ou rotas HTTP não documentadas para preencher essas lacunas. O demo e seus limites de armazenamento são decisões do jogo, não APIs extras do SDK.

Versão, tipos e exemplos completos

A declaração pública TypeScript  define os tipos para o editor. Esta referência também verifica a validação de execução do SDK 1.1.0, limites de espera, capacidades Web, tradução e ciclo TikTok. A existência do tipo não prova disponibilidade em execução; versões futuras do SDK/host podem mudar o comportamento.

• Contas e localização: botões, continuação do login e atualização segura de texto.
• Criar um jogo TikTok: declaração de presentes, projeto completo, testes locais, publicação e preparação para futura integração e validação LIVE.
• Baixar Gift Arena: código completo com execução transacional de comandos.

Os exemplos são verificados contra os tipos públicos. Isso e o simulador local não comprovam login real, acesso Cloud Ability ou entrega de presentes pagos; essas validações exigem um host elegível, a conta correta e o jogo registrado quando houver um processo de ativação.