Copy-paste integration recipes

npm i @triggair/sdk
import { createClient } from '@triggair/sdk';
const tg = createClient({ key: 'tg_pk_your_key' });

<script type="module">
  import { createClient } from 'https://esm.sh/@triggair/sdk@1'; // pin @1 or an exact version
  const tg = createClient({ key: 'tg_pk_your_key' });
</script>

const { playerId } = await tg.login();

await tg.auth.providers();                                   // ['password','google'] or [] when off
const { needsConfirmation } = await tg.auth.signUp(email, password);   // emails a confirmation link
const r = await tg.auth.signInWithPassword(email, password);
await tg.auth.signInWithGoogle();                           // popup OAuth; call from a click. Same outcomes/merge
// r.outcome: 'linked' (first login carried this device's anonymous progress) | 'resumed' | 'created' | 'conflict'
if (r.merge) await tg.auth.resolveMerge('keep_account');     // or 'use_anonymous' to bring THIS device's progress in
tg.auth.onIdentityChanged(() => refetchPlayerData());        // the active player id may have switched
await tg.auth.sendPasswordReset(email);
await tg.auth.signOut();                                     // clears the session, back to a fresh anonymous player

await tg.saves.put('slot1', { level: 4 });        // last-write-wins
await tg.saves.put('slot1', data, { ifMatch: v });  // conflict-safe (throws save_conflict)
const { data } = await tg.saves.get('slot1');
tg.saves.queue('slot1', data);                     // durable/offline (replays on reconnect)

await tg.leaderboards.submit('high_scores', 9000);
const { entries } = await tg.leaderboards.top('high_scores', { limit: 10 });

await tg.stats.update([{ key: 'kills', op: 'increment', value: 1 }]);
const stats = await tg.stats.get();   // the player's own stats

await tg.achievements.report('first_win', 1);   // reward lands in the inbox on unlock
const status = await tg.daily.status();
if (status.claimable) await tg.daily.claim();     // server-day gated; streaks tracked

const items = await tg.inbox.list();
for (const it of items) if (it.claimable) await tg.inbox.claim(it.id);

const friends = await tg.social.friends();
await tg.social.request(otherPlayerId);   // friend request state machine
const { code } = await tg.social.share({ level: 7 });   // shareable invite/deep-link
const ctx = await tg.social.resolveShare(code);         // on the recipient's device

const wallet = await tg.economy.wallet();
await tg.economy.buy('main_store', listingId, { idem: uuid });  // server-authoritative price + balance
const items = await tg.economy.inventory();
await tg.economy.equip(itemId);

const odds = await tg.economy.loot.odds('bronze_box');  // disclosed drop rates
const result = await tg.economy.loot.open('bronze_box', { idem: uuid });
await tg.economy.energy.spend('stamina', 1, { idem: uuid });   // regenerating meter

const cfg = await tg.config.get();        // your published key→value blob
const live = await tg.config.liveEvents();

const { variant } = await tg.experiments.assign('checkout_cta');  // deterministic + sticky
if (variant === 'green') showGreen(); else showDefault();          // null ⇒ control (unknown/not-running)
await tg.experiments.track('checkout_cta', 'purchase');           // record the conversion

const v = await tg.moderation.check('username', name);   // allow | mask | block | review
if (v.verdict === 'block') { /* reject */ }
await tg.moderation.report('player', targetId, 'harassment');
const me = await tg.moderation.myStatus();   // the caller's bans/mutes (shadow hidden)

await tg.compliance.setAge({ birthYear: 2013 });  // mapped to a bracket + discarded (no DOB stored)
const view = await tg.compliance.status();        // { bracket, consent_state, gated: {feature:bool} }
if (view.gated.open_chat) { /* disable in UI; the server also enforces it */ }
await tg.compliance.requestConsent('parent@email');  // emails the parent a signed decision link

tg.track('level_complete');

