1681-engine 0.0.0-stage → 0.5.9

package/dist/types/nav/navGrid.d.ts

@@ -0,0 +1,48 @@
+import { type CollisionGrid } from '../net/movement.js';
+/** A tile coordinate. */
+export interface TilePoint {
+    x: number;
+    y: number;
+}
+/**
+ * The ground a search walks: a width, a height and whether a body may stand on a tile. `walkable` is never asked
+ * about a tile outside the grid, so a game's own test needs no bounds check.
+ */
+export interface NavGrid {
+    readonly width: number;
+    readonly height: number;
+    walkable(tx: number, ty: number): boolean;
+}
+/** What a search may be told beyond the grid, shared by `findPath`, `floodFill` and `straightenPath`. */
+export interface NavOptions {
+    /**
+     * Extra cost of stepping onto a tile, on top of the step itself (1 straight, √2 diagonal). Must not be negative,
+     * or A* stops being exact. `nearWallCost` is one: it keeps a route off the edges of a clearing.
+     */
+    cost?: (tx: number, ty: number) => number;
+    /**
+     * Tiles a path may end on but never pass through or brush past diagonally: a door that throws a body onto another
+     * map, a trap, a ledge. A start standing on one may still leave it.
+     */
+    endOnly?: (tx: number, ty: number) => boolean;
+}
+/** A grid over any walkability test. */
+export declare function navGrid(width: number, height: number, walkable: (tx: number, ty: number) => boolean): NavGrid;
+/** The engine's own collision grid as ground to search: a tile a body cannot stand on is a wall. */
+export declare function navGridFromCollision(grid: CollisionGrid): NavGrid;
+/** Inside the grid and walkable. */
+export declare function isOpen(g: NavGrid, tx: number, ty: number): boolean;
+/**
+ * A `cost` that charges `extra` for a tile with a wall beside it (four-way), so a route prefers the middle of a
+ * clearing to the gap between two obstacles — the narrow way is where an auto-walking body wedges itself. 1.4 was
+ * high enough to go round a thicket and low enough to still take a gate.
+ */
+export declare function nearWallCost(g: NavGrid, extra?: number): (tx: number, ty: number) => number;
+/** Eight-way steps; the diagonals cost √2 so a path does not zig-zag where a straight line would do. */
+export declare const NAV_STEPS: readonly (readonly [number, number, number])[];
+/**
+ * May a body step from (cx, cy) by (dx, dy)? The tile must be open and, when it is end-only, be the goal; a diagonal
+ * may not cut the corner between two walls, nor brush an end-only tile on the way past.
+ */
+export declare function canStep(g: NavGrid, cx: number, cy: number, dx: number, dy: number, endOnly: ((tx: number, ty: number) => boolean) | undefined, isGoal: (tx: number, ty: number) => boolean): boolean;
+//# sourceMappingURL=navGrid.d.ts.map

package/dist/types/nav/navGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navGrid.d.ts","sourceRoot":"","sources":["../../../src/nav/navGrid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAElE,yBAAyB;AACzB,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3C;AAED,yGAAyG;AACzG,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;CAC/C;AAED,wCAAwC;AACxC,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAE7G;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAEjE;AAED,oCAAoC;AACpC,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAElE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,SAAM,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAExF;AAED,wGAAwG;AACxG,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EASnE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,OAAO,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,EAC1D,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,GAC1C,OAAO,CAUT"}

package/dist/types/nav/nearestOpen.d.ts

@@ -0,0 +1,8 @@
+import { type NavGrid, type TilePoint } from './navGrid.js';
+/**
+ * The open tile nearest to (tx, ty) within `maxRadius` rings, or null: a start or a goal inside a rock still gets a
+ * route. `ok` narrows what counts (an open tile that is not a door, say). On each ring the closest tile wins, not
+ * the first scanned — scanning order once always picked the ring's top-left corner.
+ */
+export declare function nearestOpen(g: NavGrid, tx: number, ty: number, maxRadius?: number, ok?: (x: number, y: number) => boolean): TilePoint | null;
+//# sourceMappingURL=nearestOpen.d.ts.map

