RubyGems - jsonschema_rs - Versions diffs - 0.43.0 → 0.44.0 - Mend

jsonschema_rs 0.43.0 → 0.44.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 511735bb41a48b95a424e5b92436aafe412822923eb943c0afd831ccbbcc94f8
-  data.tar.gz: 15ee16fe53ab1c97071e21cce8cf2f3ff5b74d758d63319f25133f5165a8c74c
+  metadata.gz: 51236b02371703841ea00783cfc0a9d5b97281a27a527c390795ab02f5e88aac
+  data.tar.gz: 87fb69c295b4a82d16d20fab2368aa9eb7b90167f2135b411ee8b0279db0399d
 SHA512:
-  metadata.gz: ead73ff80442e834f88215faa2c7d56f90bfdc4d8d3340211a313f74ba0ded0cb0da35e4400fb6554aafd3e0295b6c2ba18f94f26768cda847192941549f0c58
-  data.tar.gz: 5af852de21e182955493ab5dc5ffc0b7e71735128d98247508d0ff153432014387590398ca38c138ff72d2cd55bbf2ab4db0a32e83f7da810769c6ad5eeb239c
+  metadata.gz: abc58a0cf0669380c5c3035a76586e45d952584cf5742878a451a10dab18ebfb5a7210bf80f022da8a3b302ead4364337554544537f7432e46161343b8cf7888
+  data.tar.gz: 991fdcf4e5661180a09918c7bce74c3afd9adf73543b8f1ba4d0f2c046e2feccb4cb9bb757e3f315c126665d67455eaecd938d24338b8dd18c0f30b4b897ca59

data/CHANGELOG.md CHANGED Viewed

@@ -2,6 +2,16 @@
 ## [Unreleased]
+## [0.44.0] - 2026-03-02
+### Added
+- `Canonical::JSON.to_string(object)` for canonical JSON serialization (stable key ordering and numeric normalization), useful for deduplicating equivalent JSON Schemas.
+### Fixed
+- Do not produce annotations for non-string instances from `contentMediaType`, `contentEncoding`, and `contentSchema` keywords.
 ## [0.43.0] - 2026-02-28
 ### Added
@@ -43,7 +53,8 @@
 - Initial public release
