@crowdedkingdomstudios/crowdyjs 1.0.7 → 2.1.0

package/README.md

@@ -1,9 +1,16 @@
 # CrowdyJS SDK
 
 Client SDK for the Crowded Kingdoms GraphQL API with UDP proxy support.
-Handles authentication, real-time subscriptions, and all repilcation-server
-communication through a single `CrowdyClient` instance. Users should still 
-directly access the CK GraphQL API for other functions beyond replication.
+Handles authentication, real-time subscriptions, and all replication-server
+communication through a single `CrowdyClient` instance.
+
+## Links 
+
+- [NPM](https://www.npmjs.com/package/@crowdedkingdomstudios/crowdyjs)  
+- [GitHub](https://github.com/CrowdedKingdoms/CrowdyJS)  
+- [Discord](https://discord.gg/crowdedkingdoms)
+- [YouTube](https://www.youtube.com/@CrowdedKingdoms)
+
 
 ## Installation
 
@@ -116,7 +123,7 @@ const MY_UUID = Array.from(crypto.getRandomValues(new Uint8Array(16)))
 
 ```javascript
 await client.sendActorUpdate({
-  mapId: 0,
+  appId: 0,
   chunk: { x: 0, y: 0, z: 0 },
   distance: 8,
   uuid: MY_UUID,
@@ -142,7 +149,7 @@ view.setFloat32(8, posZ, true);
 const base64State = btoa(String.fromCharCode(...new Uint8Array(stateBuffer)));
 
 await client.sendActorUpdate({
-  mapId: 0,
+  appId: 0,
   chunk: { x: 0, y: 0, z: 0 },
   distance: 8,
   decayRate: 0,
@@ -163,13 +170,40 @@ Unsubscribing from notifications stops delivery but does **not** release
 the UDP session. Call `disconnectUdpProxy()` explicitly, or the server
 will release it after 30 seconds of inactivity.
 
+## Request / Notification Mapping
+
+Every accepted spatial request is fanned out by the game server as a
+notification to all clients in range, **including the sender**. Treat
+your own arrival as the round-trip echo for that send (correlate by
+`uuid` + `sequenceNumber`).
+
+| Mutation (you send)         | Notification (everyone in range receives) |
+|-----------------------------|-------------------------------------------|
+| `sendActorUpdate(...)`      | `ActorUpdateNotification`                 |
+| `sendVoxelUpdate(...)`      | `VoxelUpdateNotification`                 |
+| `sendAudioPacket(...)`      | `ClientAudioNotification`                 |
+| `sendTextPacket(...)`       | `ClientTextNotification`                  |
+| `sendClientEvent(...)`      | `ClientEventNotification`                 |
+| *(generic spatial)*         | *(generic spatial)*                       |
+
+`ServerEventNotification` is server-originated (no matching client
+mutation). `GenericErrorResponse` carries failures for any of the above
+— correlate to the offending send via `sequenceNumber`. The legacy
+`ActorUpdateResponse` and `VoxelUpdateResponse` ack types are retired
+on the wire; rely on the self-fanout notification (and
+`GenericErrorResponse` for failures) instead.
+
+> *Generic spatial* refers to wire type `GENERIC_SPATIAL_1` (an arbitrary
+> client-defined payload routed through the same spatial fan-out as the
+> typed messages above). It is not currently exposed by this SDK.
+
 ## Subscription Handlers
 
 All spatial notification types share a uniform header:
 
 | Field | Type | Description |
 |-------|------|-------------|
-| `mapId` | `string` | Map / chunk-W coordinate |
+| `appId` | `string` | App ID (tenant / world identifier) |
 | `chunkX` | `string` | Chunk X coordinate |
 | `chunkY` | `string` | Chunk Y coordinate |
 | `chunkZ` | `string` | Chunk Z coordinate |
@@ -204,7 +238,7 @@ All mutation inputs share these fields:
 
 | Field | Type | Required | Default | Description |
 |-------|------|----------|---------|-------------|
-| `mapId` | `number` | yes | -- | Map / chunk-W coordinate |
+| `appId` | `number` | yes | -- | App ID (tenant / world identifier) |
 | `chunk` | `{ x, y, z }` | yes | -- | Chunk coordinates (numbers) |
 | `uuid` | `string` | yes | -- | Random 32-byte UTF-8 string (see [Generating a UUID](#generating-a-uuid)) |
 | `distance` | `number` | no | `8` | Replication range (0-8 chunks, Chebyshev) |
@@ -285,7 +319,7 @@ const unsubErrors = client.onGenericError((e) => {
 
 // 3. Register in chunk
 await client.sendActorUpdate({
-  mapId: 0,
+  appId: 0,
   chunk: { x: 0, y: 0, z: 0 },
   distance: 8,
   uuid: MY_UUID,
@@ -301,7 +335,7 @@ const interval = setInterval(async () => {
   const state = btoa(String.fromCharCode(...buf));
 
   await client.sendActorUpdate({
-    mapId: 0,
+    appId: 0,
     chunk: { x: 0, y: 0, z: 0 },
     distance: 8,
     uuid: MY_UUID,
@@ -318,6 +352,212 @@ await client.disconnectUdpProxy();
 client.close();
 ```
 
+## Building a Real-Time Game
+
+The Quick Start above is enough to send and receive packets. Once you wire
+the SDK into an actual game these patterns will save you a lot of debugging
+time. 
+
+### Decouple the network from the render loop
+
+Browsers throttle `requestAnimationFrame` aggressively when the tab is
+backgrounded — often to ~1 fps or fully paused. If your `sendActorUpdate`
+cadence is driven by the render loop, your character will appear frozen
+to other players the moment a user switches tabs. Drive sends with
+`setInterval` (which keeps firing in background tabs):
+
+```javascript
+const SEND_INTERVAL_MS = 100; // 10 Hz
+const sendId = setInterval(async () => {
+  await client.sendActorUpdate({
+    appId, chunk: getCurrentChunk(),
+    uuid: MY_UUID,
+    state: encodeLocalPose(),
+    sequenceNumber: nextSeq(),
+  });
+}, SEND_INTERVAL_MS);
+```
+
+Apply incoming notifications **inside the WS callback**, not buffered for
+the next frame. That keeps your data model in sync with real network
+arrivals even while the render loop is paused:
+
+```javascript
+client.onActorUpdate((notification) => {
+  registry.applyRemote(notification, performance.now()); // synchronous
+});
+```
+
+The renderer should treat the registry as a *view source* — sprites
+interpolate toward registry-held targets each frame, but the registry
+itself is mutated only by the network layer.
+
+### Verify the round-trip with self-fanout
+
+The game server fans out every accepted actor update to all clients in
+the chunk, **including the sender**. Use your own arrival as the WS
+round-trip echo (correlate by `uuid` + `sequenceNumber`):
+
+```javascript
+let lastSendAt = null, lastSendSeq = null;
+let lastEchoAt = null, lastEchoSeq = null;
+
+async function sendOnce() {
+  const seq = nextSeq();
+  const ok = await client.sendActorUpdate({ /* ... */, sequenceNumber: seq });
+  if (ok) { lastSendAt = performance.now(); lastSendSeq = seq; }
+}
+
+client.onActorUpdate((n) => {
+  if (n.uuid === MY_UUID) {
+    lastEchoAt = performance.now();
+    lastEchoSeq = n.sequenceNumber;
+    return;          // don't render ourselves as a remote
+  }
+  registry.applyRemote(n);
+});
+```
+
+`ActorUpdateResponse` is retired on the wire — the self-uuid notification
+is the canonical ack. `GenericErrorResponse` carries failures (correlate
+via `sequenceNumber`).
+
+### Keep the UDP session alive
+
+The server times the UDP proxy session out after **30 s** of inactivity in
+either direction. A 10 Hz send loop trivially keeps it warm. If your
+sender pauses (e.g. no local input → no diff to send), the next mutation
+will lazily re-establish via `ensureUdpProxyConnection` — `connectUdpProxy()`
+is idempotent. There is no need for a separate keepalive.
+
+### Detect and recover from connection drops
+
+The SDK does not auto-reconnect a dropped WebSocket: `onclose` only nulls
+the internal client. Track wall-clock arrival time of *any* notification
+and force a fresh subscription if it goes silent:
+
+```javascript
+let lastNotificationAt = performance.now();
+function bumpActivity() { lastNotificationAt = performance.now(); }
+
+// Wire bumpActivity into every handler you register (actor, voxel, text,
+// audio, event, server event, error). Or wrap your subscribe call.
+client.onActorUpdate((n) => { bumpActivity(); /* ... */ });
+client.onGenericError((e) => { bumpActivity(); /* ... */ });
+
+setInterval(() => {
+  if (performance.now() - lastNotificationAt > 8000) {
+    forceResubscribe();    // see below
+  }
+}, 1000);
+```
+
+To force a fresh subscription, call your unsubscribe handles and
+`subscribe()` again — the SDK opens a new WebSocket on a fresh subscribe.
+Then send one `sendActorUpdate` to re-register your chunk position so
+others see you immediately.
+
+```javascript
+function forceResubscribe() {
+  unsubAll();
+  unsubAll = installSubscriptions(); // re-registers handlers
+  void client.sendActorUpdate({ /* re-register */ });
+}
+```
+
+### Visibility-driven heal
+
+Browsers sometimes kill the WebSocket while a tab is hidden. Listen for
+`visibilitychange` and trigger a heal on return. Pause your stale-actor
+reaper (next section) while hidden so you don't drop remotes during a
+period when you couldn't have heard from them anyway.
+
+```javascript
+document.addEventListener('visibilitychange', () => {
+  if (document.hidden) {
+    pauseReaper('tab_hidden');
+    return;
+  }
+  forceResubscribe();
+  resumeReaperWithGrace('tab_hidden', 5000);
+});
+```
+
+### Track presence with timestamps
+
+There is no live "who is in this chunk" query — `client.actors.list({ chunk })`
+returns the persisted DB roster, not the live UDP set. Each remote actor's
+presence is inferred from the last notification you saw from them:
+
+```javascript
+const remotes = new Map(); // uuid -> { firstSeenAt, lastUpdateAt, pose }
+
+client.onActorUpdate((n) => {
+  if (n.uuid === MY_UUID) return;
+  const now = performance.now();
+  const existing = remotes.get(n.uuid);
+  if (!existing) {
+    remotes.set(n.uuid, { firstSeenAt: now, lastUpdateAt: now, pose: decode(n.state) });
+  } else {
+    existing.lastUpdateAt = now;
+    existing.pose = decode(n.state);
+  }
+});
+```
+
+Periodically reap remotes that stopped sending. **Suspend reaping while
+the tab is hidden or the WS is unhealthy** — otherwise you will evict
+remotes simply because you couldn't have heard from them.
+
+```javascript
+const STALE_TIMEOUT_MS = 10_000;
+setInterval(() => {
+  if (document.hidden || isWsStale()) return;
+  const now = performance.now();
+  for (const [uuid, r] of remotes) {
+    if (now - r.lastUpdateAt > STALE_TIMEOUT_MS) remotes.delete(uuid);
+  }
+}, 3000);
+```
+
+Grant a grace window after every heal (visibility return, force-resubscribe)
+before reaping resumes — that lets remotes re-broadcast on their own
+cadence first.
+
+### Suggested module layout
+
+A clean separation makes the rest much easier:
+
+```
+GameSession (singleton, lives above your scenes / views)
+├── ActorRegistry       data + emitter; mutated only in WS callbacks
+├── ActorSender         setInterval sends; reads pose from your game
+├── NetworkHealth       visibility / WS-stale monitor + heal
+└── (uses) CrowdyClient
+```
+
+Sprites and HUD become *views* over `ActorRegistry`. Scene shutdown only
+destroys sprites; the singleton session and registry persist, so revisiting
+the scene (or returning from a hidden tab) does not lose presence state.
+Recreating sprites on scene re-entry walks the existing registry entries.
+
+### Diagnostics worth logging
+
+When something goes wrong, these are the values you'll wish you had:
+
+- `sendCount`, `lastSendAt`, `lastSendSeq` — your local sender's history.
+- `echoCount`, `lastEchoAt`, `lastEchoSeq`, `msSinceLastEcho` — the WS
+  round-trip via self-fanout. If `echoCount` flatlines while `sendCount`
+  climbs, the WS path is wedged.
+- `notificationsByType` — map of `__typename` to arrival count. Useful for
+  confirming what the server is actually emitting.
+- Per-remote `lastUpdateAt` / `msSinceUpdate`.
+- `visibilityState`, `hidden`, `lastWsResubscribeAt`, `reaperPaused`.
+
+Expose them on a global handle (e.g. `window.__MYGAME_NET__.snapshot()`)
+during development — a structured JSON snapshot is far easier to triage
+than a wall of streaming logs.
+
 ## API Reference
 
 ### Constructor
@@ -344,8 +584,8 @@ new CrowdyClient(config?: CrowdyClientConfig)
 
 | Method | Returns | Description |
 |--------|---------|-------------|
-| `connectUdpProxy()` | `Promise<UdpProxyConnectionStatus>` | Explicitly open a UDP session (optional) |
-| `disconnectUdpProxy()` | `Promise<boolean>` | Release the UDP session |
+| `connectUdpProxy()` | `Promise<UdpProxyConnectionStatus>` | Open a UDP session (idempotent: returns the existing status if one is open). Optional — `udpNotifications` and any `send*` mutation also create a session lazily. |
+| `disconnectUdpProxy()` | `Promise<boolean>` | Release the UDP session and complete the current `udpNotifications` stream. To force a fresh socket: call `disconnectUdpProxy()` then `connectUdpProxy()`. |
 | `getConnectionStatus()` | `Promise<UdpProxyConnectionStatus>` | Check if a UDP session is active |
 
 ### Mutations
@@ -381,11 +621,198 @@ the handler.
 |--------|-------------|
 | `close()` | Close the WebSocket, remove all handlers, clear auth state |
 
+## Domain APIs
+
+In addition to the replication-focused methods documented above, the
+client exposes a set of typed *domain wrappers* that cover the rest of
+the Crowded Kingdoms GraphQL API. Each wrapper is mounted on the
+`CrowdyClient` instance and uses the same auth token / base URL as the
+replication API. Operation inputs and return shapes are generated from
+the live `schema.gql` via `graphql-codegen`, so they stay in lockstep
+with the server.
+
+```javascript
+const client = new CrowdyClient({ graphqlEndpoint: '...' });
+await client.auth.login({ email, password });
+```
+
+### `client.auth` -- authentication & session lifecycle
+
+```javascript
+await client.auth.register({ email, password, gamertag });
+await client.auth.login({ email, password });
+await client.auth.confirmEmail('...token...');
+await client.auth.requestPasswordReset('user@example.com');
+await client.auth.resetPassword({ token: '...', newPassword: '...' });
+await client.auth.resendConfirmationEmail('user@example.com');
+await client.auth.changePassword('old', 'new');
+await client.auth.logout();
+await client.auth.logoutAllDevices();
+```
+
+The legacy shortcuts `client.login(email, password)` and
+`client.register(email, password, gamertag?)` are kept for backwards
+compatibility and delegate to `client.auth`.
+
+### `client.users` -- user directory & profile
+
+```javascript
+const me   = await client.users.me();
+const u    = await client.users.byId('123');
+const all  = await client.users.list();
+const list = await client.users.byGamertag('Gandalf');
+const list2 = await client.users.byEmail('a@b.c');
+
+await client.users.updateGamertag({ gamertag: 'Newname', disambiguation: '0001' });
+await client.users.updateUserState({ state: 'base64...' });
+```
+
+### `client.orgs` -- organizations / studios
+
+```javascript
+const org = await client.orgs.create({ name: 'Acme', slug: 'acme' });
+const byId   = await client.orgs.byId(org.orgId);
+const bySlug = await client.orgs.bySlug('acme');
+const members = await client.orgs.members(org.orgId);
+
+await client.orgs.inviteMember({ orgId: org.orgId, userId: '42' });
+const token = await client.orgs.createOrgToken({ orgId: org.orgId, label: 'CI' });
+```
+
+### `client.appAccess` -- app access tiers and grants
+
+```javascript
+const tiers = await client.appAccess.listTiers(appId);
+const mine  = await client.appAccess.myAccess(appId);
+
+await client.appAccess.createTier({ appId, name: 'Pro', isFree: false, tierOrder: 2 });
+await client.appAccess.grant({ appId, userId: '42', tierId });
+await client.appAccess.revoke(appId, '42');
+```
+
+### `client.billing` -- wallets & app budgets
+
+```javascript
+const wallet = await client.billing.balance(orgId);
+const txns   = await client.billing.transactions({ orgId, limit: 50, offset: 0 });
+const budget = await client.billing.appBudget(orgId, appId);
+
+await client.billing.setAppBudget({ orgId, appId, monthlyLimitCents: '5000' });
+```
+
+### `client.quotas` -- per-org / per-app service quotas
+
+```javascript
+const orgQ = await client.quotas.byOrg(orgId);
+const appQ = await client.quotas.byApp(appId);
+
+const q = await client.quotas.set({
+  orgId,
+  appId,
+  metric: 'voxel_updates',
+  limitValue: '1000000',
+  period: 'month',
+});
+await client.quotas.delete(q.quotaId);
+```
+
+### `client.chunks` -- chunk + LOD queries and admin mutations
+
+```javascript
+const chunk    = await client.chunks.get({ appId, coordinates: { x: '0', y: '0', z: '0' } });
+const lods     = await client.chunks.getLods({ appId, coordinates, lodLevels: [0, 1, 2] });
+const nearby   = await client.chunks.byDistance({ appId, centerCoordinate: coordinates, maxDistance: 4 });
+const voxels   = await client.chunks.voxelList({ appId, coordinates });
+
+await client.chunks.update({ appId, coordinates, voxels: '...base64...' });
+await client.chunks.updateState({ appId, coordinates, chunkState: '...' });
+await client.chunks.updateLods({ appId, coordinates, lods: [{ level: 0, data: '...' }] });
+```
+
+### `client.voxels` -- voxel queries, history, rollback
+
+```javascript
+await client.voxels.list({ appId, coordinates });
+await client.voxels.listByDistance({ appId, centerCoordinate: coordinates, maxDistance: 2 });
+await client.voxels.update({ appId, coordinates, location, voxelType: 5, state: '...' });
+await client.voxels.history({ appId, userId: '42', limit: 100 });
+await client.voxels.rollback({ appId, userId: '42', from, to, dryRun: true });
+```
+
+### `client.actors` -- persisted actors (CRUD)
+
+```javascript
+const a = await client.actors.create({
+  appId, uuid: '...', chunk: { x: '0', y: '0', z: '0' },
+});
+await client.actors.get(a.uuid);
+await client.actors.list({ appId });
+await client.actors.batchLookup({ uuids: [a.uuid] });
+await client.actors.update(a.uuid, { publicState: '...' });
+await client.actors.updateState(a.uuid, { publicState: '...' });
+await client.actors.delete(a.uuid);
+```
+
+For high-frequency replication, continue to use the existing
+`client.sendActorUpdate(...)` UDP path -- it is unchanged.
+
+### `client.teleport`
+
+```javascript
+const result = await client.teleport.request({
+  appId,
+  chunkAddress: { x: '0', y: '0', z: '0' },
+  voxelAddress: { x: 0, y: 0, z: 0 },
+  UUID: '...',
+});
+```
+
+### `client.state` -- per-user, per-app state
+
+```javascript
+await client.state.update({ appId, state: 'base64...' });
+await client.state.getOne(appId);
+await client.state.getAll();
+await client.state.delete(appId);
+```
+
+### `client.serverStatus`
+
+```javascript
+await client.serverStatus.serverWithLeastClients();
+await client.serverStatus.listAll();
+await client.serverStatus.listActiveGraphqlServers();
+await client.serverStatus.versionInfo();
+```
+
+### `client.apps`
+
+The current schema does not expose direct CRUD for the App entity --
+apps are provisioned out of band. `client.apps` exists as a stable
+namespace for future additions; in the meantime use `client.appAccess`,
+`client.state`, `client.billing`, `client.chunks`, and `client.voxels`
+for app-scoped functionality.
+
+## Codegen
+
+Operations live as `.graphql` files under `src/operations/<domain>/`.
+After editing them or pulling a new schema, regenerate the typed
+documents:
+
+```bash
+npm run codegen        # one-shot
+npm run codegen:watch  # watch mode
+```
+
+`npm run build` runs codegen automatically via `prebuild`.
+
 ## TypeScript
 
 The SDK is written in TypeScript and ships type declarations. All
 notification interfaces, input types, and handler signatures are fully
-typed for IDE autocomplete and compile-time safety.
+typed for IDE autocomplete and compile-time safety. Schema-derived
+input/output types (e.g. `CreateOrganizationInput`, `Organization`,
+`AppBudget`) are re-exported from the package root.
 
 ## License
 

package/dist/auth-state.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Single source of truth for the auth token within one CrowdyClient instance.
+ *
+ * Both the HTTP client (`GraphQLClient`) and the WebSocket subscription
+ * manager observe this. Anything that mutates auth state - the typed
+ * `client.auth.login()` / `register()` / `logout()` family, or external
+ * callers - flows through `setToken()` so subscription requests can never
+ * silently fail with "Must be authenticated to subscribe".
+ *
+ * (Replaces the previous arrangement where GraphQLClient and
+ * SubscriptionManager each held their own copy of the token.)
+ */
+export type AuthStateListener = (token: string | null) => void;
+export declare class AuthState {
+    private token;
+    private listeners;
+    getToken(): string | null;
+    setToken(token: string | null): void;
+    subscribe(listener: AuthStateListener): () => void;
+}
+//# sourceMappingURL=auth-state.d.ts.map

package/dist/auth-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-state.d.ts","sourceRoot":"","sources":["../src/auth-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;AAE/D,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,SAAS,CAAgC;IAEjD,QAAQ,IAAI,MAAM,GAAG,IAAI;IAIzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAYpC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI;CAQnD"}

package/dist/auth-state.js

@@ -0,0 +1,30 @@
+export class AuthState {
+    constructor() {
+        this.token = null;
+        this.listeners = new Set();
+    }
+    getToken() {
+        return this.token;
+    }
+    setToken(token) {
+        if (token === this.token)
+            return;
+        this.token = token;
+        for (const listener of this.listeners) {
+            try {
+                listener(token);
+            }
+            catch (error) {
+                console.error('AuthState listener threw:', error);
+            }
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        // Replay current value immediately so listeners initialize correctly.
+        listener(this.token);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+}

package/dist/client.d.ts

@@ -1,27 +1,33 @@
 /**
- * Core GraphQL client for HTTP queries and mutations
+ * Minimal HTTP GraphQL client. Reads its bearer token from `AuthState` so the
+ * WebSocket subscription manager and HTTP client always agree on who's
+ * authenticated. The `login` / `register` / `connectUdpProxy` /
+ * `sendActorUpdate` / etc. shortcuts that used to live here are gone -
+ * everything goes through the typed sub-clients on `CrowdyClient` (e.g.
+ * `client.auth.login`, `client.udp.sendActorUpdate`).
  */
-import type { AuthResponse, UdpProxyConnectionStatus, ActorUpdateRequestInput, VoxelUpdateRequestInput, ClientAudioPacketInput, ClientTextPacketInput, ClientEventNotificationInput } from './types.js';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { AuthState } from './auth-state.js';
+export interface GraphQLClientConfig {
+    graphqlEndpoint?: string;
+    timeout?: number;
+}
 export declare class GraphQLClient {
-    private token;
-    private graphqlEndpoint;
-    private timeout;
-    constructor(config?: {
-        graphqlEndpoint?: string;
-        timeout?: number;
-    });
-    setAuthToken(token: string | null): void;
-    getAuthToken(): string | null;
+    private readonly graphqlEndpoint;
+    private readonly timeout;
+    private readonly authState;
+    constructor(config: GraphQLClientConfig | undefined, authState: AuthState);
+    getEndpoint(): string;
+    /**
+     * Execute a typed GraphQL operation produced by codegen and return the
+     * `data` payload. Throws on transport errors, GraphQL errors, or timeouts.
+     */
+    request<TResult, TVariables>(document: TypedDocumentNode<TResult, TVariables>, variables?: TVariables): Promise<TResult>;
+    /**
+     * Internal escape hatch for raw query strings (used by hand-written
+     * adapters that haven't migrated to typed documents yet). Prefer
+     * `request()` with a `TypedDocumentNode`.
+     */
     query<T = any>(query: string, variables?: Record<string, any>): Promise<T>;
-    login(email: string, password: string): Promise<AuthResponse>;
-    register(email: string, password: string, gamertag?: string): Promise<AuthResponse>;
-    connectUdpProxy(): Promise<UdpProxyConnectionStatus>;
-    disconnectUdpProxy(): Promise<boolean>;
-    getConnectionStatus(): Promise<UdpProxyConnectionStatus>;
-    sendActorUpdate(input: ActorUpdateRequestInput): Promise<boolean>;
-    sendVoxelUpdate(input: VoxelUpdateRequestInput): Promise<boolean>;
-    sendAudioPacket(input: ClientAudioPacketInput): Promise<boolean>;
-    sendTextPacket(input: ClientTextPacketInput): Promise<boolean>;
-    sendClientEvent(input: ClientEventNotificationInput): Promise<boolean>;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,YAAY,CAAC;AAEpB,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,GAAE;QAAE,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO;IAKvE,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAIxC,YAAY,IAAI,MAAM,GAAG,IAAI;IAIvB,KAAK,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IA+C9E,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IA2B7D,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IA2BnF,eAAe,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAgBpD,kBAAkB,IAAI,OAAO,CAAC,OAAO,CAAC;IAWtC,mBAAmB,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAgBxD,eAAe,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BjE,eAAe,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IA4BjE,eAAe,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BhE,cAAc,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC;IA0B9D,eAAe,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC;CA0B7E"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;gBAE1B,MAAM,EAAE,mBAAmB,YAAK,EAAE,SAAS,EAAE,SAAS;IAOlE,WAAW,IAAI,MAAM;IAIrB;;;OAGG;IACG,OAAO,CAAC,OAAO,EAAE,UAAU,EAC/B,QAAQ,EAAE,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC,EAChD,SAAS,CAAC,EAAE,UAAU,GACrB,OAAO,CAAC,OAAO,CAAC;IAKnB;;;;OAIG;IACG,KAAK,CAAC,CAAC,GAAG,GAAG,EACjB,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAClC,OAAO,CAAC,CAAC,CAAC;CAgDd"}