relaton-un 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d4039da98331ed950c1b39945ac3ae22fcca20279b6fe151d91c1e7e65c0811
-  data.tar.gz: 10ed51aa8d99ad31c732fc280dc120f482663e44bfc8c25191408835ad17eb6a
+  metadata.gz: bd62341915793af74a836d522b901c108bda7fbc57825c0f663203d2f048777a
+  data.tar.gz: 26133140a50fb40d46db8eb3959beb9fe4bbbcf51d0716d7f1a5bcbbff782664
 SHA512:
-  metadata.gz: 0504dc57daa40acdbd2255ce64c8244794183c0c9e24e1f14c82e723f3655be36ba628af91568cb950442fcfd6aad9a8e57b8bb5beb8451cd39f2a02125580ff
-  data.tar.gz: 1929cc7e26616e2f2245d562b0c20927b4396a5363a23faee610f6723ddff02ad93223473516897c5455f25f9a983a8ca4de4011f5f561d563cfcb2d8b244f37
+  metadata.gz: 13fa9b4d6f59851cbff14ade0621bee34ab7a2d152300a4feebab83673daa4923b46789ec21b417b86969e3c5935095f68950c511ebc72afaf70a443c5da63e9
+  data.tar.gz: 8fed8aefd9a06f23f27dbc2d9c5dc6f7dc4793fd884a734f56fedf69facd70d31dbbb46fd9e81d1ea4146f4dd7df81afe6f92dcf3122072834311e9c7195ae65

data/.github/workflows/rake.yml

@@ -4,7 +4,7 @@ name: rake
 
 on:
   push:
-    branches: [ master, main ]
+    branches: [ master, main, lutaml-integration ]
     tags: [ v* ]
   pull_request:
   workflow_dispatch:

data/Gemfile

@@ -10,4 +10,5 @@ gem "rspec", "~> 3.0"
 gem "ruby-jing"
 gem "simplecov"
 gem "vcr"
+gem "wasmtime", "~> 41.0", group: :development # kept for golden-token regeneration only
 gem "webmock"

data/lib/relaton/un/token_generator.rb

@@ -1,16 +1,10 @@
 # frozen_string_literal: true
 
-begin
-  require "wasmtime"
-  WASMTIME_LOADED = true
-rescue LoadError
-  WASMTIME_LOADED = false
-end
+require_relative "wasm"
 
 module Relaton
   module Un
     module TokenGenerator
-      WASMTIME_AVAILABLE = WASMTIME_LOADED
       WASM_PATH = File.join(__dir__, "wasm_v_bg.wasm")
       DOMAIN = "documents.un.org"
 
@@ -18,11 +12,6 @@ module Relaton
       # Tokens are cached per-minute since the WASM output changes each minute.
       # @return [String] decimal string representation of the i64 token
       def self.generate
-        unless WASMTIME_AVAILABLE
-          warn "[relaton-un] wasmtime gem is not available on this platform. Token generation is disabled."
-          return nil
-        end
-
         now = Time.now.utc
         key = [now.year, now.month, now.day, now.hour, now.min]
         return @cached_token if @cached_key == key && @cached_token
@@ -31,92 +20,49 @@ module Relaton
         @cached_token = call_wasm(*key)
       end
 
-      def self.call_wasm(year, month, day, hour, minute) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        engine = Wasmtime::Engine.new
-        mod = Wasmtime::Module.new(engine, File.binread(WASM_PATH))
-        store = Wasmtime::Store.new(engine)
-        linker = Wasmtime::Linker.new(engine)
-
+      def self.call_wasm(year, month, day, hour, minute)
+        mod = (@module ||= Wasm::Module.parse(File.binread(WASM_PATH)))
         heap = Heap.new
         fake_window = Object.new
         fake_location = Object.new
-
-        # Pre-allocate well-known objects in the heap
         heap.alloc(fake_window)   # index 4
         heap.alloc(fake_location) # index 5
 
-        define_imports(linker, heap, fake_window, fake_location)
-
-        instance = linker.instantiate(store, mod)
-        result = instance.invoke("check", year, month, day, hour, minute)
-        result.to_s
+        imports = { "wbg" => build_imports(heap, fake_window, fake_location) }
+        instance = Wasm::Instance.new(mod, imports)
+        instance.invoke("check", year, month, day, hour, minute).to_s
       end
 