await navigator.serviceWorker.register('/sw.js');
await tg.push.subscribe();   // fetches the VAPID key + registers the browser subscription (adults only — behavioral_push gate)
// SW: self.addEventListener('push', e => { const n = e.data.json(); self.registration.showNotification(n.title, { body: n.body, data: n }); });

const room = await tg.realtime.join('lobby');   // authed WebSocket; resolves on connect
room.on('presence', ({ members }) => renderRoster(members));
room.on('message', ({ from, data }) => renderChat(from, data));
room.on('typing', ({ player, state }) => showTyping(player, state));
room.on('reconnecting', ({ attempt }) => setStatus('reconnecting'));
room.on('reconnected', () => setStatus('live'));
room.send({ text: 'gg' });      // fan-out to everyone else
room.typing(true);              // ephemeral indicator (not stored/moderated)

try { /* game loop */ } catch (e) {
  tg.crashes.report(e.message, { stack: e.stack, appVersion: '1.4.0' });
}

const { match } = await tg.asyncMatch.create({ type: 'chess', opponents: [otherId] });
await tg.asyncMatch.turn(match.id, { state: next, version: match.version });

await tg.storage.put('decks', 'main', { cards: [] });
const { value } = await tg.storage.get('decks', 'main');
await tg.storage.incr('stats', 'wins', 1);   // atomic, avoids read-modify-write races

await tg.codes.redeem('LAUNCH2026');   // grants the campaign reward into the inbox
await tg.economy.gifts.send(friendId, { item: 'sword', qty: 1 }, { idem: uuid });

const opens = await tg.tournaments.list();      // status: scheduled | running | closed
await tg.tournaments.join(t.id);                // may charge entry_fee → { joined, reason?, fee_txn }
await tg.leaderboards.submit(t.board, score);   // you score via the tournament's own board
const top = await tg.tournaments.standings(t.id, { limit: 20 });
const me = await tg.tournaments.me(t.id);       // { entered, rank, prize }

await tg.leagues.join('ranked');                // placed in the lowest division for the season (idempotent)
const me = await tg.leagues.me('ranked');       // { division, division_name, rank, zone: promoting|safe|relegating }
const standings = await tg.leagues.divisionTop('ranked', me.division);

const { team } = await tg.teams.create('Night Owls', 'OWL', { privacy: 'invite_only' });
await tg.teams.join(teamId);                    // open teams; invite_only → tg.teams.requestJoin(teamId)
await tg.teams.invite(teamId, playerId);        // admin/owner; recipient calls tg.teams.acceptInvite(inviteId)
const t = await tg.teams.get(teamId);           // team + roster
const board = await tg.teams.leaderboard('weekly', { agg: 'sum' });   // members' scores aggregated

await tg.keyedBoards.submit('level_times', levelId, 42.5);   // score keyed to any entity (a UGC level, a team, a map)
const top = await tg.keyedBoards.top('level_times', { limit: 10 });
const mine = await tg.keyedBoards.entry('level_times', levelId);

const bp = await tg.battlePass.get('s3');       // { bp, tier, claimed lanes }
await tg.battlePass.claim('s3', tier, 'premium');   // reward → inbox; tier_not_earned / premium_required guard it
const quests = await tg.quests.list();          // progress per objective
await tg.quests.claim(questKey);                // when complete → reward lands in the inbox

const segments = await tg.segments.mine();      // [{ key, segment_id, source }]

const { item } = await tg.ugc.create('level', { title: 'Sky Temple', payload, allow_remix: true });
await tg.ugc.submit(item.id);                   // runs moderation → published or held for review
const feed = await tg.ugc.browse({ sort: 'popular' });   // new | top | popular
await tg.ugc.play(id);                          // debounced play count; unlocks rating
await tg.ugc.rate(id, 5); await tg.ugc.like(id);
const { item: fork } = await tg.ugc.remix(id);  // fork a remix-allowed item → new draft with lineage/attribution
const tree = await tg.ugc.lineage(id);          // parent (remix_of) + root_id + remixes

const { code } = await tg.mintRecoveryCode();  // show/share once
await tg.recover(code);                        // same anonymous player on a new device