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

package/dist/kit/loot.js

@@ -1,160 +0,0 @@
-import { lootNames, lootRollFn } from './blueprints/index.js';
-import { kitContainerProperties, kitInvoke, } from './shared.js';
-/**
- * Runtime helpers for the {@link lootBlueprint} conventions: create durable
- * `LootRoll` containers, roll them (trusted — app admins by default, or the
- * blueprint's event-drop automations), and claim results atomically into an
- * item stack. The weighted selection runs entirely server-side from a stored
- * seed, so clients can neither pick their loot nor claim it twice.
- *
- * Obtained via `client.kit(appId).loot`.
- */
-export class LootKit {
-    constructor(appId, gameModel, options = {}, engines) {
-        this.appId = appId;
-        this.gameModel = gameModel;
-        this.engines = engines;
-        this.typePrefix = options.typePrefix ?? '';
-        this.names = lootNames(this.typePrefix);
-        this.engineModuleName = options.engineModuleName ?? 'loot-engine';
-    }
-    /**
-     * Is a big-table loot module deployed + enabled (cached per session)?
-     * When true, {@link enginePull} routes rolls through server-held RNG with
-     * pity timers + audit trails; the blueprint's weighted model rolls stay
-     * for small tables (the coexistence policy — "the server picks the path").
-     */
-    engineAvailable() {
-        if (!this.engines)
-            return Promise.resolve(false);
-        return this.engines.has(this.engineModuleName);
-    }
-    /** Pull from the module's table (pity-timer path); count caps at 10. */
-    async enginePull(count = 1) {
-        if (!this.engines)
-            throw new Error('loot engine unavailable: compute domain not wired');
-        const result = await this.engines.invoke(this.engineModuleName, 'pull', { count });
-        if (!result.success)
-            throw new Error(`loot.pull failed: ${result.reason ?? 'unknown'}`);
-        return result.body;
-    }
-    /** Your pity counters + roll totals from the module. */
-    async enginePity() {
-        if (!this.engines)
-            throw new Error('loot engine unavailable: compute domain not wired');
-        const result = await this.engines.invoke(this.engineModuleName, 'pity', {});
-        if (!result.success)
-            throw new Error(`loot.pity failed: ${result.reason ?? 'unknown'}`);
-        return result.body;
-    }
-    /** Your rolling audit trail from the module (dispute resolution). */
-    async engineAudit() {
-        if (!this.engines)
-            throw new Error('loot engine unavailable: compute domain not wired');
-        const result = await this.engines.invoke(this.engineModuleName, 'audit', {});
-        if (!result.success)
-            throw new Error(`loot.audit failed: ${result.reason ?? 'unknown'}`);
-        return result.body;
-    }
-    /**
-     * Create an unrolled `LootRoll` for a table, owned by `ownerUserId` (who
-     * will claim it). Event-drop automations pick from the pool of unrolled
-     * rolls — create a few ahead of time for tables wired to `drops`.
-     */
-    async createRoll(input) {
-        return this.gameModel.createContainer({
-            appId: this.appId,
-            typeName: this.names.rollType,
-            displayName: input.displayName ?? `Roll ${input.tableId}`,
-            ...(input.sessionId !== undefined ? { sessionId: input.sessionId } : {}),
-            properties: [
-                {
-                    key: 'owner_user_id',
-                    valueType: 'int',
-                    valueJson: String(input.ownerUserId),
-                },
-                {
-                    key: 'table_id',
-                    valueType: 'string',
-                    valueJson: JSON.stringify(input.tableId),
-                },
-            ],
-        });
-    }
-    /**
-     * Roll a table on an unrolled `LootRoll` — a **trusted** call (default
-     * blueprint authority: app admins). Resolves with the rolled item id.
-     *
-     * @param tableId - The roll container's table (derives the function name);
-     *   read from the container when omitted.
-     */
-    async roll(rollId, tableId) {
-        const table = tableId ?? (await this.state(rollId)).tableId;
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: lootRollFn(table, this.typePrefix),
-            selfContainerId: rollId,
-            params: {},
-        });
-    }
-    /**
-     * Claim a rolled loot into a caller-owned stack of the rolled item. The
-     * claimed flag and the grant commit atomically. Resolves with the granted
-     * quantity.
-     */
-    async claim(rollId, toStackId) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.claimFn,
-            selfContainerId: rollId,
-            params: { to_stack_id: toStackId },
-        });
-    }
-    /** Read one roll's state. */
-    async state(rollId) {
-        const container = await this.gameModel.container({
-            appId: this.appId,
-            containerId: rollId,
-        });
-        return this.toRoll(container.containerId, container.displayName, container.ownerUserId != null ? String(container.ownerUserId) : null);
-    }
-    /**
-     * List a player's rolls, optionally filtered to one table and/or to
-     * unclaimed rolled loot (the "your drops" screen).
-     */
-    async rolls(ownerUserId, options = {}) {
-        const containers = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.rollType,
-        });
-        const mine = containers.filter((c) => c.ownerUserId != null && String(c.ownerUserId) === String(ownerUserId));
-        const rolls = await Promise.all(mine.map((c) => this.toRoll(c.containerId, c.displayName, c.ownerUserId != null ? String(c.ownerUserId) : null)));
-        return rolls.filter((r) => (options.tableId === undefined || r.tableId === options.tableId) &&
-            (!options.unclaimedOnly || (!r.claimed && r.rolledItemId !== '')));
-    }
-    /**
-     * Roll/claim audit history from the model event log (each roll records its
-     * seed, item, and quantity as applied mutations).
-     */
-    async history(options = {}) {
-        return this.gameModel.events({
-            appId: this.appId,
-            functionName: options.tableId !== undefined
-                ? lootRollFn(options.tableId, this.typePrefix)
-                : this.names.claimFn,
-            ...(options.limit !== undefined ? { limit: options.limit } : {}),
-        });
-    }
-    async toRoll(containerId, displayName, ownerUserId) {
-        const props = await kitContainerProperties(this.gameModel, String(this.appId), containerId);
-        return {
-            containerId,
-            displayName,
-            ownerUserId,
-            tableId: String(props.table_id ?? ''),
-            rolledItemId: String(props.rolled_item_id ?? ''),
-            rolledQty: Number(props.rolled_qty ?? 0),
-            claimed: props.claimed === true,
-        };
-    }
-}