package/dist/types/nav/nearestOpen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearestOpen.d.ts","sourceRoot":"","sources":["../../../src/nav/nearestOpen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,OAAO,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,SAAK,EACd,EAAE,GAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAmC,GAChE,SAAS,GAAG,IAAI,CAiBlB"}

package/dist/types/nav/straightenPath.d.ts

@@ -0,0 +1,13 @@
+import { type NavGrid, type NavOptions, type TilePoint } from './navGrid.js';
+/**
+ * The same route with fewer turns. An eight-way search finds many equally short paths and hands back whichever its
+ * heap settled on, often a staircase — diagonal, straight, diagonal, straight — and a body walking one turns on every
+ * tile. Each stretch that can be is replaced with the plainest equal way through it: one diagonal run and one straight
+ * run. A replacement must cost no more than the stretch did (by the same `cost`, so it never trades the middle of a
+ * clearing for the edge of a wall), step only where the search could, and touch no end-only tile short of the end.
+ * Pass the options the path was found with.
+ */
+export declare function straightenPath(g: NavGrid, path: readonly TilePoint[], options?: NavOptions): TilePoint[];
+/** Drops the tiles a straight line already covers, so a trail is drawn as a few long legs rather than tile by tile. */
+export declare function simplifyPath(path: readonly TilePoint[]): TilePoint[];
+//# sourceMappingURL=straightenPath.d.ts.map

package/dist/types/nav/straightenPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"straightenPath.d.ts","sourceRoot":"","sources":["../../../src/nav/straightenPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAKnF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,SAAS,EAAE,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,EAAE,CA6B5G;AAuCD,uHAAuH;AACvH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAWpE"}

package/dist/types/net/Connection.d.ts

@@ -0,0 +1,88 @@
+import { EventBus } from '../events/EventBus.js';
+import type { InputStep } from './constants.js';
+import type { ClientMessage, ServerMessage, Snapshot } from './protocol.js';
+/** The close code `Connection` reports when it gave up on a socket that did not answer after a resume. */
+export declare const CLOSE_NO_ANSWER = 4408;
+export interface ConnectionEvents {
+    open: undefined;
+    /** The socket closed; `willRetry` when it will reconnect by itself. */
+    close: {
+        code: number;
+        reason: string;
+        willRetry: boolean;
+    };
+    welcome: Extract<ServerMessage, {
+        t: 'welcome';
+    }>;
+    snapshot: Snapshot;
+    /** Any message the engine does not handle: the game's own. */
+    message: {
+        t: string;
+        [k: string]: unknown;
+    };
+}
+export interface ConnectionOptions {
+    /** Reconnect after the socket drops (default true), waiting longer each time up to `maxBackoffMs`. */
+    reconnect?: boolean;
+    maxBackoffMs?: number;
+    /** Ping interval for the server clock and the round-trip time (default 1000 ms). */
+    pingMs?: number;
+    /** Sent on every (re)connect as `hello.data`. */
+    hello?: () => unknown;
+    /** The WebSocket class (default the global one; Node 22+ and browsers have it). */
+    WebSocket?: typeof WebSocket;
+    /**
+     * Close codes after which it must not reconnect (default none): the server's "kicked", "banned", "update required"…
+     * The close event then says `willRetry: false`.
+     */
+    fatalCloseCodes?: readonly number[];
+    /**
+     * After the app returns from the background, ping and give the server this long to answer (default 0: off). A phone
+     * that froze the tab can come back to a socket that still says it is open and is dead; with no pong in time the
+     * socket is dropped (close code `CLOSE_NO_ANSWER`) and reconnected as after any drop.
+     */
+    resumeProbeMs?: number;
+    /** How the probe hears of a resume (default `onAppResume`); returns the unsubscribe. */
+    onResume?: (cb: () => void) => () => void;
+}
+/**
+ * The client side of the engine's netcode over a WebSocket: hello on open, input steps batched and sent once a frame
+ * (`queueInput` then `flush`), snapshots decoded (binary or JSON) onto `events`, pings that keep the server clock
+ * (`serverNow`) and `rtt` up to date, and reconnection with backoff.
+ */
+export declare class Connection {
+    readonly url: string;
+    private readonly options;
+    readonly events: EventBus<ConnectionEvents>;
+    /** The last measured round trip, ms. */
+    rtt: number;
+    private socket;
+    private batch;
+    private closedByUs;
+    private attempt;
+    private pingTimer;
+    private retryTimer;
+    private probeTimer;
+    private stopResume;
+    constructor(url: string, options?: ConnectionOptions);
+    get open(): boolean;
+    connect(): this;
+    /** Sends a message now (dropped while closed: input is resent by the prediction's own state, not by the socket). */
+    send(msg: ClientMessage | {
+        t: string;
+        [k: string]: unknown;
+    }): void;
+    /** Adds one input step to this frame's batch; `flush` sends it. Steps must come in sequence order. */
+    queueInput(seq: number, step: InputStep): void;
+    /** Sends this frame's input steps as one message. Call once a frame. */
+    flush(): void;
+    close(): void;
+    /** The socket is gone (closed, or given up on): report it and reconnect unless told not to. */
+    private closed;
+    /** Back from the background: a pong within `resumeProbeMs` proves the socket alive, none drops it. */
+    private probe;
+    private clearProbe;
+    private ping;
+    private receive;
+}
+//# sourceMappingURL=Connection.d.ts.map