-[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.43.0...HEAD
+[Unreleased]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.44.0...HEAD
+[0.44.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.43.0...ruby-v0.44.0
 [0.43.0]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.42.2...ruby-v0.43.0
 [0.42.2]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.42.1...ruby-v0.42.2
 [0.42.1]: https://github.com/Stranger6667/jsonschema/compare/ruby-v0.42.0...ruby-v0.42.1

data/Cargo.toml CHANGED Viewed

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb"
-version = "0.43.0"
+version = "0.44.0"
 edition = "2021"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 license = "MIT"
@@ -13,7 +13,7 @@ publish = false
 crate-type = ["cdylib"]
 [dependencies]
-jsonschema = { version = "0.43.0", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring"] }
+jsonschema = { version = "0.44.0", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring"] }
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
 serde = { workspace = true }

data/README.md CHANGED Viewed

@@ -251,6 +251,22 @@ valid_eval.annotations
 #      instanceLocation: "", annotations: ["age", "name"]}]
 ```
+### Canonical JSON serialization
+Use `Canonical::JSON.to_string` when you need a stable JSON representation:
+```ruby
+schema_a = { "type" => "object", "properties" => { "b" => { "type" => "integer" }, "a" => { "type" => "string" } } }
+schema_b = { "properties" => { "a" => { "type" => "string" }, "b" => { "type" => "integer" } }, "type" => "object" }
+dump_a = JSONSchema::Canonical::JSON.to_string(schema_a)
+dump_b = JSONSchema::Canonical::JSON.to_string(schema_b)
+dump_a == dump_b # => true
+```
+Main use case: deduplicating equivalent JSON Schemas.
 ## Meta-Schema Validation
 Validate that a JSON Schema document is itself valid:

data/ext/jsonschema/Cargo.lock CHANGED Viewed

@@ -98,9 +98,9 @@ checksum = "dc0b364ead1874514c8c2855ab558056ebfeb775653e7ae45ff72f28f8f3166c"
 [[package]]
 name = "bumpalo"
-version = "3.19.1"
+version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 [[package]]
 name = "bytecount"
@@ -281,9 +281,9 @@ dependencies = [
 [[package]]
 name = "futures-channel"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -291,33 +291,33 @@ dependencies = [
 [[package]]
 name = "futures-core"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
 [[package]]
 name = "futures-io"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 [[package]]
 name = "futures-sink"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
 [[package]]
 name = "futures-task"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
 [[package]]
 name = "futures-util"
-version = "0.3.31"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
  "futures-core",
  "futures-io",
@@ -325,7 +325,6 @@ dependencies = [
  "futures-task",
  "memchr",
  "pin-project-lite",
- "pin-utils",
  "slab",
 ]
@@ -657,9 +656,9 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 [[package]]
 name = "js-sys"
-version = "0.3.85"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
+checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -667,9 +666,9 @@ dependencies = [
 [[package]]
 name = "jsonschema"
-version = "0.43.0"
+version = "0.44.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dcfbe6df48e0121219eefc8d6a30b872ac2769c7896454bda06f7b64129fa22"
+checksum = "267fb27be492e66ab147d2ce0233d88ae465b93c3565016e73998729bf3fe60f"
 dependencies = [
  "ahash",
  "bytecount",
@@ -697,7 +696,7 @@ dependencies = [
 [[package]]
 name = "jsonschema-rb-ext"
-version = "0.43.0"
+version = "0.44.0"
 dependencies = [
  "jsonschema",
  "magnus",
@@ -940,9 +939,9 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 [[package]]
 name = "pin-project-lite"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 [[package]]
 name = "pin-utils"
@@ -1044,9 +1043,9 @@ dependencies = [
 [[package]]
 name = "referencing"
-version = "0.43.0"
+version = "0.44.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37add1aa1d619a975521d262d09f100f1f767791c9386c03679450f30acd78c1"
+checksum = "12ecd0f3daefd4faff2e0821310c18e6e9d1fd00550bbd7e5a59d78184a071bc"
 dependencies = [
  "ahash",
  "fluent-uri",
@@ -1082,9 +1081,9 @@ dependencies = [
 [[package]]
 name = "regex-syntax"
-version = "0.8.9"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 [[package]]
 name = "reqwest"
@@ -1147,9 +1146,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 [[package]]
 name = "rustls"
-version = "0.23.36"
+version = "0.23.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
+checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
 dependencies = [
  "once_cell",
  "ring",
@@ -1250,9 +1249,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 [[package]]
 name = "security-framework"
-version = "3.6.0"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d17b898a6d6948c3a8ee4372c17cb384f90d2e6e912ef00895b14fd7ab54ec38"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
  "bitflags",
  "core-foundation",
@@ -1263,9 +1262,9 @@ dependencies = [
 [[package]]
 name = "security-framework-sys"
-version = "2.16.0"
+version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "321c8673b092a9a42605034a9879d73cb79101ed5fd117bc9a597b89b4e9e61a"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -1368,9 +1367,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 [[package]]
 name = "syn"
-version = "2.0.115"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e614ed320ac28113fa64972c4262d5dbc89deacdfd00c34a3e4cea073243c12"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1542,9 +1541,9 @@ checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f"
 [[package]]
 name = "unicode-ident"
-version = "1.0.23"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "537dd038a89878be9b64dd4bd1b260315c1bb94f4d784956b81e27a088d9a09e"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 [[package]]
 name = "untrusted"
@@ -1628,9 +1627,9 @@ dependencies = [
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
+checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1641,9 +1640,9 @@ dependencies = [
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.58"
+version = "0.4.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
+checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -1655,9 +1654,9 @@ dependencies = [
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
+checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1665,9 +1664,9 @@ dependencies = [
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
+checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -1678,18 +1677,18 @@ dependencies = [
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.108"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
 dependencies = [
  "unicode-ident",
 ]
 [[package]]
 name = "web-sys"
-version = "0.3.85"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
+checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -1978,18 +1977,18 @@ dependencies = [
 [[package]]
 name = "zerocopy"
-version = "0.8.39"
+version = "0.8.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
+checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
 dependencies = [
  "zerocopy-derive",
 ]
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.39"
+version = "0.8.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
+checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
 dependencies = [
  "proc-macro2",
  "quote",

data/ext/jsonschema/Cargo.toml CHANGED Viewed

@@ -1,6 +1,6 @@
 [package]
 name = "jsonschema-rb-ext"
-version = "0.43.0"
+version = "0.44.0"
 edition = "2021"
 publish = false
@@ -10,10 +10,10 @@ name = "jsonschema_rb"
 path = "../../src/lib.rs"
 [dependencies]
-jsonschema = { version = "0.43.0", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring"] }
+jsonschema = { version = "0.44.0", default-features = false, features = ["arbitrary-precision", "resolve-http", "resolve-file", "tls-ring"] }
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = "0.9"
-referencing = "0.43.0"
+referencing = "0.44.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["arbitrary_precision"] }

data/lib/jsonschema/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module JSONSchema
-  VERSION = "0.43.0"
+  VERSION = "0.44.0"
 end

data/sig/jsonschema.rbs CHANGED Viewed

@@ -7,6 +7,15 @@ module JSONSchema
   # Valid draft version symbols
   type draft = :draft4 | :draft6 | :draft7 | :draft201909 | :draft202012
+  module Canonical
+    module JSON
+      # Serialize a Ruby value to canonical JSON.
+      #
+      # Main use case: deduplicate equivalent JSON Schemas by using a stable string form.
+      def self.to_string: (untyped object) -> String
+    end
+  end
   # Create a validator with auto-detected draft version.
   #
   # @param schema The JSON Schema (Hash or JSON string)

data/src/lib.rs CHANGED Viewed

@@ -42,7 +42,7 @@ use crate::{
     },
     registry::Registry,
     retriever::{retriever_error_message, RubyRetriever},
-    ser::{to_schema_value, to_value},
+    ser::{to_canonical_string, to_schema_value, to_value},
     static_id::define_rb_intern,
 };
@@ -838,6 +838,15 @@ fn validator_for(ruby: &Ruby, args: &[Value]) -> Result<Validator, Error> {
     })
 }
+/// to_string(object) -> String
+///
+/// Serialize a Ruby value to canonical JSON.
+///
+/// Main use case: deduplicating equivalent JSON Schemas using a stable string form.
+fn canonical_json_to_string(ruby: &Ruby, object: Value) -> Result<String, Error> {
+    to_canonical_string(ruby, object)
+}
 #[allow(unsafe_code)]
 fn is_valid(ruby: &Ruby, args: &[Value]) -> Result<bool, Error> {
     let parsed_args = scan_args::<(Value, Value), (), (), (), _, ()>(args)?;
@@ -1327,6 +1336,11 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_singleton_method("each_error", function!(each_error, -1))?;
     module.define_singleton_method("evaluate", function!(evaluate, -1))?;
+    let canonical_module = module.define_module("Canonical")?;
+    let canonical_json_module = canonical_module.define_module("JSON")?;
+    canonical_json_module
+        .define_singleton_method("to_string", function!(canonical_json_to_string, 1))?;
     // Validator class
     let validator_class = module.define_class("Validator", ruby.class_object())?;
     validator_class.define_method("valid?", method!(Validator::is_valid, 1))?;

data/src/ser.rs CHANGED Viewed

@@ -1,5 +1,7 @@
 //! Serialization between Ruby values and `serde_json::Value`.
 use magnus::{
+    error::ErrorType,
+    exception::ExceptionClass,
     gc::register_mark_object,
     prelude::*,
     rb_sys::AsRawValue,
@@ -7,8 +9,15 @@ use magnus::{
     Error, Integer, RArray, RClass, RHash, RString, Ruby, Symbol, TryConvert, Value,
 };
 use rb_sys::{ruby_value_type, RB_TYPE};
+use serde::{
+    ser::{SerializeMap, SerializeSeq},
+    Serialize, Serializer,
+};
 use serde_json::{Map, Number, Value as JsonValue};
-use std::fmt;
+use std::{
+    cell::RefCell,
+    fmt::{self, Write},
+};
 static BIG_DECIMAL_CLASS: Lazy<RClass> = Lazy::new(|ruby| {
     // Ensure bigdecimal is loaded
@@ -23,6 +32,15 @@ static BIG_DECIMAL_CLASS: Lazy<RClass> = Lazy::new(|ruby| {
 });
 const RECURSION_LIMIT: u16 = 255;
+const I64_LOWER_INCLUSIVE_F64: f64 = -9_223_372_036_854_775_808.0;
+const I64_UPPER_EXCLUSIVE_F64: f64 = 9_223_372_036_854_775_808.0;
+const U64_UPPER_EXCLUSIVE_F64: f64 = 18_446_744_073_709_551_616.0;
+const IEEE754_F64_FRAC_BITS: u32 = 52;
+const IEEE754_F64_EXP_BIAS: i32 = 1023;
+const DECIMAL_BASE_U64: u64 = 1_000_000_000;
+const DECIMAL_CHUNK_WIDTH: usize = 9;
+const CANONICAL_ERROR_PREFIX: &str = "__jsonschema_rb_canonical_error__";
+const DUPLICATE_CANONICAL_KEY_MESSAGE: &str = "Hash contains duplicate keys after normalization";
 #[inline]
 pub fn to_value(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
@@ -52,6 +70,25 @@ pub fn to_schema_value(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
     to_value_typed(ruby, value, value_type, 0)
 }
+/// Serialize a Ruby value to canonical JSON.
+///
+/// Used to generate a stable string form for deduplicating equivalent schemas.
+#[inline]
+pub fn to_canonical_string(ruby: &Ruby, value: Value) -> Result<String, Error> {
+    let mut output = Vec::new();
+    let mut serializer = serde_json::Serializer::new(&mut output);
+    let scratch_pool = RefCell::new(Vec::new());
+    CanonicalRubyValue::new(ruby, value, 0, &scratch_pool)
+        .serialize(&mut serializer)
+        .map_err(|error| canonical_serde_error_to_ruby(ruby, &error))?;
+    String::from_utf8(output).map_err(|_| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            "Internal UTF-8 serialization error",
+        )
+    })
+}
 fn to_value_recursive(ruby: &Ruby, value: Value, depth: u16) -> Result<JsonValue, Error> {
     if value.is_nil() {
         return Ok(JsonValue::Null);
@@ -76,96 +113,576 @@ fn to_value_typed(
         ruby_value_type::RUBY_T_FIXNUM | ruby_value_type::RUBY_T_BIGNUM => {
             convert_integer(ruby, value)
         }
-        ruby_value_type::RUBY_T_FLOAT => {
-            let f = f64::try_convert(value)?;
-            Number::from_f64(f).map(JsonValue::Number).ok_or_else(|| {
-                Error::new(
-                    ruby.exception_arg_error(),
-                    "Cannot convert NaN or Infinity to JSON",
-                )
-            })
+        ruby_value_type::RUBY_T_FLOAT => convert_float(ruby, value),
+        ruby_value_type::RUBY_T_STRING => convert_string(ruby, value),
+        ruby_value_type::RUBY_T_SYMBOL => convert_symbol(value),
+        ruby_value_type::RUBY_T_ARRAY => convert_array(ruby, value, depth),
+        ruby_value_type::RUBY_T_HASH => convert_hash(ruby, value, depth),
+        ruby_value_type::RUBY_T_DATA if value.is_kind_of(ruby.get_inner(&BIG_DECIMAL_CLASS)) => {
+            convert_big_decimal(ruby, value)
         }
-        ruby_value_type::RUBY_T_STRING => {
-            let Some(rstring) = RString::from_value(value) else {
-                unreachable!("We checked the type tag")
-            };
-            // SAFETY: rstring is valid and we're in Ruby VM context
-            #[allow(unsafe_code)]
-            let bytes = unsafe { rstring.as_slice() };
-            match std::str::from_utf8(bytes) {
-                Ok(s) => Ok(JsonValue::String(s.to_owned())),
-                Err(_) => Err(Error::new(
-                    ruby.exception_encoding_error(),
-                    "String is not valid UTF-8",
-                )),
-            }
+        _ => unsupported_type_error(ruby, value),
+    }
+}
+#[inline]
+fn convert_float(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
+    let float = f64::try_convert(value)?;
+    Number::from_f64(float)
+        .map(JsonValue::Number)
+        .ok_or_else(|| {
+            Error::new(
+                ruby.exception_arg_error(),
+                "Cannot convert NaN or Infinity to JSON",
+            )
+        })
+}
+#[inline]
+fn convert_string(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
+    utf8_string_from_value(ruby, value, "String is not valid UTF-8").map(JsonValue::String)
+}
+#[inline]
+fn convert_symbol(value: Value) -> Result<JsonValue, Error> {
+    symbol_name_from_value(value).map(JsonValue::String)
+}
+fn convert_array(ruby: &Ruby, value: Value, depth: u16) -> Result<JsonValue, Error> {
+    if depth >= RECURSION_LIMIT {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            format!("Exceeded maximum nesting depth ({RECURSION_LIMIT})"),
+        ));
+    }
+    let Some(arr) = RArray::from_value(value) else {
+        unreachable!("We checked the type tag")
+    };
+    let len = arr.len();
+    let mut json_arr = Vec::with_capacity(len);
+    // Do not use `RArray::as_slice` here: recursive conversion may call
+    // Ruby APIs for nested values, and `as_slice` borrows Ruby-managed
+    // memory that must not be held across Ruby calls/GC.
+    for idx in 0..len {
+        let idx = isize::try_from(idx).map_err(|_| {
+            Error::new(
+                ruby.exception_arg_error(),
+                "Array index exceeds supported range",
+            )
+        })?;
+        let item: Value = arr.entry(idx)?;
+        json_arr.push(to_value_recursive(ruby, item, depth + 1)?);
+    }
+    Ok(JsonValue::Array(json_arr))
+}
+fn convert_hash(ruby: &Ruby, value: Value, depth: u16) -> Result<JsonValue, Error> {
+    if depth >= RECURSION_LIMIT {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            format!("Exceeded maximum nesting depth ({RECURSION_LIMIT})"),
+        ));
+    }
+    let Some(hash) = RHash::from_value(value) else {
+        unreachable!("We checked the type tag")
+    };
+    let mut map = Map::with_capacity(hash.len());
+    hash.foreach(|key: Value, val: Value| {
+        let key_str = hash_key_to_string(ruby, key)?;
+        let json_val = to_value_recursive(ruby, val, depth + 1)?;
+        map.insert(key_str, json_val);
+        Ok(magnus::r_hash::ForEach::Continue)
+    })?;
+    Ok(JsonValue::Object(map))
+}
+#[inline]
+fn unsupported_type_error(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
+    let class = value.class();
+    #[allow(unsafe_code)]
+    let class_name = unsafe { class.name() };
+    Err(Error::new(
+        ruby.exception_type_error(),
+        format!("Unsupported type: '{class_name}'"),
+    ))
+}
+#[derive(Clone, Copy)]
+enum CanonicalErrorKind {
+    Argument,
+    Type,
+    Encoding,
+    Runtime,
+}
+impl CanonicalErrorKind {
+    #[inline]
+    fn as_tag(self) -> &'static str {
+        match self {
+            Self::Argument => "argument",
+            Self::Type => "type",
+            Self::Encoding => "encoding",
+            Self::Runtime => "runtime",
         }
-        ruby_value_type::RUBY_T_SYMBOL => {
-            let Some(sym) = Symbol::from_value(value) else {
-                unreachable!("We checked the type tag")
-            };
-            let name = sym.name()?;
-            Ok(JsonValue::String(name.to_string()))
+    }
+    #[inline]
+    fn from_tag(tag: &str) -> Option<Self> {
+        match tag {
+            "argument" => Some(Self::Argument),
+            "type" => Some(Self::Type),
+            "encoding" => Some(Self::Encoding),
+            "runtime" => Some(Self::Runtime),
+            _ => None,
+        }
+    }
+    #[inline]
+    fn exception(self, ruby: &Ruby) -> ExceptionClass {
+        match self {
+            Self::Argument => ruby.exception_arg_error(),
+            Self::Type => ruby.exception_type_error(),
+            Self::Encoding => ruby.exception_encoding_error(),
+            Self::Runtime => ruby.exception_runtime_error(),
+        }
+    }
+}
+#[inline]
+fn canonical_error_kind_from_ruby_error(ruby: &Ruby, error: &Error) -> CanonicalErrorKind {
+    if error.is_kind_of(ruby.exception_type_error()) {
+        CanonicalErrorKind::Type
+    } else if error.is_kind_of(ruby.exception_encoding_error()) {
+        CanonicalErrorKind::Encoding
+    } else if error.is_kind_of(ruby.exception_runtime_error()) {
+        CanonicalErrorKind::Runtime
+    } else {
+        CanonicalErrorKind::Argument
+    }
+}
+#[inline]
+fn ruby_error_message(error: &Error) -> String {
+    match error.error_type() {
+        ErrorType::Error(_, message) => message.to_string(),
+        _ => error.to_string(),
+    }
+}
+#[inline]
+fn encode_canonical_error(kind: CanonicalErrorKind, message: &str) -> String {
+    format!("{CANONICAL_ERROR_PREFIX}{}|{message}", kind.as_tag())
+}
+#[inline]
+fn decode_canonical_error(message: &str) -> Option<(CanonicalErrorKind, &str)> {
+    let payload = message.strip_prefix(CANONICAL_ERROR_PREFIX)?;
+    let (tag, body) = payload.split_once('|')?;
+    Some((CanonicalErrorKind::from_tag(tag)?, body))
+}
+#[inline]
+fn canonical_serde_error_to_ruby(ruby: &Ruby, error: &serde_json::Error) -> Error {
+    let rendered = error.to_string();
+    let suffix = format!(" at line {} column {}", error.line(), error.column());
+    let without_location = rendered.strip_suffix(&suffix).unwrap_or(&rendered);
+    if let Some((kind, message)) = decode_canonical_error(without_location) {
+        return Error::new(kind.exception(ruby), message.to_string());
+    }
+    Error::new(ruby.exception_arg_error(), rendered)
+}
+#[inline]
+fn ruby_error_to_canonical_serde<S>(ruby: &Ruby, error: &Error) -> S::Error
+where
+    S: Serializer,
+{
+    let kind = canonical_error_kind_from_ruby_error(ruby, error);
+    let message = ruby_error_message(error);
+    serde::ser::Error::custom(encode_canonical_error(kind, &message))
+}
+#[inline]
+fn canonical_serde_error<S>(kind: CanonicalErrorKind, message: &str) -> S::Error
+where
+    S: Serializer,
+{
+    serde::ser::Error::custom(encode_canonical_error(kind, message))
+}
+#[inline]
+fn utf8_string_from_rstring(
+    ruby: &Ruby,
+    rstring: RString,
+    error_message: &'static str,
+) -> Result<String, Error> {
+    // SAFETY: rstring is valid and we're in Ruby VM context.
+    #[allow(unsafe_code)]
+    let bytes = unsafe { rstring.as_slice() };
+    std::str::from_utf8(bytes)
+        .map(str::to_owned)
+        .map_err(|_| Error::new(ruby.exception_encoding_error(), error_message))
+}
+#[inline]
+fn utf8_string_from_value(
+    ruby: &Ruby,
+    value: Value,
+    error_message: &'static str,
+) -> Result<String, Error> {
+    let Some(rstring) = RString::from_value(value) else {
+        unreachable!("We checked the type tag")
+    };
+    utf8_string_from_rstring(ruby, rstring, error_message)
+}
+#[inline]
+fn symbol_name_from_value(value: Value) -> Result<String, Error> {
+    let Some(sym) = Symbol::from_value(value) else {
+        unreachable!("We checked the type tag")
+    };
+    Ok(sym.name()?.to_string())
+}
+const MAX_CANONICAL_SCRATCH_POOL_SIZE: usize = 8;
+const MAX_CANONICAL_SCRATCH_CAPACITY: usize = 16_384;
+struct HashEntry {
+    key: String,
+    value: Value,
+}
+struct HashEntryScratch<'a> {
+    entries: Vec<HashEntry>,
+    pool: &'a RefCell<Vec<Vec<HashEntry>>>,
+}
+impl<'a> HashEntryScratch<'a> {
+    fn with_capacity(pool: &'a RefCell<Vec<Vec<HashEntry>>>, capacity: usize) -> Self {
+        let mut entries = pool.borrow_mut().pop().unwrap_or_default();
+        if entries.capacity() < capacity {
+            entries.reserve(capacity - entries.capacity());
+        }
+        Self { entries, pool }
+    }
+    #[inline]
+    fn entries_mut(&mut self) -> &mut Vec<HashEntry> {
+        &mut self.entries
+    }
+    #[inline]
+    fn entries(&self) -> &[HashEntry] {
+        &self.entries
+    }
+}
+impl Drop for HashEntryScratch<'_> {
+    fn drop(&mut self) {
+        self.entries.clear();
+        if self.entries.capacity() > MAX_CANONICAL_SCRATCH_CAPACITY {
+            return;
+        }
+        let mut pool = self.pool.borrow_mut();
+        if pool.len() < MAX_CANONICAL_SCRATCH_POOL_SIZE {
+            pool.push(std::mem::take(&mut self.entries));
+        }
+    }
+}
+struct CanonicalRubyValue<'scratch> {
+    ruby: &'scratch Ruby,
+    value: Value,
+    depth: u16,
+    scratch_pool: &'scratch RefCell<Vec<Vec<HashEntry>>>,
+}
+impl<'scratch> CanonicalRubyValue<'scratch> {
+    fn new(
+        ruby: &'scratch Ruby,
+        value: Value,
+        depth: u16,
+        scratch_pool: &'scratch RefCell<Vec<Vec<HashEntry>>>,
+    ) -> Self {
+        Self {
+            ruby,
+            value,
+            depth,
+            scratch_pool,
+        }
+    }
+}
+impl Serialize for CanonicalRubyValue<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        if self.value.is_nil() {
+            return serializer.serialize_unit();
         }
-        ruby_value_type::RUBY_T_ARRAY => {
-            if depth >= RECURSION_LIMIT {
-                return Err(Error::new(
-                    ruby.exception_arg_error(),
-                    format!("Exceeded maximum nesting depth ({RECURSION_LIMIT})"),
-                ));
+        // SAFETY: We're reading the type tag of a valid Ruby value
+        #[allow(unsafe_code)]
+        let value_type = unsafe { RB_TYPE(self.value.as_raw()) };
+        match value_type {
+            ruby_value_type::RUBY_T_TRUE => serializer.serialize_bool(true),
+            ruby_value_type::RUBY_T_FALSE => serializer.serialize_bool(false),
+            ruby_value_type::RUBY_T_FIXNUM | ruby_value_type::RUBY_T_BIGNUM => {
+                let number = convert_integer(self.ruby, self.value)
+                    .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                number.serialize(serializer)
             }
-            let Some(arr) = RArray::from_value(value) else {
-                unreachable!("We checked the type tag")
-            };
-            let len = arr.len();
-            let mut json_arr = Vec::with_capacity(len);
-            // Do not use `RArray::as_slice` here: recursive conversion may call
-            // Ruby APIs for nested values, and `as_slice` borrows Ruby-managed
-            // memory that must not be held across Ruby calls/GC.
-            for idx in 0..len {
-                let idx = isize::try_from(idx).map_err(|_| {
-                    Error::new(
-                        ruby.exception_arg_error(),
-                        "Array index exceeds supported range",
-                    )
-                })?;
-                let item: Value = arr.entry(idx)?;
-                json_arr.push(to_value_recursive(ruby, item, depth + 1)?);
+            ruby_value_type::RUBY_T_FLOAT => {
+                let number = convert_float_for_canonical(self.ruby, self.value)
+                    .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                number.serialize(serializer)
             }
-            Ok(JsonValue::Array(json_arr))
-        }
-        ruby_value_type::RUBY_T_HASH => {
-            if depth >= RECURSION_LIMIT {
-                return Err(Error::new(
-                    ruby.exception_arg_error(),
-                    format!("Exceeded maximum nesting depth ({RECURSION_LIMIT})"),
-                ));
+            ruby_value_type::RUBY_T_STRING => {
+                let value =
+                    utf8_string_from_value(self.ruby, self.value, "String is not valid UTF-8")
+                        .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                serializer.serialize_str(value.as_str())
+            }
+            ruby_value_type::RUBY_T_SYMBOL => {
+                let name = symbol_name_from_value(self.value)
+                    .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                serializer.serialize_str(name.as_str())
+            }
+            ruby_value_type::RUBY_T_ARRAY => {
+                if self.depth >= RECURSION_LIMIT {
+                    return Err(canonical_serde_error::<S>(
+                        CanonicalErrorKind::Argument,
+                        &format!("Exceeded maximum nesting depth ({RECURSION_LIMIT})"),
+                    ));
+                }
+                let Some(arr) = RArray::from_value(self.value) else {
+                    unreachable!("We checked the type tag")
+                };
+                let len = arr.len();
+                let mut sequence = serializer.serialize_seq(Some(len))?;
+                for idx in 0..len {
+                    let idx = isize::try_from(idx).map_err(|_| {
+                        canonical_serde_error::<S>(
+                            CanonicalErrorKind::Argument,
+                            "Array index exceeds supported range",
+                        )
+                    })?;
+                    let item: Value = arr
+                        .entry(idx)
+                        .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                    sequence.serialize_element(&CanonicalRubyValue::new(
+                        self.ruby,
+                        item,
+                        self.depth + 1,
+                        self.scratch_pool,
+                    ))?;
+                }
+                sequence.end()
+            }
+            ruby_value_type::RUBY_T_HASH => {
+                if self.depth >= RECURSION_LIMIT {
+                    return Err(canonical_serde_error::<S>(
+                        CanonicalErrorKind::Argument,
+                        &format!("Exceeded maximum nesting depth ({RECURSION_LIMIT})"),
+                    ));
+                }
+                let Some(hash) = RHash::from_value(self.value) else {
+                    unreachable!("We checked the type tag")
+                };
+                let len = hash.len();
+                let mut scratch = HashEntryScratch::with_capacity(self.scratch_pool, len);
+                hash.foreach(|key: Value, value: Value| {
+                    let key = hash_key_to_string(self.ruby, key)?;
+                    scratch.entries_mut().push(HashEntry { key, value });
+                    Ok(magnus::r_hash::ForEach::Continue)
+                })
+                .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                let entries = scratch.entries_mut();
+                entries.sort_by(|left, right| left.key.as_bytes().cmp(right.key.as_bytes()));
+                if entries
+                    .windows(2)
+                    .any(|window| window[0].key == window[1].key)
+                {
+                    return Err(canonical_serde_error::<S>(
+                        CanonicalErrorKind::Type,
+                        DUPLICATE_CANONICAL_KEY_MESSAGE,
+                    ));
+                }
+                let mut map = serializer.serialize_map(Some(len))?;
+                for entry in scratch.entries() {
+                    map.serialize_entry(
+                        entry.key.as_str(),
+                        &CanonicalRubyValue::new(
+                            self.ruby,
+                            entry.value,
+                            self.depth + 1,
+                            self.scratch_pool,
+                        ),
+                    )?;
+                }
+                map.end()
+            }
+            ruby_value_type::RUBY_T_DATA
+                if self
+                    .value
+                    .is_kind_of(self.ruby.get_inner(&BIG_DECIMAL_CLASS)) =>
+            {
+                let number = convert_big_decimal_for_canonical(self.ruby, self.value)
+                    .map_err(|error| ruby_error_to_canonical_serde::<S>(self.ruby, &error))?;
+                number.serialize(serializer)
+            }
+            _ => {
+                let class = self.value.class();
+                #[allow(unsafe_code)]
+                let class_name = unsafe { class.name() };
+                Err(canonical_serde_error::<S>(
+                    CanonicalErrorKind::Type,
+                    &format!("Unsupported type: '{class_name}'"),
+                ))
             }
-            let Some(hash) = RHash::from_value(value) else {
-                unreachable!("We checked the type tag")
-            };
-            let mut map = Map::with_capacity(hash.len());
-            hash.foreach(|key: Value, val: Value| {
-                let key_str = hash_key_to_string(ruby, key)?;
-                let json_val = to_value_recursive(ruby, val, depth + 1)?;
-                map.insert(key_str, json_val);
-                Ok(magnus::r_hash::ForEach::Continue)
-            })?;
-            Ok(JsonValue::Object(map))
         }
-        ruby_value_type::RUBY_T_DATA if value.is_kind_of(ruby.get_inner(&BIG_DECIMAL_CLASS)) => {
-            convert_big_decimal(ruby, value)
+    }
+}
+#[inline]
+fn convert_float_for_canonical(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
+    let float = f64::try_convert(value)?;
+    if !float.is_finite() {
+        return Ok(JsonValue::Null);
+    }
+    if float == 0.0 {
+        return Ok(JsonValue::Number(Number::from(0)));
+    }
+    if float.fract() == 0.0 {
+        if (0.0..U64_UPPER_EXCLUSIVE_F64).contains(&float) {
+            // SAFETY: range check above guarantees a lossless conversion.
+            #[allow(unsafe_code)]
+            let integer = unsafe { float.to_int_unchecked::<u64>() };
+            return Ok(JsonValue::Number(Number::from(integer)));
         }
-        _ => {
-            let class = value.class();
+        if (I64_LOWER_INCLUSIVE_F64..I64_UPPER_EXCLUSIVE_F64).contains(&float) {
+            // SAFETY: range check above guarantees a lossless conversion.
             #[allow(unsafe_code)]
-            let class_name = unsafe { class.name() };
-            Err(Error::new(
-                ruby.exception_type_error(),
-                format!("Unsupported type: '{class_name}'"),
-            ))
+            let integer = unsafe { float.to_int_unchecked::<i64>() };
+            return Ok(JsonValue::Number(Number::from(integer)));
+        }
+        if let Some(integer_text) = integer_text_from_float(float) {
+            if let Ok(JsonValue::Number(number)) = serde_json::from_str::<JsonValue>(&integer_text)
+            {
+                return Ok(JsonValue::Number(number));
+            }
+        }
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            "Cannot convert float to JSON",
+        ));
+    }
+    Number::from_f64(float)
+        .map(JsonValue::Number)
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "Cannot convert float to JSON"))
+}
+fn integer_text_from_float(float: f64) -> Option<String> {
+    const IEEE754_F64_FRAC_BITS_I32: i32 = 52;
+    let bits = float.to_bits();
+    let negative = (bits >> 63) != 0;
+    let exp_bits = i32::try_from((bits >> IEEE754_F64_FRAC_BITS) & 0x7ff).ok()?;
+    let frac_mask = (1_u64 << IEEE754_F64_FRAC_BITS) - 1;
+    let frac = bits & frac_mask;
+    let (mantissa, exponent) = if exp_bits == 0 {
+        (frac, 1 - IEEE754_F64_EXP_BIAS - IEEE754_F64_FRAC_BITS_I32)
+    } else {
+        (
+            (1_u64 << IEEE754_F64_FRAC_BITS) | frac,
+            exp_bits - IEEE754_F64_EXP_BIAS - IEEE754_F64_FRAC_BITS_I32,
+        )
+    };
+    if mantissa == 0 {
+        return Some("0".to_string());
+    }
+    if exponent < 0 {
+        let shift = exponent.unsigned_abs();
+        if shift >= u64::BITS {
+            return Some("0".to_string());
+        }
+        let remainder_mask = (1_u64 << shift) - 1;
+        if mantissa & remainder_mask != 0 {
+            return None;
+        }
+        let integer = mantissa >> shift;
+        let mut output = String::new();
+        if negative {
+            output.push('-');
+        }
+        let _ = write!(&mut output, "{integer}");
+        return Some(output);
+    }
+    let mut chunks = Vec::new();
+    let mut value = mantissa;
+    while value > 0 {
+        chunks.push((value % DECIMAL_BASE_U64) as u32);
+        value /= DECIMAL_BASE_U64;
+    }
+    let exponent_u32 = u32::try_from(exponent).ok()?;
+    for _ in 0..exponent_u32 {
+        let mut carry = 0_u64;
+        for chunk in &mut chunks {
+            let doubled = u64::from(*chunk) * 2 + carry;
+            *chunk = (doubled % DECIMAL_BASE_U64) as u32;
+            carry = doubled / DECIMAL_BASE_U64;
         }
+        if carry != 0 {
+            chunks.push(u32::try_from(carry).ok()?);
+        }
+    }
+    let mut output = String::new();
+    if negative {
+        output.push('-');
     }
+    let most_significant = chunks.pop()?;
+    let _ = write!(&mut output, "{most_significant}");
+    for chunk in chunks.iter().rev() {
+        let _ = write!(&mut output, "{chunk:0DECIMAL_CHUNK_WIDTH$}");
+    }
+    Some(output)
+}
+#[inline]
+fn convert_big_decimal_for_canonical(ruby: &Ruby, value: Value) -> Result<JsonValue, Error> {
+    let is_finite: bool = value.funcall("finite?", ())?;
+    if !is_finite {
+        return Ok(JsonValue::Null);
+    }
+    let fractional_part: Value = value.funcall("frac", ())?;
+    let is_integer: bool = fractional_part.funcall("zero?", ())?;
+    if is_integer {
+        let integer_value: Value = value.funcall("to_i", ())?;
+        return convert_integer(ruby, integer_value);
+    }
+    let decimal_text: String = value.funcall("to_s", ("F",))?;
+    if let Ok(JsonValue::Number(number)) = serde_json::from_str::<JsonValue>(&decimal_text) {
+        return Ok(JsonValue::Number(number));
+    }
+    Err(Error::new(
+        ruby.exception_arg_error(),
+        "Cannot convert BigDecimal to JSON",
+    ))
 }
 /// Convert Ruby BigDecimal to JSON Number while preserving precision.
@@ -216,24 +733,10 @@ fn hash_key_to_string(ruby: &Ruby, key: Value) -> Result<String, Error> {
     match key_type {
         ruby_value_type::RUBY_T_STRING => {
-            if let Some(rstring) = RString::from_value(key) {
-                // SAFETY: rstring is valid
-                #[allow(unsafe_code)]
-                let bytes = unsafe { rstring.as_slice() };
-                return std::str::from_utf8(bytes)
-                    .map(std::borrow::ToOwned::to_owned)
-                    .map_err(|_| {
-                        Error::new(
-                            ruby.exception_encoding_error(),
-                            "Hash key is not valid UTF-8",
-                        )
-                    });
-            }
+            return utf8_string_from_value(ruby, key, "Hash key is not valid UTF-8");
         }
         ruby_value_type::RUBY_T_SYMBOL => {
-            if let Some(sym) = Symbol::from_value(key) {
-                return Ok(sym.name()?.to_string());
-            }
+            return symbol_name_from_value(key);
         }
         _ => {}
     }

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonschema_rs
 version: !ruby/object:Gem::Version
-  version: 0.43.0
+  version: 0.44.0
 platform: ruby
 authors:
 - Dmitry Dygalo