konpeito 0.7.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34d8bfa7eaccc6ae3cb5352a188346ed97f98b7b12940512292899bdfba280ef
-  data.tar.gz: a2298a81832fdd48c77153575d9a41d719e7ac29a3d0ae96800cb70e99be6893
+  metadata.gz: d513cebc5d3b0574c814b92901fbe2f4154e4ffc905da31c095abf9375bcaf34
+  data.tar.gz: 8becb035b3dc4e7aa9f2cb482fa658fcf4551ceeb734fba5c7727eb87e06babd
 SHA512:
-  metadata.gz: 7c97974f67c32006787858ad2c2b3fd1a8c70c5dbd97a37d115f14d062773435bf3737352e9d456a2a9f28a28b969b0008aa472861cee46feaf18044f30c6b36
-  data.tar.gz: 24bf6571db1ca03fd46ebefe7dfc02fbf86f04a825fc5c4b3272a9d46e443df9030a019b8558df55fd8ccf3e8eca7a384bb0fcf8d485dd29fe17e5ade719176e
+  metadata.gz: e37567409349ff5fe6c87802b89ffe2ecef3cd7b4b74fc332df6534e5c5e144b0d527d9f2d67d39c532dd117ebe35aa654e2779a4c10f6191f96b0a8fa9bb168
+  data.tar.gz: aef79cd03516814b259747bf9eaa0b449d692ca6568b6ecf9c4939e05ce279d7343d65caf8ceccc74e63094839e318bf5a855ea8b2d75e54f83d6e1e7f5ef6e8

data/CHANGELOG.md

@@ -5,7 +5,70 @@ 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.9.0] - 2026-03-16
+
+### Added
+- **KUI widget expansion** (25→66 widgets): badge, avatar, progress_steps, number_stepper,
+  segmented_control, accordion, dropdown, tooltip, toast, alert/confirm dialog, slider,
+  switch, rating, textarea, color_picker, date_picker, grid, zstack, scaffold, wrap_panel,
+  nav_bar, bottom_nav, drawer, bottom_sheet, list_section, sortable_header, timeline,
+  skeleton, carousel_dots, and nested yield fix in mruby backend
+- **KUI Markdown renderer** with live window resize support
+- **KUI chart rendering**: bar, line, and pie charts
+- **KUI Castella-style theming**: style composition and theme presets
+  (dark, light, solarized, etc.)
+- **Basic IME support**: UTF-8 text buffers and CJK font loading
+- **TUI Markdown demo** and TUI build resize stubs
+- **Pomodoro Timer** KUI utility app
+- **KUI framework extensions** and two new example apps (café menu, dashboard)
+
+### Fixed
+- **case/when with integer constants** crashed with SIGSEGV
+- **Large draw functions** caused SIGSEGV in Pomodoro Timer (resolved by function splitting)
+- **Unboxed captures in escape-cells** caused GC SIGSEGV (now boxed before capture)
+- **Nested yield+block** caused SIGSEGV (re-enabled yield target stack)
+
+### Changed
+- KUI tutorial updated with new widget features
+- KUI documentation clarified as immediate-mode UI framework
+
+## [0.8.0] - 2026-03-14
+
+### Added
+- **KUI widget expansion**: text_input, checkbox, radio, toggle, spinner, status_bar,
+  selectable_list, list_item, table (header/row/cell), modal, tab_bar, tab_button,
+  tab_content — all with keyboard focus support and click-to-focus
+- **KUI focus system**: Tab/arrow key navigation across all interactive widgets with
+  focus highlight and Enter key activation
+- **KUI extended key input**: `kui_char_pressed()`, `kui_mod_pressed()`,
+  Delete/Home/End/PgUp/PgDn/F1-F12 key constants
+- **KUI text buffer API**: `kui_textbuf_copy`, `kui_textbuf_render` for dynamic content
+- **KUI GUI backend**: Full GUI implementations for all new widgets (Clay+Raylib)
+- **Game framework expansion**: tween/easing (linear, quad, cubic, bounce, elastic),
+  screen shake, scene transitions (fade), FSM, timer system, parallax scrolling,
+  simple physics (AABB, gravity, friction), particle system, object pool, grid/tile
+  utilities, debug overlay (FPS, collision rects), gamepad abstraction, save/load
+- **Game showcase demo**: "Coin Dash" score-attack platformer demonstrating
+  game framework API (physics, particles, tween, FSM, parallax, Camera2D)
+- **Physics demo**: Platformer demo showcasing NativeArray-based physics
+- **KUI form demo**: Text input, checkbox, radio, toggle showcase
+- **KUI tabs demo**: Tab bar, table, modal dialog, selectable list, status bar showcase
+- **KUI showcase demo**: Rich GUI app demonstrating all v0.8.0 widgets in a 4-tab layout
+
+### Fixed
+- **NativeArray SEGV as function argument**: `convert_value()` lacked
+  `[:native_array, :value]` case, causing raw LLVM pointers where Ruby VALUEs
+  were expected
+- **NativeArray SEGV in compound expressions**: `get_effective_unboxed_type()`
+  only checked `@variable_types` for LoadLocal nodes, causing incorrect float path
+  for integer arithmetic in if conditions
+- **KUI text input isolation**: Only focused text_input processes keyboard input
+- **KUI toggle flip-back**: Filter out termbox2 mouse release events (key 65509)
+- **KUI modal layout**: Reduced TUI padding from 16 to 1 char cells
+- **mruby keyword argument handling**: Optional keyword hash with `MRB_ARGS_ARG`
+- **KUI scroll containers not scrolling**: `Clay_GetScrollOffset()` was not called
+  in `konpeito_clay_scroll` / `konpeito_clay_tui_scroll`, so `childOffset` remained
+  zero and scroll position was never visually applied
 
 ## [0.7.1] - 2026-03-14
 
