@crowdedkingdoms/crowdyjs 17.14.0-dev.1 → 18.0.0-dev.1

package/dist/kit/matches.js

@@ -1,458 +0,0 @@
-import { CrowdyGraphQLError } from '../errors.js';
-import { encodeBase64, generateCrowdyUuid } from '../utils.js';
-import { matchesNames } from './blueprints/index.js';
-import { kitContainerProperties, kitInvoke, } from './shared.js';
-/**
- * Whether the match's current turn has run out of time — true once the
- * deadline for the open turn has fired. Always false for a match deployed
- * without `turnTimer`, and false for a deadline stranded by an earlier turn,
- * since those record a lower sequence than the one now open.
- */
-export function turnExpired(match) {
-    if (match.turnSeq === undefined || match.turnExpiredSeq === undefined)
-        return false;
-    return match.turnSeq > 0 && match.turnExpiredSeq >= match.turnSeq;
-}
-/**
- * Runtime helpers for the {@link matchesBlueprint} conventions: sessions ARE
- * the match primitive — `create` makes a session + a `MatchMeta` + a
- * per-match channel; turn order goes through the platform's session-turn
- * authority; lifecycle functions ping the channel post-commit and
- * {@link onMatchChanged} wraps the notify-to-pull loop (subscribe →
- * `"match_changed"` ping → re-pull state).
- *
- * Obtained via `client.kit(appId).matches`.
- */
-export class MatchesKit {
-    constructor(appId, gameModel, channels, udp, options = {}, engines) {
-        this.appId = appId;
-        this.gameModel = gameModel;
-        this.channels = channels;
-        this.udp = udp;
-        this.engines = engines;
-        /**
-         * This client's participant incarnation per session, remembered from
-         * {@link create} (a creator starts at 1) and {@link join}, so {@link leave}
-         * can send the value the server requires without the caller carrying it.
-         */
-        this.incarnations = new Map();
-        this.names = matchesNames(options.typePrefix ?? '');
-        this.engineModuleName = options.engineModuleName ?? 'match-engine';
-        this.actorUuid = options.actorUuid ?? generateCrowdyUuid();
-    }
-    requireChannels() {
-        if (!this.channels) {
-            throw new Error('kit.matches needs the channels domain — construct the kit via client.kit(appId)');
-        }
-        return this.channels;
-    }
-    requireUdp() {
-        if (!this.udp) {
-            throw new Error('kit.matches needs the udp domain — construct the kit via client.kit(appId)');
-        }
-        return this.udp;
-    }
-    /**
-     * Create a match: a session (the platform match primitive), a per-match
-     * notification channel, and the session-scoped `MatchMeta`.
-     *
-     * @param input.creatorUserId - The calling player's user id (stored so the
-     *   creator may start/advance/end the match).
-     * @param input.seedFromApp - Optional: container types whose app-scoped keyed
-     *   rows (a `gameModelSeed` with `bindingKey`) are stamped into the match's
-     *   session at creation, inside the same transaction, so the match starts
-     *   with its world rows present (chests, spawners, turrets). Same shape as
-     *   `CreateSessionInput.seedFromApp`: `{ typeNames, initialState? }`. At most
-     *   2,000 rows; above that the create is refused and no session exists. Only
-     *   `'session'`-scoped types; the copies are the only rows the tier's
-     *   (opt-in) ended-session retention may drop.
-     */
-    async create(input) {
-        // A kit match talks GraphQL and channel pings; the `actorUuid` here is only
-        // the channel-message sender id, never a replicated actor. Under the
-        // default `presence: 'actor'` the server would expire every player after
-        // the join grace window, so the roster is judged by nothing: players leave
-        // with `leave()`, `finish()` ends the session, and an emptied session is
-        // abandoned by the empty timeout.
-        const session = await this.gameModel.createSession({
-            appId: this.appId,
-            name: input.displayName ?? `match-${input.mode ?? 'default'}`,
-            presence: 'none',
-            ...(input.seedFromApp ? { seedFromApp: input.seedFromApp } : {}),
-        });
-        this.incarnations.set(session.sessionId, 1);
-        const channel = await this.requireChannels().create({
-            appId: this.appId,
-            name: `match-${session.sessionId}`,
-            description: 'Per-match notification channel (kit.matches notify-to-pull).',
-        });
-        const meta = await this.gameModel.createContainer({
-            appId: this.appId,
-            typeName: this.names.metaType,
-            displayName: input.displayName ?? `Match ${session.sessionId}`,
-            sessionId: session.sessionId,
-            properties: [
-                {
-                    key: 'creator_user_id',
-                    valueType: 'int',
-                    valueJson: String(input.creatorUserId),
-                },
-                { key: 'mode', valueType: 'string', valueJson: JSON.stringify(input.mode ?? '') },
-                {
-                    key: 'max_players',
-                    valueType: 'int',
-                    valueJson: String(input.maxPlayers ?? 0),
-                },
-                { key: 'channel_id', valueType: 'int', valueJson: String(channel.groupId) },
-            ],
-        });
-        return this.toMatch(meta.containerId, session.sessionId, meta.displayName);
-    }
-    /** List joinable matches (metas still in the lobby state). */
-    async open() {
-        const metas = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.metaType,
-        });
-        const matches = await Promise.all(metas
-            .filter((m) => m.sessionId != null)
-            .map((m) => this.toMatch(m.containerId, String(m.sessionId), m.displayName)));
-        return matches.filter((m) => m.state === 'lobby');
-    }
-    /** Read one match by its MatchMeta container. */
-    async get(metaId) {
-        const meta = await this.gameModel.container({
-            appId: this.appId,
-            containerId: metaId,
-        });
-        return this.toMatch(meta.containerId, meta.sessionId != null ? String(meta.sessionId) : '', meta.displayName);
-    }
-    /**
-     * Join a match: session participation + the notification channel. A rejoin
-     * (you are already in) returns your row with `incarnation + 1`. The
-     * incarnation is remembered on this kit instance for {@link leave}.
-     */
-    async join(match) {
-        const participant = await this.gameModel.joinSession({
-            appId: this.appId,
-            sessionId: match.sessionId,
-        });
-        this.incarnations.set(match.sessionId, participant.incarnation);
-        if (match.channelId !== '0' && match.channelId !== '') {
-            await this.requireChannels().join(match.channelId);
-        }
-        return participant;
-    }
-    /**
-     * Leave a match: session departure + the notification channel. The server
-     * requires the incarnation {@link join} returned to *this* client, so a
-     * superseded client can never remove the one that took over; pass it, or
-     * let the kit use the one it remembered from `create` / `join` on this
-     * instance. A kit session is `presence: 'none'`, so this and {@link finish}
-     * are the roster's only exits.
-     *
-     * @throws {Error} when no incarnation is known for the match on this
-     *   instance and none was passed.
-     * @throws {CrowdyGraphQLError} `SESSION_INCARNATION_STALE` (a newer client
-     *   of yours rejoined), `SESSION_NOT_PARTICIPANT`, `NOT_FOUND`.
-     */
-    async leave(match, incarnation) {
-        const known = incarnation ?? this.incarnations.get(match.sessionId);
-        if (known === undefined) {
-            throw new Error('kit.matches.leave needs the incarnation join() returned — pass it, or join through this kit instance');
-        }
-        const participant = await this.gameModel.leaveSession({
-            appId: this.appId,
-            sessionId: match.sessionId,
-            incarnation: known,
-        });
-        this.incarnations.delete(match.sessionId);
-        if (match.channelId !== '0' && match.channelId !== '') {
-            await this.requireChannels().leave(match.channelId);
-        }
-        return participant;
-    }
-    /** Start the match (creator or host). Pings the match channel post-commit. */
-    async start(match) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.startFn,
-            selfContainerId: match.metaId,
-            sessionId: match.sessionId,
-            params: {},
-        });
-    }
-    /** Advance to the next round (creator or host). */
-    async advanceRound(match) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.advanceRoundFn,
-            selfContainerId: match.metaId,
-            sessionId: match.sessionId,
-            params: {},
-        });
-    }
-    /** Whether it is `userId`'s session turn right now. */
-    async myTurn(match, userId) {
-        const session = await this.gameModel.session({
-            appId: this.appId,
-            sessionId: match.sessionId,
-        });
-        return (session.currentTurnUserId != null &&
-            String(session.currentTurnUserId) === String(userId));
-    }
-    /**
-     * Pass the turn to the next player via the platform's session-turn
-     * authority (current holder, host, or admin — enforced by the service),
-     * then ping the match channel so everyone re-pulls.
-     *
-     * For a match deployed with `turnTimer`, this opens the incoming turn first
-     * so it arrives with a deadline already running. Opening it before the
-     * handover also means the outgoing holder is still the session's turn user,
-     * which is what authorizes them to do it.
-     */
-    async endTurn(match, nextUserId) {
-        if (match.turnSeq !== undefined)
-            await this.beginTurn(match);
-        const session = await this.gameModel.setSessionTurn({
-            appId: this.appId,
-            sessionId: match.sessionId,
-            userId: nextUserId,
-        });
-        await this.notifyChanged(match);
-        return session;
-    }
-    /**
-     * Open a turn and arm its deadline (`turnTimer` deployments only) — the
-     * deadline replaces any still pending for this match. `endTurn` calls this
-     * for you; call it directly to give the current player a fresh clock, e.g.
-     * after granting extra time.
-     */
-    async beginTurn(match) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.beginTurnFn,
-            selfContainerId: match.metaId,
-            sessionId: match.sessionId,
-            params: {},
-        });
-    }
-    /**
-     * Cancel the pending turn deadline for this match, if any. Returns how many
-     * timers were dropped. Ending a match already strands its deadline, so this
-     * is only needed when you want turns to stop being timed while play
-     * continues.
-     */
-    async cancelTurnDeadline(match) {
-        return this.gameModel.cancelTimer({
-            appId: this.appId,
-            dedupeKey: `match_turn:${match.metaId}`,
-        });
-    }
-    /** Find-or-create a player's session-scoped Score row. */
-    async ensureScore(match, ownerUserId) {
-        const scores = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.scoreType,
-            sessionId: match.sessionId,
-        });
-        const mine = scores.find((c) => c.ownerUserId != null && String(c.ownerUserId) === String(ownerUserId));
-        if (mine)
-            return mine;
-        return this.gameModel.createContainer({
-            appId: this.appId,
-            typeName: this.names.scoreType,
-            displayName: `Score ${ownerUserId}`,
-            sessionId: match.sessionId,
-            properties: [
-                { key: 'owner_user_id', valueType: 'int', valueJson: String(ownerUserId) },
-            ],
-        });
-    }
-    /**
-     * Add points to a Score row — trusted (host-refereed by default).
-     * Resolves with the new points.
-     */
-    async score(match, scoreId, points) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.scoreFn,
-            selfContainerId: scoreId,
-            sessionId: match.sessionId,
-            params: { points },
-        });
-    }
-    /** The match standings, highest points first (client-side sort). */
-    async standings(match) {
-        const scores = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.scoreType,
-            sessionId: match.sessionId,
-        });
-        const rows = await Promise.all(scores.map(async (c) => {
-            const props = await kitContainerProperties(this.gameModel, String(this.appId), c.containerId);
-            return {
-                containerId: c.containerId,
-                ownerUserId: c.ownerUserId != null ? String(c.ownerUserId) : null,
-                points: Number(props.points ?? 0),
-            };
-        }));
-        return rows.sort((a, b) => b.points - a.points);
-    }
-    /**
-     * Finish the match and record the winner (creator or host). Also drops the
-     * pending turn deadline on a `turnTimer` match — `end_match` already
-     * strands it, so this just saves the pointless fire and channel ping.
-     *
-     * When `end_match` succeeds the backing session is ended too
-     * (`gameModelEndSession`, reason `completed`): every participant is marked
-     * left, admission closes, and the session's events become eligible for
-     * retention. The game-authoritative step runs first, so the match is
-     * decided whatever happens next; `sessionEnd` on the result says what
-     * happened to the session ({@link KitMatchSessionEnd}): `'ended'`, or
-     * `'already_ended'` for a replayed finish, or `'forbidden'` when the caller
-     * passed `end_match` (creator or the app's elected host) but is not admitted
-     * to the session end (session host or app admin only) -- the match is
-     * finished, the session is not, and nothing is thrown. Any other refusal of
-     * the session end propagates.
-     */
-    async finish(match, winnerUserId) {
-        const result = await kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.endFn,
-            selfContainerId: match.metaId,
-            sessionId: match.sessionId,
-            params: { winner_user_id: Number(winnerUserId) },
-        });
-        if (result.success && match.turnSeq !== undefined) {
-            await this.cancelTurnDeadline(match);
-        }
-        if (result.success) {
-            try {
-                await this.gameModel.endSession({
-                    appId: this.appId,
-                    sessionId: match.sessionId,
-                    reason: 'completed',
-                });
-                result.sessionEnd = 'ended';
-            }
-            catch (error) {
-                if (error instanceof CrowdyGraphQLError && error.code === 'SESSION_ENDED') {
-                    result.sessionEnd = 'already_ended';
-                }
-                else if (error instanceof CrowdyGraphQLError && error.code === 'FORBIDDEN') {
-                    result.sessionEnd = 'forbidden';
-                }
-                else {
-                    throw error;
-                }
-            }
-            if (result.sessionEnd !== 'forbidden')
-                this.incarnations.delete(match.sessionId);
-        }
-        return result;
-    }
-    /**
-     * Manually ping the match channel with `"match_changed"` (the lifecycle
-     * functions do this automatically via their declared notifications; use
-     * this after out-of-band changes such as `endTurn`).
-     */
-    async notifyChanged(match) {
-        if (match.channelId === '0' || match.channelId === '')
-            return false;
-        return this.requireUdp().sendChannelMessage({
-            channelId: match.channelId,
-            uuid: this.actorUuid,
-            payload: encodeBase64(new TextEncoder().encode('match_changed')),
-        });
-    }
-    /**
-     * The notify-to-pull loop, wrapped: subscribe to the app's notifications,
-     * and on every ping of THIS match's channel re-pull the match state and
-     * hand it to `callback`. Returns the unsubscribe function.
-     */
-    onMatchChanged(match, callback) {
-        return this.requireUdp().subscribe({
-            channelMessage: (notification) => {
-                if (String(notification.channelId) !== String(match.channelId))
-                    return;
-                void this.get(match.metaId).then(callback);
-            },
-        }, String(this.appId));
-    }
-    async toMatch(metaId, sessionId, displayName) {
-        const props = await kitContainerProperties(this.gameModel, String(this.appId), metaId);
-        return {
-            sessionId,
-            metaId,
-            displayName,
-            creatorUserId: Number(props.creator_user_id ?? 0),
-            mode: String(props.mode ?? ''),
-            state: String(props.state ?? ''),
-            round: Number(props.round ?? 0),
-            maxPlayers: Number(props.max_players ?? 0),
-            winnerUserId: Number(props.winner_user_id ?? 0),
-            channelId: String(props.channel_id ?? '0'),
-            ...(props.tick_count !== undefined
-                ? { tickCount: Number(props.tick_count) }
-                : {}),
-            ...(props.turn_seq !== undefined ? { turnSeq: Number(props.turn_seq) } : {}),
-            ...(props.turn_expired_seq !== undefined
-                ? { turnExpiredSeq: Number(props.turn_expired_seq) }
-                : {}),
-        };
-    }
-    // -- Engine path (Wave 2): server-driven lifecycle over the match engine --
-    /**
-     * Is a match compute engine deployed + enabled (cached per session)? When
-     * true the engine owns transitions (ready checks, turn order + timeouts,
-     * authoritative scoring); the blueprint's creator-driven functions remain
-     * for model-only deployments.
-     */
-    engineAvailable() {
-        if (!this.engines)
-            return Promise.resolve(false);
-        return this.engines.has(this.engineModuleName);
-    }
-    /**
-     * Declare ready on an engine match (a MatchMeta container id). The match
-     * starts server-side once every expected player is ready.
-     */
-    async engineReady(matchId) {
-        return this.engineInvoke('ready', { matchId });
-    }
-    /** Submit your move (the engine validates the turn + resolves). */
-    async engineSubmitMove(matchId, params = {}) {
-        return this.engineInvoke('submit_move', { matchId, ...params });
-    }
-    /** Forfeit an engine match. */
-    async engineForfeit(matchId) {
-        return this.engineInvoke('forfeit', { matchId });
-    }
-    /** The engine's live view: turn holder, timers, standings, summary. */
-    async engineStatus(matchId) {
-        return this.engineInvoke('status', { matchId });
-    }
-    /**
-     * Resolve a matchmaking proposal to the match the engine created for it
-     * (poll after everyone accepts; see `kit.matchmaking`).
-     */
-    async findByProposal(proposalId) {
-        if (!this.engines)
-            return null;
-        const result = await this.engines.invoke(this.engineModuleName, 'find_by_proposal', {
-            proposalId,
-        });
-        return result.success ? String(result.body.matchId ?? '') || null : null;
-    }
-    async engineInvoke(exportName, params) {
-        if (!this.engines) {
-            throw new Error('match engine unavailable: compute domain not wired');
-        }
-        const result = await this.engines.invoke(this.engineModuleName, exportName, params);
-        if (!result.success) {
-            throw new Error(`matches.${exportName} failed: ${result.reason ?? 'unknown'}`);
-        }
-        return result.body;
-    }
-}

