@crowdedkingdoms/crowdyjs 17.10.0-dev.1 → 17.12.0-dev.1

package/dist/generated/graphql.d.ts

@@ -3638,6 +3638,55 @@ export type ExecArtifactInput = {
     /** The WASM module (wasm32-unknown-unknown, built with ckx-sdk), base64. */
     wasmBase64: Scalars['String']['input'];
 };
+/** A ck-exec build (dev-tier preview): queued, building, succeeded or failed, with the compiler’s log and, once it succeeds, one module per crate. */
+export type ExecBuild = {
+    __typename?: 'ExecBuild';
+    /** The modules built so far, one per crate. */
+    artifacts: Array<ExecBuildArtifact>;
+    /** The build’s id, for `execBuildStatus` and `execDeploy`. */
+    buildId: Scalars['String']['output'];
+    /** When the build was requested. */
+    createdAt: Scalars['DateTime']['output'];
+    /** When it finished. */
+    finishedAt: Maybe<Scalars['DateTime']['output']>;
+    /** The compiler’s output once the build finishes, at most 64 KB (the end is kept). */
+    log: Maybe<Scalars['String']['output']>;
+    /** When it started compiling. */
+    startedAt: Maybe<Scalars['DateTime']['output']>;
+    /** `queued`, `building`, `succeeded` or `failed`. */
+    status: Scalars['String']['output'];
+};
+/** One module a ck-exec build produced. */
+export type ExecBuildArtifact = {
+    __typename?: 'ExecBuildArtifact';
+    /** The crate it was built from. */
+    crate: Scalars['String']['output'];
+    /** SHA-256 of the WASM: the `digest` a manifest names it by. */
+    digest: Scalars['String']['output'];
+    /** The module’s size in bytes. */
+    sizeBytes: Scalars['Int']['output'];
+};
+/** One crate of a ck-exec build: a `ckx-sdk` library with `[lib] crate-type = ["cdylib"]`, built into one module. */
+export type ExecBuildCrateInput = {
+    /** Its files, at most 64. `Cargo.toml` may have only [package], [lib] and [dependencies] from `ckx-sdk`, `serde` and `serde_json`. */
+    files: Array<ExecBuildFileInput>;
+    /** The crate’s name: lowercase letters, digits, `-` or `_`, at most 64 characters. The build reports each module under it. */
+    name: Scalars['String']['input'];
+};
+/** One source file of a ck-exec crate. */
+export type ExecBuildFileInput = {
+    /** The file’s contents, UTF-8. */
+    content: Scalars['String']['input'];
+    /** The path within the crate: `Cargo.toml`, `README.md`, or a `.rs` file under `src/`. */
+    path: Scalars['String']['input'];
+};
+/** Sources to build into ck-exec modules. */
+export type ExecBuildInput = {
+    /** The app to build for. */
+    appId: Scalars['BigInt']['input'];
+    /** The crates, at most 16, 2 MB of source in all; each becomes one module. */
+    crates: Array<ExecBuildCrateInput>;
+};
 /** Where and how a game client connects to ck-exec, the hub-and-spoke execution service (dev-tier preview). Open a WebSocket to `{gatewayUrl}/v1/connect?token={token}` before `expiresAt`. */
 export type ExecConnection = {
     __typename?: 'ExecConnection';
@@ -3656,7 +3705,9 @@ export type ExecDeployInput = {
     appId: Scalars['BigInt']['input'];
     /** Modules the manifest names that this app has not uploaded before (at most 64). A request body is limited to 10 MB, so about 7 MB of modules per call. */
     artifacts?: InputMaybe<Array<ExecArtifactInput>>;
-    /** The manifest as JSON: `{ "root": "<hub type>", "types": { "<name>": { "kind": "hub"|"spoke", "parent", "digest", "client", "calls", "scopes", ... } } }`. Every field and its platform bounds: https://docs.dev.crowdedkingdoms.com/exec/intro#the-manifest. */
+    /** A succeeded `execBuild` of this app whose modules to include, so a manifest can name them by digest without uploading them. */
+    buildId?: InputMaybe<Scalars['String']['input']>;
+    /** The manifest as JSON: `{ "root": "<hub type>", "types": { "<name>": { "kind": "hub"|"spoke", "parent", "digest", "client", "calls", "scopes", ... } } }`; with `buildId`, a type may give `"crate": "<name>"` instead of `digest`. Every field and its platform bounds: https://docs.dev.crowdedkingdoms.com/exec/intro#the-manifest. */
     manifestJson: Scalars['String']['input'];
 };
 /** The result of a ck-exec deploy. */
@@ -3704,6 +3755,92 @@ export type ExecLogLine = {
     /** The line, at most 1 KiB. */
     text: Scalars['String']['output'];
 };
+/** A mod: a player’s code on a grid they own, run by ck-exec as the hub `mod:<name>` keyed by the grid id, in its owner’s own sandbox (dev-tier preview). */
+export type ExecMod = {
+    __typename?: 'ExecMod';
+    /** Why an enabled mod will not run: a switch of the app’s kill ladder, or the app’s own switch. */
+    blocked: Maybe<Scalars['String']['output']>;
+    /** SHA-256 of its module, hex. */
+    digest: Scalars['String']['output'];
+    /** Its owner switched it on. It runs only while this holds and `blocked` is null. */
+    enabled: Scalars['Boolean']['output'];
+    gridId: Scalars['BigInt']['output'];
+    /** The marketplace listing it was installed from. */
+    listingId: Maybe<Scalars['BigInt']['output']>;
+    modId: Scalars['String']['output'];
+    /** 1-48 lowercase letters, digits, `-` or `_`. */
+    name: Scalars['String']['output'];
+    /** The player it runs as: the grid’s owner when it was deployed, or when the grid last changed hands. */
+    ownerId: Scalars['BigInt']['output'];
+    /** Whether an instance of it runs now. */
+    running: Scalars['Boolean']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    version: Scalars['Int']['output'];
+};
+/** A mod version its owner published, which any grid owner in the app may install as a mod of their own (dev-tier preview; no payments). */
+export type ExecModListing = {
+    __typename?: 'ExecModListing';
+    createdAt: Scalars['DateTime']['output'];
+    delistedAt: Maybe<Scalars['DateTime']['output']>;
+    description: Maybe<Scalars['String']['output']>;
+    /** SHA-256 of its module, hex. */
+    digest: Scalars['String']['output'];
+    installs: Scalars['Int']['output'];
+    listingId: Scalars['BigInt']['output'];
+    publisherId: Scalars['BigInt']['output'];
+    sourceModId: Scalars['String']['output'];
+    sourceVersion: Scalars['Int']['output'];
+    title: Scalars['String']['output'];
+};
+/** A rung of the mods kill ladder: one mod (target: its mod id), a player’s mods (their user id), a grid’s mods (its grid id), the installs of a marketplace listing (its listing id), or every mod in the app (no target). */
+export declare enum ExecModScope {
+    All = "ALL",
+    Grid = "GRID",
+    Listing = "LISTING",
+    Mod = "MOD",
+    Player = "PLAYER"
+}
+/** A rung of the mods kill ladder that is off (dev-tier preview). */
+export type ExecModSwitch = {
+    __typename?: 'ExecModSwitch';
+    createdAt: Scalars['DateTime']['output'];
+    /** Who switched it off, e.g. `user:<id>`. */
+    createdBy: Maybe<Scalars['String']['output']>;
+    reason: Maybe<Scalars['String']['output']>;
+    scope: ExecModScope;
+    /** The id it names; empty for `ALL`. */
+    target: Scalars['String']['output'];
+};
+/** A starter crate: a ckx-sdk hub to build with `execBuild` as it is, or to change first. */
+export type ExecStarter = {
+    __typename?: 'ExecStarter';
+    /** The crate’s name, which the pack’s manifest names it by. */
+    crate: Scalars['String']['output'];
+    /** What it does. */
+    description: Scalars['String']['output'];
+    /** Its Cargo.toml and sources. */
+    files: Array<ExecStarterFile>;
+    /** The node type the pack’s manifest deploys it as. */
+    nodeType: Scalars['String']['output'];
+};
+/** One source file of a starter crate. */
+export type ExecStarterFile = {
+    __typename?: 'ExecStarterFile';
+    /** The file’s contents. */
+    content: Scalars['String']['output'];
+    /** The path within the crate, as `execBuild` takes it. */
+    path: Scalars['String']['output'];
+};
+/** The starter packs (dev-tier preview): four crates and a manifest that deploys them as one app. */
+export type ExecStarterPack = {
+    __typename?: 'ExecStarterPack';
+    /** The manifest for `execDeploy` with the build’s id: the root `world` hub, and `matchmaker`, `session` and `npcs` under it, each naming its crate. */
+    manifestJson: Scalars['String']['output'];
+    /** The mod starter: a player’s code on a grid they own, built with `execModBuild` and deployed with `execModDeploy` rather than in the manifest. Null on a toolchain without it. */
+    mod: Maybe<ExecStarter>;
+    /** The crates. */
+    starters: Array<ExecStarter>;
+};
 /** A deployed version of an app’s ck-exec topology. */
 export type ExecVersion = {
     __typename?: 'ExecVersion';
@@ -5589,12 +5726,30 @@ export type Mutation = {
     exchangePortalCode: AppTokenResponse;
     /** Make an earlier ck-exec version active again, a rollback (dev-tier preview). Running instances pick it up when they next start, as after a deploy. Requires the org 'manage_compute' permission. */
     execActivateVersion: ExecAppStatus;
+    /** Build ck-exec modules from Rust source (dev-tier preview): each crate is compiled with the platform's pinned toolchain and `ckx-sdk`, for wasm32-unknown-unknown, and checked against the guest ABI. Returns at once with the build queued; poll `execBuildStatus`, then pass its id to `execDeploy`. Requires the org 'manage_compute' permission. */
+    execBuild: ExecBuild;
     /** Connect a player to ck-exec (dev-tier preview): the execution manager picks a host (the one running `nodeType`/`key` when given, placing it if needed) and this returns its gateway and a 60-second connect token bound to this player, this app and that host. Requires the app-scoped token of the app named. */
     execConnect: ExecConnection;
     /** Connect to an app's ck-exec code as one of its developers, for studio tools, manual runs and admin endpoints (dev-tier preview). The session's calls arrive as `Caller::Developer` with your user id and may reach any node type, not only `client` ones, but never the platform's `$` methods. Requires the org 'manage_compute' permission and your own session, not an app token. */
     execConnectAsDeveloper: ExecConnection;
     /** Deploy a new version of an app's ck-exec topology (dev-tier preview): the manifest and any modules it names that were not uploaded before. The execution manager checks the manifest's tree and bounds and each module's digest, stores them, and makes the version active; running instances pick it up when they next start. Requires the org 'manage_compute' permission. */
     execDeploy: ExecDeployResult;
+    /** Build a mod from one ckx-sdk crate (dev-tier preview), as `execBuild` builds a developer's crates. Returns at once with the build queued; poll `execModBuildStatus`, then pass its id to `execModDeploy`. One build at a time per player. Requires the 'write_server_code' permission in the app. */
+    execModBuild: ExecBuild;
+    /** Stop and remove a mod on your grid, with its state and versions (dev-tier preview). Requires being the grid's current owner and 'write_server_code' on both the app tier and the grid. */
+    execModDelete: Scalars['Boolean']['output'];
+    /** Deploy a mod build of yours to a grid you own (dev-tier preview): a new mod starts switched off; a running one restarts on the new version. Requires being the grid's current owner and 'write_server_code' on both the app tier and the grid. */
+    execModDeploy: ExecMod;
+    /** Install a listing onto a grid you own as your own mod, switched off (dev-tier preview; no payments). Requires being the grid's current owner and 'write_server_code' on both the app tier and the grid. */
+    execModInstall: ExecMod;
+    /** Publish a mod of yours, at its current version, for other grid owners in the app to install (dev-tier preview; no payments). Requires being the grid's current owner and 'write_server_code' on both the app tier and the grid. */
+    execModPublish: ExecModListing;
+    /** Switch a mod on your grid on or off (dev-tier preview). On, it runs as you once the app's code admission admits it. Requires being the grid's current owner and 'run_server_code' on both the app tier and the grid. */
+    execModSetEnabled: ExecMod;
+    /** The mods kill ladder (dev-tier preview): switch off one mod, a player's mods, a grid's mods, a listing's installs or every mod in the app, or back on. Off stops what runs at once and refuses calls. Returns the switches that are off. Requires the org 'manage_compute' permission. */
+    execModSetSwitch: Array<ExecModSwitch>;
+    /** Delist a listing you published (dev-tier preview): nobody installs it any more; installed copies keep running. */
+    execModUnpublish: Scalars['Boolean']['output'];
     /** The kill switch for an app's ck-exec code, or one node type of it (dev-tier preview). Switched off, nothing of it is placed, what runs is persisted and stopped, and calls are refused with `Denied`; switched on, instances start as they are called. Requires the org 'manage_compute' permission. */
     execSetEnabled: ExecAppStatus;
     /** ADMIN/DESTRUCTIVE: revokes ALL of the target user’s sessions by deleting every game_token row, forcing re-authentication on every device. Returns true if at least one session was revoked. Requires a super-admin bearer game token (and the management API enabled). */
@@ -6212,6 +6367,9 @@ export type MutationExecActivateVersionArgs = {
     appId: Scalars['BigInt']['input'];
     version: Scalars['Int']['input'];
 };
+export type MutationExecBuildArgs = {
+    input: ExecBuildInput;
+};
 export type MutationExecConnectArgs = {
     appId: Scalars['BigInt']['input'];
     key?: InputMaybe<Scalars['String']['input']>;
@@ -6225,6 +6383,51 @@ export type MutationExecConnectAsDeveloperArgs = {
 export type MutationExecDeployArgs = {
     input: ExecDeployInput;
 };
+export type MutationExecModBuildArgs = {
+    appId: Scalars['BigInt']['input'];
+    crate: ExecBuildCrateInput;
+};
+export type MutationExecModDeleteArgs = {
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationExecModDeployArgs = {
+    appId: Scalars['BigInt']['input'];
+    buildId: Scalars['String']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationExecModInstallArgs = {
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    listingId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationExecModPublishArgs = {
+    appId: Scalars['BigInt']['input'];
+    description?: InputMaybe<Scalars['String']['input']>;
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+};
+export type MutationExecModSetEnabledArgs = {
+    appId: Scalars['BigInt']['input'];
+    enabled: Scalars['Boolean']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+};
+export type MutationExecModSetSwitchArgs = {
+    appId: Scalars['BigInt']['input'];
+    off: Scalars['Boolean']['input'];
+    reason?: InputMaybe<Scalars['String']['input']>;
+    scope: ExecModScope;
+    target?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationExecModUnpublishArgs = {
+    appId: Scalars['BigInt']['input'];
+    listingId: Scalars['BigInt']['input'];
+};
 export type MutationExecSetEnabledArgs = {
     appId: Scalars['BigInt']['input'];
     enabled: Scalars['Boolean']['input'];
@@ -8206,12 +8409,32 @@ export type Query = {
     emailDeliverability: EmailDeliverability;
     /** Operator only (is_operator). How THIS API instance is configured to send mail: whether sending is on, the From address, the SES configuration set, the region and the suppressed domains. Answers 'why did no email arrive' without an SSH session, and reports the instance that served the query rather than the fleet. */
     emailDeliveryConfig: EmailDeliveryConfig;
+    /** An app's mods, by grid or by owner, or all of them (at most 1000) (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
+    execAppMods: Array<ExecMod>;
     /** Whether an app's ck-exec code may run: its active version, kill switches and budget pause (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
     execAppStatus: ExecAppStatus;
+    /** A ck-exec build's status, compiler log and modules (dev-tier preview); null when this app has no such build. Builds are kept for 7 days. Requires the org 'view_compute_diagnostics' permission. */
+    execBuildStatus: Maybe<ExecBuild>;
     /** What the execution manager has placed for an app: every instance, its phase and host (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
     execInstances: Array<ExecInstance>;
     /** Guest log lines from an app's ck-exec instances (`ctx.log`), newest first, kept for 24 hours (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
     execLogs: Array<ExecLogLine>;
+    /** A mod build of yours: its status, compiler log and module (dev-tier preview). Builds are kept for 7 days. */
+    execModBuildStatus: ExecBuild;
+    /** The app's mod marketplace: listed mods, most installed first (dev-tier preview). Requires access to the app. */
+    execModListings: Array<ExecModListing>;
+    /** A mod of yours' guest log lines (`ctx.log`), newest first, kept for 24 hours (dev-tier preview). */
+    execModLogs: Array<ExecLogLine>;
+    /** The mod starter (dev-tier preview): a ckx-sdk crate that greets visitors and follows what happens in its grid (`Hub::on_world`), to pass to `execModBuild`. Requires access to the app. */
+    execModStarter: ExecStarter;
+    /** The app's mod switches that are off (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
+    execModSwitches: Array<ExecModSwitch>;
+    /** A grid's mods (dev-tier preview), which players in the grid call by name as the node type `mod:<name>` with the grid id as key. Requires access to the app. */
+    execMods: Array<ExecMod>;
+    /** Your mods in an app, on every grid (dev-tier preview). */
+    execMyMods: Array<ExecMod>;
+    /** The starter packs (dev-tier preview), which replace the compute templates: a world tick (the root hub: clock, weather, resource nodes, liveops events), a matchmaker, game sessions (lobby, host, turns, scores) and an NPC and mob engine, as ckx-sdk crates to pass to `execBuild` and a manifest for `execDeploy`. Requires the org 'manage_compute' permission. */
+    execStarters: ExecStarterPack;
     /** An app's deployed ck-exec versions, newest first, and which is active (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
     execVersions: Array<ExecVersion>;
     /** Reports whether a free-play window is active now, a human-readable schedule description, and the ISO-8601 start of the next window. PUBLIC: no authentication required. Takes no arguments; computed from server config and the current clock. */
@@ -8788,9 +9011,18 @@ export type QueryEmailDeliverabilityArgs = {
     email: Scalars['String']['input'];
     eventLimit?: InputMaybe<Scalars['Int']['input']>;
 };
+export type QueryExecAppModsArgs = {
+    appId: Scalars['BigInt']['input'];
+    gridId?: InputMaybe<Scalars['BigInt']['input']>;
+    ownerId?: InputMaybe<Scalars['BigInt']['input']>;
+};
 export type QueryExecAppStatusArgs = {
     appId: Scalars['BigInt']['input'];
 };
+export type QueryExecBuildStatusArgs = {
+    appId: Scalars['BigInt']['input'];
+    buildId: Scalars['String']['input'];
+};
 export type QueryExecInstancesArgs = {
     appId: Scalars['BigInt']['input'];
 };
@@ -8802,6 +9034,37 @@ export type QueryExecLogsArgs = {
     maxLevel?: InputMaybe<Scalars['Int']['input']>;
     nodeType?: InputMaybe<Scalars['String']['input']>;
 };
+export type QueryExecModBuildStatusArgs = {
+    appId: Scalars['BigInt']['input'];
+    buildId: Scalars['String']['input'];
+};
+export type QueryExecModListingsArgs = {
+    appId: Scalars['BigInt']['input'];
+};
+export type QueryExecModLogsArgs = {
+    appId: Scalars['BigInt']['input'];
+    before?: InputMaybe<Scalars['String']['input']>;
+    gridId: Scalars['BigInt']['input'];
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    maxLevel?: InputMaybe<Scalars['Int']['input']>;
+    name: Scalars['String']['input'];
+};
+export type QueryExecModStarterArgs = {
+    appId: Scalars['BigInt']['input'];
+};
+export type QueryExecModSwitchesArgs = {
+    appId: Scalars['BigInt']['input'];
+};
+export type QueryExecModsArgs = {
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+};
+export type QueryExecMyModsArgs = {
+    appId: Scalars['BigInt']['input'];
+};
+export type QueryExecStartersArgs = {
+    appId: Scalars['BigInt']['input'];
+};
 export type QueryExecVersionsArgs = {
     appId: Scalars['BigInt']['input'];
 };
@@ -14200,6 +14463,425 @@ export type ExecSetEnabledMutation = {
         budgetPaused: boolean;
     };
 };
+export type ExecStartersQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecStartersQuery = {
+    __typename?: 'Query';
+    execStarters: {
+        __typename?: 'ExecStarterPack';
+        manifestJson: string;
+        starters: Array<{
+            __typename?: 'ExecStarter';
+            crate: string;
+            nodeType: string;
+            description: string;
+            files: Array<{
+                __typename?: 'ExecStarterFile';
+                path: string;
+                content: string;
+            }>;
+        }>;
+    };
+};
+export type ExecBuildFieldsFragment = {
+    __typename?: 'ExecBuild';
+    buildId: string;
+    status: string;
+    log: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    artifacts: Array<{
+        __typename?: 'ExecBuildArtifact';
+        crate: string;
+        digest: string;
+        sizeBytes: number;
+    }>;
+};
+export type ExecBuildMutationVariables = Exact<{
+    input: ExecBuildInput;
+}>;
+export type ExecBuildMutation = {
+    __typename?: 'Mutation';
+    execBuild: {
+        __typename?: 'ExecBuild';
+        buildId: string;
+        status: string;
+        log: string | null;
+        createdAt: string;
+        startedAt: string | null;
+        finishedAt: string | null;
+        artifacts: Array<{
+            __typename?: 'ExecBuildArtifact';
+            crate: string;
+            digest: string;
+            sizeBytes: number;
+        }>;
+    };
+};
+export type ExecBuildStatusQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    buildId: Scalars['String']['input'];
+}>;
+export type ExecBuildStatusQuery = {
+    __typename?: 'Query';
+    execBuildStatus: {
+        __typename?: 'ExecBuild';
+        buildId: string;
+        status: string;
+        log: string | null;
+        createdAt: string;
+        startedAt: string | null;
+        finishedAt: string | null;
+        artifacts: Array<{
+            __typename?: 'ExecBuildArtifact';
+            crate: string;
+            digest: string;
+            sizeBytes: number;
+        }>;
+    } | null;
+};
+export type ExecModFieldsFragment = {
+    __typename?: 'ExecMod';
+    modId: string;
+    gridId: string;
+    name: string;
+    ownerId: string;
+    version: number;
+    digest: string;
+    enabled: boolean;
+    listingId: string | null;
+    blocked: string | null;
+    running: boolean;
+    updatedAt: string;
+};
+export type ExecModListingFieldsFragment = {
+    __typename?: 'ExecModListing';
+    listingId: string;
+    title: string;
+    description: string | null;
+    publisherId: string;
+    sourceModId: string;
+    sourceVersion: number;
+    digest: string;
+    installs: number;
+    createdAt: string;
+    delistedAt: string | null;
+};
+export type ExecModSwitchFieldsFragment = {
+    __typename?: 'ExecModSwitch';
+    scope: ExecModScope;
+    target: string;
+    reason: string | null;
+    createdBy: string | null;
+    createdAt: string;
+};
+export type ExecModStarterQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecModStarterQuery = {
+    __typename?: 'Query';
+    execModStarter: {
+        __typename?: 'ExecStarter';
+        crate: string;
+        nodeType: string;
+        description: string;
+        files: Array<{
+            __typename?: 'ExecStarterFile';
+            path: string;
+            content: string;
+        }>;
+    };
+};
+export type ExecModBuildMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    crate: ExecBuildCrateInput;
+}>;
+export type ExecModBuildMutation = {
+    __typename?: 'Mutation';
+    execModBuild: {
+        __typename?: 'ExecBuild';
+        buildId: string;
+        status: string;
+        log: string | null;
+        createdAt: string;
+        startedAt: string | null;
+        finishedAt: string | null;
+        artifacts: Array<{
+            __typename?: 'ExecBuildArtifact';
+            crate: string;
+            digest: string;
+            sizeBytes: number;
+        }>;
+    };
+};
+export type ExecModBuildStatusQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    buildId: Scalars['String']['input'];
+}>;
+export type ExecModBuildStatusQuery = {
+    __typename?: 'Query';
+    execModBuildStatus: {
+        __typename?: 'ExecBuild';
+        buildId: string;
+        status: string;
+        log: string | null;
+        createdAt: string;
+        startedAt: string | null;
+        finishedAt: string | null;
+        artifacts: Array<{
+            __typename?: 'ExecBuildArtifact';
+            crate: string;
+            digest: string;
+            sizeBytes: number;
+        }>;
+    };
+};
+export type ExecModDeployMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+    buildId: Scalars['String']['input'];
+}>;
+export type ExecModDeployMutation = {
+    __typename?: 'Mutation';
+    execModDeploy: {
+        __typename?: 'ExecMod';
+        modId: string;
+        gridId: string;
+        name: string;
+        ownerId: string;
+        version: number;
+        digest: string;
+        enabled: boolean;
+        listingId: string | null;
+        blocked: string | null;
+        running: boolean;
+        updatedAt: string;
+    };
+};
+export type ExecModSetEnabledMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+    enabled: Scalars['Boolean']['input'];
+}>;
+export type ExecModSetEnabledMutation = {
+    __typename?: 'Mutation';
+    execModSetEnabled: {
+        __typename?: 'ExecMod';
+        modId: string;
+        gridId: string;
+        name: string;
+        ownerId: string;
+        version: number;
+        digest: string;
+        enabled: boolean;
+        listingId: string | null;
+        blocked: string | null;
+        running: boolean;
+        updatedAt: string;
+    };
+};
+export type ExecModDeleteMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+}>;
+export type ExecModDeleteMutation = {
+    __typename?: 'Mutation';
+    execModDelete: boolean;
+};
+export type ExecModsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+}>;
+export type ExecModsQuery = {
+    __typename?: 'Query';
+    execMods: Array<{
+        __typename?: 'ExecMod';
+        modId: string;
+        gridId: string;
+        name: string;
+        ownerId: string;
+        version: number;
+        digest: string;
+        enabled: boolean;
+        listingId: string | null;
+        blocked: string | null;
+        running: boolean;
+        updatedAt: string;
+    }>;
+};
+export type ExecMyModsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecMyModsQuery = {
+    __typename?: 'Query';
+    execMyMods: Array<{
+        __typename?: 'ExecMod';
+        modId: string;
+        gridId: string;
+        name: string;
+        ownerId: string;
+        version: number;
+        digest: string;
+        enabled: boolean;
+        listingId: string | null;
+        blocked: string | null;
+        running: boolean;
+        updatedAt: string;
+    }>;
+};
+export type ExecModLogsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+    maxLevel?: InputMaybe<Scalars['Int']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type ExecModLogsQuery = {
+    __typename?: 'Query';
+    execModLogs: Array<{
+        __typename?: 'ExecLogLine';
+        id: string;
+        nodeType: string;
+        key: string;
+        level: number;
+        host: string;
+        at: string;
+        text: string;
+    }>;
+};
+export type ExecModPublishMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+    description?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ExecModPublishMutation = {
+    __typename?: 'Mutation';
+    execModPublish: {
+        __typename?: 'ExecModListing';
+        listingId: string;
+        title: string;
+        description: string | null;
+        publisherId: string;
+        sourceModId: string;
+        sourceVersion: number;
+        digest: string;
+        installs: number;
+        createdAt: string;
+        delistedAt: string | null;
+    };
+};
+export type ExecModListingsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecModListingsQuery = {
+    __typename?: 'Query';
+    execModListings: Array<{
+        __typename?: 'ExecModListing';
+        listingId: string;
+        title: string;
+        description: string | null;
+        publisherId: string;
+        sourceModId: string;
+        sourceVersion: number;
+        digest: string;
+        installs: number;
+        createdAt: string;
+        delistedAt: string | null;
+    }>;
+};
+export type ExecModUnpublishMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    listingId: Scalars['BigInt']['input'];
+}>;
+export type ExecModUnpublishMutation = {
+    __typename?: 'Mutation';
+    execModUnpublish: boolean;
+};
+export type ExecModInstallMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+    name: Scalars['String']['input'];
+    listingId: Scalars['BigInt']['input'];
+}>;
+export type ExecModInstallMutation = {
+    __typename?: 'Mutation';
+    execModInstall: {
+        __typename?: 'ExecMod';
+        modId: string;
+        gridId: string;
+        name: string;
+        ownerId: string;
+        version: number;
+        digest: string;
+        enabled: boolean;
+        listingId: string | null;
+        blocked: string | null;
+        running: boolean;
+        updatedAt: string;
+    };
+};
+export type ExecAppModsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId?: InputMaybe<Scalars['BigInt']['input']>;
+    ownerId?: InputMaybe<Scalars['BigInt']['input']>;
+}>;
+export type ExecAppModsQuery = {
+    __typename?: 'Query';
+    execAppMods: Array<{
+        __typename?: 'ExecMod';
+        modId: string;
+        gridId: string;
+        name: string;
+        ownerId: string;
+        version: number;
+        digest: string;
+        enabled: boolean;
+        listingId: string | null;
+        blocked: string | null;
+        running: boolean;
+        updatedAt: string;
+    }>;
+};
+export type ExecModSwitchesQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecModSwitchesQuery = {
+    __typename?: 'Query';
+    execModSwitches: Array<{
+        __typename?: 'ExecModSwitch';
+        scope: ExecModScope;
+        target: string;
+        reason: string | null;
+        createdBy: string | null;
+        createdAt: string;
+    }>;
+};
+export type ExecModSetSwitchMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    scope: ExecModScope;
+    off: Scalars['Boolean']['input'];
+    target?: InputMaybe<Scalars['String']['input']>;
+    reason?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ExecModSetSwitchMutation = {
+    __typename?: 'Mutation';
+    execModSetSwitch: Array<{
+        __typename?: 'ExecModSwitch';
+        scope: ExecModScope;
+        target: string;
+        reason: string | null;
+        createdBy: string | null;
+        createdAt: string;
+    }>;
+};
 export type GridOwnershipFieldsFragment = {
     __typename?: 'GridOwnership';
     gridOwnershipId: string;
@@ -20357,6 +21039,10 @@ export declare const ComputePolicyFieldsFragmentDoc: DocumentNode<ComputePolicyF
 export declare const ComputeRunFieldsFragmentDoc: DocumentNode<ComputeRunFieldsFragment, unknown>;
 export declare const CrowdyStudioProjectFieldsFragmentDoc: DocumentNode<CrowdyStudioProjectFieldsFragment, unknown>;
 export declare const ExecAppStatusFieldsFragmentDoc: DocumentNode<ExecAppStatusFieldsFragment, unknown>;
+export declare const ExecBuildFieldsFragmentDoc: DocumentNode<ExecBuildFieldsFragment, unknown>;
+export declare const ExecModFieldsFragmentDoc: DocumentNode<ExecModFieldsFragment, unknown>;
+export declare const ExecModListingFieldsFragmentDoc: DocumentNode<ExecModListingFieldsFragment, unknown>;
+export declare const ExecModSwitchFieldsFragmentDoc: DocumentNode<ExecModSwitchFieldsFragment, unknown>;
 export declare const GridOwnershipFieldsFragmentDoc: DocumentNode<GridOwnershipFieldsFragment, unknown>;
 export declare const GmAutomationFieldsFragmentDoc: DocumentNode<GmAutomationFieldsFragment, unknown>;
 export declare const GmAutomationTriggerFieldsFragmentDoc: DocumentNode<GmAutomationTriggerFieldsFragment, unknown>;
@@ -20507,6 +21193,25 @@ export declare const ExecVersionsDocument: DocumentNode<ExecVersionsQuery, ExecV
 export declare const ExecAppStatusDocument: DocumentNode<ExecAppStatusQuery, ExecAppStatusQueryVariables>;
 export declare const ExecActivateVersionDocument: DocumentNode<ExecActivateVersionMutation, ExecActivateVersionMutationVariables>;
 export declare const ExecSetEnabledDocument: DocumentNode<ExecSetEnabledMutation, ExecSetEnabledMutationVariables>;
+export declare const ExecStartersDocument: DocumentNode<ExecStartersQuery, ExecStartersQueryVariables>;
+export declare const ExecBuildDocument: DocumentNode<ExecBuildMutation, ExecBuildMutationVariables>;
+export declare const ExecBuildStatusDocument: DocumentNode<ExecBuildStatusQuery, ExecBuildStatusQueryVariables>;
+export declare const ExecModStarterDocument: DocumentNode<ExecModStarterQuery, ExecModStarterQueryVariables>;
+export declare const ExecModBuildDocument: DocumentNode<ExecModBuildMutation, ExecModBuildMutationVariables>;
+export declare const ExecModBuildStatusDocument: DocumentNode<ExecModBuildStatusQuery, ExecModBuildStatusQueryVariables>;
+export declare const ExecModDeployDocument: DocumentNode<ExecModDeployMutation, ExecModDeployMutationVariables>;
+export declare const ExecModSetEnabledDocument: DocumentNode<ExecModSetEnabledMutation, ExecModSetEnabledMutationVariables>;
+export declare const ExecModDeleteDocument: DocumentNode<ExecModDeleteMutation, ExecModDeleteMutationVariables>;
+export declare const ExecModsDocument: DocumentNode<ExecModsQuery, ExecModsQueryVariables>;
+export declare const ExecMyModsDocument: DocumentNode<ExecMyModsQuery, ExecMyModsQueryVariables>;
+export declare const ExecModLogsDocument: DocumentNode<ExecModLogsQuery, ExecModLogsQueryVariables>;
+export declare const ExecModPublishDocument: DocumentNode<ExecModPublishMutation, ExecModPublishMutationVariables>;
+export declare const ExecModListingsDocument: DocumentNode<ExecModListingsQuery, ExecModListingsQueryVariables>;
+export declare const ExecModUnpublishDocument: DocumentNode<ExecModUnpublishMutation, ExecModUnpublishMutationVariables>;
+export declare const ExecModInstallDocument: DocumentNode<ExecModInstallMutation, ExecModInstallMutationVariables>;
+export declare const ExecAppModsDocument: DocumentNode<ExecAppModsQuery, ExecAppModsQueryVariables>;
+export declare const ExecModSwitchesDocument: DocumentNode<ExecModSwitchesQuery, ExecModSwitchesQueryVariables>;
+export declare const ExecModSetSwitchDocument: DocumentNode<ExecModSetSwitchMutation, ExecModSetSwitchMutationVariables>;
 export declare const GridOwnershipDocument: DocumentNode<GridOwnershipQuery, GridOwnershipQueryVariables>;
 export declare const AssignGridOwnershipDocument: DocumentNode<AssignGridOwnershipMutation, AssignGridOwnershipMutationVariables>;
 export declare const TransferGridOwnershipDocument: DocumentNode<TransferGridOwnershipMutation, TransferGridOwnershipMutationVariables>;