package/dist/types/net/Connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Connection.d.ts","sourceRoot":"","sources":["../../../src/net/Connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGzE,0GAA0G;AAC1G,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,uEAAuE;IACvE,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5D,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE;QAAE,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;IAClD,QAAQ,EAAE,QAAQ,CAAC;IACnB,8DAA8D;IAC9D,OAAO,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;CAC9C;AAED,MAAM,WAAW,iBAAiB;IAChC,sGAAsG;IACtG,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC;IACtB,mFAAmF;IACnF,SAAS,CAAC,EAAE,OAAO,SAAS,CAAC;IAC7B;;;OAGG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CAC3C;AAED;;;;GAIG;AACH,qBAAa,UAAU;IAcnB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAd1B,QAAQ,CAAC,MAAM,6BAAoC;IACnD,wCAAwC;IACxC,GAAG,SAAK;IACR,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,KAAK,CAAoD;IACjE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,UAAU,CAA6B;gBAGpC,GAAG,EAAE,MAAM,EACH,OAAO,GAAE,iBAAsB;IAGlD,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,OAAO,IAAI,IAAI;IAyBf,oHAAoH;IACpH,IAAI,CAAC,GAAG,EAAE,aAAa,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI;IAIpE,sGAAsG;IACtG,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAK9C,wEAAwE;IACxE,KAAK,IAAI,IAAI;IAMb,KAAK,IAAI,IAAI;IAWb,+FAA+F;IAC/F,OAAO,CAAC,MAAM;IAUd,sGAAsG;IACtG,OAAO,CAAC,KAAK;IAkBb,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,OAAO;CA0BhB"}

package/dist/types/net/InterpolationBuffer.d.ts

@@ -0,0 +1,36 @@
+import type { EntityUpdate } from './constants.js';
+export interface InterpolatedState {
+    x: number;
+    y: number;
+    aim: number;
+    /** Discrete fields come from the older of the two samples until the newer one is reached. */
+    anim: number;
+    hp: number;
+    flags: number;
+}
+/**
+ * Smooth motion for bodies the server moves (other players, monsters): snapshots arrive 10–30 times a second and
+ * jittered, so each body is drawn a little in the past (`delayMs`) between the two snapshots around that moment.
+ * Past the newest snapshot it extrapolates for at most `maxExtrapolateMs`, then holds.
+ *
+ * Times are server times (`Snapshot.time`); render at `serverNow()`.
+ */
+export declare class InterpolationBuffer {
+    /** How far in the past bodies are drawn (default 100 ms: two snapshots at 20 Hz, so one may be late). */
+    readonly delayMs: number;
+    private readonly maxExtrapolateMs;
+    private readonly keep;
+    private readonly samples;
+    constructor(
+    /** How far in the past bodies are drawn (default 100 ms: two snapshots at 20 Hz, so one may be late). */
+    delayMs?: number, maxExtrapolateMs?: number, keep?: number);
+    /** Records every body of a snapshot taken at `time`. */
+    push(time: number, updates: readonly EntityUpdate[]): void;
+    /** Forgets a body (it left view). */
+    remove(id: number): void;
+    has(id: number): boolean;
+    ids(): IterableIterator<number>;
+    /** Where body `id` should be drawn at server time `now`, or null if nothing is known of it. */
+    sample(id: number, now: number): InterpolatedState | null;
+}
+//# sourceMappingURL=InterpolationBuffer.d.ts.map

