konpeito 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18af8ec6ef271ba48955db2f05fc19b70529a318494bced5fe4e2a83febc3544
-  data.tar.gz: 076eb7d785e5bff312c1ec5b8c093c6fc1db034eabe397d5cc1d32d57438e332
+  metadata.gz: 453b0bb32e4ef66b8b6020d262200e070caf01fb483cff4a0ebd6ceba46495b3
+  data.tar.gz: 7b38fb2807e1649150a0febae5defcb8f964967a715770db1de857d6409f88b3
 SHA512:
-  metadata.gz: 30fe2f9fc64bd7c4d4cff705e8a3e46bef719e947efb6d81418ba51e54ccaad89f5cc6e145fb28a5d84960c864abcc4a284cf2868e81da2b161102619cbaae08
-  data.tar.gz: 7653068f209f65ae14e1258b0cf17c5b9b3f956a2af006d3af87375eeebc7dcaf694f8384184c8b84e98fedb3485b32ce9374d6cd148ced09bda7e6dbcc228d8
+  metadata.gz: afa5fd10db773c8e1bb3c399a39cf140b1c7577271420750368551ee80cab864683d9455860ddba185b0d53cc221df42b5beb3a7334fbc67b56747e4a7bd6e0f
+  data.tar.gz: 7fbe956b09d489f9af313c0fa6600f81960cb02cb72d95f912a4d50d9f658b4b7bff35528d43b73c223d011d0aa5c35f6c63bf09ce5f1873c14605cd7274395e

data/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to Konpeito will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.5.0] - 2026-03-10
+
+### Added
+- **Clay UI layout stdlib**: Flexbox-style UI layout library for the mruby backend. `module Clay` auto-detected like raylib — 40+ `%a{cfunc}` bindings covering lifecycle, element construction, text, borders, scrolling, floating elements, and bulk rendering via the official raylib renderer. Vendored Clay v0.14 under `vendor/clay/`.
+- **Clay UI demo**: `examples/mruby_clay_ui/clay_demo.rb` — sidebar + main content layout with TTF fonts
+- **Memory Match game**: `examples/mruby_clay_ui/memory_game.rb` — card matching game using Clay layout system with module NativeArray game state
+- **Module NativeArray**: fixed-size global arrays shared across functions via RBS module instance variables (`@field: NativeArray[T, N]`). Compiles to LLVM global arrays — no C wrapper file needed. Available on LLVM (CRuby) and mruby backends.
+- **Inline RBS module blocks**: `# @rbs module Foo ... # @rbs end` comment blocks are now extracted by the preprocessor and emitted as raw RBS, enabling module NativeArray declarations without separate `.rbs` files or empty `module Foo; end` stubs.
+- **Space Invaders example rewrite**: `examples/mruby_space_invaders/` rewritten to use module NativeArray with inline RBS — single `.rb` file, no C wrapper or separate `.rbs` needed
+- **Third-party license file**: `THIRD_PARTY_LICENSES.md` summarizing vendored library licenses (yyjson, Clay)
+
+### Fixed
+- **NativeArray GEP stride**: fix `gep` → `gep2` for all NativeArray element access (14 call sites). With LLVM opaque pointers, `gep` used array type as stride instead of element type, causing memory corruption and SIGSEGV crashes.
+
 ## [0.4.2] - 2026-03-10
 
 ### Fixed

data/THIRD_PARTY_LICENSES.md

@@ -0,0 +1,26 @@
+# Third-Party Licenses
+
+Konpeito vendors the following third-party libraries. Each library's license
+file is kept alongside its source under `vendor/`.
+
+---
+
+## yyjson
+
+- **Location:** `vendor/yyjson/`
+- **License:** MIT
+- **Copyright:** (c) 2020 YaoYuan
+- **URL:** https://github.com/ibireme/yyjson
+
+See `vendor/yyjson/LICENSE` for the full license text.
+
+---
+
+## Clay
+
+- **Location:** `vendor/clay/`
+- **License:** zlib/libpng
+- **Copyright:** (c) 2024 Nic Barker
+- **URL:** https://github.com/nicbarker/clay
+
+See `vendor/clay/LICENSE` for the full license text.

data/lib/konpeito/codegen/cruby_backend.rb

@@ -996,6 +996,13 @@ module Konpeito
           flags.concat(yyjson_objs)
         end
 
