@amxts/core 0.1.0 → 0.2.1

package/src/cli-api.mjs

@@ -7,17 +7,19 @@
 // compiles runs on Bun, as a task the command starts.
 //
 //   const core = await import('@amxts/core/cli-api');
-//   core.cliApi              3 - the contract below; the command checks it
+//   core.cliApi              5 - the contract below; the command checks it
 //   core.task('build', ['--deploy'])   { runtime: 'bun', args: [...] }
 //   core.includeSources().reapi        the ReAPI release the API is built from
 //   core.bunBinary()                   the Bun the tasks run on, installed with the core
 //   core.serverSystem([], env)         { system: 'linux', from: 'server', reason: 'hlds_linux' }
+//   core.release('windows')            where this version's server files are, and where they go
+//   core.moduleVersion(file)           '0.2.0': the release a server's module is of
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join, resolve } from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
-import { wamrcPath } from './system.mjs';
+import { manifestName, serverFiles, serverImage, wamrcPath } from './system.mjs';
 
 /** The core's folder: the package this file ships in. */
 export const coreDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
@@ -32,7 +34,7 @@ export const version = String(pkg.version);
  * returns changes in a way an older command would misread; the command says
  * which of the two to update when they differ.
  */
-export const cliApi = 3;
+export const cliApi = 5;
 
 /** Whether the core runs from a checkout (a .git folder beside it) rather than from npm. */
 export const fromSource = existsSync(join(coreDir, '.git'));
@@ -62,6 +64,7 @@ const SCRIPTS = {
 	prepare: 'prepare.ts',
 	build: 'build-wasm.ts',
 	check: 'check.ts',
+	upgrade: 'upgrade.ts',
 };
 
 /**
@@ -78,6 +81,9 @@ const SCRIPTS = {
  *   `--docker`: for the Docker server that mounts the project - no deploy,
  *   Linux only, its console shown);
  * - `check` checks a module package before it is published;
+ * - `upgrade` rewrites the project's code to this core's API, listing each change;
+ *   `--dry-run` writes nothing, `--report <file>` writes `{ changes, left }` there as JSON
+ *   and leaves what is left to do by hand to the caller to print;
  * - `typecheck` runs TypeScript over the project, after `prepare`.
  *
  * A failure is printed by the task itself and ends it with a non-zero code.
@@ -97,7 +103,7 @@ export function task(name, args = []) {
 
 /**
  * The third-party includes this core's API is generated from, as
- * includes/sources.json pins them, by id: `reapi`, `easy_http`, `resemiclip`,
+ * includes/sources.json pins them, by id: `reapi`, `resemiclip`,
  * each `{ name, version, license, home, url, sha256, include? }` - `url` gives
  * a file whose sha256 is `sha256`; for a .zip, `include` is the folder in it
  * whose .inc files are the includes. The command fetches ReAPI's for a
@@ -150,6 +156,33 @@ export function bunBinary() {
  */
 export { describeSystem, serverSystem } from './system.mjs';
 
