mcp-3d-printer-server 1.2.25 → 1.2.26

package/src/bambu-network-certs.ts

@@ -0,0 +1,154 @@
+/**
+ * Bambu's public certificates from Bambu Studio v02.08.02.61 resources/cert,
+ * the folder Bambu Studio and FULU's GUI pass to the networking plug-in's
+ * set_cert_file. printer.cer holds the BBL CA roots that sign each printer's
+ * LAN MQTT certificate; slicer_base64.cer is the cloud certificate. FULU's
+ * standalone Linux host runtime ships only slicer_base64.cer, so its plug-in
+ * cannot verify a LAN printer without these. Exact bytes, pinned by SHA-256
+ * (the same pins as scripts/setup-bambu-native.mjs).
+ */
+export const BAMBU_NETWORK_CERTIFICATES: Readonly<Record<"printer.cer" | "slicer_base64.cer", { sha256: string; base64: string }>> = Object.freeze({
+  "printer.cer": {
+    sha256: "36f2bcee347ec7adce719b5fd350099591a4d3d0ec4e039c7019890d78e152a0",
+    base64:
+      "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUZmekNDQTJlZ0F3SUJBZ0lVWHR6UjZ0UmlML1JIQlJYT295RlUwK1hybGlv" +
+      "d0RRWUpLb1pJaHZjTkFRRUwKQlFBd1JqRUxNQWtHQTFVRUJoTUNRMDR4SVRBZkJnTlZCQW9NR0VKQ1RDQlVaV05vYm05c2IyZHBa" +
+      "WE1nUTI4dQpJRXgwWkRFVU1CSUdBMVVFQXd3TFFrSk1JRU5CTWlCU1UwRXdJQmNOTWpVd05qRTNNREV6T0RBNFdoZ1BNakExCk1E" +
+      "QTJNVGN3TVRNNE1EaGFNRVl4Q3pBSkJnTlZCQVlUQWtOT01TRXdId1lEVlFRS0RCaENRa3dnVkdWamFHNXYKYkc5bmFXVnpJRU52" +
+      "TGlCTWRHUXhGREFTQmdOVkJBTU1DMEpDVENCRFFUSWdVbE5CTUlJQ0lqQU5CZ2txaGtpRwo5dzBCQVFFRkFBT0NBZzhBTUlJQ0Nn" +
+      "S0NBZ0VBbzQ1NTBHNGM0MmdUS3pRcWl4d0tUMDg5Uml6SWRacHlPY0dBCjY3OXJQYU9kV3NNcVZ3bllQUDJGcE1xWEtrakZiZWRF" +
+      "K1NwR2xvaTJOS0N1aVBOVlJicTlQSE9PWndUczdZTG8KYk93ZjUzRkp1TzZ2UkZwekZmWDF0bGM5emxGcUp2Wm5ZTzlOZ0hwTXlz" +
+      "aWRvY1djZ3JETi9TSUR5d2dQQjVDVgpiWWczVnZ6dWE5ZndaeDllNUtUOXhkNUlwVHFkVHJXUzQ3alFPVktMaGRRQ2JKRklsTXJi" +
+      "bE93TEJBeCtmSG9rCndxaDZ0a0k2S3R1eXlqdzhEeXNlYmkxbmRXakt0WjJtVzQ3cjh4Wi9KK3ozRVpxY3lKTVk2TVJ0eC96YjFq" +
+      "QkYKdUh0a2pyYjVLdjFETXpTS2xrYU5KSWJ2QytNaytoSTk3VytTakxTUnVJZEM3K29KVXpXYVN6Z3U5Y2pYQ1ZmbQpxOHQ0SUwv" +
+      "MzVoUDY5UEs5NUxnTGVjdElyUDk2Q1lBVC9hVk1HMTlGckZXMFFXRXlmVCtrekc0amt1bWZQYkhxClkybk5rRU4wK3RqajNoNFdk" +
+      "enJXZ1FFb2pLL2xoZmNSRlZrdHM3NCthWm9NcFFQK3ZtTDE3Q0ttU3pYazVvL2UKSzIxeGd4SmR6TWJkenRmVHBpYmlYazBhYmZP" +
+      "cE4rMVZSKzNOWWErYlJPQUtOeUdhUmVFR3N5VzJiamNqTng1MQo1VnF6ajNTVnhoTVNwNXZmRjlFNEExakU5OU0vbDlqUURNNlJ6" +
+      "a1QwbE1jY0dBZDV0VVNkTnZEbHJxdFFhUWlLCnYvWnNYUGdYTFRXZk9wdmFMTkVnd2RNZ1pNdWhqcGt3dkFaeW9ZZmVGOWt5eWRq" +
+      "RGg3YnZyWC8vY3ovVm9wQVUKbHhVdFF0TUNBd0VBQWFOak1HRXdIUVlEVlIwT0JCWUVGTlZKZ1FhZDFzTlROMGp4Vmt3YkovWE0x" +
+      "YW4xTUI4RwpBMVVkSXdRWU1CYUFGTlZKZ1FhZDFzTlROMGp4Vmt3YkovWE0xYW4xTUE4R0ExVWRFd0VCL3dRRk1BTUJBZjh3CkRn" +
+      "WURWUjBQQVFIL0JBUURBZ0VHTUEwR0NTcUdTSWIzRFFFQkN3VUFBNElDQVFCRlpES01KZnAvTjRnQmVGSGgKTWlGZWhhVXlNUzZl" +
+      "OW16clRmTUxKTEpvajZKb3BhOVY5aklmY0NFQkdadVJUaHFGY0FUVitVZEZIU0lOcFVjSAp1cGNDWW5helRSQzRkbjFobnhuUTFv" +
+      "alFjSHhkR3A5eEd3L1ljbEFLRDk3ZDhiUFNoZkJNVDF0bzl6Yk1LN1Q1Ckw4emdxZzAxWUlPS2pRazBIY2QwKzBpVXI2bTh6UTVQ" +
+      "OFJsM1FYcUF5ZVdncW1ZUXJyalRXd1BzZ2RmSE5YS1gKdkRyeDcvY3FyeTVsS1U4MDJoVXBsS01CeGVsdjRXODQwN1l0ajFsZkpP" +
+      "d3Z4cXh4c0ZVNWpTd2NVRzN6bzJ2awpRdGpSczhtNUJLdXA1SzFPUFlra1B1N0xkODlYMFhwVTA3My9kTkRHMTF1eGIxZURLcnRO" +
+      "UDZ2WnVaak5FMlBxCjhIQ29JMUV0UCtJdHlxdFVNdkhpNloyenNtbEEyNWJyb1Zpb2VVS3hqbEllY3BROUpSL0ZoRHU5Q1dORi9u" +
+      "RFcKTFNPUk5hTU16Z3NNU3pJK0hDaVVocU4rcU1JdlZQNnJ6R1RKendxei9sYzVMZitaUENuR0E5V0pUVDR1UEloZgp1ZmJabW5V" +
+      "SjM1V3VXS0h4b3ZEc3FCaDg4elE5c1orZWk0SGk0dlZ6T2hVZ2ZHM2FMb1NRRVlxUm9xYWJvQU5oCndDd3p5dVcyUnY1NHU1UVNC" +
+      "YmQ2R3gxT3B2c1dtTFBXZDIvaUwya0lTbDV3Zm1MR1Z5ZHZTSmErcmJPZnVBeTcKeWNWUWFjVkRRQ0FuYmhvVnJReTcrNDU0UXNL" +
+      "U1czWlY2QmN5UnJvcmV3Q3lDWWdkN255eGZseEhaVEJFeWtYWApoYUdOZS9LRk52SkJNT0l1SVV6a25SUm1pUT09Ci0tLS0tRU5E" +
+      "IENFUlRJRklDQVRFLS0tLS0KLS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUI4ekNDQVptZ0F3SUJBZ0lVZTYxakdRNFJ6" +
+      "SUM4aytzTnVxYkkvQ2FOcVBJd0NnWUlLb1pJemowRUF3SXcKUmpFTE1Ba0dBMVVFQmhNQ1EwNHhJVEFmQmdOVkJBb01HRUpDVENC" +
+      "VVpXTm9ibTlzYjJkcFpYTWdRMjh1SUV4MApaREVVTUJJR0ExVUVBd3dMUWtKTUlFTkJNaUJGUTBNd0lCY05NalV3TmpFM01ERXpP" +
+      "RE0xV2hnUE1qQTFNREEyCk1UY3dNVE00TXpWYU1FWXhDekFKQmdOVkJBWVRBa05PTVNFd0h3WURWUVFLREJoQ1Frd2dWR1ZqYUc1" +
+      "dmJHOW4KYVdWeklFTnZMaUJNZEdReEZEQVNCZ05WQkFNTUMwSkNUQ0JEUVRJZ1JVTkRNRmt3RXdZSEtvWkl6ajBDQVFZSQpLb1pJ" +
+      "emowREFRY0RRZ0FFcEtURjd3UlN0eTREWHBHSnpnQ1B3Umg4Z2hMbHhVQzNxSmJ5RWdMcVR2SmdiaXdZCkFQUEhLN2tWYlZtZXJr" +
+      "cWhIT1Q0UWVXUmxURzNkT1FHTEEyVnBhTmpNR0V3SFFZRFZSME9CQllFRkt1UnBzalkKUkVPeUlLSDdId09FNmpoR0JkNk5NQjhH" +
+      "QTFVZEl3UVlNQmFBRkt1UnBzallSRU95SUtIN0h3T0U2amhHQmQ2TgpNQThHQTFVZEV3RUIvd1FGTUFNQkFmOHdEZ1lEVlIwUEFR" +
+      "SC9CQVFEQWdFR01Bb0dDQ3FHU000OUJBTUNBMGdBCk1FVUNJRXJCaVVtM1ZkdFAzcno0a2I4YUxwSTVwK0J6TDdNOXZFbEJHV1dK" +
+      "eHBITUFpRUEzcjV0SldWR3d1eGkKWUNyQjFjNDBLWUZSRnlhaEdyaE9KWkFqL1loUmRuVT0KLS0tLS1FTkQgQ0VSVElGSUNBVEUt" +
+      "LS0tLQotLS0tLUJFR0lOIENFUlRJRklDQVRFLS0tLS0KTUlJRWVUQ0NBMkdnQXdJQkFnSVVPcStsTklhQzJ4c3N3a0ZxajVKUHlW" +
+      "Qmw0NWN3RFFZSktvWklodmNOQVFFTApCUUF3UWpFTE1Ba0dBMVVFQmhNQ1EwNHhJakFnQmdOVkJBb01HVUpDVENCVVpXTm9ibTlz" +
+      "YjJkcFpYTWdRMjh1CkxDQk1kR1F4RHpBTkJnTlZCQU1NQmtKQ1RDQkRRVEFlRncweU5UQTJNVGN3TWpBeE1qZGFGdzB6TlRBMk1U" +
+      "VXcKTWpBeE1qZGFNRVl4Q3pBSkJnTlZCQVlUQWtOT01TRXdId1lEVlFRS0RCaENRa3dnVkdWamFHNXZiRzluYVdWegpJRU52TGlC" +
+      "TWRHUXhGREFTQmdOVkJBTU1DMEpDVENCRFFUSWdVbE5CTUlJQ0lqQU5CZ2txaGtpRzl3MEJBUUVGCkFBT0NBZzhBTUlJQ0NnS0NB" +
+      "Z0VBbzQ1NTBHNGM0MmdUS3pRcWl4d0tUMDg5Uml6SWRacHlPY0dBNjc5clBhT2QKV3NNcVZ3bllQUDJGcE1xWEtrakZiZWRFK1Nw" +
+      "R2xvaTJOS0N1aVBOVlJicTlQSE9PWndUczdZTG9iT3dmNTNGSgp1TzZ2UkZwekZmWDF0bGM5emxGcUp2Wm5ZTzlOZ0hwTXlzaWRv" +
+      "Y1djZ3JETi9TSUR5d2dQQjVDVmJZZzNWdnp1CmE5ZndaeDllNUtUOXhkNUlwVHFkVHJXUzQ3alFPVktMaGRRQ2JKRklsTXJibE93" +
+      "TEJBeCtmSG9rd3FoNnRrSTYKS3R1eXlqdzhEeXNlYmkxbmRXakt0WjJtVzQ3cjh4Wi9KK3ozRVpxY3lKTVk2TVJ0eC96YjFqQkZ1" +
+      "SHRranJiNQpLdjFETXpTS2xrYU5KSWJ2QytNaytoSTk3VytTakxTUnVJZEM3K29KVXpXYVN6Z3U5Y2pYQ1ZmbXE4dDRJTC8zCjVo" +
+      "UDY5UEs5NUxnTGVjdElyUDk2Q1lBVC9hVk1HMTlGckZXMFFXRXlmVCtrekc0amt1bWZQYkhxWTJuTmtFTjAKK3RqajNoNFdkenJX" +
+      "Z1FFb2pLL2xoZmNSRlZrdHM3NCthWm9NcFFQK3ZtTDE3Q0ttU3pYazVvL2VLMjF4Z3hKZAp6TWJkenRmVHBpYmlYazBhYmZPcE4r" +
+      "MVZSKzNOWWErYlJPQUtOeUdhUmVFR3N5VzJiamNqTng1MTVWcXpqM1NWCnhoTVNwNXZmRjlFNEExakU5OU0vbDlqUURNNlJ6a1Qw" +
+      "bE1jY0dBZDV0VVNkTnZEbHJxdFFhUWlLdi9ac1hQZ1gKTFRXZk9wdmFMTkVnd2RNZ1pNdWhqcGt3dkFaeW9ZZmVGOWt5eWRqRGg3" +
+      "YnZyWC8vY3ovVm9wQVVseFV0UXRNQwpBd0VBQWFOak1HRXdEd1lEVlIwVEFRSC9CQVV3QXdFQi96QU9CZ05WSFE4QkFmOEVCQU1D" +
+      "QVFZd0hRWURWUjBPCkJCWUVGTlZKZ1FhZDFzTlROMGp4Vmt3YkovWE0xYW4xTUI4R0ExVWRJd1FZTUJhQUZJODBRbWpjWjA2UHhD" +
+      "S2UKeFh4SjVhdmRSTDRlTUEwR0NTcUdTSWIzRFFFQkN3VUFBNElCQVFBdlM4dHlmYWdhR3NGZjlZbmNBMmtvL05hNQo5QlZGKzhU" +
+      "bFVvKzMyb3pud0lWcFMxQWhTZ0xQNnJOVmVrWE5GS2J1UDVodHVkTFExN1pSQkpJL1VNVnlZRURxCklON3h2N1pqK3pKd0Y2VzZo" +
+      "YVlyamIyVms4aWd3MVh2TlVMWmZ2Vk5OS0lrdkpVaVZxRXNsV3JDK2s3NGNyay8KV3Y4Q2hWZit6cXZmSU42TFYzZXNhR1JMMDJK" +
+      "M0FwclFHYjdERGhSMUVlZlFNU2NEa05wR0pNVW12Q21ma25ybAppSzhxZ3ZRTjFTV083SlJmNmZOS0hzTjFaUXZ5UDBwZ0xXeHBU" +
+      "M1YwLzAvV3R0cVgzY01HdUpGK2pWVXptL05oCnhZaEZld0c4dmMzS3pUam53UUFwTUE2Q1c1NTRGT0pXRnlPRDJqbjV5SkxUM1Z1" +
+      "ZSthWURRUnA0YktNeAotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCi0tLS0tQkVHSU4gQ0VSVElGSUNBVEUtLS0tLQpNSUlDcmpD" +
+      "Q0FaYWdBd0lCQWdJVU9xK2xOSWFDMnhzc3drRnFqNUpQeVZCbDQ1Z3dEUVlKS29aSWh2Y05BUUVMCkJRQXdRakVMTUFrR0ExVUVC" +
+      "aE1DUTA0eElqQWdCZ05WQkFvTUdVSkNUQ0JVWldOb2JtOXNiMmRwWlhNZ1EyOHUKTENCTWRHUXhEekFOQmdOVkJBTU1Ca0pDVENC" +
+      "RFFUQWVGdzB5TlRBMk1UY3dNakF4TkRkYUZ3MHpOVEEyTVRVdwpNakF4TkRkYU1FWXhDekFKQmdOVkJBWVRBa05PTVNFd0h3WURW" +
+      "UVFLREJoQ1Frd2dWR1ZqYUc1dmJHOW5hV1Z6CklFTnZMaUJNZEdReEZEQVNCZ05WQkFNTUMwSkNUQ0JEUVRJZ1JVTkRNRmt3RXdZ" +
+      "SEtvWkl6ajBDQVFZSUtvWkkKemowREFRY0RRZ0FFcEtURjd3UlN0eTREWHBHSnpnQ1B3Umg4Z2hMbHhVQzNxSmJ5RWdMcVR2Smdi" +
+      "aXdZQVBQSApLN2tWYlZtZXJrcWhIT1Q0UWVXUmxURzNkT1FHTEEyVnBhTmpNR0V3RHdZRFZSMFRBUUgvQkFVd0F3RUIvekFPCkJn" +
+      "TlZIUThCQWY4RUJBTUNBUVl3SFFZRFZSME9CQllFRkt1UnBzallSRU95SUtIN0h3T0U2amhHQmQ2Tk1COEcKQTFVZEl3UVlNQmFB" +
+      "Rkk4MFFtamNaMDZQeENLZXhYeEo1YXZkUkw0ZU1BMEdDU3FHU0liM0RRRUJDd1VBQTRJQgpBUUNnNlBqVVNTWlYrNGJ2ZWpjVk12" +
+      "Z1htS3pmRDk1b3NXbjBjdG5vTUJ4UERhK20rR2crQmNMVDJJbEZBZTNFCktZTXZ1NFQyOTVXUWM5MnJqS1lxVzZjaXJGcHBuZzl1" +
+      "RUZXMm1aTGlteGFTbXV0c1RmdEUzc2JNVk1KL1NMWU4KUFY3VEZ2Nm1jQlNJRldYd21CT0lwYmg0QlVjVmZPTlR2ZFNmSXFmeUFW" +
+      "eHNxNHh6YzJuYzZoUEJwQW0yMUF5agpUb0MxZXYvVGJESjhWbGxGWmlFVm1XV2xJUDNhTnpBbThTMm1PcHhQQjJXbmFuYVpIU3J2" +
+      "WExGaHN0eXp3cmpECnlPMS9pc09aN3d0cjdyY3VUSmRFdnZ2Q2ltT1psa2ZSaGFEb1Rldzl0UTBFMkZWcHp6U2ludzAycW1RMXhJ" +
+      "RTkKNS9INVp6SlNQa3BlQUhXRVBuS2t4ZzB2Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0KLS0tLS1CRUdJTiBDRVJUSUZJQ0FU" +
+      "RS0tLS0tCk1JSURaVENDQWsyZ0F3SUJBZ0lVVjFGY2t3WEVseWVrMW9uRm5ROWtMN0JrNE44d0RRWUpLb1pJaHZjTkFRRUwKQlFB" +
+      "d1FqRUxNQWtHQTFVRUJoTUNRMDR4SWpBZ0JnTlZCQW9NR1VKQ1RDQlVaV05vYm05c2IyZHBaWE1nUTI4dQpMQ0JNZEdReER6QU5C" +
+      "Z05WQkFNTUJrSkNUQ0JEUVRBZUZ3MHlNakEwTURRd016UXlNVEZhRncwek1qQTBNREV3Ck16UXlNVEZhTUVJeEN6QUpCZ05WQkFZ" +
+      "VEFrTk9NU0l3SUFZRFZRUUtEQmxDUWt3Z1ZHVmphRzV2Ykc5bmFXVnoKSUVOdkxpd2dUSFJrTVE4d0RRWURWUVFEREFaQ1Frd2dR" +
+      "MEV3Z2dFaU1BMEdDU3FHU0liM0RRRUJBUVVBQTRJQgpEd0F3Z2dFS0FvSUJBUURMM3BuRGR4R09rNVo2dnVnaVQ0ZHBNMGp1KzNY" +
+      "YXR4ejA5VVk3bWJqNHRrSWRieTRICm9lRWRpWVNaamM1TEpuZ0p1Q0h3dEViQkp0MUJyaVJkU1ZyRjZNOUQyVWFCRHlhbUVvMGR4" +
+      "d1NhVnhaaURWV0MKZWVDUGRFTHBGWmRFaFNOVGFUNE83emd2Y25Gc2ZITWEvMHZNQWt2RTdpMHFwM21qRXpZTGZ6NjBheGNEb0pM" +
+      "awpwN242eEtYSStjSmJBNElsVG9GanBTbGRQbUMreW5PbzdZQU9zWHQ3QVlLWTZHbHowQndVVnpTSnhVKy8rVkZ5Ci9Rcm1ZR053" +
+      "bHJRdGRSRUhlUmkwU05LMzJ4MStiT25kZkpQMHNvanVJckRqS3NkQ0x5ZTVDU1pJdnFuYm93d1cKMWpSd1pnVEJSMjlacDJuekNv" +
+      "eEpZY1U5VFNRcC80S1p1V05WQWdNQkFBR2pVekJSTUIwR0ExVWREZ1FXQkJTUApORUpvM0dkT2o4UWluc1Y4U2VXcjNVUytIakFm" +
+      "QmdOVkhTTUVHREFXZ0JTUE5FSm8zR2RPajhRaW5zVjhTZVdyCjNVUytIakFQQmdOVkhSTUJBZjhFQlRBREFRSC9NQTBHQ1NxR1NJ" +
+      "YjNEUUVCQ3dVQUE0SUJBUUFCbEJJVDVaZUcKZmdjSzFMT2gxQ045c1R6eE1DTGJ0VFBGRjFOR0dBMTNtQXB1NmoxaDVZRUxiU0tj" +
+      "VXFmWHpNblZlQWIwNkh0dQozQ29Db2Urd2o3TE9OVEZPKyt2Qm0yL2lmNkp0L0RVdzFDQUVjTnlxZWg2RVMwTlg4TEpSVlNlMHFk" +
+      "VHhQSnVBCkJkT29vOTZpWDg5clJQb3hlZWQxY3BxNWhad2Jla2EzK0NKR1Y3Nml0V3AzNVVwNXJtbVVxcmx5UU9yL1dheDYKaXRv" +
+      "c0l6RzBNZmhnVXpVNTFBMlAvaFNuRDNORE1Ydit3VVkvQXZxZ0lMN3U3ZmJES25rdTFHekVLSWtmSDhobQpSczZkOFNDVTg5eHly" +
+      "d3pRMFBSODUzaXJIYXMzV3JIVnFhYjNQK3FOd1IwWWlyTDBRazdYdC9xM08xZ3JpTmcyCkJsYmpnM29icEhvOQotLS0tLUVORCBD" +
+      "RVJUSUZJQ0FURS0tLS0t",
+  },
+  "slicer_base64.cer": {
+    sha256: "f504dc1c37bc9741b7a95198914e67f3f6f1d917b1e45eaa14b9e84eb7b51ec8",
+    base64:
+      "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUY3ekNDQk5lZ0F3SUJBZ0lRQm5XSDBPTmY1dE1XNlZyNXhtWXhEREFOQmdr" +
+      "cWhraUc5dzBCQVFzRkFEQloKTVFzd0NRWURWUVFHRXdKVlV6RVZNQk1HQTFVRUNoTU1SR2xuYVVObGNuUWdTVzVqTVRNd01RWURW" +
+      "UVFERXlwUwpZWEJwWkZOVFRDQlVURk1nUkZZZ1VsTkJJRTFwZUdWa0lGTklRVEkxTmlBeU1ESXdJRU5CTFRFd0hoY05NakV3Ck56" +
+      "RXpNREF3TURBd1doY05Nakl3TnpFek1qTTFPVFU1V2pBWk1SY3dGUVlEVlFRRERBNHFMbUpoYldKMWJHRmkKTG1OdmJUQ0NBU0l3" +
+      "RFFZSktvWklodmNOQVFFQkJRQURnZ0VQQURDQ0FRb0NnZ0VCQUt4c3pMZGpBS21TMkpscQpaNTI4WkVsM0VxWkd2MWp1UnZ2TTR4" +
+      "cCtvcGVNWENzMWpLc2IxV2ZpZUZBL0tqWEJ6NG51ZVpzRkxhYnB5aXBBCjlvUFBkOG9HajhzWjRoOENJYk1iejJHeG1VVktUb1Ra" +
+      "OWYzd1lwMHNXRFVQVHhoWEd3L0p6cXk2bWN3cWhvQ08KUWJWck5hUUNxUXVOcElLTWx2UFg1YUsxQTBRL0FzZE4ybXBWdFNHMENw" +
+      "cGNSZjVaRTQyelZGUGcxaWVReGdpSAp3NkxXTGlaM0NHcHRueVAxc0JsSUx6VTQ4cXJoMUQwN1ptdUVITDA1cEo3ZFFBc2hzK0Jr" +
+      "bFJ6eXpUZ2lVKzFlCitRZVBGYXExRG9zekZlMndMS3Z1UjhPL1JaOGZGS0pzTnlodE80b21jMklTR3ZSb3lrN3FLU3JGUU9jNG1l" +
+      "a1kKMDJzSUZHVUNBd0VBQWFPQ0F2RXdnZ0x0TUI4R0ExVWRJd1FZTUJhQUZLU041YjU4ZWVSd0kyMHVLVFN0STFqYwo5VEYvTUIw" +
+      "R0ExVWREZ1FXQkJUUDIrTDR0YjJhOGZsMXBPWSt6RmxBNEdOamtqQW5CZ05WSFJFRUlEQWVnZzRxCkxtSmhiV0oxYkdGaUxtTnZi" +
+      "WUlNWW1GdFluVnNZV0l1WTI5dE1BNEdBMVVkRHdFQi93UUVBd0lGb0RBZEJnTlYKSFNVRUZqQVVCZ2dyQmdFRkJRY0RBUVlJS3dZ" +
+      "QkJRVUhBd0l3UGdZRFZSMGdCRGN3TlRBekJnWm5nUXdCQWdFdwpLVEFuQmdnckJnRUZCUWNDQVJZYmFIUjBjRG92TDNkM2R5NWth" +
+      "V2RwWTJWeWRDNWpiMjB2UTFCVE1JR0ZCZ2dyCkJnRUZCUWNCQVFSNU1IY3dKQVlJS3dZQkJRVUhNQUdHR0doMGRIQTZMeTl2WTNO" +
+      "d0xtUnBaMmxqWlhKMExtTnYKYlRCUEJnZ3JCZ0VGQlFjd0FvWkRhSFIwY0RvdkwyTmhZMlZ5ZEhNdVpHbG5hV05sY25RdVkyOXRM" +
+      "MUpoY0dsawpVMU5NVkV4VFJGWlNVMEZOYVhobFpGTklRVEkxTmpJd01qQkRRUzB4TG1OeWREQUpCZ05WSFJNRUFqQUFNSUlCCmZn" +
+      "WUtLd1lCQkFIV2VRSUVBZ1NDQVc0RWdnRnFBV2dBZGdBcGViN3duams1SWZCV2M1OWpwWGZsdmxkOW5HQUsKK1BsTlhTWmNKVjNI" +
+      "aEFBQUFYcWVwZEJsQUFBRUF3QkhNRVVDSUcrQVVPdnNqV1VIMDdBK0FaTkNyVVJackxYLwo2MldSVXcrM2FTWlhxSG8vQWlFQW9r" +
+      "c1dpMm13bTZrNEZDZW45VThNeTNJbmVEU1lxbnY3K2JoODhLOExrdHdBCmRnQlJvN0QxL1FGNW5GWnR1RGQ0and5a2Vzd2JKOHYz" +
+      "bm9oQ21nMysxSXNGNVFBQUFYcWVwZERWQUFBRUF3QkgKTUVVQ0lRRDZLYk5YRWZaT1pnN1MvdURIRlRWY00xczByemw0ZWtQNFhW" +
+      "cHlRSHQ5MkFJZ0pVbndQMzlDY1NjTwppZ1dZSm1yeGpCQTMxR25XajE4THVLeURWMWpYSmNRQWRnQkJ5TXF4M3lKR1NoREdvVG9K" +
+      "UW9kZVRqR0xHd1ByCjYwdkhhUENRWXBZRzlnQUFBWHFlcGRCRUFBQUVBd0JITUVVQ0lRQ3Y3dWZlY21CVmhwbVF1aUpFV1R6dFkw" +
+      "ck4KbnBnWnZnQlVNL3ppVlo0d1VBSWdRQXVHbUM5KzZzbkQwUklud3R0Ly9WdmRZcERYT2RpVVN3ZG4zdXc0NXNjdwpEUVlKS29a" +
+      "SWh2Y05BUUVMQlFBRGdnRUJBTEJSMFhuSFNBRm0zODN3TDM0VGcvZnFjdWtwWUFFTGZ4MG9zczVpCnZGUWhERUZndVovUXhjaDcw" +
+      "UmZBTnYyK0hETFVKNUJIWmZFRnpPQVZFc2xlalBEL2xPZFZKZVozWGE3azhXZXAKZDJudi9hVmR1UmlUOUc4Q0JFa3MrVWxXKzlW" +
+      "NmwvWVB5YThJMWh4bWRLWm5YWlhrSm1kOUJia1A4SndieHNzcApxUEYzRzlkc1Y1RTBab0RTWkZuOXgzSkpIM1QzNUZkSXJ4b0sv" +
+      "K3MvK3ZvbzdPbkRPWkdqekZrRjUrWW00ajZ1Cks2dW9vMVRXSmFDOW1NQ2FiNElneXJ5alNiVlNvNDlROUdsdXRvaGR2aEZrNEhD" +
+      "SWRmejJ3M0JYM29XdFJ3LzIKdUtLTHlEamRYeWYzVFlqWWFTYmJhblNmRDEycGQwWUsyejAvK0daUHZoMUtiN1E9Ci0tLS0tRU5E" +
+      "IENFUlRJRklDQVRFLS0tLS0KLS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURyekNDQXBlZ0F3SUJBZ0lRQ0R2Z1ZwQkNS" +
+      "ckdoZFdySldaSEhTakFOQmdrcWhraUc5dzBCQVFVRkFEQmgKTVFzd0NRWURWUVFHRXdKVlV6RVZNQk1HQTFVRUNoTU1SR2xuYVVO" +
+      "bGNuUWdTVzVqTVJrd0Z3WURWUVFMRXhCMwpkM2N1WkdsbmFXTmxjblF1WTI5dE1TQXdIZ1lEVlFRREV4ZEVhV2RwUTJWeWRDQkhi" +
+      "RzlpWVd3Z1VtOXZkQ0JEClFUQWVGdzB3TmpFeE1UQXdNREF3TURCYUZ3MHpNVEV4TVRBd01EQXdNREJhTUdFeEN6QUpCZ05WQkFZ" +
+      "VEFsVlQKTVJVd0V3WURWUVFLRXd4RWFXZHBRMlZ5ZENCSmJtTXhHVEFYQmdOVkJBc1RFSGQzZHk1a2FXZHBZMlZ5ZEM1agpiMjB4" +
+      "SURBZUJnTlZCQU1URjBScFoybERaWEowSUVkc2IySmhiQ0JTYjI5MElFTkJNSUlCSWpBTkJna3Foa2lHCjl3MEJBUUVGQUFPQ0FR" +
+      "OEFNSUlCQ2dLQ0FRRUE0anZoRVhMZXFLVFRvMWVxVUtLUEMzZVF5YUtsN2hMT2xsc0IKQ1NETUFaT25UakMzVS9kRHhHa0FWNTNp" +
+      "alNMZGh3WkFBSUVKenM0Ymc3L2Z6VHR4UnVMV1pzY0ZzM1luRm85NwpuaDZWZmU2M1NLTUkydGF2ZWd3NUJtVi9TbDBmdkJmNHE3" +
+      "N3VLTmQwZjNwNG1WbUZhRzVjSXpKTHYwN0E2RnB0CjQzQy9keEMvL0FIMmhkbW9SQkJZTXFsMUdOWFJvcjVINGlkcTlKb3orRWtJ" +
+      "WUl2VVg3UTZoTCtocWtwTWZUN1AKVDE5c2RsNmdTemVSbnR3aTVtM09GQnFPYXN2K3piTVVaQmZIV3ltZU1yL3k3dnJUQzBMVXE3" +
+      "ZEJNdG9NMU8vNApnZFc3alZnL3RSdm9TU2lpY05veEJOMzNzaGJ5VEFwT0I2anRTajFldFgramtNT3ZKd0lEQVFBQm8yTXdZVEFP" +
+      "CkJnTlZIUThCQWY4RUJBTUNBWVl3RHdZRFZSMFRBUUgvQkFVd0F3RUIvekFkQmdOVkhRNEVGZ1FVQTk1UU5WYlIKVEx0bThLUGlH" +
+      "eHZEbDdJOTBWVXdId1lEVlIwakJCZ3dGb0FVQTk1UU5WYlJUTHRtOEtQaUd4dkRsN0k5MFZVdwpEUVlKS29aSWh2Y05BUUVGQlFB" +
+      "RGdnRUJBTXVjTjZwSUV4SUsrdDFFbkU5U3NQVGZyZ1QxZVhrSW95UVkvRXNyCmhNQXR1ZFhIL3ZUQkgxakx1RzJjZW5Ubm1DbXJF" +
+      "YlhqY0tDaHpVeUltWk9Na1hEaXF3OGN2cE9wLzJQVjVBZGcKMDZPL25Wc0o4ZFdPNDFQMGptUDZQNmZidEdiZlltYlcwVzVCamZJ" +
+      "dHRlcDNTcCtkV09JcldjQkFJKzB0S0lKRgpQbmxVa2lhWTRJQklxRGZ2OE5aNVlCYmVyT2dPelc2c1JCYzRMMG5hNFVVK0tyazJV" +
+      "ODg2VUFiM0x1akVWMGxzCllTRVkxUVN0ZUR3c09vQnJwK3V2RlJUcDJJbkJ1VGhzNHBGc2l2OWt1WGNsVnpEQUd5U2o0ZHpwMzBk" +
+      "OHRiUWsKQ0FVdzdDMjlDNzlGdjFDNXFmUHJtQUVTcmNpSXhwZzBYNDBLUE1icDFaV1ZiZDQ9Ci0tLS0tRU5EIENFUlRJRklDQVRF" +
+      "LS0tLS0K",
+  },
+});

