@krtuworks/sdk 0.0.0-stage → 1.0.0

package/dist/identity.js

@@ -0,0 +1,437 @@
+import { CURRENT_TERMS, DEV_RESOURCE, GUEST_SCOPE, PLAYER_SCOPE } from './config.js';
+import { createDeviceKey, signProof } from './deviceKey.js';
+import { KrtuworksError } from './errors.js';
+import { base64Url, randomToken, sha256 } from './ids.js';
+import { jwtClaims } from './jwt.js';
+import { withLock } from './locks.js';
+import { errorOf, form, send } from './transport.js';
+export const DEVICE_KEY_GRANT = 'urn:krtuworks:params:oauth:grant-type:device-key';
+const PENDING_TTL_MS = 10 * 60_000;
+const REFRESH_EARLY_MS = 60_000;
+function signedOut() {
+    return new KrtuworksError('signed_out', 'No player is signed in.');
+}
+/** `terms_required` names the documents in its text: `Accept the current terms: TERMS:v2 PRIVACY:v1.` */
+export function termsIn(text) {
+    const named = text.match(/\b[A-Z][A-Z_]*:v\d+\b/g);
+    return named ? [...new Set(named)].join(' ') : null;
+}
+/**
+ * Who plays: the tokens, the device's guest key, and every way a player arrives or leaves. One token
+ * chain per sign-in client; every write of it happens under one lock (Web Locks across tabs), and a
+ * refresh writes its answer only over the refresh token it spent.
+ */
+export class Identity {
+    ctx;
+    tokens = null;
+    refreshing = null;
+    listeners = new Set();
+    /** Bumped whenever the signed-in player changes; an answer made for another one is dropped. */
+    generation = 0;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    key(name) {
+        return `krtu:${this.ctx.opts.clientId}:${name}`;
+    }
+    get lockName() {
+        return `krtu:${this.ctx.opts.clientId}:identity`;
+    }
+    get issuer() {
+        return `${this.ctx.opts.idOrigin}/oidc`;
+    }
+    async load() {
+        this.tokens = (await this.ctx.store.get(this.key('tokens'))) ?? null;
+        return this.player;
+    }
+    get player() {
+        const t = this.tokens;
+        return t ? { kind: t.kind, subject: t.subject, username: t.username, picture: t.picture } : null;
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit(change) {
+        for (const listener of this.listeners) {
+            try {
+                listener(change);
+            }
+            catch {
+                // a listener's failure is the app's; the SDK goes on
+            }
+        }
+    }
+    async meta() {
+        const meta = await this.ctx.store.get(this.key('meta'));
+        return { epoch: meta?.epoch ?? 0, waitingOwners: meta?.waitingOwners ?? [], guestRequest: meta?.guestRequest ?? null };
+    }
+    async saveMeta(meta) {
+        await this.ctx.store.set(this.key('meta'), meta);
+    }
+    /** The owners whose queues wait for a merge check, with the one to drop once it is answered. */
+    async waitingOwners() {
+        return (await this.meta()).waitingOwners;
+    }
+    /** The merge of `subject` is settled: it no longer waits, and its guest key (retired by the server) goes. */
+    async forgetWaitingOwner(subject) {
+        await withLock(this.lockName, async () => {
+            const meta = await this.meta();
+            meta.waitingOwners = meta.waitingOwners.filter((s) => s !== subject);
+            await this.saveMeta(meta);
+            const key = await this.ctx.store.get(this.key('deviceKey'));
+            if (key?.subject === subject)
+                await this.ctx.store.delete(this.key('deviceKey'));
+        });
+    }
+    /** Writes who is signed in (or nobody); a different player bumps the generation. */
+    async adopt(next) {
+        if (next)
+            await this.ctx.store.set(this.key('tokens'), next);
+        else
+            await this.ctx.store.delete(this.key('tokens'));
+        if ((this.tokens?.subject ?? null) !== (next?.subject ?? null))
+            this.generation += 1;
+        this.tokens = next;
+    }
+    // ── Tokens ──────────────────────────────────────────────────────────────
+    /**
+     * A valid access token, refreshed first when it is about to expire (or `force`: the server said it was).
+     * One refresh at a time in this tab (single flight) and across tabs (the lock).
+     */
+    async accessToken(force = false) {
+        const t = this.tokens;
+        if (!t)
+            throw signedOut();
+        if (!force && t.accessExpiresAt - REFRESH_EARLY_MS > this.ctx.clock.serverNow())
+            return t.accessToken;
+        this.refreshing ??= this.refresh(t.accessToken).finally(() => {
+            this.refreshing = null;
+        });
+        return (await this.refreshing).accessToken;
+    }
+    async token(fields) {
+        const { body, headers } = form({ client_id: this.ctx.opts.clientId, ...fields });
+        return send(this.ctx.fetch, this.ctx.clock, `${this.ctx.opts.idOrigin}/oidc/token`, { method: 'POST', headers, body });
+    }
+    tokensFrom(json, kind, previous) {
+        const access = json?.access_token;
+        if (typeof access !== 'string')
+            throw new KrtuworksError('invalid_response', 'The token answer carries no access token.');
+        const claims = jwtClaims(access);
+        const id = typeof json?.id_token === 'string' ? jwtClaims(json.id_token) : null;
+        const subject = String(claims.sub ?? id?.sub ?? '');
+        if (!subject)
+            throw new KrtuworksError('invalid_response', 'The access token names no player.');
+        const exp = typeof claims.exp === 'number' ? claims.exp * 1000 : this.ctx.clock.serverNow() + 600_000;
+        const sameSubject = previous?.subject === subject;
+        return {
+            kind,
+            subject,
+            username: typeof id?.preferred_username === 'string' ? id.preferred_username : sameSubject ? previous.username : null,
+            picture: typeof id?.picture === 'string' ? id.picture : sameSubject ? previous.picture : null,
+            accessToken: access,
+            accessExpiresAt: exp,
+            refreshToken: typeof json?.refresh_token === 'string' ? json.refresh_token : sameSubject ? previous.refreshToken : null,
+        };
+    }
+    async refresh(usedAccess) {
+        return withLock(this.lockName, async () => {
+            const stored = (await this.ctx.store.get(this.key('tokens'))) ?? null;
+            if (!stored) {
+                await this.adopt(null);
+                throw signedOut();
+            }
+            if (stored.accessToken !== usedAccess && stored.accessExpiresAt - REFRESH_EARLY_MS > this.ctx.clock.serverNow()) {
+                await this.adopt(stored);
+                return stored;
+            }
+            if (!stored.refreshToken) {
+                if (stored.kind === 'guest')
+                    return this.guestAgain(stored);
+                await this.adopt(null);
+                this.emit({ type: 'signed_out', reason: 'expired' });
+                throw signedOut();
+            }
+            const answer = await this.token({ grant_type: 'refresh_token', refresh_token: stored.refreshToken, resource: DEV_RESOURCE });
+            if (answer.status === 200) {
+                const next = this.tokensFrom(answer.json, stored.kind, stored);
+                await this.adopt(next);
+                return next;
+            }
+            return this.refused(stored, errorOf(answer));
+        });
+    }
+    /** A refresh the server refused, read by what it says; under the identity lock. */
+    async refused(stored, err) {
+        if (err.code !== 'invalid_grant')
+            throw err;
+        const why = String(err.details.description ?? err.message);
+        if (why.includes('account_merged'))
+            return this.markMergedLocked(stored.subject, null);
+        // A frozen app keeps its grants: the same refresh token works again once it is resumed.
+        if (why.includes('app_suspended'))
+            throw err;
+        await this.adopt(null);
+        if (why.includes('sanctioned')) {
+            this.emit({ type: 'sanctioned', reason: null });
+            throw new KrtuworksError('sanctioned', 'The player is banned from this app.', 403);
+        }
+        if (why.includes('account_deletion_pending')) {
+            this.emit({ type: 'deletion_pending' });
+            throw new KrtuworksError('account_deletion_pending', 'This account is waiting to be deleted.', 403);
+        }
+        // Revoked or expired: a guest signs in again with its key, anyone else needs the player.
+        if (stored.kind === 'guest')
+            return this.guestAgain(stored);
+        this.emit({ type: 'signed_out', reason: why });
+        throw signedOut();
+    }
+    async markMergedLocked(previousSubject, mergedInto) {
+        const meta = await this.meta();
+        if (!meta.waitingOwners.includes(previousSubject))
+            meta.waitingOwners.push(previousSubject);
+        await this.saveMeta(meta);
+        await this.adopt(null);
+        this.emit({ type: 'merged', previousSubject, mergedInto });
+        throw new KrtuworksError('account_merged', 'This account was merged into another one; sign in with it.', 401, null, { mergedInto });
+    }
+    /** The server said the player's account went into another one (401 account_merged). */
+    async markMerged(previousSubject, mergedInto) {
+        return withLock(this.lockName, () => this.markMergedLocked(previousSubject, mergedInto));
+    }
+    // ── Guests (device key) ──────────────────────────────────────────────────
+    async challenge(purpose) {
+        const { body, headers } = form({ client_id: this.ctx.opts.clientId, purpose });
+        const answer = await send(this.ctx.fetch, this.ctx.clock, `${this.ctx.opts.idOrigin}/oidc/device-key/challenge`, { method: 'POST', headers, body });
+        if (answer.status !== 200 || typeof answer.json?.nonce !== 'string')
+            throw errorOf(answer);
+        return answer.json.nonce;
+    }
+    async proofWith(key, purpose) {
+        const nonce = await this.challenge(purpose);
+        return signProof(key, { nonce, clientId: this.ctx.opts.clientId, purpose, iat: Math.floor(this.ctx.clock.serverNow() / 1000) });
+    }
+    /** A proof by this device's guest key for one of the guest's own calls (deletion, data copy). */
+    async guestProof(purpose) {
+        const key = await this.ctx.store.get(this.key('deviceKey'));
+        if (!key?.known)
+            throw new KrtuworksError('no_guest_key', 'This device holds no guest key.');
+        return this.proofWith(key, purpose);
+    }
+    /** The device-key grant; the caller holds the identity lock. */
+    async deviceKeyGrant(request) {
+        let key = await this.ctx.store.get(this.key('deviceKey'));
+        if (!key) {
+            // Stored before the server hears of it: a lost answer must not leave a guest no key can reach.
+            key = { ...(await createDeviceKey()), known: false, subject: null };
+            await this.ctx.store.set(this.key('deviceKey'), key);
+        }
+        if (!key.known && !request)
+            throw new KrtuworksError('birth_date_required', 'A new guest needs the age screen: pass birthDate and acceptedTerms.', 400);
+        const assertion = await this.proofWith(key, 'login');
+        const answer = await this.token({
+            grant_type: DEVICE_KEY_GRANT,
+            assertion,
+            scope: GUEST_SCOPE,
+            resource: DEV_RESOURCE,
+            birth_date: key.known ? undefined : request.birthDate,
+            accepted_terms: key.known ? undefined : request.acceptedTerms,
+        });
+        if (answer.status !== 200) {
+            const err = errorOf(answer);
+            if (err.code === 'terms_required')
+                err.details.terms = termsIn(err.message);
+            throw err;
+        }
+        const created = !key.known;
+        const tokens = this.tokensFrom(answer.json, 'guest', null);
+        if (created || key.subject !== tokens.subject)
+            await this.ctx.store.set(this.key('deviceKey'), { ...key, known: true, subject: tokens.subject });
+        return { tokens, created };
+    }
+    /** A guest whose refresh token is gone signs in again with its key; under the identity lock. */
+    async guestAgain(stored) {
+        try {
+            const { tokens } = await this.deviceKeyGrant(null);
+            await this.adopt(tokens);
+            return tokens;
+        }
+        catch (err) {
+            const e = err;
+            if (e.code !== 'invalid_grant' && e.code !== 'birth_date_required')
+                throw err;
+            const why = String(e.details?.description ?? e.message);
+            if (why.includes('account_merged'))
+                return this.markMergedLocked(stored.subject, null);
+            await this.adopt(null);
+            if (why.includes('account_deletion_pending')) {
+                this.emit({ type: 'deletion_pending' });
+                throw new KrtuworksError('account_deletion_pending', 'This account is waiting to be deleted.', 403);
+            }
+            if (why.includes('sanctioned')) {
+                this.emit({ type: 'sanctioned', reason: null });
+                throw new KrtuworksError('sanctioned', 'The player is banned from this app.', 403);
+            }
+            this.emit({ type: 'signed_out', reason: why });
+            throw signedOut();
+        }
+    }
+    /**
+     * Plays as a guest: the device's key, made now if there is none. A new guest needs the age screen's
+     * answers (13 or older, the current terms); they are kept and tried again on later launches when the
+     * server could not make the guest now. A sign-in the player starts meanwhile wins: this
+     * guest is then not used.
+     */
+    async signInAsGuest(input = {}) {
+        const meta = await this.meta();
+        const epoch = meta.epoch;
+        if (input.birthDate) {
+            meta.guestRequest = { birthDate: input.birthDate, acceptedTerms: input.acceptedTerms ?? CURRENT_TERMS };
+            await this.saveMeta(meta);
+        }
+        const result = await withLock(this.lockName, async () => {
+            const current = (await this.ctx.store.get(this.key('tokens'))) ?? null;
+            if (current) {
+                await this.adopt(current);
+                return { player: this.player, created: false, fresh: false };
+            }
+            const { tokens, created } = await this.deviceKeyGrant((await this.meta()).guestRequest);
+            const now = await this.meta();
+            if (now.epoch !== epoch)
+                throw new KrtuworksError('context_changed', 'A sign-in started while the guest was being made; the guest was not used.');
+            now.guestRequest = null;
+            await this.saveMeta(now);
+            await this.adopt(tokens);
+            return { player: this.player, created, fresh: true };
+        });
+        if (result.fresh)
+            this.emit({ type: 'guest', player: result.player, created: result.created });
+        return result.player;
+    }
+    // ── Sign-in with Krtuworks ID (authorization code + PKCE) ─────────────────
+    /**
+     * The address to send the player to. A guest playing on this device is carried along (`krtu_guest`):
+     * a new Krtuworks ID made there IS this guest, and signing in to an existing one folds the guest into
+     * it. Starting a sign-in bumps the epoch, so a guest still being made in the background is not used.
+     */
+    async beginSignIn(options = {}) {
+        const redirectUri = options.redirectUri ?? this.ctx.opts.redirectUri;
+        if (!redirectUri)
+            throw new TypeError('redirectUri is needed: one of the client\'s registered redirect addresses');
+        const epoch = await withLock(this.lockName, async () => {
+            const meta = await this.meta();
+            meta.epoch += 1;
+            await this.saveMeta(meta);
+            return meta.epoch;
+        });
+        const verifier = randomToken(32);
+        const state = randomToken(16);
+        const nonce = randomToken(16);
+        const params = new URLSearchParams({
+            client_id: this.ctx.opts.clientId,
+            redirect_uri: redirectUri,
+            response_type: 'code',
+            scope: PLAYER_SCOPE,
+            // offline_access only counts with prompt=consent (OIDC Core 11); the page shows no consent screen
+            // for the app's own players.
+            prompt: 'consent',
+            resource: DEV_RESOURCE,
+            code_challenge: base64Url(await sha256(verifier)),
+            code_challenge_method: 'S256',
+            state,
+            nonce,
+        });
+        if (this.tokens?.kind === 'guest' && options.carryGuest !== false) {
+            const key = await this.ctx.store.get(this.key('deviceKey'));
+            if (key?.known) {
+                try {
+                    params.set('krtu_guest', await this.proofWith(key, 'promote'));
+                }
+                catch {
+                    // offline or refused: the sign-in goes on without the guest
+                }
+            }
+        }
+        const pending = { verifier, nonce, redirectUri, epoch, startedAt: Date.now() };
+        await this.ctx.store.set(this.key(`signin:${state}`), pending);
+        return `${this.ctx.opts.idOrigin}/oidc/auth?${params}`;
+    }
+    /** Finishes a sign-in from the address the player came back to. */
+    async completeSignIn(callbackUrl) {
+        const url = new URL(String(callbackUrl));
+        const state = url.searchParams.get('state');
+        if (!state)
+            throw new KrtuworksError('invalid_callback', 'The address carries no sign-in.');
+        const pending = await this.ctx.store.get(this.key(`signin:${state}`));
+        await this.ctx.store.delete(this.key(`signin:${state}`));
+        if (!pending || Date.now() - pending.startedAt > PENDING_TTL_MS)
+            throw new KrtuworksError('invalid_callback', 'This sign-in is unknown or too old: start it again.');
+        const error = url.searchParams.get('error');
+        if (error)
+            throw new KrtuworksError(error, url.searchParams.get('error_description') ?? 'The sign-in did not finish.', 400);
+        const iss = url.searchParams.get('iss');
+        if (iss !== null && iss !== this.issuer)
+            throw new KrtuworksError('invalid_callback', 'The answer came from another issuer.');
+        const code = url.searchParams.get('code');
+        if (!code)
+            throw new KrtuworksError('invalid_callback', 'The address carries no code.');
+        const answer = await this.token({ grant_type: 'authorization_code', code, redirect_uri: pending.redirectUri, code_verifier: pending.verifier, resource: DEV_RESOURCE });
+        if (answer.status !== 200)
+            throw errorOf(answer);
+        this.checkIdToken(answer.json?.id_token, pending.nonce);
+        const outcome = await withLock(this.lockName, async () => {
+            const meta = await this.meta();
+            if (meta.epoch !== pending.epoch)
+                throw new KrtuworksError('context_changed', 'Another sign-in started after this one; this one was not used.');
+            const before = (await this.ctx.store.get(this.key('tokens'))) ?? null;
+            const next = this.tokensFrom(answer.json, 'account', before);
+            let promoted = false;
+            if (before?.kind === 'guest') {
+                if (before.subject === next.subject) {
+                    // The guest became this Krtuworks ID: same player, its key retired by the server.
+                    promoted = true;
+                    await this.ctx.store.delete(this.key('deviceKey'));
+                }
+                else if (!meta.waitingOwners.includes(before.subject)) {
+                    // Signed in to an existing account: the guest folds into it once the server confirms.
+                    meta.waitingOwners.push(before.subject);
+                }
+            }
+            meta.guestRequest = null;
+            await this.saveMeta(meta);
+            await this.adopt(next);
+            return { player: this.player, promoted };
+        });
+        this.emit({ type: 'signed_in', player: outcome.player, promoted: outcome.promoted });
+        return outcome.player;
+    }
+    /** OIDC Core 3.1.3.7 for a token straight from the token endpoint over TLS: issuer, audience, nonce, time. */
+    checkIdToken(idToken, nonce) {
+        if (typeof idToken !== 'string')
+            throw new KrtuworksError('invalid_response', 'The sign-in answer carries no ID token.');
+        const claims = jwtClaims(idToken);
+        const aud = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
+        const fresh = typeof claims.exp === 'number' && claims.exp * 1000 > this.ctx.clock.serverNow() - 60_000;
+        if (claims.iss !== this.issuer || !aud.includes(this.ctx.opts.clientId) || claims.nonce !== nonce || !fresh) {
+            throw new KrtuworksError('invalid_response', 'The ID token is not for this sign-in.');
+        }
+    }
+    /** Forgets the player on this device (a guest's key stays: signing in as the guest again reaches it). */
+    async signOut() {
+        const refreshToken = await withLock(this.lockName, async () => {
+            const meta = await this.meta();
+            meta.epoch += 1;
+            meta.guestRequest = null;
+            await this.saveMeta(meta);
+            const stored = (await this.ctx.store.get(this.key('tokens'))) ?? null;
+            await this.adopt(null);
+            return stored?.refreshToken ?? null;
+        });
+        if (refreshToken) {
+            const { body, headers } = form({ client_id: this.ctx.opts.clientId, token: refreshToken, token_type_hint: 'refresh_token' });
+            await send(this.ctx.fetch, this.ctx.clock, `${this.ctx.opts.idOrigin}/oidc/token/revocation`, { method: 'POST', headers, body }).catch(() => undefined);
+        }
+        this.emit({ type: 'signed_out', reason: 'signed_out' });
+    }
+}

package/dist/ids.d.ts

@@ -0,0 +1,13 @@
+/**
+ * RFC 9562 UUIDv7: 48 bits of Unix milliseconds, then random. Event, op and batch ids are made once and
+ * never again for the same thing, so an answer lost on the way is safe to ask for twice.
+ */
+export declare function uuidV7(nowMs?: number): string;
+export declare function uuidV4(): string;
+export declare function base64(input: Uint8Array): string;
+export declare function base64Url(input: Uint8Array | ArrayBuffer | string): string;
+export declare function fromBase64Url(text: string): Uint8Array;
+export declare function sha256(input: Uint8Array | string): Promise<Uint8Array>;
+export declare function sha256Hex(input: Uint8Array | string): Promise<string>;
+/** A random URL-safe string of `bytes` random bytes (PKCE verifier, state, nonce). */
+export declare function randomToken(bytes?: number): string;

package/dist/ids.js

@@ -0,0 +1,61 @@
+const encoder = new TextEncoder();
+function hex(bytes) {
+    let out = '';
+    for (const b of bytes)
+        out += b.toString(16).padStart(2, '0');
+    return out;
+}
+function uuidFrom(b) {
+    const h = hex(b);
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+/**
+ * RFC 9562 UUIDv7: 48 bits of Unix milliseconds, then random. Event, op and batch ids are made once and
+ * never again for the same thing, so an answer lost on the way is safe to ask for twice.
+ */
+export function uuidV7(nowMs = Date.now()) {
+    const b = crypto.getRandomValues(new Uint8Array(16));
+    let ts = Math.max(0, Math.floor(nowMs));
+    for (let i = 5; i >= 0; i -= 1) {
+        b[i] = ts % 256;
+        ts = Math.floor(ts / 256);
+    }
+    b[6] = (b[6] & 0x0f) | 0x70;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    return uuidFrom(b);
+}
+export function uuidV4() {
+    return crypto.randomUUID();
+}
+export function base64(input) {
+    let binary = '';
+    for (let i = 0; i < input.length; i += 0x8000)
+        binary += String.fromCharCode(...input.subarray(i, i + 0x8000));
+    return btoa(binary);
+}
+export function base64Url(input) {
+    const bytes = typeof input === 'string' ? encoder.encode(input) : input instanceof Uint8Array ? input : new Uint8Array(input);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += 0x8000)
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+export function fromBase64Url(text) {
+    const b64 = text.replace(/-/g, '+').replace(/_/g, '/');
+    const binary = atob(b64 + '='.repeat((4 - (b64.length % 4)) % 4));
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1)
+        out[i] = binary.charCodeAt(i);
+    return out;
+}
+export async function sha256(input) {
+    const bytes = typeof input === 'string' ? encoder.encode(input) : input;
+    return new Uint8Array(await crypto.subtle.digest('SHA-256', bytes));
+}
+export async function sha256Hex(input) {
+    return hex(await sha256(input));
+}
+/** A random URL-safe string of `bytes` random bytes (PKCE verifier, state, nonce). */
+export function randomToken(bytes = 32) {
+    return base64Url(crypto.getRandomValues(new Uint8Array(bytes)));
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { AVATAR_REPORT_REASONS, type AvatarReportReason } from './avatarReports.js';
+export { BUG_CATEGORIES, type BugCategory, type BugFlushResult, type BugReportInput, type BugReportView } from './bugs.js';
+export { Krtuworks, type Gate, type LeaderboardDisplay, type LeaderboardEntriesOptions, type LeaderboardEntriesView, type LeaderboardEntry, type LeaderboardsView, type LeaderboardView, type MergeSettled, type ProgressView, type SendResult, type TrackOptions, } from './client.js';
+export { CURRENT_TERMS, MODULES, type AppType, type DeviceInfo, type Environment, type KrtuworksAppConfig, type KrtuworksOptions, type Module, type Platform, } from './config.js';
+export type { Entitlement } from './entitlements.js';
+export { KrtuworksError, isKrtuworksError } from './errors.js';
+export type { EventPosition, WireEvent } from './events.js';
+export type { Family, FamilyData, Place } from './families.js';
+export type { FileRead, FileVersion, SaveOptions, SlotView } from './files.js';
+export type { IdentityChange, Player, PlayerKind } from './identity.js';
+export type { PresenceReason, PresenceResult, PresenceState } from './presence.js';
+export type { LevelRef } from './progression.js';
+export type { SortOrder, StatKind, UploadMethod } from './progress.js';
+export type { RemoteConfigValue, Switch } from './remoteConfig.js';
+export { defaultStore, indexedDbStore, memoryStore, type KrtuStore } from './store.js';
+export { configProblems, platformProblems, validate, type ValidateOptions, type ValidationCheck, type ValidationReport, type ValidationStatus } from './validator.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { AVATAR_REPORT_REASONS } from './avatarReports.js';
+export { BUG_CATEGORIES } from './bugs.js';
+export { Krtuworks, } from './client.js';
+export { CURRENT_TERMS, MODULES, } from './config.js';
+export { KrtuworksError, isKrtuworksError } from './errors.js';
+export { defaultStore, indexedDbStore, memoryStore } from './store.js';
+export { configProblems, platformProblems, validate } from './validator.js';

package/dist/jwt.d.ts

@@ -0,0 +1,2 @@
+/** A JWT's claims, unverified: the SDK reads its own tokens, it does not judge them (the servers do). */
+export declare function jwtClaims(token: string): Record<string, unknown>;

package/dist/jwt.js

@@ -0,0 +1,8 @@
+import { fromBase64Url } from './ids.js';
+/** A JWT's claims, unverified: the SDK reads its own tokens, it does not judge them (the servers do). */
+export function jwtClaims(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3)
+        throw new Error('not a JWT');
+    return JSON.parse(new TextDecoder().decode(fromBase64Url(parts[1])));
+}

package/dist/locks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs `fn` while holding `name`: across the origin's tabs with the Web Locks API, otherwise inside this
+ * process. Token refreshes and queue writes go through here, so two tabs never spend one refresh token
+ * or freeze the same events twice.
+ */
+export declare function withLock<T>(name: string, fn: () => Promise<T>): Promise<T>;

package/dist/locks.js

@@ -0,0 +1,20 @@
+const tails = new Map();
+/**
+ * Runs `fn` while holding `name`: across the origin's tabs with the Web Locks API, otherwise inside this
+ * process. Token refreshes and queue writes go through here, so two tabs never spend one refresh token
+ * or freeze the same events twice.
+ */
+export function withLock(name, fn) {
+    const locks = globalThis.navigator?.locks;
+    if (locks)
+        return locks.request(name, fn);
+    const previous = tails.get(name) ?? Promise.resolve();
+    const run = previous.then(fn);
+    const tail = run.then(() => undefined, () => undefined);
+    tails.set(name, tail);
+    void tail.then(() => {
+        if (tails.get(name) === tail)
+            tails.delete(name);
+    });
+    return run;
+}

package/dist/presence.d.ts

@@ -0,0 +1,45 @@
+import type { Api } from './api.js';
+import type { KrtuStore } from './store.js';
+export type PresenceReason = 'no_platform' | 'not_game' | 'module_disabled' | 'hidden' | 'unknown_state' | 'param_missing' | 'states_unknown' | 'platform_rejected';
+export interface PresenceResult {
+    applied: boolean;
+    reason?: PresenceReason;
+}
+export interface PresenceState {
+    key: string;
+    token: string;
+    /** The parameter names the state's text needs. */
+    params: string[];
+}
+/**
+ * The rich presence states the owner declared and whether the player shows their presence (the server
+ * `/v1/me/presence-states`, `/v1/me/presence-visibility`), kept per player in the store and revalidated
+ * with the ETag. A browser has no platform presence to write, so a call that passes every rule ends in
+ * `no_platform`.
+ */
+export declare class Presence {
+    private readonly clientId;
+    private readonly store;
+    private readonly api;
+    private readonly subject;
+    private cached;
+    constructor(clientId: string, store: KrtuStore, api: Api, subject: () => string | null);
+    private key;
+    /** Reads the current player's kept copy. */
+    load(): Promise<void>;
+    /** The player changed or signed out: nothing of the old player stays in memory. */
+    forget(): void;
+    private current;
+    states(): PresenceState[] | null;
+    visible(): boolean | null;
+    private keep;
+    /** Asks the server for the states and the choice (If-None-Match: a 304 keeps the kept copy). */
+    refresh(): Promise<void>;
+    setVisible(visible: boolean): Promise<void>;
+    /**
+     * The first rule a call breaks, or null when it passes them all: the state is declared and every
+     * parameter it declares has a non-empty value (the caller's, else the built-in one). Undeclared extras
+     * are dropped with a log line.
+     */
+    check(key: string, given: Record<string, string | number>, builtins: Record<string, () => string | null>, log: (line: string) => void): PresenceReason | null;
+}