@@ -18,7 +81,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **KUI declarative UI framework**: Pure Ruby DSL for building GUI/TUI apps with a single codebase. Wraps Clay+Raylib (GUI) or ClayTUI (TUI). Widgets: `vpanel`, `hpanel`, `fixed_panel`, `label`, `label_num`, `button`, `menu_item`, `spacer`, `divider`, `progress_bar`. Theme system and unified key event abstraction.
 - **ClayTUI stdlib**: Terminal UI backend using Clay layout engine + termbox2 rendering. Auto-detected via `ClayTUI` module reference.
 - **KonpeitoShell stdlib**: Shell execution (`exec`, `system`), environment variables (`getenv`, `setenv`), and file I/O (`read_file`, `write_file`, `append_file`, `file_exists`) for mruby backend.
-- **RPG framework stdlib**: Reusable RPG game components (tilemap, sprites, camera, battle system) for raylib-based games.
+- **Game framework stdlib**: Reusable 2D game components (tilemap, sprites, camera, battle system) for raylib-based games.
 - **Stdlib auto-detection expansion**: `KonpeitoJSON`, `KonpeitoHTTP`, `KonpeitoCrypto`, `KonpeitoCompression` added to `STDLIB_MODULE_MAP` for automatic RBS injection when referenced in source code.
 - **KUI auto-path resolution**: `require "kui_gui"` / `require "kui_tui"` works without `-I` flags — KUI stdlib directory is automatically included in compiler search paths.
 - **KUI example apps**: Counter (GUI + TUI), minimal hello, multi-page dashboard with sidebar navigation.
@@ -341,6 +404,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `%a{extern}` - external C struct wrappers
 - `%a{simd}` - SIMD vectorization
 
+[0.9.0]: https://github.com/i2y/konpeito/compare/v0.8.0...v0.9.0
+[0.8.0]: https://github.com/i2y/konpeito/compare/v0.7.1...v0.8.0
+[0.7.1]: https://github.com/i2y/konpeito/compare/v0.7.0...v0.7.1
+[0.7.0]: https://github.com/i2y/konpeito/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/i2y/konpeito/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/i2y/konpeito/compare/v0.4.2...v0.5.0
+[0.4.2]: https://github.com/i2y/konpeito/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/i2y/konpeito/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/i2y/konpeito/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/i2y/konpeito/compare/v0.3.0...v0.3.1

data/lib/konpeito/codegen/llvm_generator.rb

@@ -823,6 +823,13 @@ module Konpeito
         # We'll use rb_yield_values2 instead: VALUE rb_yield_values2(int argc, const VALUE *argv)
         @rb_yield_values2 = @mod.functions.add("rb_yield_values2", [LLVM::Int32, LLVM::Pointer(value_type)], value_type)
 
