Fix WebAssembly CI failures

Author: dannote

lib/quickbeam/wasm.ex

@@ -51,9 +51,11 @@ defmodule QuickBEAM.WASM do
       {:ok, pid} = QuickBEAM.WASM.start(module: wasm_bytes)
       {:ok, 42} = QuickBEAM.WASM.call(pid, "add", [40, 2])
   """
+  alias QuickBEAM.WASM.Server
+
   @spec start(keyword()) :: GenServer.on_start()
   def start(opts) do
-    QuickBEAM.WASM.Server.start_link(opts)
+    Server.start_link(opts)
   end
 
   @doc """
@@ -64,7 +66,7 @@ defmodule QuickBEAM.WASM do
   """
   @spec start_link(keyword()) :: GenServer.on_start()
   def start_link(opts) do
-    QuickBEAM.WASM.Server.start_link(opts)
+    Server.start_link(opts)
   end
 
   @doc """

lib/quickbeam/wasm/import_rewriter.ex

@@ -81,30 +81,9 @@ defmodule QuickBEAM.WASM.ImportRewriter do
   defp validate_import_value(%{"kind" => "memory", "min" => min, "max" => max}, provided) do
     bytes = Map.get(provided, "bytes", <<>>)
 
-    cond do
-      not is_binary(bytes) ->
-        {:error, "memory import bytes must be a binary"}
-
-      rem(byte_size(bytes), 65_536) != 0 ->
-        {:error, "memory import size must be page-aligned"}
-
-      true ->
-        actual_min = div(byte_size(bytes), 65_536)
-        actual_max = Map.get(provided, "max")
-
-        cond do
-          actual_min < min ->
-            {:error, "memory import minimum too small"}
-
-          max != nil and actual_min > max ->
-            {:error, "memory import current size exceeds declared maximum"}
-
-          max != nil and (is_nil(actual_max) or actual_max > max) ->
-            {:error, "memory import maximum too large"}
-
-          true ->
-            :ok
-        end
+    case validate_memory_bytes(bytes) do
+      :ok -> validate_memory_limits(min, max, bytes, Map.get(provided, "max"))
+      error -> error
     end
   end
 
@@ -118,6 +97,32 @@ defmodule QuickBEAM.WASM.ImportRewriter do
   defp validate_import_value(%{"kind" => "global"}, _provided),
     do: {:error, "global import type mismatch"}
 
+  defp validate_memory_bytes(bytes) when not is_binary(bytes),
+    do: {:error, "memory import bytes must be a binary"}
+
+  defp validate_memory_bytes(bytes) when rem(byte_size(bytes), 65_536) != 0,
+    do: {:error, "memory import size must be page-aligned"}
+
+  defp validate_memory_bytes(_bytes), do: :ok
+
+  defp validate_memory_limits(min, max, bytes, actual_max) do
+    actual_min = div(byte_size(bytes), 65_536)
+
+    cond do
+      actual_min < min ->
+        {:error, "memory import minimum too small"}
+
+      max != nil and actual_min > max ->
+        {:error, "memory import current size exceeds declared maximum"}
+
+      max != nil and (is_nil(actual_max) or actual_max > max) ->
+        {:error, "memory import maximum too large"}
+
+      true ->
+        :ok
+    end
+  end
+
   defp validate_global_value("i32", value) when is_integer(value), do: :ok
   defp validate_global_value("i64", value) when is_integer(value) or is_binary(value), do: :ok
   defp validate_global_value("f32", value) when is_number(value), do: :ok

lib/quickbeam/wasm/parser.ex

@@ -1,7 +1,7 @@
 defmodule QuickBEAM.WASM.Parser do
   @moduledoc false
 
-  alias QuickBEAM.WASM.{Module, Function}
+  alias QuickBEAM.WASM.{Function, Module}
 
   @wasm_magic <<0x00, 0x61, 0x73, 0x6D>>
   @wasm_version_1 <<0x01, 0x00, 0x00, 0x00>>

lib/quickbeam/wasm_api.ex

@@ -242,10 +242,7 @@ defmodule QuickBEAM.WasmAPI do
   defp initialize_imported_memories(_inst_ref, []), do: :ok
 
   defp initialize_imported_memories(inst_ref, [bytes]) do