package/dist/kit/matchmaking.d.ts

@@ -1,57 +0,0 @@
-import type { Scalars } from '../generated/graphql.js';
-import type { EngineDetector } from './engine.js';
-/** Options for {@link MatchmakingKit}. */
-export interface MatchmakingKitOptions {
-    /** The matchmaking module name. Defaults to `'matchmaking'`. */
-    moduleName?: string;
-}
-/** Your queue status: where you are queued and any live proposal. */
-export interface KitQueueStatus {
-    queuedIn: string | null;
-    proposal: {
-        proposalId: string;
-        mode: string;
-        players: string[];
-        accepted: string[];
-        handedOff: boolean;
-    } | null;
-    queueDepth: number;
-    rating: number;
-}
-/**
- * Runtime helpers for the matchmaking engine (Wave 2): rating-bucketed
- * queues with widening windows, party blocks, and accept-gated proposals
- * that hand off to the match layer over compute events. After everyone
- * accepts, resolve the created match with `kit.matches.findByProposal`.
- *
- * Obtained via `client.kit(appId).matchmaking`.
- */
-export declare class MatchmakingKit {
-    private readonly engines;
-    private readonly moduleName;
-    constructor(_appId: Scalars['BigInt']['input'], engines: EngineDetector, options?: MatchmakingKitOptions);
-    /** Is the matchmaking engine deployed + enabled (cached per session)? */
-    engineAvailable(): Promise<boolean>;
-    /**
-     * Join a queue (optionally with a party block that must match together,
-     * and an explicit rating for games that keep rating on the progression
-     * layer).
-     */
-    queueJoin(input?: {
-        mode?: string;
-        rating?: number;
-        party?: string[];
-    }): Promise<Record<string, unknown>>;
-    /** Leave your queue (all modes, or one with `mode`). */
-    queueLeave(mode?: string): Promise<Record<string, unknown>>;
-    /** Your queue/proposal status. */
-    queueStatus(mode?: string): Promise<KitQueueStatus>;
-    /** Accept a proposal; when everyone has, the match handoff fires. */
-    accept(proposalId: string): Promise<Record<string, unknown>>;
-    /** Report the decided result (Elo-lite rating update + proposal close). */
-    reportResult(proposalId: string, winnerUserId: string): Promise<Record<string, unknown>>;
-    /** Engine totals (queues/proposals/rated players). */
-    status(): Promise<Record<string, unknown>>;
-    private invoke;
-}
-//# sourceMappingURL=matchmaking.d.ts.map

