@crowdedkingdoms/crowdyjs 8.15.0 → 8.17.0

package/dist/domains/marketplace.js

@@ -0,0 +1,257 @@
+import { MarketplaceListingsDocument, MarketplaceListingVersionsDocument, MarketplaceMyAcquisitionsDocument, MarketplaceMyInstallsDocument, MarketplaceGridClientModsDocument, MarketplaceClientArtifactDocument, MarketplacePublishListingDocument, MarketplacePublishVersionDocument, MarketplaceAcquireDocument, MarketplaceInstallDocument, MarketplaceUninstallDocument, MarketplaceConsentGridClientModDocument, MarketplaceGridClaimPolicyDocument, MarketplaceGridClaimRequestsDocument, MarketplaceClaimGridOwnershipDocument, MarketplaceDecideGridClaimDocument, MarketplaceIssueGridClaimInviteDocument, MarketplaceAdmissionQueueDocument, MarketplaceAppListingsDocument, MarketplaceAppAcquisitionsDocument, MarketplaceTransferListingDocument, MarketplaceSetListingStatusDocument, MarketplaceSetGridClaimPolicyDocument, MarketplaceRenewAcquisitionDocument, MarketplaceTopUpAcquisitionDocument, MarketplaceRefundAcquisitionDocument, MarketplaceGridListingsDocument, MarketplacePurchaseGridDocument, MarketplaceSetListingPricingDocument, MarketplaceSetOrgShareDocument, MarketplaceBeginSellerOnboardingDocument, MarketplaceBeginOrgSellerOnboardingDocument, MarketplaceCreateAccountSessionDocument, MarketplaceCreateOrgAccountSessionDocument, MarketplaceMySellerBalanceDocument, MarketplaceRequestPayoutDocument, MarketplaceSpendPayoutToWalletDocument, MarketplaceCommerceRiskQueueDocument, MarketplaceDecideRiskFlagDocument, MarketplaceCreateGridListingDocument, } from '../generated/graphql.js';
+/**
+ * The P4a player-code marketplace (free mode) — exposed as
+ * `client.marketplace`. Player-facing browse/publish/acquire/install/consent
+ * and the D4 grid claim flows route to the Game API; studio moderation
+ * (admission queue, catalog administration, ownership transfer, claim-policy
+ * config) routes to the Management API.
+ *
+ * No money moves through any of these calls: every listing is free in P4a,
+ * an acquisition is an entitlement write, and the paid modes ship with P4b.
+ * Publishing snapshots artifact hashes and the DERIVED capability summary —
+ * never source; installs consent to the summary's hash.
+ */
+export class MarketplaceAPI {
+    constructor(game, management) {
+        this.game = game;
+        this.management = management;
+    }
+    // -- Store (Game API) ---------------------------------------------------------
+    /** Browse the app's active listings with admission standing per listing. */
+    async listings(variables) {
+        const data = await this.game.request(MarketplaceListingsDocument, variables);
+        return data.playerCodeListings;
+    }
+    /** Published versions of one listing (capability summaries + consent hashes). */
+    async versions(variables) {
+        const data = await this.game.request(MarketplaceListingVersionsDocument, variables);
+        return data.playerCodeListingVersions;
+    }
+    /** The caller's entitlements in this app. */
+    async myAcquisitions(variables) {
+        const data = await this.game.request(MarketplaceMyAcquisitionsDocument, variables);
+        return data.myPlayerCodeAcquisitions;
+    }
+    /** The caller's active installs in this app. */
+    async myInstalls(variables) {
+        const data = await this.game.request(MarketplaceMyInstallsDocument, variables);
+        return data.myPlayerCodeInstalls;
+    }
+    /** Create a listing (personal, or org-owned via input.ownerOrgId). */
+    async publishListing(variables) {
+        const data = await this.game.request(MarketplacePublishListingDocument, variables);
+        return data.publishPlayerCode;
+    }
+    /** Publish an immutable version from compiled module versions (hashes only). */
+    async publishVersion(variables) {
+        const data = await this.game.request(MarketplacePublishVersionDocument, variables);
+        return data.publishPlayerCodeVersion;
+    }
+    /** Free acquisition (entitlement write; idempotent per listing+caller). */
+    async acquire(variables) {
+        const data = await this.game.request(MarketplaceAcquireDocument, variables);
+        return data.acquirePlayerCode;
+    }
+    /**
+     * Install an acquisition after consenting to the version's capability
+     * hash. Server/bundled listings need an owned target gridId.
+     */
+    async install(variables) {
+        const data = await this.game.request(MarketplaceInstallDocument, variables);
+        return data.installPlayerCode;
+    }
+    /** Remove instances/attachments/fetch rights; the acquisition is retained. */
+    async uninstall(variables) {
+        const data = await this.game.request(MarketplaceUninstallDocument, variables);
+        return data.uninstallPlayerCode;
+    }
+    // -- Grid-attached client mods (D2) --------------------------------------------
+    /** Client mods attached to a grid, with the caller's consent state. */
+    async gridClientMods(variables) {
+        const data = await this.game.request(MarketplaceGridClientModsDocument, variables);
+        return data.gridClientMods;
+    }
+    /** Consent to one attachment's exact capability hash (per player). */
+    async consentGridClientMod(variables) {
+        const data = await this.game.request(MarketplaceConsentGridClientModDocument, variables);
+        return data.consentGridClientMod;
+    }
+    /** Fetch an acquired/attached listing's client artifact (base64 + metadata). */
+    async clientArtifact(variables) {
+        const data = await this.game.request(MarketplaceClientArtifactDocument, variables);
+        return data.playerCodeClientArtifact;
+    }
+    /**
+     * Fetch and decode a client artifact into broker inputs (bytes, content
+     * hash, per-dispatch fuel budget) — the marketplace twin of
+     * `playerCompute.artifactBytes` for acquired and grid-attached mods.
+     */
+    async clientArtifactBytes(variables) {
+        const a = await this.clientArtifact(variables);
+        const binary = atob(a.artifactBase64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return {
+            bytes: bytes.buffer,
+            artifactHash: a.artifactHash,
+            fuelPerDispatch: BigInt(a.clientFuelPerDispatch),
+            contractJson: a.contractJson ?? null,
+            versionId: a.versionId,
+        };
+    }
+    // -- D4 grid claim flows (Game API) ---------------------------------------------
+    /** The app's claim policy (self_claim / approval / invite / marketplace_only). */
+    async gridClaimPolicy(variables) {
+        const data = await this.game.request(MarketplaceGridClaimPolicyDocument, variables);
+        return data.gridClaimPolicy;
+    }
+    /** Pending claim requests (approvers see the app queue; players their own). */
+    async gridClaimRequests(variables) {
+        const data = await this.game.request(MarketplaceGridClaimRequestsDocument, variables);
+        return data.gridClaimRequests;
+    }
+    /** Claim grid ownership under the app policy (server-authorized, D4). */
+    async claimGridOwnership(variables) {
+        const data = await this.game.request(MarketplaceClaimGridOwnershipDocument, variables);
+        return data.claimGridOwnership;
+    }
+    /** Approve or deny a pending claim request (approvers/staff). */
+    async decideGridClaim(variables) {
+        const data = await this.game.request(MarketplaceDecideGridClaimDocument, variables);
+        return data.decideGridClaim;
+    }
+    /** Issue a standing claim invite (approvers/staff; INVITE mode). */
+    async issueGridClaimInvite(variables) {
+        const data = await this.game.request(MarketplaceIssueGridClaimInviteDocument, variables);
+        return data.issueGridClaimInvite;
+    }
+    // -- Studio moderation (Management API) ------------------------------------------
+    /** The admission queue: listings joined with allow-list standing. */
+    async admissionQueue(variables) {
+        const data = await this.management.request(MarketplaceAdmissionQueueDocument, variables);
+        return data.appCodeAdmissionQueue;
+    }
+    /** Studio catalog administration view (includes delisted/killed on request). */
+    async appListings(variables) {
+        const data = await this.management.request(MarketplaceAppListingsDocument, variables);
+        return data.appPlayerCodeListings;
+    }
+    /** All acquisitions in the app (studio audit view). */
+    async appAcquisitions(variables) {
+        const data = await this.management.request(MarketplaceAppAcquisitionsDocument, variables);
+        return data.appPlayerCodeAcquisitions;
+    }
+    /** Audited personal<->org listing transfer (DN-9). */
+    async transferListing(variables) {
+        const data = await this.management.request(MarketplaceTransferListingDocument, variables);
+        return data.transferPlayerCodeListing;
+    }
+    /**
+     * Catalog status: DELISTED/ACTIVE are owner actions; KILLED is the studio
+     * catalog kill — pair with playerCompute.setSwitch({scope:'listing'}) to
+     * also disable running installs fleet-wide.
+     */
+    async setListingStatus(variables) {
+        const data = await this.management.request(MarketplaceSetListingStatusDocument, variables);
+        return data.setPlayerCodeListingStatus;
+    }
+    /** Configure the app's D4 grid claim policy (manage_apps). */
+    async setGridClaimPolicy(variables) {
+        const data = await this.management.request(MarketplaceSetGridClaimPolicyDocument, variables);
+        return data.setAppGridClaimPolicy;
+    }
+    // -- P4b: paid modes + grid commerce (Game API) --------------------------------
+    /** Renew a RENT / extend a TIME_LIMITED acquisition (a wallet charge). */
+    async renewAcquisition(variables) {
+        const data = await this.game.request(MarketplaceRenewAcquisitionDocument, variables);
+        return data.renewPlayerCodeAcquisition;
+    }
+    /** Top up a COST_LIMITED acquisition's unit budget (a wallet charge). */
+    async topUpAcquisition(variables) {
+        const data = await this.game.request(MarketplaceTopUpAcquisitionDocument, variables);
+        return data.topUpPlayerCodeAcquisition;
+    }
+    /** Refund a paid acquisition (within window, before meaningful use). Returns cents. */
+    async refundAcquisition(variables) {
+        const data = await this.game.request(MarketplaceRefundAcquisitionDocument, variables);
+        return data.refundPlayerCodeAcquisition;
+    }
+    /** Browse the app's grid listings. */
+    async gridListings(variables) {
+        const data = await this.game.request(MarketplaceGridListingsDocument, variables);
+        return data.gridListings;
+    }
+    /** Buy a grid listing (wallet debit + atomic ownership; refund on failure). */
+    async purchaseGrid(variables) {
+        const data = await this.game.request(MarketplacePurchaseGridDocument, variables);
+        return data.purchaseGrid;
+    }
+    // -- P4b: pricing, seller payouts, grid catalog, risk (Management API) ----------
+    /** Author-only: set a listing's acquisition mode + price. */
+    async setListingPricing(variables) {
+        const data = await this.management.request(MarketplaceSetListingPricingDocument, variables);
+        return data.setListingPricing;
+    }
+    /** Set the app's marketplace org revenue share (bps; manage_billing). */
+    async setOrgShare(variables) {
+        const data = await this.management.request(MarketplaceSetOrgShareDocument, variables);
+        return data.setAppMarketplaceOrgShare;
+    }
+    /**
+     * Account Session for the EMBEDDED Connect components: initialize
+     * Connect.js with the returned publishableKey + clientSecret and mount
+     * account-onboarding / payouts / balances INSIDE your UI (no Stripe-hosted
+     * redirect). Client secrets are short-lived — pass this method as the
+     * fetchClientSecret callback so Connect.js refreshes automatically.
+     */
+    async createAccountSession(variables) {
+        const data = await this.management.request(MarketplaceCreateAccountSessionDocument, variables);
+        return data.createSellerAccountSession;
+    }
+    /** Embedded-components Account Session for an ORG payout account (manage_billing). */
+    async createOrgAccountSession(variables) {
+        const data = await this.management.request(MarketplaceCreateOrgAccountSessionDocument, variables);
+        return data.createOrgSellerAccountSession;
+    }
+    /** Begin Stripe Connect Express onboarding for the calling player-seller. */
+    async beginSellerOnboarding(variables) {
+        const data = await this.management.request(MarketplaceBeginSellerOnboardingDocument, variables);
+        return data.beginSellerOnboarding;
+    }
+    /** Begin onboarding for an org payout account (manage_billing in the org). */
+    async beginOrgSellerOnboarding(variables) {
+        const data = await this.management.request(MarketplaceBeginOrgSellerOnboardingDocument, variables);
+        return data.beginOrgSellerOnboarding;
+    }
+    /** The calling player's seller payout balance. */
+    async mySellerBalance() {
+        const data = await this.management.request(MarketplaceMySellerBalanceDocument, {});
+        return data.mySellerPayoutBalance;
+    }
+    /** Pay out the calling player's payable balance to their Connect account. */
+    async requestPayout(variables = {}) {
+        const data = await this.management.request(MarketplaceRequestPayoutDocument, variables);
+        return data.requestSellerPayout;
+    }
+    /** Earn-to-mod: convert payable balance into the player wallet. Returns cents. */
+    async spendPayoutToWallet(variables) {
+        const data = await this.management.request(MarketplaceSpendPayoutToWalletDocument, variables);
+        return data.spendPayoutBalanceToWallet;
+    }
+    /** The app's open T11 commerce risk queue (manage_compute). */
+    async commerceRiskQueue(variables) {
+        const data = await this.management.request(MarketplaceCommerceRiskQueueDocument, variables);
+        return data.commerceRiskQueue;
+    }
+    /** Release or confirm a T11 risk flag (manage_compute). */
+    async decideRiskFlag(variables) {
+        const data = await this.management.request(MarketplaceDecideRiskFlagDocument, variables);
+        return data.decideCommerceRiskFlag;
+    }
+    /** Studio: create a grid listing (blueprint or concrete; manage_apps). */
+    async createGridListing(variables) {
+        const data = await this.management.request(MarketplaceCreateGridListingDocument, variables);
+        return data.createGridListing;
+    }
+}

package/dist/domains/playerCompute.d.ts

@@ -0,0 +1,85 @@
+import type { GraphQLClient } from '../client.js';
+import { type PlayerComputeArtifactQuery, type PlayerComputeArtifactQueryVariables, type PlayerComputeUsageQuery, type PlayerComputeUsageQueryVariables, type PlayerComputeRunsQuery, type PlayerComputeRunsQueryVariables, type PlayerComputeLogsQuery, type PlayerComputeLogsQueryVariables, type PlayerComputeSetSwitchMutation, type PlayerComputeSetSwitchMutationVariables, type PlayerComputeSwitchesQuery, type PlayerComputeSwitchesQueryVariables, type PlayerComputeDeployMutation, type PlayerComputeDeployMutationVariables, type PlayerComputeSetEnabledMutation, type PlayerComputeSetEnabledMutationVariables, type PlayerComputeMyModulesQuery, type PlayerComputeMyModulesQueryVariables, type PlayerComputeVersionsQuery, type PlayerComputeVersionsQueryVariables, type PlayerComputeDeleteMutation, type PlayerComputeDeleteMutationVariables, type PlayerComputeInvokeMutation, type PlayerComputeInvokeMutationVariables } from '../generated/graphql.js';
+/**
+ * Player-authored Rust/WASM bound to player-owned grids — exposed as
+ * `client.playerCompute` and routed to the Game API.
+ *
+ * Deploying requires current grid ownership plus the target-specific
+ * `write_server_code` or `write_client_code` permission at both the app-tier
+ * and grid ACL layers. Enabling separately requires the matching run
+ * permission, a successful compile, and app admission when strict allow-list
+ * mode is active. Closed source remains visible only to its personal author.
+ */
+export declare class PlayerComputeAPI {
+    private readonly graphql;
+    constructor(graphql: GraphQLClient);
+    /**
+     * Create or update a grid-bound module and publish an immutable pending
+     * source version. Compilation is asynchronous.
+     */
+    deploy(input: PlayerComputeDeployMutationVariables['input']): Promise<PlayerComputeDeployMutation['playerComputeDeploy']>;
+    /**
+     * Request activation or stop execution. Enabling checks ownership, run
+     * permission, compile success, and app code admission independently of
+     * authoring permission.
+     */
+    setEnabled(variables: PlayerComputeSetEnabledMutationVariables): Promise<PlayerComputeSetEnabledMutation['playerComputeSetEnabled']>;
+    /**
+     * List modules authored by the caller or installed on grids they currently
+     * own. Closed source is not included in this module-level result.
+     */
+    myModules(variables: PlayerComputeMyModulesQueryVariables): Promise<PlayerComputeMyModulesQuery['playerComputeMyModules']>;
+    /**
+     * List immutable versions newest-first. Source and compile logs are redacted
+     * unless the caller is the personal author or the version is open source.
+     */
+    versions(variables: PlayerComputeVersionsQueryVariables): Promise<PlayerComputeVersionsQuery['playerComputeVersions']>;
+    /**
+     * Delete a self-authored module and its versions. The caller must still own
+     * the grid. Returns false when no matching module exists.
+     */
+    delete(variables: PlayerComputeDeleteMutationVariables): Promise<PlayerComputeDeleteMutation['playerComputeDelete']>;
+    /** Invoke an enabled/admitted server module synchronously as the grid owner. */
+    invoke(variables: PlayerComputeInvokeMutationVariables): Promise<PlayerComputeInvokeMutation['playerComputeInvoke']>;
+    /**
+     * The caller's spend/quota view for one app (P2): compute units burned in
+     * the current clock hour/day vs the effective policy caps, compile-quota
+     * utilization, and the wallet/spend-cap gate state with its typed reason
+     * (PLAYER_QUOTA_EXHAUSTED / PLAYER_WALLET_EMPTY / PLAYER_SPEND_CAP /
+     * PLAYER_COMPUTE_KILLED). The remaining-budget source for a live cost
+     * meter.
+     */
+    usage(variables: PlayerComputeUsageQueryVariables): Promise<PlayerComputeUsageQuery['playerComputeUsage']>;
+    /** Executions on an owned grid, newest first (attributed to the grid owner). */
+    runs(variables: PlayerComputeRunsQueryVariables): Promise<PlayerComputeRunsQuery['playerComputeRuns']>;
+    /** Failed-run diagnostics on an owned grid (typed error kinds), newest first. */
+    logs(variables: PlayerComputeLogsQueryVariables): Promise<PlayerComputeLogsQuery['playerComputeLogs']>;
+    /**
+     * Throw or release a kill-ladder switch at player/grid/app scope (studio,
+     * requires `manage_compute`). Quota state is retained across a kill.
+     */
+    setSwitch(variables: PlayerComputeSetSwitchMutationVariables): Promise<PlayerComputeSetSwitchMutation['playerComputeSetSwitch']>;
+    /** Active kill-ladder switches (studio, requires `view_compute_diagnostics`). */
+    switches(variables: PlayerComputeSwitchesQueryVariables): Promise<PlayerComputeSwitchesQuery['playerComputeSwitches']>;
+    /**
+     * Fetch a compiled CLIENT artifact + metadata for the browser broker (P3).
+     * Fail-closed server-side (ownership, authorship, run_client_code,
+     * admission). Returns the metadata as-is; use {@link artifactBytes} to get
+     * the decoded ArrayBuffer ready to hand {@link PlayerCodeBroker.start}.
+     */
+    artifact(variables: PlayerComputeArtifactQueryVariables): Promise<PlayerComputeArtifactQuery['playerComputeArtifact']>;
+    /**
+     * Fetch a client artifact and decode its bytes to an ArrayBuffer plus the
+     * broker inputs (content hash for side-load verification, per-dispatch fuel
+     * budget). Convenience over {@link artifact} for the live-coding client
+     * deploy loop.
+     */
+    artifactBytes(variables: PlayerComputeArtifactQueryVariables): Promise<{
+        bytes: ArrayBuffer;
+        artifactHash: string;
+        fuelPerDispatch: bigint;
+        contractJson: string | null;
+        versionId: string;
+    }>;
+}
+//# sourceMappingURL=playerCompute.d.ts.map

package/dist/domains/playerCompute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playerCompute.d.ts","sourceRoot":"","sources":["../../src/domains/playerCompute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAaL,KAAK,0BAA0B,EAC/B,KAAK,mCAAmC,EACxC,KAAK,uBAAuB,EAC5B,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,uCAAuC,EAC5C,KAAK,0BAA0B,EAC/B,KAAK,mCAAmC,EACxC,KAAK,2BAA2B,EAChC,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,EACpC,KAAK,wCAAwC,EAC7C,KAAK,2BAA2B,EAChC,KAAK,oCAAoC,EACzC,KAAK,0BAA0B,EAC/B,KAAK,mCAAmC,EACxC,KAAK,2BAA2B,EAChC,KAAK,oCAAoC,EACzC,KAAK,2BAA2B,EAChC,KAAK,oCAAoC,EAC1C,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;GASG;AACH,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,aAAa;IAEnD;;;OAGG;IACG,MAAM,CACV,KAAK,EAAE,oCAAoC,CAAC,OAAO,CAAC,GACnD,OAAO,CAAC,2BAA2B,CAAC,qBAAqB,CAAC,CAAC;IAK9D;;;;OAIG;IACG,UAAU,CACd,SAAS,EAAE,wCAAwC,GAClD,OAAO,CAAC,+BAA+B,CAAC,yBAAyB,CAAC,CAAC;IAQtE;;;OAGG;IACG,SAAS,CACb,SAAS,EAAE,oCAAoC,GAC9C,OAAO,CAAC,2BAA2B,CAAC,wBAAwB,CAAC,CAAC;IAKjE;;;OAGG;IACG,QAAQ,CACZ,SAAS,EAAE,mCAAmC,GAC7C,OAAO,CAAC,0BAA0B,CAAC,uBAAuB,CAAC,CAAC;IAK/D;;;OAGG;IACG,MAAM,CACV,SAAS,EAAE,oCAAoC,GAC9C,OAAO,CAAC,2BAA2B,CAAC,qBAAqB,CAAC,CAAC;IAK9D,gFAAgF;IAC1E,MAAM,CACV,SAAS,EAAE,oCAAoC,GAC9C,OAAO,CAAC,2BAA2B,CAAC,qBAAqB,CAAC,CAAC;IAQ9D;;;;;;;OAOG;IACG,KAAK,CACT,SAAS,EAAE,gCAAgC,GAC1C,OAAO,CAAC,uBAAuB,CAAC,oBAAoB,CAAC,CAAC;IAQzD,gFAAgF;IAC1E,IAAI,CACR,SAAS,EAAE,+BAA+B,GACzC,OAAO,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;IAQvD,iFAAiF;IAC3E,IAAI,CACR,SAAS,EAAE,+BAA+B,GACzC,OAAO,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;IAQvD;;;OAGG;IACG,SAAS,CACb,SAAS,EAAE,uCAAuC,GACjD,OAAO,CAAC,8BAA8B,CAAC,wBAAwB,CAAC,CAAC;IAQpE,iFAAiF;IAC3E,QAAQ,CACZ,SAAS,EAAE,mCAAmC,GAC7C,OAAO,CAAC,0BAA0B,CAAC,uBAAuB,CAAC,CAAC;IAQ/D;;;;;OAKG;IACG,QAAQ,CACZ,SAAS,EAAE,mCAAmC,GAC7C,OAAO,CAAC,0BAA0B,CAAC,uBAAuB,CAAC,CAAC;IAQ/D;;;;;OAKG;IACG,aAAa,CACjB,SAAS,EAAE,mCAAmC,GAC7C,OAAO,CAAC;QACT,KAAK,EAAE,WAAW,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CAaH"}

package/dist/domains/playerCompute.js

@@ -0,0 +1,127 @@
+import { PlayerComputeDeployDocument, PlayerComputeSetEnabledDocument, PlayerComputeMyModulesDocument, PlayerComputeVersionsDocument, PlayerComputeDeleteDocument, PlayerComputeInvokeDocument, PlayerComputeUsageDocument, PlayerComputeRunsDocument, PlayerComputeLogsDocument, PlayerComputeSetSwitchDocument, PlayerComputeSwitchesDocument, PlayerComputeArtifactDocument, } from '../generated/graphql.js';
+/**
+ * Player-authored Rust/WASM bound to player-owned grids — exposed as
+ * `client.playerCompute` and routed to the Game API.
+ *
+ * Deploying requires current grid ownership plus the target-specific
+ * `write_server_code` or `write_client_code` permission at both the app-tier
+ * and grid ACL layers. Enabling separately requires the matching run
+ * permission, a successful compile, and app admission when strict allow-list
+ * mode is active. Closed source remains visible only to its personal author.
+ */
+export class PlayerComputeAPI {
+    constructor(graphql) {
+        this.graphql = graphql;
+    }
+    /**
+     * Create or update a grid-bound module and publish an immutable pending
+     * source version. Compilation is asynchronous.
+     */
+    async deploy(input) {
+        const data = await this.graphql.request(PlayerComputeDeployDocument, { input });
+        return data.playerComputeDeploy;
+    }
+    /**
+     * Request activation or stop execution. Enabling checks ownership, run
+     * permission, compile success, and app code admission independently of
+     * authoring permission.
+     */
+    async setEnabled(variables) {
+        const data = await this.graphql.request(PlayerComputeSetEnabledDocument, variables);
+        return data.playerComputeSetEnabled;
+    }
+    /**
+     * List modules authored by the caller or installed on grids they currently
+     * own. Closed source is not included in this module-level result.
+     */
+    async myModules(variables) {
+        const data = await this.graphql.request(PlayerComputeMyModulesDocument, variables);
+        return data.playerComputeMyModules;
+    }
+    /**
+     * List immutable versions newest-first. Source and compile logs are redacted
+     * unless the caller is the personal author or the version is open source.
+     */
+    async versions(variables) {
+        const data = await this.graphql.request(PlayerComputeVersionsDocument, variables);
+        return data.playerComputeVersions;
+    }
+    /**
+     * Delete a self-authored module and its versions. The caller must still own
+     * the grid. Returns false when no matching module exists.
+     */
+    async delete(variables) {
+        const data = await this.graphql.request(PlayerComputeDeleteDocument, variables);
+        return data.playerComputeDelete;
+    }
+    /** Invoke an enabled/admitted server module synchronously as the grid owner. */
+    async invoke(variables) {
+        const data = await this.graphql.request(PlayerComputeInvokeDocument, variables);
+        return data.playerComputeInvoke;
+    }
+    /**
+     * The caller's spend/quota view for one app (P2): compute units burned in
+     * the current clock hour/day vs the effective policy caps, compile-quota
+     * utilization, and the wallet/spend-cap gate state with its typed reason
+     * (PLAYER_QUOTA_EXHAUSTED / PLAYER_WALLET_EMPTY / PLAYER_SPEND_CAP /
+     * PLAYER_COMPUTE_KILLED). The remaining-budget source for a live cost
+     * meter.
+     */
+    async usage(variables) {
+        const data = await this.graphql.request(PlayerComputeUsageDocument, variables);
+        return data.playerComputeUsage;
+    }
+    /** Executions on an owned grid, newest first (attributed to the grid owner). */
+    async runs(variables) {
+        const data = await this.graphql.request(PlayerComputeRunsDocument, variables);
+        return data.playerComputeRuns;
+    }
+    /** Failed-run diagnostics on an owned grid (typed error kinds), newest first. */
+    async logs(variables) {
+        const data = await this.graphql.request(PlayerComputeLogsDocument, variables);
+        return data.playerComputeLogs;
+    }
+    /**
+     * Throw or release a kill-ladder switch at player/grid/app scope (studio,
+     * requires `manage_compute`). Quota state is retained across a kill.
+     */
+    async setSwitch(variables) {
+        const data = await this.graphql.request(PlayerComputeSetSwitchDocument, variables);
+        return data.playerComputeSetSwitch;
+    }
+    /** Active kill-ladder switches (studio, requires `view_compute_diagnostics`). */
+    async switches(variables) {
+        const data = await this.graphql.request(PlayerComputeSwitchesDocument, variables);
+        return data.playerComputeSwitches;
+    }
+    /**
+     * Fetch a compiled CLIENT artifact + metadata for the browser broker (P3).
+     * Fail-closed server-side (ownership, authorship, run_client_code,
+     * admission). Returns the metadata as-is; use {@link artifactBytes} to get
+     * the decoded ArrayBuffer ready to hand {@link PlayerCodeBroker.start}.
+     */
+    async artifact(variables) {
+        const data = await this.graphql.request(PlayerComputeArtifactDocument, variables);
+        return data.playerComputeArtifact;
+    }
+    /**
+     * Fetch a client artifact and decode its bytes to an ArrayBuffer plus the
+     * broker inputs (content hash for side-load verification, per-dispatch fuel
+     * budget). Convenience over {@link artifact} for the live-coding client
+     * deploy loop.
+     */
+    async artifactBytes(variables) {
+        const a = await this.artifact(variables);
+        const binary = atob(a.artifactBase64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return {
+            bytes: bytes.buffer,
+            artifactHash: a.artifactHash,
+            fuelPerDispatch: BigInt(a.clientFuelPerDispatch),
+            contractJson: a.contractJson ?? null,
+            versionId: a.versionId,
+        };
+    }
+}

package/dist/domains/playerModel.d.ts

@@ -0,0 +1,20 @@
+import type { GraphQLClient } from '../client.js';
+import { type PlayerModelContainersQuery, type PlayerModelContainersQueryVariables, type PlayerModelContainerQuery, type PlayerModelContainerQueryVariables, type PlayerModelCreateContainerMutation, type PlayerModelCreateContainerMutationVariables, type PlayerModelSetPropertyMutation, type PlayerModelSetPropertyMutationVariables, type PlayerModelDeleteContainerMutation, type PlayerModelDeleteContainerMutationVariables, type PlayerAutomationsQuery, type PlayerAutomationsQueryVariables, type PlayerAutomationCreateMutation, type PlayerAutomationCreateMutationVariables, type PlayerAutomationSetEnabledMutation, type PlayerAutomationSetEnabledMutationVariables, type PlayerAutomationDeleteMutation, type PlayerAutomationDeleteMutationVariables } from '../generated/graphql.js';
+/**
+ * Grid-owner Model data and Automations. Every operation is forced to the
+ * current caller + owned grid by game-api; no studio gm_* row is reachable.
+ */
+export declare class PlayerModelAPI {
+    private readonly graphql;
+    constructor(graphql: GraphQLClient);
+    containers(variables: PlayerModelContainersQueryVariables): Promise<PlayerModelContainersQuery['playerModelContainers']>;
+    container(input: PlayerModelContainerQueryVariables['input']): Promise<PlayerModelContainerQuery['playerModelContainer']>;
+    createContainer(input: PlayerModelCreateContainerMutationVariables['input']): Promise<PlayerModelCreateContainerMutation['playerModelCreateContainer']>;
+    setProperty(input: PlayerModelSetPropertyMutationVariables['input']): Promise<PlayerModelSetPropertyMutation['playerModelSetProperty']>;
+    deleteContainer(input: PlayerModelDeleteContainerMutationVariables['input']): Promise<PlayerModelDeleteContainerMutation['playerModelDeleteContainer']>;
+    automations(variables: PlayerAutomationsQueryVariables): Promise<PlayerAutomationsQuery['playerAutomations']>;
+    createAutomation(input: PlayerAutomationCreateMutationVariables['input']): Promise<PlayerAutomationCreateMutation['playerAutomationCreate']>;
+    setAutomationEnabled(input: PlayerAutomationSetEnabledMutationVariables['input']): Promise<PlayerAutomationSetEnabledMutation['playerAutomationSetEnabled']>;
+    deleteAutomation(input: PlayerAutomationDeleteMutationVariables['input']): Promise<PlayerAutomationDeleteMutation['playerAutomationDelete']>;
+}
+//# sourceMappingURL=playerModel.d.ts.map

package/dist/domains/playerModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playerModel.d.ts","sourceRoot":"","sources":["../../src/domains/playerModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAUL,KAAK,0BAA0B,EAC/B,KAAK,mCAAmC,EACxC,KAAK,yBAAyB,EAC9B,KAAK,kCAAkC,EACvC,KAAK,kCAAkC,EACvC,KAAK,2CAA2C,EAChD,KAAK,8BAA8B,EACnC,KAAK,uCAAuC,EAC5C,KAAK,kCAAkC,EACvC,KAAK,2CAA2C,EAChD,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,uCAAuC,EAC5C,KAAK,kCAAkC,EACvC,KAAK,2CAA2C,EAChD,KAAK,8BAA8B,EACnC,KAAK,uCAAuC,EAC7C,MAAM,yBAAyB,CAAC;AAEjC;;;GAGG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,aAAa;IAE7C,UAAU,CACd,SAAS,EAAE,mCAAmC,GAC7C,OAAO,CAAC,0BAA0B,CAAC,uBAAuB,CAAC,CAAC;IAQzD,SAAS,CACb,KAAK,EAAE,kCAAkC,CAAC,OAAO,CAAC,GACjD,OAAO,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,CAAC;IAOvD,eAAe,CACnB,KAAK,EAAE,2CAA2C,CAAC,OAAO,CAAC,GAC1D,OAAO,CAAC,kCAAkC,CAAC,4BAA4B,CAAC,CAAC;IAQtE,WAAW,CACf,KAAK,EAAE,uCAAuC,CAAC,OAAO,CAAC,GACtD,OAAO,CAAC,8BAA8B,CAAC,wBAAwB,CAAC,CAAC;IAO9D,eAAe,CACnB,KAAK,EAAE,2CAA2C,CAAC,OAAO,CAAC,GAC1D,OAAO,CAAC,kCAAkC,CAAC,4BAA4B,CAAC,CAAC;IAQtE,WAAW,CACf,SAAS,EAAE,+BAA+B,GACzC,OAAO,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;IAQjD,gBAAgB,CACpB,KAAK,EAAE,uCAAuC,CAAC,OAAO,CAAC,GACtD,OAAO,CAAC,8BAA8B,CAAC,wBAAwB,CAAC,CAAC;IAO9D,oBAAoB,CACxB,KAAK,EAAE,2CAA2C,CAAC,OAAO,CAAC,GAC1D,OAAO,CACR,kCAAkC,CAAC,4BAA4B,CAAC,CACjE;IAQK,gBAAgB,CACpB,KAAK,EAAE,uCAAuC,CAAC,OAAO,CAAC,GACtD,OAAO,CAAC,8BAA8B,CAAC,wBAAwB,CAAC,CAAC;CAMrE"}

package/dist/domains/playerModel.js

@@ -0,0 +1,54 @@
+import { PlayerModelContainersDocument, PlayerModelContainerDocument, PlayerModelCreateContainerDocument, PlayerModelSetPropertyDocument, PlayerModelDeleteContainerDocument, PlayerAutomationsDocument, PlayerAutomationCreateDocument, PlayerAutomationSetEnabledDocument, PlayerAutomationDeleteDocument, } from '../generated/graphql.js';
+/**
+ * Grid-owner Model data and Automations. Every operation is forced to the
+ * current caller + owned grid by game-api; no studio gm_* row is reachable.
+ */
+export class PlayerModelAPI {
+    constructor(graphql) {
+        this.graphql = graphql;
+    }
+    async containers(variables) {
+        const data = await this.graphql.request(PlayerModelContainersDocument, variables);
+        return data.playerModelContainers;
+    }
+    async container(input) {
+        const data = await this.graphql.request(PlayerModelContainerDocument, {
+            input,
+        });
+        return data.playerModelContainer;
+    }
+    async createContainer(input) {
+        const data = await this.graphql.request(PlayerModelCreateContainerDocument, { input });
+        return data.playerModelCreateContainer;
+    }
+    async setProperty(input) {
+        const data = await this.graphql.request(PlayerModelSetPropertyDocument, {
+            input,
+        });
+        return data.playerModelSetProperty;
+    }
+    async deleteContainer(input) {
+        const data = await this.graphql.request(PlayerModelDeleteContainerDocument, { input });
+        return data.playerModelDeleteContainer;
+    }
+    async automations(variables) {
+        const data = await this.graphql.request(PlayerAutomationsDocument, variables);
+        return data.playerAutomations;
+    }
+    async createAutomation(input) {
+        const data = await this.graphql.request(PlayerAutomationCreateDocument, {
+            input,
+        });
+        return data.playerAutomationCreate;
+    }
+    async setAutomationEnabled(input) {
+        const data = await this.graphql.request(PlayerAutomationSetEnabledDocument, { input });
+        return data.playerAutomationSetEnabled;
+    }
+    async deleteAutomation(input) {
+        const data = await this.graphql.request(PlayerAutomationDeleteDocument, {
+            input,
+        });
+        return data.playerAutomationDelete;
+    }
+}

package/dist/domains/playerWallet.d.ts

@@ -0,0 +1,59 @@
+import type { GraphQLClient } from '../client.js';
+import { type BeginPlayerCardSetupMutation, type PlayerWalletBalanceQuery, type PlayerWalletTransactionsQuery, type PlayerWalletTransactionsQueryVariables, type PlayerUsageChargesQuery, type PlayerUsageChargesQueryVariables, type PlayerSpendCapsQuery, type SetPlayerSpendCapMutation, type SetPlayerSpendCapMutationVariables, type PlayerAutoBillingQuery, type SetPlayerAutoBillingMutation, type SetPlayerAutoBillingMutationVariables, type PlayerRuntimeStatesQuery, type PlayerWasmPoliciesQuery, type PlayerWasmPoliciesQueryVariables, type SetPlayerWasmPolicyMutation, type SetPlayerWasmPolicyMutationVariables, type DeletePlayerWasmPolicyMutation, type DeletePlayerWasmPolicyMutationVariables, type PlayerRateMarkupQuery, type PlayerRateMarkupQueryVariables, type SetPlayerRateMarkupMutation, type SetPlayerRateMarkupMutationVariables, type AppPlayerUsageQuery, type AppPlayerUsageQueryVariables, type AppPlayerMarkupAccruedQuery, type AppPlayerMarkupAccruedQueryVariables } from '../generated/graphql.js';
+/**
+ * The player wallet and player-billing surface (player compute P2, DN-5) —
+ * exposed as `client.playerWallet` and routed to the Management API.
+ *
+ * Every viewer-scoped call operates on the CALLER's own wallet: balance,
+ * ledger, hourly usage charges (platform vs studio-markup split), self-set
+ * spend caps, auto-recharge config, and per-app gate states. Fund the wallet
+ * via `client.payments.createCheckout` with purpose `PLAYER_WALLET_TOPUP`.
+ *
+ * The studio-scoped calls (policies, markup, per-player usage, accrued
+ * markup) require the corresponding org permissions (`manage_compute`,
+ * `manage_billing`, `view_compute_diagnostics`, `view_billing`).
+ */
+export declare class PlayerWalletAPI {
+    private readonly graphql;
+    constructor(graphql: GraphQLClient);
+    /** The caller's wallet, created empty on first access (never null). */
+    balance(): Promise<PlayerWalletBalanceQuery['playerWalletBalance']>;
+    /** The caller's wallet ledger, newest first. */
+    transactions(variables?: PlayerWalletTransactionsQueryVariables): Promise<PlayerWalletTransactionsQuery['playerWalletTransactions']>;
+    /**
+     * The caller's posted hourly usage charges; each splits platformCents vs
+     * markupCents with a per-metric snapshot ("what is this grid costing me").
+     */
+    charges(variables?: PlayerUsageChargesQueryVariables): Promise<PlayerUsageChargesQuery['playerUsageCharges']>;
+    /** The caller's self-set spend caps with running counters. */
+    spendCaps(): Promise<PlayerSpendCapsQuery['playerSpendCaps']>;
+    /** Set (or clear with null limits) a global or per-app self spend cap. */
+    setSpendCap(variables: SetPlayerSpendCapMutationVariables): Promise<SetPlayerSpendCapMutation['setPlayerSpendCap']>;
+    /** The caller's auto-recharge settings. */
+    autoBilling(): Promise<PlayerAutoBillingQuery['playerAutoBilling']>;
+    /** Configure auto-recharge (requires a vaulted payment method to enable). */
+    setAutoBilling(variables: SetPlayerAutoBillingMutationVariables): Promise<SetPlayerAutoBillingMutation['setPlayerAutoBilling']>;
+    /**
+     * Begin vaulting a card on the caller's player wallet (P4b): returns the
+     * Stripe SetupIntent client secret + publishable key the browser confirms.
+     * On success the card is saved for wallet auto-recharge and rent auto-renew.
+     */
+    beginCardSetup(): Promise<BeginPlayerCardSetupMutation['beginPlayerCardSetup']>;
+    /** The caller's per-app gate states (absence means active). */
+    runtimeStates(): Promise<PlayerRuntimeStatesQuery['playerRuntimeStates']>;
+    /** Studio: list an app's player policy rows (`view_compute_diagnostics`). */
+    policies(variables: PlayerWasmPoliciesQueryVariables): Promise<PlayerWasmPoliciesQuery['playerWasmPolicies']>;
+    /** Studio: upsert a player policy row (`manage_compute`). */
+    setPolicy(variables: SetPlayerWasmPolicyMutationVariables): Promise<SetPlayerWasmPolicyMutation['setPlayerWasmPolicy']>;
+    /** Studio: delete a player policy row (`manage_compute`). */
+    deletePolicy(variables: DeletePlayerWasmPolicyMutationVariables): Promise<DeletePlayerWasmPolicyMutation['deletePlayerWasmPolicy']>;
+    /** Studio: read the app's player rate-card markup in bps (`view_billing`). */
+    rateMarkup(variables: PlayerRateMarkupQueryVariables): Promise<PlayerRateMarkupQuery['playerRateMarkup']>;
+    /** Studio: set the app's player rate-card markup in bps (`manage_billing`). */
+    setRateMarkup(variables: SetPlayerRateMarkupMutationVariables): Promise<SetPlayerRateMarkupMutation['setPlayerRateMarkup']>;
+    /** Studio: per-player usage aggregate (`view_compute_diagnostics`). */
+    appPlayerUsage(variables: AppPlayerUsageQueryVariables): Promise<AppPlayerUsageQuery['appPlayerUsage']>;
+    /** Studio: total accrued markup income in cents (`view_billing`). */
+    appMarkupAccrued(variables: AppPlayerMarkupAccruedQueryVariables): Promise<AppPlayerMarkupAccruedQuery['appPlayerMarkupAccrued']>;
+}
+//# sourceMappingURL=playerWallet.d.ts.map

package/dist/domains/playerWallet.d.ts.map

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