@genex-ai/multiplayer 0.17.1 → 0.17.6

package/dist/authority/module.d.ts

@@ -0,0 +1 @@
+export { D as EntityApi, E as EntityData, G as EntityInit, U as GenexRoomModule, Y as InitContext, I as InputData, J as Json, L as LeaveReason, ae as LiftsApi, ag as MODULE_CONTRACT, ah as ModuleConfig, ap as PhysicsAnswer, aq as PhysicsApi, ar as PhysicsBodyDesc, as as PhysicsBodyState, at as PhysicsBodyType, au as PhysicsColliderDesc, av as PhysicsCommandResult, aw as PhysicsCommands, a as PhysicsErrorCode, ax as PhysicsEvent, ay as PhysicsGroups, az as PhysicsHit, aA as PhysicsJointDesc, aB as PhysicsLimits, aC as PhysicsMotor, aD as PhysicsOverlap, aE as PhysicsPose, aF as PhysicsQueryFilter, aG as PhysicsRefusal, aH as PhysicsRequest, aI as PhysicsSetPoseOptions, aJ as PhysicsShape, P as PlayerInfo, aR as PresetSpec, aS as ProjectileApi, aT as ProjectileField, aU as ProjectileFlight, aV as ProjectileHit, aW as ProjectileInit, aX as Quat, i as RemotePredict, R as ResolvedModuleConfig, aY as ResolvedPhysics, aZ as RewindApi, a_ as RoomContext, T as TickHz, b7 as Vec3, bg as defineRoom } from '../module-DqtFb5wA.js';

package/dist/authority/module.js

@@ -0,0 +1,12 @@
+import {
+  LeaveReason,
+  MODULE_CONTRACT,
+  RemotePredict,
+  defineRoom
+} from "../chunk-K3SF5VDS.js";
+export {
+  LeaveReason,
+  MODULE_CONTRACT,
+  RemotePredict,
+  defineRoom
+};

package/dist/bridge-authority.d.ts

