@amxts/core 0.2.4 → 0.3.0

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

@@ -163,7 +163,7 @@ index 771ef87..7bdb74d 100644
                  }
              }
 diff --git a/core/iwasm/aot/aot_runtime.c b/core/iwasm/aot/aot_runtime.c
-index d2621fb..47178c4 100644
+index d2621fb..1538532 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,
@@ -192,7 +192,134 @@ index d2621fb..47178c4 100644
  #endif
          }
  
-@@ -3414,6 +3414,11 @@ aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx,
+@@ -2773,6 +2773,126 @@ aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function,
+     }
+ }
+ 
++#if WASM_ENABLE_AOT_STACK_FRAME != 0
++static bool
++aot_alloc_standard_frame(WASMExecEnv *exec_env, uint32 func_index);
++#endif
++
++/* amxts: a direct call, see wasm_runtime_direct_entry in wasm_export.h */
++void *
++wasm_runtime_direct_entry(WASMFunctionInstanceCommon *function)
++{
++    AOTFunctionInstance *func = (AOTFunctionInstance *)function;
++
++    return func->is_import_func ? NULL : func->u.func.func_ptr;
++}
++
++/* amxts: see wasm_runtime_memory_view in wasm_export.h */
++uint8_t *
++wasm_runtime_memory_view(WASMExecEnv *exec_env, uint64_t *size)
++{
++    WASMMemoryInstance *memory =
++        wasm_get_default_memory((WASMModuleInstance *)exec_env->module_inst);
++
++    if (!memory) {
++        *size = 0;
++        return NULL;
++    }
++    *size = memory->memory_data_size;
++    return memory->memory_data;
++}
++
++uint32_t
++wasm_runtime_direct_frames(WASMModuleInstanceCommon *module_inst)
++{
++#if WASM_ENABLE_AOT_STACK_FRAME != 0
++    return (uint32_t)(((AOTModule *)((AOTModuleInstance *)module_inst)->module)
++                          ->feature_flags
++                      & (WASM_FEATURE_TINY_STACK_FRAME
++                         | WASM_FEATURE_FRAME_PER_FUNCTION));
++#else
++    (void)module_inst;
++    return 0;
++#endif
++}
++
++/* written into the host's call where the compiler can (link-time code
++   generation, MSVC's and GCC's): it runs before every direct call */
++#if defined(_MSC_VER)
++__forceinline
++#elif defined(__GNUC__)
++__attribute__((always_inline))
++#endif
++bool
++wasm_runtime_direct_begin(WASMExecEnv *exec_env,
++                          WASMFunctionInstanceCommon *function, uint32_t frames,
++                          void **mark)
++{
++    AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst;
++
++    /* the thread is the one the exec env first ran on, its stack the same */
++    if (!exec_env->native_stack_boundary)
++        wasm_exec_env_set_thread_info(exec_env);
++#if WASM_ENABLE_AOT_STACK_FRAME != 0
++    {
++        /* the frames as aot_alloc_frame keeps them; the mark is where they
++           stand, a tiny frame's top or a standard frame, for
++           wasm_runtime_direct_end to put them back */
++        uint32 flags = frames;
++        uint32 func_index = ((AOTFunctionInstance *)function)->func_index;
++
++        if (flags & WASM_FEATURE_TINY_STACK_FRAME) {
++            AOTTinyFrame *frame = (AOTTinyFrame *)exec_env->wasm_stack.top;
++
++            *mark = frame;
++            if (!(flags & WASM_FEATURE_FRAME_PER_FUNCTION)) {
++                if ((uint8 *)frame > exec_env->wasm_stack.top_boundary) {
++                    aot_set_exception(module_inst,
++                                      "wasm operand stack overflow");
++                    return false;
++                }
++                frame->func_index = func_index;
++                exec_env->wasm_stack.top += sizeof(AOTTinyFrame);
++            }
++        }
++        else {
++            *mark = exec_env->cur_frame;
++            if (!(flags & WASM_FEATURE_FRAME_PER_FUNCTION)
++                && !aot_alloc_standard_frame(exec_env, func_index))
++                return false;
++        }
++    }
++#else
++    (void)frames;
++    *mark = NULL;
++#endif
++    module_inst->cur_exec_env = exec_env;
++    return true;
++}
++
++bool
++wasm_runtime_direct_end(WASMExecEnv *exec_env, uint32_t frames, void *mark)
++{
++    AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst;
++    bool ret = module_inst->cur_exception[0] == '\0';
++
++#if WASM_ENABLE_DUMP_CALL_STACK != 0
++    if (!ret)
++        aot_create_call_stack(exec_env);
++#endif
++#if WASM_ENABLE_AOT_STACK_FRAME != 0
++    /* the frames the call left taken off, down to the mark at once: what
++       aot_free_frame does one at a time */
++    if (frames & WASM_FEATURE_TINY_STACK_FRAME)
++        exec_env->wasm_stack.top = (uint8 *)mark;
++    else
++        exec_env->cur_frame = (struct WASMInterpFrame *)mark;
++#endif
++    (void)frames;
++    (void)mark;
++    return ret;
++}
++
+ void
+ aot_set_exception(AOTModuleInstance *module_inst, const char *exception)
+ {
+@@ -3414,6 +3534,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);
@@ -204,7 +331,7 @@ index d2621fb..47178c4 100644
  #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,
