Upload model files

.gitattributes

@@ -386,3 +386,18 @@ target/release/deps/libzmij-53e8da00082a7bf8.rlib filter=lfs diff=lfs merge=lfs
 target/release/deps/toto_rs-224c98ba8d931f9e filter=lfs diff=lfs merge=lfs -text
 target/release/deps/toto_rs-b2be7fc1c6abc0d1 filter=lfs diff=lfs merge=lfs -text
 target/release/toto-rs filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-1b-f16.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-1b-f32.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-1b-q8.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-2.5b-f16.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-2.5b-f32.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-2.5b-q8.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-22m-f16.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-22m-f32.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-22m-q8.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-313m-f16.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-313m-f32.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-313m-q8.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-4m-f16.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-4m-f32.gguf filter=lfs diff=lfs merge=lfs -text
+toto-rs/gguf/toto-4m-q8.gguf filter=lfs diff=lfs merge=lfs -text

.python-version

@@ -0,0 +1 @@
+3.12

pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "toto-v2-env"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = ["toto-ts>=0.2.0"]
+
+[tool.uv]
+package = false

toto-rs/.gitignore

@@ -0,0 +1,6 @@
+/target
+/models
+/gguf
+/.venv
+/toto
+*.gguf

toto-rs/Cargo.lock