package/dist/types/net/InterpolationBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InterpolationBuffer.d.ts","sourceRoot":"","sources":["../../../src/net/InterpolationBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAahD,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAI5B,yGAAyG;IACzG,QAAQ,CAAC,OAAO;IAChB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI;IANvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;;IAGrD,yGAAyG;IAChG,OAAO,SAAM,EACL,gBAAgB,SAAM,EACtB,IAAI,SAAK;IAG5B,wDAAwD;IACxD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI;IAe1D,qCAAqC;IACrC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,GAAG,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAI/B,+FAA+F;IAC/F,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;CAqB1D"}

package/dist/types/net/PredictedMover.d.ts

@@ -0,0 +1,43 @@
+import type { InputStep, MovementParams } from './constants.js';
+import { type CollisionGrid, type MoverState } from './movement.js';
+import { type MoverWire } from './protocol.js';
+/**
+ * Client-side prediction for the local player's body. Every input step is applied at once (the player sees their
+ * own move with no lag) and kept until the server acknowledges it. When a snapshot says where the server has the
+ * body as of step `ack`, the body is put there and every step after `ack` is replayed on top.
+ *
+ * Movement is deterministic (`stepMover`), so with the same steps, params and grid the replay lands exactly where
+ * the prediction was and nothing moves. When it does not (the server refused a step, a collision only it knew of),
+ * the difference is `correction`: draw the body at `drawX/drawY`, which ease that jump out over a few frames instead
+ * of snapping.
+ */
+export declare class PredictedMover {
+    private params;
+    private grid;
+    readonly mover: MoverState;
+    private pending;
+    private nextSeq;
+    /** The jump the last reconciliation made, still being eased out (world px). */
+    private offsetX;
+    private offsetY;
+    /** How big the last correction was (0 when the prediction was right). */
+    correction: number;
+    /** Share of a visual correction left after each 60th of a second (default 0.8). */
+    smoothing: number;
+    constructor(x: number, y: number, params: MovementParams, grid: CollisionGrid);
+    /** Applies one input step now and keeps it for replay; returns its sequence number (send it with the step). */
+    step(step: InputStep): number;
+    /** Steps sent but not yet acknowledged. */
+    get unacknowledged(): number;
+    /** The server's word: the body as of step `ack`. Rewinds there and replays the rest. */
+    reconcile(ack: number, server: MoverWire): void;
+    /** Eases the visual correction out; call once a frame with its length in seconds. */
+    smooth(dt: number): void;
+    /** Where to draw the body: the predicted place plus the correction still being eased out. */
+    get drawX(): number;
+    get drawY(): number;
+    /** New movement rules (a buff, a slow): applied to future steps and to replays. */
+    setParams(params: MovementParams): void;
+    setGrid(grid: CollisionGrid): void;
+}
+//# sourceMappingURL=PredictedMover.d.ts.map

package/dist/types/net/PredictedMover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PredictedMover.d.ts","sourceRoot":"","sources":["../../../src/net/PredictedMover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAA0B,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;;;;;GASG;AACH,qBAAa,cAAc;IAevB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,IAAI;IAfd,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,OAAO,CAAK;IACpB,+EAA+E;IAC/E,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;IACpB,yEAAyE;IACzE,UAAU,SAAK;IACf,mFAAmF;IACnF,SAAS,SAAO;gBAGd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACD,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,aAAa;IAK7B,+GAA+G;IAC/G,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAO7B,2CAA2C;IAC3C,IAAI,cAAc,IAAI,MAAM,CAE3B;IAED,wFAAwF;IACxF,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI;IAoB/C,qFAAqF;IACrF,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQxB,6FAA6F;IAC7F,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,mFAAmF;IACnF,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIvC,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;CAGnC"}