+        # Add clay object files if Clay stdlib is used
+        clay_used = @rbs_loader&.cfunc_methods&.any? { |k, _| k.start_with?("Clay.") }
+        if clay_used
+          clay_objs = ensure_clay_compiled
+          flags.concat(clay_objs)
+        end
+
         if @rbs_loader
           stdlib_ui_dir = File.expand_path("../stdlib/ui", __dir__)
 
@@ -1051,6 +1058,25 @@ module Konpeito
         [yyjson_obj, wrapper_obj]
       end
 
+      # Compile vendored clay.h implementation if Clay stdlib is used
+      # Returns array of object file paths
+      def ensure_clay_compiled
+        clay_dir = File.expand_path("../../../vendor/clay", __dir__)
+        clay_impl_c = File.join(clay_dir, "clay_impl.c")
+        clay_impl_obj = File.join(clay_dir, "clay_impl.o")
+
+        return [] unless File.exist?(clay_impl_c)
+
+        cc = find_llvm_tool("clang") || "cc"
+
+        unless File.exist?(clay_impl_obj) && File.mtime(clay_impl_obj) > File.mtime(clay_impl_c)
+          cmd = [cc, "-c", "-O2", "-fPIC", "-o", clay_impl_obj, clay_impl_c]
+          system(*cmd) or return []
+        end
+
+        [clay_impl_obj]
+      end
+
       def ruby_link_flags
         # Get Ruby's linker flags for extensions
         [

data/lib/konpeito/codegen/inliner.rb

@@ -532,6 +532,16 @@ module Konpeito
           new_array = transform_value(inst.array, prefix, param_map)
           HIR::MultiWriteExtract.new(array: new_array, index: inst.index, type: inst.type, result_var: new_result)
 
+        when HIR::ModuleNativeArrayRef
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::ModuleNativeArrayRef.new(
+            module_name: inst.module_name,
+            field_name: inst.field_name,
+            element_type: inst.element_type,
+            size: inst.size,
+            result_var: new_result
+          )
+
         else
           # For other instructions, just return as-is with renamed result
           inst

data/lib/konpeito/codegen/llvm_generator.rb

@@ -100,6 +100,9 @@ module Konpeito
         # Scan HIR to register NativeClassTypes before code generation
         scan_for_native_class_types(hir_program)
 
+        # Declare LLVM globals for module-level NativeArray fields
+        declare_module_native_arrays(hir_program)
+
         # Pre-scan: detect parameters that can receive nil at call sites
         @nil_possible_params = scan_nil_possible_params(hir_program)
 
@@ -2182,6 +2185,8 @@ module Konpeito
           generate_sized_queue_push(inst)
         when HIR::SizedQueuePop
           generate_sized_queue_pop(inst)
+        when HIR::ModuleNativeArrayRef
+          generate_module_native_array_ref(inst)
         when HIR::NativeArrayAlloc
           generate_native_array_alloc(inst)
         when HIR::NativeArrayGet
@@ -9841,8 +9846,8 @@ module Konpeito
         # Normalize negative indices
         index_i64 = normalize_native_index(index_i64, inst.receiver)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         # Load element
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
@@ -9872,8 +9877,9 @@ module Konpeito
         target_type = element_type == :Int64 ? :i64 : :double
         converted_value = convert_value(store_value, value_type, target_type)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        llvm_elem_type = native_array_element_llvm_type(element_type)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         # Store element
         @builder.store(converted_value, elem_ptr)
@@ -9893,46 +9899,19 @@ module Konpeito
         len_value = @variables["#{receiver_var}_len"]
         return index_i64 unless len_value
 
-        func = @builder.insert_block.parent
+        # Use branchless select instead of conditional branches to avoid
+        # creating new basic blocks that break surrounding PHI node predecessors.
         is_negative = @builder.icmp(:slt, index_i64, LLVM::Int64.from_i(0))
-
-        neg_bb = func.basic_blocks.append("idx_neg")
-        pos_bb = func.basic_blocks.append("idx_pos")
-        merge_bb = func.basic_blocks.append("idx_merge")
-
-        @builder.cond(is_negative, neg_bb, pos_bb)
-
-        @builder.position_at_end(neg_bb)
         normalized = @builder.add(len_value, index_i64, "neg_idx")
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(pos_bb)
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(merge_bb)
-        @builder.phi(LLVM::Int64, { neg_bb => normalized, pos_bb => index_i64 })
+        @builder.select(is_negative, normalized, index_i64, "norm_idx")
       end
 
       # Normalize negative index for StaticArray (compile-time known size)
       def normalize_static_index(index_i64, size)
-        func = @builder.insert_block.parent
+        # Use branchless select to avoid creating new basic blocks
         is_negative = @builder.icmp(:slt, index_i64, LLVM::Int64.from_i(0))
-
-        neg_bb = func.basic_blocks.append("sidx_neg")
-        pos_bb = func.basic_blocks.append("sidx_pos")
-        merge_bb = func.basic_blocks.append("sidx_merge")
-
-        @builder.cond(is_negative, neg_bb, pos_bb)
-
-        @builder.position_at_end(neg_bb)
         normalized = @builder.add(LLVM::Int64.from_i(size), index_i64, "neg_sidx")
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(pos_bb)
-        @builder.br(merge_bb)
-
-        @builder.position_at_end(merge_bb)
-        @builder.phi(LLVM::Int64, { neg_bb => normalized, pos_bb => index_i64 })
+        @builder.select(is_negative, normalized, index_i64, "norm_sidx")
       end
 
       # Generate NativeArray length access: arr.length
@@ -9990,7 +9969,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Get element via GEP + load (no rb_ary_entry!)
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter (unboxed!)
@@ -10040,7 +10019,7 @@ module Konpeito
           convert_value(val, val_type, type_tag)
         else
           # Use first element as initial, start from index 1
-          elem_ptr = @builder.gep(array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
+          elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
           @builder.load2(llvm_elem_type, elem_ptr, "first_elem")
         end
 
@@ -10072,7 +10051,7 @@ module Konpeito
 
         # Load accumulator and element (both unboxed)
         acc_value = @builder.load2(llvm_elem_type, acc_alloca, "acc")
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameters
@@ -10172,7 +10151,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element (unboxed)
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter
@@ -10255,7 +10234,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element (unboxed)
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter
@@ -10353,7 +10332,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element and store to alloca for later use
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
         @builder.store(elem_value, elem_alloca)
 
@@ -10445,7 +10424,7 @@ module Konpeito
         @builder.position_at_end(loop_body)
 
         # Load element
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Set up block parameter
@@ -10553,7 +10532,7 @@ module Konpeito
 
         # Load accumulator and element
         acc_value = @builder.load2(llvm_elem_type, acc_alloca, "acc")
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Add (unboxed)
@@ -10614,7 +10593,7 @@ module Konpeito
         # Non-empty: initialize with first element
         @builder.position_at_end(non_empty_block)
         result_alloca = @builder.alloca(llvm_elem_type, "na_minmax_result")
-        first_ptr = @builder.gep(array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
+        first_ptr = @builder.gep2(llvm_elem_type, array_ptr, [LLVM::Int64.from_i(0)], "first_ptr")
         first_elem = @builder.load2(llvm_elem_type, first_ptr, "first")
         @builder.store(first_elem, result_alloca)
 
@@ -10634,7 +10613,7 @@ module Konpeito
 
         # Load current result and element
         current_result = @builder.load2(llvm_elem_type, result_alloca, "current")
-        elem_ptr = @builder.gep(array_ptr, [current_idx], "elem_ptr")
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [current_idx], "elem_ptr")
         elem_value = @builder.load2(llvm_elem_type, elem_ptr, "elem")
 
         # Compare and select
@@ -10704,11 +10683,16 @@ module Konpeito
       # Get the array pointer from a receiver HIR value
       def get_native_array_ptr(receiver)
         case receiver
+        when HIR::LoadLocal
+          # LoadLocal may have result_var=nil (e.g., from inliner transform_value).
+          # Use the variable name to look up the array pointer.
+          @variables[receiver.var.name] || (receiver.result_var && @variables[receiver.result_var]) ||
+            raise("NativeArray LoadLocal var '#{receiver.var.name}' not in @variables")
         when HIR::Instruction
           if receiver.result_var
             @variables[receiver.result_var]
           else
-            raise "NativeArray receiver has no result_var"
+            raise "NativeArray receiver has no result_var: #{receiver.class}"
           end
         when String
           @variables[receiver]
@@ -10720,6 +10704,8 @@ module Konpeito
       # Get the variable name from a receiver for length lookup
       def get_receiver_var_name(receiver)
         case receiver
+        when HIR::LoadLocal
+          receiver.var.name
         when HIR::Instruction
           receiver.result_var
         when String
@@ -10729,6 +10715,62 @@ module Konpeito
         end
       end
 
+      # ========================================
+      # Module-level NativeArray (LLVM global variables)
+      # ========================================
+
+      # Declare LLVM global arrays for all modules with NativeArray fields
+      def declare_module_native_arrays(hir)
+        @module_native_arrays ||= {}
+
+        hir.modules.each do |module_def|
+          next unless module_def.native_array_fields&.any?
+
+          module_def.native_array_fields.each do |field_name, info|
+            elem_type = info[:element_type]
+            size = info[:size]
+            llvm_elem_type = elem_type == :Int64 ? LLVM::Int64 : LLVM::Double
+
+            global_name = "konpeito_#{module_def.name}_#{field_name}"
+            array_type = LLVM::Type.array(llvm_elem_type, size)
+
+            global = @mod.globals.add(array_type, global_name)
+            global.initializer = LLVM::Constant.null(array_type)
+            global.linkage = :internal
+
+            @module_native_arrays["#{module_def.name}_#{field_name}"] = {
+              global: global,
+              element_type: elem_type,
+              size: size,
+              llvm_elem_type: llvm_elem_type,
+              array_type: array_type
+            }
+          end
+        end
+      end
+
+      # Generate a reference to a module-level NativeArray global
+      def generate_module_native_array_ref(inst)
+        key = "#{inst.module_name}_#{inst.field_name}"
+        info = @module_native_arrays[key]
+        raise "Unknown module NativeArray: #{key}" unless info
+
+        # GEP to get pointer to first element of global array
+        array_ptr = @builder.gep2(
+          info[:array_type], info[:global],
+          [LLVM::Int64.from_i(0), LLVM::Int64.from_i(0)],
+          "#{inst.field_name}_ptr"
+        )
+
+        if inst.result_var
+          @variables[inst.result_var] = array_ptr
+          @variable_types[inst.result_var] = :native_array
+          @variables["#{inst.result_var}_len"] = LLVM::Int64.from_i(inst.size)
+        end
+
+        array_ptr
+      end
+
       # Allocate a NativeArray on the stack
       # Returns a pointer to contiguous memory + stores length
       def generate_native_array_alloc(inst)
@@ -10778,8 +10820,8 @@ module Konpeito
         index_value, index_type = get_value_with_type(inst.index)
         index_i64 = index_type == :i64 ? index_value : @builder.call(@rb_num2long, index_value)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         if native_array_has_class_element?(element_type)
           # For NativeClass elements, return pointer to struct (for field access)
@@ -10820,8 +10862,9 @@ module Konpeito
         target_type = element_type == :Int64 ? :i64 : :double
         converted_value = convert_value(store_value, value_type, target_type)
 
-        # GEP to get element pointer
-        elem_ptr = @builder.gep(array_ptr, [index_i64], "elem_ptr")
+        # GEP to get element pointer (use gep2 with element type for correct stride)
+        llvm_elem_type = native_array_element_llvm_type(element_type)
+        elem_ptr = @builder.gep2(llvm_elem_type, array_ptr, [index_i64], "elem_ptr")
 
         # Store element
         @builder.store(converted_value, elem_ptr)
@@ -12919,8 +12962,8 @@ module Konpeito
         # Get JSON element at index
         elem_val = @builder.call(@yyjson_arr_get, root, idx, "json_elem")
 
-        # Get pointer to NativeClass struct in the array
-        struct_ptr = @builder.gep(array_ptr, [idx], "elem_struct_ptr")
+        # Get pointer to NativeClass struct in the array (use gep2 for correct stride)
+        struct_ptr = @builder.gep2(llvm_elem_type, array_ptr, [idx], "elem_struct_ptr")
 
         # Parse fields from JSON object into struct
         fields = element_class.fields

data/lib/konpeito/codegen/mruby_backend.rb

@@ -58,6 +58,10 @@ module Konpeito
             extra_obj_files << extra_obj
           end
 
+          # Compile vendored Clay library if used
+          clay_objs = ensure_clay_compiled
+          extra_obj_files.concat(clay_objs)
+
           obj_files = [obj_file, init_obj_file, helpers_obj_file] + extra_obj_files
 
           # Link into standalone executable
@@ -901,6 +905,34 @@ module Konpeito
           )
         end
 
+        # Include Clay if used
+        clay_used = @extra_c_files.any? { |f| File.basename(f).include?("clay") }
+        if clay_used
+          sections << license_section(
+            "Clay",
+            "zlib/libpng",
+            "Copyright (c) 2024 Nic Barker",
+            "https://github.com/nicbarker/clay",
+            <<~ZLIB
+              This software is provided 'as-is', without any express or implied warranty.
+              In no event will the authors be held liable for any damages arising from the
+              use of this software.
+
+              Permission is granted to anyone to use this software for any purpose,
+              including commercial applications, and to alter it and redistribute it freely,
+              subject to the following restrictions:
+
+              1. The origin of this software must not be misrepresented; you must not claim
+                 that you wrote the original software. If you use this software in a product,
+                 an acknowledgment in the product documentation would be appreciated but is
+                 not required.
+              2. Altered source versions must be plainly marked as such, and must not be
+                 misrepresented as being the original software.
+              3. This notice may not be removed or altered from any source distribution.
+            ZLIB
+          )
+        end
+
         # Include raylib if linked
         ffi_libs = @rbs_loader&.all_ffi_libraries || []
         if ffi_libs.any? { |lib| lib.to_s.include?("raylib") }
@@ -1160,8 +1192,41 @@ module Konpeito
         end
       end
 
+      # Compile vendored clay.h implementation if Clay stdlib is used
+      # Returns array of object file paths
+      def ensure_clay_compiled
+        clay_used = @extra_c_files.any? { |f| File.basename(f).include?("clay") }
+        return [] unless clay_used
+
+        clay_dir = File.expand_path("../../../vendor/clay", __dir__)
+        clay_impl_c = File.join(clay_dir, "clay_impl.c")
+        clay_impl_obj = File.join(clay_dir, "clay_impl.o")
+
+        return [] unless File.exist?(clay_impl_c)
+
+        cc, cc_flags = cross_cc_with_flags
+        cflags = cross_compiling? ? Platform.cross_mruby_cflags(@cross_mruby_dir) : (Platform.mruby_cflags rescue "-O2")
+
+        # Compile clay_impl.c (only if stale)
+        unless File.exist?(clay_impl_obj) && File.mtime(clay_impl_obj) > File.mtime(clay_impl_c)
+          cmd = [*cc, "-c", "-O2"]
+          cmd.concat(cc_flags)
+          cmd += ["-o", clay_impl_obj, clay_impl_c]
+          system(*cmd) or return []
+        end
+
+        [clay_impl_obj]
+      end
+
       def ffi_include_flags
         flags = []
+
+        # Always add vendored Clay include path if Clay stdlib is used
+        clay_dir = File.expand_path("../../../vendor/clay", __dir__)
+        if @extra_c_files.any? { |f| File.basename(f).include?("clay") } && Dir.exist?(clay_dir)
+          flags << "-I#{clay_dir}"
+        end
+
         if cross_compiling?
           # When cross-compiling, use cross library include paths
           flags << "-I#{@cross_libs_dir}/../include" if @cross_libs_dir && Dir.exist?("#{@cross_libs_dir}/../include")

data/lib/konpeito/compiler.rb

@@ -652,7 +652,8 @@ module Konpeito
 
     # Map of stdlib modules: module name pattern => stdlib directory name
     STDLIB_MODULE_MAP = {
-      "Raylib" => "raylib"
+      "Raylib" => "raylib",
+      "Clay" => "clay"
     }.freeze
 
     # Scan AST for known stdlib module references and auto-add their RBS paths
@@ -694,6 +695,7 @@ module Konpeito
     end
 
     # Auto-include stdlib C files based on FFI libraries detected by RBS loader
+    # and vendored stdlibs detected by module reference
     def inject_stdlib_c_files(extra_c_files)
       return extra_c_files unless @rbs_loader
 
@@ -716,6 +718,21 @@ module Konpeito
         end
       end
 
+      # Also include vendored stdlib C files detected by module reference
+      # (for stdlibs without %a{ffi} that use vendored C libraries)
+      @rbs_paths.each do |rbs_path|
+        STDLIB_MODULE_MAP.each_value do |stdlib_name|
+          stdlib_rbs = File.expand_path("stdlib/#{stdlib_name}/#{stdlib_name}.rbs", __dir__)
+          next unless rbs_path == stdlib_rbs
+
+          stdlib_c = File.expand_path("stdlib/#{stdlib_name}/#{stdlib_name}_native.c", __dir__)
+          if File.exist?(stdlib_c) && !extra_c_files.include?(stdlib_c)
+            extra_c_files << stdlib_c
+            log "Auto-including stdlib C wrapper: #{stdlib_name}" if verbose
+          end
+        end
+      end
+
       extra_c_files
     end
   end

data/lib/konpeito/hir/builder.rb

@@ -43,11 +43,34 @@ module Konpeito
 
       def build(typed_ast)
         visit(typed_ast)
+        ensure_module_native_array_defs
         @program
       end
 
       private
 
+      # Ensure ModuleDefs exist for all modules with NativeArray fields from RBS.
+      # When using inline RBS (rbs_inline), the Ruby source may not contain
+      # `module Foo; end`, so visit_module is never called and no ModuleDef
+      # is created. This method fills in the missing ModuleDefs.
+      def ensure_module_native_array_defs
+        return unless @rbs_loader
+
+        @rbs_loader.each_native_module do |module_name, mod_type|
+          next unless mod_type.native_array_fields&.any?
+          next if @program.modules.any? { |m| m.name == module_name.to_s }
+
+          module_def = ModuleDef.new(
+            name: module_name.to_s,
+            methods: [],
+            singleton_methods: [],
+            constants: {}
+          )
+          module_def.native_array_fields = mod_type.native_array_fields
+          @program.modules << module_def
+        end
+      end
+
       def visit(typed_node)
         return nil unless typed_node
 
@@ -884,6 +907,13 @@ module Konpeito
 
         @current_module = old_module
 
+        # Get NativeArray fields from RBS if available
+        mod_native_array_fields = {}
+        if @rbs_loader
+          mod_type = @rbs_loader.native_module_type(name)
+          mod_native_array_fields = mod_type.native_array_fields if mod_type
+        end
+
         # Merge into existing ModuleDef if this module was already opened (multi-file projects)
         existing_module_def = @program.modules.find { |m| m.name == name }
         if existing_module_def
@@ -892,6 +922,7 @@ module Konpeito
           existing_module_def.module_function_methods.concat(module_function_method_names)
           existing_module_def.private_methods.merge(module_private_method_names)
           existing_module_def.constants.merge!(module_constants)
+          existing_module_def.native_array_fields.merge!(mod_native_array_fields)
         else
           module_def = ModuleDef.new(
             name: name,
@@ -901,6 +932,7 @@ module Konpeito
           )
           module_def.module_function_methods.concat(module_function_method_names)
           module_def.private_methods.merge(module_private_method_names)
+          module_def.native_array_fields = mod_native_array_fields
           @program.modules << module_def
         end
         NilLit.new
@@ -1798,6 +1830,11 @@ module Konpeito
       def visit_call(typed_node)
         node = typed_node.node
 
+        # Check for module-level NativeArray field access (e.g., Inv.gs)
+        if (mod_arr_info = module_native_array_access?(typed_node))
+          return visit_module_native_array_ref(mod_arr_info)
+        end
+
         # Check for NativeArray.new(size) pattern
         if native_array_new_call?(typed_node)
           return visit_native_array_new(typed_node)
@@ -2366,6 +2403,40 @@ module Konpeito
         receiver_child.node.name.to_s == "NativeArray"
       end
 
+      # Check if this is a module-level NativeArray field access (e.g., Inv.gs)
+      # Returns field info hash or nil
+      def module_native_array_access?(typed_node)
+        return nil unless @rbs_loader
+
+        # Receiver must be a constant read (e.g., Inv)
+        receiver_child = typed_node.children.first
+        return nil unless receiver_child&.node_type == :constant_read
+
+        module_name = receiver_child.node.name.to_s
+        mod_type = @rbs_loader.native_module_type(module_name)
+        return nil unless mod_type
+
+        field_name = typed_node.node.name.to_s.to_sym
+        field_info = mod_type.lookup_native_array_field(field_name)
+        return nil unless field_info
+
+        { module_name: module_name, field_name: field_name, **field_info }
+      end
+
+      # Emit a ModuleNativeArrayRef for module-level NativeArray access
+      def visit_module_native_array_ref(info)
+        result_var = new_temp_var
+        inst = ModuleNativeArrayRef.new(
+          module_name: info[:module_name],
+          field_name: info[:field_name],
+          element_type: info[:element_type],
+          size: info[:size],
+          result_var: result_var
+        )
+        emit(inst)
+        inst
+      end
+
       # Check if this is a NativeArray element access: arr[i] where arr is NativeArray[NativeClass]
       def native_array_element_access?(typed_node)
         method_name = typed_node.node.name.to_s