hypercast-wasm 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10c626d762b241c551b0120df1d77ec78d4831a9328c670d2a7bc50c4f3cdf42
-  data.tar.gz: 3fbb217bfe1717648b5a579e034894c2eb55fc797f232b19d2f41aaf950299c2
+  metadata.gz: e8fba4b024f4c3f507d9c5d31187c8434d704e8ce0b613a5dd0d8de1100716e8
+  data.tar.gz: 9156a91e12b17035fa8e7cca34d79d0990e20388b6037386a1555e2a7f9526a9
 SHA512:
-  metadata.gz: 952da6145e72b6d45cda1cb1e56351941cd19f20008a5963ab0452c8c7eec2e6e4204de281d704f2dcf8967d2a8c4a12f0c69984528cd8fdd12e26daded490a2
-  data.tar.gz: e924d2a7f955fd4f748bea86a9e11b8a05343608e4eda4358c9a324aa225088b045a6b569d318fd2b4acc443c847c5809d2ddd91fdbd5fe0aeae19bfcdd56d23
+  metadata.gz: c18b51f977271062987a6c62a34154786b37fdee697661c921846c7034d07178c49b731cce9074aff07864d63a9027f77e11d4c88a9cf101cdb514aa9419aa05
+  data.tar.gz: 6f6ab24b0d6331b2d8020c93ebfb831ebc84df0bb796b6add5a6b733c938bf83d3c8525f307f5141273a81c86e448f46981bb0b27f0496936871c06618c02f8f

data/README.md