@@ -0,0 +1,100 @@
+import { f as PredictCore } from './physics-predict-49udN3a1.js';
+import { B as BridgeIdentity } from './bridge-core-Dhc73GC8.js';
+import './module-DqtFb5wA.js';
+
+/** The embed-sdk identity of an authority join: the authority cluster's urls, not the relay's. */
+/**
+ * The authority build's contract version (BRIDGE.md): 3 adds `bodiesF32` and `bodyKeysJson` (physics
+ * prediction, PROTOCOL.md §17.11) to version 2's calls, every one unchanged. The relay build stays 2.
+ */
+declare const version = 3;
+/**
+ * Replace the authority identity source (`null` restores embed-sdk, whose `urls()` are
+ * `getAuthorityUrls()` and `regions()` `getAuthorityRegions()`). For a host page that manages
+ * identity itself, and for tests against a local authority server. Not part of the engine contract.
+ */
+declare function setAuthorityIdentity(next: BridgeIdentity | null): void;
+/**
+ * The physics core a predicting room's bodies are predicted with (PROTOCOL.md §17.11): the host page
+ * hands over a loader of `@genex-ai/physics` (after its `init()`, the non-SIMD module where the
+ * browser lacks WebAssembly SIMD); `null` forgets it. Sessions opened after the call use it. Not part
+ * of the engine contract: a function cannot cross the bridge.
+ */
+declare function setAuthorityPhysicsCore(load: (() => Promise<PredictCore>) | null): void;
+/**
+ * Start joining the game's authority room and return its handle at once. The outcome arrives as a
+ * `joined` or a terminal `joinFailed` event (`code` is the JoinError: 402, 424, 429, 426, 503 after
+ * the capacity retries, 403; 0 = local, e.g. no authority URL). Throws only for malformed options.
+ */
+declare function openAuthority(optsJson: string): number;
+/**
+ * Set the input `frame()` sends on each fixed step: a JSON object of any of `moveX`, `moveY`,
+ * `moveZ`, `yaw`, `pitch` (finite numbers) and `buttons` (a bitmask). Fields you leave out keep
+ * their value; other keys and non-number values are ignored. `false` without a live seat; throws
+ * only for malformed JSON or a non-object.
+ */
+declare function setInput(handle: number, json: string): boolean;
+/**
+ * Predict a projectile you fire (PROTOCOL.md §17.9): call it while staging the input that fires
+ * (after `setInput` sets the fire button, before the `frame()` that sends it). `json` is
+ * `{ kind, x, y, z, vx, vy, vz, g? }`, the launch the room module makes: it is drawn in `frame()`'s
+ * entities at once, under the id answered here (`<seat>.<seq>.<n>`), which the server's projectile
+ * keeps. A non-finite or non-number coordinate is 0, a non-string `kind` is `''`, and a `g` that is
+ * not a finite number is left out (0). `''` without a live seat or while it reconnects (no
+ * prediction while the socket is down); throws only for malformed JSON or a non-object.
+ */
+declare function predictProjectile(handle: number, json: string): string;
+/**
+ * The `firstperson` or `vehicle` collision world (PROTOCOL.md §17.7): the `{ boxes, ramps }` JSON the room module
+ * exports. Your own entity is predicted only while its hash equals the room's `params.world`
+ * (`authorityJson().prediction` says whether and why not). Call it any time after `openAuthority`,
+ * before the seat lands too: it is applied when the session joins. `false`, with a `warning` event
+ * naming the bad value, for a world §17.7 refuses (the previous world stays), and for an unknown or
+ * closed handle; throws only for malformed JSON or a non-object.
+ */
+declare function setWorld(handle: number, json: string): boolean;
+/**
+ * Once per render frame: send the inputs now due, advance prediction and interpolation, and answer
+ * `{ tick, sent, connected, me, entities }` as JSON — `me` your own entity, predicted (or `null`),
+ * `entities` every entity as rendered (yours included; each with every AuthorityEntityView field, a
+ * vehicle's `spin` and `fuel` among them, and a physics body's drawn orientation `qx qy qz qw`
+ * with `body` and `sleep`, §17.10). `now` defaults to `performance.now()`;
+ * pass nothing unless you drive time yourself. Never throws.
+ */
+declare function frame(handle: number, now?: number): string;
+/** Numbers per body in {@link bodiesF32}: px py pz qx qy qz qw flags. */
+declare const BODY_F32_STRIDE = 8;
+/** {@link bodiesF32}'s flags: the body is predicted (§17.11), and asleep. */
+declare const BodyF32Flag: {
+    readonly PREDICTED: 1;
+    readonly ASLEEP: 2;
+};
+/**
+ * Bridge version 3 (PROTOCOL.md §17.11): every physics body as this session draws it now, in one
+ * Float32Array, {@link BODY_F32_STRIDE} numbers a body (position, orientation [x, y, z, w], flags:
+ * 1 predicted, 2 asleep) in the order `bodyKeysJson()` names. Call it after `frame()`; an engine
+ * that only moves bodies never parses the frame's body JSON. Empty for an unknown handle. Never throws.
+ */
+declare function bodiesF32(handle: number): Float32Array;
+/** The body keys `bodiesF32()` answers in, as a JSON array; `[]` for an unknown handle. Never throws. */
+declare function bodyKeysJson(handle: number): string;
+/**
+ * The session as JSON: `{ sessionId, connected, closed, tick, queued, players, telemetry,
+ * prediction }` (`prediction`: whether your own entity is predicted, and why not). Never throws; an
+ * unknown handle answers closed with no players.
+ */
+declare function authorityJson(handle: number): string;
+/**
+ * Every event queued since the last call, oldest first, as a JSON array. Never throws; an unknown
+ * handle answers `[]`.
+ */
+declare function drainAuthorityEventsJson(handle: number): string;
+/** Leave with consent: `disconnected` (4000, `"left"`) follows. Idempotent; never reconnects. */
+declare function closeAuthority(handle: number): void;
+/**
+ * `closeAuthority`, then forget the handle and free its queue: the engine dropped its session
+ * object. Afterwards the handle answers as an unknown one. Idempotent.
+ */
+declare function disposeAuthority(handle: number): void;
+
+export { BODY_F32_STRIDE, BodyF32Flag, authorityJson, bodiesF32, bodyKeysJson, closeAuthority, disposeAuthority, drainAuthorityEventsJson, frame, openAuthority, predictProjectile, setAuthorityIdentity, setAuthorityPhysicsCore, setInput, setWorld, version };