-      def self.define_imports(linker, heap, fake_window, fake_location) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        linker.func_new("wbg", "__wbindgen_object_drop_ref", [:i32], []) do |_caller, idx|
-          heap.drop(idx)
-        end
-
-        linker.func_new("wbg", "__wbg_instanceof_Window_acc97ff9f5d2c7b4", [:i32], [:i32]) do |_caller, _idx|
-          1
-        end
-
-        linker.func_new("wbg", "__wbg_location_8cc8ccf27e342c0a", [:i32], [:i32]) do |_caller, _idx|
-          heap.alloc(fake_location)
-        end
-
-        define_host_import(linker, heap)
-
-        linker.func_new("wbg", "__wbg_newnoargs_b5b063fc6c2f0376", [:i32, :i32], [:i32]) do |_caller, _ptr, _len|
-          heap.alloc(Object.new)
-        end
-
-        linker.func_new("wbg", "__wbg_call_97ae9d8645dc388b", [:i32, :i32], [:i32]) do |_caller, _func_idx, _this_idx|
-          heap.alloc(fake_window)
-        end
-
-        linker.func_new("wbg", "__wbindgen_object_clone_ref", [:i32], [:i32]) do |_caller, idx|
-          heap.alloc(heap.get(idx))
-        end
-
+      def self.build_imports(heap, fake_window, fake_location) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        w = {}
+        w["__wbindgen_object_drop_ref"] = ->(_c, idx) { heap.drop(idx); nil }
+        w["__wbg_instanceof_Window_acc97ff9f5d2c7b4"] = ->(_c, _idx) { 1 }
+        w["__wbg_location_8cc8ccf27e342c0a"] = ->(_c, _idx) { heap.alloc(fake_location) }
+        w["__wbg_newnoargs_b5b063fc6c2f0376"] = ->(_c, _ptr, _len) { heap.alloc(Object.new) }
+        w["__wbg_call_97ae9d8645dc388b"] = ->(_c, _f, _t) { heap.alloc(fake_window) }
+        w["__wbindgen_object_clone_ref"] = ->(_c, idx) { heap.alloc(heap.get(idx)) }
         %w[
           __wbg_self_6d479506f72c6a71
           __wbg_window_f2557cc78490aceb
           __wbg_globalThis_7f206bda628d5286
           __wbg_global_ba75c50d1cf384f4
-        ].each do |name|
-          linker.func_new("wbg", name, [], [:i32]) do |_caller|
-            heap.alloc(fake_window)
-          end
-        end
-
-        linker.func_new("wbg", "__wbindgen_is_undefined", [:i32], [:i32]) do |_caller, idx|
-          heap.get(idx) == :undefined ? 1 : 0
-        end
-
-        linker.func_new("wbg", "__wbindgen_debug_string", [:i32, :i32], []) do |_caller, _ret_ptr, _idx|
-          # no-op
-        end
-
-        linker.func_new("wbg", "__wbindgen_throw", [:i32, :i32], []) do |caller, ptr, len|
+        ].each { |name| w[name] = ->(_c) { heap.alloc(fake_window) } }
+        w["__wbindgen_is_undefined"] = ->(_c, idx) { heap.get(idx) == :undefined ? 1 : 0 }
+        w["__wbindgen_debug_string"] = ->(_c, _ret_ptr, _idx) { nil }
+        w["__wbindgen_throw"] = lambda do |caller, ptr, len|
           mem = caller.export("memory").to_memory
-          msg = mem.read(ptr, len)
-          raise msg
+          raise mem.read(ptr, len)
         end
-      end
-
-      # The host import writes the domain string into WASM memory.
-      # It allocates space via __wbindgen_malloc, copies the UTF-8 bytes,
-      # and writes (ptr, len) at the return pointer address.
-      def self.define_host_import(linker, _heap)
-        linker.func_new("wbg", "__wbg_host_f82dbbd8bb5ef24a", [:i32, :i32], []) do |caller, ret_ptr, _loc_idx|
+        w["__wbg_host_f82dbbd8bb5ef24a"] = lambda do |caller, ret_ptr, _loc_idx|
           mem = caller.export("memory").to_memory
