Skip to content

Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦

C

fix(tools): accept a qpack manifest that does not declare layout.json

Léon Avic Simmons09e0f68d096b
diff --git a/c/tests/fixtures/.gitattributes b/c/tests/fixtures/.gitattributes
new file mode 100644
index 00000000..bd178600
--- /dev/null
+++ b/c/tests/fixtures/.gitattributes
@@ -0,0 +1,4 @@
+# Byte-exact production fixtures: hashes.json pins manifest.json by SHA-256,
+# so a CRLF checkout (Windows runners default to core.autocrlf=true) must not
+# rewrite them.
+*.json -text
diff --git a/c/tests/fixtures/swiftlet_qpack_manifest.json b/c/tests/fixtures/swiftlet_qpack_manifest.json
deleted file mode 100644
index 0f881dbe..00000000
--- a/c/tests/fixtures/swiftlet_qpack_manifest.json
+++ /dev/null
@@ -1,57 +0,0 @@
-{
- "files" : {
- "chat_template.jinja" : 7764,
- "config.json" : 23591,
- "model.safetensors" : 1389579123,
- "packed_experts/layer_00.bin" : 452984832,
- "packed_experts/layer_01.bin" : 452984832,
- "packed_experts/layer_02.bin" : 452984832,
- "packed_experts/layer_03.bin" : 452984832,
- "packed_experts/layer_04.bin" : 452984832,
- "packed_experts/layer_05.bin" : 452984832,
- "packed_experts/layer_06.bin" : 452984832,
- "packed_experts/layer_07.bin" : 452984832,
- "packed_experts/layer_08.bin" : 452984832,
- "packed_experts/layer_09.bin" : 452984832,
- "packed_experts/layer_10.bin" : 452984832,
- "packed_experts/layer_11.bin" : 452984832,
- "packed_experts/layer_12.bin" : 452984832,
- "packed_experts/layer_13.bin" : 452984832,
- "packed_experts/layer_14.bin" : 452984832,
- "packed_experts/layer_15.bin" : 452984832,
- "packed_experts/layer_16.bin" : 452984832,
- "packed_experts/layer_17.bin" : 452984832,
- "packed_experts/layer_18.bin" : 452984832,
- "packed_experts/layer_19.bin" : 452984832,
- "packed_experts/layer_20.bin" : 452984832,
- "packed_experts/layer_21.bin" : 452984832,
- "packed_experts/layer_22.bin" : 452984832,
- "packed_experts/layer_23.bin" : 452984832,
- "packed_experts/layer_24.bin" : 452984832,
- "packed_experts/layer_25.bin" : 452984832,
- "packed_experts/layer_26.bin" : 452984832,
- "packed_experts/layer_27.bin" : 452984832,
- "packed_experts/layer_28.bin" : 452984832,
- "packed_experts/layer_29.bin" : 452984832,
- "packed_experts/layer_30.bin" : 452984832,
- "packed_experts/layer_31.bin" : 452984832,
- "packed_experts/layer_32.bin" : 452984832,
- "packed_experts/layer_33.bin" : 452984832,
- "packed_experts/layer_34.bin" : 452984832,
- "packed_experts/layer_35.bin" : 452984832,
- "packed_experts/layer_36.bin" : 452984832,
- "packed_experts/layer_37.bin" : 452984832,
- "packed_experts/layer_38.bin" : 452984832,
- "packed_experts/layer_39.bin" : 452984832,
- "packed_experts/layout.json" : 2048,
- "tokenizer.json" : 19989343,
- "tokenizer_config.json" : 1139,
- "vocab.json" : 6722759
- },
- "magic" : "QPACK",
- "modelName" : "qwen3_5_moe_text",
- "quantBits" : 4,
- "quantGroupSize" : 64,
- "sourceCheckpoint" : "qwen3.6-35b-mlx4bit",
- "version" : 1
-}
diff --git a/c/tests/fixtures/swiftlet_qwen36_35b_hashes.json b/c/tests/fixtures/swiftlet_qwen36_35b_hashes.json
new file mode 100644
index 00000000..07c8e6d5
--- /dev/null
+++ b/c/tests/fixtures/swiftlet_qwen36_35b_hashes.json
@@ -0,0 +1,52 @@
+{
+ "files": {
+ "chat_template.jinja": "e84f32a23fdda27689f868aa4a1a5621f41133e51a48d7f3efcbea2839574259",
+ "config.json": "a822a9e48b0aafbe3144ec37d4fb067e178ed96615ce6e4420b3149893cc5767",
+ "manifest.json": "cc7b107e91b647cbf8fcf3c810bccdc5156e29fe304f829414ceb60ad70e1a5d",
+ "model.safetensors": "d9c1f08c76b0e4e7f99e911767576183f3036c434a6637a4f06c76958df03f27",
+ "packed_experts/layer_00.bin": "f7e8fbd29d58b6073bcfaaf08ca1e3e8373e1b66861c82fa6c385026dc7005b8",
+ "packed_experts/layer_01.bin": "d183602f0072355b327a212d065baf9c51210d0042c58187d3aeb53aa2653993",
+ "packed_experts/layer_02.bin": "d427407c248be3e24e0200580f62951abb2b2e83d7282ffa33c9568c30dfbce8",
+ "packed_experts/layer_03.bin": "511ea7859025c408a713546806f6d113310ff194a0da2f82016a6644515a7181",
+ "packed_experts/layer_04.bin": "45ebd70309e69f867d6ba3a0b734fe9d5eacbb5ae80725774c27b342212250f8",
+ "packed_experts/layer_05.bin": "7020f8d2f0948f0cd50a5679454aaf8d4121789a875e841836425eb928df9ec0",
+ "packed_experts/layer_06.bin": "7b926a76f23898b115fc79456c910a63ac19c814bca717a8e42b611743c3be2c",
+ "packed_experts/layer_07.bin": "64da0ad2e70daf037212c649bdd61d5f99ed0407d31ae616e48bed8591f1fa19",
+ "packed_experts/layer_08.bin": "2af661e63504476cb9a32fbca802d7c3b1cfa8e4d9c8476d3d4da34f38d1aa46",
+ "packed_experts/layer_09.bin": "acf1ca5d66e623bb04a4336d640859c46646067fe2ee434196a343d88bf0f766",
+ "packed_experts/layer_10.bin": "ae796efde0efd7aaef03e6c559fa549bf2133a2042c38e0182e90d3c905dfb08",
+ "packed_experts/layer_11.bin": "9e2ff7c11641319eab071f5f7a6a6cbf2bd9c2545947430143da78bc50264c03",
+ "packed_experts/layer_12.bin": "40a7f06f5b3dcfe6a553da0f6ee3379fc095aea2999169e44a66b42960b87e3e",
+ "packed_experts/layer_13.bin": "a104e66266d0c2ed133de7ce84c0e3c6426f5f0eae4726fb71f980328af6cd01",
+ "packed_experts/layer_14.bin": "76f92b6569cf881be0dda50b387c780e47c9701da077da50c651f592d317a406",
+ "packed_experts/layer_15.bin": "a96a53c9b12c08dc2917525ea8a94d44de6aed6de367a3b4af4789294c4978d3",
+ "packed_experts/layer_16.bin": "f4d76fa5426083e70eeab25f3dd79a51e45f89cac281644a7df9087a4388e08f",
+ "packed_experts/layer_17.bin": "e63130e7c71fa471ab0045d9effd775fcf2dfc0c7c142fb7f5809afc46d23f88",
+ "packed_experts/layer_18.bin": "218767d58654b465939825b0d5c3d365fb2ab2d1ff8f17174eb6d3484f4e2453",
+ "packed_experts/layer_19.bin": "52e214ef343f537d248fa37ccbb86b9216020851bc4ee3d6ab6f8300a2819491",
+ "packed_experts/layer_20.bin": "3757d8a48ec46bb50e680f2a11db6351cfea01bd2cfba4201cc2ff1bc53f06c3",
+ "packed_experts/layer_21.bin": "553b822c5abc9ca8b60a1a38654a8ee689e96f1a00c1920c6f1dee204b237792",
+ "packed_experts/layer_22.bin": "74d22074126c03a97944eebb2fb8919dfc0cc0474d587f82c893b6d883040cd6",
+ "packed_experts/layer_23.bin": "f31bb79fec5656c55dcea7b47a5efb2f8755a643b4fd02da3b18ecb1aa11bf45",
+ "packed_experts/layer_24.bin": "df0c51ec7f7939768f32f94d1589da580a4adcbd7171edf885e2f71fca89d56d",
+ "packed_experts/layer_25.bin": "b93b0587f381ba8abfe21f05ebb21197cf87557a12f5bb217fde0503bc3f7bd8",
+ "packed_experts/layer_26.bin": "1d5dec76c8675f2577c251a9f859c37fdf410f3cfa3a6aba01cf3803727268d7",
+ "packed_experts/layer_27.bin": "3d594a093126ce33162e510f79b15254e742a6d8805940007ed091e2ea20057e",
+ "packed_experts/layer_28.bin": "27e752c2558ba291471d18b5a610e2b9e0618d41c6a9e1196770584a4ec8a0f6",
+ "packed_experts/layer_29.bin": "6c6669210e90c49de64d03514cc1b8a940b962cb0178406b3be6f2298e961853",
+ "packed_experts/layer_30.bin": "9730968251b94ee8bd2f68e6766fdcb32931e2d385240860f3f3f8e9a8544ae5",
+ "packed_experts/layer_31.bin": "68bb731a2d09cf452a9b5d0d11b87c9350ad36dc679e9d3433d94e444503d276",
+ "packed_experts/layer_32.bin": "fc335b49c0bb83667bd1037495c203e920bab6b5ce0e155c4e4f2d5580634a05",
+ "packed_experts/layer_33.bin": "d4d9af1c7b6397a67683758fbdc4180d566109319a01dfebb1bcddc470855f90",
+ "packed_experts/layer_34.bin": "8180d7efccbb9c0f28d13094e9bc46a113c7a852ba07613a145bcded7f72dac1",
+ "packed_experts/layer_35.bin": "e695e634c8c92e378e3221ba1240b1ae56a60357acba0dfdfbde4742ed61d57c",
+ "packed_experts/layer_36.bin": "300681b992213a9ae67d9de887fcfeb3c91d73d3e2625e4ff6e86d9bb3f73400",
+ "packed_experts/layer_37.bin": "01ba001da1ad2c41164c3d257dbf06f4701c319c8011dda772d83c16a6bc6902",
+ "packed_experts/layer_38.bin": "1d439cecbc69ede60db7c08ed57dc5e67fdbc1f0d323cfe065de50af8288e2de",
+ "packed_experts/layer_39.bin": "e1fa9e70174ab328e52914906c5ad1e536c2ba78124eef2ce58d16a9ebbdffcf",
+ "packed_experts/layout.json": "f43c7b28483e51924e7639d646af25c85e3c733207e0cfb247047600f2e15b3e",
+ "tokenizer.json": "87a7830d63fcf43bf241c3c5242e96e62dd3fdc29224ca26fed8ea333db72de4",
+ "tokenizer_config.json": "e98f1901ac6f0adff67b1d540bfa0c36ac1a0cf59eb72ed78146ef89aafa1182",
+ "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003"
+ }
+}
\ No newline at end of file
diff --git a/c/tests/fixtures/swiftlet_qwen36_35b_manifest.json b/c/tests/fixtures/swiftlet_qwen36_35b_manifest.json
new file mode 100644
index 00000000..d98cf25b
--- /dev/null
+++ b/c/tests/fixtures/swiftlet_qwen36_35b_manifest.json
@@ -0,0 +1,57 @@
+{
+ "files" : {
+ "chat_template.jinja" : 7764,
+ "config.json" : 23591,
+ "model.safetensors" : 1389579123,
+ "packed_experts\/layer_00.bin" : 452984832,
+ "packed_experts\/layer_01.bin" : 452984832,
+ "packed_experts\/layer_02.bin" : 452984832,
+ "packed_experts\/layer_03.bin" : 452984832,
+ "packed_experts\/layer_04.bin" : 452984832,
+ "packed_experts\/layer_05.bin" : 452984832,
+ "packed_experts\/layer_06.bin" : 452984832,
+ "packed_experts\/layer_07.bin" : 452984832,
+ "packed_experts\/layer_08.bin" : 452984832,
+ "packed_experts\/layer_09.bin" : 452984832,
+ "packed_experts\/layer_10.bin" : 452984832,
+ "packed_experts\/layer_11.bin" : 452984832,
+ "packed_experts\/layer_12.bin" : 452984832,
+ "packed_experts\/layer_13.bin" : 452984832,
+ "packed_experts\/layer_14.bin" : 452984832,
+ "packed_experts\/layer_15.bin" : 452984832,
+ "packed_experts\/layer_16.bin" : 452984832,
+ "packed_experts\/layer_17.bin" : 452984832,
+ "packed_experts\/layer_18.bin" : 452984832,
+ "packed_experts\/layer_19.bin" : 452984832,
+ "packed_experts\/layer_20.bin" : 452984832,
+ "packed_experts\/layer_21.bin" : 452984832,
+ "packed_experts\/layer_22.bin" : 452984832,
+ "packed_experts\/layer_23.bin" : 452984832,
+ "packed_experts\/layer_24.bin" : 452984832,
+ "packed_experts\/layer_25.bin" : 452984832,
+ "packed_experts\/layer_26.bin" : 452984832,
+ "packed_experts\/layer_27.bin" : 452984832,
+ "packed_experts\/layer_28.bin" : 452984832,
+ "packed_experts\/layer_29.bin" : 452984832,
+ "packed_experts\/layer_30.bin" : 452984832,
+ "packed_experts\/layer_31.bin" : 452984832,
+ "packed_experts\/layer_32.bin" : 452984832,
+ "packed_experts\/layer_33.bin" : 452984832,
+ "packed_experts\/layer_34.bin" : 452984832,
+ "packed_experts\/layer_35.bin" : 452984832,
+ "packed_experts\/layer_36.bin" : 452984832,
+ "packed_experts\/layer_37.bin" : 452984832,
+ "packed_experts\/layer_38.bin" : 452984832,
+ "packed_experts\/layer_39.bin" : 452984832,
+ "packed_experts\/layout.json" : 2048,
+ "tokenizer.json" : 19989343,
+ "tokenizer_config.json" : 1139,
+ "vocab.json" : 6722759
+ },
+ "magic" : "QPACK",
+ "modelName" : "qwen3_5_moe_text",
+ "quantBits" : 4,
+ "quantGroupSize" : 64,
+ "sourceCheckpoint" : "qwen3.6-35b-mlx4bit",
+ "version" : 1
+}
\ No newline at end of file
diff --git a/c/tests/fixtures/swiftlet_qwen3_next_80b_hashes.json b/c/tests/fixtures/swiftlet_qwen3_next_80b_hashes.json
new file mode 100644
index 00000000..2afe689a
--- /dev/null
+++ b/c/tests/fixtures/swiftlet_qwen3_next_80b_hashes.json
@@ -0,0 +1,65 @@
+{
+ "files": {
+ "README.md": "aae5ad7600a44480a2f1e8b2bf5a830264f68204313ceb9564393048ac0697a2",
+ "added_tokens.json": "c0284b582e14987fbd3d5a2cb2bd139084371ed9acbae488829a1c900833c680",
+ "chat_template.jinja": "40c21f34cf67d8c760ef72f8ad3ae5afad514299d4b06e91dd9a8d705af7b541",
+ "config.json": "f5a5422b8e3d47733f0073ff22dec1dc4a7832fec5fc1cf36eba31ace03cf0c4",
+ "generation_config.json": "d7115cb81df546589f9937943302901a1b75b08909293d1fc96782750b1c3217",
+ "manifest.json": "829587c32b92fbe2a669bfc7f673e655582d6fca984153402f9729dbc4dade51",
+ "merges.txt": "8831e4f1a044471340f7c0a83d7bd71306a5b867e95fd870f74d0c5308a904d5",
+ "model.safetensors": "11847578a9050d83a339458c4b91f34b3f8ec93d46e67ce0511be5125ae228d7",
+ "packed_experts/layer_00.bin": "85b06affa7c66674ff6c36cffe3f13d57b891932b89cfd5b2e05979c8b5135f0",
+ "packed_experts/layer_01.bin": "93e411df9433596cb125b3ca05a8870ada8781aa1d7f10ab820f3bdb96ea1958",
+ "packed_experts/layer_02.bin": "d4d2f85c1fc4c725eca2fbad13df220bc73bc6a3443c15130771a86ad8aa25e8",
+ "packed_experts/layer_03.bin": "22cdc79f48fa3cd66c9c193605bec1e41d5ff2ce5ee5c58f8a54a83d3b4e6f1f",
+ "packed_experts/layer_04.bin": "25d82dfacdf15717f33cc0bbf1200b4bb762ad8a80648b51ad60d4d0e244b182",
+ "packed_experts/layer_05.bin": "e38e7120a4d11b0eb5d6e1c6695fa04a53cc707fe132410abc3907a8cafd541b",
+ "packed_experts/layer_06.bin": "63c1bd62b3a9bbff0b801f0159cd656716634bfda4966c9f30da030288059fe1",
+ "packed_experts/layer_07.bin": "10b3c17035dbece58560c42e18c52a6ababa96131aec8de0632eaaa87132c5fa",
+ "packed_experts/layer_08.bin": "966afe9d90133b206f94cd0e945d1bb030fe6eeb2a150d0368dc96781b1e3522",
+ "packed_experts/layer_09.bin": "b8c6f8e55abc0418c8d89c83404ec95f40ee5f1e691acce9e078de6f8a3e0eeb",
+ "packed_experts/layer_10.bin": "180f03f8256ac36758dd6b4798ea4a14573cbcdfdee89e63605118cde5754912",
+ "packed_experts/layer_11.bin": "ae92af883414f29e22fe623782fdee86d12b26548b07476d15077cfda27f02d7",
+ "packed_experts/layer_12.bin": "b84c892d05478f7c2c75d16352413a81d6b3e0fc1194b558ec16492a008407c5",
+ "packed_experts/layer_13.bin": "a7e307fe0970efee81b0bb80ab4f1e8abe81940cd9515d846adf88c73ca8ebbe",
+ "packed_experts/layer_14.bin": "f2b24942a37871d19a9fc2c00b7d8558f3db566b0e336420adf4b082d1a6d26c",
+ "packed_experts/layer_15.bin": "e26bb25498640ac3be80d9ebcbbed1aa3fa10bbf114de746e48a829dfcb0a82d",
+ "packed_experts/layer_16.bin": "f3b829c4877c1ccb8f5aafbf0fa34936f9854d29cbdbfaa3e96e9c74273bed01",
+ "packed_experts/layer_17.bin": "4ab5d98503792da0cc9f395ee62ec19f17cc19919be3f69ef23f7ce3d3a2a892",
+ "packed_experts/layer_18.bin": "ba720168028b9b8147f73fbd3372922abdc50b8c4888bba1173bed156f3083b3",
+ "packed_experts/layer_19.bin": "a0f4035763127d9ec7641ecc94b4b91b8db505e38f71220d06ed83a35fcc86a9",
+ "packed_experts/layer_20.bin": "b5ce298129c3656a7618eb5b6db0908c6334c2fec4f7005f1034f656b18b7018",
+ "packed_experts/layer_21.bin": "de1388b171ebabea6e5da46425e92b0a74ec713b24fa8eb779778486df57fda4",
+ "packed_experts/layer_22.bin": "97f5386fac959aa811b2afbb0153a8a899feda4c5fe778d8995716b4f34ca3cb",
+ "packed_experts/layer_23.bin": "2e1dbe05f39c8fd47f8a05ea136cb6c0f725db330abc5d2e45c6a6c2a97c67a6",
+ "packed_experts/layer_24.bin": "201768dc1ac1f99fe876c7e12afffac690177938732c92a074a64eb50e47912d",
+ "packed_experts/layer_25.bin": "2158501bf449dd68f0abf326b53b2bb5ee52b7b5d7b7f901b7c1d640c9770edd",
+ "packed_experts/layer_26.bin": "f29f79636d2f467bf921a69b46bd38cf68b01f45723b241c2b33e9fa6a9ccf71",
+ "packed_experts/layer_27.bin": "0fbf81199fecbb547d8099252ddd37ee84ceb4e8cd196e0356a64563e18a46e3",
+ "packed_experts/layer_28.bin": "fe98c38b5957312a6dcd31afb038d4cfe8a2e344af04a5197afa3dc934741bca",
+ "packed_experts/layer_29.bin": "f6d775ec65c1e572e9e785c86e139219ea484a29f096bfe8620a8efae4978a42",
+ "packed_experts/layer_30.bin": "71616c531494de527708496ac3cbe76f1709e9f9b08aee7b21ceca24ff8b474e",
+ "packed_experts/layer_31.bin": "b3cab78674235ed187c665abdb2851277896d316374d8e47869c065a58b3660b",
+ "packed_experts/layer_32.bin": "381c0991e4578977ea714d3c9d6b40d9a5a8e38d067cf60098310f04ac258845",
+ "packed_experts/layer_33.bin": "5ea3e8c76b37bafdc2a12caa3fc7f17ba78c84f007f430b22462195ea5677059",
+ "packed_experts/layer_34.bin": "329776e3b89ac182e7a3cda1978bd5068c81417c5080f61598ac96091e0cfe14",
+ "packed_experts/layer_35.bin": "3fc56f199a7d8633f16b6b7e46ece231437828160b72c1df926b3c79f80b71ce",
+ "packed_experts/layer_36.bin": "64189f26c0c2e4268e449a371fd89b293e3beb1fc483ceb3186f292ef2a941dd",
+ "packed_experts/layer_37.bin": "1db4a477067e4a83d3517335fcc00ecc122387e7c11ba23e91f1903ca798b7dd",
+ "packed_experts/layer_38.bin": "c078e2428c033dae4399225caa0da69069cb2cc2499e26c60c054ca91133b3bf",
+ "packed_experts/layer_39.bin": "4d5d946c7b8a5a0bf1bd25b45a2bb049a607e722c222f022dff578301d350c35",
+ "packed_experts/layer_40.bin": "958454978a51d63d97cdaf45fe1e6d900c8028677daa93eb2e6c521debe84c44",
+ "packed_experts/layer_41.bin": "29c43016d43e67e5ccd49b762b7fd808863ea7024f26cc65c27001887711921a",
+ "packed_experts/layer_42.bin": "e22f2f2d8142123166b34a30efd6833fb6e54a4998b01a060f658b15b4a8641a",
+ "packed_experts/layer_43.bin": "3419684f4a57e53bb880bcc58a2749932cea85da275d176cdd1cb3a5c830c5d1",
+ "packed_experts/layer_44.bin": "5bb066d10acc33c16917b13e334e705f1caca6838db557e4bd42532ff52790f9",
+ "packed_experts/layer_45.bin": "d5e02523099a665c3955a6f13c70463ff049d764e163bc33d62ccb8f65e169d0",
+ "packed_experts/layer_46.bin": "c0c71dc46b9e4d3145c77016075deac2343469ed196abe66a9deb3033573f085",
+ "packed_experts/layer_47.bin": "fae3daf533c1edda097af8d6eb596b82cc4b9b26536e17e3269e387ef3e3a800",
+ "packed_experts/layout.json": "5c5bb6cef27b0f814caec8dd3e63ec51801f8e9499dc7c14791d150ccf115889",
+ "special_tokens_map.json": "76862e765266b85aa9459767e33cbaf13970f327a0e88d1c65846c2ddd3a1ecd",
+ "tokenizer.json": "aeb13307a71acd8fe81861d94ad54ab689df773318809eed3cbe794b4492dae4",
+ "tokenizer_config.json": "f2642d45cd7b1456d6087d6ff49fd97a9e48ec504ff8ef9a1d9d3956d309e3d0",
+ "vocab.json": "ca10d7e9fb3ed18575dd1e277a2579c16d108e32f27439684afa0e10b1440910"
+ }
+}
\ No newline at end of file
diff --git a/c/tests/fixtures/swiftlet_qwen3_next_80b_manifest.json b/c/tests/fixtures/swiftlet_qwen3_next_80b_manifest.json
new file mode 100644
index 00000000..2d1b13e5
--- /dev/null
+++ b/c/tests/fixtures/swiftlet_qwen3_next_80b_manifest.json
@@ -0,0 +1,59 @@
+{
+ "files" : {
+ "model.safetensors" : 1357687320,
+ "packed_experts\/layer_00.bin" : 905969664,
+ "packed_experts\/layer_01.bin" : 905969664,
+ "packed_experts\/layer_02.bin" : 905969664,
+ "packed_experts\/layer_03.bin" : 905969664,
+ "packed_experts\/layer_04.bin" : 905969664,
+ "packed_experts\/layer_05.bin" : 905969664,
+ "packed_experts\/layer_06.bin" : 905969664,
+ "packed_experts\/layer_07.bin" : 905969664,
+ "packed_experts\/layer_08.bin" : 905969664,
+ "packed_experts\/layer_09.bin" : 905969664,
+ "packed_experts\/layer_10.bin" : 905969664,
+ "packed_experts\/layer_11.bin" : 905969664,
+ "packed_experts\/layer_12.bin" : 905969664,
+ "packed_experts\/layer_13.bin" : 905969664,
+ "packed_experts\/layer_14.bin" : 905969664,
+ "packed_experts\/layer_15.bin" : 905969664,
+ "packed_experts\/layer_16.bin" : 905969664,
+ "packed_experts\/layer_17.bin" : 905969664,
+ "packed_experts\/layer_18.bin" : 905969664,
+ "packed_experts\/layer_19.bin" : 905969664,
+ "packed_experts\/layer_20.bin" : 905969664,
+ "packed_experts\/layer_21.bin" : 905969664,
+ "packed_experts\/layer_22.bin" : 905969664,
+ "packed_experts\/layer_23.bin" : 905969664,
+ "packed_experts\/layer_24.bin" : 905969664,
+ "packed_experts\/layer_25.bin" : 905969664,
+ "packed_experts\/layer_26.bin" : 905969664,
+ "packed_experts\/layer_27.bin" : 905969664,
+ "packed_experts\/layer_28.bin" : 905969664,
+ "packed_experts\/layer_29.bin" : 905969664,
+ "packed_experts\/layer_30.bin" : 905969664,
+ "packed_experts\/layer_31.bin" : 905969664,
+ "packed_experts\/layer_32.bin" : 905969664,
+ "packed_experts\/layer_33.bin" : 905969664,
+ "packed_experts\/layer_34.bin" : 905969664,
+ "packed_experts\/layer_35.bin" : 905969664,
+ "packed_experts\/layer_36.bin" : 905969664,
+ "packed_experts\/layer_37.bin" : 905969664,
+ "packed_experts\/layer_38.bin" : 905969664,
+ "packed_experts\/layer_39.bin" : 905969664,
+ "packed_experts\/layer_40.bin" : 905969664,
+ "packed_experts\/layer_41.bin" : 905969664,
+ "packed_experts\/layer_42.bin" : 905969664,
+ "packed_experts\/layer_43.bin" : 905969664,
+ "packed_experts\/layer_44.bin" : 905969664,
+ "packed_experts\/layer_45.bin" : 905969664,
+ "packed_experts\/layer_46.bin" : 905969664,
+ "packed_experts\/layer_47.bin" : 905969664
+ },
+ "magic" : "QPACK",
+ "modelName" : "qwen3_next",
+ "quantBits" : 4,
+ "quantGroupSize" : 64,
+ "sourceCheckpoint" : "lmstudio-community\/Qwen3-Next-80B-A3B-Instruct-MLX-4bit",
+ "version" : 1
+}
\ No newline at end of file
diff --git a/c/tests/test_qpack_http_install.py b/c/tests/test_qpack_http_install.py
index 3f347531..0ba8a699 100644
--- a/c/tests/test_qpack_http_install.py
+++ b/c/tests/test_qpack_http_install.py
@@ -382,7 +382,8 @@ class QpackHTTPInstallTest(unittest.TestCase):
transport.assert_empty()
def test_real_swiftlet_manifest_declared_auxiliaries_are_accepted(self):
- fixture = Path(__file__).parent / "fixtures" / "swiftlet_qpack_manifest.json"
+ fixture = (Path(__file__).parent / "fixtures"
+ / "swiftlet_qwen36_35b_manifest.json")
plan = parse_manifest(fixture.read_bytes(), f"hf:owner/model@{COMMIT}")
_check_adapter_namespace(plan)
self.assertEqual(
@@ -391,6 +392,71 @@ class QpackHTTPInstallTest(unittest.TestCase):
"tokenizer_config.json", "vocab.json"})
self.assertEqual(len(plan.files), 47)
+ def test_undeclared_layout_is_fetched_from_the_hub_and_required(self):
+ # The production Qwen3-Next-80B manifest declares only the weights;
+ # the reader still opens packed_experts/layout.json from disk.
+ self.files = {"model.safetensors": b"weights"}
+ self.manifest = self.make_manifest({"model.safetensors": 7})
+ layout = b'{"layer_count":1}'
+ transport = ScriptedTransport(
+ self.manifest_response(), self.config_response(),
+ self.response(layout, etag='"layout"', checksum=True),
+ self.artifact_response("model.safetensors"))
+
+ result = self.install(transport)
+
+ self.assertEqual(
+ [call["url"].rsplit("/", 1)[-1] for call in transport.calls],
+ ["manifest.json", "config.json", "layout.json", "model.safetensors"])
+ self.assertTrue(transport.calls[2]["url"].endswith(
+ "/packed_experts/layout.json"))
+ self.assertEqual(result.downloaded_files, 3)
+ self.assertEqual(
+ (self.root / "packed_experts" / "layout.json").read_bytes(), layout)
+ self.assertEqual((self.root / "manifest.json").read_bytes(), self.manifest)
+ transport.assert_empty()
+
+ root = Path(self.temporary.name) / "no-layout.qpack"
+ transport = ScriptedTransport(
+ self.manifest_response(), self.config_response(),
+ self.response(b"", status=404))
+ with self.assertRaisesRegex(QpackHTTPError, "HTTP 404"):
+ self.install(transport, root=root)
+ self.assertFalse((root / "model.safetensors.part").exists())
+ self.assertFalse((root / "manifest.json").exists())
+
+ def test_every_request_carries_the_installer_user_agent(self):
+ # Revision resolution, manifest, config, and every ranged weight
+ # request (including a retried resume) identify the installer.
+ api = Response(200, json.dumps({"sha": COMMIT}).encode(),
+ [("Content-Length", str(len(json.dumps({"sha": COMMIT}))))])
+ first = self.artifact_response(
+ "model.safetensors", body=self.files["model.safetensors"][:3])
+ first.headers = Headers([
+ ("Content-Length", str(len(self.files["model.safetensors"]))),
+ ("X-Repo-Commit", COMMIT),
+ ("ETag", '"model.safetensors"'),
+ ("X-Checksum-Sha256",
+ hashlib.sha256(self.files["model.safetensors"]).hexdigest()),
+ ])
+ transport = ScriptedTransport(
+ api, self.manifest_response(), self.config_response(), first,
+ self.artifact_response("model.safetensors", offset=3),
+ self.artifact_response("packed_experts/layout.json"))
+
+ self.install(transport, revision="main", retries=1, token="secret-token")
+
+ self.assertEqual(len(transport.calls), 6)
+ self.assertTrue(any(call["headers"].get("Range") == "bytes=3-6"
+ for call in transport.calls))
+ for call in transport.calls:
+ with self.subTest(url=call["url"]):
+ self.assertEqual(call["method"], "GET")
+ self.assertEqual(call["headers"]["User-Agent"],
+ "colibri-qpack-install/1.0")
+ self.assertEqual(call["headers"]["Accept-Encoding"], "identity")
+ transport.assert_empty()
+
def test_hugging_face_manifest_may_declare_hashes_json_as_an_artifact(self):
files = dict(self.files)
files["hashes.json"] = b'{"files":{}}'
diff --git a/c/tests/test_qpack_install_policy.py b/c/tests/test_qpack_install_policy.py
index dff628c7..c4b0dc6b 100644
--- a/c/tests/test_qpack_install_policy.py
+++ b/c/tests/test_qpack_install_policy.py
@@ -108,17 +108,57 @@ class QpackInstallPolicyTest(unittest.TestCase):
with self.subTest(name=name), self.assertRaises(QpackInstallError):
parse_manifest(self.manifest(files), "local:fixture")
- def test_manifest_rejects_invalid_sizes_and_missing_layout(self):
+ def test_manifest_rejects_invalid_sizes_and_layout_is_not_required(self):
for size in (True, False, 0, -1, 1.5, MAX_FILE_SIZE + 1):
with self.subTest(size=size), self.assertRaises(QpackInstallError):
parse_manifest(self.manifest({
"packed_experts/layout.json": size,
}), "local:fixture")
- with self.assertRaisesRegex(QpackInstallError, "layout.json"):
- parse_manifest(self.manifest({"model.safetensors": 7}), "local:fixture")
+ # The production Qwen3-Next-80B manifest declares no layout.json;
+ # Swiftlet's reader never consults the files table for it.
+ plan = parse_manifest(
+ self.manifest({"model.safetensors": 7}), "local:fixture")
+ self.assertEqual(plan.files, (QpackFile("model.safetensors", 7),))
with self.assertRaisesRegex(QpackInstallError, "source_id"):
parse_manifest(self.raw, "")
+ def test_real_swiftlet_manifests_are_accepted_with_or_without_layout(self):
+ fixtures = Path(__file__).parent / "fixtures"
+ # Qwen3-Next-80B, as published on Swiftlet's mirror: 49 entries,
+ # model.safetensors plus 48 layer blobs, no layout.json, no aux files.
+ plan = parse_manifest(
+ (fixtures / "swiftlet_qwen3_next_80b_manifest.json").read_bytes(),
+ "mirror:fixture")
+ names = [file.name for file in plan.files]
+ self.assertEqual(len(names), 49)
+ self.assertNotIn("packed_experts/layout.json", names)
+ self.assertEqual(
+ names,
+ ["model.safetensors"]
+ + [f"packed_experts/layer_{index:02d}.bin" for index in range(48)])
+ self.assertTrue(all(file.size > 0 for file in plan.files))
+ # Qwen3.6-35B, same writer, declares layout.json and the tokenizer.
+ plan = parse_manifest(
+ (fixtures / "swiftlet_qwen36_35b_manifest.json").read_bytes(),
+ "mirror:fixture")
+ self.assertEqual(len(plan.files), 47)
+ self.assertIn(QpackFile("packed_experts/layout.json", 2048), plan.files)
+
+ def test_declared_layout_with_wrong_size_cannot_commit_or_publish(self):
+ session = self.begin()
+ layout = self.file("packed_experts/layout.json")
+ self.write_partial(session, layout, b"x" * (layout.size + 1))
+ with self.assertRaisesRegex(QpackInstallError, "not complete"):
+ commit_file(session, layout)
+ self.write_partial(session, layout, b"x" * (layout.size - 1))
+ with self.assertRaisesRegex(QpackInstallError, "not complete"):
+ commit_file(session, layout)
+ self.write_partial(session, self.file("model.safetensors"), b"w" * 7)
+ commit_file(session, self.file("model.safetensors"))
+ with self.assertRaisesRegex(QpackInstallError, "before all files"):
+ publish_manifest(session, self.raw)
+ self.assertFalse((self.root / MANIFEST).exists())
+
def test_manifest_matches_swiftlet_required_fields_and_file_limit(self):
for field in ("modelName", "sourceCheckpoint"):
value = json.loads(self.raw)
diff --git a/c/tests/test_qpack_mirror_install.py b/c/tests/test_qpack_mirror_install.py
index 2ab85867..820526c3 100644
--- a/c/tests/test_qpack_mirror_install.py
+++ b/c/tests/test_qpack_mirror_install.py
@@ -9,6 +9,7 @@ from urllib.request import Request
from tools.qpack_http_install import (
HASHES_NAME,
+ LAYOUT_NAME,
QpackHTTPError,
SafeRedirectHandler,
install_mirror_qpack,
@@ -71,6 +72,15 @@ class ScriptedTransport:
raise AssertionError(f"{len(self.responses)} scripted responses unused")
+FIXTURES = Path(__file__).parent / "fixtures"
+# Swiftlet's public mirror, 2026-09-02. hashes.json pins manifest.json, so the
+# fixtures are the exact published bytes (see fixtures/.gitattributes).
+QWEN3_NEXT_80B_HASHES_SHA256 = (
+ "2133857f76c818ef2c3a72c79be1f1c5de188602af723eb996f23501913c21c6")
+QWEN36_35B_HASHES_SHA256 = (
+ "1605766290c951ce2e9f54ed4fb7d4b48b41db72a90f359b411ca80f7dd45b75")
+
+
class QpackMirrorInstallTest(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
@@ -405,6 +415,231 @@ class QpackMirrorInstallTest(unittest.TestCase):
install_mirror_qpack(
base_url, self.root, transport=ScriptedTransport())
+ def use_undeclared_layout_shape(self):
+ """The production Qwen3-Next-80B shape: weights only in the manifest,
+ layout.json (and the aux files) indexed by hashes.json alone."""
+ self.files = {
+ "model.safetensors": b"weights",
+ "packed_experts/layer_00.bin": b"layer00",
+ }
+ self.layout = b'{"layer_count":1}'
+ self.manifest = json.dumps({
+ "magic": "QPACK",
+ "version": 1,
+ "modelName": "qwen3_next",
+ "sourceCheckpoint": "owner/model@static",
+ "quantBits": 4,
+ "quantGroupSize": 32,
+ "files": {name: len(value) for name, value in self.files.items()},
+ }, sort_keys=True, separators=(",", ":")).encode()
+
+ def real_index_probe(self, name, pin):
+ """Serve a real mirror index and manifest, then refuse config.json."""
+ hashes_raw = (FIXTURES / f"{name}_hashes.json").read_bytes()
+ manifest_raw = (FIXTURES / f"{name}_manifest.json").read_bytes()
+ self.assertEqual(hashlib.sha256(hashes_raw).hexdigest(), pin,
+ "fixture bytes differ from the mirror pin; check "
+ "fixtures/.gitattributes on a CRLF checkout")
+ self.assertEqual(
+ hashlib.sha256(manifest_raw).hexdigest(),
+ json.loads(hashes_raw)["files"]["manifest.json"])
+ transport = ScriptedTransport(
+ self.response(hashes_raw), self.response(manifest_raw),
+ self.response(b"", status=404))
+ with self.assertRaisesRegex(QpackHTTPError, "HTTP 404"):
+ self.install(transport, hashes_sha256=pin)
+ self.assertEqual(
+ [call["url"].removeprefix(self.base_url + "/")
+ for call in transport.calls],
+ ["hashes.json", "manifest.json", "config.json"])
+ # The install session opened: manifest validation is behind us and
+ # the journal binds the destination to this index.
+ self.assertTrue((self.root / ".qpack-install.json").is_file())
+ self.assertEqual((self.root / HASHES_NAME).read_bytes(), hashes_raw)
+ self.assertFalse((self.root / "manifest.json").exists())
+ return json.loads(manifest_raw)["files"], json.loads(hashes_raw)["files"]
+
+ def test_real_qwen3_next_80b_index_is_accepted_and_transfers_begin(self):
+ # Before this shape was accepted the installer refused with "qpack
+ # manifest does not declare packed_experts/layout.json" after two
+ # requests and never opened the destination.
+ manifest_files, indexed = self.real_index_probe(
+ "swiftlet_qwen3_next_80b", QWEN3_NEXT_80B_HASHES_SHA256)
+ self.assertEqual(len(manifest_files), 49)
+ self.assertEqual(len(indexed), 61)
+ self.assertNotIn(LAYOUT_NAME, manifest_files)
+ self.assertIn(LAYOUT_NAME, indexed)
+
+ def test_real_qwen36_35b_index_is_still_accepted(self):
+ manifest_files, indexed = self.real_index_probe(
+ "swiftlet_qwen36_35b", QWEN36_35B_HASHES_SHA256)
+ self.assertEqual(len(manifest_files), 47)
+ self.assertEqual(len(indexed), 48)
+ self.assertEqual(manifest_files[LAYOUT_NAME], 2048)
+
+ def test_undeclared_layout_is_fetched_as_a_required_indexed_sidecar(self):
+ self.use_undeclared_layout_shape()
+ hashes_raw = self.hashes_raw(extra={LAYOUT_NAME: self.layout})
+ transport = ScriptedTransport(
+ self.response(hashes_raw), self.response(self.manifest),
+ self.response(self.config), self.response(self.layout),
+ self.artifact_response("model.safetensors"),
+ self.artifact_response("packed_experts/layer_00.bin"))
+
+ result = self.install(transport)
+
+ self.assertEqual(
+ [call["url"].removeprefix(self.base_url + "/")
+ for call in transport.calls],
+ ["hashes.json", "manifest.json", "config.json", LAYOUT_NAME,
+ "model.safetensors", "packed_experts/layer_00.bin"])
+ self.assertEqual(result.downloaded_files, 4)
+ self.assertEqual((self.root / LAYOUT_NAME).read_bytes(), self.layout)
+ self.assertFalse((self.root / "packed_experts" / ".layout.json.part").exists())
+ self.assertEqual((self.root / "manifest.json").read_bytes(), self.manifest)
+ state = json.loads((self.root / ".qpack-http.json").read_text())
+ self.assertEqual(state["aux"][LAYOUT_NAME]["sha256"],
+ hashlib.sha256(self.layout).hexdigest())
+ transport.assert_empty()
+
+ # A completed install re-verifies the sidecar offline, and notices
+ # when it changes.
+ transport = ScriptedTransport(
+ self.response(hashes_raw), self.response(self.manifest))
+ result = self.install(transport)
+ self.assertTrue(result.already_complete)
+ self.assertEqual(len(transport.calls), 2)
+ (self.root / LAYOUT_NAME).write_bytes(b'{"layer_count":2}')
+ with self.assertRaisesRegex(QpackHTTPError, "auxiliary file changed"):
+ self.install(ScriptedTransport(
+ self.response(hashes_raw), self.response(self.manifest)))
+
+ def test_undeclared_layout_absent_from_index_or_mirror_is_refused(self):
+ self.use_undeclared_layout_shape()
+ transport = ScriptedTransport(
+ self.response(self.hashes_raw()), self.response(self.manifest))
+ with self.assertRaisesRegex(
+ QpackHTTPError, f"does not cover required file: {LAYOUT_NAME}"):
+ self.install(transport)
+ self.assertEqual(len(transport.calls), 2)
+ self.assertFalse(self.root.exists())
+
+ hashes_raw = self.hashes_raw(extra={LAYOUT_NAME: self.layout})
+ transport = ScriptedTransport(
+ self.response(hashes_raw), self.response(self.manifest),
+ self.response(self.config), self.response(b"", status=404))
+ with self.assertRaisesRegex(QpackHTTPError, "HTTP 404"):
+ self.install(transport)
+ self.assertTrue(transport.calls[-1]["url"].endswith("/" + LAYOUT_NAME))
+ self.assertFalse((self.root / "model.safetensors.part").exists())
+ self.assertFalse((self.root / "manifest.json").exists())
+
+ # An indexed sidecar that is not a JSON object is refused even
+ # when its hash matches: the reader parses layout.json as an object.
+ root = Path(self.temporary.name) / "not-an-object.qpack"
+ transport = ScriptedTransport(
+ self.response(self.hashes_raw(extra={LAYOUT_NAME: b"[]"})),
+ self.response(self.manifest), self.response(self.config),
+ self.response(b"[]"))
+ with self.assertRaisesRegex(
+ QpackHTTPError, f"{LAYOUT_NAME} must be a non-empty object"):
+ self.install(transport, root=root)
+ self.assertFalse((root / LAYOUT_NAME).exists())
+
+ def test_declared_layout_with_wrong_size_is_refused_before_publication(self):
+ declared = json.loads(self.manifest)
+ declared["files"][LAYOUT_NAME] = len(self.files[LAYOUT_NAME]) + 1
+ self.manifest = json.dumps(
+ declared, sort_keys=True, separators=(",", ":")).encode()
+ transport = ScriptedTransport(
+ self.response(self.hashes_raw()), self.response(self.manifest),
+ self.response(self.config),
+ self.artifact_response("model.safetensors"),
+ self.artifact_response(LAYOUT_NAME))
+ with self.assertRaisesRegex(
+ QpackHTTPError, f"Content-Length mismatch for {LAYOUT_NAME}"):
+ self.install(transport)
+ self.assertFalse((self.root / "manifest.json").exists())
+ self.assertFalse((self.root / LAYOUT_NAME).exists())
+
+ # A sized index disagreeing with the manifest stops before any
+ # transfer at all.
+ sized = json.dumps({
+ "schema": "qpack.hashes.v1",
+ "files": {
+ name: {"sha256": digest, "size": len({
+ "manifest.json": self.manifest,
+ "config.json": self.config,
+ **self.files,
+ }[name])}
+ for name, digest in self.hash_map().items()
+ },
+ }).encode()
+ root = Path(self.temporary.name) / "sized.qpack"
+ transport = ScriptedTransport(
+ self.response(sized), self.response(self.manifest))
+ with self.assertRaisesRegex(
+ QpackHTTPError, f"size mismatch for {LAYOUT_NAME}"):
+ self.install(transport, root=root)
+ self.assertEqual(len(transport.calls), 2)
+ self.assertFalse(root.exists())
+
+ def test_missing_layer_blob_is_still_refused(self):
+ self.use_undeclared_layout_shape()
+ hashes_raw = self.hashes_raw(
+ extra={LAYOUT_NAME: self.layout},
+ omit=("packed_experts/layer_00.bin",))
+ transport = ScriptedTransport(
+ self.response(hashes_raw), self.response(self.manifest))
+ with self.assertRaisesRegex(
+ QpackHTTPError,
+ "does not cover required file: packed_experts/layer_00.bin"):
+ self.install(transport)
+ self.assertEqual(len(transport.calls), 2)
+ self.assertFalse(self.root.exists())
+
+ hashes_raw = self.hashes_raw(extra={LAYOUT_NAME: self.layout})
+ transport = ScriptedTransport(
+ self.response(hashes_raw), self.response(self.manifest),
+ self.response(self.config), self.response(self.layout),
+ self.artifact_response("model.safetensors"),
+ self.response(b"", status=404))
+ with self.assertRaisesRegex(QpackHTTPError, "HTTP 404"):
+ self.install(transport)
+ self.assertTrue(
+ transport.calls[-1]["url"].endswith("/packed_experts/layer_00.bin"))
+ self.assertTrue((self.root / "model.safetensors").is_file())
+ self.assertFalse((self.root / "manifest.json").exists())
+
+ def test_every_request_carries_the_installer_user_agent(self):
+ # Swiftlet's R2 mirror answers 403 to Python-urllib/*; the installer
+ # identifies itself on the index, manifest, sidecar and every ranged
+ # weight request, including a resume.
+ value = self.files["model.safetensors"]
+ first = self.artifact_response("model.safetensors", body=value[:3])
+ first.headers = Headers([("Content-Length", str(len(value)))])
+ interrupted = ScriptedTransport(
+ self.response(self.hashes_raw()), self.response(self.manifest),
+ self.response(self.config), first)
+ with self.assertRaisesRegex(QpackHTTPError, "short HTTP body"):
+ self.install(interrupted)
+ resumed = ScriptedTransport(
+ self.response(self.hashes_raw()), self.response(self.manifest),
+ self.artifact_response("model.safetensors", offset=3),
+ self.artifact_response(LAYOUT_NAME))
+ self.install(resumed, authorization="Bearer mirror-token")
+
+ calls = interrupted.calls + resumed.calls
+ self.assertEqual(len(calls), 8)
+ self.assertTrue(any(call["headers"].get("Range") == "bytes=3-6"
+ for call in calls))
+ for call in calls:
+ with self.subTest(url=call["url"]):
+ self.assertEqual(call["method"], "GET")
+ self.assertEqual(call["headers"]["User-Agent"],
+ "colibri-qpack-install/1.0")
+ self.assertEqual(call["headers"]["Accept-Encoding"], "identity")
+
def test_cross_origin_redirect_strips_all_explicit_secrets(self):
handler = SafeRedirectHandler()
request = Request("https://mirror.example/object", headers={
diff --git a/c/tools/README.md b/c/tools/README.md
index ffc53c0b..c0fab41f 100644
--- a/c/tools/README.md
+++ b/c/tools/README.md
@@ -9,21 +9,27 @@ not runtime dependencies of the C engine.
install session for the full transfer. Qpack v1 has sizes but no content
hashes, so frontends must also enforce immutable revisions and any available
transport checksum or ETag. It covers manifest-declared container artifacts,
- not required runtime auxiliaries such as `config.json`. Directory-fsync crash
- durability is POSIX-only.
+ not required runtime auxiliaries such as `config.json`. Swiftlet manifests
+ vary: the 35B container declares `packed_experts/layout.json` and its
+ tokenizer files, the production Qwen3-Next-80B container declares only the
+ weights, so `layout.json` is verified when declared and never required
+ here. Directory-fsync crash durability is POSIX-only.
- `qpack_http_install.py`: dependency-free Hugging Face frontend for that
policy. It resolves a branch or tag to an immutable commit before opening the
install session, streams manifest-declared files directly into `.part`
files, resumes only exact HTTP ranges, and publishes `manifest.json` last.
- `config.json` is required; manifest-declared tokenizer/configuration files
- use the same resumable artifact path, while undeclared optional files are
- copied as verified sidecars when present. Strong ETags, documented server
+ `config.json` is required, and so is `packed_experts/layout.json`, which
+ the reader opens directly: when the manifest does not declare it, it is
+ fetched as a required sidecar. Manifest-declared tokenizer/configuration
+ files use the same resumable artifact path, while undeclared optional files
+ are copied as verified sidecars when present. Strong ETags, documented server
SHA-256 values, and a locally computed full-file SHA-256 are persisted in
`.qpack-http.json` and checked on resume. `HF_TOKEN` is sent only to the Hub
origin and is stripped on cross-origin HTTPS redirects.
- `qpack_mirror_install.py`: static HTTPS/R2 frontend over the same transfer
engine. A strict `hashes.json` is required and fetched before the manifest;
- it must cover `manifest.json`, `config.json`, and every manifest artifact.
+ it must cover `manifest.json`, `config.json`, `packed_experts/layout.json`,
+ and every manifest artifact.
The legacy Swiftlet `{"files":{"path":"sha256"}}` schema and the sized
`qpack.hashes.v1` schema are accepted. The normalized mirror URL plus the
digest of the exact raw index bytes bind resume state; indexed runtime files receive
diff --git a/c/tools/qpack_http_install.py b/c/tools/qpack_http_install.py
index 07b602ba..80f636a0 100644
--- a/c/tools/qpack_http_install.py
+++ b/c/tools/qpack_http_install.py
@@ -70,6 +70,12 @@ SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$")
REPO_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
REQUIRED_AUX = ("config.json",)
+# Swiftlet's reader opens packed_experts/layout.json directly and never
+# consults the manifest files table for it. The production Qwen3-Next-80B
+# manifest sizes only model.safetensors and the layer blobs, so when the
+# manifest does not declare layout.json it is fetched as a required sidecar
+# (hash-indexed on a mirror) rather than refused.
+LAYOUT_NAME = "packed_experts/layout.json"
OPTIONAL_AUX = (
"tokenizer.json",
"tokenizer_config.json",
@@ -431,6 +437,31 @@ def _declared_auxiliary_names(plan):
return {name for name in (*REQUIRED_AUX, *OPTIONAL_AUX) if name in declared}
+def _aux_temporary_name(name: str) -> str:
+ """The .part path _atomic_bytes uses for an auxiliary, in manifest form."""
+ parent, _separator, leaf = name.rpartition("/")
+ return f"{parent}/.{leaf}.part" if parent else f".{leaf}.part"
+
+
+def _aux_target(root: Path, name: str, create_parent: bool = False) -> Path:
+ """Resolve an auxiliary path under root without crossing a symlink."""
+ parent = root
+ components = name.split("/")
+ for component in components[:-1]:
+ parent = parent / component
+ if parent.is_symlink():
+ raise QpackHTTPError(f"auxiliary path crosses a symlink: {parent}")
+ if parent.exists() and not parent.is_dir():
+ raise QpackHTTPError(f"auxiliary parent is not a directory: {parent}")
+ if create_parent and not parent.exists():
+ parent.mkdir()
+ _fsync_directory(parent.parent)
+ target = parent / components[-1]
+ if target.is_symlink():
+ raise QpackHTTPError(f"refusing symlink auxiliary path: {target}")
+ return target
+
+
def _check_adapter_namespace(plan, reserve_hashes=False) -> None:
reserved = {
STATE_NAME.casefold(),
@@ -441,12 +472,13 @@ def _check_adapter_namespace(plan, reserve_hashes=False) -> None:
HASHES_NAME.casefold(),
f".{HASHES_NAME}.part".casefold(),
))
+ declared = {file.name for file in plan.files}
declared_aux = _declared_auxiliary_names(plan)
- for name in (*REQUIRED_AUX, *OPTIONAL_AUX):
- if name in declared_aux:
+ for name in (*REQUIRED_AUX, *OPTIONAL_AUX, LAYOUT_NAME):
+ if name in declared:
continue
reserved.add(name.casefold())
- reserved.add((f".{name}.part").casefold())
+ reserved.add(_aux_temporary_name(name).casefold())
for file in plan.files:
if file.name in declared_aux and file.size > MAX_AUX_SIZE:
raise QpackHTTPError(
@@ -618,7 +650,7 @@ def _fetch_small(source, name, transport, timeout, maximum, required,
def _verify_or_fetch_aux(session, state, source, name, required, transport,
timeout, retries, sleep, completed,
expected_checksum=None, expected_size=None):
- target = session.root / name
+ target = _aux_target(session.root, name)
recorded = state["aux"].get(name)
if recorded is not None:
if (not isinstance(recorded, dict)
@@ -645,13 +677,14 @@ def _verify_or_fetch_aux(session, state, source, name, required, transport,
expected_size)
if raw is None:
return False, 0
- if name == "config.json":
+ if name in ("config.json", LAYOUT_NAME):
try:
- config = json.loads(raw)
+ document = json.loads(raw)
except (UnicodeError, json.JSONDecodeError) as error:
- raise QpackHTTPError("config.json is not valid JSON") from error
- if not isinstance(config, dict) or not config:
- raise QpackHTTPError("config.json must be a non-empty object")
+ raise QpackHTTPError(f"{name} is not valid JSON") from error
+ if not isinstance(document, dict) or not document:
+ raise QpackHTTPError(f"{name} must be a non-empty object")
+ target = _aux_target(session.root, name, create_parent=True)
_atomic_bytes(target, raw)
state["aux"][name] = {
"sha256": expected_checksum or hashlib.sha256(raw).hexdigest(),
@@ -967,7 +1000,8 @@ def _download_file(session, state, source, file, transport, timeout,
def _validate_hash_coverage(plan, manifest_raw, entries) -> None:
- required = {"manifest.json", "config.json", *(file.name for file in plan.files)}
+ required = {"manifest.json", "config.json", LAYOUT_NAME,
+ *(file.name for file in plan.files)}
missing = sorted(required - entries.keys())
if missing:
raise QpackHTTPError(
@@ -1029,6 +1063,16 @@ def _install_resolved_qpack(source, output_dir, manifest_raw, manifest_etag,
downloaded_files += int(changed)
downloaded_bytes += count
_validate_config(session.root / "config.json")
+ if LAYOUT_NAME not in files_by_name:
+ changed, count = _verify_or_fetch_aux(
+ session, state, source, LAYOUT_NAME, True, transport, timeout,
+ retries, sleep, session.complete,
+ expected_hashes[LAYOUT_NAME].sha256
+ if expected_hashes is not None else None,
+ expected_hashes[LAYOUT_NAME].size
+ if expected_hashes is not None else None)
+ downloaded_files += int(changed)
+ downloaded_bytes += count
if not session.complete:
for name in sorted(declared_aux - {"config.json"}):
changed, count, resumed = _download_file(
diff --git a/c/tools/qpack_install_policy.py b/c/tools/qpack_install_policy.py
index e5941e09..063af9e6 100644
--- a/c/tools/qpack_install_policy.py
+++ b/c/tools/qpack_install_policy.py
@@ -4,6 +4,15 @@
Qpack v1 records file sizes but no content digests. Callers must use an
immutable ``source_id`` and validate any ETag or checksum supplied by the
transport; this module prevents cross-revision resume, not silent media damage.
+
+The manifest files table is the authority for every artifact it declares, and
+nothing else. Swiftlet's own manifests vary in what they declare: the
+Qwen3.6-35B container sizes ``packed_experts/layout.json`` and its tokenizer
+files, while the production Qwen3-Next-80B container sizes only
+``model.safetensors`` and the 48 layer blobs. Swiftlet's reader never consults
+the files table for ``layout.json``, so a declared entry is verified and an
+undeclared one is not required here; frontends that need the file fetch it as
+a required auxiliary, the way they already fetch ``config.json``.
"""
from __future__ import annotations
@@ -149,7 +158,13 @@ def _validate_file(file: QpackFile) -> None:
def parse_manifest(raw: bytes, source_id: str) -> QpackInstallPlan:
- """Parse a qpack v1 manifest and bind it to an immutable source identity."""
+ """Parse a qpack v1 manifest and bind it to an immutable source identity.
+
+ Every declared file must carry a positive size, which the install session
+ then enforces on commit and before publication. ``packed_experts/layout.json``
+ is verified when declared and not required: the production Qwen3-Next-80B
+ manifest omits it (see the module docstring).
+ """
if (not isinstance(source_id, str) or not source_id.strip()
or "\x00" in source_id or len(source_id.encode("utf-8")) > 4096):
raise QpackInstallError("source_id must identify an immutable source revision")
@@ -180,8 +195,6 @@ def parse_manifest(raw: bytes, source_id: str) -> QpackInstallPlan:
file = QpackFile(name, size)
_validate_file(file)
planned.append(file)
- if not any(file.name == "packed_experts/layout.json" for file in planned):
- raise QpackInstallError("qpack manifest does not declare packed_experts/layout.json")
_validate_namespace(planned)
return QpackInstallPlan(
source_id=source_id,