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

package/dist/domains/compute.js

@@ -1,274 +0,0 @@
-import { ComputeUpsertModuleDocument, ComputeDeployVersionDocument, ComputeSetModuleEnabledDocument, ComputeResetBreakerDocument, ComputeDeleteModuleDocument, ComputeUpsertTriggerDocument, ComputeDeleteTriggerDocument, ComputeSetPolicyDocument, ComputeInvokeDocument, ComputeModulesDocument, ComputeModuleDocument, ComputeModuleVersionsDocument, ComputeModuleTriggersDocument, ComputeModulePolicyDocument, ComputeModuleRunsDocument, ComputeModuleStatsDocument, ComputeModuleLogsDocument, ComputeAppDiagnosticsDocument, ComputeDeployTemplateDocument, ComputeTemplatesDocument, } from '../generated/graphql.js';
-/** The crowdy-compute-sdk version the platform toolchain currently pins. */
-export const COMPUTE_SDK_VERSION = '0.1.3';
-/** The guest ABI version the platform currently supports. */
-export const COMPUTE_ABI_VERSION = 0;
-/**
- * Typed client for **Compute Modules** — server-side Rust/WebAssembly logic
- * on the Game API (`client.compute`). Studios upload Rust source; the
- * platform compiles it to WASM and runs it sandboxed on the game servers with
- * fuel metering, triggers (tick / event / invoke), an app-scoped host data
- * API, and replication egress. Modules are **server-only**: this client
- * manages, invokes, and observes them — nothing executes client-side.
- *
- * Authoring mutations require the org **`manage_compute`** permission;
- * monitoring queries require **`view_compute_diagnostics`**. `invoke` is
- * gated per-export by the invoke trigger's policy.
- *
- * Docs: https://docs.crowdedkingdoms.com/game-api/compute-modules
- */
-export class ComputeAPI {
-    constructor(gql) {
-        this.gql = gql;
-    }
-    // -- Authoring (manage_compute) ---------------------------------------------
-    /**
-     * Create or update a module's metadata (upsert key `(appId, name)`). New
-     * modules start disabled; enable after a successful compile.
-     *
-     * **Nothing runs for an app with no player in it.** A module ticks only while
-     * its app has at least one player connected, anywhere in the fleet, and stops
-     * when the last one leaves. `alwaysOn` is retired (2026-09-01) and passing
-     * `true` is refused — a world that must advance while empty should compute the
-     * elapsed time on its first tick after a player returns, which is cheaper than
-     * ticking an empty world and gives the same result.
-     *
-     * Requires the org **`manage_compute`** permission.
-     *
-     * @throws {CrowdyGraphQLError} `FORBIDDEN` without the permission.
-     * @throws {CrowdyGraphQLError} `BAD_REQUEST` if `alwaysOn: true` is passed.
-     */
-    async upsertModule(input) {
-        const data = await this.gql.request(ComputeUpsertModuleDocument, { input });
-        return data.computeUpsertModule;
-    }
-    /**
-     * Upload an immutable source version and make it the deployed version. The
-     * source is validated server-side (Cargo.toml + `src/*.rs` only, dependency
-     * allowlist, size caps, no build-time code) and parked as
-     * `compileStatus: "pending"` until a game server compiles it — poll with
-     * {@link moduleVersions} or {@link waitForCompile}.
-     *
-     * Requires the org **`manage_compute`** permission.
-     *
-     * @param opts - App, module, `sourceFiles` map (stringified for you), and
-     *   optional SDK/ABI pins (defaulted to the current platform pins).
-     */
-    async deployVersion(opts) {
-        const data = await this.gql.request(ComputeDeployVersionDocument, {
-            input: {
-                appId: opts.appId,
-                moduleName: opts.moduleName,
-                sourceFilesJson: JSON.stringify(opts.sourceFiles),
-                sdkVersion: opts.sdkVersion ?? COMPUTE_SDK_VERSION,
-                abiVersion: opts.abiVersion ?? COMPUTE_ABI_VERSION,
-            },
-        });
-        return data.computeDeployVersion;
-    }
-    /**
-     * Enable or disable a module. Enabling requires a successfully compiled
-     * deployed version and resets the failure circuit; disabling stops all
-     * scheduling. Requires the org **`manage_compute`** permission.
-     *
-     * This does **not** restart a module that was stopped for exceeding a
-     * resource limit (`breakerLatchedAt`). Deploy a fixed version, or call
-     * {@link resetBreaker}.
-     */
-    async setModuleEnabled(variables) {
-        const data = await this.gql.request(ComputeSetModuleEnabledDocument, variables);
-        return data.computeSetModuleEnabled;
-    }
-    /**
-     * Restart a module that was stopped for exceeding a resource limit, without
-     * deploying a new version.
-     *
-     * A module stopped this way reports `breakerLatchedAt` and a
-     * `breakerReason` saying what it exceeded. Deploying a fix clears it
-     * automatically and is the normal path; use this when the limit itself was
-     * wrong, or the load is being accepted deliberately. The reason is recorded
-     * with the module's history. Requires the org **`manage_compute`**
-     * permission.
-     */
-    async resetBreaker(variables) {
-        const data = await this.gql.request(ComputeResetBreakerDocument, variables);
-        return data.computeResetBreaker;
-    }
-    /**
-     * Delete a module and (via cascade) its versions, triggers, and lease. Run
-     * history is retained for auditing. **Destructive.** Requires the org
-     * **`manage_compute`** permission.
-     *
-     * @returns `true` if a module was deleted.
-     */
-    async deleteModule(variables) {
-        const data = await this.gql.request(ComputeDeleteModuleDocument, variables);
-        return data.computeDeleteModule;
-    }
-    /**
-     * Bind a trigger to a module: a tick loop (`triggerType: "tick"` +
-     * `tickHz`, clamped by the app policy), an event subscription
-     * (`triggerType: "event"` + `onEvent`: `function_invoked` |
-     * `property_changed` | `container_created` | `compute_event`), or a
-     * client-callable export (`triggerType: "invoke"` + `exportName` +
-     * optional `invokePolicyJson` authority tree; null policy = compute admins
-     * only). Requires the org **`manage_compute`** permission.
-     */
-    async upsertTrigger(input) {
-        const data = await this.gql.request(ComputeUpsertTriggerDocument, { input });
-        return data.computeUpsertTrigger;
-    }
-    /**
-     * Delete a trigger by id. Requires the org **`manage_compute`** permission.
-     *
-     * @returns `true` if a trigger was deleted.
-     */
-    async deleteTrigger(variables) {
-        const data = await this.gql.request(ComputeDeleteTriggerDocument, variables);
-        return data.computeDeleteTrigger;
-    }
-    /**
-     * Set the app's compute policy (guardrails: kill switch, module count,
-     * tick-rate / fuel / memory / runtime / host-op / egress ceilings, circuit
-     * tuning). Omitted fields keep their current values; values above the
-     * platform ceilings are rejected. Requires the org **`manage_compute`**
-     * permission.
-     */
-    async setPolicy(input) {
-        const data = await this.gql.request(ComputeSetPolicyDocument, { input });
-        return data.computeSetPolicy;
-    }
-    // -- Invoke ------------------------------------------------------------------
-    /**
-     * Invoke a module's client-callable export (an `invoke` trigger) as a
-     * **synchronous RPC**: the module runs server-side and its result comes
-     * back directly — unlike the spatial send surface, a failure (policy
-     * denial, fuel exhaustion, trap) is a thrown error, not a silent drop.
-     *
-     * Authorization: the export's invoke policy, or `manage_compute` holders
-     * only when no policy is set.
-     *
-     * @returns The invoke result; `resultJson` is set when the module's bytes
-     *   parse as JSON (`resultBase64` always carries the raw bytes).
-     * @throws {CrowdyGraphQLError} `FORBIDDEN` on policy denial; `BAD_REQUEST`
-     *   when the module is disabled or the call fails inside the sandbox.
-     */
-    async invoke(variables) {
-        const data = await this.gql.request(ComputeInvokeDocument, variables);
-        return data.computeInvoke;
-    }
-    // -- Monitoring (view_compute_diagnostics) ------------------------------------
-    /** List the app's modules. Requires **`view_compute_diagnostics`**. */
-    async modules(variables) {
-        const data = await this.gql.request(ComputeModulesDocument, variables);
-        return data.computeModules;
-    }
-    /** Read one module by name. Requires **`view_compute_diagnostics`**. */
-    async module(variables) {
-        const data = await this.gql.request(ComputeModuleDocument, variables);
-        return data.computeModule;
-    }
-    /**
-     * List a module's source versions, newest first, including compile
-     * status/log. Requires **`view_compute_diagnostics`**.
-     */
-    async moduleVersions(variables) {
-        const data = await this.gql.request(ComputeModuleVersionsDocument, variables);
-        return data.computeModuleVersions;
-    }
-    /**
-     * The platform's engine-template registry: ready-made engines deployable
-     * by name with {@link deployTemplate}.
-     */
-    async templates(variables) {
-        const data = await this.gql.request(ComputeTemplatesDocument, variables);
-        return data.computeTemplates;
-    }
-    /**
-     * Deploy a named engine template from the platform registry — one call
-     * instead of the upsert/deploy/trigger/enable sequence. Compilation runs
-     * asynchronously; follow with {@link waitForCompile}.
-     */
-    async deployTemplate(variables) {
-        const data = await this.gql.request(ComputeDeployTemplateDocument, variables);
-        return data.computeDeployTemplate;
-    }
-    /**
-     * Poll {@link moduleVersions} until the newest version's compile settles
-     * (`succeeded` or `failed`). Resolves with the settled version; **rejects**
-     * on compile failure (message includes the compile log) or timeout.
-     *
-     * Requires **`view_compute_diagnostics`**.
-     */
-    async waitForCompile(appId, moduleName, opts = {}) {
-        const timeoutMs = opts.timeoutMs ?? 120000;
-        const intervalMs = opts.intervalMs ?? 2000;
-        const deadline = Date.now() + timeoutMs;
-        for (;;) {
-            const versions = await this.moduleVersions({ appId, moduleName, limit: 1 });
-            const latest = versions[0];
-            if (latest?.compileStatus === 'succeeded')
-                return latest;
-            if (latest?.compileStatus === 'failed') {
-                throw new Error(`compute module '${moduleName}' compile failed:\n${latest.compileLog ?? '(no log)'}`);
-            }
-            if (Date.now() + intervalMs > deadline) {
-                throw new Error(`compute module '${moduleName}' compile did not settle within ${timeoutMs}ms` +
-                    ` (status: ${latest?.compileStatus ?? 'no version found'})`);
-            }
-            await new Promise((r) => setTimeout(r, intervalMs));
-        }
-    }
-    /**
-     * List trigger bindings, optionally filtered to one module. Requires
-     * **`view_compute_diagnostics`**.
-     */
-    async moduleTriggers(variables) {
-        const data = await this.gql.request(ComputeModuleTriggersDocument, variables);
-        return data.computeModuleTriggers;
-    }
-    /**
-     * Read the app's compute policy (platform defaults when unset). Requires
-     * **`view_compute_diagnostics`**.
-     */
-    async modulePolicy(variables) {
-        const data = await this.gql.request(ComputeModulePolicyDocument, variables);
-        return data.computeModulePolicy;
-    }
-    /**
-     * List runs, newest first (module loads/`init`, every failure, and circuit
-     * probes; healthy high-frequency ticks are aggregated into per-minute
-     * usage instead of one row per tick). Requires
-     * **`view_compute_diagnostics`**.
-     */
-    async moduleRuns(variables) {
-        const data = await this.gql.request(ComputeModuleRunsDocument, variables);
-        return data.computeModuleRuns;
-    }
-    /**
-     * Aggregate activity over a recent window (default 60 minutes): run and
-     * failure counts, fuel, egress, per-module breakdown. Requires
-     * **`view_compute_diagnostics`**.
-     */
-    async moduleStats(variables) {
-        const data = await this.gql.request(ComputeModuleStatsDocument, variables);
-        return data.computeModuleStats;
-    }
-    /**
-     * Diagnostic log lines (guest `log()` output + failure lines), newest
-     * first. Requires **`view_compute_diagnostics`**.
-     */
-    async moduleLogs(variables) {
-        const data = await this.gql.request(ComputeModuleLogsDocument, variables);
-        return data.computeModuleLogs;
-    }
-    /**
-     * Snapshot of the app's compute footprint: module/version/trigger counts,
-     * 24h run activity, most-active modules. Requires
-     * **`view_compute_diagnostics`**.
-     */
-    async appDiagnostics(variables) {
-        const data = await this.gql.request(ComputeAppDiagnosticsDocument, variables);
-        return data.computeAppDiagnostics;
-    }
-}

