@amxts/core 0.2.4 → 0.3.0

package/scripts/build-wasm.ts

@@ -35,7 +35,7 @@ import { createSocket } from 'node:dgram';
 // generic one. Both
 // must come from the same WAMR release as the module, or the loader reports
 // "unknown binary version" (CONTRIBUTING.md builds both from one checkout).
-import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, utimesSync, watch, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, utimesSync, watch, writeFileSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { includePath } from './compile';
 import { compileAll } from './compile-pool';
@@ -46,6 +46,7 @@ import { pluginCache } from './plugin-cache';
 import { includeName } from './plugin-natives';
 import { fromRegistry, prebuiltOf, prebuiltSurface } from './prebuilt';
 import { CORE_DIR, CORE_PLUGINS, loadProject, modulesInUse, pluginList, projectPlugins, sourcesFor, staleCopies } from './project';
+import { aotSection, ENV_SECTION, envProblems, parseDotenv } from './server-env';
 import { sharedModulesBuild } from './shared-modules';
 import { describeSystem, serverFolder, serverSystem, SYSTEM_NAME, WAMRC_PACKAGE, wamrcPath } from './system';
 import { c, live, log, progress, since } from './ui';
@@ -406,6 +407,16 @@ async function deployAndReload(built: string[], names: string): Promise<string>
 		if (before && byRcon) utimesSync(target, before.atime, before.mtime);
 	}
 
+	// A variable a plugin requires that the server's .env has not, or has of
+	// another kind: the module refuses the plugin unless the server's
+	// environment, which this cannot see, has it (scripts/server-env.ts).
+	const dotenvPath = join(serverDir, '.env');
+	const dotenv = parseDotenv(existsSync(dotenvPath) ? readFileSync(dotenvPath, 'utf8') : '');
+	for (const file of built) {
+		const missing = envProblems((aotSection(readFileSync(join(outDir, file)), ENV_SECTION) ?? '').split('\n').filter(Boolean), dotenv);
+		if (missing.length) log.warn(`${file.replace(/\.aot$/, '')} needs ${missing.join(', ')}, which ${shown(dotenvPath)} has not: the server refuses it unless its environment has it`);
+	}
+
 	// A plugin that exports natives has an include for Pawn plugins beside it;
 	// it goes where amxxpc on the server looks, when the server has one.
 	const pawnIncludes = join(serverDir, '..', 'amxmodx', 'scripting', 'include');
@@ -416,17 +427,6 @@ async function deployAndReload(built: string[], names: string): Promise<string>
 	// The module's own natives for Pawn: the fields plugins add to Player.
 	if (existsSync(pawnIncludes)) copyFileSync(join(CORE_DIR, 'runtime/host/amxts.inc'), join(pawnIncludes, 'amxts.inc'));
 
-	// A folder beside the plugins is a library - `~/lib/thing`, `~/myplugin/config`.
-	// It is compiled into the .aot already, so nothing here needs it; a .ts
-	// plugin written on the server does, and it was silently compiling against
-	// whatever copy happened to be there.
-	const ownFolder = resolve(sourceDir) !== resolve(CORE_PLUGINS) || resolve(project.dir) === resolve(CORE_DIR);
-	for (const entry of ownFolder ? readdirSync(sourceDir, { withFileTypes: true }) : []) {
-		if (entry.isDirectory()) {
-			cpSync(join(sourceDir, entry.name), join(serverDir, 'plugins', entry.name), { recursive: true });
-		}
-	}
-
 	if (project.config) {
 		writeFileSync(listPath, serverList(existing, readFileSync(join(outDir, 'plugins.ini'), 'utf8')));
 	} else if (existing.length === 0) {

package/scripts/check.ts

@@ -38,7 +38,10 @@ try {
 }
 
 if (!pkg && problems.length === 0) {
-	fail('amxts check: this folder is not a module package - package.json has no "amxts": { "module": ... }');
+	// A project: its plugins are checked by typecheck and build, not by this.
+	fail(existsSync(join(dir, 'amxts.config.ts'))
+		? 'amxts check checks a module package before it is published; in a project, `npx amxts typecheck` checks the plugins and `npx amxts build` builds them'
+		: 'amxts check: this folder is not a module package - package.json has no "amxts": { "module": ... }');
 	process.exit(1);
 }
 

package/scripts/client-messages.ts

@@ -1,6 +1,6 @@
 // The messages Counter-Strike's server sends its clients, as
 // server.addMessageListener(name, ...) hears them - read by
-// scripts/generate-host.ts, which writes their events into as/events.ts.
+// scripts/generate-image.ts, which writes their events into as/events.ts.
 //
 // Every name the game registers is a message a plugin can listen to, by the
 // name MESSAGE_NAMES gives it in the player's words: `death`, not `DeathMsg`.
@@ -129,10 +129,82 @@ export const MESSAGE_FIELDS: Record<string, MessageField[]> = {
 		f('slot', 6, 'number'),
 		f('position', 7, 'number'),
 		f('weapon', 8, 'weapon'),
+		f('flags', 9, 'number'),
 	],
 	WeapPickup: [f('weapon', 1, 'weapon')],
 };
 