@@ -146,8 +146,8 @@ HyperCast::NumFormat.new(decimal_sep: ".", group_sep: ",", flags: HyperCast::ALL
 
 The flags are `GROUPING`, `PARENTHESES`, `EXPONENT`, `RADIX_PREFIXES`, `PERCENT` and
 `CURRENCY` (`ALL_STYLES` is all six), plus `TRAILING_SIGN` — deliberately not in
-`ALL_STYLES`; see below — and the `SEPARATOR_DETECT` policy. A separator is one or two
-characters (`", "`, comma then space, is a separator), up to 8 UTF-8 bytes.
+`ALL_STYLES`; see below — and the `SEPARATOR_DETECT` policy. A separator is 1 to 8 UTF-8
+bytes (`", "`, comma then space, is a separator).
 
 Everything past the separators and the flags is what a culture table would fill in, and
 every such field is declared, never looked up — `from_i18n` fills what Rails' locale data
@@ -250,12 +250,13 @@ any `NumFormat`, and the flags and every other field are left alone, so a `unit:
 format without `CURRENCY` is declared but not honored, as it would be in the constructor.
 `from_i18n` reads Symbol or String keys and ignores every other key, so
 `number.currency.format` passed alone works as well. Missing keys keep the invariant's
-fields. An empty `delimiter` (a locale that writes no grouping) turns `GROUPING` off. A
+fields, except that a missing mark never repeats the one the Hash declares:
+`{separator: ","}` groups with `"."`, as Python's and PHP's locale bridges do. An empty `delimiter` (a locale that writes no grouping) turns `GROUPING` off. A
 `negative_format` that writes the sign after the number (`"%n-"`, `"%n %u-"`) turns
 `TRAILING_SIGN` on; `"-%n"`, the Rails default, leaves it off. `currency_format:` takes
 `number.currency.format` beside `number.format`: its `separator` and `delimiter` become
 `currency_decimal_sep` and `currency_group_sep` (a key it lacks declares nothing, so the
-number separator stands in), its `unit` the currency symbol, and its `negative_format`
+number separator stands in, unless that would repeat the currency mark it does declare), its `unit` the currency symbol, and its `negative_format`
 counts the same way. `flags:` defaults to `ALL_STYLES`.
 
 That is everything the Hash offers. Rails carries no minus or plus sign, no percent symbol
@@ -263,8 +264,7 @@ and no digits, so `from_i18n` leaves those undeclared — the core reads ASCII `
 and `0`–`9` — and a locale that writes them differently declares them on the result:
 `from_i18n(I18n.t("number.format")).with(minus_sign: "−")` for Estonian.
 
-A call without the keywords is exactly the call it was, with no extra allocation on either
-backend. A call with them builds a format each time (a few microseconds), so in a loop,
+A call without the keywords allocates nothing extra on either backend. A call with them builds a format each time (a few microseconds), so in a loop,
 build it once with `override` or `from_i18n` and pass that instead.
 
 ### `datetime`: a culture's AM/PM
@@ -274,8 +274,8 @@ the clock (`3:04 PM`) or ahead of it (`PM 3:04`). `am:` and `pm:` declare a cult
 words beside the English ones — German's `vorm.`/`nachm.`, Korean's `오전`/`오후`
 (written ahead of the clock), Spanish's `a. m.`/`p. m.` (a space inside is fine) — matched
 exactly, with or without a space between word and clock. English is still read whatever is
-declared; `nil`, the default, declares nothing, so a call without the keywords is exactly
-the call it was. Like a `NumFormat`'s symbols the words are declared, never looked up:
+declared; `nil`, the default, declares nothing, so a call without the keywords reads the
+English pair only. Like a `NumFormat`'s symbols the words are declared, never looked up:
 Ruby's stdlib has no day-period data, and `I18n.t("time.am")`/`("time.pm")` are where a
 Rails app finds them.
 
@@ -349,16 +349,14 @@ HyperCast::Interop.version(0x000700)                       # => "0.7.0"
    2.85 µs: a little behind `Time.iso8601`, sitting on Fiddle's per-call marshalling floor.
 
    Separator detection is nearly free here: `1.234.567,89` under `NumFormat::DETECT` runs
-   at 154 ns against 145 ns for the same text under a declared eurozone format. Both cost
-   nearly twice that in 0.1.0, for a reason that had nothing to do with parsing: every format other than `INVARIANT` paid three method dispatches and two
-   `String` allocations per call to read its separators back out of the `Data`. `DETECT`
-   is now identity-matched like `INVARIANT`, and any other format is resolved once per
-   thread and memoized by identity — anchored in a thread-variable so the memo's key can
-   never be a recycled address — which turned the per-call cost into one pointer compare.
+   at 154 ns against 145 ns for the same text under a declared eurozone format. Reading a
+   format costs one pointer compare: `DETECT` is identity-matched like `INVARIANT`, and any
+   other format is resolved once per thread and memoized by identity — anchored in a
+   thread-variable so the memo's key can never be a recycled address.
 
    A declared currency symbol costs text that does not carry one about 6 ns on the Magnus
-   backend: in one run, `1,234,567` took 151 ns under `INVARIANT` and 157 ns under a format
-   declaring `$`. A fault costs more than a success: the same run returned the `Fault` for
+   backend: in a run for 0.9.0, separate from the [Benchmarks](#benchmarks) table, `1,234,567`
+   took 151 ns under `INVARIANT` and 157 ns under a format declaring `$`. A fault costs more than a success: the same run returned the `Fault` for
    `12345x7` in 222 ns, against 101 ns for `Integer("12345x7", exception: false)` returning
    `nil`. The door builds a reason and a span where `Integer()` hands back nothing.
    The three reason Symbols and the option Symbols (`:seconds`, `:month_day_year`, …) are
@@ -366,8 +364,9 @@ HyperCast::Interop.version(0x000700)                       # => "0.7.0"
    `Symbol#name` materialization.
 
 **The honest trade-off:** the civil doors do not beat `strptime`. The date-time door is
-level with `DateTime.strptime` (904 ns against 901 ns) and the date door a little behind
-`Date.strptime` (620 ns against 513 ns). The parse isn't the cost; the carrier is. Building
+level with `DateTime.strptime` (877 ns against 851 ns, the session of the
+[table below](#benchmarks)) and the date door a little behind `Date.strptime` (620 ns against
+513 ns, measured for 0.4.0 and not re-timed since). The parse isn't the cost; the carrier is. Building
 a stdlib `DateTime` with an exact `Rational` second costs more than the whole native call,
 where the timestamp door's `Time` is built by a single cheap `rb_time_nano_new`. If you want
 Ruby's fastest civil parse and don't need the verdict or the declared order, `strptime` is
@@ -377,9 +376,8 @@ which is an artifact of the type, not a zone the parse assigned.
 On the Fiddle fallback the doors are parity-at-best — Fiddle's
 per-call floor is the mechanism's price, kept because it's the universal zero-compile
 path. Its doors build nothing per call that does not change between calls: each format
-owns one native pointer, memoized by identity and passed straight through. (Benchmark forensics worth knowing: the doors read 4.3 µs until
-per-call `Fiddle::Pointer.malloc` finalizers were hoisted to thread-local scratch —
-receipts include their own archaeology.)
+owns one native pointer, memoized by identity and passed straight through, and its scratch
+is thread-local rather than a `Fiddle::Pointer.malloc` per call.
 
 ## Benchmarks
 
@@ -433,33 +431,41 @@ buffers; the core itself keeps no state between calls. `spec/cast_spec.rb`'s
 concurrent-callers example runs under both.
 
 **Ractors.** Main Ractor only, on every backend: called from another Ractor the doors raise
-`Ractor::UnsafeError`.
+(`Ractor::UnsafeError` from the Magnus extension, `Ractor::IsolationError` on Fiddle).
 
 ## Verifying provenance
 
-Every gem RubyGems.org serves — the universal fallback, each of the seven precompiled
-platform gems and `hypercast-wasm` — carries its own GitHub build-provenance attestation, signed directly by
-this repo's own `release.yml` (the `rubygems-publish` job attests `ruby/pkg/*.gem` right
-before the push), so plain `--repo` verifies any of them:
+Every gem RubyGems.org serves — the universal fallback, each of the seven precompiled platform
+gems and `hypercast-wasm` — verifies from the release tag alone: the release attestation,
+signed by this repository's `release.yml` at the tag, names every one of them, with the
+release inventory as its predicate.
 
 ```sh
-gem fetch hypercast -v X.Y.Z --platform <platform>   # or omit --platform for the universal gem
-gh attestation verify hypercast-X.Y.Z-<platform>.gem --repo SkunkWerkx/HyperCast
+gem fetch hypercast -v <version> --platform <platform>   # or omit --platform for the universal gem
+gh attestation verify hypercast-<version>-<platform>.gem --repo SkunkWerkx/HyperCast \
+  --source-ref refs/tags/v<version> --predicate-type https://github.com/SkunkWerkx/.github/predicates/release/v1
 ```
 
-That's the release's second layer of checking, not the only one: before any gem gets built,
-the same job verifies every native binary it packs — the Fiddle libraries, the Magnus
-extensions (one per Ruby ABI per platform), the `wasm32-wasip1` archives — against *their own*
-attestations — those are signed from `SkunkWerkx/.github` by `hyper-build-native.yml` and
-`hyper-build-wasm.yml`, so
-that check needs `--signer-repo SkunkWerkx/.github` added — and refuses to proceed on an
-unverified one.
-RubyGems.org has no unpublish and no duplicate-version overwrite, so this all happens while a
-bad artifact is still reversible. The release run's job summary then re-fetches every gem
-from the CDN and records attested-vs-served digests, turning "rubygems.org stores an upload
-verbatim" into a per-release measurement rather than an assumption — see
-[csharp/README.md's provenance section](../csharp/README.md#native-binary-provenance) for
-more on why `--signer-repo` is needed for some artifacts here and not others.
+Each gem's build provenance is this repository's too: the `ruby-pack` job attests
+`ruby/pkg/*.gem` as soon as they are built and `rubygems-publish` pushes those preserved
+bytes, so plain `--repo` verifies it:
+
+```sh
+gh attestation verify hypercast-<version>-<platform>.gem --repo SkunkWerkx/HyperCast
+```
+
+That is the release's second layer of checking, not the only one: before any gem is built, the
+same job verifies every native binary it packs — the Fiddle libraries, the Magnus extensions
+(one per Ruby ABI per platform), the `wasm32-wasip1` archives — against *their own* build
+provenance, signed from `SkunkWerkx/.github` by `hyper-build-native.yml` and
+`hyper-build-wasm.yml` (so that check needs `--signer-repo SkunkWerkx/.github` added), and
+refuses to proceed on an unverified one. RubyGems.org has no unpublish and no
+duplicate-version overwrite, so all of this happens while a bad artifact is still reversible,
+and the push itself is a separate dispatch from the preserved bytes. The release run then
+re-fetches every gem from rubygems.org and fails unless each matches the attested bytes
+exactly, turning "rubygems.org stores an upload verbatim" into a per-release check rather than
+an assumption. The root README's [Provenance](../README.md#provenance) section has the whole
+picture.
 
 ## Install
 
@@ -529,8 +535,7 @@ Ruby newer than the release, or a platform with no platform gem. `bundle install
 Bundler 2.6, not on 3.3's 2.5); otherwise install the compiler and headers. Pinning `fiddle`
 to your Ruby's version in the `Gemfile.lock` does not stop the build.
 
-Both Windows architectures get a Magnus gem, and the reasoning that once kept them on Fiddle
-was backwards: MinGW is the *only* Windows flavour `rb-sys` targets (`x64-mingw-ucrt` and
+Both Windows architectures get a Magnus gem: MinGW is the *only* Windows flavour `rb-sys` targets (`x64-mingw-ucrt` and
 `aarch64-mingw-ucrt`, both `supported: true` in its own `data/toolchains.json`); the one it
 has no support for is MSVC. Windows is also where the Fiddle fallback cost the most, so these
 are the most worthwhile gems in the set. Both extensions are built for the `gnullvm` Rust
@@ -576,6 +581,12 @@ Load `ruby.wasm` with [`@ruby/wasm-wasi`](https://www.npmjs.com/package/@ruby/wa
 - **No Rust toolchain.** The gem's `extconf.rb` only hands rbwasm the prebuilt archive, and
   rbwasm downloads its own wasi-sdk. The first `rbwasm build` compiles Ruby itself and takes
   15–20 minutes; later builds reuse it.
+- **macOS with Homebrew: limit pkg-config to `openssl@3`.** Run the build as
+  `PKG_CONFIG_LIBDIR="$(brew --prefix openssl@3)/lib/pkgconfig" bundle exec rbwasm build …`.
+  Without it Homebrew's pkg-config files reach into the build twice: its `openssl` is OpenSSL
+  4, which the native Ruby rbwasm builds first does not compile against, and its `libyaml`
+  is a macOS library that psych then links into the wasm interpreter, which fails for Ruby
+  4.0.
 - **`Decimal#to_d` needs `gem "bigdecimal"` in that Gemfile.** bigdecimal is a bundled gem
   with a C extension, and ruby.wasm builds a bundled gem's extension only when the Gemfile
   names it; without it, `to_d` raises `LoadError`. `to_s` and `to_r` need nothing.

data/lib/hypercast.rb

@@ -30,7 +30,7 @@ require_relative "hypercast/runtime"
 module HyperCast
   # This gem's own version — kept in lockstep with hypercast.gemspec by the
   # prepare-release workflow, so the two can never drift apart again.
-  VERSION = "0.9.0"
+  VERSION = "1.0.0"
 
   # The success case of a verdict: a cast value.
   Success = Data.define(:value)
@@ -60,7 +60,7 @@ module HyperCast
   # invariant culture, and nothing that parsed before stops parsing. The currency symbol is
   # honored only while the CURRENCY flag is set — declared with the flag off, the symbol is
   # a :malformed Fault at the symbol, and the flag with no symbol matches nothing — and the
-  # percent symbol while PERCENT is. A separator may be one or two characters (", " —
+  # percent symbol while PERCENT is. A separator may be wider than one character (", " —
   # comma, space — is a separator), up to 8 UTF-8 bytes. A malformed format is a caller bug
   # (ArgumentError), never a verdict: an empty or over-long separator, equal separators (or
   # an equal pair in force for currency amounts), a symbol carrying an ASCII digit, a sign
@@ -125,7 +125,9 @@ module HyperCast
     # key (precision, format, significant, ...) ignored — so
     # `NumFormat.from_i18n(I18n.t("number.format"))` drops a Rails locale straight in, with
     # no I18n dependency here. A missing or nil key keeps the invariant's "." / "," / no
-    # symbol. An empty delimiter — the locale writes no grouping — turns GROUPING off rather
+    # symbol, except where that would repeat the mark the Hash does declare: a separator of
+    # "," with no delimiter groups with ".", and a delimiter of "." with no separator takes
+    # "," for the decimal mark. An empty delimiter — the locale writes no grouping — turns GROUPING off rather
     # than declaring a separator, since a NumFormat always carries one; the placeholder it
     # gets is whichever of "," and "." the decimal mark is not. A negative_format that writes
     # the sign after the number ("%n-", "%n %u-") turns TRAILING_SIGN on; "-%n", the Rails
@@ -136,7 +138,9 @@ module HyperCast
     # differ (the Swiss German franc, say — "1'234.50" beside "1.234,50"): its separator and
     # delimiter become the currency separators, read in place of the number ones when the
     # unit is found in the text, and its unit the currency symbol. A missing key there
-    # declares nothing, keeping the number separator it stands in for; an explicitly empty
+    # declares nothing, keeping the number separator it stands in for, unless that would
+    # repeat the currency mark it does declare, in which case the missing one is whichever
+    # of "," and "." that mark is not; an explicitly empty
     # delimiter gets the same placeholder rule as above; its negative_format turns
     # TRAILING_SIGN on the same way. Passed alone, number.currency.format reads as the one
     # number format, as before.
@@ -149,10 +153,10 @@ module HyperCast
     # narrow flags: for anything stricter.
     def self.from_i18n(number_format, currency_format: nil, flags: ALL_STYLES)
       entries = i18n_entries(number_format)
-      separator = entries[:separator] || "."
-      delimiter = entries[:delimiter] || ","
-      if delimiter == ""
-        flags &= ~GROUPING
+      separator = entries[:separator] || (entries[:delimiter] == "." ? "," : ".")
+      delimiter = entries[:delimiter]
+      if delimiter.nil? || delimiter == ""
+        flags &= ~GROUPING if delimiter == ""
         delimiter = separator == "," ? "." : ","
       end
       flags |= TRAILING_SIGN if trailing_sign?(entries[:negative_format])
@@ -164,6 +168,11 @@ module HyperCast
         currency_separator = money[:separator] || ""
         currency_delimiter = money[:delimiter] || ""
         currency_delimiter = (money[:separator] || separator) == "," ? "." : "," if money[:delimiter] == ""
+        if currency_separator.empty? && currency_delimiter == separator
+          currency_separator = currency_delimiter == "," ? "." : ","
+        elsif currency_delimiter.empty? && currency_separator == delimiter
+          currency_delimiter = currency_separator == "," ? "." : ","
+        end
         flags |= TRAILING_SIGN if trailing_sign?(money[:negative_format])
       end
       new(decimal_sep: separator, group_sep: delimiter, flags: flags, currency: currency,
@@ -253,7 +262,7 @@ module HyperCast
   NumFormat::CURRENCY_MAX_BYTES = 16
 
   # The widest separator, sign or percent symbol the native ABI carries inline, in UTF-8
-  # bytes: one or two characters of any script.
+  # bytes: enough for every separator a real culture declares (one or two characters).
   NumFormat::SYMBOL_MAX_BYTES = 8
 
   # The size of NumFormat#packed — the native ABI's size-tagged NumFormat layout — in bytes.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hypercast-wasm
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Brian Buvinghausen