@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/server/gameServer.d.ts

@@ -0,0 +1,346 @@
+import type { Ratings } from './ratings';
+import type { GameListing } from '#engine/session/protocol';
+import type { Logger } from '#engine/log';
+import { type ServerLog } from './log';
+import type { PlayerId } from '#engine/entity';
+import type { RejectedKind } from '#engine/errors';
+import type { GameResult, ServerSeat } from '#engine/game';
+import type { SessionHost } from '#engine/session/remote';
+import type { World } from '#engine/world';
+import type { GameMode } from './mode';
+import { type ServerHttpOptions, type ServerMetrics } from './ops';
+import { type ConnectionSource } from './websocket';
+/** @beta */
+export interface GameServerOptions {
+    mode: GameMode;
+    /** Port to listen on: 0 for any free one */
+    port: number;
+    /** Seats the computer plays, whoever joins */
+    ai?: PlayerId[];
+    /**
+     * Where ratings are kept (`Ratings`, `createRatings`): the players' shown in the lobby and the list of games, and
+     * moved by every game that ends. A player is who brings the same key (`join`'s `who`), or the `seat` hook's `id`
+     */
+    ratings?: Ratings;
+    /**
+     * The game's settings it starts with (`ServerHooks.settings`), in place of their defaults: the map a room was made
+     * for. Only those the game offers, with a value it offers
+     */
+    settings?: Record<string, string>;
+    /** Starts once every seat for a player is taken, without anyone saying so. Yes when left out */
+    autoStart?: boolean;
+    /** What `admin` messages must carry: no admin without */
+    adminKey?: string;
+    /** Where results are kept as files, when the game has no `saveResult` of its own. Kept nowhere without */
+    resultsDir?: string;
+    /** Commands a second a connection may send, and how many at once: what is over the limit is dropped, and answered refused. 30 and 60 */
+    rate?: {
+        perSecond: number;
+        burst: number;
+    };
+    /**
+     * Messages a second a connection may send besides its commands (`rate`), and how many at once: what is over is
+     * dropped, unanswered. A player's screen says it got what it was sent `sendRate` times a second, pings every two
+     * seconds and asks for the ground a part at a time. 100 and 200 when left out
+     *
+     * @beta
+     */
+    messageRate?: {
+        perSecond: number;
+        burst: number;
+    };
+    /**
+     * The lobby's messages a second a connection may send, and how many at once: a join, a seat, a name, a setting,
+     * ready, start, an admin's word. Each is told to everyone (and an admin's key tried): what is over is dropped. 4 and
+     * 20 when left out
+     *
+     * @beta
+     */
+    lobbyRate?: {
+        perSecond: number;
+        burst: number;
+    };
+    sendRate?: number;
+    /** Whether the seated players may use the debug tools (`debug.*` commands): for a game to try things out in. No when left out */
+    debug?: boolean;
+    /** Whether to compress what goes to players whose browsers can take it (`permessage-deflate`). Yes when left out */
+    compress?: boolean;
+    /**
+     * Whether those who come once the seats are taken, or who ask to, may watch: they see everything, the whole map
+     * without fog and every player's resources, so a player who could watch on the side would know all the other
+     * side does. No when left out. `{ key }` lets in who brings the key (`join`'s `key`); a function decides for each
+     * who asks
+     */
+    watch?: boolean | {
+        key: string;
+    } | ((request: WatchRequest) => boolean);
+    /**
+     * Seconds who watches a game being played sees it behind (`delayed`): so that a watcher cannot tell a side where the
+     * other is now. None when left out
+     */
+    watchDelay?: number;
+    /**
+     * Who sits where, decided for each who joins: for a login, a matchmaker's ticket, a seat a lobby gave, a name
+     * checked. It gets who asks (`SeatRequest`: their address, name, the ticket they brought and the seats free) and
+     * answers a seat, the name to use and who they are, or a refusal with a reason; it may be asynchronous, to ask a
+     * login service. Without, the first free seat, by the name sent. One who comes back with their seat's token takes it
+     * again without being asked about. Watching is still `watch`'s
+     */
+    seat?: (request: SeatRequest) => SeatAnswer | Promise<SeatAnswer>;
+    /**
+     * What becomes of a player whose client sends what an honest one never does (`commandRejected`: a command not what
+     * it says it is, another player's unit, a unit there never was): each is counted by seat and said in the log, and
+     * this decides, from who it is, why and how many: `ignore`, `warn` (said in the log as a warning), `kick` (let go,
+     * their token and id no good any more) or `end` (the game ends, with no winner). Without, a warning each time, and a
+     * kick once there are `cheating.kickAfter` within `cheating.seconds`
+     */
+    onCheat?: (report: CheatReport) => CheatAnswer | void;
+    /** How many refusals in how many seconds the server kicks after when there is no `onCheat`, and `CheatReport.recent` counts over. 20 in 10 */
+    cheating?: {
+        kickAfter?: number;
+        seconds?: number;
+    };
+    /** Seconds between two lines of where the host's time goes, while a game runs: none without */
+    stats?: number;
+    /**
+     * Whether the navigations of its worlds are built in a worker thread (S37), so that a world being made does not
+     * hold up the ticks of the games already running: yes when left out, where the engine is built (in this
+     * repository, which runs it as it is written, they are built on the server's thread). Handed to the mode's worlds
+     * (`GameMode.makeWorld`'s `context.navigation`): a mode of its own passes it on
+     */
+    navigationWorker?: boolean;
+    /**
+     * Seconds a game goes on once every player has left it, for one of them to come back with their token: then it ends,
+     * with no winner, and the server goes back to its lobby. 60 when left out; 0 ends it at once, `Infinity` never. A game
+     * may end itself sooner or later its own way (`ServerHooks.onPlayerLeave`, `world.winner`)
+     */
+    abandonAfter?: number;
+    /** Seconds of the game a player may go without saying it got what it was sent, before it is let go (`SessionHostOptions.dropSilentAfter`) */
+    dropSilentAfter?: number;
+    /** Bytes of what is kept for each player to make a delta against, at most (`SessionHostOptions.keptBytes`): 8 MB when left out */
+    keptBytes?: number;
+    /** Seconds a connection may say nothing, pings unanswered, before it is closed (`SocketServerOptions.idleTimeout`) */
+    idleTimeout?: number;
+    /** Bytes waiting to go out to a connection, at most, before it is closed (`SocketServerOptions.maxBuffered`) */
+    maxBuffered?: number;
+    /**
+     * Connections open at once, at most (`SocketServerOptions.maxConnections`): one more is turned away before it is a
+     * WebSocket. 1024 when left out
+     *
+     * @beta
+     */
+    maxConnections?: number;
+    /**
+     * Seconds a connection has to join (`join`) before it is closed: one that never does is told nothing of the lobby
+     * meanwhile, and would be kept for good, as a browser answers the pings that let go of those gone (RV38). 10 when
+     * left out; `Infinity` waits for ever
+     *
+     * @beta
+     */
+    joinWithin?: number;
+    /**
+     * Where the server says what it does (seats, games, slow ticks, what went wrong), and its games with it: a logger
+     * (`Logger`), whose entries say what they are about by name, or a function that takes each as a line of text.
+     * Warnings and errors go to the root logger when left out
+     */
+    log?: ServerLog;
+    /**
+     * The addresses on its HTTP server besides the sockets: one that says whether it is well (`/health`) and one with
+     * its numbers (`/metrics`), each to move or leave out, and a key the numbers take. See `ServerHttpOptions`
+     */
+    http?: ServerHttpOptions;
+}
+/**
+ * Who asks to watch a game (`GameServerOptions.watch`)
+ *
+ * @beta
+ */
+export interface WatchRequest {
+    /** The address they connect from */
+    address: string;
+    /** The name they gave */
+    name?: string;
+    /** The key they brought */
+    key?: string;
+    /** Whether a seat is held from the same address: a player who would watch their own game from the side */
+    seated: boolean;
+    phase: GameServer['phase'];
+}
+/**
+ * A player whose client sent what an honest one never does (`GameServerOptions.onCheat`)
+ *
+ * @beta
+ */
+export interface CheatReport {
+    seat: ServerSeat;
+    /** The address they connect from */
+    address?: string;
+    /** Why it was turned away (`commandRejected`'s kind), in words (its reason), and the command's type when it is known */
+    kind: RejectedKind;
+    reason: string;
+    type?: string;
+    /** How many there were within `cheating.seconds`, this one with them, and in the whole game */
+    recent: number;
+    total: number;
+}
+/**
+ * What the server does about it (`GameServerOptions.onCheat`): nothing, a warning in the log, let them go, or end the game
+ *
+ * @beta
+ */
+export type CheatAnswer = 'ignore' | 'warn' | 'kick' | 'end';
+/**
+ * Who asks for a seat (`GameServerOptions.seat`)
+ *
+ * @beta
+ */
+export interface SeatRequest {
+    /** The address they connect from */
+    address: string;
+    /** The name they gave */
+    name?: string;
+    /** What they brought to be let in by (`join`'s `ticket`): a login's token, a matchmaker's ticket. Checked by the game, never by the server */
+    ticket?: string;
+    /** The seats nobody holds now, in the mode's order: none once a game is on, where only coming back is left */
+    free: ServerSeat[];
+    phase: GameServer['phase'];
+}
+/**
+ * Where who asked sits (`GameServerOptions.seat`): a seat by its player (the first free one when left out), the name to
+ * use there (theirs, or the seat's, when left out), and who they are (`id`): one who comes again as the same id gets the
+ * seat they hold, from another page or after a drop, and the connection there before is let go. A seat another holds is
+ * refused. `{ refuse }` sends them away with the reason, which they are told
+ *
+ * @beta
+ */
+export type SeatAnswer = {
+    player?: PlayerId;
+    name?: string;
+    id?: string;
+    /**
+     * Who to rate them as (`ratings`): a login's account. The key they brought (`join`'s `who`) when left out, and
+     * `id` without one; a matchmaker's ticket, a new id every game, is no one to rate
+     */
+    rate?: string;
+} | {
+    refuse: string;
+};
+/**
+ * A server of a game: its connections, who joins and where they go (`Doorman`), its lobby (`Lobby`: the seats, the
+ * settings, when a game starts) and its game while one is on (`Match`)
+ *
+ * @beta
+ */
+export declare class GameServer {
+    private readonly source;
+    readonly options: GameServerOptions;
+    /** Who builds the navigations of its worlds: its worker thread (`navigationWorker`), or the world's own way */
+    private readonly navigation?;
+    phase: 'lobby' | 'game' | 'ended';
+    private readonly clients;
+    /** The keys of those the lobby voted out (`kick`): kept out until the server starts afresh (`reset`) */
+    private readonly kickedOut;
+    /** Where each who joins goes */
+    private readonly doorman;
+    /** The seats, the settings, and when a game starts */
+    private readonly lobby;
+    /** The game on, or the one that ended while its players are still on its screen */
+    private match?;
+    private constructor();
+    /** Starts a server, and resolves once it listens */
+    static start(options: GameServerOptions): Promise<GameServer>;
+    /**
+     * A server whose connections come from elsewhere (`ConnectionSource`): a room of `GameRooms`, those a port it shares
+     * hands it. Closing it closes those, and leaves where they come from to whoever owns it
+     */
+    static attach(source: ConnectionSource, options: Omit<GameServerOptions, 'port'>): Promise<GameServer>;
+    /** Says it is there, and starts a game at once where the computer has every seat */
+    private begin;
+    /** The game's settings (`ServerHooks.settings`), as chosen in the lobby */
+    get settings(): Record<string, string>;
+    /** The world of the game on, or of the one that ended while its players are still on its screen */
+    get world(): World | undefined;
+    /** What sends the game to its players, while there is one */
+    get host(): SessionHost | undefined;
+    /** Who paused the game: an admin, or a player (with a pause of theirs, for so long at most). Nobody while it runs */
+    get pausedBy(): PlayerId | 'admin' | undefined;
+    /** When it started, for its uptime */
+    private readonly startedAt;
+    /** Games played to their end */
+    private played;
+    /** What the hosts of the games before this one counted: the numbers go on from there */
+    private readonly past;
+    /** It takes no new games: it is stopping once the running one is over (`close({ drain })`) */
+    draining: boolean;
+    /** Tells a stop that waits that the running game is over */
+    private drained?;
+    /** What a list of games says of it (`GET /games`, `GameListing`), as the room it is reached at */
+    listing(room: string): GameListing;
+    /** How many are connected to it, playing or watching: none, for a room that may be closed */
+    get connections(): number;
+    /** How many watch */
+    private get watching();
+    /** Its numbers now: what `/metrics` says (see `ServerMetrics`) */
+    metrics(): ServerMetrics;
+    /** The game let go of, what its host counted kept for the numbers */
+    private dropMatch;
+    get port(): number;
+    /** Bytes sent to those connected now, as they went over the wire: compressed, where they are */
+    get bytesSent(): number;
+    /** What the server and its games say: see `GameServerOptions.log` */
+    readonly logger: Logger;
+    private log;
+    private accept;
+    private tell;
+    /** Tells everyone who joined: never a connection that has not (RV38) */
+    private tellAll;
+    private receive;
+    /** Whether a command of this client's goes in: a bucket that fills at the rate allowed. Why not, when it does not */
+    private allow;
+    private join;
+    /** Takes who joined where the doorman said: a seat, watching, told every seat is taken, or away with why */
+    private enter;
+    /** A seated player moves to another seat, free, in the lobby */
+    private move;
+    /** Seats a client, and lets go whoever had the seat before: a player back from another page. A name the game gave goes in any phase */
+    private sit;
+    /** The game's hooks */
+    private get hooks();
+    /**
+     * Who comes once the seats are taken watches, when the server lets them (`watch`): everything, the whole map without fog, every player's resources. From
+     * the side of the world's neutral player, so that nobody's units are theirs; from the first seat's, in a world without one
+     */
+    private watch;
+    private seatInGame;
+    private leave;
+    /** Makes the world, seats everyone at it, and runs it */
+    startGame(): Promise<void>;
+    /** Lets a player go for good: told why, their connection closed, and their token and id no good any more */
+    kick(player: PlayerId, reason: string): void;
+    /** The game is over: the result told to everyone and kept. The game goes on being shown until everyone has left */
+    endGame(): Promise<GameResult | undefined>;
+    /**
+     * Back to the lobby after a game, with who is still there in their seats: a player of it who joins again ("Again",
+     * with their seat's token) takes theirs, the seats of those gone are free
+     */
+    private backToLobby;
+    /** Back to the lobby, for a new game: the old one gone, every seat free */
+    private reset;
+    private admin;
+    /**
+     * Pauses the game for everyone, or lets it go on. A player's pause (`by`, from the `pause` command) ends by itself
+     * after its seconds, or when a seated player says `resume`; an admin's, when the admin says so
+     */
+    pause(paused: boolean, by?: {
+        player: PlayerId;
+        seconds: number;
+    }): void;
+    /**
+     * Stops the server: every connection closed. With `drain`, it first takes no new games (its health says so, for a
+     * load balancer to send nobody new) and waits for the running one to end, up to so many seconds: then it is ended
+     * (no winner, the players told the server stopped) and the server closes
+     */
+    close(options?: {
+        drain?: number;
+    }): Promise<void>;
+}

