@amxts/core 0.2.3 → 0.3.0

package/scripts/tracked-fs.ts

@@ -73,10 +73,19 @@ export function readdirSync(path: PathLike): string[] {
 		note('readdir', path, 'missing');
 		throw error;
 	}
-	note('readdir', path, hashOf([...names].sort().join('\n')));
+	note('readdir', path, listingOf(names));
 	return names;
 }
 
+/**
+ * What a folder's listing is noted as: its names but the hidden ones - a
+ * project's node_modules gains `.cache` with the first build's own cache,
+ * which no compile depends on.
+ */
+function listingOf(names: string[]): string {
+	return hashOf(names.filter(name => !name.startsWith('.')).sort().join('\n'));
+}
+
 /** `run`, with every file read it makes - and anything else read meanwhile - noted. */
 export async function recordReads<T>(run: () => Promise<T>): Promise<{ reads: Reads; result: PromiseSettledResult<T> }> {
 	const reads: Reads = {};
@@ -97,7 +106,7 @@ function seenNow(op: string, path: string): string {
 			case 'read': return hashOf(fs.readFileSync(path));
 			case 'exists': return String(fs.existsSync(path));
 			case 'stat': return kindOf(fs.statSync(path));
-			case 'readdir': return hashOf(fs.readdirSync(path).sort().join('\n'));
+			case 'readdir': return listingOf(fs.readdirSync(path));
 			default: return 'unknown';
 		}
 	} catch {

package/scripts/typed-commands.ts

@@ -32,6 +32,18 @@
 // - the call's `server.addCommand<KickArgs>` becomes that function's name,
 //   padded, so the rest of the line keeps its columns.
 //
+// Several names, `server.addCommand(["/cp", "cp"], ...)`, are one command:
+// the usage first, then names without arguments. A player's command without
+// arguments takes a handler of the player too, `(player) => ...`: its
+// argument's type is the class and `__AmxtsPlayer`, which the compiler hands
+// the class's `player` (`Context & Player`).
+//
+// A player's command added at the top level of the file with a function
+// declared there by name, `server.addCommand("/hp", onHp)`, gets no closure:
+// its parser is a function of its own that calls the handler by its name, and
+// the module calls another for the command typed in the console - in the
+// facade's place, the words taken from __commandWords.
+//
 // The interface is read from the source text - a syntax tree, no type checker
 // - in this file or imported, as the typed configs read theirs.
 import type { ImportReader } from './typed-configs';
@@ -57,6 +69,14 @@ function usageOf(node: ts.Expression, typed: boolean, file: ts.SourceFile): Usag
 	return { name: '', args: [] };
 }
 
+/** A command's other name, after its usage: a name in place, without arguments. */
+function aliasOf(node: ts.Expression, file: ts.SourceFile): string {
+	if (!ts.isStringLiteralLike(node)) throw new ShapeError(node, file, 'a command\'s other names are written in place: server.addCommand(["/cp", "cp"], ...)');
+	const usage = usageOrFail(parseUsage(node.text), node, file);
+	if (usage.args.length > 0) throw new ShapeError(node, file, `"${node.text}" - the arguments are written once, in the first name: ["/kick <target>", "/k"]`);
+	return usage.name;
+}
+
 function usageOrFail(usage: Usage | string, node: ts.Node, file: ts.SourceFile): Usage {
 	if (typeof usage === 'string') throw new ShapeError(node, file, usage);
 	return usage;
@@ -165,13 +185,30 @@ function readOf(arg: Argument, at: number, last: boolean, tabs: string): string[
 	}
 }
 
+/**
+ * A handler declared by name that the parser calls directly: its name, and the
+ * type its parameter is declared with - the interface, which the generated
+ * class implements - or null when it takes none.
+ */
+interface Direct {
+	name: string;
+	takes: string | null;
+}
+
 /**
  * The generated code for one call: the class of its handler's argument - an
  * implementation of `shape`, the interface the call names - and the function
- * that registers it.
+ * that registers it; with `direct`, the parser and the console's function
+ * besides, which call the handler by its name.
  */