@@ -0,0 +1,2860 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "accelerate-src"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "415ed64958754dbe991900f3940677e6a7eefb4d7367afd70d642677b0c7d19d"
+
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+dependencies = [
+ "bytemuck_derive",
+]
+
+[[package]]
+name = "bytemuck_derive"
+version = "1.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "candle-core"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ccf5ee3532e66868516d9b315f73aec9f34ea1a37ae98514534d458915dbf1"
+dependencies = [
+ "accelerate-src",
+ "byteorder",
+ "gemm 0.17.1",
+ "half",
+ "libc",
+ "memmap2",
+ "num-traits",
+ "num_cpus",
+ "rand",
+ "rand_distr",
+ "rayon",
+ "safetensors",
+ "thiserror",
+ "ug",
+ "yoke 0.7.5",
+ "zip",
+]
+
+[[package]]
+name = "candle-nn"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be1160c3b63f47d40d91110a3e1e1e566ae38edddbbf492a60b40ffc3bc1ff38"
+dependencies = [
+ "accelerate-src",
+ "candle-core",
+ "half",
+ "num-traits",
+ "rayon",
+ "safetensors",
+ "serde",
+ "thiserror",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.62"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "clap"
+version = "4.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "unicode-width",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dyn-stack"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e53799688f5632f364f8fb387488dd05db9fe45db7011be066fc20e7027f8b"
+dependencies = [
+ "bytemuck",
+ "reborrow",
+]
+
+[[package]]
+name = "dyn-stack"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c4713e43e2886ba72b8271aa66c93d722116acf7a75555cce11dcde84388fe8"
+dependencies = [
+ "bytemuck",
+ "dyn-stack-macros",
+]
+
+[[package]]
+name = "dyn-stack-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9"
+
+[[package]]
+name = "either"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "gemm"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ab24cc62135b40090e31a76a9b2766a501979f3070fa27f689c27ec04377d32"
+dependencies = [
+ "dyn-stack 0.10.0",
+ "gemm-c32 0.17.1",
+ "gemm-c64 0.17.1",
+ "gemm-common 0.17.1",
+ "gemm-f16 0.17.1",
+ "gemm-f32 0.17.1",
+ "gemm-f64 0.17.1",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 10.7.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab96b703d31950f1aeddded248bc95543c9efc7ac9c4a21fda8703a83ee35451"
+dependencies = [
+ "dyn-stack 0.13.2",
+ "gemm-c32 0.18.2",
+ "gemm-c64 0.18.2",
+ "gemm-common 0.18.2",
+ "gemm-f16 0.18.2",
+ "gemm-f32 0.18.2",
+ "gemm-f64 0.18.2",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 11.6.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-c32"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9c030d0b983d1e34a546b86e08f600c11696fde16199f971cd46c12e67512c0"
+dependencies = [
+ "dyn-stack 0.10.0",
+ "gemm-common 0.17.1",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 10.7.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-c32"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6db9fd9f40421d00eea9dd0770045a5603b8d684654816637732463f4073847"
+dependencies = [
+ "dyn-stack 0.13.2",
+ "gemm-common 0.18.2",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 11.6.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-c64"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbb5f2e79fefb9693d18e1066a557b4546cd334b226beadc68b11a8f9431852a"
+dependencies = [
+ "dyn-stack 0.10.0",
+ "gemm-common 0.17.1",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 10.7.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-c64"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfcad8a3d35a43758330b635d02edad980c1e143dc2f21e6fd25f9e4eada8edf"
+dependencies = [
+ "dyn-stack 0.13.2",
+ "gemm-common 0.18.2",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 11.6.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-common"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2e7ea062c987abcd8db95db917b4ffb4ecdfd0668471d8dc54734fdff2354e8"
+dependencies = [
+ "bytemuck",
+ "dyn-stack 0.10.0",
+ "half",
+ "num-complex",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "pulp 0.18.22",
+ "raw-cpuid 10.7.0",
+ "rayon",
+ "seq-macro",
+ "sysctl 0.5.5",
+]
+
+[[package]]
+name = "gemm-common"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a352d4a69cbe938b9e2a9cb7a3a63b7e72f9349174a2752a558a8a563510d0f3"
+dependencies = [
+ "bytemuck",
+ "dyn-stack 0.13.2",
+ "half",
+ "libm",
+ "num-complex",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "pulp 0.21.5",
+ "raw-cpuid 11.6.0",
+ "rayon",
+ "seq-macro",
+ "sysctl 0.6.0",
+]
+
+[[package]]
+name = "gemm-f16"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca4c06b9b11952071d317604acb332e924e817bd891bec8dfb494168c7cedd4"
+dependencies = [
+ "dyn-stack 0.10.0",
+ "gemm-common 0.17.1",
+ "gemm-f32 0.17.1",
+ "half",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 10.7.0",
+ "rayon",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-f16"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff95ae3259432f3c3410eaa919033cd03791d81cebd18018393dc147952e109"
+dependencies = [
+ "dyn-stack 0.13.2",
+ "gemm-common 0.18.2",
+ "gemm-f32 0.18.2",
+ "half",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 11.6.0",
+ "rayon",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-f32"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9a69f51aaefbd9cf12d18faf273d3e982d9d711f60775645ed5c8047b4ae113"
+dependencies = [
+ "dyn-stack 0.10.0",
+ "gemm-common 0.17.1",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 10.7.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-f32"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc8d3d4385393304f407392f754cd2dc4b315d05063f62cf09f47b58de276864"
+dependencies = [
+ "dyn-stack 0.13.2",
+ "gemm-common 0.18.2",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 11.6.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-f64"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa397a48544fadf0b81ec8741e5c0fba0043008113f71f2034def1935645d2b0"
+dependencies = [
+ "dyn-stack 0.10.0",
+ "gemm-common 0.17.1",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 10.7.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-f64"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35b2a4f76ce4b8b16eadc11ccf2e083252d8237c1b589558a49b0183545015bd"
+dependencies = [
+ "dyn-stack 0.13.2",
+ "gemm-common 0.18.2",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid 11.6.0",
+ "seq-macro",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "h2"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "bytemuck",
+ "cfg-if",
+ "crunchy",
+ "num-traits",
+ "rand",
+ "rand_distr",
+ "zerocopy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hyper"
+version = "0.14.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2 0.5.10",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+dependencies = [
+ "bytes",
+ "hyper",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke 0.8.2",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke 0.8.2",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "indicatif"
+version = "0.17.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
+dependencies = [
+ "console",
+ "number_prefix",
+ "portable-atomic",
+ "unicode-width",
+ "web-time",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "js-sys"
+version = "0.3.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "142bc4740e452c1e57ade0cbc129f139c9093e354346f0872ef985f4f5cf5f11"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memmap2"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
+dependencies = [
+ "libc",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "num"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "bytemuck",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "number_prefix"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "openssl"
+version = "0.10.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a45fa2aa886c42762255da344f0a0d313e254066c46aad76f300c3d3da62d967"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.116"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pulp"
+version = "0.18.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0a01a0dc67cf4558d279f0c25b0962bd08fc6dec0137699eae304103e882fe6"
+dependencies = [
+ "bytemuck",
+ "libm",
+ "num-complex",
+ "reborrow",
+]
+
+[[package]]
+name = "pulp"
+version = "0.21.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b86df24f0a7ddd5e4b95c94fc9ed8a98f1ca94d3b01bdce2824097e7835907"
+dependencies = [
+ "bytemuck",
+ "cfg-if",
+ "libm",
+ "num-complex",
+ "reborrow",
+ "version_check",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rand_distr"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
+dependencies = [
+ "num-traits",
+ "rand",
+]
+
+[[package]]
+name = "raw-cpuid"
+version = "10.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c297679cb867470fa8c9f67dbba74a78d78e3e98d7cf2b08d6d71540f797332"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "raw-cpuid"
+version = "11.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "reborrow"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03251193000f4bd3b042892be858ee50e8b3719f2b08e5833ac4353724632430"
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.11.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
+dependencies = [
+ "base64 0.21.7",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "hyper",
+ "hyper-tls",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pemfile",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "system-configuration",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-util",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "winreg",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "safetensors"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44560c11236a6130a46ce36c836a62936dc81ebf8c36a37947423571be0e55b6"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
+[[package]]
+name = "seq-macro"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.150"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sysctl"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec7dddc5f0fee506baf8b9fdb989e242f17e4b11c61dfbb0635b705217199eea"
+dependencies = [
+ "bitflags 2.11.1",
+ "byteorder",
+ "enum-as-inner",
+ "libc",
+ "thiserror",
+ "walkdir",
+]
+
+[[package]]
+name = "sysctl"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc"
+dependencies = [
+ "bitflags 2.11.1",
+ "byteorder",
+ "enum-as-inner",
+ "libc",
+ "thiserror",
+ "walkdir",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.52.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2 0.6.3",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.25.11+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toto-rs"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "base64 0.22.1",
+ "byteorder",
+ "candle-core",
+ "candle-nn",
+ "clap",
+ "futures-util",
+ "indicatif",
+ "reqwest",
+ "safetensors",
+ "serde",
+ "serde_json",
+ "sha2",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "ug"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03719c61a91b51541f076dfdba45caacf750b230cefaa4b32d6f5411c3f7f437"
+dependencies = [
+ "gemm 0.18.2",
+ "half",
+ "libloading",
+ "memmap2",
+ "num",
+ "num-traits",
+ "num_cpus",
+ "rayon",
+ "safetensors",
+ "serde",
+ "thiserror",
+ "tracing",
+ "yoke 0.7.5",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.3+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+dependencies = [
+ "wit-bindgen 0.57.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed04576f974d2b2fba0f38c51dbc5518011e38c36bf1143164be765528fd409"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9473dbd2991ae90b6291c3c32c30c6187ac49aa32f9905d1cce280ec1e110b0f"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "916151b09da36bd82f6615cbf3a419e2f0ba23a03c6160e8e92eb6bd4aa1dec6"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "299047362ccbfce148b67ab7e73349f77748e00c8296f9542adfad2ad82c5c5e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a929b2c61f11ba3e9bc35b50c1f25cb38e0e892c0c231ae2b8cf78d5dad4437"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.1",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d621441cfc37b84979402712047321980c178f299193a3589d05b99e8763436"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winnow"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.1",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
+[[package]]
+name = "yoke"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive 0.7.5",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive 0.8.2",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
+dependencies = [
+ "displaydoc",
+ "yoke 0.8.2",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
+dependencies = [
+ "yoke 0.8.2",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zip"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cc23c04387f4da0374be4533ad1208cbb091d5c11d070dfef13676ad6497164"
+dependencies = [
+ "arbitrary",
+ "crc32fast",
+ "crossbeam-utils",
+ "displaydoc",
+ "indexmap",
+ "num_enum",
+ "thiserror",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

toto-rs/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "toto-rs"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "toto-rs"
+path = "src/main.rs"
+
+[dependencies]
+reqwest = { version = "0.11", features = ["stream", "json"] }
+futures-util = "0.3"
+tokio = { version = "1", features = ["full"] }
+safetensors = "0.4"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+clap = { version = "4", features = ["derive", "env"] }
+anyhow = "1"
+byteorder = "1"
+indicatif = "0.17"
+sha2 = "0.10"
+base64 = "0.22"
+tokio-util = { version = "0.7", features = ["io"] }
+candle-core = { version = "0.8", features = ["accelerate"] }
+candle-nn   = { version = "0.8", features = ["accelerate"] }

toto-rs/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Andrew Mayes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

toto-rs/README.md

@@ -0,0 +1,86 @@
+# toto-rs
+
+Pure-Rust CLI to download, convert, and run [Datadog Toto-2.0](https://huggingface.co/collections/Datadog/toto-20-6768ce5e1b4c1d0e7c5b9fed) time-series forecasting models. No Python runtime needed for inference.
+
+## What it does
+
+- Downloads Toto-2.0 weights from HuggingFace
+- Converts safetensors → GGUF (F32, F16, or Q8_0)
+- Runs inference natively via [candle](https://github.com/huggingface/candle), reading directly from the GGUF file
+
+## Build
+
+```
+cargo build --release
+```
+
+## Usage
+
+### Convert a model
+
+```
+./target/release/toto-rs convert \
+  --model Datadog/Toto-2.0-2.5B \
+  --output gguf/toto-2.5b-f16.gguf \
+  --dtype f16
+```
+
+Available models: `Datadog/Toto-2.0-{4m,22m,313m,1B,2.5B}`  
+Available dtypes: `f32`, `f16`, `q8`
+
+To convert all sizes in all three dtypes at once:
+
+```
+./scripts/convert_all.sh
+```
+
+For gated models pass a HuggingFace token:
+
+```
+HF_TOKEN=hf_xxx ./scripts/convert_all.sh
+```
+
+### Run inference
+
+Input is a CSV file with a header row and one column per variate:
+
+```
+./target/release/toto-rs infer \
+  --gguf gguf/toto-2.5b-f16.gguf \
+  --config models/toto-2.5b/config.json \
+  --input data.csv \
+  --prediction-length 64
+```
+
+Output is a CSV of 9-quantile forecasts (q0.1 … q0.9) for each variate, one row per forecast step. Use `--f64` for double-precision arithmetic (matches PyTorch numerics, ~2× memory).
+
+## Benchmark
+
+Measured on Apple M-series (CPU), 512-step context → 64-step forecast, 3 runs averaged.
+
+| Model     | dtype |  Size (GB) | Time (s) | MAE vs F32 |
+|-----------|-------|-----------:|---------:|-----------:|
+| toto-4m   | f32   |       0.02 |     0.01 |          — |
+|           | f16   |       0.01 |     0.02 |      0.176 |
+|           | q8    |       0.00 |     0.01 |      3.242 |
+| toto-22m  | f32   |       0.09 |     0.04 |          — |
+|           | f16   |       0.04 |     0.04 |      0.071 |
+|           | q8    |       0.02 |     0.04 |      5.030 |
+| toto-313m | f32   |       1.25 |     0.32 |          — |
+|           | f16   |       0.63 |     0.36 |      0.074 |
+|           | q8    |       0.33 |     0.39 |      0.316 |
+| toto-1b   | f32   |       4.16 |     1.20 |          — |
+|           | f16   |       2.08 |     1.19 |      0.074 |
+|           | q8    |       1.11 |     0.87 |      0.334 |
+| toto-2.5b | f32   |       9.82 |     5.40 |          — |
+|           | f16   |       4.91 |     3.04 |      0.066 |
+|           | q8    |       2.61 |     3.49 |      0.243 |
+
+**F16 is the recommended dtype**: ~2× compression vs F32 with only ~0.07 MAE on models ≥313m. Q8 is useful when memory is the bottleneck and the model is ≥313m (small models are numerically sensitive).
+
+To reproduce:
+
+```
+pip install -r requirements.txt
+python benchmark.py
+```

toto-rs/benchmark.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Benchmark all Toto GGUF files: file size, inference speed, and quantization error.
+
+Usage:
+    python benchmark.py                  # all models & dtypes
+    python benchmark.py --model toto-4m  # one model only
+    python benchmark.py --ctx 256        # custom context length
+"""
+import argparse
+import math
+import os
+import subprocess
+import sys
+import time
+
+import numpy as np
+
+GGUF_DIR = "./gguf"
+MODELS_DIR = "./models"
+BIN = "./target/release/toto-rs"
+
+MODELS = [
+    ("toto-4m",   "Datadog/Toto-2.0-4m"),
+    ("toto-22m",  "Datadog/Toto-2.0-22m"),
+    ("toto-313m", "Datadog/Toto-2.0-313m"),
+    ("toto-1b",   "Datadog/Toto-2.0-1B"),
+    ("toto-2.5b", "Datadog/Toto-2.0-2.5B"),
+]
+DTYPES = ["f32", "f16", "q8"]
+
+PRED_LEN = 64
+N_TIMED_RUNS = 3
+
+
+def make_input(ctx_len: int) -> str:
+    """Build a CSV string with a single sine-wave variate."""
+    lines = ["value"]
+    for t in range(ctx_len):
+        v = 100.0 * math.sin(2 * math.pi * t / 32) + 500.0
+        lines.append(f"{v:.6f}")
+    return "\n".join(lines) + "\n"
+
+
+def gguf_path(tag: str, dtype: str) -> str:
+    return os.path.join(GGUF_DIR, f"{tag}-{dtype}.gguf")
+
+
+def config_path(tag: str) -> str:
+    return os.path.join(MODELS_DIR, tag, "config.json")
+
+
+def run_inference(gguf: str, config: str, csv_input: str, ctx_len: int) -> np.ndarray | None:
+    """Run toto-rs infer and return quantile array [9][pred_len], or None on error."""
+    try:
+        result = subprocess.run(
+            [
+                BIN, "infer",
+                "--gguf", gguf,
+                "--config", config,
+                "--input", "-",
+                "--prediction-length", str(PRED_LEN),
+                "--context-length", str(ctx_len),
+            ],
+            input=csv_input,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"    ERROR: {e.stderr.strip().splitlines()[-1] if e.stderr else e}", file=sys.stderr)
+        return None
+
+    lines = result.stdout.strip().splitlines()
+    if len(lines) < PRED_LEN + 1:
+        return None
+    data = np.array([
+        [float(lines[r + 1].split(",")[q]) for r in range(PRED_LEN)]
+        for q in range(9)
+    ])
+    return data
+
+
+def time_inference(gguf: str, config: str, csv_input: str, ctx_len: int, n_runs: int) -> float | None:
+    """Return mean wall-clock seconds for n_runs inference calls."""
+    times = []
+    for _ in range(n_runs):
+        t0 = time.perf_counter()
+        ok = run_inference(gguf, config, csv_input, ctx_len)
+        if ok is None:
+            return None
+        times.append(time.perf_counter() - t0)
+    return float(np.mean(times))
+
+
+def file_size_gb(path: str) -> float:
+    return os.path.getsize(path) / 1e9
+
+
+def fmt(val, missing="—"):
+    return missing if val is None else val
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", help="restrict to one tag, e.g. toto-4m")
+    parser.add_argument("--ctx", type=int, default=512, help="context length (default 512)")
+    args = parser.parse_args()
+
+    ctx_len = args.ctx
+    csv_input = make_input(ctx_len)
+
+    models = [(t, hf) for t, hf in MODELS if args.model is None or t == args.model]
+    if not models:
+        sys.exit(f"No model matching --model {args.model!r}")
+
+    # Column widths
+    w_tag = 10
+    w_dtype = 6
+    w_size = 8
+    w_time = 9
+    w_mae = 10
+
+    header = (
+        f"{'Model':<{w_tag}} {'dtype':<{w_dtype}} {'Size(GB)':>{w_size}} "
+        f"{'Time(s)':>{w_time}} {'MAE_vs_F32':>{w_mae}}"
+    )
+    sep = "-" * len(header)
+    print(f"\nContext={ctx_len} steps, prediction={PRED_LEN} steps, {N_TIMED_RUNS} timed runs\n")
+    print(header)
+    print(sep)
+
+    for tag, _hf in models:
+        cfg = config_path(tag)
+        if not os.path.exists(cfg):
+            print(f"{tag:<{w_tag}} [no config.json — run convert first]")
+            continue
+
+        # F32 reference for relative error
+        f32_gguf = gguf_path(tag, "f32")
+        f32_ref: np.ndarray | None = None
+        if os.path.exists(f32_gguf):
+            f32_ref = run_inference(f32_gguf, cfg, csv_input, ctx_len)
+
+        first_row = True
+        for dtype in DTYPES:
+            path = gguf_path(tag, dtype)
+            model_col = tag if first_row else ""
+            first_row = False
+
+            if not os.path.exists(path):
+                print(
+                    f"{model_col:<{w_tag}} {dtype:<{w_dtype}} {'missing':>{w_size}} "
+                    f"{'—':>{w_time}} {'—':>{w_mae}}"
+                )
+                continue
+
+            size = file_size_gb(path)
+            elapsed = time_inference(path, cfg, csv_input, ctx_len, N_TIMED_RUNS)
+
+            mae_str = "—"
+            if f32_ref is not None and dtype != "f32":
+                preds = run_inference(path, cfg, csv_input, ctx_len)
+                if preds is not None:
+                    mae = float(np.abs(preds - f32_ref).mean())
+                    mae_str = f"{mae:.5f}"
+
+            elapsed_str = f"{elapsed:.2f}" if elapsed is not None else "—"
+            print(
+                f"{model_col:<{w_tag}} {dtype:<{w_dtype}} {size:>{w_size}.2f} "
+                f"{elapsed_str:>{w_time}} {mae_str:>{w_mae}}"
+            )
+
+        if not first_row:
+            print(sep)
+
+
+if __name__ == "__main__":
+    main()

toto-rs/gguf/toto-1b-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8610f41c5e763a284880ee891569e0da0f5d67f477b90488327b2ff6dd5f445
+size 2082086944

toto-rs/gguf/toto-1b-f32.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca731b1f760fc9fa385cf194536a7c2ad6025cc8817e46bc84d5832e52680035
+size 4164152992

toto-rs/gguf/toto-1b-q8.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5b6a0539779ea30c291e65b1c47d8a25897ed8b328ad5d935a6d69678bfb5dd
+size 1106119520

toto-rs/gguf/toto-2.5b-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e25a276f593341924e599ebe04d5237153eff25ac2b630c40671d07e1305abcc
+size 4908591136

toto-rs/gguf/toto-2.5b-f32.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b45c20ab3ddb30c82f883437e40f37dd94ce852f87996982ba509097a62d3da
+size 9817154720

toto-rs/gguf/toto-2.5b-q8.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc0779a8f85a3edff7a24dfd4081b6fa9f821e558cce1df57fd32cd348a713b0
+size 2607703328

toto-rs/gguf/toto-22m-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e222378a32d2099f0c27f49335c5e1f6d7062f8f94e6b2fc40e1d18a81bc519
+size 43835552

toto-rs/gguf/toto-22m-f32.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:161bd2bab49feb239711f7a8b474988dfcc65a3ff14157b736582c66fb7362a5
+size 87666720

toto-rs/gguf/toto-22m-q8.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a11e5d8798e76938b6f510aa5557828ce90ced831f84786c01bc80cc8de87046
+size 23289888

toto-rs/gguf/toto-313m-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39041f941a2dd42c5df24c608b3a3125e210bb34c9347025e34e283f36bad0a2
+size 625383488

toto-rs/gguf/toto-313m-f32.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9fbe115438aebbc3b4d300f8c727bc8742d60b21918dc8c4a1bb676defad217
+size 1250752704

toto-rs/gguf/toto-313m-q8.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc5048ed8dc1365608985aebb53b86b1f76396d8131d8cba4cafea6730c50efc
+size 332242368

toto-rs/gguf/toto-4m-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3863b379552b82c7194a66b002c4989e610428642fdbbc36da3ac152246e1a5
+size 8292192

toto-rs/gguf/toto-4m-f32.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1e2d64dcd48c170b63c83362919f8dc4a1b12ee5e25ca520edb5dc88854612e
+size 16581088

toto-rs/gguf/toto-4m-q8.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee2a072101c5bdffae69573227e3f5cd5e0acf021e0934e30d059ce7d4832160
+size 4407072

toto-rs/requirements.txt

@@ -0,0 +1 @@
+numpy

toto-rs/scripts/compare_python.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Compare toto-rs Rust inference vs. Python Toto-2.0 reference.
+
+NOTE: The Toto Python package API has diverged from the released weights.
+This script runs the Rust binary for all three dtypes and compares f16/q8
+against f32 (intra-Rust comparison) to measure quantization degradation.
+A full Python vs Rust comparison requires the original toto training codebase.
+
+Usage:
+    python scripts/compare_python.py [--model 22m] [--dtype f32|f16|q8]
+"""
+import argparse
+import math
+import subprocess
+import sys
+import os
+import tempfile
+import numpy as np
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+RUST_BIN  = os.path.join(REPO_ROOT, "target", "release", "toto-rs")
+
+
+def make_context(n=128):
+    t = np.linspace(0, 4 * np.pi, n)
+    return (np.sin(t) + 0.05 * t + 1.0).astype(np.float32)
+
+
+def run_rust(model: str, dtype: str, context: np.ndarray, prediction_length: int = 32) -> np.ndarray:
+    gguf   = os.path.join(REPO_ROOT, "gguf", f"toto-{model}-{dtype}.gguf")
+    config = os.path.join(REPO_ROOT, "models", f"toto-{model}", "config.json")
+
+    # Write context to a temp CSV
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
+        tmp = f.name
+        f.write("value\n")
+        for v in context:
+            f.write(f"{v:.8f}\n")
+
+    try:
+        result = subprocess.run(
+            [RUST_BIN, "infer", "--gguf", gguf, "--config", config,
+             "--input", tmp, "--prediction-length", str(prediction_length)],
+            capture_output=True, text=True, check=True,
+        )
+    finally:
+        os.unlink(tmp)
+
+    lines = [l for l in result.stdout.strip().splitlines() if l]
+    # Skip header row, read median quantile column (q0.5)
+    header = lines[0].split(",")
+    q5_idx = next((i for i, h in enumerate(header) if "q0.5" in h), 4)
+    vals = []
+    for line in lines[1:]:
+        fields = line.split(",")
+        vals.append(float(fields[q5_idx]))
+    return np.array(vals, dtype=np.float32)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", default="22m",
+                        choices=["4m", "22m", "313m", "1b", "2.5b"])
+    parser.add_argument("--dtype", default="f32", choices=["f32", "f16", "q8"])
+    parser.add_argument("--prediction-length", type=int, default=32)
+    args = parser.parse_args()
+
+    context = make_context(128)
+    print(f"Model: toto-{args.model}, dtype: {args.dtype}, prediction_length: {args.prediction_length}")
+
+    print(f"Running Rust f32 reference …")
+    f32_out = run_rust(args.model, "f32", context, args.prediction_length)
+    print(f"  f32 shape: {f32_out.shape}, first 5: {f32_out[:5]}")
+
+    if args.dtype == "f32":
+        print(f"\nMax  |Δ|: 0.000000  (f32 vs f32)")
+        print(f"Mean |Δ|: 0.000000")
+        return
+
+    print(f"Running Rust {args.dtype} …")
+    rs_out = run_rust(args.model, args.dtype, context, args.prediction_length)
+
+    diff = np.abs(f32_out - rs_out)
+    print(f"\nComparison (f32 vs {args.dtype}) over {len(diff)} steps:")
+    print(f"  Max  |Δ|: {diff.max():.6f}")
+    print(f"  Mean |Δ|: {diff.mean():.6f}")
+
+
+if __name__ == "__main__":
+    main()

toto-rs/scripts/convert_all.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Convert all Toto-2.0 model sizes to F32, F16, and Q8_0 GGUF.
+#
+# Usage:
+#   ./scripts/convert_all.sh              # convert everything
+#   ./scripts/convert_all.sh toto-4m      # only convert the 4m model
+#   HF_TOKEN=hf_xxx ./scripts/convert_all.sh
+#
+# Outputs go to: gguf/<tag>-<dtype>.gguf
+# Model weights are cached in: models/<tag>/
+set -euo pipefail
+
+BIN="./target/release/toto-rs"
+GGUF_DIR="./gguf"
+MODELS_DIR="./models"
+
+# model_id:tag pairs
+MODELS=(
+    "Datadog/Toto-2.0-4m:toto-4m"
+    "Datadog/Toto-2.0-22m:toto-22m"
+    "Datadog/Toto-2.0-313m:toto-313m"
+    "Datadog/Toto-2.0-1B:toto-1b"
+    "Datadog/Toto-2.0-2.5B:toto-2.5b"
+)
+DTYPES=(f32 f16 q8)
+
+FILTER="${1:-}"  # optional: restrict to one tag
+
+mkdir -p "$GGUF_DIR"
+
+for entry in "${MODELS[@]}"; do
+    model_id="${entry%%:*}"
+    tag="${entry##*:}"
+
+    if [[ -n "$FILTER" && "$tag" != "$FILTER" ]]; then
+        continue
+    fi
+
+    model_dir="${MODELS_DIR}/${tag}"
+    mkdir -p "$model_dir"
+
+    for dtype in "${DTYPES[@]}"; do
+        output="${GGUF_DIR}/${tag}-${dtype}.gguf"
+
+        if [[ -f "$output" ]]; then
+            echo "[skip] $output already exists"
+            continue
+        fi
+
+        echo ""
+        echo "=== $model_id  →  $dtype  →  $output ==="
+        "$BIN" convert \
+            --model "$model_id" \
+            --model-dir "$model_dir" \
+            --output "$output" \
+            --dtype "$dtype" \
+            ${HF_TOKEN:+--token "$HF_TOKEN"}
+    done
+done
+
+echo ""
+echo "All done. GGUF files:"
+ls -lh "$GGUF_DIR"/*.gguf 2>/dev/null || echo "  (none found)"

toto-rs/scripts/upload.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Upload source + GGUF files to HuggingFace Hub via the built-in upload subcommand.
+#
+# Usage:
+#   HF_TOKEN=hf_... ./scripts/upload.sh [--repo owner/repo-name]
+#
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+BIN=./target/release/toto-rs
+
+if [[ ! -f "$BIN" ]]; then
+  echo "Binary not found — building release …"
+  cargo build --release
+fi
+
+exec "$BIN" upload \
+  --repo "amaye15/toto-gguf" \
+  ${HF_TOKEN:+--token "$HF_TOKEN"} \
+  "$@"

toto-rs/src/config.rs

@@ -0,0 +1,43 @@
+use serde::Deserialize;
+
+/// Mirrors the relevant fields from Datadog/Toto-2.0 config.json.
+/// Accepts the Python model field names (d_model, num_layers, …).
+/// Unknown fields are ignored so we stay forward-compatible.
+#[derive(Debug, Deserialize)]
+pub struct TotoConfig {
+    /// Number of transformer layers.
+    #[serde(alias = "num_layers", default = "default_u32::<48>")]
+    pub num_hidden_layers: u32,
+
+    /// Hidden / embedding dimension.
+    #[serde(alias = "d_model", default = "default_u32::<2048>")]
+    pub hidden_size: u32,
+
+    /// Number of query attention heads.
+    #[serde(alias = "num_heads", default = "default_u32::<32>")]
+    pub num_attention_heads: u32,
+
+    /// Number of KV groups (num_groups in Python = GQA groups).
+    #[serde(alias = "num_groups", default = "default_u32::<32>")]
+    pub num_key_value_heads: u32,
+
+    /// Per-head QK dimension.
+    #[serde(alias = "qk_dim", default = "default_u32::<64>")]
+    pub head_dim: u32,
+
+    /// Patch size in timesteps.
+    #[serde(default = "default_u32::<32>")]
+    pub patch_size: u32,
+
+    /// Number of output quantile levels.
+    #[serde(default = "default_u32::<9>")]
+    pub num_quantiles: u32,
+}
+
+impl TotoConfig {
+    pub fn from_json(s: &str) -> anyhow::Result<Self> {
+        Ok(serde_json::from_str(s)?)
+    }
+}
+
+fn default_u32<const N: u32>() -> u32 { N }

toto-rs/src/convert.rs

@@ -0,0 +1,397 @@
+use std::fs::File;
+use std::io::BufWriter;
+use std::path::Path;
+
+use anyhow::Context;
+use indicatif::{ProgressBar, ProgressStyle};
+use safetensors::SafeTensors;
+
+use safetensors::Dtype as StDtype;
+
+use crate::config::TotoConfig;
+use crate::download::ModelFiles;
+use crate::gguf::{GGMLType, GGUFMetaValue, GGUFWriter};
+use crate::tensor_map::map_tensor_name;
+
+/// Options that control how tensors are stored in the output GGUF.
+pub struct ConvertOptions {
+    /// Target dtype for all tensors in the output file.
+    pub output_dtype: GGMLType,
+}
+
+/// Read `files`, convert every tensor, and write a GGUF file to `output_path`.
+pub fn convert(
+    model_id: &str,
+    files: &ModelFiles,
+    config: &TotoConfig,
+    opts: &ConvertOptions,
+    output_path: &Path,
+) -> anyhow::Result<()> {
+    let mut writer = GGUFWriter::new();
+
+    // Embed Toto architecture metadata.
+    write_metadata(&mut writer, model_id, config);
+
+    // Discover all tensor names across shards before writing (we need a total
+    // for the progress bar and to detect duplicates).
+    let shard_bytes = load_shard_bytes(&files.safetensors_shards)?;
+    let shard_views: Vec<SafeTensors> = shard_bytes
+        .iter()
+        .map(|b| SafeTensors::deserialize(b).context("deserialize shard"))
+        .collect::<anyhow::Result<_>>()?;
+
+    let total_tensors: usize = shard_views.iter().map(|s| s.len()).sum();
+    println!(
+        "Found {} tensors across {} shard(s).",
+        total_tensors,
+        shard_views.len()
+    );
+
+    let pb = ProgressBar::new(total_tensors as u64);
+    pb.set_style(
+        ProgressStyle::with_template(
+            "{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} {msg}",
+        )
+        .unwrap()
+        .progress_chars("=>-"),
+    );
+
+    let mut mapped = 0usize;
+    let mut skipped: Vec<String> = Vec::new();
+    let mut fallback_count = 0usize;
+
+    for shard in &shard_views {
+        for (hf_name, tensor_view) in shard.tensors() {
+            pb.set_message(hf_name.to_string());
+
+            let gguf_name = match map_tensor_name(&hf_name) {
+                Some(n) => n,
+                None => {
+                    skipped.push(hf_name.to_string());
+                    pb.inc(1);
+                    continue;
+                }
+            };
+
+            let src_dtype = ggml_type_from_st(tensor_view.dtype())
+                .with_context(|| format!("tensor {hf_name}: unsupported dtype {:?}", tensor_view.dtype()))?;
+
+            let raw_data = tensor_view.data();
+            let py_shape = tensor_view.shape(); // Python row-major: [d0, d1, ..., d_inner]
+            let n_elems: usize = py_shape.iter().product();
+            let innermost = py_shape.last().copied().unwrap_or(1);
+            let outermost = py_shape.first().copied().unwrap_or(1);
+
+            // Q8_0: candle requires the innermost dimension (last Python dim, first GGUF dim) to
+            // be divisible by 32. When that fails for a 2D weight with a block-aligned outermost
+            // dim, we transpose the data and flip the GGUF shape so candle sees the weight with
+            // the divisible dimension as innermost. The inference loader corrects the orientation.
+            let (dst_dtype, gguf_shape, tensor_data) =
+                if opts.output_dtype == GGMLType::Q8_0 && innermost % 32 != 0 {
+                    if py_shape.len() == 2 && outermost % 32 == 0 && n_elems % 32 == 0 {
+                        // Transpose: (d_out × d_in) → (d_in × d_out) so d_out becomes innermost.
+                        let f32_vals = decode_to_f32(raw_data, src_dtype)
+                            .with_context(|| format!("tensor {hf_name}: decode failed"))?;
+                        let transposed = transpose_f32(&f32_vals, outermost, innermost);
+                        let qdata = quantize_q8_0(&transposed)
+                            .with_context(|| format!("tensor {hf_name}: quantize failed"))?;
+                        // GGUF shape = Python shape order (NOT reversed). Candle reverses it back,
+                        // seeing (d_in, d_out) with last dim d_out divisible by 32.
+                        let gs = py_shape.iter().map(|&d| d as u64).collect();
+                        (GGMLType::Q8_0, gs, qdata)
+                    } else {
+                        // Can't transpose (1D scalar/bias or no suitable fallback dim) → F32.
+                        fallback_count += 1;
+                        let data = cast_data(raw_data, src_dtype, GGMLType::F32)
+                            .with_context(|| format!("tensor {hf_name}: cast failed"))?;
+                        let gs = py_shape.iter().rev().map(|&d| d as u64).collect();
+                        (GGMLType::F32, gs, data)
+                    }
+                } else if opts.output_dtype == GGMLType::Q8_0 && n_elems % 32 != 0 {
+                    // Scalar / tiny tensor — fall back to F32.
+                    fallback_count += 1;
+                    let data = cast_data(raw_data, src_dtype, GGMLType::F32)
+                        .with_context(|| format!("tensor {hf_name}: cast failed"))?;
+                    let gs = py_shape.iter().rev().map(|&d| d as u64).collect();
+                    (GGMLType::F32, gs, data)
+                } else {
+                    let dst = opts.output_dtype;
+                    let data = cast_data(raw_data, src_dtype, dst)
+                        .with_context(|| format!("tensor {hf_name}: cast failed"))?;
+                    let gs = py_shape.iter().rev().map(|&d| d as u64).collect();
+                    (dst, gs, data)
+                };
+
+            writer.add_tensor(gguf_name, gguf_shape, dst_dtype, tensor_data);
+            mapped += 1;
+            pb.inc(1);
+        }
+    }
+
+    pb.finish_with_message("tensors processed");
+
+    if !skipped.is_empty() {
+        eprintln!(
+            "\nWarning: {} tensor(s) had unrecognised names and were skipped:",
+            skipped.len()
+        );
+        for name in &skipped {
+            eprintln!("  {name}");
+        }
+        eprintln!("Update tensor_map.rs to include these if needed.");
+    }
+
+    if fallback_count > 0 {
+        eprintln!(
+            "\nNote: {fallback_count} tensor(s) fell back to F32 (scalars/biases too \
+             small for Q8_0 blocks)."
+        );
+    }
+    println!("Writing {mapped} tensors to {} …", output_path.display());
+    let out_file = File::create(output_path)
+        .with_context(|| format!("create output file {}", output_path.display()))?;
+    let mut buf_writer = BufWriter::new(out_file);
+    writer.write_to(&mut buf_writer)?;
+    println!("Done.");
+
+    Ok(())
+}
+
+fn ggml_type_from_st(dtype: StDtype) -> anyhow::Result<GGMLType> {
+    match dtype {
+        StDtype::F32 => Ok(GGMLType::F32),
+        StDtype::F16 => Ok(GGMLType::F16),
+        StDtype::BF16 => Ok(GGMLType::BF16),
+        other => anyhow::bail!("unsupported safetensors dtype: {other:?}"),
+    }
+}
+
+/// Build the GGUF metadata section from the parsed config.
+fn write_metadata(writer: &mut GGUFWriter, model_id: &str, config: &TotoConfig) {
+    writer.add_metadata("general.architecture", GGUFMetaValue::String("toto2".into()));
+    writer.add_metadata("general.name", GGUFMetaValue::String(model_id.into()));
+    writer.add_metadata(
+        "toto2.block_count",
+        GGUFMetaValue::Uint32(config.num_hidden_layers),
+    );
+    writer.add_metadata(
+        "toto2.embedding_length",
+        GGUFMetaValue::Uint32(config.hidden_size),
+    );
+    writer.add_metadata(
+        "toto2.attention.head_count",
+        GGUFMetaValue::Uint32(config.num_attention_heads),
+    );
+    writer.add_metadata(
+        "toto2.attention.head_count_kv",
+        GGUFMetaValue::Uint32(config.num_key_value_heads),
+    );
+    writer.add_metadata(
+        "toto2.attention.head_dim",
+        GGUFMetaValue::Uint32(config.head_dim),
+    );
+    writer.add_metadata(
+        "toto2.patch_size",
+        GGUFMetaValue::Uint32(config.patch_size),
+    );
+    writer.add_metadata(
+        "toto2.quantile_count",
+        GGUFMetaValue::Uint32(config.num_quantiles),
+    );
+}
+
+/// Memory-map and read each shard file into a `Vec<u8>`.
+fn load_shard_bytes(shards: &[std::path::PathBuf]) -> anyhow::Result<Vec<Vec<u8>>> {
+    shards
+        .iter()
+        .map(|p| {
+            std::fs::read(p).with_context(|| format!("read shard {}", p.display()))
+        })
+        .collect()
+}
+
+/// Cast tensor bytes from `src_dtype` to `dst_dtype`.
+/// If both are the same non-quantized dtype, returns a copy of the input bytes.
+fn cast_data(data: &[u8], src: GGMLType, dst: GGMLType) -> anyhow::Result<Vec<u8>> {
+    if src == dst {
+        return Ok(data.to_vec());
+    }
+
+    // For Q8_0 destination: decode to f32 first, then quantize.
+    if dst == GGMLType::Q8_0 {
+        let f32_values = decode_to_f32(data, src)?;
+        return quantize_q8_0(&f32_values);
+    }
+
+    match (src, dst) {
+        (GGMLType::F32, GGMLType::F16) => {
+            let f32_values = parse_f32_le(data)?;
+            let mut out = Vec::with_capacity(f32_values.len() * 2);
+            for v in f32_values {
+                let bits = f32_to_f16_bits(v);
+                out.extend_from_slice(&bits.to_le_bytes());
+            }
+            Ok(out)
+        }
+        (GGMLType::BF16, GGMLType::F32) => {
+            let mut out = Vec::with_capacity(data.len() * 2);
+            for chunk in data.chunks_exact(2) {
+                let bf16_bits = u16::from_le_bytes([chunk[0], chunk[1]]);
+                let f32_bits = (bf16_bits as u32) << 16;
+                out.extend_from_slice(&f32_bits.to_le_bytes());
+            }
+            Ok(out)
+        }
+        (GGMLType::BF16, GGMLType::F16) => {
+            // BF16 → F32 → F16
+            let mut out = Vec::with_capacity(data.len());
+            for chunk in data.chunks_exact(2) {
+                let bf16_bits = u16::from_le_bytes([chunk[0], chunk[1]]);
+                let f32_bits = (bf16_bits as u32) << 16;
+                let f32_val = f32::from_bits(f32_bits);
+                let f16_bits = f32_to_f16_bits(f32_val);
+                out.extend_from_slice(&f16_bits.to_le_bytes());
+            }
+            Ok(out)
+        }
+        (GGMLType::F16, GGMLType::F32) => {
+            let mut out = Vec::with_capacity(data.len() * 2);
+            for chunk in data.chunks_exact(2) {
+                let f16_bits = u16::from_le_bytes([chunk[0], chunk[1]]);
+                let f32_val = f16_to_f32(f16_bits);
+                out.extend_from_slice(&f32_val.to_bits().to_le_bytes());
+            }
+            Ok(out)
+        }
+        _ => anyhow::bail!("unsupported cast: {src:?} → {dst:?}"),
+    }
+}
+
+/// Decode any supported float dtype to a Vec<f32>.
+fn decode_to_f32(data: &[u8], src: GGMLType) -> anyhow::Result<Vec<f32>> {
+    match src {
+        GGMLType::F32 => parse_f32_le(data),
+        GGMLType::F16 => {
+            data.chunks_exact(2)
+                .map(|c| Ok(f16_to_f32(u16::from_le_bytes([c[0], c[1]]))))
+                .collect()
+        }
+        GGMLType::BF16 => {
+            data.chunks_exact(2)
+                .map(|c| {
+                    let bf16_bits = u16::from_le_bytes([c[0], c[1]]);
+                    Ok(f32::from_bits((bf16_bits as u32) << 16))
+                })
+                .collect()
+        }
+        GGMLType::Q8_0 => anyhow::bail!("Q8_0 → Q8_0 re-quantization not supported as source"),
+    }
+}
+
+/// Transpose a flat (n_rows × n_cols) row-major F32 array to (n_cols × n_rows).
+fn transpose_f32(data: &[f32], n_rows: usize, n_cols: usize) -> Vec<f32> {
+    let mut out = vec![0.0f32; n_rows * n_cols];
+    for r in 0..n_rows {
+        for c in 0..n_cols {
+            out[c * n_rows + r] = data[r * n_cols + c];
+        }
+    }
+    out
+}
+
+/// Quantize a slice of f32 values to GGML Q8_0 block format.
+///
+/// Each block: `[f16 scale (2 bytes)][32 × i8 (32 bytes)]` = 34 bytes.
+/// Requires `values.len()` to be a multiple of 32.
+fn quantize_q8_0(values: &[f32]) -> anyhow::Result<Vec<u8>> {
+    const BLOCK: usize = 32;
+    if values.len() % BLOCK != 0 {
+        anyhow::bail!(
+            "Q8_0 requires element count divisible by {BLOCK}, got {}",
+            values.len()
+        );
+    }
+    let n_blocks = values.len() / BLOCK;
+    let mut out = vec![0u8; n_blocks * 34];
+
+    for b in 0..n_blocks {
+        let blk = &values[b * BLOCK..(b + 1) * BLOCK];
+        let amax = blk.iter().copied().map(f32::abs).fold(0.0f32, f32::max);
+        let d = if amax == 0.0 { 0.0f32 } else { amax / 127.0 };
+        let d_inv = if d == 0.0 { 0.0f32 } else { 1.0 / d };
+
+        let base = b * 34;
+        let d_f16 = f32_to_f16_bits(d);
+        out[base..base + 2].copy_from_slice(&d_f16.to_le_bytes());
+        for i in 0..BLOCK {
+            let q = (blk[i] * d_inv).round().clamp(-127.0, 127.0) as i8;
+            out[base + 2 + i] = q as u8;
+        }
+    }
+    Ok(out)
+}
+
+/// Parse a little-endian byte slice into a Vec<f32> (len must be divisible by 4).
+fn parse_f32_le(data: &[u8]) -> anyhow::Result<Vec<f32>> {
+    if data.len() % 4 != 0 {
+        anyhow::bail!("f32 data length not divisible by 4");
+    }
+    Ok(data.chunks_exact(4)
+        .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
+        .collect())
+}
+
+/// Convert f32 to IEEE 754 binary16 bit pattern.
+fn f32_to_f16_bits(v: f32) -> u16 {
+    // Fast software path — no hardware f16 needed.
+    let bits = v.to_bits();
+    let sign = ((bits >> 16) & 0x8000) as u16;
+    let exp = ((bits >> 23) & 0xFF) as i32;
+    let mantissa = bits & 0x007F_FFFF;
+
+    if exp == 0xFF {
+        // NaN or Inf
+        return sign | 0x7C00 | if mantissa != 0 { 0x0200 } else { 0 };
+    }
+
+    let new_exp = exp - 127 + 15;
+    if new_exp >= 31 {
+        return sign | 0x7C00; // Inf
+    }
+    if new_exp <= 0 {
+        if new_exp < -10 {
+            return sign; // Underflow to zero
+        }
+        // Subnormal
+        let m = (mantissa | 0x0080_0000) >> (1 - new_exp);
+        return sign | (m >> 13) as u16;
+    }
+    sign | ((new_exp as u16) << 10) | (mantissa >> 13) as u16
+}
+
+/// Convert IEEE 754 binary16 bit pattern to f32.
+fn f16_to_f32(bits: u16) -> f32 {
+    let sign = ((bits & 0x8000) as u32) << 16;
+    let exp = ((bits >> 10) & 0x1F) as i32;
+    let mantissa = (bits & 0x03FF) as u32;
+
+    let f32_bits = if exp == 0 {
+        if mantissa == 0 {
+            sign
+        } else {
+            // Subnormal → normalise
+            let mut m = mantissa;
+            let mut e = 0i32;
+            while m & 0x0400 == 0 {
+                m <<= 1;
+                e += 1;
+            }
+            sign | ((127 - 15 - e + 1) as u32) << 23 | (m & 0x03FF) << 13
+        }
+    } else if exp == 31 {
+        sign | 0x7F80_0000 | (mantissa << 13)
+    } else {
+        sign | ((exp + 127 - 15) as u32) << 23 | (mantissa << 13)
+    };
+    f32::from_bits(f32_bits)
+}

toto-rs/src/download.rs

@@ -0,0 +1,184 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::Context;
+use futures_util::StreamExt;
+use serde::Deserialize;
+use tokio::io::AsyncWriteExt;
+
+const HF_BASE: &str = "https://huggingface.co";
+
+/// Paths to all local files needed for conversion.
+pub struct ModelFiles {
+    pub config_json: PathBuf,
+    /// Ordered list of safetensors shard paths, already downloaded locally.
+    pub safetensors_shards: Vec<PathBuf>,
+}
+
+/// Download (or locate from cache) all model files for `repo_id` into `model_dir`.
+pub async fn download_model(
+    repo_id: &str,
+    hf_token: Option<&str>,
+    model_dir: &Path,
+) -> anyhow::Result<ModelFiles> {
+    let client = build_client(hf_token)?;
+    std::fs::create_dir_all(model_dir).context("create model dir")?;
+
+    println!("Fetching config.json …");
+    let config_json = fetch_file(&client, repo_id, "config.json", model_dir).await?;
+
+    // Detect sharded model by fetching the index file.
+    let shards =
+        match fetch_file(&client, repo_id, "model.safetensors.index.json", model_dir).await {
+            Ok(index_path) => {
+                println!("Found sharded model — reading index …");
+                resolve_shards(&client, repo_id, &index_path, model_dir).await?
+            }
+            Err(_) => {
+                println!("Fetching model.safetensors …");
+                let shard =
+                    fetch_file(&client, repo_id, "model.safetensors", model_dir).await?;
+                vec![shard]
+            }
+        };
+
+    Ok(ModelFiles {
+        config_json,
+        safetensors_shards: shards,
+    })
+}
+
+fn build_client(hf_token: Option<&str>) -> anyhow::Result<reqwest::Client> {
+    let mut headers = reqwest::header::HeaderMap::new();
+    headers.insert(
+        reqwest::header::USER_AGENT,
+        "toto-rs/0.1".parse().unwrap(),
+    );
+    if let Some(token) = hf_token {
+        headers.insert(
+            reqwest::header::AUTHORIZATION,
+            format!("Bearer {token}").parse().context("invalid HF token")?,
+        );
+    }
+    Ok(reqwest::Client::builder()
+        .default_headers(headers)
+        .redirect(reqwest::redirect::Policy::limited(10))
+        .build()?)
+}
+
+/// Download `filename` from `repo_id` into `dest_dir`, resuming if a partial
+/// `.tmp` file already exists. Returns the local path of the completed file.
+async fn fetch_file(
+    client: &reqwest::Client,
+    repo_id: &str,
+    filename: &str,
+    dest_dir: &Path,
+) -> anyhow::Result<PathBuf> {
+    let dest = dest_dir.join(filename.replace('/', "_"));
+    if dest.exists() {
+        println!("  (cached) {filename}");
+        return Ok(dest);
+    }
+
+    let dest_tmp = dest.with_extension("tmp");
+    let already = if dest_tmp.exists() {
+        dest_tmp.metadata()?.len()
+    } else {
+        0
+    };
+
+    let url = format!("{HF_BASE}/{repo_id}/resolve/main/{filename}");
+
+    let mut req = client.get(&url);
+    if already > 0 {
+        req = req.header(reqwest::header::RANGE, format!("bytes={already}-"));
+        println!("  Resuming {filename} from {} MB …", already / 1_000_000);
+    }
+
+    let response = req
+        .send()
+        .await
+        .with_context(|| format!("GET {url}"))?;
+
+    let status = response.status();
+    // 206 = partial content (resume accepted), 200 = full content
+    if !status.is_success() {
+        anyhow::bail!("HTTP {status} fetching {filename} from {repo_id}");
+    }
+
+    // If server ignored the Range header and sent 200, truncate the tmp file.
+    let (file, resume_offset) = if status == reqwest::StatusCode::PARTIAL_CONTENT {
+        let f = tokio::fs::OpenOptions::new()
+            .append(true)
+            .open(&dest_tmp)
+            .await
+            .with_context(|| format!("open tmp {}", dest_tmp.display()))?;
+        (f, already)
+    } else {
+        let f = tokio::fs::File::create(&dest_tmp)
+            .await
+            .with_context(|| format!("create tmp {}", dest_tmp.display()))?;
+        (f, 0)
+    };
+
+    let total = response
+        .content_length()
+        .map(|n| n + resume_offset)
+        .unwrap_or(0);
+
+    let pb = indicatif::ProgressBar::new(total);
+    pb.set_style(
+        indicatif::ProgressStyle::with_template(
+            "  {msg} [{bar:40}] {bytes}/{total_bytes} ({bytes_per_sec}, eta {eta})",
+        )
+        .unwrap()
+        .progress_chars("=>-"),
+    );
+    pb.set_message(filename.to_string());
+    pb.set_position(resume_offset);
+
+    {
+        let mut file = file;
+        let mut stream = response.bytes_stream();
+        while let Some(chunk) = stream.next().await {
+            let chunk = chunk.with_context(|| format!("stream chunk of {filename}"))?;
+            pb.inc(chunk.len() as u64);
+            file.write_all(&chunk)
+                .await
+                .with_context(|| format!("write chunk to {}", dest_tmp.display()))?;
+        }
+    }
+
+    pb.finish_and_clear();
+    std::fs::rename(&dest_tmp, &dest)
+        .with_context(|| format!("rename tmp → {}", dest.display()))?;
+
+    Ok(dest)
+}
+
+/// Parse the shard index JSON and download every unique shard.
+async fn resolve_shards(
+    client: &reqwest::Client,
+    repo_id: &str,
+    index_path: &Path,
+    cache_dir: &Path,
+) -> anyhow::Result<Vec<PathBuf>> {
+    #[derive(Deserialize)]
+    struct Index {
+        weight_map: std::collections::HashMap<String, String>,
+    }
+
+    let raw = std::fs::read_to_string(index_path).context("read index json")?;
+    let index: Index = serde_json::from_str(&raw).context("parse index json")?;
+
+    let mut shard_names: Vec<String> = index.weight_map.into_values().collect();
+    shard_names.sort();
+    shard_names.dedup();
+
+    let mut paths = Vec::with_capacity(shard_names.len());
+    for name in &shard_names {
+        println!("  Fetching {name} …");
+        let p = fetch_file(client, repo_id, name, cache_dir).await?;
+        paths.push(p);
+    }
+    Ok(paths)
+}

toto-rs/src/gguf/mod.rs

@@ -0,0 +1,5 @@
+pub mod types;
+pub mod writer;
+
+pub use types::{GGMLType, GGUFMetaValue};
+pub use writer::GGUFWriter;

toto-rs/src/gguf/types.rs

@@ -0,0 +1,83 @@
+/// GGML tensor data types used in GGUF files.
+/// Values match the ggml_type enum in ggml.h.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum GGMLType {
+    F32 = 0,
+    F16 = 1,
+    /// Q8_0: blocks of 32 × i8 with a shared f16 scale (34 bytes/block).
+    Q8_0 = 8,
+    BF16 = 30,
+}
+
+impl GGMLType {
+    /// (block_elems, bytes_per_block) for block-quantized types; None for float types.
+    /// Q8_0: 32 × i8 values + 1 × f16 scale = 34 bytes/block.
+    #[allow(dead_code)]
+    pub fn block_shape(self) -> Option<(usize, usize)> {
+        match self {
+            GGMLType::Q8_0 => Some((32, 34)),
+            _ => None,
+        }
+    }
+}
+
+/// GGUF metadata value types (gguf_metadata_value_type).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+#[allow(dead_code)]
+pub enum GGUFValueType {
+    Uint8 = 0,
+    Int8 = 1,
+    Uint16 = 2,
+    Int16 = 3,
+    Uint32 = 4,
+    Int32 = 5,
+    Float32 = 6,
+    Bool = 7,
+    String = 8,
+    Array = 9,
+    Uint64 = 10,
+    Int64 = 11,
+    Float64 = 12,
+}
+
+/// A typed metadata value for a GGUF key-value pair.
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub enum GGUFMetaValue {
+    Uint8(u8),
+    Int8(i8),
+    Uint16(u16),
+    Int16(i16),
+    Uint32(u32),
+    Int32(i32),
+    Float32(f32),
+    Bool(bool),
+    String(String),
+    Uint64(u64),
+    Int64(i64),
+    Float64(f64),
+    ArrayUint32(Vec<u32>),
+    ArrayString(Vec<String>),
+}
+
+impl GGUFMetaValue {
+    pub fn value_type(&self) -> GGUFValueType {
+        match self {
+            GGUFMetaValue::Uint8(_) => GGUFValueType::Uint8,
+            GGUFMetaValue::Int8(_) => GGUFValueType::Int8,
+            GGUFMetaValue::Uint16(_) => GGUFValueType::Uint16,
+            GGUFMetaValue::Int16(_) => GGUFValueType::Int16,
+            GGUFMetaValue::Uint32(_) => GGUFValueType::Uint32,
+            GGUFMetaValue::Int32(_) => GGUFValueType::Int32,
+            GGUFMetaValue::Float32(_) => GGUFValueType::Float32,
+            GGUFMetaValue::Bool(_) => GGUFValueType::Bool,
+            GGUFMetaValue::String(_) => GGUFValueType::String,
+            GGUFMetaValue::Uint64(_) => GGUFValueType::Uint64,
+            GGUFMetaValue::Int64(_) => GGUFValueType::Int64,
+            GGUFMetaValue::Float64(_) => GGUFValueType::Float64,
+            GGUFMetaValue::ArrayUint32(_) | GGUFMetaValue::ArrayString(_) => GGUFValueType::Array,
+        }
+    }
+}

toto-rs/src/gguf/writer.rs

@@ -0,0 +1,154 @@
+use std::io::{self, Seek, Write};
+
+use byteorder::{LittleEndian, WriteBytesExt};
+
+use super::types::{GGMLType, GGUFMetaValue, GGUFValueType};
+
+const GGUF_MAGIC: &[u8; 4] = b"GGUF";
+const GGUF_VERSION: u32 = 3;
+const ALIGNMENT: u64 = 32;
+
+/// Describes one tensor's position in the GGUF data section.
+#[derive(Debug)]
+struct TensorInfo {
+    name: String,
+    shape: Vec<u64>,
+    dtype: GGMLType,
+    /// Byte offset from the start of the tensor data block.
+    offset: u64,
+    /// Raw tensor bytes (row-major, little-endian).
+    data: Vec<u8>,
+}
+
+/// Streaming GGUF v3 writer.
+///
+/// Call [`add_metadata`] for every key-value pair, then [`add_tensor`] for
+/// every tensor, then [`write_to`] to flush the complete file.
+pub struct GGUFWriter {
+    metadata: Vec<(String, GGUFMetaValue)>,
+    tensors: Vec<TensorInfo>,
+    /// Running data-block offset for the next tensor.
+    data_offset: u64,
+}
+
+impl GGUFWriter {
+    pub fn new() -> Self {
+        Self {
+            metadata: Vec::new(),
+            tensors: Vec::new(),
+            data_offset: 0,
+        }
+    }
+
+    pub fn add_metadata(&mut self, key: impl Into<String>, value: GGUFMetaValue) {
+        self.metadata.push((key.into(), value));
+    }
+
+    /// Buffer a tensor. `data` must already be in the target dtype byte layout.
+    pub fn add_tensor(
+        &mut self,
+        name: impl Into<String>,
+        shape: Vec<u64>,
+        dtype: GGMLType,
+        data: Vec<u8>,
+    ) {
+        let offset = self.data_offset;
+        let padded_len = round_up(data.len() as u64, ALIGNMENT);
+        self.data_offset += padded_len;
+        self.tensors.push(TensorInfo {
+            name: name.into(),
+            shape,
+            dtype,
+            offset,
+            data,
+        });
+    }
+
+    /// Serialize the complete GGUF file to `writer`.
+    pub fn write_to<W: Write + Seek>(&self, writer: &mut W) -> anyhow::Result<()> {
+        // --- header ---
+        writer.write_all(GGUF_MAGIC)?;
+        writer.write_u32::<LittleEndian>(GGUF_VERSION)?;
+        writer.write_u64::<LittleEndian>(self.tensors.len() as u64)?;
+        writer.write_u64::<LittleEndian>(self.metadata.len() as u64)?;
+
+        // --- metadata key-value pairs ---
+        for (key, value) in &self.metadata {
+            write_string(writer, key)?;
+            writer.write_u32::<LittleEndian>(value.value_type() as u32)?;
+            write_value(writer, value)?;
+        }
+
+        // --- tensor info ---
+        for t in &self.tensors {
+            write_string(writer, &t.name)?;
+            writer.write_u32::<LittleEndian>(t.shape.len() as u32)?;
+            for &dim in &t.shape {
+                writer.write_u64::<LittleEndian>(dim)?;
+            }
+            writer.write_u32::<LittleEndian>(t.dtype as u32)?;
+            writer.write_u64::<LittleEndian>(t.offset)?;
+        }
+
+        // --- align to ALIGNMENT before tensor data ---
+        let pos = writer.stream_position()?;
+        let aligned = round_up(pos, ALIGNMENT);
+        if aligned > pos {
+            let pad = vec![0u8; (aligned - pos) as usize];
+            writer.write_all(&pad)?;
+        }
+
+        // --- tensor data (each padded to ALIGNMENT) ---
+        for t in &self.tensors {
+            writer.write_all(&t.data)?;
+            let remainder = t.data.len() as u64 % ALIGNMENT;
+            if remainder != 0 {
+                let pad = vec![0u8; (ALIGNMENT - remainder) as usize];
+                writer.write_all(&pad)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+fn round_up(value: u64, align: u64) -> u64 {
+    (value + align - 1) / align * align
+}
+
+fn write_string<W: Write>(writer: &mut W, s: &str) -> io::Result<()> {
+    writer.write_u64::<LittleEndian>(s.len() as u64)?;
+    writer.write_all(s.as_bytes())
+}
+
+fn write_value<W: Write>(writer: &mut W, value: &GGUFMetaValue) -> anyhow::Result<()> {
+    match value {
+        GGUFMetaValue::Uint8(v) => writer.write_u8(*v)?,
+        GGUFMetaValue::Int8(v) => writer.write_i8(*v)?,
+        GGUFMetaValue::Uint16(v) => writer.write_u16::<LittleEndian>(*v)?,
+        GGUFMetaValue::Int16(v) => writer.write_i16::<LittleEndian>(*v)?,
+        GGUFMetaValue::Uint32(v) => writer.write_u32::<LittleEndian>(*v)?,
+        GGUFMetaValue::Int32(v) => writer.write_i32::<LittleEndian>(*v)?,
+        GGUFMetaValue::Float32(v) => writer.write_f32::<LittleEndian>(*v)?,
+        GGUFMetaValue::Bool(v) => writer.write_u8(*v as u8)?,
+        GGUFMetaValue::String(v) => write_string(writer, v)?,
+        GGUFMetaValue::Uint64(v) => writer.write_u64::<LittleEndian>(*v)?,
+        GGUFMetaValue::Int64(v) => writer.write_i64::<LittleEndian>(*v)?,
+        GGUFMetaValue::Float64(v) => writer.write_f64::<LittleEndian>(*v)?,
+        GGUFMetaValue::ArrayUint32(arr) => {
+            writer.write_u32::<LittleEndian>(GGUFValueType::Uint32 as u32)?;
+            writer.write_u64::<LittleEndian>(arr.len() as u64)?;
+            for v in arr {
+                writer.write_u32::<LittleEndian>(*v)?;
+            }
+        }
+        GGUFMetaValue::ArrayString(arr) => {
+            writer.write_u32::<LittleEndian>(GGUFValueType::String as u32)?;
+            writer.write_u64::<LittleEndian>(arr.len() as u64)?;
+            for s in arr {
+                write_string(writer, s)?;
+            }
+        }
+    }
+    Ok(())
+}

toto-rs/src/infer/mod.rs

@@ -0,0 +1,644 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+//
+// This product includes software developed at Datadog (https://www.datadoghq.com/)
+// Copyright 2026 Datadog, Inc.
+
+//! Toto-2 inference engine.
+//!
+//! Unit-scaling (μP) inference notes:
+//! * `uu.Linear` → `F.linear(x, w, b) / sqrt(fan_in)`
+//! * `uu.LinearReadout` → `F.linear(x, w, b) / fan_in`
+//! * `U.silu` → `F.silu(x) * 1.766782948` (unit-scaled)
+//! * τ-rule: `residual_split` is identity; `residual_add(h,skip,τ)` = `h*(τ/d) + skip*(1/d)` where `d=√(1+τ²)`
+//! * `PerDimScale(q, w)` = `q * softplus(w) / log(2)` — the 0.52103 unit-scaling factors cancel
+
+mod rope;
+
+use std::io::{BufReader, Read, Seek};
+use std::path::Path;
+
+use anyhow::{bail, Context, Result};
+use candle_core::quantized::gguf_file;
+use candle_core::{DType, Device, Tensor, D};
+use candle_nn::ops;
+
+use rope::RopeCache;
+
+const SILU_SCALE: f64 = 1.766782948312328;
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+#[derive(Clone, Debug)]
+pub struct InferConfig {
+    pub d_model: usize,
+    pub num_layers: usize,
+    pub num_heads: usize,
+    pub num_groups: usize,
+    pub qk_dim: usize,
+    pub v_dim: usize,
+    pub patch_size: usize,
+    pub norm_eps: f64,
+    pub layer_group_size: usize,
+    pub num_variate_layers_per_group: usize,
+    pub variate_layer_first: bool,
+    pub use_xpos: bool,
+    pub residual_mult: f64,
+    pub residual_attn_ratio: f64,
+    /// Run forward pass in F64 to match PyTorch numerical precision.
+    /// Weights are cast to F64 at load time (~2× memory). Default: false.
+    pub compute_f64: bool,
+}
+
+impl InferConfig {
+    fn is_variate_layer(&self, idx: usize) -> bool {
+        if self.variate_layer_first {
+            idx % self.layer_group_size < self.num_variate_layers_per_group
+        } else {
+            idx % self.layer_group_size
+                >= self.layer_group_size - self.num_variate_layers_per_group
+        }
+    }
+    fn q_size(&self) -> usize { self.qk_dim * self.num_heads }
+    fn k_size(&self) -> usize { self.qk_dim * self.num_groups }
+    fn v_size(&self) -> usize { self.v_dim * self.num_groups }
+}
+
+// ---------------------------------------------------------------------------
+// Weights
+// ---------------------------------------------------------------------------
+
+struct ResidualMlpWeights {
+    l1_w: Tensor, l1_b: Tensor,
+    l2_w: Tensor, l2_b: Tensor,
+    skip_w: Tensor, skip_b: Tensor,
+    tau: f64,
+    is_output: bool, // true → use LinearReadout scale (1/fan_in) for l2 and skip
+}
+
+struct BlockWeights {
+    attn_qkv_w: Tensor,
+    attn_qkv_b: Option<Tensor>,
+    attn_out_w: Tensor,
+    attn_out_b: Option<Tensor>,
+    attn_pds: Option<Tensor>, // [qk_dim] raw param
+    attn_tau: f64,
+    ffn_up_w: Tensor,
+    ffn_down_w: Tensor,
+    mlp_tau: f64,
+}
+
+// ---------------------------------------------------------------------------
+// Model
+// ---------------------------------------------------------------------------
+
+pub struct TotoModel {
+    device: Device,
+    pub config: InferConfig,
+    rope: RopeCache,
+    patch_proj: ResidualMlpWeights,
+    blocks: Vec<BlockWeights>,
+    output_head: ResidualMlpWeights,
+}
+
+// ---------------------------------------------------------------------------
+// GGUF loading helpers (free functions to avoid multiple &mut borrows)
+// ---------------------------------------------------------------------------
+
+fn load_tensor(
+    content: &gguf_file::Content,
+    reader: &mut (impl Read + Seek),
+    name: &str,
+    device: &Device,
+    dtype: DType,
+) -> Result<Tensor> {
+    let qt = content
+        .tensor(reader, name, device)
+        .with_context(|| format!("load tensor '{name}'"))?;
+    Ok(qt.dequantize(device)?.to_dtype(dtype)?)
+}
+
+fn try_load_tensor(
+    content: &gguf_file::Content,
+    reader: &mut (impl Read + Seek),
+    name: &str,
+    device: &Device,
+    dtype: DType,
+) -> Result<Option<Tensor>> {
+    match content.tensor(reader, name, device) {
+        Ok(qt) => Ok(Some(qt.dequantize(device)?.to_dtype(dtype)?)),
+        Err(_) => Ok(None),
+    }
+}
+
+/// Compute attn_tau and mlp_tau for each layer using the transformer residual scaling rule.
+///
+/// This reproduces `uu.transformer_residual_scaling_rule` + the per-layer buffer assignment
+/// from `SelfAttentionTransformerLayer.__init__` in the Python model.
+fn compute_taus(num_layers: usize, residual_mult: f64, residual_attn_ratio: f64) -> (Vec<f64>, Vec<f64>) {
+    let total_depth = 2 * num_layers;
+    let alpha_mlp = residual_mult * (2.0 / (1.0 + residual_attn_ratio.powi(2))).sqrt();
+    let alpha_attn = residual_attn_ratio * alpha_mlp;
+
+    let tau = |index: usize| -> f64 {
+        let n_attn = (index + 1) / 2;
+        let n_mlp = index / 2;
+        let num = if index % 2 == 0 { alpha_attn } else { alpha_mlp };
+        let den = (total_depth as f64 / 2.0
+            + n_attn as f64 * alpha_attn.powi(2)
+            + n_mlp as f64 * alpha_mlp.powi(2))
+        .sqrt();
+        num / den
+    };
+
+    (0..num_layers).map(|i| (tau(2 * i), tau(2 * i + 1))).unzip()
+}
+
+impl TotoModel {
+    pub fn load(gguf_path: &Path, config: InferConfig) -> Result<Self> {
+        let device = Device::Cpu;
+        let dtype = if config.compute_f64 { DType::F64 } else { DType::F32 };
+        let file = std::fs::File::open(gguf_path)
+            .with_context(|| format!("open {}", gguf_path.display()))?;
+        let mut reader = BufReader::new(file);
+        let content = gguf_file::Content::read(&mut reader)
+            .context("parse GGUF header")?;
+
+        macro_rules! ld {
+            ($name:expr) => { load_tensor(&content, &mut reader, $name, &device, dtype) };
+        }
+        macro_rules! tld {
+            ($name:expr) => { try_load_tensor(&content, &mut reader, $name, &device, dtype) };
+        }
+
+        // --- patch_proj ---
+        let patch_proj = ResidualMlpWeights {
+            l1_w: ld!("patch_proj.linear1.weight")?,
+            l1_b: ld!("patch_proj.linear1.bias")?,
+            l2_w: ld!("patch_proj.linear2.weight")?,
+            l2_b: ld!("patch_proj.linear2.bias")?,
+            skip_w: ld!("patch_proj.skip_proj.weight")?,
+            skip_b: ld!("patch_proj.skip_proj.bias")?,
+            tau: 1.0,
+            is_output: false,
+        };
+
+        // Tau values are deterministic given the config — compute rather than load
+        // (avoids candle's inability to dequantize 0-dim tensors)
+        let (attn_taus, mlp_taus) = compute_taus(
+            config.num_layers,
+            config.residual_mult,
+            config.residual_attn_ratio,
+        );
+
+        // --- transformer blocks ---
+        let mut blocks = Vec::with_capacity(config.num_layers);
+        for n in 0..config.num_layers {
+            blocks.push(BlockWeights {
+                attn_qkv_w: ld!(&format!("blk.{n}.attn_qkv.weight"))?,
+                attn_qkv_b: tld!(&format!("blk.{n}.attn_qkv.bias"))?,
+                attn_out_w: ld!(&format!("blk.{n}.attn_output.weight"))?,
+                attn_out_b: tld!(&format!("blk.{n}.attn_output.bias"))?,
+                attn_pds:   tld!(&format!("blk.{n}.attn_pds.weight"))?,
+                attn_tau: attn_taus[n],
+                ffn_up_w:   ld!(&format!("blk.{n}.ffn_up.weight"))?,
+                ffn_down_w: {
+                    let w = ld!(&format!("blk.{n}.ffn_down.weight"))?;
+                    // Q8_0 converter stores this weight transposed so candle's innermost
+                    // dim (d_model) is block-aligned. Detect by dim(0) == d_ff and flip back.
+                    if w.dim(0)? != config.d_model {
+                        w.t()?.contiguous()?
+                    } else {
+                        w
+                    }
+                },
+                mlp_tau: mlp_taus[n],
+            });
+        }
+
+        // --- output_head ---
+        let output_head = ResidualMlpWeights {
+            l1_w: ld!("output_head.linear1.weight")?,
+            l1_b: ld!("output_head.linear1.bias")?,
+            l2_w: ld!("output_head.linear2.weight")?,
+            l2_b: ld!("output_head.linear2.bias")?,
+            skip_w: ld!("output_head.skip_proj.weight")?,
+            skip_b: ld!("output_head.skip_proj.bias")?,
+            tau: 1.0,
+            is_output: true,
+        };
+
+        let rope = RopeCache::new(config.qk_dim, 8192);
+        Ok(Self { device, config, rope, patch_proj, blocks, output_head })
+    }
+
+    // -----------------------------------------------------------------------
+    // Public API
+    // -----------------------------------------------------------------------
+
+    /// Forecast from context.
+    ///
+    /// `target[n_var][ctx_len]` — observed values.
+    /// `mask[n_var][ctx_len]` — true for valid observations.
+    /// Returns `quantiles[9][n_var][prediction_length]`.
+    ///
+    /// Toto is a full-context model: the prediction region is appended to the
+    /// context as masked (all-zero) patches before the forward pass.  The model
+    /// attends over the full sequence and outputs quantiles for the future region.
+    pub fn forecast(
+        &self,
+        target: &[Vec<f32>],
+        mask: &[Vec<bool>],
+        prediction_length: usize,
+    ) -> Result<Vec<Vec<Vec<f32>>>> {
+        let n_var = target.len();
+        let ctx_len = target[0].len();
+        let patch_size = self.config.patch_size;
+
+        if ctx_len % patch_size != 0 {
+            bail!("ctx_len ({ctx_len}) must be divisible by patch_size ({patch_size})");
+        }
+        let ctx_patches = ctx_len / patch_size;
+        // Number of forecast patches needed (ceiling division)
+        let fcst_patches = (prediction_length + patch_size - 1) / patch_size;
+        let total_patches = ctx_patches + fcst_patches;
+
+        // Causal patched std scaler on context only
+        let mut locs = Vec::with_capacity(n_var);
+        let mut scales = Vec::with_capacity(n_var);
+        for v in 0..n_var {
+            let (loc, scale) = causal_patched_std_scaler(&target[v], &mask[v], patch_size);
+            locs.push(loc);
+            scales.push(scale);
+        }
+
+        // Build full input: context patches (observed) + forecast patches (masked zeros)
+        // Shape: [1, n_var, total_patches, 2*patch_size]
+        let mut patch_data = vec![0.0f32; n_var * total_patches * 2 * patch_size];
+        for v in 0..n_var {
+            // Context patches
+            for p in 0..ctx_patches {
+                let base = v * total_patches * 2 * patch_size + p * 2 * patch_size;
+                for i in 0..patch_size {
+                    let t = p * patch_size + i;
+                    let obs = mask[v][t];
+                    let val = if obs {
+                        (((target[v][t] - locs[v][t]) / scales[v][t]) as f64).asinh() as f32
+                    } else {
+                        0.0
+                    };
+                    patch_data[base + i] = val;
+                    patch_data[base + patch_size + i] = if obs { 0.0 } else { 1.0 };
+                }
+            }
+            // Forecast patches: all zeros, not observed (mask channel = 1)
+            for p in ctx_patches..total_patches {
+                let base = v * total_patches * 2 * patch_size + p * 2 * patch_size;
+                for i in 0..patch_size {
+                    patch_data[base + i] = 0.0;
+                    patch_data[base + patch_size + i] = 1.0; // not observed
+                }
+            }
+        }
+
+        let dtype = if self.config.compute_f64 { DType::F64 } else { DType::F32 };
+        let x = Tensor::from_vec(
+            patch_data,
+            (1usize, n_var, total_patches, 2 * patch_size),
+            &self.device,
+        )?.to_dtype(dtype)?;
+
+        // patch_proj (InputResidualMLP)
+        let x = self.forward_residual_mlp(&x, &self.patch_proj)?;
+
+        // transformer
+        let x = self.forward_transformer(x, n_var, total_patches)?;
+
+        // output_head (OutputResidualMLP)
+        let x = self.forward_residual_mlp(&x, &self.output_head)?;
+        // x: [1, n_var, total_patches, patch_size * 9]
+
+        // Next-patch predictor: output at position i predicts patch i+1.
+        // Python: x_out[..., -(block+1):-1] where block=fcst_patches
+        // = positions [ctx_patches-1, ctx_patches+fcst_patches-1)
+        let x = x.narrow(2, ctx_patches - 1, fcst_patches)?;
+        // x: [1, n_var, fcst_patches, patch_size * 9]
+        let fcst_steps = fcst_patches * patch_size;
+
+        // Unflatten → [1, n_var, fcst_patches, patch_size, 9]
+        let out = x.reshape((1usize, n_var, fcst_patches, patch_size, 9))?;
+        // Permute → [9, 1, n_var, fcst_patches, patch_size]
+        let out = out.permute([4, 0, 1, 2, 3])?.contiguous()?;
+        // Flatten → [9, n_var, fcst_steps]
+        let out = out.reshape((9usize, n_var, fcst_steps))?;
+
+        // Trim to exactly prediction_length (if fcst_steps > prediction_length)
+        let out = if fcst_steps > prediction_length {
+            out.narrow(2, 0, prediction_length)?
+        } else {
+            out
+        };
+        // Cast back to F32 for output (harmless if already F32)
+        let out_data = out.to_dtype(DType::F32)?.to_vec3::<f32>()?; // [9][n_var][pred_len]
+
+        // Denormalise: sinh(quantile) * scale + loc (using final-patch stats)
+        let loc_final: Vec<f32> = (0..n_var).map(|v| locs[v][ctx_len - 1]).collect();
+        let scale_final: Vec<f32> = (0..n_var).map(|v| scales[v][ctx_len - 1]).collect();
+
+        let mut result = vec![vec![vec![0.0f32; prediction_length]; n_var]; 9];
+        for q in 0..9 {
+            for v in 0..n_var {
+                for t in 0..prediction_length {
+                    let raw = out_data[q][v][t] as f64;
+                    result[q][v][t] = (raw.sinh() as f32) * scale_final[v] + loc_final[v];
+                }
+            }
+        }
+        Ok(result)
+    }
+
+    // -----------------------------------------------------------------------
+    // ResidualMLP forward
+    // -----------------------------------------------------------------------
+
+    fn forward_residual_mlp(&self, x: &Tensor, w: &ResidualMlpWeights) -> Result<Tensor> {
+        // residual_split at inference = identity; both branches see x
+        let h = uu_linear(x, &w.l1_w, Some(&w.l1_b))?;
+        let h = uu_silu(&h)?;
+
+        let h = if w.is_output {
+            uu_linear_readout(&h, &w.l2_w, Some(&w.l2_b))?
+        } else {
+            uu_linear(&h, &w.l2_w, Some(&w.l2_b))?
+        };
+
+        let skip = if w.is_output {
+            uu_linear_readout(x, &w.skip_w, Some(&w.skip_b))?
+        } else {
+            uu_linear(x, &w.skip_w, Some(&w.skip_b))?
+        };
+
+        residual_add(&h, &skip, w.tau)
+    }
+
+    // -----------------------------------------------------------------------
+    // Transformer
+    // -----------------------------------------------------------------------
+
+    fn forward_transformer(&self, mut x: Tensor, n_var: usize, num_patches: usize) -> Result<Tensor> {
+        for (idx, blk) in self.blocks.iter().enumerate() {
+            x = if self.config.is_variate_layer(idx) {
+                self.forward_variate_layer(x, blk, n_var, num_patches)?
+            } else {
+                self.forward_time_layer(x, blk, n_var, num_patches)?
+            };
+        }
+        rms_norm(&x, self.config.norm_eps)
+    }
+
+    fn forward_time_layer(
+        &self,
+        x: Tensor,
+        blk: &BlockWeights,
+        n_var: usize,
+        num_patches: usize,
+    ) -> Result<Tensor> {
+        let cfg = &self.config;
+        // [1, n_var, num_patches, d_model] → [n_var, num_patches, d_model]
+        let state = x.reshape((n_var, num_patches, cfg.d_model))?;
+
+        let skip = state.clone();
+        let normed = rms_norm(&state, cfg.norm_eps)?;
+        let seq_ids: Vec<u32> = (0..num_patches as u32).collect();
+        let attn_out = self.forward_attention(&normed, blk, &seq_ids, /*is_variate=*/false)?;
+        let state = residual_add(&attn_out, &skip, blk.attn_tau)?;
+
+        let skip = state.clone();
+        let normed = rms_norm(&state, cfg.norm_eps)?;
+        let ffn_out = self.forward_ffn(&normed, blk)?;
+        let state = residual_add(&ffn_out, &skip, blk.mlp_tau)?;
+
+        // Restore [1, n_var, num_patches, d_model]
+        Ok(state.reshape((1usize, n_var, num_patches, cfg.d_model))?)
+    }
+
+    fn forward_variate_layer(
+        &self,
+        x: Tensor,
+        blk: &BlockWeights,
+        n_var: usize,
+        num_patches: usize,
+    ) -> Result<Tensor> {
+        let cfg = &self.config;
+        // [1, n_var, num_patches, d] → [num_patches, n_var, d]
+        let state = x.permute([0, 2, 1, 3])?.contiguous()?.reshape((num_patches, n_var, cfg.d_model))?;
+
+        let skip = state.clone();
+        let normed = rms_norm(&state, cfg.norm_eps)?;
+        let attn_out = self.forward_attention(&normed, blk, &[], /*is_variate=*/true)?;
+        let state = residual_add(&attn_out, &skip, blk.attn_tau)?;
+
+        let skip = state.clone();
+        let normed = rms_norm(&state, cfg.norm_eps)?;
+        let ffn_out = self.forward_ffn(&normed, blk)?;
+        let state = residual_add(&ffn_out, &skip, blk.mlp_tau)?;
+
+        // [num_patches, n_var, d] → [1, n_var, num_patches, d]
+        Ok(state
+            .reshape((1usize, num_patches, n_var, cfg.d_model))?
+            .permute([0, 2, 1, 3])?
+            .contiguous()?)
+    }
+
+    // -----------------------------------------------------------------------
+    // Self-attention
+    // -----------------------------------------------------------------------
+
+    fn forward_attention(
+        &self,
+        state: &Tensor,
+        blk: &BlockWeights,
+        seq_ids: &[u32],
+        is_variate: bool,
+    ) -> Result<Tensor> {
+        let cfg = &self.config;
+        let (batch, seq, _d) = state.dims3()?;
+
+        // Fused QKV — narrow then contiguous (narrow on last-dim creates non-contiguous views)
+        let qkv = uu_linear(state, &blk.attn_qkv_w, blk.attn_qkv_b.as_ref())?;
+        let q = qkv.narrow(D::Minus1, 0, cfg.q_size())?.contiguous()?;
+        let k = qkv.narrow(D::Minus1, cfg.q_size(), cfg.k_size())?.contiguous()?;
+        let v = qkv.narrow(D::Minus1, cfg.q_size() + cfg.k_size(), cfg.v_size())?.contiguous()?;
+
+        // [batch, seq, heads, head_dim] → [batch, heads, seq, head_dim]
+        let q = q.reshape((batch, seq, cfg.num_heads, cfg.qk_dim))?.permute([0, 2, 1, 3])?.contiguous()?;
+        let k = k.reshape((batch, seq, cfg.num_groups, cfg.qk_dim))?.permute([0, 2, 1, 3])?.contiguous()?;
+        let v = v.reshape((batch, seq, cfg.num_groups, cfg.v_dim))?.permute([0, 2, 1, 3])?.contiguous()?;
+
+        // PerDimScale on Q
+        let q = match blk.attn_pds.as_ref() {
+            Some(pds_w) => apply_per_dim_scale(&q, pds_w)?,
+            None => q,
+        };
+
+        // xPos-RoPE (time layers only)
+        let (q, k) = if !is_variate && !seq_ids.is_empty() && cfg.use_xpos {
+            let q = self.rope.apply(&q, seq_ids, 1.0, &self.device)?;
+            let k = self.rope.apply(&k, seq_ids, -1.0, &self.device)?;
+            (q, k)
+        } else {
+            (q, k)
+        };
+
+        // MuP scale: 1/qk_dim
+        let scale = 1.0 / cfg.qk_dim as f64;
+        let scores = (q.matmul(&k.transpose(D::Minus1, D::Minus2)?)? * scale)?;
+
+        // Causal mask for time layers
+        let scores = if !is_variate {
+            apply_causal_mask(scores, seq)?
+        } else {
+            scores
+        };
+
+        let attn = ops::softmax_last_dim(&scores)?;
+        let out = attn.matmul(&v)?;
+        // [batch, heads, seq, v_dim] → [batch, seq, heads*v_dim]
+        let out = out.permute([0, 2, 1, 3])?.contiguous()?.reshape((batch, seq, cfg.num_heads * cfg.v_dim))?;
+
+        uu_linear(&out, &blk.attn_out_w, blk.attn_out_b.as_ref())
+    }
+
+    // -----------------------------------------------------------------------
+    // SwiGLU FFN
+    // -----------------------------------------------------------------------
+
+    fn forward_ffn(&self, x: &Tensor, blk: &BlockWeights) -> Result<Tensor> {
+        let fc1_out = uu_linear(x, &blk.ffn_up_w, None)?;
+        let half = fc1_out.dim(D::Minus1)? / 2;
+        let gate = fc1_out.narrow(D::Minus1, 0, half)?;
+        let val = fc1_out.narrow(D::Minus1, half, half)?;
+        // Standard F.silu (not unit-scaled) as in the Python FFN
+        let activated = (gate * ops::silu(&val)?)?;
+        uu_linear(&activated, &blk.ffn_down_w, None)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Unit-scaling ops
+// ---------------------------------------------------------------------------
+
+/// Unit-scaled linear for arbitrary batch shapes.
+///
+/// Flattens leading dims to 2D for matmul (candle doesn't broadcast 2D weights against nD inputs),
+/// then restores the original batch shape.
+fn uu_linear(x: &Tensor, w: &Tensor, b: Option<&Tensor>) -> Result<Tensor> {
+    linear_with_scale(x, w, b, 1.0 / (w.dim(1)? as f64).sqrt())
+}
+
+fn uu_linear_readout(x: &Tensor, w: &Tensor, b: Option<&Tensor>) -> Result<Tensor> {
+    linear_with_scale(x, w, b, 1.0 / w.dim(1)? as f64)
+}
+
+fn linear_with_scale(x: &Tensor, w: &Tensor, b: Option<&Tensor>, scale: f64) -> Result<Tensor> {
+    let shape = x.dims().to_vec();
+    let d_in = *shape.last().unwrap();
+    let batch: usize = shape[..shape.len() - 1].iter().product();
+    let d_out = w.dim(0)?;
+
+    let x_flat = x.reshape((batch, d_in))?;
+    let out_flat = x_flat.matmul(&w.t()?)?; // [batch, d_out]
+
+    let mut out_shape = shape[..shape.len() - 1].to_vec();
+    out_shape.push(d_out);
+    let out = out_flat.reshape(out_shape)?;
+    let out = if let Some(b) = b { out.broadcast_add(b)? } else { out };
+    Ok((out * scale)?)
+}
+
+fn uu_silu(x: &Tensor) -> Result<Tensor> {
+    Ok((ops::silu(x)? * SILU_SCALE)?)
+}
+
+fn rms_norm(x: &Tensor, eps: f64) -> Result<Tensor> {
+    let x2 = x.sqr()?;
+    let mean_x2 = x2.mean_keepdim(D::Minus1)?;
+    let rms = mean_x2.affine(1.0, eps)?.sqrt()?;
+    Ok(x.broadcast_div(&rms)?)
+}
+
+fn residual_add(h: &Tensor, skip: &Tensor, tau: f64) -> Result<Tensor> {
+    let denom = (1.0 + tau * tau).sqrt();
+    Ok(((h * (tau / denom))? + (skip * (1.0 / denom))?)?)
+}
+
+fn apply_per_dim_scale(q: &Tensor, pds_w: &Tensor) -> Result<Tensor> {
+    // Python: q * F.softplus(pds_w) / log(2)
+    // The 0.52103 unit-scaling factors cancel between uu.softplus and per_dim_scale.
+    let sp = (pds_w.exp()? + 1.0)?.log()?; // F.softplus
+    let log2 = std::f64::consts::LN_2;
+    let r = (sp / log2)?;
+    Ok(q.broadcast_mul(&r)?)
+}
+
+fn apply_causal_mask(scores: Tensor, seq: usize) -> Result<Tensor> {
+    let mut mask_data = vec![0.0f32; seq * seq];
+    for i in 0..seq {
+        for j in (i + 1)..seq {
+            mask_data[i * seq + j] = f32::NEG_INFINITY;
+        }
+    }
+    let mask = Tensor::from_vec(mask_data, (seq, seq), scores.device())?
+        .to_dtype(scores.dtype())?;
+    Ok(scores.broadcast_add(&mask)?)
+}
+
+// ---------------------------------------------------------------------------
+// Causal patched std scaler
+// ---------------------------------------------------------------------------
+
+fn causal_patched_std_scaler(
+    data: &[f32],
+    mask: &[bool],
+    patch_size: usize,
+) -> (Vec<f32>, Vec<f32>) {
+    let n = data.len();
+    let num_patches = n / patch_size;
+
+    let mut cum_count = 0.0f64;
+    let mut m1 = 0.0f64;
+    let mut m2 = 0.0f64;
+    let correction = 1.0f64;
+    let minimum_scale = 1e-6f64;
+
+    let mut patch_loc = vec![0.0f32; num_patches];
+    let mut patch_scale = vec![1e-6f32; num_patches];
+
+    for p in 0..num_patches {
+        for i in 0..patch_size {
+            let t = p * patch_size + i;
+            if mask[t] {
+                let x = data[t] as f64;
+                cum_count += 1.0;
+                let prev_m1 = m1;
+                m1 += (x - m1) / cum_count;
+                m2 += (x - prev_m1) * (x - m1);
+            }
+        }
+        patch_loc[p] = m1 as f32;
+        let denom = (cum_count - correction).max(1.0);
+        patch_scale[p] = (m2 / denom).sqrt().max(minimum_scale) as f32;
+    }
+
+    let mut loc = vec![0.0f32; n];
+    let mut scale = vec![1e-6f32; n];
+    for p in 0..num_patches {
+        for i in 0..patch_size {
+            let t = p * patch_size + i;
+            loc[t] = patch_loc[p];
+            scale[t] = patch_scale[p];
+        }
+    }
+    (loc, scale)
+}

toto-rs/src/infer/rope.rs

@@ -0,0 +1,119 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+//
+// This product includes software developed at Datadog (https://www.datadoghq.com/)
+// Copyright 2026 Datadog, Inc.
+
+use anyhow::Result;
+use candle_core::{Device, Tensor, D};
+
+/// Precomputed RoPE (with xPos scaling) for a partial head dimension.
+///
+/// Applied to the first `proj_width` dims of each head.
+/// For the 2.5B model: `partial_factor=(0.0, 0.5)` → `proj_width = qk_dim/2 = 32`.
+pub struct RopeCache {
+    pub proj_width: usize,
+    cos: Vec<Vec<f32>>,         // [max_len][proj_width]
+    sin: Vec<Vec<f32>>,         // [max_len][proj_width]
+    xpos_base_scale: Vec<f32>,  // [proj_width/2]
+}
+
+impl RopeCache {
+    pub fn new(qk_dim: usize, max_len: usize) -> Self {
+        let proj_width = qk_dim / 2; // partial_factor (0.0, 0.5)
+        let half = proj_width / 2;
+        let base = 10000_f32;
+
+        let theta: Vec<f32> = (0..half)
+            .map(|i| 1.0 / base.powf(2.0 * i as f32 / proj_width as f32))
+            .collect();
+
+        let mut cos = vec![vec![0.0f32; proj_width]; max_len];
+        let mut sin = vec![vec![0.0f32; proj_width]; max_len];
+        for m in 0..max_len {
+            for i in 0..half {
+                let angle = m as f32 * theta[i];
+                cos[m][2 * i] = angle.cos();
+                cos[m][2 * i + 1] = angle.cos();
+                sin[m][2 * i] = angle.sin();
+                sin[m][2 * i + 1] = angle.sin();
+            }
+        }
+
+        // xPos base scale: (2i + 0.4*proj_width) / (1.4*proj_width)
+        let xpos_base_scale: Vec<f32> = (0..half)
+            .map(|i| ((2 * i) as f32 + 0.4 * proj_width as f32) / (1.4 * proj_width as f32))
+            .collect();
+
+        Self { proj_width, cos, sin, xpos_base_scale }
+    }
+
+    /// Apply xPos-RoPE to query or key.
+    ///
+    /// `x`: `[batch, heads, seq, qk_dim]` — first `proj_width` dims are rotated.
+    /// `seq_ids`: position index per sequence step.
+    /// `xpos_exponent`: +1.0 for query, -1.0 for key.
+    pub fn apply(
+        &self,
+        x: &Tensor,
+        seq_ids: &[u32],
+        xpos_exponent: f32,
+        device: &Device,
+    ) -> Result<Tensor> {
+        let qk_dim = x.dim(D::Minus1)?;
+        let proj_width = self.proj_width;
+        let half = proj_width / 2;
+        let seq_len = seq_ids.len();
+
+        let max_pos = seq_ids.iter().copied().max().unwrap_or(0) as f32;
+        let center = ((max_pos as u32 + 1) / 2) as f32;
+
+        let mut cos_data = vec![0.0f32; seq_len * proj_width];
+        let mut sin_data = vec![0.0f32; seq_len * proj_width];
+        for (si, &pos) in seq_ids.iter().enumerate() {
+            let power = (pos as f32 - center) / 256.0; // xpos_scale_base = 256
+            for i in 0..half {
+                let xpos_s = self.xpos_base_scale[i].powf(power).powf(xpos_exponent);
+                let c = self.cos[pos as usize][2 * i] * xpos_s;
+                let s = self.sin[pos as usize][2 * i] * xpos_s;
+                cos_data[si * proj_width + 2 * i] = c;
+                cos_data[si * proj_width + 2 * i + 1] = c;
+                sin_data[si * proj_width + 2 * i] = s;
+                sin_data[si * proj_width + 2 * i + 1] = s;
+            }
+        }
+
+        // [1, 1, seq, proj_width] for broadcasting; cast to match x dtype (e.g. F64)
+        let pos_cos = Tensor::from_vec(cos_data, (1usize, 1, seq_len, proj_width), device)?
+            .to_dtype(x.dtype())?;
+        let pos_sin = Tensor::from_vec(sin_data, (1usize, 1, seq_len, proj_width), device)?
+            .to_dtype(x.dtype())?;
+
+        // Split rotated vs pass-through dims
+        let x_rot = x.narrow(D::Minus1, 0, proj_width)?;
+        let rot_x = rotate_half(&x_rot, proj_width)?;
+        let rotated = (x_rot.broadcast_mul(&pos_cos)? + rot_x.broadcast_mul(&pos_sin)?)?;
+
+        let result = if qk_dim > proj_width {
+            let x_pass = x.narrow(D::Minus1, proj_width, qk_dim - proj_width)?.contiguous()?;
+            Tensor::cat(&[&rotated, &x_pass], D::Minus1)?
+        } else {
+            rotated
+        };
+        Ok(result.contiguous()?)
+    }
+}
+
+/// rotate_half: [a0, b0, a1, b1, ...] → [-b0, a0, -b1, a1, ...]
+fn rotate_half(x: &Tensor, proj_width: usize) -> Result<Tensor> {
+    let half = proj_width / 2;
+    let mut shape = x.dims().to_vec();
+    let last = shape.len() - 1;
+    shape[last] = half;
+    shape.push(2);
+    let x_pairs = x.reshape(shape)?;
+    let x1 = x_pairs.narrow(D::Minus1, 0, 1)?;
+    let x2 = x_pairs.narrow(D::Minus1, 1, 1)?;
+    let rotated = Tensor::cat(&[&x2.neg()?, &x1], D::Minus1)?;
+    let out_shape = x.dims().to_vec();
+    Ok(rotated.reshape(out_shape)?)
+}

toto-rs/src/main.rs

@@ -0,0 +1,290 @@
+mod config;
+mod convert;
+mod download;
+mod gguf;
+mod infer;
+mod tensor_map;
+mod upload;
+
+use std::path::PathBuf;
+
+use anyhow::Context;
+use clap::{Parser, Subcommand, ValueEnum};
+
+use config::TotoConfig;
+use convert::{convert, ConvertOptions};
+use download::download_model;
+use gguf::GGMLType;
+use infer::{InferConfig, TotoModel};
+
+#[derive(Parser)]
+#[command(name = "toto-rs", about = "Convert and run Datadog/Toto-2.0-2.5B")]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    /// Upload source + GGUF files to HuggingFace Hub.
+    Upload {
+        /// HuggingFace repo to upload to (owner/name).
+        #[arg(short, long, default_value = "amaye15/toto-gguf")]
+        repo: String,
+        /// HuggingFace API token (or set HF_TOKEN env var).
+        #[arg(long, env = "HF_TOKEN")]
+        token: String,
+    },
+    /// Download a Toto model from HuggingFace and convert it to GGUF.
+    Convert {
+        #[arg(short, long, default_value = "Datadog/Toto-2.0-2.5B")]
+        model: String,
+        #[arg(short, long, default_value = "toto.gguf")]
+        output: PathBuf,
+        #[arg(long, default_value = "f16")]
+        dtype: DtypeArg,
+        #[arg(long, default_value = "models")]
+        model_dir: PathBuf,
+        #[arg(long, env = "HF_TOKEN")]
+        token: Option<String>,
+    },
+    /// Print all tensor names in a local safetensors file.
+    InspectTensors {
+        path: PathBuf,
+    },
+    /// Run Toto-2 time-series forecasting from a GGUF file.
+    ///
+    /// Reads CSV input (header + one column per variate).
+    /// Prints 9-quantile forecasts as CSV to stdout.
+    Infer {
+        /// Path to the GGUF file.
+        #[arg(short, long, default_value = "toto.gguf")]
+        gguf: PathBuf,
+
+        /// Path to config.json from the original HuggingFace model.
+        #[arg(long, default_value = "models/config.json")]
+        config: PathBuf,
+
+        /// CSV file: header row + one column per variate, one row per timestep.
+        /// Use '-' to read from stdin.
+        #[arg(short, long)]
+        input: PathBuf,
+
+        /// Number of future timesteps to forecast.
+        #[arg(short, long, default_value = "64")]
+        prediction_length: usize,
+
+        /// Context length fed to the model (must be divisible by patch_size=32).
+        /// Defaults to the last 4096 timesteps (or all if shorter).
+        #[arg(long)]
+        context_length: Option<usize>,
+
+        /// Run the forward pass in F64 (double precision) to match PyTorch
+        /// numerical accuracy. Uses ~2× memory. Default: F32.
+        #[arg(long = "f64", default_value_t = false)]
+        use_f64: bool,
+    },
+}
+
+#[derive(Clone, ValueEnum)]
+enum DtypeArg {
+    F32,
+    F16,
+    Bf16,
+    Q8,
+}
+
+impl From<DtypeArg> for GGMLType {
+    fn from(d: DtypeArg) -> Self {
+        match d {
+            DtypeArg::F32 => GGMLType::F32,
+            DtypeArg::F16 => GGMLType::F16,
+            DtypeArg::Bf16 => GGMLType::BF16,
+            DtypeArg::Q8 => GGMLType::Q8_0,
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        Command::Upload { repo, token } => {
+            let crate_root = std::env::current_dir().context("current dir")?;
+            let model_root = crate_root.parent()
+                .map(|p| p.to_path_buf())
+                .unwrap_or(crate_root);
+            upload::run(&repo, &token, &model_root).await?;
+        }
+
+        Command::Convert { model, output, dtype, model_dir, token } => {
+            println!("Downloading {model} into {} …", model_dir.display());
+            let files = download_model(&model, token.as_deref(), &model_dir)
+                .await
+                .context("download failed")?;
+
+            let config_str = std::fs::read_to_string(&files.config_json)
+                .context("read config.json")?;
+            let config = TotoConfig::from_json(&config_str)
+                .context("parse config.json")?;
+
+            println!(
+                "Config: {} layers, hidden={}, heads={}",
+                config.num_hidden_layers, config.hidden_size, config.num_attention_heads
+            );
+
+            let opts = ConvertOptions { output_dtype: dtype.into() };
+            convert(&model, &files, &config, &opts, &output)?;
+            println!("Wrote {}", output.display());
+        }
+
+        Command::InspectTensors { path } => {
+            let bytes = std::fs::read(&path)
+                .with_context(|| format!("read {}", path.display()))?;
+            let tensors = safetensors::SafeTensors::deserialize(&bytes)
+                .context("deserialize safetensors")?;
+            println!("Tensors in {}:", path.display());
+            let mut names: Vec<_> = tensors.names().into_iter().collect();
+            names.sort();
+            for name in names {
+                let t = tensors.tensor(name).unwrap();
+                println!("  {name:60} {:?} {:?}", t.dtype(), t.shape());
+            }
+        }
+
+        Command::Infer { gguf, config, input, prediction_length, context_length, use_f64 } => {
+            // Load model config
+            let config_str = std::fs::read_to_string(&config)
+                .with_context(|| format!("read {}", config.display()))?;
+            let toto_config: serde_json::Value = serde_json::from_str(&config_str)?;
+
+            let infer_config = InferConfig {
+                d_model: toto_config["d_model"].as_u64().unwrap_or(2048) as usize,
+                num_layers: toto_config["num_layers"].as_u64().unwrap_or(48) as usize,
+                num_heads: toto_config["num_heads"].as_u64().unwrap_or(32) as usize,
+                num_groups: toto_config["num_groups"].as_u64().unwrap_or(32) as usize,
+                qk_dim: toto_config["qk_dim"].as_u64().unwrap_or(64) as usize,
+                v_dim: toto_config["v_dim"].as_u64().unwrap_or(64) as usize,
+                patch_size: toto_config["patch_size"].as_u64().unwrap_or(32) as usize,
+                norm_eps: toto_config["norm_eps"].as_f64().unwrap_or(5e-4),
+                layer_group_size: toto_config["layer_group_size"].as_u64().unwrap_or(48) as usize,
+                num_variate_layers_per_group: toto_config["num_variate_layers_per_group"]
+                    .as_u64().unwrap_or(1) as usize,
+                variate_layer_first: toto_config["variate_layer_first"].as_bool().unwrap_or(false),
+                use_xpos: toto_config["use_xpos"].as_bool().unwrap_or(true),
+                residual_mult: toto_config["residual_mult"].as_f64().unwrap_or(0.75),
+                residual_attn_ratio: toto_config["residual_attn_ratio"].as_f64().unwrap_or(5.136215466577748),
+                compute_f64: use_f64,
+            };
+
+            let patch_size = infer_config.patch_size;
+
+            // Read CSV input
+            let csv_str = if input.as_os_str() == "-" {
+                use std::io::Read;
+                let mut s = String::new();
+                std::io::stdin().read_to_string(&mut s)?;
+                s
+            } else {
+                std::fs::read_to_string(&input)
+                    .with_context(|| format!("read {}", input.display()))?
+            };
+
+            let (mut data, header) = parse_csv(&csv_str)?;
+            let n_var = data.len();
+            let total_len = data[0].len();
+
+            // Determine context window
+            let ctx_len = {
+                let max_ctx = context_length.unwrap_or(4096);
+                let usable = total_len.min(max_ctx);
+                // Round down to nearest multiple of patch_size
+                (usable / patch_size) * patch_size
+            };
+            if ctx_len == 0 {
+                anyhow::bail!(
+                    "Context length is 0. Need at least {patch_size} timesteps."
+                );
+            }
+
+            // Trim to context window (last ctx_len points)
+            let start = total_len.saturating_sub(ctx_len);
+            for v in 0..n_var {
+                data[v] = data[v][start..].to_vec();
+            }
+
+            // All-observed mask
+            let mask: Vec<Vec<bool>> = (0..n_var)
+                .map(|_| vec![true; ctx_len])
+                .collect();
+
+            eprintln!(
+                "Loading model from {} …",
+                gguf.display()
+            );
+            let model = TotoModel::load(&gguf, infer_config)
+                .context("load model")?;
+
+            eprintln!(
+                "Running inference: {n_var} variate(s), {ctx_len} context steps → \
+                 {prediction_length} forecast steps"
+            );
+            let quantiles = model.forecast(&data, &mask, prediction_length)
+                .context("forecast")?;
+            // quantiles: [9][n_var][prediction_length]
+
+            // Print CSV header
+            let quantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9];
+            let mut cols = Vec::new();
+            for q in quantile_levels {
+                for v in &header {
+                    cols.push(format!("{v}_q{q:.1}"));
+                }
+            }
+            println!("{}", cols.join(","));
+
+            // Print forecast rows
+            for t in 0..prediction_length {
+                let mut row = Vec::new();
+                for qi in 0..9 {
+                    for v in 0..n_var {
+                        row.push(format!("{:.6}", quantiles[qi][v][t]));
+                    }
+                }
+                println!("{}", row.join(","));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Parse CSV: first row is header, remaining rows are timestep values.
+/// Returns `(data[n_var][timesteps], header[n_var])`.
+fn parse_csv(csv: &str) -> anyhow::Result<(Vec<Vec<f32>>, Vec<String>)> {
+    let mut lines = csv.lines();
+    let header_line = lines.next().context("CSV is empty")?;
+    let headers: Vec<String> = header_line.split(',').map(|s| s.trim().to_string()).collect();
+    let n_var = headers.len();
+
+    let mut data: Vec<Vec<f32>> = vec![Vec::new(); n_var];
+    for (row_idx, line) in lines.enumerate() {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let fields: Vec<&str> = line.split(',').collect();
+        if fields.len() != n_var {
+            anyhow::bail!(
+                "Row {row_idx}: expected {n_var} columns, got {}",
+                fields.len()
+            );
+        }
+        for (v, f) in fields.iter().enumerate() {
+            let val: f32 = f.trim().parse()
+                .with_context(|| format!("row {row_idx}, col {v}: {:?}", f.trim()))?;
+            data[v].push(val);
+        }
+    }
+    Ok((data, headers))
+}

toto-rs/src/tensor_map.rs

@@ -0,0 +1,136 @@
+/// Convert a Toto HuggingFace tensor name to the GGUF blk.N convention.
+/// Returns `None` for unrecognised names (caller will warn and skip them).
+///
+/// Actual tensor names were confirmed by running `inspect-tensors` on the
+/// downloaded model.safetensors checkpoint.
+pub fn map_tensor_name(hf_name: &str) -> Option<String> {
+    // --- patch projection (two-layer MLP with skip connection) ---
+    match hf_name {
+        "patch_proj.linear1.weight" => return Some("patch_proj.linear1.weight".into()),
+        "patch_proj.linear1.bias"   => return Some("patch_proj.linear1.bias".into()),
+        "patch_proj.linear2.weight" => return Some("patch_proj.linear2.weight".into()),
+        "patch_proj.linear2.bias"   => return Some("patch_proj.linear2.bias".into()),
+        "patch_proj.skip_proj.weight" => return Some("patch_proj.skip_proj.weight".into()),
+        "patch_proj.skip_proj.bias"   => return Some("patch_proj.skip_proj.bias".into()),
+        _ => {}
+    }
+
+    // --- output head projection (two-layer MLP with skip connection) ---
+    match hf_name {
+        "output_head.param_projection.proj.linear1.weight" =>
+            return Some("output_head.linear1.weight".into()),
+        "output_head.param_projection.proj.linear1.bias" =>
+            return Some("output_head.linear1.bias".into()),
+        "output_head.param_projection.proj.linear2.weight" =>
+            return Some("output_head.linear2.weight".into()),
+        "output_head.param_projection.proj.linear2.bias" =>
+            return Some("output_head.linear2.bias".into()),
+        "output_head.param_projection.proj.skip_proj.weight" =>
+            return Some("output_head.skip_proj.weight".into()),
+        "output_head.param_projection.proj.skip_proj.bias" =>
+            return Some("output_head.skip_proj.bias".into()),
+        _ => {}
+    }
+
+    // --- per-block tensors ---
+    // Pattern: transformer.layers.{N}.<suffix>
+    let rest = hf_name.strip_prefix("transformer.layers.")?;
+    let (block_str, suffix) = rest.split_once('.')?;
+    let block: u32 = block_str.parse().ok()?;
+
+    let gguf_suffix = map_block_suffix(suffix)?;
+    Some(format!("blk.{block}.{gguf_suffix}"))
+}
+
+fn map_block_suffix(suffix: &str) -> Option<&'static str> {
+    Some(match suffix {
+        // Fused QKV projection
+        "attn.in_proj.weight"  => "attn_qkv.weight",
+        "attn.in_proj.bias"    => "attn_qkv.bias",
+        // Output projection
+        "attn.out_proj.weight" => "attn_output.weight",
+        "attn.out_proj.bias"   => "attn_output.bias",
+        // Per-dimension scale (Toto-specific learned scaling)
+        "attn._pds.per_dim_scale" => "attn_pds.weight",
+        // Attention temperature (learned scalar per block)
+        "attn_tau" => "attn_tau",
+        // Feed-forward
+        "ffn.fc1.weight" => "ffn_up.weight",
+        "ffn.fc1.bias"   => "ffn_up.bias",
+        "ffn.fc2.weight" => "ffn_down.weight",
+        "ffn.fc2.bias"   => "ffn_down.bias",
+        // MLP temperature (learned scalar per block)
+        "mlp_tau" => "mlp_tau",
+        _ => return None,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn patch_proj() {
+        assert_eq!(
+            map_tensor_name("patch_proj.linear1.weight"),
+            Some("patch_proj.linear1.weight".into())
+        );
+        assert_eq!(
+            map_tensor_name("patch_proj.skip_proj.bias"),
+            Some("patch_proj.skip_proj.bias".into())
+        );
+    }
+
+    #[test]
+    fn block_attn_qkv() {
+        assert_eq!(
+            map_tensor_name("transformer.layers.0.attn.in_proj.weight"),
+            Some("blk.0.attn_qkv.weight".into())
+        );
+    }
+
+    #[test]
+    fn block_attn_pds() {
+        assert_eq!(
+            map_tensor_name("transformer.layers.3.attn._pds.per_dim_scale"),
+            Some("blk.3.attn_pds.weight".into())
+        );
+    }
+
+    #[test]
+    fn block_attn_tau() {
+        assert_eq!(
+            map_tensor_name("transformer.layers.47.attn_tau"),
+            Some("blk.47.attn_tau".into())
+        );
+    }
+
+    #[test]
+    fn block_ffn() {
+        assert_eq!(
+            map_tensor_name("transformer.layers.12.ffn.fc1.weight"),
+            Some("blk.12.ffn_up.weight".into())
+        );
+        assert_eq!(
+            map_tensor_name("transformer.layers.12.ffn.fc2.weight"),
+            Some("blk.12.ffn_down.weight".into())
+        );
+    }
+
+    #[test]
+    fn output_head() {
+        assert_eq!(
+            map_tensor_name("output_head.param_projection.proj.linear2.weight"),
+            Some("output_head.linear2.weight".into())
+        );
+        assert_eq!(
+            map_tensor_name("output_head.param_projection.proj.skip_proj.bias"),
+            Some("output_head.skip_proj.bias".into())
+        );
+    }
+
+    #[test]
+    fn unknown_returns_none() {
+        assert_eq!(map_tensor_name("some.unknown.tensor"), None);
+    }
+}

toto-rs/src/upload.rs

@@ -0,0 +1,533 @@
+use std::io::Read;
+use std::path::{Path, PathBuf};
+
+use anyhow::Context;
+use base64::Engine as _;
+use futures_util::StreamExt;
+use indicatif::{ProgressBar, ProgressStyle};
+use sha2::{Digest, Sha256};
+use tokio_util::io::ReaderStream;
+
+const HF_BASE: &str = "https://huggingface.co";
+const PREUPLOAD_SAMPLE: usize = 512;
+
+const SKIP_DIRS: &[&str] = &["target", ".git", "__pycache__", ".venv", "models"];
+
+struct RegularFile {
+    remote: String,
+    content_b64: String,
+}
+
+struct LfsFile {
+    local: PathBuf,
+    remote: String,
+    size: u64,
+    oid: String, // sha256 hex
+}
+
+pub async fn run(repo_id: &str, token: &str, root: &Path) -> anyhow::Result<()> {
+    let client = build_client(token)?;
+
+    ensure_repo(&client, repo_id).await?;
+
+    let files = gather_files(root)?;
+    println!("Gathered {} file(s) to upload …", files.len());
+
+    let (regular, lfs) = classify_files(&client, repo_id, &files).await?;
+    println!("  {} regular, {} LFS", regular.len(), lfs.len());
+
+    if !lfs.is_empty() {
+        upload_lfs(&client, repo_id, &lfs).await?;
+    }
+
+    make_commit(&client, repo_id, &regular, &lfs).await?;
+
+    println!("Uploaded → https://huggingface.co/{repo_id}");
+    Ok(())
+}
+
+fn build_client(token: &str) -> anyhow::Result<reqwest::Client> {
+    let mut headers = reqwest::header::HeaderMap::new();
+    headers.insert(
+        reqwest::header::AUTHORIZATION,
+        format!("Bearer {token}").parse().context("invalid HF token")?,
+    );
+    headers.insert(
+        reqwest::header::USER_AGENT,
+        "toto-rs/0.1".parse().unwrap(),
+    );
+    Ok(reqwest::Client::builder().default_headers(headers).build()?)
+}
+
+async fn ensure_repo(client: &reqwest::Client, repo_id: &str) -> anyhow::Result<()> {
+    let name = repo_id.split('/').nth(1).context("repo_id must be owner/name")?;
+    let resp: reqwest::Response = client
+        .post(format!("{HF_BASE}/api/repos/create"))
+        .json(&serde_json::json!({ "name": name, "type": "model", "private": false }))
+        .send()
+        .await
+        .context("create repo")?;
+
+    let status = resp.status();
+    if status.is_success() {
+        println!("Created repo {repo_id}");
+    } else if status.as_u16() == 409 {
+        // already exists — fine
+    } else {
+        let body: String = resp.text().await.unwrap_or_default();
+        anyhow::bail!("create repo: HTTP {status}: {body}");
+    }
+    Ok(())
+}
+
+/// Ask HF which files need LFS vs regular inline upload, then prepare both lists.
+async fn classify_files(
+    client: &reqwest::Client,
+    repo_id: &str,
+    files: &[(PathBuf, String)],
+) -> anyhow::Result<(Vec<RegularFile>, Vec<LfsFile>)> {
+    // Build preupload request
+    let mut preupload_entries: Vec<serde_json::Value> = Vec::new();
+    for (local, remote) in files {
+        let size = std::fs::metadata(local)
+            .with_context(|| format!("stat {}", local.display()))?
+            .len();
+        let sample = {
+            let bytes = std::fs::read(local)
+                .with_context(|| format!("read {}", local.display()))?;
+            let n = bytes.len().min(PREUPLOAD_SAMPLE);
+            base64::engine::general_purpose::STANDARD.encode(&bytes[..n])
+        };
+        preupload_entries.push(serde_json::json!({
+            "path": remote,
+            "size": size,
+            "sample": sample,
+        }));
+    }
+
+    let url = format!("{HF_BASE}/api/models/{repo_id}/preupload/main");
+    let resp: reqwest::Response = client
+        .post(&url)
+        .json(&serde_json::json!({ "files": preupload_entries }))
+        .send()
+        .await
+        .context("preupload request")?;
+
+    let status = resp.status();
+    if !status.is_success() {
+        let body: String = resp.text().await.unwrap_or_default();
+        anyhow::bail!("preupload: HTTP {status}: {body}");
+    }
+
+    #[derive(serde::Deserialize)]
+    struct PreuploadFile {
+        path: String,
+        #[serde(rename = "uploadMode")]
+        upload_mode: String,
+        #[serde(rename = "shouldIgnore", default)]
+        should_ignore: bool,
+    }
+    #[derive(serde::Deserialize)]
+    struct PreuploadResp { files: Vec<PreuploadFile> }
+
+    let preupload: PreuploadResp = resp.json().await.context("parse preupload response")?;
+    let modes: std::collections::HashMap<String, (String, bool)> = preupload.files
+        .into_iter()
+        .map(|f| (f.path, (f.upload_mode, f.should_ignore)))
+        .collect();
+
+    let mut regular: Vec<RegularFile> = Vec::new();
+    let mut lfs: Vec<LfsFile> = Vec::new();
+
+    for (local, remote) in files {
+        let (mode, _should_ignore) = modes
+            .get(remote)
+            .map(|(m, s)| (m.as_str(), *s))
+            .unwrap_or(("regular", false));
+        if mode == "lfs" {
+            let size = std::fs::metadata(local)?.len();
+            let oid = sha256_file(local)?;
+            lfs.push(LfsFile { local: local.clone(), remote: remote.clone(), size, oid });
+        } else {
+            let bytes = std::fs::read(local)
+                .with_context(|| format!("read {}", local.display()))?;
+            let content_b64 = base64::engine::general_purpose::STANDARD.encode(&bytes);
+            regular.push(RegularFile { remote: remote.clone(), content_b64 });
+        }
+    }
+
+    Ok((regular, lfs))
+}
+
+fn gather_files(root: &Path) -> anyhow::Result<Vec<(PathBuf, String)>> {
+    let mut out = Vec::new();
+    walk_dir(root, "", &mut out)?;
+    Ok(out)
+}
+
+fn walk_dir(dir: &Path, prefix: &str, out: &mut Vec<(PathBuf, String)>) -> anyhow::Result<()> {
+    let mut entries: Vec<_> = std::fs::read_dir(dir)
+        .with_context(|| format!("read_dir {}", dir.display()))?
+        .collect::<Result<_, _>>()?;
+    entries.sort_by_key(|e| e.file_name());
+    for entry in entries {
+        let path = entry.path();
+        let name = entry
+            .file_name()
+            .into_string()
+            .map_err(|_| anyhow::anyhow!("non-UTF-8 filename"))?;
+        if SKIP_DIRS.contains(&name.as_str()) {
+            continue;
+        }
+        let remote = if prefix.is_empty() { name.clone() } else { format!("{prefix}/{name}") };
+        if path.is_file() {
+            out.push((path, remote));
+        } else if path.is_dir() {
+            walk_dir(&path, &remote, out)?;
+        }
+    }
+    Ok(())
+}
+
+fn sha256_file(path: &Path) -> anyhow::Result<String> {
+    let mut f =
+        std::fs::File::open(path).with_context(|| format!("open {}", path.display()))?;
+    let mut hasher = Sha256::new();
+    let mut buf = vec![0u8; 8 * 1024 * 1024];
+    loop {
+        let n = f.read(&mut buf)?;
+        if n == 0 {
+            break;
+        }
+        hasher.update(&buf[..n]);
+    }
+    Ok(format!("{:x}", hasher.finalize()))
+}
+
+async fn upload_lfs(
+    client: &reqwest::Client,
+    repo_id: &str,
+    files: &[LfsFile],
+) -> anyhow::Result<()> {
+    let objects: Vec<_> = files
+        .iter()
+        .map(|f| serde_json::json!({ "oid": f.oid, "size": f.size }))
+        .collect();
+
+    // Request both multipart (for files >5 GB) and basic transfers
+    let url = format!("{HF_BASE}/{repo_id}.git/info/lfs/objects/batch");
+    let lfs_body = serde_json::to_string(&serde_json::json!({
+        "operation": "upload",
+        "transfers": ["multipart", "basic"],
+        "objects": objects,
+    }))?;
+    let resp: reqwest::Response = client
+        .post(&url)
+        .header("Content-Type", "application/vnd.git-lfs+json")
+        .header("Accept", "application/vnd.git-lfs+json")
+        .body(lfs_body)
+        .send()
+        .await
+        .context("LFS batch request")?;
+
+    let status = resp.status();
+    if !status.is_success() {
+        let body: String = resp.text().await.unwrap_or_default();
+        anyhow::bail!("LFS batch: HTTP {status}: {body}");
+    }
+
+    #[derive(serde::Deserialize)]
+    struct BatchResp {
+        objects: Vec<serde_json::Value>,
+    }
+    let batch: BatchResp = resp.json().await.context("parse LFS batch response")?;
+
+    for (file, obj) in files.iter().zip(batch.objects.iter()) {
+        let Some(upload_href) =
+            obj.pointer("/actions/upload/href").and_then(|v: &serde_json::Value| v.as_str())
+        else {
+            println!("  (already on LFS) {}", file.remote);
+            continue;
+        };
+
+        // Multipart if the server provided chunk_size in the header
+        let is_multipart = obj.pointer("/actions/upload/header/chunk_size").is_some();
+
+        if is_multipart {
+            upload_lfs_object_multipart(file, upload_href, obj).await
+                .with_context(|| format!("upload (multipart) {}", file.remote))?;
+        } else {
+            upload_lfs_object(file, upload_href, obj).await
+                .with_context(|| format!("upload {}", file.remote))?;
+        }
+
+        // Verify step (optional but recommended by Git LFS spec)
+        if let Some(verify_href) =
+            obj.pointer("/actions/verify/href").and_then(|v: &serde_json::Value| v.as_str())
+        {
+            let verify_headers = obj
+                .pointer("/actions/verify/header")
+                .and_then(|v: &serde_json::Value| v.as_object())
+                .cloned()
+                .unwrap_or_default();
+
+            let mut vreq: reqwest::RequestBuilder = reqwest::Client::new()
+                .post(verify_href)
+                .header("Content-Type", "application/vnd.git-lfs+json")
+                .json(&serde_json::json!({ "oid": file.oid, "size": file.size }));
+            for (k, v) in &verify_headers {
+                if let Some(val) = v.as_str() {
+                    vreq = vreq.header(k.as_str(), val);
+                }
+            }
+            let vresp: reqwest::Response = vreq.send().await.context("LFS verify")?;
+            if !vresp.status().is_success() {
+                eprintln!("  Warning: LFS verify returned {}", vresp.status());
+            }
+        }
+    }
+
+    Ok(())
+}
+
+async fn upload_lfs_object(
+    file: &LfsFile,
+    href: &str,
+    obj: &serde_json::Value,
+) -> anyhow::Result<()> {
+    let pb = ProgressBar::new(file.size);
+    pb.set_style(
+        ProgressStyle::with_template(
+            "  {msg} [{bar:40}] {bytes}/{total_bytes} ({bytes_per_sec}, eta {eta})",
+        )
+        .unwrap()
+        .progress_chars("=>-"),
+    );
+    pb.set_message(file.remote.clone());
+
+    let f = tokio::fs::File::open(&file.local)
+        .await
+        .with_context(|| format!("open {}", file.local.display()))?;
+
+    let pb2 = pb.clone();
+    let stream = ReaderStream::new(f).map(move |chunk| {
+        if let Ok(ref b) = chunk {
+            pb2.inc(b.len() as u64);
+        }
+        chunk
+    });
+
+    // LFS upload goes to S3 / Azure — use a plain client (no HF auth header)
+    let mut req = reqwest::Client::new()
+        .put(href)
+        .header("Content-Length", file.size.to_string());
+
+    if let Some(extra) = obj.pointer("/actions/upload/header").and_then(|v| v.as_object()) {
+        for (k, v) in extra {
+            if let Some(val) = v.as_str() {
+                req = req.header(k.as_str(), val);
+            }
+        }
+    }
+
+    let resp = req
+        .body(reqwest::Body::wrap_stream(stream))
+        .send()
+        .await
+        .context("PUT LFS object")?;
+
+    pb.finish_and_clear();
+
+    let status = resp.status();
+    if !status.is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("LFS PUT HTTP {status}: {body}");
+    }
+
+    Ok(())
+}
+
+async fn upload_lfs_object_multipart(
+    file: &LfsFile,
+    complete_href: &str,
+    obj: &serde_json::Value,
+) -> anyhow::Result<()> {
+    use tokio::io::AsyncReadExt;
+
+    let header = obj
+        .pointer("/actions/upload/header")
+        .and_then(|v| v.as_object())
+        .ok_or_else(|| anyhow::anyhow!("no header in multipart LFS response"))?;
+
+    let chunk_size: usize = header
+        .get("chunk_size")
+        .and_then(|v| v.as_str())
+        .and_then(|s| s.parse().ok())
+        .ok_or_else(|| anyhow::anyhow!("missing chunk_size in multipart header"))?;
+
+    // Collect part URLs sorted numerically by key ("00001", "00002", …)
+    let mut parts: Vec<(u32, String)> = header
+        .iter()
+        .filter_map(|(k, v)| {
+            let n: u32 = k.parse().ok()?;
+            Some((n, v.as_str()?.to_string()))
+        })
+        .collect();
+    parts.sort_by_key(|(n, _)| *n);
+
+    let pb = ProgressBar::new(file.size);
+    pb.set_style(
+        ProgressStyle::with_template(
+            "  {msg} [{bar:40}] {bytes}/{total_bytes} ({bytes_per_sec}, eta {eta})",
+        )
+        .unwrap()
+        .progress_chars("=>-"),
+    );
+    pb.set_message(file.remote.clone());
+
+    let mut f = tokio::fs::File::open(&file.local)
+        .await
+        .with_context(|| format!("open {}", file.local.display()))?;
+
+    let s3 = reqwest::Client::new(); // plain client — S3 parts use pre-signed URLs
+    let mut etags: Vec<(u32, String)> = Vec::with_capacity(parts.len());
+
+    for (part_num, url) in &parts {
+        // Read up to chunk_size bytes for this part
+        let mut buf = vec![0u8; chunk_size];
+        let mut pos = 0;
+        while pos < chunk_size {
+            let n = f.read(&mut buf[pos..]).await?;
+            if n == 0 { break; }
+            pos += n;
+        }
+        if pos == 0 { break; }
+        buf.truncate(pos);
+        let len = buf.len();
+
+        // Retry up to 3 times on transient connection errors
+        const MAX_RETRIES: usize = 3;
+        let mut last_err: Option<anyhow::Error> = None;
+        let mut etag_opt: Option<String> = None;
+        for attempt in 0..MAX_RETRIES {
+            if attempt > 0 {
+                tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+                eprintln!("  Retrying part {part_num} (attempt {})…", attempt + 1);
+            }
+            match s3
+                .put(url.as_str())
+                .header("Content-Length", len.to_string())
+                .body(buf.clone())
+                .send()
+                .await
+            {
+                Err(e) => {
+                    last_err = Some(anyhow::anyhow!("PUT part {part_num}: {e}"));
+                }
+                Ok(resp) => {
+                    let status = resp.status();
+                    let tag = resp.headers().get("etag")
+                        .and_then(|v| v.to_str().ok())
+                        .map(|s| s.to_string());
+                    if status.is_success() {
+                        if let Some(t) = tag {
+                            etag_opt = Some(t);
+                            last_err = None;
+                            break;
+                        } else {
+                            last_err = Some(anyhow::anyhow!("PUT part {part_num}: no ETag in response"));
+                        }
+                    } else {
+                        let body = resp.text().await.unwrap_or_default();
+                        last_err = Some(anyhow::anyhow!("PUT part {part_num}: HTTP {status}: {body}"));
+                    }
+                }
+            }
+        }
+        let etag = etag_opt.ok_or_else(|| {
+            last_err.unwrap_or_else(|| anyhow::anyhow!("PUT part {part_num}: exhausted retries"))
+        })?;
+
+        pb.inc(len as u64);
+        etags.push((*part_num, etag));
+    }
+
+    pb.finish_and_clear();
+
+    // Tell HF to assemble the parts on S3
+    let parts_json: Vec<serde_json::Value> = etags
+        .iter()
+        .map(|(n, e)| serde_json::json!({ "partNumber": n, "etag": e }))
+        .collect();
+
+    let resp = s3
+        .post(complete_href)
+        .json(&serde_json::json!({ "oid": file.oid, "parts": parts_json }))
+        .send()
+        .await
+        .context("complete multipart")?;
+
+    let status = resp.status();
+    if !status.is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("complete multipart: HTTP {status}: {body}");
+    }
+
+    Ok(())
+}
+
+async fn make_commit(
+    client: &reqwest::Client,
+    repo_id: &str,
+    regular: &[RegularFile],
+    lfs: &[LfsFile],
+) -> anyhow::Result<()> {
+    let mut lines: Vec<String> = Vec::new();
+
+    lines.push(serde_json::to_string(&serde_json::json!({
+        "key": "header",
+        "value": { "summary": "Upload model files", "description": "" },
+    }))?);
+
+    for rf in regular {
+        lines.push(serde_json::to_string(&serde_json::json!({
+            "key": "file",
+            "value": {
+                "path": rf.remote,
+                "encoding": "base64",
+                "content": rf.content_b64,
+            },
+        }))?);
+    }
+
+    for lf in lfs {
+        lines.push(serde_json::to_string(&serde_json::json!({
+            "key": "lfsFile",
+            "value": {
+                "path": lf.remote,
+                "algo": "sha256",
+                "oid": lf.oid,
+                "size": lf.size,
+            },
+        }))?);
+    }
+
+    let body = lines.join("\n");
+
+    let url = format!("{HF_BASE}/api/models/{repo_id}/commit/main");
+    let resp = client
+        .post(&url)
+        .header("Content-Type", "application/x-ndjson")
+        .body(body)
+        .send()
+        .await
+        .context("POST commit")?;
+
+    let status = resp.status();
+    if !status.is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("commit: HTTP {status}: {body}");
+    }
+
+    Ok(())
+}