@amxts/core 0.1.0

package/scripts/system.ts

@@ -0,0 +1,33 @@
+// The server's system for the build (src/system.mjs says how it is decided and
+// why it matters), and where the core keeps what each system needs.
+import type { System } from '../src/system.mjs';
+import { readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { executable, MODULE_FILE } from '../src/system.mjs';
+
+export type { ServerSystem, System } from '../src/system.mjs';
+export { describeSystem, detectServerSystem, executable, HOST_SYSTEM, MODULE_FILE, parseSystem, serverSystem, SYSTEM_NAME, SYSTEMS, TARGET_ABI, WAMRC_PACKAGE, wamrcPath } from '../src/system.mjs';
+
+const CORE = resolve(fileURLToPath(new URL('..', import.meta.url)));
+
+/** Where the amxts module of a system is built: CMake's Release folder on Windows, runtime/build/linux from the Linux toolchain. */
+export function modulePath(system: System): string {
+	return system === 'windows'
+		? join(CORE, 'runtime/build/Release', MODULE_FILE.windows)
+		: join(CORE, 'runtime/build/linux', MODULE_FILE.linux);
+}
+
+/**
+ * The API a plugin imports, and the declarations an editor reads with it
+ * (the globals of amxts.d.ts, promise.types.d.ts): every file at the top of
+ * as/. A server kit carries them beside its plugins.
+ */
+export function apiFiles(): string[] {
+	return readdirSync(join(CORE, 'as')).filter(name => name.endsWith('.ts'));
+}
+
+/** AMX Mod X's Pawn compiler in amxmodx/base, for this machine. */
+export function amxxpcPath(): string {
+	return join(CORE, 'amxmodx/base', executable('amxxpc'));
+}

package/scripts/tracked-fs.ts

@@ -0,0 +1,115 @@
+// The file reads of a compile, for a cache that has to know what it depended on.
+//
+// The scripts a compile runs through (project.ts, shared-modules.ts,
+// plugin-natives.ts, includes.ts) take readFileSync, existsSync, statSync and
+// readdirSync from here instead of node:fs. They are node:fs's own, and while
+// a compile is being recorded (`recordReads`) every call is noted with what it
+// saw: a file's content hash, whether a path exists, what kind it is. A cached
+// result is still good while every one of them answers the same (`unchanged`).
+//
+// Two compiles recorded at once both note each other's reads: a cache entry
+// then depends on a little more than it needs, never on less.
+import type { PathLike, Stats } from 'node:fs';
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import { resolve } from 'node:path';
+
+/** What a compile read: `<op>\0<absolute path>` -> what it saw. */
+export type Reads = Record<string, string>;
+
+const recording = new Set<Reads>();
+
+export function hashOf(data: string | Uint8Array): string {
+	return createHash('sha1').update(data).digest('hex');
+}
+
+function note(op: string, path: PathLike, seen: string) {
+	if (!recording.size) return;
+	const key = `${op}\0${resolve(String(path))}`;
+	for (const reads of recording) reads[key] = seen;
+}
+
+function kindOf(stats: Stats): string {
+	return stats.isFile() ? 'file' : stats.isDirectory() ? 'dir' : 'other';
+}
+
+export function readFileSync(path: PathLike, encoding: BufferEncoding): string;
+export function readFileSync(path: PathLike): Buffer;
+export function readFileSync(path: PathLike, encoding?: BufferEncoding): string | Buffer {
+	let bytes: Buffer;
+	try {
+		bytes = fs.readFileSync(path);
+	} catch (error) {
+		note('read', path, 'missing');
+		throw error;
+	}
+	note('read', path, hashOf(bytes));
+	return encoding ? bytes.toString(encoding) : bytes;
+}
+
+export function existsSync(path: PathLike): boolean {
+	const exists = fs.existsSync(path);
+	note('exists', path, String(exists));
+	return exists;
+}
+
+export function statSync(path: PathLike): Stats {
+	let stats: Stats;
+	try {
+		stats = fs.statSync(path);
+	} catch (error) {
+		note('stat', path, 'missing');
+		throw error;
+	}
+	note('stat', path, kindOf(stats));
+	return stats;
+}
+
+export function readdirSync(path: PathLike): string[] {
+	let names: string[];
+	try {
+		names = fs.readdirSync(path);
+	} catch (error) {
+		note('readdir', path, 'missing');
+		throw error;
+	}
+	note('readdir', path, hashOf([...names].sort().join('\n')));
+	return names;
+}
+
+/** `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 = {};
+	recording.add(reads);
+	try {
+		return { reads, result: { status: 'fulfilled', value: await run() } };
+	} catch (reason) {
+		return { reads, result: { status: 'rejected', reason } };
+	} finally {
+		recording.delete(reads);
+	}
+}
+
+/** What one noted read sees now. */
+function seenNow(op: string, path: string): string {
+	try {
+		switch (op) {
+			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'));
+			default: return 'unknown';
+		}
+	} catch {
+		return 'missing';
+	}
+}
+
+/** Whether every read noted in `reads` would see today what it saw then. */
+export function unchanged(reads: Reads): boolean {
+	for (const [key, seen] of Object.entries(reads)) {
+		const at = key.indexOf('\0');
+		if (seenNow(key.slice(0, at), key.slice(at + 1)) !== seen) return false;
+	}
+	return true;
+}