-    case QuickBEAM.Native.wasm_write_memory(inst_ref, 0, bytes) do
-      :ok -> :ok
-      {:error, msg} -> {:error, msg}
-    end
+    QuickBEAM.Native.wasm_write_memory(inst_ref, 0, bytes)
   end
 
   defp initialize_imported_memories(_inst_ref, _many),

lib/quickbeam/wasm_js.zig

@@ -237,6 +237,7 @@ fn instruction_limit(ctx: *qjs.JSContext, state: *ContextState) c_int {
 }
 
 fn js_value_to_wasm(ctx: *qjs.JSContext, value: qjs.JSValue, kind: wamr.wasm_valkind_t) !wamr.wasm_val_t {
+    // SAFETY: `result` is fully assigned in the kind-specific branch before it is returned.
     var result: wamr.wasm_val_t = undefined;
     result.kind = kind;
     result._paddings = [_]u8{0} ** 7;
@@ -490,6 +491,7 @@ fn wasm_read_global_impl(
     defer qjs.JS_FreeCString(ctx, name_ptr);
 
     var err_buf: [256]u8 = undefined;
+    // SAFETY: WAMR initializes `value` on successful global reads before it is used.
     var value: wamr.wasm_val_t = undefined;
     if (!wamr.wamr_bridge_read_global(entry.managed.inst, name_ptr, &value, &err_buf, err_buf.len)) {
         return throw_error(ctx, std.mem.sliceTo(&err_buf, 0));
@@ -515,6 +517,7 @@ fn wasm_write_global_impl(
     defer qjs.JS_FreeCString(ctx, name_ptr);
 
     var err_buf: [256]u8 = undefined;
+    // SAFETY: WAMR initializes `current` on successful global reads before it is inspected.
     var current: wamr.wasm_val_t = undefined;
     if (!wamr.wamr_bridge_read_global(entry.managed.inst, name_ptr, &current, &err_buf, err_buf.len)) {
         return throw_error(ctx, std.mem.sliceTo(&err_buf, 0));

lib/quickbeam/wasm_nif.zig

@@ -28,6 +28,7 @@ const HostImportSpec = wasm_host_imports.ImportSpec;
 
 fn get_map_binary(env: *e.ErlNifEnv, map: e.ErlNifTerm, key: [:0]const u8) ![]const u8 {
     const key_term = beam.make_into_atom(key, .{ .env = env });
+    // SAFETY: `enif_get_map_value` initializes `value_term` before it is read.
     var value_term: e.ErlNifTerm = undefined;
     if (e.enif_get_map_value(env, map, key_term.v, &value_term) == 0) return error.BadArg;
     return beam.get([]const u8, .{ .v = value_term }, .{ .env = env });
@@ -43,7 +44,9 @@ fn parse_host_imports(env: *e.ErlNifEnv, imports: beam.term) ![]HostImportSpec {
     var list = imports.v;
     var index: usize = 0;
     while (index < result.len) : (index += 1) {
+        // SAFETY: `enif_get_list_cell` initializes `head` and `tail` on success before use.
         var head: e.ErlNifTerm = undefined;
+        // SAFETY: `enif_get_list_cell` initializes `head` and `tail` on success before use.
         var tail: e.ErlNifTerm = undefined;
         if (e.enif_get_list_cell(env, list, &head, &tail) == 0) return error.BadArg;
 
@@ -67,6 +70,7 @@ fn next_host_call_id() u64 {
 }
 
 fn extract_error_message(env: *e.ErlNifEnv, term: e.ErlNifTerm, fallback: []const u8) []const u8 {
+    // SAFETY: `enif_inspect_binary` initializes `bin` on success before it is read.
     var bin: e.ErlNifBinary = undefined;
     if (e.enif_inspect_binary(env, term, &bin) != 0 and bin.size > 0) {
         return bin.data[0..bin.size];
@@ -256,6 +260,7 @@ fn parse_f64_term(env: *e.ErlNifEnv, term: beam.term) !f64 {
 }
 
 fn term_to_wasm_val(env: *e.ErlNifEnv, term: beam.term, kind: wamr.wasm_valkind_t) !wamr.wasm_val_t {
+    // SAFETY: `value` is fully populated in the kind-specific branch before it is returned.
     var value: wamr.wasm_val_t = undefined;
     value.kind = kind;
     value._paddings = [_]u8{0} ** 7;
@@ -509,6 +514,7 @@ pub fn wasm_memory_grow(inst_res: WasmInstanceResource, delta: u32) beam.term {
 
 pub fn wasm_read_memory(inst_res: WasmInstanceResource, offset: u32, length: u32) beam.term {
     const env = beam.context.env orelse return make_error("no env");
+    // SAFETY: `enif_alloc_binary` initializes `bin` on success before it is passed on.
     var bin: e.ErlNifBinary = undefined;
     if (e.enif_alloc_binary(length, &bin) == 0) return make_error("out of memory");
 
@@ -538,6 +544,7 @@ pub fn wasm_read_global(inst_res: WasmInstanceResource, name: []const u8) beam.t
     defer std.heap.c_allocator.free(name_z);
 
     var err_buf: [256]u8 = undefined;
+    // SAFETY: WAMR initializes `value` on successful global reads before it is used.
     var value: wamr.wasm_val_t = undefined;
 
     if (!wamr.wamr_bridge_read_global(inst, name_z.ptr, &value, &err_buf, err_buf.len)) {
@@ -557,6 +564,7 @@ pub fn wasm_write_global(inst_res: WasmInstanceResource, name: []const u8, value
     defer std.heap.c_allocator.free(name_z);
 
     var err_buf: [256]u8 = undefined;
+    // SAFETY: WAMR initializes `current` on successful global reads before it is inspected.
     var current: wamr.wasm_val_t = undefined;
 
     if (!wamr.wamr_bridge_read_global(inst, name_z.ptr, &current, &err_buf, err_buf.len)) {

lib/quickbeam/worker.zig

@@ -589,6 +589,7 @@ pub const WorkerState = struct {
         }
         self.atoms.deinit(self.ctx);
         wasm_js.destroy_context(self.ctx);
+        qjs.JS_RunGC(self.rt);
         qjs.JS_FreeContext(self.ctx);
         self.ctx = qjs.JS_NewContext(self.rt) orelse {
             result.ok = false;
@@ -1200,6 +1201,7 @@ pub fn quickbeam_wasm_host_invoke_js_impl(runtime_data: ?*anyopaque, callback_na
         if (result.env) |result_env| {
             defer beam.free_env(result_env);
             if (result.term) |term| {
+                // SAFETY: `enif_inspect_binary` initializes `bin` on success before it is read.
                 var bin: e.ErlNifBinary = undefined;
                 if (e.enif_inspect_binary(result_env, term, &bin) != 0 and bin.size > 0) {
                     copy_error_buf(err_buf, err_buf_size, bin.data[0..bin.size]);

test/core/memory_test.exs

@@ -35,7 +35,16 @@ defmodule QuickBEAM.Core.MemoryTest do
     test "memory stabilizes across reset cycles", %{} do
       {:ok, rt} = QuickBEAM.start()
 
-      # First cycle establishes the pool size
+      # First reset can under-report because some runtime structures are only
+      # allocated on the first evaluation after a fresh context is installed.
+      # Establish the baseline after one full warm reset cycle.
+      QuickBEAM.eval(rt, """
+      globalThis.data = [];
+      for (let i = 0; i < 5000; i++) data.push({x: i});
+      """)
+
+      QuickBEAM.reset(rt)
+
       QuickBEAM.eval(rt, """
       globalThis.data = [];
       for (let i = 0; i < 5000; i++) data.push({x: i});

test/wasm_test.exs

@@ -2,7 +2,7 @@ defmodule QuickBEAM.WASMTest do
   use ExUnit.Case, async: false
 
   alias QuickBEAM.WASM
-  alias QuickBEAM.WASM.{Module, Function}
+  alias QuickBEAM.WASM.{Function, Module}
 
   # Minimal "add" module in WAT:
   #   (module
@@ -643,13 +643,13 @@ defmodule QuickBEAM.WASMTest do
     test "memory_size returns bytes" do
       {:ok, pid} = WASM.start(module: @memory_func_wasm)
       {:ok, size} = WASM.memory_size(pid)
-      assert size == 65536
+      assert size == 65_536
       WASM.stop(pid)
     end
 
     test "read out of bounds returns error" do
       {:ok, pid} = WASM.start(module: @memory_func_wasm)
-      {:error, _} = WASM.read_memory(pid, 65530, 100)
+      {:error, _} = WASM.read_memory(pid, 65_530, 100)
       WASM.stop(pid)
     end
   end