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

package/dist/domains/gameModel.js

@@ -1,1333 +0,0 @@
-import { createClient as createWsClient } from 'graphql-ws';
-import { print } from 'graphql';
-import { 
-// Runtime (player) ops
-GameModelCreateSessionDocument, GameModelJoinSessionDocument, GameModelSetSessionTurnDocument, GameModelLeaveSessionDocument, GameModelSetSessionAdmissionDocument, GameModelTransferSessionHostDocument, GameModelEndSessionDocument, GameModelSessionSnapshotDocument, GameModelSessionEventsDocument, GameModelSessionInspectDocument, GameModelSessionChangedDocument, GameModelCreateContainerDocument, GameModelDeleteContainerDocument, GameModelSetPropertyDocument, GameModelAddEdgeDocument, GameModelDeleteEdgeDocument, GameModelInvokeDocument, GameModelContainerDocument, GameModelContainerChangedDocument, GameModelActivePlayerCountDocument, GameModelActivePlayerCountChangedDocument, GameModelContainersDocument, GameModelContainerStateDocument, GameModelContainerStatesDocument, GameModelTraverseDocument, GameModelSessionDocument, GameModelSessionsDocument, GameModelEventsDocument, GameModelFlowDocument, 
-// Studio authoring ops
-GameModelSeedDocument, GameModelUpsertContainerTypeDocument, GameModelUpsertPropertyDefDocument, GameModelDeletePropertyDefDocument, GameModelDeleteContainerTypeDocument, GameModelUpsertFunctionDocument, GameModelDeleteFunctionDocument, GameModelDefineFeatureDocument, GameModelGrantTierFeatureDocument, GameModelSetPolicyDocument, GameModelTypeSchemaDocument, GameModelContainerTypesDocument, GameModelPropertyDefsDocument, GameModelFunctionDocument, GameModelFunctionsDocument, GameModelFeaturesDocument, GameModelTierFeaturesDocument, GameModelPolicyDocument, GameModelRevokeTierFeatureDocument, GameModelEventsConnectionDocument, 
-// Automations (autonomous processes / NPCs)
-GameModelUpsertAutomationDocument, GameModelDeleteAutomationDocument, GameModelSetAutomationEnabledDocument, GameModelUpsertAutomationTriggerDocument, GameModelDeleteAutomationTriggerDocument, GameModelSetAutomationPolicyDocument, GameModelRunAutomationDocument, GameModelAutomationsDocument, GameModelAutomationDocument, GameModelAutomationTriggersDocument, GameModelAutomationPolicyDocument, GameModelAutomationRunsDocument, GameModelAutomationStatsDocument, GameModelAppDiagnosticsDocument, GameModelScheduleInvokeDocument, GameModelCancelTimerDocument, GameModelTimersDocument, } from '../generated/graphql.js';
-export class GameModelAPI {
-    constructor(gql, ws) {
-        this.gql = gql;
-        this.ws = ws;
-    }
-    /**
-     * **Player count** — read the best-known number of active gameplay sessions
-     * for one app. Requires a bearer token scoped to exactly `appId`.
-     *
-     * This is a **session count**, not a distinct-user or actor count: one user
-     * with multiple active sessions contributes more than once. A session that
-     * disappears without a clean disconnect can remain counted for approximately
-     * 120 seconds while its inactivity is recognized.
-     *
-     * Treat the result as authoritative only when `status === 'FRESH'`.
-     * `PARTIAL` is an incomplete best-known count and `UNAVAILABLE` means no fresh
-     * observation exists; neither status is an authoritative zero. `appId` and
-     * the monotonic `revision` are generated `BigInt` scalars represented as
-     * decimal strings.
-     *
-     * @param appId - App to count, as a decimal-string `BigInt`; it must match
-     *   the app scope of the bearer token.
-     * @returns The generated snapshot payload: `appId`, `activePlayerCount`,
-     *   `status`, nullable `observedAt`, and `revision`.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING` when the
-     *   token is missing or is not scoped to `appId`.
-     */
-    async activePlayerCount(appId) {
-        const data = await this.gql.request(GameModelActivePlayerCountDocument, {
-            appId,
-        });
-        return data.gameModelActivePlayerCount;
-    }
-    /**
-     * **Player-count subscription** — stream complete active-session count
-     * transitions for one app. Requires a bearer token scoped to exactly
-     * `variables.appId` and a game-api `wsUrl` in the client config.
-     *
-     * This stream counts gameplay **sessions**, not distinct users or actors;
-     * abandoned sessions can remain counted for approximately 120 seconds while
-     * inactivity is recognized. It emits no initial/bootstrap event, so establish
-     * the stream and then call {@link activePlayerCount} for the current snapshot.
-     * `PARTIAL` and `UNAVAILABLE` observations neither emit transitions nor
-     * represent an authoritative zero.
-     *
-     * Delivery is best-effort and may miss or repeat events across reconnects.
-     * Deduplicate by the decimal-string `revision`. Requery
-     * {@link activePlayerCount} after every reconnect or whenever revisions have
-     * a gap; the query is the source of truth.
-     *
-     * @param variables - Exact call shape `{ appId }`, where `appId` is the
-     *   decimal-string `BigInt` matching the app-scoped bearer token.
-     * @param handlers - `next` per transition; optional `error`, `complete`, and
-     *   `webSocketImpl` for runtimes without a global `WebSocket`.
-     * @returns An unsubscribe function that disposes this subscription and its
-     *   graphql-transport-ws client.
-     * @throws {Error} Synchronously when the client config has no `wsUrl`.
-     */
-    activePlayerCountChanged(variables, handlers) {
-        if (!this.ws?.wsUrl) {
-            throw new Error('activePlayerCountChanged requires a wsUrl in the client config (graphql-transport-ws endpoint)');
-        }
-        const client = createWsClient({
-            url: this.ws.wsUrl,
-            lazy: false,
-            retryAttempts: 8,
-            ...(handlers.webSocketImpl
-                ? { webSocketImpl: handlers.webSocketImpl }
-                : {}),
-            connectionParams: () => {
-                const token = this.ws?.getToken();
-                return token ? { Authorization: `Bearer ${token}` } : {};
-            },
-        });
-        const dispose = client.subscribe({ query: print(GameModelActivePlayerCountChangedDocument), variables }, {
-            next: (msg) => {
-                const data = msg.data;
-                if (data?.gameModelActivePlayerCountChanged) {
-                    handlers.next(data.gameModelActivePlayerCountChanged);
-                }
-                else if (msg.errors) {
-                    handlers.error?.(msg.errors);
-                }
-            },
-            error: (err) => handlers.error?.(err),
-            complete: () => handlers.complete?.(),
-        });
-        return () => {
-            dispose();
-            void client.dispose();
-        };
-    }
-    /**
-     * **Subscriptions** — stream container-change notifications for an app
-     * (`gameModelContainerChanged`): an invoke mutated a container, a direct
-     * `setProperty` wrote it, or it was created/deleted. Events are
-     * **metadata only** (containerId, typeName, changedKeys — no property
-     * values): pull the visibility-filtered state with {@link containerState}
-     * on receipt. Post-commit and best-effort, exactly like model-driven
-     * notifications — replaces interval polling with pull-on-push. Requires a
-     * game-api with the container-change feed (2026-07+) and a `wsUrl` in the
-     * client config.
-     *
-     * @param variables - `{ appId, typeName?, sessionId? }` delivery filters.
-     * @param handlers - `next` per change; optional `error` / `complete`.
-     * @returns An unsubscribe function (closes this subscription's socket).
-     */
-    containerChanged(variables, handlers) {
-        if (!this.ws?.wsUrl) {
-            throw new Error('containerChanged requires a wsUrl in the client config (graphql-transport-ws endpoint)');
-        }
-        const client = createWsClient({
-            url: this.ws.wsUrl,
-            lazy: false,
-            retryAttempts: 8,
-            ...(handlers.webSocketImpl
-                ? { webSocketImpl: handlers.webSocketImpl }
-                : {}),
-            connectionParams: () => {
-                const token = this.ws?.getToken();
-                return token ? { Authorization: `Bearer ${token}` } : {};
-            },
-        });
-        const dispose = client.subscribe({ query: print(GameModelContainerChangedDocument), variables }, {
-            next: (msg) => {
-                const data = msg.data;
-                if (data?.gameModelContainerChanged) {
-                    handlers.next(data.gameModelContainerChanged);
-                }
-                else if (msg.errors) {
-                    handlers.error?.(msg.errors);
-                }
-            },
-            error: (err) => handlers.error?.(err),
-            complete: () => handlers.complete?.(),
-        });
-        return () => {
-            dispose();
-            void client.dispose();
-        };
-    }
-    /**
-     * **Subscriptions** — stream the revisions of one session as they commit
-     * (`gameModelSessionChanged`): joins, rejoins, leaves, presence expiries,
-     * host changes, admission changes, turn changes and the end. There is no
-     * bootstrap event: pull {@link sessionSnapshot} 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 and best-effort over a bounded buffer; the events
-     * table ({@link sessionEvents}) is the record. Requires a `wsUrl` in the
-     * client config.
-     *
-     * @param variables - `{ appId, sessionId, afterRevision? }`.
-     * @param handlers - `next` per revision; optional `error` / `complete` /
-     *   `webSocketImpl`.
-     * @returns An unsubscribe function (closes this subscription's socket).
-     * @throws {Error} Synchronously when the client config has no `wsUrl`.
-     */
-    sessionChanged(variables, handlers) {
-        if (!this.ws?.wsUrl) {
-            throw new Error('sessionChanged requires a wsUrl in the client config (graphql-transport-ws endpoint)');
-        }
-        const client = createWsClient({
-            url: this.ws.wsUrl,
-            lazy: false,
-            retryAttempts: 8,
-            ...(handlers.webSocketImpl
-                ? { webSocketImpl: handlers.webSocketImpl }
-                : {}),
-            connectionParams: () => {
-                const token = this.ws?.getToken();
-                return token ? { Authorization: `Bearer ${token}` } : {};
-            },
-        });
-        const dispose = client.subscribe({ query: print(GameModelSessionChangedDocument), variables }, {
-            next: (msg) => {
-                const data = msg.data;
-                if (data?.gameModelSessionChanged) {
-                    handlers.next(data.gameModelSessionChanged);
-                }
-                else if (msg.errors) {
-                    handlers.error?.(msg.errors);
-                }
-            },
-            error: (err) => handlers.error?.(err),
-            complete: () => handlers.complete?.(),
-        });
-        return () => {
-            dispose();
-            void client.dispose();
-        };
-    }
-    // -- Runtime (player) -------------------------------------------------------
-    /**
-     * **Sessions** — 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 ({@link setPolicy}); the caller becomes the creator
-     * and a participant.
-     *
-     * **Presence mode.** `presence: 'actor'` (the default) expires a joined
-     * participant with no fresh Buddy actor in the app after the join grace
-     * window. `presence: 'none'` never expires anybody: use it 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
-     * {@link leaveSession}, {@link endSession} and the empty timeout once
-     * everyone has left. The mode is fixed at creation.
-     *
-     * @param input - {@link CreateSessionInput}: `appId` (decimal string), an
-     *   optional `name`, optional `metadataJson` (a JSON-object string),
-     *   optional `participantUserIds` (decimal-string ids of initial participants
-     *   besides the creator), optional `maxParticipants`, `admission`,
-     *   `emptyTimeoutSec`, `presence` and `idempotencyKey`.
-     *   Pass `seedFromApp: { typeNames, initialState? }` to stamp the app's keyed
-     *   template rows of those types (the rows a {@link seed} with `bindingKey`
-     *   wrote) into the new session inside the creation transaction: same
-     *   `bindingKey`, `displayName`, `metadataJson` and `ownerUserId` per row, so a
-     *   later `gameModelEnsureContainer` in the session finds every key present.
-     *   `initialState` is `'defaults'` (type defaults) or `'app'` (copy the app
-     *   rows' current properties). At most 2,000 rows per session; above that the
-     *   creation is refused and no session exists. The count is on the create
-     *   response as `seededContainerCount` (null on later reads) and on the
-     *   session's `created` event as `containersSeeded`. A template type must be
-     *   `instantiableBy: 'admin'` or carry a `bindPolicyJson` (a plain member
-     *   type is refused: a player may own one of its app keys); an `'app'`-scoped
-     *   type is refused. The copies are marked, and on a tier whose operator has
-     *   enabled retention (`GM_SESSION_CONTAINER_RETENTION_DAYS`; off by default)
-     *   they -- and only they -- are dropped once the session has been ended that
-     *   long; hand-made rows in the session are never purged.
-     * @returns The created {@link GmSession} (`sessionId`, `status`, creator,
-     *   host, admission, `presence`, revision, `seededContainerCount`, …).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING` if the token
-     *   is missing or not scoped to the app, `FORBIDDEN` if the session-creation
-     *   policy disallows the caller, or `BAD_USER_INPUT` for malformed input, an
-     *   undefined `seedFromApp` type, or more than 2,000 template rows.
-     */
-    async createSession(input) {
-        const data = await this.gql.request(GameModelCreateSessionDocument, { input });
-        return data.gameModelCreateSession;
-    }
-    /**
-     * **Sessions** — join a session, or **reconnect** to one you are already in.
-     * A rejoin returns your row with `incarnation + 1` and supersedes any older
-     * client of yours; keep the returned `incarnation`, {@link leaveSession}
-     * needs it. Pass `actorUuid` (your own Buddy actor, 32 hex chars — the uuid
-     * you replicate with) to bind this participant's presence to that actor;
-     * without it any fresh actor of yours in the app keeps you present.
-     * **Presence is your actor** (in a `presence: 'actor'` session, the default):
-     * a participant with no fresh Buddy actor in the app after the join grace
-     * window is expired by the server (`participant_expired`); a client that only
-     * speaks GraphQL must rejoin to come back. In a `presence: 'none'` session
-     * nobody is expired and `actorUuid` is recorded but not judged.
-     *
-     * @param input - {@link JoinSessionInput}: `appId` (decimal string),
-     *   `sessionId`, optional `role`, optional `actorUuid`, optional
-     *   `idempotencyKey` (replaying returns the same incarnation).
-     * @returns The {@link GmSessionParticipant} row (`state`, `incarnation`,
-     *   `actorUuid`, `joinedAt`, ...).
-     * @throws {CrowdyGraphQLError} `SESSION_FULL` (every seat taken),
-     *   `SESSION_LOCKED` (admission locked and you never joined),
-     *   `SESSION_CLOSED`, `SESSION_ENDED`, `FORBIDDEN` (the `actorUuid` is not
-     *   yours or is already bound by another participant), `NOT_FOUND`,
-     *   `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    async joinSession(input) {
-        const data = await this.gql.request(GameModelJoinSessionDocument, { input });
-        return data.gameModelJoinSession;
-    }
-    /**
-     * **Sessions** — set or clear the session's current-turn user, for turn-based
-     * play (turn authority is enforced by the service).
-     *
-     * @param input - {@link SetSessionTurnInput}: `appId` (decimal string),
-     *   `sessionId`, and `userId` (the decimal-string id of the user whose turn it
-     *   now is) — pass `userId: null` to **clear** the turn.
-     * @returns The updated {@link GmSession} (with `currentTurnUserId` reflecting
-     *   the change).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `NOT_FOUND` if the session doesn't exist, or `FORBIDDEN` if the caller may
-     *   not change the turn.
-     */
-    async setSessionTurn(input) {
-        const data = await this.gql.request(GameModelSetSessionTurnDocument, { input });
-        return data.gameModelSetSessionTurn;
-    }
-    /**
-     * **Sessions** — leave a session you are joined to. `incarnation` is
-     * **required**: it is the value {@link joinSession} returned to *this*
-     * client (a creator starts at 1), so a superseded client can never remove
-     * the one that took over. Leaving an already-left row is a no-op. If you
-     * were host, the longest-joined present participant succeeds you
-     * (`host_changed`).
-     *
-     * @param input - {@link LeaveSessionInput}: `appId`, `sessionId`,
-     *   `incarnation`, optional `idempotencyKey`.
-     * @returns Your {@link GmSessionParticipant} row, now `state: 'left'` with
-     *   `leftReason: 'left'`.
-     * @throws {CrowdyGraphQLError} `SESSION_INCARNATION_STALE` (a newer client
-     *   rejoined as you — stop acting from this one, or rejoin),
-     *   `SESSION_NOT_PARTICIPANT`, `NOT_FOUND`.
-     */
-    async leaveSession(input) {
-        const data = await this.gql.request(GameModelLeaveSessionDocument, { input });
-        return data.gameModelLeaveSession;
-    }
-    /**
-     * **Sessions** — change who may still join: `'open'` (anyone the app
-     * admits), `'locked'` (only participants who already joined may reconnect —
-     * set it when the match starts), `'closed'` (nobody). Session host or app
-     * admin (`manage_apps`). Emits `admission_changed`.
-     *
-     * @param input - {@link SetSessionAdmissionInput}: `appId`, `sessionId`,
-     *   `admission`, optional `expectedHostTerm` (the `hostTerm` you last read:
-     *   refused if the host changed since), optional `idempotencyKey`.
-     * @returns The updated {@link GmSession}.
-     * @throws {CrowdyGraphQLError} `FORBIDDEN` (not host / admin),
-     *   `SESSION_HOST_TERM_STALE`, `SESSION_ENDED`, `NOT_FOUND`.
-     */
-    async setSessionAdmission(input) {
-        const data = await this.gql.request(GameModelSetSessionAdmissionDocument, { input });
-        return data.gameModelSetSessionAdmission;
-    }
-    /**
-     * **Sessions** — hand the host role to another *joined* participant.
-     * Session host or app admin. Increments `hostTerm` and emits
-     * `host_changed` (reason `transferred`).
-     *
-     * @param input - {@link TransferSessionHostInput}: `appId`, `sessionId`,
-     *   `toUserId` (decimal string), optional `expectedHostTerm`, optional
-     *   `idempotencyKey`.
-     * @returns The updated {@link GmSession} (`hostUserId`, `hostTerm`).
-     * @throws {CrowdyGraphQLError} `FORBIDDEN`, `SESSION_HOST_TERM_STALE`,
-     *   `SESSION_TARGET_NOT_PARTICIPANT` (the user named is not joined; refetch
-     *   the snapshot and pick a participant), `SESSION_ENDED`.
-     */
-    async transferSessionHost(input) {
-        const data = await this.gql.request(GameModelTransferSessionHostDocument, { input });
-        return data.gameModelTransferSessionHost;
-    }
-    /**
-     * **Sessions** — end a session as `'completed'` (default) or `'abandoned'`.
-     * Every joined participant is marked left (`session_ended`), admission
-     * becomes `closed`, `endedAt` / `endReason` are set and an `ended` event
-     * closes the revision log. Session host or app admin. (The server also ends a
-     * session nobody has been joined to for longer than its `emptyTimeoutSec` as
-     * `abandoned` / `empty_timeout`.)
-     *
-     * @param input - {@link EndSessionInput}: `appId`, `sessionId`, optional
-     *   `reason`, optional `expectedHostTerm`, optional `idempotencyKey`.
-     * @returns The ended {@link GmSession}.
-     * @throws {CrowdyGraphQLError} `FORBIDDEN`, `SESSION_HOST_TERM_STALE`,
-     *   `SESSION_ENDED` (already ended), `NOT_FOUND`.
-     */
-    async endSession(input) {
-        const data = await this.gql.request(GameModelEndSessionDocument, { input });
-        return data.gameModelEndSession;
-    }
-    /**
-     * **Containers** — instantiate a container (a runtime entity of a given type),
-     * optionally within a session, with an owner and initial property values.
-     * Subject to the type's `instantiableBy` rule (`admin | member | owner`).
-     *
-     * @param input - {@link CreateContainerInput}: `appId` (decimal string), an
-     *   optional `sessionId` (omit for an app-global container), the `typeName` to
-     *   instantiate, a `displayName`, optional `description`, optional
-     *   `ownerUserId` (decimal string; defaults to the caller for member/owner
-     *   instantiation), optional `metadataJson` (JSON-object string), and optional
-     *   initial `properties` (each `{ key, valueType, valueJson }` with a
-     *   JSON-encoded value).
-     * @returns The created {@link GmContainer}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` if `instantiableBy` disallows the caller, `NOT_FOUND` for an
-     *   unknown type, or `BAD_USER_INPUT` for malformed properties.
-     */
-    async createContainer(input) {
-        const data = await this.gql.request(GameModelCreateContainerDocument, { input });
-        return data.gameModelCreateContainer;
-    }
-    /**
-     * **Containers** — delete a container instance. Cascades its instance
-     * properties and any edges connected to it. Allowed for an app admin or the
-     * container owner. **Destructive.**
-     *
-     * @param variables - `{ appId, containerId }`: `appId` (decimal string) and
-     *   the container UUID to delete.
-     * @returns `true` if a container was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` if the caller is neither an app admin nor the owner.
-     */
-    async deleteContainer(variables) {
-        const data = await this.gql.request(GameModelDeleteContainerDocument, variables);
-        return data.gameModelDeleteContainer;
-    }
-    /**
-     * **Containers** — set a single property value on a container directly (outside
-     * a function). Allowed only when the property's `writable` rule
-     * (`function | owner | admin`) permits the caller; the value is JSON-encoded
-     * and coerced to the property's declared value type. For game-logic changes
-     * prefer {@link invoke}, which enforces an authority policy and logs an event.
-     *
-     * @param input - {@link SetContainerPropertyInput}: `appId` (decimal string),
-     *   `containerId`, the property `key`, its `valueType` (must match the property
-     *   definition), and `valueJson` (the JSON-encoded value to write).
-     * @returns The updated {@link GmContainer}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` if the property's `writable` rule forbids a direct write,
-     *   `NOT_FOUND` for an unknown container/property, or `BAD_USER_INPUT` for a
-     *   value-type mismatch.
-     */
-    async setProperty(input) {
-        const data = await this.gql.request(GameModelSetPropertyDocument, { input });
-        return data.gameModelSetProperty;
-    }
-    /**
-     * **Edges** — create a directed relationship edge between two containers (the
-     * game model is a graph), with a relationship type and optional weight.
-     *
-     * @param input - {@link AddEdgeInput}: `appId` (decimal string),
-     *   `fromContainerId` (source) and `toContainerId` (target), a
-     *   `relationshipType` label, an optional numeric `weight`, and optional
-     *   `metadataJson` (JSON-object string).
-     * @returns The created {@link GmEdge} (`edgeId`, endpoints, type, weight).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `NOT_FOUND` if either container is unknown, or `BAD_USER_INPUT`.
-     */
-    async addEdge(input) {
-        const data = await this.gql.request(GameModelAddEdgeDocument, { input });
-        return data.gameModelAddEdge;
-    }
-    /**
-     * **Edges** — delete a directed relationship edge. Allowed for an app admin or
-     * the owner of the source (`from`) container. **Destructive.**
-     *
-     * @param variables - `{ appId, edgeId }`: `appId` (decimal string) and the
-     *   edge UUID to delete.
-     * @returns `true` if an edge was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` if the caller may not delete the edge.
-     */
-    async deleteEdge(variables) {
-        const data = await this.gql.request(GameModelDeleteEdgeDocument, variables);
-        return data.gameModelDeleteEdge;
-    }
-    /**
-     * **Functions** — invoke a studio-defined function against a `self` container
-     * with JSON params. This is the primary, *safe* way for players to mutate game
-     * state: the server enforces the function's invoke policy (the 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, and logs an {@link events | event}. Only `player`-scope functions
-     * are invocable here.
-     *
-     * Note: an authority denial or an expression-evaluation error is **not** a
-     * thrown exception — it comes back as a resolved result with `success: false`
-     * and `fault.code` (`NOT_ALLOWED` for a policy refusal). Inspect
-     * `result.success` rather than relying on `try/catch` for those cases.
-     *
-     * **The invoke policy applies to app admins too** (ck-api v1.89.0). Your own
-     * account, testing your own game, is judged exactly like a player's. Before
-     * that release a `manage_apps` holder skipped every policy implicitly, which
-     * made policies look unenforced to the people who wrote them. Administrative
-     * tooling that needs to run a function regardless of its policy sets
-     * `bypassPolicy: true`: honoured only with `manage_apps` (a GraphQL
-     * `NOT_ALLOWED` error otherwise, nothing runs), reported back as
-     * `policyBypassed: true` on the result, and audit-logged server-side.
-     *
-     * @param input - {@link InvokeFunctionInput}: `appId` (decimal string), the
-     *   `functionName`, the `selfContainerId` (the container the function runs
-     *   against, referenced as `self` in expressions), an optional `sessionId`
-     *   context, `paramsJson` (a JSON-object string of params), and the optional
-     *   administrative `bypassPolicy` flag described above.
-     * @returns A {@link GmInvokeResult}: `success`, the logged `eventId`, the
-     *   JSON-encoded `returnValueJson`, the `mutationsApplied` (each with
-     *   before/after JSON values), `fault` when `success` is `false`, and
-     *   `policyBypassed` when the call skipped the policy on purpose.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `NOT_FOUND` for an unknown function/container, `FORBIDDEN` if the function
-     *   isn't `player`-scope, `NOT_ALLOWED` for `bypassPolicy` without
-     *   `manage_apps`, or `BAD_USER_INPUT` for malformed params. (Authority and
-     *   evaluation failures surface as `success: false`, see above.)
-     */
-    async invoke(input) {
-        const data = await this.gql.request(GameModelInvokeDocument, { input });
-        return data.gameModelInvoke;
-    }
-    /**
-     * **Containers** — fetch one container (instance) by id, with its full record
-     * (unfiltered metadata). For a player-facing view whose property values are
-     * filtered to what the caller may see, use {@link containerState} instead.
-     *
-     * @param variables - `{ appId, containerId }`: `appId` (decimal string) is the
-     *   owning app and `containerId` is the container UUID to fetch.
-     * @returns The {@link GmContainer}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if no such container.
-     */
-    async container(variables) {
-        const data = await this.gql.request(GameModelContainerDocument, variables);
-        return data.gameModelContainer;
-    }
-    /**
-     * **Containers** — list containers in an app, optionally narrowed by container
-     * type and/or session, filtered by property predicates, and paged.
-     *
-     * @param variables - `{ appId, typeName?, sessionId?, where?, limit?, offset? }`:
-     *   `appId` (decimal string); optional `typeName` (omit for all types);
-     *   optional `sessionId` (omit for all containers, including app-global
-     *   ones); optional `where` (max 8 AND-combined
-     *   `{ key, op, valueJson }` predicates — ops `==`, `!=`, `<`, `>`, `<=`,
-     *   `>=`; requires `typeName`; missing properties fall back to the type
-     *   default — the same predicate shape automation selectors use); optional
-     *   `limit`/`offset` paging applied after filtering over the stable
-     *   created-at ordering. `bindingKey` narrows to the one row ensured (or
-     *   seeded) under that key — with `typeName` and `sessionId` it is the
-     *   get-by-key read. **An omitted `limit` returns 200 rows and the
-     *   maximum is 1,000** (`BAD_REQUEST` above it); without `where` the page is
-     *   read in SQL, with `where` the predicates are evaluated after reading at
-     *   most 10,000 rows of the type and a larger type is refused. Requires
-     *   game-api with container predicates (2026-07 or later); older servers
-     *   reject the new arguments.
-     * @returns The matching {@link GmContainer}s.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `BAD_USER_INPUT` for `where` without `typeName` / unsupported ops.
-     */
-    async containers(variables) {
-        const data = await this.gql.request(GameModelContainersDocument, variables);
-        return data.gameModelContainers;
-    }
-    /**
-     * **Containers** — fetch a container together with its property values
-     * filtered to what the **calling** user is allowed to see (`public` always;
-     * `owner`/`hidden` depend on the caller's relationship to the container). Use
-     * this for a player-facing view of an entity.
-     *
-     * @param variables - `{ appId, containerId }`: `appId` (decimal string) and
-     *   the `containerId` UUID whose visible state to fetch.
-     * @returns A {@link GmContainerState}; its `propertiesJson` is a JSON-object
-     *   string of the properties visible to the caller (`JSON.parse` it).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if no such container.
-     */
-    async containerState(variables) {
-        const data = await this.gql.request(GameModelContainerStateDocument, variables);
-        return data.gameModelContainerState;
-    }
-    /**
-     * **Containers** — the bulk twin of {@link containerState}: identity plus the
-     * property state visible to the **calling** user for up to **500** containers
-     * in one call, with the same per-row visibility rules. Ids the app does not
-     * hold are omitted rather than errors, duplicates come back once, and the
-     * order follows the input. After paging {@link containers} (default 200, max
-     * 1,000 per page), two of these pull a page's state — a level of thousands of
-     * placed objects loads in a handful of calls instead of one per object.
-     *
-     * @param variables - `{ appId, containerIds }`: `appId` (decimal string) and
-     *   up to 500 container UUIDs.
-     * @returns An array of {@link GmContainerState}; each `propertiesJson` is a
-     *   JSON-object string of the properties visible to the caller.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `BAD_REQUEST` for more than 500 ids or a non-UUID id.
-     */
-    async containerStates(variables) {
-        const data = await this.gql.request(GameModelContainerStatesDocument, variables);
-        return data.gameModelContainerStates;
-    }
-    /**
-     * **Edges** — traverse the container graph from a root container along a
-     * relationship type up to a given depth, returning the reachable nodes and the
-     * edges between them.
-     *
-     * @param variables - `{ appId, rootId, relationshipType, depth? }`: `appId`
-     *   (decimal string); the `rootId` container UUID to start from; the
-     *   `relationshipType` edge label to follow; and optional `depth`, the number
-     *   of edge hops to follow from the root (defaults to `1`).
-     * @returns A {@link GmTraverseResult}: the `rootId`, the reachable `nodes`
-     *   ({@link GmContainer}[]), and the traversed `edges` ({@link GmEdge}[]).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if the root container is unknown.
-     */
-    async traverse(variables) {
-        const data = await this.gql.request(GameModelTraverseDocument, variables);
-        return data.gameModelTraverse;
-    }
-    /**
-     * **Sessions** — fetch one session by id.
-     *
-     * @param variables - `{ appId, sessionId }`: `appId` (decimal string) and the
-     *   `sessionId` to fetch.
-     * @returns The {@link GmSession}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if no such session.
-     */
-    async session(variables) {
-        const data = await this.gql.request(GameModelSessionDocument, variables);
-        return data.gameModelSession;
-    }
-    /**
-     * **Sessions** — list sessions in an app, newest first, optionally filtered
-     * by `status` (`active | completed | abandoned`), `admission`
-     * (`open | locked | closed` — `'open'` lists joinable lobbies) and/or
-     * `hostUserId`.
-     *
-     * @param variables - `{ appId, status?, admission?, hostUserId?, limit? }`
-     *   (`limit` defaults to 200, max 1000).
-     * @returns The matching {@link GmSession}s.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    async sessions(variables) {
-        const data = await this.gql.request(GameModelSessionsDocument, variables);
-        return data.gameModelSessions;
-    }
-    /**
-     * **Sessions** — the authoritative state of one session at one revision: the
-     * session row and every *joined* participant. Pull it when you subscribe
-     * with {@link sessionChanged}, after a reconnect, or when the stream shows a
-     * revision gap; then apply only events whose `revision` is above
-     * `snapshot.revision`.
-     *
-     * @param variables - `{ appId, sessionId }`.
-     * @returns `{ revision, session, participants }`.
-     * @throws {CrowdyGraphQLError} `NOT_FOUND`, `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    async sessionSnapshot(variables) {
-        const data = await this.gql.request(GameModelSessionSnapshotDocument, variables);
-        return data.gameModelSessionSnapshot;
-    }
-    /**
-     * **Sessions** — the events of a session with a revision strictly greater
-     * than `afterRevision`, oldest first: the gap-fill read behind
-     * {@link sessionChanged}. Events of ended sessions are retained for a bounded
-     * period, then purged.
-     *
-     * @param variables - `{ appId, sessionId, afterRevision, limit? }`;
-     *   `afterRevision` is a decimal string (`'0'` for everything retained).
-     * @returns The matching {@link GmSessionEvent}s.
-     */
-    async sessionEvents(variables) {
-        const data = await this.gql.request(GameModelSessionEventsDocument, variables);
-        return data.gameModelSessionEvents;
-    }
-    /**
-     * **Sessions (operators)** — the full roster including departed participants
-     * (with `leftReason` and `incarnation`), each joined participant's live
-     * presence verdict (`fresh | grace | stale | legacy | left`), and the most
-     * recent events. Requires app-admin (`manage_apps`).
-     *
-     * @param variables - `{ appId, sessionId }`.
-     * @throws {CrowdyGraphQLError} `FORBIDDEN` without `manage_apps`.
-     */
-    async sessionInspect(variables) {
-        const data = await this.gql.request(GameModelSessionInspectDocument, variables);
-        return data.gameModelSessionInspect;
-    }
-    /**
-     * **Events** — query the function-invocation event log (audit trail) with
-     * optional filters and pagination. Useful for debugging functions or showing
-     * recent activity.
-     *
-     * @param variables - `{ appId, sessionId?, selfContainerId?, functionName?,
-     *   success?, limit?, offset? }`: `appId` (decimal string); optional
-     *   `sessionId`; optional `selfContainerId` (the UUID the function ran
-     *   against); optional `functionName`; optional `success` (`true` = succeeded,
-     *   `false` = failed). `limit` (page size) and `offset` (rows to skip) are
-     *   **deprecated** — see below.
-     * @returns The matching {@link GmEvent}s (each with `paramsJson`,
-     *   `mutationsAppliedJson`, `returnValueJson`, `success`, `errorMessage`, and
-     *   `executedAt`).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     * @remarks The `limit`/`offset` fields use deprecated offset pagination. For
-     *   large logs prefer the Relay-style `gameModelEventsConnection(first:, after:)`
-     *   cursor query (available on the schema via `client.graphql`). See
-     *   https://docs.crowdedkingdoms.com/overview/pagination.
-     */
-    async events(variables) {
-        const data = await this.gql.request(GameModelEventsDocument, variables);
-        return data.gameModelEvents;
-    }
-    /**
-     * **Events** — Relay-style cursor pagination over the function-invocation
-     * event log; the preferred alternative to {@link events} for large logs. Page
-     * with `first` plus the previous page's `pageInfo.endCursor` as `after`. See
-     * https://docs.crowdedkingdoms.com/overview/pagination.
-     *
-     * @param variables - `{ appId, first?, after?, sessionId?, selfContainerId?,
-     *   functionName?, success? }`.
-     * @returns A {@link GameModelEventsConnection} (`edges { cursor node }`,
-     *   `pageInfo`, `totalCount`).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    async eventsConnection(variables) {
-        const data = await this.gql.request(GameModelEventsConnectionDocument, variables);
-        return data.gameModelEventsConnection;
-    }
-    /**
-     * **Diagnostics** — stitch one flow correlation id into a single
-     * cross-engine timeline: the model **events** ({@link events} rows), the
-     * **automationRuns**, and the compute **moduleRuns** that share the
-     * `flowId` minted at the entry edge (a player {@link invoke}, an automation
-     * run, or a `computeInvoke`) and propagated across `model_invoke`, the
-     * event bus, and `emit_compute_event`. Each array is ordered by time
-     * ascending, so the three together read as one causal trace — "what
-     * happened to this kill's reward" in one query instead of three
-     * hand-joined ones. Take the `flowId` from the `flowId` field on any
-     * {@link GmEvent}, {@link GmAutomationRun}, or {@link WasmModuleRun}
-     * (selected by the default fragments since SDK 8.13.0).
-     *
-     * Requires the app-admin **`manage_apps`** permission (a diagnostics
-     * surface, like {@link automationRuns}) and a game-api with the
-     * `gameModelFlow` query (2026-07-19 or later; older servers reject the
-     * operation with a validation error).
-     *
-     * @param variables - `{ appId, flowId }`: `appId` (decimal string) and the
-     *   flow correlation id (a UUID string). An unknown `flowId` returns three
-     *   empty arrays.
-     * @returns The {@link GmFlowTimeline}: `flowId`, `events`,
-     *   `automationRuns`, and `moduleRuns`, each time-ascending.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_REQUEST`
-     *   if `flowId` is not a UUID.
-     */
-    async flow(variables) {
-        const data = await this.gql.request(GameModelFlowDocument, variables);
-        return data.gameModelFlow;
-    }
-    // -- Studio authoring -------------------------------------------------------
-    /**
-     * **Seed** — bulk-create game-model definitions (container types, property
-     * defs, functions) and optionally instances (containers + edges) in one
-     * transaction; used to initialize or import a model.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link SeedGameModelInput}: `appId` (decimal string); an
-     *   optional `sessionId` to seed instances into (omit/`null` = app-global);
-     *   and arrays of `containerTypes`, `propertyDefinitions`, `functions`,
-     *   `containers`, and `edges` to create. Seed containers carry a developer
-     *   `tempId`; seed edges reference containers by those temp ids
-     *   (`fromTempId`/`toTempId`). A container may name its own `bindingKey`
-     *   (on a type that is `instantiableBy: 'admin'` or carries a `bindPolicyJson`,
-     *   and not beginning with `seed:`) so a runtime `gameModelEnsureContainer` later
-     *   resolves the same row; otherwise it binds as `seed:` + `tempId`. A
-     *   caller-keyed row that already exists is adopted only if its `ownerUserId`
-     *   matches (a re-seed); a row a player claimed first is refused and nothing
-     *   is written. At most
-     *   **1,000 containers per call**, all-or-nothing; the same key on two types
-     *   is two rows. A container type may declare `scope: 'app'` (one row per key
-     *   for the whole app) or `'session'` (default). Seeded rows fire no
-     *   `container_created` automation triggers or change-feed events.
-     * @returns A {@link GmSeedResult}: the counts created, non-fatal `warnings`,
-     *   and `idMapJson` — a JSON-object string mapping each seed `tempId` to the
-     *   created container UUID (`JSON.parse` it to wire up follow-up calls).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (with `extensions.requiredPermission === 'manage_apps'`) if the
-     *   caller lacks app-admin, or `BAD_USER_INPUT` for malformed definitions.
-     */
-    async seed(input) {
-        const data = await this.gql.request(GameModelSeedDocument, { input });
-        return data.gameModelSeed;
-    }
-    /**
-     * **Container types** — create or update a container type: the studio-defined
-     * schema for a kind of runtime entity (like a class). Idempotent on
-     * `(appId, typeName)`.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertContainerTypeInput}: `appId` (decimal string);
-     *   the `typeName` (the stable upsert key, unique per app); a `displayName`;
-     *   optional `description`; optional `instantiableBy` (`admin | member |
-     *   owner`); optional `defaultPropertyVisibility` (`public | owner | hidden`);
-     *   optional `bindPolicyJson` (who may claim a `bindingKey` on
-     *   `ensureContainer`; omit to leave the type unbound); optional `scope`
-     *   (`'session'` default — one row per key per session; `'app'` — one row
-     *   per key for the whole app, on which `ensureContainer` /
-     *   `createContainer` with a `sessionId` are refused with
-     *   `CONTAINER_TYPE_APP_SCOPED`; changing to `'app'` is refused while the
-     *   type holds session-scoped rows); and optional `metadataJson`
-     *   (JSON-object string).
-     * @returns The upserted {@link GmContainerType}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`.
-     */
-    async upsertContainerType(input) {
-        const data = await this.gql.request(GameModelUpsertContainerTypeDocument, { input });
-        return data.gameModelUpsertContainerType;
-    }
-    /**
-     * **Property definitions** — create or update a typed property on a container
-     * type (a field with a default value, read visibility, and writability).
-     * Idempotent on `(appId, containerTypeName, key)`.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertPropertyDefInput}: `appId` (decimal string); the
-     *   `containerTypeName` to define on; the property `key` (part of the upsert
-     *   key); a `valueType` (`int | float | string | bool | array | object |
-     *   container_ref`); optional `defaultValueJson` (JSON-encoded default);
-     *   optional `visibility` (`public | owner | hidden`); optional `writable`
-     *   (`function | owner | admin`); and optional `description`.
-     * @returns The upserted {@link GmPropertyDef}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), `NOT_FOUND` for an
-     *   unknown container type, or `BAD_USER_INPUT`.
-     */
-    async upsertPropertyDef(input) {
-        const data = await this.gql.request(GameModelUpsertPropertyDefDocument, { input });
-        return data.gameModelUpsertPropertyDef;
-    }
-    /**
-     * **Property definitions** — delete a property definition from a container
-     * type. Does **not** remove instance property values already stored on
-     * containers. **Destructive.**
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, containerTypeName, key }`.
-     * @returns `true` if a definition was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`).
-     */
-    async deletePropertyDef(variables) {
-        const data = await this.gql.request(GameModelDeletePropertyDefDocument, variables);
-        return data.gameModelDeletePropertyDef;
-    }
-    /**
-     * **Container types** — delete a container type and its property definitions.
-     * Refuses if live containers of that type exist, or if functions are bound to
-     * it — delete those first. **Destructive.**
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, typeName }`.
-     * @returns `true` if a type was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`
-     *   when containers or bound functions still exist.
-     */
-    async deleteContainerType(variables) {
-        const data = await this.gql.request(GameModelDeleteContainerTypeDocument, variables);
-        return data.gameModelDeleteContainerType;
-    }
-    /**
-     * **Functions** — create or update a studio-defined function: a named,
-     * sandboxed behaviour with typed parameters, declared property mutations
-     * (expressions compiled to an AST server-side — never `eval`'d), an optional
-     * return expression, an invoke scope, and an invoke policy (authority rule
-     * tree). Idempotent on `(appId, name)`. Players run these via {@link invoke}.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertFunctionInput}: `appId` (decimal string); the
-     *   `name` (upsert key, used to invoke it); optional `containerTypeName` to
-     *   bind to (omit for a global function); optional `description`; optional
-     *   `returnType`; `parameters` (typed `{ name, valueType, required?,
-     *   defaultValueJson?, … }`); `mutations` (declared writes `{ target, property,
-     *   expression }`, applied atomically); optional `returnExpression`;
-     *   `invokeScope` (`player | server | internal`); and `invokePolicyJson` (a
-     *   JSON-encoded authority rule tree).
-     * @returns The upserted {@link GmFunction}, including any non-fatal
-     *   static-analysis `warnings` from this upload.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`
-     *   for an expression/policy that fails to compile.
-     */
-    async upsertFunction(input) {
-        const data = await this.gql.request(GameModelUpsertFunctionDocument, { input });
-        return data.gameModelUpsertFunction;
-    }
-    /**
-     * **Functions** — delete a studio-defined function by name. **Destructive.**
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name }`: `appId` (decimal string) and the
-     *   function `name` to delete.
-     * @returns `true` if a function was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`) if the caller lacks
-     *   app-admin.
-     */
-    async deleteFunction(variables) {
-        const data = await this.gql.request(GameModelDeleteFunctionDocument, variables);
-        return data.gameModelDeleteFunction;
-    }
-    /**
-     * **App features** — 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 `(appId, featureKey)`.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link DefineAppFeatureInput}: `appId` (decimal string); the
-     *   `featureKey` (referenced by `tier_feature` rules); and an optional
-     *   `description`.
-     * @returns The defined {@link GmAppFeature}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`.
-     */
-    async defineFeature(input) {
-        const data = await this.gql.request(GameModelDefineFeatureDocument, { input });
-        return data.gameModelDefineFeature;
-    }
-    /**
-     * **App features** — grant a feature key to an access tier, so users on that
-     * tier satisfy `tier_feature` authority checks for it.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link GrantTierFeatureInput}: `appId` (decimal string); the
-     *   `tierId` (decimal string) of the access tier; and the `featureKey` to
-     *   grant to that tier.
-     * @returns The {@link GmTierFeature} grant record.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `NOT_FOUND` for an
-     *   unknown tier/feature.
-     */
-    async grantTierFeature(input) {
-        const data = await this.gql.request(GameModelGrantTierFeatureDocument, { input });
-        return data.gameModelGrantTierFeature;
-    }
-    /**
-     * **Policy** — set the app's game-model runtime policy: who may create
-     * sessions and the default role assigned to new session participants.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link SetGameModelPolicyInput}: `appId` (decimal string); an
-     *   optional `sessionCreationPolicy` (`admin | member | anyone`); and an
-     *   optional `defaultParticipantRole`.
-     * @returns The updated {@link GmAppPolicy}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`.
-     */
-    async setPolicy(input) {
-        const data = await this.gql.request(GameModelSetPolicyDocument, { input });
-        return data.gameModelSetPolicy;
-    }
-    /**
-     * **Container types** — fetch a container type's full schema: its property
-     * definitions plus the functions available on it. A studio/authoring read.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, typeName }`: `appId` (decimal string) and the
-     *   `typeName` whose schema to fetch.
-     * @returns A {@link GmTypeSchema}: the `typeName`, its `propertyDefinitions`
-     *   ({@link GmPropertyDef}[]), and its `functions` ({@link GmFunction}[]).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `NOT_FOUND` for an
-     *   unknown type.
-     */
-    async typeSchema(variables) {
-        const data = await this.gql.request(GameModelTypeSchemaDocument, variables);
-        return data.gameModelTypeSchema;
-    }
-    /**
-     * **Container types** — list every container type defined for an app. A
-     * studio/authoring read. Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The app's {@link GmContainerType}s.
-     */
-    async containerTypes(variables) {
-        const data = await this.gql.request(GameModelContainerTypesDocument, variables);
-        return data.gameModelContainerTypes;
-    }
-    /**
-     * **Property definitions** — list the property definitions for one container
-     * type. A studio/authoring read. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, typeName }`.
-     * @returns The type's {@link GmPropertyDef}s.
-     */
-    async propertyDefs(variables) {
-        const data = await this.gql.request(GameModelPropertyDefsDocument, variables);
-        return data.gameModelPropertyDefs;
-    }
-    /**
-     * **Functions** — fetch one studio-defined function by name (including its
-     * parameters, mutations, and notification effects). Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns The {@link GmFunction}.
-     */
-    async getFunction(variables) {
-        const data = await this.gql.request(GameModelFunctionDocument, variables);
-        return data.gameModelFunction;
-    }
-    /**
-     * **Functions** — list studio-defined functions for an app, optionally
-     * filtered to those bound to a container type. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, containerTypeName? }`.
-     * @returns The matching {@link GmFunction}s.
-     */
-    async functions(variables) {
-        const data = await this.gql.request(GameModelFunctionsDocument, variables);
-        return data.gameModelFunctions;
-    }
-    /**
-     * **App features** — list the feature keys defined for an app. Requires the
-     * app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The app's {@link GmAppFeature}s.
-     */
-    async features(variables) {
-        const data = await this.gql.request(GameModelFeaturesDocument, variables);
-        return data.gameModelFeatures;
-    }
-    /**
-     * **App features** — list tier→feature grants for an app, optionally filtered
-     * to one tier. Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, tierId? }`.
-     * @returns The {@link GmTierFeature} grants.
-     */
-    async tierFeatures(variables) {
-        const data = await this.gql.request(GameModelTierFeaturesDocument, variables);
-        return data.gameModelTierFeatures;
-    }
-    /**
-     * **App features** — revoke a feature key from an access tier (the inverse of
-     * {@link grantTierFeature}). Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param input - {@link GrantTierFeatureInput} (`appId`, `tierId`, `featureKey`).
-     * @returns `true` if a grant was removed.
-     */
-    async revokeTierFeature(input) {
-        const data = await this.gql.request(GameModelRevokeTierFeatureDocument, {
-            input,
-        });
-        return data.gameModelRevokeTierFeature;
-    }
-    /**
-     * **Policy** — read the app's game-model runtime policy (session-creation
-     * policy + default participant role). Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAppPolicy}.
-     */
-    async policy(variables) {
-        const data = await this.gql.request(GameModelPolicyDocument, variables);
-        return data.gameModelPolicy;
-    }
-    // -- Automations (autonomous processes / NPCs) ------------------------------
-    /**
-     * **Automations** — 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` (see {@link upsertFunction}).
-     * Idempotent on `(appId, name)`. The game-api dispatcher runs it headlessly;
-     * a tick is just "invoke a function on behalf of the server".
-     *
-     * **Only while the app has a player in it** (2026-09-01). A scheduled
-     * automation that comes due while the app is empty is skipped silently and
-     * rescheduled from the moment a player returns; the missed runs are never made
-     * up. Write the entry point so it is idempotent in ELAPSED TIME -- advance the
-     * world by `now - lastRun` rather than by one step per tick -- or it will
-     * silently fall behind whenever nobody is playing. `event` and `manual`
-     * triggers are unaffected: something already asked for those.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertAutomationInput}: `appId`; `name` (upsert key);
-     *   the action — `actionKind: 'model_function'` (default) with
-     *   `functionName`, or `actionKind: 'compute_invoke'` with
-     *   `computeModuleName` + `computeExport` (invokes a compute-module invoke
-     *   export on the trusted server path; `targetMode` forced to `global`,
-     *   selectors don't apply — requires game-api 2026-07+); `targetMode`
-     *   (`container | type | global`) with `selfContainerId` /
-     *   `targetTypeName`; optional `sessionId`, `paramsJson`, `selectorJson`
-     *   (model-data candidate selection), `runAsUserId`; the trigger
-     *   (`triggerType`, `scheduleKind`, `intervalMs` / `cronExpr`); and the safety
-     *   budget (`maxTargets`, `maxFnDepth`, `gasLimit`, `runTimeoutMs`,
-     *   `maxRunsPerMinute`, `failureThreshold`, `cooldownMs`).
-     * @returns The upserted {@link GmAutomation}, including circuit-breaker state.
-     */
-    async upsertAutomation(input) {
-        const data = await this.gql.request(GameModelUpsertAutomationDocument, { input });
-        return data.gameModelUpsertAutomation;
-    }
-    /**
-     * **Automations** — delete an automation by name (also removes its event
-     * triggers). **Destructive.** Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns `true` if one was deleted.
-     */
-    async deleteAutomation(variables) {
-        const data = await this.gql.request(GameModelDeleteAutomationDocument, variables);
-        return data.gameModelDeleteAutomation;
-    }
-    /**
-     * **Automations** — enable or disable an automation. Re-enabling also resets
-     * its circuit breaker so a tripped automation resumes. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name, enabled }`.
-     * @returns The updated {@link GmAutomation}.
-     */
-    async setAutomationEnabled(variables) {
-        const data = await this.gql.request(GameModelSetAutomationEnabledDocument, variables);
-        return data.gameModelSetAutomationEnabled;
-    }
-    /**
-     * **Automations** — create an event trigger that fires an automation in
-     * reaction to model activity (`function_invoked` | `property_changed` |
-     * `container_created` | `player_count_changed`), matched in the API server
-     * post-commit. Requires the app-admin **`manage_apps`** permission.
-     *
-     * Each event matches on its own filters, and a filter the event does not
-     * match on is rejected rather than silently never firing:
-     * `function_invoked` takes `functionName` and `containerTypeName` (the type
-     * of the invocation's `self` container); `property_changed` takes
-     * `containerTypeName`, `propertyKey`, and `writeSource`;
-     * `container_created` takes `containerTypeName`; `player_count_changed`
-     * takes none.
-     *
-     * `writeSource` decides which writes a `property_changed` trigger sees:
-     * `direct` (a {@link GameModelAPI.setProperty} call), `function` (a mutation
-     * applied inside an invoke, automation run, or timer fire), or `any`
-     * (default). Most game logic writes properties from inside functions, so a
-     * trigger watching such a property needs `function` or `any`.
-     *
-     * @param input - {@link UpsertAutomationTriggerInput}: `appId`,
-     *   `automationName`, `onEvent`, the filters valid for that event, and
-     *   `debounceMs`.
-     * @returns The created {@link GmAutomationTrigger}.
-     */
-    async upsertAutomationTrigger(input) {
-        const data = await this.gql.request(GameModelUpsertAutomationTriggerDocument, { input });
-        return data.gameModelUpsertAutomationTrigger;
-    }
-    /**
-     * **Automations** — delete an event trigger by id. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, triggerId }`.
-     * @returns `true` if one was deleted.
-     */
-    async deleteAutomationTrigger(variables) {
-        const data = await this.gql.request(GameModelDeleteAutomationTriggerDocument, variables);
-        return data.gameModelDeleteAutomationTrigger;
-    }
-    /**
-     * **Automations** — set the app's automation policy (platform guardrails: the
-     * kill switch, max automations, the minimum schedule interval floor, max
-     * fan-out, max event cascade depth, the aggregate per-minute run ceiling, and
-     * the timer floor / pending-timer ceiling).
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link SetAutomationPolicyInput}.
-     * @returns The updated {@link GmAutomationPolicy}.
-     */
-    async setAutomationPolicy(input) {
-        const data = await this.gql.request(GameModelSetAutomationPolicyDocument, { input });
-        return data.gameModelSetAutomationPolicy;
-    }
-    /**
-     * **Automations** — run an automation once, immediately (manual trigger),
-     * regardless of its schedule. Applies the same guard chain and records a run.
-     * Useful for testing an NPC. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns The recorded {@link GmAutomationRun}.
-     */
-    async runAutomation(variables) {
-        const data = await this.gql.request(GameModelRunAutomationDocument, variables);
-        return data.gameModelRunAutomation;
-    }
-    /**
-     * **Automations** — list the automations defined for an app (with
-     * circuit-breaker state). Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAutomation}s.
-     */
-    async automations(variables) {
-        const data = await this.gql.request(GameModelAutomationsDocument, variables);
-        return data.gameModelAutomations;
-    }
-    /**
-     * **Automations** — fetch one automation by name. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns The {@link GmAutomation}.
-     */
-    async automation(variables) {
-        const data = await this.gql.request(GameModelAutomationDocument, variables);
-        return data.gameModelAutomation;
-    }
-    /**
-     * **Automations** — list event triggers for an app, optionally filtered to one
-     * automation by name. Requires the app-admin **`manage_apps`** permission.
-     *
-     * Use this to debug a trigger that isn't firing: `warnings` reports filters
-     * that can never match, `lastMatchedAt` is null until the trigger has
-     * actually dispatched a run, and `matchCount24h` shows recent activity.
-     *
-     * @param variables - `{ appId, automationName? }`.
-     * @returns The {@link GmAutomationTrigger}s.
-     */
-    async automationTriggers(variables) {
-        const data = await this.gql.request(GameModelAutomationTriggersDocument, variables);
-        return data.gameModelAutomationTriggers;
-    }
-    /**
-     * **Automations** — read the app's automation policy. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAutomationPolicy}.
-     */
-    async automationPolicy(variables) {
-        const data = await this.gql.request(GameModelAutomationPolicyDocument, variables);
-        return data.gameModelAutomationPolicy;
-    }
-    /**
-     * **Automations** — list automation runs (the monitoring/audit trail), newest
-     * first, optionally filtered by automation name and/or outcome. Requires the
-     * app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, automationName?, success?, limit?, offset? }`.
-     * @returns The {@link GmAutomationRun}s.
-     */
-    async automationRuns(variables) {
-        const data = await this.gql.request(GameModelAutomationRunsDocument, variables);
-        return data.gameModelAutomationRuns;
-    }
-    /**
-     * **Automations** — aggregate automation activity over a recent window
-     * (throughput, failure rate, compute, per-automation breakdown). The
-     * "what are my NPCs doing" view. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, windowMinutes? }` (default 60, max 1440).
-     * @returns The {@link GmAutomationStats}.
-     */
-    async automationStats(variables) {
-        const data = await this.gql.request(GameModelAutomationStatsDocument, variables);
-        return data.gameModelAutomationStats;
-    }
-    /**
-     * **Diagnostics** — a snapshot of an app's game-model footprint and recent
-     * activity (row counts + 24h invocation activity + top functions). Helps
-     * developers understand what is in their game and their database. Requires the
-     * app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAppDiagnostics}.
-     */
-    async appDiagnostics(variables) {
-        const data = await this.gql.request(GameModelAppDiagnosticsDocument, variables);
-        return data.gameModelAppDiagnostics;
-    }
-    /**
-     * **Timers** — arm a one-shot timer: invoke a function once, after a delay.
-     * The timer is durable (it survives an API restart) and claimed by exactly one
-     * replica, so it fires once. Requires the app-admin **`manage_apps`**
-     * permission, because a timer fires headlessly with system authority rather
-     * than a player's.
-     *
-     * A timer whose deadline passes while the app has no players **waits** rather
-     * than firing into an empty world: the sweep only claims timers for apps with a
-     * player present, so it is still armed and fires when somebody returns. It is
-     * therefore late, not lost -- read the current time in the handler rather than
-     * assuming the delay you asked for is the delay that elapsed.
-     *
-     * For player-driven delays, declare a `timers` effect on the function instead
-     * (see {@link GameModelAPI.upsertFunction}) so the delay is part of your game
-     * logic and is armed atomically with that invocation's mutations.
-     *
-     * The target function must be `autonomousInvocable`. Pass `dedupeKey` to make
-     * re-arming replace the pending timer instead of queueing another fire, which
-     * is how you implement "reset the countdown".
-     *
-     * @param input - {@link ScheduleInvokeInput}: `appId`, `functionName`,
-     *   `selfContainerId`, `delayMs`, and optional `paramsJson`, `sessionId`, and
-     *   `dedupeKey`.
-     * @returns The armed {@link GmTimer}.
-     */
-    async scheduleInvoke(input) {
-        const data = await this.gql.request(GameModelScheduleInvokeDocument, { input });
-        return data.gameModelScheduleInvoke;
-    }
-    /**
-     * **Timers** — cancel pending timers by id or by dedupe key. A timer already
-     * claimed for execution cannot be cancelled. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, timerId?, dedupeKey? }` (supply at least one
-     *   selector).
-     * @returns How many pending timers were removed.
-     */
-    async cancelTimer(variables) {
-        const data = await this.gql.request(GameModelCancelTimerDocument, variables);
-        return data.gameModelCancelTimer;
-    }
-    /**
-     * **Timers** — list pending one-shot timers, soonest first. A timer leaves
-     * this list the instant it is claimed for execution, so an empty list means
-     * nothing is *scheduled* — not that nothing ran. Fires that already happened
-     * appear in {@link GameModelAPI.automationRuns} with
-     * `triggerSource: 'timer'`. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, sessionId?, limit? }` (limit 1-200, default 50).
-     * @returns The pending {@link GmTimer}s.
-     */
-    async timers(variables) {
-        const data = await this.gql.request(GameModelTimersDocument, variables);
-        return data.gameModelTimers;
-    }
-}