+/** How a message's argument is written: `write_byte`, `write_short` and the rest; `string*` every text from there on. */
+export type MessageWrite = 'byte' | 'char' | 'short' | 'long' | 'coord' | 'angle' | 'string' | 'string*';
+
+/**
+ * The messages a plugin can send by name (player.send, server.send): each
+ * argument as the game writes it, in order - ReGameDLL's MESSAGE_BEGIN
+ * sites. A message is here only when its fields name every argument, so
+ * what an author gives is the whole message; `=n` is an argument the game
+ * always writes as `n` (ScoreInfo's class).
+ */
+export const MESSAGE_WRITES: Record<string, string> = {
+	ADStop: '',
+	AllowSpec: 'byte',
+	AmmoPickup: 'byte byte',
+	AmmoX: 'byte byte',
+	ArmorType: 'byte',
+	BarTime: 'short',
+	BarTime2: 'short short',
+	Battery: 'short',
+	BlinkAcct: 'byte',
+	BombDrop: 'coord coord coord byte',
+	BombPickup: '',
+	BotVoice: 'byte byte',
+	BuyClose: '',
+	Crosshair: 'byte',
+	CurWeapon: 'byte byte byte',
+	Damage: 'byte byte long coord coord coord',
+	DeathMsg: 'byte byte byte string',
+	Flashlight: 'byte byte',
+	FlashBat: 'byte',
+	Geiger: 'byte',
+	Health: 'byte',
+	HideWeapon: 'byte',
+	HostageK: 'byte',
+	InitHUD: '',
+	ItemPickup: 'string',
+	ItemStatus: 'byte',
+	Location: 'byte string',
+	Money: 'long byte',
+	MOTD: 'byte string',
+	NVGToggle: 'byte',
+	Radar: 'byte coord coord coord',
+	ResetHUD: '',
+	RoundTime: 'short',
+	SayText: 'byte string string*',
+	Scenario: 'byte string byte',
+	ScoreAttrib: 'byte byte',
+	ScoreInfo: 'byte short short short=0 short',
+	ScreenFade: 'short short short byte byte byte byte',
+	ScreenShake: 'short short short',
+	SendAudio: 'byte string short',
+	ServerName: 'string',
+	SetFOV: 'byte',
+	ShowTimer: '',
+	SpecHealth: 'byte',
+	SpecHealth2: 'byte byte',
+	Spectator: 'byte byte',
+	StatusIcon: 'byte string byte byte byte',
+	StatusText: 'byte string',
+	StatusValue: 'byte short',
+	TaskTime: 'short byte byte',
+	TeamInfo: 'byte string',
+	TeamScore: 'string short',
+	TextMsg: 'byte string string*',
+	Train: 'byte',
+	TutorClose: '',
+	ViewMode: '',
+	WeaponList: 'string byte byte byte byte byte byte byte byte',
+	WeapPickup: 'byte',
+};
+
 /** Every message Counter-Strike 1.6 registers, by the name get_user_msgid takes. */
 export const CLIENT_MESSAGES = `
 	ADStop AllowSpec AmmoPickup AmmoX ArmorType BarTime BarTime2 Battery BlinkAcct BombDrop BombPickup

package/scripts/compile-cache.ts

@@ -1,12 +1,15 @@
 // Compiles kept on disk, reused while what they read is the same.
 //
 // A compile is keyed by everything that is not a file it read - the
-// compiler, the hood's scripts, the version the core builds as (a plugin
-// carries it in its ABI), the flags, the project and its config - and
-// stored with every file read it made (scripts/tracked-fs.ts): the entry, what
-// it imports, the facade and the generated API, the module packages. It is
-// taken again only while each of those reads sees the same thing it saw, so a
-// hit is what compiling again would give, byte for byte.
+// compiler, the hood's scripts, the line of the version the core builds as
+// (a plugin carries it in its ABI), the flags, the project and its config -
+// and stored with every file read it made (scripts/tracked-fs.ts): the entry,
+// what it imports, the facade and the generated API, the module packages,
+// the files the ABI's hash is made of. It is taken again only while each of
+// those reads sees the same thing it saw, so a hit is what compiling again
+// would give, byte for byte - but for the patch of the version in its ABI,
+// which the module does not compare (scripts/build-identity.ts): a core's
+// patch release with the same hood takes the plugins of the one before.
 //
 // One key holds one entry: a compile made again replaces the one before, so a
 // cache does not grow with every edit. The testing library keeps its compiles
@@ -16,7 +19,7 @@ import type { Reads } from './tracked-fs';
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { coreVersion } from './build-identity';
+import { coreVersion, releaseLine } from './build-identity';
 import { listIncludes } from './includes';
 import { currentProjectDir, loadProject } from './project';
 import { hashOf, recordReads, unchanged } from './tracked-fs';
@@ -120,7 +123,7 @@ export function diskCache(dir: string | null, code: () => string, ownIncludes: s
 	let identity: string | null = null;
 	const fileOf = (parts: unknown[]) => {
 		identity ??= hashOf(`${FORMAT}\n${code()}`);
-		return join(dir!, `${hashOf(JSON.stringify([identity, coreVersion(), projectIdentity(ownIncludes), ...parts]))}.json`);
+		return join(dir!, `${hashOf(JSON.stringify([identity, releaseLine(coreVersion()), projectIdentity(ownIncludes), ...parts]))}.json`);
 	};
 
 	let pruned = false;

package/scripts/compile-pool.ts

@@ -7,7 +7,7 @@
 import type { Plugin } from './compile';
 import type { NativesBeside, PluginNative } from './plugin-natives';
 import { spawn } from 'node:child_process';
-import { availableParallelism } from 'node:os';
+import { availableParallelism, constants, setPriority } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { setNativesBeside } from './plugin-natives';
@@ -66,8 +66,9 @@ export interface WorkerJob {
 export type WorkerResult = Compiled & { beside: NativesBeside };
 
 /** A worker process: one job at a time, until it is closed. */
-function worker() {
+function worker(low: boolean) {
 	const child = spawn(process.execPath, [WORKER], { stdio: ['ignore', 'inherit', 'inherit', 'ipc'] });
+	if (low) setPriority(child.pid!, constants.priority.PRIORITY_BELOW_NORMAL);
 	let waiting: { resolve: (result: WorkerResult) => void; reject: (error: Error) => void } | null = null;
 	const answer = () => {
 		const now = waiting;
@@ -93,6 +94,8 @@ export interface CompileAll {
 	here: (plugin: Plugin, natives: PluginNative[]) => Promise<string | null>;
 	started?: (index: number) => void;
 	finished?: (index: number, compiled: Compiled) => void;
+	/** The workers below the machine's other work: the test server's build, which no one waits on at the keyboard. */
+	low?: boolean;
 }
 
 /**
@@ -102,7 +105,7 @@ export interface CompileAll {
  */
 export async function compileAll(plugins: Plugin[], options: CompileAll): Promise<(Compiled | null)[]> {
 	const slots = Math.min(plugins.length, compileSlots());
-	const workers = slots > 1 ? Array.from({ length: slots }, worker) : [];
+	const workers = slots > 1 ? Array.from({ length: slots }, () => worker(options.low ?? false)) : [];
 	let failed = false;
 	const compile = async (plugin: Plugin, slot: number): Promise<Compiled> => {
 		if (workers.length === 0) {

package/scripts/compile-worker.ts

@@ -1,23 +1,23 @@
-// A compile process of scripts/compile-pool.ts: compiles the plugins it is
-// sent, one at a time, through the build's plugin cache (scripts/plugin-cache.ts),
-// and answers each with what went wrong and the plugin's natives. It ends when
-// the build disconnects.
-import type { WorkerJob, WorkerResult } from './compile-pool';
-import type { PluginNative } from './plugin-natives';
-import { pluginCache } from './plugin-cache';
-import { nativesBeside } from './plugin-natives';
-
-const caches = new Map<string, ReturnType<typeof pluginCache>>();
-
-process.on('message', async ({ plugin, dir, includes }: WorkerJob) => {
-	const key = JSON.stringify([dir, includes]);
-	if (!caches.has(key)) caches.set(key, pluginCache(dir, includes));
-	const natives: PluginNative[] = [];
-	let problem: string | null;
-	try {
-		problem = await caches.get(key)!.compile(plugin, natives);
-	} catch (error) {
-		problem = String((error as Error).stack ?? error);
-	}
-	process.send!({ problem, natives, beside: nativesBeside(natives) } satisfies WorkerResult);
-});
+// A compile process of scripts/compile-pool.ts: compiles the plugins it is
+// sent, one at a time, through the build's plugin cache (scripts/plugin-cache.ts),
+// and answers each with what went wrong and the plugin's natives. It ends when
+// the build disconnects.
+import type { WorkerJob, WorkerResult } from './compile-pool';
+import type { PluginNative } from './plugin-natives';
+import { pluginCache } from './plugin-cache';
+import { nativesBeside } from './plugin-natives';
+
+const caches = new Map<string, ReturnType<typeof pluginCache>>();
+
+process.on('message', async ({ plugin, dir, includes }: WorkerJob) => {
+	const key = JSON.stringify([dir, includes]);
+	if (!caches.has(key)) caches.set(key, pluginCache(dir, includes));
+	const natives: PluginNative[] = [];
+	let problem: string | null;
+	try {
+		problem = await caches.get(key)!.compile(plugin, natives);
+	} catch (error) {
+		problem = String((error as Error).stack ?? error);
+	}
+	process.send!({ problem, natives, beside: nativesBeside(natives) } satisfies WorkerResult);
+});

package/scripts/compile.ts

@@ -6,24 +6,26 @@ import { spawnSync } from 'node:child_process';
 
 // Compiles one plugin: .ts in, .aot out.
 //
-// Both halves of the project use this one function - `bun run plugins` here,
-// and amxts-compile.exe on a server - so that a plugin compiles the same way
-// in both places. In particular the `~/` alias, which is ours rather than
-// AssemblyScript's and lives in the readFile hook below.
+// Every build compiles through this one function - `amxts build` and `dev`,
+// the tests, the modules' prebuilt plugins - so that a plugin compiles the
+// same way everywhere. In particular the `~/` alias, which is ours rather
+// than AssemblyScript's and lives in the readFile hook below.
 import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, dirname, relative, resolve } from 'node:path';
-// The Binaryen asc itself runs on - the same copy, so the compiler a server
-// gets carries one - for the one pass asc does not run: Asyncify.
+// The Binaryen asc itself runs on - the same copy - for the one pass asc
+// does not run: Asyncify.
 // @ts-ignore - shipped as JavaScript, with types beside it we do not need here
 import * as assemblyscript from '../runtime/deps/assemblyscript/dist/assemblyscript.js';
 // @ts-ignore - its types are beside it, under a path tsconfig does not map
 import binaryen from '../runtime/deps/assemblyscript/node_modules/binaryen/index.js';
 import { ascMain } from './asc';
-import { ABI_SECTION, abiIdentity } from './build-identity';
+import { ABI_SECTION, nativesFile, pluginAbi } from './build-identity';
+import { LEAF_NATIVES } from './leaf-natives';
 import { playerFieldsBuild } from './player-fields';
 import { includeName, nativeContract, nativesTransform, pawnInclude } from './plugin-natives';
 import { ascPath, sourcesFor } from './project';
 import { targetTransforms } from './reapi-events';
+import { ENV_SECTION, envBuild } from './server-env';
 import { sharedModulesBuild } from './shared-modules';
 import { displayName, MAP_SECTION, mapText, pluginMap, withSection } from './source-map';
 import { HOST_SYSTEM, TARGET_ABI } from './system';
@@ -53,6 +55,9 @@ export interface Plugin {
 /** Binaryen's optimisation level: a quick build's, and a full one's - asc's own --optimize. */
 const OPTIMIZE = { quick: 1, full: 3 };
 
+/** The size, in Binaryen's nodes, up to which a full build inlines any function (inlineSmall). */
+const INLINE_SIZE = 30;
+
 /** The hood's exports every plugin carries; see compilePlugin. */
 export const HOOD_EXPORTS = '__amxts_exports.ts';
 
@@ -80,6 +85,9 @@ export const ASYNC_EXPORTS = BASE_EXPORTS + [
 	'',
 ].join('\n');
 
+/** The names ASYNC_EXPORTS exports. */
+const ASYNC_NAMES = [...ASYNC_EXPORTS.matchAll(/export function (\w+)/g)].map(match => match[1]);
+
 /**
  * A transform that moves the imports at the end of a file - the ones the
  * build adds (scripts/auto-imports.ts), after the file's last line - to its
@@ -104,6 +112,37 @@ export const SUSPEND_IMPORT = 'env.co_suspend';
 /** The import of a plugin that makes a promise: it is compiled again with ASYNC_EXPORTS. */
 const WAKE_IMPORT = 'env.co_wake';
 
+/**
+ * The imports that use the plugin's memory they are given only while they
+ * run, and keep no address of it: an object whose address goes only to them
+ * can be made in its function's frame (makeStackObjects).
+ */
+const BORROWING_IMPORTS = new Set(['env.ent_vector']);
+
+/**
+ * The arguments of Pawn's natives that the module's thunk copies - text in
+ * or out, an array - and so keeps no address of, by the native's import:
+ * read off runtime/natives.txt. An object whose address goes only there, a field of the
+ * options a function reads, is no reason to keep it on the heap.
+ */
+const COPIED_ARGUMENTS: ReadonlyMap<string, number[]> = (() => {
+	const file = nativesFile();
+	if (!file) return new Map();
+	return new Map(readFileSync(file, 'utf8').split(/\r?\n/).flatMap((line) => {
+		const [name, , crossing] = line.split(' ');
+		if (!crossing || line.startsWith('#') || crossing === 'leaf') return [];
+		return [[`env.${name}`, crossing.split(',').flatMap((each, index) => (each === 'v' ? [] : [index]))]];
+	}));
+})();
+
+/**
+ * The imports that never run the plugin's code - the abort, which does not
+ * return, and those marked `@leaf` - so a call to one runs no step of the
+ * collector: a function whose objects are all made in its frame and that
+ * calls nothing else keeps no shadow stack (makeStackObjects).
+ */
+const QUIET_IMPORTS = new Set(['env.abort', 'env.ent_vector', ...[...LEAF_NATIVES].map(name => `env.${name}`)]);
+
 /**
  * What wamrc keeps for a failed call's stack (scripts/source-map.ts): each
  * function's frame with its index and the offset of the call it is in, or of
@@ -116,11 +155,11 @@ const WAKE_IMPORT = 'env.co_wake';
 const STACK_FLAGS = ['--enable-dump-call-stack', '--call-stack-features=bounds-checks,ip,func-idx,trap-ip'];
 
 /**
- * The map goes into the .aot either way, and so does the ABI the plugin is
- * compiled against, which the module checks before it loads it
- * (scripts/build-identity.ts).
+ * The map goes into the .aot either way, and so do the ABI the plugin is
+ * compiled against and the variables it requires, which the module checks
+ * before it loads it (scripts/build-identity.ts, scripts/server-env.ts).
  */
-const SECTIONS = `--emit-custom-sections=${MAP_SECTION},${ABI_SECTION}`;
+const SECTIONS = `--emit-custom-sections=${MAP_SECTION},${ABI_SECTION},${ENV_SECTION}`;
 
 /**
  * The CPU the machine code is for: a Pentium 4's, SSE2. LLVM's i386 left
@@ -234,18 +273,23 @@ export async function compileToWasm(
 	// A quick build leaves the optimising to one Binaryen pass afterwards.
 	const flags = [...(plugin.quick ? [] : ['--optimize']), ...(names ? ['--debug'] : []), '--sourceMap'];
 	const level = plugin.quick ? OPTIMIZE.quick : null;
-	let made = await compileWasm(plugin, BASE_EXPORTS, flags, level, natives);
+	// A quick build compiles every plugin with the scheduler's exports, once,
+	// and one that never waits loses them (finishing).
+	const hoodExports = plugin.quick ? ASYNC_EXPORTS : BASE_EXPORTS;
+	let made = await compileWasm(plugin, hoodExports, flags, level, natives);
 
 	// A plugin that makes a promise - an async function, fetch, sleep - has
-	// the host drive its jobs, so it is compiled again with the scheduler's
-	// exports.
-	if (typeof made !== 'string' && importsOf(made.binary).has(WAKE_IMPORT)) {
+	// the host drive its jobs, so a full build compiles it again with the
+	// scheduler's exports: asc's optimiser has the whole program, and one
+	// compiled with them would come out otherwise.
+	if (hoodExports === BASE_EXPORTS && typeof made !== 'string' && importsOf(made.binary).has(WAKE_IMPORT)) {
 		if (natives) natives.length = 0;
 		made = await compileWasm(plugin, ASYNC_EXPORTS, flags, level, natives);
 	}
 	if (typeof made === 'string') return made;
 	mkdirSync(dirname(resolve(wasm)), { recursive: true });
-	writeFileSync(wasm, withSection(withSection(made.binary, MAP_SECTION, mapText(made.map)), ABI_SECTION, abiIdentity()));
+	const sections = withSection(withSection(made.binary, MAP_SECTION, mapText(made.map)), ABI_SECTION, pluginAbi(importsOf(made.binary)));
+	writeFileSync(wasm, made.env.length ? withSection(sections, ENV_SECTION, made.env.join('\n')) : sections);
 	return null;
 }
 
@@ -265,10 +309,26 @@ export async function compileToWasm(
 export function finishing(hoodExports: string, level: number | null, done: (first: number, names: string[]) => void = () => {}) {
 	return {
 		afterCompile(module: any) {
+			// Read before asc's optimiser, which folds the global away.
+			const dataEnd = (binaryen.getExpressionInfo(binaryen.getGlobalInfo(module.getGlobal(DATA_END)).init) as binaryen.ConstInfo).value as number;
 			const emit = module.emitBinary.bind(module);
 			module.emitBinary = (url?: string) => {
-				const imports = new Set(functionsOf(module).map(each => each.imported));
+				let imports = new Set(functionsOf(module).map(each => each.imported));
+				// A quick build's plugin that never waits, compiled with the
+				// scheduler's exports: they go, and what only they reached.
+				if (hoodExports === ASYNC_EXPORTS && level !== null && !imports.has(WAKE_IMPORT)) {
+					for (const name of ASYNC_NAMES) module.removeExport(name);
+					module.runPasses(['remove-unused-module-elements']);
+					imports = new Set(functionsOf(module).map(each => each.imported));
+				}
 				if (hoodExports === ASYNC_EXPORTS || !imports.has(WAKE_IMPORT)) {
+					exportCallGlobals(module);
+					if (level === null) {
+						inlineSmall(module);
+						// A number that only ever holds a whole number within i32 is kept in an i32.
+						assemblyscript.keepWholeNumbers(module.ptr);
+						makeStackObjects(module, dataEnd);
+					}
 					if (imports.has(SUSPEND_IMPORT)) asyncify(module, level ?? OPTIMIZE.full);
 					else if (level !== null) optimize(module, level);
 				}
@@ -292,6 +352,60 @@ function functionsOf(module: any): { name: string; imported: string | null }[] {
 	return ordered.map(info => ({ name: info.name, imported: info.module ? `${info.module}.${info.base}` : null }));
 }
 
+/**
+ * A full build's small functions inlined where they are called. A function
+ * that keeps a shadow-stack frame calls ~stack_check, its guard, and
+ * Binaryen does not inline a function that calls another unless it is
+ * tiny - so a small function with a frame stayed a call.
+ */
+function inlineSmall(module: any) {
+	const always = binaryen.getAlwaysInlineMaxSize();
+	binaryen.setOptimizeLevel(OPTIMIZE.full);
+	binaryen.setShrinkLevel(0);
+	binaryen.setAlwaysInlineMaxSize(INLINE_SIZE);
+	module.runPasses(['inlining-optimizing']);
+	binaryen.setAlwaysInlineMaxSize(always);
+}
+
+/** Where the plugin's static data ends, and its shadow stack's bottom. */
+const DATA_END = '~lib/memory/__data_end';
+
+/**
+ * A full build's objects that never leave the function that makes them,
+ * made in its frame rather than on the heap - `player.origin.x` and the
+ * options literal of `player.showHud(text, { hold: 2 })` allocate nothing -
+ * by the compiler's pass over the inlined code, which knows which
+ * parameters each function keeps. A function an async function's coroutine
+ * may park in keeps its objects on the heap.
+ */
+function makeStackObjects(module: any, dataEnd: number) {
+	const functions = functionsOf(module);
+	const named = (imports: Set<string>) => functions.filter(each => each.imported && imports.has(each.imported)).map(each => each.name);
+	// An import's name with an argument's index, for one argument.
+	const copied = functions.flatMap(each => (COPIED_ARGUMENTS.get(each.imported ?? '') ?? []).map(index => `${each.name}#${index}`));
+	assemblyscript.makeStackObjects(module.ptr, [...named(BORROWING_IMPORTS), ...copied], named(new Set([SUSPEND_IMPORT])), dataEnd, named(QUIET_IMPORTS));
+}
+
+/**
+ * The globals a call of a function value sets, which the module sets too
+ * when it calls a listener itself rather than the plugin's walk of the
+ * listeners (the module's Handler.via): the closure's variables, how many
+ * arguments the call passes, the player an async function started there runs
+ * under. Exported under the names the module looks up; one the plugin has
+ * not got is not needed.
+ */
+const CALL_GLOBALS = [
+	['~lib/function/__env', '__env'],
+	['~argumentsLength', '__argumentsLength'],
+	['~lib/~/promise/__co_ambient_player', '__co_ambient_player'],
+];
+
+function exportCallGlobals(module: any) {
+	for (const [name, exported] of CALL_GLOBALS) {
+		if (module.getGlobal(name)) module.addGlobalExport(name, exported);
+	}
+}
+
 /** Binaryen's optimisation at `level`: what a quick build runs in place of asc's. */
 function optimize(module: any, level: number) {
 	binaryen.setOptimizeLevel(level);
@@ -303,6 +417,8 @@ function optimize(module: any, level: number) {
 interface Compiled {
 	binary: Uint8Array;
 	map: PluginMap;
+	/** Its env() calls as the section amxts.env writes them, a line a name (scripts/server-env.ts). */
+	env: string[];
 }
 
 /**
@@ -339,6 +455,9 @@ async function compileWasm(
 		return String((problem as Error).message ?? problem);
 	}
 
+	// The settings it reads with env(), from every file it reaches (scripts/server-env.ts).
+	const env = envBuild();
+
 	let binary: Uint8Array | null = null;
 	let sourceMap = '';
 	let functions = { first: 0, names: [] as string[] };
@@ -361,7 +480,10 @@ async function compileWasm(
 				// `~/` is the plugins folder: ascPath answers the alias.
 				const path = ascPath(plugin.root, filename, baseDir);
 				const text = sources.read(path);
-				return text === null ? null : shared.read(path, playerFields.read(relative('.', (sources.real(path) ?? path)), text));
+				if (text === null) return null;
+				const file = relative('.', (sources.real(path) ?? path));
+				env.read(file, text);
+				return shared.read(path, playerFields.read(file, text));
 			},
 
 			// The binary and its source map, for compileToWasm to write as one.
@@ -389,6 +511,7 @@ async function compileWasm(
 	// An import of a module the config does not list says so first: asc's
 	// "not found" after it is only the consequence.
 	if (sources.problems.length) return [...sources.problems, stderr.toString()].join('\n').trim();
+	if (env.problems.length) return env.problems.join('\n');
 
 	// A transform's refusal - a native whose signature cannot cross - is an
 	// error with nothing written to stderr.
@@ -397,7 +520,7 @@ async function compileWasm(
 	// folder, where the module finds the sources to show a failed line. A
 	// build to ship names none - the machine's folders are not the server's.
 	const root = level === null ? '' : sources.project.dir;
-	return { binary, map: pluginMap(sourceMap, file => fileName(sources, plugin.root, file), functions.first, functions.names.map(displayName), root) };
+	return { binary, env: env.entries(), map: pluginMap(sourceMap, file => fileName(sources, plugin.root, file), functions.first, functions.names.map(displayName), root) };
 }
 
 /**

package/scripts/docs/as/amxts.ts

@@ -222,11 +222,14 @@ export default {
 			server.addCommand<KickArgs>("/kick <target> [reason]", ({ player, target, reason }) => {
 			  target.kick(reason ?? \`Kicked by \${player.name}\`);
 			}, { access: "kick" });
-			server.addCommand("/hp", ({ player }) => print(player, \`\${player.health} HP\`));
+			server.addCommand("/hp", ({ player }) => player.print(\`\${player.health} HP\`));
+			server.addCommand(["/cp", "cp"], checkpoint);   // several names; a handler of the player
 			\`\`\`
 
 			A name with \`/\` is a chat command, one without a console command, and
-			\`"say <phrase>"\` a phrase written in chat. A \`number\` argument is
+			\`"say <phrase>"\` a phrase written in chat. Several names - the usage
+			first, then other names - are one command. A command without
+			arguments takes a handler of the player, \`(player) => ...\`. A \`number\` argument is
 			parsed, a \`Player\` found by \`#userid\`, the whole name or a part of it,
 			a \`string\` taken as it is - the last one takes the rest of the line. A
 			word that is not what the command takes answers the player with the
@@ -248,11 +251,14 @@ export default {
 			server.addCommand<KickArgs>("/kick <target> [reason]", ({ player, target, reason }) => {
 			  target.kick(reason ?? \`Kicked by \${player.name}\`);
 			}, { access: "kick" });
-			server.addCommand("/hp", ({ player }) => print(player, \`\${player.health} HP\`));
+			server.addCommand("/hp", ({ player }) => player.print(\`\${player.health} HP\`));
+			server.addCommand(["/cp", "cp"], checkpoint);   // несколько имён; обработчик игрока
 			\`\`\`
 
 			Имя со \`/\` — команда чата, без него — команда консоли, а
-			\`"say <фраза>"\` — фраза, написанная в чат. Аргумент \`number\`
+			\`"say <фраза>"\` — фраза, написанная в чат. Несколько имён — сначала
+			использование, затем другие имена — одна команда. Команда без
+			аргументов принимает обработчик игрока, \`(player) => ...\`. Аргумент \`number\`
 			разбирается как число, \`Player\` находится по \`#userid\`, имени целиком
 			или его части, \`string\` берётся как есть — последний забирает остаток
 			строки. На слово, которое команда не принимает, игрок получает её