tickcli-js 0.0.0-stage → 0.1.1

package/dist/hub.d.ts

@@ -0,0 +1,619 @@
+export declare const PROTOCOL = 1;
+/** Close codes (also in docs/security.md). 1012 = restart. */
+export declare const CLOSE: {
+    readonly restart: 1012;
+    readonly roomError: 1011;
+    readonly busy: 1013;
+    readonly silent: 4009;
+    readonly notAllowed: 4001;
+    readonly full: 4002;
+    readonly replaced: 4003;
+    readonly tooFast: 4004;
+    readonly badMessage: 4005;
+    readonly removed: 4006;
+    readonly gameUpdated: 4007;
+    readonly tooSlow: 4008;
+    readonly idle: 4010;
+};
+export interface Limits {
+    maxPlayers: number;
+    maxRooms: number;
+    maxRoomsPerScope: number;
+    maxConnections: number;
+    maxPending: number;
+    maxPerAddress: number;
+    joinsPerMinute: number;
+    messageBytes: number;
+    playerStateBytes: number;
+    sharedStateBytes: number;
+    stateRate: number;
+    sharedRate: number;
+    actionRate: number;
+    timeRate: number;
+    pendingMs: number;
+    seatHoldMs: number;
+    evictAfterMs: number;
+    awayHoldMs: number;
+    hostSilenceMs: number;
+    roomOutBytes: number;
+    maxOutMbit: number;
+    silentMs: number;
+    acceptRate: number;
+    actionTimeoutMs: number;
+    slowBytes: number;
+    dropBytes: number;
+    rateBytes: number;
+    rateUpMs: number;
+    listRate: number;
+    idleMs: number;
+    idleWarnMs: number;
+    listIdleMs: number;
+    tickMs: number;
+    profileBytes: number;
+    profileEveryMs: number;
+    worldEveryMs: number;
+    saveDays: number;
+}
+export declare const DEFAULT_LIMITS: Limits;
+/** One open socket, as the hub sees it. */
+export interface Conn {
+    send(data: string): void;
+    close(code: number, reason: string): void;
+    /** bytes queued and not yet written to the network */
+    buffered(): number;
+}
+/**
+ * Where saves live; the host app supplies it. `who` is a seat key ("u:<user id>") for a person's profile, null for a game's shared world save (rooms
+ * played together), "alone:<seat key>" for one person's own world save (Play alone: a room of one keeps its own game, so playing together never
+ * touches it). `slot` is the app's stable key for the game. store(..., null) deletes. Keep a world at least `saveDays` (90).
+ */
+export interface SavePort {
+    /** null = nothing saved. Reject only when the save could not be read (the hub then writes nothing over it and tries again later). */
+    load(scope: string, slot: string, who: string | null): Promise<{
+        at: number;
+        data: unknown;
+        v?: number;
+    } | null>;
+    /** meta.session: one id per room session for world saves, so a store that keeps an earlier copy can take it once per session. meta.v: the game's
+     *  save format number (multiplayer.saveVersion), kept with the data and given back by load (a file without it counts as 1). */
+    store(scope: string, slot: string, who: string | null, data: unknown | null, meta?: {
+        session?: string;
+        v?: number;
+    }): Promise<void>;
+}
+/** Who a connection is, decided by the server (ticket or guest pass), never by the page. */
+export interface Who {
+    /** stable seat key: "u:<user id>" or "g:<guest pass id>" */
+    seat: string;
+    name: string;
+    guest: boolean;
+}
+/** The page's declaration: room size and the number range of each player field. */
+/** saveVersion: the game's save format (whole number, default 1); a page edited to read another shape raises it (README: saved games). */
+export interface Spec {
+    max: number;
+    player: Record<string, [number, number]>;
+    save: boolean;
+    saveVersion: number;
+}
+export interface PlayerView {
+    id: string;
+    name: string;
+    online: boolean;
+    hidden: boolean;
+    guest: boolean;
+    state: Record<string, unknown>;
+}
+type Json = null | boolean | number | string | Json[] | {
+    [k: string]: Json;
+};
+/** The shape limits of everything a page writes (also in room.js, which checks before sending, and in the README). */
+export declare const SHAPE: {
+    readonly text: 200;
+    readonly list: 64;
+    readonly keys: 64;
+    readonly depth: 4;
+    readonly key: 40;
+};
+/** Plain JSON within the shape limits: depth, keys, text and list lengths, finite numbers. Returns false for anything else. */
+export declare function plain(v: unknown, depth?: number): v is Json;
+/** Where a value breaks the shape limits: the path of the first bad part ("mobs.12.name", "" for the value itself), or null when it is fine. */
+export declare function badPath(v: unknown, depth?: number, at?: string): string | null;
+/** A checked spec, or null. */
+export declare function parseSpec(raw: unknown, maxPlayers?: number): Spec | null;
+/** Apply a patch to state: objects merge key by key, null removes, anything else (lists too) replaces. Returns a new object; `into` is not changed. */
+export declare function applyPatch(into: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;
+/** The part of a patch that changes `cur`: leaves equal to the current value are left out, a null for a key that is not there too, lists equal by
+ *  their JSON text. Null = nothing changes. So a game may write whole objects every step: only what changed is applied, counted and sent. */
+export declare function changedOnly(cur: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown> | null;
+/** How many bytes the JSON text of `cur` grows by when `patch` (already reduced by changedOnly) is applied: only the changed leaves are measured. */
+export declare function sizeDelta(cur: Record<string, unknown>, patch: Record<string, unknown>): number;
+/** Combine two patches that go out together (nulls kept, so removals still reach the others). */
+export declare function joinPatch(into: Record<string, unknown>, patch: Record<string, unknown>): void;
+declare class Bucket {
+    tokens: number;
+    at: number;
+    rate: number;
+    constructor(rate: number, now: number);
+    take(now: number): boolean;
+}
+interface Seat {
+    key: string;
+    id: string;
+    name: string;
+    guest: boolean;
+    state: Record<string, unknown>;
+    session: Session | null;
+    hidden: boolean;
+    /** the host's game loop stopped reporting (a frozen tab) while its socket stayed open */
+    stalled: boolean;
+    since: number;
+    offlineAt: number;
+    lastAct: number;
+    /** the save format number of the profile as loaded */
+    profV: number;
+    /** restored from a snapshot after a restart: the first welcome says kept (the page carries on in the same match) */
+    kept: boolean;
+    /** the person's saved profile once loaded (null = not loaded, or saving is off) */
+    prof: Record<string, unknown> | null;
+    profLoad: Promise<Record<string, unknown> | null> | null;
+    profDirty: boolean;
+    profAt: number;
+    /** JSON size of state, kept up to date by each write (an exact count near the limit and every 256 writes) */
+    stateBytes: number;
+}
+interface Room {
+    key: string;
+    scope: string;
+    game: string;
+    spec: Spec;
+    specKey: string;
+    code: string;
+    priv: boolean;
+    /** the app's stable key for saves ("" = none) and whether this room keeps a world save */
+    slot: string;
+    /** Play alone: the one seat this room belongs to ("" = a room for anyone). Its world save is that person's own, not the shared one. */
+    owner: string;
+    world: boolean;
+    /** the world save this room holds the lease on ("" = none). One room at a time writes a given save. */
+    lease: string;
+    /** the game keeps a world save, but another room is playing it: this room is not saved */
+    saveBusy: boolean;
+    /** the world save's load: nothing is written (and nothing cleared) until it is "ready"; "failed" retries on a timer (loadAt) */
+    worldState: "off" | "loading" | "ready" | "failed";
+    loadTries: number;
+    loadAt: number;
+    /** a Start that came while the save was still loading: run once it is loaded (Continue / New game is offered first when a save turns up) */
+    startWait: {
+        resume: boolean;
+        at: number;
+    } | null;
+    /** this room's session id for the store (one earlier copy per session) */
+    sid: string;
+    saved: {
+        at: number;
+        data: Record<string, unknown>;
+        v: number;
+    } | null;
+    /** how many shared writes the room had at the last world write; a world save is due when it differs */
+    wrev: number;
+    savedWrev: number;
+    savedAt: number;
+    /** the host cleared the save (the game is won or lost): nothing is written until the next start */
+    noSave: boolean;
+    resumed: boolean;
+    seats: Map<string, Seat>;
+    byId: Map<string, Seat>;
+    banned: Set<string>;
+    match: number;
+    rev: number;
+    term: number;
+    host: Seat | null;
+    hostAliveAt: number;
+    started: boolean;
+    /** a match ended; the next start begins a new one */
+    played: boolean;
+    shared: Record<string, unknown>;
+    pendPlayers: Map<string, Record<string, unknown>>;
+    pendShared: {
+        patch: Record<string, unknown>;
+        term: number;
+    } | null;
+    /** when the pending values were sampled by their senders (shared clock): per player id, and for the shared part */
+    pendPT: Map<string, number>;
+    pendSC: number;
+    pendAt: number;
+    actions: Map<number, {
+        from: Seat;
+        ref: number;
+        at: number;
+    }>;
+    nextAction: number;
+    tickN: number;
+    /** bytes sent to this room's sockets: total, at the last one-second mark, and the rate over the last second */
+    outBytes: number;
+    outMark: number;
+    outRate: number;
+    /** effects waiting for the next frame (g.fx, shots): they go out with the state, in order */
+    /** 0..9: which sub-tick this room sends on, so all rooms do not write their sockets in the same instant */
+    phase: number;
+    /** data budget: the room's moving average of bytes out a second, its send interval multiplier (1, 2, 4, 8) and whether its host was told */
+    outAvg: number;
+    slowF: number;
+    slowTold: boolean;
+    pendFx: {
+        from: string;
+        name: string;
+        data: unknown;
+    }[];
+    pendFxBytes: number;
+    /** when the room was made (room list: newest first among equals) */
+    created: number;
+    /** when a person last did something here (moved, acted, sent an effect, joined, left, started, came back to the page, pressed stay);
+     *  the host's automatic shared writes and the pages' clock pings do not count, so a game left running with nobody at it still ends */
+    activeAt: number;
+    /** the players were told the room closes soon */
+    idleWarned: boolean;
+    /** state frames sent on the tick so far; a reader on rate 1/d gets every d-th one (see Session.div) */
+    flushN: number;
+    /** per slower rate (2, 4): everything since that rate's last frame, merged; null while every reader is on the full rate */
+    tiers: Map<number, Frame> | null;
+    /** JSON size of shared, kept like seat.stateBytes; writes since the last exact count */
+    sharedBytes: number;
+    sizeChecks: number;
+}
+/** A frame's content: changed player fields and their sample times, the shared patch and its sample time, effects. */
+interface Frame {
+    players: Map<string, Record<string, unknown>>;
+    pt: Map<string, number>;
+    shared: {
+        patch: Record<string, unknown>;
+        term: number;
+    } | null;
+    sc: number;
+    fx: {
+        from: string;
+        name: string;
+        data: unknown;
+    }[];
+}
+/** One socket's life in the hub: pending (not yet identified) -> identified -> joined a room -> closed. */
+export declare class Session {
+    who: Who | null;
+    scope: string;
+    game: string;
+    slot: string;
+    room: Room | null;
+    seat: Seat | null;
+    dead: boolean;
+    lagging: boolean;
+    readonly opened: number;
+    state: Bucket;
+    acts: Bucket;
+    /** clock pings: their own small bucket, and a count before sign-in */
+    clock: Bucket;
+    early: number;
+    strikes: number;
+    /** when this socket was last told too_fast */
+    slowAt: number;
+    /** when the last message came in (a visible page sends a clock ping every 5 s) */
+    lastRx: number;
+    /** shared writes: a bucket of their own (room.js sends at most 12.5 a second plus split parts) */
+    sharedB: Bucket;
+    /** Update rate: this reader gets every div-th state frame (1, 2 or 4; effects and changes in between are merged into it, nothing is lost).
+     *  netDiv is the hub's own reading of the socket (its send queue), askDiv what the page asked for (rate {div}: a slow link or device seen by
+     *  the page); the slower of the two is used, taken over only when every rate's frame has just gone out (so nobody misses a change). */
+    div: number;
+    netDiv: number;
+    askDiv: number;
+    /** when netDiv last went down, and since when the send queue has been near empty */
+    downAt: number;
+    clearAt: number;
+    /** the page's round trip to the hub (ms, its own best recent ping, sent along with its clock pings); 0 = not known */
+    rtt: number;
+    /** room-list requests */
+    listB: Bucket;
+    /** what the page understands (join f: ["fxb", ...]): "fxb" = effects inside the delta frame. Pages without it get one fx message per effect. */
+    feats: Set<string>;
+    readonly hub: RoomHub;
+    readonly conn: Conn;
+    readonly addr: string;
+    constructor(hub: RoomHub, conn: Conn, addr: string);
+    /** The server decided who this is (ticket or guest pass) and which namespace and game version they may join. */
+    identify(scope: string, game: string, who: Who, slot?: string): void;
+    receive(text: string): void;
+    /** The socket closed (any reason). */
+    closed(): void;
+    send(m: Record<string, unknown>): void;
+    end(code: number, reason: string): void;
+}
+/** Live numbers (per second over the last second unless named otherwise). No names, no scope ids. */
+export interface LiveStats {
+    framesOut: number;
+    bytesOut: number;
+    msgsIn: number;
+    /** time one sub-tick took (one every 10 ms), over the last 1,200 (about 12 s; ms) */
+    tickMs: {
+        p50: number;
+        p99: number;
+        max: number;
+    };
+    /** sockets behind on their reads now */
+    slow: number;
+    /** rooms with a match in progress */
+    started: number;
+    savesOk: number;
+    savesFailed: number;
+    loadsFailed: number;
+    worldWritesPerMin: number;
+    /** event-loop delay, set by the host process (main.ts) once a minute */
+    loop: {
+        p50: number;
+        p99: number;
+        max: number;
+    } | null;
+    /** over the data cap or a late loop now; rooms slowed by their own budget */
+    pressure: boolean;
+    slowedRooms: number;
+    /** the 5 rooms sending the most */
+    top: {
+        players: number;
+        bytesOut: number;
+        sharedBytes: number;
+    }[];
+}
+/** A restart's hand-over of live rooms (exportRooms / importRooms). The format number changes when the shape does; another format is ignored. */
+export declare const SNAPSHOT_FORMAT = 1;
+export interface SnapRoom {
+    key: string;
+    scope: string;
+    game: string;
+    spec: Spec;
+    code: string;
+    priv: boolean;
+    slot: string;
+    owner: string;
+    world: boolean;
+    lease: string;
+    saveBusy: boolean;
+    worldState: "ready" | "loading";
+    saved: {
+        at: number;
+        data: Record<string, unknown>;
+        v: number;
+    } | null;
+    wrev: number;
+    savedWrev: number;
+    noSave: boolean;
+    resumed: boolean;
+    sid: string;
+    match: number;
+    rev: number;
+    term: number;
+    started: boolean;
+    played: boolean;
+    shared: Record<string, unknown>;
+    banned: string[];
+    seats: {
+        key: string;
+        id: string;
+        name: string;
+        guest: boolean;
+        state: Record<string, unknown>;
+        hidden: boolean;
+        since: number;
+    }[];
+}
+export interface RoomsSnapshot {
+    format: number;
+    at: number;
+    rooms: SnapRoom[];
+}
+export interface HubStats {
+    rooms: number;
+    players: number;
+    online: number;
+    connections: number;
+    pending: number;
+    refused: Record<string, number>;
+    live: LiveStats;
+}
+export declare class RoomHub {
+    readonly limits: Limits;
+    readonly now: () => number;
+    readonly boot: string;
+    private readonly secret;
+    private rooms;
+    private sessions;
+    pending: number;
+    private perAddr;
+    private joins;
+    private refused;
+    private timer;
+    private sub;
+    private acceptAt;
+    private accepted;
+    private houseAt;
+    /** games whose room failed once (logged once each) */
+    private erred;
+    private closing;
+    private readonly saves;
+    private writing;
+    /** the newest write of each save ("scope|slot|who"): a load waits for that one only, not for other rooms' saves */
+    private writingKey;
+    private loading;
+    /** plain counters for stats() (saves_ok, ...) */
+    private counts;
+    /** meters: totals, the totals at the last one-second mark, the per-second rates, tick times, world writes in the last minute */
+    private meter;
+    private mark;
+    private rates;
+    private tickTimes;
+    private tickCount;
+    private worldWrites;
+    /** event-loop delay from the host process (main.ts sets it once a minute) */
+    loop: {
+        p50: number;
+        p99: number;
+        max: number;
+    } | null;
+    /** the same over the last 10 s (main.ts), for the half-rate switch */
+    loopRecent: {
+        p99: number;
+    } | null;
+    /** over the data cap or a late loop: bigger rooms at half rate, no new rooms */
+    pressure: boolean;
+    /** world save leases: "scope|slot|who" -> the room key that may write it */
+    private leases;
+    /** shutdown() hands the live rooms to this (a restart writes them to disk; importRooms() in the next process takes them back) */
+    private readonly onSnapshot;
+    /** the room list (rooms {}) is answered; off: the answer is {off: true} */
+    readonly listRooms: boolean;
+    /** room lists made in the last 250 ms, per namespace, game and save slot (many pages asking at once cost one build) */
+    private lists;
+    /** rooms allowed in one namespace when it differs from limits.maxRoomsPerScope (a host app's per-customer cap, tickcli-js/remote) */
+    private readonly roomsPerScope;
+    constructor(opts: {
+        secret: string;
+        now?: () => number;
+        limits?: Partial<Limits>;
+        saves?: SavePort;
+        onSnapshot?: (snap: RoomsSnapshot) => Promise<void> | void;
+        listRooms?: boolean;
+        roomsPerScope?: (scope: string) => number | undefined;
+    });
+    /** A short public id for a seat in one namespace; the seat key itself (a user id or guest pass id) is never shown to others. */
+    publicId(scope: string, seat: string): string;
+    /** The save slot a socket plays under; without a store there are no slots. */
+    private slotOf;
+    private refuse;
+    private count;
+    /** A new socket. Null = refused (the caller closes it with the code given). */
+    connect(conn: Conn, addr: string): Session | {
+        refused: number;
+        reason: string;
+    };
+    /** Meter: `n` copies of a text of `len` bytes (UTF-8, as on the wire) went out (to one room's sockets when given). */
+    sent(len: number, n: number, room?: Room | null): void;
+    receive(s: Session, text: string): void;
+    private bad;
+    /** Over the rate: the message is dropped; a sender that keeps pushing far past it is disconnected. */
+    private strike;
+    private err;
+    private join;
+    /** A person did something in the room: its idle time starts over (a warning already sent is taken back). */
+    private active;
+    /** Nobody did anything for idleMs: saves are written, every page hears 4010 (game.js offers a new room), the room is gone. */
+    private closeIdle;
+    /** Moves a room running an older version of its game off its code (see join): a new hidden code, private, its save lease kept; its pages hear
+     *  `newer` (game.js: press restart to play the new version). */
+    private retire;
+    private create;
+    private snapshot;
+    /** Host = the longest-connected player who is online and visible. None = the match waits. Every change starts a new term. */
+    private elect;
+    private alive;
+    private vis;
+    private me;
+    private sharedWrite;
+    /** The sender's sample time of a write (its shared clock, whole ms), trusted within 500 ms back and 50 ms ahead; else now. Pages draw others
+     *  at these times, so updates sent 80 ms apart are drawn 80 ms apart whatever the fan-out tick did to them. */
+    private stamp;
+    /** A state size after a write: the running count, or the exact one when it is within 10% of the limit and every 256th time (a drift is counted). */
+    private sized;
+    private fx;
+    private rename;
+    private act;
+    private result;
+    private startMatch;
+    private beginMatch;
+    private endMatch;
+    private kick;
+    private removeSeat;
+    /** Forget a room (its last write is already queued) and give up its save lease. Every path that ends a room goes through here. */
+    private closeRoom;
+    /** A socket is gone. Its seat stays (offline) for seatHoldMs, without host duty. */
+    drop(s: Session): void;
+    private write;
+    /** The person's profile, loaded once per seat. Null = saving is off here, or the store failed (nothing is ever written over a profile that did not load). */
+    private loadProfile;
+    private sendProfile;
+    private saveProfile;
+    private flushProfile;
+    /** Load the room's world save. Until it is loaded nothing is written or cleared (a save that could not be read is never written over); a failed
+     *  load is tried again after 2, 5, 15 s and then every 30 s, and the lobby says the game is not being saved meanwhile. */
+    private loadWorld;
+    private loadFailed;
+    /** Write the shared state as the world save when it changed (every worldEveryMs, or now when forced) and holds something besides the shell's own keys. */
+    private saveWorld;
+    /** {t:"world", clear:true}: the host ends the saved game (won, lost, abandoned); nothing is saved again until the next start. */
+    private worldMsg;
+    private broadcast;
+    /** Send a room's pending changes and effects now. Variants of one frame, each made once: the host does not get its own shared writes back
+     *  (it applied them), pages without "fxb" get effects as single fx messages, an effect never goes back to its sender's old-style page, and hidden
+     *  pages get nothing (one fresh copy when they come back). fxOnly: effects alone (big rooms send state every second tick, effects every tick).
+     *  tick: called by the fan-out tick. Readers on a slower rate (Session.div) get every div-th tick frame, with everything since their last one
+     *  merged in; any other call (a join, a leave, a new host, the start) sends every rate's frame at once, so those events never overtake a change. */
+    private flush;
+    /** The room's pending changes as one frame (null when there is nothing), and the pending lists cleared. */
+    private takePending;
+    /** Readers take their wanted rate (the slower of the hub's reading and the page's ask); the merged frames exist only for rates in use. */
+    private retier;
+    /** One frame to the room's readers on rate 1/div. A room of one gets none: everything in it came from that page (its own moves, its
+     *  own shared writes as host, its own effects), so playing alone costs no data coming down. */
+    private emit;
+    /** The open rooms a page could join instead (rooms {spec?}): same namespace, game version and save slot; not private, not someone's game
+     *  alone, not empty. Per room: code, host name, players connected and away (dropped, seat held), max, started, match, the host's round trip to the hub (ms, 0 = not
+     *  known: the host's browser runs the rules, so its link is what a newcomer feels), slowed (the room sends less often than normal), full,
+     *  yours. Up to 50, the ones you can join first, then those waiting to start, then the fullest, then the newest. Made at most every 250 ms
+     *  per game; asking costs one token of a 1-a-second bucket. */
+    private roomList;
+    /** Every tickMs: send changes (every second tick in rooms over 8), handle slow readers, timeouts, silent hosts, expired seats. */
+    tick(): void;
+    /** A room over its data budget sends half as often (up to 8 times less), its host is told once (error too_much_data); it speeds up again when
+     *  the faster rate would be under 80% of the budget. */
+    private budget;
+    /** How many ticks apart a room sends its state: 1 (50 ms), 2 in rooms over 8 players, times its own budget factor, times 2 under server pressure
+     *  for rooms over 4 players. */
+    private every;
+    /** Once a second: the rates over the last second (server and per room). */
+    private meters;
+    /** Everything but the room sends; `sendAll` false when subTick sends rooms on their own phase. */
+    private tickInner;
+    private housekeep;
+    /** One room's part of a tick. An error there closes that room (1011) and the server keeps going: one bad room never stops the process. */
+    private guard;
+    /** Called every tickMs / 5 by start(). Housekeeping once per tickMs; each room sends on its own phase (every 5 sub-ticks, every 10 in rooms
+     *  over 8 players, effects every 5), so 2,000 sockets are not written in one burst. tick() stays the one-call form for tests and simple hosts. */
+    subTick(): void;
+    start(): void;
+    stop(): void;
+    /** Server shutdown: pending changes and saves are written, the live rooms go to onSnapshot (the next process takes them back), then every player
+     *  hears 1012 and reconnects. Without onSnapshot a restart ends every match. */
+    shutdown(): Promise<void>;
+    /** The live rooms as plain JSON: everything a new process needs to carry on (sockets, timers and open actions are not kept). */
+    exportRooms(): RoomsSnapshot;
+    /** Take back rooms from exportRooms() after a restart: every seat offline (held 60 s for its player to come back), no host until one is back, a new
+     *  term, save leases taken again. A snapshot older than maxAgeMs or of another format is ignored. Returns how many rooms came back. */
+    importRooms(snap: unknown, o?: {
+        maxAgeMs?: number;
+    }): number;
+    /** Write every changed profile and world now and wait until the store has taken them (a restart, a test). */
+    flushSaves(): Promise<void>;
+    /** Resolves once every world save being read now has been read (tests, a bench). */
+    whenLoaded(): Promise<void>;
+    private settle;
+    /** Close every room of one namespace (a public link stopped). */
+    closeScope(scope: string, reason?: string): void;
+    /** One namespace's use right now: rooms, seats, connected players and bytes out a second (over the last second). For per-customer caps. */
+    scopeStats(scope: string): {
+        rooms: number;
+        players: number;
+        online: number;
+        bytesOut: number;
+    };
+    stats(): HubStats;
+}
+/** A guest's display name: letters, digits, spaces, "_" and "-", at most 20 characters. */
+export declare function cleanName(raw: unknown): string | null;
+export {};