package/dist/domains/controlPlane.d.ts

@@ -1,38 +0,0 @@
-import type { GraphQLClient } from '../client.js';
-import { type CpComputePlatformCeilingsQuery, type CpSetComputePlatformCeilingsMutation, type CpSetComputePlatformCeilingsInput } from '../generated/graphql.js';
-/**
- * Operator (platform-policy) surface — exposed as `client.operator`.
- *
- * As of the v13 unified API this surface is reduced to the platform-wide
- * compute ceilings: dedicated customer environments were retired, and the
- * infrastructure control plane (environments, change orders, secrets, release
- * management, audit) moved to the separate infra-control-plane service with
- * its own auth and operator console. EVERY operation here still requires
- * `users.is_operator` (super-admins implicitly have it).
- *
- * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` without a session, `FORBIDDEN`
- *   when the caller is not an operator.
- */
-export declare class ControlPlaneAPI {
-    private readonly api;
-    constructor(api: GraphQLClient);
-    /**
-     * The platform-wide compute ceilings (max modules, tick rates, fuel,
-     * memory, run time, db-op and egress budgets).
-     *
-     * @returns The stored ceilings row.
-     */
-    computePlatformCeilings(): Promise<CpComputePlatformCeilingsQuery['cpComputePlatformCeilings']>;
-    /**
-     * Patch the platform compute ceilings. Patch semantics per knob: omit =
-     * unchanged, explicit `null` = clear the override (fall back to the
-     * game-api bootstrap default), positive value = set. Takes effect on the
-     * next `computeSetPolicy` call (no restart), within a 30s cache bound.
-     * Writes a `compute.platform_ceilings_set` audit entry.
-     *
-     * @param input - The per-knob patch.
-     * @returns The stored ceilings after the patch.
-     */
-    setComputePlatformCeilings(input: CpSetComputePlatformCeilingsInput): Promise<CpSetComputePlatformCeilingsMutation['cpSetComputePlatformCeilings']>;
-}
-//# sourceMappingURL=controlPlane.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"controlPlane.d.ts","sourceRoot":"","sources":["../../src/domains/controlPlane.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAGL,KAAK,8BAA8B,EACnC,KAAK,oCAAoC,EACzC,KAAK,iCAAiC,EACvC,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,aAAa;IAE/C;;;;;OAKG;IACG,uBAAuB,IAAI,OAAO,CACtC,8BAA8B,CAAC,2BAA2B,CAAC,CAC5D;IAOD;;;;;;;;;OASG;IACG,0BAA0B,CAC9B,KAAK,EAAE,iCAAiC,GACvC,OAAO,CACR,oCAAoC,CAAC,8BAA8B,CAAC,CACrE;CAOF"}