+        # Nested yield: yield to the enclosing method's block from inside a block callback
+        @konpeito_yield_to_method_block = @mod.functions.add("konpeito_yield_to_method_block", [value_type], value_type)
+        @konpeito_yield_to_method_block_values = @mod.functions.add("konpeito_yield_to_method_block_values",
+          [LLVM::Int32, LLVM::Pointer(value_type)], value_type)
+        @konpeito_push_yield_target = @mod.functions.add("konpeito_push_yield_target", [], LLVM::Type.void)
+        @konpeito_pop_yield_target = @mod.functions.add("konpeito_pop_yield_target", [], LLVM::Type.void)
+
         # int rb_block_given_p(void) - check if block is given
         @rb_block_given_p = @mod.functions.add("rb_block_given_p", [], LLVM::Int32)
 
@@ -1597,6 +1604,24 @@ module Konpeito
             boxed_value = func.params[i + 1]  # +1 to skip self
           type_tag = @variable_types[param.name]
 
+          if type_tag == :native_array
+            # NativeArray parameter: the VALUE is actually a pointer address (via ptr2int).
+            # Reconstruct the pointer and store directly in @variables (not alloca).
+            # generate_load_local reads NativeArray values from @variables, not allocas.
+            array_ptr = @builder.int2ptr(boxed_value, ptr_type, "#{param.name}_ptr")
+            @variables[param.name] = array_ptr
+            # Propagate element type and length from the parameter's HM type if available
+            if param.type.is_a?(TypeChecker::Types::NativeArrayType)
+              elem_type = param.type.element_type
+              @variables["#{param.name}_len"] = LLVM::Int64.from_i(param.type.size || 0)
+              if elem_type && elem_type != :Int64 && elem_type != :Float64
+                @native_array_class_types ||= {}
+                @native_array_class_types[param.name] = elem_type
+              end
+            end
+            next
+          end
+
           # Unbox parameter if it's a numeric type
           value_to_store = case type_tag
           when :i64
@@ -1749,6 +1774,15 @@ module Konpeito
           @builder.store(arena_idx, @mruby_gc_arena_alloca)
         end
 
+        # For mruby: if this function has yield inside block callbacks (nested yield),
+        # push the current method's block as the yield target so that nested callbacks
+        # can yield to the correct block instead of the innermost callback.
+        @needs_yield_target_pop = false
+        if @runtime == :mruby && function_has_nested_yield?(hir_func)
+          @builder.call(@konpeito_push_yield_target)
+          @needs_yield_target_pop = true
+        end
+
         # Insert profiling entry probe after parameter setup
         insert_profile_entry_probe(hir_func)
 
@@ -1778,6 +1812,10 @@ module Konpeito
       # For the mruby backend, restores the arena to the saved index and
       # protects the return value from GC before returning.
       def emit_ret(value)
+        # Pop yield target before return if this function pushed one
+        if @needs_yield_target_pop
+          @builder.call(@konpeito_pop_yield_target)
+        end
         if @mruby_gc_arena_alloca
           idx = @builder.load2(LLVM::Int32, @mruby_gc_arena_alloca, "_arena_r")
           @builder.call(@konpeito_gc_arena_restore, idx)
@@ -1789,6 +1827,32 @@ module Konpeito
         @builder.ret(value)
       end
 
+      # Check if a function has yield inside any block callback body (nested yield).
+      # Direct yield in the function body does NOT count (that uses rb_yield normally).
+      def function_has_nested_yield?(hir_func)
+        hir_func.body.each do |bb|
+          bb.instructions.each do |inst|
+            if inst.is_a?(HIR::Call) && inst.block
+              return true if block_body_contains_yield?(inst.block)
+            end
+          end
+        end
+        false
+      end
+
+      # Recursively check if a block body contains a Yield instruction.
+      def block_body_contains_yield?(block_def)
+        block_def.body.each do |bb|
+          bb.instructions.each do |inst|
+            return true if inst.is_a?(HIR::Yield)
+            if inst.is_a?(HIR::Call) && inst.block
+              return true if block_body_contains_yield?(inst.block)
+            end
+          end
+        end
+        false
+      end
+
       # Topologically sort blocks based on phi dependencies
       # Ensures blocks are generated after the blocks their phi nodes reference
       def sort_blocks_by_phi_dependencies(blocks)
@@ -2004,6 +2068,10 @@ module Konpeito
           [LLVM::Int64, :i64]
         elsif float_type?(ruby_type)
           [LLVM::Double, :double]
+        elsif ruby_type.is_a?(TypeChecker::Types::NativeArrayType)
+          # NativeArray parameters: alloca holds VALUE (i64) but type is :native_array
+          # The actual pointer is reconstructed from the VALUE in parameter setup
+          [value_type, :native_array]
         else
           [value_type, :value]
         end
