@amxts/core 0.2.4 → 0.3.0

package/src/testing/server.ts

@@ -1,22 +1,25 @@
 import type { PluginNative } from '../../scripts/plugin-natives';
 import type { Native, NativeCall } from './natives';
 import type { HookShape } from './tables';
-import { pawnLayout } from '../../scripts/plugin-natives';
 // A game server in TypeScript, standing where runtime/src/module.cpp and AMX
 // Mod X stand on a real one.
 //
 // A plugin's wasm imports two things from "env": the bridge externals the
 // facade declares (slot, clcmd, task, on, hook, call, arg_text, say_text ...)
 // and the natives as/natives.ts declares, which take Pawn cells. The bridge is
-// implemented here the way module.cpp implements it - callback slots, the
+// implemented here the way module.cpp implements it - publicFor names, the
 // events registry, Fire with its outcome - and the natives in natives.ts,
 // against the players and entities below. An import neither covers throws,
 // naming itself, the first time the plugin calls it.
+import { basename } from 'node:path';
+import { inflateRawSync } from 'node:zlib';
+import { pawnLayout } from '../../scripts/plugin-natives';
+import { envProblems, parseDotenv } from '../../scripts/server-env';
 import { compile } from './compile';
-import { Coroutines, nextTaskId } from './coroutines';
+import { Coroutines } from './coroutines';
 import { installKitFor } from './kits';
 import { bitsFloat, floatBits, Memory, utf8Fit } from './memory';
-import { fieldCell, NATIVES, setFieldCell, WEAPON_NAMES } from './natives';
+import { AUTH_TYPES, clientCommand, fieldCell, giveWeapon, NATIVES, setFieldCell, switchTo, WEAPON_NAMES } from './natives';
 import { FakeNetwork } from './network';
 import { constant, tables } from './tables';
 
@@ -48,6 +51,13 @@ export function normalizePath(path: string): string {
 	return path.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
 }
 
