@crowdedkingdoms/crowdyjs 17.3.0-dev.1 → 17.4.0-test.1

package/dist/generated/graphql.d.ts

@@ -2353,14 +2353,24 @@ export type CreatePortalAuthorizationCodeInput = {
 };
 /** Create a runtime session. */
 export type CreateSessionInput = {
+    /** Initial admission: 'open' (default) or 'locked' (only the initial participants may join/reconnect until the host unlocks). */
+    admission?: InputMaybe<Scalars['String']['input']>;
     /** The app (tenant) the session belongs to. */
     appId: Scalars['BigInt']['input'];
+    /** Seconds a session may sit with nobody joined before the server ends it as abandoned. Omit for the platform default; 0 disables the timeout for this session. */
+    emptyTimeoutSec?: InputMaybe<Scalars['Int']['input']>;
+    /** Optional idempotency key. Replaying with the same key and identical input returns the first session instead of creating a second; the same key with different input returns IDEMPOTENCY_CONFLICT. Keys expire after 24h. */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
+    /** Seat cap: the most participants that may be joined at once. Omit for unbounded. Initial participants count against it. */
+    maxParticipants?: InputMaybe<Scalars['Int']['input']>;
     /** JSON object of session metadata. */
     metadataJson?: InputMaybe<Scalars['String']['input']>;
     /** Optional session name. */
     name?: InputMaybe<Scalars['String']['input']>;
     /** Initial participants besides the creator. */
     participantUserIds?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    /** How the roster is judged: 'actor' (default) expires a joined participant with no fresh Buddy actor in the app after the join grace window; 'none' never expires anybody. Use 'none' for turn-based play that talks GraphQL and channel pings and never replicates an actor (kit.matches does), where the roster's only exits are leave and end. */
+    presence?: InputMaybe<Scalars['String']['input']>;
 };
 /** Create a team in an app. */
 export type CreateTeamInput = {
@@ -3539,6 +3549,19 @@ export type EmailStatusRecord = {
     /** valid | bounced | complained. */
     status: Scalars['String']['output'];
 };
+/** End a session. Host or app admin ('manage_apps'). */
+export type EndSessionInput = {
+    /** The app (tenant) that owns the session. */
+    appId: Scalars['BigInt']['input'];
+    /** Optional: the hostTerm you last read. Refused with SESSION_HOST_TERM_STALE if the host has changed since. */
+    expectedHostTerm?: InputMaybe<Scalars['Int']['input']>;
+    /** Optional idempotency key (24h). */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
+    /** Terminal status: 'completed' (default; the match ran its course) or 'abandoned'. Either way every joined participant is marked left (session_ended) and admission becomes closed. */
+    reason?: InputMaybe<Scalars['String']['input']>;
+    /** The session id to end. */
+    sessionId: Scalars['String']['input'];
+};
 /** Compute units attributed to one engine over the query window. */
 export type EngineComputeUnits = {
     __typename?: 'EngineComputeUnits';
@@ -4541,31 +4564,109 @@ export type GmSeedResult = {
 /** A runtime session: an isolated instance scope (e.g. a match or room) for containers. */
 export type GmSession = {
     __typename?: 'GmSession';
+    /** Who may still get in: 'open' (anyone the app admits), 'locked' (only a participant who already joined may reconnect), 'closed' (nobody; set automatically when the session ends). */
+    admission: Scalars['String']['output'];
     /** The app (tenant) that owns the session. */
     appId: Scalars['BigInt']['output'];
+    /** When the session was created. */
+    createdAt: Scalars['DateTime']['output'];
     /** The user who created the session. */
     createdByUserId: Maybe<Scalars['BigInt']['output']>;
     /** The user whose turn it currently is (turn-based play), or null. */
     currentTurnUserId: Maybe<Scalars['BigInt']['output']>;
+    /** Why it ended: 'completed' or 'abandoned' by the host/admin, 'empty_timeout' when the server ended a session nobody was in. */
+    endReason: Maybe<Scalars['String']['output']>;
+    /** When the session ended, or null while active. */
+    endedAt: Maybe<Scalars['DateTime']['output']>;
+    /** Increments on every host change. Send it as expectedHostTerm on host actions to be refused (SESSION_HOST_TERM_STALE) instead of acting on a host change you have not seen. */
+    hostTerm: Scalars['Int']['output'];
+    /** The current session host, or null while nobody is joined. The creator starts as host; when the host leaves or expires, the longest-joined present participant succeeds. */
+    hostUserId: Maybe<Scalars['BigInt']['output']>;
+    /** Seat cap: the most participants that may be joined at once. Null means unbounded. A participant reconnecting never counts against it twice. */
+    maxParticipants: Maybe<Scalars['Int']['output']>;
     /** JSON object of developer metadata. */
     metadataJson: Scalars['String']['output'];
     /** Optional session name. */
     name: Maybe<Scalars['String']['output']>;
+    /** How many participants are joined right now. */
+    participantCount: Scalars['Int']['output'];
+    /** How the roster is judged: 'actor' (default) expires a joined participant with no fresh Buddy actor in the app after the join grace window; 'none' never expires anybody -- for turn-based play that never replicates an actor -- so the roster's only exits are leave, end, and the empty timeout once everyone has left. */
+    presence: Scalars['String']['output'];
+    /** Monotonic change counter. Every event in gameModelSessionChanged carries the revision that produced it; gameModelSessionSnapshot returns the revision it describes. Compare as integers. */
+    revision: Scalars['String']['output'];
     /** Unique session id. */
     sessionId: Scalars['String']['output'];
     /** Lifecycle status (e.g. active). */
     status: Scalars['String']['output'];
 };
+/** One session revision: what changed, in order. The payload names the subject (user id, host, admission, ...) as a JSON object. */
+export type GmSessionEvent = {
+    __typename?: 'GmSessionEvent';
+    /** The app (tenant). */
+    appId: Scalars['BigInt']['output'];
+    /** When the revision was committed. */
+    createdAt: Scalars['DateTime']['output'];
+    /** created | participant_joined | participant_rejoined | participant_left | participant_expired | host_changed | admission_changed | turn_changed | ended */
+    kind: Scalars['String']['output'];
+    /** JSON object describing the change (e.g. {"userId":"…","incarnation":2} for a join, {"hostUserId":"…","hostTerm":3,"previousHostUserId":"…","reason":"host_left"} for a host change). */
+    payloadJson: Scalars['String']['output'];
+    /** The revision this event produced. Strictly increasing per session; a gap means a missed event -- pull gameModelSessionSnapshot or gameModelSessionEvents(afterRevision). */
+    revision: Scalars['String']['output'];
+    /** The session this revision belongs to. */
+    sessionId: Scalars['String']['output'];
+};
+/** An operator's view of one session: the full roster including departed participants, each joined participant's live presence verdict, and the most recent events. */
+export type GmSessionInspection = {
+    __typename?: 'GmSessionInspection';
+    /** Every participant row, joined and left, oldest join first. */
+    participants: Array<GmSessionParticipantInspection>;
+    /** The most recent events, newest first. */
+    recentEvents: Array<GmSessionEvent>;
+    /** The session row. */
+    session: GmSession;
+};
 /** A user's participation in a session. */
 export type GmSessionParticipant = {
     __typename?: 'GmSessionParticipant';
+    /** The Buddy actor uuid the client bound at join, if any. When set, this participant's presence is that actor's; when null, any fresh actor of the user in the app counts. */
+    actorUuid: Maybe<Scalars['String']['output']>;
+    /** Counts this user's joins to this session. A reconnect is the same row with incarnation + 1; a leave that names an older incarnation is a superseded client and is refused (SESSION_INCARNATION_STALE). */
+    incarnation: Scalars['Int']['output'];
+    /** When the user first joined (kept across reconnects). */
+    joinedAt: Scalars['DateTime']['output'];
+    /** When the participant last left, or null while joined. */
+    leftAt: Maybe<Scalars['DateTime']['output']>;
+    /** Why the participant left: 'left' (their own call), 'presence_expired' (no fresh actor past the grace window), 'session_ended', 'kicked'. */
+    leftReason: Maybe<Scalars['String']['output']>;
     /** The participant role within the session. */
     role: Scalars['String']['output'];
     /** The session id. */
     sessionId: Scalars['String']['output'];
+    /** 'joined' while the user is in the session, 'left' after a leave, a presence expiry, or the session ending. Rows are kept so the roster history is answerable. */
+    state: Scalars['String']['output'];
     /** The participant user id. */
     userId: Scalars['BigInt']['output'];
 };
+/** A joined participant with the platform's current presence verdict, for operators. */
+export type GmSessionParticipantInspection = {
+    __typename?: 'GmSessionParticipantInspection';
+    /** The roster row. */
+    participant: GmSessionParticipant;
+    /** 'fresh' (a qualifying actor is present), 'grace' (inside the join grace window, not yet judged), 'stale' (no qualifying actor; the next presence sweep will expire this participant), 'none' (the session's presence mode is 'none'; never expired), 'legacy' (row predates presence tracking; never expired), 'left' (not joined). */
+    presence: Scalars['String']['output'];
+    /** When the presence rule starts applying to this participant (join + grace), or null for a row the rule never applies to (a legacy row, or a session whose presence mode is 'none'). */
+    presenceFrom: Maybe<Scalars['DateTime']['output']>;
+};
+/** The authoritative state of one session at one revision: the session and every joined participant. The catch-up read after a subscription gap or a reconnect. */
+export type GmSessionSnapshot = {
+    __typename?: 'GmSessionSnapshot';
+    /** Every participant whose state is joined, oldest join first. */
+    participants: Array<GmSessionParticipant>;
+    /** The revision this snapshot describes. Discard buffered events at or below it and apply the ones above it. */
+    revision: Scalars['String']['output'];
+    /** The session row at this revision. */
+    session: GmSession;
+};
 /** A grant of a feature key to an access tier. */
 export type GmTierFeature = {
     __typename?: 'GmTierFeature';
@@ -5066,15 +5167,30 @@ export type InvokeFunctionInput = {
     /** Optional session context for the invocation. */
     sessionId?: InputMaybe<Scalars['String']['input']>;
 };
-/** Join an existing session. */
+/** Join an existing session, or reconnect to one you are already in. */
 export type JoinSessionInput = {
+    /** Optional: the Buddy actor uuid this client is playing as (32 hex characters, dashes accepted). It must be the caller's own actor. When given, the participant's presence is that actor's presence in the app; a new actor after a reconnect should rejoin with its uuid. When omitted, any fresh actor of this user in the app keeps the participant present. */
+    actorUuid?: InputMaybe<Scalars['String']['input']>;
     /** The app (tenant) that owns the session. */
     appId: Scalars['BigInt']['input'];
+    /** Optional idempotency key. Replaying with the same key and identical input returns the first result (same incarnation) instead of joining again. Keys expire after 24h. */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
     /** Optional participant role to join as. */
     role?: InputMaybe<Scalars['String']['input']>;
     /** The session id to join. */
     sessionId: Scalars['String']['input'];
 };
+/** Leave a session you are joined to. */
+export type LeaveSessionInput = {
+    /** The app (tenant) that owns the session. */
+    appId: Scalars['BigInt']['input'];
+    /** Optional idempotency key (24h). */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
+    /** The incarnation gameModelJoinSession returned to THIS client (a creator starts at 1; gameModelSessionSnapshot shows every participant's). Required: if a newer client has since rejoined as the same user, the call is refused with SESSION_INCARNATION_STALE and the newer client stays joined, so a superseded client can never remove the one that took over. */
+    incarnation: Scalars['Int']['input'];
+    /** The session id to leave. */
+    sessionId: Scalars['String']['input'];
+};
 /** Link an additional federated identity to the signed-in account. */
 export type LinkIdentityInput = {
     code: Scalars['String']['input'];
@@ -5326,7 +5442,7 @@ export type Mutation = {
     gameModelCancelTimer: Scalars['Int']['output'];
     /** Instantiate a container (a runtime entity of a given type), optionally within a session, with an owner and initial properties. Subject to the type's instantiableBy rule (admin | member | owner). Requires a valid token. */
     gameModelCreateContainer: GmContainer;
-    /** Create a runtime session: an isolated instance scope for containers (e.g. a match, room, or save). Subject to the app's session creation policy. The caller becomes the creator and a participant. Requires a valid token. */
+    /** Create a runtime session: an isolated instance scope for containers (e.g. a match, room, or save) with its own roster, host, admission and capacity. Subject to the app's session creation policy. The caller becomes creator, host (term 1) and a joined participant. Presence is actor presence: a participant with no fresh Buddy actor in the app after the join grace window is expired by the server. Requires a valid token. */
     gameModelCreateSession: GmSession;
     /** Define an app feature key that functions can gate on (via a tier_feature authority rule) and that access tiers can be granted. Idempotent on (app, featureKey). Requires app-admin ('manage_apps'). */
     gameModelDefineFeature: GmAppFeature;
@@ -5344,14 +5460,18 @@ export type Mutation = {
     gameModelDeleteFunction: Scalars['Boolean']['output'];
     /** Delete a property definition from a container type. Does not remove instance property values already stored on containers. Requires app-admin ('manage_apps'). DESTRUCTIVE. Returns true if a definition was deleted. */
     gameModelDeletePropertyDef: Scalars['Boolean']['output'];
+    /** End a session as 'completed' (default) or 'abandoned': every joined participant is marked left (session_ended), admission becomes closed, and an ended event closes the revision log. Session host or app admin ('manage_apps'); expectedHostTerm refuses a stale host. The server also ends sessions nobody has been joined to for longer than their empty timeout. Requires a valid token. */
+    gameModelEndSession: GmSession;
     /** Atomically get-or-create a container by an opaque bindingKey, unique per (appId, typeName, sessionId). Concurrent ensures with the same key all return the SAME containerId and exactly one response has created: true — no client-side leader election or list-then-create coordination is needed for shared world objects. When the row already exists this behaves like a read (creation-only fields are ignored and the type's instantiableBy rule is NOT enforced); when it does not exist, creation is authorized exactly like gameModelCreateContainer (instantiableBy + owner rules) AND by the type's bindPolicy, so a caller who may not instantiate the type, or may not claim keys for it, errors only in the not-exists case. bindingKey is client-supplied, so on a member- or owner-instantiable type ANY entitled player may create the keyed row and becomes its owner — which inverts every owner_of_self invoke policy on that type. Set the container type's bindPolicy (e.g. {"type":"is_host"}), or use an admin-instantiable type, for any object more than one player shares. The prefix `seed:` is reserved for gameModelSeed (v1.93.0); a non-admin ensure cannot claim it. Requires a valid token. */
     gameModelEnsureContainer: GmEnsureContainerResult;
     /** Grant a feature key to an access tier, so users on that tier satisfy tier_feature authority checks for it. Requires app-admin ('manage_apps'). */
     gameModelGrantTierFeature: GmTierFeature;
     /** Invoke a studio-defined function against a 'self' container with JSON params. The server enforces the function's invoke policy (authority rule tree: owner_of_self / is_host / is_current_turn / is_participant / tier_feature / group_permission / grid_permission / condition), evaluates its expressions, atomically applies its declared property mutations, logs an event, and returns the result (return value + mutations applied, or success=false with an error message). Invoke-policy denials are gameplay verdicts, NOT exceptions: they return success=false with errorMessage and log a failure event (observable via gameModelEvents). Scope violations (calling a server-scope function as a non-admin, or an internal function directly) are misconfigurations and throw FORBIDDEN. THE POLICY APPLIES TO APP ADMINS TOO (since v1.89.0): a manage_apps holder is judged exactly like a player unless the input sets bypassPolicy=true, which is refused for anyone else, marks the result policyBypassed=true and is audit-logged. This is the primary, safe way for players to mutate game state. Requires a valid token; only player-scope functions are invocable here. RATE LIMITED per player per app, defaulting to 120 invocations per 10 seconds: over the limit the call is refused with extensions.code RATE_LIMITED, extensions.blame 'budget' (the caller's own budget — not a fault in the game's code and not a platform failure) and extensions.retryAfterMs. A client that awaits each response cannot reach the limit, because the per-call ceiling already bounds a serial caller well below it. */
     gameModelInvoke: GmInvokeResult;
-    /** Join an existing session as a participant, optionally with a role. Requires a valid token and app access. */
+    /** Join a session, or reconnect to one you are already in. Refused with SESSION_ENDED, SESSION_CLOSED, SESSION_LOCKED (unless you already joined) or SESSION_FULL. A rejoin returns the same row with incarnation + 1 and supersedes any older client of yours. Pass actorUuid to bind the participant's presence to that Buddy actor. Requires a valid token. */
     gameModelJoinSession: GmSessionParticipant;
+    /** Leave a session you are joined to. Send the incarnation gameModelJoinSession gave you so a superseded client cannot remove the one that took over (SESSION_INCARNATION_STALE). Leaving an already-left row is a no-op. If you were host, the longest-joined present participant succeeds you (host_changed). Requires a valid token. */
+    gameModelLeaveSession: GmSessionParticipant;
     /** Revoke a feature key from an access tier. Requires app-admin ('manage_apps'). Returns true if a grant was removed. */
     gameModelRevokeTierFeature: Scalars['Boolean']['output'];
     /** Run an automation once, immediately (manual trigger), regardless of its schedule. Applies the same guard chain (app gate, rate limit, circuit) and records a run. Useful for testing an NPC. Requires app-admin ('manage_apps'). */
@@ -5368,8 +5488,12 @@ export type Mutation = {
     gameModelSetPolicy: GmAppPolicy;
     /** Set a single property value on a container directly (outside a function). Allowed only when the property's writability (function | owner | admin) permits the caller. The value is JSON-encoded and coerced to the property's value type. Requires a valid token. For game-logic changes prefer gameModelInvoke. */
     gameModelSetProperty: GmContainer;
-    /** Set or clear the session's current-turn user, for turn-based play (authority enforced by the service). Pass userId null to clear the turn. Requires a valid token. */
+    /** Change who may still join: 'open', 'locked' (participants who already joined may reconnect, nobody new), or 'closed' (nobody). Session host or app admin ('manage_apps'); expectedHostTerm refuses a stale host. Emits admission_changed. Requires a valid token. */
+    gameModelSetSessionAdmission: GmSession;
+    /** Set or clear the session's current-turn user, for turn-based play. Allowed for an app admin, the app's elected host, the session host, or the current turn holder. Pass userId null to clear the turn; expectedHostTerm refuses a stale host. Requires a valid token. */
     gameModelSetSessionTurn: GmSession;
+    /** Hand the session host role to another joined participant. Session host or app admin ('manage_apps'); expectedHostTerm refuses a stale host. Increments hostTerm and emits host_changed. Requires a valid token. */
+    gameModelTransferSessionHost: GmSession;
     /** Create or update an autonomous process ("automation" / NPC): a server-driven entry-point function bound to a trigger (schedule | event | manual), an optional run-as identity, a target/candidate selector, and a per-automation safety budget. The entry-point function must be marked autonomousInvocable. Idempotent on (app, name). Requires app-admin ('manage_apps'). NOTHING RUNS FOR AN APP WITH NO PLAYER IN IT: a SCHEDULE trigger that comes due while the app is empty is skipped and rescheduled from the moment a player returns, and the missed runs are never made up -- so write the entry point to advance the world by elapsed time rather than by one step per run. Event and manual triggers are unaffected, because something already asked. */
     gameModelUpsertAutomation: GmAutomation;
     /** Create an event trigger that fires an automation in reaction to model activity or a complete app-scoped active-player-count transition. player_count_changed rejects model filters, starts silent-baseline tracking, injects reserved previous/current/delta/revision params, and uses trailing-edge debounce; other event behavior is unchanged. Matched in the API server post-commit. Requires app-admin ('manage_apps'). */
@@ -5966,6 +6090,9 @@ export type MutationGameModelDeletePropertyDefArgs = {
     containerTypeName: Scalars['String']['input'];
     key: Scalars['String']['input'];
 };
+export type MutationGameModelEndSessionArgs = {
+    input: EndSessionInput;
+};
 export type MutationGameModelEnsureContainerArgs = {
     input: EnsureContainerInput;
 };
@@ -5978,6 +6105,9 @@ export type MutationGameModelInvokeArgs = {
 export type MutationGameModelJoinSessionArgs = {
     input: JoinSessionInput;
 };
+export type MutationGameModelLeaveSessionArgs = {
+    input: LeaveSessionInput;
+};
 export type MutationGameModelRevokeTierFeatureArgs = {
     input: GrantTierFeatureInput;
 };
@@ -6005,9 +6135,15 @@ export type MutationGameModelSetPolicyArgs = {
 export type MutationGameModelSetPropertyArgs = {
     input: SetContainerPropertyInput;
 };
+export type MutationGameModelSetSessionAdmissionArgs = {
+    input: SetSessionAdmissionInput;
+};
 export type MutationGameModelSetSessionTurnArgs = {
     input: SetSessionTurnInput;
 };
+export type MutationGameModelTransferSessionHostArgs = {
+    input: TransferSessionHostInput;
+};
 export type MutationGameModelUpsertAutomationArgs = {
     input: UpsertAutomationInput;
 };
@@ -7917,9 +8053,15 @@ export type Query = {
     gameModelPolicy: GmAppPolicy;
     /** List the property definitions for a container type. Requires app-admin ('manage_apps'). */
     gameModelPropertyDefs: Array<GmPropertyDef>;
-    /** Fetch one session by id. Requires a valid token. */
+    /** Fetch one session by id, with its joined-participant count, host, admission and revision. Requires a valid token. */
     gameModelSession: GmSession;
-    /** List sessions in an app, optionally filtered by status. Requires a valid token. */
+    /** The session events with a revision greater than afterRevision, oldest first: the gap-fill read behind gameModelSessionChanged. Events of ended sessions are retained for a bounded period, then purged. Requires a valid token. */
+    gameModelSessionEvents: Array<GmSessionEvent>;
+    /** Operator view of one session: the full roster including departed participants (with left reason and incarnation), each joined participant's live presence verdict, and the most recent events. Requires app-admin ('manage_apps'). */
+    gameModelSessionInspect: GmSessionInspection;
+    /** The authoritative state of one session at one revision: the session row and every joined participant. Pull it when you subscribe, after a reconnect, or when gameModelSessionChanged shows a revision gap; then apply only events with a higher revision. Requires a valid token. */
+    gameModelSessionSnapshot: GmSessionSnapshot;
+    /** List sessions in an app, newest first, optionally filtered by status, admission and/or host. Requires a valid token. */
     gameModelSessions: Array<GmSession>;
     /** List tier -> feature grants for an app, optionally filtered to one tier. Requires app-admin ('manage_apps'). */
     gameModelTierFeatures: Array<GmTierFeature>;
@@ -8540,8 +8682,25 @@ export type QueryGameModelSessionArgs = {
     appId: Scalars['BigInt']['input'];
     sessionId: Scalars['String']['input'];
 };
+export type QueryGameModelSessionEventsArgs = {
+    afterRevision: Scalars['String']['input'];
+    appId: Scalars['BigInt']['input'];
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    sessionId: Scalars['String']['input'];
+};
+export type QueryGameModelSessionInspectArgs = {
+    appId: Scalars['BigInt']['input'];
+    sessionId: Scalars['String']['input'];
+};
+export type QueryGameModelSessionSnapshotArgs = {
+    appId: Scalars['BigInt']['input'];
+    sessionId: Scalars['String']['input'];
+};
 export type QueryGameModelSessionsArgs = {
+    admission?: InputMaybe<Scalars['String']['input']>;
     appId: Scalars['BigInt']['input'];
+    hostUserId?: InputMaybe<Scalars['BigInt']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
     status?: InputMaybe<Scalars['String']['input']>;
 };
 export type QueryGameModelTierFeaturesArgs = {
@@ -9769,10 +9928,27 @@ export type SetRateCardResult = {
     /** The dimension as it now stands. */
     entry: RateCardEntryType;
 };
+/** Change who may still join a session. Host or app admin ('manage_apps'). */
+export type SetSessionAdmissionInput = {
+    /** 'open' (anyone the app admits), 'locked' (only participants who already joined may reconnect), 'closed' (nobody, not even by reconnection). */
+    admission: Scalars['String']['input'];
+    /** The app (tenant) that owns the session. */
+    appId: Scalars['BigInt']['input'];
+    /** Optional: the hostTerm you last read. Refused with SESSION_HOST_TERM_STALE if the host has changed since. */
+    expectedHostTerm?: InputMaybe<Scalars['Int']['input']>;
+    /** Optional idempotency key (24h). */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
+    /** The session id to update. */
+    sessionId: Scalars['String']['input'];
+};
 /** Set or clear the current-turn user of a session. */
 export type SetSessionTurnInput = {
     /** The app (tenant) that owns the session. */
     appId: Scalars['BigInt']['input'];
+    /** Optional: the hostTerm you last read. Refused with SESSION_HOST_TERM_STALE if the host has changed since, so a stale host never sets the turn. */
+    expectedHostTerm?: InputMaybe<Scalars['Int']['input']>;
+    /** Optional idempotency key (24h). */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
     /** The session id to update. */
     sessionId: Scalars['String']['input'];
     /** The user whose turn it now is (NULL clears the turn). */
@@ -9872,6 +10048,8 @@ export type Subscription = {
     gameModelActivePlayerCountChanged: GameModelActivePlayerCountChange;
     /** Push notification whenever a container in the app changes: an invoke mutated it, a direct gameModelSetProperty wrote it, or it was created/deleted. Metadata only (containerId, typeName, changedKeys — no property values); pull the visibility-filtered state with gameModelContainerState on receipt. Post-commit and best-effort (a dropped event costs one missed pull, never correctness) — durable reads remain the source of truth. Optional typeName/sessionId filters narrow delivery. Fans out across all API replicas. Requires a valid token. Replaces interval polling with pull-on-push. */
     gameModelContainerChanged: GmContainerChange;
+    /** Stream the revisions of one session as they commit: joins, rejoins, leaves, presence expiries, host changes, admission changes, turn changes, and the end. There is no bootstrap event: pull gameModelSessionSnapshot first (or pass afterRevision to replay retained events from there). Revisions are strictly increasing; on a gap or after a reconnect, pull the snapshot again. Cross-replica, best-effort wakeup over a bounded oldest-drop buffer; the events table is the record. Requires a valid token. */
+    gameModelSessionChanged: GmSessionEvent;
     /** Realtime downlink from the game server: spatial notifications and responses, GenericErrorResponse (errors from your sends, correlated by sequenceNumber), and RealtimeConnectionEvent (lifecycle/setup failures). Requires a bearer game token AND an appId-scoped connection — the appId is read from the graphql-transport-ws connection (game tokens are app-agnostic and one UDP socket is shared across apps, so an app-agnostic subscription is rejected with a RealtimeConnectionEvent code APP_ID_REQUIRED, and a missing/invalid token with AUTH_REQUIRED). On subscribe, opens a UDP proxy session if none exists (binds to the least-loaded game server); open/transport failures are delivered as RealtimeConnectionEvent (code UDP_PROXY_CONNECTION_FAILED) and then the stream ends. Only this app’s spatial fan-out is delivered; appId-less control frames always pass. Subscribe before/while sending so async results are not missed. Unsubscribing stops delivery only — it does NOT close the UDP session; call disconnectUdpProxy (or rely on the server inactivity timeout) to release it. */
     udpNotifications: Maybe<UdpNotification>;
 };
@@ -9883,6 +10061,11 @@ export type SubscriptionGameModelContainerChangedArgs = {
     sessionId?: InputMaybe<Scalars['String']['input']>;
     typeName?: InputMaybe<Scalars['String']['input']>;
 };
+export type SubscriptionGameModelSessionChangedArgs = {
+    afterRevision?: InputMaybe<Scalars['String']['input']>;
+    appId: Scalars['BigInt']['input'];
+    sessionId: Scalars['String']['input'];
+};
 export type TeleportRequestInput = {
     /** App (game) to teleport within. Must be greater than 0 (a non-positive value yields errorCode INVALID_APP_ID). BigInt sent as a decimal string. */
     appId: Scalars['BigInt']['input'];
@@ -9929,6 +10112,19 @@ export type TransferPlayerCodeListingInput = {
     /** Numeric user id or org id of the new owner, per toOwnerKind. */
     toOwnerRef: Scalars['BigInt']['input'];
 };
+/** Hand the session host role to another joined participant. Host or app admin ('manage_apps'). */
+export type TransferSessionHostInput = {
+    /** The app (tenant) that owns the session. */
+    appId: Scalars['BigInt']['input'];
+    /** Optional: the hostTerm you last read. Refused with SESSION_HOST_TERM_STALE if the host has changed since. */
+    expectedHostTerm?: InputMaybe<Scalars['Int']['input']>;
+    /** Optional idempotency key (24h). */
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
+    /** The session id. */
+    sessionId: Scalars['String']['input'];
+    /** The joined participant who becomes host. */
+    toUserId: Scalars['BigInt']['input'];
+};
 /** Error codes returned by UDP game servers (and surfaced on `GenericErrorResponse.errorCode`) in response to a spatial/realtime message. NO_ERROR (0) indicates success; every other value indicates a failure. The numeric value is the byte sent on the wire; GraphQL exposes the name. Note: a failed message does not always produce an error — some auth failures are dropped silently (see the docs). */
 export declare enum UdpErrorCode {
     /** No app matches the supplied appId. */
@@ -14472,6 +14668,37 @@ export type GmSessionFieldsFragment = {
     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;
+};
+export type GmSessionParticipantFieldsFragment = {
+    __typename?: 'GmSessionParticipant';
+    sessionId: string;
+    userId: string;
+    role: string;
+    state: string;
+    incarnation: number;
+    actorUuid: string | null;
+    joinedAt: string;
+    leftAt: string | null;
+    leftReason: string | null;
+};
+export type GmSessionEventFieldsFragment = {
+    __typename?: 'GmSessionEvent';
+    appId: string;
+    sessionId: string;
+    revision: string;
+    kind: string;
+    payloadJson: string;
+    createdAt: string;
 };
 export type GmContainerFieldsFragment = {
     __typename?: 'GmContainer';
@@ -14521,6 +14748,16 @@ export type GameModelCreateSessionMutation = {
         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;
     };
 };
 export type GameModelJoinSessionMutationVariables = Exact<{
@@ -14533,6 +14770,30 @@ export type GameModelJoinSessionMutation = {
         sessionId: string;
         userId: string;
         role: string;
+        state: string;
+        incarnation: number;
+        actorUuid: string | null;
+        joinedAt: string;
+        leftAt: string | null;
+        leftReason: string | null;
+    };
+};
+export type GameModelLeaveSessionMutationVariables = Exact<{
+    input: LeaveSessionInput;
+}>;
+export type GameModelLeaveSessionMutation = {
+    __typename?: 'Mutation';
+    gameModelLeaveSession: {
+        __typename?: 'GmSessionParticipant';
+        sessionId: string;
+        userId: string;
+        role: string;
+        state: string;
+        incarnation: number;
+        actorUuid: string | null;
+        joinedAt: string;
+        leftAt: string | null;
+        leftReason: string | null;
     };
 };
 export type GameModelSetSessionTurnMutationVariables = Exact<{
@@ -14549,6 +14810,94 @@ export type GameModelSetSessionTurnMutation = {
         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;
+    };
+};
+export type GameModelSetSessionAdmissionMutationVariables = Exact<{
+    input: SetSessionAdmissionInput;
+}>;
+export type GameModelSetSessionAdmissionMutation = {
+    __typename?: 'Mutation';
+    gameModelSetSessionAdmission: {
+        __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;
+    };
+};
+export type GameModelTransferSessionHostMutationVariables = Exact<{
+    input: TransferSessionHostInput;
+}>;
+export type GameModelTransferSessionHostMutation = {
+    __typename?: 'Mutation';
+    gameModelTransferSessionHost: {
+        __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;
+    };
+};
+export type GameModelEndSessionMutationVariables = Exact<{
+    input: EndSessionInput;
+}>;
+export type GameModelEndSessionMutation = {
+    __typename?: 'Mutation';
+    gameModelEndSession: {
+        __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;
     };
 };
 export type GameModelCreateContainerMutationVariables = Exact<{
@@ -14767,11 +15116,24 @@ export type GameModelSessionQuery = {
         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;
     };
 };
 export type GameModelSessionsQueryVariables = Exact<{
     appId: Scalars['BigInt']['input'];
     status?: InputMaybe<Scalars['String']['input']>;
+    admission?: InputMaybe<Scalars['String']['input']>;
+    hostUserId?: InputMaybe<Scalars['BigInt']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
 }>;
 export type GameModelSessionsQuery = {
     __typename?: 'Query';
@@ -14784,8 +15146,152 @@ export type GameModelSessionsQuery = {
         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;
     }>;
 };
+export type GameModelSessionSnapshotQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    sessionId: Scalars['String']['input'];
+}>;
+export type GameModelSessionSnapshotQuery = {
+    __typename?: 'Query';
+    gameModelSessionSnapshot: {
+        __typename?: 'GmSessionSnapshot';
+        revision: string;
+        session: {
+            __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;
+        };
+        participants: Array<{
+            __typename?: 'GmSessionParticipant';
+            sessionId: string;
+            userId: string;
+            role: string;
+            state: string;
+            incarnation: number;
+            actorUuid: string | null;
+            joinedAt: string;
+            leftAt: string | null;
+            leftReason: string | null;
+        }>;
+    };
+};
+export type GameModelSessionEventsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    sessionId: Scalars['String']['input'];
+    afterRevision: Scalars['String']['input'];
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type GameModelSessionEventsQuery = {
+    __typename?: 'Query';
+    gameModelSessionEvents: Array<{
+        __typename?: 'GmSessionEvent';
+        appId: string;
+        sessionId: string;
+        revision: string;
+        kind: string;
+        payloadJson: string;
+        createdAt: string;
+    }>;
+};
+export type GameModelSessionInspectQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    sessionId: Scalars['String']['input'];
+}>;
+export type GameModelSessionInspectQuery = {
+    __typename?: 'Query';
+    gameModelSessionInspect: {
+        __typename?: 'GmSessionInspection';
+        session: {
+            __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;
+        };
+        participants: Array<{
+            __typename?: 'GmSessionParticipantInspection';
+            presence: string;
+            presenceFrom: string | null;
+            participant: {
+                __typename?: 'GmSessionParticipant';
+                sessionId: string;
+                userId: string;
+                role: string;
+                state: string;
+                incarnation: number;
+                actorUuid: string | null;
+                joinedAt: string;
+                leftAt: string | null;
+                leftReason: string | null;
+            };
+        }>;
+        recentEvents: Array<{
+            __typename?: 'GmSessionEvent';
+            appId: string;
+            sessionId: string;
+            revision: string;
+            kind: string;
+            payloadJson: string;
+            createdAt: string;
+        }>;
+    };
+};
+export type GameModelSessionChangedSubscriptionVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    sessionId: Scalars['String']['input'];
+    afterRevision?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type GameModelSessionChangedSubscription = {
+    __typename?: 'Subscription';
+    gameModelSessionChanged: {
+        __typename?: 'GmSessionEvent';
+        appId: string;
+        sessionId: string;
+        revision: string;
+        kind: string;
+        payloadJson: string;
+        createdAt: string;
+    };
+};
 export type GameModelEventsQueryVariables = Exact<{
     appId: Scalars['BigInt']['input'];
     sessionId?: InputMaybe<Scalars['String']['input']>;
@@ -19347,6 +19853,8 @@ export declare const GmAutomationPolicyFieldsFragmentDoc: DocumentNode<GmAutomat
 export declare const GmAutomationRunFieldsFragmentDoc: DocumentNode<GmAutomationRunFieldsFragment, unknown>;
 export declare const GmTimerFieldsFragmentDoc: DocumentNode<GmTimerFieldsFragment, unknown>;
 export declare const GmSessionFieldsFragmentDoc: DocumentNode<GmSessionFieldsFragment, unknown>;
+export declare const GmSessionParticipantFieldsFragmentDoc: DocumentNode<GmSessionParticipantFieldsFragment, unknown>;
+export declare const GmSessionEventFieldsFragmentDoc: DocumentNode<GmSessionEventFieldsFragment, unknown>;
 export declare const GmContainerFieldsFragmentDoc: DocumentNode<GmContainerFieldsFragment, unknown>;
 export declare const GmInvokeResultFieldsFragmentDoc: DocumentNode<GmInvokeResultFieldsFragment, unknown>;
 export declare const GmFunctionFieldsFragmentDoc: DocumentNode<GmFunctionFieldsFragment, unknown>;
@@ -19516,7 +20024,11 @@ export declare const GameModelActivePlayerCountDocument: DocumentNode<GameModelA
 export declare const GameModelActivePlayerCountChangedDocument: DocumentNode<GameModelActivePlayerCountChangedSubscription, GameModelActivePlayerCountChangedSubscriptionVariables>;
 export declare const GameModelCreateSessionDocument: DocumentNode<GameModelCreateSessionMutation, GameModelCreateSessionMutationVariables>;
 export declare const GameModelJoinSessionDocument: DocumentNode<GameModelJoinSessionMutation, GameModelJoinSessionMutationVariables>;
+export declare const GameModelLeaveSessionDocument: DocumentNode<GameModelLeaveSessionMutation, GameModelLeaveSessionMutationVariables>;
 export declare const GameModelSetSessionTurnDocument: DocumentNode<GameModelSetSessionTurnMutation, GameModelSetSessionTurnMutationVariables>;
+export declare const GameModelSetSessionAdmissionDocument: DocumentNode<GameModelSetSessionAdmissionMutation, GameModelSetSessionAdmissionMutationVariables>;
+export declare const GameModelTransferSessionHostDocument: DocumentNode<GameModelTransferSessionHostMutation, GameModelTransferSessionHostMutationVariables>;
+export declare const GameModelEndSessionDocument: DocumentNode<GameModelEndSessionMutation, GameModelEndSessionMutationVariables>;
 export declare const GameModelCreateContainerDocument: DocumentNode<GameModelCreateContainerMutation, GameModelCreateContainerMutationVariables>;
 export declare const GameModelDeleteContainerDocument: DocumentNode<GameModelDeleteContainerMutation, GameModelDeleteContainerMutationVariables>;
 export declare const GameModelSetPropertyDocument: DocumentNode<GameModelSetPropertyMutation, GameModelSetPropertyMutationVariables>;
@@ -19530,6 +20042,10 @@ export declare const GameModelContainerStateDocument: DocumentNode<GameModelCont
 export declare const GameModelTraverseDocument: DocumentNode<GameModelTraverseQuery, GameModelTraverseQueryVariables>;
 export declare const GameModelSessionDocument: DocumentNode<GameModelSessionQuery, GameModelSessionQueryVariables>;
 export declare const GameModelSessionsDocument: DocumentNode<GameModelSessionsQuery, GameModelSessionsQueryVariables>;
+export declare const GameModelSessionSnapshotDocument: DocumentNode<GameModelSessionSnapshotQuery, GameModelSessionSnapshotQueryVariables>;
+export declare const GameModelSessionEventsDocument: DocumentNode<GameModelSessionEventsQuery, GameModelSessionEventsQueryVariables>;
+export declare const GameModelSessionInspectDocument: DocumentNode<GameModelSessionInspectQuery, GameModelSessionInspectQueryVariables>;
+export declare const GameModelSessionChangedDocument: DocumentNode<GameModelSessionChangedSubscription, GameModelSessionChangedSubscriptionVariables>;
 export declare const GameModelEventsDocument: DocumentNode<GameModelEventsQuery, GameModelEventsQueryVariables>;
 export declare const GameModelEventsConnectionDocument: DocumentNode<GameModelEventsConnectionQuery, GameModelEventsConnectionQueryVariables>;
 export declare const GameModelFlowDocument: DocumentNode<GameModelFlowQuery, GameModelFlowQueryVariables>;