konpeito 0.4.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18af8ec6ef271ba48955db2f05fc19b70529a318494bced5fe4e2a83febc3544
-  data.tar.gz: 076eb7d785e5bff312c1ec5b8c093c6fc1db034eabe397d5cc1d32d57438e332
+  metadata.gz: c6e49cc678968c9afbf41e3483ce19ac9d0f506bf18b31def5de3468fdef18b3
+  data.tar.gz: f6f85c8b6d646c56ace6b35338ea66adeabc53eec3a21b50b0953346145b0d59
 SHA512:
-  metadata.gz: 30fe2f9fc64bd7c4d4cff705e8a3e46bef719e947efb6d81418ba51e54ccaad89f5cc6e145fb28a5d84960c864abcc4a284cf2868e81da2b161102619cbaae08
-  data.tar.gz: 7653068f209f65ae14e1258b0cf17c5b9b3f956a2af006d3af87375eeebc7dcaf694f8384184c8b84e98fedb3485b32ce9374d6cd148ced09bda7e6dbcc228d8
+  metadata.gz: cc766128892195b93c5acf173b7a84c3ee86415932b9d477a952a824cb9167b15c7e63b74ab894dcd7e8213e731b5c6b2dfd1f2ef829c2e380583d7e85f1536b
+  data.tar.gz: 692f32eee6feb583b24b7f468fbd659c784f01c41ecde853272966c13bdda0032c47e8d55d0d0f0d084dd9493f0df50d9f0f483245f7d9f1a8ef98f43bbb6c70

data/CHANGELOG.md

@@ -5,6 +5,45 @@ 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.6.0] - 2026-03-11
+
+### Added
+- **Raylib stdlib expansion**: 119 new cfunc bindings (87 → 206 total) for 2D RPG/SLG game development
+  - Texture/Sprite management (10): load, unload, draw, draw_rec, draw_pro, draw_scaled, dimensions, validity check
+  - Audio — Sound (10): load, unload, play, stop, pause, resume, playing?, volume, pitch
+  - Audio — Music (13): load, unload, play, stop, pause, resume, update, playing?, volume, pitch, time_length, time_played, seek
+  - Audio — Device (4): init, close, ready?, master volume
+  - Camera2D (4): begin/end mode, world-to-screen coordinate conversion (x/y)
+  - File I/O (4): save/load text files, file/directory existence checks
+  - Font management (6): load, load_ex, unload, draw_text_ex, measure_text_ex (x/y)
+  - Gamepad input (7 + 21 constants): button pressed/down/released/up, axis movement/count, D-pad/face/trigger/middle button and axis constants
+  - Extended shapes (5): draw_rectangle_pro, draw_rectangle_rounded, gradient v/h, circle sector
+  - Collision detection (5): recs, circles, circle-rec, point-rec, point-circle
+  - ID table pattern for resource management: textures (256), sounds (128), music (32), fonts (32)
+- **RPG tilemap demo**: `examples/mruby_rpg_demo/rpg_demo.rb` — 40×40 tilemap, smooth camera scrolling, 4-direction player movement with animation, sign interaction, HUD with step counter
+- macOS audio framework linker flags (CoreAudio, AudioToolbox, CoreFoundation)
+
+### Fixed
+- **Inliner CFuncCall bug**: `clone_and_rename()` now handles `CFuncCall`, `ExternConstructorCall`, and `ExternMethodCall` — parameters are correctly remapped when user functions calling `@cfunc` are inlined (previously fell through to default case, returning instructions with unmapped parameters)
+- **CI lint**: use anonymous block forwarding (`&`) in `rbs_loader.rb`
+- **CI test isolation**: use unique symbol names in `module_native_array_test` to avoid ELF symbol interposition on Linux
+
+## [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,50 @@ 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
+          )
+
+        when HIR::CFuncCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::CFuncCall.new(
+            c_func_name: inst.c_func_name,
+            args: new_args,
+            cfunc_type: inst.cfunc_type,
+            result_var: new_result
+          )
+
+        when HIR::ExternConstructorCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::ExternConstructorCall.new(
+            extern_type: inst.extern_type,
+            c_func_name: inst.c_func_name,
+            args: new_args,
+            method_sig: inst.method_sig,
+            result_var: new_result
+          )
+
+        when HIR::ExternMethodCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_receiver = transform_value(inst.receiver, prefix, param_map)
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::ExternMethodCall.new(
+            receiver: new_receiver,
+            c_func_name: inst.c_func_name,
+            args: new_args,
+            extern_type: inst.extern_type,
+            method_sig: inst.method_sig,
+            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") }
@@ -1139,7 +1171,9 @@ module Konpeito
         # Known framework dependencies for popular libraries
         case lib_name
         when "raylib"
-          ["-framework", "IOKit", "-framework", "Cocoa", "-framework", "OpenGL"]
+          ["-framework", "IOKit", "-framework", "Cocoa", "-framework", "OpenGL",
+           "-framework", "CoreAudio", "-framework", "AudioToolbox",
+           "-framework", "CoreFoundation"]
         when "SDL2", "sdl2"
           ["-framework", "IOKit", "-framework", "Cocoa", "-framework", "Carbon",
            "-framework", "CoreAudio", "-framework", "AudioToolbox",
@@ -1160,8 +1194,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