package/dist/types/net/Room.d.ts

@@ -0,0 +1,69 @@
+import type { InputStep, MovementParams } from './constants.js';
+import { type CollisionGrid, type MoverState } from './movement.js';
+import { type Snapshot } from './protocol.js';
+export interface RoomPlayer<D = unknown> {
+    readonly id: number;
+    readonly mover: MoverState;
+    /** The game's own data for this player (sent to others in `sp` when they first see it). */
+    data: D;
+    params: MovementParams;
+    /** The last input step applied (-1 before any): what snapshots acknowledge. */
+    ack: number;
+    /** Steps received and not yet applied. */
+    readonly queue: InputStep[];
+    /** What the snapshot's update record carries beside the position; the game sets them. */
+    aim: number;
+    anim: number;
+    hp: number;
+    flags: number;
+    /** Refused inputs (nonsense numbers, a flood): a game may kick past some count. */
+    strikes: number;
+}
+export interface RoomOptions<D> {
+    grid: CollisionGrid;
+    /** Movement rules a new player starts with. */
+    params: MovementParams;
+    /** Where a player who joins stands. */
+    spawn: (id: number, data: D) => {
+        x: number;
+        y: number;
+    };
+    /** Steps a player may have waiting before more are refused (default 30: half a second at 60). */
+    maxQueue?: number;
+    /** A player with more than `backlog` waiting catches up by running up to `maxStepsPerTick` a tick (default 3, 4). */
+    maxStepsPerTick?: number;
+    backlog?: number;
+    /** Called after each step a player takes (set aim, anim, flags from it). */
+    onStep?: (player: RoomPlayer<D>, step: InputStep) => void;
+}
+/**
+ * An authoritative room for a server: players send input steps, the room applies them with the same `stepMover` the
+ * clients predict with, and builds each player a snapshot of everyone (with their own body whole, so their
+ * prediction can rewind to it). Transport-free: wire `input`, `step` and `snapshotFor` to any socket library.
+ *
+ * Every step a player sends is applied once, in order; a client cannot move faster by sending more (the queue is
+ * capped and drained at most `maxStepsPerTick` a tick), and nonsense input is refused and counted.
+ */
+export declare class Room<D = unknown> {
+    private readonly options;
+    readonly players: Map<number, RoomPlayer<D>>;
+    tick: number;
+    private readonly known;
+    private readonly maxQueue;
+    private readonly maxSteps;
+    private readonly backlog;
+    constructor(options: RoomOptions<D>);
+    join(id: number, data: D): RoomPlayer<D>;
+    leave(id: number): void;
+    /**
+     * Input steps `seq`, `seq + 1`, … from a player. Steps already received are skipped (a resend), any step with
+     * numbers no client sends refuses the whole message, and steps past a full queue are dropped. Returns false when
+     * something was refused.
+     */
+    input(id: number, seq: number, steps: readonly InputStep[]): boolean;
+    /** One simulation step for everyone. */
+    step(): void;
+    /** The snapshot player `id` should get now. `time` is the server's wall clock (ms). */
+    snapshotFor(id: number, time: number): Snapshot | null;
+}
+//# sourceMappingURL=Room.d.ts.map

package/dist/types/net/Room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Room.d.ts","sourceRoot":"","sources":["../../../src/net/Room.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAA0B,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,2FAA2F;IAC3F,IAAI,EAAE,CAAC,CAAC;IACR,MAAM,EAAE,cAAc,CAAC;IACvB,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAC;IACZ,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;IAC5B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,IAAI,EAAE,aAAa,CAAC;IACpB,+CAA+C;IAC/C,MAAM,EAAE,cAAc,CAAC;IACvB,uCAAuC;IACvC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,iGAAiG;IACjG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qHAAqH;IACrH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CAC3D;AAED;;;;;;;GAOG;AACH,qBAAa,IAAI,CAAC,CAAC,GAAG,OAAO;IAQf,OAAO,CAAC,QAAQ,CAAC,OAAO;IAPpC,QAAQ,CAAC,OAAO,6BAAoC;IACpD,IAAI,SAAK;IACT,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAEJ,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;IAMpD,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAqBxC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO;IAkCpE,wCAAwC;IACxC,IAAI,IAAI,IAAI;IAeZ,uFAAuF;IACvF,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;CA2BvD"}