package/src/control-reply.ts

@@ -0,0 +1,41 @@
+/**
+ * The printer's answer to Pause, Resume or Stop, shared by every route (FULU's local network and Bambu Cloud,
+ * and the direct local network a printer in LAN Only + Developer Mode takes).
+ */
+
+export type ControlReply = { accepted: boolean; errCode: number };
+
+/**
+ * The printer's answer to a control it was sent: it echoes command and sequence_id, with
+ * err_code set when it refuses. A P1S on authorization firmware signs it: {"header":{...},"print":{...}}.
+ */
+export function controlReply(msg: unknown, command: string, sequenceId: string): ControlReply | undefined {
+  if (typeof msg !== "string" || !msg.includes(sequenceId)) return undefined;
+  let print: any;
+  try { print = JSON.parse(msg)?.print; } catch { return undefined; }
+  if (print?.command !== command || String(print.sequence_id) !== sequenceId) return undefined;
+  const errCode = Number(print.err_code ?? 0) || 0;
+  const failed = typeof print.result === "string" && print.result.toLowerCase() !== "success";
+  return { accepted: errCode === 0 && !failed, errCode };
+}
+
+/**
+ * The printer's command verification refused the envelope. These codes do not
+ * establish that third-party controls are unsupported: P1S 01.10 also returns
+ * 0x0502400A for a valid signature with a sequence ID outside the Studio window.
+ */
+export function isAuthorizationRefusal(errCode: number): boolean {
+  const code = errCode >>> 0;
+  return code >= 0x05024007 && code <= 0x0502400B;
+}
+
+/** What to tell a person about a refused control. direct: the control went straight to the printer (Developer Mode connection). */
+export function refusedControlMessage(command: string, route: string, errCode: number, direct = false): string {
+  const word = `${command[0]!.toUpperCase()}${command.slice(1)}`;
+  const code = (errCode >>> 0).toString(16).toUpperCase().padStart(8, "0");
+  if (!isAuthorizationRefusal(errCode)) return `The printer refused ${word} over ${route} (error ${code}). Nothing changed on the printer.`;
+  const message = `The printer refused ${word} (error ${code}): its command verification failed. `;
+  return message + (direct
+    ? "Check LAN Only and Developer Mode for the direct connection, or choose an authenticated Local network or Bambu Cloud connection."
+    : "Check the authenticated connection and signing setup for this printer.");
+}