@@ -3029,6 +3097,9 @@ module Konpeito
         when [:native_class, :value]
           # NativeClass struct pointer to VALUE (i64)
           @builder.ptr2int(value, LLVM::Int64)
+        when [:native_array, :value]
+          # NativeArray pointer to VALUE (i64) — encode pointer address as integer
+          @builder.ptr2int(value, LLVM::Int64)
         when [:i64, :double]
           @builder.si2fp(value, LLVM::Double)
         when [:double, :i64]
@@ -4789,11 +4860,19 @@ module Konpeito
         if use_escape_cells
           esc_ary = @builder.call(@rb_ary_new_capa, LLVM::Int64.from_i(all_captures.size), "blk_esc_ary")
           all_captures.each do |cap|
+            cap_type = capture_types[cap.name] || :value
             val = if @variable_allocas[cap.name]
                     @builder.load2(value_type, @variable_allocas[cap.name], "blk_esc_#{cap.name}")
                   else
                     qnil
                   end
+            # Box unboxed values before pushing to the escape-cells Ruby Array.
+            # The GC scans array elements as mrb_values; a raw unboxed integer
+            # (e.g., from NativeArray) without fixnum tag bits would be
+            # misinterpreted as a heap pointer → SIGSEGV in gc_mark_children.
+            if cap_type != :value
+              val = convert_value(val, cap_type, :value)
+            end
             @builder.call(@rb_ary_push, esc_ary, val)
           end
 
@@ -4891,8 +4970,9 @@ module Konpeito
         # Set @in_block_callback so nested proc creation uses GC-safe escape-cells mode.
         # Reset mruby constant cache — LLVM values are scoped per function, so
         # cached %qnil/%qtrue from the parent function are invalid here.
-        # Clear GC arena alloca — callbacks don't own their own arena scope.
         @in_block_callback = true
+
+        # Clear GC arena alloca — callbacks run under the caller's arena scope.
         @mruby_gc_arena_alloca = nil
         @variables = {}
         @variable_types = {}
@@ -4911,13 +4991,21 @@ module Konpeito
             captures.each_with_index do |capture, i|
               val = @builder.call(@rb_ary_entry, ary_val,
                                   LLVM::Int64.from_i(i), "esc_#{capture.name}")
+              # Values were boxed when pushed to the escape-cells array
+              # (to prevent GC from misinterpreting raw unboxed integers as
+              # heap pointers).  Unbox them back to their original type.
+              cap_type = capture_types[capture.name] || :value
+              if cap_type != :value
+                val = convert_value(val, :value, cap_type)
+              end
               # Store in an alloca so LoadLocal/StoreLocal can use it normally.
               # Writes to this alloca stay local (no back-write to the GC array),
               # which is correct for snapshots from a returned outer scope.
-              cap_alloca = @builder.alloca(value_type, "esc_alloca_#{capture.name}")
+              llvm_type = type_tag_to_llvm_type(cap_type)
+              cap_alloca = @builder.alloca(llvm_type, "esc_alloca_#{capture.name}")
               @builder.store(val, cap_alloca)
               @variable_allocas[capture.name] = cap_alloca
-              @variable_types[capture.name] = capture_types[capture.name] || :value
+              @variable_types[capture.name] = cap_type
             end
           else
             # data2 is a pointer to array of VALUE* (pointers to captured variables).
@@ -5124,10 +5212,7 @@ module Konpeito
               # Return the last value in the block, or Qnil
               # For while_exit blocks, the last instruction loads the break value
               if last_instr
-                result_val = last_instr
-                # Box unboxed values before returning
-                result_type = :value  # Default
-                @builder.ret(result_val)
+                @builder.ret(last_instr)
               else
                 @builder.ret(qnil)
               end
@@ -7372,6 +7457,15 @@ module Konpeito
           return type_tag if type_tag == :i64 || type_tag == :double
         end
 
+        # Check @variable_types for any instruction with result_var.
+        # This is critical for sub-expressions (e.g. NativeArrayGet, Call) whose
+        # HIR type may be an unresolved TypeVar but whose actual generated type
+        # is correctly tracked in @variable_types.
+        if hir_value.is_a?(HIR::Instruction) && hir_value.result_var
+          type_tag = @variable_types[hir_value.result_var]
+          return type_tag if type_tag == :i64 || type_tag == :double
+        end
+
         # Check HIR type
         hir_type = get_type(hir_value)
         if integer_type?(hir_type)
