LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M12: lightcraft-segment: Apache-2.0, checked weights, pure-Rust model download
Brandon Thomasb52f43d1d50f
diff --git a/.gitignore b/.gitignoreindex 823f92765..51531a34b 100644--- a/.gitignore+++ b/.gitignore@@ -8,3 +8,6 @@ plan/.DS_Store.claude//craft-fonts+# model weights are never committed (SAM 3: docs/ai-masks.md)+*.safetensors+*.safetensors.partdiff --git a/Cargo.lock b/Cargo.lockindex 6a07ead6b..3f0861610 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -146,6 +146,41 @@ version = "2.0.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"+[[package]]+name = "aead"+version = "0.5.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"+dependencies = [+ "crypto-common",+ "generic-array",+]++[[package]]+name = "aes"+version = "0.8.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"+dependencies = [+ "cfg-if",+ "cipher",+ "cpufeatures",+]++[[package]]+name = "aes-gcm"+version = "0.10.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"+dependencies = [+ "aead",+ "aes",+ "cipher",+ "ctr",+ "ghash",+ "subtle",+]+[[package]]name = "ahash"version = "0.8.12"@@ -543,6 +578,18 @@ dependencies = ["windows-link",]+[[package]]+name = "base16ct"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"++[[package]]+name = "base64ct"+version = "1.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"+[[package]]name = "bit-set"version = "0.8.0"@@ -600,6 +647,15 @@ version = "0.1.6"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"+[[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 = "block2"version = "0.5.1"@@ -771,7 +827,7 @@ dependencies = ["num_cpus","objc2-foundation 0.3.2","objc2-metal 0.3.2",- "rand",+ "rand 0.9.5","rand_distr","rayon","safetensors 0.7.0",@@ -856,6 +912,41 @@ dependencies = ["libc",]+[[package]]+name = "chacha20"+version = "0.9.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"+dependencies = [+ "cfg-if",+ "cipher",+ "cpufeatures",+]++[[package]]+name = "chacha20poly1305"+version = "0.10.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"+dependencies = [+ "aead",+ "chacha20",+ "cipher",+ "poly1305",+ "zeroize",+]++[[package]]+name = "cipher"+version = "0.4.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"+dependencies = [+ "crypto-common",+ "inout",+ "zeroize",+]+[[package]]name = "clipboard-win"version = "5.4.1"@@ -910,6 +1001,12 @@ dependencies = ["crossbeam-utils",]+[[package]]+name = "const-oid"+version = "0.9.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"+[[package]]name = "core-foundation"version = "0.9.4"@@ -950,6 +1047,15 @@ dependencies = ["libc",]+[[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.2"@@ -999,12 +1105,81 @@ version = "0.2.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"+[[package]]+name = "crypto-bigint"+version = "0.5.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"+dependencies = [+ "generic-array",+ "rand_core 0.6.4",+ "subtle",+ "zeroize",+]++[[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 = "ctr"+version = "0.9.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"+dependencies = [+ "cipher",+]+[[package]]name = "cursor-icon"version = "1.2.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"+[[package]]+name = "curve25519-dalek"+version = "4.1.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"+dependencies = [+ "cfg-if",+ "cpufeatures",+ "curve25519-dalek-derive",+ "digest",+ "fiat-crypto",+ "rustc_version",+ "subtle",+ "zeroize",+]++[[package]]+name = "curve25519-dalek-derive"+version = "0.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "der"+version = "0.7.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"+dependencies = [+ "const-oid",+ "pem-rfc7468",+ "zeroize",+]+[[package]]name = "dhat"version = "0.3.3"@@ -1021,6 +1196,18 @@ dependencies = ["thousands",]+[[package]]+name = "digest"+version = "0.10.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"+dependencies = [+ "block-buffer",+ "const-oid",+ "crypto-common",+ "subtle",+]+[[package]]name = "dispatch"version = "0.2.0"@@ -1085,6 +1272,20 @@ version = "0.1.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9"+[[package]]+name = "ecdsa"+version = "0.16.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"+dependencies = [+ "der",+ "digest",+ "elliptic-curve",+ "rfc6979",+ "signature",+ "spki",+]+[[package]]name = "ecolor"version = "0.36.2"@@ -1095,6 +1296,30 @@ dependencies = ["emath",]+[[package]]+name = "ed25519"+version = "2.2.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"+dependencies = [+ "pkcs8",+ "signature",+]++[[package]]+name = "ed25519-dalek"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "70e796c081cee67dc755e1a36a0a172b897fab85fc3f6bc48307991f64e4eca9"+dependencies = [+ "curve25519-dalek",+ "ed25519",+ "serde",+ "sha2",+ "subtle",+ "zeroize",+]+[[package]]name = "eframe"version = "0.36.2"@@ -1212,6 +1437,27 @@ version = "1.18.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"+[[package]]+name = "elliptic-curve"+version = "0.13.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"+dependencies = [+ "base16ct",+ "crypto-bigint",+ "digest",+ "ff",+ "generic-array",+ "group",+ "hkdf",+ "pem-rfc7468",+ "pkcs8",+ "rand_core 0.6.4",+ "sec1",+ "subtle",+ "zeroize",+]+[[package]]name = "emath"version = "0.36.2"@@ -1389,6 +1635,22 @@ version = "0.4.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693"+[[package]]+name = "ff"+version = "0.13.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"+dependencies = [+ "rand_core 0.6.4",+ "subtle",+]++[[package]]+name = "fiat-crypto"+version = "0.2.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"+[[package]]name = "find-msvc-tools"version = "0.1.14"@@ -1414,7 +1676,7 @@ checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5"dependencies = ["half","num-traits",- "rand",+ "rand 0.9.5","rand_distr",]@@ -1759,6 +2021,17 @@ dependencies = ["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",+ "zeroize",+]+[[package]]name = "gethostname"version = "1.1.0"@@ -1769,6 +2042,17 @@ dependencies = ["windows-link",]+[[package]]+name = "getrandom"+version = "0.2.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"+dependencies = [+ "cfg-if",+ "libc",+ "wasi",+]+[[package]]name = "getrandom"version = "0.3.4"@@ -1792,6 +2076,16 @@ dependencies = ["r-efi 6.0.0",]+[[package]]+name = "ghash"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"+dependencies = [+ "opaque-debug",+ "polyval",+]+[[package]]name = "gif"version = "0.14.2"@@ -1927,6 +2221,17 @@ dependencies = ["windows",]+[[package]]+name = "group"+version = "0.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"+dependencies = [+ "ff",+ "rand_core 0.6.4",+ "subtle",+]+[[package]]name = "guillotiere"version = "0.7.0"@@ -1946,7 +2251,7 @@ dependencies = ["cfg-if","crunchy","num-traits",- "rand",+ "rand 0.9.5","rand_distr","zerocopy",]@@ -2003,6 +2308,24 @@ version = "0.4.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"+[[package]]+name = "hkdf"+version = "0.12.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"+dependencies = [+ "hmac",+]++[[package]]+name = "hmac"+version = "0.12.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"+dependencies = [+ "digest",+]+[[package]]name = "image"version = "0.25.10"@@ -2048,6 +2371,15 @@ dependencies = ["hashbrown 0.17.1",]+[[package]]+name = "inout"+version = "0.1.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"+dependencies = [+ "generic-array",+]+[[package]]name = "interpolate_name"version = "0.2.4"@@ -2397,6 +2729,9 @@ name = "lazy_static"version = "1.5.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"+dependencies = [+ "spin",+][[package]]name = "libc"@@ -2705,9 +3040,13 @@ dependencies = ["candle-core","candle-nn","log",+ "rustls",+ "rustls-rustcrypto","serde","serde_json",+ "sha2","thiserror 2.0.21",+ "webpki-roots",][[package]]@@ -3065,6 +3404,22 @@ dependencies = ["num-traits",]+[[package]]+name = "num-bigint-dig"+version = "0.8.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7"+dependencies = [+ "lazy_static",+ "libm",+ "num-integer",+ "num-iter",+ "num-traits",+ "rand 0.8.8",+ "smallvec",+ "zeroize",+]+[[package]]name = "num-complex"version = "0.4.6"@@ -3496,6 +3851,12 @@ version = "1.21.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"+[[package]]+name = "opaque-debug"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"+[[package]]name = "orbclient"version = "0.3.55"@@ -3534,6 +3895,30 @@ dependencies = ["ttf-parser",]+[[package]]+name = "p256"+version = "0.13.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b"+dependencies = [+ "ecdsa",+ "elliptic-curve",+ "primeorder",+ "sha2",+]++[[package]]+name = "p384"+version = "0.13.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6"+dependencies = [+ "ecdsa",+ "elliptic-curve",+ "primeorder",+ "sha2",+]+[[package]]name = "parking"version = "2.2.1"@@ -3575,6 +3960,15 @@ version = "0.1.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"+[[package]]+name = "pem-rfc7468"+version = "0.7.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"+dependencies = [+ "base64ct",+]+[[package]]name = "peniko"version = "0.6.1"@@ -3674,6 +4068,38 @@ dependencies = ["futures-io",]+[[package]]+name = "pkcs1"+version = "0.7.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"+dependencies = [+ "der",+ "pkcs8",+ "spki",+]++[[package]]+name = "pkcs5"+version = "0.7.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e847e2c91a18bfa887dd028ec33f2fe6f25db77db3619024764914affe8b69a6"+dependencies = [+ "der",+ "spki",+]++[[package]]+name = "pkcs8"+version = "0.10.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"+dependencies = [+ "der",+ "pkcs5",+ "spki",+]+[[package]]name = "pkg-config"version = "0.3.34"@@ -3725,6 +4151,17 @@ version = "1.0.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "bc6355899e1c9462875b6757c79f3caa011a1fdae12bbb1a2e72dd1f234f8336"+[[package]]+name = "poly1305"+version = "0.8.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"+dependencies = [+ "cpufeatures",+ "opaque-debug",+ "universal-hash",+]+[[package]]name = "polycool"version = "0.4.0"@@ -3734,6 +4171,18 @@ dependencies = ["arrayvec",]+[[package]]+name = "polyval"+version = "0.6.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"+dependencies = [+ "cfg-if",+ "cpufeatures",+ "opaque-debug",+ "universal-hash",+]+[[package]]name = "portable-atomic"version = "1.15.0"@@ -3764,6 +4213,15 @@ version = "0.3.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"+[[package]]+name = "primeorder"+version = "0.13.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"+dependencies = [+ "elliptic-curve",+]+[[package]]name = "proc-macro-crate"version = "3.5.0"@@ -3811,8 +4269,8 @@ dependencies = ["bit-vec 0.8.0","bitflags 2.13.2","num-traits",- "rand",- "rand_chacha",+ "rand 0.9.5",+ "rand_chacha 0.9.0","rand_xorshift","regex-syntax","rusty-fork",@@ -3914,14 +4372,34 @@ version = "6.0.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"+[[package]]+name = "rand"+version = "0.8.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"+dependencies = [+ "rand_chacha 0.3.1",+ "rand_core 0.6.4",+]+[[package]]name = "rand"version = "0.9.5"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"dependencies = [- "rand_chacha",- "rand_core",+ "rand_chacha 0.9.0",+ "rand_core 0.9.5",+]++[[package]]+name = "rand_chacha"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"+dependencies = [+ "ppv-lite86",+ "rand_core 0.6.4",][[package]]@@ -3931,7 +4409,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"dependencies = ["ppv-lite86",- "rand_core",+ "rand_core 0.9.5",+]++[[package]]+name = "rand_core"+version = "0.6.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"+dependencies = [+ "getrandom 0.2.17",][[package]]@@ -3950,7 +4437,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"dependencies = ["num-traits",- "rand",+ "rand 0.9.5",][[package]]@@ -3959,7 +4446,7 @@ version = "0.4.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"dependencies = [- "rand_core",+ "rand_core 0.9.5",][[package]]@@ -3995,8 +4482,8 @@ dependencies = ["num-traits","paste","profiling",- "rand",- "rand_chacha",+ "rand 0.9.5",+ "rand_chacha 0.9.0","simd_helpers","thiserror 2.0.21","v_frame",@@ -4121,6 +4608,16 @@ version = "1.1.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"+[[package]]+name = "rfc6979"+version = "0.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"+dependencies = [+ "hmac",+ "subtle",+]+[[package]]name = "rfd"version = "0.17.2"@@ -4154,6 +4651,41 @@ version = "0.8.53"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4"+[[package]]+name = "ring"+version = "0.17.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"+dependencies = [+ "cc",+ "cfg-if",+ "getrandom 0.2.17",+ "libc",+ "untrusted",+ "windows-sys 0.52.0",+]++[[package]]+name = "rsa"+version = "0.9.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d"+dependencies = [+ "const-oid",+ "digest",+ "num-bigint-dig",+ "num-integer",+ "num-traits",+ "pkcs1",+ "pkcs8",+ "rand_core 0.6.4",+ "sha2",+ "signature",+ "spki",+ "subtle",+ "zeroize",+]+[[package]]name = "rustc-demangle"version = "0.1.28"@@ -4207,6 +4739,80 @@ dependencies = ["windows-sys 0.61.2",]+[[package]]+name = "rustls"+version = "0.23.45"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"+dependencies = [+ "once_cell",+ "rustls-pki-types",+ "rustls-webpki 0.103.15",+ "subtle",+ "zeroize",+]++[[package]]+name = "rustls-pki-types"+version = "1.15.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"+dependencies = [+ "zeroize",+]++[[package]]+name = "rustls-rustcrypto"+version = "0.0.2-alpha"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f12052947763ab8515f753315357599e9b0b4dab3b8ba15f30f725fe6d025557"+dependencies = [+ "aead",+ "aes-gcm",+ "chacha20poly1305",+ "crypto-common",+ "der",+ "digest",+ "ecdsa",+ "ed25519-dalek",+ "hmac",+ "p256",+ "p384",+ "paste",+ "pkcs8",+ "rand_core 0.6.4",+ "rsa",+ "rustls",+ "rustls-pki-types",+ "rustls-webpki 0.102.8",+ "sec1",+ "sha2",+ "signature",+ "x25519-dalek",+]++[[package]]+name = "rustls-webpki"+version = "0.102.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"+dependencies = [+ "ring",+ "rustls-pki-types",+ "untrusted",+]++[[package]]+name = "rustls-webpki"+version = "0.103.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"+dependencies = [+ "ring",+ "rustls-pki-types",+ "untrusted",+]+[[package]]name = "rustversion"version = "1.0.23"@@ -4267,6 +4873,20 @@ version = "1.2.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"+[[package]]+name = "sec1"+version = "0.7.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"+dependencies = [+ "base16ct",+ "der",+ "generic-array",+ "pkcs8",+ "subtle",+ "zeroize",+]+[[package]]name = "self_cell"version = "1.3.0"@@ -4348,6 +4968,17 @@ dependencies = ["serde_core",]+[[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 = "2.0.1"@@ -4364,6 +4995,16 @@ dependencies = ["libc",]+[[package]]+name = "signature"+version = "2.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"+dependencies = [+ "digest",+ "rand_core 0.6.4",+]+[[package]]name = "simd-adler32"version = "0.3.10"@@ -4504,6 +5145,12 @@ dependencies = ["serde",]+[[package]]+name = "spin"+version = "0.9.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e"+[[package]]name = "spirv"version = "0.4.0+sdk-1.4.341.0"@@ -4513,6 +5160,16 @@ dependencies = ["bitflags 2.13.2",]+[[package]]+name = "spki"+version = "0.7.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"+dependencies = [+ "base64ct",+ "der",+]+[[package]]name = "stable_deref_trait"version = "1.2.1"@@ -4525,6 +5182,12 @@ version = "1.1.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"+[[package]]+name = "subtle"+version = "2.6.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"+[[package]]name = "syn"version = "2.0.119"@@ -4778,6 +5441,12 @@ version = "0.12.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e"+[[package]]+name = "typenum"+version = "1.20.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"+[[package]]name = "uds_windows"version = "1.2.1"@@ -4854,6 +5523,22 @@ version = "0.2.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"+[[package]]+name = "universal-hash"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"+dependencies = [+ "crypto-common",+ "subtle",+]++[[package]]+name = "untrusted"+version = "0.9.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"+[[package]]name = "uuid"version = "1.26.1"@@ -4928,6 +5613,12 @@ dependencies = ["winapi-util",]+[[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.4+wasi-0.2.12"@@ -5148,6 +5839,15 @@ dependencies = ["wasm-bindgen",]+[[package]]+name = "webpki-roots"+version = "1.0.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"+dependencies = [+ "rustls-pki-types",+]+[[package]]name = "weezl"version = "0.1.12"@@ -5729,6 +6429,17 @@ version = "0.13.2"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"+[[package]]+name = "x25519-dalek"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"+dependencies = [+ "curve25519-dalek",+ "rand_core 0.6.4",+ "zeroize",+]+[[package]]name = "xcursor"version = "0.3.11"@@ -5969,6 +6680,26 @@ dependencies = ["synstructure 0.14.0",]+[[package]]+name = "zeroize"+version = "1.9.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879"+dependencies = [+ "zeroize_derive",+]++[[package]]+name = "zeroize_derive"+version = "1.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]+[[package]]name = "zip"version = "7.2.0"diff --git a/crates/segment/Cargo.toml b/crates/segment/Cargo.tomlindex 336b052fe..bd7b0d665 100644--- a/crates/segment/Cargo.toml+++ b/crates/segment/Cargo.toml@@ -2,7 +2,7 @@name = "lightcraft-segment"version.workspace = trueedition.workspace = true-license.workspace = true+license = "Apache-2.0"description = "LightCraft segmentation: SAM 3 (Segment Anything with Concepts) inference in pure Rust (L3)"[lints]@@ -18,6 +18,10 @@ log = { workspace = true }[target.'cfg(not(target_arch = "wasm32"))'.dependencies]candle-core = { workspace = true }candle-nn = { workspace = true }+rustls = { version = "0.23", default-features = false, features = ["std", "tls12"] }+rustls-rustcrypto = "0.0.2-alpha"+webpki-roots = "1"+sha2 = { version = "0.10", default-features = false, features = ["std"] }[target.'cfg(target_os = "macos")'.dependencies]candle-core = { workspace = true, features = ["metal"] }diff --git a/crates/segment/src/clip.rs b/crates/segment/src/clip.rsindex c392d5c5f..b69c148a4 100644--- a/crates/segment/src/clip.rs+++ b/crates/segment/src/clip.rs@@ -1,5 +1,9 @@//! The CLIP text encoder (24 layers, 1024 wide, causal) that turns a prompt into the token//! features SAM 3's detector attends to.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`models/sam3/modeling_sam3.py`, CLIP text model), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use candle_core::{Device, Module, Tensor};use candle_nn::{Embedding, LayerNorm, VarBuilder};diff --git a/crates/segment/src/detector.rs b/crates/segment/src/detector.rsindex b21b32d84..7c4eccbd3 100644--- a/crates/segment/src/detector.rs+++ b/crates/segment/src/detector.rs@@ -1,6 +1,10 @@//! Text prompts (SAM 3's concept detector): the prompt's CLIP features fused into the image//! features by a DETR encoder, 200 object queries refined by a DETR decoder (with box//! relative-position bias and a presence token), per-query masks from a pixel decoder.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`models/sam3/modeling_sam3.py`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use candle_core::{D, Device, IndexOp, Module, Tensor};use candle_nn::{Conv2d, Conv2dConfig, GroupNorm, LayerNorm, Linear, VarBuilder};diff --git a/crates/segment/src/fetch/http.rs b/crates/segment/src/fetch/http.rsnew file mode 100644index 000000000..332f01477--- /dev/null+++ b/crates/segment/src/fetch/http.rs@@ -0,0 +1,541 @@+//! A small HTTP/1.1 GET client for model downloads, in pure Rust: `std::net` sockets and, for+//! `https://`, rustls with the RustCrypto provider (`rustls-rustcrypto`; no `ring` or+//! `aws-lc-rs`, so nothing is compiled from C or assembly) and the Mozilla root certificates+//! (`webpki-roots`).+//!+//! Only what a large-file download needs: one request per connection (`Connection: close`),+//! `Range` requests for resuming, redirects (followed by the caller), `Content-Length`,+//! chunked and read-to-close bodies. Every read waits at most `stall` for data and checks the+//! cancel flag at least twice a second, so a dead server or a cancelled download never hangs+//! the downloading thread. No proxies (see docs/ai-masks.md).++use std::io::{ErrorKind, Read, Write};+use std::net::{TcpStream, ToSocketAddrs};+use std::sync::Arc;+use std::sync::atomic::{AtomicBool, Ordering};+use std::time::{Duration, Instant};++/// Why a request failed.+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum HttpError {+ /// The URL can't be used (scheme, host, characters).+ BadUrl(String),+ /// Name resolution or connecting failed (or took longer than the connect timeout).+ Connect(String),+ /// No data arrived for the stall timeout.+ Stalled,+ /// The cancel flag was raised.+ Cancelled,+ /// TLS failed (certificate, handshake).+ Tls(String),+ /// The server's response could not be understood.+ Protocol(String),+ /// Any other I/O error.+ Io(String),+}++impl std::fmt::Display for HttpError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ HttpError::BadUrl(e) => write!(f, "unusable URL: {e}"),+ HttpError::Connect(e) => write!(f, "could not connect: {e}"),+ HttpError::Stalled => write!(f, "the server stopped sending data"),+ HttpError::Cancelled => write!(f, "cancelled"),+ HttpError::Tls(e) => write!(f, "secure connection failed: {e}"),+ HttpError::Protocol(e) => write!(f, "unexpected response: {e}"),+ HttpError::Io(e) => write!(f, "{e}"),+ }+ }+}++/// A parsed `http://` or `https://` URL.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct Url {+ pub tls: bool,+ pub host: String,+ pub port: u16,+ /// Path and query, starting with `/`.+ pub path: String,+}++impl Url {+ pub fn parse(s: &str) -> Result<Url, HttpError> {+ let bad = |why: &str| HttpError::BadUrl(format!("{s}: {why}"));+ let s = s.trim();+ if s.chars().any(|c| c.is_control() || c == ' ') {+ return Err(bad("contains spaces or control characters"));+ }+ let (tls, rest) = if let Some(r) = s.strip_prefix("https://") {+ (true, r)+ } else if let Some(r) = s.strip_prefix("http://") {+ (false, r)+ } else {+ return Err(bad("only http:// and https:// are supported"));+ };+ let rest = rest.split('#').next().unwrap_or_default();+ let (authority, path) = match rest.find(['/', '?']) {+ Some(i) => (rest.get(..i).unwrap_or_default(), rest.get(i..).unwrap_or_default()),+ None => (rest, ""),+ };+ let path = if path.starts_with('/') { path.to_string() } else { format!("/{path}") };+ if authority.contains('@') {+ return Err(bad("user names and passwords in URLs are not supported"));+ }+ let (host, port) = if let Some(v6) = authority.strip_prefix('[') {+ let end = v6.find(']').ok_or_else(|| bad("unterminated IPv6 address"))?;+ let host = v6.get(..end).unwrap_or_default();+ let after = v6.get(end + 1..).unwrap_or_default();+ (host.to_string(), after.strip_prefix(':'))+ } else {+ match authority.rsplit_once(':') {+ Some((h, p)) => (h.to_string(), Some(p)),+ None => (authority.to_string(), None),+ }+ };+ let port = match port {+ Some(p) => p.parse::<u16>().ok().filter(|p| *p != 0).ok_or_else(|| bad("bad port"))?,+ None if tls => 443,+ None => 80,+ };+ if host.is_empty() || !host.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '.' | ':' | '_')) {+ return Err(bad("bad host name"));+ }+ Ok(Url { tls, host: host.to_ascii_lowercase(), port, path })+ }++ /// `Location` of a redirect, resolved against this URL.+ pub fn join(&self, location: &str) -> Result<Url, HttpError> {+ let l = location.trim();+ if l.starts_with("http://") || l.starts_with("https://") {+ return Url::parse(l);+ }+ // another scheme (`ftp:`, `file:`, `data:`…)+ if let Some((scheme, _)) = l.split_once(':')+ && !scheme.is_empty()+ && scheme.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))+ {+ return Err(HttpError::BadUrl(format!("redirect to an unsupported location `{scheme}:`")));+ }+ let scheme = if self.tls { "https" } else { "http" };+ let host = if self.host.contains(':') { format!("[{}]", self.host) } else { self.host.clone() };+ let base = format!("{scheme}://{host}:{}", self.port);+ if let Some(rest) = l.strip_prefix("//") {+ return Url::parse(&format!("{scheme}://{rest}"));+ }+ if l.starts_with('/') {+ return Url::parse(&format!("{base}{l}"));+ }+ // relative to the current directory+ let dir = self.path.split('?').next().unwrap_or("/");+ let dir = dir.rsplit_once('/').map_or("", |(d, _)| d);+ Url::parse(&format!("{base}{dir}/{l}"))+ }++ fn host_header(&self) -> String {+ let host = if self.host.contains(':') { format!("[{}]", self.host) } else { self.host.clone() };+ let default = if self.tls { 443 } else { 80 };+ if self.port == default { host } else { format!("{host}:{}", self.port) }+ }++ /// The URL without its query (for messages: a query may hold a signed token).+ pub fn display(&self) -> String {+ let scheme = if self.tls { "https" } else { "http" };+ format!("{scheme}://{}{}", self.host_header(), self.path.split('?').next().unwrap_or("/"))+ }+}++/// Timeouts and the cancel flag for one request.+pub struct Limits<'a> {+ pub connect: Duration,+ pub stall: Duration,+ pub cancel: &'a AtomicBool,+}++/// How often a blocked read wakes up to check the cancel flag.+const TICK: Duration = Duration::from_millis(250);+/// Longest status line + headers accepted.+const MAX_HEAD: usize = 64 * 1024;++enum Stream {+ Plain(TcpStream),+ Tls(Box<rustls::ClientConnection>, TcpStream),+}++fn is_timeout(e: &std::io::Error) -> bool {+ matches!(e.kind(), ErrorKind::WouldBlock | ErrorKind::TimedOut | ErrorKind::Interrupted)+}++fn tls_config() -> Result<Arc<rustls::ClientConfig>, HttpError> {+ let roots = rustls::RootCertStore { roots: webpki_roots::TLS_SERVER_ROOTS.to_vec() };+ let config = rustls::ClientConfig::builder_with_provider(Arc::new(rustls_rustcrypto::provider()))+ .with_safe_default_protocol_versions()+ .map_err(|e| HttpError::Tls(e.to_string()))?+ .with_root_certificates(roots)+ .with_no_client_auth();+ Ok(Arc::new(config))+}++impl Stream {+ fn connect(url: &Url, limits: &Limits) -> Result<Stream, HttpError> {+ let addrs: Vec<_> = (url.host.as_str(), url.port).to_socket_addrs().map_err(|e| HttpError::Connect(format!("{}: {e}", url.host)))?.collect();+ if addrs.is_empty() {+ return Err(HttpError::Connect(format!("{}: no address", url.host)));+ }+ let mut last = String::new();+ let mut sock = None;+ for a in addrs {+ if limits.cancel.load(Ordering::Relaxed) {+ return Err(HttpError::Cancelled);+ }+ match TcpStream::connect_timeout(&a, limits.connect) {+ Ok(s) => {+ sock = Some(s);+ break;+ }+ Err(e) => last = format!("{}: {e}", url.host),+ }+ }+ let sock = sock.ok_or(HttpError::Connect(last))?;+ sock.set_read_timeout(Some(TICK)).map_err(|e| HttpError::Io(e.to_string()))?;+ sock.set_write_timeout(Some(TICK)).map_err(|e| HttpError::Io(e.to_string()))?;+ let _ = sock.set_nodelay(true);+ if !url.tls {+ return Ok(Stream::Plain(sock));+ }+ let name = rustls::pki_types::ServerName::try_from(url.host.clone()).map_err(|e| HttpError::Tls(format!("{}: {e}", url.host)))?;+ let conn = rustls::ClientConnection::new(tls_config()?, name).map_err(|e| HttpError::Tls(e.to_string()))?;+ let mut s = Stream::Tls(Box::new(conn), sock);+ s.handshake(limits)?;+ Ok(s)+ }++ /// Wait for `f` to make progress, retrying timeouts until `stall` passes without any.+ fn retry<T>(limits: &Limits, mut f: impl FnMut() -> std::io::Result<T>) -> Result<T, HttpError> {+ let start = Instant::now();+ loop {+ if limits.cancel.load(Ordering::Relaxed) {+ return Err(HttpError::Cancelled);+ }+ match f() {+ Ok(v) => return Ok(v),+ Err(e) if is_timeout(&e) => {+ if start.elapsed() >= limits.stall {+ return Err(HttpError::Stalled);+ }+ }+ Err(e) if e.kind() == ErrorKind::InvalidData => return Err(HttpError::Tls(e.to_string())),+ Err(e) => return Err(HttpError::Io(e.to_string())),+ }+ }+ }++ fn handshake(&mut self, limits: &Limits) -> Result<(), HttpError> {+ let Stream::Tls(conn, sock) = self else { return Ok(()) };+ while conn.is_handshaking() {+ Self::retry(limits, || conn.complete_io(sock))?;+ }+ Ok(())+ }++ fn write_all(&mut self, data: &[u8], limits: &Limits) -> Result<(), HttpError> {+ match self {+ Stream::Plain(sock) => {+ let mut rest = data;+ while !rest.is_empty() {+ let n = Self::retry(limits, || sock.write(rest))?;+ if n == 0 {+ return Err(HttpError::Io("connection closed while sending the request".into()));+ }+ rest = rest.get(n..).unwrap_or_default();+ }+ Ok(())+ }+ Stream::Tls(conn, sock) => {+ // buffered by rustls, then sent as TLS records+ conn.writer().write_all(data).map_err(|e| HttpError::Tls(e.to_string()))?;+ while conn.wants_write() {+ Self::retry(limits, || conn.write_tls(sock))?;+ }+ Ok(())+ }+ }+ }++ /// Read some bytes (0 at the end of the stream), waiting at most `stall` for them.+ fn read(&mut self, buf: &mut [u8], limits: &Limits) -> Result<usize, HttpError> {+ match self {+ Stream::Plain(sock) => Self::retry(limits, || sock.read(buf)),+ Stream::Tls(conn, sock) => {+ let start = Instant::now();+ loop {+ if limits.cancel.load(Ordering::Relaxed) {+ return Err(HttpError::Cancelled);+ }+ match conn.reader().read(buf) {+ Ok(n) => return Ok(n),+ // closed without close_notify: the caller checks the length it got+ Err(e) if e.kind() == ErrorKind::UnexpectedEof => return Ok(0),+ Err(e) if e.kind() == ErrorKind::WouldBlock => {}+ Err(e) => return Err(HttpError::Tls(e.to_string())),+ }+ // no plaintext buffered: more TLS records from the socket+ match conn.read_tls(sock) {+ Ok(0) => return Ok(0),+ Ok(_) => {+ conn.process_new_packets().map_err(|e| HttpError::Tls(e.to_string()))?;+ while conn.wants_write() {+ Self::retry(limits, || conn.write_tls(sock))?;+ }+ }+ Err(e) if is_timeout(&e) => {+ if start.elapsed() >= limits.stall {+ return Err(HttpError::Stalled);+ }+ }+ Err(e) => return Err(HttpError::Io(e.to_string())),+ }+ }+ }+ }+ }+}++/// The connection with a read buffer (headers and chunk sizes are read line by line).+struct Conn {+ stream: Stream,+ buf: Vec<u8>,+ pos: usize,+}++impl Conn {+ fn fill(&mut self, limits: &Limits) -> Result<usize, HttpError> {+ if self.pos >= self.buf.len() {+ self.buf.clear();+ self.pos = 0;+ }+ let mut tmp = [0u8; 64 * 1024];+ let n = self.stream.read(&mut tmp, limits)?;+ self.buf.extend_from_slice(tmp.get(..n).unwrap_or_default());+ Ok(n)+ }++ /// One line without its CRLF; at most `max` bytes.+ fn line(&mut self, max: usize, limits: &Limits) -> Result<String, HttpError> {+ loop {+ let avail = self.buf.get(self.pos..).unwrap_or_default();+ if let Some(i) = avail.iter().position(|b| *b == b'\n') {+ let line = avail.get(..i).unwrap_or_default();+ let line = line.strip_suffix(b"\r").unwrap_or(line);+ let s = String::from_utf8_lossy(line).into_owned();+ self.pos = self.pos.saturating_add(i + 1);+ return Ok(s);+ }+ if avail.len() > max {+ return Err(HttpError::Protocol("header line too long".into()));+ }+ // keep the partial line, read more after it+ if self.pos > 0 {+ self.buf.drain(..self.pos.min(self.buf.len()));+ self.pos = 0;+ }+ let mut tmp = [0u8; 16 * 1024];+ let n = self.stream.read(&mut tmp, limits)?;+ if n == 0 {+ return Err(HttpError::Protocol("connection closed in the middle of the response".into()));+ }+ self.buf.extend_from_slice(tmp.get(..n).unwrap_or_default());+ }+ }++ /// Up to `out.len()` body bytes (0 at the end of the stream).+ fn read(&mut self, out: &mut [u8], limits: &Limits) -> Result<usize, HttpError> {+ if self.pos >= self.buf.len() && self.fill(limits)? == 0 {+ return Ok(0);+ }+ let avail = self.buf.get(self.pos..).unwrap_or_default();+ let n = avail.len().min(out.len());+ if let (Some(dst), Some(src)) = (out.get_mut(..n), avail.get(..n)) {+ dst.copy_from_slice(src);+ }+ self.pos = self.pos.saturating_add(n);+ Ok(n)+ }+}++/// A response's status, headers and body.+pub struct Response {+ pub status: u16,+ headers: Vec<(String, String)>,+ conn: Conn,+ body: BodyMode,+}++enum BodyMode {+ Length(u64),+ Chunked { left: u64, done: bool },+ Close,+ Done,+}++impl Response {+ /// The first header named `name` (case-insensitive).+ pub fn header(&self, name: &str) -> Option<&str> {+ self.headers.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v.as_str())+ }++ /// The body's length when the server announced it.+ pub fn content_length(&self) -> Option<u64> {+ match self.body {+ BodyMode::Length(n) => Some(n),+ _ => None,+ }+ }++ /// Read body bytes into `out` (0 at the end of the body).+ pub fn read(&mut self, out: &mut [u8], limits: &Limits) -> Result<usize, HttpError> {+ match &mut self.body {+ BodyMode::Done => Ok(0),+ BodyMode::Length(left) => {+ if *left == 0 {+ self.body = BodyMode::Done;+ return Ok(0);+ }+ let want = usize::try_from(*left).unwrap_or(usize::MAX).min(out.len());+ let n = self.conn.read(out.get_mut(..want).unwrap_or_default(), limits)?;+ if n == 0 {+ return Err(HttpError::Protocol("the connection closed before the end of the file".into()));+ }+ *left = left.saturating_sub(n as u64);+ Ok(n)+ }+ BodyMode::Close => {+ let n = self.conn.read(out, limits)?;+ if n == 0 {+ self.body = BodyMode::Done;+ }+ Ok(n)+ }+ BodyMode::Chunked { left, done } => {+ if *done {+ return Ok(0);+ }+ if *left == 0 {+ let line = self.conn.line(1024, limits)?;+ let hex = line.split(';').next().unwrap_or_default().trim();+ let size = u64::from_str_radix(hex, 16).map_err(|_| HttpError::Protocol(format!("bad chunk size `{hex}`")))?;+ if size == 0 {+ // trailers, up to the empty line+ let mut n = 0;+ while !self.conn.line(MAX_HEAD, limits)?.is_empty() {+ n += 1;+ if n > 100 {+ return Err(HttpError::Protocol("too many trailers".into()));+ }+ }+ *done = true;+ return Ok(0);+ }+ *left = size;+ }+ let want = usize::try_from(*left).unwrap_or(usize::MAX).min(out.len());+ let n = self.conn.read(out.get_mut(..want).unwrap_or_default(), limits)?;+ if n == 0 {+ return Err(HttpError::Protocol("the connection closed in the middle of a chunk".into()));+ }+ *left = left.saturating_sub(n as u64);+ if *left == 0 && !self.conn.line(16, limits)?.is_empty() {+ return Err(HttpError::Protocol("missing CRLF after a chunk".into()));+ }+ Ok(n)+ }+ }+ }+}++/// Send `GET url` with extra `headers` and read the status line and headers.+pub fn get(url: &Url, headers: &[(&str, String)], limits: &Limits) -> Result<Response, HttpError> {+ let mut req = format!(+ "GET {} HTTP/1.1\r\nHost: {}\r\nUser-Agent: LightCraft/{}\r\nAccept: */*\r\nAccept-Encoding: identity\r\nConnection: close\r\n",+ url.path,+ url.host_header(),+ env!("CARGO_PKG_VERSION")+ );+ for (k, v) in headers {+ if v.chars().any(|c| c == '\r' || c == '\n') || k.chars().any(|c| c == '\r' || c == '\n' || c == ':') {+ return Err(HttpError::BadUrl("header with a line break".into()));+ }+ req.push_str(&format!("{k}: {v}\r\n"));+ }+ req.push_str("\r\n");+ let mut stream = Stream::connect(url, limits)?;+ stream.write_all(req.as_bytes(), limits)?;+ let mut conn = Conn { stream, buf: Vec::new(), pos: 0 };+ let status_line = conn.line(MAX_HEAD, limits)?;+ let mut parts = status_line.split_whitespace();+ let version = parts.next().unwrap_or_default();+ if !version.starts_with("HTTP/1.") {+ return Err(HttpError::Protocol(format!("not an HTTP/1.x response: {}", status_line.chars().take(60).collect::<String>())));+ }+ let status = parts.next().and_then(|s| s.parse::<u16>().ok()).ok_or_else(|| HttpError::Protocol("bad status line".into()))?;+ let mut headers = Vec::new();+ let mut total = status_line.len();+ loop {+ let line = conn.line(MAX_HEAD, limits)?;+ if line.is_empty() {+ break;+ }+ total = total.saturating_add(line.len());+ if total > MAX_HEAD || headers.len() > 200 {+ return Err(HttpError::Protocol("response headers too large".into()));+ }+ if let Some((k, v)) = line.split_once(':') {+ headers.push((k.trim().to_string(), v.trim().to_string()));+ }+ }+ let find = |name: &str| headers.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v.as_str());+ let body = if status == 204 || status == 304 || (100..200).contains(&status) {+ BodyMode::Done+ } else if find("transfer-encoding").is_some_and(|v| v.to_ascii_lowercase().contains("chunked")) {+ BodyMode::Chunked { left: 0, done: false }+ } else if let Some(n) = find("content-length") {+ BodyMode::Length(n.trim().parse::<u64>().map_err(|_| HttpError::Protocol(format!("bad Content-Length `{n}`")))?)+ } else {+ BodyMode::Close+ };+ Ok(Response { status, headers, conn, body })+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn parses_urls() {+ let u = Url::parse("https://cdn.example.com/models/sam3/model.safetensors?sig=1#x").unwrap();+ assert_eq!((u.tls, u.host.as_str(), u.port, u.path.as_str()), (true, "cdn.example.com", 443, "/models/sam3/model.safetensors?sig=1"));+ assert_eq!(u.display(), "https://cdn.example.com/models/sam3/model.safetensors");+ let u = Url::parse("http://127.0.0.1:8080").unwrap();+ assert_eq!((u.tls, u.port, u.path.as_str()), (false, 8080, "/"));+ let u = Url::parse("http://[::1]:9/a").unwrap();+ assert_eq!((u.host.as_str(), u.port), ("::1", 9));+ for bad in ["ftp://x/y", "https://", "https://a b/", "https://u:p@h/", "http://h:0/", "http://h:99999/", "https://h/\r\nX: y", "file:///etc"]+ {+ assert!(Url::parse(bad).is_err(), "{bad}");+ }+ }++ #[test]+ fn resolves_redirects() {+ let u = Url::parse("https://a.example/x/y/file?q").unwrap();+ assert_eq!(u.join("https://b.example/z").unwrap().host, "b.example");+ assert_eq!(u.join("/root").unwrap().path, "/root");+ assert_eq!(u.join("other").unwrap().path, "/x/y/other");+ assert_eq!(u.join("//c.example/p").unwrap().host, "c.example");+ assert!(u.join("ftp://nope").is_err());+ }++ #[test]+ fn the_tls_config_builds_with_the_pure_rust_provider() {+ assert!(tls_config().is_ok());+ }+}diff --git a/crates/segment/src/fetch/mod.rs b/crates/segment/src/fetch/mod.rsnew file mode 100644index 000000000..92c5b6ea0--- /dev/null+++ b/crates/segment/src/fetch/mod.rs@@ -0,0 +1,424 @@+//! Downloading the SAM 3 model, only when the user asked for it: from an ordered list of mirrors+//! (the next one when a mirror fails), resuming partial files, with connect and stall timeouts,+//! a size cap, progress and cancellation, and checked (exact size, SHA-256 where pinned) before+//! each file is moved into the model folder. Runs on whatever thread calls [`download`] (the+//! engine uses a background thread; the UI thread never waits for the network).+//!+//! Files are written to `<name>.part` next to their final place and renamed when verified, so a+//! model folder never holds a half-written file under a real name, and an interrupted download+//! resumes from where it stopped. A file that fails its check is deleted, never kept.+//!+//! The weights are never part of LightCraft (SAM License, see docs/ai-masks.md); where they are+//! downloaded from is configured by [`DEFAULT_MIRRORS`] and the user's own list.++pub mod http;++use std::fs::{File, OpenOptions};+use std::io::{Read, Write};+use std::path::{Path, PathBuf};+use std::sync::atomic::{AtomicBool, Ordering};+use std::time::Duration;++use sha2::{Digest, Sha256};++use http::{HttpError, Limits, Url};++/// One file of the model.+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct FileSpec {+ pub name: &'static str,+ /// Exact size in bytes, when pinned (then the download resumes and is checked against it).+ pub size: Option<u64>,+ /// SHA-256 (lower-case hex), when pinned.+ pub sha256: Option<&'static str>,+ /// Largest size accepted when `size` is not pinned.+ pub max: u64,+}++/// The `facebook/sam3` checkpoint files [`crate::Sam3::load`] needs.+///+/// `model.safetensors` is pinned to the official checkpoint (Hugging Face LFS SHA-256). The two+/// tokenizer files are small text files without a pinned hash yet: they are only parsed by the+/// tokenizer (never executed) and capped in size.+// TODO(maintainer): pin `vocab.json` and `merges.txt` (size + SHA-256) when the files are+// uploaded to LightCraft's CDN.+pub const SAM3_FILES: &[FileSpec] = &[+ FileSpec { name: "vocab.json", size: None, sha256: None, max: 16 << 20 },+ FileSpec { name: "merges.txt", size: None, sha256: None, max: 16 << 20 },+ FileSpec {+ name: crate::WEIGHTS_FILE,+ size: Some(SAM3_WEIGHTS_SIZE),+ sha256: Some("6d06f0a5f84e435071fe6603e61d0b4cc7b40e0d39d487cfd4d67d8cc11cc14a"),+ max: SAM3_WEIGHTS_SIZE,+ },+];++/// Size of the official `model.safetensors` (3.44 GB).+pub const SAM3_WEIGHTS_SIZE: u64 = 3_439_938_512;++/// Where LightCraft downloads the model from, in order: each is a base URL, and file `f` is at+/// `<base>/<f>`. **Empty for now**: LightCraft has no download location of its own yet, so the+/// in-app download needs the user's list (`LIGHTCRAFT_SAM3_MIRRORS` or the mirrors file, see+/// [`mirrors`] and docs/ai-masks.md) until this is filled in.+///+/// Hugging Face's `facebook/sam3` can't be a default: it is gated (each user must accept the+/// SAM License there and download with their own token).+// TODO(maintainer): add LightCraft's CDN locations (https, primary first), e.g.+// "https://<cdn-host>/models/sam3/<revision>" — the files there must match `SAM3_FILES`.+pub const DEFAULT_MIRRORS: &[&str] = &[];++/// Environment variable with extra mirrors (base URLs separated by commas, spaces or newlines),+/// tried before the defaults.+pub const MIRRORS_ENV: &str = "LIGHTCRAFT_SAM3_MIRRORS";++/// Most mirrors used (a hostile list can't make a download loop forever).+const MAX_MIRRORS: usize = 16;+/// Redirects followed per request.+const MAX_REDIRECTS: usize = 8;++/// The mirrors to try, in order: the environment variable's, then the mirrors file's (one base+/// URL per line, `#` comments), then [`DEFAULT_MIRRORS`]; duplicates and unusable URLs dropped.+pub fn mirrors(env: Option<&str>, file: Option<&Path>) -> Vec<String> {+ let mut out: Vec<String> = Vec::new();+ let mut add = |s: &str| {+ let s = s.trim().trim_end_matches('/');+ if !s.is_empty() && Url::parse(s).is_ok() && !out.iter().any(|m| m == s) && out.len() < MAX_MIRRORS {+ out.push(s.to_string());+ }+ };+ if let Some(env) = env {+ env.split([',', ' ', '\n', '\t']).for_each(&mut add);+ }+ // a small text file; anything larger isn't a mirror list+ if let Some(text) = file.and_then(|f| std::fs::metadata(f).ok().filter(|m| m.len() < 64 * 1024).and_then(|_| std::fs::read_to_string(f).ok())) {+ text.lines().map(|l| l.split('#').next().unwrap_or_default()).for_each(&mut add);+ }+ DEFAULT_MIRRORS.iter().for_each(|m| add(m));+ out+}++/// Download settings.+#[derive(Clone, Debug)]+pub struct Options {+ /// Longest wait to connect to a mirror.+ pub connect_timeout: Duration,+ /// Longest wait for the next bytes once connected.+ pub stall_timeout: Duration,+ /// Tries per mirror and file (each resumes where the last one stopped).+ pub attempts: u32,+}++impl Default for Options {+ fn default() -> Self {+ Options { connect_timeout: Duration::from_secs(15), stall_timeout: Duration::from_secs(30), attempts: 3 }+ }+}++/// Where a download is.+#[derive(Clone, Debug, Default, PartialEq, Eq)]+pub struct Progress {+ pub file: String,+ /// Bytes of all files on disk so far, and the total expected (pinned sizes + announced ones).+ pub done: u64,+ pub total: u64,+ /// The mirror in use (without query).+ pub mirror: String,+}++/// Why a download failed.+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum DownloadError {+ /// No mirror is configured.+ NoMirrors,+ Cancelled,+ /// A local file problem (folder not writable, disk full…).+ Disk(String),+ /// Every mirror failed for `file`; the reason for each.+ AllMirrorsFailed {+ file: String,+ errors: Vec<String>,+ },+}++impl std::fmt::Display for DownloadError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ DownloadError::NoMirrors => write!(+ f,+ "no download location is configured for the SAM 3 model in this build (set {MIRRORS_ENV}, or put the files in the model folder yourself; see docs/ai-masks.md)"+ ),+ DownloadError::Cancelled => write!(f, "the download was cancelled"),+ DownloadError::Disk(e) => write!(f, "{e}"),+ DownloadError::AllMirrorsFailed { file, errors } => write!(f, "could not download {file}: {}", errors.join("; ")),+ }+ }+}++/// One mirror's failure for one file; `Retry` resumes on the same mirror.+enum Fail {+ Retry(String),+ NextMirror(String),+ Cancelled,+ Disk(String),+}++/// Download `files` into `dir` from `mirrors` (in order; see [`mirrors`]). Files already there+/// and verified are kept. `progress` is called as bytes arrive (often: throttle in it).+pub fn download(+ files: &[FileSpec],+ mirrors: &[String],+ dir: &Path,+ opts: &Options,+ cancel: &AtomicBool,+ progress: &mut dyn FnMut(&Progress),+) -> Result<(), DownloadError> {+ std::fs::create_dir_all(dir).map_err(|e| DownloadError::Disk(format!("can't create {}: {e}", dir.display())))?;+ // what's left to fetch+ let mut todo = Vec::new();+ for f in files {+ if !verified(f, &dir.join(f.name))? {+ todo.push(f);+ }+ }+ if todo.is_empty() {+ return Ok(());+ }+ if mirrors.is_empty() {+ return Err(DownloadError::NoMirrors);+ }+ let total: u64 = files.iter().map(|f| f.size.unwrap_or(0)).sum();+ let mut before: u64 = files.iter().filter(|f| !todo.contains(f)).filter_map(|f| f.size).sum();+ for f in todo {+ let mut errors = Vec::new();+ let mut ok = false;+ 'mirrors: for m in mirrors {+ let url = format!("{m}/{}", f.name);+ for _ in 0..opts.attempts.max(1) {+ if cancel.load(Ordering::Relaxed) {+ return Err(DownloadError::Cancelled);+ }+ let mut report = |n: u64, announced: u64| {+ let mirror = Url::parse(m).map(|u| u.display()).unwrap_or_default();+ progress(&Progress {+ file: f.name.to_string(),+ done: before.saturating_add(n),+ total: total.max(before.saturating_add(announced)),+ mirror,+ })+ };+ match fetch_file(f, &url, dir, opts, cancel, &mut report) {+ Ok(()) => {+ ok = true;+ break 'mirrors;+ }+ Err(Fail::Cancelled) => return Err(DownloadError::Cancelled),+ Err(Fail::Disk(e)) => return Err(DownloadError::Disk(e)),+ Err(Fail::Retry(e)) => {+ log::warn!("SAM 3 download of {url}: {e} (retrying)");+ errors.push(format!("{}: {e}", short(m)));+ }+ Err(Fail::NextMirror(e)) => {+ log::warn!("SAM 3 download of {url}: {e}");+ errors.push(format!("{}: {e}", short(m)));+ continue 'mirrors;+ }+ }+ }+ }+ if !ok {+ return Err(DownloadError::AllMirrorsFailed { file: f.name.to_string(), errors });+ }+ before = before.saturating_add(std::fs::metadata(dir.join(f.name)).map(|m| m.len()).unwrap_or(0));+ }+ Ok(())+}++/// A mirror for messages (no query string: it may hold a token).+fn short(m: &str) -> String {+ Url::parse(m).map(|u| u.display()).unwrap_or_else(|_| "mirror".into())+}++/// Whether `path` is already the right file (exact size and hash when pinned).+fn verified(f: &FileSpec, path: &Path) -> Result<bool, DownloadError> {+ let Ok(meta) = std::fs::metadata(path) else { return Ok(false) };+ if !meta.is_file() || meta.len() == 0 {+ return Ok(false);+ }+ if f.size.is_some_and(|s| s != meta.len()) || meta.len() > f.max {+ return Ok(false);+ }+ match f.sha256 {+ Some(want) => Ok(sha256_file(path).map_err(DownloadError::Disk)? == want),+ None => Ok(true),+ }+}++fn sha256_file(path: &Path) -> Result<String, String> {+ let mut file = File::open(path).map_err(|e| format!("{}: {e}", path.display()))?;+ let mut h = Sha256::new();+ let mut buf = vec![0u8; 1 << 20];+ loop {+ let n = file.read(&mut buf).map_err(|e| format!("{}: {e}", path.display()))?;+ if n == 0 {+ break;+ }+ h.update(buf.get(..n).unwrap_or_default());+ }+ Ok(h.finalize().iter().map(|b| format!("{b:02x}")).collect())+}++fn part_path(dir: &Path, name: &str) -> PathBuf {+ dir.join(format!("{name}.part"))+}++/// Fetch one file from one mirror into `<name>.part` (resuming it when its size is pinned),+/// check it and move it into place.+fn fetch_file(f: &FileSpec, url: &str, dir: &Path, opts: &Options, cancel: &AtomicBool, report: &mut dyn FnMut(u64, u64)) -> Result<(), Fail> {+ let part = part_path(dir, f.name);+ let limit = f.size.unwrap_or(f.max);+ let disk = |e: std::io::Error| Fail::Disk(format!("{}: {e}", part.display()));+ // resume only a pinned file (an unpinned one can't be checked after resuming)+ let mut have = match std::fs::metadata(&part) {+ Ok(m) if f.size.is_some() && m.len() <= limit => m.len(),+ Ok(_) => {+ std::fs::remove_file(&part).map_err(disk)?;+ 0+ }+ Err(_) => 0,+ };+ let fetched = f.size != Some(have) || have == 0;+ if fetched {+ let limits = Limits { connect: opts.connect_timeout, stall: opts.stall_timeout, cancel };+ let mut url = Url::parse(url).map_err(|e| Fail::NextMirror(e.to_string()))?;+ let origin = url.host.clone();+ let mut redirects = 0;+ let mut resp = loop {+ let mut headers = vec![];+ if have > 0 {+ headers.push(("Range", format!("bytes={have}-")));+ }+ // a token for the configured host only (never sent on to a redirect's host)+ if let Ok(t) = std::env::var("LIGHTCRAFT_SAM3_TOKEN")+ && !t.trim().is_empty()+ && url.tls+ && url.host == origin+ {+ headers.push(("Authorization", format!("Bearer {}", t.trim())));+ }+ let r = http::get(&url, &headers, &limits).map_err(http_fail)?;+ match r.status {+ 301 | 302 | 303 | 307 | 308 => {+ redirects += 1;+ if redirects > MAX_REDIRECTS {+ return Err(Fail::NextMirror("too many redirects".into()));+ }+ let loc = r.header("location").ok_or_else(|| Fail::NextMirror("redirect without a location".into()))?;+ url = url.join(loc).map_err(|e| Fail::NextMirror(e.to_string()))?;+ }+ _ => break r,+ }+ };+ let mut file = match resp.status {+ 200 => {+ // the whole file (from the start, also when a range was asked for)+ if resp.content_length().is_some_and(|n| n > limit || f.size.is_some_and(|s| s != n)) {+ return Err(Fail::NextMirror(format!("the server's file has the wrong size ({:?} bytes)", resp.content_length())));+ }+ have = 0;+ File::create(&part).map_err(disk)?+ }+ 206 if have > 0 => {+ let range = resp.header("content-range").unwrap_or_default();+ let (start, total) = parse_content_range(range).ok_or_else(|| Fail::NextMirror(format!("bad Content-Range `{range}`")))?;+ if start != have || total.is_some_and(|t| Some(t) != f.size) {+ return Err(Fail::NextMirror(format!("the server resumed at the wrong place ({range})")));+ }+ OpenOptions::new().append(true).open(&part).map_err(disk)?+ }+ 416 => {+ // the partial file doesn't fit what the server has: start over+ std::fs::remove_file(&part).map_err(disk)?;+ return Err(Fail::Retry("the partial download didn't match; starting over".into()));+ }+ 401 | 403 => return Err(Fail::NextMirror(format!("access denied (HTTP {})", resp.status))),+ 404 | 410 => return Err(Fail::NextMirror(format!("not found (HTTP {})", resp.status))),+ s if s >= 500 => return Err(Fail::Retry(format!("server error (HTTP {s})"))),+ s => return Err(Fail::NextMirror(format!("HTTP {s}"))),+ };+ let announced = f.size.unwrap_or_else(|| resp.content_length().unwrap_or(0));+ report(have, announced);+ let mut buf = vec![0u8; 256 * 1024];+ loop {+ let n = match resp.read(&mut buf, &limits) {+ Ok(n) => n,+ Err(e) => {+ let _ = file.flush();+ if f.size.is_none() {+ drop(file);+ let _ = std::fs::remove_file(&part);+ }+ return Err(http_fail(e));+ }+ };+ if n == 0 {+ break;+ }+ if have.saturating_add(n as u64) > limit {+ drop(file);+ let _ = std::fs::remove_file(&part);+ return Err(Fail::NextMirror(format!("the server sent more than the expected {limit} bytes")));+ }+ file.write_all(buf.get(..n).unwrap_or_default()).map_err(disk)?;+ have = have.saturating_add(n as u64);+ report(have, announced);+ }+ file.sync_all().map_err(disk)?;+ }+ // checks: exact size, hash+ let len = std::fs::metadata(&part).map_err(disk)?.len();+ if f.size.is_some_and(|s| s != len) {+ return Err(Fail::Retry(format!("incomplete ({len} of {} bytes)", f.size.unwrap_or(0))));+ }+ if len == 0 {+ let _ = std::fs::remove_file(&part);+ return Err(Fail::NextMirror("the server sent an empty file".into()));+ }+ if let Some(want) = f.sha256 {+ let got = sha256_file(&part).map_err(Fail::Disk)?;+ if got != want {+ std::fs::remove_file(&part).map_err(disk)?;+ let why = format!("the file is damaged or not the official one (SHA-256 {got})");+ // a damaged partial file from an earlier run isn't this mirror's fault+ return Err(if fetched { Fail::NextMirror(why) } else { Fail::Retry(why) });+ }+ }+ std::fs::rename(&part, dir.join(f.name)).map_err(disk)?;+ Ok(())+}++fn http_fail(e: HttpError) -> Fail {+ match e {+ HttpError::Cancelled => Fail::Cancelled,+ HttpError::Stalled | HttpError::Io(_) | HttpError::Protocol(_) => Fail::Retry(e.to_string()),+ HttpError::BadUrl(_) | HttpError::Connect(_) | HttpError::Tls(_) => Fail::NextMirror(e.to_string()),+ }+}++/// `bytes a-b/total` → (a, total) (`*` total → None).+fn parse_content_range(v: &str) -> Option<(u64, Option<u64>)> {+ let v = v.trim().strip_prefix("bytes")?.trim();+ let (range, total) = v.split_once('/')?;+ let (a, b) = range.split_once('-')?;+ let (a, b) = (a.trim().parse::<u64>().ok()?, b.trim().parse::<u64>().ok()?);+ if b < a {+ return None;+ }+ let total = match total.trim() {+ "*" => None,+ t => Some(t.parse::<u64>().ok()?),+ };+ Some((a, total))+}++#[cfg(test)]+mod tests;diff --git a/crates/segment/src/fetch/tests.rs b/crates/segment/src/fetch/tests.rsnew file mode 100644index 000000000..81e38f018--- /dev/null+++ b/crates/segment/src/fetch/tests.rs@@ -0,0 +1,314 @@+//! The downloader against a local HTTP server (std `TcpListener`; never the internet): mirror+//! fallback, redirects, resuming, chunked bodies, stalls, hash mismatches, size caps, cancel.++use std::io::{BufRead, BufReader, Write};+use std::net::{TcpListener, TcpStream};+use std::sync::Arc;+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};+use std::time::{Duration, Instant};++use super::*;++/// The served file: 300 kB of a deterministic pattern.+fn payload() -> Vec<u8> {+ (0..300_000u32).map(|i| (i.wrapping_mul(2_654_435_761) >> 13) as u8).collect()+}++fn sha_hex(b: &[u8]) -> String {+ Sha256::digest(b).iter().map(|b| format!("{b:02x}")).collect()+}++fn leak(s: String) -> &'static str {+ Box::leak(s.into_boxed_str())+}++fn pinned() -> FileSpec {+ let p = payload();+ FileSpec { name: "model.bin", size: Some(p.len() as u64), sha256: Some(leak(sha_hex(&p))), max: p.len() as u64 }+}++struct Server {+ base: String,+ hits: Arc<AtomicUsize>,+}++/// Serve on 127.0.0.1; the first path segment picks the behaviour.+fn server() -> Server {+ let l = TcpListener::bind("127.0.0.1:0").unwrap();+ let base = format!("http://{}", l.local_addr().unwrap());+ let hits = Arc::new(AtomicUsize::new(0));+ let h = hits.clone();+ std::thread::spawn(move || {+ for s in l.incoming().flatten() {+ let h = h.clone();+ std::thread::spawn(move || handle(s, &h));+ }+ });+ Server { base, hits }+}++fn handle(mut s: TcpStream, hits: &AtomicUsize) {+ let n = hits.fetch_add(1, Ordering::SeqCst);+ let mut r = BufReader::new(s.try_clone().unwrap());+ let mut first = String::new();+ if r.read_line(&mut first).is_err() {+ return;+ }+ let mut range: Option<u64> = None;+ loop {+ let mut l = String::new();+ if r.read_line(&mut l).unwrap_or(0) == 0 || l.trim().is_empty() {+ break;+ }+ if let Some(v) = l.to_ascii_lowercase().strip_prefix("range: bytes=") {+ range = v.trim().trim_end_matches('-').parse().ok();+ }+ }+ let path = first.split_whitespace().nth(1).unwrap_or("/").to_string();+ let mode = path.trim_start_matches('/').split('/').next().unwrap_or("").to_string();+ let body = payload();+ let send = |s: &mut TcpStream, status: &str, headers: &str, data: &[u8]| {+ let _ = s.write_all(format!("HTTP/1.1 {status}\r\n{headers}Connection: close\r\n\r\n").as_bytes());+ let _ = s.write_all(data);+ };+ match mode.as_str() {+ "missing" => send(&mut s, "404 Not Found", "Content-Length: 9\r\n", b"not found"),+ "error" => send(&mut s, "500 Oops", "Content-Length: 25\r\n", b"<html>server error</html>"),+ "redirect" => send(&mut s, "302 Found", &format!("Location: {}\r\nContent-Length: 0\r\n", path.replacen("/redirect", "/good", 1)), b""),+ "wrong" => {+ let mut b = body.clone();+ b[1000] ^= 0xff;+ send(&mut s, "200 OK", &format!("Content-Length: {}\r\n", b.len()), &b)+ }+ "toolong" => {+ // no length announced, more bytes than the file can have+ let mut b = body.clone();+ b.extend_from_slice(&[7u8; 5000]);+ send(&mut s, "200 OK", "", &b)+ }+ "chunked" => {+ let _ = s.write_all(b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n");+ for c in body.chunks(70_001) {+ let _ = s.write_all(format!("{:x};ext=1\r\n", c.len()).as_bytes());+ let _ = s.write_all(c);+ let _ = s.write_all(b"\r\n");+ }+ let _ = s.write_all(b"0\r\nX-Trailer: 1\r\n\r\n");+ }+ "stall" => {+ // half the file, then nothing+ let _ = s.write_all(format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", body.len()).as_bytes());+ let _ = s.write_all(&body[..body.len() / 2]);+ std::thread::sleep(Duration::from_secs(5));+ }+ "slow" => {+ let _ = s.write_all(format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", body.len()).as_bytes());+ for c in body.chunks(1000) {+ if s.write_all(c).is_err() {+ return;+ }+ std::thread::sleep(Duration::from_millis(20));+ }+ }+ "flaky" if n.is_multiple_of(2) && range.is_none() => {+ // the first try breaks off after a third+ let _ = s.write_all(format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", body.len()).as_bytes());+ let _ = s.write_all(&body[..body.len() / 3]);+ }+ "range416" if range.is_some() => send(&mut s, "416 Range Not Satisfiable", "Content-Length: 0\r\n", b""),+ "norange" | "range416" => send(&mut s, "200 OK", &format!("Content-Length: {}\r\n", body.len()), &body),+ _ => match range {+ Some(from) if from as usize >= body.len() => send(&mut s, "416 Range Not Satisfiable", "Content-Length: 0\r\n", b""),+ Some(from) => send(+ &mut s,+ "206 Partial Content",+ &format!("Content-Range: bytes {from}-{}/{}\r\nContent-Length: {}\r\n", body.len() - 1, body.len(), body.len() - from as usize),+ &body[from as usize..],+ ),+ None => send(&mut s, "200 OK", &format!("Content-Length: {}\r\n", body.len()), &body),+ },+ }+}++fn tmp(name: &str) -> PathBuf {+ let d = std::env::temp_dir().join(format!("lc-sam3-fetch-{name}-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&d);+ d+}++fn quick() -> Options {+ Options { connect_timeout: Duration::from_secs(2), stall_timeout: Duration::from_millis(600), attempts: 2 }+}++fn run(files: &[FileSpec], mirrors: &[String], dir: &Path, cancel: &AtomicBool) -> (Result<(), DownloadError>, Vec<Progress>) {+ let mut seen = Vec::new();+ let r = download(files, mirrors, dir, &quick(), cancel, &mut |p| seen.push(p.clone()));+ (r, seen)+}++#[test]+fn falls_back_to_the_next_mirror_and_verifies() {+ let srv = server();+ let dir = tmp("fallback");+ let mirrors = vec![+ format!("{}/missing", srv.base),+ format!("{}/error", srv.base),+ "http://127.0.0.1:1/unreachable".to_string(),+ format!("{}/redirect", srv.base),+ ];+ let (r, seen) = run(&[pinned()], &mirrors, &dir, &AtomicBool::new(false));+ r.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ assert!(!part_path(&dir, "model.bin").exists());+ let last = seen.last().unwrap();+ assert_eq!((last.done, last.total), (300_000, 300_000));+ // an error page never ends up in the file: nothing left over from the failed mirrors+ assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 1);+ // installed: nothing is fetched again+ let hits = srv.hits.load(Ordering::SeqCst);+ run(&[pinned()], &mirrors, &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(srv.hits.load(Ordering::SeqCst), hits);+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn a_hash_mismatch_is_deleted_and_the_next_mirror_used() {+ let srv = server();+ let dir = tmp("hash");+ let (r, _) = run(&[pinned()], &[format!("{}/wrong", srv.base)], &dir, &AtomicBool::new(false));+ let e = r.unwrap_err().to_string();+ assert!(e.contains("SHA-256"), "{e}");+ assert!(!dir.join("model.bin").exists() && !part_path(&dir, "model.bin").exists(), "a damaged file is never kept");+ run(&[pinned()], &[format!("{}/wrong", srv.base), format!("{}/good", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn resumes_partial_files_and_restarts_bad_ones() {+ let srv = server();+ let dir = tmp("resume");+ std::fs::create_dir_all(&dir).unwrap();+ // a third already there+ std::fs::write(part_path(&dir, "model.bin"), &payload()[..100_000]).unwrap();+ run(&[pinned()], &[format!("{}/good", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ // a partial file with the wrong bytes: the hash fails, it's deleted, the next try starts over+ std::fs::remove_file(dir.join("model.bin")).unwrap();+ std::fs::write(part_path(&dir, "model.bin"), vec![0u8; 100_000]).unwrap();+ run(&[pinned()], &[format!("{}/good", srv.base), format!("{}/good", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ // a server ignoring Range: the whole file again, not appended+ std::fs::remove_file(dir.join("model.bin")).unwrap();+ std::fs::write(part_path(&dir, "model.bin"), &payload()[..5]).unwrap();+ run(&[pinned()], &[format!("{}/norange", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ // a connection breaking off is resumed on the same mirror+ std::fs::remove_file(dir.join("model.bin")).unwrap();+ run(&[pinned()], &[format!("{}/flaky", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn a_416_or_a_bad_complete_part_starts_over() {+ let srv = server();+ let dir = tmp("416");+ std::fs::create_dir_all(&dir).unwrap();+ // the server refuses the range: the part is dropped and the file fetched whole (no loop)+ std::fs::write(part_path(&dir, "model.bin"), &payload()[..100]).unwrap();+ run(&[pinned()], &[format!("{}/range416", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ // as long as the file but wrong: hash fails → deleted → downloaded again from the same mirror+ std::fs::remove_file(dir.join("model.bin")).unwrap();+ std::fs::write(part_path(&dir, "model.bin"), vec![1u8; 300_000]).unwrap();+ run(&[pinned()], &[format!("{}/good", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn chunked_bodies_and_unpinned_files() {+ let srv = server();+ let dir = tmp("chunked");+ let f = FileSpec { name: "vocab.json", size: None, sha256: None, max: 1 << 20 };+ run(std::slice::from_ref(&f), &[format!("{}/chunked", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("vocab.json")).unwrap(), payload());+ // more than the cap: refused, nothing kept+ let small = FileSpec { max: 1000, ..f };+ let dir2 = tmp("cap");+ let e = run(&[small], &[format!("{}/good", srv.base)], &dir2, &AtomicBool::new(false)).0.unwrap_err().to_string();+ assert!(e.contains("wrong size") || e.contains("more than"), "{e}");+ assert!(!dir2.join("vocab.json").exists() && !part_path(&dir2, "vocab.json").exists());+ let _ = std::fs::remove_dir_all(&dir);+ let _ = std::fs::remove_dir_all(&dir2);+}++#[test]+fn a_server_sending_too_much_is_cut_off() {+ let srv = server();+ let dir = tmp("toolong");+ let e = run(&[pinned()], &[format!("{}/toolong", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap_err().to_string();+ assert!(e.contains("more than"), "{e}");+ assert!(!dir.join("model.bin").exists() && !part_path(&dir, "model.bin").exists());+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn a_stalled_server_times_out_and_the_next_mirror_finishes() {+ let srv = server();+ let dir = tmp("stall");+ let t = Instant::now();+ let (r, _) = run(&[pinned()], &[format!("{}/stall", srv.base), format!("{}/good", srv.base)], &dir, &AtomicBool::new(false));+ r.unwrap();+ assert!(t.elapsed() < Duration::from_secs(4), "{:?}", t.elapsed());+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn cancel_stops_quickly_and_keeps_the_part_for_later() {+ let srv = server();+ let dir = tmp("cancel");+ let cancel = Arc::new(AtomicBool::new(false));+ let c = cancel.clone();+ std::thread::spawn(move || {+ std::thread::sleep(Duration::from_millis(400));+ c.store(true, Ordering::SeqCst);+ });+ let t = Instant::now();+ let (r, _) = run(&[pinned()], &[format!("{}/slow", srv.base)], &dir, &cancel);+ assert_eq!(r, Err(DownloadError::Cancelled));+ assert!(t.elapsed() < Duration::from_secs(3), "{:?}", t.elapsed());+ assert!(!dir.join("model.bin").exists());+ let kept = std::fs::metadata(part_path(&dir, "model.bin")).map(|m| m.len()).unwrap_or(0);+ assert!(kept > 0 && kept < 300_000, "{kept}");+ // and the next run resumes it+ run(&[pinned()], &[format!("{}/good", srv.base)], &dir, &AtomicBool::new(false)).0.unwrap();+ assert_eq!(std::fs::read(dir.join("model.bin")).unwrap(), payload());+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn no_mirrors_is_a_clear_error_and_mirror_lists_are_parsed() {+ let dir = tmp("nomirror");+ let e = run(&[pinned()], &[], &dir, &AtomicBool::new(false)).0.unwrap_err();+ assert_eq!(e, DownloadError::NoMirrors);+ assert!(e.to_string().contains(MIRRORS_ENV));+ let file = std::env::temp_dir().join(format!("lc-sam3-mirrors-{}.txt", std::process::id()));+ std::fs::write(&file, "# mine\nhttps://b.example/m/ # second\n\nnot a url\nhttps://a.example/x\n").unwrap();+ let m = mirrors(Some("https://a.example/x/, ftp://no"), Some(&file));+ assert_eq!(m[..2], ["https://a.example/x".to_string(), "https://b.example/m".to_string()]);+ assert_eq!(m.len(), 2 + DEFAULT_MIRRORS.len());+ assert_eq!(mirrors(None, Some(Path::new("/nonexistent/mirrors.txt"))).len(), DEFAULT_MIRRORS.len());+ let _ = std::fs::remove_file(&file);+ let _ = std::fs::remove_dir_all(&dir);+}++#[test]+fn content_ranges() {+ assert_eq!(parse_content_range("bytes 100-299/300"), Some((100, Some(300))));+ assert_eq!(parse_content_range("bytes 0-0/*"), Some((0, None)));+ assert_eq!(parse_content_range("bytes 9-1/300"), None);+ assert_eq!(parse_content_range("items 1-2/3"), None);+}diff --git a/crates/segment/src/lib.rs b/crates/segment/src/lib.rsindex 83bcbbafe..42aed5380 100644--- a/crates/segment/src/lib.rs+++ b/crates/segment/src/lib.rs@@ -13,7 +13,16 @@//! read from a directory the user downloads them to ([`Sam3::load`]).//!//! Ported from the Hugging Face `transformers` implementation (Apache-2.0); see `NOTICE`.-//! No UI dependencies (L3).+//! This crate is therefore licensed under the Apache License 2.0 only (not the MIT option of+//! the rest of LightCraft). No UI dependencies (L3).+//!+//! [`fetch`] downloads the model, only when the user asks for it (from configurable mirrors,+//! verified before use). Nothing in LightCraft requires the model: without it, AI masks report+//! that it isn't installed and everything else works.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`src/transformers/models/sam3` and `sam3_tracker`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.#![forbid(unsafe_code)]#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]@@ -21,6 +30,8 @@mod clip;#[cfg(not(target_arch = "wasm32"))]mod detector;+#[cfg(not(target_arch = "wasm32"))]+pub mod fetch;pub mod mask;#[cfg(not(target_arch = "wasm32"))]mod neck;diff --git a/crates/segment/src/mask.rs b/crates/segment/src/mask.rsindex 1e61c1f7c..af349a262 100644--- a/crates/segment/src/mask.rs+++ b/crates/segment/src/mask.rs@@ -1,4 +1,8 @@//! Image preprocessing and mask post-processing (CPU, no model needed).+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`models/sam3/image_processing_sam3*.py`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use crate::{Error, Result};diff --git a/crates/segment/src/neck.rs b/crates/segment/src/neck.rsindex df4db88d1..c4f716dd6 100644--- a/crates/segment/src/neck.rs+++ b/crates/segment/src/neck.rs@@ -1,5 +1,9 @@//! The feature pyramid (`Sam3VisionNeck`): the backbone's 72 × 72 map at four scales//! (288, 144, 72 and 36 per side), each projected to 256 channels.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`models/sam3/modeling_sam3.py`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use candle_core::{Module, Tensor};use candle_nn::{Conv2d, Conv2dConfig, ConvTranspose2d, ConvTranspose2dConfig, VarBuilder};diff --git a/crates/segment/src/nn.rs b/crates/segment/src/nn.rsindex cec6a58b1..540196e5d 100644--- a/crates/segment/src/nn.rs+++ b/crates/segment/src/nn.rs@@ -1,4 +1,8 @@//! Shared building blocks: attention, MLPs, layer norms, sine position encodings.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`models/sam3/modeling_sam3.py`, `models/sam3_tracker`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use candle_core::{D, DType, Device, Module, Tensor};use candle_nn::{LayerNorm, Linear, VarBuilder};diff --git a/crates/segment/src/tokenizer.rs b/crates/segment/src/tokenizer.rsindex c1a9f3c10..0819aa48f 100644--- a/crates/segment/src/tokenizer.rs+++ b/crates/segment/src/tokenizer.rs@@ -1,5 +1,9 @@//! The CLIP byte-pair-encoding tokenizer (lower-cased, `</w>` word ends), padded to the//! 32-token context SAM 3's text encoder takes.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (the CLIP tokenizer used by `models/sam3`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use std::collections::HashMap;use std::path::Path;diff --git a/crates/segment/src/tracker.rs b/crates/segment/src/tracker.rsindex 828d56b66..d51219c80 100644--- a/crates/segment/src/tracker.rs+++ b/crates/segment/src/tracker.rs@@ -1,5 +1,9 @@//! Point prompts (SAM 3's interactive "tracker" head, SAM 2 style): a prompt encoder for//! positive/negative clicks and a two-way-transformer mask decoder over the image features.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`models/sam3_tracker/modeling_sam3_tracker.py`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use candle_core::{DType, Device, IndexOp, Module, Tensor};use candle_nn::{Conv2d, Conv2dConfig, ConvTranspose2d, ConvTranspose2dConfig, LayerNorm, VarBuilder};diff --git a/crates/segment/src/vit.rs b/crates/segment/src/vit.rsindex ad9018269..16b09a729 100644--- a/crates/segment/src/vit.rs+++ b/crates/segment/src/vit.rs@@ -1,5 +1,9 @@//! The SAM 3 vision backbone: a 32-layer ViT (Perception Encoder) with 2-D axial rotary//! position encoding, windowed attention (24 × 24) in most layers and global attention in four.+//!+//! Modified work (Apache License 2.0, §4(b)): ported by the LightCraft contributors in 2026 from+//! the Python/PyTorch SAM 3 code of Hugging Face Transformers (`models/sam3/modeling_sam3.py`), Copyright The HuggingFace+//! Team and Meta Platforms, Inc.; translated to Rust on candle and restructured. See NOTICE.use candle_core::{D, Device, Module, Tensor};use candle_nn::{Conv2d, Conv2dConfig, LayerNorm, VarBuilder};diff --git a/crates/segment/src/weights.rs b/crates/segment/src/weights.rsindex 15de564ae..70ac92b22 100644--- a/crates/segment/src/weights.rs+++ b/crates/segment/src/weights.rs@@ -31,10 +31,11 @@ pub struct Weights {impl Weights {pub fn open(path: &Path) -> Result<Arc<Self>> {let mut file = File::open(path).map_err(|e| Error::Model(format!("{}: {e}", path.display())))?;+ let file_len = file.metadata().map_err(|e| Error::Model(format!("{}: {e}", path.display())))?.len();let mut len = [0u8; 8];file.read_exact(&mut len).map_err(|e| Error::Model(format!("{}: {e}", path.display())))?;let n = u64::from_le_bytes(len);- if n > 100 << 20 {+ if n > 100 << 20 || n.saturating_add(8) > file_len {return Err(Error::Model(format!("{}: not a safetensors file (header of {n} bytes)", path.display())));}let mut header = vec![0u8; n as usize];@@ -62,6 +63,10 @@ impl Weights {if end.checked_sub(start) != want.map(|w| w as u64) {return Err(Error::Model(format!("{name}: size does not match its shape")));}+ // the bytes must be in the file (a damaged or truncated download fails here, not later)+ if (8 + n).checked_add(end).is_none_or(|e| e > file_len) {+ return Err(Error::Model(format!("{}: tensor {name} lies outside the file (incomplete or damaged download?)", path.display())));+ }entries.insert(name, Entry { shape, start, end });}Ok(Arc::new(Self { file: Mutex::new(file), entries, data_start: 8 + n }))@@ -74,7 +79,9 @@ impl Weights {/// Tensor `name` as stored, on the CPU.pub fn read(&self, name: &str) -> Result<Tensor> {let e = self.entries.get(name).ok_or_else(|| Error::Model(format!("missing tensor `{name}`")))?;- let mut bytes = vec![0u8; e.end.saturating_sub(e.start) as usize];+ // checked against the file's length in `open`+ let len = usize::try_from(e.end.saturating_sub(e.start)).map_err(|_| Error::Model(format!("{name}: too large")))?;+ let mut bytes = vec![0u8; len];{let mut f = self.file.lock().unwrap_or_else(std::sync::PoisonError::into_inner);f.seek(SeekFrom::Start(self.data_start + e.start)).map_err(|err| Error::Model(format!("{name}: {err}")))?;@@ -106,3 +113,39 @@ impl SimpleBackend for Backend {self.0.contains(name)}}++#[cfg(test)]+mod tests {+ use super::*;++ fn write(name: &str, header: &str, data_len: usize) -> std::path::PathBuf {+ let p = std::env::temp_dir().join(format!("lc-weights-{name}-{}.safetensors", std::process::id()));+ let mut b = (header.len() as u64).to_le_bytes().to_vec();+ b.extend_from_slice(header.as_bytes());+ b.extend(std::iter::repeat_n(0u8, data_len));+ std::fs::write(&p, b).unwrap();+ p+ }++ #[test]+ fn tensors_must_lie_inside_the_file() {+ let ok = write("ok", r#"{"a":{"dtype":"F32","shape":[2,2],"data_offsets":[0,16]}}"#, 16);+ let w = Weights::open(&ok).unwrap();+ assert_eq!(w.read("a").unwrap().dims(), &[2, 2]);+ // a truncated download: the header promises bytes that aren't there+ let short = write("short", r#"{"a":{"dtype":"F32","shape":[2,2],"data_offsets":[0,16]}}"#, 8);+ assert!(Weights::open(&short).err().unwrap().to_string().contains("outside the file"));+ // hostile offsets: huge, or beyond u64+ let huge = write("huge", r#"{"a":{"dtype":"F32","shape":[1073741824,1073741824],"data_offsets":[0,4611686018427387904]}}"#, 16);+ assert!(Weights::open(&huge).is_err());+ let wrap = write("wrap", r#"{"a":{"dtype":"F32","shape":[1],"data_offsets":[18446744073709551612,18446744073709551616]}}"#, 16);+ assert!(Weights::open(&wrap).is_err());+ // a header longer than the file+ let p = std::env::temp_dir().join(format!("lc-weights-hdr-{}.safetensors", std::process::id()));+ std::fs::write(&p, 1000u64.to_le_bytes()).unwrap();+ assert!(Weights::open(&p).is_err());+ for f in [ok, short, huge, wrap, p] {+ let _ = std::fs::remove_file(f);+ }+ }+}