+@@ -3474,6 +3599,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);
@@ -341,11 +468,223 @@ index 82f70ca..ea501fb 100644
  
      while (frame_ip < frame_ip_end) {
          opcode = *frame_ip++;
+diff --git a/core/iwasm/compilation/aot_emit_conversion.c b/core/iwasm/compilation/aot_emit_conversion.c
+index fa5c2ab..0317f29 100644
+--- a/core/iwasm/compilation/aot_emit_conversion.c
++++ b/core/iwasm/compilation/aot_emit_conversion.c
+@@ -254,6 +254,74 @@ trunc_sat_float_to_int(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
+             res = aot_call_llvm_intrinsic(comp_ctx, func_ctx, intrinsic,
+                                           dest_type, &src_type, 1, operand);
+         }
++        else if (sign && dest_type == I64_TYPE && src_type == F64_TYPE
++                 && !comp_ctx->is_indirect_mode
++                 && !strncmp(comp_ctx->target_arch, "i386", 4)) {
++            /* amxts: on i386 a double becomes a 64-bit integer through the
++               x87 - a store, fld, two fldcw and fistp - while one within 32
++               bits, which is nearly every one (a number made a cell is
++               trunc_sat to 64 bits and a wrap), takes SSE2's cvttsd2si. */
++            LLVMBasicBlockRef narrow_block, wide_block, joined_block;
++            LLVMValueRef fits, narrow, wide, branch;
++            LLVMMetadataRef weights[3];
++
++            fits = LLVMBuildAnd(
++                comp_ctx->builder,
++                LLVMBuildFCmp(comp_ctx->builder, LLVMRealOGT, operand,
++                              F64_CONST(-2147483649.0), "above_i32_min"),
++                LLVMBuildFCmp(comp_ctx->builder, LLVMRealOLT, operand,
++                              F64_CONST(2147483648.0), "below_i32_max"),
++                "fits_i32");
++            ADD_BASIC_BLOCK(joined_block, "trunc_joined");
++            ADD_BASIC_BLOCK(wide_block, "trunc_wide");
++            ADD_BASIC_BLOCK(narrow_block, "trunc_narrow");
++            if (!fits
++                || !(branch = LLVMBuildCondBr(comp_ctx->builder, fits,
++                                              narrow_block, wide_block))) {
++                aot_set_last_error("llvm build cond br failed.");
++                goto fail;
++            }
++            /* Weighted as nearly always narrow, or LLVM makes it a select
++               and runs the x87 path every time too. */
++            weights[0] = LLVMMDStringInContext2(comp_ctx->context,
++                                                "branch_weights", 14);
++            weights[1] = LLVMValueAsMetadata(I32_CONST(2000));
++            weights[2] = LLVMValueAsMetadata(I32_CONST(1));
++            LLVMSetMetadata(
++                branch,
++                LLVMGetMDKindIDInContext(comp_ctx->context, "prof", 4),
++                LLVMMetadataAsValue(comp_ctx->context,
++                                    LLVMMDNodeInContext2(comp_ctx->context,
++                                                         weights, 3)));
++
++            LLVMPositionBuilderAtEnd(comp_ctx->builder, narrow_block);
++            narrow = LLVMBuildSExt(
++                comp_ctx->builder,
++                LLVMBuildFPToSI(comp_ctx->builder, operand, I32_TYPE,
++                                "trunc_i32"),
++                I64_TYPE, "trunc_i32_wide");
++            if (!narrow || !LLVMBuildBr(comp_ctx->builder, joined_block)) {
++                aot_set_last_error("llvm build br failed.");
++                goto fail;
++            }
++
++            LLVMPositionBuilderAtEnd(comp_ctx->builder, wide_block);
++            wide = LLVMBuildFPToSI(comp_ctx->builder, operand, I64_TYPE, name);
++            if (!wide || !LLVMBuildBr(comp_ctx->builder, joined_block)) {
++                aot_set_last_error("llvm build br failed.");
++                goto fail;
++            }
++
++            LLVMPositionBuilderAtEnd(comp_ctx->builder, joined_block);
++            if (!(res = LLVMBuildPhi(comp_ctx->builder, I64_TYPE,
++                                     "trunc_joined_phi"))) {
++                aot_set_last_error("llvm build phi failed.");
++                goto fail;
++            }
++            LLVMAddIncoming(res, &narrow, &narrow_block, 1);
++            LLVMAddIncoming(res, &wide, &wide_block, 1);
++            check_greater_succ = joined_block;
++        }
+         else {
+             if (sign) {
+                 res = LLVMBuildFPToSI(comp_ctx->builder, operand, dest_type,
+@@ -319,6 +387,83 @@ fail:
+     return false;
+ }
+ 
++/* amxts: i32.trunc_sat_f64_s on i386 with SSE2 as cvttsd2si itself, which
++   answers 0x80000000 for NaN and for a number out of i32's range: only that
++   answer, rare, takes the branch that saturates. WAMR's own way tests NaN,
++   the bottom and the top, a branch each, around every conversion: a `%`
++   checks both its numbers are whole this way, and the three branches cost a
++   remainder of two numbers that change in a loop a tenth of its time. */
++static bool
++trunc_sat_f64_to_i32_x86(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
++                         LLVMValueRef operand)
++{
++    LLVMBasicBlockRef fast_block, slow_block, res_block;
++    LLVMTypeRef vector_type = LLVMVectorType(F64_TYPE, 2);
++    LLVMValueRef vector, raw, indefinite, branch, nan, positive, slow, phi;
++    LLVMMetadataRef weights[3];
++
++    if (!(vector = LLVMBuildInsertElement(comp_ctx->builder,
++                                          LLVMGetUndef(vector_type), operand,
++                                          I32_ZERO, "cvttsd2si_in"))
++        || !(raw = aot_call_llvm_intrinsic(comp_ctx, func_ctx,
++                                           "llvm.x86.sse2.cvttsd2si", I32_TYPE,
++                                           &vector_type, 1, vector))
++        || !(indefinite =
++                 LLVMBuildICmp(comp_ctx->builder, LLVMIntEQ, raw,
++                               I32_CONST(INT32_MIN), "cvttsd2si_indefinite"))) {
++        aot_set_last_error("llvm build conversion failed.");
++        return false;
++    }
++
++    fast_block = LLVMGetInsertBlock(comp_ctx->builder);
++    ADD_BASIC_BLOCK(res_block, "trunc_sat_done");
++    ADD_BASIC_BLOCK(slow_block, "trunc_sat_edge");
++    if (!(branch = LLVMBuildCondBr(comp_ctx->builder, indefinite, slow_block,
++                                   res_block))) {
++        aot_set_last_error("llvm build cond br failed.");
++        goto fail;
++    }
++    /* Weighted as nearly never the edge. */
++    weights[0] =
++        LLVMMDStringInContext2(comp_ctx->context, "branch_weights", 14);
++    weights[1] = LLVMValueAsMetadata(I32_CONST(1));
++    weights[2] = LLVMValueAsMetadata(I32_CONST(2000));
++    LLVMSetMetadata(
++        branch, LLVMGetMDKindIDInContext(comp_ctx->context, "prof", 4),
++        LLVMMetadataAsValue(comp_ctx->context,
++                            LLVMMDNodeInContext2(comp_ctx->context, weights, 3)));
++
++    /* NaN is 0, a number above the range INT32_MAX, any other INT32_MIN -
++       -2^31 itself among them. */
++    LLVMPositionBuilderAtEnd(comp_ctx->builder, slow_block);
++    if (!(nan = LLVMBuildFCmp(comp_ctx->builder, LLVMRealUNO, operand,
++                              operand, "is_nan"))
++        || !(positive = LLVMBuildFCmp(comp_ctx->builder, LLVMRealOGT, operand,
++                                      F64_CONST(0.0), "is_positive"))
++        || !(slow = LLVMBuildSelect(
++                 comp_ctx->builder, nan, I32_ZERO,
++                 LLVMBuildSelect(comp_ctx->builder, positive,
++                                 I32_CONST(INT32_MAX), I32_CONST(INT32_MIN),
++                                 "saturated"),
++                 "saturated_or_nan"))
++        || !LLVMBuildBr(comp_ctx->builder, res_block)) {
++        aot_set_last_error("llvm build conversion failed.");
++        goto fail;
++    }
++
++    LLVMPositionBuilderAtEnd(comp_ctx->builder, res_block);
++    if (!(phi = LLVMBuildPhi(comp_ctx->builder, I32_TYPE, "trunc_sat_phi"))) {
++        aot_set_last_error("llvm build phi failed.");
++        goto fail;
++    }
++    LLVMAddIncoming(phi, &raw, &fast_block, 1);
++    LLVMAddIncoming(phi, &slow, &slow_block, 1);
++    PUSH_I32(phi);
++    return true;
++fail:
++    return false;
++}
++
+ bool
+ aot_compile_op_i32_wrap_i64(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx)
+ {
+@@ -438,6 +583,11 @@ aot_compile_op_i32_trunc_f64(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
+         return trunc_float_to_int(
+             comp_ctx, func_ctx, value, F64_TYPE, I32_TYPE, min_value, max_value,
+             sign ? "i32_trunc_f64_s" : "i32_trunc_f64_u", sign);
++    else if (sign && !comp_ctx->is_indirect_mode
++             && !comp_ctx->disable_llvm_intrinsics
++             && !strncmp(comp_ctx->target_arch, "i386", 4)
++             && aot_target_has_sse2(comp_ctx))
++        return trunc_sat_f64_to_i32_x86(comp_ctx, func_ctx, value);
+     else
+         return trunc_sat_float_to_int(
+             comp_ctx, func_ctx, value, F64_TYPE, I32_TYPE, min_value, max_value,
+diff --git a/core/iwasm/compilation/aot_llvm.h b/core/iwasm/compilation/aot_llvm.h
+index 9f62f66..b8cb7d3 100644
+--- a/core/iwasm/compilation/aot_llvm.h
++++ b/core/iwasm/compilation/aot_llvm.h
+@@ -644,6 +644,10 @@ aot_load_const_from_table(AOTCompContext *comp_ctx, LLVMValueRef base,
+ bool
+ aot_check_simd_compatibility(const char *arch_c_str, const char *cpu_c_str);
+ 
++/* amxts: whether the machine code is for a CPU with SSE2. */
++bool
++aot_target_has_sse2(const AOTCompContext *comp_ctx);
++
+ void
+ aot_apply_llvm_new_pass_manager(AOTCompContext *comp_ctx, LLVMModuleRef module);
+ 
+diff --git a/core/iwasm/compilation/aot_llvm_extra.cpp b/core/iwasm/compilation/aot_llvm_extra.cpp
+index 35b25c8..f06a36c 100644
+--- a/core/iwasm/compilation/aot_llvm_extra.cpp
++++ b/core/iwasm/compilation/aot_llvm_extra.cpp
+@@ -145,6 +145,17 @@ ExpandMemoryOpPass::run(Function &F, FunctionAnalysisManager &AM)
+     return PA;
+ }
+ 
++/* amxts: whether the machine code is for a CPU with SSE2: --cpu=pentium4
++   and every one after it, not a bare --target=i386. */
++bool
++aot_target_has_sse2(const AOTCompContext *comp_ctx)
++{
++    const llvm::MCSubtargetInfo *info =
++        reinterpret_cast<llvm::TargetMachine *>(comp_ctx->target_machine)
++            ->getMCSubtargetInfo();
++    return info != nullptr && info->checkFeatures("+sse2");
++}
++
+ bool
+ aot_check_simd_compatibility(const char *arch_c_str, const char *cpu_c_str)
+ {
 diff --git a/core/iwasm/include/wasm_export.h b/core/iwasm/include/wasm_export.h
-index 81efb8f..2d80cf2 100644
+index 81efb8f..3a08bbe 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
+@@ -2075,6 +2075,93 @@ WASM_RUNTIME_API_EXTERN uint32_t
  wasm_runtime_dump_call_stack_to_buf(wasm_exec_env_t exec_env, char *buf,
                                      uint32_t len);
  
@@ -362,6 +701,79 @@ index 81efb8f..2d80cf2 100644
 +WASM_RUNTIME_API_EXTERN uint32_t
 +wasm_runtime_take_trap_frames(wasm_module_inst_t module_inst,
 +                              WASMCApiFrame *buffer, uint32_t length);
++
++/**
++ * amxts: the machine code of an AOT function, for a host that calls it
++ * itself, many times, rather than through wasm_runtime_call_wasm: called as
++ * `result fn(wasm_exec_env_t, params...)` with the C types of its wasm ones
++ * (i32 int32_t, i64 int64_t, f32 float, f64 double), between
++ * wasm_runtime_direct_begin and wasm_runtime_direct_end, always on the
++ * thread the exec env first ran on: its native stack's boundary, which the
++ * code checks, is set once.
++ *
++ * @param function the function, of an AOT module
++ *
++ * @return its machine code, or NULL for an imported function
++ */
++WASM_RUNTIME_API_EXTERN void *
++wasm_runtime_direct_entry(wasm_function_inst_t function);
++
++/**
++ * amxts: the linear memory of the instance an exec env runs, as it is now:
++ * where it starts in the host, and its size. A native reads and writes the
++ * plugin's memory through it without asking for each address; the memory
++ * moves when it grows, so it is asked again after anything that may run the
++ * plugin's code.
++ *
++ * @param exec_env the exec env
++ * @param size where its size in bytes goes
++ *
++ * @return where it starts, or NULL with a size of 0 when it has none
++ */
++WASM_RUNTIME_API_EXTERN uint8_t *
++wasm_runtime_memory_view(wasm_exec_env_t exec_env, uint64_t *size);
++
++/**
++ * amxts: how an instance's AOT code keeps its frames, for
++ * wasm_runtime_direct_begin and wasm_runtime_direct_end: read once, as the
++ * module was compiled.
++ *
++ * @param module_inst the instance
++ *
++ * @return its frames' kind
++ */
++WASM_RUNTIME_API_EXTERN uint32_t
++wasm_runtime_direct_frames(wasm_module_inst_t module_inst);
++
++/**
++ * amxts: before a direct call (wasm_runtime_direct_entry): the frame the
++ * call's stack starts with, and the instance's exec env.
++ *
++ * @param exec_env the exec env the call runs in
++ * @param function the function called
++ * @param frames what wasm_runtime_direct_frames gave for its instance
++ * @param mark where the frames stand, for wasm_runtime_direct_end
++ *
++ * @return false, with an exception set, when the call has no room
++ */
++WASM_RUNTIME_API_EXTERN bool
++wasm_runtime_direct_begin(wasm_exec_env_t exec_env,
++                          wasm_function_inst_t function, uint32_t frames,
++                          void **mark);
++
++/**
++ * amxts: after a direct call: whether it ended without an exception - a
++ * failed one keeps its frames for wasm_runtime_take_trap_frames - and the
++ * frames it left taken off.
++ *
++ * @param exec_env the exec env the call ran in
++ * @param frames what wasm_runtime_direct_frames gave for its instance
++ * @param mark what wasm_runtime_direct_begin gave
++ *
++ * @return true when the call succeeded
++ */
++WASM_RUNTIME_API_EXTERN bool
++wasm_runtime_direct_end(wasm_exec_env_t exec_env, uint32_t frames, void *mark);
 +
  /**
   * Get the size required to store the LLVM PGO profile data

package/scripts/auto-imports.ts

@@ -68,7 +68,7 @@ export const CORE = '@amxts/core';
  */
 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',
+	'Call CellArray CellBuffer Handler WideHandler NoArgument arg argc argString argText cell cellFloat cells cellsToString cmd cmdWide floatCell handled hook unhook hostIndex nativeFn noOrigin out paint playerIds publicFor putCell readText ret setArg setArgText stringToCells swapTeam text TEXT_MAX',
 	// The kit's.
 	'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.

package/scripts/build-identity.ts

@@ -1,20 +1,12 @@
-// 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.
+// The build a module is 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).
 //
 // 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 { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
@@ -38,46 +30,44 @@ export function buildIdentity(): string {
 	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.
+// What a plugin and the module have to agree on, in two parts.
+//
+// The ground: the machine code's - the WAMR patch, which both wamrc and the
+// module's runtime are built with, and the versions of WAMR and
+// AssemblyScript the patches are for (AssemblyScript lays out the strings the
+// module reads) - and ABI_REVISION. It is the version and a hash of those,
+// `0.3.1+abi.1a2b3c4d`, which the module carries as its own (AMXTS_ABI).
 //
-// 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.
+// The imports: every function the plugin imports, each with its shape - its
+// line of the natives table (runtime/natives.txt), which holds every import
+// the module has, the hood's own and Pawn's natives alike: the types wamrc
+// compiles a direct call with, how the module's thunk passes the arguments,
+// and `leaf`. A plugin carries the ground's identity, then the shape of each
+// import it uses (pluginAbi), and the module loads it when the line and the
+// ground are its own and it has every import with the same shape. So a
+// plugin built by any patch of a line loads on any patch's module that has
+// what it uses, and a module package's prebuilt plugin serves the whole line:
+// a patch adds imports, and only what uses them needs it. An import keeps
+// its shape for the line (shapeChanges): a change of shape is a new import.
+//
+// The full version stays in the identity to be read: the release a module
+// is of (src/system.mjs), what a refusal names. 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. Not the facade's code: it is compiled into each plugin, which
+// carries its own, so plugins of two patches talk only through the imports -
+// and, between a module and the plugins that use it, through the module's
+// surface, whose own hash the module checks when a plugin first calls it
+// (scripts/shared-modules.ts).
 
 /**
  * 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).
+ * an import's shape or the patches changing: what a cell of an event means,
+ * an export the module calls, how a value crosses between plugins
+ * (as/remote.ts), what names a plugin in a shared module's call (2: its run,
+ * not its index). A patch release must not raise it.
  */
 const ABI_REVISION = 2;
 
@@ -86,30 +76,77 @@ 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'}`;
-	});
+/** The natives table a compile reads: AMXTS_NATIVES, else the core's. */
+export function nativesFile(): string | undefined {
+	return [process.env.AMXTS_NATIVES, join(CORE, 'runtime/natives.txt')].find(each => each && existsSync(each));
 }
 
-declare const AMXTS_ABI: string;
+/** A natives table's lines, but its comments: `add (iiii)i [a1>,v,s,v leaf`. */
+const tableLines = (text: string) => text.split(/\r?\n/).filter(line => line && !line.startsWith('#'));
+
+/** The name of an import's shape: `add` of `add (iiii)i [a1>,v,s,v leaf`. */
+export const importName = (shape: string) => shape.split(' ', 1)[0];
+
+/** Every import there is, by name, with its shape. */
+export function importShapes(): Map<string, string> {
+	const file = nativesFile();
+	const lines = file ? tableLines(tracked.readFileSync(file, 'utf8')) : [];
+	return new Map(lines.map(line => [importName(line), line]));
+}
 
 /**
- * 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.
+ * The ground this core compiles plugins on, which the module it builds loads
+ * plugins of: `0.3.1+abi.1a2b3c4d`. It is read off the patches, 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');
+	// A patch by its name, which carries the upstream version; WAMR's by its content too.
+	const dir = join(CORE, 'runtime/patches');
+	const patches = tracked.readdirSync(dir).filter(file => file.endsWith('.patch')).map(file => (file.startsWith('wamr-') ? `${file}\n${tracked.readFileSync(join(dir, file), 'utf8')}` : file));
+	const hash = createHash('sha256').update([`revision ${ABI_REVISION}`, ...patches.sort()].join('\n')).digest('hex');
 	return `${coreVersion()}+abi.${hash.slice(0, 8)}`;
 }
+
+/**
+ * The ABI section of a plugin that imports `imports` (`env.add`, as a wasm
+ * names them): the identity, then the shape of each import, a line each.
+ */
+export function pluginAbi(imports: Iterable<string>): string {
+	const shapes = importShapes();
+	const used = [...imports].filter(each => each.startsWith('env.')).map(each => shapes.get(each.slice(4)) ?? each.slice(4));
+	return [abiIdentity(), ...used.sort()].join('\n');
+}
+
+/**
+ * The imports of the line's last release, each with its shape, relative to
+ * the core: `bun run abi:lock` writes it when a version is released.
+ */
+export const ABI_LOCK = 'runtime/abi-lock.txt';
+
+/**
+ * The shapes of a released lock (runtime/abi-lock.txt: the version, then
+ * every import of it) that a natives table has no longer, or has otherwise,
+ * while the two are of one line: a plugin built for that release would be
+ * refused by this one's module. Another line owes the lock nothing.
+ */
+export function shapeChanges(lock: string, natives: string, version = coreVersion()): string[] {
+	const [released = '', ...shapes] = tableLines(lock);
+	if (releaseLine(released) !== releaseLine(version)) return [];
+	const now = new Set(tableLines(natives));
+	return shapes.filter(shape => !now.has(shape));
+}
+
+/** The line of a version, `major.minor`: `0.3` of `0.3.1` and of `0.3.0-rc.1`. */
+export function releaseLine(version: string): string {
+	return version.split('.', 2).join('.');
+}
+
+/**
+ * What the module compares of an identity: its line and its ground's hash,
+ * `0.3+abi.1a2b3c4d` of `0.3.1+abi.1a2b3c4d`. The modules of two identities
+ * with one abiLine load each other's plugins, of the imports they both have.
+ */
+export function abiLine(abi: string): string {
+	const at = abi.indexOf('+');
+	return at < 0 ? abi : `${releaseLine(abi.slice(0, at))}${abi.slice(at)}`;
+}