package/src/counterpart/camera-sources.ts

@@ -0,0 +1,102 @@
+import {Agent as HttpAgent, type IncomingMessage} from "node:http";
+import {Agent as HttpsAgent} from "node:https";
+import {isAxiosError, type AxiosInstance} from "axios";
+import type {OpenCameraSource} from "./camera-stream.js";
+
+type Handlers = Parameters<OpenCameraSource>[0];
+export type CameraUrl = {url: string; headers: Record<string, string>};
+const MAX_BYTES = 5_000_000;
+
+/** Same bounded JPEG framing as the Bambu stream; native code decodes pixels. */
+export function mjpegParser(onFrame: (bytes: Buffer) => void, onError: (error: Error) => void): (chunk: Buffer) => void {
+  let buffer = Buffer.alloc(0), failed = false;
+  return chunk => {
+    if (failed) return;
+    buffer = Buffer.concat([buffer, chunk]);
+    for (;;) {
+      const start = buffer.indexOf(Buffer.from([0xff, 0xd8]));
+      if (start < 0) { buffer = buffer.subarray(Math.max(0, buffer.length - 1)); return; }
+      if (start) buffer = buffer.subarray(start);
+      const end = buffer.indexOf(Buffer.from([0xff, 0xd9]), 2);
+      if ((end >= 0 ? end + 2 : buffer.length) > MAX_BYTES) {
+        failed = true; onError(new Error("Camera JPEG too large")); return;
+      }
+      if (end < 0) return;
+      onFrame(Buffer.from(buffer.subarray(0, end + 2))); buffer = buffer.subarray(end + 2);
+    }
+  };
+}
+
+/** One persistent MJPEG response, or serialized snapshot requests on one keep-alive socket. */
+export function openHttpCameraSource(http: AxiosInstance, plan: {urls: CameraUrl[]; snapshots?: CameraUrl[]; mode: "http-mjpeg" | "http-snapshot"}, fps: number, handlers: Handlers): ReturnType<OpenCameraSource> {
+  const controller = new AbortController();
+  const httpAgent = new HttpAgent({keepAlive: true, maxSockets: 1});
+  const httpsAgent = new HttpsAgent({keepAlive: true, maxSockets: 1});
+  let closed = false, response: IncomingMessage | undefined, selected: CameraUrl | undefined;
+  let mode = plan.mode;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const fail = (error: unknown) => {
+    if (!closed) handlers.onError(new Error(isAxiosError(error) && [401, 403].includes(error.response?.status ?? 0) ? "Camera authentication failed" : "Camera unavailable"));
+  };
+  const close = () => {
+    closed = true; clearTimeout(timer); controller.abort(); response?.destroy(); httpAgent.destroy(); httpsAgent.destroy();
+  };
+  const useSnapshot = () => { mode = "http-snapshot"; selected = undefined; };
+  const request = async (): Promise<IncomingMessage | undefined> => {
+    for (const candidate of selected ? [selected] : mode === "http-snapshot" && plan.snapshots?.length ? plan.snapshots : plan.urls) {
+      try {
+        const result = await http.get<IncomingMessage>(candidate.url, {
+          headers: candidate.headers, responseType: "stream", timeout: 8000,
+          maxRedirects: Object.keys(candidate.headers).length ? 0 : 3,
+          httpAgent, httpsAgent, signal: controller.signal,
+        });
+        response = result.data;
+        if (closed) { response.destroy(); return undefined; }
+        const contentType = String(result.headers["content-type"] ?? "");
+        if (mode === "http-mjpeg" && !/^multipart\/x-mixed-replace\b/i.test(contentType)) {
+          response.destroy();
+          if (plan.snapshots?.length) { useSnapshot(); return request(); }
+          throw new Error("Camera did not return MJPEG");
+        }
+        selected = candidate;
+        return response;
+      } catch (error) {
+        // Error responses are streams too; always release their socket before trying another URL.
+        if (isAxiosError(error)) error.response?.data?.destroy?.();
+        if (closed || (isAxiosError(error) && [401, 403].includes(error.response?.status ?? 0))) throw error;
+        if (mode === "http-mjpeg" && plan.snapshots?.length && isAxiosError(error) && [404, 405, 415].includes(error.response?.status ?? 0)) {
+          useSnapshot(); return request();
+        }
+      }
+    }
+    throw new Error("No camera URL answered");
+  };
+  const run = async () => {
+    const began = Date.now(), body = await request();
+    if (!body || closed) return;
+    if (mode === "http-mjpeg") {
+      const arm = () => { clearTimeout(timer); timer = setTimeout(() => fail(new Error("Camera timed out")), 15000); timer.unref(); };
+      arm();
+      const parse = mjpegParser(bytes => { arm(); if (!closed) handlers.onFrame(bytes); }, fail);
+      for await (const chunk of body) { if (closed) return; parse(Buffer.from(chunk)); }
+      if (!closed) handlers.onEnd();
+    } else {
+      let size = 0; const chunks: Buffer[] = [];
+      for await (const chunk of body) {
+        if (closed) return;
+        const bytes = Buffer.from(chunk); size += bytes.length;
+        if (size > MAX_BYTES) { body.destroy(); throw new Error("Camera JPEG too large"); }
+        chunks.push(bytes);
+      }
+      if (closed) return;
+      const jpeg = Buffer.concat(chunks);
+      if (jpeg.length < 3 || jpeg[0] !== 0xff || jpeg[1] !== 0xd8 || jpeg[2] !== 0xff) throw new Error("Camera did not return JPEG");
+      handlers.onFrame(jpeg);
+      if (closed) return;
+      timer = setTimeout(() => { void run().catch(fail); }, Math.max(0, 1000 / fps - (Date.now() - began)));
+      timer.unref();
+    }
+  };
+  void run().catch(fail);
+  return {close};
+}