@@ -7948,15 +8042,20 @@ module Konpeito
       end
 
       def generate_yield(inst)
+        # When yield is inside a block callback, use the yield target stack
+        # to reach the enclosing method's block instead of the innermost callback.
+        yield_fn = @in_block_callback ? @konpeito_yield_to_method_block : @rb_yield
+        yield_values_fn = @in_block_callback ? @konpeito_yield_to_method_block_values : @rb_yield_values2
+
         result = if inst.args.empty?
           # yield with no arguments - pass Qnil
-          @builder.call(@rb_yield, qnil)
+          @builder.call(yield_fn, qnil)
         elsif inst.args.size == 1
           # yield with single argument — must be boxed VALUE for rb_yield
           arg_value = get_value_as_ruby(inst.args.first)
-          @builder.call(@rb_yield, arg_value)
+          @builder.call(yield_fn, arg_value)
         else
-          # yield with multiple arguments - use rb_yield_values2
+          # yield with multiple arguments
           argc = LLVM::Int32.from_i(inst.args.size)
 
           # Allocate array on stack
@@ -7970,7 +8069,7 @@ module Konpeito
 
           # Cast to VALUE*
           argv_ptr = @builder.bit_cast(argv, LLVM::Pointer(value_type))
-          @builder.call(@rb_yield_values2, argc, argv_ptr)
+          @builder.call(yield_values_fn, argc, argv_ptr)
         end
 
         @variables[inst.result_var] = result if inst.result_var
@@ -8855,6 +8954,10 @@ module Konpeito
           # String === arg: Use rb_str_equal
           return inline_string_case_eq(receiver, arg)
         elsif receiver_hir.is_a?(HIR::ConstantLookup)
+          if is_integer_type?(receiver_hir.type)
+            # Integer constant (e.g. OP_ADD = 1) === arg: VALUE equality check
+            return inline_value_case_eq(receiver, arg)
+          end
           # Class/Module === arg: Use rb_obj_is_kind_of
           return inline_class_case_eq(receiver, arg)
         end
@@ -8892,6 +8995,13 @@ module Konpeito
         @builder.select(result_bool, qtrue, qfalse)
       end
 
+      # Inline VALUE equality check for integer constants (e.g. OP_ADD = 1)
+      # Since CRuby/mruby Fixnums are immediate values, VALUE equality == numeric equality
+      def inline_value_case_eq(receiver, arg)
+        eq_bool = @builder.icmp(:eq, receiver, arg)
+        @builder.select(eq_bool, qtrue, qfalse)
+      end
+
       # Inline String === arg comparison
       def inline_string_case_eq(receiver, arg)
         # Use rb_str_equal which returns Qtrue/Qfalse

data/lib/konpeito/codegen/mruby_backend.rb

@@ -78,13 +78,17 @@ module Konpeito
           # Generate license file alongside the executable
           generate_license_file
         ensure
-          # Clean up intermediate files
+          # Clean up intermediate files (keep .ll for debugging if ENV['KONPEITO_KEEP_IR'] is set)
+          keep_ir = ENV['KONPEITO_KEEP_IR']
           all_temps = [ir_file, obj_file, init_c_file, init_obj_file, helpers_obj_file] + extra_obj_files
           all_temps.each do |f|
+            next if keep_ir && f&.end_with?('.ll')
             FileUtils.rm_f(f) if f && File.exist?(f)
           end
           # Also clean optimized IR if it was generated
-          FileUtils.rm_f("#{ir_file}.opt.ll") if File.exist?("#{ir_file}.opt.ll")
+          unless keep_ir
+            FileUtils.rm_f("#{ir_file}.opt.ll") if File.exist?("#{ir_file}.opt.ll")
+          end
         end
       end
 
@@ -125,6 +129,8 @@ module Konpeito
         lines << "/* Block stack for rb_yield/rb_block_given_p support */"
         lines << "extern void konpeito_push_block(mrb_value block);"
         lines << "extern void konpeito_pop_block(void);"
+        lines << "extern void konpeito_push_yield_target(void);"
+        lines << "extern void konpeito_pop_yield_target(void);"
         lines << ""
 
         # Collect NativeClasses from RBS loader
@@ -302,7 +308,7 @@ module Konpeito
 
             arity = llvm_generator.variadic_functions[mangled_name] ? -1 : func.params.size - 1
             wrapper = "mrb_wrap_#{mangled_name}"
