From d01599d86cf808e2929ab5df839356b23e06b6d4 Mon Sep 17 00:00:00 2001 From: "Claude (dbsp-circuit)" Date: Sat, 10 Oct 2026 12:23:46 -0700 Subject: [PATCH] build(nix): regenerate Cargo.nix for zset, numtower and zset-ffi (improvise-bw4p.1) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01VdfEGXA7aJ6ftMsCc9PJze --- Cargo.nix | 839 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 749 insertions(+), 90 deletions(-) diff --git a/Cargo.nix b/Cargo.nix index b78b6f31..17f0f403 100644 --- a/Cargo.nix +++ b/Cargo.nix @@ -149,6 +149,36 @@ rec { packageId = "improvise-ws-server"; }; + # Debug support which might change between releases. + # File a bug if you depend on any for non-debug work! + debug = internal.debugCrate { inherit packageId; }; + }; + "numtower" = rec { + packageId = "numtower"; + build = internal.buildRustCrateWithFeatures { + packageId = "numtower"; + }; + + # Debug support which might change between releases. + # File a bug if you depend on any for non-debug work! + debug = internal.debugCrate { inherit packageId; }; + }; + "zset" = rec { + packageId = "zset"; + build = internal.buildRustCrateWithFeatures { + packageId = "zset"; + }; + + # Debug support which might change between releases. + # File a bug if you depend on any for non-debug work! + debug = internal.debugCrate { inherit packageId; }; + }; + "zset-ffi" = rec { + packageId = "zset-ffi"; + build = internal.buildRustCrateWithFeatures { + packageId = "zset-ffi"; + }; + # Debug support which might change between releases. # File a bug if you depend on any for non-debug work! debug = internal.debugCrate { inherit packageId; }; @@ -403,6 +433,22 @@ rec { }; resolvedDefaultFeatures = [ "std" ]; }; + "arrayvec" = rec { + crateName = "arrayvec"; + version = "0.7.8"; + edition = "2018"; + sha256 = "0mmd8lrijbvg1qp4c5zis5dq41a3mjv2rb6bxkyj9kwaw2k6gyyk"; + authors = [ + "bluss" + ]; + features = { + "borsh" = [ "dep:borsh" ]; + "default" = [ "std" ]; + "serde" = [ "dep:serde" ]; + "zeroize" = [ "dep:zeroize" ]; + }; + resolvedDefaultFeatures = [ "std" ]; + }; "atomic" = rec { crateName = "atomic"; version = "0.6.1"; @@ -603,6 +649,93 @@ rec { "zeroize" = [ "dep:zeroize" ]; }; }; + "borsh" = rec { + crateName = "borsh"; + version = "1.8.1"; + edition = "2018"; + crateBin = []; + sha256 = "02p2lhz49944wc6j5dzr42y1mkrv0znbicg3cl61b9bbda25sg2m"; + authors = [ + "Near Inc " + ]; + dependencies = [ + { + name = "borsh-derive"; + packageId = "borsh-derive"; + optional = true; + } + { + name = "bytes"; + packageId = "bytes"; + optional = true; + usesDefaultFeatures = false; + } + ]; + buildDependencies = [ + { + name = "cfg_aliases"; + packageId = "cfg_aliases"; + } + ]; + features = { + "ascii" = [ "dep:ascii" ]; + "borsh-derive" = [ "dep:borsh-derive" ]; + "bson" = [ "dep:bson" ]; + "bytes" = [ "dep:bytes" ]; + "default" = [ "std" ]; + "derive" = [ "borsh-derive" ]; + "hashbrown" = [ "dep:hashbrown" ]; + "indexmap" = [ "dep:indexmap" ]; + "std" = [ "bytes?/std" ]; + "unstable__schema" = [ "derive" "borsh-derive/schema" ]; + "uuid" = [ "dep:uuid" ]; + }; + resolvedDefaultFeatures = [ "borsh-derive" "derive" "std" "unstable__schema" ]; + }; + "borsh-derive" = rec { + crateName = "borsh-derive"; + version = "1.8.1"; + edition = "2018"; + sha256 = "0mlzrbwzcr7qaky1iap09m0nrzp6crjd79sinj4iz808cxjzxk8j"; + procMacro = true; + libName = "borsh_derive"; + authors = [ + "Near Inc " + ]; + dependencies = [ + { + name = "once_cell"; + packageId = "once_cell"; + } + { + name = "proc-macro-crate"; + packageId = "proc-macro-crate"; + } + { + name = "proc-macro2"; + packageId = "proc-macro2"; + } + { + name = "quote"; + packageId = "quote"; + } + { + name = "syn"; + packageId = "syn 3.0.6"; + features = [ "full" "fold" ]; + } + ]; + devDependencies = [ + { + name = "syn"; + packageId = "syn 3.0.6"; + features = [ "full" "fold" "parsing" ]; + } + ]; + features = { + }; + resolvedDefaultFeatures = [ "default" "schema" ]; + }; "bumpalo" = rec { crateName = "bumpalo"; version = "3.20.3"; @@ -2147,6 +2280,42 @@ rec { }; resolvedDefaultFeatures = [ "more_lengths" ]; }; + "getrandom 0.2.17" = rec { + crateName = "getrandom"; + version = "0.2.17"; + edition = "2018"; + sha256 = "1l2ac6jfj9xhpjjgmcx6s1x89bbnw9x6j9258yy6xjkzpq0bqapz"; + authors = [ + "The Rand Project Developers" + ]; + dependencies = [ + { + name = "cfg-if"; + packageId = "cfg-if"; + } + { + name = "libc"; + packageId = "libc"; + usesDefaultFeatures = false; + target = { target, features }: (target."unix" or false); + } + { + name = "wasi"; + packageId = "wasi"; + usesDefaultFeatures = false; + target = { target, features }: ("wasi" == target."os" or null); + } + ]; + features = { + "compiler_builtins" = [ "dep:compiler_builtins" ]; + "core" = [ "dep:core" ]; + "js" = [ "wasm-bindgen" "js-sys" ]; + "js-sys" = [ "dep:js-sys" ]; + "rustc-dep-of-std" = [ "compiler_builtins" "core" "libc/rustc-dep-of-std" "wasi/rustc-dep-of-std" ]; + "wasm-bindgen" = [ "dep:wasm-bindgen" ]; + }; + resolvedDefaultFeatures = [ "std" ]; + }; "getrandom 0.3.4" = rec { crateName = "getrandom"; version = "0.3.4"; @@ -3412,6 +3581,28 @@ rec { }; resolvedDefaultFeatures = [ "default" "extra_traits" "std" ]; }; + "libloading" = rec { + crateName = "libloading"; + version = "0.8.9"; + edition = "2015"; + sha256 = "0mfwxwjwi2cf0plxcd685yxzavlslz7xirss3b9cbrzyk4hv1i6p"; + authors = [ + "Simonas Kazlauskas " + ]; + dependencies = [ + { + name = "cfg-if"; + packageId = "cfg-if"; + target = { target, features }: (target."unix" or false); + } + { + name = "windows-link"; + packageId = "windows-link"; + target = { target, features }: (target."windows" or false); + } + ]; + + }; "libm" = rec { crateName = "libm"; version = "0.2.16"; @@ -3785,6 +3976,39 @@ rec { }; resolvedDefaultFeatures = [ "alloc" "std" ]; }; + "num-bigint" = rec { + crateName = "num-bigint"; + version = "0.4.8"; + edition = "2021"; + sha256 = "0ry3xjal8f5xhdinani268ci13h14mf7j4w0y1gflfzhw3knk7n8"; + libName = "num_bigint"; + authors = [ + "The Rust Project Developers" + ]; + dependencies = [ + { + name = "num-integer"; + packageId = "num-integer"; + usesDefaultFeatures = false; + features = [ "i128" ]; + } + { + name = "num-traits"; + packageId = "num-traits"; + usesDefaultFeatures = false; + features = [ "i128" ]; + } + ]; + features = { + "arbitrary" = [ "dep:arbitrary" ]; + "default" = [ "std" ]; + "quickcheck" = [ "dep:quickcheck" ]; + "rand" = [ "dep:rand" ]; + "serde" = [ "dep:serde" ]; + "std" = [ "num-integer/std" "num-traits/std" ]; + }; + resolvedDefaultFeatures = [ "std" ]; + }; "num-conv" = rec { crateName = "num-conv"; version = "0.2.2"; @@ -3822,6 +4046,67 @@ rec { ]; }; + "num-integer" = rec { + crateName = "num-integer"; + version = "0.1.47"; + edition = "2018"; + sha256 = "02z1p3azy6p10n99skrab4a6hhfd4amf2i9gm8sxqd1p9dfxkqkw"; + libName = "num_integer"; + authors = [ + "The Rust Project Developers" + ]; + dependencies = [ + { + name = "num-traits"; + packageId = "num-traits"; + usesDefaultFeatures = false; + features = [ "i128" ]; + } + ]; + features = { + "default" = [ "std" ]; + "std" = [ "num-traits/std" ]; + }; + resolvedDefaultFeatures = [ "i128" "std" ]; + }; + "num-rational" = rec { + crateName = "num-rational"; + version = "0.4.2"; + edition = "2021"; + sha256 = "093qndy02817vpgcqjnj139im3jl7vkq4h68kykdqqh577d18ggq"; + libName = "num_rational"; + authors = [ + "The Rust Project Developers" + ]; + dependencies = [ + { + name = "num-bigint"; + packageId = "num-bigint"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "num-integer"; + packageId = "num-integer"; + usesDefaultFeatures = false; + features = [ "i128" ]; + } + { + name = "num-traits"; + packageId = "num-traits"; + usesDefaultFeatures = false; + features = [ "i128" ]; + } + ]; + features = { + "default" = [ "num-bigint" "std" ]; + "num-bigint" = [ "dep:num-bigint" ]; + "num-bigint-std" = [ "num-bigint/std" ]; + "serde" = [ "dep:serde" ]; + "std" = [ "num-bigint?/std" "num-integer/std" "num-traits/std" ]; + }; + resolvedDefaultFeatures = [ "default" "num-bigint" "num-bigint-std" "std" ]; + }; "num-traits" = rec { crateName = "num-traits"; version = "0.2.19"; @@ -3841,7 +4126,7 @@ rec { "default" = [ "std" ]; "libm" = [ "dep:libm" ]; }; - resolvedDefaultFeatures = [ "default" "std" ]; + resolvedDefaultFeatures = [ "default" "i128" "std" ]; }; "num_threads" = rec { crateName = "num_threads"; @@ -3859,6 +4144,54 @@ rec { } ]; + }; + "numtower" = rec { + crateName = "numtower"; + version = "0.1.0"; + edition = "2024"; + src = lib.cleanSourceWith { filter = sourceFilter; src = ./crates/numtower; }; + dependencies = [ + { + name = "num-bigint"; + packageId = "num-bigint"; + usesDefaultFeatures = false; + features = [ "std" ]; + } + { + name = "num-integer"; + packageId = "num-integer"; + usesDefaultFeatures = false; + } + { + name = "num-rational"; + packageId = "num-rational"; + usesDefaultFeatures = false; + } + { + name = "num-traits"; + packageId = "num-traits"; + usesDefaultFeatures = false; + features = [ "std" ]; + } + { + name = "rust_decimal"; + packageId = "rust_decimal"; + usesDefaultFeatures = false; + features = [ "std" ]; + } + ]; + devDependencies = [ + { + name = "num-rational"; + packageId = "num-rational"; + features = [ "num-bigint-std" ]; + } + { + name = "proptest"; + packageId = "proptest"; + } + ]; + }; "once_cell" = rec { crateName = "once_cell"; @@ -4406,6 +4739,25 @@ rec { }; resolvedDefaultFeatures = [ "simd" "std" ]; }; + "proc-macro-crate" = rec { + crateName = "proc-macro-crate"; + version = "3.5.0"; + edition = "2021"; + sha256 = "0kv1g1d1zjwxlgcaba2qlshzyy32j03xic8rskqlcr5mnblsfyz6"; + libName = "proc_macro_crate"; + authors = [ + "Bastian Köcher " + ]; + dependencies = [ + { + name = "toml_edit"; + packageId = "toml_edit"; + usesDefaultFeatures = false; + features = [ "parse" ]; + } + ]; + + }; "proc-macro2" = rec { crateName = "proc-macro2"; version = "1.0.107"; @@ -4463,7 +4815,7 @@ rec { } { name = "rand_chacha"; - packageId = "rand_chacha"; + packageId = "rand_chacha 0.9.0"; usesDefaultFeatures = false; } { @@ -4616,6 +4968,19 @@ rec { "The Rust Project Developers" ]; dependencies = [ + { + name = "libc"; + packageId = "libc"; + optional = true; + usesDefaultFeatures = false; + target = { target, features }: (target."unix" or false); + } + { + name = "rand_chacha"; + packageId = "rand_chacha 0.3.1"; + optional = true; + usesDefaultFeatures = false; + } { name = "rand_core"; packageId = "rand_core 0.6.4"; @@ -4632,7 +4997,7 @@ rec { "std" = [ "rand_core/std" "rand_chacha/std" "alloc" "getrandom" "libc" ]; "std_rng" = [ "rand_chacha" ]; }; - resolvedDefaultFeatures = [ "small_rng" ]; + resolvedDefaultFeatures = [ "alloc" "getrandom" "libc" "rand_chacha" "small_rng" "std" ]; }; "rand 0.9.5" = rec { crateName = "rand"; @@ -4646,7 +5011,7 @@ rec { dependencies = [ { name = "rand_chacha"; - packageId = "rand_chacha"; + packageId = "rand_chacha 0.9.0"; optional = true; usesDefaultFeatures = false; } @@ -4666,7 +5031,37 @@ rec { }; resolvedDefaultFeatures = [ "alloc" "os_rng" "std" ]; }; - "rand_chacha" = rec { + "rand_chacha 0.3.1" = rec { + crateName = "rand_chacha"; + version = "0.3.1"; + edition = "2018"; + sha256 = "123x2adin558xbhvqb8w4f6syjsdkmqff8cxwhmjacpsl1ihmhg6"; + authors = [ + "The Rand Project Developers" + "The Rust Project Developers" + "The CryptoCorrosion Contributors" + ]; + dependencies = [ + { + name = "ppv-lite86"; + packageId = "ppv-lite86"; + usesDefaultFeatures = false; + features = [ "simd" ]; + } + { + name = "rand_core"; + packageId = "rand_core 0.6.4"; + } + ]; + features = { + "default" = [ "std" ]; + "serde" = [ "dep:serde" ]; + "serde1" = [ "serde" ]; + "std" = [ "ppv-lite86/std" ]; + }; + resolvedDefaultFeatures = [ "std" ]; + }; + "rand_chacha 0.9.0" = rec { crateName = "rand_chacha"; version = "0.9.0"; edition = "2021"; @@ -4722,12 +5117,20 @@ rec { "The Rand Project Developers" "The Rust Project Developers" ]; + dependencies = [ + { + name = "getrandom"; + packageId = "getrandom 0.2.17"; + optional = true; + } + ]; features = { "getrandom" = [ "dep:getrandom" ]; "serde" = [ "dep:serde" ]; "serde1" = [ "serde" ]; "std" = [ "alloc" "getrandom" "getrandom/std" ]; }; + resolvedDefaultFeatures = [ "alloc" "getrandom" "std" ]; }; "rand_core 0.9.5" = rec { crateName = "rand_core"; @@ -5311,6 +5714,147 @@ rec { }; resolvedDefaultFeatures = [ "default" "std" "unicode" "unicode-age" "unicode-bool" "unicode-case" "unicode-gencat" "unicode-perl" "unicode-script" "unicode-segment" ]; }; + "rust_decimal" = rec { + crateName = "rust_decimal"; + version = "1.43.0"; + edition = "2021"; + sha256 = "0fnd56zidby90qy98ffkmx7rjcvng7ssdglz37f43b6wflp2flvn"; + authors = [ + "Paul Mason " + ]; + dependencies = [ + { + name = "arrayvec"; + packageId = "arrayvec"; + usesDefaultFeatures = false; + } + { + name = "borsh"; + packageId = "borsh"; + optional = true; + usesDefaultFeatures = false; + features = [ "derive" "unstable__schema" ]; + } + { + name = "bytes"; + packageId = "bytes"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "num-traits"; + packageId = "num-traits"; + usesDefaultFeatures = false; + features = [ "i128" ]; + } + { + name = "rand"; + packageId = "rand 0.8.8"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "rand"; + packageId = "rand 0.9.5"; + rename = "rand-0_9"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "serde"; + packageId = "serde"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "serde_json"; + packageId = "serde_json"; + optional = true; + usesDefaultFeatures = false; + } + { + name = "wasm-bindgen"; + packageId = "wasm-bindgen"; + optional = true; + usesDefaultFeatures = false; + target = { target, features }: ("wasm32" == target."arch" or null); + } + ]; + devDependencies = [ + { + name = "bytes"; + packageId = "bytes"; + usesDefaultFeatures = false; + target = { target, features }: (!("wasm32" == target."arch" or null)); + } + { + name = "rand"; + packageId = "rand 0.8.8"; + usesDefaultFeatures = false; + target = { target, features }: (!("wasm32" == target."arch" or null)); + features = [ "getrandom" ]; + } + { + name = "rand"; + packageId = "rand 0.9.5"; + rename = "rand-0_9"; + usesDefaultFeatures = false; + target = { target, features }: (!("wasm32" == target."arch" or null)); + features = [ "thread_rng" ]; + } + { + name = "serde"; + packageId = "serde"; + usesDefaultFeatures = false; + features = [ "derive" ]; + } + { + name = "serde_json"; + packageId = "serde_json"; + } + { + name = "wasm-bindgen"; + packageId = "wasm-bindgen"; + usesDefaultFeatures = false; + target = { target, features }: ("wasm32" == target."arch" or null); + } + ]; + features = { + "borsh" = [ "dep:borsh" "std" ]; + "bytemuck" = [ "c-repr" "dep:bytemuck" "dep:bytemuck_derive" ]; + "db-diesel-mysql" = [ "diesel/mysql_backend" "std" ]; + "db-diesel-postgres" = [ "diesel/postgres_backend" "std" ]; + "db-diesel2-mysql" = [ "db-diesel-mysql" ]; + "db-diesel2-postgres" = [ "db-diesel-postgres" ]; + "db-postgres" = [ "dep:bytes" "dep:postgres-types" "std" ]; + "db-tokio-postgres" = [ "dep:bytes" "dep:postgres-types" "std" ]; + "default" = [ "serde" "std" ]; + "diesel" = [ "dep:diesel" ]; + "macros" = [ "dep:rust_decimal_macros" ]; + "maths-nopanic" = [ "maths" ]; + "ndarray" = [ "dep:ndarray" ]; + "proptest" = [ "dep:proptest" ]; + "rand" = [ "dep:rand" ]; + "rand-0_9" = [ "dep:rand-0_9" ]; + "rocket-traits" = [ "dep:rocket" "std" ]; + "rust-fuzz" = [ "dep:arbitrary" ]; + "serde" = [ "dep:serde" "wasm-bindgen?/serde" ]; + "serde-arbitrary-precision" = [ "serde-with-arbitrary-precision" ]; + "serde-bincode" = [ "serde-str" ]; + "serde-float" = [ "serde-with-float" ]; + "serde-str" = [ "serde-with-str" ]; + "serde-with-arbitrary-precision" = [ "serde" "serde_json/arbitrary_precision" "serde_json/std" "zmij" ]; + "serde-with-float" = [ "serde" ]; + "serde-with-str" = [ "serde" ]; + "serde_json" = [ "dep:serde_json" ]; + "std" = [ "arrayvec/std" "wasm-bindgen?/std" "borsh?/std" "bytes?/std" "rand?/std" "rand-0_9?/std" "serde?/std" "serde_json?/std" ]; + "tokio-pg" = [ "db-tokio-postgres" ]; + "tokio-postgres" = [ "dep:tokio-postgres" ]; + "wasm" = [ "dep:wasm-bindgen" ]; + "zmij" = [ "dep:zmij" ]; + }; + resolvedDefaultFeatures = [ "std" ]; + }; "rustc_version" = rec { crateName = "rustc_version"; version = "0.4.1"; @@ -6110,7 +6654,7 @@ rec { "proc-macro" = [ "proc-macro2/proc-macro" "quote?/proc-macro" ]; "test" = [ "syn-test-suite/all-features" ]; }; - resolvedDefaultFeatures = [ "clone-impls" "default" "derive" "extra-traits" "full" "parsing" "printing" "proc-macro" "visit" "visit-mut" ]; + resolvedDefaultFeatures = [ "clone-impls" "default" "derive" "extra-traits" "fold" "full" "parsing" "printing" "proc-macro" "visit" "visit-mut" ]; }; "tempfile" = rec { crateName = "tempfile"; @@ -6785,6 +7329,82 @@ rec { }; resolvedDefaultFeatures = [ "connect" "default" "handshake" "stream" ]; }; + "toml_datetime" = rec { + crateName = "toml_datetime"; + version = "1.1.2+spec-1.1.0"; + edition = "2024"; + sha256 = "0lrhcmqvhjr259w4f2kijya7fgi0kpmhg9fb3m144v3cj1kxg1ib"; + dependencies = [ + { + name = "serde_core"; + packageId = "serde_core"; + optional = true; + usesDefaultFeatures = false; + } + ]; + features = { + "alloc" = [ "serde_core?/alloc" ]; + "default" = [ "std" ]; + "serde" = [ "dep:serde_core" ]; + "std" = [ "alloc" "serde_core?/std" ]; + }; + resolvedDefaultFeatures = [ "alloc" "default" "std" ]; + }; + "toml_edit" = rec { + crateName = "toml_edit"; + version = "0.25.17+spec-1.1.0"; + edition = "2024"; + sha256 = "174w1b2fjg1jb0wi7384v1m59g7ga79458i022gafjakpddisr73"; + dependencies = [ + { + name = "indexmap"; + packageId = "indexmap"; + features = [ "std" ]; + } + { + name = "toml_datetime"; + packageId = "toml_datetime"; + } + { + name = "toml_parser"; + packageId = "toml_parser"; + optional = true; + } + { + name = "winnow"; + packageId = "winnow"; + optional = true; + } + ]; + features = { + "debug" = [ "toml_parser?/debug" "dep:anstream" "dep:anstyle" "display" ]; + "default" = [ "parse" "display" ]; + "display" = [ "dep:toml_writer" ]; + "parse" = [ "dep:toml_parser" "dep:winnow" ]; + "serde" = [ "dep:serde_core" "toml_datetime/serde" "dep:serde_spanned" ]; + }; + resolvedDefaultFeatures = [ "parse" ]; + }; + "toml_parser" = rec { + crateName = "toml_parser"; + version = "1.1.5+spec-1.1.0"; + edition = "2024"; + sha256 = "0k3lljyi4zxchdklaqghkwbl7wkd2ab1w16hlyniqzid0fl979ms"; + dependencies = [ + { + name = "winnow"; + packageId = "winnow"; + usesDefaultFeatures = false; + } + ]; + features = { + "debug" = [ "std" "dep:anstream" "dep:anstyle" ]; + "default" = [ "std" ]; + "simd" = [ "winnow/simd" ]; + "std" = [ "alloc" ]; + }; + resolvedDefaultFeatures = [ "alloc" "default" "std" ]; + }; "tungstenite" = rec { crateName = "tungstenite"; version = "0.30.0"; @@ -8447,6 +9067,31 @@ rec { }; resolvedDefaultFeatures = [ "Wdk" "Wdk_Foundation" "Wdk_Storage" "Wdk_Storage_FileSystem" "Wdk_System" "Wdk_System_IO" "Win32" "Win32_Foundation" "Win32_Networking" "Win32_Networking_WinSock" "Win32_Security" "Win32_Storage" "Win32_Storage_FileSystem" "Win32_System" "Win32_System_Console" "Win32_System_Diagnostics" "Win32_System_Diagnostics_Debug" "Win32_System_IO" "Win32_System_Pipes" "Win32_System_SystemServices" "Win32_System_Threading" "Win32_System_WindowsProgramming" "default" ]; }; + "winnow" = rec { + crateName = "winnow"; + version = "1.0.4"; + edition = "2021"; + sha256 = "10fzxipa7lx16172p3aca9j60hzbqgjki2f95kqksd5qywcp7f93"; + dependencies = [ + { + name = "memchr"; + packageId = "memchr"; + optional = true; + usesDefaultFeatures = false; + } + ]; + features = { + "ascii" = [ "parser" ]; + "binary" = [ "parser" ]; + "debug" = [ "std" "dep:anstream" "dep:anstyle" "dep:is_terminal_polyfill" "dep:terminal_size" ]; + "default" = [ "std" "ascii" "binary" ]; + "simd" = [ "dep:memchr" ]; + "std" = [ "alloc" "memchr?/std" ]; + "unstable-doc" = [ "alloc" "std" "ascii" "binary" "simd" "unstable-recover" ]; + "unstable-recover" = [ "parser" ]; + }; + resolvedDefaultFeatures = [ "alloc" "ascii" "binary" "default" "parser" "std" ]; + }; "wit-bindgen" = rec { crateName = "wit-bindgen"; version = "0.57.1"; @@ -8559,6 +9204,39 @@ rec { "no-panic" = [ "dep:no-panic" ]; }; }; + "zset" = rec { + crateName = "zset"; + version = "0.1.0"; + edition = "2024"; + src = lib.cleanSourceWith { filter = sourceFilter; src = ./crates/zset; }; + devDependencies = [ + { + name = "proptest"; + packageId = "proptest"; + } + ]; + + }; + "zset-ffi" = rec { + crateName = "zset-ffi"; + version = "0.1.0"; + edition = "2024"; + src = lib.cleanSourceWith { filter = sourceFilter; src = ./crates/zset-ffi; }; + libName = "zset_ffi";type = [ "cdylib" "staticlib" "rlib" ]; + dependencies = [ + { + name = "zset"; + packageId = "zset"; + } + ]; + devDependencies = [ + { + name = "libloading"; + packageId = "libloading"; + } + ]; + + }; }; # @@ -8887,15 +9565,7 @@ rec { ) crateConfigs; target = makeTarget pkgs.stdenv.hostPlatform; - # Build-time dependency graph (for proc-macros and build - # dependencies). When not cross-compiling it equals the host - # graph, so reuse `self`; otherwise build it for - # `pkgs.buildPackages`. - build = - if pkgs.stdenv.buildPlatform.config == pkgs.stdenv.hostPlatform.config then - self - else - mkBuiltByPackageIdByPkgs pkgs.buildPackages; + build = mkBuiltByPackageIdByPkgs pkgs.buildPackages; }; in self; @@ -8911,35 +9581,38 @@ rec { devDependencies = lib.optionals (runTests && packageId == rootPackageId) ( crateConfig'.devDependencies or [ ] ); - # Enabled (platform- and feature-filtered) dependency lists, reused - # for both derivation wiring and the crate renames below. - enabledDependencies = filterEnabledDependencies { + dependencies = dependencyDerivations { inherit features; inherit (self) target; + buildByPackageId = + depPackageId: + # proc_macro crates must be compiled for the build architecture + if crateConfigs.${depPackageId}.procMacro or false then + self.build.crates.${depPackageId} + else + self.crates.${depPackageId}; dependencies = (crateConfig.dependencies or [ ]) ++ devDependencies; }; - enabledBuildDependencies = filterEnabledDependencies { + buildDependencies = dependencyDerivations { inherit features; inherit (self.build) target; + buildByPackageId = depPackageId: self.build.crates.${depPackageId}; dependencies = crateConfig.buildDependencies or [ ]; }; - dependencies = map - ( - dependency: - # proc_macro crates must be compiled for the build architecture - if crateConfigs.${dependency.packageId}.procMacro or false then - self.build.crates.${dependency.packageId} - else - self.crates.${dependency.packageId} - ) - enabledDependencies; - buildDependencies = map - (dependency: self.build.crates.${dependency.packageId}) - enabledBuildDependencies; - # Order (build dependencies, then normal dependencies) feeds the - # crateRenames grouping below. dependenciesWithRenames = - lib.filter (d: d ? "rename") (enabledBuildDependencies ++ enabledDependencies); + let + buildDeps = filterEnabledDependencies { + inherit features; + inherit (self) target; + dependencies = crateConfig.dependencies or [ ] ++ devDependencies; + }; + hostDeps = filterEnabledDependencies { + inherit features; + inherit (self.build) target; + dependencies = crateConfig.buildDependencies or [ ]; + }; + in + lib.filter (d: d ? "rename") (hostDeps ++ buildDeps); # Crate renames have the form: # # { @@ -9111,17 +9784,6 @@ rec { corresponding feature sets are merged. Features in rust are additive. */ mergePackageFeatures = - args: builtins.mapAttrs (_packageId: builtins.attrNames) (mergePackageFeaturesImpl args); - - /* - Core of the feature-resolution fixpoint. The cache (`featuresByPackageId`) - maps each packageId to a feature *set* (an attrset `feature -> 1`) rather - than a sorted list, so the fold merges with `//` and detects convergence - with attrset equality instead of re-concatenating and re-sorting the - accumulated feature list on every step. `mergePackageFeatures` projects the - result back to canonical sorted lists. - */ - mergePackageFeaturesImpl = { crateConfigs ? crates , packageId , rootPackageId ? packageId @@ -9170,15 +9832,14 @@ rec { cache: { packageId, features }: let - cacheFeatures = cache.${packageId} or { }; - # `features` is the (small) incoming list; merge it into the set. - combinedFeatures = cacheFeatures // listToSet features; + cacheFeatures = cache.${packageId} or [ ]; + combinedFeatures = sortedUnique (cacheFeatures ++ features); in - if cache ? ${packageId} && cacheFeatures == combinedFeatures then + if cache ? ${packageId} && cache.${packageId} == combinedFeatures then cache else - mergePackageFeaturesImpl { - features = builtins.attrNames combinedFeatures; + mergePackageFeatures { + features = combinedFeatures; featuresByPackageId = cache; inherit crateConfigs @@ -9191,8 +9852,8 @@ rec { ); cacheWithSelf = let - cacheFeatures = featuresByPackageId.${packageId} or { }; - combinedFeatures = cacheFeatures // listToSet enabledFeatures; + cacheFeatures = featuresByPackageId.${packageId} or [ ]; + combinedFeatures = sortedUnique (cacheFeatures ++ enabledFeatures); in featuresByPackageId // { @@ -9219,31 +9880,27 @@ rec { assert (builtins.isList features); assert (builtins.isAttrs target); - let - # Identical for every dep in this call; build the predicate arg once. - targetArgs = { inherit features target; }; - in lib.filter ( dep: - (dep.target or (features: true)) targetArgs + let + targetFunc = dep.target or (features: true); + in + targetFunc { inherit features target; } && (!(dep.optional or false) || builtins.any (doesFeatureEnableDependency dep) features) ) dependencies; # Returns whether the given feature should enable the given dependency. doesFeatureEnableDependency = - dependency: - # Callers partially apply this once per dependency, then test every feature, - # so hoist the dep-invariant strings out of the per-feature comparison. + dependency: feature: let name = dependency.rename or dependency.name; - depName = "dep:" + name; prefix = "${name}/"; len = builtins.stringLength prefix; + startsWithPrefix = builtins.substring 0 len feature == prefix; in - feature: - feature == name || feature == depName || builtins.substring 0 len feature == prefix; + feature == name || feature == "dep:" + name || startsWithPrefix; /* Returns the expanded features for the given inputFeatures by applying the @@ -9257,24 +9914,29 @@ rec { assert (builtins.isAttrs featureMap); assert (builtins.isList inputFeatures); let - # Transitive closure of `inputFeatures` under `featureMap`. `seen` - # tracks already-expanded features so each is visited at most once; - # this also breaks feature cycles (issue #209). expandFeaturesNoCycle = - seen: features: - builtins.foldl' - ( - acc: feature: - if acc ? ${feature} then - acc - else - expandFeaturesNoCycle (acc // { ${feature} = 1; }) (featureMap.${feature} or [ ]) - ) - seen - features; - seen = expandFeaturesNoCycle { } inputFeatures; + oldSeen: inputFeatures: + if inputFeatures != [ ] then + let + # The feature we're currently expanding. + feature = builtins.head inputFeatures; + # All the features we've seen/expanded so far, including the one + # we're currently processing. + seen = oldSeen // { + ${feature} = 1; + }; + # Expand the feature but be careful to not re-introduce a feature + # that we've already seen: this can easily cause a cycle, see issue + # #209. + enables = builtins.filter (f: !(seen ? "${f}")) (featureMap."${feature}" or [ ]); + in + [ feature ] ++ (expandFeaturesNoCycle seen (builtins.tail inputFeatures ++ enables)) + # No more features left, nothing to expand to. + else + [ ]; + outFeatures = expandFeaturesNoCycle { } inputFeatures; in - sortedUnique (builtins.attrNames seen); + sortedUnique outFeatures; /* This function adds optional dependencies as features if they are enabled @@ -9333,19 +9995,16 @@ rec { in defaultOrNil ++ explicitFeatures ++ additionalDependencyFeatures; - # Builds a feature set (attrset `feature -> 1`) from a list of feature names. - listToSet = - features: - builtins.listToAttrs (map (feature: { name = feature; value = 1; }) features); - # Sorts and removes duplicates from a list of strings. sortedUnique = features: assert (builtins.isList features); - # attrNames returns keys in ascending string order, so the result is - # sorted and deduplicated. The feature-merge fixpoint relies on this - # canonical order to detect convergence. - builtins.attrNames (listToSet features); + assert (builtins.all builtins.isString features); + let + outFeaturesSet = lib.foldl (set: feature: set // { "${feature}" = 1; }) { } features; + outFeaturesUnique = builtins.attrNames outFeaturesSet; + in + builtins.sort (a: b: a < b) outFeaturesUnique; deprecationWarning = message: value: