Complete SDK facade

API at a glance

• Inkwell.ready()
• Inkwell.loading / session / analytics / assets / player / presence / performance
• Inkwell.backend / chat / leaderboards / achievements / stats / offline / invites
• Inkwell.game / feedback

Server, private storage, config and wire utilities use their own package subpaths; they are not fields on Inkwell.

GameServiceError exposes status and code. Distinguish rejected operations from offline writes accepted into a local queue. Never ship creator credentials in browser code.

All exported symbols

• AcceptedGameInvite
• Achievement
• AchievementChange
• AchievementDefinition
• AchievementNotification
• AchievementPercentage
• AchievementQuery
• AchievementUnlock
• AggregateAssetProgress
• AggregateGameStat
• AggregateGameStatQuery
• AnalyticsProperties
• AnyBackendProtocol
• AssetProgress
• AssetTracker
• BackendActionError
• BackendConnection
• BackendConnectionError
• BackendPresence
• BackendProtocol
• BackendTransport
• BackendTransportCapabilities
• BackendTransportKind
• CachedGameRead
• ChatAuthor
• ChatConnectOptions
• ChatConnection
• ChatHistory
• ChatMessage
• ChatModerationEvent
• ChatReceipt
• ChatSendOptions
• ChatState
• GameInfo
• GameServiceError
• GameStat
• GameStatChange
• GameStatDefinition
• GameStatSchema
• Inkwell
• InviteContext
• InviteError
• InviteValue
• Leaderboard
• LeaderboardDefinition
• LeaderboardEntry
• LeaderboardInfo
• LeaderboardQuery
• LeaderboardResult
• OfflineStatus
• PerformanceMonitorOptions
• PerformanceSnapshot
• Player
• Presence
• PresentFriend
• PresentPlayer
• ProgressBatch
• ProgressBatchOptions
• ProgressBatchResult
• QueuedGameWrite
• ScoreResult
• ScoreSubmission
• ServerLeaderboard
• StatUpdate
• UnreliableDelivery
• WebSocketBackendTransport
• WebTransportBackendTransport
• achievements
• analytics
• assets
• backend
• chat
• complete
• connectBackend
• createAchievements
• createChat
• createLeaderboards
• createOffline
• createServerAchievements
• createServerChat
• createServerLeaderboards
• createServerStats
• createStats
• default
• defaultTracker
• feedback
• game
• getAccepted
• getGame
• getPlayer
• getPresence
• invites
• leaderboards
• loading
• offline
• onAccepted
• onAchievementChange
• onAchievementNotification
• onStatChange
• openFeedback
• performanceMonitoring
• performanceSnapshot
• player
• presence
• ready
• reportPerformance
• requestBackend
• session
• setContextProvider
• startPerformanceMonitoring
• stats
• stopPerformanceMonitoring
• track
• trackPromise
• trackedFetch
• validateInviteContext

Exact TypeScript API

Generated from the SDK source, including input options, return values, public types and overloads. Relative imports below are links between SDK source modules, not additional package subpaths. Only the entrypoints listed in the reference index are supported import paths.

export { game, get as getGame } from './game.js';
export type { GameInfo } from './game.js';
export { feedback, open as openFeedback } from './feedback.js';
import { ready } from "./core.js";
import { connectBackend, requestBackend } from "./backend.js";
export * from './invites.js';
export * from './offline.js';
export * from './chat.js';
export * from "./achievements.js";
export * from "./stats.js";
export * from "./leaderboards.js";
export { GameServiceError } from "./game-services.js";
export { ready } from "./core.js";
export { loading } from './loading.js';
export { complete, session } from "./session.js";
export { analytics, track } from "./analytics.js";
export { AssetTracker, assets, defaultTracker, trackedFetch, trackPromise } from "./assets.js";
export type { AnalyticsProperties } from "./analytics.js";
export type { AggregateAssetProgress, AssetProgress } from "./assets.js";
export { get as getPlayer, player } from "./player.js";
export type { Player } from "./player.js";
export { get as getPresence, presence } from "./presence.js";
export type { Presence, BackendPresence, PresentFriend, PresentPlayer } from "./presence.js";
export { performanceMonitoring, report as reportPerformance, snapshot as performanceSnapshot, start as startPerformanceMonitoring, stop as stopPerformanceMonitoring, } from "./performance.js";
export type { PerformanceMonitorOptions, PerformanceSnapshot } from "./performance.js";
export { backend, BackendActionError, BackendConnection, BackendConnectionError, connectBackend, requestBackend, WebSocketBackendTransport, WebTransportBackendTransport, } from "./backend.js";
export type { AnyBackendProtocol, BackendProtocol, BackendTransport, BackendTransportCapabilities, BackendTransportKind, UnreliableDelivery, } from "./backend.js";
export declare const Inkwell: Readonly<{
    ready: typeof ready;
    game: Readonly<{
        get: typeof import("./game.js").get;
    }>;
    feedback: Readonly<{
        open: typeof import("./feedback.js").open;
    }>;
    loading: Readonly<{
        progress: typeof import("./loading.js").progress;
        fail: typeof import("./loading.js").fail;
    }>;
    session: Readonly<{
        complete: typeof import("./session.js").complete;
    }>;
    analytics: Readonly<{
        track: typeof import("./analytics.js").track;
    }>;
    assets: Readonly<{
        AssetTracker: typeof import("./assets.js").AssetTracker;
        defaultTracker: import("./assets.js").AssetTracker;
        trackedFetch: typeof import("./assets.js").trackedFetch;
        trackPromise: typeof import("./assets.js").trackPromise;
    }>;
    player: Readonly<{
        get: typeof import("./player.js").get;
    }>;
    presence: Readonly<{
        get: typeof import("./presence.js").get;
    }>;
    performance: Readonly<{
        start: typeof import("./performance.js").start;
        stop: typeof import("./performance.js").stop;
        report: typeof import("./performance.js").report;
        snapshot: typeof import("./performance.js").snapshot;
    }>;
    backend: Readonly<{
        connect: typeof connectBackend;
        request: typeof requestBackend;
    }>;
    leaderboards: Readonly<{
        board: (name: string) => import("./leaderboards.js").Leaderboard;
        find(name: string): Promise<import("./leaderboards.js").Leaderboard | null>;
        findOrCreate(definition: Pick<import("./leaderboards.js").LeaderboardDefinition, "name" | "sort" | "display">): Promise<import("./leaderboards.js").Leaderboard>;
        list: (offset?: number) => Promise<{
            boards: import("./leaderboards.js").LeaderboardInfo[];
            nextOffset: number | null;
        }>;
    }>;
    achievements: Readonly<{
        onChange: typeof import("./achievements.js").onAchievementChange;
        games: (options?: {
            after?: string;
            query?: string;
        }) => Promise<{
            games: {
                slug: string;
                title: string;
                publisherUsername: string;
                achievementCount: number;
            }[];
            nextCursor: string | null;
        }>;
        summary: (options?: Pick<import("./achievements.js").AchievementQuery, "game" | "username">) => Promise<{
            total: number;
            unlocked: number;
        }>;
        count(options?: Pick<import("./achievements.js").AchievementQuery, "game">): Promise<number>;
        onNotification: typeof import("./achievements.js").onAchievementNotification;
        indicateProgress: (name: string, current: number, max: number, options?: {
            locale?: string;
        }) => Promise<{
            displayed: boolean;
        }>;
        list: (options?: import("./achievements.js").AchievementQuery) => Promise<{
            achievements: import("./achievements.js").Achievement[];
            nextOffset: number | null;
        } & import("./offline.js").CachedGameRead>;
        get(name: string, options?: import("./achievements.js").AchievementQuery): Promise<{
            offline: boolean | undefined;
            cachedAt: number | undefined;
            pendingWrites: number | undefined;
            name: string;
            title: string;
            description: string;
            iconUrl: string | null;
            hidden: boolean;
            unlocked: boolean;
            unlockedAt: string | null;
            progress: {
                current: number;
                min: number;
                target: number;
                percent: number;
            } | null;
        } | null>;
        unlock: (name: string) => Promise<import("./offline.js").QueuedGameWrite | import("./achievements.js").AchievementUnlock>;
        clear: (name: string) => Promise<{
            success: true;
        }>;
        percentage(name: string, options?: {
            game?: string;
        }): Promise<import("./achievements.js").AchievementPercentage | null>;
        percentages: (options?: {
            game?: string;
            offset?: number;
        }) => Promise<{
            achievements: import("./achievements.js").AchievementPercentage[];
            nextOffset: number | null;
        }>;
    }>;
    stats: Readonly<{
        onChange: typeof import("./stats.js").onStatChange;
        schema: (options?: {
            name?: string;
            offset?: number;
        }) => Promise<{
            stats: import("./stats.js").GameStatSchema[];
            nextOffset: number | null;
        }>;
        get(name: string, options?: {
            username?: string;
        }): Promise<{
            offline: boolean | undefined;
            cachedAt: number | undefined;
            pendingWrites: number | undefined;
            name: string;
            title: string;
            kind: "int" | "float" | "avgrate";
            value: number;
            updatedAt: string | null;
        } | null>;
        reset: (options?: {
            achievements?: boolean;
        }) => Promise<{
            statsCleared: number;
            achievementsCleared: number;
        }>;
        list: (options?: {
            username?: string;
            offset?: number;
        }) => Promise<{
            stats: import("./stats.js").GameStat[];
            nextOffset: number | null;
        } & import("./offline.js").CachedGameRead>;
        set: (name: string, value: number, options?: {
            requestId?: string;
        }) => Promise<import("./offline.js").QueuedGameWrite | import("./stats.js").StatUpdate>;
        increment: (name: string, amount?: number, options?: {
            requestId?: string;
        }) => Promise<import("./offline.js").QueuedGameWrite | import("./stats.js").StatUpdate>;
        updateAverage: (name: string, count: number, seconds: number, options?: {
            requestId?: string;
        }) => Promise<import("./offline.js").QueuedGameWrite | import("./stats.js").StatUpdate>;
        aggregate: (options?: import("./stats.js").AggregateGameStatQuery) => Promise<{
            stats: import("./stats.js").AggregateGameStat[];
            nextOffset: number | null;
        }>;
    }>;
    chat: Readonly<{
        setDefaultPanelVisible: (visible: boolean) => Promise<{
            visible: boolean;
        }>;
        connect: (channel?: string, options?: import("./chat.js").ChatConnectOptions) => Promise<import("./chat.js").ChatConnection>;
        list: () => Promise<{
            channels: {
                name: string;
                serverWritesOnly: boolean;
            }[];
        }>;
    }>;
    offline: Readonly<{
        enable: () => Promise<import("./offline.js").OfflineStatus>;
        disable: () => Promise<import("./offline.js").OfflineStatus>;
        status: () => Promise<import("./offline.js").OfflineStatus>;
        flush: () => Promise<{
            pending: number;
            failures: number;
        }>;
    }>;
    invites: Readonly<{
        setContextProvider: typeof import("./invites.js").setContextProvider;
        getAccepted: typeof import("./invites.js").getAccepted;
        onAccepted: typeof import("./invites.js").onAccepted;
    }>;
}>;
export default Inkwell;

export declare class GameServiceError extends Error {
    readonly status: number;
    readonly code: string;
    constructor(message: string, status?: number, code?: string);
}
export type GameServiceRequest = <T>(service: string, request: Record<string, unknown>) => Promise<T>;
export declare const requestGameService: GameServiceRequest;
/** Server-only adapter. Credentials must never be bundled into browser games. */
export declare function createGameServiceRequest(options: {
    baseUrl: string;
    token: string;
    fetch?: typeof fetch;
}): GameServiceRequest;

export declare const SDK_SOURCE: "inkwell-sdk";
export declare const SDK_VERSION: 1;
export type InkwellMessageType = "ready" | "loading.progress" | "loading.error" | "session.complete" | "analytics.track" | "assets.progress" | "player.get" | "presence.get" | "performance.sample" | "backend.connect" | "backend.fetch";
export type InkwellMessage = {
    source: typeof SDK_SOURCE;
    version: typeof SDK_VERSION;
    type: InkwellMessageType;
    payload?: Record<string, unknown>;
    sentAt: number;
};
export declare function parentOrigin(): string | null;
export declare function requestId(): string;
export declare function emit(type: InkwellMessageType, payload?: Record<string, unknown>): boolean;