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/.gitattributesnew file mode 100644index 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 -textdiff --git a/c/tests/fixtures/swiftlet_qpack_manifest.json b/c/tests/fixtures/swiftlet_qpack_manifest.jsondeleted file mode 100644index 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.jsonnew file mode 100644index 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 filediff --git a/c/tests/fixtures/swiftlet_qwen36_35b_manifest.json b/c/tests/fixtures/swiftlet_qwen36_35b_manifest.jsonnew file mode 100644index 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 filediff --git a/c/tests/fixtures/swiftlet_qwen3_next_80b_hashes.json b/c/tests/fixtures/swiftlet_qwen3_next_80b_hashes.jsonnew file mode 100644index 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 filediff --git a/c/tests/fixtures/swiftlet_qwen3_next_80b_manifest.json b/c/tests/fixtures/swiftlet_qwen3_next_80b_manifest.jsonnew file mode 100644index 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 filediff --git a/c/tests/test_qpack_http_install.py b/c/tests/test_qpack_http_install.pyindex 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.pyindex 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.pyindex 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 Requestfrom 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.mdindex 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 contenthashes, so frontends must also enforce immutable revisions and any availabletransport 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 thatpolicy. It resolves a branch or tag to an immutable commit before opening theinstall 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 serverSHA-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 Huborigin and is stripped on cross-origin HTTPS redirects.- `qpack_mirror_install.py`: static HTTPS/R2 frontend over the same transferengine. 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 thedigest of the exact raw index bytes bind resume state; indexed runtime files receivediff --git a/c/tools/qpack_http_install.py b/c/tools/qpack_http_install.pyindex 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:continuereserved.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 += countif 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.pyindex 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 animmutable ``source_id`` and validate any ETag or checksum supplied by thetransport; 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,