hegeltest 0.3.0-aarch64-linux → 0.3.4-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59566789fc5421093c72e287628336fab5c24639d62b566878b1e6e30b3a1fc0
-  data.tar.gz: 7de554881f5a231f8bf18d9ae59991a856522e9ec4aa99ed18271e6da92b274a
+  metadata.gz: 544ae6338014de3a6d333bdb22908f05407e134f410f56c951bb514ca17a10b1
+  data.tar.gz: a0d77af10c8df7d6179f45983c179d07698dee54e88f1445a66d39ab7679a926
 SHA512:
-  metadata.gz: da16a45a6da1fb0b3577e89f2de9b93af360dd1c2ebb4ea605b275223cf6ca1a5797ef52d0ffde2d716d4f33266f6d516cdfc1d1e39a3549ab2b810b7c1c1af9
-  data.tar.gz: 6d39c970f6a98059c7275a3c38af692994f09cb4831e785273e0355b537952a746d34c0b3f786d57ea695447d64019e1f5d504aa6f2c4b3d1fbdcf479a988260
+  metadata.gz: fa798e612d182cc9f43c4c1ce0fd52dc17312b5a4b02b9340fd29ccbe0d60c3ab5543b4cd1bdadc6f94b05f70bf0b620940ef6f7ed47e52fe1604750dcb579c5
+  data.tar.gz: 901a2da33ccf6ba6579f4cbeb2852ef25c04da21ca9b9542b2e3661a00a7c7f1544208d9729e7da059331a6046ee7139136ff30890f5a47266ecfdaa1980175c

data/CHANGELOG.md

@@ -2,6 +2,105 @@
 
 ## [Unreleased]
 