package/dist/kit/matchmaking.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchmaking.d.ts","sourceRoot":"","sources":["../../src/kit/matchmaking.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;KACpB,GAAG,IAAI,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,qBAAa,cAAc;IAKvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAGlC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACjB,OAAO,EAAE,cAAc,EACxC,OAAO,GAAE,qBAA0B;IAKrC,yEAAyE;IACzE,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC;IAInC;;;;OAIG;IACG,SAAS,CAAC,KAAK,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;IAIhF,wDAAwD;IAClD,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM;IAI9B,kCAAkC;IAC5B,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAUzD,qEAAqE;IAC/D,MAAM,CAAC,UAAU,EAAE,MAAM;IAI/B,2EAA2E;IACrE,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAI3D,sDAAsD;IAChD,MAAM;YAIE,MAAM;CAOrB"}

package/dist/kit/matchmaking.js

@@ -1,59 +0,0 @@
-/**
- * Runtime helpers for the matchmaking engine (Wave 2): rating-bucketed
- * queues with widening windows, party blocks, and accept-gated proposals
- * that hand off to the match layer over compute events. After everyone
- * accepts, resolve the created match with `kit.matches.findByProposal`.
- *
- * Obtained via `client.kit(appId).matchmaking`.
- */
-export class MatchmakingKit {
-    constructor(_appId, engines, options = {}) {
-        this.engines = engines;
-        this.moduleName = options.moduleName ?? 'matchmaking';
-    }
-    /** Is the matchmaking engine deployed + enabled (cached per session)? */
-    engineAvailable() {
-        return this.engines.has(this.moduleName);
-    }
-    /**
-     * Join a queue (optionally with a party block that must match together,
-     * and an explicit rating for games that keep rating on the progression
-     * layer).
-     */
-    async queueJoin(input = {}) {
-        return this.invoke('queue_join', input);
-    }
-    /** Leave your queue (all modes, or one with `mode`). */
-    async queueLeave(mode) {
-        return this.invoke('queue_leave', mode ? { mode } : {});
-    }
-    /** Your queue/proposal status. */
-    async queueStatus(mode) {
-        const body = await this.invoke('queue_status', mode ? { mode } : {});
-        return {
-            queuedIn: body.queuedIn != null ? String(body.queuedIn) : null,
-            proposal: body.proposal ?? null,
-            queueDepth: Number(body.queueDepth ?? 0),
-            rating: Number(body.rating ?? 0),
-        };
-    }
-    /** Accept a proposal; when everyone has, the match handoff fires. */
-    async accept(proposalId) {
-        return this.invoke('accept', { proposalId });
-    }
-    /** Report the decided result (Elo-lite rating update + proposal close). */
-    async reportResult(proposalId, winnerUserId) {
-        return this.invoke('report_result', { proposalId, winnerUserId });
-    }
-    /** Engine totals (queues/proposals/rated players). */
-    async status() {
-        return this.invoke('status', {});
-    }
-    async invoke(exportName, params) {
-        const result = await this.engines.invoke(this.moduleName, exportName, params);
-        if (!result.success) {
-            throw new Error(`matchmaking.${exportName} failed: ${result.reason ?? 'unknown'}`);
-        }
-        return result.body;
-    }
-}