package/dist/types/net/RoomHost.d.ts

@@ -0,0 +1,74 @@
+import type { Room } from './Room.js';
+import type { ServerMessage } from './protocol.js';
+/** The least a server socket must do; a `ws` WebSocket, a uWebSockets one or a test double all fit. */
+export interface HostSocket {
+    send(data: string | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+}
+export interface RoomHostOptions<D> {
+    /** Simulation steps a second (default 60) and snapshots a second (default 20). */
+    stepRate?: number;
+    snapRate?: number;
+    /** Turns a hello's data into the player's data (validate it here); throw to refuse the player. */
+    admit?: (data: unknown, id: number) => D;
+    /** Refused inputs before the player is disconnected (default 20). */
+    maxStrikes?: number;
+    /** The game's own messages (anything the engine does not handle). */
+    onMessage?: (id: number, msg: {
+        t: string;
+        [k: string]: unknown;
+    }) => void;
+    /** Called when a player joins or leaves. */
+    onJoin?: (id: number) => void;
+    onLeave?: (id: number) => void;
+    /** Wall clock, for tests (default Date.now). */
+    now?: () => number;
+}
+/**
+ * Runs a `Room` for connected sockets: a socket says hello and joins, its input goes to the room, the room steps at
+ * `stepRate`, and every player gets its own snapshot at `snapRate` (binary when it carries bodies). Pings are
+ * answered with the server's time. A player who keeps sending nonsense is disconnected.
+ *
+ * ```ts
+ * const host = new RoomHost(room);
+ * wss.on('connection', (ws) => {
+ *   const id = host.connect(ws);
+ *   ws.on('message', (data, binary) => host.message(id, binary ? data : data.toString()));
+ *   ws.on('close', () => host.disconnect(id));
+ * });
+ * host.start();
+ * ```
+ */
+export declare class RoomHost<D = unknown> {
+    readonly room: Room<D>;
+    private readonly options;
+    private readonly sockets;
+    private readonly joined;
+    private nextId;
+    private stepTimer;
+    private lastStepAt;
+    private stepsDue;
+    private readonly stepMs;
+    private readonly snapEvery;
+    private readonly now;
+    constructor(room: Room<D>, options?: RoomHostOptions<D>);
+    /** A socket connected; returns the id its messages and its close are reported under. */
+    connect(socket: HostSocket): number;
+    /** A message arrived from socket `id` (text as a string, binary as bytes). */
+    message(id: number, data: string | ArrayBuffer | Uint8Array): void;
+    /** Socket `id` closed. */
+    disconnect(id: number): void;
+    /** Sends one of the game's own messages to a player. */
+    sendTo(id: number, msg: ServerMessage | {
+        t: string;
+        [k: string]: unknown;
+    }): void;
+    /** Starts stepping on a timer. Steps are counted by the clock, so a late timer runs the steps it owes. */
+    start(): void;
+    stop(): void;
+    /** One step, and the snapshots when they are due. Exposed for tests and for servers that drive their own loop. */
+    stepOnce(): void;
+    private strike;
+    private checkStrikes;
+}
+//# sourceMappingURL=RoomHost.d.ts.map

package/dist/types/net/RoomHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoomHost.d.ts","sourceRoot":"","sources":["../../../src/net/RoomHost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAiB,aAAa,EAAY,MAAM,YAAY,CAAC;AAEzE,uGAAuG;AACvG,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IACtC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7C;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kGAAkG;IAClG,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,KAAK,CAAC,CAAC;IACzC,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3E,4CAA4C;IAC5C,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,QAAQ,CAAC,CAAC,GAAG,OAAO;IAY7B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAGxB,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACL,OAAO,GAAE,eAAe,CAAC,CAAC,CAAM;IAOnD,wFAAwF;IACxF,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAMnC,8EAA8E;IAC9E,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,IAAI;IAyClE,0BAA0B;IAC1B,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ5B,wDAAwD;IACxD,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI;IAOlF,0GAA0G;IAC1G,KAAK,IAAI,IAAI;IAgBb,IAAI,IAAI,IAAI;IAKZ,kHAAkH;IAClH,QAAQ,IAAI,IAAI;IAUhB,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,YAAY;CAOrB"}

package/dist/types/net/cadence.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Every repeated player action with a timer — the basic attack, a skill's cooldown, the cast and attack locks, a
+ * potion — runs on a **schedule**, not on "the last time plus some slack". An action may arrive up to its slack
+ * early (network jitter bunches packets), but the next one is then due a whole interval after the later of the
+ * arrival and the time this one was due, so the slack never adds up: a client sending every 0.8 of an interval
+ * lands at most one per interval (67 in 100), not 100. A server must run the same arithmetic.
+ */
+export declare const CADENCE: {
+    /** A basic attack may arrive this share of its interval early. */
+    readonly attackEarlyShare: 0.2;
+    /** The cast lock and the attack lock a cast leaves may be cut this short. */
+    readonly lockSlackMs: 60;
+    /** A skill may be cast this long before its cooldown ends. */
+    readonly cooldownSlackMs: 40;
+    /** A potion may be drunk this long before its kind's cooldown ends. */
+    readonly potionSlackMs: 150;
+};
+/** Whether an action arriving at `now` is earlier than its slack allows; `due` undefined = never taken, due at once. */
+export declare function cadenceEarly(now: number, due: number | undefined, slack: number): boolean;
+/** When the action after one accepted at `now` is due: a whole interval after the later of `now` and `due`. */
+export declare function cadenceNext(now: number, due: number | undefined, interval: number): number;
+//# sourceMappingURL=cadence.d.ts.map

package/dist/types/net/cadence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cadence.d.ts","sourceRoot":"","sources":["../../../src/net/cadence.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;IAClB,kEAAkE;;IAElE,6EAA6E;;IAE7E,8DAA8D;;IAE9D,uEAAuE;;CAE/D,CAAC;AAEX,wHAAwH;AACxH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEzF;AAED,+GAA+G;AAC/G,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1F"}

package/dist/types/net/constants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The movement defaults. Every one of them can be changed without forking: the tile size and the body's half extents
+ * are fields of the `CollisionGrid` (`createCollisionGrid`'s `tileSize` and options), the dash bit and the step length
+ * are optional fields of `MovementParams`. Client and server must agree on whichever numbers a game picks.
+ */
+/** The default tile size, px; a grid carries its own (`CollisionGrid.tileSize`). */
+export declare const TILE_SIZE = 16;
+/** The default fixed input steps a second (`MovementParams.stepDt` overrides the step's length). */
+export declare const INPUT_STEP_RATE = 60;
+export declare const INPUT_STEP_DT: number;
+/** The default bit of an input step's flags that asks for a dash (`MovementParams.dashFlag` overrides it). */
+export declare const INPUT_FLAG_DASH = 1;
+/** The default collision box, half extents (px); `createCollisionGrid`'s `bodyHalfWidth`/`bodyHalfHeight` override them. */
+export declare const BODY_HALF_WIDTH = 5;
+export declare const BODY_HALF_HEIGHT = 3;
+export declare const COLLISION_EPSILON = 0.01;
+/** One fixed input step: [axisX, axisY, flags]. */
+export type InputStep = [number, number, number];
+export interface MovementParams {
+    speed: number;
+    dashSpeed: number;
+    dashSteps: number;
+    dashCooldownSteps: number;
+    canMove: boolean;
+    canDash: boolean;
+    /** The bit of an input step's flags that starts a dash (default `INPUT_FLAG_DASH`). */
+    dashFlag?: number;
+    /** Seconds one input step lasts (default `INPUT_STEP_DT`); speeds are px a second. */
+    stepDt?: number;
+}
+/** One body's state in a snapshot: [id, x, y, aim, anim, hp, flags]. */
+export type EntityUpdate = [number, number, number, number, number, number, number];
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/net/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/net/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oFAAoF;AACpF,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,oGAAoG;AACpG,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,aAAa,QAAsB,CAAC;AAEjD,8GAA8G;AAC9G,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,4HAA4H;AAC5H,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEjD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wEAAwE;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC"}

package/dist/types/net/lobby/LobbyClient.d.ts

@@ -0,0 +1,107 @@
+import { EventBus } from '../../events/EventBus.js';
+import type { LobbyClientMessage, LobbyErrorCode, MatchPlayer, RoomState, RoomSummary } from './lobbyProtocol.js';
+/** What a `LobbyClient` sends through and hears from: a `Connection` fits. */
+export interface LobbyLink {
+    send(msg: {
+        t: string;
+        [k: string]: unknown;
+    }): void;
+    readonly events: {
+        on(event: 'message', fn: (msg: {
+            t: string;
+            [k: string]: unknown;
+        }) => void): () => void;
+    };
+}
+export interface PendingMatch {
+    id: string;
+    mode: string;
+    players: MatchPlayer[];
+    expiresAt: number;
+    accepted: number[];
+    /** You answered already. */
+    answered: boolean;
+}
+export interface LobbyClientEvents {
+    /** Anything in the client's state changed: redraw the lobby screen. */
+    change: undefined;
+    chat: {
+        from: number;
+        text: string;
+    };
+    error: {
+        code: LobbyErrorCode;
+        message: string;
+    };
+    kicked: undefined;
+    found: PendingMatch;
+    cancelled: {
+        match: string;
+        reason: 'declined' | 'timeout' | 'left';
+        requeued: boolean;
+    };
+    /** Go and play: `data` is what the server's `onStart` gave you. */
+    start: {
+        match: string;
+        mode: string;
+        players: MatchPlayer[];
+        data: unknown;
+    };
+}
+/**
+ * The lobby as a client sees it: the room list, your room, your place in the queue and a match waiting for your
+ * answer, kept up to date from the server's messages, with a method for everything a lobby screen does. Hand it the
+ * game's `Connection` (or anything that sends JSON and emits the messages it does not handle):
+ *
+ * ```ts
+ * const conn = new Connection('wss://lobby.example.com', { hello: () => ({ name }) }).connect();
+ * const lobby = new LobbyClient(conn);
+ * lobby.events.on('change', () => drawLobby(lobby));
+ * lobby.events.on('start', ({ data }) => joinGame(data));
+ * lobby.queue('duel');
+ * ```
+ */
+export declare class LobbyClient {
+    private readonly link;
+    readonly events: EventBus<LobbyClientEvents>;
+    /** Your id in the lobby (-1 until welcomed). */
+    id: number;
+    modes: string[];
+    rooms: RoomSummary[];
+    room: RoomState | null;
+    /** Your queue: the mode, since when (server ms) and how many other groups wait for it. */
+    queued: {
+        mode: string;
+        since: number;
+        waiting: number;
+    } | null;
+    /** Kept out of the queue until then (server ms), after a declined match. */
+    lockedUntil: number;
+    match: PendingMatch | null;
+    private readonly off;
+    constructor(link: LobbyLink);
+    get isHost(): boolean;
+    /** Every member of your room but the host has said ready. */
+    get roomReady(): boolean;
+    list(): void;
+    create(options?: Omit<Extract<LobbyClientMessage, {
+        t: 'lobby/create';
+    }>, 't'>): void;
+    join(room: string): void;
+    joinByCode(code: string): void;
+    leave(): void;
+    setReady(ready: boolean): void;
+    kick(player: number): void;
+    promote(player: number): void;
+    setSettings(settings: unknown): void;
+    chat(text: string): void;
+    startRoom(): void;
+    queue(mode: string): void;
+    leaveQueue(): void;
+    accept(): void;
+    decline(): void;
+    destroy(): void;
+    private send;
+    private receive;
+}
+//# sourceMappingURL=LobbyClient.d.ts.map

package/dist/types/net/lobby/LobbyClient.d.ts.map

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