pre-commit: fix prettier formatting in doc/guides/capi.md

Co-authored-by: Claude <noreply@anthropic.com>
2026-06-08 16:11:16 +00:00 · 2026-03-12 13:09:44 +09:00
47 changed files with 3057 additions and 3319 deletions
@@ -5,29 +5,11 @@ updates:
    directory: "/"
    schedule:
      interval: "daily"
-    groups:
-      bundler-dependencies:
-        patterns:
-          - "*"
    cooldown:
      default-days: 7
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "daily"
-    groups:
-      github-actions-dependencies:
-        patterns:
-          - "*"
-    cooldown:
-      default-days: 7
-  - package-ecosystem: "pre-commit"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    groups:
-      pre-commit-hooks:
-        patterns:
-          - "*"
    cooldown:
      default-days: 7
@@ -32,8 +32,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Compiler version
@@ -47,8 +45,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Cache cosmocc
@@ -75,8 +71,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Build and test
@@ -19,8 +19,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Initialize CodeQL
        uses: github/codeql-action/init@v4
        with:
@@ -2,9 +2,6 @@ name: Coverage

 on: [push]

-permissions:
-  contents: read
-
 jobs:
  coverage:
    name: Coverage
@@ -20,8 +17,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Compiler version
@@ -12,8 +12,6 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - uses: ls-lint/action@v2.3.1
        with:
          config: .github/linters/.ls-lint.yml
@@ -1,22 +0,0 @@
-# https://github.com/j178/prek
-name: Manual hooks
-
-on: [pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  pre-commit:
-    name: Run pre-commit
-    runs-on: ubuntu-latest
-    steps:
-      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
-        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-      - uses: j178/prek-action@v2
-        with:
-          install-only: true
-      - name: Run manual pre-commit hooks
-        run: prek run --color=always --all-files --hook-stage manual
@@ -13,8 +13,8 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-      - uses: j178/prek-action@v2
+      - uses: j178/prek-action@v1
        with:
          extra-args: --all-files
+      - name: Run manual pre-commit hooks
+        run: prek run --color=always --all-files --hook-stage manual
@@ -20,8 +20,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref_name }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Builds
        id: builds
        run: |
@@ -19,7 +19,6 @@ jobs:
        with:
          # Full git history is needed to get a proper list of changed files within `super-linter`
          fetch-depth: 0
-          persist-credentials: false
      - name: Lint Code Base
        uses: super-linter/super-linter/slim@v8.5.0
        env:
@@ -3,7 +3,7 @@
 default_stages: [pre-commit, pre-push]
 default_language_version:
  python: python3
-  node: 24.14.0
+  node: 24.11.1
 minimum_pre_commit_version: "3.2.0"
 exclude: "^tools/lrama/"
 repos:
@@ -24,7 +24,6 @@ repos:
        files: \.(md|ya?ml)$
        language: node
        additional_dependencies: ["prettier@3.7.4"]
-        pass_filenames: false
        stages: [manual]
      - id: check-zip-file-is-not-committed
        name: disallow zip files
@@ -35,13 +34,13 @@ repos:
          track and have security implications. Please remove the zip file from the repository.
        files: \.zip$
  - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.30.1
+    rev: v8.30.0
    hooks:
      - id: gitleaks
        name: run gitleaks
        description: detect hardcoded secrets with gitleaks
  - repo: https://github.com/oxipng/oxipng
-    rev: v10.1.0
+    rev: v10.0.0
    hooks:
      - id: oxipng
        name: run oxipng
@@ -73,7 +72,7 @@ repos:
      - id: mixed-line-ending
      - id: trailing-whitespace
  - repo: https://github.com/Lucas-C/pre-commit-hooks
-    rev: v1.5.6
+    rev: v1.5.5
    hooks:
      - id: forbid-tabs
        name: run no-tabs checker
@@ -85,19 +84,19 @@ repos:
        args: [--whitespaces-count, "2"]
        exclude: Makefile$
  - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.12
+    rev: v1.7.9
    hooks:
      - id: actionlint
        name: run actionlint
        description: lint GitHub Actions workflow files
  - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.1
    hooks:
      - id: codespell
        name: run codespell
        description: check spelling with codespell
  - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.48.0
+    rev: v0.46.0
    hooks:
      - id: markdownlint
        name: run markdownlint
@@ -106,7 +105,7 @@ repos:
        types: [markdown]
        files: \.md$
  - repo: https://github.com/rubocop/rubocop
-    rev: v1.86.0
+    rev: v1.81.7
    hooks:
      - id: rubocop
        name: run rubocop
@@ -120,7 +119,7 @@ repos:
        name: run shellcheck
        description: check shell scripts with a static analysis tool
  - repo: https://github.com/adrienverge/yamllint
-    rev: v1.38.0
+    rev: v1.37.1
    hooks:
      - id: yamllint
        name: run yamllint
@@ -3,4 +3,3 @@ build
 coverage
 doc/internal/opcode.md
 tools/lrama
-.venv
@@ -51,8 +51,6 @@ To get mruby, you can download the stable version 4.0.0 from the official mruby
 GitHub repository or clone the trunk of the mruby source tree with the "git
 clone" command. You can also install and compile mruby using [ruby-install](https://github.com/postmodern/ruby-install), [ruby-build](https://github.com/rbenv/ruby-build), [rvm](https://github.com/rvm/rvm), [conda](https://anaconda.org/channels/conda-forge/packages/mruby/overview) or [Homebrew](https://formulae.brew.sh/formula/mruby).

