@amxts/core 0.1.0 → 0.2.0

package/runtime/patches/wamr-2.4.5-amxts.patch

@@ -162,6 +162,60 @@ index 771ef87..7bdb74d 100644
                      module->float_plt_count++;
                  }
              }
+diff --git a/core/iwasm/aot/aot_runtime.c b/core/iwasm/aot/aot_runtime.c
+index d2621fb..47178c4 100644
+--- a/core/iwasm/aot/aot_runtime.c
++++ b/core/iwasm/aot/aot_runtime.c
+@@ -2682,9 +2682,9 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
+             }
+ #endif
+ #if WASM_ENABLE_DUMP_CALL_STACK != 0
+-            if (aot_create_call_stack(exec_env)) {
+-                aot_dump_call_stack(exec_env, true, NULL, 0);
+-            }
++            /* amxts: the host reads the frames (wasm_runtime_take_trap_frames)
++               and prints them its own way, rather than to stdout here */
++            aot_create_call_stack(exec_env);
+ #endif
+         }
+ 
+@@ -2755,9 +2755,9 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
+             }
+ #endif
+ #if WASM_ENABLE_DUMP_CALL_STACK != 0
+-            if (aot_create_call_stack(exec_env)) {
+-                aot_dump_call_stack(exec_env, true, NULL, 0);
+-            }
++            /* amxts: the host reads the frames (wasm_runtime_take_trap_frames)
++               and prints them its own way, rather than to stdout here */
++            aot_create_call_stack(exec_env);
+ #endif
+         }
+ 
+@@ -3414,6 +3414,11 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
+ #endif
+         ret = invoke_native_internal(exec_env, func_ptr, func_type, signature,
+                                      attachment, argv1, argc, argv);
++#if WASM_ENABLE_DUMP_CALL_STACK != 0
++        /* amxts: the frames of a trap, as aot_call_function keeps them */
++        if (!ret)
++            aot_create_call_stack(exec_env);
++#endif
+ #if WASM_ENABLE_AOT_STACK_FRAME != 0
+         /* Free all frames allocated, note that some frames
+            may be allocated in AOT code and haven't been
+@@ -3474,6 +3479,11 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
+ #endif
+         ret = invoke_native_internal(exec_env, func_ptr, func_type, signature,
+                                      attachment, argv, argc, argv);
++#if WASM_ENABLE_DUMP_CALL_STACK != 0
++        /* amxts: the frames of a trap, as aot_call_function keeps them */
++        if (!ret)
++            aot_create_call_stack(exec_env);
++#endif
+ #if WASM_ENABLE_AOT_STACK_FRAME != 0
+         /* Free all frames allocated, note that some frames
+            may be allocated in AOT code and haven't been
 diff --git a/core/iwasm/aot/arch/aot_reloc_x86_32.c b/core/iwasm/aot/arch/aot_reloc_x86_32.c
 index f7f2421..89ba8b9 100644
 --- a/core/iwasm/aot/arch/aot_reloc_x86_32.c
@@ -218,6 +272,100 @@ index 060bb2c..28c182d 100644
                  return NULL;
              }
              else
+diff --git a/core/iwasm/common/wasm_runtime_common.c b/core/iwasm/common/wasm_runtime_common.c
+index 943b46f..e93f867 100644
+--- a/core/iwasm/common/wasm_runtime_common.c
++++ b/core/iwasm/common/wasm_runtime_common.c
+@@ -6867,6 +6867,32 @@ wasm_runtime_dump_call_stack_to_buf(wasm_exec_env_t exec_env, char *buf,
+ 
+     return 0;
+ }
++
++/* amxts: the frames the last trap left, innermost first, and forgets them */
++uint32
++wasm_runtime_take_trap_frames(WASMModuleInstanceCommon *module_inst,
++                              WASMCApiFrame *buffer, uint32 length)
++{
++    Vector *frames = ((WASMModuleInstance *)module_inst)->frames;
++    uint32 count = 0, i, size;
++
++    if (!frames)
++        return 0;
++    size = (uint32)bh_vector_size(frames);
++    for (i = 0; i < size; i++) {
++        WASMCApiFrame frame;
++        if (!bh_vector_get(frames, i, &frame))
++            break;
++        if (frame.lp)
++            wasm_runtime_free(frame.lp);
++        if (count < length) {
++            frame.lp = NULL;
++            buffer[count++] = frame;
++        }
++    }
++    bh_vector_destroy(frames);
++    return count;
++}
+ #endif /* end of WASM_ENABLE_DUMP_CALL_STACK */
+ 
+ #if WASM_ENABLE_STATIC_PGO != 0
+diff --git a/core/iwasm/compilation/aot_compiler.c b/core/iwasm/compilation/aot_compiler.c
+index 82f70ca..ea501fb 100644
+--- a/core/iwasm/compilation/aot_compiler.c
++++ b/core/iwasm/compilation/aot_compiler.c
+@@ -1027,6 +1027,15 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index)
+         comp_ctx->builder,
+         func_ctx->block_stack.block_list_head->llvm_entry_block);
+ 
++    /* amxts: the frame first - the frame's own bounds check below can trap,
++       and a trap's ip (trap-ip) is read from it; before, that was the frame
++       of the function compiled last, freed, and wamrc crashed */
++    if (comp_ctx->aux_stack_frame_type) {
++        if (!init_comp_frame(comp_ctx, func_ctx, func_index)) {
++            return false;
++        }
++        comp_ctx->aot_frame->frame_ip = frame_ip;
++    }
+     if (comp_ctx->aux_stack_frame_type
+         && comp_ctx->call_stack_features.frame_per_function) {
+         INT_CONST(func_index_ref,
+@@ -1037,11 +1046,6 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index)
+             return false;
+         }
+     }
+-    if (comp_ctx->aux_stack_frame_type) {
+-        if (!init_comp_frame(comp_ctx, func_ctx, func_index)) {
+-            return false;
+-        }
+-    }
+ 
+     while (frame_ip < frame_ip_end) {
+         opcode = *frame_ip++;
+diff --git a/core/iwasm/include/wasm_export.h b/core/iwasm/include/wasm_export.h
+index 81efb8f..2d80cf2 100644
+--- a/core/iwasm/include/wasm_export.h
++++ b/core/iwasm/include/wasm_export.h
+@@ -2075,6 +2075,20 @@ WASM_RUNTIME_API_EXTERN uint32_t
+ wasm_runtime_dump_call_stack_to_buf(wasm_exec_env_t exec_env, char *buf,
+                                     uint32_t len);
+ 
++/**
++ * amxts: the frames of the last trap - a call that failed - innermost first,
++ * and forgets them, so a later failure that left none reads none.
++ *
++ * @param module_inst the module instance the call failed in
++ * @param buffer where the frames go
++ * @param length how many fit
++ *
++ * @return how many were written
++ */
++WASM_RUNTIME_API_EXTERN uint32_t
++wasm_runtime_take_trap_frames(wasm_module_inst_t module_inst,
++                              WASMCApiFrame *buffer, uint32_t length);
++
+ /**
+  * Get the size required to store the LLVM PGO profile data
+  *
 diff --git a/wamr-compiler/CMakeLists.txt b/wamr-compiler/CMakeLists.txt
 index 8ee61ca..5a496cd 100644
 --- a/wamr-compiler/CMakeLists.txt

package/scripts/apply-docs.ts

@@ -360,7 +360,7 @@ export interface DocSource {
 	root: string;
 }
 
-/** The core's hand-written API: what `~/facade` and the globals give a plugin. */
+/** The core's hand-written API: what `@amxts/core` and the globals give a plugin. */
 export const CORE_API = [
 	'as/facade.ts',
 	'as/promise.ts',
@@ -371,7 +371,7 @@ export const CORE_API = [
 	'as/os.ts',
 	'as/amxts.d.ts',
 	'as/lib/check.ts',
-	'as/modules/http.ts',
+	'as/fetch.ts',
 ];
 
 export function docsFileOf(root: string, file: string): string {

package/scripts/auto-imports.ts

@@ -70,9 +70,9 @@ export const HOOD = new Set([
 	// Cells and raw handlers.
 	'Call CellArray CellBuffer Handler WideHandler NoArgument arg argc argString argText cell cellFloat cells cellsToString cmd cmdWide floatCell handled hook hostIndex nativeFn noOrigin out paint playerIds publicFor putCell readText ret setArg setArgText stringToCells swapTeam text TEXT_MAX',
 	// The kit's.
-	'caller cellArrayRows cellsText colorTags createCellArray defineModule destroyCellArray menuColors PawnCall PawnFunction pushCellArrayRow showMenu textCells',
+	'caller callingPlugin cellArrayRows cellsText colorTags createCellArray defineModule destroyCellArray menuColors onPluginStop PawnCall PawnFunction pushCellArrayRow request RequestErrorKind RequestOptions RequestResult showMenu textCells',
 	// The generated listener and flag tables.
-	'addGameListener addServerListener removeGameListener removeServerListener GameAnswerMap GameEventMap ServerEventMap HookEntry HookEvent EntvarFlags FlagFamily FlagList flagList FlagStore MemberFlags ACCESS BUTTON DAMAGE EFFECT ENTITY_FLAG HIDE_HUD PHYSICS_FLAG WEAPON_STATE',
+	'addGameListener addServerListener removeGameListener removeServerListener GameAnswerMap GameEventMap ServerEventMap ServerMessageMap protocolMessageNames HookEntry HookEvent EntvarFlags FlagFamily FlagList flagList FlagStore MemberFlags ACCESS BUTTON DAMAGE EFFECT ENTITY_FLAG HIDE_HUD PHYSICS_FLAG WEAPON_STATE',
 ].flatMap(group => group.split(' ')));
 
 // ---------------------------------------------------------------- the table

package/scripts/build-identity.ts

@@ -0,0 +1,115 @@
+// The build a module and the compiler beside it on a server are of: the
+// version and the commit, as a release's manifest names them -
+// `0.2.0+1bf291c0ab`, SemVer's build metadata.
+//
+// `bun run generate` writes it into the module (runtime/src/embedded.h), and
+// `bun run serverkit` builds amxts-compile with the one read back from there,
+// so the two agree whenever they come from one build. Before it compiles a
+// plugin's source, the module asks the compiler for its build
+// (`amxts-compile --version`) and refuses one of another: the module writes
+// the API a plugin imports, and a compiler of another release reads it with
+// another AssemblyScript, which fails with errors that say nothing of why.
+//
+// A plugin carries an identity of its own: the ABI it was compiled against,
+// which the module checks before it loads the plugin (abiIdentity, below).
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import pkg from '../package.json';
+import * as tracked from './tracked-fs';
+
+/**
+ * The version the core builds as: its package.json's, or AMXTS_AS_VERSION's.
+ * `bun run publish:local --as 0.2.0` stages the packages as another version
+ * than the checkout's; the modules it compiles for them, and a module built
+ * for a server that runs their plugins, are of that version only with it set.
+ */
+export function coreVersion(): string {
+	return process.env.AMXTS_AS_VERSION || pkg.version;
+}
+
+/** This checkout's build: the version, and the commit when git knows it. */
+export function buildIdentity(): string {
+	const git = spawnSync('git', ['rev-parse', '--short=10', 'HEAD'], { encoding: 'utf-8' });
+	const commit = git.status === 0 ? git.stdout.trim() : '';
+	return commit ? `${coreVersion()}+${commit}` : coreVersion();
+}
+
+/** A string the generated module carries (`#define <name> "..."`), or null before `bun run generate`. */
+function moduleDefine(name: string): string | null {
+	const header = './runtime/src/embedded.h';
+	if (!existsSync(header)) return null;
+	return new RegExp(`^#define ${name} "([^"]*)"$`, 'm').exec(readFileSync(header, 'utf-8'))?.[1] ?? null;
+}
+
+/** The build the generated module carries, or null before `bun run generate`. */
+export const moduleBuild = () => moduleDefine('AMXTS_BUILD');
+
+/** The ABI the generated module loads plugins of, or null before `bun run generate`. */
+export const moduleAbi = () => moduleDefine('AMXTS_ABI');
+
+/** The `--define`s that build amxts-compile as of `build`, stamping plugins with `abi`. */
+export function buildDefines(build: string, abi: string): string[] {
+	return [`--define=AMXTS_BUILD=${JSON.stringify(build)}`, `--define=AMXTS_ABI=${JSON.stringify(abi)}`];
+}
+
+// ---------------------------------------------------------------- the ABI
+//
+// What a plugin and the module have to agree on: the imports the hood
+// declares (`@external("env", ...)` in as/, by name and by the types they
+// take and give) and the natives table wamrc compiles direct calls against
+// (runtime/natives.txt). A plugin of another ABI calls an import the module
+// does not have, or has with another signature, and the server crashes; so
+// the module loads no plugin whose ABI is not its own.
+//
+// It is the version and a hash of those - `0.2.0+abi.1a2b3c4d`. Not the
+// commit: a module from a release and the plugins built with the core from
+// npm, or a module package's prebuilt plugin, are of one release but not
+// built from one checkout. The version tells releases apart; the hash, builds
+// of one version whose imports differ. The same release rebuilt is the same
+// ABI, and a change that is only the facade's own code needs no rebuilt
+// plugins.
+
+/**
+ * Raised by hand when the module and the facade change how they talk without
+ * an import changing its name or its types: what a cell of an event means,
+ * an export the module calls, what names a plugin in a shared module's call
+ * (2: its run, not its index).
+ */
+const ABI_REVISION = 2;
+
+/** The custom section of a plugin that holds its ABI: wamrc copies it into the .aot. */
+export const ABI_SECTION = 'amxts.abi';
+
+const CORE = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+// One import: `@external("env", "ent_get") declare function _entGet(id: i32, offset: i32): i32;`.
+const IMPORT = /@external\("env",\s*"([^"]+)"\)\s*(?:export\s+)?declare\s+function\s+\w+\s*\(([^)]*)\)\s*(?::([^;]+))?;/g;
+
+/** The imports a file of the hood declares: `ent_get(i32,i32)i32`, the parameters' names left out. */
+export function importsOf(code: string): string[] {
+	return [...code.matchAll(IMPORT)].map(([, name, params, result]) => {
+		const types = params.split(',').map(param => param.slice(param.indexOf(':') + 1).trim()).filter(Boolean);
+		return `${name}(${types.join(',')})${result?.trim() ?? 'void'}`;
+	});
+}
+
+declare const AMXTS_ABI: string;
+
+/**
+ * The ABI this core compiles plugins for, which the module it builds loads.
+ * amxts-compile on a server has the module's own built in; anywhere else it
+ * is read off the hood's files, through the tracked reads, so a cached
+ * compile is made again when they change.
+ */
+export function abiIdentity(): string {
+	if (typeof AMXTS_ABI === 'string') return AMXTS_ABI;
+	const plugins = join(CORE, 'as');
+	const imports = tracked.readdirSync(plugins).filter(file => file.endsWith('.ts')).flatMap(file => importsOf(tracked.readFileSync(join(plugins, file), 'utf8')));
+	const natives = tracked.readFileSync(join(CORE, 'runtime/natives.txt'), 'utf8').split(/\r?\n/).filter(Boolean);
+	const hash = createHash('sha256').update([`revision ${ABI_REVISION}`, ...imports.sort(), ...natives.sort()].join('\n')).digest('hex');
+	return `${coreVersion()}+abi.${hash.slice(0, 8)}`;
+}

package/scripts/build-wasm.ts

@@ -1,6 +1,5 @@
 import type { Plugin } from './compile';
-import type { PluginNative } from './plugin-natives';
-import type { ModulePackage } from './project';
+import type { ModulePackage, Sources } from './project';
 import { createSocket } from 'node:dgram';
 // Builds a project's plugins into .aot files the server can load, and
 // optionally copies them there. The project is the current folder: its
@@ -32,22 +31,24 @@ import { createSocket } from 'node:dgram';
 // Two compilers, in order: asc turns AssemblyScript into wasm, wamrc turns
 // wasm into i386 machine code - in the object format of the server's system,
 // Windows or Linux, whichever this machine is (scripts/system.ts). wamrc is given runtime/natives.txt so that a
-// call into a host native compiles to a direct call — 2 ns instead of 28. Both
+// call into a host native compiles to a direct call, far cheaper than WAMR's
+// 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 { basename, dirname, join, relative, resolve } from 'node:path';
 import { includePath } from './compile';
+import { compileAll } from './compile-pool';
 import { followConsoles, projectContainers, runCommand } from './docker-server';
 import { FileContents, sourceIn, sourcesIn } from './file-contents';
 import { serverIncludes } from './includes';
 import { pluginCache } from './plugin-cache';
 import { includeName } from './plugin-natives';
-import { fromRegistry, prebuiltOf } from './prebuilt';
+import { fromRegistry, prebuiltOf, prebuiltSurface } from './prebuilt';
 import { CORE_DIR, CORE_PLUGINS, loadProject, modulesInUse, pluginList, projectPlugins, sourcesFor } from './project';
 import { sharedModulesBuild } from './shared-modules';
-import { describeSystem, serverSystem, SYSTEM_NAME, WAMRC_PACKAGE, wamrcPath } from './system';
-import { c, log, progress, since } from './ui';
+import { describeSystem, serverFolder, serverSystem, SYSTEM_NAME, WAMRC_PACKAGE, wamrcPath } from './system';
+import { c, live, log, progress, since } from './ui';
 
 function fail(message: string, hint?: string): void {
 	log.error(message.trim());
@@ -78,8 +79,17 @@ const asc_ = process.env.AMXTS_ASC ?? join(CORE_DIR, 'runtime/deps/assemblyscrip
 const signatures = process.env.AMXTS_NATIVES ?? join(CORE_DIR, 'runtime/natives.txt');
 // Where --deploy copies the built plugins: the amxts folder inside a server's
 // addons. It is per-machine, so it comes from the environment rather than from
-// this file, and .env keeps it out of everyone else's way.
-const serverDir = process.env.AMXTS_SERVER ?? '';
+// this file, and .env keeps it out of everyone else's way. AMXTS_SERVER may
+// also name a folder above it - the server's own, cstrike, cstrike/addons
+// (src/system.mjs).
+const serverSetting = process.env.AMXTS_SERVER ?? '';
+let serverDir = '';
+try {
+	serverDir = serverFolder(serverSetting);
+} catch (error) {
+	fail((error as Error).message);
+	process.exit(1);
+}
 
 // The module's server command that starts every plugin over from disk.
 const RELOAD_COMMAND = 'amxts_reload';
@@ -159,22 +169,23 @@ for (const plugin of ownPlugins()) {
 	}
 }
 
-/** The owners of the modules the plugins use, in load order. */
-function moduleOwners(): Target[] {
-	const sources = sourcesFor(CORE_PLUGINS);
+/**
+ * The owners of the modules the plugins use, in load order. A save's
+ * rebuild reads the sources once (`sources`), for this and what it affects.
+ */
+function moduleOwners(sources = sourcesFor(CORE_PLUGINS)): Target[] {
 	return modulesInUse(sources, ownPlugins().map(plugin => plugin.source)).map(pkg => ({ source: sources.ownerSource(pkg), name: pkg.short, pkg }));
 }
 
 /** The modules' owners, in load order, then the project's plugins. */
-function allPlugins(): Target[] {
-	return [...moduleOwners(), ...ownPlugins()];
+function allPlugins(sources: Sources): Target[] {
+	return [...moduleOwners(sources), ...ownPlugins()];
 }
 
 /** The plugins a change to these files has to rebuild: every one importing them. */
-function affected(files: string[]): Target[] {
-	const sources = sourcesFor(CORE_PLUGINS);
+function affected(files: string[], sources: Sources): Target[] {
 	const changed = files.map(file => resolve(file));
-	return allPlugins().filter((plugin) => {
+	return allPlugins(sources).filter((plugin) => {
 		const reached = [...sources.reach(join(CORE_PLUGINS, sources.entry(plugin.source)))].map(place => sources.real(place) ?? place);
 		return changed.some(file => reached.includes(file));
 	});
@@ -211,22 +222,30 @@ const includes = new Map<string, string>();
  * wrote. Named before the first build as after it, or a dev started again
  * would compile everything again.
  */
-const cache = pluginCache(project.dir, [
+const cacheIncludes = [
 	'amxts',
 	...[...project.modules.map(pkg => pkg.short), ...ownPlugins().map(plugin => plugin.name)].map(includeName),
 	...project.modules.flatMap(pkg => (pkg.include ? [basename(pkg.include).replace(/\.inc$/, '')] : [])),
 	...readdirSync(outDir).filter(file => file.endsWith('.inc')).map(file => file.replace(/\.inc$/, '')),
-]);
+];
+const cache = pluginCache(project.dir, cacheIncludes);
 
 /**
  * Builds these plugins: a module that comes compiled for this project is
  * put in place as it came (scripts/prebuilt.ts), one an earlier build kept,
- * from the same files, likewise; the rest are compiled. The first build of a
- * run says when it has a module to compile. Returns the .aot names, or null
- * after printing the error.
+ * from the same files, likewise; the rest are compiled, several at once when
+ * there is room (scripts/compile-pool.ts). The first build of a run says when
+ * it has a module to compile. Returns the .aot names, or null after printing
+ * the errors.
  */
-async function compile(plugins: Target[], first: boolean): Promise<string[] | null> {
-	const sources = sourcesFor(CORE_PLUGINS);
+async function compile(plugins: Target[], first: boolean, sources: Sources): Promise<string[] | null> {
+	// Why a module is not taken as it came, said once.
+	const said = new Set<string>();
+	const say = (why: string, instead: string) => {
+		if (said.has(why)) return;
+		said.add(why);
+		log.info(`${why} - ${instead}`);
+	};
 	const planned = plugins.map((each) => {
 		const plugin: Plugin = {
 			source: each.source,
@@ -240,31 +259,53 @@ async function compile(plugins: Target[], first: boolean): Promise<string[] | nu
 			quick,
 		};
 		const prebuilt = each.pkg ? prebuiltOf(each.pkg, target.system, sources) : null;
-		if (prebuilt && 'why' in prebuilt) log.info(`${prebuilt.why} - compiling it here`);
+		if (prebuilt && 'why' in prebuilt) say(prebuilt.why, 'compiling it here');
 		if (prebuilt && 'aot' in prebuilt) return { ...each, plugin, how: 'prebuilt', natives: cache.take(plugin, prebuilt) };
 		return { ...each, plugin, how: 'unchanged', natives: cache.reuse(plugin) };
 	});
+	// The surface a plugin compiles a module's proxy from (scripts/shared-modules.ts) comes with it too.
+	for (const each of first ? plugins : []) {
+		const shipped = each.pkg ? prebuiltSurface(each.pkg, sources) : null;
+		if (shipped && 'why' in shipped) say(shipped.why, 'analysing it here');
+	}
 	const fresh = planned.filter(each => !each.natives);
 	if (first && fresh.some(each => each.pkg)) {
 		log.info('The first build compiles the modules to machine code: it takes about a minute.');
 	}
-	// What comes prebuilt or unchanged is taken quietly: only what is compiled shows.
-
-	for (const [i, each] of fresh.entries()) {
-		const natives: PluginNative[] = [];
-		const started = performance.now();
-		const step = progress(`compiling ${c.bold(each.name)} ${c.dim(`${i + 1}/${fresh.length}`)}`);
-		const problem = await cache.compile(each.plugin, natives).catch((error) => {
-			step.end();
-			throw error;
-		});
-		step.end(problem ? undefined : `${c.bold(each.name)} ${c.dim(`· ${since(started)}`)}`);
-		if (problem) {
-			fail(`${c.bold(each.name)} does not compile:\n${readable(problem)}\n`, keepWatching ? 'The server keeps the last good build.' : undefined);
-			return null;
-		}
-		each.natives = natives;
+	// What comes prebuilt or unchanged is taken quietly: only what is compiled
+	// shows - a line for each as it is done, and as it starts: in a terminal
+	// one line, rewritten, says what is being compiled now.
+	const running = new Map<number, number>();
+	let step: ReturnType<typeof progress> | null = null;
+	const counted = (index: number) => c.dim(`${index + 1}/${fresh.length}`);
+	const redraw = (done?: string) => {
+		step?.end(done);
+		const names = [...running.keys()].map(index => c.bold(fresh[index].name)).join(', ');
+		step = running.size ? progress(`compiling ${names} ${counted(Math.max(...running.keys()))}`) : null;
+	};
+	const compiled = await compileAll(fresh.map(each => each.plugin), {
+		dir: project.dir,
+		includes: cacheIncludes,
+		here: (plugin, natives) => cache.compile(plugin, natives),
+		started(index) {
+			running.set(index, performance.now());
+			if (live) redraw();
+			else progress(`compiling ${c.bold(fresh[index].name)} ${counted(index)}`);
+		},
+		finished(index, { problem }) {
+			const done = problem ? undefined : `${c.bold(fresh[index].name)} ${c.dim(`· ${since(running.get(index)!)}`)}`;
+			running.delete(index);
+			if (live) redraw(done);
+			else if (done) log.success(done);
+		},
+	}).finally(() => step?.end());
+
+	const failures = compiled.flatMap((each, index) => (each?.problem ? [`${c.bold(fresh[index].name)} does not compile:\n${readable(each.problem)}\n`] : []));
+	if (failures.length) {
+		fail(failures.join('\n'), keepWatching ? 'The server keeps the last good build.' : undefined);
+		return null;
 	}
+	for (const [index, each] of fresh.entries()) each.natives = compiled[index]!.natives;
 
 	for (const each of planned) {
 		includes.set(`${each.name}.aot`, includePath(each.plugin.output, each.natives!));
@@ -401,7 +442,10 @@ async function deployAndReload(built: string[], names: string): Promise<string>
 		return `deployed ${names} - the module reloads them on its own`;
 	}
 
-	const reply = await ask(`rcon ${challenge} "${password}" ${RELOAD_COMMAND}`, 5000);
+	// Only what changed starts over; a new plugin needs the list read again,
+	// which only a reload of them all does.
+	const reload = added.length > 0 ? RELOAD_COMMAND : built.map(file => `${RELOAD_COMMAND} ${file.replace(/\.aot$/, '')}`).join('; ');
+	const reply = await ask(`rcon ${challenge} "${password}" ${reload}`, 5000);
 
 	if (reply === null || /bad rcon_password/i.test(reply)) {
 		// Nothing reloaded them, so let the module's watcher see the new files.
@@ -410,8 +454,12 @@ async function deployAndReload(built: string[], names: string): Promise<string>
 		return `deployed ${names} - rcon ${reply === null ? 'got no answer' : 'refused the password'}, the module reloads them on its own`;
 	}
 
-	const lines = reply.split('\n').map(line => line.trimEnd()).filter(Boolean);
-	return [`deployed, the server reloaded ${names}`, ...lines.map(line => c.dim(`  ${line}`))].join('\n');
+	// The module's own "reloading x" and "loaded x" only repeat the line above;
+	// anything else it says - a refusal, an error - is shown.
+	const lines = reply.split('\n').map(line => line.trimEnd()).filter(line => line && !/^\[amxts\] (?:reloading|loaded) /.test(line));
+	const loaded = built.every(file => reply.includes(`[amxts] loaded ${file}`));
+	const head = loaded ? `deployed, the server reloaded ${names}` : `deployed ${names} - the server did not load it all:`;
+	return [head, ...lines.map(line => c.dim(`  ${line}`))].join('\n');
 }
 
 /**
@@ -454,11 +502,11 @@ function writeList(owners: Target[]) {
  * the files a rebuild is for. A module a save brings into use is built with
  * the plugin that uses it.
  */
-async function run(plugins: Target[], verb: string, why = ''): Promise<boolean> {
+async function run(plugins: Target[], verb: string, why = '', sources = sourcesFor(CORE_PLUGINS)): Promise<boolean> {
 	const started = performance.now();
-	const owners = moduleOwners();
+	const owners = moduleOwners(sources);
 	const fresh = owners.filter(owner => !listed?.includes(owner.name) && !plugins.some(plugin => plugin.name === owner.name));
-	const built = await compile([...fresh, ...plugins], listed === null);
+	const built = await compile([...fresh, ...plugins], listed === null, sources);
 	if (!built) return false;
 	writeList(owners);
 
@@ -478,7 +526,9 @@ async function serverLine(): Promise<string> {
 	const system = SYSTEM_NAME[target.system];
 	if (forDocker) return `the Docker one that mounts this project · ${system}`;
 	if (!serverDir) return `${c.dim('none - AMXTS_SERVER is not set')} · the plugins are for ${system}`;
-	const folder = serverDir.replace(/\\/g, '/');
+	// The folder used, and what AMXTS_SERVER holds when it named one above it.
+	const above = serverSetting === serverDir ? '' : c.dim(` (AMXTS_SERVER=${serverSetting.replace(/\\/g, '/')})`);
+	const folder = `${serverDir.replace(/\\/g, '/')}${above}`;
 	if (!existsSync(serverDir)) return `${folder} ${c.yellow('is not there')} · the plugins are for ${system}`;
 	const includes = serverIncludes();
 	const rehlds = includes ? existsSync(join(includes, 'reapi.inc')) : project.config?.target !== 'hlds';
@@ -498,7 +548,7 @@ async function header(): Promise<void> {
 	const module = (pkg: ModulePackage) => {
 		const notes = [
 			!fromRegistry(pkg.dir) && 'local',
-			!used.includes(pkg) && 'no plugin uses it',
+			pkg.library ? 'library' : !used.includes(pkg) && 'no plugin uses it',
 		].filter(Boolean);
 		return `${pkg.short} ${pkg.version}${notes.length ? c.dim(` (${notes.join(', ')})`) : ''}`;
 	};
@@ -560,8 +610,9 @@ async function flush(): Promise<void> {
 
 	const files = contents.changed([...heard]);
 	heard.clear();
-	const plugins = affected(files);
-	if (plugins.length > 0) await run(plugins, 'rebuilt', `${files.map(shown).join(', ')} changed: `).catch(error => fail(String(error)));
+	const sources = sourcesFor(CORE_PLUGINS);
+	const plugins = affected(files, sources);
+	if (plugins.length > 0) await run(plugins, 'rebuilt', `${files.map(shown).join(', ')} changed: `, sources).catch(error => fail(String(error)));
 
 	building = false;
 	void flush();

package/scripts/check.ts

@@ -2,7 +2,8 @@
 // module's folder, as a CI step:
 //
 // - package.json's "amxts" field points at files that are there;
-// - the module file declares itself with defineModule, meta.name its name;
+// - the module file declares itself with defineModule, meta.name its name -
+//   or, for a library (`"library": true`), has none and compiles;
 // - README.md and LICENSE are there;
 // - the natives compile, and include/<name>.inc is what the build writes from
 //   them - not stale after an edit of natives.ts. With `"contract": true`
@@ -18,6 +19,7 @@ import { importedName } from './auto-imports';
 import { compileToWasm } from './compile';
 import { includeName, pawnInclude } from './plugin-natives';
 import { CORE_PLUGINS, loadProject, readDefinition, readPackage, sourcesFor } from './project';
+import { compileAlone } from './shared-modules';
 import { c, log } from './ui';
 
 function fail(message: string): void {
@@ -44,8 +46,9 @@ if (pkg) {
 	passed.push(`"amxts" points at ${[pkg.module, pkg.natives, pkg.include].filter(Boolean).map(file => relative(dir, file!).replace(/\\/g, '/')).join(', ')}`);
 
 	try {
-		const definition = readDefinition(pkg.module);
-		if (!definition) problems.push(`${relative(dir, pkg.module)}: no \`export default defineModule({ meta: { name: "${pkg.short}" }, ... })\``);
+		const definition = pkg.library ? null : readDefinition(pkg.module);
+		if (pkg.library) passed.push('a library: compiled into each plugin that imports it');
+		else if (!definition) problems.push(`${relative(dir, pkg.module)}: no \`export default defineModule({ meta: { name: "${pkg.short}" }, ... })\``);
 		else if (!definition.name) problems.push(`${relative(dir, pkg.module)}: defineModule has no meta.name - "${pkg.short}"`);
 		else passed.push(`defineModule: ${definition.name}${definition.configKey ? `, options under "${definition.configKey}"` : ''}${definition.imports.length ? `, plugins use it as ${definition.imports.map(importedName).join(', ')}` : ''}`);
 	} catch (problem) {
@@ -59,6 +62,17 @@ if (pkg) {
 	const project = loadProject(dir);
 	problems.push(...project.problems);
 	if (pkg.natives && project.problems.length === 0) await checkNatives(pkg);
+	if (pkg.library && project.problems.length === 0) await checkLibrary(pkg);
+}
+
+async function checkLibrary(library: NonNullable<typeof pkg>) {
+	const file = relative(dir, library.module).replace(/\\/g, '/');
+	try {
+		await compileAlone(CORE_PLUGINS, library.short);
+		passed.push(`${file} compiles`);
+	} catch (problem) {
+		problems.push((problem as Error).message.replace(`~/modules/${library.short}`, file));
+	}
 }
 
 async function checkNatives(module: NonNullable<typeof pkg>) {