-function commandCode(index: number, method: 'addCommand' | 'addServerCommand', args: Argument[], shape: string | undefined): string {
+function commandCode(index: number, method: 'addCommand' | 'addServerCommand', args: Argument[], shape: string | undefined, kept: boolean, direct: Direct | null, names: boolean): string {
 	const player = method === 'addCommand';
+	// A command without arguments takes a handler of the player too.
+	const takes = `__AmxtsCommandArgs${index}${player && !shape && args.length === 0 ? ' & __AmxtsPlayer' : ''}`;
+	const usage = names ? 'usage: string[]' : 'usage: string';
+	const register = (run: string, consoleIndex: string) => names
+		? `\t__amxtsServer.__addCommand(usage[0], ${run}, options, ${consoleIndex}, usage.slice(1));`
+		: `\t__amxtsServer.__addCommand(usage, ${run}, options${consoleIndex === '0' ? '' : `, ${consoleIndex}`});`;
 	const type = `__AmxtsCommandArgs${index}`;
 	const required = args.filter(arg => !arg.optional).length;
 	const lastIsText = args.length > 0 && args[args.length - 1].kind.kind === 'text';
@@ -179,25 +216,120 @@ function commandCode(index: number, method: 'addCommand' | 'addServerCommand', a
 		const lines = readOf(arg, at, at === args.length - 1, arg.optional ? '\t\t\t' : '\t\t');
 		return arg.optional ? [`\t\tif (words.count > ${at}) {`, ...lines, '\t\t}'] : lines;
 	});
-	return [
-		`class ${type}${shape ? ` implements ${shape}` : ''} {`,
-		...(player ? ['\tplayer!: __AmxtsPlayer;'] : []),
-		...args.map(arg => `\t${arg.name}${arg.optional ? '?' : '!'}: ${typeOf(arg)};`),
-		'}',
-		`function __amxtsCommand${index}(usage: string, handler: (args: ${type}) => void${player ? ', options: __AmxtsCommandOptions = {}' : ''}): void {`,
-		`\t__amxtsServer.__${method}(usage, (words: __AmxtsCommandWords): void => {`,
-		`\t\tconst args = new ${type}();`,
+	// The words read into the handler's argument, inside the closure; one tab less in a function of its own.
+	const parse = [
+		`\t\tconst args = ${kept ? `__amxtsArgs${index}` : `new ${type}()`};`,
 		...(player ? ['\t\targs.player = words.player!;'] : []),
 		...(required > 0 ? [`\t\tif (!words.need(${required})) return;`] : []),
 		...reads,
 		...(lastIsText ? [] : [`\t\tif (!words.done(${args.length})) return;`]),
 		'\t\tif (words.failed) return;',
-		'\t\thandler(args);',
-		`\t}${player ? ', options' : ''});`,
+	];
+	const run = ['(words: __AmxtsCommandWords): void => {', ...parse, '\t\thandler(args);', '\t}'].join('\n');
+	const closure = [
+		`function __amxtsCommand${index}(${usage}, handler: (args: ${takes}) => void${player ? ', options: __AmxtsCommandOptions = {}' : ''}): void {`,
+		player ? register(run, '0') : `\t__amxtsServer.__${method}(usage, ${run});`,
+		'}',
+	];
+	return [
+		`class ${type}${shape ? ` implements ${shape}` : ''} {`,
+		...(player ? ['\tplayer!: __AmxtsPlayer;'] : []),
+		...args.map(arg => `\t${arg.name}${arg.optional ? '?' : '!'}: ${typeOf(arg)};`),
 		'}',
+		...(kept ? [`const __amxtsArgs${index} = new ${type}();`] : []),
+		...(direct ? directCode(index, direct, args.length > 0, parse, usage, register) : closure),
 	].join('\n');
 }
 
+/**
+ * A command's functions for a handler the parser calls by its name: the
+ * parser, the one the module calls for the command typed in the console - a
+ * command of no words for a handler of none reads only a word too many - and
+ * the one that registers them.
+ */
+function directCode(index: number, direct: Direct, words: boolean, parse: string[], usage: string, register: (run: string, consoleIndex: string) => string): string[] {
+	const run = `__amxtsCommandRun${index}`;
+	const entry = direct.takes == null && !words
+		? [
+				'\tif (argc > 1) {',
+				'\t\t__amxtsCommandUsage(tag, id);',
+				'\t\treturn;',
+				'\t}',
+				'\tconst ambient = __co_ambient_player;',
+				'\t__co_ambient_player = id;',
+				`\t${direct.name}();`,
+				'\t__co_ambient_player = ambient;',
+			]
+		: [
+				'\tconst words = __amxtsCommandWords(tag, id, argc);',
+				`\t${run}(words);`,
+				'\t__amxtsCommandDone(words);',
+			];
+	// A handler of the player is given the player, one of the arguments the object.
+	const given = direct.takes == null ? '' : direct.takes === 'Player' ? 'args.player' : 'args';
+	const handler = direct.takes === 'Player' ? '__AmxtsPlayer' : direct.takes ?? `__AmxtsCommandArgs${index}`;
+	return [
+		`function ${run}(words: __AmxtsCommandWords): void {`,
+		...parse.map(line => line.slice(1)),
+		`\t${direct.name}(${given});`,
+		'}',
+		`function __amxtsCommandConsole${index}(tag: i32, id: i32, access: i32, unused: i32, argc: i32): void {`,
+		...entry,
+		'}',
+		`function __amxtsCommand${index}(${usage}, handler: (args: ${handler}) => void, options: __AmxtsCommandOptions = {}): void {`,
+		register(run, `__amxtsCommandConsole${index}.index`),
+		'}',
+	];
+}
+
+/**
+ * The handler the parser can call by its name: a function declared by name at
+ * the top level of the file, not async, not generic, given to a player's
+ * command added at the top level too - where no other declaration can take
+ * its name.
+ */
+function directOf(call: ts.CallExpression, method: string, file: ts.SourceFile): Direct | null {
+	const handler = call.arguments[1];
+	if (method !== 'addCommand' || !handler || !ts.isIdentifier(handler)) return null;
+	if (!ts.isExpressionStatement(call.parent) || call.parent.parent !== file) return null;
+	const fn = file.statements.find((each): each is ts.FunctionDeclaration => ts.isFunctionDeclaration(each) && each.name?.text === handler.text);
+	if (!fn || fn.typeParameters || fn.modifiers?.some(each => each.kind === ts.SyntaxKind.AsyncKeyword)) return null;
+	const parameter = fn.parameters[0];
+	if (parameter && !parameter.type) return null;
+	return { name: handler.text, takes: parameter ? parameter.type!.getText(file) : null };
+}
+
+/**
+ * Whether a handler can keep nothing of the object its arguments come in: it
+ * takes none, or takes them apart as it starts - `({ player, target }) =>`,
+ * or a function of this file declared so. Then every call of the command
+ * hands it the same object, filled anew: a command allocates nothing. One
+ * with an optional argument gets a new one, which leaves an argument not
+ * typed unset.
+ */
+function keepsNothing(handler: ts.Expression | undefined, file: ts.SourceFile): boolean {
+	const named = handler && ts.isIdentifier(handler) ? handler.text : null;
+	const fn = handler && (ts.isArrowFunction(handler) || ts.isFunctionExpression(handler))
+		? handler
+		: file.statements.find((each): each is ts.FunctionDeclaration => ts.isFunctionDeclaration(each) && named != null && each.name?.text === named);
+	if (!fn) return false;
+	const first = fn.parameters[0];
+	return !first || takesPlayer(fn, file) || (ts.isObjectBindingPattern(first.name) && first.name.elements.every(each => !each.dotDotDotToken));
+}
+
+/**
+ * Whether a handler takes the player rather than the command's object, as
+ * the compiler decides it (`Context & Player`): its parameter is a name,
+ * written `Player` or not typed, and it never reads the name's `.player`.
+ */
+function takesPlayer(fn: ts.SignatureDeclaration, file: ts.SourceFile): boolean {
+	const first = fn.parameters[0];
+	if (!first || !ts.isIdentifier(first.name)) return false;
+	if (first.type) return first.type.getText(file) === 'Player';
+	const body = 'body' in fn && fn.body ? fn.body.getText(file) : '';
+	return !new RegExp(`(?<![\\w$])${first.name.text}\\??\\.player(?![\\w$])`).test(body);
+}
+
 export interface TypedCommands {
 	text: string;
 	problems: string[];
@@ -236,10 +368,16 @@ export function typedCommands(path: string, display: string, text: string, impor
 		try {
 			const usageNode = node.arguments[0];
 			if (!usageNode) throw new ShapeError(node, file, 'the usage is missing: server.addCommand("/hp", ({ player }) => ...)');
-			const usage = usageOf(usageNode, !!node.typeArguments?.length, file);
+			// ["/cp", "cp"]: the usage, then the command's other names.
+			const names = ts.isArrayLiteralExpression(usageNode) ? usageNode.elements : null;
+			if (names && (method !== 'addCommand' || names.length === 0)) throw new ShapeError(usageNode, file, method === 'addCommand' ? 'the names are missing: server.addCommand(["/cp", "cp"], ...)' : 'a server command has one name');
+			const usage = usageOf(names ? names[0] : usageNode, !!node.typeArguments?.length, file);
+			names?.slice(1).forEach(each => aliasOf(each, file));
 			const name = `__amxtsCommand${functions.length}`;
 			const shape = node.typeArguments?.[0]?.getText(file);
-			functions.push(commandCode(functions.length, method, argumentsOf(node, usage, shapes, at, method === 'addCommand'), shape));
+			const args = argumentsOf(node, usage, shapes, at, method === 'addCommand');
+			const kept = !args.some(arg => arg.optional) && keepsNothing(node.arguments[1], file);
+			functions.push(commandCode(functions.length, method, args, shape, kept, directOf(node, method, file), !!names));
 			const start = node.expression.getStart(file);
 			const end = node.arguments.pos - 1;
 			edits.push({ start, end, with: name.padEnd(end - start) });
@@ -258,6 +396,6 @@ export function typedCommands(path: string, display: string, text: string, impor
 	for (const edit of edits.sort((a, b) => b.start - a.start)) out = out.slice(0, edit.start) + edit.with + out.slice(edit.end);
 
 	const code = ['// GENERATED by scripts/typed-commands.ts: the commands this file adds, each word read as its type says.', ...functions].join('\n');
-	const facade = `import { server as __amxtsServer, Player as __AmxtsPlayer, CommandOptions as __AmxtsCommandOptions, __CommandWords as __AmxtsCommandWords } from "${FACADE}";`;
+	const facade = `import { server as __amxtsServer, Player as __AmxtsPlayer, CommandOptions as __AmxtsCommandOptions, __CommandWords as __AmxtsCommandWords, __commandWords as __amxtsCommandWords, __commandDone as __amxtsCommandDone, __commandUsage as __amxtsCommandUsage } from "${FACADE}";`;
 	return { text: withGenerated(path, out, code, facade), problems };
 }

package/scripts/upgrade-calls.ts

@@ -0,0 +1,225 @@
+import type { Change, Edit, Left } from './upgrade';
+// The calls `amxts upgrade` brings up to date (scripts/upgrade.ts): the ones
+// whose shape changed, not their name.
+//
+// - `print(player, text)` is `player.print(text)`, `print(0, text)` is
+//   `server.print(text)`, and `print({ id, variant }, text)` is the same with
+//   the variant last - `0` for everyone was Pawn's, and the object said what
+//   the variant says. Once no call of the free print is left, its import goes. A player's id is read off his Player:
+//   `print(player.id, ...)` is `player.print(...)`; another number is listed.
+// - `removeAllItems(true)` is `removeAllItems({ suit: true })`: a bare
+//   boolean nobody reads.
+// - `Storage.get` gives `undefined` for a key that is not there, as `Map.get`
+//   does: a comparison of its value with `null` compares with `undefined`,
+//   and a `| null` it was annotated with is `| undefined`.
+// - `give` takes any text: the cast to `ItemName` goes, and its import when
+//   nothing else names the type.
+// - A test's `server.vault(name)` is `server.storage(name)`: a Storage is not nVault.
+// - An entity's `viewModel` and `weaponModel` are the model's file, text: a
+//   `0` written or compared is `""`, another number is listed.
+// - `cmd()` and `cmdWide()` take no `info`: the fourth argument goes.
+// - Listed: a listener of the server events `pause`, `unpause` and `modules`,
+//   which are gone; reapi's `DisableHookChain` and `EnableHookChain`, where a
+//   `hook()` handle goes to `unhook`; `cells("text")` given to a call, where
+//   a raw native takes a const string as it is.
+import ts from 'typescript';
+import { applyEdits } from './upgrade';
+
+/** The words a file must have for a pass to look at it. */
+const CALL_WORDS = /\bprint\s*\(|\bremoveAllItems\s*\(|\bStorage\b|\bgive\s*\(|\.vault\s*\(|\.(?:view|weapon)Model\b|\bcmd(?:Wide)?\s*\(|HookChain\s*\(|\bcells\s*\(|["'](?:pause|unpause|modules)["']/;
+
+/** The server events AMX Mod X raises for a Pawn plugin about itself alone. */
+const GONE_EVENTS = new Set(['pause', 'unpause', 'modules']);
+
+/** The fields that held a number of the engine's strings and hold the model's file. */
+const MODELS = new Set(['viewModel', 'weaponModel']);
+
+/** What `x.print(` takes as it is; anything else is wrapped in parens. */
+const PLAIN = new Set([
+	ts.SyntaxKind.Identifier,
+	ts.SyntaxKind.PropertyAccessExpression,
+	ts.SyntaxKind.ElementAccessExpression,
+	ts.SyntaxKind.CallExpression,
+	ts.SyntaxKind.NonNullExpression,
+	ts.SyntaxKind.ParenthesizedExpression,
+	ts.SyntaxKind.ThisKeyword,
+]);
+
+const NULL_COMPARISONS = new Set([
+	ts.SyntaxKind.EqualsEqualsToken,
+	ts.SyntaxKind.EqualsEqualsEqualsToken,
+	ts.SyntaxKind.ExclamationEqualsToken,
+	ts.SyntaxKind.ExclamationEqualsEqualsToken,
+]);
+
+/** A file's calls brought to their new shapes; what upgrade cannot rewrite safely is listed. */
+export function upgradeCalls(file: string, text: string): { text: string; changes: Change[]; left: Left[] } {
+	if (!CALL_WORDS.test(text)) return { text, changes: [], left: [] };
+	const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
+	const edits: Edit[] = [];
+	const left: Left[] = [];
+	const lineOf = (node: ts.Node) => source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+	const textOf = (node: ts.Node) => node.getText(source);
+	const replace = (node: ts.Node, to: string) => edits.push({ start: node.getStart(source), end: node.getEnd(), with: to, from: textOf(node) });
+	// The names the rewrites took out of the code - the free print, the casts
+	// give no longer needs - and how many times each.
+	const gone = new Map<string, number>();
+	const went = (name: string) => gone.set(name, (gone.get(name) ?? 0) + 1);
+
+	// The names a Storage is held by, and the names that hold what its get gave.
+	const storages = new Set<string>();
+	const stored = new Set<string>();
+	const isStorageGet = (node: ts.Node): boolean => {
+		const call = ts.isNonNullExpression(node) || ts.isParenthesizedExpression(node) ? node.expression : node;
+		return ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression) && call.expression.name.text === 'get'
+			&& ts.isIdentifier(call.expression.expression) && storages.has(call.expression.expression.text);
+	};
+	const collect = (node: ts.Node) => {
+		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+			const init = node.initializer;
+			if (ts.isNewExpression(init) && ts.isIdentifier(init.expression) && init.expression.text === 'Storage') storages.add(node.name.text);
+		}
+		ts.forEachChild(node, collect);
+	};
+	collect(source);
+	const collectStored = (node: ts.Node) => {
+		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isStorageGet(node.initializer)) {
+			stored.add(node.name.text);
+			if (node.type && /\|\s*null\b/.test(textOf(node.type))) replace(node.type, textOf(node.type).replace(/\|\s*null\b/, '| undefined'));
+		}
+		ts.forEachChild(node, collectStored);
+	};
+	collectStored(source);
+
+	const visit = (node: ts.Node) => {
+		ts.forEachChild(node, visit);
+
+		// `player.viewModel = 0`, `weapon.weaponModel == 0`
+		if (ts.isBinaryExpression(node) && ts.isPropertyAccessExpression(node.left) && MODELS.has(node.left.name.text) && ts.isNumericLiteral(node.right)) {
+			if (node.right.text === '0') replace(node.right, '""');
+			else left.push({ file, line: lineOf(node), why: `${node.left.name.text} is the model's file now, text: "models/v_knife.mdl"` });
+			return;
+		}
+
+		// `x == null`, where x is a Storage's get or a name that holds one.
+		if (ts.isBinaryExpression(node) && NULL_COMPARISONS.has(node.operatorToken.kind)) {
+			const sides = [node.left, node.right];
+			const nullSide = sides.find(side => side.kind === ts.SyntaxKind.NullKeyword);
+			const other = sides.find(side => side !== nullSide);
+			if (nullSide && other && (isStorageGet(other) || (ts.isIdentifier(other) && stored.has(other.text)))) replace(nullSide, 'undefined');
+			return;
+		}
+		if (!ts.isCallExpression(node)) return;
+		const callee = node.expression;
+		const args = node.arguments;
+
+		// cmd(name, handler, flag, info) and cmdWide - no info.
+		if (ts.isIdentifier(callee) && (callee.text === 'cmd' || callee.text === 'cmdWide') && args.length === 4) {
+			edits.push({ start: args[2].getEnd(), end: args[3].getEnd(), with: '', from: text.slice(args[2].getEnd(), args[3].getEnd()) });
+			return;
+		}
+		if (ts.isIdentifier(callee) && (callee.text === 'DisableHookChain' || callee.text === 'EnableHookChain')) {
+			left.push({ file, line: lineOf(node), why: 'a hook() handle is the module\'s: take the hook off with unhook(handle), and hook() again to put it back' });
+			return;
+		}
+		if (ts.isIdentifier(callee) && callee.text === 'cells' && args.length === 1 && ts.isStringLiteral(args[0]) && ts.isCallExpression(node.parent)) {
+			left.push({ file, line: lineOf(node), why: `a raw native takes a const string as it is: ${textOf(args[0])}, not ${textOf(node)}` });
+			return;
+		}
+		if (ts.isPropertyAccessExpression(callee) && /^(?:add|remove)EventListener$/.test(callee.name.text) && args[0] && ts.isStringLiteral(args[0]) && GONE_EVENTS.has(args[0].text)) {
+			left.push({ file, line: lineOf(node), why: `the server event "${args[0].text}" is gone: AMX Mod X raises it for a Pawn plugin about itself alone - remove the listener` });
+			return;
+		}
+
+		// print(player, ...), print(0, ...) and print({ id, variant }, text)
+		// Only the callee and the first argument are rewritten, so a change
+		// inside the text (a Storage's get) is kept.
+		if (ts.isIdentifier(callee) && callee.text === 'print' && args.length >= 2) {
+			let to = args[0];
+			let place = '';
+			const head = (to: string) => edits.push({ start: callee.getStart(source), end: args[1].getStart(source), with: to, from: text.slice(callee.getStart(source), args[1].getStart(source)) });
+			if (ts.isObjectLiteralExpression(to)) {
+				const { properties } = to;
+				const field = (name: string) => properties.find((p): p is ts.PropertyAssignment => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === name);
+				const id = field('id');
+				const variant = field('variant');
+				if (!id || args.length > 2 || properties.some(p => p !== id && p !== variant)) {
+					left.push({ file, line: lineOf(node), why: 'print takes a player now, and the place as its second argument: player.print(text, "center"); everyone is server.print(text, "center")' });
+					return;
+				}
+				if (variant) place = `, ${textOf(variant.initializer)}`;
+				to = id.initializer;
+			}
+			// A player's id names the player it is read off.
+			if (ts.isPropertyAccessExpression(to) && to.name.text === 'id') to = to.expression;
+			if (ts.isNumericLiteral(to) && to.text !== '0') {
+				left.push({ file, line: lineOf(node), why: 'print takes a player now: `player.print(text)`' });
+				return;
+			}
+
+			if (ts.isNumericLiteral(to)) head('server.print(');
+			else head(`${PLAIN.has(to.kind) ? textOf(to) : `(${textOf(to)})`}.print(`);
+			went('print');
+			if (place) edits.push({ start: args[1].getEnd(), end: args[1].getEnd(), with: place, from: '' });
+			return;
+		}
+		if (!ts.isPropertyAccessExpression(callee)) return;
+
+		// removeAllItems(true) - the suit too.
+		if (callee.name.text === 'removeAllItems' && args.length === 1) {
+			const suit = args[0];
+			if (suit.kind === ts.SyntaxKind.FalseKeyword) replace(node, `${textOf(callee)}()`);
+			else if (!ts.isObjectLiteralExpression(suit)) replace(suit, suit.kind === ts.SyntaxKind.TrueKeyword ? '{ suit: true }' : `{ suit: ${textOf(suit)} }`);
+			return;
+		}
+
+		// A test's server.vault(name)
+		if (callee.name.text === 'vault' && ts.isIdentifier(callee.expression) && callee.expression.text === 'server') {
+			replace(callee.name, 'storage');
+			return;
+		}
+
+		// give(<ItemName>name), give(name as ItemName)
+		if (callee.name.text === 'give' && args.length >= 1) {
+			const item = args[0];
+			const cast = ts.isTypeAssertionExpression(item) || ts.isAsExpression(item) ? item : undefined;
+			if (cast && /^(?:ItemName|WeaponName)$/.test(textOf(cast.type))) {
+				replace(item, textOf(cast.expression));
+				went(textOf(cast.type));
+			}
+		}
+	};
+	visit(source);
+	for (const [name, count] of gone) dropImport(name, count);
+	return { ...applyEdits(file, text, source, edits), left };
+
+	/** Where the line at `at` ends, its line break included. */
+	function lineEnd(at: number) {
+		return text[at] === '\r' ? at + 2 : text[at] === '\n' ? at + 1 : at;
+	}
+
+	/** The core's import of a name the file used only where the rewrites took it out. */
+	function dropImport(name: string, count: number) {
+		let named = 0;
+		const countNames = (node: ts.Node) => {
+			if (ts.isIdentifier(node) && node.text === name && !ts.isImportSpecifier(node.parent)) named++;
+			ts.forEachChild(node, countNames);
+		};
+		countNames(source);
+		if (named > count) return;
+		for (const statement of source.statements) {
+			if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || !/^(?:@amxts\/core|~\/)/.test(statement.moduleSpecifier.text)) continue;
+			const bindings = statement.importClause?.namedBindings;
+			if (!bindings || !ts.isNamedImports(bindings)) continue;
+			const at = bindings.elements.findIndex(element => element.name.text === name);
+			if (at < 0) continue;
+			const { elements } = bindings;
+			const alone = elements.length === 1 && !statement.importClause!.name;
+			const start = alone ? statement.getStart(source) : at > 0 ? elements[at - 1].getEnd() : elements[at].getStart(source);
+			let end = alone ? lineEnd(statement.getEnd()) : at > 0 ? elements[at].getEnd() : elements[at + 1].getStart(source);
+			// A blank line after it goes too where it would be the first, or a second one.
+			if (alone && text[end] && lineEnd(end) > end && text.slice(end, lineEnd(end)).trim() === '' && /^\s*$|\n[\t\r ]*\n[\t ]*$/.test(text.slice(0, start))) end = lineEnd(end);
+			edits.push({ start, end, with: '', from: text.slice(start, end).trim() });
+		}
+	}
+}

package/scripts/upgrade-names.ts

@@ -233,7 +233,7 @@ export const COMMON = new Set(['menu', 'weapon', 'memory', 'conditions', 'activi
 /**
  * Server events by their old names - the Pawn forward's and the short one
  * before it - each by the name in the author's words
- * (scripts/generate-host.ts's EVENT_NAMES).
+ * (scripts/generate-image.ts's EVENT_NAMES).
  */
 export const SERVER_EVENTS: Record<string, string> = {
 	plugin_init: 'init',
@@ -241,10 +241,7 @@ export const SERVER_EVENTS: Record<string, string> = {
 	cfg: 'pluginsLoaded',
 	plugin_cfg: 'pluginsLoaded',
 	plugin_end: 'end',
-	plugin_pause: 'pause',
-	plugin_unpause: 'unpause',
 	plugin_log: 'log',
-	plugin_modules: 'modules',
 	changelevel: 'changeLevel',
 	server_changelevel: 'changeLevel',
 	server_frame: 'frame',