+## [0.3.4] - 2026-10-20
+
+### Engine: libhegel 0.47.2 (was 0.47.1)
+
+The [libhegel 0.47.2 release notes](https://github.com/hegeldev/hegel/releases/tag/libhegel/0.47.2)
+describe 0.47.2. It is the first engine release from the hegeldev/hegel
+repository.
+
+Each platform gem carries `libhegel` 0.47.2. The engine does not change its
+C interface. A caller has nothing to change in code, and gets the same
+results. The engine changes one text: the message of an internal engine
+error now gives <https://github.com/hegeldev/hegel/issues> as the place to
+report the problem, not the hegel-rust issue tracker.
+
+### Development
+
+- `rake libhegel:fetch` and `rake libhegel:fetch_all` download libhegel
+  0.47.2 and later from the hegeldev/hegel releases, and earlier versions
+  from the hegeldev/hegel-rust releases.
+
+## [0.3.3] - 2026-10-17
+
+### Engine: libhegel 0.47.1 (was 0.45.13)
+
+The [libhegel 0.47.1 release notes](https://github.com/hegeldev/hegel-rust/releases/tag/libhegel-v0.47.1)
+describe 0.47.1 alone. The
+[engine changelog](https://github.com/hegeldev/hegel-rust/blob/libhegel-v0.47.1/hegel-c/CHANGELOG.md)
+describes each engine release after 0.45.13, up to 0.47.1.
+
+Each platform gem carries `libhegel` 0.47.1. The engine changes its C
+interface: every string is now a `hegel_string_t`, a pointer and a length.
+These bindings follow that change. A caller has nothing to change in code.
+The engine move changes these results for a caller:
+
+- A run with the default `report_multiple_failures: false` that finds more
+  than one distinct failure shrinks only the smallest of them and reports
+  it. Before, the engine shrank each failure and then reported one. The
+  example database keeps every distinct failure, as found. Such a run calls
+  the test body fewer times: for a body with two distinct failures and
+  `test_cases: 100`, 73 to 131 calls over 20 seeded runs, where 0.45.13
+  made 157 to 202. Both versions reported the same failure in each run.
+- A string that holds a NUL character, such as a `target` label or a
+  `database:` path, reaches the engine whole. Before, it raised
+  `ArgumentError` ("string contains null byte") from the `ffi` gem.
+
+## [0.3.2] - 2026-10-16
+
+### Engine: libhegel 0.45.13 (was 0.45.7)
+
+The [libhegel 0.45.13 release notes](https://github.com/hegeldev/hegel-rust/releases/tag/libhegel-v0.45.13)
+describe 0.45.13 alone. The
+[engine changelog](https://github.com/hegeldev/hegel-rust/blob/libhegel-v0.45.13/hegel-c/CHANGELOG.md)
+describes each engine release after 0.45.7, up to 0.45.13.
+
+Each platform gem carries `libhegel` 0.45.13. The engine only adds to its C
+interface, and these bindings do not use the addition. A caller has nothing
+to change in code. The engine changes these results for a caller:
+
+- A run with a `seed:` can draw different values than it did before. The
+  engine changed how it copies values between spans that have the same
+  label, and how it draws an integer from a range wider than 128 bits.
+- A failure that depends on an integer that is a multiple of a number, such
+  as 6, shrinks to the smallest such value more often. Before, the shrinker
+  could stop at a larger multiple, such as 78.
+- A run of 1,000 test cases or more starts to use `target` scores soon
+  after it starts. Before, it started after half of the test cases.
+- The `note:` line with the engine's nondeterminism caveat shows only for a
+  failure that the engine saw pass at least one time. Before, every failure
+  of a run that the engine treated as nondeterministic showed it.
+- `reproduce_failure:` stops a replay when the test body draws differently
+  from the recorded choices. If no replay reproduces the failure, the run
+  raises `Hegel::Error` with the message that says that the blob did not
+  reproduce a failure, and the engine writes one line to standard error
+  that names the position where the draws left the recorded choices.
+  Before, the engine continued the replay with new draws and could report a
+  different failure as the failure of the blob.
+
+## [0.3.1] - 2026-10-15
+
+### Engine: libhegel 0.45.7 (was 0.45.4)
+
+The [libhegel 0.45.7 release notes](https://github.com/hegeldev/hegel-rust/releases/tag/libhegel-v0.45.7)
+describe 0.45.7 alone. The
+[engine changelog](https://github.com/hegeldev/hegel-rust/blob/libhegel-v0.45.7/hegel-c/CHANGELOG.md)
+describes each engine release after 0.45.4, up to 0.45.7.
+
+Each platform gem carries `libhegel` 0.45.7. The engine only adds to its C
+interface, and these bindings do not use the addition. A caller has nothing
+to change in code. The engine changes these messages for a caller:
+
+- `from_regex` with a pattern that no string matches, such as `"(?!)"`,
+  raises `Hegel::Error` with a message that names the pattern and says
+  that it `matches no string`. Before, the run raised `Hegel::Error` with
+  a message that starts with `Unsatisfiable`.
+- The FilterTooMuch health check message says how to suppress the check
+  with the `suppress_health_check` setting, and it says "rejected by
+  assume() or a filter". Before, it showed Rust syntax. The
+  `FailedHealthCheck:` and `Unsatisfiable` prefixes do not change.
+
 ## [0.3.0] - 2026-10-14
 
 ### Engine: libhegel 0.45.4 (was 0.45.1)
@@ -174,6 +273,10 @@ The engine is called through the `ffi` gem. Each platform gem carries the
 matching `libhegel` 0.32.5 build. The platform-independent gem carries none,
 so a run on it needs `HEGEL_LIBHEGEL_PATH` pointing at a local build.
 
+[0.3.4]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.3.4
+[0.3.3]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.3.3
+[0.3.2]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.3.2
+[0.3.1]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.3.1
 [0.3.0]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.3.0
 [0.2.1]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.2.1
 [0.2.0]: https://github.com/meganemura/hegel-ruby/releases/tag/v0.2.0

data/README.md

@@ -7,7 +7,7 @@
 > there reviews or endorses it.
 >
 > The official implementations are
-> [Rust](https://github.com/hegeldev/hegel-rust),
+> [Rust](https://github.com/hegeldev/hegel/tree/main/frontends/rust),
 > [Go](https://github.com/hegeldev/hegel-go),
 > [C++](https://github.com/hegeldev/hegel-cpp),
 > [TypeScript](https://github.com/hegeldev/hegel-typescript),

data/docs/README.md

@@ -31,6 +31,8 @@ An index of the design records for `hegel-ruby`.
 - [0022: Keep microsecond times over a nanosecond engine](adr/0022-keep-microsecond-times-over-a-nanosecond-engine.md)
 - [0023: Leave unset settings to the engine's profile](adr/0023-leave-unset-settings-to-the-engines-profile.md)
 - [0024: Release when a merge changes the gem version](adr/0024-release-when-a-merge-changes-the-gem-version.md)
+- [0025: Copy each string input into a hegel_string_t](adr/0025-copy-each-string-input-into-a-hegel-string-t.md)
+- [0026: Select the engine release repository by version](adr/0026-select-the-engine-release-repository-by-version.md)
 
 A new decision gets a new record. A changed decision supersedes the old
 record instead of editing it, so the history stays readable.

data/docs/adr/0025-copy-each-string-input-into-a-hegel-string-t.md

@@ -0,0 +1,61 @@
+# 0025: Copy each string input into a hegel_string_t
+
+## Status
+
+Accepted.
+
+## Context
+
+libhegel 0.46.0 changed every string in its C interface to a
+`hegel_string_t`, a struct of a data pointer and a byte length. An ordinary
+input goes by value. An optional input goes through a pointer to the
+struct, and a NULL pointer means that the value is absent. An output is a
+struct that the engine writes. Before 0.46, a string input was a
+NUL-terminated `const char *`, which the `ffi` gem marshals from a Ruby
+String with the `:string` type. That type stops at the first NUL, and
+`ffi` 1.17.4 raises `ArgumentError` for a String with an interior NUL.
+
+The struct is 16 bytes on a 64-bit platform. The calling conventions do not
+pass a struct of that size in the same way: x86-64 System V and AArch64
+pass it in two registers, and Windows x64 passes it through a hidden
+pointer. This is inferred from the ABI documents of each platform, not
+measured here; the CI runs the suite on each of them. A binding that
+declared two scalar arguments in place of the struct would match some of
+these conventions and not others.
+
+hegel-rust's own frontend (`src/ffi.rs` at `libhegel-v0.47.1`) borrows the
+bytes of a Rust string for the length of the call.
+
+## Decision
+
+`LibHegel::Real` declares each `hegel_string_t` argument as
+`StringStruct.by_value`, and lets libffi apply the calling convention of the
+platform. It declares each optional string argument as `:pointer`, and
+passes `nil` for an absent value and a `StringStruct` for a present one, so
+that `""` stays different from `nil`. `settings_set_database` needs that
+difference: `""` turns the database off, and `nil` keeps the engine's
+default directory.
+
+Each input string is copied into a native buffer that the struct holds. The
+binding does not point the struct at the memory of the Ruby String: a copy
+does not depend on how long the garbage collector keeps that memory in
+place (inferred: compaction can move the contents of a short String).
+Measured on `ffi` 1.17.4, a struct field keeps the buffer it holds alive
+through a full garbage collection. The struct is an argument of the native
+call, so the buffer lives until the call returns.
+
+An output is read by its length, not up to its trailing NUL, because an
+engine string can hold an interior NUL.
+
+## Consequences
+
+A string that holds a NUL character, for example a `target` label, reaches
+the engine whole. Before, it raised `ArgumentError`.
+
+Each string input costs one native allocation and one copy. The strings that
+cross on each test case are short: an origin for an interesting case, and
+a label for each `target` call.
+
+The rename of `hegel_generate_string_result_free` to
+`hegel_owned_string_free` renames the binding method to `owned_string_free`.
+`LibHegel::METHODS`, the Fake, and `sig/hegel.rbs` follow it.

data/docs/adr/0026-select-the-engine-release-repository-by-version.md

@@ -0,0 +1,47 @@
+# 0026: Select the engine release repository by version
+
+## Status
+
+Accepted.
+
+## Context
+
+Up to libhegel 0.47.1, hegeldev/hegel-rust published each engine release
+with the tag `libhegel-v<version>`. From 0.47.2, the engine and the Rust
+frontend live in the monorepo hegeldev/hegel, which publishes each engine
+release with the tag `libhegel/<version>`. hegeldev/hegel-rust is now an
+archive and gets no new release. The asset names did not change: `hegel.h`,
+`libhegel-<os>-<arch>.<ext>`, and `<asset>.sha256`.
+
+Measured on 2026-10-19 with HTTP requests to the release download URLs:
+hegeldev/hegel does not carry the assets of the old releases
+(`libhegel/0.47.1/hegel.h` gives HTTP 404). Measured on 2026-10-20: each of
+the five platform assets of 0.47.2, and its `.sha256` file, gives HTTP 200
+from hegeldev/hegel.
+
+## Decision
+
+`Hegel::LibhegelFetch.release_base` selects the repository from the version.
+A version of 0.47.2 or later downloads from
+`https://github.com/hegeldev/hegel/releases/download/libhegel/<version>`. An
+earlier version downloads from
+`https://github.com/hegeldev/hegel-rust/releases/download/libhegel-v<version>`.
+
+The rule keeps the old releases reachable. A contributor who checks out an
+old commit of this gem can still run `rake libhegel:fetch` for the version
+that commit pins.
+
+One alternative was refused: a single base URL for the new repository. It
+is shorter, but it breaks `rake libhegel:fetch` on every old commit, because
+the new repository does not carry the old assets.
+
+## Consequences
+
+The CHANGELOG rule in CLAUDE.md links the engine release notes and
+`libhegel/CHANGELOG.md` in hegeldev/hegel for an engine move to 0.47.2 or
+later. The reference paths in CLAUDE.md and `docs/architecture.md` point into
+the monorepo tree: `libhegel/` for the engine, and `frontends/rust/` for the
+Rust frontend.
+
+If the old releases move to hegeldev/hegel later, the legacy branch can go,
+and this record gets a successor.

data/docs/architecture.md

@@ -43,10 +43,13 @@ schedules it.
 
 ## Where meaning comes from
 
-libhegel is hegel-rust's native engine. hegel-rust's Cargo workspace builds
-it from the `hegel-c` directory, as the crate `hegeltest-c`, whose header is
-`hegel-c/include/hegel.h`. That header defines the ABI this gem calls: what
-each function does, what its error codes mean, and who owns each pointer.
+libhegel is the native engine of every Hegel frontend. Since 0.47.2, the
+hegeldev/hegel Cargo workspace builds it from the `libhegel` directory, as
+the crate `hegeltest-c`, whose header is `libhegel/include/hegel.h`. The
+same workspace holds the Rust frontend, hegel-rust, at `frontends/rust`.
+Releases up to 0.47.1 came from hegeldev/hegel-rust, where the engine was at
+`hegel-c`. The header defines the ABI this gem calls: what each function
+does, what its error codes mean, and who owns each pointer.
 
 The Java, Go, TypeScript, OCaml, and C++ implementations bind the same
 engine. Each works under a constraint hegel-rust does not have: a dynamic
@@ -171,12 +174,16 @@ fields.
 
 ## Answered
 
-A drawn string arrives as a pointer and a length, is not NUL-terminated,
-and can hold interior NUL bytes, because the drawn alphabet can include
-U+0000. Read by length. Measured against 0.45.0: an alphabet pinned to
-U+0000 produces a three-byte draw that reads as `""` when taken up to the
-first NUL and as three NUL bytes when taken by its reported length. Every
-string observed reports `valid_encoding?` after `force_encoding(UTF-8)`.
+A drawn string arrives as a pointer and a length, and can hold interior
+NUL bytes, because the drawn alphabet can include U+0000. Read by length.
+Before libhegel 0.46 the string had no NUL terminator. Since 0.46 every
+string the engine hands back is a `hegel_string_t` with a trailing NUL that
+its length excludes, but an interior NUL still ends the string early for a
+reader that stops at the first NUL. Measured against 0.45.0: an alphabet
+pinned to U+0000 produces a three-byte draw that reads as `""` when taken
+up to the first NUL and as three NUL bytes when taken by its reported
+length. Every string observed reports `valid_encoding?` after
+`force_encoding(UTF-8)`.
 
 Prism recovers a draw's assignment target through a method chain, an
 instance-variable assignment, and an assignment spanning several lines.

data/lib/hegel/lib_hegel/real.rb

@@ -18,7 +18,7 @@ module Hegel
     # symbol.
     class Real
       # hegel_date_t / hegel_time_t / hegel_datetime_t, transcribed field
-      # for field from hegel-c/include/hegel.h. FFI::Struct computes each
+      # for field from libhegel/include/hegel.h. FFI::Struct computes each
       # field's offset and the struct's own alignment padding from this
       # layout -- the same C-ABI rules the compiled library was built
       # against -- so there is no hand-computed byte offset here to drift
@@ -40,17 +40,19 @@ module Hegel
         layout :date, DateStruct, :time, TimeStruct
       end
 
-      # hegel_generate_string_result_t and hegel_generate_bytes_result_t are
-      # both `{ char *data; size_t len; }` in hegel-c/include/hegel.h --
-      # byte-for-byte the same layout under two names, one per element type
-      # the two calls draw. One Ruby struct mirrors both; #generate_string
-      # and #generate_bytes each pass a fresh instance as the out-parameter
-      # and read it back through their own method below.
-      class RawResultStruct < FFI::Struct
+      # hegel_string_t (`{ const char *data; size_t len; }`), and
+      # hegel_generate_bytes_result_t (`{ uint8_t *data; size_t len; }`),
+      # from libhegel/include/hegel.h: the same layout under two names. Since
+      # libhegel 0.46 every string crosses the ABI as a hegel_string_t: by
+      # value for an ordinary input, through a nullable pointer for an
+      # optional input, and as a struct the engine writes for an output.
+      # hegel_owned_string_t, which #generate_string reads, is a typedef of
+      # hegel_string_t. One Ruby struct mirrors all of them.
+      class StringStruct < FFI::Struct
         layout :data, :pointer, :len, :size_t
       end
 
-      private_constant :DateStruct, :TimeStruct, :DatetimeStruct, :RawResultStruct
+      private_constant :DateStruct, :TimeStruct, :DatetimeStruct, :StringStruct
 
       # Opens +path+ (default: Hegel::Locate.resolve) and binds the
       # functions this boundary calls. Immediately after, opens a context
@@ -75,7 +77,7 @@ module Hegel
 
         @hegel_context_new_fn = bind("hegel_context_new", [], :pointer)
         @hegel_context_free_fn = bind("hegel_context_free", [:pointer], :int32)
-        @hegel_context_last_error_fn = bind("hegel_context_last_error", [:pointer], :pointer)
+        @hegel_context_last_error_fn = bind("hegel_context_last_error", [:pointer], StringStruct.by_value)
         @hegel_version_fn = bind("hegel_version", [:pointer, :pointer], :int32)
 
         @hegel_settings_new_fn = bind("hegel_settings_new", [:pointer, :pointer], :int32)
@@ -93,13 +95,13 @@ module Hegel
           "hegel_settings_set_derandomize", [:pointer, :pointer, :bool], :int32
         )
         @hegel_settings_set_database_fn = bind(
-          "hegel_settings_set_database", [:pointer, :pointer, :string], :int32
+          "hegel_settings_set_database", [:pointer, :pointer, :pointer], :int32
         )
         @hegel_settings_set_report_multiple_failures_fn = bind(
           "hegel_settings_set_report_multiple_failures", [:pointer, :pointer, :bool], :int32
         )
         @hegel_settings_set_database_key_fn = bind(
-          "hegel_settings_set_database_key", [:pointer, :pointer, :string], :int32
+          "hegel_settings_set_database_key", [:pointer, :pointer, :pointer], :int32
         )
         @hegel_settings_set_phases_fn = bind(
           "hegel_settings_set_phases", [:pointer, :pointer, :uint32], :int32
@@ -112,7 +114,7 @@ module Hegel
           "hegel_run_start", [:pointer, :pointer, :pointer, :pointer, :pointer], :int32
         )
         @hegel_run_start_blob_fn = bind(
-          "hegel_run_start_blob", [:pointer, :pointer, :string, :pointer, :pointer, :pointer], :int32
+          "hegel_run_start_blob", [:pointer, :pointer, StringStruct.by_value, :pointer, :pointer, :pointer], :int32
         )
         @hegel_next_test_case_fn = bind("hegel_next_test_case", [:pointer, :pointer, :pointer], :int32)
         @hegel_test_case_should_capture_fn = bind(
@@ -120,8 +122,8 @@ module Hegel
         )
         @hegel_run_free_fn = bind("hegel_run_free", [:pointer, :pointer], :int32)
         @hegel_test_case_free_fn = bind("hegel_test_case_free", [:pointer, :pointer], :int32)
-        @hegel_mark_complete_fn = bind("hegel_mark_complete", [:pointer, :pointer, :uint32, :string], :int32)
-        @hegel_target_fn = bind("hegel_target", [:pointer, :pointer, :double, :string], :int32)
+        @hegel_mark_complete_fn = bind("hegel_mark_complete", [:pointer, :pointer, :uint32, :pointer], :int32)
+        @hegel_target_fn = bind("hegel_target", [:pointer, :pointer, :double, StringStruct.by_value], :int32)
 
         @hegel_run_result_fn = bind("hegel_run_result", [:pointer, :pointer, :pointer], :int32)
         @hegel_run_result_free_fn = bind("hegel_run_result_free", [:pointer, :pointer], :int32)
@@ -159,7 +161,7 @@ module Hegel
         )
         @hegel_collection_more_fn = bind("hegel_collection_more", [:pointer, :pointer, :pointer, :pointer], :int32)
         @hegel_collection_reject_fn = bind(
-          "hegel_collection_reject", [:pointer, :pointer, :pointer, :string], :int32
+          "hegel_collection_reject", [:pointer, :pointer, :pointer, :pointer], :int32
         )
         @hegel_collection_free_fn = bind("hegel_collection_free", [:pointer, :pointer], :int32)
 
@@ -196,14 +198,14 @@ module Hegel
           [:pointer, :pointer, :uint32, :double, :double, :bool, :bool, :bool, :bool, :double, :pointer], :int32
         )
 
-        # hegel_string_generator_text takes 14 arguments past ctx; the
-        # last 8 (categories_len through exclude_characters_len) are the
-        # category and explicit-character filter parameters this task
-        # does not wire up (see #string_generator_text).
+        # hegel_string_generator_text takes 12 arguments past ctx; the
+        # last 6 (categories through exclude_characters) are the category
+        # and explicit-character filter parameters this binding does not
+        # wire up (see #string_generator_text).
         @hegel_string_generator_text_fn = bind(
           "hegel_string_generator_text",
-          [:pointer, :uint64, :uint64, :string, :uint32, :uint32,
-            :pointer, :size_t, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t,
+          [:pointer, :uint64, :uint64, :pointer, :uint32, :uint32,
+            :pointer, :size_t, :pointer, :size_t, StringStruct.by_value, StringStruct.by_value,
             :pointer],
           :int32
         )
@@ -211,9 +213,7 @@ module Hegel
         @hegel_generate_string_fn = bind(
           "hegel_generate_string", [:pointer, :pointer, :pointer, :pointer], :int32
         )
-        @hegel_generate_string_result_free_fn = bind(
-          "hegel_generate_string_result_free", [:pointer, :pointer], :int32
-        )
+        @hegel_owned_string_free_fn = bind("hegel_owned_string_free", [:pointer, :pointer], :int32)
 
         @hegel_generate_bytes_fn = bind(
           "hegel_generate_bytes", [:pointer, :pointer, :uint64, :uint64, :pointer], :int32
@@ -223,7 +223,7 @@ module Hegel
         )
 
         @hegel_string_generator_regex_fn = bind(
-          "hegel_string_generator_regex", [:pointer, :pointer, :size_t, :bool, :pointer, :pointer], :int32
+          "hegel_string_generator_regex", [:pointer, StringStruct.by_value, :bool, :pointer, :pointer], :int32
         )
         @hegel_string_generator_email_fn = bind("hegel_string_generator_email", [:pointer, :pointer], :int32)
         @hegel_string_generator_url_fn = bind("hegel_string_generator_url", [:pointer, :pointer], :int32)
@@ -273,18 +273,18 @@ module Hegel
       # before returning, since the header documents that buffer as
       # borrowed and invalidated by the next call taking the same context.
       def context_last_error(ctx)
-        utf8(@hegel_context_last_error_fn.call(ctx))
+        read_string(@hegel_context_last_error_fn.call(ctx))
       end
 
       # Returns the loaded engine's version string, or raises the
       # exception LibHegel.check! translates this call's result code to.
       def version(ctx)
-        out = FFI::MemoryPointer.new(:pointer)
+        out = StringStruct.new
         code = @hegel_version_fn.call(ctx, out)
         # This call takes only ctx and this method's own out argument; neither
         # makes the real engine return anything but HEGEL_OK.
         LibHegel.check!(self, ctx, code) # mutineer:disable-line statement_removal
-        utf8(out.read_pointer)
+        read_string(out)
       end
 
       # Returns a settings handle initialized from the engine's resolved
@@ -334,11 +334,11 @@ module Hegel
       end
 
       # +database+ may be nil (libhegel's own default path) or a String,
-      # including "" to disable the database. Declared :string below, so a
-      # Ruby String marshals as a const char* to its bytes and nil marshals
-      # to NULL, both directly -- no separate pointer to build here.
+      # including "" to disable the database. The header takes an optional
+      # string here, so nil goes over as a NULL pointer and "" as a pointer
+      # to an empty string; see #optional_string.
       def settings_set_database(ctx, s, database)
-        code = @hegel_settings_set_database_fn.call(ctx, s, database)
+        code = @hegel_settings_set_database_fn.call(ctx, s, optional_string(database))
         LibHegel.check!(self, ctx, code)
         nil
       end
@@ -350,10 +350,10 @@ module Hegel
       end
 
       # +key+ may be nil, which the header documents as clearing the key
-      # (the default); nil marshals to NULL for this :string argument, the
+      # (the default); nil goes over as NULL through #optional_string, the
       # same as #settings_set_database's own nilable database argument.
       def settings_set_database_key(ctx, s, key)
-        code = @hegel_settings_set_database_key_fn.call(ctx, s, key)
+        code = @hegel_settings_set_database_key_fn.call(ctx, s, optional_string(key))
         LibHegel.check!(self, ctx, code)
         nil
       end
@@ -393,7 +393,7 @@ module Hegel
       # version.
       def run_start_blob(ctx, settings, blob)
         out = FFI::MemoryPointer.new(:pointer)
-        code = @hegel_run_start_blob_fn.call(ctx, settings, blob, nil, nil, out)
+        code = @hegel_run_start_blob_fn.call(ctx, settings, string_view(blob), nil, nil, out)
         LibHegel.check!(self, ctx, code)
         out.read_pointer
       end
@@ -442,9 +442,9 @@ module Hegel
       # +origin+ must be non-nil only when +status+ is
       # HEGEL_STATUS_INTERESTING, per the header; this layer neither builds
       # nor validates that string, only passes through what the caller
-      # supplies. nil marshals to NULL for this :string argument.
+      # supplies. nil goes over as NULL through #optional_string.
       def mark_complete(ctx, tc, status, origin)
-        code = @hegel_mark_complete_fn.call(ctx, tc, status, origin)
+        code = @hegel_mark_complete_fn.call(ctx, tc, status, optional_string(origin))
         LibHegel.check!(self, ctx, code)
         nil
       end
@@ -456,7 +456,7 @@ module Hegel
       # checked here, matching how this layer leaves every other
       # argument-shape rule to the engine's own HEGEL_E_INVALID_ARG.
       def target(ctx, tc, value, label)
-        code = @hegel_target_fn.call(ctx, tc, value, label)
+        code = @hegel_target_fn.call(ctx, tc, value, string_view(label))
         LibHegel.check!(self, ctx, code)
         nil
       end
@@ -538,10 +538,10 @@ module Hegel
       # returning, since it is owned by the failure and only valid until
       # #failure_free.
       def failure_origin(ctx, f)
-        out = FFI::MemoryPointer.new(:pointer)
+        out = StringStruct.new
         code = @hegel_failure_origin_fn.call(ctx, f, out)
         LibHegel.check!(self, ctx, code)
-        utf8(out.read_pointer)
+        read_string(out)
       end
 
       # Returns nil when libhegel produced no reproduction blob for this
@@ -659,12 +659,12 @@ module Hegel
       end
 
       # Tells libhegel the last element +collection+ produced is invalid.
-      # +why+ is an optional human-readable reason (nil marshals to NULL
-      # for this :string argument, which the header allows); the header
+      # +why+ is an optional human-readable reason (nil goes over as NULL
+      # through #optional_string, which the header allows); the header
       # documents it as validated but reserved for future rejection
       # diagnostics, unused today.
       def collection_reject(ctx, tc, collection, why = nil)
-        code = @hegel_collection_reject_fn.call(ctx, tc, collection, why)
+        code = @hegel_collection_reject_fn.call(ctx, tc, collection, optional_string(why))
         LibHegel.check!(self, ctx, code)
         nil
       end
@@ -733,9 +733,9 @@ module Hegel
 
       # Returns a caller-owned state-machine handle, released separately
       # with #state_machine_free. +rule_names+ and +invariant_names+ are
-      # each an Array of Ruby Strings, packed into the const char *const *
-      # arguments hegel_new_state_machine expects by #pack_name_array; see
-      # that method's own comment for how and why. +always_check+ holds one
+      # each an Array of Ruby Strings, packed into the hegel_string_t arrays
+      # hegel_new_state_machine expects by #pack_name_array; see that
+      # method's own comment for how and why. +always_check+ holds one
       # flag per invariant name. Validating +rule_names+ as non-empty (the
       # header's own requirement) is left to the caller, the same division
       # of labor #new_collection leaves to the caller for its own
@@ -840,17 +840,18 @@ module Hegel
 
       # Returns a caller-owned string generator handle, released
       # separately with #string_generator_free (or scoped with
-      # Hegel::TestCase#with_text_generator). +categories+,
-      # +exclude_categories+, +include_characters+, and
-      # +exclude_characters+ are always passed as NULL/0 below: this call
-      # only wires up the codepoint-range constraints of the 14-argument
-      # bind; the category and explicit-character filter arguments are a
-      # later generator's scope, layered on top of this same bind.
+      # Hegel::TestCase#with_text_generator). +categories+ and
+      # +exclude_categories+ are always passed as NULL/0 below, and
+      # +include_characters+ and +exclude_characters+ as empty strings:
+      # this call only wires up the codepoint-range constraints of the
+      # 12-argument bind; the category and explicit-character filter
+      # arguments are a later generator's scope, layered on top of this
+      # same bind.
       def string_generator_text(ctx, min_size:, max_size:, codec: nil, min_codepoint: 0, max_codepoint: 0xFFFFFFFF)
         out = FFI::MemoryPointer.new(:pointer)
         code = @hegel_string_generator_text_fn.call(
-          ctx, min_size, max_size, codec, min_codepoint, max_codepoint,
-          nil, 0, nil, 0, nil, 0, nil, 0,
+          ctx, min_size, max_size, optional_string(codec), min_codepoint, max_codepoint,
+          nil, 0, nil, 0, StringStruct.new, StringStruct.new,
           out
         )
         LibHegel.check!(self, ctx, code)
@@ -867,47 +868,46 @@ module Hegel
         nil
       end
 
-      # Returns a drawn String, force-encoded as UTF-8 (this codec's
-      # alphabet), copying exactly the returned +len+ bytes rather than
-      # reading a NUL-terminated buffer: the header documents it as not
-      # NUL-terminated and possibly containing interior NUL bytes, since
-      # the drawn alphabet can include U+0000.
+      # Returns a drawn String, labelled UTF-8 by #read_string. The draw can
+      # hold interior NUL bytes, since the drawn alphabet can include
+      # U+0000, so #read_string copies exactly the returned +len+ bytes.
       #
       # The native buffer is released in +ensure+ via
-      # #generate_string_result_free, called directly from here rather
+      # #owned_string_free, called directly from here rather
       # than left to the caller: nothing outside this file may hold or
       # read the raw struct (ffi is confined to this file), so unlike
       # #new_collection or #string_generator_text, the freeable handle
       # here never leaves this method. Freeing is safe even when the draw
       # above raised: +out+ starts zero-filled (FFI::Struct.new allocates
       # cleared memory) and libhegel only writes into it on success, so
-      # the struct #generate_string_result_free sees here is always
+      # the struct #owned_string_free sees here is always
       # either a completed draw or the all-zero state the header
       # documents as already safe to free.
       def generate_string(ctx, tc, generator)
-        out = RawResultStruct.new
+        out = StringStruct.new
         code = @hegel_generate_string_fn.call(ctx, tc, generator, out)
         LibHegel.check!(self, ctx, code)
-        out[:data].read_bytes(out[:len]).force_encoding(Encoding::UTF_8)
+        read_string(out)
       ensure
-        generate_string_result_free(ctx, out)
+        owned_string_free(ctx, out)
       end
 
-      # No-op when +result+ is nil, matching
-      # hegel_generate_string_result_free's documented no-op-on-NULL
-      # contract (also safe on an already-freed, zeroed struct); not
-      # translated, for the same reason as #context_free.
-      def generate_string_result_free(ctx, result)
+      # No-op when +result+ is nil, matching hegel_owned_string_free's
+      # documented no-op-on-NULL contract (also safe on an already-freed,
+      # zeroed struct); not translated, for the same reason as
+      # #context_free. Before libhegel 0.46 this call was
+      # hegel_generate_string_result_free.
+      def owned_string_free(ctx, result)
         # Removing this call only leaks native memory; Ruby has no way to
         # observe the leak.
-        @hegel_generate_string_result_free_fn.call(ctx, result) # mutineer:disable-line statement_removal
+        @hegel_owned_string_free_fn.call(ctx, result) # mutineer:disable-line statement_removal
         nil
       end
 
       # Returns drawn bytes as a String, read via +len+ the same way
       # #generate_string reads its own out-parameter: the header gives no
-      # NUL-termination guarantee for this buffer either, so the length is
-      # what makes the copy exact.
+      # NUL-termination guarantee for this buffer, so the length is what
+      # makes the copy exact.
       #
       # Unlike #generate_string, the result is never force-encoded.
       # hegel_generate_bytes_result_t is documented as a byte buffer, not
@@ -923,7 +923,7 @@ module Hegel
       # header documents hegel_generate_bytes_result_free as safe on an
       # already-freed (zeroed) struct too.
       def generate_bytes(ctx, tc, min_size, max_size)
-        out = RawResultStruct.new
+        out = StringStruct.new
         code = @hegel_generate_bytes_fn.call(ctx, tc, min_size, max_size, out)
         LibHegel.check!(self, ctx, code)
         out[:data].read_bytes(out[:len])
@@ -953,9 +953,8 @@ module Hegel
       # a NUL character in it reaches the engine instead of ending it.
       def string_generator_regex(ctx, pattern, fullmatch, alphabet = nil)
         out = FFI::MemoryPointer.new(:pointer)
-        bytes = pattern.encode(Encoding::UTF_8)
         code = @hegel_string_generator_regex_fn.call(
-          ctx, bytes_to_pointer(bytes), bytes.bytesize, fullmatch, alphabet, out
+          ctx, string_view(pattern.encode(Encoding::UTF_8)), fullmatch, alphabet, out
         )
         LibHegel.check!(self, ctx, code)
         out.read_pointer
@@ -1103,8 +1102,8 @@ module Hegel
       end
 
       # Copies +bytes+ into a freshly allocated buffer, for
-      # #generate_integer_big's min_value/max_value: a const uint8_t*
-      # argument libhegel reads from, the opposite direction of an
+      # #generate_integer_big's min_value/max_value and for #write_string:
+      # input bytes libhegel reads from, the opposite direction of an
       # out-parameter buffer (which libhegel writes into, and the caller
       # then reads).
       def bytes_to_pointer(bytes)
@@ -1113,21 +1112,50 @@ module Hegel
         ptr
       end
 
-      # Packs +names+ (an Array of Ruby Strings) into a const char *const *
-      # for #new_state_machine's rule_names/invariant_names arguments: one
-      # address per name, written into a single buffer via
-      # write_array_of_pointer.
+      # Writes +string+'s bytes into +struct+, a StringStruct, as a borrowed
+      # hegel_string_t input. The bytes go over with their length and no
+      # terminator, so an interior NUL reaches the engine. An empty string
+      # gets a zero-size buffer: the header accepts any pointer for a
+      # length of zero.
+      #
+      # FFI::Struct keeps a reference to a pointer it stores in a field, so
+      # the copied buffer lives as long as +struct+ does. Measured on ffi
+      # 1.17.4: after a full GC, a WeakRef to a buffer held only by a struct
+      # field is still alive, and one to a buffer with no holder is not. A
+      # caller keeps the struct live for the native call by passing it as an
+      # argument.
+      def write_string(struct, string)
+        struct[:data] = bytes_to_pointer(string)
+        struct[:len] = string.bytesize
+        struct
+      end
+
+      # A hegel_string_t for an ordinary input argument, passed by value.
+      def string_view(string)
+        write_string(StringStruct.new, string)
+      end
+
+      # A pointer to a hegel_string_t for an optional input argument: nil
+      # for an absent value, which marshals to NULL, and a struct
+      # otherwise. The header separates the two cases: NULL means absent,
+      # and a pointer to an empty string means present and empty. "" for
+      # #settings_set_database depends on that difference.
+      def optional_string(string)
+        string && string_view(string)
+      end
+
+      # Packs +names+ (an Array of Ruby Strings) into a contiguous array of
+      # hegel_string_t for #new_state_machine's rule_names/invariant_names
+      # arguments: one StringStruct per name, each written in place over
+      # its own slot of a single buffer.
       #
-      # Returns [pointer, kept_alive]. FFI::MemoryPointer.from_string
-      # copies each name into a fresh native buffer that Ruby object owns
-      # -- unlike a pointer built straight off a Ruby String's own bytes,
-      # nothing here depends on the original +names+ Strings staying live
-      # -- so what must stay live until the native call reads them is the
-      # per-name FFI::MemoryPointer array itself; write_array_of_pointer
-      # only copies the addresses those objects report, not a reference to
-      # the objects, so the caller keeping +kept_alive+ as a live local for
-      # the length of the call is what keeps the buffers each one owns
-      # from being garbage-collected first.
+      # Returns [pointer, kept_alive]. #write_string copies each name into
+      # a fresh native buffer -- nothing here depends on the original
+      # +names+ Strings staying live -- and each slot's struct holds a
+      # reference to that buffer. The array buffer holds only addresses,
+      # not references, so the caller keeping +kept_alive+ (the slot
+      # structs) as a live local for the length of the call is what keeps
+      # the buffers each one owns from being garbage-collected first.
       #
       # Empty +names+ maps to [nil, []] -- NULL and (by the caller passing
       # names.size, 0) the header's own contract for invariant_names' "no
@@ -1142,10 +1170,11 @@ module Hegel
         # hegel_new_state_machine reads zero names either way.
         return [nil, []] if names.empty? # mutineer:disable-line statement_removal
 
-        pointers = names.map { |name| FFI::MemoryPointer.from_string(name) }
-        array = FFI::MemoryPointer.new(:pointer, names.size)
-        array.write_array_of_pointer(pointers)
-        [array, pointers]
+        array = FFI::MemoryPointer.new(StringStruct, names.size)
+        slots = names.each_with_index.map do |name, i|
+          write_string(StringStruct.new(array + (i * StringStruct.size)), name)
+        end
+        [array, slots]
       end
 
       # Packs +flags+ (an Array of true/false) into a const bool * buffer,
@@ -1222,26 +1251,29 @@ module Hegel
         [struct[:hour], struct[:minute], struct[:second], struct[:nanosecond]]
       end
 
-      # Reads +out+'s const char* out-parameter into a Ruby String, or
-      # returns nil if libhegel left it NULL. Shared by #run_result_error,
-      # #failure_reproduction_blob, and #failure_caveat, the out-parameters
-      # the header documents as nullable, so both branches only need to be
-      # exercised once between the call sites rather than at each one.
+      # Reads +out+'s const hegel_string_t* out-parameter into a Ruby
+      # String, or returns nil if libhegel left it NULL. Shared by
+      # #run_result_error, #failure_reproduction_blob, and #failure_caveat,
+      # the out-parameters the header documents as nullable, so both
+      # branches only need to be exercised once between the call sites
+      # rather than at each one.
       def nullable_out_string(out)
         ptr = out.read_pointer
-        ptr.null? ? nil : utf8(ptr)
-      end
-
-      # Reads the NUL-terminated string at +pointer+ and labels it UTF-8.
-      # The header calls every string libhegel hands back valid UTF-8, but
-      # FFI::Pointer#read_string labels what it reads ASCII-8BIT. A caller
-      # who matches an error message against a pattern of their own then
-      # gets Encoding::CompatibilityError rather than an answer, and the
-      # engine's own messages do carry characters outside ASCII: the
-      # FilterTooMuch health check writes an em dash into the sentence a
-      # caller is most likely to read.
-      def utf8(pointer)
-        pointer.read_string.force_encoding(Encoding::UTF_8)
+        ptr.null? ? nil : read_string(StringStruct.new(ptr))
+      end
+
+      # Copies the +len+ bytes at +struct+'s data pointer and labels them
+      # UTF-8. The header calls every string libhegel hands back valid
+      # UTF-8, but FFI::Pointer#read_bytes labels what it reads ASCII-8BIT.
+      # A caller who matches an error message against a pattern of their
+      # own then gets Encoding::CompatibilityError rather than an answer,
+      # and the engine's own messages do carry characters outside ASCII:
+      # the FilterTooMuch health check writes an em dash into the sentence
+      # a caller is most likely to read. The length decides the copy, not
+      # the trailing NUL the header also promises, since a string can hold
+      # an interior NUL.
+      def read_string(struct)
+        struct[:data].read_bytes(struct[:len]).force_encoding(Encoding::UTF_8)
       end
     end
   end

data/lib/hegel/lib_hegel.rb

@@ -18,7 +18,7 @@ module Hegel
   # is testable without the native engine. hegel-java makes the same split,
   # between its Libhegel interface, RealLibhegel, and FakeLibhegel.
   module LibHegel
-    # hegel_result_t, named from hegel-c/include/hegel.h's enum of the same
+    # hegel_result_t, named from libhegel/include/hegel.h's enum of the same
     # name. HEGEL_OK is success; every other value is a negative error code.
     HEGEL_OK = 0
     HEGEL_E_STOP_TEST = -1
@@ -118,7 +118,7 @@ module Hegel
       start_span stop_span
       new_collection collection_more collection_reject collection_free
       generate_float
-      string_generator_text string_generator_free generate_string generate_string_result_free
+      string_generator_text string_generator_free generate_string owned_string_free
       generate_bytes generate_bytes_result_free
       string_generator_regex string_generator_email string_generator_url string_generator_domain
       generate_ipv4 generate_ipv6 generate_uuid

data/lib/hegel/libhegel_version.rb

@@ -5,5 +5,5 @@ module Hegel
   # Hegel::VERSION (the gem's own release): hegel-go and hegel-typescript keep
   # the two separate too, so bumping the pinned engine can land as its own
   # commit without also releasing a new gem version.
-  LIBHEGEL_VERSION = "0.45.4"
+  LIBHEGEL_VERSION = "0.47.2"
 end

data/lib/hegel/locate.rb

@@ -16,7 +16,7 @@ module Hegel
   #    fallback.
   # 2. The copy bundled into the gem under +lib/hegel/libhegel/+.
   #
-  # A sibling `../hegel-rust` checkout is deliberately not searched. The env
+  # A sibling engine checkout (`../hegel`) is deliberately not searched. The env
   # override already covers local-engine-build workflows without depending
   # on any particular checkout layout, and `rake libhegel:fetch` covers the
   # rest; a rule that depends on a layout this repo's own checkout does not
@@ -32,10 +32,10 @@ module Hegel
     LIBRARY_PATH_ENV = "HEGEL_LIBHEGEL_PATH"
 
     # Published release asset name for each supported "<host_cpu>-<host_os>"
-    # pair, mirroring the artifacts hegel-rust publishes for the pinned
-    # LIBHEGEL_VERSION. Hosts absent from this table (e.g. x86_64-darwin,
-    # Intel Mac) are unsupported because hegel-rust does not publish a build
-    # for them.
+    # pair, mirroring the artifacts the libhegel release of the pinned
+    # LIBHEGEL_VERSION publishes. Hosts absent from this table (e.g.
+    # x86_64-darwin, Intel Mac) are unsupported because that release does not
+    # publish a build for them.
     ASSET_NAMES = {
       "arm64-darwin" => "libhegel-darwin-arm64.dylib",
       "x86_64-linux" => "libhegel-linux-amd64.so",
@@ -76,7 +76,7 @@ module Hegel
     end
 
     # The release asset name for the given host, or raises Hegel::Error if
-    # hegel-rust does not publish a build for it.
+    # the libhegel release does not publish a build for it.
     def asset_name(host_cpu:, host_os:)
       release_asset_name(host_cpu, host_os) || raise(Hegel::Error, unsupported_host_message(host_cpu, host_os))
     end
@@ -101,7 +101,7 @@ module Hegel
     #    directory override is how an unsupported host (e.g. x86_64-darwin)
     #    points at a local build in the first place, so treating it as an
     #    error here would close off that path.
-    # 2. libhegel_c.<ext>, the name cargo gives the library when hegel-c's
+    # 2. libhegel_c.<ext>, the name cargo gives the library when libhegel's
     #    crate (`[lib] name = "hegel_c"`) is built without renaming it.
     # 3. libhegel.<ext>, a renamed copy, per the hegel-go and hegel-ocaml
     #    READMEs.
@@ -122,8 +122,8 @@ module Hegel
       [release_asset_name(host_cpu, host_os), "libhegel_c.#{ext}", "libhegel.#{ext}"].compact
     end
 
-    # The release asset name for the given host, or nil if hegel-rust does
-    # not publish a build for it. Split from asset_name (which raises) so a
+    # The release asset name for the given host, or nil if the libhegel
+    # release does not publish a build for it. Split from asset_name (which raises) so a
     # directory override can treat an unsupported host as "skip this
     # candidate" instead of an error.
     def release_asset_name(host_cpu, host_os)
@@ -159,7 +159,7 @@ module Hegel
     end
 
     # Shared-library extension for host_os alone, independent of whether the
-    # specific host_cpu is one hegel-rust publishes a build for. This lets
+    # specific host_cpu is one libhegel publishes a build for. This lets
     # an explicit directory override (step 1) resolve on an otherwise
     # unsupported host (e.g. x86_64-darwin), matching a local libhegel build
     # that always produces the OS-native extension.

data/lib/hegel/runner.rb

@@ -178,9 +178,9 @@ module Hegel
     # Pulls test cases from +run+ until hegel_next_test_case reports none
     # left (a nil out-parameter, not an error). Never counts iterations
     # itself: test_cases bounds generation, not how many times shrinking
-    # and rejected cases call the body. Measured against libhegel 0.45.4, a
+    # and rejected cases call the body. Measured against libhegel 0.47.1, a
     # run configured for 20 test cases whose body rejected nearly every case
-    # took 475 to 1607 iterations. +stats+ does its own, different counting
+    # took 811 to 1847 iterations. +stats+ does its own, different counting
     # -- see GenerationStats above.
     def drive(impl, ctx, run, stats, captures, &block)
       loop do

data/lib/hegel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hegel
-  VERSION = "0.3.0"
+  VERSION = "0.3.4"
 end

data/lib/tasks/libhegel.rake

@@ -13,16 +13,28 @@ require_relative "../hegel/libhegel_version"
 # needs is fetched here ahead of time, not at resolution time.
 module Hegel
   module LibhegelFetch
-    RELEASE_BASE = "https://github.com/hegeldev/hegel-rust/releases/download"
+    # libhegel 0.47.2 is the first engine release from the hegeldev/hegel
+    # monorepo, tagged libhegel/<version>. hegeldev/hegel-rust holds the
+    # releases up to 0.47.1, tagged libhegel-v<version>, and gets no new
+    # release. hegeldev/hegel does not carry the assets of those older
+    # releases (measured on 2026-10-19: HTTP 404 for libhegel/0.47.1/hegel.h),
+    # so the version selects the repository.
+    MONOREPO_RELEASE_BASE = "https://github.com/hegeldev/hegel/releases/download"
+    MONOREPO_FIRST_VERSION = Gem::Version.new("0.47.2")
+    LEGACY_RELEASE_BASE = "https://github.com/hegeldev/hegel-rust/releases/download"
     DEFAULT_ROOT = File.expand_path("../../tmp/libhegel", __dir__)
 
     module_function
 
-    # Since libhegel 0.42.1, hegel-rust tags an engine release
-    # libhegel-v<version>. The plain v<version> tags belong to its hegeltest
-    # crate, whose version numbers differ from the engine's.
+    # In hegeldev/hegel-rust, the plain v<version> tags belong to the
+    # hegeltest crate, whose version numbers differ from the engine's. In
+    # hegeldev/hegel, the frontends/rust/<version> tags have the same role.
     def release_base(version)
-      "#{RELEASE_BASE}/libhegel-v#{version}"
+      if Gem::Version.new(version) >= MONOREPO_FIRST_VERSION
+        "#{MONOREPO_RELEASE_BASE}/libhegel/#{version}"
+      else
+        "#{LEGACY_RELEASE_BASE}/libhegel-v#{version}"
+      end
     end
 
     # Fetches the host's pinned asset into <root>/<version>/<asset>,

data/lib/tasks/platform_gems.rake

@@ -7,8 +7,8 @@ require_relative "../hegel/locate"
 require_relative "../hegel/libhegel_version"
 require_relative "../hegel/errors"
 
-# Packages this gem for the five platforms hegel-rust publishes a libhegel
-# build for (see Hegel::Locate::ASSET_NAMES), on top of the platform-
+# Packages this gem for the five platforms libhegel publishes a build
+# for (see Hegel::Locate::ASSET_NAMES), on top of the platform-
 # independent "ruby" gem `rake build` already produces. A platform gem
 # differs from that ruby gem in exactly two ways: spec.platform names the
 # platform, and lib/hegel/libhegel/ (Hegel::Locate::GEM_LIBHEGEL_DIR) carries
@@ -103,7 +103,7 @@ module Hegel
 end
 
 namespace :platform_gems do
-  desc "Build the hegeltest gem for every platform hegel-rust publishes libhegel for, " \
+  desc "Build the hegeltest gem for every platform libhegel publishes a build for, " \
     "from assets already fetched by `rake libhegel:fetch_all`"
   task :build do
     Hegel::PlatformGems.build_all.each { |path| puts "built: #{path}" }

data/sig/hegel.rbs

@@ -544,7 +544,7 @@ module Hegel
       def string_generator_text: (untyped ctx, min_size: Integer, max_size: Integer, ?codec: String?, ?min_codepoint: Integer, ?max_codepoint: Integer) -> untyped
       def string_generator_free: (untyped ctx, untyped generator) -> nil
       def generate_string: (untyped ctx, untyped tc, untyped generator) -> String
-      def generate_string_result_free: (untyped ctx, untyped result) -> nil
+      def owned_string_free: (untyped ctx, untyped result) -> nil
       def generate_bytes: (untyped ctx, untyped tc, Integer min_size, Integer max_size) -> String
       def generate_bytes_result_free: (untyped ctx, untyped result) -> nil
       def string_generator_regex: (untyped ctx, String pattern, bool fullmatch, ?untyped alphabet) -> untyped

data/skills/hegel-ruby/references/ruby/reference.md

@@ -494,12 +494,12 @@ expose) are not available in this binding; `codec:`, `min_codepoint:`, and
 `max_codepoint:` are the alphabet controls it exposes today.
 
 Other generators cover most character-set jobs. These results were measured
-with libhegel 0.45.4:
+with libhegel 0.47.1:
 
 | Job | Generator | Measured output |
 |---|---|---|
-| Characters to include | `from_regex("[ぁ-んA-Z0-9]{1,5}", fullmatch: true)` | `"0"`, `"ぢ3"`, `"るJこ"`; 30 draws all matched the pattern |
-| Characters to exclude | `from_regex("[^,\\t\\n]{0,6}", fullmatch: true)` | `""`, `"\u0010ùóR'<"`; 30 draws contained no comma, tab, or newline |
+| Characters to include | `from_regex("[ぁ-んA-Z0-9]{1,5}", fullmatch: true)` | `"0"`, `"D"`, `"Yもで"`; 30 draws all matched the pattern |
+| Characters to exclude | `from_regex("[^,\\t\\n]{0,6}", fullmatch: true)` | `""`, `"RÈbÁ¡"`; 30 draws contained no comma, tab, or newline |
 | A contiguous block | `text(min_codepoint: 0x300, max_codepoint: 0x36F)` | Every character of 100 draws was in U+0300 through U+036F |
 | An arbitrary alphabet | `arrays(sampled_from(%w[ß a İ]), max_size: 4).map(&:join)` | 30 draws, each built only from `ß`, `a`, and `İ` |
 
@@ -512,14 +512,13 @@ inputs and reported this health check:
 
 ```
 FailedHealthCheck: FilterTooMuch — it looks like this test is filtering out
-too many inputs. 50 inputs were filtered out by assume() while only 0 valid
-inputs were generated. If this is expected, suppress the check with
-suppress_health_check = [HealthCheck::FilterTooMuch].
+too many inputs. 50 inputs were rejected by assume() or a filter while only
+0 valid inputs were generated. If this is expected, suppress the
+FilterTooMuch health check with the suppress_health_check setting.
 ```
 
-The engine writes that last sentence in its own naming. This binding takes
-the same setting as `suppress_health_check: [:filter_too_much]`, listed in
-[Settings](#settings).
+This binding takes that setting as
+`suppress_health_check: [:filter_too_much]`, listed in [Settings](#settings).
 
 Unconfigured `text` draws from a much wider Unicode range. In 200 draws of
 `text(min_size: 1, max_size: 4)`, the results included emoji, private-use
@@ -745,6 +744,13 @@ translated): `from_regex(/[a-z]{3}/)` raises `Hegel::Error` at draw time,
 Regexp"`. Pass `my_regexp.source` explicitly for a pattern confirmed to
 need no flags and to use only syntax the two grammars share.
 
+A pattern that no string matches, such as `"(?!)"`, also raises
+`Hegel::Error` at draw time. The engine writes the message, and it names
+the pattern: `from_regex("(?!)")` raises
+`"HEGEL_E_INVALID_ARG (-5): regex pattern \"(?!)\" matches no string the
+generator can produce"`. Since libhegel 0.45.7 the engine makes this
+check.
+
 ### `emails`
 
 An RFC 5321/5322 email address `String`.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hegeltest
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.4
 platform: aarch64-linux
 authors:
 - meganemura
@@ -70,6 +70,8 @@ files:
 - docs/adr/0022-keep-microsecond-times-over-a-nanosecond-engine.md
 - docs/adr/0023-leave-unset-settings-to-the-engines-profile.md
 - docs/adr/0024-release-when-a-merge-changes-the-gem-version.md
+- docs/adr/0025-copy-each-string-input-into-a-hegel-string-t.md
+- docs/adr/0026-select-the-engine-release-repository-by-version.md
 - docs/architecture.md
 - lib/hegel.rb
 - lib/hegel/draw_name.rb