package/dist/kit/matches.d.ts

@@ -1,301 +0,0 @@
-import type { ChannelsAPI } from '../domains/channels.js';
-import type { EngineDetector } from './engine.js';
-import type { GameModelAPI } from '../domains/gameModel.js';
-import type { UdpAPI } from '../domains/udp.js';
-import type { Scalars } from '../generated/graphql.js';
-import { type KitInvokeResult } from './shared.js';
-/**
- * What {@link MatchesKit.finish} did about the backing session after a
- * successful `end_match`: `'ended'` (it ended it), `'already_ended'` (a
- * replayed finish; the session was already ended), `'forbidden'` (the caller
- * passed `end_match` -- creator or the app's elected host -- but is neither
- * the session host nor an app admin, so the session is still active; an app
- * admin can `gameModel.endSession` it).
- * Absent when `end_match` itself was refused (`success: false`).
- */
-export type KitMatchSessionEnd = 'ended' | 'already_ended' | 'forbidden';
-/** {@link MatchesKit.finish}'s result: the invoke result plus what happened to the session. */
-export type KitMatchFinishResult = KitInvokeResult<string> & {
-    sessionEnd?: KitMatchSessionEnd;
-};
-/** Options for {@link MatchesKit}. Must match the deployed matches blueprint. */
-export interface MatchesKitOptions {
-    /**
-     * The compute module driving server-side match lifecycle when the app
-     * runs an engine. Defaults to `'match-engine'`.
-     */
-    engineModuleName?: string;
-    /** The `typePrefix` the matches blueprint was deployed with. */
-    typePrefix?: string;
-    /**
-     * The 32-ASCII-char actor uuid used as the sender id on channel pings.
-     * Defaults to a random uuid per kit instance.
-     */
-    actorUuid?: string;
-}
-/** A parsed view of one match. */
-export interface KitMatch {
-    /** The session backing the match (participants + turn order). */
-    sessionId: string;
-    /** The MatchMeta container id (the `self` of the lifecycle functions). */
-    metaId: string;
-    displayName: string;
-    creatorUserId: number;
-    mode: string;
-    state: string;
-    round: number;
-    maxPlayers: number;
-    winnerUserId: number;
-    /** The per-match notification channel (0 when none was wired). */
-    channelId: string;
-    /** Present when the blueprint was deployed with `turnTick`. */
-    tickCount?: number;
-    /**
-     * The current turn's sequence number. Present only when the blueprint was
-     * deployed with `turnTimer`, which is how the helpers detect that turns
-     * carry a deadline.
-     */
-    turnSeq?: number;
-    /** The highest turn sequence whose deadline elapsed. See {@link turnExpired}. */
-    turnExpiredSeq?: number;
-}
-/**
- * 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 declare function turnExpired(match: KitMatch): boolean;
-/** One row of the match standings. */
-export interface KitMatchScore {
-    containerId: string;
-    ownerUserId: string | null;
-    points: number;
-}
-/**
- * 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 declare class MatchesKit {
-    private readonly appId;
-    private readonly gameModel;
-    private readonly channels;
-    private readonly udp;
-    private readonly engines?;
-    private readonly names;
-    private readonly actorUuid;
-    private readonly engineModuleName;
-    /**
-     * 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.
-     */
-    private readonly incarnations;
-    constructor(appId: Scalars['BigInt']['input'], gameModel: GameModelAPI, channels: ChannelsAPI | undefined, udp: UdpAPI | undefined, options?: MatchesKitOptions, engines?: EngineDetector | undefined);
-    private requireChannels;
-    private requireUdp;
-    /**
-     * 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.
-     */
-    create(input: {
-        creatorUserId: Scalars['BigInt']['input'];
-        mode?: string;
-        maxPlayers?: number;
-        displayName?: string;
-        seedFromApp?: {
-            typeNames: string[];
-            initialState?: 'defaults' | 'app';
-        };
-    }): Promise<KitMatch>;
-    /** List joinable matches (metas still in the lobby state). */
-    open(): Promise<KitMatch[]>;
-    /** Read one match by its MatchMeta container. */
-    get(metaId: string): Promise<KitMatch>;
-    /**
-     * 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}.
-     */
-    join(match: KitMatch): Promise<{
-        __typename?: "GmSessionParticipant";
-        sessionId: string;
-        userId: string;
-        role: string;
-        state: string;
-        incarnation: number;
-        actorUuid: string | null;
-        joinedAt: string;
-        leftAt: string | null;
-        leftReason: string | null;
-    }>;
-    /**
-     * 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`.
-     */
-    leave(match: KitMatch, incarnation?: number): Promise<{
-        __typename?: "GmSessionParticipant";
-        sessionId: string;
-        userId: string;
-        role: string;
-        state: string;
-        incarnation: number;
-        actorUuid: string | null;
-        joinedAt: string;
-        leftAt: string | null;
-        leftReason: string | null;
-    }>;
-    /** Start the match (creator or host). Pings the match channel post-commit. */
-    start(match: KitMatch): Promise<KitInvokeResult<string>>;
-    /** Advance to the next round (creator or host). */
-    advanceRound(match: KitMatch): Promise<KitInvokeResult<number>>;
-    /** Whether it is `userId`'s session turn right now. */
-    myTurn(match: KitMatch, userId: Scalars['BigInt']['input']): Promise<boolean>;
-    /**
-     * 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.
-     */
-    endTurn(match: KitMatch, nextUserId: Scalars['BigInt']['input']): Promise<{
-        __typename?: "GmSession";
-        sessionId: string;
-        appId: string;
-        name: string | null;
-        status: string;
-        createdByUserId: string | null;
-        currentTurnUserId: string | null;
-        metadataJson: string;
-        admission: string;
-        maxParticipants: number | null;
-        participantCount: number;
-        hostUserId: string | null;
-        hostTerm: number;
-        revision: string;
-        endedAt: string | null;
-        endReason: string | null;
-        createdAt: string;
-        presence: string;
-        gridId: string | null;
-        seededContainerCount: number | null;
-    }>;
-    /**
-     * 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.
-     */
-    beginTurn(match: KitMatch): Promise<KitInvokeResult<number>>;
-    /**
-     * 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.
-     */
-    cancelTurnDeadline(match: KitMatch): Promise<number>;
-    /** Find-or-create a player's session-scoped Score row. */
-    ensureScore(match: KitMatch, ownerUserId: Scalars['BigInt']['input']): Promise<{
-        __typename?: "GmContainer";
-        containerId: string;
-        appId: string;
-        sessionId: string | null;
-        typeName: string;
-        displayName: string;
-        description: string | null;
-        ownerUserId: string | null;
-        metadataJson: string;
-    }>;
-    /**
-     * Add points to a Score row — trusted (host-refereed by default).
-     * Resolves with the new points.
-     */
-    score(match: KitMatch, scoreId: string, points: number): Promise<KitInvokeResult<number>>;
-    /** The match standings, highest points first (client-side sort). */
-    standings(match: KitMatch): Promise<KitMatchScore[]>;
-    /**
-     * 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.
-     */
-    finish(match: KitMatch, winnerUserId: Scalars['BigInt']['input']): Promise<KitMatchFinishResult>;
-    /**
-     * 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`).
-     */
-    notifyChanged(match: KitMatch): Promise<boolean>;
-    /**
-     * 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: KitMatch, callback: (match: KitMatch) => void): () => void;
-    private toMatch;
-    /**
-     * 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(): Promise<boolean>;
-    /**
-     * Declare ready on an engine match (a MatchMeta container id). The match
-     * starts server-side once every expected player is ready.
-     */
-    engineReady(matchId: string): Promise<Record<string, unknown>>;
-    /** Submit your move (the engine validates the turn + resolves). */
-    engineSubmitMove(matchId: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
-    /** Forfeit an engine match. */
-    engineForfeit(matchId: string): Promise<Record<string, unknown>>;
-    /** The engine's live view: turn holder, timers, standings, summary. */
-    engineStatus(matchId: string): Promise<Record<string, unknown>>;
-    /**
-     * Resolve a matchmaking proposal to the match the engine created for it
-     * (poll after everyone accepts; see `kit.matchmaking`).
-     */
-    findByProposal(proposalId: string): Promise<string | null>;
-    private engineInvoke;
-}
-//# sourceMappingURL=matches.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"matches.d.ts","sourceRoot":"","sources":["../../src/kit/matches.ts"],"names":[],"mappings":"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"}