+/**
+ * This version's GitHub Release, for a server of one system: `url` is where
+ * its files are (AMXTS_RELEASE_URL - a URL or a folder - takes another),
+ * `manifest` the file there that lists each one's sha256, `files` the ones a
+ * server runs and where they go under its game folder (cstrike), the module
+ * first; a `tool` only where the server has one. `image` is the server image
+ * of this version, for a server in Docker.
+ *
+ * @param {'windows' | 'linux'} system
+ */
+export function release(system) {
+	return {
+		version,
+		url: process.env.AMXTS_RELEASE_URL || `https://github.com/amxts/amxts/releases/download/v${version}/`,
+		manifest: manifestName(system),
+		files: serverFiles(system),
+		image: serverImage(version),
+	};
+}
+
+/**
+ * The release a module file is of - `0.2.0`, read from the ABI string the
+ * module carries, without loading it - or null when there is no file or it
+ * carries none.
+ */
+export { moduleVersion } from './system.mjs';
+
 /** The TypeScript the core builds with: the command reads amxts.config.ts with its parser. */
 export function typescript() {
 	return require('typescript');

package/src/system.mjs

@@ -13,9 +13,9 @@
 //
 // Plain JavaScript: the build (scripts/system.ts) and the amxts command, through
 // cli-api, both read it.
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 
@@ -38,6 +38,52 @@ export const TARGET_ABI = { windows: 'msvc', linux: 'gnu' };
 /** The amxts module's file, as AMX Mod X on that system looks it up for `amxts_amxx` in modules.ini. @type {Record<System, string>} */
 export const MODULE_FILE = { windows: 'amxts_amxx.dll', linux: 'amxts_amxx_i386.so' };
 
+/**
+ * The files of a system's GitHub Release that a server runs: the name each is
+ * attached under, and where it goes under the game folder (cstrike). A `tool`
+ * is the compiler for `.ts` plugins written on the server, which a server has
+ * only when its kit put it there.
+ * @param {System} system
+ * @returns {{ asset: string, path: string, tool: boolean }[]} the module first, then the tools
+ */
+export function serverFiles(system) {
+	const suffix = `${system}-x64`;
+	return [
+		{ asset: MODULE_FILE[system], path: `addons/amxmodx/modules/${MODULE_FILE[system]}`, tool: false },
+		{ asset: executable(`amxts-compile-${suffix}`, system), path: `addons/amxts/tools/${executable('amxts-compile', system)}`, tool: true },
+		{ asset: executable(`wamrc-${suffix}`, system), path: `addons/amxts/tools/${executable('wamrc', system)}`, tool: true },
+	];
+}
+
+/** A system's release manifest, attached beside its files: the version, and each file's size and sha256. */
+export function manifestName(system) {
+	return `amxts-${system}.json`;
+}
+
+/** The server image of a version. */
+export function serverImage(version) {
+	return `ghcr.io/amxts/server:${version}`;
+}
+
+// The ABI the module loads plugins of, which the module carries as a string
+// (AMXTS_ABI in the generated runtime/src/embedded.h): `0.2.0+abi.1a2b3c4d`.
+const MODULE_ABI = /(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\+abi\.[0-9a-f]{8}/;
+
+/**
+ * The amxts release a module file is of, read from the ABI string it
+ * carries - the file is read, not loaded, so a module a running server holds
+ * is read as well. Null when there is no file or no such string.
+ * @param {string} file
+ * @returns {string | null} the version: `0.2.0`
+ */
+export function moduleVersion(file) {
+	try {
+		return MODULE_ABI.exec(readFileSync(file, 'latin1'))?.[1] ?? null;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * `windows`, `win32`, `linux`, any case; null for anything else.
  * @param {string | undefined | null} value
@@ -50,6 +96,31 @@ export function parseSystem(value) {
 	return null;
 }
 
+// The folders AMXTS_SERVER may name above the server's addons/amxts, by what
+// is below them: hlds's own (cstrike/addons), the game's (addons).
+const ABOVE_ADDONS = [join('cstrike', 'addons'), 'addons'];
+
+/**
+ * The server's addons/amxts folder, from what AMXTS_SERVER holds: that
+ * folder itself, or the hlds folder, cstrike or cstrike/addons above it. A
+ * path that is not there yet is taken as addons/amxts, as it is written -
+ * dev builds, and deploys once it is - and so is a folder named amxts, or
+ * one holding the module's plugins.ini. Throws, naming where it looked, for
+ * a folder that is none of them.
+ * @param {string} path
+ * @returns {string} the folder; '' for ''
+ */
+export function serverFolder(path) {
+	if (!path) return '';
+	const dir = resolve(path);
+	if (!existsSync(dir) || basename(dir).toLowerCase() === 'amxts' || existsSync(join(dir, 'plugins.ini'))) return path;
+	if (basename(dir).toLowerCase() === 'addons') return join(dir, 'amxts');
+	const addons = ABOVE_ADDONS.map(below => join(dir, below)).find(folder => existsSync(folder));
+	if (addons) return join(addons, 'amxts');
+	const looked = [...ABOVE_ADDONS, 'plugins.ini'].map(below => join(dir, below).replace(/\\/g, '/'));
+	throw new Error(`AMXTS_SERVER=${path.replace(/\\/g, '/')} is not a server: there is no ${looked.join(', ')}. Set it to the server's folder (where hlds is), its cstrike, or cstrike/addons/amxts.`);
+}
+
 /**
  * What a server's files say it runs. `amxtsDir` is AMXTS_SERVER: the server's
  * addons/amxts, so hlds sits three folders up. Null when nothing there says.
@@ -101,7 +172,7 @@ export function serverSystem(argv = process.argv, env = process.env) {
 		if (!system) throw new Error(`AMXTS_SERVER_OS=${env.AMXTS_SERVER_OS}: windows or linux`);
 		return { system, from: 'env' };
 	}
-	const found = detectServerSystem(env.AMXTS_SERVER ?? '');
+	const found = detectServerSystem(serverFolder(env.AMXTS_SERVER ?? ''));
 	if (found) return { system: found.system, from: 'server', reason: found.reason };
 	return { system: HOST_SYSTEM, from: 'host' };
 }

package/src/testing/compile.ts

@@ -6,10 +6,11 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
 import { ascMain } from '../../scripts/asc';
-import { ASYNC_EXPORTS, asyncify, BASE_EXPORTS, compileToWasm, HoistImports, HOOD_EXPORTS, importsOf } from '../../scripts/compile';
+import { ASYNC_EXPORTS, BASE_EXPORTS, compileToWasm, finishing, HoistImports, HOOD_EXPORTS, importsOf } from '../../scripts/compile';
 import { playerFieldsBuild } from '../../scripts/player-fields';
 import { nativesBeside, nativesTransform, setNativesBeside } from '../../scripts/plugin-natives';
 import { ascPath, CONFIG_FILE, currentProjectDir, sourcesFor } from '../../scripts/project';
+import { targetTransforms } from '../../scripts/reapi-events';
 import { sharedModulesBuild } from '../../scripts/shared-modules';
 import { existsSync, hashOf } from '../../scripts/tracked-fs';
 import { cached } from './compile-cache';
@@ -69,6 +70,7 @@ function moduleOwner(source: string): string | null {
 	if (!/^@?[\w.-]+(?:\/[\w.-]+)?$/.test(source) || source.endsWith('.ts')) return null;
 	const sources = sourcesFor(PLUGINS_ROOT);
 	const pkg = sources.project.modules.find(each => each.name === source);
+	if (pkg?.library) throw new Error(`${source} is a library: it runs inside the plugins that import it - load one of them`);
 	return pkg ? sources.ownerSource(pkg) : null;
 }
 
@@ -103,15 +105,16 @@ async function build(path: string): Promise<Compiled> {
 
 /**
  * A plugin that makes a promise is compiled again with the scheduler's
- * exports and run through Asyncify, as scripts/compile.ts builds it for a
- * server - so an async function parks and resumes here as it does there.
+ * exports, and run through Asyncify when it can park, as scripts/compile.ts
+ * builds it for a server - so an async function parks and resumes here as it
+ * does there.
  */
 async function buildFresh(path: string): Promise<Omit<Compiled, 'module'>> {
 	const first = await buildWith(path, BASE_EXPORTS);
 	if (!importsOf(first.binary).has('env.co_wake')) return first;
 
 	const second = await buildWith(path, ASYNC_EXPORTS);
-	return { natives: second.natives, binary: asyncify(second.binary), async: true };
+	return { ...second, async: true };
 }
 
 async function buildWith(path: string, hoodExports: string): Promise<Omit<Compiled, 'module'>> {
@@ -143,7 +146,7 @@ async function buildWith(path: string, hoodExports: string): Promise<Omit<Compil
 				if (typeof contents !== 'string') binary = contents;
 			},
 			listFiles: () => [],
-			transforms: [HoistImports, nativesTransform(entry, natives, PLUGINS_ROOT), playerFields.transform, shared.transform],
+			transforms: [HoistImports, nativesTransform(entry, natives, PLUGINS_ROOT), playerFields.transform, shared.transform, ...targetTransforms(sources.project.config?.target), finishing(hoodExports, null)],
 		},
 	);
 

package/src/testing/index.ts

@@ -26,7 +26,8 @@ export { constant } from './tables';
 
 /**
  * Compiles a plugin (once per test run), loads it into a new fake server and
- * starts the map: its top level runs, then plugin_init and plugin_cfg.
+ * starts the map: its top level runs, then plugin_init, plugin_cfg and
+ * OnConfigsExecuted.
  *
  * Several plugins go into one server as an array - they hear each other's
  * forwards and natives, as on a real one.

package/src/testing/natives.ts

@@ -10,7 +10,7 @@
 // answers stops the test with its name; add it below, keeping to what the real
 // one does closely enough for a test to be believed.
 import type { Memory } from './memory';
-import type { FakePlayer, FakeServer, PluginInstance, SentForward, TeamName, Value } from './server';
+import type { FakePlayer, FakeServer, HookArg, PluginInstance, SentForward, TeamName, Value } from './server';
 import { bitsFloat, floatBits } from './memory';
 import { FakeEntity, flagBits, normalizePath, TEAMS } from './server';
 import { constant, tables } from './tables';
@@ -98,6 +98,33 @@ function cellOf(field: number, value: number | number[] | string): number {
 	return tables().floatFields.has(field) ? floatBits(value) : value | 0;
 }
 
+/**
+ * A field's cell as the module reads it in memory (runtime/src/fields.h): a
+ * whole number, a float's bits, an entity's index; `element` is a vector's
+ * component or an array member's element.
+ */
+export function fieldCell(target: FakeEntity | undefined, field: number, element = 0): number {
+	const { arrayFields } = tables();
+	const value = target?.fields.get(FakeEntity.key(field, arrayFields.has(field) ? element : undefined));
+	if (Array.isArray(value)) return floatBits(value[element] ?? 0);
+	return value === undefined || (element > 0 && !arrayFields.has(field)) ? 0 : cellOf(field, value);
+}
+
+/** Writes a field's cell as the module does: a float's bits, one component of a vector, one element of an array. */
+export function setFieldCell(target: FakeEntity | undefined, field: number, cell: number, element = 0): void {
+	if (!target) return;
+	const { arrayFields, floatFields, vectorFields } = tables();
+	const key = FakeEntity.key(field, arrayFields.has(field) ? element : undefined);
+	if (vectorFields.has(field)) {
+		const before = target.fields.get(key);
+		const vector = Array.isArray(before) ? [...before] : [0, 0, 0];
+		vector[element] = bitsFloat(cell);
+		target.fields.set(key, vector);
+		return;
+	}
+	target.fields.set(key, floatFields.has(field) ? bitsFloat(cell) : cell);
+}
+
 /** get_entvar and get_member: a vector into the tail's buffer, text into its buffer, a cell returned. */
 function readField(call: NativeCall, target: FakeEntity | undefined, field: number, tail: number[], element?: number): number {
 	if (!target) return 0;
@@ -229,8 +256,13 @@ function executeHam(call: NativeCall, fn: number, id: number, tail: number[], ho
 	return Number(call.server.runHam(shape, id, args).result) | 0;
 }
 
+/** A vector given by address: its three numbers. */
+function vectorAt(call: NativeCall, at: number): number[] {
+	return [0, 1, 2].map(k => call.memory.float(at + k * 4));
+}
+
 /** SetHamParam*: `which` counts from 1, the entity itself. */
-function setHamParam(call: NativeCall, which: number, value: Value): number {
+function setHamParam(call: NativeCall, which: number, value: HookArg): number {
 	chain(call).args[which - 1] = value;
 	return 1;
 }
@@ -265,6 +297,9 @@ function sendText(call: NativeCall, id: number, variant: 'chat' | 'center' | 'co
 
 const PRINT_VARIANTS = ['', 'notify', 'console', 'chat', 'center'] as const;
 
+// Reunion's client_auth_type by its number, as the player's API names each.
+const AUTH_TYPES = ['unknown', 'dproto', 'steam', 'steamEmu', 'revEmu', 'oldRevEmu', 'hltv', 'sc2009', 'avsmp', 'sxei', 'revEmu2013', 'sse3'];
+
 /** A Pawn string of UTF-8 bytes - a path, a line of a file - as text. */
 function bytesText(call: NativeCall, pointer: number): string {
 	return call.memory.text(pointer, 65536);
@@ -420,8 +455,52 @@ export const NATIVES: Record<string, Native> = {
 	get_gametime: c => floatBits(c.server.time / 1000),
 	LibraryExists: (c, [name]) => +c.server.modules.has(c.memory.text(name)),
 
+	menu_create: (c, [title, handler]) => c.server.createMenu(c.memory.text(title), c.server.slotByPublic(c.memory.text(handler))),
+	menu_additem: (c, [menu, name, _info, _access, callback]) => {
+		c.server.menu(menu).items.push({ name: c.memory.text(name), callback });
+		return 1;
+	},
+	menu_makecallback: (c, [fn]) => c.server.menuCallbacks.push(c.server.slotByPublic(c.memory.text(fn))) - 1,
+	menu_item_setname: (c, [menu, item, name]) => {
+		const entry = c.server.menu(menu).items[item];
+		if (!entry) return 0;
+		entry.name = c.memory.text(name);
+		return 1;
+	},
+	menu_items: (c, [menu]) => c.server.menu(menu).items.length,
+	menu_display: (c, [id, menu, page]) => {
+		const target = player(c, id);
+		if (!target) throw new Error(`menu_display: player ${id} is not in game`);
+		c.server.displayMenu(target, c.server.menu(menu), page);
+	},
+	menu_destroy: (c, [menu]) => {
+		c.server.destroyMenu(menu);
+		return 1;
+	},
+	// The tail comes by address: a number's cell, or a string's.
+	menu_setprop: (c, [menu, prop, value]) => {
+		const made = c.server.menu(menu);
+		const props: Record<string, () => void> = {
+			MPROP_PERPAGE: () => made.perPage = c.memory.cell(value),
+			MPROP_EXIT: () => made.exit = c.memory.cell(value) !== constant('MEXIT_NEVER'),
+			MPROP_BACKNAME: () => made.back = c.memory.text(value),
+			MPROP_NEXTNAME: () => made.next = c.memory.text(value),
+			MPROP_EXITNAME: () => made.exitName = c.memory.text(value),
+			MPROP_TITLE: () => made.title = c.memory.text(value),
+			MPROP_NUMBER_COLOR: () => made.numberColor = c.memory.text(value),
+		};
+		const set = Object.entries(props).find(([name]) => constant(name) === prop)?.[1];
+		if (!set) throw new Error(`menu_setprop: the fake server knows no menu property ${prop}`);
+		set();
+		return 1;
+	},
 	server_cmd: (c, [format, ...tail]) => {
-		c.server.commands.push(formatPawn(c, c.memory.text(format), tail));
+		const line = formatPawn(c, c.memory.text(format), tail);
+		c.server.commands.push(line);
+		// The engine's kick: the player by userid leaves, with the reason.
+		const kick = line.match(/^kick #(\d+)(?: "(.*)")?/);
+		const kicked = kick && c.server.players.find(one => one.userid === Number(kick[1]));
+		if (kicked) kicked.disconnect({ reason: kick[2] ?? 'Kicked' });
 	},
 	server_print: (c, [format, ...tail]) => {
 		c.server.logLines.push(formatPawn(c, c.memory.text(format), tail));
@@ -448,6 +527,7 @@ export const NATIVES: Record<string, Native> = {
 
 	read_argc: c => c.server.argv.length,
 	read_argv: (c, [index, buffer, length]) => c.memory.setText(buffer, length, c.server.argv[index] ?? ''),
+	get_user_userid: (c, [id]) => player(c, id)?.userid ?? -1,
 	read_args: (c, [buffer, length]) => c.memory.setText(buffer, length, c.server.argv.slice(1).join(' ')),
 
 	// ------------------------------------------------------------ players
@@ -456,8 +536,13 @@ export const NATIVES: Record<string, Native> = {
 	is_user_alive: (c, [id]) => +!!player(c, id)?.alive,
 	is_user_bot: (c, [id]) => +!!player(c, id)?.bot,
 	is_user_hltv: () => 0,
+	// reapi's Reunion natives: they are there only when reapi finds Reunion.
+	has_reunion: c => +(c.server.modules.has('reapi') && c.server.reunion),
+	REU_GetAuthtype: (c, [id]) => Math.max(0, AUTH_TYPES.indexOf(player(c, id)?.authType ?? '')),
+	REU_GetProtocol: (c, [id]) => player(c, id)?.protocol ?? 0,
+	REU_GetAuthKey: (c, [id, buffer, length]) => c.memory.setText(buffer, length, player(c, id)?.authKey ?? ''),
 	get_user_name: (c, [id, buffer, length]) => c.memory.setText(buffer, length, id === 0 ? 'Console' : player(c, id)?.name ?? ''),
-	get_user_authid: (c, [id, buffer, length]) => c.memory.setText(buffer, length, player(c, id)?.authid ?? ''),
+	get_user_authid: (c, [id, buffer, length]) => c.memory.setText(buffer, length, player(c, id)?.steamId ?? ''),
 	get_user_ip: (c, [id, buffer, length, withoutPort]) => {
 		const ip = player(c, id)?.ip ?? '';
 		return c.memory.setText(buffer, length, withoutPort ? ip.replace(/:\d+$/, '') : ip);
@@ -601,6 +686,8 @@ export const NATIVES: Record<string, Native> = {
 	create_entity: (c, [classname]) => c.server.createEntity(c.memory.text(classname)).id,
 	remove_entity: (c, [id]) => +c.server.entities.delete(id),
 	is_valid_ent: (c, [id]) => +c.server.entities.has(id),
+	// 2: the entity has the game's private data, which every fake one has.
+	pev_valid: (c, [id]) => (player(c, id) || c.server.entities.has(id) ? 2 : 0),
 	find_ent_by_class: (c, [start, classname]) => {
 		const name = c.memory.text(classname);
 		const found = [...c.server.entities.values()].find(e => e.id > start && e.classname === name);
@@ -799,6 +886,11 @@ export const NATIVES: Record<string, Native> = {
 		c.server.semiclipMasks.set(id, mask | 0);
 	},
 	resemiclip_get_user_mask: (c, [id]) => c.server.semiclipMasks.get(id) ?? 0,
+	// A hook's handle switched off and on, as reapi and Ham Sandwich do: a switched-off one does not call the plugin.
+	DisableHookChain: (c, [handle]) => c.server.switchHook(handle, false),
+	EnableHookChain: (c, [handle]) => c.server.switchHook(handle, true),
+	DisableHamForward: (c, [handle]) => c.server.switchHook(handle, false),
+	EnableHamForward: (c, [handle]) => c.server.switchHook(handle, true),
 	register_touch: (c, [touched, toucher, callback]) => {
 		c.server.touches.push({ touched: c.memory.text(touched), toucher: c.memory.text(toucher), slot: c.server.slotByPublic(c.memory.text(callback)) });
 		return c.server.touches.length;
@@ -874,6 +966,19 @@ export const NATIVES: Record<string, Native> = {
 		for (const listener of c.server.messageListeners) listener(message);
 		return 1;
 	},
+	// emessage_end: the message goes out through the engine, so every plugin's
+	// register_message hooks hear it on its way - a plugin's message_end they do not.
+	emessage_end: (c) => {
+		const message = c.server.writing;
+		if (!message) return 1;
+		c.server.writing = null;
+		const target = c.server.player(message.player);
+		const sent = c.server.sendMessage(message.name, message.args, target ? { player: target } : {});
+		if (sent.prevented) return 1;
+		message.args = sent.args;
+		c.server.writing = message;
+		return NATIVES.message_end(c, []) as number;
+	},
 	write_coord_f: (c, [value]) => {
 		c.server.writing?.args.push(bitsFloat(value));
 		return 1;
@@ -887,7 +992,7 @@ export const NATIVES: Record<string, Native> = {
 	SetHamParamEntity: (c, [which, value]) => setHamParam(c, which, value),
 	SetHamParamFloat: (c, [which, value]) => setHamParam(c, which, bitsFloat(value)),
 	SetHamParamString: (c, [which, text]) => setHamParam(c, which, c.memory.text(text)),
-	SetHamParamVector: (c, [which]) => setHamParam(c, which, 0),
+	SetHamParamVector: (c, [which, at]) => setHamParam(c, which, vectorAt(c, at)),
 	SetHamReturnInteger: (c, [value]) => setHamReturn(c, value),
 	SetHamReturnEntity: (c, [value]) => setHamReturn(c, value),
 	SetHamReturnFloat: (c, [value]) => setHamReturn(c, bitsFloat(value)),
@@ -901,6 +1006,89 @@ export const NATIVES: Record<string, Native> = {
 	set_dhudmessage: (c, [r, g, b, x, y, _effects, _fxtime, hold]) => {
 		c.server.hud = { color: [r, g, b], x: bitsFloat(x), y: bitsFloat(y), hold: bitsFloat(hold), channel: -1 };
 	},
+	// A server without reapi hears ReGameDLL's events through these (as/hlds.ts).
+	// register_logevent(function[], argsnum, ...filters): server.gameLog() calls it.
+	register_logevent: (c, [callback, argc, ...filters]) => {
+		c.server.logEvents.push({ argc, filters: filters.map(at => c.memory.text(at)), slot: c.server.slotByPublic(c.memory.text(callback)) });
+		return c.server.logEvents.length;
+	},
+	read_logdata: (c, [buffer, length]) => c.memory.setText(buffer, length, c.server.logLine),
+	read_logargc: c => c.server.logArgs.length,
+	read_logargv: (c, [index, buffer, length]) => c.memory.setText(buffer, length, c.server.logArgs[index] ?? ''),
+	// A line logged through the engine, where the logevents hear it.
+	elog_message: (c, [format, ...tail]) => {
+		c.server.gameLog(formatPawn(c, c.memory.text(format), tail));
+		return 1;
+	},
+	// register_event(event[], function[], flags[], cond[], ...): server.sendMessage() calls it once the message is sent.
+	register_event: (c, [name, callback, _flags, ...conditions]) => {
+		c.server.messageEvents.push({ name: c.memory.text(name), conditions: conditions.map(at => c.memory.text(at)), slot: c.server.slotByPublic(c.memory.text(callback)) });
+		return c.server.messageEvents.length;
+	},
+	register_forward: (c, [fn, callback, post]) => {
+		const key = `${fn}:${post ? 'post' : 'pre'}`;
+		c.server.fakemetaForwards.set(key, [...(c.server.fakemetaForwards.get(key) ?? []), c.server.slotByPublic(c.memory.text(callback))]);
+		return c.server.fakemetaForwards.size;
+	},
+	forward_return: (c, [type, value]) => {
+		c.server.forwardAnswer = type === constant('FMV_STRING') ? c.memory.text(value) : c.memory.cell(value);
+		return 1;
+	},
+	get_orig_retval: c => c.server.origRetval,
+	register_clcmd: (c, [name, callback]) => {
+		const command = c.memory.text(name).toLowerCase();
+		c.server.clientCommands.set(command, [...(c.server.clientCommands.get(command) ?? []), c.server.slotByPublic(c.memory.text(callback))]);
+		return 1;
+	},
+	// The engine's functions the hood calls: an event's index, and who hears whom.
+	// The engine's and the game's functions, each argument of the tail by
+	// address, as fakemeta reads them; what a plugin calls is in engineCalls.
+	engfunc: (c, [type, ...tail]) => {
+		const [cell, float, vector, text] = [(i: number) => c.memory.cell(tail[i]), (i: number) => c.memory.float(tail[i]), (i: number) => c.memory.vector(tail[i]).join(','), (i: number) => c.memory.text(tail[i])];
+		const call = (line: string) => c.server.engineCalls.push(line);
+		if (type === constant('EngFunc_PrecacheEvent')) return c.server.precached.indexOf(text(1)) + 1 || c.server.precached.push(text(1));
+		if (type === constant('EngFunc_SetClientListening')) c.server.listening.push([cell(0), cell(1), cell(2)]);
+		if (type === constant('EngFunc_PrecacheModel')) return c.server.precached.indexOf(text(0)) + 1 || c.server.precached.push(text(0));
+		if (type === constant('EngFunc_TraceLine')) call(`TraceLine ${vector(0)} ${vector(1)} ${cell(2)} ${cell(3)} ${tail.length > 4 ? cell(4) : '-'}`);
+		if (type === constant('EngFunc_VecToAngles')) c.memory.setVector(tail[1], [0, 90, 0]);
+		if (type === constant('EngFunc_Time')) return floatBits(c.server.time / 1000);
+		if (type === constant('EngFunc_CreateFakeClient')) {
+			if (c.server.players.length >= c.server.maxPlayers) return 0;
+			return c.server.join(text(0), { bot: true, team: 'UNASSIGNED', alive: false }).id;
+		}
+		if (type === constant('EngFunc_RunPlayerMove')) {
+			const bot = player(c, cell(0));
+			const [, yaw] = c.memory.vector(tail[1]);
+			const [forward, msec] = [float(2), cell(7)];
+			call(`RunPlayerMove ${cell(0)} ${vector(1)} ${forward} ${float(3)} ${float(4)} ${cell(5)} ${cell(6)} ${msec}`);
+			if (bot) bot.origin = [bot.origin[0] + Math.cos(yaw * Math.PI / 180) * forward * msec / 1000, bot.origin[1] + Math.sin(yaw * Math.PI / 180) * forward * msec / 1000, bot.origin[2]];
+		}
+		return 0;
+	},
+	dllfunc: (c, [type, ...tail]) => {
+		if (type === constant('DLLFunc_GetGameDescription')) c.memory.setText(tail[0], c.memory.cell(tail[1]), 'Counter-Strike');
+		if (type === constant('DLLFunc_ClientConnect')) {
+			c.server.engineCalls.push(`ClientConnect ${c.memory.cell(tail[0])} ${c.memory.text(tail[1])} ${c.memory.text(tail[2])}`);
+			// The game turns away a name it does not like, and says why.
+			if (!c.memory.text(tail[1]).startsWith('Rejected')) return 1;
+			c.memory.setText(tail[3], c.memory.cell(tail[4]), 'No room for you');
+			return 0;
+		}
+		if (type === constant('DLLFunc_ClientPutInServer')) c.server.engineCalls.push(`ClientPutInServer ${c.memory.cell(tail[0])}`);
+		return 0;
+	},
+	global_get: (c, [field, ...tail]) => {
+		if (field === constant('glb_frametime') && tail[0]) c.memory.setFloat(tail[0], 0.01);
+		return 0;
+	},
+	get_ent_data: (c, [id, _class, member, element]) => fieldCell(entity(c, id) ?? player(c, id), constant(c.memory.text(member)), element),
+	cs_get_user_money: (c, [id]) => fieldCell(player(c, id), constant('m_iAccount')),
+	find_ent_by_model: (c, [start, classname, model]) => {
+		const [wanted, path] = [c.memory.text(classname), c.memory.text(model)];
+		const found = [...c.server.entities.values()].find(one => one.id > start && one.classname === wanted && one.get('var_model') === path);
+		return found?.id ?? 0;
+	},
+	get_timeleft: () => 0,
 	CreateHudSyncObj: () => ++hudSyncObjects,
 	ShowSyncHudMsg: (c, [id, _sync, format, ...tail]) => sendText(c, id, 'hud', formatPawn(c, c.memory.text(format), tail)),
 	ClearSyncHud: () => 1,
@@ -921,5 +1109,11 @@ const SAME_AS: Record<string, string> = {
 	write_char: 'write_byte',
 	write_short: 'write_byte',
 	write_long: 'write_byte',
+	// A message sent through the engine, which every plugin's message hooks hear (emessage_end).
+	emessage_begin: 'message_begin',
+	ewrite_byte: 'write_byte',
+	ewrite_long: 'write_byte',
+	ewrite_short: 'write_byte',
+	ewrite_string: 'write_string',
 };
 for (const [name, same] of Object.entries(SAME_AS)) NATIVES[name] = NATIVES[same];