-The release candidate version 4.0.0 of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/archive/4.0.0-rc3.zip](https://github.com/mruby/mruby/archive/4.0.0-rc3.zip)
-
 The latest development version of mruby can be downloaded via the following URL: [https://github.com/mruby/mruby/zipball/master](https://github.com/mruby/mruby/zipball/master)

 The trunk of the mruby source tree can be checked out with the
@@ -30,7 +30,7 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|

    #configuration for low memory environment
    cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
    cc.defines << %w(MRB_GC_STRESS)
    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
    #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
@@ -16,7 +16,7 @@ MRuby::CrossBuild.new("RX630") do |conf|
    #configuration for low memory environment
    cc.defines << %w(MRB_USE_FLOAT32)
    cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
    cc.defines << %w(MRB_GC_STRESS)
    cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
    #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
@@ -27,7 +27,7 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|

    #configuration for low memory environment
    cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
    cc.defines << %w(MRB_GC_STRESS)
    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
    #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
@@ -4,44 +4,44 @@

 New to mruby? Start here:

-| Document                                     | Description                            |
-| -------------------------------------------- | -------------------------------------- |
+| Document | Description |
+| -------- | ----------- |
 | [Getting Started](guides/getting-started.md) | Build mruby and run your first program |
-| [Language Features](guides/language.md)      | Ruby subset supported by mruby         |
-| [Limitations](limitations.md)                | Behavioral differences from CRuby      |
+| [Language Features](guides/language.md) | Ruby subset supported by mruby |
+| [Limitations](limitations.md) | Behavioral differences from CRuby |

 ## Guides (for embedders and gem authors)

 ### Embedding mruby in C

-| Document                                | Description                                      |
-| --------------------------------------- | ------------------------------------------------ |
-| [C API Reference](guides/capi.md)       | Values, classes, methods, error handling, fibers |
-| [GC Arena](guides/gc-arena-howto.md)    | Managing temporary objects in C extensions       |
-| [Linking](guides/link.md)               | Linking with `libmruby`                          |
-| [Amalgamation](guides/amalgamation.md)  | Single-file build for easy integration           |
-| [Precompiled Symbols](guides/symbol.md) | Compile-time symbol allocation                   |
+| Document | Description |
+| -------- | ----------- |
+| [C API Reference](guides/capi.md) | Values, classes, methods, error handling, fibers |
+| [GC Arena](guides/gc-arena-howto.md) | Managing temporary objects in C extensions |
+| [Linking](guides/link.md) | Linking with `libmruby` |
+| [Amalgamation](guides/amalgamation.md) | Single-file build for easy integration |
+| [Precompiled Symbols](guides/symbol.md) | Compile-time symbol allocation |

 ### Building and Configuring

-| Document                                 | Description                                 |
-| ---------------------------------------- | ------------------------------------------- |
-| [Compilation](guides/compile.md)         | Build system, cross-compilation, toolchains |
-| [Build Configuration](guides/mrbconf.md) | Compile-time macros (`MRB_*` flags)         |
-| [mrbgems](guides/mrbgems.md)             | Creating and managing gems                  |
-| [Memory](guides/memory.md)               | Allocator customization and heap regions    |
+| Document | Description |
+| -------- | ----------- |
+| [Compilation](guides/compile.md) | Build system, cross-compilation, toolchains |
+| [Build Configuration](guides/mrbconf.md) | Compile-time macros (`MRB_*` flags) |
+| [mrbgems](guides/mrbgems.md) | Creating and managing gems |
+| [Memory](guides/memory.md) | Allocator customization and heap regions |

 ### Tools

-| Document                                        | Description                                     |
-| ----------------------------------------------- | ----------------------------------------------- |
-| [Debugger](guides/debugger.md)                  | Using `mrdb` for debugging                      |
+| Document | Description |
+| -------- | ----------- |
+| [Debugger](guides/debugger.md) | Using `mrdb` for debugging |
 | [ROM Method Tables](guides/rom-method-table.md) | Read-only method tables for constrained devices |

 ### Reference

-| Document                              | Description        |
-| ------------------------------------- | ------------------ |
+| Document | Description |
+| -------- | ----------- |
 | [Directory Structure](guides/hier.md) | Source tree layout |

 ## Internals (for mruby contributors)
@@ -49,14 +49,14 @@ New to mruby? Start here:
 Start with [Architecture](internal/architecture.md) for an overview,
 then dive into the subsystem you need:

-| Document                                  | Description                                        |
-| ----------------------------------------- | -------------------------------------------------- |
-| [Architecture](internal/architecture.md)  | Overview of object model, VM, GC, compiler         |
-| [Virtual Machine](internal/vm.md)         | Dispatch loop, call frames, method lookup, fibers  |
-| [Garbage Collector](internal/gc.md)       | Tri-color marking, write barriers, generational GC |
-| [Compiler Pipeline](internal/compiler.md) | Parser, code generator, IRep, binary format        |
-| [Opcodes](internal/opcode.md)             | VM instruction set reference                       |
-| [Value Boxing](internal/boxing.md)        | How `mrb_value` encodes types                      |
+| Document | Description |
+| -------- | ----------- |
+| [Architecture](internal/architecture.md) | Overview of object model, VM, GC, compiler |
+| [Virtual Machine](internal/vm.md) | Dispatch loop, call frames, method lookup, fibers |
+| [Garbage Collector](internal/gc.md) | Tri-color marking, write barriers, generational GC |
+| [Compiler Pipeline](internal/compiler.md) | Parser, code generator, IRep, binary format |
+| [Opcodes](internal/opcode.md) | VM instruction set reference |
+| [Value Boxing](internal/boxing.md) | How `mrb_value` encodes types |

 ## Release Notes

@@ -205,11 +205,11 @@ mruby's numeric type sizes depend on the boxing mode and platform.

 ### Integer

-| Configuration                          | Range            |
-| -------------------------------------- | ---------------- |
+| Configuration | Range |
+| ------------- | ----- |
 | 64-bit word boxing (default on 64-bit) | roughly +/- 2^62 |
 | 32-bit word boxing (default on 32-bit) | roughly +/- 2^30 |
-| NaN boxing (64-bit only)               | -2^31 to 2^31-1  |
+| NaN boxing (64-bit only) | -2^31 to 2^31-1 |

 Integer overflow raises a `RangeError` unless the `mruby-bigint` gem
 is included, in which case integers automatically promote to
@@ -235,32 +235,32 @@ With word boxing on 64-bit, many float values are stored inline

 These classes are always available in mruby (no gem required):

-| Class         | Notes                                  |
-| ------------- | -------------------------------------- |
-| Object        | Base class for all objects             |
-| Module        | Module definition and mixin            |
-| Class         | Class definition and instantiation     |
-| NilClass      | Singleton `nil`                        |
-| TrueClass     | Singleton `true`                       |
-| FalseClass    | Singleton `false`                      |
-| Integer       | Fixed-precision integer                |
-| Float         | Floating-point (unless `MRB_NO_FLOAT`) |
-| Symbol        | Interned identifier                    |
-| String        | Mutable byte string                    |
-| Array         | Ordered collection                     |
-| Hash          | Key-value mapping                      |
-| Range         | Interval representation                |
-| Proc          | Closure / callable object              |
-| Exception     | Exception hierarchy root               |
-| StandardError | Common error base                      |
+| Class | Notes |
+| ----- | ----- |
+| Object | Base class for all objects |
+| Module | Module definition and mixin |
+| Class | Class definition and instantiation |
+| NilClass | Singleton `nil` |
+| TrueClass | Singleton `true` |
+| FalseClass | Singleton `false` |
+| Integer | Fixed-precision integer |
+| Float | Floating-point (unless `MRB_NO_FLOAT`) |
+| Symbol | Interned identifier |
+| String | Mutable byte string |
+| Array | Ordered collection |
+| Hash | Key-value mapping |
+| Range | Interval representation |
+| Proc | Closure / callable object |
+| Exception | Exception hierarchy root |
+| StandardError | Common error base |

 ### Core Modules

-| Module     | Notes                                     |
-| ---------- | ----------------------------------------- |
-| Kernel     | Core methods (`puts`, `p`, `raise`, etc.) |
-| Comparable | Comparison operators via `<=>`            |
-| Enumerable | Collection iteration methods              |
+| Module | Notes |
+| ------ | ----- |
+| Kernel | Core methods (`puts`, `p`, `raise`, etc.) |
+| Comparable | Comparison operators via `<=>` |
+| Enumerable | Collection iteration methods |

 ## Standard Library (via gemboxes)

@@ -270,70 +270,70 @@ gembox provides the class or feature you need:

 ### Classes and Modules

-| Class/Module          | Gembox     | Gem               |
-| --------------------- | ---------- | ----------------- |
-| Fiber                 | stdlib     | mruby-fiber       |
-| Enumerator            | stdlib     | mruby-enumerator  |
-| Enumerator::Lazy      | stdlib     | mruby-enum-lazy   |
-| Set                   | stdlib     | mruby-set         |
-| ObjectSpace           | stdlib     | mruby-objectspace |
-| Time                  | stdlib-ext | mruby-time        |
-| Struct                | stdlib-ext | mruby-struct      |
-| Data                  | stdlib-ext | mruby-data        |
-| Random                | stdlib-ext | mruby-random      |
-| IO, File              | stdlib-io  | mruby-io          |
-| Socket                | stdlib-io  | mruby-socket      |
-| Dir                   | stdlib-io  | mruby-dir         |
-| Errno                 | stdlib-io  | mruby-errno       |
-| Math                  | math       | mruby-math        |
-| Rational              | math       | mruby-rational    |
-| Complex               | math       | mruby-complex     |
-| Bigint                | math       | mruby-bigint      |
-| Method, UnboundMethod | metaprog   | mruby-method      |
+| Class/Module | Gembox | Gem |
+| ------------ | ------ | --- |
+| Fiber | stdlib | mruby-fiber |
+| Enumerator | stdlib | mruby-enumerator |
+| Enumerator::Lazy | stdlib | mruby-enum-lazy |
+| Set | stdlib | mruby-set |
+| ObjectSpace | stdlib | mruby-objectspace |
+| Time | stdlib-ext | mruby-time |
+| Struct | stdlib-ext | mruby-struct |
+| Data | stdlib-ext | mruby-data |
+| Random | stdlib-ext | mruby-random |
+| IO, File | stdlib-io | mruby-io |
+| Socket | stdlib-io | mruby-socket |
+| Dir | stdlib-io | mruby-dir |
+| Errno | stdlib-io | mruby-errno |
+| Math | math | mruby-math |
+| Rational | math | mruby-rational |
+| Complex | math | mruby-complex |
+| Bigint | math | mruby-bigint |
+| Method, UnboundMethod | metaprog | mruby-method |

 ### Methods and Features

-| Feature                       | Gembox     | Gem                |
-| ----------------------------- | ---------- | ------------------ |
-| `catch`/`throw`               | stdlib     | mruby-catch        |
-| `Kernel#sprintf`, `String#%`  | stdlib-ext | mruby-sprintf      |
-| `Array#pack`, `String#unpack` | stdlib-ext | mruby-pack         |
-| `Kernel#rand`                 | stdlib-ext | mruby-random       |
-| `Kernel#eval`                 | metaprog   | mruby-eval         |
-| `Kernel#binding`              | metaprog   | mruby-binding      |
-| `Proc#binding`                | metaprog   | mruby-proc-binding |
-| Runtime compiler              | metaprog   | mruby-compiler     |
+| Feature | Gembox | Gem |
+| ------- | ------ | --- |
+| `catch`/`throw` | stdlib | mruby-catch |
+| `Kernel#sprintf`, `String#%` | stdlib-ext | mruby-sprintf |
+| `Array#pack`, `String#unpack` | stdlib-ext | mruby-pack |
+| `Kernel#rand` | stdlib-ext | mruby-random |
+| `Kernel#eval` | metaprog | mruby-eval |
+| `Kernel#binding` | metaprog | mruby-binding |
+| `Proc#binding` | metaprog | mruby-proc-binding |
+| Runtime compiler | metaprog | mruby-compiler |

 ### Core Class Extensions

 The `stdlib` gembox also extends built-in classes with additional
 methods. These are included by default:

-| Extension               | Examples                                       |
-| ----------------------- | ---------------------------------------------- |
-| Array extensions        | `#dig`, `#union`, `#difference`                |
-| Hash extensions         | `#dig`, `#transform_keys`, `#transform_values` |
-| String extensions       | `#encode`, `#bytes`, `#chars`                  |
-| Numeric extensions      | `Integer#digits`, `Integer#pow`                |
-| Comparable extensions   | `#clamp`                                       |
-| Enumerable extensions   | `#sort_by`, `#min_by`, `#max_by`, `#tally`     |
-| Range extensions        | `#size`, `#cover?`                             |
-| Proc extensions         | `#<<`, `#>>` (composition)                     |
-| Symbol extensions       | `#to_proc`                                     |
-| Object extensions       | `#then`, `#yield_self`                         |
-| Kernel extensions       | `#__method__`                                  |
-| Class/Module extensions | `Module#name`                                  |
+| Extension | Examples |
+| --------- | -------- |
+| Array extensions | `#dig`, `#union`, `#difference` |
+| Hash extensions | `#dig`, `#transform_keys`, `#transform_values` |
+| String extensions | `#encode`, `#bytes`, `#chars` |
+| Numeric extensions | `Integer#digits`, `Integer#pow` |
+| Comparable extensions | `#clamp` |
+| Enumerable extensions | `#sort_by`, `#min_by`, `#max_by`, `#tally` |
+| Range extensions | `#size`, `#cover?` |
+| Proc extensions | `#<<`, `#>>` (composition) |
+| Symbol extensions | `#to_proc` |
+| Object extensions | `#then`, `#yield_self` |
+| Kernel extensions | `#__method__` |
+| Class/Module extensions | `Module#name` |

 ### Gembox Summary

-| Gembox       | Contents                                      | Notes                                        |
-| ------------ | --------------------------------------------- | -------------------------------------------- |
-| `stdlib`     | Core class extensions, Fiber, Enumerator, Set | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `stdlib-ext` | Time, Struct, Data, Random, sprintf, pack     | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `stdlib-io`  | IO, File, Dir, Socket, Errno                  | Requires stdio                               |
-| `math`       | Math, Rational, Complex, Bigint               | Works with `MRB_NO_STDIO`                    |
-| `metaprog`   | eval, binding, Method, compiler               | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `default`    | All of the above + CLI tools                  | Full installation                            |
+| Gembox | Contents | Notes |
+| ------ | -------- | ----- |
+| `stdlib` | Core class extensions, Fiber, Enumerator, Set | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `stdlib-ext` | Time, Struct, Data, Random, sprintf, pack | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `stdlib-io` | IO, File, Dir, Socket, Errno | Requires stdio |
+| `math` | Math, Rational, Complex, Bigint | Works with `MRB_NO_STDIO` |
+| `metaprog` | eval, binding, Method, compiler | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `default` | All of the above + CLI tools | Full installation |

 ## Key Differences from CRuby

@@ -416,15 +416,15 @@ differently on 32-bit or NaN boxing configurations.

 Key compile-time macros that affect language behavior:

-| Macro                | Effect                             |
-| -------------------- | ---------------------------------- |
-| `MRB_NO_FLOAT`       | Remove all float support           |
-| `MRB_USE_FLOAT32`    | Use 32-bit float instead of double |
-| `MRB_UTF8_STRING`    | Enable UTF-8 string handling       |
-| `MRB_INT32`          | Force 32-bit integer               |
-| `MRB_INT64`          | Force 64-bit integer               |
-| `MRB_STR_LENGTH_MAX` | Max string length (default 1MB)    |
-| `MRB_ARY_LENGTH_MAX` | Max array length (default 2^17)    |
+| Macro | Effect |
+| ----- | ------ |
+| `MRB_NO_FLOAT` | Remove all float support |
+| `MRB_USE_FLOAT32` | Use 32-bit float instead of double |
+| `MRB_UTF8_STRING` | Enable UTF-8 string handling |
+| `MRB_INT32` | Force 32-bit integer |
+| `MRB_INT64` | Force 64-bit integer |
+| `MRB_STR_LENGTH_MAX` | Max string length (default 1MB) |
+| `MRB_ARY_LENGTH_MAX` | Max array length (default 2^17) |

 See [mrbconf.md](mrbconf.md) for the complete list of configuration
 macros.
@@ -202,10 +202,10 @@ any other heap page. The only differences are:
 The page size is controlled by `MRB_HEAP_PAGE_SIZE` (default: 1024 slots).
 Each page occupies:

-| Platform | Slot size | Page size (approx) |
-| -------- | --------- | ------------------ |
-| 64-bit   | 40 bytes  | ~41 KB             |
-| 32-bit   | 24 bytes  | ~25 KB             |
+| Platform | Slot size | Page size (approx)  |
+|----------|-----------|---------------------|
+| 64-bit   | 40 bytes  | ~41 KB              |
+| 32-bit   | 24 bytes  | ~25 KB              |

 To estimate pages for a given buffer: `pages = buffer_size / sizeof(mrb_heap_page)`.
 Each page provides `MRB_HEAP_PAGE_SIZE` object slots.
@@ -233,10 +233,10 @@ end
 - Specifies 4th argument(`argc`) max value of `mrb_funcall`.
 - Raises `ArgumentError` when the `argc` argument is bigger then this value `mrb_funcall`.

-`KHASH_INITIAL_SIZE`
+`KHASH_DEFAULT_SIZE`

 - Default value is `32`.
- Specifies initial size of khash table bucket.
+- Specifies default size of khash table bucket.
 - Used in `kh_init_ ## name` function.

 `MRB_NO_METHOD_CACHE`
@@ -272,7 +272,7 @@ deployment targets. Define one of the following:
 `MRB_CONSTRAINED_BASELINE_PROFILE`

 - For micro controllers.
- Enables `MRB_NO_METHOD_CACHE`, reduces `KHASH_INITIAL_SIZE` to `16`,
+- Enables `MRB_NO_METHOD_CACHE`, reduces `KHASH_DEFAULT_SIZE` to `16`,
  and `MRB_HEAP_PAGE_SIZE` to `256`.

 `MRB_BASELINE_PROFILE`
@@ -31,17 +31,17 @@ struct RBasic (8 bytes on 64-bit)

 All object structs embed this header via `MRB_OBJECT_HEADER`:

-| Struct       | Ruby Type        | Extra Fields                       |
-| ------------ | ---------------- | ---------------------------------- |
-| `RObject`    | Object instances | `iv` (instance variables)          |
-| `RClass`     | Class/Module     | `iv`, `mt` (method table), `super` |
-| `RString`    | String           | embedded or heap buffer, length    |
-| `RArray`     | Array            | embedded or heap buffer, length    |
-| `RHash`      | Hash             | hash table or k-v array            |
-| `RProc`      | Proc/Lambda      | `irep` or C function, environment  |
-| `RData`      | C data wrapper   | `void *data`, `mrb_data_type`      |
-| `RFiber`     | Fiber            | `mrb_context`                      |
-| `RException` | Exception        | `iv`                               |
+| Struct | Ruby Type | Extra Fields |
+| ------ | --------- | ------------ |
+| `RObject` | Object instances | `iv` (instance variables) |
+| `RClass` | Class/Module | `iv`, `mt` (method table), `super` |
+| `RString` | String | embedded or heap buffer, length |
+| `RArray` | Array | embedded or heap buffer, length |
+| `RHash` | Hash | hash table or k-v array |
+| `RProc` | Proc/Lambda | `irep` or C function, environment |
+| `RData` | C data wrapper | `void *data`, `mrb_data_type` |
+| `RFiber` | Fiber | `mrb_context` |
+| `RException` | Exception | `iv` |

 Immediate values (Integer, Symbol, `true`, `false`, `nil`) are encoded
 directly in `mrb_value` without heap allocation. The encoding depends on
@@ -111,52 +111,52 @@ See [compiler.md](compiler.md) for detailed compiler internals,

 ### Core (`src/`)

-| File          | Responsibility                                 |
-| ------------- | ---------------------------------------------- |
-| `vm.c`        | Bytecode dispatch loop, method invocation      |
-| `state.c`     | `mrb_state` init/close, irep management        |
-| `gc.c`        | Garbage collector (mark-sweep, incremental)    |
-| `class.c`     | Class/module definition, method tables         |
-| `object.c`    | Core object operations                         |
-| `variable.c`  | Instance/class/global variables, object shapes |
-| `proc.c`      | Proc/Lambda/closure handling                   |
-| `array.c`     | Array implementation                           |
-| `string.c`    | String implementation (embedded, shared, heap) |
-| `hash.c`      | Hash implementation (open addressing)          |
-| `numeric.c`   | Integer/Float arithmetic                       |
-| `symbol.c`    | Symbol table and interning                     |
-| `range.c`     | Range implementation                           |
-| `error.c`     | Exception creation, raise, backtrace           |
-| `kernel.c`    | Kernel module methods                          |
-| `load.c`      | `.mrb` bytecode loading                        |
-| `dump.c`      | Bytecode serialization (write `.mrb`)          |
-| `print.c`     | Print/puts/p output                            |
-| `backtrace.c` | Stack trace generation                         |
+| File | Responsibility |
+| ---- | -------------- |
+| `vm.c` | Bytecode dispatch loop, method invocation |
+| `state.c` | `mrb_state` init/close, irep management |
+| `gc.c` | Garbage collector (mark-sweep, incremental) |
+| `class.c` | Class/module definition, method tables |
+| `object.c` | Core object operations |
+| `variable.c` | Instance/class/global variables, object shapes |
+| `proc.c` | Proc/Lambda/closure handling |
+| `array.c` | Array implementation |
+| `string.c` | String implementation (embedded, shared, heap) |
+| `hash.c` | Hash implementation (open addressing) |
+| `numeric.c` | Integer/Float arithmetic |
+| `symbol.c` | Symbol table and interning |
+| `range.c` | Range implementation |
+| `error.c` | Exception creation, raise, backtrace |
+| `kernel.c` | Kernel module methods |
+| `load.c` | `.mrb` bytecode loading |
+| `dump.c` | Bytecode serialization (write `.mrb`) |
+| `print.c` | Print/puts/p output |
+| `backtrace.c` | Stack trace generation |

 ### Compiler (`mrbgems/mruby-compiler/core/`)

-| File        | Responsibility                  |
-| ----------- | ------------------------------- |
-| `parse.y`   | Yacc grammar → AST              |
-| `y.tab.c`   | Generated parser (from parse.y) |
-| `codegen.c` | AST → bytecode (irep)           |
-| `node.h`    | AST node type definitions       |
+| File | Responsibility |
+| ---- | -------------- |
+| `parse.y` | Yacc grammar → AST |
+| `y.tab.c` | Generated parser (from parse.y) |
+| `codegen.c` | AST → bytecode (irep) |
+| `node.h` | AST node type definitions |

 ### Key Headers (`include/mruby/`)

-| Header       | Contents                              |
-| ------------ | ------------------------------------- |
-| `mruby.h`    | `mrb_state`, core API declarations    |
-| `value.h`    | `mrb_value`, type enums, value macros |
-| `object.h`   | `RBasic`, `RObject`, object header    |
-| `class.h`    | `RClass`, method table types          |
-| `string.h`   | `RString`, string macros              |
-| `array.h`    | `RArray`, array macros                |
-| `hash.h`     | `RHash`, hash API                     |
-| `data.h`     | `RData`, C data wrapping              |
-| `irep.h`     | `mrb_irep`, bytecode structures       |
-| `compile.h`  | Compiler context, `mrb_load_string`   |
-| `boxing_*.h` | Value boxing implementations          |
+| Header | Contents |
+| ------ | -------- |
+| `mruby.h` | `mrb_state`, core API declarations |
+| `value.h` | `mrb_value`, type enums, value macros |
+| `object.h` | `RBasic`, `RObject`, object header |
+| `class.h` | `RClass`, method table types |
+| `string.h` | `RString`, string macros |
+| `array.h` | `RArray`, array macros |
+| `hash.h` | `RHash`, hash API |
+| `data.h` | `RData`, C data wrapping |
+| `irep.h` | `mrb_irep`, bytecode structures |
+| `compile.h` | Compiler context, `mrb_load_string` |
+| `boxing_*.h` | Value boxing implementations |

 ## mrbgems System

@@ -77,16 +77,16 @@ No boxing represents `mrb_value` by the C struct with `type` and the value union

 ## Comparison

-| Property               | Word Boxing       | NaN Boxing       | No Boxing            |
-| ---------------------- | ----------------- | ---------------- | -------------------- |
-| `mrb_value` size       | 1 word (4/8 byte) | 8 bytes          | 2 words (8/16 bytes) |
-| Default on             | most platforms    | (manual opt-in)  | `host-debug`         |
-| Macro                  | `MRB_WORD_BOXING` | `MRB_NAN_BOXING` | `MRB_NO_BOXING`      |
-| Inline integers        | yes (31/63 bit)   | yes (32 bit)     | yes (full width)     |
-| Inline floats (64-bit) | yes (rotation)    | yes (native)     | yes (struct field)   |
-| Inline floats (32-bit) | no (heap RFloat)  | yes (native)     | yes (struct field)   |
-| Pointer size limit     | none              | 48 bits          | none                 |
-| Debugger friendly      | no                | no               | yes                  |
+| Property               | Word Boxing        | NaN Boxing         | No Boxing            |
+| ---------------------- | ------------------ | ------------------ | -------------------- |
+| `mrb_value` size       | 1 word (4/8 byte)  | 8 bytes            | 2 words (8/16 bytes) |
+| Default on             | most platforms     | (manual opt-in)    | `host-debug`         |
+| Macro                  | `MRB_WORD_BOXING`  | `MRB_NAN_BOXING`   | `MRB_NO_BOXING`      |
+| Inline integers        | yes (31/63 bit)    | yes (32 bit)       | yes (full width)     |
+| Inline floats (64-bit) | yes (rotation)     | yes (native)       | yes (struct field)   |
+| Inline floats (32-bit) | no (heap RFloat)   | yes (native)       | yes (struct field)   |
+| Pointer size limit     | none               | 48 bits            | none                 |
+| Debugger friendly      | no                 | no                 | yes                  |

 ## ABI Compatibility

@@ -40,18 +40,18 @@ file: `mrbgems/mruby-compiler/core/parse.y`.

 The parser maintains extensive state in `mrb_parser_state`:

- **lstate**: current lexer state (EXPR_BEG, EXPR_END, EXPR_ARG,
-  EXPR_DOT, EXPR_FNAME, etc.). Controls how tokens like `+`/`-`
+- **lstate**: current lexer state (EXPR\_BEG, EXPR\_END, EXPR\_ARG,
+  EXPR\_DOT, EXPR\_FNAME, etc.). Controls how tokens like `+`/`-`
  are interpreted (sign vs operator) and whether newlines are
  significant.
 - **locals**: stack of local variable lists (one per scope), stored
  as cons-lists of symbols.
- **lex_strterm**: string/heredoc parsing state for handling nested
+- **lex\_strterm**: string/heredoc parsing state for handling nested
  interpolation.
- **cond_stack**, **cmdarg_stack**: bit stacks tracking
+- **cond\_stack**, **cmdarg\_stack**: bit stacks tracking
  conditional and command argument contexts.
 - **tree**: root AST node after successful parse.
- **error_buffer**: accumulated parse errors.
+- **error\_buffer**: accumulated parse errors.

 ### AST Nodes

@@ -123,10 +123,10 @@ reuse temporaries within an expression.
 Instructions are emitted via helper functions:

 - `genop_0(opcode)`: no operands
- `genop_1(opcode, a)`: one operand (auto-extends with OP_EXT1
+- `genop_1(opcode, a)`: one operand (auto-extends with OP\_EXT1
  if a > 255)
 - `genop_2(opcode, a, b)`: two operands (auto-extends with
-  OP_EXT1/2/3 as needed)
+  OP\_EXT1/2/3 as needed)
 - `genop_3(opcode, a, b, c)`: three operands
 - `genop_W(opcode, a)`: 24-bit operand
 - `genop_2S(opcode, a, b)`: one 8-bit + one 16-bit operand
@@ -176,14 +176,14 @@ mrb_irep

 Pool entries store constants referenced by instructions:

-| Type             | Tag | Description                     |
-| ---------------- | --- | ------------------------------- |
-| `IREP_TT_STR`    | 0   | Dynamic string (heap allocated) |
-| `IREP_TT_SSTR`   | 2   | Static string (read-only)       |
-| `IREP_TT_INT32`  | 1   | 32-bit integer                  |
-| `IREP_TT_INT64`  | 3   | 64-bit integer                  |
-| `IREP_TT_FLOAT`  | 5   | Floating-point number           |
-| `IREP_TT_BIGINT` | 7   | Arbitrary-precision integer     |
+| Type | Tag | Description |
+| ---- | --- | ----------- |
+| `IREP_TT_STR` | 0 | Dynamic string (heap allocated) |
+| `IREP_TT_SSTR` | 2 | Static string (read-only) |
+| `IREP_TT_INT32` | 1 | 32-bit integer |
+| `IREP_TT_INT64` | 3 | 64-bit integer |
+| `IREP_TT_FLOAT` | 5 | Floating-point number |
+| `IREP_TT_BIGINT` | 7 | Arbitrary-precision integer |

 The code generator deduplicates pool entries: identical strings
 and equal numeric values share the same pool index.
@@ -209,28 +209,28 @@ During exception unwinding, handlers are searched in reverse order
 Standard instructions use 8-bit operands. When a value exceeds
 255, extension prefixes widen operands to 16 bits:

-| Prefix    | Effect                            |
-| --------- | --------------------------------- |
-| `OP_EXT1` | First operand (a) becomes 16-bit  |
+| Prefix | Effect |
+| ------ | ------ |
+| `OP_EXT1` | First operand (a) becomes 16-bit |
 | `OP_EXT2` | Second operand (b) becomes 16-bit |
-| `OP_EXT3` | Both a and b become 16-bit        |
+| `OP_EXT3` | Both a and b become 16-bit |

 Instruction formats:

-| Format | Layout                        | Size    |
-| ------ | ----------------------------- | ------- |
-| Z      | opcode only                   | 1 byte  |
-| B      | opcode + a(8)                 | 2 bytes |
-| BB     | opcode + a(8) + b(8)          | 3 bytes |
-| BBB    | opcode + a(8) + b(8) + c(8)   | 4 bytes |
-| BS     | opcode + a(8) + b(16)         | 4 bytes |
-| BSS    | opcode + a(8) + b(16) + c(16) | 6 bytes |
-| S      | opcode + a(16)                | 3 bytes |
-| W      | opcode + a(24)                | 4 bytes |
+| Format | Layout | Size |
+| ------ | ------ | ---- |
+| Z | opcode only | 1 byte |
+| B | opcode + a(8) | 2 bytes |
+| BB | opcode + a(8) + b(8) | 3 bytes |
+| BBB | opcode + a(8) + b(8) + c(8) | 4 bytes |
+| BS | opcode + a(8) + b(16) | 4 bytes |
+| BSS | opcode + a(8) + b(16) + c(16) | 6 bytes |
+| S | opcode + a(16) | 3 bytes |
+| W | opcode + a(24) | 4 bytes |

 See [opcode.md](opcode.md) for the full instruction table.

-## OP_ENTER: Argument Specification
+## OP\_ENTER: Argument Specification

 `OP_ENTER` encodes a method's argument layout in a 24-bit value
 (W format). The bit fields are defined by the `MRB_ARGS_*` macros:
@@ -258,16 +258,16 @@ string interning for common symbols.
 Generated by `lib/mruby/presym.rb`, the presym table maps symbol
 names to compile-time constants:

-| Macro             | Example               | Symbol        |
-| ----------------- | --------------------- | ------------- |
-| `MRB_SYM(name)`   | `MRB_SYM(initialize)` | `:initialize` |
-| `MRB_SYM_B(name)` | `MRB_SYM_B(map)`      | `:map!`       |
-| `MRB_SYM_Q(name)` | `MRB_SYM_Q(nil)`      | `:nil?`       |
-| `MRB_SYM_E(name)` | `MRB_SYM_E(name)`     | `:name=`      |
-| `MRB_OPSYM(op)`   | `MRB_OPSYM(add)`      | `:+`          |
-| `MRB_IVSYM(name)` | `MRB_IVSYM(name)`     | `:@name`      |
-| `MRB_CVSYM(name)` | `MRB_CVSYM(count)`    | `:@@count`    |
-| `MRB_GVSYM(name)` | `MRB_GVSYM(stdout)`   | `:$stdout`    |
+| Macro | Example | Symbol |
+| ----- | ------- | ------ |
+| `MRB_SYM(name)` | `MRB_SYM(initialize)` | `:initialize` |
+| `MRB_SYM_B(name)` | `MRB_SYM_B(map)` | `:map!` |
+| `MRB_SYM_Q(name)` | `MRB_SYM_Q(nil)` | `:nil?` |
+| `MRB_SYM_E(name)` | `MRB_SYM_E(name)` | `:name=` |
+| `MRB_OPSYM(op)` | `MRB_OPSYM(add)` | `:+` |
+| `MRB_IVSYM(name)` | `MRB_IVSYM(name)` | `:@name` |
+| `MRB_CVSYM(name)` | `MRB_CVSYM(count)` | `:@@count` |
+| `MRB_GVSYM(name)` | `MRB_GVSYM(stdout)` | `:$stdout` |

 ## Binary Format (.mrb)

@@ -299,25 +299,25 @@ mrbc -Boutput source.rb           # C array format

 ## Compilation Limits

-| Limit                  | Value                         |
-| ---------------------- | ----------------------------- |
-| Max nesting depth      | 256 (`MRB_CODEGEN_LEVEL_MAX`) |
-| Max local variables    | 255 (uint16 `nlocals`)        |
-| Max symbols per irep   | 65535                         |
-| Max operand (standard) | 255 (8-bit)                   |
-| Max operand (extended) | 65535 (16-bit)                |
+| Limit | Value |
+| ----- | ----- |
+| Max nesting depth | 256 (`MRB_CODEGEN_LEVEL_MAX`) |
+| Max local variables | 255 (uint16 `nlocals`) |
+| Max symbols per irep | 65535 |
+| Max operand (standard) | 255 (8-bit) |
+| Max operand (extended) | 65535 (16-bit) |

 ## Source Files

-| File                                    | Contents                  |
-| --------------------------------------- | ------------------------- |
-| `mrbgems/mruby-compiler/core/parse.y`   | Lrama/Bison grammar       |
-| `mrbgems/mruby-compiler/core/y.tab.c`   | Generated parser          |
-| `mrbgems/mruby-compiler/core/codegen.c` | Code generator            |
-| `mrbgems/mruby-compiler/core/node.h`    | AST node types            |
-| `include/mruby/irep.h`                  | IRep structure definition |
-| `include/mruby/compile.h`               | Compiler context API      |
-| `include/mruby/ops.h`                   | Opcode definitions        |
-| `src/load.c`                            | Binary format loader      |
-| `src/dump.c`                            | Binary format writer      |
-| `lib/mruby/presym.rb`                   | Presym table generator    |
+| File | Contents |
+| ---- | -------- |
+| `mrbgems/mruby-compiler/core/parse.y` | Lrama/Bison grammar |
+| `mrbgems/mruby-compiler/core/y.tab.c` | Generated parser |
+| `mrbgems/mruby-compiler/core/codegen.c` | Code generator |
+| `mrbgems/mruby-compiler/core/node.h` | AST node types |
+| `include/mruby/irep.h` | IRep structure definition |
+| `include/mruby/compile.h` | Compiler context API |
+| `include/mruby/ops.h` | Opcode definitions |
+| `src/load.c` | Binary format loader |
+| `src/dump.c` | Binary format writer |
+| `lib/mruby/presym.rb` | Presym table generator |
@@ -26,12 +26,12 @@ pauses.
 Every heap-allocated object has a color stored in
 `RBasic::gc_color` (3 bits):

-| Color          | Value  | Meaning                              |
-| -------------- | ------ | ------------------------------------ |
-| White (A or B) | 1 or 2 | Unmarked, candidate for collection   |
-| Gray           | 0      | Marked, but children not yet scanned |
-| Black          | 4      | Fully marked and scanned             |
-| Red            | 7      | Static/ROM object, never collected   |
+| Color | Value | Meaning |
+| ----- | ----- | ------- |
+| White (A or B) | 1 or 2 | Unmarked, candidate for collection |
+| Gray | 0 | Marked, but children not yet scanned |
+| Black | 4 | Fully marked and scanned |
+| Red | 7 | Static/ROM object, never collected |

 The GC uses two white types (A and B) in a flip-flop scheme. At the
 start of each GC cycle, the meaning of "current white" is flipped by
@@ -107,7 +107,7 @@ The GC operates as a three-state machine:
 GC_STATE_ROOT --> GC_STATE_MARK --> GC_STATE_SWEEP --> GC_STATE_ROOT
 ```

-### Root Scan (GC_STATE_ROOT)
+### Root Scan (GC\_STATE\_ROOT)

 Marks objects directly reachable from the VM:

@@ -121,7 +121,7 @@ Marks objects directly reachable from the VM:

 After root scanning, the white color is flipped.

-### Incremental Marking (GC_STATE_MARK)
+### Incremental Marking (GC\_STATE\_MARK)

 Gray objects are popped from the gray stack and their children
 marked. Each step processes a limited number of objects:
@@ -137,7 +137,7 @@ When the gray stack is exhausted, the final marking phase re-marks
 the arena and global variables to catch objects created during
 marking, then transitions to sweep.

-### Sweep (GC_STATE_SWEEP)
+### Sweep (GC\_STATE\_SWEEP)

 Iterates through heap pages. For each object:

@@ -325,15 +325,15 @@ From Ruby: `GC.start`.

 ### Compile-Time

-| Macro                          | Default | Description                             |
-| ------------------------------ | ------- | --------------------------------------- |
-| `MRB_HEAP_PAGE_SIZE`           | 1024    | Objects per heap page                   |
-| `MRB_GRAY_STACK_SIZE`          | 1024    | Gray stack capacity                     |
-| `MRB_GC_ARENA_SIZE`            | 100     | Arena size (fixed mode) or initial size |
-| `MRB_GC_FIXED_ARENA`           | off     | Use fixed-size arena                    |
-| `MRB_GC_TURN_OFF_GENERATIONAL` | off     | Disable generational mode               |
-| `MRB_GC_STRESS`                | off     | Full GC on every allocation (debug)     |
-| `MRB_USE_MALLOC_TRIM`          | off     | Call `malloc_trim()` after full GC      |
+| Macro | Default | Description |
+| ----- | ------- | ----------- |
+| `MRB_HEAP_PAGE_SIZE` | 1024 | Objects per heap page |
+| `MRB_GRAY_STACK_SIZE` | 1024 | Gray stack capacity |
+| `MRB_GC_ARENA_SIZE` | 100 | Arena size (fixed mode) or initial size |
+| `MRB_GC_FIXED_ARENA` | off | Use fixed-size arena |
+| `MRB_GC_TURN_OFF_GENERATIONAL` | off | Disable generational mode |
+| `MRB_GC_STRESS` | off | Full GC on every allocation (debug) |
+| `MRB_USE_MALLOC_TRIM` | off | Call `malloc_trim()` after full GC |

 ### Runtime

@@ -350,8 +350,8 @@ GC.disable                 # disable GC

 ## Source Files

-| File                 | Contents                          |
-| -------------------- | --------------------------------- |
-| `src/gc.c`           | GC implementation (~1400 lines)   |
+| File | Contents |
+| ---- | -------- |
+| `src/gc.c` | GC implementation (~1400 lines) |
 | `include/mruby/gc.h` | `mrb_gc` structure, public GC API |
-| `include/mruby.h`    | Arena save/restore macros         |
+| `include/mruby.h` | Arena save/restore macros |
@@ -97,12 +97,12 @@ return n + 1 (skip self)

 ### Call Context Info (cci)

-| Value | Name            | Meaning                               |
-| ----- | --------------- | ------------------------------------- |
-| 0     | `CINFO_NONE`    | Normal VM-to-VM call                  |
-| 1     | `CINFO_DIRECT`  | Explicit VM call (block, lambda.call) |
-| 2     | `CINFO_SKIP`    | Skip frame in stack traces            |
-| 3     | `CINFO_RESUMED` | Fiber resumed (stop execution)        |
+| Value | Name | Meaning |
+| ----- | ---- | ------- |
+| 0 | `CINFO_NONE` | Normal VM-to-VM call |
+| 1 | `CINFO_DIRECT` | Explicit VM call (block, lambda.call) |
+| 2 | `CINFO_SKIP` | Skip frame in stack traces |
+| 3 | `CINFO_RESUMED` | Fiber resumed (stop execution) |

 ## Dispatch Loop

@@ -241,13 +241,13 @@ correctness.

 ### Proc Types

-| Flag                | Meaning                        |
-| ------------------- | ------------------------------ |
-| `MRB_PROC_CFUNC_FL` | C function (not irep-based)    |
-| `MRB_PROC_STRICT`   | Lambda (strict argument check) |
-| `MRB_PROC_ORPHAN`   | No environment attachment      |
-| `MRB_PROC_ENVSET`   | Has captured environment       |
-| `MRB_PROC_SCOPE`    | Defines a new variable scope   |
+| Flag | Meaning |
+| ---- | ------- |
+| `MRB_PROC_CFUNC_FL` | C function (not irep-based) |
+| `MRB_PROC_STRICT` | Lambda (strict argument check) |
+| `MRB_PROC_ORPHAN` | No environment attachment |
+| `MRB_PROC_ENVSET` | Has captured environment |
+| `MRB_PROC_SCOPE` | Defines a new variable scope |

 ## Fiber Switching

@@ -317,9 +317,9 @@ ensuring the incremental GC correctly tracks live references.

 ## Source Files

-| File                    | Contents                                       |
-| ----------------------- | ---------------------------------------------- |
-| `src/vm.c`              | Dispatch loop, method invocation (~1900 lines) |
-| `include/mruby.h`       | `mrb_state`, `mrb_callinfo`, `mrb_context`     |
-| `include/mruby/proc.h`  | `RProc`, `REnv` structures                     |
-| `include/mruby/throw.h` | `MRB_TRY`/`MRB_CATCH` macros                   |
+| File | Contents |
+| ---- | -------- |
+| `src/vm.c` | Dispatch loop, method invocation (~1900 lines) |
+| `include/mruby.h` | `mrb_state`, `mrb_callinfo`, `mrb_context` |
+| `include/mruby/proc.h` | `RProc`, `REnv` structures |
+| `include/mruby/throw.h` | `MRB_TRY`/`MRB_CATCH` macros |
@@ -274,11 +274,11 @@ enabled with the `MRB_UTF8_STRING` compile flag.

 Integer size depends on the value boxing configuration:

-| Configuration                 | Integer range    |
-| ----------------------------- | ---------------- |
+| Configuration | Integer range |
+| ------------- | ------------- |
 | Word boxing, 64-bit (default) | roughly +/- 2^62 |
 | Word boxing, 32-bit (default) | roughly +/- 2^30 |
-| NaN boxing (64-bit only)      | -2^31 to 2^31-1  |
+| NaN boxing (64-bit only) | -2^31 to 2^31-1 |

 Code relying on 64-bit integer precision may behave differently
 across configurations. The `mruby-bigint` gem provides
@@ -138,8 +138,8 @@
 /* turn off generational GC by default */
 //#define MRB_GC_TURN_OFF_GENERATIONAL

-/* initial size of khash table bucket */
-//#define KHASH_INITIAL_SIZE 32
+/* default size of khash table bucket */
+//#define KHASH_DEFAULT_SIZE 32

 /* allocated memory address alignment */
 //#define POOL_ALIGNMENT 4
@@ -208,8 +208,8 @@
 #  define MRB_NO_METHOD_CACHE
 # endif

-# ifndef KHASH_INITIAL_SIZE
-#  define KHASH_INITIAL_SIZE 16
+# ifndef KHASH_DEFAULT_SIZE
+#  define KHASH_DEFAULT_SIZE 16
 # endif

 # ifndef MRB_HEAP_PAGE_SIZE
@@ -21,7 +21,7 @@ typedef uint32_t khint_t;
 typedef khint_t khiter_t;

 #ifndef KHASH_INITIAL_SIZE
-# define KHASH_INITIAL_SIZE 32
+# define KHASH_INITIAL_SIZE 8
 #endif
 #define KHASH_MIN_SIZE 8
 #define KHASH_SMALL_LIMIT 4
@@ -316,11 +316,7 @@ struct RCptr {
 #endif
 #define mrb_test(o)   mrb_bool(o)
 #ifndef mrb_bigint_p
-#ifdef MRB_USE_BIGINT
 #define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
-#else
-#define mrb_bigint_p(o) FALSE
-#endif
 #endif

 /**
@@ -57,7 +57,7 @@ MRB_BEGIN_DECL
 /*
 * Patch level string. (optional)
 */
-#define MRUBY_PATCHLEVEL_STR "RC3"
+#define MRUBY_PATCHLEVEL_STR ""

 #ifndef MRUBY_PATCHLEVEL_STR
 # if MRUBY_PATCHLEVEL < 0
@@ -80,7 +80,7 @@ MRB_BEGIN_DECL
 /*
 * Release year.
 */
-#define MRUBY_RELEASE_YEAR 2026
+#define MRUBY_RELEASE_YEAR 2025

 /*
 * Release month.
@@ -90,7 +90,7 @@ MRB_BEGIN_DECL
 /*
 * Release day.
 */
-#define MRUBY_RELEASE_DAY 2
+#define MRUBY_RELEASE_DAY 20

 /*
 * Release date as a string.
@@ -109,8 +109,7 @@ module MRuby
        if build.kind_of?(MRuby::CrossBuild)
          return %w(x86_64-w64-mingw32 i686-w64-mingw32).include?(build.host_target)
        elsif build.kind_of?(MRuby::Build)
-          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") } ||
-                 ('a'..'z').to_a.any? { |vol| Dir.exist?("/#{vol}/") }
+          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") }
        end
        return false
      end
@@ -611,15 +611,37 @@ class Array
  #   ary.product(*arys)                  ->   array
  #   ary.product(*arys) { |item| ... }   ->   self
  def product(*arys, &block)
-    gen = __product_generate(arys, &block)
-    return gen unless block
-
-    if gen
-      while group = __product_next(arys, gen)
-        yield group
+    size = arys.size
+    i = size
+    while i > 0
+      i -= 1
+      unless arys[i].kind_of?(Array)
+        raise TypeError, "no implicit conversion into Array"
      end
    end
-    self
+
+    i = size
+    total = self.size
+    total *= arys[i -= 1].size while i > 0
+
+    if block
+      i = 0
+      while i < total
+        group = self.__product_group(arys, i, size + 1)
+        block.call(group)
+        i += 1
+      end
+      return self
+    else
+      result = [nil] * total
+      i = 0
+      while i < total
+        group = self.__product_group(arys, i, size + 1)
+        result[i] = group
+        i += 1
+      end
+      return result
+    end
  end

  ##
@@ -6,7 +6,6 @@
 #include <mruby/hash.h>
 #include <mruby/data.h>
 #include <mruby/class.h>
-#include <mruby/numeric.h>
 #include <mruby/internal.h>
 #include <mruby/khash.h>
 #include <mruby/error.h>
@@ -79,14 +78,11 @@ ary_assoc(mrb_state *mrb, mrb_value ary)
 {
  mrb_value k = mrb_get_arg1(mrb);

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
    mrb_value v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
-    mrb_gc_protect(mrb, v); // v may be removed from ary by mrb_equal()
    if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 &&
        mrb_equal(mrb, RARRAY_PTR(v)[0], k))
      return v;
-    mrb_gc_arena_restore(mrb, ai);
  }
  return mrb_nil_value();
 }
@@ -110,15 +106,12 @@ ary_rassoc(mrb_state *mrb, mrb_value ary)
 {
  mrb_value value = mrb_get_arg1(mrb);

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
    mrb_value v = RARRAY_PTR(ary)[i];
-    mrb_gc_protect(mrb, v); // v may be removed from ary by mrb_equal()
    if (mrb_array_p(v) &&
        RARRAY_LEN(v) > 1 &&
        mrb_equal(mrb, RARRAY_PTR(v)[1], value))
      return v;
-    mrb_gc_arena_restore(mrb, ai);
  }
  return mrb_nil_value();
 }
@@ -416,12 +409,9 @@ ary_init_temp_set(mrb_state *mrb, ary_set_t *set, mrb_int capacity)
 static void
 ary_populate_temp_set(mrb_state *mrb, ary_set_t *set, mrb_value ary)
 {
-  int ai = mrb_gc_arena_save(mrb);
-  for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
-    mrb_value p = RARRAY_PTR(ary)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from ary by kh_put(ary_set, ...)
-    kh_put(ary_set, mrb, set, p);
-    mrb_gc_arena_restore(mrb, ai);
+  mrb_int len = RARRAY_LEN(ary);
+  for (mrb_int i = 0; i < len; i++) {
+    kh_put(ary_set, mrb, set, RARRAY_PTR(ary)[i]);
  }
 }

@@ -470,15 +460,12 @@ ary_subtract_body(mrb_state *mrb, void *data)
    ary_populate_temp_set(mrb, ctx->set, ctx->argv[i]);
  }

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->self); i++) {
    mrb_value p = RARRAY_PTR(ctx->self)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from self by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
    if (kh_is_end(ctx->set, k)) {  /* key doesn't exist in any ary */
      mrb_ary_push(mrb, ctx->result, p);
    }
-    mrb_gc_arena_restore(mrb, ai);
  }

  return ctx->result;
@@ -512,13 +499,13 @@ ary_subtract_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_va
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
+    mrb_int self_len = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < self_len; i++) {
      mrb_value p = RARRAY_PTR(self)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from self by mrb_equal()
      mrb_bool found = FALSE;
      for (mrb_int j = 0; j < argc; j++) {
-        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
+        mrb_int len = RARRAY_LEN(argv[j]);
+        for (mrb_int k = 0; k < len; k++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
            found = TRUE;
            break;
@@ -529,7 +516,6 @@ ary_subtract_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_va
      if (!found) {
        mrb_ary_push(mrb, result, p);
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -573,10 +559,12 @@ ary_difference(mrb_state *mrb, mrb_value self)
  return ary_subtract_internal(mrb, self, argc, argv);
 }

+
 static void
 add_uniq(mrb_state *mrb, mrb_value item, mrb_value result)
 {
-  for (mrb_int i = 0; i < RARRAY_LEN(result); i++) {
+  const mrb_int len = RARRAY_LEN(result);
+  for (mrb_int i = 0; i < len; i++) {
    if (mrb_eql(mrb, item, RARRAY_PTR(result)[i])) {
      return;
    }
@@ -596,18 +584,15 @@ static mrb_value
 ary_union_body(mrb_state *mrb, void *data)
 {
  struct ary_union_ctx *ctx = (struct ary_union_ctx *)data;
-  int ai = mrb_gc_arena_save(mrb);

  /* Add unique elements from self */
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->self_copy); i++) {
    mrb_value elem = RARRAY_PTR(ctx->self_copy)[i];
-    mrb_gc_protect(mrb, elem); // elem may be removed from self_copy by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
    if (kh_is_end(ctx->set, k)) {
      kh_put(ary_set, mrb, ctx->set, elem);
      mrb_ary_push(mrb, ctx->result, elem);
    }
-    mrb_gc_arena_restore(mrb, ai);
  }

  /* Add unique elements from others */
@@ -615,13 +600,11 @@ ary_union_body(mrb_state *mrb, void *data)
    mrb_value other = ctx->argv[i];
    for (mrb_int j = 0; j < RARRAY_LEN(other); j++) {
      mrb_value elem = RARRAY_PTR(other)[j];
-      mrb_gc_protect(mrb, elem); // elem may be removed from other by kh_get(ary_set, ...)
      khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
      if (kh_is_end(ctx->set, k)) {
        kh_put(ary_set, mrb, ctx->set, elem);
        mrb_ary_push(mrb, ctx->result, elem);
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -653,25 +636,19 @@ ary_union_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_value
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-
    /* Use linear search for small arrays */
    /* Add unique elements from self */
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
-      mrb_value p = RARRAY_PTR(self)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from self by add_uniq()
-      add_uniq(mrb, p, result);
-      mrb_gc_arena_restore(mrb, ai);
+    mrb_int alen = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < alen; i++) {
+      add_uniq(mrb, RARRAY_PTR(self)[i], result);
    }

    /* Add unique elements from others */
    for (mrb_int i = 0; i < argc; i++) {
      mrb_value other = argv[i];
-      for (mrb_int j = 0; j < RARRAY_LEN(other); j++) {
-        mrb_value p = RARRAY_PTR(other)[j];
-        mrb_gc_protect(mrb, p); // p may be removed from other by add_uniq()
-        add_uniq(mrb, p, result);
-        mrb_gc_arena_restore(mrb, ai);
+      mrb_int olen = RARRAY_LEN(other);
+      for (mrb_int j = 0; j < olen; j++) {
+        add_uniq(mrb, RARRAY_PTR(other)[j], result);
      }
    }
  }
@@ -734,16 +711,13 @@ ary_intersection_body(mrb_state *mrb, void *data)
    ary_populate_temp_set(mrb, ctx->set, ctx->argv[i]);
  }

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->self); i++) {
    mrb_value p = RARRAY_PTR(ctx->self)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from self by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
    if (!kh_is_end(ctx->set, k)) {
      mrb_ary_push(mrb, ctx->result, p);
      kh_del(ary_set, mrb, ctx->set, k);
    }
-    mrb_gc_arena_restore(mrb, ai);
  }

  return ctx->result;
@@ -777,15 +751,15 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
+    mrb_int self_len = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < self_len; i++) {
      mrb_value p = RARRAY_PTR(self)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from self by mrb_equal()
      mrb_bool found_in_all = TRUE;

      for (mrb_int j = 0; j < argc; j++) {
        mrb_bool found_in_current_other = FALSE;
-        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
+        mrb_int len = RARRAY_LEN(argv[j]);
+        for (mrb_int k = 0; k < len; k++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
            found_in_current_other = TRUE;
            break;
@@ -799,7 +773,8 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr

      if (found_in_all) {
        mrb_bool already_added = FALSE;
-        for (mrb_int j = 0; j < RARRAY_LEN(result); j++) {
+        mrb_int result_len = RARRAY_LEN(result);
+        for (mrb_int j = 0; j < result_len; j++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(result)[j])) {
            already_added = TRUE;
            break;
@@ -809,7 +784,6 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
          mrb_ary_push(mrb, result, p);
        }
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }
  return result;
@@ -880,12 +854,8 @@ ary_intersect_p_body(mrb_state *mrb, void *data)

  ary_populate_temp_set(mrb, ctx->set, ctx->shorter_ary_copy);

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->longer_ary); i++) {
-    mrb_value p = RARRAY_PTR(ctx->longer_ary)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from longer_ary by kh_get(ary_set, ...)
-    khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
-    mrb_gc_arena_restore(mrb, ai);
+    khiter_t k = kh_get(ary_set, mrb, ctx->set, RARRAY_PTR(ctx->longer_ary)[i]);
    if (!kh_is_end(ctx->set, k)) {
      *ctx->found = TRUE;
      break;
@@ -935,16 +905,12 @@ ary_intersect_p(mrb_state *mrb, mrb_value self)
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
    for (mrb_int i = 0; i < RARRAY_LEN(longer_ary); i++) {
-      mrb_value p = RARRAY_PTR(longer_ary)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from longer_ary by mrb_equal()
      for (mrb_int j = 0; j < RARRAY_LEN(shorter_ary); j++) {
-        if (mrb_equal(mrb, p, RARRAY_PTR(shorter_ary)[j])) {
+        if (mrb_equal(mrb, RARRAY_PTR(longer_ary)[i], RARRAY_PTR(shorter_ary)[j])) {
          return mrb_true_value();
        }
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1075,7 +1041,6 @@ ary_fill_exec(mrb_state *mrb, mrb_value self)
  }

  /* Fill the array */
-  mrb_ary_modify(mrb, ary);
  mrb_value *ptr = ARY_PTR(ary) + start;
  for (mrb_int i = 0; i < length; i++) {
    ptr[i] = obj;
@@ -1093,6 +1058,7 @@ struct ary_uniq_bang_ctx {
  mrb_value self_copy;
  mrb_value self;
  mrb_int *write_pos;
+  mrb_int len;
 };

 static mrb_value
@@ -1102,19 +1068,15 @@ ary_uniq_bang_body(mrb_state *mrb, void *data)

  ary_populate_temp_set(mrb, ctx->set, ctx->self_copy);

-  int ai = mrb_gc_arena_save(mrb);
-  for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(ctx->self); read_pos++) {
+  for (mrb_int read_pos = 0; read_pos < ctx->len; read_pos++) {
    mrb_value elem = RARRAY_PTR(ctx->self)[read_pos];
-    mrb_gc_protect(mrb, elem); // elem may be removed from self by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
    if (!kh_is_end(ctx->set, k)) {
-      if (*ctx->write_pos != read_pos && *ctx->write_pos < RARRAY_LEN(ctx->self)) {
-        mrb_ary_modify(mrb, mrb_ary_ptr(ctx->self));
+      if (*ctx->write_pos != read_pos) {
        RARRAY_PTR(ctx->self)[*ctx->write_pos] = elem;
      }
      (*ctx->write_pos)++;
      kh_del(ary_set, mrb, ctx->set, k);
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1141,32 +1103,28 @@ ary_uniq_bang(mrb_state *mrb, mrb_value self)
    ary_set_t *set = &set_struct;
    ary_init_temp_set(mrb, set, len);

-    struct ary_uniq_bang_ctx ctx = { set, self_copy, self, &write_pos };
+    struct ary_uniq_bang_ctx ctx = { set, self_copy, self, &write_pos, len };
    mrb_value result;
    MRB_ENSURE(mrb, result, ary_uniq_bang_body, &ctx) {
      ary_destroy_temp_set(mrb, set);
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(self); read_pos++) {
+    for (mrb_int read_pos = 0; read_pos < len; read_pos++) {
      mrb_value elem = RARRAY_PTR(self)[read_pos];
-      mrb_gc_protect(mrb, elem); // elem may be removed from self by mrb_equal()
      mrb_bool found = FALSE;
-      for (mrb_int j = 0; j < write_pos && j < RARRAY_LEN(self); j++) {
+      for (mrb_int j = 0; j < write_pos; j++) {
        if (mrb_equal(mrb, elem, RARRAY_PTR(self)[j])) {
          found = TRUE;
          break;
        }
      }
      if (!found) {
-        if (write_pos != read_pos && write_pos < RARRAY_LEN(self)) {
-          mrb_ary_modify(mrb, mrb_ary_ptr(self));
+        if (write_pos != read_pos) {
          RARRAY_PTR(self)[write_pos] = elem;
        }
        write_pos++;
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1415,13 +1373,6 @@ ary_insert(mrb_state *mrb, mrb_value self)
  return self;
 }

-struct ary_product_generator {
-  mrb_int total;
-  mrb_int cursor;
-};
-
-static struct mrb_data_type ary_product_generator_type = { "ary_product_generator", mrb_free };
-
 /*
 *  Internal helper for Array#product to construct a group array.
 *  Takes the base array (self), the array of other arrays (arys),
@@ -1429,85 +1380,29 @@ static struct mrb_data_type ary_product_generator_type = { "ary_product_generato
 *  of the group array (group_len).
 */
 static mrb_value
-ary_product_fetch(mrb_state *mrb, mrb_value self_ary, mrb_value arys_ary, mrb_int n)
+ary_product_group(mrb_state *mrb, mrb_value self_ary)
 {
-  mrb_int j = RARRAY_LEN(arys_ary); // Corresponds to 'size' in Ruby
-  mrb_value group = mrb_ary_new_capa(mrb, j + 1 /* self_ary */);
+  mrb_value arys_ary;
+  mrb_int current_i, group_len;
+  mrb_get_args(mrb, "Aii", &arys_ary, &current_i, &group_len);

-  while (j-- > 0) {
+  mrb_value group = mrb_ary_new_capa(mrb, group_len);
+  mrb_int j = RARRAY_LEN(arys_ary); // Corresponds to 'size' in Ruby
+  mrb_int n = current_i;
+
+  while (j > 0) {
+    j -= 1;
    mrb_value a = RARRAY_PTR(arys_ary)[j]; // arys[j]
    mrb_check_type(mrb, a, MRB_TT_ARRAY);
    mrb_int b = RARRAY_LEN(a);             // a.size
-    if (b <= 0) {
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot compute product with an empty array");
-    }
    mrb_ary_set(mrb, group, j + 1, RARRAY_PTR(a)[n % b]);
    n /= b;
  }
-  if (n >= RARRAY_LEN(self_ary)) {
-    mrb_raise(mrb, E_INDEX_ERROR, "index out of range");
-  }
  mrb_ary_set(mrb, group, 0, RARRAY_PTR(self_ary)[n]);

  return group;
 }

-static mrb_value
-ary_product_generate(mrb_state *mrb, mrb_value self)
-{
-  mrb_value arys_ary, block;
-  mrb_get_args(mrb, "A&", &arys_ary, &block);
-
-  mrb_int total = RARRAY_LEN(self);
-  for (mrb_int i = 0; i < RARRAY_LEN(arys_ary); i++) {
-    mrb_value a = RARRAY_PTR(arys_ary)[i];
-    mrb_check_type(mrb, a, MRB_TT_ARRAY);
-    mrb_int n = RARRAY_LEN(a);
-    if (n == 0) {
-      total = 0;
-      break;
-    }
-    if (mrb_int_mul_overflow(total, n, &total)) {
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "result too big");
-    }
-  }
-
-  if (mrb_nil_p(block)) {
-    mrb_value result = mrb_ary_new_capa(mrb, total);
-    for (mrb_int i = 0; i < total; i++) {
-      mrb_value group = ary_product_fetch(mrb, self, arys_ary, i);
-      mrb_ary_push(mrb, result, group);
-    }
-    return result;
-  }
-  else if (total > 0) {
-    struct RData *d;
-    struct ary_product_generator *g;
-    Data_Make_Struct(mrb, mrb->object_class, struct ary_product_generator,
-                     &ary_product_generator_type, g, d);
-    g->total = total;
-    g->cursor = 0;
-    return mrb_obj_value(d);
-  }
-  else {
-    return mrb_nil_value();
-  }
-}
-
-static mrb_value
-ary_product_next(mrb_state *mrb, mrb_value self)
-{
-  mrb_value arys;
-  struct ary_product_generator *g;
-  mrb_get_args(mrb, "Ad", &arys, &g, &ary_product_generator_type);
-
-  if (g->cursor >= g->total) {
-    return mrb_nil_value();
-  }
-
-  return ary_product_fetch(mrb, self, arys, g->cursor++);
-}
-
 /*
 *  call-seq:
 *     ary.deconstruct -> ary
@@ -1668,8 +1563,7 @@ static const mrb_mt_entry array_ext_rom_entries[] = {
  MRB_MT_ENTRY(ary_fetch,              MRB_SYM(__fetch),            MRB_ARGS_REQ(3)),
  MRB_MT_ENTRY(ary_insert,             MRB_SYM(insert),             MRB_ARGS_ARG(1,-1)),
  MRB_MT_ENTRY(ary_deconstruct,        MRB_SYM(deconstruct),        MRB_ARGS_NONE()),
-  MRB_MT_ENTRY(ary_product_generate,   MRB_SYM(__product_generate), MRB_ARGS_REQ(1)),
-  MRB_MT_ENTRY(ary_product_next,       MRB_SYM(__product_next),     MRB_ARGS_REQ(2)),
+  MRB_MT_ENTRY(ary_product_group,      MRB_SYM(__product_group),    MRB_ARGS_REQ(3)),
  MRB_MT_ENTRY(ary_combination_init,   MRB_SYM(__combination_init), MRB_ARGS_REQ(2)),
  MRB_MT_ENTRY(ary_combination_next,   MRB_SYM(__combination_next), MRB_ARGS_REQ(1)),
 };
@@ -3175,12 +3175,8 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
 {
  if (val) {
    int array_size = 0;
-    int first = 1;
-    int slimit = GEN_LIT_ARY_MAX;
    node *current = tree;

-    if (cursp() >= slimit) slimit = GEN_VAL_STACK_MAX;
-
    /* Process each segment separated by NODE_LITERAL_DELIM */
    while (current) {
      /* Find the segment boundaries without allocating */
@@ -3217,24 +3213,6 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)

        /* Only process non-empty segments */
        if (!is_empty_segment) {
-          /* Flush accumulated elements when stack is full */
-          if (cursp() >= slimit) {
-            if (array_size > 0) {
-              pop_n(array_size);
-              if (first) {
-                genop_2(s, OP_ARRAY, cursp(), array_size);
-                push();
-                first = 0;
-              }
-              else {
-                pop();
-                genop_2(s, OP_ARYPUSH, cursp(), array_size);
-                push();
-              }
-              array_size = 0;
-            }
-          }
-
          /* Temporarily terminate the segment by saving and clearing the cdr */
          node *saved_cdr = NULL;
          if (segment_prev) {
@@ -3265,14 +3243,8 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
      }
    }

-    /* Handle remaining elements */
-    if (!first) {
-      if (array_size > 0) {
-        pop_n(array_size + 1);
-        genop_2(s, OP_ARYPUSH, cursp(), array_size);
-      }
-    }
-    else if (array_size > 0) {
+    /* Generate the array from pushed elements */
+    if (array_size > 0) {
      pop_n(array_size);
      genop_2(s, OP_ARRAY, cursp(), array_size);
    }
@@ -4455,9 +4427,10 @@ codegen_case_match(codegen_scope *s, node *varnode, int val)
    current_in = current_in->cdr;
  }

-  /* No pattern matched - raise NoMatchingPatternError */
-  genop_1(s, OP_LOADFALSE, cursp());
-  genop_1(s, OP_MATCHERR, cursp());
+  /* No pattern matched - generate nil or error */
+  if (val) {
+    genop_1(s, OP_LOADNIL, cursp());
+  }

  /* Dispatch all end jumps */
  if (case_end_jumps != JMPLINK_START) {
@@ -3260,7 +3260,7 @@ primary         : literal
                      $<stack>$ = p->cmdarg_stack;
                      p->cmdarg_stack = 0;
                    }
-                  compstmt {p->lstate = EXPR_ENDARG;} rparen
+                  stmt {p->lstate = EXPR_ENDARG;} rparen
                    {
                      p->cmdarg_stack = $<stack>2;
                      $$ = $3;
@@ -4563,13 +4563,13 @@ f_label         : tIDENTIFIER tLABEL_TAG
                    {
                      $$ = $1;
                      local_nest(p);
-                      p->lstate = EXPR_MID;  /* make newlines significant after label */
+                      p->lstate = EXPR_ARG;  /* make newlines significant after label */
                    }
                | tNUMPARAM tLABEL_TAG
                    {
                      $$ = intern_numparam($1);
                      local_nest(p);
-                      p->lstate = EXPR_MID;  /* make newlines significant after label */
+                      p->lstate = EXPR_ARG;  /* make newlines significant after label */
                    }
                ;

@@ -291,12 +291,11 @@ class Enumerator
    #
    def flat_map(&block)
      Lazy.new(self){|yielder, val|
-        result = block.call(val)
-        if result.respond_to?(:each)
-          result.each {|x| yielder << x }
-        else
-          yielder << result
-        end
+        ary = block.call(val)
+        # TODO: check ary is an Array
+        ary.each {|x|
+          yielder << x
+        }
      }
    end
    alias collect_concat flat_map
@@ -46,18 +46,6 @@ assert("Enumerator::Lazy#to_enum") do
  assert_equal [0*1, 2*3, 4*5, 6*7], lazy_enum.map { |a| a.first * a.last }.first(4)
 end

-assert("Enumerator::Lazy#flat_map with array from block") do
-  assert_equal [1, 10, 2, 20, 3, 30], [1, 2, 3].lazy.flat_map {|x| [x, x*10]}.force
-end
-
-assert("Enumerator::Lazy#flat_map with non-enumerable from block") do
-  assert_equal [1, 2, 3], [1, 2, 3].lazy.flat_map {|x| x}.force
-end
-
-assert("Enumerator::Lazy#flat_map with nested array from block") do
-  assert_equal [[1, 2], [3, 4]], [1, 3].lazy.flat_map {|x| [[x, x+1]]}.force
-end
-
 assert("Enumerator::Lazy#grep_v") do
  lazy_grep_v = (0..).lazy.grep_v(2..4)
  assert_kind_of Enumerator::Lazy, lazy_grep_v
@@ -190,7 +190,11 @@ int_powm(mrb_state *mrb, mrb_value x)
    return mrb_int_pow(mrb, x, mrb_get_arg1(mrb));
  }
  mrb_get_args(mrb, "oo", &e, &m);
-  if (!mrb_integer_p(e) && !mrb_bigint_p(e)) {
+  if (!mrb_integer_p(e)
+#ifdef MRB_USE_BIGINT
+      && !mrb_bigint_p(e)
+#endif
+      ) {
    mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): 2nd argument not allowed unless 1st argument is an integer");
  }
 #ifdef MRB_USE_BIGINT
@@ -701,11 +701,13 @@ class UDPSocket < IPSocket
  #   data, addr = sock.recvfrom_nonblock(1024)
  #
  def recvfrom_nonblock(*args)
+    s = self
    begin
      self._setnonblock(true)
      self.recvfrom(*args)
    ensure
-      self._setnonblock(false)
+      # XXX: self is a SystemcallException here! (should be bug)
+      s._setnonblock(false)
    end
  end

@@ -19,11 +19,9 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
  file assert_c => [assert_rb, build.mrbcfile] do |t|
    _pp "GEN", t.name.relative_path
    mkdir_p File.dirname(t.name)
-    tmpfile = t.name + ".tmp"
-    open(tmpfile, 'w') do |f|
+    open(t.name, 'w') do |f|
      mrbc.run f, assert_rb, 'mrbtest_assert_irep', cdump: false
    end
-    File.rename(tmpfile, t.name)
  end

  gem_table = build.gems.generate_gem_table build
@@ -38,8 +36,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
    file g.test_rbireps => [g.test_rbfiles, build.mrbcfile].flatten do |t|
      _pp "GEN", t.name.relative_path
      mkdir_p File.dirname(t.name)
-      tmpfile = t.name + ".tmp"
-      open(tmpfile, 'w') do |f|
+      open(t.name, 'w') do |f|
        g.print_gem_test_header(f)
        test_preload = g.test_preload and [g.dir, MRUBY_ROOT].map {|dir|
          File.expand_path(g.test_preload, dir)
@@ -120,7 +117,6 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
        end
        f.puts %Q[}]
      end
-      File.rename(tmpfile, t.name)
    end
  end

@@ -138,8 +134,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
  file clib => ["#{build.build_dir}/mrbgems/active_gems.txt", build.mrbcfile, __FILE__] do |_t|
    _pp "GEN", clib.relative_path
    mkdir_p File.dirname(clib)
-    tmpfile = clib + ".tmp"
-    open(tmpfile, 'w') do |f|
+    open(clib, 'w') do |f|
      f.puts %Q[/*]
      f.puts %Q[ * This file contains a list of all]
      f.puts %Q[ * test functions.]
@@ -174,6 +169,5 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
      end
      f.puts %Q[}]
    end
-    File.rename(tmpfile, clib)
  end
 end
@@ -2748,7 +2748,7 @@ prepare_writer_name(mrb_state *mrb, mrb_sym sym)
 }

 static mrb_value
-mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_int aargc, mrb_value (*accessor)(mrb_state*, mrb_value), mrb_sym (*access_name)(mrb_state*, mrb_sym))
+mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_value (*accessor)(mrb_state*, mrb_value), mrb_sym (*access_name)(mrb_state*, mrb_sym))
 {
  struct RClass *c = mrb_class_ptr(mod);
  const mrb_value *argv;
@@ -2765,7 +2765,6 @@ mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_int aargc, mrb_value (*access
    }

    struct RProc *p = mrb_proc_new_cfunc_with_env(mrb, accessor, 1, &name);
-    p->flags |= aargc == 0 ? MRB_PROC_NOARG : 0;
    mrb_method_t m;
    MRB_METHOD_FROM_PROC(m, p);
    mrb_define_method_raw(mrb, c, method, m);
@@ -2784,7 +2783,7 @@ attr_reader(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_mod_attr_reader(mrb_state *mrb, mrb_value mod)
 {
-  return mod_attr_define(mrb, mod, 0, attr_reader, NULL);
+  return mod_attr_define(mrb, mod, attr_reader, NULL);
 }

 static mrb_value
@@ -2800,7 +2799,7 @@ attr_writer(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_mod_attr_writer(mrb_state *mrb, mrb_value mod)
 {
-  return mod_attr_define(mrb, mod, 1, attr_writer, prepare_writer_name);
+  return mod_attr_define(mrb, mod, attr_writer, prepare_writer_name);
 }

 static mrb_value
@@ -541,15 +541,15 @@ mrb_gc_unregister(mrb_state *mrb, mrb_value obj)
  if (!mrb_array_p(table)) return;
  struct RArray *a = mrb_ary_ptr(table);
  mrb_ary_modify(mrb, a);
-  mrb_int len = ARY_LEN(a);
+  mrb_int len = ARY_LEN(a)-1;
  mrb_value *ptr = ARY_PTR(a);
-  mrb_int w = 0;
-  for (mrb_int r = 0; r < len; r++) {
-    if (mrb_ptr(ptr[r]) != mrb_ptr(obj)) {
-      ptr[w++] = ptr[r];
+  for (mrb_int i = 0; i <= len; i++) {
+    if (mrb_ptr(ptr[i]) == mrb_ptr(obj)) {
+      ARY_SET_LEN(a, len);
+      memmove(&ptr[i], &ptr[i + 1], (len - i) * sizeof(mrb_value));
+      break;
    }
  }
-  ARY_SET_LEN(a, w);
 }

 MRB_API struct RBasic*
@@ -432,7 +432,11 @@ mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, con
  for (mrb_int i = 0; i < argc; i++) {
    mrb_value v = argv[i];

-    if (mrb_integer_p(v) || mrb_bigint_p(v)) {
+    if (mrb_integer_p(v)
+#ifdef MRB_USE_BIGINT
+        || mrb_bigint_p(v)
+#endif
+        ) {
      mrb_int i = mrb_as_int(mrb, v);
      mrb_ary_push(mrb, result, func(mrb, obj, i));
    }
@@ -134,29 +134,19 @@ static inline void
 envadjust(mrb_state *mrb, mrb_value *oldbase, mrb_value *newbase)
 {
  mrb_callinfo *ci = mrb->c->cibase;
-  /*
-   * Byte-level calculation to avoid truncation when allocator alignment is
-   * smaller than sizeof(mrb_value).
-   * eg: MRB_NO_BOXING + MRB_INT64 with MRB_32BIT => sizeof(mrb_value)=16
-   *     And when memory allocator's alignment is 8 bytes
-   * Pointer subtraction on mrb_value* would truncate (8/16 -> 0).
-   * So, we use char* for pointer calculation to get the correct offset in bytes,
-   * then apply that offset to mrb_value* pointers.
-   */
-  ptrdiff_t off = (char *)newbase - (char *)oldbase;
+  ptrdiff_t delta = newbase - oldbase;

-  if (off == 0) return;
+  if (delta == 0) return;
  while (ci <= mrb->c->ci) {
    struct REnv *e = mrb_vm_ci_env(ci);

-    mrb_value *new_stack = (mrb_value *)((char *)ci->stack + off);
-
    if (e) {
      mrb_assert(e->cxt == mrb->c && MRB_ENV_ONSTACK_P(e));
      mrb_assert(e->stack == ci->stack);
-      e->stack = new_stack;
+
+      e->stack += delta;
    }
-    ci->stack = new_stack;
+    ci->stack += delta;
    ci++;
  }
 }
@@ -2713,10 +2703,11 @@ RETRY_TRY_BLOCK:
      if (kidx < 0 || !mrb_hash_p(kdict=regs[kidx]) || !mrb_hash_key_p(mrb, kdict, k)) {
        RAISE_FORMAT(mrb, E_ARGUMENT_ERROR, "missing keyword: %v", k);
      }
-
-      v = mrb_hash_delete_key(mrb, kdict, k);
+      v = mrb_hash_get(mrb, kdict, k);
      ci = mrb->c->ci;
      regs[a] = v;
+      mrb_hash_delete_key(mrb, kdict, k);
+      ci = mrb->c->ci;
      NEXT;
    }

@@ -3122,9 +3113,7 @@ RETRY_TRY_BLOCK:
      {                                                                     \
        mrb_value arg = mrb_int_value(mrb, c);                              \
        mrb_sym mid = MRB_OPSYM(op_name);                                   \
-        mrb_value v = mrb_funcall_argv(mrb, regs[a], mid, 1, &arg);         \
-        ci = mrb->c->ci;                                                    \
-        regs[a] = v;                                                        \
+        regs[a] = mrb_funcall_argv(mrb, regs[a], mid, 1, &arg);             \
        mrb_gc_arena_restore(mrb, ai);                                      \
      }                                                                     \
      break;                                                                \
@@ -29,7 +29,7 @@ MRuby.each_target do |build|
    end
  end

-  presym_task = file presym.list_path => ppps do
+  file presym.list_path => ppps do
    presyms = presym.scan(ppps)
    current_presyms = presym.read_list if File.exist?(presym.list_path)
    if presyms != current_presyms
@@ -41,21 +41,6 @@ MRuby.each_target do |build|
    end
  end

-  # Don't directly write dependency tasks in the "task" arguments.
-  # The rake system tracks dependencies recursively
-  # (see Rake::Task#all_prerequisite_tasks and #collect_prerequisites).
-  # Therefore, indirect dependencies from ".o" to ".pi" must be eliminated.
-  # ref. https://github.com/mruby/mruby/issues/6721
-  # This task acts a proxy-like for the "presym.list_path" task.
-  presym_proxy = task "gensym:update:#{build.name}" do
-    presym_task.invoke
-  end
-
-  # Override the "timestamp" method to reflect the presym file.
-  presym_proxy.define_singleton_method :timestamp do
-    presym_task.timestamp
-  end
-
  # Ensure .o files depend on presym headers being generated.
  # This is critical when a build's .o files are compiled during another
  # build's presym scanning chain (before :gensym completes), e.g.:
@@ -65,7 +50,7 @@ MRuby.each_target do |build|
    next unless File.extname(prereq) == build.exts.object
    next unless prereq.start_with?(build_dir)
    next if mrbc_build_dir && prereq.start_with?(mrbc_build_dir)
-    file prereq => presym_proxy
+    file prereq => presym.list_path
  end

  task gensym: presym.list_path
@@ -163,9 +163,6 @@ assert('Module#attr_reader', '15.2.2.4.13') do

  AttrTestReader.cattr_val = 'test'
  assert_equal 'test', AttrTestReader.cattr
-
-  assert_raise(ArgumentError) { attr_instance.iattr(1) }
-  assert_raise(ArgumentError) { attr_instance.iattr(1, 2, 3) }
 end

 assert('Module#attr_writer', '15.2.2.4.14') do
@@ -680,20 +680,6 @@ assert 'keyword arguments' do
  assert_equal [{a: 1}, {b: 2}], m({a: 1}, b: 2)
  assert_raise(ArgumentError) { m({a: 1}, {b: 2}) }

-  def m1(a: {}) a end
-  assert_equal({}, m1)
-  assert_equal(:abc, m1(a: :abc))
-
-  def m2(a: +1) a end
-  assert_equal(1, m2)
-
-  assert_nothing_raised do
-    def m3 arg:
-      123
-    end
-  end
-  assert_equal(123, m3(arg: 456))
-
  def m(*, a:) a end
  assert_equal 1, m(a: 1)
  assert_equal 3, m(1, 2, a: 3)
@@ -1260,13 +1246,12 @@ assert('pattern matching - NoMatchingPatternError') do
    assert_true e.message.is_a?(String)
  end

-  # case/in without else raises NoMatchingPatternError
-  assert_raise(NoMatchingPatternError) do
-    case 5
-    in 1 then :one
-    in 2 then :two
-    end
+  # case/in without else returns nil (no match)
+  result = case 5
+  in 1 then :one
+  in 2 then :two
  end
+  assert_nil result
 end

 assert('pattern matching - complex patterns') do