package/dist/server/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `@v12-engine/engine/server`: a game server, for Node. `startServer` runs a game for players who connect over WebSockets;
+ * the parts it is made of are here too, and a relay for games played in a page and watched from others.
+ *
+ * Nothing of any one game is in it: a game is handed in
+ */
+export type { StartServerOptions } from './start';
+export { startServer } from './start';
+export type { CheatAnswer, CheatReport, GameServerOptions, SeatAnswer, SeatRequest, WatchRequest } from './gameServer';
+export { GameServer } from './gameServer';
+export type { GameRoomsOptions, RoomKind, RoomOptions } from './rooms';
+export { GameRooms } from './rooms';
+export type { ServerHttpOptions, ServerMetrics } from './ops';
+export type { GameMode, GeneratedModeOptions, MapModeOptions, ModeBrain, ModeSeat } from './mode';
+export { againstTheRest, generatedMode, looksOfSeats, mapMode, PLAYER_COLOR_NAMES, racesOfSeats, seatLooksOf, seatsOf } from './mode';
+export { seatSettingsOf } from './seatSettings';
+export type { RelayOptions } from './relay';
+export type { ServerLog } from './log';
+export { WatchRelay } from './relay';
+export type { Connection, ConnectionSource, SocketServer, SocketServerOptions } from './websocket';
+export { startSocketServer } from './websocket';
+export { nodeNavigationBuilder } from './navigation';
+export { createRatings, type RatedPlayer, type Rating, ratedId, type Ratings } from './ratings';
+export { readPacks, withPackFiles } from './packs';