package/dist/domains/controlPlane.js

@@ -1,43 +0,0 @@
-import { CpComputePlatformCeilingsDocument, CpSetComputePlatformCeilingsDocument, } from '../generated/graphql.js';
-/**
- * Operator (platform-policy) surface — exposed as `client.operator`.
- *
- * As of the v13 unified API this surface is reduced to the platform-wide
- * compute ceilings: dedicated customer environments were retired, and the
- * infrastructure control plane (environments, change orders, secrets, release
- * management, audit) moved to the separate infra-control-plane service with
- * its own auth and operator console. EVERY operation here still requires
- * `users.is_operator` (super-admins implicitly have it).
- *
- * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` without a session, `FORBIDDEN`
- *   when the caller is not an operator.
- */
-export class ControlPlaneAPI {
-    constructor(api) {
-        this.api = api;
-    }
-    /**
-     * The platform-wide compute ceilings (max modules, tick rates, fuel,
-     * memory, run time, db-op and egress budgets).
-     *
-     * @returns The stored ceilings row.
-     */
-    async computePlatformCeilings() {
-        const data = await this.api.request(CpComputePlatformCeilingsDocument);
-        return data.cpComputePlatformCeilings;
-    }
-    /**
-     * Patch the platform compute ceilings. Patch semantics per knob: omit =
-     * unchanged, explicit `null` = clear the override (fall back to the
-     * game-api bootstrap default), positive value = set. Takes effect on the
-     * next `computeSetPolicy` call (no restart), within a 30s cache bound.
-     * Writes a `compute.platform_ceilings_set` audit entry.
-     *
-     * @param input - The per-knob patch.
-     * @returns The stored ceilings after the patch.
-     */
-    async setComputePlatformCeilings(input) {
-        const data = await this.api.request(CpSetComputePlatformCeilingsDocument, { input });
-        return data.cpSetComputePlatformCeilings;
-    }
-}