@amxts/core 0.1.0 → 0.2.1

package/as/remote.ts

@@ -14,7 +14,8 @@
 // one export the module calls, __amxts_rpc. It is hood: plugins never import it.
 // __co_bindEnv, which makes a stand-in, is as/promise.ts's; __env, where the
 // stand-in finds its place, the compiler library's.
-import "~/promise";
+import "./promise";
+import { __callFrom, __pluginStopped } from "./facade";
 
 // @ts-ignore: decorator
 @external("env", "amxts_serve") declare function _serve(name: string, hash: i32): void;
@@ -29,8 +30,12 @@ import "~/promise";
 // @ts-ignore: decorator
 @external("env", "amxts_rpc_result") declare function _result(to: usize): void;
 
+// What a request is: its first four bytes. KIND_GONE is RPC_GONE in
+// runtime/src/module.cpp, which sends it to an owner when a plugin that called
+// it stops.
 const KIND_MODULE: i32 = 0;
 const KIND_CALLBACK: i32 = 1;
+const KIND_GONE: i32 = 2;
 
 /** What a call carries: its arguments, or its answer, as bytes. */
 export class Writer {
@@ -75,7 +80,7 @@ export class Writer {
 export class Reader {
 	at: i32 = 0;
 
-	/** `from`: the plugin that wrote it - where a function it carries lives. */
+	/** `from`: the run of the plugin that wrote it - where a function it carries lives. */
 	constructor(public data: ArrayBuffer, public from: i32) {}
 
 	private take(bytes: i32): usize {
@@ -117,7 +122,13 @@ export class Service {
 	private id: i32 = -1;
 	private failed: bool = false;
 
-	constructor(public name: string, public hash: i32) {}
+	// Asked as the plugin starts, which tells the server that this plugin
+	// uses the module: its owner then stays while the plugin runs, and starts
+	// over with it. The owner may start later; a call asks again.
+	constructor(public name: string, public hash: i32) {
+		const id = _owner(name, hash);
+		if (id >= 0) this.id = id;
+	}
 
 	/** A call of the module's `op`-th function (or field). */
 	begin(op: i32): Writer {
@@ -132,13 +143,13 @@ export class Service {
 		if (this.id < 0) {
 			const id = _owner(this.name, this.hash);
 			if (id < 0) return this.fail(id == -2
-				? `~/modules/${this.name}: ${this.name}.aot was built from another version of it - build both again`
-				: `~/modules/${this.name}: no plugin runs it - is ${this.name}.aot in plugins.ini?`);
+				? `${this.name}: ${this.name}.aot was built from another version of it - build both again`
+				: `${this.name}: no plugin runs it - is ${this.name}.aot in plugins.ini?`);
 			this.id = id;
 		}
 
 		const answer = send(this.id, -1, w);
-		if (answer == null) return this.fail(`~/modules/${this.name}: the call failed in ${this.name}`);
+		if (answer == null) return this.fail(`${this.name}: the call failed in ${this.name}`);
 		this.failed = false;
 		return answer!;
 	}
@@ -150,7 +161,7 @@ export class Service {
 	}
 }
 
-/** The answer from `service`, or from `plugin` when service is -1; null when there is none. */
+/** The answer from `service`, or from the run `plugin` when service is -1; null when there is none. */
 function send(service: i32, plugin: i32, w: Writer): Reader | null {
 	const length = _rpc(service, plugin, changetype<usize>(w.data), w.length);
 	if (length < 4) return null;
@@ -188,12 +199,16 @@ export function sendFunction(fn: usize, sig: i32, invoke: Invoke): i32 {
 	return id;
 }
 
-/** Where a stand-in calls: the plugin a function lives in, and its number there. */
+/** Where a stand-in calls: the run of the plugin a function lives in, and its number there. */
 class Remote {
 	constructor(public plugin: i32, public id: i32) {}
 }
 
-const standIns = new Map<string, usize>();
+/**
+ * The stand-ins made, by "<run>:<id>". Held here: a stand-in is only ever
+ * reached through what it was given to. A run's go when it stops.
+ */
+const standIns = new Map<string, Object>();
 
 /**
  * A stand-in for function `id` of the plugin that wrote `r`: a copy of
@@ -205,16 +220,21 @@ export function receiveFunction(r: Reader, stub: usize): usize {
 	const id = r.i32();
 	if (id == 0) return 0;
 	const key = `${r.from}:${id}`;
-	if (standIns.has(key)) return standIns.get(key);
+	if (standIns.has(key)) return changetype<usize>(standIns.get(key));
 	// @ts-ignore: as/promise.ts's, global to the compiler and unknown to the editor
 	const bound: usize = __co_bindEnv(stub, new Remote(r.from, id));
-	standIns.set(key, bound);
-	// Held here: the stand-in is only ever reached through what it was given to.
-	kept.push(changetype<Object>(bound));
+	standIns.set(key, changetype<Object>(bound));
 	return bound;
 }
 
-const kept: Object[] = [];
+/** The run `run` stopped: its stand-ins call nothing any more, and the module drops what it gave. */
+function stopped(run: i32): void {
+	const prefix = `${run}:`;
+	for (const key of standIns.keys()) {
+		if (key.startsWith(prefix)) standIns.delete(key);
+	}
+	__pluginStopped(run);
+}
 
 /** The first thing a stub does: where it calls. Before any other call, which would change __env. */
 export function remoteTarget(): Remote {
@@ -267,7 +287,7 @@ export class Handles {
 	}
 }
 
-/** @hidden What the module calls: a request of `length` bytes from plugin `from`. */
+/** @hidden What the module calls: a request of `length` bytes from the run `from` of a plugin. */
 export function __amxts_rpc(length: i32, from: i32): void {
 	const data = new ArrayBuffer(length);
 	_take(changetype<usize>(data));
@@ -278,10 +298,14 @@ export function __amxts_rpc(length: i32, from: i32): void {
 
 	if (kind == KIND_MODULE) {
 		const dispatch = served;
+		const outer = __callFrom(from);
 		if (dispatch != null) dispatch(id, r, w);
+		__callFrom(outer);
 	} else if (kind == KIND_CALLBACK && id > 0 && id <= callbacks.length) {
 		const callback = callbacks[id - 1];
 		callback.invoke(changetype<usize>(callback.fn), callback.sig, r, w);
+	} else if (kind == KIND_GONE) {
+		stopped(from);
 	}
 
 	_reply(changetype<usize>(w.data), w.length);

package/as/tsconfig.json

@@ -3,12 +3,17 @@
 	"compilerOptions": {
 		"target": "es2015",
 		"moduleDetection": "force",
+		"useUnknownInCatchVariables": false,
 		"module": "esnext",
 		"moduleResolution": "bundler",
 		"paths": {
-			"~/*": ["./*"],
 			"@amxts/core": ["./facade.ts"],
-			"@amxts/core/*": ["./*"],
+			"@amxts/core/natives": ["./natives.ts"],
+			"@amxts/core/constants": ["./constants.ts"],
+			"@amxts/core/fs": ["./fs.ts"],
+			"@amxts/core/os": ["./os.ts"],
+			"@amxts/core/kit": ["./kit.ts"],
+			"@amxts/core/check": ["./lib/check.ts"],
 			"@amxts/menu-core": ["../../amxts-modules/menu-core/src/index.ts"],
 			"@amxts/config-core": ["../../amxts-modules/config-core/src/index.ts"]
 		}

package/as/vector.ts

@@ -8,24 +8,27 @@
 
 /** Three numbers, x y z, with the math a plugin needs on them. */
 export class Vector extends Array<number> {
+	// x, y and z read and write their element without the index's check: a
+	// Vector is made with room for three, which a shorter length leaves in
+	// place, and the check was a call - most of what reading one cost.
 	constructor(x: number = 0.0, y: number = 0.0, z: number = 0.0) {
 		super(3);
-		this[0] = x;
-		this[1] = y;
-		this[2] = z;
+		unchecked(this[0] = x);
+		unchecked(this[1] = y);
+		unchecked(this[2] = z);
 	}
 
 	/** The x coordinate, `vector[0]`. */
-	get x() { return this[0]; }
-	set x(value: number) { this[0] = value; }
+	get x() { return unchecked(this[0]); }
+	set x(value: number) { unchecked(this[0] = value); }
 
 	/** The y coordinate, `vector[1]`. */
-	get y() { return this[1]; }
-	set y(value: number) { this[1] = value; }
+	get y() { return unchecked(this[1]); }
+	set y(value: number) { unchecked(this[1] = value); }
 
 	/** The z coordinate, `vector[2]`. */
-	get z() { return this[2]; }
-	set z(value: number) { this[2] = value; }
+	get z() { return unchecked(this[2]); }
+	set z(value: number) { unchecked(this[2] = value); }
 
 	/** A new vector: this one plus `other`, number by number. */
 	add(other: number[]) {

package/includes/order.txt

@@ -12,43 +12,36 @@ reapi
 hamsandwich
 cstrike
 engine
+fakemeta
 nvault
-easy_http
+geoip
 resemiclip
 universal_config
 menu_core
 
-# engine, nvault and geoip are stock AMX Mod X modules shipped with the server
-# (addons/amxmodx/modules/); geoip is listed in modules.ini and the other two
-# are auto-detected from the `#pragma reqlib` amxxpc writes into the .amxx.
-# easy_http and resemiclip are third-party modules, both present as DLLs and
-# both enabled explicitly in modules.ini.
+# engine, fakemeta, nvault and geoip are stock AMX Mod X modules shipped with
+# the server (addons/amxmodx/modules/); geoip is listed in modules.ini and the
+# others are auto-detected from the `#pragma reqlib` amxxpc writes into the
+# .amxx. The module itself calls engine's get_global_int and fakemeta's
+# pev_valid and get_pdata_int to find the engine's edicts (runtime/src/fields.h).
+# resemiclip is a third-party module, present as a DLL and enabled explicitly
+# in modules.ini.
 #
 # universal_config and menu_core are not modules: their natives come from
 # universal_config.amxx and menu_core.amxx, which plugins.ini loads ahead of
 # amxts_host.amxx. AMX Mod X resolves plugin-registered natives after every
-# plugin has run plugin_natives(), so the host links against them fine - but a
-# server without those two plugins must put a `-` back in front of them.
+# plugin has run plugin_natives(), so the host links against them fine, and a
+# server without those two plugins loads it too (below).
 
 # A line starting with `-` is a deny marker: the include is still resolved and
-# parsed (amxxpc needs the file on disk to compile reapi.inc, which #includes
-# it unconditionally), but its natives are never pulled into the host's native
-# table. A #include costs nothing; a reference in __pull_natives() does — it
-# makes AMX Mod X refuse to load the plugin on a server that doesn't have the
-# native, taking the whole runtime down with it. None of these three are safe
-# to assume: vtc and rechecker are optional reapi add-ons, and reunion natives
-# are only registered when reapi detects Reunion at runtime, so even a server
-# that loads the Reunion metamod plugin cannot be assumed to expose them.
-# A server that wants one of these removes its `-`.
-# geoip is in modules.ini and its DLL is there, and it still cannot be pulled:
-# the module disables its own natives when it cannot find the GeoIP2 databases,
-# which it announces at startup and which this server does. A module being
-# loaded is not the same as its natives existing, and the difference is only
-# visible by starting the server - the host plugin refused to load with
-# "unknown function (name geoip_continent_name)" and took the whole runtime
-# with it. A server with the databases in place removes this marker.
--geoip
-
--reapi_vtc
--reapi_reunion
--reapi_rechecker
+# parsed (amxxpc needs the file on disk to compile an include that #includes
+# it), but its natives are never pulled into the host's native table. None is
+# needed today.
+#
+# A native the server does not have does not keep the host from loading: the
+# host's native filter lets it load without the native, and a call to it
+# answers 0 and says so once. So the includes whose natives a server may lack
+# are pulled like any other: reapi's add-ons - Reunion's natives exist only
+# when reapi finds Reunion, VTC's and ReChecker's only with those plugins - and
+# geoip, whose module turns its natives off when the GeoIP2 databases are not
+# there. The facade asks before it calls one (has_reunion).

package/includes/sources.json

@@ -8,14 +8,6 @@
 		"sha256": "f33a7435540bea8706db3fa948e51a85b511f5b18c383b97402a204dc5419195",
 		"include": "addons/amxmodx/scripting/include/"
 	},
-	"easy_http": {
-		"name": "AmxxEasyHttp",
-		"version": "1.4.0",
-		"license": "MIT",
-		"home": "https://github.com/Next21Team/AmxxEasyHttp",
-		"url": "https://github.com/Next21Team/AmxxEasyHttp/releases/download/1.4.0/easy_http.inc",
-		"sha256": "5196ae17ea58eeaebd293639f96e0c8bbfe06b40e28daab2c80395538b62f1d9"
-	},
 	"resemiclip": {
 		"name": "ReSemiclip AMXX",
 		"version": "2.3.9-amxx",

package/node_modules/assemblyscript/std/assembly/index.d.ts

@@ -2240,12 +2240,12 @@ declare class Date {
   /** Returns the UTC timestamp in milliseconds of the specified date. */
   static UTC(
     year: i32,
-    month: i32,
-    day: i32,
-    hour: i32,
-    minute: i32,
-    second: i32,
-    millisecond: i32
+    month?: i32,
+    day?: i32,
+    hour?: i32,
+    minute?: i32,
+    second?: i32,
+    millisecond?: i32
   ): f64;
   /** Returns the current UTC timestamp in milliseconds. */
   static now(): f64;
@@ -2455,6 +2455,8 @@ interface String {
 }
 
 declare class Map<K,V> {
+  /** A Map of the `[key, value]` entries, set in their order. */
+  constructor(entries?: [K, V][] | null);
   /** The entries, `[key, value]`, in the order the keys were added. */
   entries(): [K, V][];
   /** Calls `fn` with each value and key, in the order the keys were added. */
@@ -2472,6 +2474,8 @@ declare class Map<K,V> {
 }
 
 declare class Set<K> {
+  /** A Set of the values, added in their order. */
+  constructor(values?: K[] | null);
   /** Calls `fn` with each value, in the order they were added. */
   forEach(fn: (value: K, value2: K, set: Set<K>) => void): void;
   [Symbol.iterator](): IterableIterator<K>;
@@ -2678,15 +2682,15 @@ declare namespace console {
   /** Logs `message` to console if `assertion` is false-ish. */
   export function assert<T>(assertion: T, message?: string): void;
   /** Outputs `message` to the console. */
-  export function log(message?: string): void;
+  export function log(message?: string | Error): void;
   /** Outputs `message` to the console, prefixed with "Debug:". */
-  export function debug(message?: string): void;
+  export function debug(message?: string | Error): void;
   /** Outputs `message` to the console, prefixed with "Info:". */
-  export function info(message?: string): void;
+  export function info(message?: string | Error): void;
   /** Outputs `message` to the console, prefixed with "Warning:". */
-  export function warn(message?: string): void;
+  export function warn(message?: string | Error): void;
   /** Outputs `message` to the console, prefixed with "Error:". */
-  export function error(message?: string): void;
+  export function error(message?: string | Error): void;
   /** Starts a new timer using the specified `label`. */
   export function time(label?: string): void;
   /** Logs the current value of a timer previously started with `console.time`. */
@@ -2820,3 +2824,8 @@ declare namespace JSON {
   /** The value as JSON text; `space` indents it - that many spaces, or the text itself. A field left undefined is left out. */
   function stringify(value: unknown, replacer?: null, space?: number | string): string;
 }
+
+/** @hidden amxts: what an error's `stack` is made of - the host's frames, then their words. */
+declare abstract class ErrorStack { abstract frames(): StaticArray<u32>; abstract text(frames: StaticArray<u32>): string }
+/** @hidden amxts: the hood's ErrorStack. */
+declare let __errorStack: ErrorStack | null;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@amxts/core",
 	"type": "module",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"description": "Counter-Strike 1.6 plugins in TypeScript: compiled ahead of time and run inside AMX Mod X, next to Pawn plugins.",
 	"author": {
 		"name": "kukson777",
@@ -25,7 +25,12 @@
 	],
 	"exports": {
 		".": "./as/facade.ts",
+		"./natives": "./as/natives.ts",
+		"./constants": "./as/constants.ts",
+		"./fs": "./as/fs.ts",
+		"./os": "./as/os.ts",
 		"./kit": "./as/kit.ts",
+		"./check": "./as/lib/check.ts",
 		"./test-utils": "./src/testing/index.ts",
 		"./cli-api": "./src/cli-api.mjs",
 		"./package.json": "./package.json",
@@ -44,13 +49,19 @@
 		"scripts/apply-docs.ts",
 		"scripts/asc.ts",
 		"scripts/auto-imports.ts",
+		"scripts/build-identity.ts",
 		"scripts/build-wasm.ts",
 		"scripts/check.ts",
+		"scripts/client-messages.ts",
 		"scripts/compile-cache.ts",
+		"scripts/compile-pool.ts",
+		"scripts/compile-worker.ts",
 		"scripts/compile.ts",
 		"scripts/docker-server.ts",
 		"scripts/docs",
+		"scripts/editor-api.ts",
 		"scripts/file-contents.ts",
+		"scripts/hlds-events.ts",
 		"scripts/includes.ts",
 		"scripts/player-fields.ts",
 		"scripts/plugin-cache.ts",
@@ -58,12 +69,18 @@
 		"scripts/prebuilt.ts",
 		"scripts/prepare.ts",
 		"scripts/project.ts",
+		"scripts/reapi-events.ts",
 		"scripts/run.ts",
 		"scripts/shared-modules.ts",
+		"scripts/source-map.ts",
 		"scripts/system.ts",
 		"scripts/tracked-fs.ts",
+		"scripts/typed-commands.ts",
 		"scripts/typed-configs.ts",
 		"scripts/ui.ts",
+		"scripts/upgrade.ts",
+		"scripts/upgrade-menus.ts",
+		"scripts/upgrade-names.ts",
 		"includes/*.inc",
 		"includes/order.txt",
 		"includes/sources.json",
@@ -81,30 +98,35 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@amxts/cli": "^0.1.0",
+		"@amxts/cli": "^0.2.0",
 		"bun": "^1.4.2",
 		"typescript": "^5.6.0",
 		"assemblyscript": "0.28.20"
 	},
 	"optionalDependencies": {
-		"@amxts/wamrc-linux-x64": "^0.1.0",
-		"@amxts/wamrc-win32-x64": "^0.1.0"
+		"@amxts/wamrc-linux-x64": "^0.2.1",
+		"@amxts/wamrc-win32-x64": "^0.2.1"
 	},
 	"devDependencies": {
-		"@amxts/config-core": "^0.1.0",
-		"@amxts/menu-core": "^0.1.0",
+		"@amxts/config-core": "^0.1.1",
+		"@amxts/menu-core": "^0.2.0",
 		"@e18e/eslint-plugin": "^0.8.1",
 		"@eslint-community/eslint-plugin-eslint-comments": "^4.8.1",
 		"@stylistic/eslint-plugin": "^5.10.0",
 		"@types/node": "^22.0.0",
+		"basic-ftp": "^6.2.1",
 		"binaryen": "131.0.0-nightly.20260721",
+		"changelogen": "0.6.2",
 		"eslint-plugin-antfu": "^3.2.3",
 		"eslint-plugin-command": "^4.0.0",
 		"eslint-plugin-n": "^18.4.0",
 		"eslint-plugin-perfectionist": "^5.12.1",
 		"eslint-plugin-regexp": "^3.3.1",
+		"ftp-srv": "^4.6.3",
 		"oxfmt": "^0.70.0",
-		"oxlint": "^1.85.0"
+		"oxlint": "^1.85.0",
+		"ssh2": "^1.17.0",
+		"ssh2-sftp-client": "^12.1.1"
 	},
 	"bundleDependencies": [
 		"assemblyscript"

package/runtime/deps/assemblyscript/dist/asc.js

@@ -3726,24 +3726,33 @@ export namespace console {
     binding.assert(!!condition, message);
   }
 
-  export function log(message: string = ""): void {
-    binding.log(message);
+  // amxts: a string, or an Error - written as its stack, as JavaScript's console does
+  export function log<T = string>(message: T = changetype<T>("")): void {
+    binding.log(text<T>(message));
   }
 
-  export function debug(message: string = ""): void {
-    binding.debug(message);
+  export function debug<T = string>(message: T = changetype<T>("")): void {
+    binding.debug(text<T>(message));
   }
 
-  export function info(message: string = ""): void {
-    binding.info(message);
+  export function info<T = string>(message: T = changetype<T>("")): void {
+    binding.info(text<T>(message));
   }
 
-  export function warn(message: string = ""): void {
-    binding.warn(message);
+  export function warn<T = string>(message: T = changetype<T>("")): void {
+    binding.warn(text<T>(message));
   }
 
-  export function error(message: string = ""): void {
-    binding.error(message);
+  export function error<T = string>(message: T = changetype<T>("")): void {
+    binding.error(text<T>(message));
+  }
+
+  // @ts-ignore: decorator
+  @inline function text<T>(message: T): string {
+    if (isString<T>()) return changetype<string>(message);
+    if (isReference<T>() && !isNullable<T>() && message instanceof Error) return changetype<Error>(message).stack;
+    ERROR("console takes a string or an Error");
+    return "";
   }
 
   export function time(label: string = "default"): void {
@@ -4438,12 +4447,24 @@ export declare function INFO(message?: string): void;
 `,error:`export class Error {
 
   name: string  = "Error";
-  stack: string = ""; // TODO
+
+  // amxts: the calls that made it, as the host keeps them, for \`stack\`
+  /** @hidden */
+  __frames: StaticArray<u32> | null = __errorStack ? changetype<ErrorStack>(__errorStack).frames() : null;
 
   constructor(
     public message: string = ""
   ) {}
 
+  /** amxts: the error and where it was made, a call a line, as JavaScript writes it. */
+  get stack(): string {
+    let hook = __errorStack;
+    let frames = this.__frames;
+    if (!hook || !frames) return this.toString();
+    let calls = hook.text(frames);
+    return calls.length ? this.toString() + "\\n" + calls : this.toString();
+  }
+
   toString(): string {
     let message = this.message;
     return message.length
@@ -4452,6 +4473,23 @@ export declare function INFO(message?: string): void;
   }
 }
 
+/**
+ * @hidden amxts: what an error's \`stack\` is made of - the frames of the calls
+ * that made it, then their words - which only the host the plugin runs on
+ * has. The hood sets it (as/facade.ts); without it \`stack\` is the error's
+ * first line alone.
+ */
+export abstract class ErrorStack {
+  /** The frames of the calls running now. */
+  abstract frames(): StaticArray<u32>;
+  /** \`frames\` as lines: "    at name (file:line:column)". */
+  abstract text(frames: StaticArray<u32>): string;
+}
+
+/** @hidden see ErrorStack. */
+// @ts-ignore: decorator
+@lazy export let __errorStack: ErrorStack | null = null;
+
 export class RangeError extends Error {
   constructor(message: string = "") {
     super(message);
@@ -4508,7 +4546,7 @@ export function __throw(error: Error, fileName: string, lineNumber: u32, columnN
     __thrown = error;
     return true;
   }
-  abort(error.message, fileName, lineNumber, columnNumber);
+  abort(error.toString(), fileName, lineNumber, columnNumber);
   return false;
 }
 
@@ -4673,6 +4711,16 @@ export function __textFunction<F>(text: string): F {
   const fn: F = () => text;
   return fn;
 }
+
+/**
+ * amxts: a boolean given where \`boolean | (...) => boolean\` is declared - held
+ * as the function, so a boolean becomes one that returns it
+ * (Compiler.compileText).
+ */
+export function __boolFunction<F>(value: bool): F {
+  const fn: F = () => value;
+  return fn;
+}
 `,iterator:`export abstract class Iterable<T> {
   // ?
 }
@@ -5315,8 +5363,14 @@ export class Map<K,V> {
   private entriesOffset: i32 = 0;
   private entriesCount: i32 = 0;
 
-  constructor() {
-    /* nop */
+  /** amxts: \`new Map(entries)\` sets the \`[key, value]\` entries in their order, as JavaScript's Map does. */
+  constructor(entries: __Tuple2<K,V>[] | null = null) {
+    if (entries) {
+      for (let i = 0, k = entries.length; i < k; ++i) {
+        let entry = unchecked(entries[i]);
+        this.set(entry._0, entry._1);
+      }
+    }
   }
 
   get size(): i32 {
@@ -7224,6 +7278,19 @@ export namespace NativeMath {
   }
 
   export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c
+    // amxts: a plugin's whole numbers are f64, and \`n % d\` of two of them
+    // within i32 is i32's remainder, which takes the dividend's sign as
+    // JavaScript's does; a zero keeps the dividend's sign (-4 % 2 is -0).
+    // NaN, infinities, fractions, a zero divisor and larger numbers go on
+    // to the general remainder below.
+    if (builtin_abs<f64>(x) < 2147483648.0 && builtin_abs<f64>(y) < 2147483648.0) {
+      let ix = <i32>x;
+      let iy = <i32>y;
+      if (<f64>ix == x && <f64>iy == y && iy != 0) {
+        let r = ix % iy;
+        return r ? <f64>r : builtin_copysign<f64>(0.0, x);
+      }
+    }
     if (builtin_abs<f64>(y) == 1.0) {
       // x % 1, x % -1  ==>  sign(x) * abs(x - 1.0 * trunc(x / 1.0))
       // TODO: move this rule to compiler's optimization pass.
@@ -12437,8 +12504,11 @@ export class Set<T> {
   private entriesOffset: i32 = 0;
   private entriesCount: i32 = 0;
 
-  constructor() {
-    /* nop */
+  /** amxts: \`new Set(values)\` adds the values in their order, as JavaScript's Set does. */
+  constructor(values: T[] | null = null) {
+    if (values) {
+      for (let i = 0, k = values.length; i < k; ++i) this.add(unchecked(values[i]));
+    }
   }
 
   get size(): i32 {