package/dist/server/lobby.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/log.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from '#engine/log';
+/**
+ * What a server may be given to log with: a logger, or a function that takes each line as text
+ *
+ * @beta
+ */
+export type ServerLog = Logger | ((line: string) => void);
+/**
+ * The logger of a server, from what it was started with. A logger: one under it. A function of lines: a logger of its
+ * own that gives it the server's own entries as their words, and everything else (a game's, a warning) as a whole
+ * line. Nothing: one under the root, which says warnings and errors only, as a server said nothing else before
+ */
+export declare function serverLogger(given: ServerLog | undefined): Logger;

package/dist/server/match.d.ts

@@ -0,0 +1,24 @@
+import type { PlayerId } from '#engine/entity';
+import type { ServerSeat } from '#engine/game';
+import { type Logger } from '#engine/log';
+import type { NavigationBuilds } from '#engine/navigation/builds';
+import type { LobbyServerMessage } from '../session/wire';
+import type { GameServerOptions } from './gameServer';
+/** What a game reads of the server it is played on */
+export interface MatchContext {
+    readonly options: GameServerOptions;
+    readonly logger: Logger;
+    readonly seats: readonly Seat[];
+    /** Who builds the navigation of its world, where the server says */
+    readonly navigation?: NavigationBuilds;
+    /** How many watch now: for the line of where the host's time goes */
+    readonly watching: number;
+    publicSeat(seat: Seat): ServerSeat;
+    /** What nobody joined is the computer's: once the world is made, before the computers sit */
+    fill(): void;
+    /** Tells everyone connected */
+    tellAll(message: LobbyServerMessage): void;
+    kick(player: PlayerId, reason: string): void;
+    /** The game is over: the server ends it (`GameServer.endGame`) */
+    end(): void;
+}

