@amxts/core 0.1.0 → 0.2.1

package/src/testing/server.ts

@@ -16,7 +16,8 @@ import { compile } from './compile';
 import { Coroutines, nextTaskId } from './coroutines';
 import { installKitFor } from './kits';
 import { bitsFloat, floatBits, Memory, utf8Fit } from './memory';
-import { NATIVES, WEAPON_NAMES } from './natives';
+import { fieldCell, NATIVES, setFieldCell, WEAPON_NAMES } from './natives';
+import { FakeNetwork } from './network';
 import { constant, tables } from './tables';
 
 declare const WebAssembly: any;
@@ -64,6 +65,8 @@ interface Handler {
 	shape: number;
 	/** A closure's number: fn is then the plugin's dispatcher, called with it first (Handler.tag in module.cpp). */
 	tag?: number;
+	/** on_cell's filter: the handler hears the forward only when this argument is `value`. */
+	where?: { arg: number; value: number };
 }
 
 /** A host public standing in for a handler: `__amxts_cb<index>`. */
@@ -72,6 +75,12 @@ interface Slot extends Handler {
 	/** What the call answers when the handler says nothing. */
 	fallback: number;
 	key: string;
+	/**
+	 * Switched off while what it delivers has no listener - by the plugin
+	 * (slot_on), or a hook by DisableHookChain and DisableHamForward: a call
+	 * answers the fallback without reaching the plugin.
+	 */
+	off?: boolean;
 }
 
 interface Task {
@@ -94,7 +103,7 @@ interface Cvar {
 export interface Chain {
 	shape: HookShape;
 	answer: Value;
-	args: Value[];
+	args: HookArg[];
 	/** SetHookChainReturn ran: reapi lets a chain that answers be stopped only then. */
 	answered?: boolean;
 }
@@ -106,9 +115,12 @@ export interface HookResult {
 	/** The chain's answer after every listener: a number, a boolean or text, by the chain. */
 	result: Value;
 	/** The arguments as the listeners left them (`event.damage = 10`). */
-	args: Value[];
+	args: HookArg[];
 }
 
+/** A hookchain's argument: a number, a boolean, text, or a vector as `[x, y, z]`. */
+export type HookArg = Value | number[];
+
 /** A user message a plugin sent: ScreenFade, StatusIcon, ... */
 export interface UserMessage {
 	name: string;
@@ -129,6 +141,36 @@ export interface SentForward {
 	args: (Value | number[])[];
 }
 
+/** A menu of AMX Mod X's own, made by menu_create, as the fake keeps it. */
+export interface FakeMenu {
+	id: number;
+	title: string;
+	/** The public menu_create was given: called with (player, menu, item). */
+	handler: Slot;
+	/** Each item's name and its callback's number from menu_makecallback, or -1. */
+	items: { name: string; callback: number }[];
+	/** MPROP_PERPAGE: `0` is one page, without Back and More. */
+	perPage: number;
+	/** MPROP_EXIT is not MEXIT_NEVER. */
+	exit: boolean;
+	back: string;
+	next: string;
+	exitName: string;
+	numberColor: string;
+}
+
+/** A menu of AMX Mod X's own on a player's screen, as menu_display drew it. */
+export interface MenuScreen {
+	menu: number;
+	page: number;
+	/** What he sees, with the game's colour codes: `\r1.\w Armor`. */
+	text: string;
+	/** The keys that answer: 1-9 and 0. */
+	keys: number[];
+	/** The keys of the items drawn grey, which do nothing. */
+	disabled: number[];
+}
+
 /** One line a player was shown. */
 export interface Message {
 	variant: 'chat' | 'center' | 'console' | 'notify' | 'hud';
@@ -147,12 +189,14 @@ export interface ServerOptions {
 	/** Files in the game folder before the plugin loads, by path: `{ "addons/amxmodx/configs/x.ini": "..." }`. */
 	files?: Record<string, string>;
 	/**
-	 * The system the server runs on, as `~/os` finds it: "win32" puts the amxts
+	 * The system the server runs on, as `@amxts/core/os` finds it: "win32" puts the amxts
 	 * module's amxts_amxx.dll in the modules folder. "linux" unless said.
 	 */
 	platform?: 'win32' | 'linux';
 	/** The server's time zone, what Date's local getters read: "Asia/Yerevan". This machine's unless said. */
 	timeZone?: string;
+	/** Whether reapi finds Reunion, so a player's `authType`, `protocol` and `authKey` are his own. Not unless said. */
+	reunion?: boolean;
 }
 
 export type TeamName = 'UNASSIGNED' | 'TERRORIST' | 'CT' | 'SPECTATOR';
@@ -165,8 +209,15 @@ export interface JoinOptions {
 	armor?: number;
 	alive?: boolean;
 	bot?: boolean;
-	authid?: string;
+	/** His SteamID: "STEAM_0:0:<id>" unless said, "BOT" for a bot. */
+	steamId?: string;
 	ip?: string;
+	/** How Reunion says his game proved who he is, by its name in the player's API: "steam" unless said. */
+	authType?: string;
+	/** His game's protocol, as Reunion says: 48 unless said. */
+	protocol?: number;
+	/** The key Reunion read from his game: "" unless said. */
+	authKey?: string;
 	/** Admin flags as users.ini writes them: "abcdefghijklmnopqrstu". "z" - a plain user - unless said. */
 	flags?: string;
 	origin?: number[];
@@ -176,11 +227,16 @@ export interface JoinOptions {
 
 const SHAPE_NARROW = 0;
 const SHAPE_WIDE = 1;
+/** A slot taken back after a reload: SLOT_REUSED in module.cpp. */
+const SLOT_REUSED = 0x10000;
+/** A request that tells an owner a plugin which called it stopped: RPC_GONE in module.cpp, KIND_GONE in as/remote.ts. */
+const RPC_GONE = 2;
 const PLUGIN_HANDLED = 1;
 const HC_SUPERCEDE = 1;
 const HC_BREAK = 2;
-// A Ham Sandwich hook's answer that blocks the game's function.
+// A Ham Sandwich hook's answer that blocks the game's function, and fakemeta's.
 const HAM_SUPERCEDE = 4;
+const FMRES_SUPERCEDE = 4;
 // A message argument's types, as get_msg_argtype answers.
 const ARG_BYTE = 1;
 const ARG_COORD = 6;
@@ -266,8 +322,11 @@ export class FakePlayer extends FakeEntity {
 	connected = true;
 	alive: boolean;
 	readonly bot: boolean;
-	readonly authid: string;
+	readonly steamId: string;
 	readonly ip: string;
+	readonly authType: string;
+	readonly protocol: number;
+	readonly authKey: string;
 	/** Admin flags as bits: ADMIN_* . */
 	flags: number;
 	/** SPEAK_* flags: `muted` is SPEAK_MUTED. */
@@ -280,14 +339,22 @@ export class FakePlayer extends FakeEntity {
 	readonly commands: string[] = [];
 	/** His userinfo keys - `lang` says his language. */
 	readonly info = new Map<string, string>();
+	/** The menu of AMX Mod X's own on his screen (menu_display), or null; `menuselect <key>` answers it. */
+	menu: MenuScreen | null = null;
+	/** His userid, the number `#12` names him by in a command: the server counts them up as players come. */
+	readonly userid: number;
 
 	constructor(server: FakeServer, id: number, public name: string, options: JoinOptions) {
 		super(server, id, 'player');
 		this.alive = options.alive ?? true;
 		this.bot = options.bot ?? false;
-		this.authid = options.authid ?? (this.bot ? 'BOT' : `STEAM_0:0:${id}`);
+		this.steamId = options.steamId ?? (this.bot ? 'BOT' : `STEAM_0:0:${id}`);
 		this.ip = options.ip ?? `127.0.0.${id}:27005`;
+		this.authType = options.authType ?? 'steam';
+		this.protocol = options.protocol ?? 48;
+		this.authKey = options.authKey ?? '';
 		this.flags = flagBits(options.flags ?? 'z');
+		this.userid = server.nextUserid();
 		this.team = options.team ?? 'CT';
 		this.health = options.health ?? 100;
 		this.armor = options.armor ?? 0;
@@ -408,9 +475,14 @@ export class FakePlayer extends FakeEntity {
 		return false;
 	}
 
-	/** A console command, split the way the engine splits it: `amx_slap "Some One" 5`. True if handled. */
+	/**
+	 * A console command, split the way the engine splits it: `amx_slap "Some One" 5`.
+	 * `menuselect <key>` goes to his menu first, as AMX Mod X takes it. True if handled.
+	 */
 	command(line: string): boolean {
-		return this.server.clientCommand(this, splitCommand(line));
+		const argv = splitCommand(line);
+		if (argv[0] === 'menuselect' && this.menu && this.server.selectMenu(this, Number(argv[1]))) return true;
+		return this.server.clientCommand(this, argv);
 	}
 
 	/** Leaves the server: the disconnect events, then the slot is free. */
@@ -452,12 +524,34 @@ function splitCommand(line: string): string[] {
 	return [...line.matchAll(/"([^"]*)"|(\S+)/g)].map(m => m[1] ?? m[2]);
 }
 
+/**
+ * A log line split as AMX Mod X splits it for read_logargv: a quoted part
+ * and a part in brackets each one argument, the text between them another.
+ */
+export function splitLog(line: string): string[] {
+	// The spaces between two parts are none.
+	return [...line.matchAll(/"([^"]*)"|\(([^)]*)\)|([^"(]+)/g)]
+		.filter(m => m[3] === undefined || m[3].trim() !== '')
+		.map(m => m[1] ?? m[2] ?? m[3].trim());
+}
+
 /** A loaded plugin: its instance and its memory. */
+/** The runs handed out so far: each plugin loaded is a new one. */
+let runs = 0;
+
 export class PluginInstance {
 	instance: any;
 	memory!: Memory;
 	/** What plugin() said about it. */
 	info = { name: '', version: '', author: '', description: '' };
+	/** Taken off the server (FakeServer.unload): its slots answer nothing until the same file takes them back. */
+	unloaded = false;
+	/** This run of the plugin, as module.cpp's Plugin.run: what the other side of a shared module's call knows it by. */
+	readonly run = ++runs;
+	/** The shared modules it calls (Plugin.uses): their owners hear when it is unloaded. */
+	readonly uses: string[] = [];
+	/** It called back a function of a plugin unloaded since, and was told so: once. */
+	toldGone = false;
 
 	/** The coroutine scheduler, for a plugin that awaits; null for one that does not. */
 	readonly coroutines: Coroutines | null;
@@ -492,7 +586,7 @@ export class PluginInstance {
 
 		if (this.server.hasNative(name)) return (...args: number[]) => this.server.callNativeImpl(this, name, args);
 
-		// Another plugin's `export function`, called through ~/natives as AMX
+		// Another plugin's `export function`, called through @amxts/core/natives as AMX
 		// Mod X would route it; whether one exports it is known only at the call.
 		return (...cells: number[]) => {
 			if (this.server.exported.has(name)) return this.server.callFromPlugin(this, name, cells);
@@ -515,6 +609,8 @@ export class FakeServer {
 	readonly map: string;
 	readonly maxPlayers: number;
 	readonly modules: Set<string>;
+	/** Whether reapi finds Reunion (has_reunion). */
+	readonly reunion: boolean;
 	/** Milliseconds since the map started; advance() moves it. */
 	time = 0;
 	/** Date.now() when the map started. */
@@ -575,6 +671,8 @@ export class FakeServer {
 
 	/** The game rules' members a plugin set (set_member_game), by member. */
 	readonly rules = new Map<number, number>();
+	/** The members plugins asked member_slot for, by slot: each one's reapi constant. */
+	private readonly memberSlots: number[] = [];
 	/** Rounds a plugin ended with rg_round_end, in order. */
 	readonly roundEnds: { status: number; event: number; delay: number; message: string; sound: string; trigger: boolean }[] = [];
 	/** Sounds played: from an entity (emit_sound, rh_emit_sound2), or to a player alone (SendAudio, rg_send_audio). */
@@ -610,8 +708,37 @@ export class FakeServer {
 	hookedMessage: { args: (number | string)[]; types: number[] } | null = null;
 	/** register_touch's callbacks. */
 	readonly touches: { touched: string; toucher: string; slot: Slot }[] = [];
+	/** register_logevent's callbacks: the number of arguments a line has, and the filters it passes. @internal */
+	readonly logEvents: { argc: number; filters: string[]; slot: Slot }[] = [];
+	/** The log line logevent callbacks are reading, as AMX Mod X splits it. @internal */
+	logArgs: string[] = [];
+	/** That line whole, as read_logdata reads it. @internal */
+	logLine = '';
+	/** register_event's callbacks, by the message's name, with their conditions ("1=0"). @internal */
+	readonly messageEvents: { name: string; conditions: string[]; slot: Slot }[] = [];
+	/** register_forward's callbacks, by `<FM_* number>:pre|post`. */
+	readonly fakemetaForwards = new Map<string, Slot[]>();
+	/** What a fakemeta callback answered with forward_return, and what get_orig_retval reads. @internal */
+	forwardAnswer: number | string | null = null;
+	origRetval = 0;
+	/** The engine's EngFunc_SetClientListening calls plugins made: listener, sender, whether he hears. */
+	readonly listening: number[][] = [];
+	/** The engine's and the game's functions plugins called through engfunc and dllfunc, each as a line: `TraceLine 1,2,3 4,5,6 1 7 0`. */
+	readonly engineCalls: string[] = [];
 	/** query_client_cvar's questions, waiting for answerCvar(). */
 	readonly cvarQueries: { player: number; cvar: string; slot: Slot }[] = [];
+	/** The menus menu_create made and menu_destroy has not taken away, by id. */
+	readonly menus = new Map<number, FakeMenu>();
+	/** menu_makecallback's publics, by the number it gave. @internal */
+	readonly menuCallbacks: Slot[] = [];
+	private menuIds = 0;
+	private userids = 1;
+
+	/** A userid for a player who comes: one more than the last. @internal */
+	nextUserid(): number {
+		return this.userids++;
+	}
+
 	/** What precache_model and precache_sound were asked for, in order: the index is the place + 1. */
 	readonly precached: string[] = [];
 	/**
@@ -623,7 +750,7 @@ export class FakeServer {
 	/** Which of those texts are lists of player ids ("3,5"), by `slot:key`: a player who leaves goes from them. */
 	readonly playerLists = new Set<string>();
 	/**
-	 * The playerchange listeners, as the module keeps them: per plugin, the
+	 * The playerChange listeners, as the module keeps them: per plugin, the
 	 * fields it hears ("" for every one) and the trampoline that hands a change
 	 * to its listeners.
 	 */
@@ -640,13 +767,15 @@ export class FakeServer {
 	private outcome = 0;
 	private outcomeSaid = false;
 	private taskOrder = 0;
-	private hookHandles = 0;
+	/** The slots of RegisterHookChain's and RegisterHam's handles, which DisableHookChain and the rest take. */
+	private readonly hookSlots = new Map<number, Slot>();
 	private entityIds: number;
 
 	constructor(options: ServerOptions = {}) {
 		this.map = options.map ?? 'de_dust2';
 		this.maxPlayers = options.maxPlayers ?? 32;
 		this.modules = new Set(options.modules ?? ['reapi', 'cstrike', 'fun', 'hamsandwich', 'engine', 'fakemeta', 'nvault', 'resemiclip']);
+		this.reunion = options.reunion ?? false;
 		this.entityIds = this.maxPlayers + 1;
 		this.timeZone = options.timeZone;
 		// AMX Mod X's own, which a test may set: the languages.
@@ -697,11 +826,17 @@ export class FakeServer {
 		return plugin;
 	}
 
-	/** plugin_precache, plugin_init and plugin_cfg, as a map start sends them. */
+	/**
+	 * What a map start sends, in AMX Mod X's order: plugin_precache,
+	 * plugin_init, plugin_cfg, then OnAutoConfigsBuffered and
+	 * OnConfigsExecuted, once the server has run its configs.
+	 */
 	start(): void {
 		this.fire('plugin_precache');
 		this.fire('plugin_init');
 		this.fire('plugin_cfg');
+		this.fire('OnAutoConfigsBuffered');
+		this.fire('OnConfigsExecuted');
 	}
 
 	// ------------------------------------------------------------ what a test reads
@@ -870,11 +1005,29 @@ export class FakeServer {
 		this.entities.set(id, player);
 
 		this.fire('client_connect', id);
-		this.fire('client_authorized', id, player.authid);
+		this.fire('client_authorized', id, player.steamId);
 		this.fire('client_putinserver', id);
 		return player;
 	}
 
+	/** The module's network client: the requests plugins sent with fetch. @internal */
+	readonly network = new FakeNetwork(this);
+
+	/**
+	 * Waits for the responses to the requests the plugins sent with `fetch`,
+	 * and hands each to its plugin as the server's next frame would; a
+	 * request sent on the way is waited for too. A timer between two tries
+	 * waits for `advance()`.
+	 *
+	 * ```ts
+	 * player.say("/weather");
+	 * await server.responses();
+	 * ```
+	 */
+	async responses(): Promise<void> {
+		await this.network.settle();
+	}
+
 	/**
 	 * Moves the clock forward and runs every timer that comes due on the way,
 	 * in order - a repeating one as many times as it fits.
@@ -913,6 +1066,7 @@ export class FakeServer {
 
 			let result = 0;
 			for (const handler of [...(this.events.get(name) ?? [])]) {
+				if (handler.where && Number(args[handler.where.arg]) !== handler.where.value) continue;
 				const one = this.call(handler, [first], 0);
 				if (one > result) result = one;
 			}
@@ -932,24 +1086,26 @@ export class FakeServer {
 	 *
 	 * ```ts
 	 * server.fireHook("takeDamage", [victim.id, 0, attacker.id, 30.0, 2]);
-	 * server.fireHook("flPlayerFallDamage", [player.id], { result: 40 });
+	 * server.fireHook("fallDamage", [player.id], { result: 40 });
 	 * ```
 	 *
 	 * `event` is the name game.addEventListener takes, or reapi's short one
 	 * ("take_damage"). `args` are the chain's arguments in order; a float is
-	 * written as a number and goes as one. `result` is what the game's own
+	 * written as a number and goes as one, a vector as `[x, y, z]`. `result` is what the game's own
 	 * function answers when it runs - what a post listener reads as
 	 * event.result.
 	 */
-	fireHook(event: string, args: Value[] = [], options: { result?: Value } = {}): HookResult {
+	fireHook(event: string, args: HookArg[] = [], options: { result?: Value } = {}): HookResult {
 		const shape = tables().hooks.get(event);
 		if (!shape) throw new Error(`no hookchain named "${event}" in as/hooks.ts`);
 
-		const cells = args.map((a, i) => typeof a === 'string'
-			? a
-			: typeof a === 'boolean'
-				? (a ? 1 : 0)
-				: shape.floats.has(i) ? floatBits(a) : a | 0);
+		const cells: ArgValue[] = args.map((a, i) => Array.isArray(a)
+			? a.map(floatBits)
+			: typeof a === 'string'
+				? a
+				: typeof a === 'boolean'
+					? (a ? 1 : 0)
+					: shape.floats.has(i) ? floatBits(a) : a | 0);
 		const handed = cells.slice(0, 4).map(c => typeof c === 'number' ? c : 0);
 
 		const nothing: Value = shape.answer === constant('ATYPE_BOOL') ? false : shape.answer === constant('ATYPE_STRING') ? '' : 0;
@@ -980,6 +1136,12 @@ export class FakeServer {
 			if (!prevented) chain.answer = options.result ?? nothing;
 
 			if (!broken) {
+				// A vector is an array reapi copies back into the game's: what
+				// a pre listener wrote in it is what the game and the post
+				// listeners get.
+				cells.forEach((cell, i) => {
+					if (Array.isArray(cell)) chain.args[i] = cell.map(bitsFloat);
+				});
 				for (const slot of [...listeners.post]) {
 					this.withCallArgs(cells, () => this.call(slot, handed, slot.fallback));
 				}
@@ -1001,8 +1163,11 @@ export class FakeServer {
 	 * const sent = server.sendMessage("RoundTime", [120]);   // sent.args: [90] with a listener that writes 90
 	 * ```
 	 *
-	 * A text argument is a string; a whole number is written as a byte, a
-	 * fraction as a coordinate, unless `types` gives each argument's ARG_*.
+	 * `name` is the game's name of the message, `"TextMsg"` for the
+	 * `"text"` that server.addMessageListener takes, and `args` are its
+	 * arguments in the game's order. A text argument is a string; a whole
+	 * number is written as a byte, a fraction as a coordinate, unless `types`
+	 * gives each argument's ARG_*.
 	 * Returns whether a callback stopped it, and the arguments as they left.
 	 */
 	sendMessage(name: string, args: (number | string)[], options: { player?: FakePlayer; types?: number[] } = {}): { prevented: boolean; args: (number | string)[] } {
@@ -1020,6 +1185,14 @@ export class FakeServer {
 				const handed = [id ?? 0, receiver ? 1 : 0, receiver, 0];
 				if (this.withCallArgs(handed, () => this.call(slot, handed, 0)) === PLUGIN_HANDLED) prevented = true;
 			}
+			// register_event's callbacks hear it once it is sent, when its conditions hold.
+			const holds = (condition: string) => {
+				const match = condition.match(/^(\d+)=(.*)$/);
+				return !match || String(message.args[Number(match[1]) - 1]) === match[2];
+			};
+			for (const { slot } of this.messageEvents.filter(one => one.name === name && one.conditions.every(holds))) {
+				if (!prevented) this.withCallArgs([receiver], () => this.call(slot, [receiver, 0, 0, 0], 0));
+			}
 			return { prevented, args: message.args };
 		} finally {
 			this.hookedMessage = previous;
@@ -1041,7 +1214,7 @@ export class FakeServer {
 	 * function's arguments after the entity, a float as a number and a vector
 	 * as an array of three.
 	 */
-	fireHam(event: string, entity: FakeEntity | number, args: Value[] = [], options: { result?: Value } = {}): HookResult {
+	fireHam(event: string, entity: FakeEntity | number, args: HookArg[] = [], options: { result?: Value } = {}): HookResult {
 		const shape = tables().hooks.get(event);
 		if (shape?.ham === undefined) throw new Error(`no Ham Sandwich function under the event "${event}" in as/hooks.ts`);
 		return this.runHam(shape, typeof entity === 'number' ? entity : entity.id, args, options.result);
@@ -1051,7 +1224,7 @@ export class FakeServer {
 	 * fireHam's work, and ExecuteHamB's: `args` without the entity.
 	 * @internal
 	 */
-	runHam(shape: HookShape, id: number, args: (Value | number[])[], result?: Value): HookResult {
+	runHam(shape: HookShape, id: number, args: HookArg[], result?: Value): HookResult {
 		const classname = this.entities.get(id)?.classname ?? (id >= 1 && id <= this.maxPlayers ? 'player' : '');
 		const all = [id, ...args];
 		const cells: ArgValue[] = all.map((a, i) => Array.isArray(a)
@@ -1063,7 +1236,7 @@ export class FakeServer {
 					: shape.floats.has(i) ? floatBits(a) : a | 0);
 		const handed = cells.slice(0, 4).map(c => typeof c === 'number' ? c : 0);
 		const nothing: Value = shape.answer === constant('ATYPE_STRING') ? '' : 0;
-		const chain: Chain = { shape, answer: nothing, args: all.map(a => Array.isArray(a) ? 0 : a) };
+		const chain: Chain = { shape, answer: nothing, args: all };
 		const listeners = (post: boolean) => this.hams.get(`${shape.ham}:${classname}:${post ? 'post' : 'pre'}`) ?? [];
 
 		const previous = this.chain;
@@ -1281,7 +1454,7 @@ export class FakeServer {
 
 	/**
 	 * A plugin calling another plugin's `export function` native
-	 * through its ~/natives wrapper: the cells it pushed - text and buffers as
+	 * through its @amxts/core/natives wrapper: the cells it pushed - text and buffers as
 	 * addresses in its memory - turned into the frame the native reads, and
 	 * what the native wrote into a buffer copied back, as AMX Mod X does.
 	 * @internal
@@ -1344,6 +1517,9 @@ export class FakeServer {
 
 	/** Fire in module.cpp: one handler, its outcome, and the state put back. @internal */
 	call(handler: Handler, args: number[], fallback: number): number {
+		// An orphan answers PLUGIN_CONTINUE, as in n_callback: a command passes on to the plugin loaded since.
+		if (handler.plugin.unloaded) return 0;
+		if ((handler as Slot).off) return fallback;
 		const fn = handler.plugin.table.get(handler.fn);
 		const cells = handler.shape === SHAPE_WIDE ? [0, 1, 2, 3].map(i => args[i] ?? 0) : [args[0] ?? 0];
 		if (handler.tag) cells.unshift(handler.tag);
@@ -1431,6 +1607,208 @@ export class FakeServer {
 		}
 	}
 
+	/**
+	 * Takes a plugin off the server, as `amxts_reload` does before it loads
+	 * the plugins again: its timers are removed, and a call to one of its
+	 * other slots answers nothing, until a plugin of the same file asks for
+	 * the same key and takes the slot back. `load` the file again for the
+	 * reload's second half.
+	 */
+	unload(plugin: PluginInstance): void {
+		plugin.unloaded = true;
+		this.plugins.splice(this.plugins.indexOf(plugin), 1);
+		for (let i = this.tasks.length - 1; i >= 0; i--) {
+			if (this.tasks[i].slot.plugin === plugin) this.tasks.splice(i, 1);
+		}
+
+		// The modules it served answer nothing; the owners of those it called drop what it gave them (TellOwners).
+		for (const service of this.services.filter(each => each.plugin === plugin)) service.plugin = null;
+		const owners = this.services.filter(each => plugin.uses.includes(each.name) && each.plugin && each.plugin !== plugin);
+		const gone = new Uint8Array(new Int32Array([RPC_GONE, 0]).buffer);
+		for (const owner of owners) this.request(owner.plugin!, plugin.run, gone);
+	}
+
+	/** A menu by its id, or the error AMX Mod X gives for another number. @internal */
+	menu(id: number): FakeMenu {
+		const menu = this.menus.get(id);
+		if (!menu) throw new Error(`Invalid menu id ${id}`);
+		return menu;
+	}
+
+	/** menu_create: a menu of seven items a page, with Back, More and Exit. @internal */
+	createMenu(title: string, handler: Slot): number {
+		const id = this.menuIds++;
+		this.menus.set(id, { id, title, handler, items: [], perPage: 7, exit: true, back: 'Back', next: 'More', exitName: 'Exit', numberColor: '\\r' });
+		return id;
+	}
+
+	/** menu_destroy: whoever has it open sees it close, and its handler hears MENU_EXIT. @internal */
+	destroyMenu(id: number): void {
+		const menu = this.menu(id);
+		this.menus.delete(id);
+		for (const player of this.players.filter(one => one.menu?.menu === id)) {
+			player.menu = null;
+			this.menuAnswer(menu, player, constant('MENU_EXIT'));
+		}
+	}
+
+	/**
+	 * menu_display: a page drawn for a player. An item with a callback is
+	 * asked as AMX Mod X asks it, as it is drawn - the callback may name it
+	 * for him, and its answer greys it out. Another menu he had open is
+	 * closed first: its handler hears MENU_EXIT. @internal
+	 */
+	displayMenu(player: FakePlayer, menu: FakeMenu, page: number): void {
+		const before = player.menu;
+		player.menu = null;
+		const replaced = before && before.menu !== menu.id ? this.menus.get(before.menu) : undefined;
+		if (replaced) this.menuAnswer(replaced, player, constant('MENU_EXIT'));
+
+		const perPage = menu.perPage === 0 ? Math.min(menu.items.length, 10) : menu.perPage;
+		const pages = Math.max(1, Math.ceil(menu.items.length / Math.max(perPage, 1)));
+		const at = Math.min(Math.max(page, 0), pages - 1);
+		const lines = [`${menu.title}${pages > 1 ? ` ${at + 1}/${pages}` : ''}`, ''];
+		const keys: number[] = [];
+		const disabled: number[] = [];
+		const line = (key: number, text: string) => lines.push(`${menu.numberColor}${key}.\\w ${text}`);
+
+		for (let i = 0; i < perPage && at * perPage + i < menu.items.length; i++) {
+			const item = at * perPage + i;
+			const callback = this.menuCallbacks[menu.items[item].callback];
+			const args = [player.id, menu.id, item];
+			const answer = callback ? this.withCallArgs(args, () => this.call(callback, args, constant('ITEM_IGNORE'))) : constant('ITEM_IGNORE');
+			const key = (i + 1) % 10;
+			keys.push(key);
+			if (answer !== constant('ITEM_DISABLED')) {
+				line(key, menu.items[item].name);
+				continue;
+			}
+			disabled.push(key);
+			lines.push(`\\d${key}. ${menu.items[item].name}`);
+		}
+
+		const paged = menu.perPage > 0;
+		if (paged) lines.push('');
+		if (paged && at > 0) {
+			keys.push(8);
+			line(8, menu.back);
+		}
+		if (paged && at < pages - 1) {
+			keys.push(9);
+			line(9, menu.next);
+		}
+		if (paged && menu.exit) {
+			keys.push(0);
+			line(0, menu.exitName);
+		}
+
+		player.menu = { menu: menu.id, page: at, text: lines.join('\n'), keys, disabled };
+	}
+
+	/** A key on a menu of AMX Mod X's own: an item to the handler, Back and More a page, Exit MENU_EXIT. Whether the menu took it. @internal */
+	selectMenu(player: FakePlayer, key: number): boolean {
+		const screen = player.menu;
+		const menu = screen ? this.menus.get(screen.menu) : undefined;
+		if (!screen || !menu || !screen.keys.includes(key)) return false;
+
+		const paged = menu.perPage > 0;
+		const turn = paged && key === 8 ? -1 : paged && key === 9 ? 1 : 0;
+		if (turn !== 0 || screen.disabled.includes(key)) {
+			this.displayMenu(player, menu, screen.page + turn);
+			return true;
+		}
+
+		player.menu = null;
+		const perPage = paged ? menu.perPage : 10;
+		this.menuAnswer(menu, player, paged && key === 0 ? constant('MENU_EXIT') : screen.page * perPage + (key === 0 ? 10 : key) - 1);
+		return true;
+	}
+
+	private menuAnswer(menu: FakeMenu, player: FakePlayer, item: number): void {
+		const args = [player.id, menu.id, item];
+		this.withCallArgs(args, () => this.call(menu.handler, args, 0));
+	}
+
+	/**
+	 * A line of the game's log, as the engine hands it to AMX Mod X: split
+	 * into its arguments as AMX Mod X splits it, and every logevent callback
+	 * whose filters it passes is called.
+	 *
+	 * ```ts
+	 * server.gameLog('World triggered "Round_End"');
+	 * server.gameLog(`"${alice.name}<${alice.userid}><STEAM_0:0:1><TERRORIST>" triggered "Planted_The_Bomb"`);
+	 * ```
+	 */
+	gameLog(line: string): void {
+		// AMX Mod X keeps one parsed line: one logged while a callback runs
+		// replaces it, and the walk of the outer line's callbacks goes on with it.
+		this.logLine = line;
+		this.logArgs = splitLog(line);
+		const argc = this.logArgs.length;
+		const passes = (filter: string) => {
+			const match = filter.match(/^(\d+)([=&!])(.*)$/);
+			if (!match) return true;
+			const value = this.logArgs[Number(match[1])] ?? '';
+			return match[2] === '=' ? value === match[3] : match[2] === '&' ? value.includes(match[3]) : value !== match[3];
+		};
+		for (const event of [...this.logEvents]) {
+			if (event.argc === argc && event.filters.every(passes)) this.withCallArgs([], () => this.call(event.slot, [0, 0, 0, 0], 0));
+		}
+	}
+
+	/**
+	 * A fakemeta function the game calls, through the register_forward
+	 * callbacks of it: the pre ones, then, unless one of them superseded it,
+	 * the post ones with `result` as get_orig_retval reads it. Returns whether
+	 * it was superseded and what a callback answered with forward_return.
+	 *
+	 * ```ts
+	 * server.fireForward('FM_EmitSound', [alice.id, 2, 'player/die1.wav', 1.0, 0.8, 0, 100]);
+	 * ```
+	 */
+	fireForward(name: string, args: ArgValue[], result = 0): { superseded: boolean; answer: number | string | null } {
+		const fn = constant(name);
+		const handed = args.slice(0, 4).map(a => typeof a === 'number' ? a : 0);
+		const cells = args.map(a => typeof a === 'number' && !Number.isInteger(a) ? floatBits(a) : a);
+		this.forwardAnswer = null;
+		let superseded = false;
+		for (const slot of [...(this.fakemetaForwards.get(`${fn}:pre`) ?? [])]) {
+			if (this.withCallArgs(cells, () => this.call(slot, handed, slot.fallback)) >= FMRES_SUPERCEDE) superseded = true;
+		}
+		if (!superseded) {
+			this.origRetval = result;
+			for (const slot of [...(this.fakemetaForwards.get(`${fn}:post`) ?? [])]) this.withCallArgs(cells, () => this.call(slot, handed, slot.fallback));
+		}
+		return { superseded, answer: this.forwardAnswer };
+	}
+
+	/** Switches a hook off or on by the handle RegisterHookChain or RegisterHam gave. @internal */
+	switchHook(handle: number, on: boolean): number {
+		const slot = this.hookSlots.get(handle);
+		if (!slot) throw new Error(`the fake server knows no hook handle ${handle}`);
+		slot.off = !on;
+		return 1;
+	}
+
+	/**
+	 * Whether a game event's hook calls the plugin - reapi's chain, or Ham
+	 * Sandwich's function on a class: false while the plugin has switched it
+	 * off, for having no listener; undefined when it was never registered.
+	 *
+	 * ```ts
+	 * server.hooked('resetMaxSpeed');                // the chain, before the game
+	 * server.hooked('spawn', { classname: 'player', post: true });
+	 * ```
+	 */
+	hooked(event: string, options: { post?: boolean; classname?: string } = {}): boolean | undefined {
+		const shape = tables().hooks.get(event);
+		if (!shape) throw new Error(`no hookchain named "${event}" in as/hooks.ts`);
+		const slots = options.classname !== undefined
+			? this.hams.get(`${shape.ham}:${options.classname}:${options.post ? 'post' : 'pre'}`)
+			: this.hookchains.get(shape.kind)?.[options.post ? 'post' : 'pre'];
+		return slots?.length ? slots.some(slot => !slot.off) : undefined;
+	}
+
 	/** A slot by the public name a native was given: "__amxts_cb3". @internal */
 	slotByPublic(name: string): Slot {
 		const match = name.match(/^__amxts_cb(\d+)$/);
@@ -1507,11 +1885,21 @@ export class FakeServer {
 	}
 
 	/** Modules a plugin runs for the others (module.cpp's g_services), and the bytes of the call in flight. @internal */
-	private services: { name: string; hash: number; plugin: number }[] = [];
+	private services: { name: string; hash: number; plugin: PluginInstance | null }[] = [];
 	private rpcRequest = new Uint8Array(0);
 	private rpcReply = new Uint8Array(0);
 	private rpcResult = new Uint8Array(0);
 
+	/** Runs a request in `callee`'s __amxts_rpc, from the run `from` (module.cpp's RunRequest): its answer, or null. */
+	private request(callee: PluginInstance, from: number, request: Uint8Array<ArrayBuffer>): Uint8Array | null {
+		const rpc = callee.instance.exports.__amxts_rpc;
+		if (!rpc) return null;
+		this.rpcRequest = request;
+		this.rpcReply = new Uint8Array(0);
+		this.within(callee, () => rpc(this.rpcRequest.length, from));
+		return this.rpcReply;
+	}
+
 	/**
 	 * The externals the facade declares, as module.cpp registers
 	 * them in g_wasmNatives. Each is called with the plugin that called it.
@@ -1521,30 +1909,32 @@ export class FakeServer {
 		// Shared modules: module.cpp's w_serve, w_owner, w_rpc and the three that move the bytes.
 		amxts_serve(this: FakeServer, plugin: PluginInstance, name: number, hash: number) {
 			const wanted = plugin.memory.string(name);
-			const index = this.plugins.indexOf(plugin);
 			const known = this.services.find(s => s.name === wanted);
-			if (known) Object.assign(known, { hash, plugin: index });
-			else this.services.push({ name: wanted, hash, plugin: index });
+			if (known) Object.assign(known, { hash, plugin });
+			else this.services.push({ name: wanted, hash, plugin });
 		},
 
 		amxts_owner(this: FakeServer, plugin: PluginInstance, name: number, hash: number) {
 			const wanted = plugin.memory.string(name);
+			if (!plugin.uses.includes(wanted)) plugin.uses.push(wanted);
 			const index = this.services.findIndex(s => s.name === wanted);
-			if (index < 0 || this.services[index].plugin < 0) return -1;
+			if (index < 0 || !this.services[index].plugin) return -1;
 			return this.services[index].hash === hash ? index : -2;
 		},
 
 		amxts_rpc(this: FakeServer, plugin: PluginInstance, service: number, target: number, data: number, length: number) {
-			const index = service >= 0 ? (this.services[service]?.plugin ?? -1) : target;
-			const callee = this.plugins[index];
-			const rpc = callee?.instance.exports.__amxts_rpc;
-			if (!rpc) return -1;
-			this.rpcRequest = new Uint8Array(plugin.instance.exports.memory.buffer, data, length).slice();
-			this.rpcReply = new Uint8Array(0);
-			this.within(callee, () => rpc(length, this.plugins.indexOf(plugin)));
-			const answer = new Uint8Array(4 + this.rpcReply.length);
-			new DataView(answer.buffer).setInt32(0, index, true);
-			answer.set(this.rpcReply, 4);
+			const callee = service >= 0 ? this.services[service]?.plugin : this.plugins.find(one => one.run === target);
+
+			if (service < 0 && !callee && !plugin.toldGone) {
+				plugin.toldGone = true;
+				this.logLines.push(`[amxts] ${plugin.source} called back a function of a plugin that was unloaded or reloaded since - the call answers nothing`);
+			}
+
+			const reply = callee ? this.request(callee, plugin.run, new Uint8Array(plugin.instance.exports.memory.buffer, data, length).slice()) : null;
+			if (!callee || !reply) return -1;
+			const answer = new Uint8Array(4 + reply.length);
+			new DataView(answer.buffer).setInt32(0, callee.run, true);
+			answer.set(reply, 4);
 			this.rpcResult = answer;
 			return answer.length;
 		},
@@ -1563,11 +1953,58 @@ export class FakeServer {
 			this.rpcResult = new Uint8Array(0);
 		},
 
+		// The network client: module.cpp's w_net_*, over Bun's fetch and FTP and SFTP clients (network.ts).
+		net_open(this: FakeServer, plugin: PluginInstance, url: number) {
+			return this.network.open(plugin, plugin.memory.string(url));
+		},
+		net_option(this: FakeServer, plugin: PluginInstance, id: number, name: number, value: number) {
+			return this.network.option(plugin, id, plugin.memory.string(name), plugin.memory.string(value));
+		},
+		net_body(this: FakeServer, plugin: PluginInstance, id: number, data: number, length: number) {
+			this.network.body(plugin, id, new Uint8Array(plugin.instance.exports.memory.buffer, data, length).slice());
+		},
+		net_send(this: FakeServer, plugin: PluginInstance, id: number, fn: number) {
+			return this.network.send(plugin, id, fn);
+		},
+		net_cancel(this: FakeServer, plugin: PluginInstance, id: number) {
+			this.network.cancel(plugin, id);
+		},
+		net_close(this: FakeServer, plugin: PluginInstance, id: number) {
+			this.network.cancel(plugin, id);
+		},
+		net_status(this: FakeServer, plugin: PluginInstance, id: number) {
+			return this.network.status(plugin, id);
+		},
+		net_redirects(this: FakeServer, plugin: PluginInstance, id: number) {
+			return this.network.redirects(plugin, id);
+		},
+		net_text(this: FakeServer, plugin: PluginInstance, id: number, what: number, out: number, max: number) {
+			return this.network.text(plugin, id, what, out, max);
+		},
+		net_size(this: FakeServer, plugin: PluginInstance, id: number) {
+			return this.network.size(plugin, id);
+		},
+		net_read(this: FakeServer, plugin: PluginInstance, id: number, out: number, max: number) {
+			return this.network.read(plugin, id, out, max);
+		},
+		net_reply(this: FakeServer, plugin: PluginInstance, id: number) {
+			return this.network.reply(plugin, id);
+		},
+
 		abort(this: FakeServer, plugin: PluginInstance, message: number, file: number, line: number, column: number) {
 			const text = message ? plugin.memory.string(message) : 'assertion failed';
 			throw new Error(`abort: ${text} (${file ? plugin.memory.string(file) : '?'}:${line}:${column})`);
 		},
 
+		// An error's stack: the server reads frames WAMR keeps, which a
+		// plugin run here has none of - `stack` is the error's first line.
+		stack_frames() {
+			return 0;
+		},
+		stack_text() {
+			return 0;
+		},
+
 		seed() {
 			return Date.now();
 		},
@@ -1636,6 +2073,22 @@ export class FakeServer {
 			list.push({ plugin, fn, shape });
 		},
 
+		// The plugin's handler of a forward taken off, once its event has no listener left.
+		off(this: FakeServer, plugin: PluginInstance, name: number, fn: number) {
+			const list = this.events.get(plugin.memory.string(name)) ?? [];
+			for (let i = list.length - 1; i >= 0; i--) {
+				if (list[i].plugin === plugin && list[i].fn === fn) list.splice(i, 1);
+			}
+		},
+
+		// on, for the calls whose argument `arg` is `value` alone - compared before the plugin, as module.cpp does.
+		on_cell(this: FakeServer, plugin: PluginInstance, name: number, fn: number, shape: number, arg: number, value: number) {
+			const event = plugin.memory.string(name);
+			let list = this.events.get(event);
+			if (!list) this.events.set(event, list = []);
+			list.push({ plugin, fn, shape, where: { arg, value } });
+		},
+
 		subscribe(this: FakeServer, plugin: PluginInstance, name: number, fn: number, tag: number) {
 			const forward = plugin.memory.string(name);
 			let list = this.subscriptions.get(forward);
@@ -1661,8 +2114,19 @@ export class FakeServer {
 			this.withCallArgs(args, () => this.deliver(forward));
 		},
 
+		// A slot a reload left takes the same file's plugin back, as SLOT_REUSED says in module.cpp.
 		slot(this: FakeServer, plugin: PluginInstance, fn: number, shape: number, key: number, fallback: number) {
-			return this.takeSlot(plugin, fn, shape, plugin.memory.string(key), fallback).index;
+			const name = plugin.memory.string(key);
+			const left = name ? this.slots.find(one => one.key === name && one.plugin.unloaded && one.plugin.source === plugin.source) : undefined;
+			if (!left) return this.takeSlot(plugin, fn, shape, name, fallback).index;
+			Object.assign(left, { plugin, fn, shape, fallback, tag: this.takeTag() });
+			return left.index | SLOT_REUSED;
+		},
+
+		// One of the plugin's slots switched off while what it delivers has no listener, or back on.
+		slot_on(this: FakeServer, plugin: PluginInstance, index: number, on: number) {
+			const slot = this.slots[index];
+			if (slot?.plugin === plugin) slot.off = on === 0;
 		},
 
 		clcmd(this: FakeServer, plugin: PluginInstance, pattern: number, fn: number, flags: number, info: number, shape: number) {
@@ -1698,7 +2162,8 @@ export class FakeServer {
 			let chain = this.hookchains.get(kind);
 			if (!chain) this.hookchains.set(kind, chain = { pre: [], post: [] });
 			(post ? chain.post : chain.pre).push(slot);
-			return ++this.hookHandles;
+			this.hookSlots.set(this.hookSlots.size + 1, slot);
+			return this.hookSlots.size;
 		},
 
 		// RegisterHam: kept by the function's id and the class, for hamCall().
@@ -1708,7 +2173,8 @@ export class FakeServer {
 			const list = this.hams.get(key) ?? [];
 			list.push(slot);
 			this.hams.set(key, list);
-			return ++this.hookHandles;
+			this.hookSlots.set(this.hookSlots.size + 1, slot);
+			return this.hookSlots.size;
 		},
 
 		tag(this: FakeServer, _plugin: PluginInstance, tag: number) {
@@ -1788,6 +2254,64 @@ export class FakeServer {
 			return length;
 		},
 
+		// Entity fields and members, as the module reads them where the game
+		// keeps them (runtime/src/fields.h): an entvar by its offset in
+		// entvars_t, a member by the slot member_slot gave its gamedata name,
+		// the game rules' by the id -1.
+		ent_get(this: FakeServer, plugin: PluginInstance, id: number, offset: number) {
+			const at = tables().entvarAt.get(offset);
+			return at ? fieldCell(this.entities.get(id), at.field, at.component) : 0;
+		},
+
+		ent_set(this: FakeServer, plugin: PluginInstance, id: number, offset: number, cell: number) {
+			const at = tables().entvarAt.get(offset);
+			if (at) setFieldCell(this.entities.get(id), at.field, cell, at.component);
+		},
+
+		ent_entity(this: FakeServer, plugin: PluginInstance, id: number, offset: number) {
+			const at = tables().entvarAt.get(offset);
+			return at ? fieldCell(this.entities.get(id), at.field) : 0;
+		},
+
+		ent_set_entity(this: FakeServer, plugin: PluginInstance, id: number, offset: number, index: number) {
+			const at = tables().entvarAt.get(offset);
+			if (at) setFieldCell(this.entities.get(id), at.field, Math.max(index, 0));
+		},
+
+		member_slot(this: FakeServer, plugin: PluginInstance, className: number, name: number) {
+			const key = `${plugin.memory.string(className)}::${plugin.memory.string(name)}`;
+			const field = tables().memberNamed.get(key);
+			if (field === undefined) throw new Error(`no reapi member is ${key} in the gamedata`);
+			const slot = this.memberSlots.indexOf(field);
+			return slot >= 0 ? slot : this.memberSlots.push(field) - 1;
+		},
+
+		member_get(this: FakeServer, plugin: PluginInstance, id: number, slot: number, element: number) {
+			const field = this.memberSlots[slot];
+			if (id === -1) return this.rules.get(field) ?? 0;
+			return fieldCell(this.entities.get(id), field, element);
+		},
+
+		member_set(this: FakeServer, plugin: PluginInstance, id: number, slot: number, element: number, cell: number) {
+			const field = this.memberSlots[slot];
+			if (id === -1) this.rules.set(field, cell);
+			else setFieldCell(this.entities.get(id), field, cell, element);
+		},
+
+		member_text(this: FakeServer, plugin: PluginInstance, id: number, slot: number, out: number, max: number) {
+			const value = this.entities.get(id)?.fields.get(FakeEntity.key(this.memberSlots[slot]));
+			return plugin.memory.setUtf8(out, max, typeof value === 'string' ? value : '');
+		},
+
+		member_set_text(this: FakeServer, plugin: PluginInstance, id: number, slot: number, text: number) {
+			this.entities.get(id)?.fields.set(FakeEntity.key(this.memberSlots[slot]), plugin.memory.string(text));
+		},
+
+		// The fake keeps its game rules where the module would find them.
+		game_rules() {
+			return 1;
+		},
+
 		// The fields plugins add to Player: the imports their generated accessors call.
 		player_data_get(this: FakeServer, plugin: PluginInstance, id: number, key: number) {
 			return this.playerNumber(id, plugin.memory.string(key));
@@ -1811,7 +2335,7 @@ export class FakeServer {
 			this.setPlayerData(id, plugin.memory.string(key), plugin.memory.string(value), true);
 		},
 
-		// playerchange: the module wakes a plugin for the fields it listens for.
+		// playerChange: the module wakes a plugin for the fields it listens for.
 		player_change_listen(this: FakeServer, plugin: PluginInstance, field: number, fn: number) {
 			const name = plugin.memory.string(field);
 			const known = this.fieldListeners.find(one => one.plugin === plugin);