package/src/counterpart/camera-stream.ts

@@ -0,0 +1,195 @@
+/** One camera source per printer; bounded frames and native thumbnail processing. */
+// Keep the core server and existing snapshots usable when the optional native addon
+// cannot load (for example early Node 18 or an unsupported CPU).
+// This narrow optional boundary also lets a Node 18 checkout build after npm omits Sharp.
+// Runtime/package tests exercise these methods against the pinned native module.
+interface NativeImage {
+  metadata(): Promise<{width?: number; height?: number}>;
+  resize(width: number, height: number, options: {fit: "fill"}): NativeImage;
+  resize(options: {width: number; withoutEnlargement: boolean}): NativeImage;
+  greyscale(): NativeImage;
+  raw(): NativeImage;
+  jpeg(options: {quality: number}): NativeImage;
+  toBuffer(): Promise<Buffer>;
+  toBuffer(options: {resolveWithObject: true}): Promise<{data: Buffer; info: {width: number; height: number}}>;
+}
+type NativeProcessor = ((input: Buffer, options: {limitInputPixels: number}) => NativeImage) & {
+  cache(options: {memory: number; files: number; items: number}): void;
+};
+let native: Promise<NativeProcessor> | undefined;
+async function nativeSharp() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 20 || (major === 20 && minor < 9)) throw new Error("Native camera processing requires Node 20.9+");
+  const optionalPackage: string = "sharp";
+  native ??= import(optionalPackage).then(module => {
+    const processor = module.default as NativeProcessor;
+    processor.cache({memory: 8, files: 0, items: 32});
+    return processor;
+  });
+  return native;
+}
+export async function cameraNativeAvailable(): Promise<boolean> {
+  try { await nativeSharp(); return true; } catch { return false; }
+}
+
+export type CameraTransport = "http";
+export type CameraSource = { close(): void };
+export type OpenCameraSource = (handlers: { onFrame(bytes: Buffer): void; onError(error: Error): void; onEnd(): void }) => CameraSource;
+export type FrameOptions = { sinceSeq?: number; waitMs?: number; maxWidth?: number; maxBytes?: number; changedOnly?: boolean; minChange?: number; signal?: AbortSignal };
+export type StreamFrameResult = { status: "frame" | "unchanged" | "stopped" | "unavailable"; seq: number; capturedAt?: string; width?: number; height?: number; format?: "image/jpeg"; base64?: string; change?: number; reason?: "auth" | "unreachable" | "no-camera" };
+type Frame = { seq: number; bytes: Buffer; thumb: Buffer; at: number; width: number; height: number; scaled: Map<string, Promise<{data: Buffer; info: {width: number; height: number}}>> };
+export type StreamOptions = { transport: CameraTransport; fps: number; idleTimeoutMs: number; open: OpenCameraSource; skipFirstFrame: boolean };
+
+export function thumbnailChange(a: Uint8Array, b: Uint8Array): number {
+  let total = 0;
+  for (let i = 0; i < a.length; i++) total += Math.abs(a[i] - b[i]);
+  return total / (a.length * 255);
+}
+
+export class CameraStream {
+  readonly startedAt = new Date().toISOString();
+  readonly transport: CameraTransport;
+  readonly fps: number;
+  #source?: CameraSource;
+  #timer?: ReturnType<typeof setTimeout>;
+  #generation = 0;
+  #processing = false;
+  #lastAccepted = -Infinity;
+  #latest?: Frame;
+  // Keep thumbnails of frames actually delivered, not every camera frame. A quiet view may keep
+  // comparing with its first frame for hours; a rolling JPEG history would repeatedly resend it.
+  #references = new Map<number, Buffer>();
+  #waiters = new Set<() => void>();
+  #stopped = false;
+  #reconnected = false;
+  #reason?: StreamFrameResult["reason"];
+  #seq = 0;
+  constructor(private options: StreamOptions, private nextSeq: () => number, private now: () => number = Date.now) {
+    this.transport = options.transport; this.fps = options.fps;
+  }
+  get stopped(): boolean { return this.#stopped; }
+  start(): void { this.touch(); this.#connect(); }
+  touch(idleTimeoutMs?: number): void {
+    if (this.#stopped) return;
+    if (idleTimeoutMs !== undefined) this.options.idleTimeoutMs = idleTimeoutMs;
+    clearTimeout(this.#timer);
+    this.#timer = setTimeout(() => this.stop(), this.options.idleTimeoutMs);
+    this.#timer.unref();
+  }
+  stop(): void {
+    if (this.#stopped) return;
+    this.#stopped = true; this.#generation++;
+    clearTimeout(this.#timer);
+    this.#source?.close(); this.#source = undefined;
+    this.#latest = undefined; this.#references.clear(); this.#wake();
+  }
+  #wake(): void { for (const wake of [...this.#waiters]) wake(); }
+  #connect(): void {
+    const generation = ++this.#generation;
+    let buffered: Buffer | undefined, live = !this.options.skipFirstFrame;
+    const current = () => !this.#stopped && generation === this.#generation;
+    try {
+      const source = this.options.open({
+        onFrame: bytes => {
+          if (!current()) return;
+          // P1/A1 replay their stale buffered frame, sometimes more than once.
+          if (!live) { if (!buffered) { buffered = bytes; return; } if (bytes.equals(buffered)) return; buffered = undefined; live = true; }
+          if (this.#processing || this.now() - this.#lastAccepted < 1000 / this.fps) return;
+          this.#lastAccepted = this.now(); this.#processing = true;
+          void this.#accept(bytes, generation).catch(() => { if (current()) this.#lost("unreachable"); })
+            .finally(() => { this.#processing = false; });
+        },
+        onError: error => { if (current()) this.#lost(/auth|payload size|401|403/i.test(error.message) ? "auth" : "unreachable"); },
+        onEnd: () => { if (current()) this.#lost("unreachable"); },
+      });
+      // A transport may fail synchronously. Never keep its abandoned source after reconnect/stop.
+      if (current()) this.#source = source; else source.close();
+    } catch { if (current()) this.#lost("unreachable"); }
+  }
+  #lost(reason: NonNullable<StreamFrameResult["reason"]>): void {
+    this.#generation++;
+    this.#source?.close(); this.#source = undefined;
+    if (!this.#reconnected && reason !== "auth") { this.#reconnected = true; this.#connect(); return; }
+    this.#reason = reason; this.stop();
+  }
+  async #accept(bytes: Buffer, generation: number): Promise<void> {
+    if (bytes.length > 5_000_000) throw Error("Camera JPEG too large");
+    const decoder = (await nativeSharp())(bytes, {limitInputPixels: 8_000_000});
+    const metadata = await decoder.metadata();
+    const thumb = await decoder.resize(32, 18, {fit: "fill"}).greyscale().raw().toBuffer();
+    if (this.#stopped || generation !== this.#generation) return;
+    this.#latest = {seq: this.#seq = this.nextSeq(), bytes, thumb, at: this.now(), width: metadata.width!, height: metadata.height!, scaled: new Map()};
+    this.#wake();
+  }
+  async frame(options: FrameOptions = {}): Promise<StreamFrameResult> {
+    const since = options.sinceSeq ?? 0, deadline = Date.now() + (options.waitMs ?? 0);
+    this.touch();
+    for (;;) {
+      options.signal?.throwIfAborted();
+      if (this.#reason) return {status: "unavailable", seq: this.#seq, reason: this.#reason};
+      if (this.#stopped) return {status: "stopped", seq: this.#seq};
+      const latest = this.#latest;
+      if (latest && latest.seq > since) {
+        const reference = this.#references.get(since);
+        const change = reference ? thumbnailChange(latest.thumb, reference) : 1;
+        if (options.changedOnly === false || change >= (options.minChange ?? 0.02)) return this.#result(latest, change, options.maxWidth, options.maxBytes);
+      }
+      const left = deadline - Date.now();
+      if (left <= 0) return {status: "unchanged", seq: since, ...(latest ? {capturedAt: new Date(latest.at).toISOString()} : {})};
+      await new Promise<void>(resolve => {
+        const done = () => { clearTimeout(timer); this.#waiters.delete(done); options.signal?.removeEventListener("abort", done); resolve(); };
+        const timer = setTimeout(done, left);
+        this.#waiters.add(done); options.signal?.addEventListener("abort", done, {once: true});
+      });
+    }
+  }
+  async latest(waitMs: number): Promise<Buffer | undefined> {
+    const result = await this.frame({waitMs, changedOnly: false});
+    return result.status === "frame" ? Buffer.from(result.base64!, "base64") : undefined;
+  }
+  async #encoded(frame: Frame, width: number, maxBytes?: number): Promise<{data: Buffer; info: {width: number; height: number}}> {
+    // Start near the byte target instead of always encoding a full-size frame that will be
+    // discarded. Source JPEG density is a cheap conservative estimate, not a size guarantee.
+    if (maxBytes && frame.bytes.length > maxBytes) width = Math.min(width, Math.max(1, Math.floor(frame.width * Math.sqrt(maxBytes / frame.bytes.length) * 0.8)));
+    // At most four native encodes. The final 1-pixel fallback guarantees a bounded result
+    // even for pathological entropy; quality stays 70 and aspect ratio is preserved.
+    for (let attempt = 0; attempt < 4; attempt++) {
+      const encoded = await (await nativeSharp())(frame.bytes, {limitInputPixels: 8_000_000}).resize({width, withoutEnlargement: true}).jpeg({quality: 70}).toBuffer({resolveWithObject: true});
+      if (!maxBytes || encoded.data.length <= maxBytes) return encoded;
+      width = attempt === 2 ? 1 : Math.max(1, Math.floor(width * Math.min(0.8, Math.sqrt(maxBytes / encoded.data.length) * 0.9)));
+    }
+    throw new Error("Camera frame could not fit max_bytes");
+  }
+  async #result(frame: Frame, change: number, maxWidth?: number, maxBytes?: number): Promise<StreamFrameResult> {
+    let bytes = frame.bytes, width = frame.width, height = frame.height;
+    if ((maxWidth && width > maxWidth) || (maxBytes && bytes.length > maxBytes)) {
+      const key = `${maxWidth ?? width}:${maxBytes ?? 0}`;
+      let scaled = frame.scaled.get(key);
+      if (!scaled) {
+        scaled = this.#encoded(frame, Math.min(width, maxWidth ?? width), maxBytes);
+        if (frame.scaled.size < 4) frame.scaled.set(key, scaled);
+      }
+      const resized = await scaled; bytes = resized.data; width = resized.info.width; height = resized.info.height;
+    }
+    if (this.#stopped) return this.#reason ? {status: "unavailable", seq: this.#seq, reason: this.#reason} : {status: "stopped", seq: this.#seq};
+    this.#references.set(frame.seq, frame.thumb);
+    if (this.#references.size > 256) this.#references.delete(this.#references.keys().next().value!);
+    return {status: "frame", seq: frame.seq, capturedAt: new Date(frame.at).toISOString(), width, height, format: "image/jpeg", base64: bytes.toString("base64"), change};
+  }
+}
+
+export class CameraStreams {
+  #streams = new Map<string, CameraStream>();
+  #sequence = 0;
+  constructor(private now: () => number = Date.now) {}
+  get(key: string): CameraStream | undefined { return this.#streams.get(key); }
+  start(key: string, options: StreamOptions): {stream: CameraStream; status: "started" | "running"} {
+    const existing = this.get(key);
+    if (existing && !existing.stopped) { existing.touch(options.idleTimeoutMs); return {stream: existing, status: "running"}; }
+    const stream = new CameraStream(options, () => ++this.#sequence, this.now);
+    this.#streams.set(key, stream); stream.start();
+    return {stream, status: "started"};
+  }
+  stop(key: string): void { this.get(key)?.stop(); }
+  stopAll(): void { for (const stream of this.#streams.values()) stream.stop(); this.#streams.clear(); }
+}

package/src/counterpart/camera-tools.ts

@@ -0,0 +1,35 @@
+/** Additive stream tools; discovery is the capability check for older clients. */
+const routing = {
+  port: {type: "string", description: "Printer API port; defaults to PRINTER_PORT."},
+  type: {type: "string", description: "Printer backend; defaults to PRINTER_TYPE."},
+  api_key: {type: "string", description: "Printer API key; defaults to API_KEY."},
+  host: {type: "string", description: "Printer host or IP; defaults to PRINTER_HOST."},
+  bambu_serial: {type: "string", description: "Printer serial number; defaults to the configured serial and identifies its shared stream."},
+  bambu_token: {type: "string", description: "Printer LAN access code; defaults to the configured access code."},
+};
+const frameSchema = {
+  type: "object" as const, properties: {
+    status: {type: "string", enum: ["frame", "unchanged", "stopped", "unavailable"]}, seq: {type: "integer", minimum: 0},
+    capturedAt: {type: "string"}, width: {type: "integer"}, height: {type: "integer"},
+    format: {type: "string", const: "image/jpeg"}, base64: {type: "string"}, change: {type: "number"},
+    reason: {type: "string", enum: ["no-camera", "auth", "unreachable"]},
+  }, required: ["status", "seq"],
+};
+export const CAMERA_STREAM_TOOLS = [
+  {name: "camera_stream_start", description: "Start or renew one persistent camera connection for this printer. Call only while watched; it closes automatically after idle_timeout_ms without a viewer request. camera_snapshot then reuses its latest frame. No printer motion or print commands.",
+    inputSchema: {type: "object" as const, properties: {...routing, fps: {type: "number", minimum: 0.2, maximum: 2, default: 1, description: "Maximum processed frames per second. The first viewer sets the rate until the stream closes."}, idle_timeout_ms: {type: "integer", minimum: 5000, maximum: 120000, default: 30000, description: "Close the shared connection after this many milliseconds without a viewer request."}}, additionalProperties: false},
+    outputSchema: {type: "object" as const, properties: {status: {type: "string", enum: ["started", "running", "not-supported"]}, reason: {type: "string", enum: ["runtime"]}, transport: {type: "string", enum: ["http"]}, fps: {type: "number"}, startedAt: {type: "string"}}, required: ["status"], oneOf: [
+      {properties: {status: {enum: ["started", "running"]}}, required: ["transport", "fps", "startedAt"]},
+      {properties: {status: {const: "not-supported"}}, required: ["reason"]},
+    ]}},
+  {name: "camera_frame", description: "Read the shared camera stream, optionally waiting up to 10 seconds. Returns JPEG only when newer than since_seq and visibly changed (32×18 grayscale difference). Retain the last delivered frame's seq on unchanged. max_width resizes JPEG to the viewer. Does not start a stopped stream.",
+    inputSchema: {type: "object" as const, properties: {...routing, since_seq: {type: "integer", minimum: 0, default: 0, description: "Sequence of the last delivered JPEG; retain it when a result is unchanged."}, wait_ms: {type: "integer", minimum: 0, maximum: 10000, default: 0, description: "Maximum time to await a newer changed frame; zero returns immediately."}, max_width: {type: "integer", minimum: 1, maximum: 4096, description: "Optional maximum JPEG width in pixels, preserving aspect ratio and never enlarging."}, max_bytes: {type: "integer", minimum: 4096, maximum: 5000000, description: "Optional maximum encoded JPEG bytes. Downscales further at quality 70 when needed; base64 adds about one third plus protocol overhead. Use 42000 for a two-second 30 KB/s viewer budget."}, changed_only: {type: "boolean", default: true, description: "Return JPEG only when its thumbnail differs enough from the last delivered frame."}, min_change: {type: "number", minimum: 0, maximum: 1, default: 0.02, description: "Minimum mean absolute grayscale thumbnail difference, normalized from zero to one."}}, additionalProperties: false}, outputSchema: frameSchema},
+  {name: "camera_stream_stop", description: "Close this printer's camera connection and free its cached frames. Other printers keep their own streams. Active viewers may restart it; normally let the idle timeout close a shared stream.",
+    inputSchema: {type: "object" as const, properties: routing, additionalProperties: false}, outputSchema: {type: "object" as const, properties: {status: {type: "string", const: "stopped"}}, required: ["status"]}},
+];
+
+export function cameraNumber(value: unknown, fallback: number, min: number, max: number, name: string, integer = false): number {
+  const n = value === undefined ? fallback : value;
+  if (typeof n !== "number" || !Number.isFinite(n) || n < min || n > max || (integer && !Number.isSafeInteger(n))) throw new Error(`${name} must be ${integer ? "an integer" : "a number"} from ${min} to ${max}`);
+  return n;
+}

package/src/counterpart/contract.ts

@@ -56,6 +56,7 @@ export interface CounterpartCapabilities {
   progress: boolean;
   layers: boolean;
   camera: CameraCapability;
+  cameraStream?: boolean;
   filaments: FilamentCapability;
   pause: boolean;
   resume: boolean;
@@ -78,11 +79,12 @@ export interface CounterpartPrinterInfo {
 }
 
 export interface FilamentSlot {
-  id: "ext";
+  /** "ext" for a single-spool printer; Bambu: the absolute AMS tray ("0"-"15", "128"+) or external spool ("254", "255"). */
+  id: string;
   material?: string;
   color?: string;
   name?: string;
-  source: "spoolman" | "unknown";
+  source: "spoolman" | "printer" | "unknown";
   /** Absolute path of the slicer filament profile for this material, as slice_stl's load_filaments takes it. */
   profile?: string;
 }
@@ -144,6 +146,7 @@ export const PRINTER_INFO_OUTPUT_SCHEMA = {
         progress: { type: "boolean" },
         layers: { type: "boolean" },
         camera: { type: "string", enum: ["bambu-tcp", "rtsp", "http-snapshot", "none"] },
+        cameraStream: {type: "boolean"},
         filaments: { type: "string", enum: ["ams", "single", "none"] },
         pause: { type: "boolean" },
         resume: { type: "boolean" },
@@ -204,11 +207,16 @@ export const CAMERA_SNAPSHOT_OUTPUT_SCHEMA = {
   },
 } as const;
 
-/** outputSchema for get_printer_filaments in this server: one external slot. */
+/**
+ * outputSchema for get_printer_filaments: one external slot, or for Bambu every
+ * loaded AMS tray and external spool plus bambu-printer-mcp's inventory fields
+ * (trays, summary, recommended, load_filaments_all), which keep its nulls.
+ */
 export const FILAMENTS_OUTPUT_SCHEMA = {
   type: "object",
   required: ["slots"],
   properties: {
+    trays: { type: "array", description: "Bambu only: bambu-printer-mcp's AMS tray list (slot = ams_id * 4 + tray_id), empty trays included.", items: { type: "object" } },
     slots: {
       type: "array",
       items: {
@@ -219,7 +227,7 @@ export const FILAMENTS_OUTPUT_SCHEMA = {
           material: { type: "string" },
           color: { type: "string" },
           name: { type: "string" },
-          source: { type: "string", enum: ["spoolman", "unknown"] },
+          source: { type: "string", enum: ["spoolman", "printer", "unknown"] },
           profile: {
             type: "string",
             description: "Absolute path of the installed slicer filament profile for this slot's material, which slice_stl accepts as load_filaments. Omitted when none resolves.",