package/dist/server/mode.d.ts

@@ -0,0 +1,168 @@
+import type { Logger } from '#engine/log';
+import type { NavigationBuilds } from '#engine/navigation/builds';
+import type { BrainDef } from '#engine/ai/brain';
+import type { AiOptions } from '#engine/ai/options';
+import type { PlayerId } from '#engine/entity';
+import { type GameModule, type ServerHooks } from '#engine/game';
+import { type GeneratorOptions, type MapGenerator } from '#engine/generate';
+import { type GameMap } from '#engine/map';
+import type { Vec2 } from '#engine/math';
+import type { World } from '#engine/world';
+/**
+ * A seat a mode has: a player of the world, by default for whoever joins, or for the computer
+ *
+ * @beta
+ */
+export interface ModeSeat {
+    player: PlayerId;
+    name: string;
+    /** Where it starts, for a computer player to know where its opponents are */
+    base?: Vec2;
+    /** The team it plays for, shown in the lobby: the map's, for a mode made from a map */
+    team?: number;
+    /**
+     * Settings of the seat that are not the lobby's to choose, by name (`ServerHooks.seatSettings`): the race a map gives
+     * its player (`MapPlayer.race`)
+     */
+    fixed?: Record<string, string>;
+    /**
+     * Settings of the seat chosen for it until someone chooses otherwise, by name: its team and its colour on the map
+     * (`seatLooksOf`)
+     */
+    preset?: Record<string, string>;
+}
+/**
+ * What a server runs: a game module, the seats of a game of it, and how its world is made. Each game starts from a
+ * world made anew, with the lobby's settings
+ *
+ * @beta
+ */
+export interface GameMode {
+    id: string;
+    name: string;
+    game: GameModule;
+    seats: ModeSeat[];
+    /**
+     * What can be chosen for each seat in the lobby, in place of what the game offers (`seatSettingsOf(game)`): the races
+     * a map offers (`GameMap.races`)
+     */
+    seatSettings?: NonNullable<ServerHooks['seatSettings']>;
+    /**
+     * Makes the world of a game. `context.log` is the server's logger, for the world's own to be made under;
+     * `context.seats` what was chosen for each seat in the lobby, by player (`ServerHooks.seatSettings`): a race among
+     * them, in a game with races (`seatSettingsOf`), for the world to give each player (`MapWorldOptions.races`);
+     * `context.navigation` who builds its navigation (the server's worker thread: `GameServerOptions.navigationWorker`)
+     */
+    makeWorld(settings: Record<string, string>, context?: {
+        log?: Logger;
+        seats?: Readonly<Record<PlayerId, Readonly<Record<string, string>>>>;
+        navigation?: NavigationBuilds;
+    }): Promise<World>;
+    /**
+     * How a computer player in a seat plays: with what was chosen for that seat in the lobby (`settings`, from
+     * `ServerHooks.seatSettings`: a difficulty, a race). No computer players without
+     */
+    ai?(seat: ModeSeat, seats: readonly ModeSeat[], settings: Readonly<Record<string, string>>): AiOptions;
+    /**
+     * Which brain plays a seat of the computer (`defineBrain`), or its id (one the game lists in `GameModule.brains`, or
+     * the engine's `core.melee`): one for every seat, or one by seat, with what was chosen for it in the lobby. The first
+     * brain the game lists when left out
+     */
+    brain?: ModeBrain;
+}
+/**
+ * Which brain plays a seat of the computer on a server (`GameMode.brain`): a brain, its id, or one chosen by seat
+ *
+ * @beta
+ */
+export type ModeBrain = BrainDef | string | ((seat: ModeSeat, seats: readonly ModeSeat[], settings: Readonly<Record<string, string>>) => BrainDef | string | undefined);
+/**
+ * A computer player that goes for everyone else's base: what a seat of the computer does when the server says nothing
+ * else. As hard as its seat's `difficulty` says and of the `personality` it says, where the game offers them to choose
+ * (`ServerHooks.seatSettings`, `seatSettingsOf`); a name the game does not have is left to the defaults
+ *
+ * @beta
+ */
+export declare const againstTheRest: (seat: ModeSeat, seats: readonly ModeSeat[], settings?: Readonly<Record<string, string>>) => AiOptions;
+/**
+ * The race chosen for each seat in the lobby, by player: none where nobody chose one, or the game has no races
+ *
+ * @beta
+ */
+export declare function racesOfSeats(seats: Readonly<Record<PlayerId, Readonly<Record<string, string>>>> | undefined): Record<PlayerId, string> | undefined;
+/**
+ * The seats a map has room for: a seat for each of its players with a start, the creeps apart
+ *
+ * @beta
+ */
+export declare const seatsOf: (map: GameMap) => ModeSeat[];
+/**
+ * The names of the players' colours (`PLAYER_COLORS`), in their order, as a lobby shows them
+ *
+ * @beta
+ */
+export declare const PLAYER_COLOR_NAMES: readonly ['Blue', 'Red', 'Teal', 'Purple', 'Yellow', 'Orange', 'Green', 'Pink', 'Grey', 'Light blue', 'Dark green', 'Brown', 'Maroon', 'Navy', 'Turquoise', 'Violet', 'Wheat', 'Peach', 'Mint', 'Lavender', 'Coal', 'Snow', 'Emerald', 'Peanut'];
+/**
+ * What a lobby offers to choose for each seat of a map's game beside the game's own: a team, of as many as there are
+ * seats, and a colour of the players' (`PLAYER_COLORS`, by `PLAYER_COLOR_NAMES`), no two seats the same. Each seat has
+ * the map's until chosen otherwise (`ModeSeat.preset`)
+ *
+ * @beta
+ */
+export declare function seatLooksOf(seats: readonly ModeSeat[]): NonNullable<ServerHooks['seatSettings']>;
+/**
+ * The teams and colours chosen in the lobby (`seatLooksOf`), by player, where they are not the map's: what
+ * `MapWorldOptions.teams` and `colors` take
+ *
+ * @beta
+ */
+export declare function looksOfSeats(seats: Readonly<Record<PlayerId, Readonly<Record<string, string>>>> | undefined, modeSeats: readonly ModeSeat[]): {
+    teams?: Record<PlayerId, number>;
+    colors?: Record<PlayerId, [number, number, number]>;
+};
+/**
+ * How a mode is made from a map (`mapMode`)
+ *
+ * @beta
+ */
+export interface MapModeOptions {
+    /** The seats a player may take. One for each player of the map with a start when left out */
+    seats?: ModeSeat[];
+    /** How a computer player in a seat plays: against everyone else's base when left out, `null` for none */
+    ai?: GameMode['ai'] | null;
+    /** Which brain plays a seat of the computer: the first the game lists when left out */
+    brain?: ModeBrain;
+    /**
+     * What the game does once a world is made from the map, before anyone plays (the game's `start`, as a page or
+     * `startServer` runs it): the units at each start, the first wave sent. Nothing when left out
+     */
+    start?: (world: World, context: {
+        map: GameMap;
+        settings: Record<string, string>;
+    }) => void | Promise<void>;
+}
+/**
+ * A game on a map of it: a seat for each player the map has a start for, and a world made from the map for each game
+ *
+ * @beta
+ */
+export declare function mapMode(game: GameModule, map: GameMap, options?: MapModeOptions): GameMode;
+/**
+ * How a mode on a generated map is made (`generatedMode`): the generator's options (the seed a new one each time
+ * when left out), and what a mode on a map takes
+ *
+ * @beta
+ */
+export interface GeneratedModeOptions extends Omit<GeneratorOptions, 'seed'>, MapModeOptions {
+    seed?: number;
+}
+/**
+ * A game on a map made by a generator (`generateMap`): the map made once, with the seed given or a new one, and a
+ * game of it as on any map (`mapMode`): a seat for each start, the world made from it for each game. For a room of a
+ * random map (`RoomKind.room` as a function: a new map for each room made)
+ *
+ * @beta
+ */
+export declare function generatedMode(game: GameModule, generator: MapGenerator, options: GeneratedModeOptions): GameMode & {
+    map: GameMap;
+};

package/dist/server/navigation-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/navigation.d.ts

@@ -0,0 +1,11 @@
+import { type NavigationBuilder } from '#engine/navigation/builds';
+/**
+ * A builder of navigations in a worker thread of this process (S37): what a server builds with, so that the world of
+ * one game being made does not hold up the ticks of the others (two seconds for a map of 512 cells a side). One
+ * thread, made the first time and kept, which keeps the process alive only while it builds. Nothing where the
+ * worker's file is not there: in this repository, which runs the engine as it is written, it builds on the thread
+ * that asks
+ *
+ * @beta
+ */
+export declare function nodeNavigationBuilder(): NavigationBuilder | undefined;