@v12-engine/engine 0.1.0 → 0.4.0

package/dist/server/seat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seat.js","names":[],"sources":["../../src/server/seat.ts"],"sourcesContent":["/**\n * A seat of a server's game (`Seat`): who holds it, and what each step of its life clears, said in one place\n * (design review E12). Taken by a connection (`take`), let go of by one that may come back to it (`drop`), given up\n * (`free`), made new for a new game (`reset`), held no more by whoever it was (`revoke`: a kick)\n */\nimport type { PlayerId } from '#engine/entity'\nimport type { ServerSeat } from '#engine/game'\nimport type { ModeSeat } from './mode'\nimport type { Connection } from './websocket'\n\n/** A token to come back to a seat with: what only who has it knows */\nexport function randomToken(): string {\n\tconst bytes = new Uint8Array(16)\n\tcrypto.getRandomValues(bytes)\n\treturn [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('')\n}\n\n/**\n * A seat of a server's game and who holds it\n *\n * @internal\n */\nexport class Seat implements ServerSeat {\n\t/** The world's player this seat plays */\n\treadonly player: PlayerId\n\t/** The name shown for the seat: the mode's, or the one its player gave */\n\tname: string\n\t/** A computer plays it */\n\tai: boolean\n\t/** Someone is in it now */\n\tconnected = false\n\t/** Whether the player has said they are ready to start, in the lobby */\n\tready = false\n\t/** The seat's chosen settings by name, such as its race, team and colour */\n\tsettings?: Record<string, string>\n\t/** Who it is rated as (`ratedId`), where the server rates */\n\trated?: string\n\t/** Its player's rating in the mode (`Rating.rating`), where the server rates */\n\trating?: number\n\t/** What lets who held it back in: theirs while they hold it, in the lobby and in the game */\n\ttoken?: string\n\t/** Who holds it, as the `seat` hook said (`SeatAnswer.id`) */\n\tid?: string\n\t/** When what an honest client never sends came from it, in this game: the last `cheating.seconds`' worth, and how many in all */\n\tcheats: { at: number[]; total: number } = { at: [], total: 0 }\n\t/** The connection of who is in it */\n\tconnection?: Connection\n\n\tconstructor(\n\t\t/** What the mode says of it */\n\t\treadonly mode: ModeSeat,\n\t\t/** Whether a computer plays it when nobody holds it */\n\t\tprivate readonly computer: boolean,\n\t\tsettings: Record<string, string>\n\t) {\n\t\tthis.player = mode.player\n\t\tthis.name = mode.name\n\t\tthis.ai = computer\n\t\tthis.settings = settings\n\t}\n\n\t/** Nobody in it, nor holding it in a game to come back to, nor a computer */\n\tget isFree(): boolean {\n\t\treturn !this.ai && !this.connected && this.token === undefined\n\t}\n\n\t/**\n\t * Taken by a connection: whoever was in it before is closed out (a player back from another page), and its token is\n\t * kept, or made. A name it is given is taken. Gives the token\n\t */\n\ttake(connection: Connection, name?: string): string {\n\t\tif (this.connection && this.connection !== connection) this.connection.close()\n\t\tthis.connected = true\n\t\tthis.connection = connection\n\t\tthis.token ??= randomToken()\n\t\tif (name) this.name = name.slice(0, 24)\n\t\treturn this.token\n\t}\n\n\t/** Whoever holds another seat moves here, in the lobby: their connection, token, who they are and their name; not ready */\n\ttakeFrom(other: Seat): void {\n\t\tthis.connected = true\n\t\tthis.connection = other.connection\n\t\tthis.token = other.token\n\t\tthis.id = other.id\n\t\tthis.rated = other.rated\n\t\tthis.name = other.name\n\t\tthis.ready = false\n\t\tother.free()\n\t}\n\n\t/** Its connection gone, held for who had it to come back to (a game on): their token, who they are and their name stay */\n\tdrop(): void {\n\t\tthis.connected = false\n\t\tthis.connection = undefined\n\t}\n\n\t/** Given up: free for anyone, with the mode's name, nobody's token, not ready */\n\tfree(): void {\n\t\tthis.drop()\n\t\tthis.token = undefined\n\t\tthis.id = undefined\n\t\tthis.rated = undefined\n\t\tthis.ready = false\n\t\tthis.name = this.mode.name\n\t}\n\n\t/** Held no more by who it was: their token and who they are no good (a kick). Their connection is closed by the caller */\n\trevoke(): void {\n\t\tthis.token = undefined\n\t\tthis.id = undefined\n\t\tthis.rated = undefined\n\t}\n\n\t/** What a new game starts it with: nobody's cheats, not ready, the computer's where the server says */\n\tnewGame(): void {\n\t\tthis.cheats = { at: [], total: 0 }\n\t\tthis.ready = false\n\t\tthis.ai = this.computer\n\t}\n\n\t/** New, for a new game with nobody: free, and as a new game starts it */\n\treset(): void {\n\t\tthis.free()\n\t\tthis.newGame()\n\t}\n}\n"],"mappings":";;AAWA,SAAgB,cAAsB;CACrC,MAAM,wBAAQ,IAAI,WAAW,EAAE;CAC/B,OAAO,gBAAgB,KAAK;CAC5B,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE;AAC5E;;;;;;AAOA,IAAa,OAAb,MAAwC;CA4B7B;CAEQ;;CA5BlB;;CAEA;;CAEA;;CAEA,YAAY;;CAEZ,QAAQ;;CAER;;CAEA;;CAEA;;CAEA;;CAEA;;CAEA,SAA0C;EAAE,IAAI,CAAC;EAAG,OAAO;CAAE;;CAE7D;CAEA,YAEC,MAEA,UACA,UACC;EAJQ,KAAA,OAAA;EAEQ,KAAA,WAAA;EAGjB,KAAK,SAAS,KAAK;EACnB,KAAK,OAAO,KAAK;EACjB,KAAK,KAAK;EACV,KAAK,WAAW;CACjB;;CAGA,IAAI,SAAkB;EACrB,OAAO,CAAC,KAAK,MAAM,CAAC,KAAK,aAAa,KAAK,UAAU,KAAA;CACtD;;;;;CAMA,KAAK,YAAwB,MAAuB;EACnD,IAAI,KAAK,cAAc,KAAK,eAAe,YAAY,KAAK,WAAW,MAAM;EAC7E,KAAK,YAAY;EACjB,KAAK,aAAa;EAClB,KAAK,UAAU,YAAY;EAC3B,IAAI,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG,EAAE;EACtC,OAAO,KAAK;CACb;;CAGA,SAAS,OAAmB;EAC3B,KAAK,YAAY;EACjB,KAAK,aAAa,MAAM;EACxB,KAAK,QAAQ,MAAM;EACnB,KAAK,KAAK,MAAM;EAChB,KAAK,QAAQ,MAAM;EACnB,KAAK,OAAO,MAAM;EAClB,KAAK,QAAQ;EACb,MAAM,KAAK;CACZ;;CAGA,OAAa;EACZ,KAAK,YAAY;EACjB,KAAK,aAAa,KAAA;CACnB;;CAGA,OAAa;EACZ,KAAK,KAAK;EACV,KAAK,QAAQ,KAAA;EACb,KAAK,KAAK,KAAA;EACV,KAAK,QAAQ,KAAA;EACb,KAAK,QAAQ;EACb,KAAK,OAAO,KAAK,KAAK;CACvB;;CAGA,SAAe;EACd,KAAK,QAAQ,KAAA;EACb,KAAK,KAAK,KAAA;EACV,KAAK,QAAQ,KAAA;CACd;;CAGA,UAAgB;EACf,KAAK,SAAS;GAAE,IAAI,CAAC;GAAG,OAAO;EAAE;EACjC,KAAK,QAAQ;EACb,KAAK,KAAK,KAAK;CAChB;;CAGA,QAAc;EACb,KAAK,KAAK;EACV,KAAK,QAAQ;CACd;AACD"}

package/dist/server/seatSettings.d.ts

@@ -1,9 +1,9 @@
 /**
  * What a lobby offers to choose for each seat (`seatSettingsOf`): a race where the game has races, and for a game that
- * says how its computers play (`GameModule.ai`) a difficulty and a personality, the engine's and the game's own. On the
+ * says how its computers play (`Rules.ai`) a difficulty and a personality, the engine's and the game's own. On the
  * server's side: it reads the computer player's profiles (`@v12-engine/engine/ai`), which the engine's core does not load
  */
-import type { GameModule, ServerHooks } from '#engine/game';
+import type { Rules, ServerHooks } from '#engine/game';
 /**
  * What a game offers to choose for each seat in a lobby (`ServerHooks.seatSettings`), with a race among them where the
  * game has races and does not offer its own choice of one: each race, by its name, and `random` where there are two
@@ -12,4 +12,4 @@ import type { GameModule, ServerHooks } from '#engine/game';
  *
  * @beta
  */
-export declare function seatSettingsOf(game: GameModule, races?: readonly string[]): NonNullable<ServerHooks['seatSettings']>;
+export declare function seatSettingsOf(game: Rules, races?: readonly string[]): NonNullable<ServerHooks['seatSettings']>;

package/dist/server/seatSettings.js

@@ -0,0 +1,63 @@
+import { RANDOM_RACE } from "../races.js";
+import { difficultiesOf, personalitiesOf } from "../ai/profiles.js";
+//#region src/server/seatSettings.ts
+/** A name as a lobby shows it: `insane` as `Insane` */
+var titled = (id) => id.charAt(0).toUpperCase() + id.slice(1);
+/**
+* What a lobby offers a computer's seat of a game that says how its computers play (`Rules.ai`, AI plan D1): a
+* difficulty and a personality, the engine's and the game's own. Nothing for a game that says nothing, or `lobby: false`
+*/
+function computerSettingsOf(game) {
+	if (!game.ai || game.ai.lobby === false) return {};
+	const registry = { module: game };
+	const difficulties = Object.keys(difficultiesOf(registry));
+	const personalities = Object.keys(personalitiesOf(registry));
+	return {
+		difficulty: {
+			label: "Difficulty",
+			options: difficulties,
+			labels: Object.fromEntries(difficulties.map((id) => [id, titled(id)])),
+			default: game.ai.defaults?.difficulty ?? "normal"
+		},
+		personality: {
+			label: "Personality",
+			options: personalities,
+			labels: Object.fromEntries(personalities.map((id) => [id, titled(id)])),
+			default: game.ai.defaults?.personality ?? "balanced"
+		}
+	};
+}
+/**
+* What a game offers to choose for each seat in a lobby (`ServerHooks.seatSettings`), with a race among them where the
+* game has races and does not offer its own choice of one: each race, by its name, and `random` where there are two
+* or more; only those of
+* `races` where given (the races a map offers, `GameMap.races`). The first is chosen until someone does
+*
+* @beta
+*/
+function seatSettingsOf(game, races) {
+	const own = {
+		...computerSettingsOf(game),
+		...game.server?.seatSettings
+	};
+	const all = game.races ?? [];
+	if (!all.length || own.race) return own;
+	const offered = races?.length ? all.filter((race) => races.includes(race.id)) : all;
+	const options = [...offered.map((race) => race.id), ...offered.length > 1 ? [RANDOM_RACE] : []];
+	return {
+		race: {
+			label: "Race",
+			options: options.length ? options : [all[0].id],
+			labels: {
+				...Object.fromEntries(all.map((race) => [race.id, race.name])),
+				[RANDOM_RACE]: "Random"
+			},
+			default: options[0] ?? all[0].id
+		},
+		...own
+	};
+}
+//#endregion
+export { seatSettingsOf };
+
+//# sourceMappingURL=seatSettings.js.map

package/dist/server/seatSettings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seatSettings.js","names":[],"sources":["../../src/server/seatSettings.ts"],"sourcesContent":["/**\n * What a lobby offers to choose for each seat (`seatSettingsOf`): a race where the game has races, and for a game that\n * says how its computers play (`Rules.ai`) a difficulty and a personality, the engine's and the game's own. On the\n * server's side: it reads the computer player's profiles (`@v12-engine/engine/ai`), which the engine's core does not load\n */\nimport type { Rules, ServerHooks } from '#engine/game'\nimport { RANDOM_RACE } from '#engine/races'\nimport { difficultiesOf, personalitiesOf } from '#engine/ai/profiles'\n\n/** A name as a lobby shows it: `insane` as `Insane` */\nconst titled = (id: string) => id.charAt(0).toUpperCase() + id.slice(1)\n\n/**\n * What a lobby offers a computer's seat of a game that says how its computers play (`Rules.ai`, AI plan D1): a\n * difficulty and a personality, the engine's and the game's own. Nothing for a game that says nothing, or `lobby: false`\n */\nfunction computerSettingsOf(game: Rules): NonNullable<ServerHooks['seatSettings']> {\n\tif (!game.ai || game.ai.lobby === false) return {}\n\tconst registry = { module: game }\n\tconst difficulties = Object.keys(difficultiesOf(registry))\n\tconst personalities = Object.keys(personalitiesOf(registry))\n\treturn {\n\t\tdifficulty: {\n\t\t\tlabel: 'Difficulty',\n\t\t\toptions: difficulties,\n\t\t\tlabels: Object.fromEntries(difficulties.map((id) => [id, titled(id)])),\n\t\t\tdefault: game.ai.defaults?.difficulty ?? 'normal'\n\t\t},\n\t\tpersonality: {\n\t\t\tlabel: 'Personality',\n\t\t\toptions: personalities,\n\t\t\tlabels: Object.fromEntries(personalities.map((id) => [id, titled(id)])),\n\t\t\tdefault: game.ai.defaults?.personality ?? 'balanced'\n\t\t}\n\t}\n}\n\n/**\n * What a game offers to choose for each seat in a lobby (`ServerHooks.seatSettings`), with a race among them where the\n * game has races and does not offer its own choice of one: each race, by its name, and `random` where there are two\n * or more; only those of\n * `races` where given (the races a map offers, `GameMap.races`). The first is chosen until someone does\n *\n * @beta\n */\nexport function seatSettingsOf(game: Rules, races?: readonly string[]): NonNullable<ServerHooks['seatSettings']> {\n\tconst own = { ...computerSettingsOf(game), ...game.server?.seatSettings }\n\tconst all = game.races ?? []\n\tif (!all.length || own.race) return own\n\tconst offered = races?.length ? all.filter((race) => races.includes(race.id)) : all\n\t// random where there is more than one to draw from\n\tconst options = [...offered.map((race) => race.id), ...(offered.length > 1 ? [RANDOM_RACE] : [])]\n\treturn {\n\t\trace: {\n\t\t\tlabel: 'Race',\n\t\t\toptions: options.length ? options : [all[0].id],\n\t\t\t// every race's name, those a map fixes for a seat among them\n\t\t\tlabels: { ...Object.fromEntries(all.map((race) => [race.id, race.name])), [RANDOM_RACE]: 'Random' },\n\t\t\tdefault: options[0] ?? all[0].id\n\t\t},\n\t\t...own\n\t}\n}\n"],"mappings":";;;;AAUA,IAAM,UAAU,OAAe,GAAG,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,GAAG,MAAM,CAAC;;;;;AAMtE,SAAS,mBAAmB,MAAuD;CAClF,IAAI,CAAC,KAAK,MAAM,KAAK,GAAG,UAAU,OAAO,OAAO,CAAC;CACjD,MAAM,WAAW,EAAE,QAAQ,KAAK;CAChC,MAAM,eAAe,OAAO,KAAK,eAAe,QAAQ,CAAC;CACzD,MAAM,gBAAgB,OAAO,KAAK,gBAAgB,QAAQ,CAAC;CAC3D,OAAO;EACN,YAAY;GACX,OAAO;GACP,SAAS;GACT,QAAQ,OAAO,YAAY,aAAa,KAAK,OAAO,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC;GACrE,SAAS,KAAK,GAAG,UAAU,cAAc;EAC1C;EACA,aAAa;GACZ,OAAO;GACP,SAAS;GACT,QAAQ,OAAO,YAAY,cAAc,KAAK,OAAO,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC;GACtE,SAAS,KAAK,GAAG,UAAU,eAAe;EAC3C;CACD;AACD;;;;;;;;;AAUA,SAAgB,eAAe,MAAa,OAAqE;CAChH,MAAM,MAAM;EAAE,GAAG,mBAAmB,IAAI;EAAG,GAAG,KAAK,QAAQ;CAAa;CACxE,MAAM,MAAM,KAAK,SAAS,CAAC;CAC3B,IAAI,CAAC,IAAI,UAAU,IAAI,MAAM,OAAO;CACpC,MAAM,UAAU,OAAO,SAAS,IAAI,QAAQ,SAAS,MAAM,SAAS,KAAK,EAAE,CAAC,IAAI;CAEhF,MAAM,UAAU,CAAC,GAAG,QAAQ,KAAK,SAAS,KAAK,EAAE,GAAG,GAAI,QAAQ,SAAS,IAAI,CAAC,WAAW,IAAI,CAAC,CAAE;CAChG,OAAO;EACN,MAAM;GACL,OAAO;GACP,SAAS,QAAQ,SAAS,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE;GAE9C,QAAQ;IAAE,GAAG,OAAO,YAAY,IAAI,KAAK,SAAS,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC,CAAC;KAAI,cAAc;GAAS;GAClG,SAAS,QAAQ,MAAM,IAAI,EAAE,CAAC;EAC/B;EACA,GAAG;CACJ;AACD"}

package/dist/server/secret.js

@@ -0,0 +1,13 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+//#region src/server/secret.ts
+/** A secret as bytes of one length, whatever its own: what is compared takes as long whatever it is */
+var digest = (text) => createHash("sha256").update(text).digest();
+/**
+* Whether what was brought is the secret (an admin's key, a key to watch, to the numbers), compared in a time that
+* says nothing of how much of it is right (RV37)
+*/
+var sameSecret = (brought, secret) => timingSafeEqual(digest(brought), digest(secret));
+//#endregion
+export { sameSecret };
+
+//# sourceMappingURL=secret.js.map

package/dist/server/secret.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret.js","names":[],"sources":["../../src/server/secret.ts"],"sourcesContent":["import { createHash, timingSafeEqual } from 'node:crypto'\n\n/** A secret as bytes of one length, whatever its own: what is compared takes as long whatever it is */\nconst digest = (text: string) => createHash('sha256').update(text).digest()\n\n/**\n * Whether what was brought is the secret (an admin's key, a key to watch, to the numbers), compared in a time that\n * says nothing of how much of it is right (RV37)\n */\nexport const sameSecret = (brought: string, secret: string): boolean => timingSafeEqual(digest(brought), digest(secret))\n"],"mappings":";;;AAGA,IAAM,UAAU,SAAiB,WAAW,QAAQ,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO;;;;;AAM1E,IAAa,cAAc,SAAiB,WAA4B,gBAAgB,OAAO,OAAO,GAAG,OAAO,MAAM,CAAC"}

package/dist/server/start.d.ts

@@ -1,6 +1,7 @@
 import type { Logger } from '#engine/log';
 import type { BrainDef } from '#engine/ai/brain';
-import type { GameModule } from '#engine/game';
+import type { Rules } from '#engine/game';
+import { type Game } from '#engine/createGame';
 import type { GameMap } from '#engine/map';
 import type { World } from '#engine/world';
 import { GameServer, type GameServerOptions } from './gameServer';
@@ -11,8 +12,13 @@ import { type GameMode, type ModeSeat } from './mode';
  * @beta
  */
 export interface StartServerOptions extends Omit<GameServerOptions, 'mode' | 'port'> {
-    /** The rules of the game (`GameModule`): of a game defined whole, its `rules`. A server never sees a game's view */
-    game: GameModule;
+    /**
+     * The game (`createGame`): its rules, its start (`Game.onStart`) where `onStart` is left out, and its first map where
+     * `map`, `makeWorld` and `mode` are. A server never fetches a game's view. Or `rules` in its place
+     */
+    game?: Game<unknown>;
+    /** The module of the game (`Rules`), in the place of `game`: the full API underneath, its start and map said here */
+    rules?: Rules;
     /** The port to listen on: 8787 when left out, 0 for any free one */
     port?: number;
     /** A map of the game: each game is played on a world made from it, with a seat for each of its players with a start */
@@ -24,7 +30,7 @@ export interface StartServerOptions extends Omit<GameServerOptions, 'mode' | 'po
     /** The seats a player may take. Those of the map when left out */
     seats?: ModeSeat[];
     /** What the game does once a world is made, before anyone plays: a mission given, the first wave sent */
-    start?: (world: World, context: {
+    onStart?: (world: World, context: {
         map?: GameMap;
         settings: Record<string, string>;
     }) => void | Promise<void>;
@@ -44,11 +50,12 @@ export interface StartServerOptions extends Omit<GameServerOptions, 'mode' | 'po
  * Starts a server of a game, and resolves once it listens: a lobby that seats who joins, then games of it, one after
  * the other, each on a world made anew.
  *
- *     const server = await startServer({ game: rules, map, start: (world) => startMission(world) })
+ *     const server = await startServer({ game })
+ *     const server = await startServer({ rules, map, onStart: (world) => startMission(world) })
  *     // server.port, server.close()
  *
  * The parts are there on their own: `GameServer.start` with a `GameMode`, `mapMode`, `SessionHost`
  *
- * @beta
+ * @public
  */
 export declare function startServer(options: StartServerOptions): Promise<GameServer>;

package/dist/server/start.js

@@ -0,0 +1,76 @@
+import { isGame } from "../createGame.js";
+import { GameServer } from "./gameServer.js";
+import { againstTheRest, mapMode, seatsOf } from "./mode.js";
+//#region src/server/start.ts
+/**
+* Starts a server of a game, and resolves once it listens: a lobby that seats who joins, then games of it, one after
+* the other, each on a world made anew.
+*
+*     const server = await startServer({ game })
+*     const server = await startServer({ rules, map, onStart: (world) => startMission(world) })
+*     // server.port, server.close()
+*
+* The parts are there on their own: `GameServer.start` with a `GameMode`, `mapMode`, `SessionHost`
+*
+* @public
+*/
+async function startServer(options) {
+	const { game, rules: givenRules, port = 8787, map: givenMap, makeWorld, seats, onStart: givenStart, computer, mode: givenMode, name, ...server } = options;
+	if (game && !isGame(game)) throw new Error("startServer: `game` is a game made by createGame; a module (`Rules`) is given as `rules`");
+	const rules = game ? game.toRules() : givenRules;
+	if (!rules) throw new Error("startServer: say the game (`game`, made by createGame) or its module (`rules`)");
+	const onStart = givenStart ?? game?.toStart();
+	const map = givenMap ?? (game && !makeWorld && !givenMode ? await game.loadMap() : void 0);
+	return GameServer.start({
+		...server,
+		port,
+		mode: givenMode ?? modeOf(rules, {
+			map,
+			makeWorld,
+			seats,
+			onStart,
+			computer,
+			name
+		})
+	});
+}
+/** The mode a server runs, from what it was started with */
+function modeOf(game, options) {
+	const { map, makeWorld, onStart } = options;
+	if (!map && !makeWorld) throw new Error("startServer: a server needs a map of the game, or a makeWorld, to make the world of each game from");
+	const seats = options.seats ?? (map ? seatsOf(map) : void 0);
+	if (!seats?.length) throw new Error(map ? `startServer: the map "${map.name}" has no player with a start. Give its players starts, or say the seats` : "startServer: say the seats players may take (seats), with a world made in code");
+	const { computer } = options;
+	const brain = computer && typeof computer === "object" ? computer : void 0;
+	const ai = brain ? againstTheRest : computer;
+	const base = map && !makeWorld ? mapMode(game, map, {
+		seats,
+		ai,
+		brain
+	}) : void 0;
+	return {
+		id: base?.id ?? game.id,
+		name: options.name ?? base?.name ?? game.name,
+		rules: game,
+		seats,
+		async makeWorld(settings, context) {
+			const world = base ? await base.makeWorld(settings, context) : await makeWorld(settings, context);
+			try {
+				await onStart?.(world, {
+					map,
+					settings
+				});
+			} catch (error) {
+				world.dispose();
+				throw error;
+			}
+			return world;
+		},
+		...ai !== null && { ai: ai ?? againstTheRest },
+		...brain && { brain }
+	};
+}
+//#endregion
+export { startServer };
+
+//# sourceMappingURL=start.js.map

package/dist/server/start.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.js","names":[],"sources":["../../src/server/start.ts"],"sourcesContent":["import type { Logger } from '#engine/log'\nimport type { BrainDef } from '#engine/ai/brain'\nimport type { Rules } from '#engine/game'\nimport { type Game, isGame } from '#engine/createGame'\nimport type { GameMap } from '#engine/map'\nimport type { World } from '#engine/world'\nimport { GameServer, type GameServerOptions } from './gameServer'\nimport { againstTheRest, type GameMode, mapMode, type ModeSeat, seatsOf } from './mode'\n\n/**\n * What a game server is started with: the game, where its worlds come from, and the server's own options\n *\n * @beta\n */\nexport interface StartServerOptions extends Omit<GameServerOptions, 'mode' | 'port'> {\n\t/**\n\t * The game (`createGame`): its rules, its start (`Game.onStart`) where `onStart` is left out, and its first map where\n\t * `map`, `makeWorld` and `mode` are. A server never fetches a game's view. Or `rules` in its place\n\t */\n\tgame?: Game<unknown>\n\t/** The module of the game (`Rules`), in the place of `game`: the full API underneath, its start and map said here */\n\trules?: Rules\n\t/** The port to listen on: 8787 when left out, 0 for any free one */\n\tport?: number\n\t/** A map of the game: each game is played on a world made from it, with a seat for each of its players with a start */\n\tmap?: GameMap\n\t/** A world made in code for each game, with the lobby's settings: in the place of a map. Says its `seats` too */\n\tmakeWorld?: (settings: Record<string, string>, context?: { log?: Logger }) => World | Promise<World>\n\t/** The seats a player may take. Those of the map when left out */\n\tseats?: ModeSeat[]\n\t/** What the game does once a world is made, before anyone plays: a mission given, the first wave sent */\n\tonStart?: (world: World, context: { map?: GameMap; settings: Record<string, string> }) => void | Promise<void>\n\t/**\n\t * How a computer player in a seat plays (`ai` says which seats, and those nobody took are its too): its options by\n\t * seat (`GameMode.ai`), or the brain that plays every seat of the computer (`defineBrain`), against everyone else's\n\t * base; the first brain the game lists, against everyone else's base when left out; `null` for\n\t * a game the computer does not play. `mode` for a brain by seat (`GameMode.brain`)\n\t */\n\tcomputer?: GameMode['ai'] | BrainDef | null\n\t/** A mode put together elsewhere, in the place of all of the above but the game */\n\tmode?: GameMode\n\t/** What the mode is called. The map's name, or the game's */\n\tname?: string\n}\n\n/**\n * Starts a server of a game, and resolves once it listens: a lobby that seats who joins, then games of it, one after\n * the other, each on a world made anew.\n *\n *     const server = await startServer({ game })\n *     const server = await startServer({ rules, map, onStart: (world) => startMission(world) })\n *     // server.port, server.close()\n *\n * The parts are there on their own: `GameServer.start` with a `GameMode`, `mapMode`, `SessionHost`\n *\n * @public\n */\nexport async function startServer(options: StartServerOptions): Promise<GameServer> {\n\tconst { game, rules: givenRules, port = 8787, map: givenMap, makeWorld, seats, onStart: givenStart, computer, mode: givenMode, name, ...server } = options\n\tif (game && !isGame(game)) throw new Error('startServer: `game` is a game made by createGame; a module (`Rules`) is given as `rules`')\n\tconst rules = game ? game.toRules() : givenRules\n\tif (!rules) throw new Error('startServer: say the game (`game`, made by createGame) or its module (`rules`)')\n\tconst onStart = givenStart ?? game?.toStart()\n\tconst map = givenMap ?? (game && !makeWorld && !givenMode ? await game.loadMap() : undefined)\n\treturn GameServer.start({ ...server, port, mode: givenMode ?? modeOf(rules, { map, makeWorld, seats, onStart, computer, name }) })\n}\n\n/** The mode a server runs, from what it was started with */\nfunction modeOf(game: Rules, options: Pick<StartServerOptions, 'map' | 'makeWorld' | 'seats' | 'onStart' | 'computer' | 'name'>): GameMode {\n\tconst { map, makeWorld, onStart } = options\n\tif (!map && !makeWorld) throw new Error('startServer: a server needs a map of the game, or a makeWorld, to make the world of each game from')\n\tconst seats = options.seats ?? (map ? seatsOf(map) : undefined)\n\tif (!seats?.length) {\n\t\tthrow new Error(\n\t\t\tmap\n\t\t\t\t? `startServer: the map \"${map.name}\" has no player with a start. Give its players starts, or say the seats`\n\t\t\t\t: 'startServer: say the seats players may take (seats), with a world made in code'\n\t\t)\n\t}\n\tconst { computer } = options\n\t// a brain, or the options of each seat\n\tconst brain = computer && typeof computer === 'object' ? computer : undefined\n\tconst ai = brain ? againstTheRest : (computer as GameMode['ai'] | null | undefined)\n\tconst base = map && !makeWorld ? mapMode(game, map, { seats, ai, brain }) : undefined\n\treturn {\n\t\tid: base?.id ?? game.id,\n\t\tname: options.name ?? base?.name ?? game.name,\n\t\trules: game,\n\t\tseats,\n\t\tasync makeWorld(settings, context) {\n\t\t\tconst world = base ? await base.makeWorld(settings, context) : await makeWorld!(settings, context)\n\t\t\ttry {\n\t\t\t\tawait onStart?.(world, { map, settings })\n\t\t\t} catch (error) {\n\t\t\t\tworld.dispose()\n\t\t\t\tthrow error\n\t\t\t}\n\t\t\treturn world\n\t\t},\n\t\t...(ai !== null && { ai: ai ?? againstTheRest }),\n\t\t...(brain && { brain })\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAyDA,eAAsB,YAAY,SAAkD;CACnF,MAAM,EAAE,MAAM,OAAO,YAAY,OAAO,MAAM,KAAK,UAAU,WAAW,OAAO,SAAS,YAAY,UAAU,MAAM,WAAW,MAAM,GAAG,WAAW;CACnJ,IAAI,QAAQ,CAAC,OAAO,IAAI,GAAG,MAAM,IAAI,MAAM,0FAA0F;CACrI,MAAM,QAAQ,OAAO,KAAK,QAAQ,IAAI;CACtC,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,gFAAgF;CAC5G,MAAM,UAAU,cAAc,MAAM,QAAQ;CAC5C,MAAM,MAAM,aAAa,QAAQ,CAAC,aAAa,CAAC,YAAY,MAAM,KAAK,QAAQ,IAAI,KAAA;CACnF,OAAO,WAAW,MAAM;EAAE,GAAG;EAAQ;EAAM,MAAM,aAAa,OAAO,OAAO;GAAE;GAAK;GAAW;GAAO;GAAS;GAAU;EAAK,CAAC;CAAE,CAAC;AAClI;;AAGA,SAAS,OAAO,MAAa,SAA8G;CAC1I,MAAM,EAAE,KAAK,WAAW,YAAY;CACpC,IAAI,CAAC,OAAO,CAAC,WAAW,MAAM,IAAI,MAAM,oGAAoG;CAC5I,MAAM,QAAQ,QAAQ,UAAU,MAAM,QAAQ,GAAG,IAAI,KAAA;CACrD,IAAI,CAAC,OAAO,QACX,MAAM,IAAI,MACT,MACG,yBAAyB,IAAI,KAAK,2EAClC,gFACJ;CAED,MAAM,EAAE,aAAa;CAErB,MAAM,QAAQ,YAAY,OAAO,aAAa,WAAW,WAAW,KAAA;CACpE,MAAM,KAAK,QAAQ,iBAAkB;CACrC,MAAM,OAAO,OAAO,CAAC,YAAY,QAAQ,MAAM,KAAK;EAAE;EAAO;EAAI;CAAM,CAAC,IAAI,KAAA;CAC5E,OAAO;EACN,IAAI,MAAM,MAAM,KAAK;EACrB,MAAM,QAAQ,QAAQ,MAAM,QAAQ,KAAK;EACzC,OAAO;EACP;EACA,MAAM,UAAU,UAAU,SAAS;GAClC,MAAM,QAAQ,OAAO,MAAM,KAAK,UAAU,UAAU,OAAO,IAAI,MAAM,UAAW,UAAU,OAAO;GACjG,IAAI;IACH,MAAM,UAAU,OAAO;KAAE;KAAK;IAAS,CAAC;GACzC,SAAS,OAAO;IACf,MAAM,QAAQ;IACd,MAAM;GACP;GACA,OAAO;EACR;EACA,GAAI,OAAO,QAAQ,EAAE,IAAI,MAAM,eAAe;EAC9C,GAAI,SAAS,EAAE,MAAM;CACtB;AACD"}

package/dist/server/websocket.d.ts

@@ -7,15 +7,22 @@ import type { Transport } from '#engine/session/remote';
  * @beta
  */
 export interface Connection extends Transport {
+    /** The address the connection was asked at */
     readonly url: string;
+    /** The network address the connection comes from */
     readonly address: string;
     /** Bytes written to it so far, as they go over the wire: compressed, where it is */
     readonly bytesSent: number;
     /** Whether what goes over it is compressed (`permessage-deflate`) */
     readonly compressed: boolean;
 }
-/** @beta */
+/**
+ * What `startSocketServer` is started with: the port, the log and the limits and compression of its connections
+ *
+ * @beta
+ */
 export interface SocketServerOptions {
+    /** Port to listen on: 0 for any free one */
     port: number;
     /** Where it says what goes wrong with a connection. The root logger when left out */
     log?: Logger;
@@ -62,6 +69,7 @@ export interface ConnectionSource {
  * @beta
  */
 export interface SocketServer extends ConnectionSource {
+    /** The underlying Node HTTP server */
     readonly server: Server;
     /** The port it listens on: the one given, or the one it was given for 0 */
     readonly port: number;

package/dist/server/websocket.js

@@ -0,0 +1,306 @@
+import { errorFields, rootLogger } from "../log.js";
+import { createHash } from "node:crypto";
+import { createServer } from "node:http";
+import { constants, createDeflateRaw, inflateRawSync } from "node:zlib";
+//#region src/server/websocket.ts
+var GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var TEXT = 1;
+var CONTINUATION = 0;
+var CLOSE = 8;
+var PING = 9;
+var PONG = 10;
+/**
+* Starts a WebSocket server, and resolves once it listens
+*
+* @beta
+*/
+function startSocketServer(options) {
+	const maxMessage = options.maxMessage ?? 65536;
+	const maxConnections = options.maxConnections ?? 1024;
+	const limits = {
+		idle: (options.idleTimeout ?? 60) * 1e3,
+		buffered: options.maxBuffered ?? 16777216
+	};
+	let handler = () => {};
+	const open = /* @__PURE__ */ new Set();
+	/** Each connection's own check: pinged when quiet, closed when silent too long */
+	const sweeps = /* @__PURE__ */ new Set();
+	const sweeper = setInterval(() => {
+		for (const sweep of sweeps) sweep();
+	}, Math.max(Math.min(limits.idle / 3, 2e4), 50));
+	sweeper.unref?.();
+	const server = createServer(options.onRequest ?? ((_request, response) => {
+		response.writeHead(426, { "content-type": "text/plain" });
+		response.end("A game server: connect with a WebSocket\n");
+	}));
+	server.on("upgrade", (request, socket) => {
+		const key = request.headers["sec-websocket-key"];
+		if (request.headers.upgrade?.toLowerCase() !== "websocket" || typeof key !== "string") {
+			socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+			return;
+		}
+		if (open.size >= maxConnections) {
+			socket.end("HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\n\r\n");
+			return;
+		}
+		const accept = createHash("sha1").update(key + GUID).digest("base64");
+		const offered = String(request.headers["sec-websocket-extensions"] ?? "");
+		const compressed = (options.compress ?? true) && /(^|,)\s*permessage-deflate\b/.test(offered);
+		const extension = compressed ? "Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover\r\n" : "";
+		socket.write(`HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${accept}\r\n${extension}\r\n`);
+		open.add(socket);
+		const { connection, sweep } = connectionOf(socket, request, maxMessage, compressed, limits, options.log ?? rootLogger);
+		sweeps.add(sweep);
+		socket.on("close", () => {
+			open.delete(socket);
+			sweeps.delete(sweep);
+		});
+		handler(connection);
+	});
+	return new Promise((resolve) => server.listen(options.port, () => {
+		const address = server.address();
+		resolve({
+			server,
+			port: typeof address === "object" && address ? address.port : options.port,
+			onConnection: (next) => handler = next,
+			close: () => new Promise((done) => {
+				clearInterval(sweeper);
+				for (const socket of open) socket.destroy();
+				server.close(() => done());
+			})
+		});
+	}));
+}
+/** The end every compressed message has, which the wire leaves off (RFC 7692): an empty block of a sync flush */
+var SYNC_TAIL = Buffer.from([
+	0,
+	0,
+	255,
+	255
+]);
+/** Messages shorter than this go as they are: compressing them would save next to nothing */
+var COMPRESS_FROM = 64;
+/** Milliseconds a connection closed from here stays open for the other end's own close, which says it has read everything */
+var CLOSE_WAIT = 1e3;
+/** A frame to send: a server's are never masked. `deflated` marks a compressed message (RSV1) */
+function frame(opcode, payload, deflated = false) {
+	const length = payload.length;
+	const head = length < 126 ? Buffer.alloc(2) : length < 65536 ? Buffer.alloc(4) : Buffer.alloc(10);
+	head[0] = 128 | (deflated ? 64 : 0) | opcode;
+	if (length < 126) head[1] = length;
+	else if (length < 65536) {
+		head[1] = 126;
+		head.writeUInt16BE(length, 2);
+	} else {
+		head[1] = 127;
+		head.writeBigUInt64BE(BigInt(length), 2);
+	}
+	return Buffer.concat([head, payload]);
+}
+/**
+* Compresses messages one after another against all the ones before (`permessage-deflate` with context): a delta
+* says much of what the one before it said, which the compressor remembers. In order, as zlib works in the background
+*/
+var Compressor = class {
+	deflate = createDeflateRaw({
+		windowBits: 15,
+		memLevel: 8
+	});
+	chunks = [];
+	/** The last message being compressed: the next waits for it, so that they go out in order */
+	queue = Promise.resolve();
+	/** Closed: what is still queued is let go, not written into a stream that is gone */
+	closed = false;
+	constructor() {
+		this.deflate.on("data", (chunk) => this.chunks.push(chunk));
+	}
+	/** Compresses a message, and hands it on when done: in the order they were given */
+	compress(message, done) {
+		this.queue = this.queue.then(() => new Promise((resolve) => {
+			if (this.closed) return resolve();
+			this.deflate.write(message);
+			this.deflate.flush(constants.Z_SYNC_FLUSH, () => {
+				const all = Buffer.concat(this.chunks.splice(0));
+				done(all.subarray(0, all.length - SYNC_TAIL.length));
+				resolve();
+			});
+		}));
+	}
+	/** Runs once what is being compressed has gone: for what goes as it is, in its turn */
+	after(run) {
+		this.queue = this.queue.then(run);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.deflate.close();
+	}
+};
+function connectionOf(socket, request, maxMessage, compressed, limits, log) {
+	let onMessage = () => {};
+	let onClose = () => {};
+	let closed = false;
+	let buffer = Buffer.alloc(0);
+	/** The parts of a text message sent in several frames, until its last, and whether it came compressed */
+	let parts = [];
+	let deflated = false;
+	let bytesSent = 0;
+	const compressor = compressed ? new Compressor() : void 0;
+	/** Whether the close frame has gone: nothing more is written after it */
+	let ended = false;
+	/** When something last came in */
+	let heardAt = Date.now();
+	const write = (data) => {
+		if (ended || socket.destroyed) return;
+		bytesSent += data.length;
+		socket.write(data);
+		if (socket.writableLength > limits.buffered) {
+			log.warn("server", "a connection took in too slowly, it is closed", {
+				waiting: socket.writableLength,
+				address: request.socket.remoteAddress
+			});
+			ended = true;
+			socket.destroy();
+		}
+	};
+	const shut = () => {
+		if (closed) return;
+		closed = true;
+		onClose();
+	};
+	/** Our close has gone, and the other end's is waited for, a moment: what comes in is read for that alone */
+	let lingering;
+	const end = () => {
+		clearTimeout(lingering);
+		lingering = void 0;
+		socket.end();
+	};
+	/** `answering`: the other end closed first, and has nothing more to say or to read */
+	const close = (code = 1e3, answering = false) => {
+		if (closed) return;
+		const payload = Buffer.alloc(2);
+		payload.writeUInt16BE(code, 0);
+		const finish = () => {
+			write(frame(CLOSE, payload));
+			ended = true;
+			compressor?.close();
+			if (answering || socket.destroyed) return end();
+			lingering = setTimeout(end, CLOSE_WAIT);
+			lingering.unref?.();
+		};
+		if (compressor) compressor.after(finish);
+		else finish();
+		shut();
+	};
+	socket.on("data", (data) => {
+		if (closed && !lingering) return;
+		heardAt = Date.now();
+		buffer = Buffer.concat([buffer, data]);
+		for (;;) {
+			if (closed && !lingering || buffer.length < 2) return;
+			const fin = (buffer[0] & 128) !== 0;
+			const rsv1 = (buffer[0] & 64) !== 0;
+			const opcode = buffer[0] & 15;
+			const masked = (buffer[1] & 128) !== 0;
+			let length = buffer[1] & 127;
+			let at = 2;
+			if (length === 126) {
+				if (buffer.length < 4) return;
+				length = buffer.readUInt16BE(2);
+				at = 4;
+			} else if (length === 127) {
+				if (buffer.length < 10) return;
+				const long = buffer.readBigUInt64BE(2);
+				if (long > BigInt(maxMessage)) return closed ? end() : close(1009);
+				length = Number(long);
+				at = 10;
+			}
+			if (!masked) return closed ? end() : close(1002);
+			if (length > maxMessage) return closed ? end() : close(1009);
+			if (buffer.length < at + 4 + length) return;
+			const mask = buffer.subarray(at, at + 4);
+			const payload = Buffer.from(buffer.subarray(at + 4, at + 4 + length));
+			for (let i = 0; i < payload.length; i++) payload[i] ^= mask[i & 3];
+			buffer = buffer.subarray(at + 4 + length);
+			if (closed) {
+				if (opcode === CLOSE) return end();
+				continue;
+			}
+			if (opcode === TEXT || opcode === CONTINUATION) {
+				if (opcode === TEXT) deflated = rsv1 && compressed;
+				parts.push(payload);
+				if (parts.reduce((sum, part) => sum + part.length, 0) > maxMessage) return close(1009);
+				if (!fin) continue;
+				let data = Buffer.concat(parts);
+				parts = [];
+				if (deflated) try {
+					data = inflateRawSync(Buffer.concat([data, SYNC_TAIL]), {
+						maxOutputLength: maxMessage,
+						finishFlush: constants.Z_SYNC_FLUSH
+					});
+				} catch {
+					return close(1009);
+				}
+				try {
+					onMessage(data.toString("utf8"));
+				} catch (error) {
+					log.error("server", "a message could not be handled, the connection is closed", {
+						error: errorFields(error),
+						address: request.socket.remoteAddress
+					});
+					return close(1011);
+				}
+			} else if (opcode === PING) write(frame(PONG, payload));
+			else if (opcode === CLOSE) return close(1e3, true);
+		}
+	});
+	const gone = () => {
+		clearTimeout(lingering);
+		lingering = void 0;
+		ended = true;
+		compressor?.close();
+		shut();
+	};
+	socket.on("close", gone);
+	socket.on("error", gone);
+	const connection = {
+		url: request.url ?? "/",
+		address: request.socket.remoteAddress ?? "",
+		compressed,
+		get bytesSent() {
+			return bytesSent;
+		},
+		send(message) {
+			if (closed) return;
+			const data = Buffer.from(message, "utf8");
+			if (!compressor || data.length < COMPRESS_FROM) {
+				if (compressor) compressor.after(() => write(frame(TEXT, data)));
+				else write(frame(TEXT, data));
+				return;
+			}
+			compressor.compress(data, (deflatedData) => write(frame(TEXT, deflatedData, true)));
+		},
+		onMessage(next) {
+			onMessage = next;
+		},
+		onClose(next) {
+			onClose = next;
+		},
+		close: () => close()
+	};
+	/** Pings a connection that has been quiet, and closes one that has said nothing for longer than it may */
+	const sweep = () => {
+		if (closed) return;
+		const quiet = Date.now() - heardAt;
+		if (quiet > limits.idle) return close(1001);
+		if (quiet > limits.idle / 3) write(frame(PING, Buffer.alloc(0)));
+	};
+	return {
+		connection,
+		sweep
+	};
+}
+//#endregion
+export { startSocketServer };
+
+//# sourceMappingURL=websocket.js.map