+/** A path of the game folder, or null when it would leave it - absolute, a drive, a `..` - as the module's GamePath. */
+function gamePath(path: string): string | null {
+	const normal = normalizePath(path);
+	if (normal === '' || path.startsWith('/') || path.startsWith('\\') || path.includes(':') || normal.split('/').includes('..')) return null;
+	return normal;
+}
+
 /** A parameter's include default as the value Pawn passes when the call leaves it out. */
 function pawnDefaultValue(text: string | null): Value {
 	if (text === null) return 0;
@@ -67,6 +77,13 @@ interface Handler {
 	tag?: number;
 	/** on_cell's filter: the handler hears the forward only when this argument is `value`. */
 	where?: { arg: number; value: number };
+	/**
+	 * The plugin's one listener, called in place of the handler with the
+	 * event's object (Handler.via in module.cpp, set by on_direct and
+	 * hook_direct): its table index, its closure's variables, the object, and
+	 * whether the first cell is the player an async function runs under.
+	 */
+	via?: { fn: number; env: number; arg: number; player: boolean };
 }
 
 /** A host public standing in for a handler: `__amxts_cb<index>`. */
@@ -81,11 +98,14 @@ interface Slot extends Handler {
 	 * answers the fallback without reaching the plugin.
 	 */
 	off?: boolean;
+	/** A command's admin flags: a player with none of them does not reach it. */
+	access?: number;
 }
 
 interface Task {
 	slot: Slot;
-	id: number;
+	/** The timer's own slot, which task hands the plugin: the lowest free one, as module.cpp reuses them. */
+	timer: number;
 	interval: number;
 	due: number;
 	repeat: boolean;
@@ -99,13 +119,17 @@ interface Cvar {
 	hooks: Slot[];
 }
 
-/** The hookchain being run, for GetHookChainReturn and friends. */
+/** The hooked call being run: what chain_set writes and arg(-1) reads. */
 export interface Chain {
 	shape: HookShape;
 	answer: Value;
 	args: HookArg[];
-	/** SetHookChainReturn ran: reapi lets a chain that answers be stopped only then. */
+	/** The arguments as cells, which arg() reads: a float as its bits, a vector as three. */
+	cells: ArgValue[];
+	/** A listener answered (chain_set(-1)): the game's own answer is not taken. */
 	answered?: boolean;
+	/** A Ham Sandwich function's call: a boolean answer is a number, as Ham Sandwich gives it. */
+	ham?: boolean;
 }
 
 /** What firing a hookchain came to. */
@@ -128,9 +152,9 @@ export interface UserMessage {
 	player: number;
 	/** What was written, in order: bytes, shorts and longs as numbers, strings as text. */
 	args: (number | string)[];
-	/** For a temporary effect (`SVC_TEMPENTITY`): who it went to, as `MSG_*` - `0` everyone, `4` those who see `origin`, `8` one player. */
+	/** For the engine's own message (`SVC_TEMPENTITY`, `SVC_NEWMOVEVARS`, ...): who it went to, as `MSG_*` - `0` everyone, `4` those who see `origin`, `8` one player. */
 	dest?: number;
-	/** For a temporary effect: the point it is seen from, with `dest` `4`. */
+	/** For the engine's own message: the point it is seen from, with `dest` `4`. */
 	origin?: number[];
 }
 
@@ -174,7 +198,10 @@ export interface MenuScreen {
 /** One line a player was shown. */
 export interface Message {
 	variant: 'chat' | 'center' | 'console' | 'notify' | 'hud';
+	/** The text, colour codes taken out. */
 	text: string;
+	/** The line as the client got it, colour codes `\x01`-`\x04` kept. */
+	raw: string;
 }
 
 export interface ServerOptions {
@@ -188,6 +215,8 @@ export interface ServerOptions {
 	cvars?: Record<string, string>;
 	/** Files in the game folder before the plugin loads, by path: `{ "addons/amxmodx/configs/x.ini": "..." }`. */
 	files?: Record<string, string>;
+	/** The server's environment, which `env()` reads over `addons/amxts/.env`: `{ MYPLUGIN_TOKEN: "abc" }`. None unless said. */
+	env?: Record<string, string>;
 	/**
 	 * 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.
@@ -195,8 +224,14 @@ export interface ServerOptions {
 	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. */
+	/** Whether the server has Reunion, so a player's `authType`, `protocol` and `authKey` are his own: the first two through ReHLDS (`chains`), the key through reapi. Not unless said. */
 	reunion?: boolean;
+	/**
+	 * Whether the server has ReGameDLL and ReHLDS - their hookchains, which the
+	 * module hooks itself, and ReGameDLL's API, through which it acts. As it has
+	 * reapi (`modules`) unless said: a server without reapi is plain HLDS's model.
+	 */
+	chains?: boolean;
 }
 
 export type TeamName = 'UNASSIGNED' | 'TERRORIST' | 'CT' | 'SPECTATOR';
@@ -228,20 +263,30 @@ 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;
+const SLOT_REUSED = 0x40000000;
 /** 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, and fakemeta's.
-const HAM_SUPERCEDE = 4;
+// What a hooked function's listener says: the game's function does not run;
+// and the listeners after it do not either (OUTCOME_* in gamehooks.h).
+const OUTCOME_BREAK = 2;
+// fakemeta's answer that blocks the game's function.
 const FMRES_SUPERCEDE = 4;
 // A message argument's types, as get_msg_argtype answers.
 const ARG_BYTE = 1;
+const ARG_ANGLE = 5;
 const ARG_COORD = 6;
 const ARG_STRING = 7;
 
+// A message's destination, as the module hands it to a message's hook.
+const MSG_ONE = 1;
+const MSG_ALL = 2;
+
+// The functions stock_hook takes, by number (STOCK_* in as/facade.ts), and
+// the fakemeta function each is.
+const STOCK_FUNCTIONS = ['FM_SetModel', 'FM_EmitSound', 'FM_Voice_SetClientListening', 'FM_PrecacheModel', 'FM_PrecacheSound', 'FM_PrecacheGeneric', 'FM_GetGameDescription'];
+const STOCK_CVAR_ANSWER = 7;
+
 /**
  * Date#getTimezoneOffset() in a time zone: minutes from its wall clock at
  * that moment to UTC, UTC+4 being -240. This machine's without one.
@@ -303,11 +348,52 @@ export class FakeWeapon extends FakeEntity {
 	constructor(server: FakeServer, id: number, readonly kind: string, owner: number) {
 		super(server, id, kind);
 		this.set('m_iId', WEAPON_NAMES.indexOf(kind));
+		this.set('m_Weapon_iPrimaryAmmoType', ammoTypeOf(kind));
 		this.set('var_owner', owner);
 		this.set('m_pPlayer', owner);
 	}
 }
 
+/** A player's backpack ammo by weapon name, read and written in his m_rgAmmo. */
+class AmmoMap extends Map<string, number> {
+	constructor(private readonly owner: FakeEntity) {
+		super();
+	}
+
+	override get(weapon: string): number {
+		return ammoTypeOf(weapon) < 0 ? 0 : Number(this.owner.get('m_rgAmmo', ammoTypeOf(weapon)));
+	}
+
+	override set(weapon: string, amount: number): this {
+		if (ammoTypeOf(weapon) >= 0) this.owner.set('m_rgAmmo', amount, ammoTypeOf(weapon));
+		return this;
+	}
+}
+
+/** The kind of ammo a weapon takes, its place in m_rgAmmo, as the game numbers them; -1 for none. */
+function ammoTypeOf(kind: string): number {
+	const at = AMMO_KINDS.findIndex(weapons => weapons.split(' ').includes(kind.replace('weapon_', '')));
+	return at < 0 ? -1 : at + 1;
+}
+
+/** The weapons each kind of ammo is for, from 1: .338 Magnum, 7.62 NATO, ... the bomb. */
+const AMMO_KINDS = [
+	'awp',
+	'ak47 scout g3sg1',
+	'm249',
+	'aug sg550 galil famas m4a1 sg552',
+	'm3 xm1014',
+	'usp mac10 ump45',
+	'p90 fiveseven',
+	'deagle',
+	'p228',
+	'glock18 mp5navy tmp elite',
+	'flashbang',
+	'hegrenade',
+	'smokegrenade',
+	'c4',
+];
+
 /** Which of m_rgpPlayerItems a weapon goes in: 1 primary, 2 pistol, 3 knife, 4 grenades, 5 C4. */
 function slotOf(kind: string): number {
 	if (kind === 'weapon_knife') return 3;
@@ -331,12 +417,16 @@ export class FakePlayer extends FakeEntity {
 	flags: number;
 	/** SPEAK_* flags: `muted` is SPEAK_MUTED. */
 	speak = 0;
-	/** Backpack ammo by weapon name. */
-	readonly ammo = new Map<string, number>();
+	/** Backpack ammo by weapon name: his m_rgAmmo at the weapon's kind of ammo, as the game keeps it. */
+	readonly ammo: Map<string, number> = new AmmoMap(this);
 	/** Every line he was shown, in order. */
 	readonly messages: Message[] = [];
 	/** What was run in his console: client_cmd, engclient_cmd. */
 	readonly commands: string[] = [];
+	/** Whether his steps make no sound (player_silent). */
+	silentSteps = false;
+	/** When he connected, by the server's clock (`server.time`, milliseconds). */
+	readonly connectedAt: number;
 	/** 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. */
@@ -344,8 +434,22 @@ export class FakePlayer extends FakeEntity {
 	/** 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) {
+	/** His name. A new one reaches the plugins as AMX Mod X's does: their facades read it again. */
+	get name(): string {
+		return this.named;
+	}
+
+	set name(value: string) {
+		this.named = value;
+		this.set('var_netname', value);
+		this.server.countNameChange(this.id);
+	}
+
+	private named: string;
+
+	constructor(server: FakeServer, id: number, name: string, options: JoinOptions) {
 		super(server, id, 'player');
+		this.named = name;
 		this.alive = options.alive ?? true;
 		this.bot = options.bot ?? false;
 		this.steamId = options.steamId ?? (this.bot ? 'BOT' : `STEAM_0:0:${id}`);
@@ -355,6 +459,7 @@ export class FakePlayer extends FakeEntity {
 		this.authKey = options.authKey ?? '';
 		this.flags = flagBits(options.flags ?? 'z');
 		this.userid = server.nextUserid();
+		this.connectedAt = server.time;
 		this.team = options.team ?? 'CT';
 		this.health = options.health ?? 100;
 		this.armor = options.armor ?? 0;
@@ -387,6 +492,11 @@ export class FakePlayer extends FakeEntity {
 
 	/** The chat lines he was shown, one a line, colour bytes taken out. */
 	get chat(): string { return this.lines('chat'); }
+	/**
+	 * The chat lines as the client got them, colour codes `\x01`-`\x04` kept:
+	 * the client draws no colour in a line that does not start with one.
+	 */
+	get chatRaw(): string { return this.messages.filter(m => m.variant === 'chat').map(m => m.raw).join('\n'); }
 	/** What was printed in the middle of his screen. */
 	get center(): string { return this.lines('center'); }
 	/** What was printed in his console. */
@@ -402,7 +512,7 @@ export class FakePlayer extends FakeEntity {
 	show(variant: Message['variant'], text: string): void {
 		// The colour codes ^1-^4 a chat line carries are not text.
 		// oxlint-disable-next-line no-control-regex
-		this.messages.push({ variant, text: text.replace(/[\x01-\x04]/g, '') });
+		this.messages.push({ variant, text: text.replace(/[\x01-\x04]/g, ''), raw: text });
 	}
 
 	/** Forgets what he was shown, for a test that checks one step at a time. */
@@ -448,6 +558,21 @@ export class FakePlayer extends FakeEntity {
 		return weapon;
 	}
 
+	/** Takes a weapon out of his slots, as the game's RemovePlayerItem does: it is no longer his. */
+	takeWeapon(weapon: FakeEntity): void {
+		const slot = slotOf(weapon.classname);
+		const first = Number(this.get('m_rgpPlayerItems', slot));
+		if (first === weapon.id) {
+			this.set('m_rgpPlayerItems', Number(weapon.get('m_pNext')), slot);
+		} else {
+			for (let at = this.server.entities.get(first); at; at = this.server.entities.get(Number(at.get('m_pNext')))) {
+				if (Number(at.get('m_pNext')) === weapon.id) at.set('m_pNext', Number(weapon.get('m_pNext')));
+			}
+		}
+		weapon.set('m_pNext', 0);
+		if (Number(this.get('m_pActiveItem')) === weapon.id) this.set('m_pActiveItem', 0);
+	}
+
 	/** Takes every weapon away. */
 	stripWeapons(): void {
 		for (const weapon of this.items) this.server.entities.delete(weapon.id);
@@ -477,12 +602,17 @@ export class FakePlayer extends FakeEntity {
 
 	/**
 	 * 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.
+	 * `menuselect <key>` goes to his menu of AMX Mod X's own first, as AMX Mod
+	 * X takes it, and last to the menu a plugin's Menu shows him, as the
+	 * module takes it; the key `0` or `10`. True if handled.
 	 */
 	command(line: string): boolean {
 		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);
+		const select = argv[0] === 'menuselect';
+		const key = Number(argv[1]) % 10;
+		const pressed = select ? this.server.takeMenuKey(this, key) : null;
+		if (select && this.menu && this.server.selectMenu(this, key)) return true;
+		return this.server.clientCommand(this, argv) || (pressed !== null && this.server.pressMenu(this, pressed));
 	}
 
 	/** Leaves the server: the disconnect events, then the slot is free. */
@@ -491,6 +621,7 @@ export class FakePlayer extends FakeEntity {
 		const reason = options.reason ?? 'Client sent \'drop\'';
 		this.server.fire('client_disconnected', this.id, dropped, reason, 192);
 		this.server.clearPlayerData(this.id);
+		this.server.shownMenus.delete(this.id);
 		this.server.fire('client_disconnect', this.id);
 		this.connected = false;
 		this.alive = false;
@@ -520,6 +651,10 @@ function unsimulated(name: string): Error {
 }
 
 /** A command line as the engine splits it: on spaces, a quoted part kept whole. */
+function addTo(commands: Map<string, Slot[]>, name: string, slot: Slot): void {
+	commands.set(name, [...(commands.get(name) ?? []), slot]);
+}
+
 function splitCommand(line: string): string[] {
 	return [...line.matchAll(/"([^"]*)"|(\S+)/g)].map(m => m[1] ?? m[2]);
 }
@@ -539,6 +674,12 @@ export function splitLog(line: string): string[] {
 /** The runs handed out so far: each plugin loaded is a new one. */
 let runs = 0;
 
+/** A trace's start and end, six numbers (f64) where the plugin's facade put them. */
+function tracePoints(plugin: PluginInstance, at: number): number[][] {
+	const numbers = Array.from({ length: 6 }, (_, i) => plugin.memory.number(at + i * 8));
+	return [numbers.slice(0, 3), numbers.slice(3)];
+}
+
 export class PluginInstance {
 	instance: any;
 	memory!: Memory;
@@ -552,6 +693,10 @@ export class PluginInstance {
 	readonly uses: string[] = [];
 	/** It called back a function of a plugin unloaded since, and was told so: once. */
 	toldGone = false;
+	/** Where its facade's table of the slots a new player took is (player_slots); 0 until it gives one. */
+	playerSlots = 0;
+	/** Where its facade's count of each slot's name changes is (player_names); 0 until it gives one. */
+	playerNames = 0;
 
 	/** The coroutine scheduler, for a plugin that awaits; null for one that does not. */
 	readonly coroutines: Coroutines | null;
@@ -584,12 +729,13 @@ export class PluginInstance {
 			return (...args: number[]) => bridge.call(this.server, this, ...args);
 		}
 
-		if (this.server.hasNative(name)) return (...args: number[]) => this.server.callNativeImpl(this, name, args);
+		const marks = tables().crossings.get(name) ?? [];
+		if (this.server.hasNative(name)) return (...args: number[]) => this.memory.across(marks, args, cells => this.server.callNativeImpl(this, name, cells));
 
 		// 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);
+		return (...args: number[]) => {
+			if (this.server.exported.has(name)) return this.memory.across(marks, args, cells => this.server.callFromPlugin(this, name, cells));
 			throw unsimulated(name);
 		};
 	}
@@ -609,8 +755,30 @@ export class FakeServer {
 	readonly map: string;
 	readonly maxPlayers: number;
 	readonly modules: Set<string>;
+	/** The GeoIP database, by address: `server.countries.set("1.2.3.4", { code: "DE", name: "Germany" })`. */
+	readonly countries = new Map<string, { code: string; name: string }>();
+	/** The server's environment, which `env()` reads over `addons/amxts/.env` (a file in `files`). */
+	env: Record<string, string>;
+	/** The model a plugin put on each player (player.model), by his id. */
+	readonly models = new Map<number, string>();
+	/** The entity each player sees through (player.view), by his id; 0 or none for his own eyes. */
+	readonly views = new Map<number, number>();
+	/** The maps the fake server has: map_valid and change_level know these. */
+	readonly maps: string[] = ['de_dust2', 'de_inferno', 'cs_office'];
+	/**
+	 * Walls of the fake world a trace stops at: a plane at `x`, with the
+	 * entity a trace that meets it hits (0, the world, when left out) and the
+	 * hit group.
+	 */
+	readonly walls: { x: number; entity?: number; hitGroup?: number }[] = [];
+	/** What plugins asked of plugins (server.plugins), in order: "stop shop.aot", "reload shop.aot". */
+	readonly pluginActions: string[] = [];
+	/** What the game rules were asked to run, in order: "restartRound", "checkWinConditions". */
+	readonly rulesRuns: string[] = [];
 	/** Whether reapi finds Reunion (has_reunion). */
 	readonly reunion: boolean;
+	/** Whether the module finds ReGameDLL's and ReHLDS's hookchains (game_api). */
+	readonly chains: boolean;
 	/** Milliseconds since the map started; advance() moves it. */
 	time = 0;
 	/** Date.now() when the map started. */
@@ -666,13 +834,28 @@ export class FakeServer {
 	readonly exported = new Map<string, Handler>();
 	readonly cvars = new Map<string, Cvar>();
 	readonly vaultHandles: string[] = [];
+	/** The Storages plugins opened, by handle: their names. */
+	readonly storeNames: string[] = [];
+	/** When each Storage key was last set, by "name\0key": the fake's clock, in seconds. */
+	readonly storeTimes = new Map<string, number>();
 	readonly forwardHandles: { name: string; types: number[] }[] = [];
-	hud = { color: [200, 100, 0], x: -1, y: 0.35, hold: 12, channel: -1 };
+	/** How the last HUD message was sent: its colour, place, hold, channel (-1 automatic), line (0 none) and size. */
+	hud = { color: [200, 100, 0], x: -1, y: 0.35, hold: 12, channel: -1, line: 0, large: false };
+	/** The HUD lines plugins made. */
+	hudLines = 0;
 
 	/** 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[] = [];
+	/**
+	 * What playbackEvent's listeners asked of the last event `fire` raised:
+	 * stopped (`preventDefault()`), or played only to these player ids
+	 * (`recipients`), `null` for all it reaches.
+	 */
+	playback: { blocked: boolean; recipients: number[] | null } = { blocked: false, recipients: null };
+	/** The map's light, as `server.lightStyle` last set it: `"m"` the map's own. */
+	lightStyle = 'm';
 	/** 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). */
@@ -682,6 +865,12 @@ export class FakeServer {
 	 * went to (0 for everyone), and what was written, write_* by write_*.
 	 */
 	readonly userMessages: UserMessage[] = [];
+	/**
+	 * The player's movement a movement event (`airMove`, `jumpMovement`, ...)
+	 * reads: `event.touchCount` and `event.frameTime`. Set it before
+	 * fireHook.
+	 */
+	readonly playerMove = { touchCount: 0, frameTime: 0 };
 	/** The ids get_user_msgid handed out, by name - ShowMenu's is the game's 96. @internal */
 	readonly messageIds = new Map<string, number>([['ShowMenu', 96]]);
 	/** The message between message_begin and message_end. @internal */
@@ -704,10 +893,16 @@ export class FakeServer {
 	readonly hamCalls: { fn: number; entity: number; args: number[]; hooks: boolean }[] = [];
 	/** register_message's callbacks, by the message's id. */
 	readonly messageHooks = new Map<number, Slot[]>();
+	/** The module's hooks of a message (msg_hook), by its id: they hear it after register_message's. @internal */
+	readonly moduleMessageHooks = new Map<number, Slot[]>();
 	/** The message register_message's callbacks are reading and writing: its arguments and their ARG_* types. @internal */
 	hookedMessage: { args: (number | string)[]; types: number[] } | null = null;
 	/** register_touch's callbacks. */
 	readonly touches: { touched: string; toucher: string; slot: Slot }[] = [];
+	/** The entityState listeners' hooks: the class each is about, "" any. */
+	readonly stateHooks: { classname: string; slot: Slot }[] = [];
+	/** The state being sent while its listeners run (sendState), by the module's field numbers. */
+	sending: number[] | null = null;
 	/** 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 */
@@ -718,6 +913,8 @@ export class FakeServer {
 	readonly messageEvents: { name: string; conditions: string[]; slot: Slot }[] = [];
 	/** register_forward's callbacks, by `<FM_* number>:pre|post`. */
 	readonly fakemetaForwards = new Map<string, Slot[]>();
+	/** The module's hooks of the same functions (stock_hook), by `<STOCK_* number>:pre|post`. @internal */
+	readonly stockHooks = 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;
@@ -725,12 +922,15 @@ export class FakeServer {
 	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 }[] = [];
+	/** query_client_cvar's questions, and the module's (query_cvar) by their ids, waiting for answerCvar(). */
+	readonly cvarQueries: { player: number; cvar: string; slot?: Slot; request?: number }[] = [];
+	private cvarRequests = 0;
 	/** 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[] = [];
+	/** The menu a plugin's Menu shows each player (menu_open), by his id: its handler of the keys, and the keys it takes as show_menu's bits. @internal */
+	readonly shownMenus = new Map<number, Handler & { keys: number }>();
 	private menuIds = 0;
 	private userids = 1;
 
@@ -776,10 +976,15 @@ export class FakeServer {
 		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.chains = options.chains ?? this.modules.has('reapi');
+		// The voice manager counts the server's slots, as the game sets it up.
+		this.rules.set(constant('m_nMaxPlayers'), this.maxPlayers);
 		this.entityIds = this.maxPlayers + 1;
 		this.timeZone = options.timeZone;
-		// AMX Mod X's own, which a test may set: the languages.
-		const cvars = { amx_language: 'en', amx_client_languages: '1', ...options.cvars };
+		this.env = { ...options.env };
+		// AMX Mod X's own, which a test may set: the languages; and the game's
+		// a plugin often sets, at the game's defaults.
+		const cvars = { amx_language: 'en', amx_client_languages: '1', mp_freezetime: '6', mp_round_infinite: '0', ...options.cvars };
 		for (const [name, value] of Object.entries(cvars)) this.createCvar(name, value);
 		for (const [path, text] of Object.entries(options.files ?? {})) this.writeFile(path, text);
 		if (options.platform === 'win32') this.writeFile('addons/amxmodx/modules/amxts_amxx.dll', '');
@@ -816,7 +1021,10 @@ export class FakeServer {
 	 */
 	async load(source: string): Promise<PluginInstance> {
 		await installKitFor(this, source);
-		const { module, natives, binary, async } = await compile(source);
+		const { module, natives, binary, async, env } = await compile(source);
+		// A variable it requires that neither the environment nor .env has, or one of another kind, keeps it from starting, as the module does.
+		const missing = envProblems(env, this.variables());
+		if (missing.length) throw new Error(`[amxts] ${basename(source, '.ts')} needs ${missing.join(', ')} in addons/amxts/.env`);
 		const plugin = new PluginInstance(this, source, module, natives, async ? binary : undefined);
 		this.plugins.push(plugin);
 		for (const native of natives) {
@@ -861,6 +1069,13 @@ export class FakeServer {
 		return this.cvars.get(name.toLowerCase())?.value;
 	}
 
+	/** What `env()` reads: `addons/amxts/.env`, and the environment over it. @internal */
+	variables(): Map<string, string> {
+		const variables = parseDotenv(this.file('addons/amxts/.env') ?? '');
+		for (const [name, value] of Object.entries(this.env)) variables.set(name, value);
+		return variables;
+	}
+
 	/** Sets a cvar as the console would: `mp_freezetime 5`, and its change listeners hear it. */
 	setCvar(name: string, value: string | number): void {
 		const cvar = this.cvars.get(name.toLowerCase()) ?? this.createCvar(name, '');
@@ -880,8 +1095,12 @@ export class FakeServer {
 
 	// ------------------------------------------------------------ dictionaries
 
-	/** The dictionaries' lines by language, then key: what register_dictionary loaded and translate() added. */
-	readonly dictionary = new Map<string, Map<string, string>>();
+	/**
+	 * The dictionaries' lines by language, then key: what register_dictionary
+	 * loaded and translate() added. It starts with the languages AMX Mod X's
+	 * own dictionaries bring, as a server's does.
+	 */
+	readonly dictionary = new Map<string, Map<string, string>>(['en', 'de', 'sr', 'tr', 'fr', 'sv', 'da', 'pl', 'nl', 'es', 'bp', 'cz', 'fi', 'ru'].map(code => [code, new Map()]));
 	/** Every key in the order it came, as GetLangTransKey numbers them. */
 	private readonly langKeys: string[] = [];
 
@@ -986,11 +1205,36 @@ export class FakeServer {
 		return array.items.map(item => array.cellSize === 1 ? item[0] : [...item]);
 	}
 
-	/** A storage's nVault, as a Map a test can fill before the plugin reads it. */
-	vault(name: string): Map<string, string> {
-		let vault = this.vaults.get(name);
-		if (!vault) this.vaults.set(name, vault = new Map());
-		return vault;
+	/** A trace from `start` to `end` through the fake world, written as the module writes it: stopped at the first wall across it. @internal */
+	writeTrace(plugin: PluginInstance, out: number, start: number[], end: number[]): void {
+		let fraction = 1;
+		let wall: { x: number; entity?: number; hitGroup?: number } | null = null;
+		for (const each of this.walls) {
+			const at = end[0] === start[0] ? -1 : (each.x - start[0]) / (end[0] - start[0]);
+			if (at >= 0 && at < fraction) {
+				fraction = at;
+				wall = each;
+			}
+		}
+		const stop = start.map((v, i) => v + (end[i] - v) * fraction);
+		const normal = wall ? [Math.sign(start[0] - end[0]), 0, 0] : [0, 0, 0];
+		const values = [fraction, ...stop, ...normal, wall ? (wall.entity ?? 0) : -1, 4, wall?.hitGroup ?? 0];
+		values.forEach((value, i) => plugin.memory.setNumber(out + i * 8, value));
+	}
+
+	/** A Storage's values by key, as a Map a test can fill before the plugin reads it - a Pawn plugin's nVault of that name too. */
+	storage(name: string): Map<string, string> {
+		let storage = this.vaults.get(name);
+		if (!storage) this.vaults.set(name, storage = new Map());
+		return storage;
+	}
+
+	/** A bot's move, through engfunc or the module's own call: written to engineCalls, and the bot carried along its yaw. @internal */
+	runPlayerMove(id: number, angles: number[], forward: number, side: number, up: number, buttons: number, impulse: number, msec: number): void {
+		this.engineCalls.push(`RunPlayerMove ${id} ${angles.join(',')} ${forward} ${side} ${up} ${buttons} ${impulse} ${msec}`);
+		const bot = this.players.find(each => each.id === id);
+		const turn = angles[1] * Math.PI / 180;
+		if (bot) bot.origin = [bot.origin[0] + Math.cos(turn) * forward * msec / 1000, bot.origin[1] + Math.sin(turn) * forward * msec / 1000, bot.origin[2]];
 	}
 
 	// ------------------------------------------------------------ what a test does
@@ -1045,14 +1289,14 @@ export class FakeServer {
 			if (due.repeat) due.due += due.interval;
 			else this.tasks.splice(this.tasks.indexOf(due), 1);
 
-			this.withCallArgs([due.id], () => this.call(due.slot, [due.id], 0));
+			this.withCallArgs([due.timer], () => this.call(due.slot, [due.timer], 0));
 		}
 
 		this.time = until;
 	}
 
 	/**
-	 * Raises a forward the host plugin relays - "client_putinserver",
+	 * Raises a forward the module raises - "client_putinserver",
 	 * "plugin_cfg" - or one a Pawn plugin sends: every handler and every
 	 * Forward.subscribe() of that name hears it. Text arrives as text, a
 	 * boolean as 1 or 0, an array as its cells (a Float's as its bits). As in
@@ -1061,6 +1305,8 @@ export class FakeServer {
 	 */
 	fire(name: string, ...args: ArgValue[]): number {
 		const first = typeof args[0] === 'number' || typeof args[0] === 'boolean' ? Number(args[0]) : 0;
+		if (name === 'client_connect') this.newPlayer(first);
+		if (name === 'pfn_playbackevent') this.playback = { blocked: false, recipients: null };
 		return this.withCallArgs(args, () => {
 			this.deliver(name);
 
@@ -1074,6 +1320,22 @@ export class FakeServer {
 		});
 	}
 
+	/** A player connects to slot `id`: each plugin's facade makes him a Player of his own, as the module's NewPlayer has it. */
+	private newPlayer(id: number): void {
+		for (const plugin of this.plugins) {
+			if (plugin.playerSlots && id >= 0 && id <= 32) plugin.memory.setCell(plugin.playerSlots + id * 4, 1);
+		}
+		this.countNameChange(id);
+	}
+
+	/** Player `id`'s name changed: each plugin's facade reads it again, as the module's NameChanges has it. */
+	countNameChange(id: number): void {
+		for (const plugin of this.plugins) {
+			const at = plugin.playerNames + id * 4;
+			if (plugin.playerNames && id >= 0 && id <= 32) plugin.memory.setCell(at, plugin.memory.cell(at) + 2);
+		}
+	}
+
 	/** Every Forward.subscribe() of a forward, called with its tag; the arguments are the context's. */
 	private deliver(forward: string): void {
 		for (const { handler, tag } of [...(this.subscriptions.get(forward) ?? [])]) this.call(handler, [tag], 0);
@@ -1098,7 +1360,18 @@ export class FakeServer {
 	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 listeners = this.hookchains.get(shape.kind) ?? { pre: [], post: [] };
+		return this.runChain(shape, listeners.pre, listeners.post, args, options.result, false);
+	}
 
+	/**
+	 * A hooked call, as the module's hook runs it (gamehooks.h): the pre
+	 * listeners - one that answers or blocks keeps the game's function from
+	 * running, one that breaks stops every listener after it - then the
+	 * game's function, then the post listeners. The listeners read the
+	 * arguments as cells and write them (chain_set); -1 is the answer.
+	 */
+	private runChain(shape: HookShape, pre: Slot[], post: Slot[], args: HookArg[], result: Value | undefined, ham: boolean): HookResult {
 		const cells: ArgValue[] = args.map((a, i) => Array.isArray(a)
 			? a.map(floatBits)
 			: typeof a === 'string'
@@ -1107,10 +1380,8 @@ export class FakeServer {
 					? (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;
-		const chain: Chain = { shape, answer: nothing, args: [...args] };
-		const listeners = this.hookchains.get(shape.kind) ?? { pre: [], post: [] };
+		const nothing: Value = shape.answer === 'text' ? '' : shape.answer === 'bool' && !ham ? false : 0;
+		const chain: Chain = { shape, answer: nothing, args: [...args], cells, ham };
 
 		const previous = this.chain;
 		this.chain = chain;
@@ -1118,41 +1389,54 @@ export class FakeServer {
 		try {
 			let prevented = false;
 			let broken = false;
-
-			for (const slot of [...listeners.pre]) {
-				const said = this.withCallArgs(cells, () => this.call(slot, handed, slot.fallback));
-				// What reapi answers a plugin that blocks a chain with a return value
-				// before setting one - a run time error, and the block does not hold.
-				if ((said === HC_SUPERCEDE || said === HC_BREAK) && shape.answer >= 0 && !chain.answered) {
-					throw new Error(`${event}: Can't suppress original function call without new return value set, so you must call SetHookChainReturn.`);
+			const walk = (slots: Slot[], before: boolean) => {
+				for (const slot of [...slots]) {
+					if (slot.off) continue;
+					const said = this.withCallArgs(cells, () => this.call(slot, handed, 0));
+					if (said === OUTCOME_BREAK) {
+						broken = true;
+						return;
+					}
+					if (said !== 0 && before) prevented = true;
 				}
-				if (said === HC_SUPERCEDE) prevented = true;
-				if (said === HC_BREAK) {
-					prevented = broken = true;
-					break;
-				}
-			}
-
-			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));
-				}
-			}
+			};
 
-			return { prevented, result: chain.answer, args: chain.args };
+			walk(pre, true);
+			if (!prevented && !broken && !chain.answered) chain.answer = result ?? nothing;
+			// A vector is written where the game keeps it: 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);
+			});
+			if (!broken) walk(post, false);
+			return { prevented: prevented || broken, result: chain.answer, args: chain.args };
 		} finally {
 			this.chain = previous;
 		}
 	}
 
+	/** What a listener wrote through chain_set: argument `index`, or the answer at -1. @internal */
+	chainSet(index: number, value: ArgValue): void {
+		const chain = this.chain;
+		if (!chain) throw new Error('chain_set outside a hooked call');
+		if (index < 0) {
+			const answer = chain.shape.answer;
+			chain.answer = typeof value !== 'number' ? value as Value : answer === 'float' ? bitsFloat(value) : answer === 'bool' && !chain.ham ? value !== 0 : value;
+			chain.answered = true;
+			return;
+		}
+		chain.cells[index] = value;
+		chain.args[index] = typeof value !== 'number' ? value as HookArg : chain.shape.floats.has(index) ? bitsFloat(value) : value;
+	}
+
+	/** The answer of the hooked call as a cell, as arg(-1) reads it. @internal */
+	chainAnswer(): ArgValue {
+		const answer = this.chain?.answer ?? 0;
+		if (typeof answer === 'boolean') return answer ? 1 : 0;
+		if (typeof answer === 'number') return this.chain?.shape.answer === 'float' ? floatBits(answer) : answer | 0;
+		return answer;
+	}
+
 	/**
 	 * Sends a message to a client the way the game would, through the
 	 * register_message callbacks of its name: they read and change its
@@ -1185,6 +1469,11 @@ 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;
 			}
+			// The module's hooks: the receiver, the id, the destination; any answer blocks it.
+			for (const slot of [...(id !== undefined ? this.moduleMessageHooks.get(id) ?? [] : [])]) {
+				const handed = [receiver, id ?? 0, receiver ? MSG_ONE : MSG_ALL, 0];
+				if (this.withCallArgs(handed, () => this.call(slot, handed, 0)) !== 0) 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+)=(.*)$/);
@@ -1226,33 +1515,8 @@ export class FakeServer {
 	 */
 	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)
-			? 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_STRING') ? '' : 0;
-		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;
-		this.chain = chain;
-
-		try {
-			let prevented = false;
-			for (const slot of [...listeners(false)]) {
-				if (this.withCallArgs(cells, () => this.call(slot, handed, slot.fallback)) >= HAM_SUPERCEDE) prevented = true;
-			}
-			if (!prevented) chain.answer = result ?? nothing;
-			for (const slot of [...listeners(true)]) this.withCallArgs(cells, () => this.call(slot, handed, slot.fallback));
-			return { prevented, result: chain.answer, args: chain.args };
-		} finally {
-			this.chain = previous;
-		}
+		return this.runChain(shape, listeners(false), listeners(true), [id, ...args], result, true);
 	}
 
 	/**
@@ -1529,7 +1793,8 @@ export class FakeServer {
 		this.outcomeSaid = false;
 
 		try {
-			this.within(handler.plugin, () => fn(...cells));
+			const via = handler.via;
+			this.within(handler.plugin, () => (via ? this.callVia(handler.plugin, via, args[0] ?? 0) : fn(...cells)));
 			return this.outcomeSaid ? this.outcome : fallback;
 		} finally {
 			this.outcomeSaid = said;
@@ -1537,6 +1802,26 @@ export class FakeServer {
 		}
 	}
 
+	/** CallVia in module.cpp: the one listener, with what the plugin's own call of it sets first. */
+	private callVia(plugin: PluginInstance, via: NonNullable<Handler['via']>, first: number): void {
+		const globals = plugin.instance.exports;
+		if (globals.__env) globals.__env.value = via.env;
+		if (globals.__argumentsLength) globals.__argumentsLength.value = 1;
+		const ambient = via.player ? globals.__co_ambient_player : undefined;
+		const before = ambient?.value;
+		if (ambient) ambient.value = first;
+		try {
+			plugin.table.get(via.fn)(via.arg);
+		} finally {
+			if (ambient) ambient.value = before;
+		}
+	}
+
+	/** Has `handler` call its plugin's one listener `fn` itself (Handler.via); 0 the handler again. */
+	private direct(handler: Handler, fn: number, env: number, arg: number, player: boolean): void {
+		handler.via = fn ? { fn, env, arg, player } : undefined;
+	}
+
 	/** Runs `body` as `plugin`: what its natives are called on behalf of. @internal */
 	within<T>(plugin: PluginInstance, body: () => T): T {
 		const previous = this.current;
@@ -1590,8 +1875,11 @@ export class FakeServer {
 
 	/** The handlers of the command in argv, in order, until one takes it. */
 	private handleCommand(handlers: Map<string, Slot[]>, id: number): boolean {
+		const flags = this.players.find(each => each.id === id)?.flags ?? 0;
 		return [...(handlers.get(this.argv[0].toLowerCase()) ?? [])].some((slot) => {
-			const args = [id, 0, slot.index];
+			if (slot.access && !(flags & slot.access)) return false;
+			// The module's own handlers read the count of the command's words, its name counted, last.
+			const args = [id, 0, slot.index, this.argv.length];
 			return this.withCallArgs(args, () => this.call(slot, args, slot.fallback)) >= PLUGIN_HANDLED;
 		});
 	}
@@ -1628,6 +1916,29 @@ export class FakeServer {
 		for (const owner of owners) this.request(owner.plugin!, plugin.run, gone);
 	}
 
+	/**
+	 * `amxts_reload <plugin>`: the plugin hears `"end"` and goes, its file is
+	 * loaded again, and the new one hears the map's start - `"init"`,
+	 * `"pluginsLoaded"`, `"configsQueued"`, `"configsExecuted"` - as a
+	 * reload on a running map does.
+	 */
+	async reload(plugin: PluginInstance): Promise<PluginInstance> {
+		this.fireTo(plugin, 'plugin_end');
+		this.unload(plugin);
+		const fresh = await this.load(plugin.source);
+		for (const name of ['plugin_init', 'plugin_cfg', 'OnAutoConfigsBuffered', 'OnConfigsExecuted']) this.fireTo(fresh, name);
+		return fresh;
+	}
+
+	/** A forward with no arguments to one plugin's handlers, as the module's RaiseTo. */
+	private fireTo(plugin: PluginInstance, name: string): void {
+		this.withCallArgs([], () => {
+			for (const handler of [...(this.events.get(name) ?? [])]) {
+				if (handler.plugin === plugin) this.call(handler, [0], 0);
+			}
+		});
+	}
+
 	/** 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);
@@ -1705,11 +2016,54 @@ export class FakeServer {
 		player.menu = { menu: menu.id, page: at, text: lines.join('\n'), keys, disabled };
 	}
 
+	/**
+	 * show_menu: the text on the player's screen, or every player's for 0,
+	 * with the keys it takes; a menu of AMX Mod X's own he had open is closed
+	 * first, its handler hearing MENU_EXIT. @internal
+	 */
+	showMenu(id: number, keys: number, text: string): void {
+		for (const player of this.players.filter(one => one.connected && (id === 0 || one.id === id))) {
+			// The module's show_menu: a menu over a plugin's Menu takes its keys.
+			this.shownMenus.delete(player.id);
+			const before = player.menu;
+			player.menu = null;
+			const replaced = before ? this.menus.get(before.menu) : undefined;
+			if (replaced) this.menuAnswer(replaced, player, constant('MENU_EXIT'));
+			const pressable = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0].filter(key => keys & (1 << (key === 0 ? 9 : key - 1)));
+			player.menu = { menu: -1, page: 0, text, keys: pressable, disabled: [] };
+		}
+	}
+
+	/**
+	 * A key of the menu a plugin's Menu shows the player, taken off as the
+	 * module takes it: its handler and the key, 0 for 1 and 9 for 0 - or null
+	 * when he has none from a running plugin, or it does not take the key. @internal
+	 */
+	takeMenuKey(player: FakePlayer, key: number): { handler: Handler; index: number } | null {
+		const shown = this.shownMenus.get(player.id);
+		const index = key === 0 ? 9 : key - 1;
+		if (!shown || shown.plugin.unloaded || index < 0 || index > 9 || !(shown.keys & (1 << index))) return null;
+		this.shownMenus.delete(player.id);
+		return { handler: shown, index };
+	}
+
+	/** A key of a Menu's page to its plugin, as the module hands it on. @internal */
+	pressMenu(player: FakePlayer, pressed: { handler: Handler; index: number }): boolean {
+		const args = [player.id, pressed.index, 0, 0];
+		this.withCallArgs(args, () => this.call(pressed.handler, args, 0));
+		return true;
+	}
+
 	/** 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;
+		if (!screen || !screen.keys.includes(key)) return false;
+		const menu = this.menus.get(screen.menu);
+		// show_menu's: the screen goes, and the key passes on.
+		if (!menu) {
+			player.menu = null;
+			return false;
+		}
 
 		const paged = menu.perPage > 0;
 		const turn = paged && key === 8 ? -1 : paged && key === 9 ? 1 : 0;
@@ -1730,9 +2084,10 @@ export class FakeServer {
 	}
 
 	/**
-	 * 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.
+	 * A line of the game's log, as the engine hands it to the module: split
+	 * into its arguments as AMX Mod X splits them, and every log hook whose
+	 * filters it passes is called. A line logged while one runs is heard by
+	 * its own, and read_logargv reads the outer line again after it.
 	 *
 	 * ```ts
 	 * server.gameLog('World triggered "Round_End"');
@@ -1740,19 +2095,25 @@ export class FakeServer {
 	 * ```
 	 */
 	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 [outerLine, outerArgs] = [this.logLine, this.logArgs];
+		const args = splitLog(line);
 		const passes = (filter: string) => {
 			const match = filter.match(/^(\d+)([=&!])(.*)$/);
 			if (!match) return true;
-			const value = this.logArgs[Number(match[1])] ?? '';
+			const value = args[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));
+		try {
+			// The log event hears every line, as the module raises it.
+			[this.logLine, this.logArgs] = [line, args];
+			this.fire('plugin_log');
+			for (const event of [...this.logEvents]) {
+				if (event.argc !== args.length || !event.filters.every(passes)) continue;
+				[this.logLine, this.logArgs] = [line, args];
+				this.withCallArgs([], () => this.call(event.slot, [0, 0, 0, 0], 0));
+			}
+		} finally {
+			[this.logLine, this.logArgs] = [outerLine, outerArgs];
 		}
 	}
 
@@ -1775,14 +2136,38 @@ export class FakeServer {
 		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));
+
+		// The module's own hooks of the function: any answer blocks it, and
+		// chain_set writes an argument or (at -1) its answer.
+		const stock = STOCK_FUNCTIONS.indexOf(name);
+		const chain: Chain = { shape: { kind: name, floats: new Set(), texts: new Set(), answer: typeof result === 'string' ? 'text' : 'int' }, answer: result, args: [...args] as HookArg[], cells };
+		const previous = this.chain;
+		this.chain = chain;
+		try {
+			for (const slot of [...(this.stockHooks.get(`${stock}:pre`) ?? [])]) {
+				if (this.withCallArgs(cells, () => this.call(slot, handed, 0)) !== 0) superseded = true;
+			}
+			if (chain.answered) this.forwardAnswer = chain.answer as number | string;
+			if (!superseded) {
+				this.origRetval = result;
+				for (const slot of [...(this.fakemetaForwards.get(`${fn}:post`) ?? [])]) this.withCallArgs(cells, () => this.call(slot, handed, slot.fallback));
+				for (const slot of [...(this.stockHooks.get(`${stock}:post`) ?? [])]) this.withCallArgs(cells, () => this.call(slot, handed, 0));
+			}
+		} finally {
+			this.chain = previous;
 		}
 		return { superseded, answer: this.forwardAnswer };
 	}
 
-	/** Switches a hook off or on by the handle RegisterHookChain or RegisterHam gave. @internal */
+	/** A handler of one of the module's hooks, under `key` in `hooks`; its handle for hook_on. @internal */
+	addModuleHook<K>(plugin: PluginInstance, fn: number, hooks: Map<K, Slot[]>, key: K): number {
+		const slot = this.takeSlot(plugin, fn, SHAPE_WIDE, '', 0);
+		hooks.set(key, [...(hooks.get(key) ?? []), slot]);
+		this.hookSlots.set(this.hookSlots.size + 1, slot);
+		return this.hookSlots.size;
+	}
+
+	/** Switches a hook off or on by its handle: the module's (hook_on), or a raw RegisterHookChain's or RegisterHam's. @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}`);
@@ -1817,6 +2202,26 @@ export class FakeServer {
 		return slot;
 	}
 
+	/**
+	 * What the server sends `host` of `entity` (AddToFullPack): its listeners
+	 * run on the state - sixteen numbers, by the module's field numbers:
+	 * origin, angles, render mode, amount, colour, fx, effects, model index,
+	 * body, skin - and say what was sent, or that it was hidden.
+	 */
+	sendState(host: FakePlayer, entity: FakeEntity, state: number[] = Array.from({ length: 16 }).fill(0) as number[]): { hidden: boolean; state: number[] } {
+		const sent = [...state];
+		let hidden = false;
+		this.sending = sent;
+		try {
+			for (const { slot } of this.stateHooks.filter(h => h.classname === '' || h.classname === entity.classname)) {
+				if (this.withCallArgs([host.id, entity.id], () => this.call(slot, [host.id, entity.id], 0)) > 0) hidden = true;
+			}
+		} finally {
+			this.sending = null;
+		}
+		return { hidden, state: sent };
+	}
+
 	/**
 	 * One entity moving into another: the register_touch callbacks whose
 	 * classes match ("*" or "" is any), called as the engine module calls
@@ -1831,10 +2236,21 @@ export class FakeServer {
 		return answer;
 	}
 
-	/** A client answering query_client_cvar: every question about that cvar it had. */
+	/**
+	 * A client answering query_client_cvar and the module's questions: every
+	 * question about that cvar it had. The module's go to its hooks of the
+	 * answer, (player, id, cvar, value), once.
+	 */
 	answerCvar(player: FakePlayer, cvar: string, value: string): void {
 		for (const query of this.cvarQueries.filter(q => q.player === player.id && q.cvar === cvar)) {
-			this.withCallArgs([player.id, cvar, value], () => this.call(query.slot, [player.id, 0, 0, 0], 0));
+			if (query.slot) {
+				const slot = query.slot;
+				this.withCallArgs([player.id, cvar, value], () => this.call(slot, [player.id, 0, 0, 0], 0));
+				continue;
+			}
+			this.cvarQueries.splice(this.cvarQueries.indexOf(query), 1);
+			const args = [player.id, query.request ?? 0, cvar, value];
+			for (const slot of [...(this.stockHooks.get(`${STOCK_CVAR_ANSWER}:pre`) ?? [])]) this.withCallArgs(args, () => this.call(slot, [player.id, query.request ?? 0, 0, 0], 0));
 		}
 	}
 
@@ -1987,6 +2403,36 @@ export class FakeServer {
 		net_read(this: FakeServer, plugin: PluginInstance, id: number, out: number, max: number) {
 			return this.network.read(plugin, id, out, max);
 		},
+
+		// A file's bytes, in files: as the module's fs_read and fs_write, a path that leaves the game folder is refused.
+		fs_read(this: FakeServer, plugin: PluginInstance, name: number, out: number, max: number) {
+			const path = gamePath(plugin.memory.string(name));
+			const bytes = path === null ? undefined : this.files.get(path);
+			if (!bytes) return -1;
+			if (out && max > 0) plugin.memory.setRaw(out, bytes.subarray(0, max));
+			return bytes.length;
+		},
+		fs_write(this: FakeServer, plugin: PluginInstance, name: number, data: number, length: number, append: number) {
+			const path = gamePath(plugin.memory.string(name));
+			if (path === null || !this.folderExists(path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '')) return 0;
+			const bytes = new Uint8Array(plugin.instance.exports.memory.buffer, data, length);
+			const before = append ? this.files.get(path) ?? new Uint8Array(0) : new Uint8Array(0);
+			const file = new Uint8Array(before.length + length);
+			file.set(before);
+			file.set(bytes, before.length);
+			this.files.set(path, file);
+			return 1;
+		},
+		zip_inflate(this: FakeServer, plugin: PluginInstance, data: number, length: number, out: number, max: number) {
+			try {
+				const inflated = inflateRawSync(new Uint8Array(plugin.instance.exports.memory.buffer, data, length));
+				if (inflated.length > max) return -1;
+				plugin.memory.setRaw(out, inflated);
+				return inflated.length;
+			} catch {
+				return -1;
+			}
+		},
 		net_reply(this: FakeServer, plugin: PluginInstance, id: number) {
 			return this.network.reply(plugin, id);
 		},
@@ -2073,6 +2519,13 @@ export class FakeServer {
 			list.push({ plugin, fn, shape });
 		},
 
+		// The plugin's handler of a forward calls its one listener itself, or the handler again.
+		on_direct(this: FakeServer, plugin: PluginInstance, name: number, fn: number, target: number, env: number, arg: number, player: number) {
+			for (const handler of this.events.get(plugin.memory.string(name)) ?? []) {
+				if (handler.plugin === plugin && handler.fn === fn) this.direct(handler, target, env, arg, player !== 0);
+			}
+		},
+
 		// 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)) ?? [];
@@ -2096,8 +2549,7 @@ export class FakeServer {
 			list.push({ handler: { plugin, fn, shape: SHAPE_NARROW }, tag });
 		},
 
-		// No forward is relayed by a host plugin here, so every one a
-		// TypeScript plugin emits reaches its subscribers this way: `s` a
+		// A forward a TypeScript plugin emits reaches its subscribers this way: `s` a
 		// string, `a` an array as its count and then its cells, the rest cells.
 		emit_local(this: FakeServer, plugin: PluginInstance, name: number, mask: number, cells: number, argc: number) {
 			const forward = plugin.memory.string(name);
@@ -2123,35 +2575,318 @@ export class FakeServer {
 			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;
+		// The module's own table of commands, as ClientCommand and the engine's server commands walk it.
+		clcmd(this: FakeServer, plugin: PluginInstance, name: number, fn: number, flags: number, shape: number) {
+			const slot = this.takeSlot(plugin, fn, shape, '', PLUGIN_HANDLED);
+			slot.access = flags;
+			addTo(this.clientCommands, plugin.memory.string(name).toLowerCase(), slot);
 		},
 
-		clcmd(this: FakeServer, plugin: PluginInstance, pattern: number, fn: number, flags: number, info: number, shape: number) {
-			const name = plugin.memory.string(pattern);
-			const slot = this.takeSlot(plugin, fn, shape, `clcmd:${name}`, PLUGIN_HANDLED);
-			let list = this.clientCommands.get(name.toLowerCase());
-			if (!list) this.clientCommands.set(name.toLowerCase(), list = []);
-			list.push(slot);
-			return slot.index;
+		srvcmd(this: FakeServer, plugin: PluginInstance, name: number, fn: number, shape: number) {
+			addTo(this.serverCommands, plugin.memory.string(name).toLowerCase(), this.takeSlot(plugin, fn, shape, '', PLUGIN_HANDLED));
+		},
+
+		// The menu a plugin's Menu shows a player, said after show_menu; no keys for none, 0 for every player.
+		menu_open(this: FakeServer, plugin: PluginInstance, id: number, keys: number, fn: number) {
+			const tag = this.takeTag();
+			if (id === 0) this.shownMenus.clear();
+			else this.shownMenus.delete(id);
+			if (id > 0 && keys & 0x3FF) this.shownMenus.set(id, { plugin, fn, shape: SHAPE_WIDE, tag, keys: keys & 0x3FF });
+		},
+
+		// A client's command, as one he sent: a bot's line, the team menu's choice, a weapon's.
+		bot_cmd(this: FakeServer, plugin: PluginInstance, id: number, line: number) {
+			const target = this.players.find(each => each.id === id);
+			const text = plugin.memory.string(line);
+			if (target?.bot) target.command(text);
+			else clientCommand(target, text);
+		},
+
+		// What a player is given and does, as the module does it on ReGameDLL.
+		// -1 for a name the game has no class of: the fake's game has its weapons and every item_ and ammo_ class.
+		player_give(this: FakeServer, plugin: PluginInstance, id: number, name: number) {
+			const item = plugin.memory.string(name);
+			return WEAPON_NAMES.includes(item) || /^(?:item|ammo)_\w+$/.test(item) ? giveWeapon(this.player(id), item) : -1;
+		},
+		player_strip(this: FakeServer, plugin: PluginInstance, id: number) {
+			this.player(id)?.stripWeapons();
+		},
+		player_respawn(this: FakeServer, plugin: PluginInstance, id: number) {
+			NATIVES.rg_round_respawn({ server: this, plugin, memory: plugin.memory }, [id]);
+		},
+		player_speed() {},
+		player_switch(this: FakeServer, plugin: PluginInstance, id: number, name: number) {
+			return switchTo(this.player(id), plugin.memory.string(name));
+		},
+		player_join(this: FakeServer, plugin: PluginInstance, id: number, team: number) {
+			if (!this.chains) return -1;
+			return NATIVES.rg_join_team({ server: this, plugin, memory: plugin.memory }, [id, team]);
+		},
+		player_observe(this: FakeServer, plugin: PluginInstance, id: number, mode: number) {
+			if (!this.chains) return -1;
+			return NATIVES.rg_set_observer_mode({ server: this, plugin, memory: plugin.memory }, [id, mode]);
+		},
+		player_team(this: FakeServer, plugin: PluginInstance, id: number, team: number) {
+			NATIVES.rg_set_user_team({ server: this, plugin, memory: plugin.memory }, [id, team]);
+		},
+		// The game rules' RestartRound (1) and CheckWinConditions (2), counted.
+		game_rules_run(this: FakeServer, plugin: PluginInstance, action: number) {
+			this.rulesRuns.push(action === 1 ? 'restartRound' : 'checkWinConditions');
+			return 1;
+		},
+		// A slot's items taken with their ammo, as ReGameDLL's RemovePlayerItemEx takes each.
+		player_remove_slot(this: FakeServer, plugin: PluginInstance, id: number, slot: number) {
+			const target = this.player(id);
+			if (!target) return 0;
+			for (const weapon of target.items.filter(w => slotOf(w.kind) === slot)) {
+				target.ammo.set(weapon.kind, 0);
+				target.takeWeapon(weapon);
+				this.entities.delete(weapon.id);
+			}
+			return 1;
+		},
+		// A weapon dropped: no longer his, left in the world.
+		player_drop(this: FakeServer, plugin: PluginInstance, id: number, name: number) {
+			const target = this.player(id);
+			const weapon = target?.items.find(w => w.kind === plugin.memory.string(name));
+			if (!target || !weapon || weapon.kind === 'weapon_knife') return;
+			target.takeWeapon(weapon);
+			weapon.set('var_owner', 0);
+			weapon.set('m_pPlayer', 0);
+		},
+		// The user id (1), the ping (2), the seconds since he came (4).
+		player_stat(this: FakeServer, plugin: PluginInstance, id: number, what: number) {
+			const target = this.player(id);
+			if (!target) return 0;
+			return what === 1 ? target.userid : what === 4 ? Math.floor((this.time - target.connectedAt) / 1000) : 0;
+		},
+		// env(): a variable's UTF-8 length, as much of it as fits into `max`; -1 for none - the module's env_get.
+		env_get(this: FakeServer, plugin: PluginInstance, name: number, out: number, max: number) {
+			const value = this.variables().get(plugin.memory.string(name));
+			return value === undefined ? -1 : plugin.memory.setUtf8(out, max, value);
+		},
+		info_get(this: FakeServer, plugin: PluginInstance, id: number, key: number, out: number, max: number) {
+			return plugin.memory.setUtf8(out, max, this.player(id)?.info.get(plugin.memory.string(key)) ?? '');
+		},
+		info_set(this: FakeServer, plugin: PluginInstance, id: number, key: number, value: number) {
+			this.player(id)?.info.set(plugin.memory.string(key), plugin.memory.string(value));
+		},
+		player_silent(this: FakeServer, plugin: PluginInstance, id: number, on: number) {
+			const target = this.player(id);
+			if (!target) return 0;
+			if (on < 0) return target.silentSteps ? 1 : 0;
+			target.silentSteps = on !== 0;
+			return 1;
+		},
+		// An address's country (code 1, name 2) from `server.countries`; -1 for one it has not.
+		geo_country(this: FakeServer, plugin: PluginInstance, ip: number, what: number, out: number, max: number) {
+			const country = this.countries.get(plugin.memory.string(ip));
+			return country ? plugin.memory.setUtf8(out, max, what === 1 ? country.code : country.name) : -1;
+		},
+		// The player to the other side, as the game swaps sides; a spectator stays.
+		player_switch_team(this: FakeServer, plugin: PluginInstance, id: number) {
+			const target = this.player(id);
+			if (target?.team === 'TERRORIST') target.team = 'CT';
+			else if (target?.team === 'CT') target.team = 'TERRORIST';
+		},
+		// The plugins: the TypeScript ones loaded here, by their source's file; no Pawn plugin.
+		plugins_count(this: FakeServer) {
+			return this.plugins.length;
+		},
+		plugin_text(this: FakeServer, plugin: PluginInstance, index: number, what: number, out: number, max: number) {
+			const target = this.plugins[index];
+			const text = !target ? '' : what === 1 ? target.source.split(/[\\/]/).pop()! : what === 2 ? target.info.name : what === 3 ? target.info.version : what === 4 ? target.info.author : '';
+			return plugin.memory.setUtf8(out, max, text);
+		},
+		plugin_state(this: FakeServer, plugin: PluginInstance, index: number) {
+			const target = this.plugins[index];
+			return !target ? -1 : target.unloaded ? 1 : 0;
+		},
+		// What was asked of a plugin, done at the next frame on the server: recorded here.
+		plugin_action(this: FakeServer, plugin: PluginInstance, name: number, action: number) {
+			this.pluginActions.push(`${['', 'stop', 'start', 'reload'][action]} ${plugin.memory.string(name)}`);
+		},
+		pawn_plugins_count() {
+			return 0;
+		},
+		pawn_plugin_text(this: FakeServer, plugin: PluginInstance, index: number, what: number, out: number, max: number) {
+			return plugin.memory.setUtf8(out, max, '');
+		},
+		pawn_plugin_pause() {
+			return 0;
+		},
+		// A Storage: the map storage(name) gives, by a handle a name.
+		store_open(this: FakeServer, plugin: PluginInstance, name: number) {
+			const wanted = plugin.memory.string(name);
+			if (!wanted || /[/\\:*?"<>|]/.test(wanted)) return -1;
+			this.storage(wanted);
+			const at = this.storeNames.indexOf(wanted);
+			return at >= 0 ? at : this.storeNames.push(wanted) - 1;
+		},
+		store_get(this: FakeServer, plugin: PluginInstance, handle: number, key: number, out: number, max: number) {
+			const value = this.storage(this.storeNames[handle]).get(plugin.memory.string(key));
+			if (value === undefined) return -1;
+			const length = Buffer.byteLength(value);
+			return length > max ? length : plugin.memory.setUtf8(out, max, value);
+		},
+		store_set(this: FakeServer, plugin: PluginInstance, handle: number, key: number, value: number) {
+			const name = this.storeNames[handle];
+			this.storage(name).set(plugin.memory.string(key), plugin.memory.string(value));
+			this.storeTimes.set(`${name}\0${plugin.memory.string(key)}`, (this.startedAt + this.time) / 1000);
+		},
+		store_delete(this: FakeServer, plugin: PluginInstance, handle: number, key: number) {
+			return +this.storage(this.storeNames[handle]).delete(plugin.memory.string(key));
+		},
+		store_count(this: FakeServer, plugin: PluginInstance, handle: number) {
+			return this.storage(this.storeNames[handle]).size;
+		},
+		store_keys(this: FakeServer, plugin: PluginInstance, handle: number, out: number, max: number) {
+			const keys = [...this.storage(this.storeNames[handle]).keys()].sort().map(key => `${key}\0`).join('');
+			const length = Buffer.byteLength(keys);
+			if (length > max || length === 0) return length;
+			plugin.memory.setUtf8(out, max, keys);
+			return length;
+		},
+		// What was set before `before` (seconds since 1970, on the fake clock) goes; a value a test put in has no time and stays.
+		store_prune(this: FakeServer, plugin: PluginInstance, handle: number, before: number) {
+			const name = this.storeNames[handle];
+			let removed = 0;
+			for (const key of [...this.storage(name).keys()]) {
+				const time = this.storeTimes.get(`${name}\0${key}`);
+				if (time !== undefined && time < before) {
+					this.storage(name).delete(key);
+					removed++;
+				}
+			}
+			return removed;
+		},
+		// The server's game and versions: ReHLDS's and ReGameDLL's APIs where the hookchains are.
+		server_text(this: FakeServer, plugin: PluginInstance, what: number, out: number, max: number) {
+			const text = ['', 'cstrike', '0.3.0', this.chains ? '3.14' : '', this.chains ? '5.28' : ''][what] ?? '';
+			return plugin.memory.setUtf8(out, max, text);
+		},
+		map_valid(this: FakeServer, plugin: PluginInstance, name: number) {
+			return +this.maps.includes(plugin.memory.string(name));
+		},
+		change_level(this: FakeServer, plugin: PluginInstance, name: number) {
+			const map = plugin.memory.string(name);
+			if (!this.maps.includes(map)) return 0;
+			this.engineCalls.push(`ChangeLevel ${map}`);
+			return 1;
+		},
+		playback_block(this: FakeServer) {
+			this.playback.blocked = true;
+		},
+		playback_to(this: FakeServer, plugin: PluginInstance, ids: number, count: number) {
+			this.playback.recipients = Array.from({ length: count }, (_, i) => plugin.memory.cell(ids + i * 4));
+		},
+		light_style(this: FakeServer, plugin: PluginInstance, text: number) {
+			this.lightStyle = plugin.memory.string(text) || 'm';
+			this.engineCalls.push(`LightStyle 0 ${this.lightStyle}`);
+		},
+		// The engine's lightstyle message to one player, as a message he was sent: "" is the server's light.
+		player_light_style(this: FakeServer, plugin: PluginInstance, id: number, text: number) {
+			const player = this.player(id);
+			if (!player || player.bot) return;
+			this.userMessages.push({ name: 'LightStyle', player: id, args: [0, plugin.memory.string(text) || this.lightStyle] });
+		},
+		// HUD messages: the text to each player, as his messages' "hud" line; how it was set, in server.hud.
+		hud_line(this: FakeServer) {
+			return ++this.hudLines;
+		},
+		hud_show(this: FakeServer, plugin: PluginInstance, id: number, line: number, params: number, text: number) {
+			const p = Array.from({ length: 12 }, (_, i) => plugin.memory.number(params + i * 8));
+			this.hud = { color: [p[3], p[4], p[5]], x: p[0], y: p[1], hold: p[7], channel: p[10], line, large: p[11] !== 0 };
+			const message = plugin.memory.string(text);
+			for (const target of id > 0 ? [this.player(id)] : this.players) {
+				if (target && !target.bot) target.show('hud', message);
+			}
+		},
+		hud_clear(this: FakeServer, plugin: PluginInstance, id: number, line: number) {
+			this.engineCalls.push(`HudClear ${id} ${line}`);
+		},
+		// The model a plugin put on each player, by his id: written into his userinfo as the module does.
+		player_model(this: FakeServer, plugin: PluginInstance, id: number, model: number, index: number) {
+			const target = this.player(id);
+			if (!target) return;
+			const name = plugin.memory.string(model);
+			if (name) this.models.set(id, name);
+			else this.models.delete(id);
+			target.info.set('model', name || 'urban');
+			this.engineCalls.push(`Model ${id} ${name || '-'} ${index}`);
+		},
+		player_model_get(this: FakeServer, plugin: PluginInstance, id: number, out: number, max: number) {
+			return plugin.memory.setUtf8(out, max, this.models.get(id) ?? '');
+		},
+		// What each player sees through, by his id: 0 his own eyes.
+		player_view(this: FakeServer, plugin: PluginInstance, id: number, target: number) {
+			this.engineCalls.push(`SetView ${id} ${target || id}`);
+			this.views.set(id, target === id ? 0 : target);
+		},
+		player_view_get(this: FakeServer, plugin: PluginInstance, id: number) {
+			return this.views.get(id) ?? 0;
+		},
+		// Traces: the fake world is empty, unless a test puts a wall (server.walls)
+		// across the way; each trace is written to engineCalls.
+		world_trace_line(this: FakeServer, plugin: PluginInstance, points: number, flags: number, ignore: number, out: number) {
+			const [start, end] = tracePoints(plugin, points);
+			this.engineCalls.push(`TraceLine ${start.join(',')} ${end.join(',')} ${flags} ${ignore}`);
+			this.writeTrace(plugin, out, start, end);
+		},
+		world_trace_hull(this: FakeServer, plugin: PluginInstance, points: number, hull: number, flags: number, ignore: number, out: number) {
+			const [start, end] = tracePoints(plugin, points);
+			this.engineCalls.push(`TraceHull ${start.join(',')} ${end.join(',')} ${hull} ${flags} ${ignore}`);
+			this.writeTrace(plugin, out, start, end);
+		},
+		// Inside a wall is solid; the walls are planes across x.
+		world_contents(this: FakeServer, plugin: PluginInstance, point: number) {
+			const x = tracePoints(plugin, point)[0][0];
+			return this.walls.some(wall => wall.x === x) ? -2 : -1;
+		},
+		entity_drop(this: FakeServer, plugin: PluginInstance, id: number) {
+			this.engineCalls.push(`DropToFloor ${id}`);
+			return 1;
+		},
+		// The log line being told (-1) or one of its arguments, and how many it has.
+		log_text(this: FakeServer, plugin: PluginInstance, index: number, out: number, max: number) {
+			return plugin.memory.setUtf8(out, max, index < 0 ? this.logLine : this.logArgs[index] ?? '');
+		},
+		log_count(this: FakeServer) {
+			return this.logArgs.length;
+		},
+		// Reunion's answers: -1 without it.
+		reunion(this: FakeServer, plugin: PluginInstance, what: number, id: number) {
+			const target = this.players.find(each => each.id === id);
+			if (!this.reunion || !this.chains || !target) return -1;
+			return what === 1 ? target.protocol : Math.max(0, AUTH_TYPES.indexOf(target.authType));
+		},
+		reunion_key(this: FakeServer, plugin: PluginInstance, id: number, out: number, max: number) {
+			const target = this.players.find(each => each.id === id);
+			return plugin.memory.setUtf8(out, max, this.reunion && this.chains ? target?.authKey ?? '' : '');
+		},
+
+		// engfunc(EngFunc_RunPlayerMove, ...) made by the module itself, the angles and the speeds Floats' bits; 0 for no player there, which engfunc then takes.
+		run_player_move(this: FakeServer, plugin: PluginInstance, id: number, pitch: number, yaw: number, roll: number, forward: number, side: number, up: number, buttons: number, impulse: number, msec: number) {
+			if (!this.players.some(each => each.id === id)) return 0;
+			this.runPlayerMove(id, [bitsFloat(pitch), bitsFloat(yaw), bitsFloat(roll)], bitsFloat(forward), bitsFloat(side), bitsFloat(up), buttons, impulse, msec);
+			return 1;
 		},
 
-		task(this: FakeServer, plugin: PluginInstance, secondsBits: number, fn: number, id: number, repeat: number) {
+		task(this: FakeServer, plugin: PluginInstance, secondsBits: number, fn: number, repeat: number) {
 			const slot = this.takeSlot(plugin, fn, 0, '', 0);
 			const interval = Math.round(bitsFloat(secondsBits) * 1000);
-			this.tasks.push({ slot, id, interval, due: this.time + interval, repeat: repeat !== 0, order: this.taskOrder++ });
-			return slot.index;
+			let timer = 0;
+			while (this.tasks.some(task => task.timer === timer)) timer++;
+			this.tasks.push({ slot, timer, interval, due: this.time + interval, repeat: repeat !== 0, order: this.taskOrder++ });
+			return timer;
 		},
 
-		// remove_task with `outside`: every task of that id, whoever armed it.
-		stop_task(this: FakeServer, plugin: PluginInstance, id: number) {
-			const before = this.tasks.length;
-			for (let i = this.tasks.length - 1; i >= 0; i--) {
-				if (this.tasks[i].id === id) this.tasks.splice(i, 1);
-			}
-			return before - this.tasks.length;
+		// The calling plugin's timer in that slot.
+		stop_task(this: FakeServer, plugin: PluginInstance, timer: number) {
+			const at = this.tasks.findIndex(task => task.timer === timer && task.slot.plugin === plugin);
+			if (at < 0) return 0;
+			this.tasks.splice(at, 1);
+			return 1;
 		},
 
 		hook(this: FakeServer, plugin: PluginInstance, id: number, fn: number, post: number) {
@@ -2166,7 +2901,7 @@ export class FakeServer {
 			return this.hookSlots.size;
 		},
 
-		// RegisterHam: kept by the function's id and the class, for hamCall().
+		// A Ham Sandwich function hooked on a class: kept by the function's id and the class, for runHam().
 		ham(this: FakeServer, plugin: PluginInstance, id: number, entityClass: number, fn: number, post: number) {
 			const slot = this.takeSlot(plugin, fn, SHAPE_WIDE, `ham:${id}:${post}`, 0);
 			const key = `${id}:${plugin.memory.string(entityClass)}:${post ? 'post' : 'pre'}`;
@@ -2177,13 +2912,158 @@ export class FakeServer {
 			return this.hookSlots.size;
 		},
 
-		tag(this: FakeServer, _plugin: PluginInstance, tag: number) {
-			this.pendingTag = tag;
+		hook_on(this: FakeServer, _plugin: PluginInstance, handle: number, on: number) {
+			this.switchHook(handle, on !== 0);
+		},
+
+		// A hook's handler calls its plugin's one listener itself, or the handler again.
+		hook_direct(this: FakeServer, _plugin: PluginInstance, handle: number, target: number, env: number, arg: number) {
+			const slot = this.hookSlots.get(handle);
+			if (slot) this.direct(slot, target, env, arg, false);
+		},
+
+		// The module's hooks of the engine's and the game's functions
+		// (runtime/src/enginehooks.h), kept with the natives' callbacks of the
+		// same things: sendMessage, gameLog, changeCvar, touch, fireForward
+		// and answerCvar call both.
+		msg_hook(this: FakeServer, plugin: PluginInstance, id: number, fn: number) {
+			return this.addModuleHook(plugin, fn, this.moduleMessageHooks, id);
+		},
+
+		msg_argc(this: FakeServer, _plugin: PluginInstance) {
+			return this.hookedMessage?.args.length ?? 0;
+		},
+
+		msg_arg_type(this: FakeServer, _plugin: PluginInstance, index: number) {
+			return this.hookedMessage?.types[index] ?? 0;
+		},
+
+		msg_number(this: FakeServer, _plugin: PluginInstance, index: number) {
+			const message = this.hookedMessage;
+			const value = Number(message?.args[index] ?? 0) || 0;
+			const type = message?.types[index];
+			return type === ARG_COORD || type === ARG_ANGLE ? value : Math.trunc(value);
+		},
+
+		msg_text(this: FakeServer, plugin: PluginInstance, index: number, out: number, max: number) {
+			const value = this.hookedMessage?.args[index];
+			return plugin.memory.setBytes(out, max, typeof value === 'string' ? value : '');
+		},
+
+		msg_set_number(this: FakeServer, _plugin: PluginInstance, index: number, value: number) {
+			const message = this.hookedMessage;
+			const type = message?.types[index];
+			if (!message || type === undefined || type === ARG_STRING) return;
+			message.args[index] = type === ARG_COORD || type === ARG_ANGLE ? value : Math.trunc(value);
+		},
+
+		msg_set_text(this: FakeServer, plugin: PluginInstance, index: number, text: number) {
+			const message = this.hookedMessage;
+			if (message?.types[index] === ARG_STRING) message.args[index] = plugin.memory.string(text);
+		},
+
+		log_hook(this: FakeServer, plugin: PluginInstance, argc: number, filter: number, fn: number) {
+			const text = plugin.memory.string(filter);
+			const slot = this.takeSlot(plugin, fn, SHAPE_WIDE, '', 0);
+			this.logEvents.push({ argc, filters: text ? [text] : [], slot });
+			this.hookSlots.set(this.hookSlots.size + 1, slot);
+			return this.hookSlots.size;
+		},
+
+		cvar_hook(this: FakeServer, plugin: PluginInstance, name: number, fn: number) {
+			const cvar = this.cvars.get(plugin.memory.string(name).toLowerCase());
+			if (!cvar) return 0;
+			const slot = this.takeSlot(plugin, fn, SHAPE_WIDE, '', 0);
+			cvar.hooks.push(slot);
+			this.hookSlots.set(this.hookSlots.size + 1, slot);
+			return this.hookSlots.size;
+		},
+
+		// Every cvar's change is heard as it is made here.
+		cvar_exact() {
+			return 1;
+		},
+
+		state_hook(this: FakeServer, plugin: PluginInstance, classname: number, fn: number) {
+			const slot = this.takeSlot(plugin, fn, SHAPE_WIDE, '', 0);
+			this.stateHooks.push({ classname: plugin.memory.string(classname), slot });
+			this.hookSlots.set(this.hookSlots.size + 1, slot);
+			return this.hookSlots.size;
+		},
+		// A movement event's touchCount (0) and frameTime (1), from server.playerMove.
+		move_get(this: FakeServer, plugin: PluginInstance, field: number) {
+			return field === 0 ? this.playerMove.touchCount : field === 1 ? this.playerMove.frameTime : 0;
+		},
+		state_get(this: FakeServer, plugin: PluginInstance, field: number) {
+			return this.sending?.[field] ?? 0;
+		},
+		state_set(this: FakeServer, plugin: PluginInstance, field: number, value: number) {
+			if (this.sending) this.sending[field] = value;
+		},
+
+		touch_hook(this: FakeServer, plugin: PluginInstance, touched: number, toucher: number, fn: number) {
+			const slot = this.takeSlot(plugin, fn, SHAPE_WIDE, '', 0);
+			this.touches.push({ touched: plugin.memory.string(touched), toucher: plugin.memory.string(toucher), slot });
+			this.hookSlots.set(this.hookSlots.size + 1, slot);
+			return this.hookSlots.size;
+		},
+
+		stock_hook(this: FakeServer, plugin: PluginInstance, fn: number, handler: number, post: number) {
+			return this.addModuleHook(plugin, handler, this.stockHooks, `${fn}:${post ? 'post' : 'pre'}`);
+		},
+
+		// A question to the client: answerCvar() answers it by its id.
+		query_cvar(this: FakeServer, plugin: PluginInstance, id: number, name: number) {
+			if (!this.players.some(each => each.id === id)) return 0;
+			const request = ++this.cvarRequests;
+			this.cvarQueries.push({ player: id, cvar: plugin.memory.string(name).toLowerCase(), request });
+			return request;
 		},
 
-		// A plugin that never awaits still takes its timers' handles from here.
-		co_id(this: FakeServer, _plugin: PluginInstance) {
-			return nextTaskId();
+		chain_set(this: FakeServer, _plugin: PluginInstance, index: number, value: number) {
+			this.chainSet(index, value);
+		},
+
+		chain_set_text(this: FakeServer, plugin: PluginInstance, index: number, text: number) {
+			this.chainSet(index, plugin.memory.string(text));
+		},
+
+		game_api(this: FakeServer, _plugin: PluginInstance) {
+			return this.chains ? 3 : 0;
+		},
+
+		// One phase of a chain's listeners for game.endRound's dispatch, as module.cpp's chain_dispatch.
+		chain_dispatch(this: FakeServer, plugin: PluginInstance, id: number, post: number, at: number, count: number, result: number) {
+			const kind = tables().hookNames.get(id);
+			const shape = kind === undefined ? undefined : tables().hooks.get(kind);
+			if (!kind || !shape) return 0;
+			const cells: ArgValue[] = Array.from({ length: count }, (_, i) => plugin.memory.cell(at + i * 4));
+			const args: HookArg[] = cells.map((cell, i) => shape.floats.has(i) ? bitsFloat(cell as number) : cell as number);
+			const previous = this.chain;
+			this.chain = { shape, answer: result !== 0, args, cells };
+			let said = 0;
+			try {
+				for (const slot of [...(this.hookchains.get(kind)?.[post ? 'post' : 'pre'] ?? [])]) {
+					if (slot.off) continue;
+					const outcome = this.withCallArgs(cells, () => this.call(slot, cells.slice(0, 4).map(Number), 0));
+					if (outcome === OUTCOME_BREAK) {
+						said |= 2;
+						break;
+					}
+					if (outcome !== 0 && !post) said |= 1;
+				}
+			} finally {
+				this.chain = previous;
+			}
+			cells.forEach((cell, i) => plugin.memory.setCell(at + i * 4, Number(cell)));
+			return said;
+		},
+
+		// ExecuteHam, which ham_bypass comes before, runs no listener here anyway.
+		ham_bypass(this: FakeServer, _plugin: PluginInstance, _fn: number, _id: number) {},
+
+		tag(this: FakeServer, _plugin: PluginInstance, tag: number) {
+			this.pendingTag = tag;
 		},
 
 		export(this: FakeServer, plugin: PluginInstance, name: number, fn: number) {
@@ -2197,12 +3077,12 @@ export class FakeServer {
 		},
 
 		arg(this: FakeServer, plugin: PluginInstance, index: number) {
-			const value = this.callArgs?.[index];
+			const value = index === -1 && this.chain ? this.chainAnswer() : this.callArgs?.[index];
 			return typeof value === 'number' ? value | 0 : typeof value === 'boolean' ? +value : 0;
 		},
 
 		arg_text(this: FakeServer, plugin: PluginInstance, index: number, out: number, max: number) {
-			const value = this.callArgs?.[index];
+			const value = index === -1 && this.chain ? this.chainAnswer() : this.callArgs?.[index];
 			return plugin.memory.setBytes(out, max, typeof value === 'string' ? value : '');
 		},
 
@@ -2220,7 +3100,7 @@ export class FakeServer {
 		},
 
 		arg_array(this: FakeServer, plugin: PluginInstance, index: number, out: number, count: number) {
-			const given = this.callArgs?.[index];
+			const given = index === -1 && this.chain ? [0, 0, 0] : this.callArgs?.[index];
 			const value = given instanceof Pointer
 				? Array.from({ length: count }, (_, i) => given.plugin.memory.cell(given.at + i * 4))
 				: given;
@@ -2230,6 +3110,10 @@ export class FakeServer {
 		},
 
 		set_arg_array(this: FakeServer, plugin: PluginInstance, index: number, cells: number, count: number) {
+			if (index === -1 && this.chain) {
+				this.chainSet(-1, 0);
+				return count;
+			}
 			const value = this.callArgs?.[index];
 			if (!Array.isArray(value) || count < 0) return 0;
 			for (let i = 0; i < count; i++) value[i] = plugin.memory.cell(cells + i * 4);
@@ -2268,6 +3152,44 @@ export class FakeServer {
 			if (at) setFieldCell(this.entities.get(id), at.field, cell, at.component);
 		},
 
+		// A vector entvar into the plugin's three numbers at `out`.
+		ent_vector(this: FakeServer, plugin: PluginInstance, id: number, offset: number, out: number) {
+			for (let i = 0; i < 3; i++) {
+				const at = tables().entvarAt.get(offset + i * 4);
+				plugin.memory.setNumber(out + i * 8, at ? bitsFloat(fieldCell(this.entities.get(id), at.field, at.component)) : 0);
+			}
+		},
+
+		// What a field's setter sends with the field: emessage_* to one player in the game.
+		send_one(this: FakeServer, plugin: PluginInstance, player: number, type: number) {
+			if (this.callNativeImpl(plugin, 'is_user_connected', [player]) === 0) return 0;
+			return this.callNativeImpl(plugin, 'emessage_begin', [MSG_ONE, type, 0, player]);
+		},
+
+		send_byte(this: FakeServer, plugin: PluginInstance, value: number) {
+			this.writing?.args.push(value);
+		},
+
+		send_long(this: FakeServer, plugin: PluginInstance, value: number) {
+			this.writing?.args.push(value);
+		},
+
+		send_string(this: FakeServer, plugin: PluginInstance, text: number) {
+			this.writing?.args.push(plugin.memory.string(text));
+		},
+
+		send_end(this: FakeServer, plugin: PluginInstance) {
+			this.callNativeImpl(plugin, 'emessage_end', []);
+		},
+
+		// A message of one or two numbers in one call: each written as its two bits of `kinds` say, 0 for none.
+		send_cells(this: FakeServer, plugin: PluginInstance, player: number, type: number, first: number, second: number, kinds: number) {
+			if (this.callNativeImpl(plugin, 'is_user_connected', [player]) === 0 || this.callNativeImpl(plugin, 'emessage_begin', [MSG_ONE, type, 0, player]) === 0) return;
+			if (kinds & 3) this.writing?.args.push(first);
+			if ((kinds >> 2) & 3) this.writing?.args.push(second);
+			this.callNativeImpl(plugin, 'emessage_end', []);
+		},
+
 		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;
@@ -2280,7 +3202,11 @@ export class FakeServer {
 
 		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);
+			// A member of ReGameDLL's own is not on a server without it.
+			const regameOnly = ['m_bSkipShowMenu', 'm_bNeededPlayers', 'm_flEscapeRatio', 'm_flTimeLimit', 'm_flGameStartTime', 'm_bTeamBalanced'];
+			if (!this.chains && regameOnly.includes(plugin.memory.string(name))) return -1;
+			// A member the facade reads by its own name (m_iTeam) has reapi's name too.
+			const field = tables().memberNamed.get(key) ?? tables().constants.get(plugin.memory.string(name));
 			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;
@@ -2335,6 +3261,14 @@ export class FakeServer {
 			this.setPlayerData(id, plugin.memory.string(key), plugin.memory.string(value), true);
 		},
 
+		player_slots(this: FakeServer, plugin: PluginInstance, at: number) {
+			plugin.playerSlots = at;
+		},
+
+		player_names(this: FakeServer, plugin: PluginInstance, at: number) {
+			plugin.playerNames = at;
+		},
+
 		// 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);
@@ -2368,16 +3302,21 @@ export class FakeServer {
 		// The dispatcher: a native with a `...` tail, its arguments laid out as
 		// cells. Every mask letter but `n` is an address in the plugin's memory,
 		// which is what a Pawn frame holds too - so the native gets the cells as
-		// they are, and reads through the addresses itself.
+		// they are, and reads through the addresses itself; an `s` is the
+		// plugin's string, which crosses as a Pawn string on the heap.
 		call(this: FakeServer, plugin: PluginInstance, id: number, argsPtr: number, maskPtr: number, argc: number) {
 			const name = tables().dispatched.get(id);
 			if (!name) throw new Error(`the dispatcher has no native with id ${id}`);
 
 			const args: number[] = [];
-			for (let i = 0; i < argc; i++) args.push(plugin.memory.cell(argsPtr + i * 4));
+			const marks: string[] = [];
+			for (let i = 0; i < argc; i++) {
+				args.push(plugin.memory.cell(argsPtr + i * 4));
+				marks.push(String.fromCharCode(plugin.memory.byte(maskPtr + i)));
+			}
 
 			if (!this.hasNative(name)) throw unsimulated(name);
-			return this.callNativeImpl(plugin, name, args);
+			return plugin.memory.across(marks, args, cells => this.callNativeImpl(plugin, name, cells));
 		},
 	};