-          malloc_fn = caller.export("__wbindgen_malloc").to_func
+          malloc = caller.export("__wbindgen_malloc").to_func
           host_bytes = DOMAIN.encode("utf-8")
-          ptr = malloc_fn.call(host_bytes.bytesize)
+          ptr = malloc.call(host_bytes.bytesize)
           mem.write(ptr, host_bytes)
           mem.write(ret_ptr, [ptr, host_bytes.bytesize].pack("V2"))
+          nil
         end
+        w
       end
 
       # Manages a slab-allocated heap of Ruby objects indexed by i32,
@@ -153,7 +99,7 @@ module Relaton
         end
       end
 
-      private_class_method :call_wasm, :define_imports, :define_host_import
+      private_class_method :call_wasm, :build_imports
     end
   end
 end

data/lib/relaton/un/version.rb

@@ -1,5 +1,5 @@
 module Relaton
   module Un
-    VERSION = "2.1.0".freeze
+    VERSION = "2.1.1".freeze
   end
 end

data/lib/relaton/un/wasm/decoder.rb

@@ -0,0 +1,434 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Un
+    module Wasm
+      # Binary WebAssembly decoder. Handles the subset of WASM MVP plus the
+      # sign-extension proposal that the shipped wasm_v_bg.wasm uses. No
+      # floats, no SIMD, no bulk-memory, no reference types beyond funcref.
+      class Decoder
+        MAGIC = "\x00asm".b
+        VERSION = "\x01\x00\x00\x00".b
+
+        VALTYPE_I32 = 0x7F
+        VALTYPE_I64 = 0x7E
+        VALTYPE_F32 = 0x7D
+        VALTYPE_F64 = 0x7C
+
+        def initialize(bytes)
+          @bytes = bytes.b
+          @pos = 0
+        end
+
+        def decode
+          header!
+          mod = Module.new
+          until eof?
+            id = read_byte
+            size = read_u32
+            section_end = @pos + size
+            decode_section(mod, id, section_end)
+            @pos = section_end
+          end
+          mod
+        end
+
+        private
+
+        def header!
+          magic = take(4)
+          raise DecodeError, "bad magic: #{magic.inspect}" unless magic == MAGIC
+
+          version = take(4)
+          raise DecodeError, "bad version: #{version.inspect}" unless version == VERSION
+        end
+
+        def decode_section(mod, id, section_end)
+          case id
+          when 0  then skip_to(section_end) # custom
+          when 1  then decode_types(mod)
+          when 2  then decode_imports(mod)
+          when 3  then decode_functions(mod)
+          when 4  then decode_tables(mod)
+          when 5  then decode_memories(mod)
+          when 6  then decode_globals(mod)
+          when 7  then decode_exports(mod)
+          when 8  then mod.instance_variable_set(:@start, read_u32)
+          when 9  then decode_elements(mod)
+          when 10 then decode_code(mod)
+          when 11 then decode_data(mod)
+          else raise DecodeError, "unknown section id #{id}"
+          end
+        end
+
+        def decode_types(mod)
+          read_vec do
+            tag = read_byte
+            raise DecodeError, "bad functype tag #{tag}" unless tag == 0x60
+
+            params = read_vec { read_byte }
+            results = read_vec { read_byte }
+            mod.types << FuncType.new(params, results)
+          end
+        end
+
+        def decode_imports(mod)
+          read_vec do
+            mod_name = read_name
+            field = read_name
+            kind_byte = read_byte
+            kind, desc = case kind_byte
+                        when 0x00 then [:func, read_u32]
+                        when 0x01 then [:table, decode_tabletype]
+                        when 0x02 then [:memory, decode_memtype]
+                        when 0x03 then [:global, [read_byte, read_byte == 1]]
+                        else raise DecodeError, "bad import kind #{kind_byte}"
+                        end
+            mod.imports << Import.new(mod_name, field, kind, desc)
+            mod.function_type_indices << desc if kind == :func
+          end
+        end
+
+        def decode_functions(mod)
+          read_vec do
+            mod.function_type_indices << read_u32
+          end
+        end
+
+        def decode_tables(mod)
+          read_vec do
+            mod.tables << decode_tabletype
+          end
+        end
+
+        def decode_memories(mod)
+          read_vec do
+            mod.memories << decode_memtype
+          end
+        end
+
+        def decode_globals(mod)
+          read_vec do
+            valtype = read_byte
+            mutable = read_byte == 1
+            init_expr = decode_const_expr
+            mod.globals << Global.new(valtype, mutable, init_expr)
+          end
+        end
+
+        def decode_exports(mod)
+          read_vec do
+            name = read_name
+            kind_byte = read_byte
+            kind = case kind_byte
+                  when 0x00 then :func
+                  when 0x01 then :table
+                  when 0x02 then :memory
+                  when 0x03 then :global
+                  else raise DecodeError, "bad export kind #{kind_byte}"
+                  end
+            mod.exports << Export.new(name, kind, read_u32)
+          end
+        end
+
+        def decode_elements(mod)
+          read_vec do
+            flags = read_u32
+            # MVP form: flags == 0 means active, table 0, offset, funcref vec.
+            raise DecodeError, "unsupported element segment flags #{flags}" unless flags.zero?
+
+            offset_expr = decode_const_expr
+            funcs = read_vec { read_u32 }
+            mod.elements << Element.new(0, offset_expr, funcs)
+          end
+        end
+
+        def decode_code(mod)
+          read_vec do
+            size = read_u32
+            body_end = @pos + size
+            local_groups = read_vec { [read_u32, read_byte] } # [count, valtype]
+            locals = local_groups.flat_map { |count, vt| Array.new(count, vt) }
+            body = decode_instructions(body_end)
+            mod.code << Code.new(locals, body)
+            @pos = body_end
+          end
+        end
+
+        def decode_data(mod)
+          read_vec do
+            flags = read_u32
+            mem_idx = 0
+            offset_expr = nil
+            case flags
+            when 0
+              offset_expr = decode_const_expr
+            when 1
+              # passive — not used here
+            when 2
+              mem_idx = read_u32
+              offset_expr = decode_const_expr
+            else
+              raise DecodeError, "bad data flags #{flags}"
+            end
+            bytes = take(read_u32)
+            mod.data << Data.new(mem_idx, offset_expr, bytes)
+          end
+        end
+
+        def decode_tabletype
+          elem_type = read_byte
+          decode_limits.then { |init, max| TableType.new(elem_type, init, max) }
+        end
+
+        def decode_memtype
+          decode_limits.then { |init, max| MemoryType.new(init, max) }
+        end
+
+        def decode_limits
+          flag = read_byte
+          init = read_u32
+          max = flag == 1 ? read_u32 : nil
+          [init, max]
+        end
+
+        # A constant init expression: a single instruction followed by `end`.
+        # For our module it'll only be i32.const / i64.const / global.get.
+        def decode_const_expr
+          op = read_byte
+          val = case op
+               when 0x41 then [:i32_const, read_s32]
+               when 0x42 then [:i64_const, read_s64]
+               when 0x23 then [:global_get, read_u32]
+               else raise DecodeError, "unsupported const expr op 0x#{op.to_s(16)}"
+               end
+          end_op = read_byte
+          raise DecodeError, "const expr not terminated with end (got 0x#{end_op.to_s(16)})" unless end_op == 0x0B
+
+          val
+        end
+
+        # Decode the instruction stream of a function body up to its final
+        # `end`. Returns a flat array of [op_sym, *operands]. Block-introducing
+        # ops are post-processed to carry `end_pc` (and `else_pc` for `if`)
+        # so the interpreter can jump without scanning at runtime.
+        def decode_instructions(body_end)
+          instrs = []
+          stack = [] # of [kind_sym, instr_index]
+
+          until @pos >= body_end
+            op = read_byte
+            pc = instrs.size
+            case op
+            when 0x00 then instrs << [:unreachable]
+            when 0x01 then instrs << [:nop]
+            when 0x02
+              bt = decode_blocktype
+              instrs << [:block, bt, nil] # end_pc filled in below
+              stack << [:block, pc]
+            when 0x03
+              bt = decode_blocktype
+              instrs << [:loop, bt, nil]
+              stack << [:loop, pc]
+            when 0x04
+              bt = decode_blocktype
+              instrs << [:if, bt, nil, nil] # else_pc, end_pc
+              stack << [:if, pc]
+            when 0x05
+              if_kind, if_pc = stack.last
+              raise DecodeError, "else without matching if" unless if_kind == :if
+
+              instrs[if_pc][2] = pc # else_pc points at the `else` instruction
+              instrs << [:else, nil]
+            when 0x0B
+              instrs << [:end]
+              if stack.any?
+                kind, intro_pc = stack.pop
+                case kind
+                when :block, :loop then instrs[intro_pc][2] = pc
+                when :if
+                  instrs[intro_pc][3] = pc # end_pc
+                  instrs[intro_pc][2] ||= pc # else_pc defaults to end_pc
+                  # if there was an `else`, fix it up
+                  else_pc = instrs[intro_pc][2]
+                  instrs[else_pc][1] = pc if else_pc < pc && instrs[else_pc][0] == :else
+                end
+              end
+            when 0x0C then instrs << [:br, read_u32]
+            when 0x0D then instrs << [:br_if, read_u32]
+            when 0x0E
+              labels = read_vec { read_u32 }
+              default = read_u32
+              instrs << [:br_table, labels, default]
+            when 0x0F then instrs << [:return_]
+            when 0x10 then instrs << [:call, read_u32]
+            when 0x11
+              type_idx = read_u32
+              table_idx = read_u32
+              instrs << [:call_indirect, type_idx, table_idx]
+            when 0x1A then instrs << [:drop]
+            when 0x1B then instrs << [:select]
+            when 0x20 then instrs << [:local_get, read_u32]
+            when 0x21 then instrs << [:local_set, read_u32]
+            when 0x22 then instrs << [:local_tee, read_u32]
+            when 0x23 then instrs << [:global_get, read_u32]
+            when 0x24 then instrs << [:global_set, read_u32]
+            when 0x28..0x3E
+              align = read_u32
+              offset = read_u32
+              instrs << [MEM_OPS[op], align, offset]
+            when 0x3F
+              read_byte # reserved
+              instrs << [:memory_size]
+            when 0x40
+              read_byte # reserved
+              instrs << [:memory_grow]
+            when 0x41 then instrs << [:i32_const, read_s32]
+            when 0x42 then instrs << [:i64_const, read_s64]
+            when 0x45..0x8A then instrs << [NUM_OPS.fetch(op)]
+            when 0xA7 then instrs << [:i32_wrap_i64]
+            when 0xAC then instrs << [:i64_extend_i32_s]
+            when 0xAD then instrs << [:i64_extend_i32_u]
+            when 0xC0 then instrs << [:i32_extend8_s]
+            when 0xC1 then instrs << [:i32_extend16_s]
+            when 0xC2 then instrs << [:i64_extend8_s]
+            when 0xC3 then instrs << [:i64_extend16_s]
+            when 0xC4 then instrs << [:i64_extend32_s]
+            else
+              raise DecodeError, "unsupported opcode 0x#{op.to_s(16)} at byte #{@pos - 1}"
+            end
+          end
+          instrs
+        end
+
+        # Block type: 0x40 = empty, single valtype byte, or signed LEB128 type
+        # index. Returns one of [:empty] / [:value, valtype] / [:typeidx, idx].
+        def decode_blocktype
+          b = peek_byte
+          if b == 0x40
+            read_byte
+            [:empty]
+          elsif [VALTYPE_I32, VALTYPE_I64, VALTYPE_F32, VALTYPE_F64].include?(b)
+            [:value, read_byte]
+          else
+            [:typeidx, read_s33]
+          end
+        end
+
+        MEM_OPS = {
+          0x28 => :i32_load,    0x29 => :i64_load,
+          0x2C => :i32_load8_s, 0x2D => :i32_load8_u,
+          0x2E => :i32_load16_s, 0x2F => :i32_load16_u,
+          0x30 => :i64_load8_s, 0x31 => :i64_load8_u,
+          0x32 => :i64_load16_s, 0x33 => :i64_load16_u,
+          0x34 => :i64_load32_s, 0x35 => :i64_load32_u,
+          0x36 => :i32_store,   0x37 => :i64_store,
+          0x3A => :i32_store8,  0x3B => :i32_store16,
+          0x3C => :i64_store8,  0x3D => :i64_store16,
+          0x3E => :i64_store32
+        }.freeze
+
+        NUM_OPS = {
+          0x45 => :i32_eqz, 0x46 => :i32_eq, 0x47 => :i32_ne,
+          0x48 => :i32_lt_s, 0x49 => :i32_lt_u, 0x4A => :i32_gt_s, 0x4B => :i32_gt_u,
+          0x4C => :i32_le_s, 0x4D => :i32_le_u, 0x4E => :i32_ge_s, 0x4F => :i32_ge_u,
+          0x50 => :i64_eqz, 0x51 => :i64_eq, 0x52 => :i64_ne,
+          0x53 => :i64_lt_s, 0x54 => :i64_lt_u, 0x55 => :i64_gt_s, 0x56 => :i64_gt_u,
+          0x57 => :i64_le_s, 0x58 => :i64_le_u, 0x59 => :i64_ge_s, 0x5A => :i64_ge_u,
+          0x67 => :i32_clz, 0x68 => :i32_ctz, 0x69 => :i32_popcnt,
+          0x6A => :i32_add, 0x6B => :i32_sub, 0x6C => :i32_mul,
+          0x6D => :i32_div_s, 0x6E => :i32_div_u, 0x6F => :i32_rem_s, 0x70 => :i32_rem_u,
+          0x71 => :i32_and, 0x72 => :i32_or, 0x73 => :i32_xor,
+          0x74 => :i32_shl, 0x75 => :i32_shr_s, 0x76 => :i32_shr_u,
+          0x77 => :i32_rotl, 0x78 => :i32_rotr,
+          0x79 => :i64_clz, 0x7A => :i64_ctz, 0x7B => :i64_popcnt,
+          0x7C => :i64_add, 0x7D => :i64_sub, 0x7E => :i64_mul,
+          0x7F => :i64_div_s, 0x80 => :i64_div_u, 0x81 => :i64_rem_s, 0x82 => :i64_rem_u,
+          0x83 => :i64_and, 0x84 => :i64_or, 0x85 => :i64_xor,
+          0x86 => :i64_shl, 0x87 => :i64_shr_s, 0x88 => :i64_shr_u,
+          0x89 => :i64_rotl, 0x8A => :i64_rotr
+        }.freeze
+
+        # ---- low-level reading -----------------------------------------------
+
+        def eof?
+          @pos >= @bytes.bytesize
+        end
+
+        def read_byte
+          b = @bytes.getbyte(@pos)
+          raise DecodeError, "unexpected eof" unless b
+
+          @pos += 1
+          b
+        end
+
+        def peek_byte
+          @bytes.getbyte(@pos) or raise(DecodeError, "unexpected eof")
+        end
+
+        def take(n)
+          s = @bytes.byteslice(@pos, n)
+          raise DecodeError, "unexpected eof (wanted #{n} bytes)" unless s && s.bytesize == n
+
+          @pos += n
+          s
+        end
+
+        def skip_to(end_pos)
+          @pos = end_pos
+        end
+
+        def read_u32
+          result = 0
+          shift = 0
+          loop do
+            b = read_byte
+            result |= (b & 0x7F) << shift
+            break if (b & 0x80).zero?
+
+            shift += 7
+            raise DecodeError, "u32 overflow" if shift > 35
+          end
+          result
+        end
+
+        def read_s32
+          read_signed(32)
+        end
+
+        def read_s33
+          read_signed(33)
+        end
+
+        def read_s64
+          read_signed(64)
+        end
+
+        def read_signed(bits)
+          result = 0
+          shift = 0
+          loop do
+            b = read_byte
+            result |= (b & 0x7F) << shift
+            shift += 7
+            if (b & 0x80).zero?
+              result -= (1 << shift) if shift < bits && (b & 0x40).positive?
+              return result
+            end
+            raise DecodeError, "signed overflow" if shift > bits + 7
+          end
+        end
+
+        def read_name
+          take(read_u32).force_encoding(Encoding::UTF_8)
+        end
+
+        def read_vec
+          count = read_u32
+          Array.new(count) { yield }
+        end
+      end
+    end
+  end
+end