-            mrb_args = arity_to_mrb_args(arity)
+            mrb_args = effective_mrb_args(mangled_name, arity)
             lines << "    mrb_define_method(mrb, #{module_var}, \"#{method_name}\", #{wrapper}, #{mrb_args});"
           end
 
@@ -316,7 +322,7 @@ module Konpeito
 
             arity = llvm_generator.variadic_functions[mangled_name] ? -1 : func.params.size - 1
             wrapper = "mrb_wrap_#{mangled_name}"
-            mrb_args = arity_to_mrb_args(arity)
+            mrb_args = effective_mrb_args(mangled_name, arity)
             lines << "    mrb_define_class_method(mrb, #{module_var}, \"#{method_name}\", #{wrapper}, #{mrb_args});"
           end
 
@@ -372,7 +378,7 @@ module Konpeito
 
             arity = llvm_generator.variadic_functions[mangled_name] ? -1 : func.params.size - 1
             wrapper = "mrb_wrap_#{mangled_name}"
-            mrb_args = arity_to_mrb_args(arity)
+            mrb_args = effective_mrb_args(mangled_name, arity)
             lines << "    mrb_define_method(mrb, #{class_var}, \"#{method_name}\", #{wrapper}, #{mrb_args});"
           end
 
@@ -386,7 +392,7 @@ module Konpeito
 
             arity = llvm_generator.variadic_functions[mangled_name] ? -1 : func.params.size - 1
             wrapper = "mrb_wrap_#{mangled_name}"
-            mrb_args = arity_to_mrb_args(arity)
+            mrb_args = effective_mrb_args(mangled_name, arity)
             lines << "    mrb_define_class_method(mrb, #{class_var}, \"#{method_name}\", #{wrapper}, #{mrb_args});"
           end
 
@@ -408,7 +414,7 @@ module Konpeito
 
           arity = llvm_generator.variadic_functions[mangled_name] ? -1 : func.params.size - 1
           wrapper = "mrb_wrap_#{mangled_name}"
-          mrb_args = arity_to_mrb_args(arity)
+          mrb_args = effective_mrb_args(mangled_name, arity)
           lines << "    mrb_define_method(mrb, mrb->object_class, \"#{func_def.name}\", #{wrapper}, #{mrb_args});"
         end
 
@@ -456,13 +462,14 @@ module Konpeito
         else
           arity = llvm_func.params.size - 1  # Subtract self
 
-          # Check if this function has only keyword args (no positional params).
-          # If so, the kwargs hash arg is optional — caller may pass 0 args
-          # when no keywords are specified (e.g., `footer do ... end`).
+          # Check if this function has keyword args.
+          # The kwargs hash arg should be optional — caller may pass only
+          # positional args when no keywords are specified.
           func_base_name = mangled_name.sub(/\Arn_/, "")
           kw_info = llvm_generator.keyword_param_functions[func_base_name] ||
                     llvm_generator.keyword_param_functions[func_base_name.to_sym]
           kwargs_only = kw_info && kw_info[:regular_count] == 0 && arity == 1
+          has_mixed_kwargs = kw_info && kw_info[:regular_count] > 0 && arity > 1
 
           lines << "static mrb_value #{wrapper_name}(mrb_state *mrb, mrb_value self) {"
           if kwargs_only
@@ -470,6 +477,15 @@ module Konpeito
             lines << "    mrb_value a0 = mrb_nil_value(), _block = mrb_nil_value();"
             lines << "    mrb_get_args(mrb, \"|o&\", &a0, &_block);"
             lines << "    if (mrb_nil_p(a0)) a0 = mrb_hash_new(mrb);"
+          elsif has_mixed_kwargs
+            # Positional args + optional kwargs hash — last arg defaults to empty hash
+            kw_hash_idx = arity - 1
+            req_count = kw_info[:regular_count]
+            lines << "    mrb_value #{(0...arity).map { |i| "a#{i} = mrb_nil_value()" }.join(', ')}, _block = mrb_nil_value();"
+            format_str = "o" * req_count + "|o&"
+            args_list = (0...arity).map { |i| "&a#{i}" }.join(", ") + ", &_block"
+            lines << "    mrb_get_args(mrb, \"#{format_str}\", #{args_list});"
+            lines << "    if (mrb_nil_p(a#{kw_hash_idx})) a#{kw_hash_idx} = mrb_hash_new(mrb);"
           elsif arity > 0
             lines << "    mrb_value #{(0...arity).map { |i| "a#{i}" }.join(', ')}, _block;"
             format_str = "o" * arity + "&"