package/dist/kit/minigames.d.ts

@@ -1,30 +0,0 @@
-import type { Scalars } from '../generated/graphql.js';
-import type { EngineDetector, EngineInvokeResult } from './engine.js';
-/** Options for {@link MinigamesKit}. */
-export interface MinigamesKitOptions {
-    /** Default module when calls omit one (e.g. your scaffolded game). */
-    defaultModuleName?: string;
-}
-/**
- * A thin invoke wrapper for invoke-loop minigames (the Wave 2 `minigame`
- * scaffold pattern): synchronous `play` RPCs with server-bound caller
- * identity, server-held secrets, and per-caller records. Every method
- * resolves the engine envelope — denials come back as
- * `{success: false, reason}` rather than throwing.
- *
- * Obtained via `client.kit(appId).minigames`.
- */
-export declare class MinigamesKit {
-    private readonly engines;
-    private readonly defaultModuleName?;
-    constructor(_appId: Scalars['BigInt']['input'], engines: EngineDetector, options?: MinigamesKitOptions);
-    /** Is a minigame module deployed + enabled (cached per session)? */
-    engineAvailable(moduleName?: string): Promise<boolean>;
-    /** One round: invoke the game's `play` export with your move. */
-    play(params: Record<string, unknown>, moduleName?: string): Promise<EngineInvokeResult>;
-    /** Your per-caller record. */
-    record(moduleName?: string): Promise<EngineInvokeResult>;
-    /** Any other export the game defines (typed result envelope). */
-    invoke(exportName: string, params?: Record<string, unknown>, moduleName?: string): Promise<EngineInvokeResult>;
-}
-//# sourceMappingURL=minigames.d.ts.map

