@crowdedkingdoms/crowdyjs 18.4.0-test.1 → 18.4.1-dev.1

package/dist/generated/graphql-schema.js

@@ -0,0 +1,599 @@
+/** The interval a free allowance resets on and a dimension is rounded over. Every dimension is billed as its period aggregate crosses each whole cent, within about a minute of the usage arriving; the development quota is MONTH. */
+export var AllowancePeriod;
+(function (AllowancePeriod) {
+    AllowancePeriod["Day"] = "DAY";
+    AllowancePeriod["Hour"] = "HOUR";
+    AllowancePeriod["Month"] = "MONTH";
+})(AllowancePeriod || (AllowancePeriod = {}));
+/** Where an app runs: none (draft), shared (the shared game-api), or dedicated (a provisioned environment). */
+export var AppDeploymentTarget;
+(function (AppDeploymentTarget) {
+    /** Runs on a dedicated, org-provisioned environment. */
+    AppDeploymentTarget["Dedicated"] = "DEDICATED";
+    /** Draft / unpublished: the app is not deployed to any runtime. */
+    AppDeploymentTarget["None"] = "NONE";
+    /** Runs on the multi-tenant shared game-api (publishAppToShared). */
+    AppDeploymentTarget["Shared"] = "SHARED";
+})(AppDeploymentTarget || (AppDeploymentTarget = {}));
+/** The per-app runtime gate game-api + Buddy enforce. See runtimeDenialReason when not active. */
+export var AppRuntimeStatus;
+(function (AppRuntimeStatus) {
+    /** Allowed to run; clients may connect. */
+    AppRuntimeStatus["Active"] = "ACTIVE";
+    /** Blocked from running now (e.g. insufficient funds, spend cap hit, or free allowance exhausted); recoverable once the cause clears. */
+    AppRuntimeStatus["Denied"] = "DENIED";
+    /** Still running on a temporary allowance (e.g. low funds) but at risk of being denied soon. */
+    AppRuntimeStatus["Grace"] = "GRACE";
+    /** Hard-stopped (e.g. lapsed subscription); requires action to restore. */
+    AppRuntimeStatus["Suspended"] = "SUSPENDED";
+})(AppRuntimeStatus || (AppRuntimeStatus = {}));
+/** Lifecycle state of an app. Independent of AppVisibility; the public marketplace requires status=LIVE. */
+export var AppStatus;
+(function (AppStatus) {
+    /** Soft-deleted via archiveApp: retained but read-only and excluded from the marketplace. Reversible by setting status back to DRAFT or LIVE. */
+    AppStatus["Archived"] = "ARCHIVED";
+    /** Work-in-progress: invisible to non-members and never listed in the marketplace. Selectable manually via updateApp; new apps default to LIVE. */
+    AppStatus["Draft"] = "DRAFT";
+    /** Published and purchasable/playable; eligible for the public marketplace when visibility=PUBLIC. */
+    AppStatus["Live"] = "LIVE";
+})(AppStatus || (AppStatus = {}));
+/** Controls where an app can be discovered. Independent of AppStatus (the marketplace additionally requires status=LIVE). */
+export var AppVisibility;
+(function (AppVisibility) {
+    /** Hidden from the marketplace; visible only to org members and users with an access grant. */
+    AppVisibility["Private"] = "PRIVATE";
+    /** Listed in the public marketplace (when status=LIVE) and resolvable by slug. */
+    AppVisibility["Public"] = "PUBLIC";
+    /** Hidden from marketplace listings but accessible to anyone who knows the direct org/app slug link. */
+    AppVisibility["Unlisted"] = "UNLISTED";
+})(AppVisibility || (AppVisibility = {}));
+/** Why the checkout exists. Drives which side effect runs on webhook completion: ORG_WALLET_TOPUP credits an org_wallet; PLAYER_WALLET_TOPUP credits the caller's player_wallet; APP_ACCESS_PURCHASE upserts app_user_access; DONATION inserts donations; PROPERTY_TOKENS credits property_tokens; SHARED_APP_SUBSCRIPTION activates a paid shared-environment app slot. */
+export var CheckoutPurpose;
+(function (CheckoutPurpose) {
+    /** Purchase a user's access to an app at a given tier. Requires appId and tierId. Upserts app_user_access on completion. */
+    CheckoutPurpose["AppAccessPurchase"] = "APP_ACCESS_PURCHASE";
+    /**
+     * Deprecated. Historically a one-off donation to an app. No longer purchasable and rejected at runtime by createCheckout.
+     * @deprecated No longer purchasable; use ORG_WALLET_TOPUP or APP_ACCESS_PURCHASE. Retained for historical checkouts.
+     */
+    CheckoutPurpose["Donation"] = "DONATION";
+    /** Add funds to an organization wallet. Requires orgId and amountCents, and the caller must hold the org "manage_billing" permission. Credits the org wallet on completion. */
+    CheckoutPurpose["OrgWalletTopup"] = "ORG_WALLET_TOPUP";
+    /** Add funds to the caller's own player wallet, which pays for their mods past the monthly trial (see PlayerWallet). Requires amountCents only — any authenticated user may fund their own wallet; no org permission is involved. Credits the player wallet idempotently on completion. */
+    CheckoutPurpose["PlayerWalletTopup"] = "PLAYER_WALLET_TOPUP";
+    /**
+     * Deprecated. Historically a purchase of in-world property tokens. No longer purchasable and rejected at runtime by createCheckout.
+     * @deprecated No longer purchasable; use ORG_WALLET_TOPUP or APP_ACCESS_PURCHASE. Retained for historical checkouts.
+     */
+    CheckoutPurpose["PropertyTokens"] = "PROPERTY_TOKENS";
+    /**
+     * @deprecated Legacy recurring subscription for a paid shared app slot. No longer purchasable via createCheckout; retained for historical checkouts and webhook reconciliation.
+     * @deprecated Shared apps use org wallet hourly usage billing. Publish via publishAppToShared and top up with ORG_WALLET_TOPUP.
+     */
+    CheckoutPurpose["SharedAppSubscription"] = "SHARED_APP_SUBSCRIPTION";
+})(CheckoutPurpose || (CheckoutPurpose = {}));
+/** Lifecycle state of a Checkout. Updated by webhook reconciliation, not by the redirect URL. */
+export var CheckoutStatus;
+(function (CheckoutStatus) {
+    /** The user abandoned or canceled the checkout before completion. Terminal state. */
+    CheckoutStatus["Canceled"] = "CANCELED";
+    /** Payment succeeded and the purpose side effect was applied (e.g. wallet credited). Terminal success state. */
+    CheckoutStatus["Completed"] = "COMPLETED";
+    /** The provider session expired before payment completed (see `expiresAt`). Terminal state. */
+    CheckoutStatus["Expired"] = "EXPIRED";
+    /** Payment attempt failed or was declined; see the checkout `error` field for details. Terminal failure state. */
+    CheckoutStatus["Failed"] = "FAILED";
+    /** Created and awaiting payment. Initial state right after createCheckout; the user has not finished paying yet. */
+    CheckoutStatus["Pending"] = "PENDING";
+})(CheckoutStatus || (CheckoutStatus = {}));
+/** Controls player-code censorship for an app. IMPLICIT_ALLOW admits lawful code by default; ALLOW_LIST requires every code target, including self-authored code, to match an active code/author/org admission. */
+export var CodeAdmissionMode;
+(function (CodeAdmissionMode) {
+    CodeAdmissionMode["AllowList"] = "ALLOW_LIST";
+    CodeAdmissionMode["ImplicitAllow"] = "IMPLICIT_ALLOW";
+})(CodeAdmissionMode || (CodeAdmissionMode = {}));
+/** The identity admitted by an app code allow-list entry: one code listing, one author user, or one authoring organization. */
+export var CodeAdmissionSubjectKind;
+(function (CodeAdmissionSubjectKind) {
+    CodeAdmissionSubjectKind["Author"] = "AUTHOR";
+    CodeAdmissionSubjectKind["Code"] = "CODE";
+    CodeAdmissionSubjectKind["Org"] = "ORG";
+})(CodeAdmissionSubjectKind || (CodeAdmissionSubjectKind = {}));
+/** Single-use human decision lifecycle for one canonical argument hash. */
+export var CrowdyStudioAgentApprovalStatus;
+(function (CrowdyStudioAgentApprovalStatus) {
+    /** Used exactly once for dispatch/execution. */
+    CrowdyStudioAgentApprovalStatus["Consumed"] = "CONSUMED";
+    /** Human denied the exact call. */
+    CrowdyStudioAgentApprovalStatus["Denied"] = "DENIED";
+    /** TTL elapsed before use. */
+    CrowdyStudioAgentApprovalStatus["Expired"] = "EXPIRED";
+    /** Granted but not yet atomically consumed. */
+    CrowdyStudioAgentApprovalStatus["Granted"] = "GRANTED";
+    /** Awaiting the matching attached human. */
+    CrowdyStudioAgentApprovalStatus["Pending"] = "PENDING";
+    /** Invalidated by context or policy change. */
+    CrowdyStudioAgentApprovalStatus["Revoked"] = "REVOKED";
+})(CrowdyStudioAgentApprovalStatus || (CrowdyStudioAgentApprovalStatus = {}));
+/** Version 1 durable ordered event vocabulary. */
+export var CrowdyStudioAgentEventType;
+(function (CrowdyStudioAgentEventType) {
+    /** Approval was atomically consumed once. */
+    CrowdyStudioAgentEventType["ApprovalConsumed"] = "APPROVAL_CONSUMED";
+    /** Human denied the pending exact approval. */
+    CrowdyStudioAgentEventType["ApprovalDenied"] = "APPROVAL_DENIED";
+    /** Approval TTL elapsed. */
+    CrowdyStudioAgentEventType["ApprovalExpired"] = "APPROVAL_EXPIRED";
+    /** Human granted the pending exact approval. */
+    CrowdyStudioAgentEventType["ApprovalGranted"] = "APPROVAL_GRANTED";
+    /** Exact argument-hash human approval was requested. */
+    CrowdyStudioAgentEventType["ApprovalRequested"] = "APPROVAL_REQUESTED";
+    /** Bounded coalesced assistant text; final message is canonical. */
+    CrowdyStudioAgentEventType["AssistantChunk"] = "ASSISTANT_CHUNK";
+    /** Canonical final assistant response. */
+    CrowdyStudioAgentEventType["AssistantMessage"] = "ASSISTANT_MESSAGE";
+    /** Provider reservation/accounting state changed. */
+    CrowdyStudioAgentEventType["BudgetUpdated"] = "BUDGET_UPDATED";
+    /** Immutable private pre-image checkpoint was created. */
+    CrowdyStudioAgentEventType["CheckpointCreated"] = "CHECKPOINT_CREATED";
+    /** Checkpoint restored as a new project revision. */
+    CrowdyStudioAgentEventType["CheckpointRestored"] = "CHECKPOINT_RESTORED";
+    /** A new monotonic client epoch attached and fenced older tabs. */
+    CrowdyStudioAgentEventType["ClientAttached"] = "CLIENT_ATTACHED";
+    /** The interactive browser detached. */
+    CrowdyStudioAgentEventType["ClientDetached"] = "CLIENT_DETACHED";
+    /** Authoritative context changed and old authority was fenced. */
+    CrowdyStudioAgentEventType["ContextChanged"] = "CONTEXT_CHANGED";
+    /** Lease reached its expiry. */
+    CrowdyStudioAgentEventType["LeaseExpired"] = "LEASE_EXPIRED";
+    /** Workspace or Play lease was granted. */
+    CrowdyStudioAgentEventType["LeaseGranted"] = "LEASE_GRANTED";
+    /** Lease was immediately revoked. */
+    CrowdyStudioAgentEventType["LeaseRevoked"] = "LEASE_REVOKED";
+    /** Human selected ASK, BUILD, or PLAY. */
+    CrowdyStudioAgentEventType["ModeSelected"] = "MODE_SELECTED";
+    /** Human cancellation became durable. */
+    CrowdyStudioAgentEventType["RunCancelled"] = "RUN_CANCELLED";
+    /** Run reached a typed terminal failure. */
+    CrowdyStudioAgentEventType["RunFailed"] = "RUN_FAILED";
+    /** Active run entered a recoverable pause. */
+    CrowdyStudioAgentEventType["RunPaused"] = "RUN_PAUSED";
+    /** Safety preemption became durable. */
+    CrowdyStudioAgentEventType["RunPreempted"] = "RUN_PREEMPTED";
+    /** A leased worker started the serialized run. */
+    CrowdyStudioAgentEventType["RunStarted"] = "RUN_STARTED";
+    /** Run completed successfully. */
+    CrowdyStudioAgentEventType["RunSucceeded"] = "RUN_SUCCEEDED";
+    /** Session closed and retention cleanup began. */
+    CrowdyStudioAgentEventType["SessionClosed"] = "SESSION_CLOSED";
+    /** Session and pinned policy/registry context were created. */
+    CrowdyStudioAgentEventType["SessionCreated"] = "SESSION_CREATED";
+    /** Human paused the session and revoked capabilities. */
+    CrowdyStudioAgentEventType["SessionPaused"] = "SESSION_PAUSED";
+    /** Human explicitly resumed after context revalidation. */
+    CrowdyStudioAgentEventType["SessionResumed"] = "SESSION_RESUMED";
+    /** Human denied the exact proposal. */
+    CrowdyStudioAgentEventType["ToolDenied"] = "TOOL_DENIED";
+    /** Typed browser call was durably dispatched once. */
+    CrowdyStudioAgentEventType["ToolDispatched"] = "TOOL_DISPATCHED";
+    /** Typed executor reported a safe terminal failure. */
+    CrowdyStudioAgentEventType["ToolFailed"] = "TOOL_FAILED";
+    /** Effect may have occurred; no blind retry is allowed. */
+    CrowdyStudioAgentEventType["ToolOutcomeUnknown"] = "TOOL_OUTCOME_UNKNOWN";
+    /** Provider proposal passed exact name and input validation. */
+    CrowdyStudioAgentEventType["ToolProposed"] = "TOOL_PROPOSED";
+    /** Typed executor output passed validation. */
+    CrowdyStudioAgentEventType["ToolSucceeded"] = "TOOL_SUCCEEDED";
+    /** Recorded tool deadline elapsed. */
+    CrowdyStudioAgentEventType["ToolTimedOut"] = "TOOL_TIMED_OUT";
+    /** Redacted bounded human message accepted for one run. */
+    CrowdyStudioAgentEventType["UserMessage"] = "USER_MESSAGE";
+})(CrowdyStudioAgentEventType || (CrowdyStudioAgentEventType = {}));
+/** Lifecycle of a short-lived workspace or Play capability. */
+export var CrowdyStudioAgentLeaseStatus;
+(function (CrowdyStudioAgentLeaseStatus) {
+    /** Usable until its exact expiry/context changes. */
+    CrowdyStudioAgentLeaseStatus["Active"] = "ACTIVE";
+    /** Expired and cannot be renewed by the model. */
+    CrowdyStudioAgentLeaseStatus["Expired"] = "EXPIRED";
+    /** Explicitly or automatically revoked. */
+    CrowdyStudioAgentLeaseStatus["Revoked"] = "REVOKED";
+})(CrowdyStudioAgentLeaseStatus || (CrowdyStudioAgentLeaseStatus = {}));
+/** Capability family represented by a lease. */
+export var CrowdyStudioAgentLeaseType;
+(function (CrowdyStudioAgentLeaseType) {
+    /** Visible human-granted browser control lease, capped at ten minutes. */
+    CrowdyStudioAgentLeaseType["Play"] = "PLAY";
+    /** Thirty-second server-acquired lease bound to project revision and target write scopes. */
+    CrowdyStudioAgentLeaseType["Workspace"] = "WORKSPACE";
+})(CrowdyStudioAgentLeaseType || (CrowdyStudioAgentLeaseType = {}));
+/** Human-selected authority mode. The model cannot change modes or elevate itself. */
+export var CrowdyStudioAgentMode;
+(function (CrowdyStudioAgentMode) {
+    /** Read bounded project, diagnostics, policy, and host context; no project or game writes. */
+    CrowdyStudioAgentMode["Ask"] = "ASK";
+    /** Permit routine checkpointed project edits and draft tests under target write/run permissions and a workspace lease; live deployment is available only through an exact human approval. */
+    CrowdyStudioAgentMode["Build"] = "BUILD";
+    /** Permit bounded browser-host observation and gameplay tools only through a visible, human-granted, scoped lease; human input and policy/context changes preempt control immediately. */
+    CrowdyStudioAgentMode["Play"] = "PLAY";
+})(CrowdyStudioAgentMode || (CrowdyStudioAgentMode = {}));
+/** Whether a policy object is the platform row, app row, or intersection. */
+export var CrowdyStudioAgentPolicyKind;
+(function (CrowdyStudioAgentPolicyKind) {
+    /** App-owned policy after write-time platform clamping. */
+    CrowdyStudioAgentPolicyKind["App"] = "APP";
+    /** Fail-closed intersection of platform, operator-kill, and app policy. */
+    CrowdyStudioAgentPolicyKind["Effective"] = "EFFECTIVE";
+    /** Operator-owned platform policy and hard ceilings. */
+    CrowdyStudioAgentPolicyKind["Platform"] = "PLATFORM";
+})(CrowdyStudioAgentPolicyKind || (CrowdyStudioAgentPolicyKind = {}));
+/** Tool risk classes from crowdy.agent-tools/1. App policy may only remove platform-allowed classes; locked approval requirements still apply. */
+export var CrowdyStudioAgentRiskClass;
+(function (CrowdyStudioAgentRiskClass) {
+    /** Destructive action; exact human approval required. */
+    CrowdyStudioAgentRiskClass["Destructive"] = "DESTRUCTIVE";
+    /** Money or commerce action; exact human approval required. */
+    CrowdyStudioAgentRiskClass["Economic"] = "ECONOMIC";
+    /** Irreversible action; exact human approval required. */
+    CrowdyStudioAgentRiskClass["Irreversible"] = "IRREVERSIBLE";
+    /** Owner/app-scoped reads with redaction. */
+    CrowdyStudioAgentRiskClass["ReadOnly"] = "READ_ONLY";
+    /** Reversible Build writes with revision checks and checkpoints. */
+    CrowdyStudioAgentRiskClass["RoutineWrite"] = "ROUTINE_WRITE";
+    /** Trust, consent, or capability change; exact human approval required. */
+    CrowdyStudioAgentRiskClass["TrustConsent"] = "TRUST_CONSENT";
+    /** Routine Play actions requiring a visible human-granted lease. */
+    CrowdyStudioAgentRiskClass["WorldControl"] = "WORLD_CONTROL";
+})(CrowdyStudioAgentRiskClass || (CrowdyStudioAgentRiskClass = {}));
+/** Serialized durable state of one accepted human message and its provider/tool loop. */
+export var CrowdyStudioAgentRunStatus;
+(function (CrowdyStudioAgentRunStatus) {
+    /** Terminal human cancellation. */
+    CrowdyStudioAgentRunStatus["Cancelled"] = "CANCELLED";
+    /** Terminal typed failure; inspect errorCode. */
+    CrowdyStudioAgentRunStatus["Failed"] = "FAILED";
+    /** Recoverable human pause; resume revalidates context. */
+    CrowdyStudioAgentRunStatus["Paused"] = "PAUSED";
+    /** Terminal safety preemption caused by context/control loss. */
+    CrowdyStudioAgentRunStatus["Preempted"] = "PREEMPTED";
+    /** Durably accepted and awaiting a worker claim. */
+    CrowdyStudioAgentRunStatus["Queued"] = "QUEUED";
+    /** Owned by one leased orchestrator worker. */
+    CrowdyStudioAgentRunStatus["Running"] = "RUNNING";
+    /** Finished with a canonical assistant message. */
+    CrowdyStudioAgentRunStatus["Succeeded"] = "SUCCEEDED";
+    /** Waiting for a short-lived exact human decision. */
+    CrowdyStudioAgentRunStatus["WaitingForApproval"] = "WAITING_FOR_APPROVAL";
+    /** Waiting for one matching browser tool result. */
+    CrowdyStudioAgentRunStatus["WaitingForTool"] = "WAITING_FOR_TOOL";
+})(CrowdyStudioAgentRunStatus || (CrowdyStudioAgentRunStatus = {}));
+/** Durable lifecycle state of an owner/app agent session. */
+export var CrowdyStudioAgentSessionStatus;
+(function (CrowdyStudioAgentSessionStatus) {
+    /** Accepts human control mutations and one run. */
+    CrowdyStudioAgentSessionStatus["Active"] = "ACTIVE";
+    /** Permanently closed, all capabilities revoked, and retention cleanup scheduled. */
+    CrowdyStudioAgentSessionStatus["Closed"] = "CLOSED";
+    /** Stopped by the human or reconnect flow; explicit context-revalidating resume is required. */
+    CrowdyStudioAgentSessionStatus["Paused"] = "PAUSED";
+    /** Disabled by authoritative policy or platform control and cannot resume. */
+    CrowdyStudioAgentSessionStatus["Revoked"] = "REVOKED";
+})(CrowdyStudioAgentSessionStatus || (CrowdyStudioAgentSessionStatus = {}));
+/** Durable state of one descriptor-pinned serialized tool proposal. */
+export var CrowdyStudioAgentToolCallStatus;
+(function (CrowdyStudioAgentToolCallStatus) {
+    /** Cancelled before a known successful effect. */
+    CrowdyStudioAgentToolCallStatus["Cancelled"] = "CANCELLED";
+    /** Human denied the exact proposal. */
+    CrowdyStudioAgentToolCallStatus["Denied"] = "DENIED";
+    /** Durably sent to the matching attached browser epoch. */
+    CrowdyStudioAgentToolCallStatus["Dispatched"] = "DISPATCHED";
+    /** Typed executor failure. */
+    CrowdyStudioAgentToolCallStatus["Failed"] = "FAILED";
+    /** An effect may have occurred; it is never retried blindly and requires human inspection. */
+    CrowdyStudioAgentToolCallStatus["OutcomeUnknown"] = "OUTCOME_UNKNOWN";
+    /** Validated and recorded, not yet dispatched. */
+    CrowdyStudioAgentToolCallStatus["Proposed"] = "PROPOSED";
+    /** Executor began the typed operation. */
+    CrowdyStudioAgentToolCallStatus["Running"] = "RUNNING";
+    /** Fenced by an epoch or context change. */
+    CrowdyStudioAgentToolCallStatus["Stale"] = "STALE";
+    /** Typed output validated successfully. */
+    CrowdyStudioAgentToolCallStatus["Succeeded"] = "SUCCEEDED";
+    /** The recorded tool deadline elapsed. */
+    CrowdyStudioAgentToolCallStatus["TimedOut"] = "TIMED_OUT";
+    /** Blocked on the exact argument-hash approval. */
+    CrowdyStudioAgentToolCallStatus["WaitingForApproval"] = "WAITING_FOR_APPROVAL";
+})(CrowdyStudioAgentToolCallStatus || (CrowdyStudioAgentToolCallStatus = {}));
+/** Trusted boundary that executes a typed tool. */
+export var CrowdyStudioAgentToolExecutor;
+(function (CrowdyStudioAgentToolExecutor) {
+    /** The attached CrowdyJS host executes once after epoch/context/lease validation. */
+    CrowdyStudioAgentToolExecutor["Browser"] = "BROWSER";
+    /** Game API invokes an owner-scoped domain service; never shell or arbitrary GraphQL. */
+    CrowdyStudioAgentToolExecutor["Server"] = "SERVER";
+})(CrowdyStudioAgentToolExecutor || (CrowdyStudioAgentToolExecutor = {}));
+/** Terminal result reported once by a browser executor. */
+export var CrowdyStudioAgentToolResultStatus;
+(function (CrowdyStudioAgentToolResultStatus) {
+    /** Known cancelled before successful effect. */
+    CrowdyStudioAgentToolResultStatus["Cancelled"] = "CANCELLED";
+    /** Effect is known failed with a typed safe error. */
+    CrowdyStudioAgentToolResultStatus["Failed"] = "FAILED";
+    /** Effect may have happened; server fails the run without retrying. */
+    CrowdyStudioAgentToolResultStatus["OutcomeUnknown"] = "OUTCOME_UNKNOWN";
+    /** Effect and typed output are known successful. */
+    CrowdyStudioAgentToolResultStatus["Succeeded"] = "SUCCEEDED";
+    /** Browser deadline elapsed. */
+    CrowdyStudioAgentToolResultStatus["TimedOut"] = "TIMED_OUT";
+})(CrowdyStudioAgentToolResultStatus || (CrowdyStudioAgentToolResultStatus = {}));
+/** Server-classified effect risk; app policy may only tighten it. */
+export var CrowdyStudioAgentToolRisk;
+(function (CrowdyStudioAgentToolRisk) {
+    /** Possible data/path loss; exact human approval required. */
+    CrowdyStudioAgentToolRisk["Destructive"] = "DESTRUCTIVE";
+    /** Moves or commits value; exact human approval required. */
+    CrowdyStudioAgentToolRisk["Economic"] = "ECONOMIC";
+    /** Cannot be safely undone; exact human approval required. */
+    CrowdyStudioAgentToolRisk["Irreversible"] = "IRREVERSIBLE";
+    /** No canonical state mutation. */
+    CrowdyStudioAgentToolRisk["ReadOnly"] = "READ_ONLY";
+    /** Reversible expected-revision write with checkpointing. */
+    CrowdyStudioAgentToolRisk["RoutineWrite"] = "ROUTINE_WRITE";
+    /** Changes trust or consent; exact human approval required. */
+    CrowdyStudioAgentToolRisk["TrustConsent"] = "TRUST_CONSENT";
+    /** Routine game control requiring an explicit Play scope. */
+    CrowdyStudioAgentToolRisk["WorldControl"] = "WORLD_CONTROL";
+})(CrowdyStudioAgentToolRisk || (CrowdyStudioAgentToolRisk = {}));
+/** Crowdy Studio catalog visibility. Player catalog queries return only published entries. */
+export var CrowdyStudioCommonStatus;
+(function (CrowdyStudioCommonStatus) {
+    /** Retained for provenance but hidden from new player catalog reads and imports. */
+    CrowdyStudioCommonStatus["Archived"] = "ARCHIVED";
+    /** Crowdy Studio work in progress; hidden from player common-file queries. */
+    CrowdyStudioCommonStatus["Draft"] = "DRAFT";
+    /** Available to app-scoped players for reading and copy-by-value import. */
+    CrowdyStudioCommonStatus["Published"] = "PUBLISHED";
+})(CrowdyStudioCommonStatus || (CrowdyStudioCommonStatus = {}));
+/** How a project file entered the project. Imported content is copied by value; provenance is informational and does not create a live link. */
+export var CrowdyStudioFileProvenance;
+(function (CrowdyStudioFileProvenance) {
+    /** The owner authored or directly saved this project file. */
+    CrowdyStudioFileProvenance["Authored"] = "AUTHORED";
+    /** The file was copied from a specific immutable version of the app’s Crowdy Studio-curated common catalog. */
+    CrowdyStudioFileProvenance["Common"] = "COMMON";
+    /** The file was copied from a specific revision of the owner’s private personal library. */
+    CrowdyStudioFileProvenance["Library"] = "LIBRARY";
+})(CrowdyStudioFileProvenance || (CrowdyStudioFileProvenance = {}));
+/** What the first commit of a bind does. The repository and the Studio project cannot both be the truth on day one, so the owner says which one is. */
+export var CrowdyStudioGitHubBindInitial;
+(function (CrowdyStudioGitHubBindInitial) {
+    /** The Studio project files are committed to the branch (with a crowdy.json when the repository has none). Refused with GITHUB_REPO_HAS_FILES when the repository already carries rust under the layout roots. */
+    CrowdyStudioGitHubBindInitial["PushProject"] = "PUSH_PROJECT";
+    /** The repository is adopted as it is; the Studio project files are replaced by the rust under the layout roots at branch HEAD. Refused with GITHUB_REPO_EMPTY when there is nothing to take. */
+    CrowdyStudioGitHubBindInitial["TakeRepository"] = "TAKE_REPOSITORY";
+})(CrowdyStudioGitHubBindInitial || (CrowdyStudioGitHubBindInitial = {}));
+/** The source catalog used for a copy-by-value project file import. */
+export var CrowdyStudioImportSource;
+(function (CrowdyStudioImportSource) {
+    /** Import from an immutable published common-file version in the requested app. */
+    CrowdyStudioImportSource["Common"] = "COMMON";
+    /** Import from a private personal-library file owned by the authenticated caller. */
+    CrowdyStudioImportSource["Library"] = "LIBRARY";
+})(CrowdyStudioImportSource || (CrowdyStudioImportSource = {}));
+/** Editor preference describing how the project presents its server and client targets; it never grants deployment or runtime authority. */
+export var CrowdyStudioPairingPreference;
+(function (CrowdyStudioPairingPreference) {
+    /** Present only the client-target authoring workflow. */
+    CrowdyStudioPairingPreference["ClientOnly"] = "CLIENT_ONLY";
+    /** Present server and client sources independently without an implied requirement edge. */
+    CrowdyStudioPairingPreference["Independent"] = "INDEPENDENT";
+    /** Present server and client sources as two coordinated halves of one Crowdy Studio project. */
+    CrowdyStudioPairingPreference["Paired"] = "PAIRED";
+    /** Present only the server-target authoring workflow. */
+    CrowdyStudioPairingPreference["ServerOnly"] = "SERVER_ONLY";
+})(CrowdyStudioPairingPreference || (CrowdyStudioPairingPreference = {}));
+/** Where a project’s files are authored. Every project starts as STUDIO; its owner may bind a GitHub repository later (crowdyStudioGitHubBind) and unbind it again. GitHub is never required. */
+export var CrowdyStudioProjectSource;
+(function (CrowdyStudioProjectSource) {
+    /** The bound repository is the working tree. `files` is a server-maintained mirror of the rust under the layout roots at githubSha; writes go through crowdyStudioGitHubPutFile / DeleteFile with expectedCommitSha, and the Studio file mutations refuse with GITHUB_BOUND_USE_CONTENTS. */
+    CrowdyStudioProjectSource["Github"] = "GITHUB";
+    /** Files live in Crowdy Studio and are written with the crowdyStudioProject* file mutations under the project revision. */
+    CrowdyStudioProjectSource["Studio"] = "STUDIO";
+})(CrowdyStudioProjectSource || (CrowdyStudioProjectSource = {}));
+/** The independently capped source target inside a player-owned Crowdy Studio project. */
+export var CrowdyStudioTarget;
+(function (CrowdyStudioTarget) {
+    /** Browser-worker Rust that can run only after the caller separately passes current grid ownership and write_client_code deployment checks. */
+    CrowdyStudioTarget["Client"] = "CLIENT";
+    /** Server-target Rust that can run only after the caller separately passes current grid ownership and write_server_code deployment checks. */
+    CrowdyStudioTarget["Server"] = "SERVER";
+})(CrowdyStudioTarget || (CrowdyStudioTarget = {}));
+/** Whether a datacenter currently has a ck-api instance able to serve clients. Three-valued on purpose: "nothing is serving there" and "the liveness signal could not be read" look identical through a boolean and call for opposite reactions. */
+export var DatacenterServingStatus;
+(function (DatacenterServingStatus) {
+    /** The signal was readable and reported no instance able to take a client there. An app placed here would be created and stored correctly, and its players would be told the app is temporarily offline until an instance returns. */
+    DatacenterServingStatus["NotServing"] = "NOT_SERVING";
+    /** At least one instance in that datacenter has heartbeated within the freshness window and is not draining. */
+    DatacenterServingStatus["Serving"] = "SERVING";
+    /** The liveness signal itself could not be read or trusted. Must NOT be presented as an outage: a fleet-wide heartbeat failure once made every datacenter look dead while all of them were fine, and healthy players were told their app was offline. */
+    DatacenterServingStatus["Unknown"] = "UNKNOWN";
+})(DatacenterServingStatus || (DatacenterServingStatus = {}));
+/** 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 var ExecModScope;
+(function (ExecModScope) {
+    ExecModScope["All"] = "ALL";
+    ExecModScope["Grid"] = "GRID";
+    ExecModScope["Listing"] = "LISTING";
+    ExecModScope["Mod"] = "MOD";
+    ExecModScope["Player"] = "PLAYER";
+})(ExecModScope || (ExecModScope = {}));
+/** How a player claim confers grid ownership in this app (D4): SELF_CLAIM (the claim alone assigns ownership), APPROVAL (claims create requests designated approvers accept), INVITE (only against a standing invite), or MARKETPLACE_ONLY (direct claims refused). setAppGridClaimPolicy refuses MARKETPLACE_ONLY while paid grid commerce is off the public API. */
+export var GridClaimPolicy;
+(function (GridClaimPolicy) {
+    GridClaimPolicy["Approval"] = "APPROVAL";
+    GridClaimPolicy["Invite"] = "INVITE";
+    GridClaimPolicy["MarketplaceOnly"] = "MARKETPLACE_ONLY";
+    GridClaimPolicy["SelfClaim"] = "SELF_CLAIM";
+})(GridClaimPolicy || (GridClaimPolicy = {}));
+/** Kind of principal holding grid title. P1 can assign USER owners; GROUP and ORG are schema-reserved for future shared ownership. */
+export var GridOwnerKind;
+(function (GridOwnerKind) {
+    GridOwnerKind["Group"] = "GROUP";
+    GridOwnerKind["Org"] = "ORG";
+    GridOwnerKind["User"] = "USER";
+})(GridOwnerKind || (GridOwnerKind = {}));
+/** Whether the current title is permanent ownership or an expiring rental. */
+export var GridTenure;
+(function (GridTenure) {
+    GridTenure["Owned"] = "OWNED";
+    GridTenure["Rented"] = "RENTED";
+})(GridTenure || (GridTenure = {}));
+/** Lifecycle of one publish. STAGING: upload URLs issued, objects arriving. LIVE: promoted and serving. SUPERSEDED: a later publish went live. FAILED: completion refused. ABANDONED: the developer gave up (abandonGamePublish). */
+export var HostedGamePublishState;
+(function (HostedGamePublishState) {
+    HostedGamePublishState["Abandoned"] = "ABANDONED";
+    HostedGamePublishState["Failed"] = "FAILED";
+    HostedGamePublishState["Live"] = "LIVE";
+    HostedGamePublishState["Staging"] = "STAGING";
+    HostedGamePublishState["Superseded"] = "SUPERSEDED";
+})(HostedGamePublishState || (HostedGamePublishState = {}));
+/** Whether a hosted game is served. LIVE: served at its launchUrl. DISABLED: switched off by its developer (setHostedGameEnabled). TAKEN_DOWN: removed by an operator; the developer cannot publish or re-enable until an operator restores it. */
+export var HostedGameStatus;
+(function (HostedGameStatus) {
+    HostedGameStatus["Disabled"] = "DISABLED";
+    HostedGameStatus["Live"] = "LIVE";
+    HostedGameStatus["TakenDown"] = "TAKEN_DOWN";
+})(HostedGameStatus || (HostedGameStatus = {}));
+/** External payment processor for a checkout. */
+export var PaymentProvider;
+(function (PaymentProvider) {
+    /** PayPal. Hosted approval flow; the approved order is captured via capturePaypalCheckout (which completes the checkout), with PayPal webhooks as backup reconciliation. */
+    PaymentProvider["Paypal"] = "PAYPAL";
+    /** Stripe Checkout. Hosted card payment session; completion is confirmed via Stripe webhooks. */
+    PaymentProvider["Stripe"] = "STRIPE";
+})(PaymentProvider || (PaymentProvider = {}));
+/** How a listing is acquired. P4a ships FREE only; the paid modes (buy, rent, time-limited, cost-limited) arrive with the P4b money workstream. */
+export var PlayerCodeAcquisitionMode;
+(function (PlayerCodeAcquisitionMode) {
+    PlayerCodeAcquisitionMode["Buy"] = "BUY";
+    PlayerCodeAcquisitionMode["CostLimited"] = "COST_LIMITED";
+    PlayerCodeAcquisitionMode["Free"] = "FREE";
+    PlayerCodeAcquisitionMode["Rent"] = "RENT";
+    PlayerCodeAcquisitionMode["TimeLimited"] = "TIME_LIMITED";
+})(PlayerCodeAcquisitionMode || (PlayerCodeAcquisitionMode = {}));
+/** A listing's standing under this app's admission mode: ADMITTED (installable), PENDING (browsable but uninstallable in allow_list apps), or REVOKED (installs drain). */
+export var PlayerCodeAdmissionState;
+(function (PlayerCodeAdmissionState) {
+    PlayerCodeAdmissionState["Admitted"] = "ADMITTED";
+    PlayerCodeAdmissionState["Pending"] = "PENDING";
+    PlayerCodeAdmissionState["Revoked"] = "REVOKED";
+})(PlayerCodeAdmissionState || (PlayerCodeAdmissionState = {}));
+/** Source-access mode of a listing: CLOSED (artifacts + contracts only) or OPEN_SOURCE (source readable; irreversible per published version). */
+export var PlayerCodeLicenseMode;
+(function (PlayerCodeLicenseMode) {
+    PlayerCodeLicenseMode["Closed"] = "CLOSED";
+    PlayerCodeLicenseMode["OpenSource"] = "OPEN_SOURCE";
+})(PlayerCodeLicenseMode || (PlayerCodeLicenseMode = {}));
+/** Catalog status of a listing: ACTIVE (browsable/acquirable), DELISTED (author withdrew it — existing installs keep their pinned versions), KILLED (studio/operator kill). */
+export var PlayerCodeListingStatus;
+(function (PlayerCodeListingStatus) {
+    PlayerCodeListingStatus["Active"] = "ACTIVE";
+    PlayerCodeListingStatus["Delisted"] = "DELISTED";
+    PlayerCodeListingStatus["Killed"] = "KILLED";
+})(PlayerCodeListingStatus || (PlayerCodeListingStatus = {}));
+/** Who owns a marketplace code listing: a player user or an org (DN-9: the org then holds source access and listing control). */
+export var PlayerCodeOwnerKind;
+(function (PlayerCodeOwnerKind) {
+    PlayerCodeOwnerKind["Org"] = "ORG";
+    PlayerCodeOwnerKind["User"] = "USER";
+})(PlayerCodeOwnerKind || (PlayerCodeOwnerKind = {}));
+/** Which rate card. SHARED prices organization metered usage for shared-environment apps (billed hourly to the org wallet as "shared_usage"). PLAYER prices player compute (billed hourly to the player wallet as "usage_debit"). */
+export var RateScope;
+(function (RateScope) {
+    RateScope["Player"] = "PLAYER";
+    RateScope["Shared"] = "SHARED";
+})(RateScope || (RateScope = {}));
+/** Lifecycle/capacity state of a game/GraphQL server in the fleet. Only ReadyForClients servers should receive new client connections; serverWithLeastClients and activeGraphQLServers already filter to healthy, non-overloaded servers. */
+export var ServerState;
+(function (ServerState) {
+    /** Hard resource overload. Like NearCapacity (excluded from new-client selection), and the server is also actively shedding clients: it sends each affected client a reconnect command and drops their session after a short grace period so they migrate to another server. */
+    ServerState["Full"] = "Full";
+    /** Soft resource overload (a CPU core or system memory has been high for several seconds). Existing sessions continue, but the server is excluded from serverWithLeastClients so no new clients are routed here until it recovers. */
+    ServerState["NearCapacity"] = "NearCapacity";
+    /** The server is down or unreachable (failed health checks). Do not route any traffic here. */
+    ServerState["Offline"] = "Offline";
+    /** The server is healthy and accepting clients. This is the only state safe to route new connections to. */
+    ServerState["ReadyForClients"] = "ReadyForClients";
+    /** The server is booting and not yet accepting clients. Do not route new connections here; wait for ReadyForClients. */
+    ServerState["Starting"] = "Starting";
+    /** The server is draining and shutting down: existing sessions may continue briefly but no new clients should be routed here. */
+    ServerState["Stopping"] = "Stopping";
+})(ServerState || (ServerState = {}));
+/** Error codes returned by UDP game servers (and surfaced on `GenericErrorResponse.errorCode`) in response to a spatial/realtime message. NO_ERROR (0) indicates success; every other value indicates a failure. The numeric value is the byte sent on the wire; GraphQL exposes the name. Note: a failed message does not always produce an error — some auth failures are dropped silently (see the docs). */
+export var UdpErrorCode;
+(function (UdpErrorCode) {
+    /** No app matches the supplied appId. */
+    UdpErrorCode["AppNotFound"] = "APP_NOT_FOUND";
+    /** The app exists but is not currently loaded/active on this server. */
+    UdpErrorCode["AppNotLoaded"] = "APP_NOT_LOADED";
+    /** The password did not match (login validation). */
+    UdpErrorCode["BadPassword"] = "BAD_PASSWORD";
+    UdpErrorCode["CannotDeleteDefaultWorldGrid"] = "CANNOT_DELETE_DEFAULT_WORLD_GRID";
+    /** No chunk exists at the referenced coordinates. */
+    UdpErrorCode["ChunkNotFound"] = "CHUNK_NOT_FOUND";
+    /** Registration failed because the email is already in use. */
+    UdpErrorCode["EmailAlreadyExists"] = "EMAIL_ALREADY_EXISTS";
+    /** Email failed format validation. */
+    UdpErrorCode["EmailInvalid"] = "EMAIL_INVALID";
+    /** No account matches the supplied email (login validation). */
+    UdpErrorCode["EmailNotFound"] = "EMAIL_NOT_FOUND";
+    /** Email failed maximum-length validation. */
+    UdpErrorCode["EmailTooLong"] = "EMAIL_TOO_LONG";
+    /** Email failed minimum-length validation. */
+    UdpErrorCode["EmailTooShort"] = "EMAIL_TOO_SHORT";
+    /** The requested gamertag is already taken. */
+    UdpErrorCode["GamertagAlreadyExists"] = "GAMERTAG_ALREADY_EXISTS";
+    /** The game token is not the expected length. Use the exact token returned by login (do not trim or re-encode it). */
+    UdpErrorCode["GameTokenWrongSize"] = "GAME_TOKEN_WRONG_SIZE";
+    /** A grid already exists at these coordinates. */
+    UdpErrorCode["GridAlreadyExists"] = "GRID_ALREADY_EXISTS";
+    UdpErrorCode["GridHasNestedChildren"] = "GRID_HAS_NESTED_CHILDREN";
+    UdpErrorCode["GridNotFound"] = "GRID_NOT_FOUND";
+    /** The target coordinates fall outside any grid assigned to the caller. */
+    UdpErrorCode["GridOutsideAssignment"] = "GRID_OUTSIDE_ASSIGNMENT";
+    /** The requested grid overlaps an existing grid. */
+    UdpErrorCode["GridOverlapsExisting"] = "GRID_OVERLAPS_EXISTING";
+    /** The appId was missing, zero, or not a valid value. */
+    UdpErrorCode["InvalidAppId"] = "INVALID_APP_ID";
+    /** The grid coordinates were invalid. */
+    UdpErrorCode["InvalidGridCoordinates"] = "INVALID_GRID_COORDINATES";
+    /** The message was malformed or failed validation. Check the byte layout. */
+    UdpErrorCode["InvalidRequest"] = "INVALID_REQUEST";
+    /** The state/payload bytes were invalid for this message type. */
+    UdpErrorCode["InvalidStateData"] = "INVALID_STATE_DATA";
+    /** The game token was rejected (expired, malformed, or revoked). Re-authenticate against the Management API to obtain a fresh token. */
+    UdpErrorCode["InvalidToken"] = "INVALID_TOKEN";
+    /** The supplied token was not a valid length. */
+    UdpErrorCode["InvalidTokenLength"] = "INVALID_TOKEN_LENGTH";
+    /** A supplied name exceeded the maximum length. */
+    UdpErrorCode["NameTooLong"] = "NAME_TOO_LONG";
+    /** No error (0). The message was accepted. */
+    UdpErrorCode["NoError"] = "NO_ERROR";
+    /** No grid assignment covers the referenced coordinates. */
+    UdpErrorCode["NoMatchingGridAssignment"] = "NO_MATCHING_GRID_ASSIGNMENT";
+    /** Password failed maximum-length validation. */
+    UdpErrorCode["PasswordTooLong"] = "PASSWORD_TOO_LONG";
+    /** Password failed minimum-length validation. */
+    UdpErrorCode["PasswordTooShort"] = "PASSWORD_TOO_SHORT";
+    /** The app-scoped gameplay token has expired. Refresh it (same app, via refreshAppToken) before it lapses, or re-portal through the Overworld for a fresh token, then re-authorize the realtime session. */
+    UdpErrorCode["TokenExpired"] = "TOKEN_EXPIRED";
+    /** The caller lacks the runtime/grid permission required for this action. Grid permissions can load asynchronously, so the first message to a newly entered region may transiently return this — retry shortly. */
+    UdpErrorCode["Unauthorized"] = "UNAUTHORIZED";
+    /** Unspecified server error (1). Retry; if it persists, report it. */
+    UdpErrorCode["UnknownError"] = "UNKNOWN_ERROR";
+    /** Requires app-admin privileges (the 'manage_apps' permission). */
+    UdpErrorCode["UserNotAppAdmin"] = "USER_NOT_APP_ADMIN";
+    /** This client has no authenticated session on the server. Complete the UDP token handshake (or open the UDP proxy) before sending spatial messages. */
+    UdpErrorCode["UserNotAuthenticated"] = "USER_NOT_AUTHENTICATED";
+})(UdpErrorCode || (UdpErrorCode = {}));