@@ -804,6 +820,24 @@ module Konpeito
         end
       end
 
+      # Compute mrb_args for a function, accounting for optional keyword hash.
+      # Functions with keyword params can be called with or without the keyword
+      # hash argument, so the kwargs arg must be registered as optional.
+      def effective_mrb_args(mangled_name, arity)
+        return arity_to_mrb_args(arity) if arity <= 0
+
+        func_base_name = mangled_name.sub(/\Arn_/, "")
+        kw_info = llvm_generator.keyword_param_functions[func_base_name] ||
+                  llvm_generator.keyword_param_functions[func_base_name.to_sym]
+        if kw_info
+          # Keyword hash is optional — use MRB_ARGS_ARG(required, optional)
+          req = kw_info[:regular_count]
+          "MRB_ARGS_ARG(#{req}, #{arity - req})"
+        else
+          arity_to_mrb_args(arity)
+        end
+      end
+
       def resolve_superclass_mrb_expr(superclass, non_native_classes)
         return "mrb->object_class" unless superclass
 

data/lib/konpeito/codegen/mruby_helpers.c

@@ -96,6 +96,90 @@ void konpeito_pop_block(void) {
     }
 }
 
+/* Forward declarations for yield target stack and nested yield support */
+static mrb_value konpeito_get_block(void);
+static konpeito_native_cb_entry *konpeito_get_native_cb(void);
+mrb_value rb_yield(mrb_value val);
+mrb_value rb_yield_values2(int argc, const mrb_value *argv);
+
+/* ================================================================
+ * Yield target stack for nested yield
+ *
+ * When a method receives a block and its body (via nested block
+ * callbacks) calls yield, the global block stack top points to the
+ * innermost callback, not the method's block.
+ *
+ * The yield target stack captures the block at method entry so that
+ * yield inside any nested callback can find the correct target.
+ * ================================================================ */
+
+static mrb_value konpeito_yield_target_block[KONPEITO_MAX_BLOCK_STACK];
+static konpeito_native_cb_entry konpeito_yield_target_native[KONPEITO_MAX_BLOCK_STACK];
+static int konpeito_yield_target_depth = 0;
+
+void konpeito_push_yield_target(void) {
+    if (konpeito_yield_target_depth < KONPEITO_MAX_BLOCK_STACK) {
+        /* Capture the current top of block_stack as the yield target */
+        konpeito_yield_target_block[konpeito_yield_target_depth] = konpeito_get_block();
+        konpeito_native_cb_entry *native = konpeito_get_native_cb();
+        if (native) {
+            konpeito_yield_target_native[konpeito_yield_target_depth] = *native;
+        } else {
+            konpeito_yield_target_native[konpeito_yield_target_depth].func = NULL;
+        }
+        konpeito_yield_target_depth++;
+    }
+}
+
+void konpeito_pop_yield_target(void) {
+    if (konpeito_yield_target_depth > 0) {
+        konpeito_yield_target_depth--;
+    }
+}
+
+/* Yield to the enclosing method's block (not the immediate callback).
+ * Used by yield inside block callbacks to propagate correctly. */
+mrb_value konpeito_yield_to_method_block(mrb_value val) {
+    mrb_state *mrb = konpeito_mrb_state;
+
+    if (konpeito_yield_target_depth > 0) {
+        konpeito_native_cb_entry *target =
+            &konpeito_yield_target_native[konpeito_yield_target_depth - 1];
+        if (target->func) {
+            mrb_value argv[1];
+            argv[0] = val;
+            return target->func(val, target->data2, 1, argv);
+        }
+        mrb_value block = konpeito_yield_target_block[konpeito_yield_target_depth - 1];
+        if (!mrb_nil_p(block)) {
+            return mrb_funcall(mrb, block, "call", 1, val);
+        }
+    }
+
+    /* Fallback to normal yield */
+    return rb_yield(val);
+}
+
+mrb_value konpeito_yield_to_method_block_values(int argc, const mrb_value *argv) {
+    mrb_state *mrb = konpeito_mrb_state;
+
+    if (konpeito_yield_target_depth > 0) {
+        konpeito_native_cb_entry *target =
+            &konpeito_yield_target_native[konpeito_yield_target_depth - 1];
+        if (target->func) {
+            mrb_value yielded = (argc > 0) ? argv[0] : mrb_nil_value();
+            return target->func(yielded, target->data2, argc, argv);
+        }
+        mrb_value block = konpeito_yield_target_block[konpeito_yield_target_depth - 1];
+        if (!mrb_nil_p(block)) {
+            mrb_sym call_sym = mrb_intern_cstr(mrb, "call");
+            return mrb_funcall_argv(mrb, block, call_sym, argc, argv);
+        }
+    }
+
+    return rb_yield_values2(argc, argv);
+}
+
 static mrb_value konpeito_get_block(void) {
     if (konpeito_block_stack_depth > 0) {
         return konpeito_block_stack[konpeito_block_stack_depth - 1];
@@ -1052,3 +1136,26 @@ void konpeito_mrb_data_init(mrb_value obj, void *ptr, const mrb_data_type *type)
 
 /* mrb_top_self wrapper */
 mrb_value konpeito_mrb_top_self(mrb_state *mrb) { return mrb_top_self(mrb); }
+
+/* ================================================================
+ * Live resize bridge — calls Ruby _kui_resize_frame() from C
+ * ================================================================ */
+
+/* Forward declaration from clay_native.c */
+typedef void (*clay_frame_fn)(void);
+extern void konpeito_clay_set_resize_frame_fn(clay_frame_fn fn);
+
+static void konpeito_resize_frame_bridge(void) {
+    mrb_state *mrb = konpeito_mrb_state;
+    if (!mrb) return;
+    int ai = mrb_gc_arena_save(mrb);
+    mrb_funcall(mrb, mrb_top_self(mrb), "_kui_resize_frame", 0);
+    if (mrb->exc) {
+        mrb->exc = NULL;  /* swallow errors during resize */
+    }
+    mrb_gc_arena_restore(mrb, ai);
+}
+
+void konpeito_register_resize_callback(void) {
+    konpeito_clay_set_resize_frame_fn(konpeito_resize_frame_bridge);
+}

data/lib/konpeito/stdlib/clay/clay.rb

@@ -26,6 +26,7 @@ module Clay
   def self.layout(dir, pl, pr, pt, pb, gap, swt, swv, sht, shv, ax, ay) end
   def self.bg(r, g, b, a, corner_radius) end
   def self.border(r, g, b, a, top, right, bottom, left, corner_radius) end
+  def self.set_custom(chart_id) end
   def self.scroll(horizontal, vertical) end
   def self.floating(ox, oy, z, att_elem, att_parent) end
 
@@ -33,6 +34,7 @@ module Clay
   def self.text(text, font_id, font_size, r, g, b, a, wrap) end
   def self.set_measure_text_raylib() end
   def self.load_font(path, size) end
+  def self.load_font_cjk(path, size) end
 
   # Render Command Access
   def self.cmd_type(index) end
@@ -48,10 +50,18 @@ module Clay
   def self.cmd_font_id(index) end
   def self.cmd_font_size(index) end
   def self.cmd_corner_radius(index) end
+  def self.cmd_ix(index) end
+  def self.cmd_iy(index) end
+  def self.cmd_iw(index) end
+  def self.cmd_ih(index) end
+  def self.cmd_custom_data(index) end
   def self.cmd_border_width_top(index) end
 
   # Bulk Rendering
   def self.render_raylib() end
+  def self.set_bg_color(r, g, b) end
+  def self.is_resizing() end
+  def self.register_resize_callback() end
 
   # Scroll
   def self.update_scroll(dx, dy, dt) end
@@ -63,4 +73,20 @@ module Clay
   def self.sizing_percent() end
   def self.left_to_right() end
   def self.top_to_bottom() end
+
+  # Text Buffer System
+  def self.textbuf_clear(id) end
+  def self.textbuf_copy(dst, src) end
+  def self.textbuf_putchar(id, ch) end
+  def self.textbuf_backspace(id) end
+  def self.textbuf_delete(id) end
+  def self.textbuf_cursor_left(id) end
+  def self.textbuf_cursor_right(id) end
+  def self.textbuf_cursor_home(id) end
+  def self.textbuf_cursor_end(id) end
+  def self.textbuf_len(id) end
+  def self.textbuf_cursor(id) end
+  def self.textbuf_render(id, fid, fsz, r, g, b) end
+  def self.textbuf_render_range(id, start_pos, end_pos, fid, fsz, r, g, b) end
+  def self.text_char(ch, fid, fsz, r, g, b) end
 end