package/dist/kit/minigames.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"minigames.d.ts","sourceRoot":"","sources":["../../src/kit/minigames.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtE,wCAAwC;AACxC,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,qBAAa,YAAY;IAKrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAS;gBAG1C,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACjB,OAAO,EAAE,cAAc,EACxC,OAAO,GAAE,mBAAwB;IAKnC,oEAAoE;IACpE,eAAe,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMtD,iEAAiE;IAC3D,IAAI,CACR,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,kBAAkB,CAAC;IAI9B,8BAA8B;IACxB,MAAM,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAI9D,iEAAiE;IAC3D,MAAM,CACV,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACpC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,kBAAkB,CAAC;CAO/B"}

package/dist/kit/minigames.js

@@ -1,38 +0,0 @@
-/**
- * A thin invoke wrapper for invoke-loop minigames (the Wave 2 `minigame`
- * scaffold pattern): synchronous `play` RPCs with server-bound caller
- * identity, server-held secrets, and per-caller records. Every method
- * resolves the engine envelope — denials come back as
- * `{success: false, reason}` rather than throwing.
- *
- * Obtained via `client.kit(appId).minigames`.
- */
-export class MinigamesKit {
-    constructor(_appId, engines, options = {}) {
-        this.engines = engines;
-        this.defaultModuleName = options.defaultModuleName;
-    }
-    /** Is a minigame module deployed + enabled (cached per session)? */
-    engineAvailable(moduleName) {
-        const name = moduleName ?? this.defaultModuleName;
-        if (!name)
-            return Promise.resolve(false);
-        return this.engines.has(name);
-    }
-    /** One round: invoke the game's `play` export with your move. */
-    async play(params, moduleName) {
-        return this.invoke('play', params, moduleName);
-    }
-    /** Your per-caller record. */
-    async record(moduleName) {
-        return this.invoke('record', {}, moduleName);
-    }
-    /** Any other export the game defines (typed result envelope). */
-    async invoke(exportName, params = {}, moduleName) {
-        const name = moduleName ?? this.defaultModuleName;
-        if (!name) {
-            return { success: false, reason: 'no minigame module configured', body: {} };
-        }
-        return this.engines.invoke(name, exportName, params);
-    }
-}