-- CeetOS signed release. Generated; do not edit.
-- CEETOS_RELEASE_MANIFEST:{channel="release",profile="router-server",version="0.17.1",size=269899,digest="84bb01d432fa3008ad0f80cf10f05e3de5509e4194da4b2df423bf27a7040897",key_id="router-server-release-0.17.0",next_key_id="router-server-release-0.17.1",next_public="4f+2ROcAJOSoHcmrDSkh+RSr6oFzR3EWEfT7Dwu7/KxHHEmUWGJSK9zfUBGzszbNqbdNQeSIQX+/4EnPSAp3KE4ZItg3UHai+XgfLWalsNGlEOgi0Vbv8fndgn54kDAHl+xIZQF9iVVzlS45pvaRFrvqOsxkSE18BAuWBSHYYnZx+P/4vfInjCbmfCA4mhhKT5kAeTLoayQVf0+KDU0Vsq5bYx94SRYTChBIf/NPZ25i229qU/1n4mVmdsE8RIuq+fQEBF89id78msOTMOHAYzHJKsXnMQEA2l9USKJ+VD3jI6SJ0DsPrzAw7zEhpnc1llPVzkwT4Gko4wpXKhjrzwpK4/lvAY22XHa96WmBAaZaptfxRnEq1E1iguyM7S9I65HEE9dqEj7crQ3tRw7+rRZTc2K7tuxm9rQXlQE4B10fxpReahwZRQG4wxHrJCPSpk8D6ME8agXvZZy4/0GodVA6A7gFocz50qfr9G1tbxY71zGZUJAPsA+MzTqs0vhOLVHV/mR3y679yaYGaZDBtiJpfNzN5BE8LD5Mnzp9xVWIIu3ECqUGAU9lidcJ6gkCVhLyqswbRMI0TaD5fnpvnHUarbemQn8vRMnRQOpm4hz2IiylW/HA50pgUJ1+ONpU54e1DJtfYx7pgI3QgbYkcW6jSrhAuiqGjL0DhboK7Y8dv6yhOzornakYD91FkFYzhbpLvSl/oxRVJiQrd0xysDN0L8ACQgG9xVN6zsB4+LaA//40Rla8liVhOm90j8igknLhoEsuu+GYJtfWrNjfsZDikdc878TeUbTPt3+Awaf46i2Xw6ehSxjaLLcY/RPCLUVsU/4Gy9T56dAvglx1yVCIciyWooGKn9robMepe16t5tc6/OOmLH5sUJ+3FLeDwOGCgZAcOB5bi+4qjea0bbZhfXMhh+r3GW6WRw3BS49fExpGs4/F+GJuik1Gbhq06rOS440ex3xEgAYTBqG6huxaeKw7CDNSXFMgYh2tmNJeBpqDa8SMZlz+M8k19/tm8aUI9faAvtqVIhnMP1oaf07F/kBbsx1uw1zrxY/KU4RcNRqKBhqy0GaD5txvo8utIz/JvYG53gnBbsmIGB8oPNwg+UAEN8bK8UD97yXvxaTZ2Cde1VxGfVyCsd47tngLfR/1YwMKlhuX9z8IzZfz83ofhu5O7qyaN6YrQ4LEZZQxs9GM2tvNEpxZGSG4w8dMG4EseMIA0NChZMocpwrCOQCpgxtfzCXIwKLCBlqL2RII+uzFZiatbmJ5Zae790YPLS4QbP9KJu/ttIgQqI/kefdL7Sbtsrjc2Sa3GeFnD/NllP+iaEqetzyyt7BBaF2709qSzwMSeh8wal0JKNdjMpMOq1lpsJQMHDzk/u2/gVK8MD+GQPEBoc9lrp/e8vftrkazqSSHwUTIH1iApB41lblmdlgiIrEMrox5HTgSkDOneS2dIhaediE48HnEt/b8tbMYe285GPMaOkPjtGpBOEwuUh9J3YE59ZWoeuqYb1Aq+SQhI1FDqtqll4dK+cs1VNl/R45RCvNBWchT5ihOI0A+tuqjdwhgNQajsF9s5SPdLvOwUwlUoAmbFVIfW22H/1Yf8RVFd+NDyl1NuZBsYJQZwHQZvL3RUc/Kl3yOehk9jU7WrwecKYi4UKogQqr13+IQlZw1RZYzyzWCok4fKGZnZ6anqFLFPnz2UL+p9d/3Et690NFijaIijHiNDNMvUorWSzom8hYtN/ms36lUu/ahsPjFj0XTIMntNf8voG3tQSq+SCD0posWmDXXj2McNkEg2XzNJwfL/LxViVLmGtrBfnuTNYaEeQRwVFED/oaFyeSgtOxC4X3vyl7mAbiE5oguHq1sLxtPF9NcjN+B/QpZ1MK5ad8pXM9MrBpTQ8V4nUKXhC+aAYX/bMuWZUtvFhCpcRXmKEExCk0MPmR5emKmdkpoVWZOpl1cla75cwZU0+QLyPFGt4di+aqaQdI3/Q+MXcnLS0ZFRps3w/x2mbK2IXCCqCYyuwHj6UYiwrS4bOYiZzIEfutA70pojNDH7fXOgUM26MckPSbbIGW3D0FtmXoVz0k5aQyNWilCqW6J3Rc6ka+8Rx0izhcUlelPZuPljyoOwDxwEfZuMSyyoEOGYTUYlv6ugTJetOYfUXTzV3s5cGfsiIhlUcVHa99mrE9RQJwilo8yhq2yGLD8pXRh8UmfZD8+86+fMv0e7u6zSgLD3S0YUtcLoFpT94nVpXI/9Xh/ERVjSfuJrpGxMclykEXrSztBv+lcI94h8FMiNbBVxxAygtXu4biQLyoWLDgpqlbnA9pGvNMBXw8I8QYG4CHecOJOhIhA44KIq81mcyMLjSJ/lPq6lqHgqbjm8n8SLP8+tBvNh4EDsEmK5HbhvGhdbV3tmd8M+mi6wZAMgcFLjPqLSjnuom8/LsPIZrlF+tjcmVDNEhZYEx4RfZTkdkFgBtQlaW7Mmia49mFBYIy+WPyUNOoWx20asvrCYsbMhruO2o0+K+m/afLRqFwKOv3p+sRY0tBnszPMF9c6ZPr1RrEPsXLjldY7K5PKb0+j2psfESSwA5vf+1uGxm3R1DoX0ZQIUY5joByskdWTmgVUWm7gaW/rVSTDf4TRfdrb+9k7+pssGTFhAwL+0EABBy8XB1aKHge4/VTxVRUI4D7GLv/0WfSvTmFznlSxFUDHCzoIiVdZpYRVayu3F++rxwnSoc8E2VLfGXu7+tsv65h+JK8g1Jo/CauH3h6yHYeflS+b8uhatv8qKEcZnMq/4zcz+CVXco8ElI2BAKwp35MQye1i5np2RrzZAB+HMz+yMHHbnP+A1A3tLKlcbxwJSuhCNDwI3tGu1eKphKgaSC/RN2DFuMyzLkxPoi0KPlZGQ8SxGu8B0RkgtmXAlnjZclgmLcUTfefGxQIo7SqjlJhnwNYm1OVg24KxBheyrOH3gTNQnfRbaItfqZTB3lmnuqLfgJQx6v3yHbE3NBSD0di3g3uAZsPx4a6LJF4buQZpPpq3cclYw3t6729RFcW5cnM6ReDfMAYIQZzQzqBhhUgaT3RnGdRfVzb6K7KlOII54PmOIdp50+o2+zRxQqVKFzRj2osG4P4Sq4fzI11RSmlv+ypnW+iVN5voI/wdEsHLLZevib/IsC4tjsdq7kEtObBW4BXhwJme5/D2MgvoOprEJ9Kg78RE2Kybr3EJ3gKx+iLibEa+42hDdOZvpsAu7lKl/t5BtPrBn98NIvrRyTfddcwj34ETlqAlzwK70sJL6tdFv0dKCr/1Hxvo6n/P7AKaYrQWHl2YlPUr+Cxjr6gVddYJ+7KX54fMUy5RE78fMGmEEavsWUySjbAI53uXxN9rv8bqfu1N1tdmSV7Ddz8n4H6GONfL4ths/XgB3SRL1o/+oVSRVUO5XhhWx8wh6sDMdWCJ5LsrZZEZEB1gzC3/ULhB9t3uFaz+1vHih3L8ZqZ3wttKEqzVHaYHcq5P5vvTRoQvziKkXrmJ5gYv0whOp6kgtrQqEzxdalprjKFAdRTqModW2ITBnNpfLqz3dABu+QihzE/nS14iHgj6LlgfpL+Efnaab+dViaM5XsRS/KEjQSaPFTRpdisfJR/v3s3NcCwbgFw3kLov61KMr44s6euB/K13tOV2/vO9YPbeSjWHbWNmg5xsJIL5vpnTr+OXnORAj4ocHII6S0+YfU9Ee0DusBoU9BtTDs+6CTUjCUuTP+lc9BKPhdv9WH367faEcPC8PnDdQJl/YMXWDNVxXJhiO+wFHxrmsAi6WRUSsjPHe0O9/g4iePvvj2bHo92dT1XX4zl69Xpceq0rZJa0c5Q/2MZyD4aNV6ksP/G8anvTGTvhIS3x3n0b2BwRcRYVJYnThW+7xDEhzli6s0A9HlRI6/THapxpviCZAfSKAbopE+0oVLcaVycD0Ph0QPAwKTIZHYA+Jq+Y2QosZU9MQJkUo9syRyazrrmAir9e0vhOxBhGU5HZ4/pHGT5O7TxXmTsQQk97VpPCBtIYYZBwKxWYLLDpl4OoXqia/b5YX3UU0DDBvk4lw0vZI45m7Xo1tnMk6ijQLIasdprxrw1rMnst7x/QXi9I/w+anCzvOyltS2V16IqqVcTlr9kcXCVoyDSuNDTlh/esmrEfQQkvjAUyYSWVf5KFHA+WkmHyED49gDJZpNsnGBG2Dg+3oBIk77ywnJHmMKt6rFHlsHAjFjeFa3f75O333gL3VHtH+KjsdXzgIA23F7gKQMKnj8mtb+KyAPzwxd48P0qcOsT9mCmwKigHoyp2+C35B0Cd0QNXd9hyRZ1n3tBG4oCuxxPpE2C0xsHcqVkgAQKuhyTOOmehXx4FDmsaxGeaAbBBaHif7kyrONgFfIwaJdTDM3Uygaa/0NnMZ2CFONemmh/qsHvkD9JWJGJzdOkWHnhiwJZGNYda+YxkWtz960S1CnbB/V2cEu4a0aMOZyhdvTZaPXxKY/b/pYC1qyNgWFWwK3Ikr/jzvT7oCPqRlK9E0rYyMjnJh3BU9d0t8yoNKRkZl8Whj8yR2P0/e51C1Zg49H+4fk491bgyjchnel4qcI0BRqvvfgWXf9GLnllyZ/ZODzwJ/brp4MoYE0kDi6xg4Z45oGs66i6S3t4ONF3rBjhdUi4q/dUKTxHwQ/aws2ofJTi63xHmTyfrKsC5dk2fekiV/vw9nt3McoWxGb9+5No7A3WqY8qoT0gzAkxOVKFkllZIJiOvaRqA7hd2xM1F2IWqQ+aoe8kq8kCKrbctJQIMG342QpjncmXUPqlwqf+uvebVi6a/B2pcvG4tnkOu7hzZVFmjXLDFeDX+MdPvGFPNOe432vJB7djpDTQueyQqNMJGDFeadMIXu6vPxSgq0Sz3QwsbBlQMlGtwAu+jqSPjBs9ml99asYy3l8h9Erdy4HB2gFtbIxnjepB8mbZSB7CTDFABQcXAdLK34poqq0cLhX2c7N51fSCz25acp2dIWJZZcrN93Ztv0axFV2xzqMGUVpvnkzdo7Mj6LGTM8jbqVz/wpXiYPi/k77xDiI+pQrRSuovM8R9BexnScxt/u5uKFb3rqhitJZCT6Z0fKgk+ZUER3hRn6ULpK4VcwynoDRD4QbYy2/g4cqo4kxguzrNJYRSQSAa9hHoCFwD5SSKPF2LLwXf011scsFbenw8L1crWJb1n60npwfSBsP9j6+YPHJf7CXmHNdmnVjg3DL/YKo6L66N9w2ltp1BWQGLlC6Xi4nym4jgUZs+xtGk9C8jABzgQCywZ9+YGDmDfIadR1/FqoVISVmMhxlOUFqH9ubgNwkNQmi4nvVd2cEU2BvgCGD3AnM9XfplGcbltuUzBABlAVdIZxaMb/p4/UCpzcYHvdGKKutE0MlBJdzgp0Gud4PXcZ2LD2sROx0pSS0qI3QxtujqS//lhMhVNlfG1tc8sUXIXr/e7y7tzorJ8Fi4m6mOSi6iKIXeFHhzTj6+Kj4TAarLjiCB0cb2rKaUqWNvwPH8eg/faq0HtAxMnQnf38K3iU29wxE1Ji82cS4CVtD2SeBBApvR/TWU3vA8Qiji9lKiZXKJ+rpVENHB0LqYOOr33gTjxjp+KG1C8SG73aOn3CMHLu6rXWK2ra0KY1DA9oq20J4x+uIH30jrbyCCzl2rH9edrOzFTvzhJLYLvS1JReLTUY7oV9BSj8RNITVuzltFuGfqjM+TH6n7KEZRnFXuU+pwOF8LwUQADfldfmVCCcklHecmGsd1xr0QJQVRJegw7T2RL6NwYg1Sqf8i0q5deSzkFI6ABtgdn+4z5GJJwmSr+hKj8HxoZIdyzzu8oIde8LFRqdz07wJbDpKlfn/cAgRttsNqGzmN4IPF40j7xpAraN6snADL9853XisY0dPuZaVkKNqFv/4lVDOQY7/UJIWPVpdewFgZEIaf0VwTuNwbX+iPzMIGc6bRRzcPT+lxoxz9XeeeTyWVi080bkOUpjQMe36uXTjAGpybdtL0T7+zb2OFm3fV4FyheaHj9Qi75L4GNBZOn4y11ADxlm2Fw5U9w3j43PqnYPFg2lici7w81jAV2IiFcnJQZloVO4VkvXNC8xwqx0a+f5WcYHWbAZxDvwrrHRNIgftDu03gN1cIck8fd+EmFGgXtKGIqG/DvlkZJVQN8zPz2GfJ1BXQSEis7drZndFCt4NBEzMpVuBPZZ5oiM8t5hR+d1ukkNA/PfPzKUvEuhMNfbU+o8Chri730IMy5IaUaOEz6Hr+eDJcWrHIZQ88CI/1780el6mJ/+lF4WLS/hUS7k37WBb6Po1R3gYQgA3DNPROZo1WyRld93+NK4HHKfHwthT2iapWrx0pNtQUObE5UxPkGzdmsiIUj+m9gK3SExAJ3F01Ad+1AMkHGaig0lhu4nilLUnY34LRKyP6LcVL5t/cCxS1hDQzub/KDZzfrP4lrhHZHy+CeopbEMKnD8XDBg8s/mYo8NVvGiXUeiXzxY76nxNWTJeqMmLvxTokC5MYijUvSkPkizsE3Lk6Mk1bxaIojVFgIJt2SAQTc/8Sn/tL7uq0nahdx7Pq5sIkhgwrU1zeP1+YcQnV0T7e450U444CpHrdWU+pbl00zlQyiowCvZxMYMMUeqdrB94IKS8HE+YVsBK3ilvGu5bu6nFSSXq/t3YI9FWMXxlEo1EcgdDEmvS3MwxIyj1nmS4bF4+1X9qw1GpAWjYDgGe+F1i7KUziteo/1fpZoM0xzegGI8rbf3cslytUgnxe0rFDr2Dc3JXbKi7BIXeCOqSLgpbTtuL+hcodCJK3ZLVN7jXUtOrOOYOKad4T/I8+BxHD95BOxomXMR9Fm2KBISHyPakJ2hPTgkmTdHaFGKiXY2fFre0aMap3/yi7a5fNnYMLsXGk+Yc/9N3/LbNG5CjRQrYkMt1mpKzfCUymgeBLeHebaM4LbH1kMY6/EZBpap/nF3wDY0m2Z8s3QnB07H906McWdNmiIpAwv6Y371vAy3hfnL+X8aPFBEwO3zD6s5TkIieSi4QRE15Giy1MMb9oxz8gAQ6a55ZZ4pdTDX3n2/JpvYgBQoTXOyUTlGWAAFhqxis8npqDIBFqsVrwewDsGWM5JxzgS3j26W6UNfVIC551l0re3597r2bOF6RY8uj4vYdHEEBFvWy6gvIiw0ivDrbOnAJrs57EGAI3HUdra3vQCjt1nSrTJPRXqDIGhN6PHAhGN9sDZuNAM0zfzxhOmDxjLuyxsb+dvUQ/us5AYiGDGkK8mdlacuwfXq6LlIv+xVPdgcOcGe616Bg8RAEr2P234+0xm6uKg5WQ8X9DCPIeHbRUKpXs4jz799OkNmUYebw+NCsOeHDM54wrv2pawd7rWqMbJ2Voz6ZZFC9RcDzJmOmw11tWiZvI0aDKTUhpkEYsF4hu36Xr8mXZ2U+h5bNbjI8IdiL/7cb7F9FaBh3eoxMN+TOY7YXibA/sczaLSuBa+hdXaJnGxdwWjhBag75CX+ZZaW7p5xkOVlF9yjhIzPUPNXRfou0d2h9cZrjAlpS8Bi4Ihp0L430LoFpWEhB+li+kRnJLC8uwK57SdOtNQhrY8d6ypkMU626+61BbFu+0ki1isxrZ84HP/u4WegAyd8fcC6RFZ8s95EhTnNse6ot4NXGhQRhX3yknHRwOSgEJwmXoC1KrYpgTUerL4D4KgajfvUl7O7N2Lb+75u6tFJ3/ln9NVPCQaH8FyEFCw56yaClRO7f3pDsjey8+b1Rxbrs8prlFC+yu5AMeXcrf1tbq153AScHesip+IiJsrqoexF5ZY20uCq9CRJ6TC12RENjd7ctIMmt2lsX8be6YK7KHQe2z9kHwSW6laR6u6Tz1I70yzVGMIckBy8JHBfstm7AZWAN5MPsvggqOP1anibudCvCCBFJrxpatEHJHKqiyRFmp3CW7mncjbItcRwPWWrnBi0VpD58kyN0yqIWEHb3ENj2zyZ+sZ8vcfF5eHdFoPxE/v9E2qjm1krQHbug/cTCow9ecwVREU44SU32HpVv0WSD+Bv8jHkkkqCemVfMGnYFP4CQeanc+dbsdb/n97QbOtzX5zghdqWONVU26vU0nhOXD0ncWybnBUd8kFFcSFpZPLudA+uK38K0Rh7KLwHnvdXrP8lVMBQUzQP/I9m+k6sbOQYmeDeY/HNBbUyfJUlgPtqoPfdsP/xlGINuDaQLLxkHpeN3fMXXg5T15NrrpxYaYB0C+pcAXfU0EsWvBb8pqr15LncKVrWfaDA3mfJAbD1e2XAV2BuyuL55LvwD3BiBvFGshiVx1Vjrd/kC+Ggw+WxT+6N1GeULN6NxxPDc0Il3ZqHTY32j5lFKOgXa4Z3SuDcaoh5VJwy/J3k97/v138/j5/bYqopN1ofPEB8tTTsOikQXjal4OppMl8LDY0b6wrzbMXZFgQzBQjhNlRCTqHhLN8LN/jYWd3eQx/kfMYpGQdI+bZ4oLKEB5Ru8MkoCQ614+nPkucKaqEjisOgbHM0Wic4D630PDjq1/2Hxx5fOL2YRBcfR4xna2WR+SydaSxNA8YVa8k3LYUwQHw7MLmBInU5vd/OLHbLTMO6lqQddFAjtNcHqMrcoo4pxyU88ZKwuP8Ybra//Xtil2aYY5bhbQ6wd7JZYw7kmG87FsFdV1hEmirUkZxc6wMobNDFHZ7vl1zFVeezPXcdGtAvGioJJ97s/5Ih1GamoKWHN6wASmRQQ2rRYm9/1dMea0WmSLpfgtT9brArZN2snzRgQQIP+faFvGs3tnjoSHlquOeQFUOvCOzX8ZdxE81Vr4eBs5QEAfP4p6KEfZFPXZQPTbKxKhq577Uov2tXGDW3ioPfVQjLlcnBouHlFfGHtD8V+cQ1lsVBnV7UY/MlBQOIViqgcRrbUkx1w/4YPmfXjzmc9Gi1hV1KK4nb2pDCA9XrWoOogSLdufzQn/QNccQMFnCOTWe4XPgCdzjqaLE0VhY07Y669r6S1MLZeZ/5PMEbYu/aDJSs/CKX/3TcRNW6xTnmRxAYH2JIZXLKfhoqfel92wAyAonXCKiw3Q8Lfh3o27+LghKJVwHxuTjXWKY/aHFAMvN/v5EE6UAWMgcspfLj3EtQHj+njczbirMGiMJsMu+MhDTBeopOM78328XiJCBcLkW3nUKKDR2VOcYVXMYH2E4b+MxMDrlI5TIvNirWCiJ0IB/rzggnK2u+5PhvlPlHLdTBZSg+MOrMgmaZoXjczI1Z9F3wluddg9PSALKOhH3qBXipSZPNMrp7PLzuvKPqMzbvA7BfL21pz9Vp9VBlDORWoLMHTAG3ZYjWJDeOPtqcpFXx2WKP4dNi9EjGHC2PZWM/KZXTpNzqYDcJd4/hoY+EwmCgng1/tmiKrnKdjkyU6q6jFEOw76YDVCyuGGQB9+fmplefHet/uqC1xmJR7mHbKHQtv+3gYhyawZax2jPKS9LaeSoRMpbT1YLfExi/kPmNoFVlpI7cnft7+wCbFNf32rOj/iOZEyEhT1NbvBWpNUZaUbudDx6FqBeS7djVH7JHeggEgTmXm+4DessEkfgW9czE0X3Se6sdLSHiFe5+CC/VFnfCXC3g+Ld9zJLRsoKRtWRRwSWQjWeiNPh9GpJ5fjqJlORMya1LZeFY9M/mKJBY+1gVQt2AUheVnCu8mUvwzeS0lJHvi1rUK6aJyqVQ6mfYWeO+2lrt7704KGZ1Eer62VSaJ4lzkicXH5xlClKeeoBLz3kbHGyeZFNLhOLTu1nRqO2Dd3y5pTjQTjqU6lqi/kXygAJetPNtPQ8rlc/OxU9EMZ85ySRzO/8pa1mxXX4uF6y9K0I2j2mrOa3nwfXRoMTy6wfsSUsjD6u9OrbPILX/Burr9q7WkIMkl9FcIUnxQVRDtLPSbNmw15KYeA4zBTFiYmFAoMpedjZAt8OcbLVU25+m+GqioJZYsw2C311LuNcsCpxv6PcMzgFR671xDOKzMU93G6Pbic4W+AfcNBXEJYS7jsB+iCNVxuBirZhGM8lvKg9JM9cEs2nelmCRtb+Keo3+HCIsbxAPfwLsDzdW2ZPXAOS5u86M0MEWFLXMJ2jUn1YylQCArQUMcWhOX5P5u7wFyxVOrpRvlNRx8Tfw0gguQkSRgWJvZ5TcyjL/qCIPhosHvYwVgSow42Z+ROYO3XdPTNPrbHjoi9mjKBo9GZHGinB4XhlCtScHXwBPx88uIpi3foTvyG8bxYQS1HdPrvQdXeBwPf950OgPkbLhqg+RHqzm11dkmbXlX72hNwjQ0PMnCYZ/g1UR2muVcMYDnO9f7c/39imH6Bl7nKonkvxPFgA/aUA/6FK+zFLZSWh49ubz+VGMmJakdH98teihirSc1/jDCjULf0Vdf7hTx6paVsupR2rWwzFb3HMJ8KmCvZ9Vz4rD4Pj8Wea163Ki9H5z/kX/3VxEoJMVgWHafA5hDgYXECc6JNxhi8kzx5DrCSX+9pe3ATh+UZnTpsiSghhOxdgJeg6gnRvMw9gFj9GMIVfEQ/xLxc8XpchgP2ABSV96bShfPU2z3C+apulL0w1L5TREV51OOd4MX14E1Ur//16OpktH2EW+EwZnCdzZPLe+NK2wo6LCYkkBsAvvtvtQzCNBdyxV6CyQlaqISG6k1fcaImPz/uksyjaHj441+6Ko9k2wFdXgCbFPosRAqLgol8PrBVrKS1zdS2vjzyPEey+WdmnhlTXH7wlYkRAgTvBbE4L3qjQMD3sZMSz7slrlKmdjWxtfs3AGM4HFPe8uAaTo/RsF6YrAYBRy5CxPvONyRP0pSQGVw7A7qqeYXv6OU8bG1Buefyyxv4QD4eegZ8Pu0LAICNk+k4+ION1T4oQMqLfDCoby7g1wtmwGalzvxwWvy/D/jNShY1AXTsoNz104y6Y1BdmzBy7BiSm7SRZn89k9Xw0cgS9LDq4p2gaMLIhOB/HOqEbI5goHcPVCPoJRYMeto4dSX9YML0QMOnKdC5HEz2ha26Bj4M1l7UDEvESz1n5qDynn0kiW/2UNSoZojBegnJ37n1YUJIKb0B1bMKez4KG9skGSpZ+0CnZna3M4n4u0OXgfTur95+O+ma1dLkLwTf3gxArUnL0sMPMKBi1RPShrOMu86Ww0q8DA+1X7Z74bWjPMfcFfDVRlFscbOgwOwr/Qv6Vx8t7MliXCB37CNA8FXom4jBm93gAqxzd0wmBcbXoOmV/b7VFUsma0FU1hrDA3LHDrfjgQVU4pJOCcluvYSHzQuKBys5cVFj4IXFuXWLFm4uCiKJzP6DU/mGViKW5W8vuIYaejfKD5YYZ4qXROmeuaiSxEGdXsYGaBp1ytjcJbN5APw34psFGlYrrGOW+3Xc9Neb99sxqg0tKsM3yJPkQWI4D+IJvIwOHGxU4v76c+r4Djsb7EekOa+S16Dgz4yQehuSHs7B5JVWMWWkHkqMfrgkY5ES79eospOnjPH95lRVxJ+PMdv/8len5/sG8iZi+Wt8WpBgafZM3xEmWgQGvVxAPDjYFS5Q2tUwVu4dhatOsnEJfMwzxoO5KLEn2NDJRzMsow9Hr2P5DsLu9AsyUkcmXUKN3sGD1oEskdQ3xdOJoXqB9cnTo62o9LSyLuChXXvMgK0ruG0awt94r/qQeTbIOtNSMwWsCce75/MJ/vZrRd2TWPh3+fVArGZ3mcInTb28E3o7swi27qEVQOUysGYWm4lfyhPgtdDGcD1NIKx0qS/tiN9/6F35EvCSgOGD/hURWhrgGmr3XHSHO5EJY4jpa8WNXcXAHP9q4FZ2HUluyJw5jStu/+6krzmClK1ZKcN/qFyHNBgLCNiy6Kcd8zDWKehoWRf0qXuG9ulv/ekiylRz9oGHmP6/iBB514AOXPC5MpOxcac7xrTnpYh1SYTZl2NswUVOOyZFsvrFeSNnW77gdaOO07O31UlpzCfPM6hIV24n8EPkltrNr0NB72ed6/66/fpQIcK9no134otTxXBsZDseNvv0WhUwLuVKR/UvGKUwJr3IfBOKK901aj2j16rfVvB5gfVpym1X1OdFicl4Xsfrbd+ebZgMAL3IgGirrMcqfv7SqC+va/st1lbnyboxptSJdqcP858iW120z9JcSR7kUYG+L0/hE0iVEuDGyBWws2Q3p0swSx3iFbid4M7zZZppYx/Et9Ul9sWknDf2LxUfzBju/H0paCfKSJ4Kx/AOlj0tKmVuk4eofGBgY7ak3tbvXIb1cplOjX8HH99GZpqWwsS0GX4qEGcY+B+MmYc4ZXvtDPV27RkxL2BuH3bJbvpz7UJTJJAdKdzP343+B+QH8sSH4yS4BlgCS3QKyxFM5ym/EiExDqsCDq3hSyNklcDa7sM/SEKdP+0ZdDCjKPFrnJDyyxUKhjs1qrFkTKnFZpOtkkltdBWBkxtrpc/MbuPIpLxX9vnRP0bOKWBF98HeJ8+PB7wu25HttFphkrHwvYkAbXc71mp6hnDGlXnbX+z0sJwlI2OokZJ9LSrbPNXY48DoZAp7+L+yPysY8xK+nnnMEg3pCh2S8nfwwtJToPWJIxwVf+a8wSwqtrrLBcmF9Oe2MZfr7SbEX1OaFtHqsLIDuwBgEMrC4iVhyEzACNLC9jihIhybAgOryjCVV5Mz3GxJ+6mkqw6tO0KYC3/8LuIFvqYhEyy8TjduhU6BoHhSZbTqUNapG/I3VT44gpqcbjBDYFvV65HD1o9E9hoj+VeMPRTVoePeAFrkIJIPglGKaYzGZyL9fazRKSJEyyRxYufvtCJvh6vVvUaQ6xP/0QUT1MEHfMQ5J6oJ42OSkImc3ybmTb7gSm5wQbV08mX+oH2G8Wtteyv5gQxtff3/1OoiBAxS5BYK2auFvqyQFkfKAtKuCEk2M0qMF6pTh+aU2GJNpsnZXOCUWySXd5Z6nTsf90QUkVbJnjCOYnkXT7CKPeLJUP4d7/qCSMlCyU8niwzwFR6LMEeR93ITbybciDK1LPyt9DkxR7U03Ef80piJsEbr7ey6dckPCd5Fs4Imv+Ll+KzQB87UJdnaTLU6Z523nmcDeN4NZMwUGqUHlWAVbCJHK4VguiG67U+2mj38n10qqRXJfZhVZ/rMCjs6g6eiB2WZR45FuomjFQ+bKxfjf74SM6qiQ+rlRT2uyadEnecbv6Jli6n0l4lZNdmqI8yyATM1m+miD1dpAFMj/GC2LkcmuNIMRaRQn+QOJ4O7mBhfO9quNSs4WEaeQYRL1xe6lNmWcHPbIzMRuxUFIyCX/mMAjXTQnMfDYsJKIHxWUmLmkWJ3dRdg/zjI1zFGS1FK4RnfTaB/Zu94KW2Ia7tELBDOmk7k9Te0r0lAdwcaWq42a1cPu1QDf60IEsiOq7T4xnPAvUgIupZBaJeSmKyvZW99+MM36PXUvFZXA/e+E3Ia1L9WVFBmMpLD4NLOWr86r+3wyMENPApGb42/10/jvdrZXGJaX2747dJYeXrHZdtTNQe0PJvm9Xla1sChYYXtulBfYnYDS9dd7MC0Samntmh8DjBOu6fHcaV45YAV2z6VlzXS9WEGtYeQIOnysWAd8X8F1sPZPGXN8/f6TTNuK/oTY/XLUXq5H955t7AT59yh5Dg/0QApBrARrn2BUvqZgNyWKBgQYeRE5Zi35p+c5Xhq+1unj2MlmrI5jDGjJFBfiM/O+huoET3KQNsmQxUabcJxgxBl9nIn8XM1iV++eGe7CGCJ3QJfRxTw6ZJBtUiD9HdUKhx9ojoVObAG/93AN7uFr6BCWrISz8It59PXbRWMq0ifU4csbn+VSzE4L8BmKrkY6yPRMhx1gehp14RLSdk6w3qD+oM5Hd8DgDowfBcNUqa2TPIcUnYyg1Xq8nKIqgRtu0fDjNnh5/LCJMxxE05LgA/cTzXUTDeHSESH/+5MCS9CW2nUgz8T56uhjRgbhPyGV9IcGFTFsET5/iI2hc6u+X8/W+gglh9sr0GvB+bYtsrQ6P+RCEfYMNQSt1BmjE41SIvS+C7tqteu4Wc2dgfdFA/bJK62H966AOfmhlAx4wwwqokJJC7UEYcarCMz0vtWTyQIdB/BpcfMj0sw9tX0jY9GRO92W9yGGVIrUl1yPUtMOin50f3TDNSJ0aG7TZI9hTceYsHG9FxeVmQHeu0rJglAuOghOCLNGvmxKblW7Ovy8dcEkXOnfprO7agFFjbPx5FCm7ROjWezrbOL/UC59BtP0X7W8jRi73URd8X46iZw46yQS8O3XzX1WaUHF2CNgwa16gTpysepWwteZlcelvxoQ054w59sv79/wWmiaS/pmVKy7Zb8Lej5C6VonKOhYoEAgr5LREvACULHqK8NGJZArEz8FPT2Y2n4y/fypGQZHPwsKxMbNr+JLqrxvsqwLvtuecEeCtLDGXpovzMPB4BmOJVElezTGyLRVYWW1xzSpGU62FkCFNdMTEVP2Uty4Mn39IbFcXFhTRtV3scCvOGgusDOIzFhi/tjWo4T9aacfmR3w6hfe8bIHWEUltTazddAXOmNGzwj92KZAusEXe8VanzzyX7Ab+JOuSNGcbTMMV3OdviByq83dhvUCm3WdoNWZyaXxa1hMKPKYzkTCVezBKTucFGYZNfZnGh5RN7nQx9G6wKg71Zo0Nxv4C90qMzoQ4dxCGqOTuUkuSNjLjknNtIdOlVty+IdpasI65VE5TPXwoAYwKzsG0T8DLK3NcKEX8tVD8xTkEWEg83EY/ryedfOTYyMyD3VXtdR6rFkH+in6jR/tnIfitUsTT9naGcq4POa8t9cZEsW/r8wh74JHRFwexRB9GGuXUsJfZmdA3gcTGAgUr016ns5+a+MzBlSB0Vw+1MRP2HDSQ1i/lriWHVKOJn9KqYEI+MSijvXH0966ELoXNL99VTNRBj+G3AR4SLnR+ldCwJ9bAkm5dRfdNZJBo/MyF3uct5XCYZfWWoHUIfGztUXUNQHWLybGY8YoWVNQIctnchUH5uTtpjgNK8mgtrIgWfNy53VC10d3f9TRd85oVyO6NL1J3K5IBS1shhwVjmdl5FwfthSXZJtJoN2N9iVkFvVUs/3GrUt3QoXoI3w22XeqNLAvzGCPOK1eKhu+vVbwC6sZdTZSzGat3Ax+VmdYL+vRXH/Ua2eumaoaAgrG+ZldNG1Yyglzezr2XVQH36FSgVkHn0eCeTfFa5VagGmU3WJQFI7t1+SKtNjRHc4rUxsdmT2eTvS2q9kRTzJJwlAbABzDvbjabKGXAYvPN78Xqdg5fxpv8aYi2EzbvQr7YZk7tEDWiWbEaL/rOdVe/2/xDxLNP3LkTBQI6AEKEFrgxXX37nFTvUlzm3rTNdJ85GgZHPTtIWqecDlGO3Q2rIMv/LkCrUg5LiSEBWUrf/qxGqLnpYI9dblajQyEfhHjj7mdfb3wS/8CjnoQrIumFhsuOPbDmQwjkUGcK7pSBDucMdAdSZzWj924r69J53qdia33VaT7r1mga+graX/VckHwc3igMq757gchKihz/pZ7B0GY2CJSg7fjDPosKolLWbrd1N7MzaD0Fk90Mwy6n18sKqvKnftxnNxxTjL4D8kkY6KmMETUB07if5z9DnRrs23NgZ9j06nJnQt7u3BuuBwU+gde6TNVxiLPCPJ4Z3JBXQYXChzNuq1mKnyLFMbWRGSEcDsMNt9r2Ewsk5di2/A5okD20Zm+Yb7U3Tyfe+TUM8tgA5F3Sg9LjNDsmyWfRM/mhKYYxexX/XPWPZcEbLAjr78nGonj48XfaJYmoVOqsqcFbkn3s2RlV5NgUz43uhD2bZ5Ym6AXrA+KVYLtJmdMUiPjZ53EGi6vDZxOBst2q+lOz6EGSOz1n7s6AVLXqcpfZmw2oYKCxvwBjubHPB6Iqy8PT44P3iNdJiRSdwKAeZbn7+mYcVr129DWATaLRKwYwuibla5KnADIiR14lSIyFhgDMZaUgedPxYQV0DhcV0cHLa9z/lVES3Qw/g03D7Ii/PS/TDkLZKLO6hgX0UV/plDu6bcwrl7Q1xQxziLvuJvyGP34Pst0R2V33uLclApPi4QDgp1ToNV57AFPyjMfpiT2sDI5b8cxHQrUQIcxbG1kASaceX1MwTdlZwIzQ2OsR1simv/9L6/BC4yxDjoJJYmIFBPGQ8fmISCtRQAhYoffoDdJ8f+MCd5WAi4gpl4yS83rhLAVCDqmuZ5G2gIJ7RRwfMSYv8NK/1ocQoA32Nq6IXy0+viRzTq5uXbNPs/goAiJtxI0o1caTVZ7v2O0466BZKNyexOrR9h0eAnptv7Y4mwdmyApVU0gZALs9RVxTPlixMPhW37iAU2GJ2Yr6pwHiFcGmWmgqdoo5ZQpGYWpQtAS8/4EDGm8bI7nVnkceZ2jTIB0WAtzcwJg9qTYzyFe6V9NNjKkitNagc2E7hM29hXVbqYKKtAHmQibbcEVHump4qCxcaVRZdmVlh6fnG549LUFvkAM0xxxIqh6UBoGpg5FhNTY6VOZYk9nrd72wrpRO36u9eLv5EaSnjV+OsWZNIVnmxfUts8Z2mxDbb2AlkztTaN/2jkuAVUX6Hor9Go/E81aMXhZK6LH6QvyXHqIOCd6uBGxJP2L6VJfzM1WGaDpS3hJRjRQcNrEIvr5kMKRY6hvtzRZkGtH8386Px34xfZbTkO0wtpEpAVsjtJjik3q5IMTMt2aq2TvNSq38ZTFUX0Lpz50iACRN9LCtTrTWNyHGHLwRcMh2RCnT3/3HfC3IoR9zceKWpL9i5n/WThdj+oLgFRrExRjGqEY3C5fN8e6N/lp6rkK+fZw89mAgCqpFqlaG31ZA4IVrbgYazHXlil21di1Fd96zm3TQU6GmmAjiUeHbqJNR5HbgpufN1phrj3HcD4eBwV68ad97G25vcXfnOvq48snRQmpM0sSji2A9SvQMekQyav2xLdy3V3NG/lF3TXLGSb3HPr4SmrqPj8XJBAugbNPSiCzcmyPrsOVRTxYj8hjlmmPO2tKDg0gcvisNUMNfXT5iusCTc0aodVYRsKwjk2XDStJDIUa4v6umMUV481/oDRuRxoLi2Cg5hW3H5Dh12BpMXt9kgqDnvPMtO8N/RgBjspHc7eoZvamdf6EREgcrAR/ZXou8FHx0r3kTIGwW38U3IqkFPh6bNAcHu+5Ex8zDtxMrU6eYwKsaUwvRRFJpotAWQS3djnriJlI/Y0ClUuNIqi+DZfIx3obXqN8J7q/SYmuu91WQeaFuS5IURCvWw/BxxSLdSw/wY+ujwDUZyzVetspmtMX16Kzuu2rzAHUocv/i8EvhS8sx2jo19FpUQHeWimmhiifBXrZoKmlPte74Kc5bEaRZdONkFJA1jJk5f8vGvCVNbv7Opa/ZrNyA6z6a8lB4NyvhMkSVQY8zgRKokkbGxNl7+vpib55z9Scrnt6cUrCt+6yveGuQ2NQs51Z9no19hlkysVou5VEanZ/39unQKAeHRxRQKvF3/mCN8Va0jZU5DLVr0IPCo/ZH+pRxlnD6uVmAgj+KSWl0WhxqmXv664BnJym1JKhZFDlnZx9mW71BIryFZYrjrKVVzIlavrd+uun01P3r4cq6UOOjUdO2Zrh6xMu7sLITm9klZRC9UvZI0c7z0Fs9loyN6j7g2JIz5DKkVQzvinsAj16B/wZovnJeOm5ZbUDG20gB9w4iITilekaR4bBP9IzOtdg6PbDIqi+tIw1PZxaXvuhPS9oR2ExHcERJx2qmJLZGJsx0qMWoaalmyzQaDNZSxl932lWHmWXoVAVLAeXmSICcEbgqeJF71ktN90FVsUXp3wfSJhMbqZzRAxFgq+RnwJe6Q/ETTMG6aHps5EEfySyfRXEupYAjGtdy/WRPxrB5xtuV3d+DQLOaZsz8B5GqHqZW8VNyZkkOgyJjQloqmXZ7GoUpU/meUtHzfId9CZGMfglh5nUskjnLf/eDLU9TWFYfQ02Ukpg13j7tWdxbFGvVX2kVHQaXz3/Rnc3WcEy8vQ/98iGt5QUDlFsjgDVMPUMoGIoCNloY5EoMHewSkM+uvIDdAT/GtTAMHqZWgaLzo8novw4Zrxc0vFlBIvV2X+saxLePjaEATJCe+sRpei1SjK8xBvxKe8uLnl/k5D67zLil7g4aJViF9k8aJ2yYJiIFTFaAO5wOAXFKXf8pxQ0rbwpbON7RHZdxbHAv/DyqOZy6ZtSWRwhKbWT7ls01m+uS431oKkz6VCc0fbX/W32+vwWkaQBqgDWyr5SYaaq8aiatG3jWI9IKtxCdQ8/wDNCywud58ZjEWnUSaRVTms8RWLTtF0QwvxNEBqJG636HUBseQZXdVnBz6nAL3w/iqKHYgqrb4KHfuxKbBkeToNAkznUE48mb++6vIzbBRSk+qW3xr2mARehcjgMGhGLtKGF03erfkccdWMCZtrDoytn+dGT4ow0ke2bAgZBhzdvpE3j5nUFuadI4AjbbyF8F+uOt/DesgF9l27RGg00/9cvaHr2mBlzBl6bT+efeadLVZi1kHbAGZ20FcfL3597Ehla7YQF/X05fu0c+t6wwab9ZJ/F+ZP+M1TOjvQ2Ek5iv514dm6YW+PpszTL3lMxjLoRnJZ/7+uCJ0IiutV2MoUtWpwIu/0hD+3QQJ2dh09RnEJkPj5bDbp82OACvDDxyhj1XL02xTQyQyEb/5i/Uzp5roqkYdoxr0gZ3T6WugcmYh0GB7oFpi2i6z/MUWElbsUZSq3lziqmVfcZiZq3ugnd8g01ZCxNb05xRMNULQbpKS5MGocYX2v69ksWWrS6bAk0a8XDYgDpV8Xg48IQTmOicD7XBjb6T1SYRnbxE3FSyksapIg53SXyxBb8vjpqRVlnYNWI1O4JeeB30RlCbF52yr9Xny1bQV9GvsK9/uHLTjtpaamiX+bNYtQxWrMLyKSWjnpGKQOyha15N7gN3rPoWfHR376YUBdjYOvksjzVHgSMecPb8N1aC9pmIwyuBejU0lyX7bq1eZ/psp0JD2v5ap0T8ipVeMdeHfJW6pYD3GFtE6x22dnMc0fNcUr6Qh7h9ebNy0/MoiVJRTA0nKcTIXs0+s299aKJVBWvTaUrdu0UN/8JGw8TJ5AV41p1bDe3VPTrhyn50V9oZi1oGbBDXuF3jC0CWtzkOPtpr+RGpdhj0+bBAG3BKfdoJ+LhnK27yDX9drUWPMNUH+wev37FXR+J6uGpRdd4nSxId7GsR8GqMQn+ALbHMurEC5FbkbUfJ/GM9RU9fpNOccvIptYUcPsWTdqDq9syVUbpFQ1fsE+RAPwvZBh1r2TqsBibl9mb++xCwdqwsqN141BrSExJaXlkD0r0vVpNyoCCMVfhWbdp2fZ1BFCy0ph9tB/1Iq2FffOEycfrMdpnglcomt2vufW+pxJMatYd/TU/aUOuYWmWLYDquQhc1vZ9gJa3HSek04+zdMBvsr5eu9zFwWhX7KsSsAxG0NwEos/bJ1JvHjCacrA48+SQbdhNlgVaoL432/44Owct+xMIDbsESJwQMDp4Y/XlF7kqFEoc549Q5prsETesPTPCBGyLefKODR+QogY+tkzan0T8qtvo1lF1DGEBCbWweKrVna9bK7ZmFxveTpwMHUebqaU6vWJ1NLpPhBejWoGNDg2tZ/uVdY/NeNyCg9it5YXT6EM3tE3E++UgUcR0aV+HWRQQLBa2843clKT+cZMVIQoGqXKT75L9Is1aJmoUadMDWrIBvaNeSu4uRCK9aJr3s3kYFRguy0er4uxtERmFSM2zghj37HqL6ayLcYJ+r4isNkMwohJR83a01Whbdztv6yQpBeK7q2bOSS/jQgsvd7Jqov1KaMS8eF6N4jBKN8qePQSgqS7PQaEG6Z/e1w2lj3HqsJRvkFqNvmW2a+EBOr7tp7hXcHfgk1CkA/6b7P1HOEzdBNv84pSnF2jZttH5A0q7aDjupOU++D69f+VGai0fSDM5u1oRx3rs+yTzV7CHJPjOiiknc4tiJxHFCqLHQu1dgx3W5iYXLIzu2OAkkU96D+6LOSm67s/dBhM+R2FJUj/6/boXnQ4YFTB4zU++qNoMWOlid9DdOXWntYUpy9QzG8C2j43XN8ehgvG/8F+rrsL5r3Wy6wn8JrBGMUehQMVRrX+AWHE8+Nzl0vjpfSaN9IG73KI3oVFvVxAB3+TqrwjX6T1TyQGL6B5xa+agkp10fG1CQeCmoCK56PwHB1SLqC0UiRBqQj2n+nIeEIcZKlt3Q2SZhIlcuc6QnRoDMHhG2XsY7sONfwdRZv2k1ocG4zH5lpsryTtO5Mv1csKoqMoh0x62tZovtT4lEudSRf2TUcrx/WeL+e6l1cdIJbXuK+RTfH33QU0h1TxOvyPSl9YYHDXESK/6/QyA96y12RYgPrkVJsr3f9MEDMu10woIhRSDO+2VG5pPoq3RMObvNXYQPwsAk//fA5oc8AQddIFKNF+snvd7h+FIhMk4IgIPs2Ut19af/bWu/jF+eOtOH6ulMsVz95TUWfreOik5oCNoU+6dkHHuDQQGLNDPq+wCZn/TpVcWTupp6ju4zak5WFWoPhfkbyrF86BS0EIfamOF/MoxKEbC51ZjAKn3NlNDapkUcR8OCiY3YJ327k0XRnJPR9NlFqKz46Hbzvbqsu/bmV98to45IByDrnksJJskCdBQxzyz/YYR8U7nI41YncuL0mNMbLOah9iGPZbtPIpApDEOVa4T1pERB7qsQEXMaYN3LkWkRfmnupRyyh+8MywnBCLG6A8k8E5zxpievDlO4Vo7ldXWmJquMYJd9A/ixXfLmXKJufQkfsZ2OcrIOPYYN9QTl1fE9IvHrkyU4HfLHiil4aelr6YyGlrjtxwe3LlrH2dvge4xca7YSk3iHlROM1y8myk9JfZ7Xzj9fRoQtR3mdQMBx3PA8gezYhFxPHoITX+MfmxiGiDbrdUJ63WncTOZPw/AZFkzYqtyHYYiwIx5ClboXNtOoKMvAf4fev9S2uuQOM0cqbEpRnrP+XJ18V2K7kwtYL59UYONeyDLhwATIECWkfbwLyZaowYC8bVj9DSX8tN2mbtGtjpDFd12nI106PvvopZn2ygo1bR5GJlfVzqCsceD58FRlZR2KyvJGTKBTHzCNBeVC3Zcttr7Wh31ly7JdH6/rIgCh6QddQ7upVToFm35A05kq7cBET4cVFeKZ1BZDykrXcDoQXsQKXLpxeWMNJyjV2azZ3NJiI1F2c3uZWq0V5dRhNllI1xPatFJC91asSixrfOvlfer71vRuvH23vaCIC8i5mXNG8TuTdnh8qaJna6U5BNZZUfsV0BqdPly8PbddQGd5AHl8vFXQryLuYIGNstLvDzQS3yti+YdxPXPfrSLcBmgapCUpiwSPHH7HH6a+YZz5ObCOOD1jseWeEp/vhesyq8Fl5UU4sjVQoBXZO+db7SMpmfdlXPgShafQDl0zNREwjDMKMCPQq/NPRlA6kfgP8zo2aG1U0rbOOeMwPU/Fv/OsioHyEsXIxITAiUhI4OUCV4Ryst9gG1usTH3qDzbegO0X03PsUp07+I9I49xlq5NCyNdGGrBaOF7Nn/r9VSTxrREmwVEf9y4nYYRrb9bi4PcoeUkYod8U33ai3lzoV/q+4Cychn322PBPxpCtwNCdpRKp3SctHjDjCq+mOP7sSnxgSpnFuU7wfCfo1/QiFdtVJX5f2WWZbELn/Ctrztq0mQvcLSs8S1T/iIVvvaphvuEEqEZJUXIYBm+Tc77MaYHG8lbrEKg6YOZrGXWYbf+hG3EHMNpCLRX0LYBzW/BO3kmgXyOId2t3FWOuZBN+QSs8OeIZXc2rN0Isq83t6q5CuRr7MAOHVPHc7KPhsMexFK6afErFq8RwjYoQMlfDU1SMBMnNmgaGcHPs4LnPhqVW4z4RgjBy3yzhqaXgXfbnXJV/5dixQ=="}
-- CEETOS_RELEASE_SIGNATURE:DFxPPAextbegkVIzJQIqHJ3OODeGqUfEO/m2O96qQqZhrQlDRodihBRA9gQoqqaU+6bWFAftIBC85QYCMw8ImCwmOsM9q6NXEZwIU8WsY+V/vaxelw01AgiU6iiax1aWEWWWdg/rLMEt1N3WInSp7JCmdBgFiec9G6D3tfcl+9rwkvFrhdCAlJ5fHp8jUvgsO5Wki9u+lUhoBPYJYrWZq6iIyMszJu5LiIdtuXtElTUf5GQVEg1kKc0Did4QPDMS/70yAmWO9RWdw6R0wLhiLg1f0cOUV9yvMHiQ5pvS0QuKKTU2lB81Umq4JaZhsqM3eLulkqmUWggarDZ465y7zHM5FQD2bHoNHt453UNr0HfX+NltQBKgykY1EUQ8qP5fMN/uVH5n+lQqaB9aunetBPNO0RJkQjqwSlVYvA30RaiUPzGAq2CaSBmcQMdP999G0/8poTni0KNN7F6erp9anotigr28KFGOjxbgVtNm7aXfIC2zVAhUvPF3ezmPE/UL28aSeVIuEkhyE/WdvhyZyrGqlEdA1Fb2mbAzNKtbtkuRwvNIwvWw0jqgAlMZBgaeBKLTOWtX4i0AfuX0n2Bj/apf1cuisj4z2tnfiayrrWqsOS1YoFh/SG2jSBCHE+QfDRhwDKTQxj1pUPZBU1x/0GOukDEXCJ556dV095YLq1xw4emk9VO3KCBMZUtY1zkOFQ5pJbUrw4q8rz+LV6d7wwZ9UGbnertURIKa8E3iCc4Ejcra5ITfcUhh5yd5bV/HcSWX2h0CZpwV5L2gZgWjWNOOybgU9VYzdD9ngjJKsQ9J7HJfVWVjWrEghKUB5AVXTYWOYY7rO6N+VhjaaY7NFJJZ3gb+4LIgHlnyKcgyYVRG6VO2n9u/kudXDRdHbCn/Ax4Z0ctjjVdBYe/TTJ8YlzK9eVkM2uPb1iA7LDKehfEs9S0sqyrjVgCVjuQrdksHdZdlavLTxRh7SrRirqG1HzkCLSnn12Kye0QVPPwtp1PinTo1KjWPCI+Fk1Krdt4ggQWdqRRTJh2ikm+tYarJ/CCCcSUbj51+U2Hj9rvO9LaFh5XA+DNfqVwE+uDQj21BgT9JiHKgsD7E0qZRAnzOAv2F9gYqAoNNhakIt3/lGBnUN6fn9vxl9/zAe4vIsDtXvaDjRn1Sfs8iu/nQgDmJ757tfIVdZoWsgLj5KT/tpfYk94ijs1sLRoEEudfQxJhZgSMG42zE3gr15cCeWQ0O23TTjKkBJ+T9lsDnENoGNK1tsfvkTQwvu+RUveDjC9EogkzJKbhohvD2sE9Vu+obBjamgZ5TjVHH2og/Im11TOQ58hR8WIq1DrimWV4lhv/MnHfCOWfEAdiTf6CRwnc9VFebYGxUusXGB8+DLsXop0h8n0j0p5LY4TPhmMSj2ZtWvLdScRRzHpl6uN4QIU14G8oPqRGz326KrX91FwQ//K+iLiAaIgl6FmQIE6M+6GP8W91eV7JeK2akbIIZCnBxAJ3/OpDsWwHfT4Xv3z/Qpgk6JsMHE6JHCk1Zwu3rOLe/s+Ar3yWmjqravIuXaoVX6DBUnlOAAG+F6rLhMLIDnN9gqO7T/uuz1XiyrgcthhAQaYdORX6iLMUU3dlghhtpWnGdClnzRYNGFjxxNgYW9T4zt+AeOcVf+oaxGf8MCan68gY2giKasY+F5H4zqTJI0hDfg3C4x4gvMFAQ0tEbXg+jMyFz07ZoQQCycADYU5QNoUWnWE6GiSER7cYAl2sodFKNXOVxy+LzNJVy9PqUGIBSdnUWphD32sCgeItUR8mUFbL5bEPDEb7l/tjnrRfwhp/l8RU7riZ/qVnJmcMsTe7f7LevYFd3EI+xcOKAJ1QYkbSTBwXS2tr4VKMx0xNwg+VYGuP1hAwbBlmirFfDnOIEASu4lIzbTeCaKwuvwGolRATmysdOimIrFZSFoske6USrBAW5qHmOQ23L3plRaLc781oWY7eb71CqFFV+gd0V2StD/HFenHR03mVmPGMiPTh/wCy9EzY9lmYPfWwkIykSiY9pi7aM7NA3+jx9lRTdJmfgP9ej7AdyjlfUyXqbVA9mBOTxBpGmCXf4rmAEal6Bm98+yvGtfvYA92+pDZ3SgdUrZ/W6pOLgpGnrz0hrwFi2Sy6TjXof6usSSy03e1nHUkzHx0azLfgT/pvsImjNm/sz/pnR9oQrZ/mOTztDUkBxmsOy+UyifflQ1P1HhBX4Nbi1F/gt3BwxUFDhK6Ki4BBGY05mUzl4tWS3VmPdp8pyTW76NxviNu16aogfUXn+ycO6ZWMKzZtSHKnTCxa6lN09IOOE3dGy5YJSzZfInK26+ylqffJFb30skB372AtTXY5ScpSjgp4etUx5mAvZLm5at68+KUg1NKuqyWe5KR/4FyYGS0v5P7RUgkp8FR9n+ROlYvNSVSJxS5neI+Xxh//Cad30BoJvY9FAYnkteyTDudJCaGHoXW2ZlInxQv1nxdt10GQsavvmSd1u0sTbN6kWzeaNJS3hCCPc90ATmcm9dnIN2h6WecE4HPWhHZLWlYu5lRLtpVLUkpGZLTudsfYOAtknZAv7a8m/U1wHPiWaPtL8BkXjVwatrH+6jSat3t/I/ZeOzi5rug+QOxqJWzv3OGjSLziwdbYylQYjrW7UBb5a3lY18knRBCbwypTuYf6M0MzFO8Zyh7t/w+w8eg7AnAButHlPudo5fAcPMFlcyizN2ebqvlhkCUorUWRakmGWB1+pqQBpnU4F9CQIZPbNAMhnjB+jaYeY1aBBQEjleBhnaf+pyJgqUNVV3ZrpvsjfVIAXr8bGgbbYSgptQec4ylSkzdMtXlIYq58U1yW7xvuRV5RipY//LTGTQtVpHu1iR+CB2uzknn0Ee3dJp/xc6OzrEje6XQRZn7Y2GgOD5hpA7pSJd2I/Oo+elMJz0mqRUflOyaUH3fq2bu8yBA4NTJRaNPeyp+b34Asjars8tkEmdSCb03V4wkYQnOz4VilyhF/yaIXSJ24DXK6kyeNHSQtOC7XQrr0jUp+Il5Q3pjad1s9HRiFbbMv8Rf7dUDODSPdidQIRDXMzkPG5uza35OxMt82Z4I/qf3s3/D7w+QMF9prpWnKuiRtCk14ZkjH3QkVhQIW3wUZsdRZNUAf/4CQa2k5PRTSUuvupz6P31+Ged0KHtPZER88AZYK8hvpuibR/Y9nMqsbK7BcKGDgp7hxZ8AFkTlaigwomC8xzaVWRojwxmKY+V2+9l1qEqOPDDZPYGd+izotp8v768CrCZ0LV7A4xeob190ggHhrTYEViulsJj6ApAs0DOlAvOMiiCl2HljNZI6qzX6ojxXYjnzp/rTyf0lN4+awK0doTiK3qAVpCK+QxL7ieZCQzWJqYx+s+FzF/GahWLBRt4VHhQi32YfgwJw3pDoY0UWs5M5d9o7Edr9GlaKlpk6g1f0D3SZ6zOftnVg+dewMDcOU6IaHw5WEQA5L6RfMGSXzjdXYoKATNn3XSBO4kB0ZWYDblZkIU0wT1POHdT/d7t1yK2U5LrFBE4FYN04PYGYDMS4WxMuaFDJp1hhd5RWOuUByvl0CMKpqyGGmxzme9Gu1J21T1t3Z8PBxo2TcIpY5YKuLh+Xed0pHydFcYGexoShpuWFc0UGunSGsZzn1wfv7sMSVHArVk+mAidM0pM6MDcu8u4dFCx2pSyJiim33nsKvHmiiSwNaLQfKFNZFh9GTCew1suGZvclnojL4X71XTxH38nuXK/ZgQ7xalwoQDm5FQZEjy8d5py79dcp4gb0QxTy8e3Ei3DZ8rBc8zegv91VbKxJkME2EJGU9QcHc5m97lpwAkIpVSwRaF7L/v8HFPCAEQT7c655IoWIKttO0FPbeKDGNo+1snKXIrCnHvyHh8h/9OfNAv+P8buGIDGS1DpI764VTuebKLmNxIMoHccLrren7jTJYJEQkNK0kenQ6VQwqE1nMAZXqDWVkclDkO9x0bkI7924br3WbR9j9De4hU/V7QHmf6E7mTErVej3XN2y7LvSlSqbH6P3WD2DzrApx/oQM/SIGTvBBQ10xTi0ZXoTHiE2nHN9t6m2xIkrd1rXGV3Mn+nA2tRaKXi3MpQAN2kdhZDeaYtq3eULWxb/h2gsuWFxsEGncZTjeLM062cNWA+XOUVvg4Wtnec/y/CGoZTndDdddYsX0I7HOx3xQbTu1I/ftSlCdfDUc3QOkfYnUsn9AcfDgYrXGxDiVKZEeAtijrYqrUV3FpKqNIoyyGzwf6cL2JBbRNfJaQsM0aCPZbZ7olxSATa4tbYaWyUivs5XGLXPbh5A3EgGWfcmLGY5rNb00DSPVWcPEnGTB8cWEMofTRwOVfVqzYBgInsU2xPMr6rL7BYdlf6OJX7OdaTeaE0NOQ3ld9zSp6i6kwOlkdztTA4ZrffTNwKnkOJK47MQO/KqZir1pJO0gXe6sW0KPJbXJT5mVrcX8z3qnS4fuYxZRMt5r5Q9NDKdJYfFYP0RN77Xb32+8OrYyc3roosXupafIzx9+Yzs5uKZeRiU+BvNeLjLRyiHfZymtvQOP621GqLaXYGFJESSyqvjoFcfvUyIjgpvwBiAPhNXjumj/F42OS1LjWSUZiKLnfNt9LgJilJ4n5+pkui0/emhmFFx8I1nO76UEqwko4h3ty2FvYrYJCZ8+gkaVb9DCKo3E9E7mtzdAJZ5EwViqFgzwV15Wml4+5vTpCEPckuxvIHXGhhWIrwWlF4mF34JB6qJ7JSgboupV6ziEkB2Fc6qPcUilCtJ09g+5/6rVpdkaWtn4MXbj5Q7JE2Co5DPOXltuXvUGAi5HtEKNusE4bTxjSJSfOXE7ylUZb2BmjBtEM8m6EaZ6BsM+rFtJfOttIW+xWATT83s8EB7d1oPIZw3+K4tg+0Gmd+f3Gg5bxtW30KssiWDXbqh+y4hoIoBqkn1mm3Xgs/Ft2TW5L3hhR3swdKqSQ/4IuS4WwlFwL+SVTG9psQ+NPg0gV8CuqBPa3zTXi/tVeotwNUsDVTGKSks9nUIdwMunzRucTa8jWJE13A9J6PKmisIQsd62awcEPjaxR7ze+cyeLNezkD7+uUFd4zaIjfl+aKz5e7KTDEanZP2hzuChqU0xepdupy20Tt3FtLvuSrqEYvhyHii3wX/4dNCOexoN8nSsiJiLS3TQwQB9UIx9TEDdQH3meYFIixLuzTRbJITH8W6ZcsapgqMfg41QVh+wGWR29fTS61AF1/6suJ2AmFiByiSh3we67u4ZqAWnRurcp8qzZzyKv+TuiLzcddZu0qFSLziHhSl2l9qFRO+PEHkfqZkrP0+hVeiq+sAIIlTJ1C3V3SpnSkswO0QMlYZpQ02VQeAhFWhrq+QrSCQxVI8Mu/tev2919k+resSHkcp00SOZ5b/pAe/AK/MIwtytPObR+PP7ShOx5Tze87JxNn+iabe49xkbvGm3k8IbV5HeJ9RBOacStJ9XfodVpAe8iZ22HbNPqIxuhctYkDwqAMLPXdbu2iZoc8+WdmK0LbzyvdUn99Xqq63sDqg/3pglsAL6ortjO6TDOK0t1ouI84GzNZ8S8HbQDOH+oOX5tBkfddU1dDAK510CCYVMgQNYOX37LLklwwzPd8meUviLHCMQESOGVtwvaUqIAH2Ut4eyAxe6hCkAAUN+frOW/Ju6tFCnSQr/Kg99iW4v+Lw21QNnhDAHSEzQLBNQuiegpqUo5JFui4Lk8JMCpFbxUvQsH8bZnHqcUmGW7sR3v+nevRrYnqwlzy8EjjzHRzV2vtbxPMDgNOU4LkZWOpBfVKeV4WqrpPYvC6K/ds0t+9AlzmfwRUx4QN3T8HDfSLpXh2VsU5WYgabjrIwEf08nCExzwRvTjGD9zq8HPEc1UMx2FEFUB2nPGKab9iS2eHgJhkSr26yCzJvPuH6Ekq6zglqUkWlZPX9Tdq9ZetWNqWjeOsVgQGVGWIoLzI0eGZ33Oa2RF+RLovOVDcg78xQQ+ZHIFRPArWnNKMtmeOJ64RwHttepocSKR8qkcew9sWa4SXq9puv3+tsd7eA2KC6sdr86bRWdRerfDbr0KCRClN9QOXM2QdypLyJv+bbKm26LiuHpya4KHcRIOBpVUxSgaI2Y3z1/O+JXtVKu0oLZ61xQikcsvrTV3XfwOvDEjMrZBmKBVriDG/f7kemdm0lBxLN4pjXSlDmtIrX/qQiAKzwdh2725LYpPrKyW4qKoV8BjP+6bSyY0ZYkDvUGesB6TOJf/wu2kliLZMYr4RGNMrnJ9BCqbo1ZOlEzBk7lMaO7Dm61IyWuNizqoEIuejgZvry4Vho2rKlFGQNk2VzQfO3yHc2c9BxJZK6t65VlZ9nqb/HtQXZFk1UG4SJTHosPcNOAJx7UOfcgNdlPoIteUSkRG8ZFEOQYLzv26iou/EoWXyXzm92mCLnpvGC0q81YtkLzZyUW41gA7W4S0K58Hgnv+ysw1y3hqeXmEgucC/hO6EOYtZH/IBCgKXOfzW1G3BEkqCV+oCp4xVVnredv9lm6Gz/Z+5pgFt9LUy3prOc6JiNGkjQxwzInLdHby9GfWrnRcjGNDbAb0tfDVx4UOvzM0uUtWenByyqOxXCEIXW61rMZ+naI17fUER2Te2+mA1auB3NfgJO7xjWqnyxrULi39NEkl5tMVa4ffGqT9O0X3ErwpNPWMpXV96bZM7Fcg2THp6KuUrz1zz/RrIg/wJSRDbCWQwhYQ+1rl9pjIJot/V7ssYL9dLwOwkBJjYctDF1Imh47nHjDeJG1vcFsFz8vyWxVum7LoBsPLRq4DFW4nJUWhLuqNyH2umVHAbzBGG96tbM893eY9/0iIsvXNshi4++DPxhwjQ+RGuZezZlZtJRqJ8UYT+2Dy9Cm7SH6+IFw7XxR3I07KkVkeLMZkHPNg+3CX3k8KgOyHGZdmGYIRJlyPbLr+T3iYdQpYGMZGcSCYknVc5Gl3+PACOGWsEO7v+9VlCYg/Cv+rf1jg2ysvEcGl41puZ/6HfR1sW9AN0VmD3F5wUN9In8oNYqFT3/BUmahBLnsAryAKqwK7uMSetg7+NMLy00JG7a13u/z5PGspA1CB2eCYLBSCWPqLNvbzMaDe/beJE7zaQS3hBoGpH+BbDsUUEGZfIcEH41bNp5uDiyEPmQVEHnwJKD/N5RvXOc70cqvzCEtVcHke/OPH+6AE1X0IO4IeSlOQ5d5aGLosVyi7x0zFKcif1DPfuuE9Qjq86JFYBSHqcbWw072OWmJKlm/WduX4dBK2YZhRgGyzCsfWR5hbnCw0fhLt+a0ENyRG+HqUkEg0oGp0yUJ9l78HDHoIfIxZ3G6ERhxq31cbvKoalLVv17vWAWgdCk6Gr1YVrkSxAvGEWrn/rxlySDPUBZMilJjCpdAqN24qAwVDruHgOQ0fZJiVE+eqquyngfDJgSst7SSWRNTU21DpTadOTBXUsQPOD7a8U2Osk6NZQ1TRq+FURe46Ew8FTDJsp9//r4HRXOUeDg5nVlphpC0IKwFJBFgb2raBQ2kmoqmh8T2FuhU5LQjhE71G3Qb8HTUfMAkMUZcPwu7yyvGeFTK1U/1ZVcpWbvHoO7tZLGcMKsAEmZvFb1dBJimgWDNMM/ByowWVcrX1Tc/8uUsmOJalgMjMlHBX6UUJQyAqBZgjrOsl21pYADMYEw/5qXWaZyuCDFQYTv11lXbQCMhQO4gH+3DsO8LJSm0bn5rKl7qo3GKOeBeIfkm38ket7Eq0/Xn/T+fJwTYupCOAnwnODKcA1nVoHo3K9SNQ3iqHQCvM/WbzR5pgK4PzpJYP4jL3KqetZV+3zaKzp/GWyyqBSf6bkluJtrrJ3URdpPcaswigExFnUwxAYTTDXDJXoWio+Frc+1oGAUb2kd+icIzgh+B2WV10wtpuKl93hoXX8AW/xph8F9yNQs4XhiJxI/z963MJw07yMTtI2rj93dhkYdans3Zh/3e2g7nt8YfH1G2PtKXHcXs2HlPR1G6WfvJNOpWwkxd3WGXEIBXXaf8TjxnMaM5Tm8SKyVXEx4kZWlsuQjcF/xCAc/BeMhYdh0OhIHsL8hN9MUaSHZ3MtqRH6GBOIKVCsUxe45AWxBs05MUVCz0bc4NTbGHHZK778oE6LGk1t4szIG6mfK/qeeCL/kUK87A5mAlG8WiBGRo4nezSyL8mgHPO+pokt7nmx7qUMdPbetqJnde8r+SWEOr2edEsfiWoG1vGcJ/sszXjROvfTT1XHfhuk6gjQhEglZg6RPHrgAPcTRUQYs6VnMZnaJMfiCKANBFjrqJZVF0IwhgYXagbn9//ARR4L+Ir8C1/hMVc2yGw8fiqk0ylDXD4gIobAOCxMci6qDCTHQvjThQe88tsOugSZMkhL5S+dZ6C1nfMWMWRLLapTq0Cjfb/lE4pQbOwUhOdZHV46ycHP8Fo19ddjm8e7AL3yUQaurdvw/wdxAvYY6gdOprMK44MZLK4PDWHJWTC2Ybpmu5OLQSuwWwJ9CHA9SAo+bsG3lzMA/ZmXLf9Nrk93cpA2pXB+fDpmjhRjvo7r5rL1QX2DvaeuQIb1xDa3G8jZnAu/LbbtyLUiBwZxCegj6r0XEQRu+Foj8O57RO7S1+IhW02soDUqiZNZWbp6bXyzdw3YIQHupmKjPq2sKDfbaZGf7hG1F24MJCnd1tRUXugbPO+9BeJHBXhXSXxPP/GenFmrslsy3r9/0xhHtMZp02A84+Qge64SGfSPJK8X+rNYhXeS2XWTb1Zn+IyvB2UbpnySV19J0ujAh5/NLzGSB58V0iXmYKm48rI9iGId++z2W+dnPWY7zo8RKqi2yasPCw4Mds+3BKqJczf/i6vcp+YQKmGvbm7AA3ueig9SVSb7pQC5jejFOdPqS1EdNj9B4tpzZUoAWBCB8VhYGqRJLaeBZqaNKRnAZeN8VIzJ4LOFhuIxpWj5EkUJ2mtdA29T8hFmN4mvelu09TuJUQF3ZkFdQBhHWK7yTljdDNpnUT8DL8c3vod7FVBpoWKZ/tfZvzMAtQAMMYZoHv5hmHFEMZVUOQvIQquwF5E3CnkevmmRSdaoa8kYUdggshtPTw/Dx1kWkK1Xz82sejXAOscZccNrAMlM8OvzcAh+6ajP2Lago5DP4YmrnxYoTfnrzYQogEu25o537AWCV3PqDZNFuG5ovFbJfcXy7Djh+Vs2mhoxMbP+SUc9b18e5sJ3BRnH5NnXMNtuPrJ2e0aZ9yyiCJl9IZzjrock4RwtgK2bLtZdfqBe3icGMUClyqyzrNzwKK0YqU59spfFrkN/gn9vEYA8D1ZtWvTcC9zBr0ucUcBQDitegs7kM32oUj57/HW6q2J/dxcyHovgjWLrdCVTOvY5Y2MXcjYETfcPw/E6Nj34+RT/4K1ZuE/jdL7XqhKG4e0logJ1EOXc9GQZrsmR4vk/L2i1Eq9ejU/AqUKak9xKegQnFWnzwnSQWU5DAaQ1qs14ArhjxpB+QzZ+w/Z3cfowQrBmmfMvQIubwKuF0iiuPXG80uPGl4WYKb5T9oE4qj0B/7N0pM7pTNgf6/maT8HC55NIMbAL4/g/68Hym0pnPBekS/LSeE3+1DBwt1X0QVMvMSU6HCanOAXQU5cwMCfbGp3jJpOiLssln8EqfK2pyILnltL3+Cn6IsoGhB34wGp6bCHDNSsK8GzL1kuqrD6mb5CkuFkcsDcOQkJ1HXxEkyKOlQ9ydYgxBzmUu/5tXWLhkiYQffAkadC4oTncFPDBrzdyQJbo3KFJgd6gfr2Pt0YNn5s+eS7xe1Ye1KI/g+Zbch+rqTC5+jcpFqHMMGnwk0Yi9Cxj0mz+4F9nwewzBwu5DHH9ihs/w9IXgLD7qVmKlkiYGPzcWZm+3CHE0f7tl8HOX/OLjJiAIxF5juyjhckux66JxO+z4irZZ7gS2ozvtnOukP53gE3N0+pUkR0cTQE0d3f5wiZglR1tN14PEFaR/qZLKV/gPvD7jiH7qhuAo3YjhtnVeQYqmI+QGQp+8l9p5nSXjC4XUCFRBu1IK3NWhOlX2rMxF61Eqeqijm/veH/VXIUaE495MU2XRe7kPl+MGUDbXBIrXuSwNhXDfBBIHeM8znEp9sT6zX/o+bzvq45ulfvTA9kgy6Imc4BjK+iKXiV+YI29lSOJXCJx3/nm6EW+yofaIVFkofHAVv1tCfWK+A9yuIxaSvYsWANrei6m9GjD5ZKQAUMOACwNPRjKQImyneK6pflIIYRN5wQo+9ERSBmIbyBKKr5rKarg0GlFoZ4XbLdqEBSPfaVIT4wjIOQOOfUwHFn1rvLz5hC95j7KaHFkZVNSyVDSTUR7bcW7oxIomVCSLvia0STPojgf+bomWItzMI0UjiJ2+nvXGIeQjhwXKh5lCN1H9Z8pubsVmoi7QpHbacrsaECDQqiyUk8CHOqPuXIHcXdqt1QKlWuo+n+YV5A7AVFe2FnYMLibK/XRsQXFfIb8G+utr+Rfxo25IiJ5vn2SNCEoEmPxBST4dCej53S8cNWZYi7uOZOeP5Zv+StU2Zyo0s8m8V87H6P290Jxmyz3NqsBaRoewb1j5URM3+ArPvdZNiBZRdkknyS4ky50t7bXNbQT2S04q3kzGjg4DB6wRKMy4tWya+PrefL1i5ZyT553lhtd4a/8fHLODyc9Be7igESO4CqTb8tZlh9LVnmjikxN1xjaL/Hdm66pCdRblGMkaUtkdDoi6uEsLJJ/l+YNuAhMFF8dtb7AxLIqRkPd5bUi5lJdqjkV7Qrd59csE17KALK88uDGqxLZMb2N6PLdDVGQiMSMRDrY23SF9+Hdjd86g6WmJYlO32bbGPvtkASizstPvCL0jjArWX9u6ULnQJ4BAqipagYj0+HDxPz7B9QgQUWJ+8qoaLzCqPcetASi0iy3RCSxFCgqBZcN9YDqI+18cWnMxRIdPx6k3M=
-- CEETOS_RELEASE_PAYLOAD_BEGIN
-- CeetOS installer. Generated; do not edit.
local files = {
  ["startup.lua"] = "local pendingPath,releasePath=\"/ceetos-updates/pending.lua\",\"/ceetos-updates/release.lua\"local pending if fs.exists(pendingPath)then local loader=loadfile(pendingPath)if loader then local ok,value=pcall(loader)if ok and type(value)==\"table\"then pending=value end end end local function checksum(text)local hash=2166136261 for index=1,#text do hash=(hash*31+text:byte(index))%4294967296 end return string.format(\"%08x\",hash)end local function recoveryAgent()local root,descriptor=\"/ceetos-dev/recovery\",\"/ceetos-dev/recovery/slots.lua\"local source=\"/ceetos/recovery/agent.lua\"if not fs.exists(source)then return nil end if not fs.exists(root)then fs.makeDir(root)end local slots={}if fs.exists(descriptor)then local handle=fs.open(descriptor,\"r\")if handle then slots=textutils.unserialise(handle.readAll())or{};handle.close()end end slots.active=slots.active==\"a\"and\"a\"or\"b\"local inactive=slots.active==\"a\"and\"b\"or\"a\"local input=fs.open(source,\"r\")local text=input and input.readAll()or nil if input then input.close()end if not text then return nil end local candidate=root..\"/agent-\"..inactive..\".lua\"if(slots[inactive]or\"\")~=checksum(text)and load(text,candidate,\"t\")then local temporary=candidate..\".tmp\"local output=fs.open(temporary,\"w\")if output then output.write(text);output.close();if fs.exists(candidate)then fs.delete(candidate)end;fs.move(temporary,candidate);slots[inactive]=checksum(text)end end local active=root..\"/agent-\"..slots.active..\".lua\"local fallback=root..\"/agent-\"..inactive..\".lua\"local activeSlot,fallbackSlot=slots.active,inactive local function validSlot(path,expected)if not fs.exists(path)then return false end local handle=fs.open(path,\"r\");local body=handle and handle.readAll()or nil if handle then handle.close()end return body~=nil and(expected==nil or expected==checksum(body))and load(body,path,\"t\")~=nil end if not validSlot(active,slots[slots.active])then if validSlot(fallback,slots[inactive])then active,fallback,slots.active=fallback,active,inactive activeSlot,fallbackSlot=inactive,activeSlot else return nil end end local out=fs.open(descriptor..\".tmp\",\"w\")if out then out.write(textutils.serialise(slots));out.close();if fs.exists(descriptor)then fs.delete(descriptor)end;fs.move(descriptor..\".tmp\",descriptor)end return{primary=active,fallback=validSlot(fallback,slots[fallbackSlot])and fallback or nil}end local recovery=recoveryAgent()if pending and pending.state==\"apply\"and fs.exists(releasePath)then shell.run(releasePath,\"--ceetos-apply\")elseif recovery then local ok=shell.run(recovery.primary)if ok==false and recovery.fallback then shell.run(recovery.fallback)end elseif fs.exists(\"/ceetos/startup.lua\")then shell.run(\"/ceetos/startup.lua\")else shell.run(\"shell\")end",
  ["ceetos/startup.lua"] = "local root=\"/ceetos\"local profile={id=\"desktop\"}if fs.exists(root..\"/profile.lua\")then local loader=loadfile(root..\"/profile.lua\")if loader then local ok,value=pcall(loader);if ok and type(value)==\"table\"then profile=value end end end if profile.id~=\"desktop\"and fs.exists(root..\"/server.lua\")then shell.run(root..\"/server.lua\")elseif fs.exists(root..\"/ceet.lua\")then shell.run(root..\"/ceet.lua\")else printError(\"CeetOS is incomplete; starting CraftOS shell.\")shell.run(\"shell\")end",
  ["ceetos/profile.lua"] = "return {schema=1,id=\"router-server\"}",
  ["ceetos/lib/store.lua"] = "local M={}local cache={}local function internalPath(path)return type(path)~=\"string\"or path:sub(-4)==\".new\"or path:sub(-4)==\".bak\"end local function call(fn,...)local result={pcall(fn,...)}if not result[1]then return false,tostring(result[2])end if result[2]==false then return false,tostring(result[3]or\"operation failed\")end return true,result[2],result[3]end local function exists(path)local ok,value=call(fs.exists,path)return ok and value==true end local function remove(path)if not exists(path)then return true end local ok,err=call(fs.delete,path)return ok,err end local function ensureDirectory(path)local dir=fs.getDir(path)if dir==\"\"or exists(dir)then return true end local ok,err=call(fs.makeDir,dir)return ok,err end local function readRaw(path)local ok,handleOrErr=call(fs.open,path,\"r\")if not ok or not handleOrErr then return false,nil,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local readOk,content=call(handle.readAll)local closeOk,closeErr=call(handle.close)if not readOk then return false,nil,content end if not closeOk then return false,nil,closeErr end return true,content end local function writeRaw(path,content)local ok,handleOrErr=call(fs.open,path,\"w\")if not ok or not handleOrErr then return false,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local writeOk,writeErr=call(handle.write,content)local closeOk,closeErr=call(handle.close)if not writeOk then return false,writeErr end if not closeOk then return false,closeErr end return true end local function move(source,destination)local ok,err=call(fs.move,source,destination)return ok,err end local function decode(raw)local ok,value=pcall(textutils.unserialise,raw)if not ok or value==nil then return false,nil,\"invalid serialised value\"end return true,value end local function readValue(path)local ok,raw,err=readRaw(path)if not ok then return false,nil,err end return decode(raw)end local function recoverValue(path)local activeOk,activeValue=false,nil if exists(path)then activeOk,activeValue=readValue(path)end if activeOk then remove(path..\".new\")remove(path..\".bak\")return true,activeValue end local backupOk,backupValue=false,nil if exists(path..\".bak\")then backupOk,backupValue=readValue(path..\".bak\")end if backupOk then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,backupValue end remove(path..\".new\")return false,nil end local function validLines(raw)for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local ok,value=pcall(textutils.unserialise,line)if not ok or value==nil then return false,\"invalid appended value\"end end end return true end local function recoverAppend(path)if exists(path)then local activeOk,raw=readRaw(path)if activeOk then local valid=validLines(raw)if valid then remove(path..\".new\")remove(path..\".bak\")return true,raw end end end if exists(path..\".bak\")then local backupOk,raw=readRaw(path..\".bak\")if backupOk and validLines(raw)then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,raw end end remove(path..\".new\")return false,\"no valid appended value\"end local function commitRaw(path,raw,validator)local dirOk,dirErr=ensureDirectory(path)if not dirOk then return false,dirErr end local temporary,backup=path..\".new\",path..\".bak\"local removeOk,removeErr=remove(temporary)if not removeOk then return false,removeErr end local writeOk,writeErr=writeRaw(temporary,raw)if not writeOk then remove(temporary);return false,writeErr end local checkOk,checkedRaw,checkErr=readRaw(temporary)if not checkOk then remove(temporary);return false,checkErr end local valid,validErr=validator(checkedRaw)if not valid then remove(temporary);return false,validErr or\"temporary validation failed\"end local backupRemoveOk,backupRemoveErr=remove(backup)if not backupRemoveOk then remove(temporary);return false,backupRemoveErr end if exists(path)then local backupOk,backupErr=move(path,backup)if not backupOk then remove(temporary);return false,backupErr end local activateOk,activateErr=move(temporary,path)if not activateOk then if not exists(path)then move(backup,path)end remove(temporary)return false,activateErr end else local activateOk,activateErr=move(temporary,path)if not activateOk then remove(temporary);return false,activateErr end end return true end function M.readCached(path,fallback)if internalPath(path)then return fallback end local entry=cache[path]if entry~=nil then return entry.value end return M.readFresh(path,fallback)end function M.readFresh(path,fallback)if internalPath(path)then return fallback end local ok,value=recoverValue(path)if not ok then value=fallback end cache[path]={value=value}return value end function M.read(path,fallback)return M.readCached(path,fallback)end function M.writeAtomic(path,value)if internalPath(path)then return false,\"cannot write store temporary or backup path\"end if value==nil then return false,\"cannot store nil\"end local serialisedOk,raw=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(raw)~=\"string\"then return false,tostring(raw or\"could not serialise value\")end local valid=decode(raw)if not valid then return false,\"could not validate serialised value\"end recoverValue(path)local ok,err=commitRaw(path,raw,decode)if ok then cache[path]={value=value}end return ok,err end function M.write(path,value)return M.writeAtomic(path,value)end function M.append(path,value,limits)if internalPath(path)then return false,\"cannot append to store temporary or backup path\"end if value==nil then return false,\"cannot append nil\"end local serialisedOk,line=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(line)~=\"string\"then return false,tostring(line or\"could not serialise value\")end local valid=validLines(line..\"\\n\")if not valid then return false,\"could not validate appended value\"end local recovered,current=recoverAppend(path)if not recovered then if exists(path)or exists(path..\".bak\")then return false,current end current=\"\"end local lines={}for existing in(current..\"\\n\"):gmatch(\"(.-)\\n\")do if existing~=\"\"then lines[#lines+1]=existing end end lines[#lines+1]=line local maxEntries=limits and tonumber(limits.maxEntries)local maxBytes=limits and tonumber(limits.maxBytes)if maxEntries then maxEntries=math.max(1,math.floor(maxEntries))end if maxBytes then maxBytes=math.max(1,math.floor(maxBytes))end while maxEntries and#lines>maxEntries do table.remove(lines,1)end local raw=table.concat(lines,\"\\n\")if#raw>0 then raw=raw..\"\\n\"end while maxBytes and#raw>maxBytes and#lines>1 do table.remove(lines,1)raw=table.concat(lines,\"\\n\")..\"\\n\"end if maxBytes and#raw>maxBytes then return false,\"appended value exceeds byte limit\"end local ok,err=commitRaw(path,raw,validLines)if ok then cache[path]=nil end return ok,err end function M.readAppend(path)if internalPath(path)then return\"\"end local ok,raw=recoverAppend(path)return ok and raw or\"\"end function M.invalidate(path)cache[path]=nil end return M",
  ["ceetos/lib/profile.lua"] = "local store=require(\"ceetos.lib.store\")local M={}M.PATH=\"/ceetos/profile.lua\"M.IDS={desktop=true,[\"recipe-server\"]=true,[\"router-server\"]=true,[\"auth-server\"]=true}local cache local function normalise(value)if type(value)~=\"table\"then value={}end local id=tostring(value.id or value.profile or\"desktop\")if not M.IDS[id]then id=\"desktop\"end return{schema=1,id=id,installedAt=tonumber(value.installedAt)or 0}end function M.current()if not cache then cache=normalise(store.read(M.PATH,{id=\"desktop\"}))end return cache end function M.id()return M.current().id end function M.is(id)return M.id()==id end function M.isServer()return M.id()~=\"desktop\"end function M.set(id)assert(M.IDS[id],\"invalid CeetOS profile\")cache={schema=1,id=id,installedAt=os.epoch(\"utc\")}return store.write(M.PATH,cache)end function M.capability(name)local id=M.id()local tableFor={desktop={desktop=true,craftingClient=true,orders=true},[\"recipe-server\"]={server=true,recipes=true,recipeImport=true,recipePlan=true},[\"router-server\"]={server=true,routing=true},[\"auth-server\"]={server=true,authAuthority=true},}return tableFor[id][name]==true end return M",
  ["ceetos/lib/auth.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local audit=require(\"ceetos.lib.audit\")local M={current=nil}local USERS=\"/ceetos/data/users.lua\"local SESSION=\"/ceetos/data/session.lua\"local TOMBSTONES=\"/ceetos/data/user-tombstones.lua\"local THROTTLE=\"/ceetos/data/login-throttle.lua\"local RECOVERY=\"/ceetos/data/recovery.lua\"local AUTHORITY=\"/ceetos/data/auth-authority.lua\"local CENTRAL_SESSION=\"/ceetos/data/auth-session.lua\"local DIRECTORY=\"/ceetos/data/auth-directory.lua\"local rank={viewer=1,operator=2,admin=3}M.SESSION_TTL_MS=8*60*60*1000 M.LOGIN_THROTTLE={failures=5,windowMs=5*60*1000,lockMs=60*1000,maxEntries=64}local configuredWorkFactor=password.DEFAULT_WORK_FACTOR local sessionPathDelete local function now()return os.epoch(\"utc\")end local function accountName(name)return type(name)==\"string\"and name:match(\"^[%w_%-]+$\")and#name<=32 end local function users()store.invalidate(USERS);return store.read(USERS,{})end local function save(value)return store.write(USERS,value)end local function tombstones()store.invalidate(TOMBSTONES);return store.read(TOMBSTONES,{})end local function saveTombstones(value)return store.write(TOMBSTONES,value)end local function authority()store.invalidate(AUTHORITY)local value=store.read(AUTHORITY,nil)return type(value)==\"table\"and value.active==true and type(value.id)==\"string\"and value or nil end function M.authority()return authority()end function M.centralActive()return authority()~=nil end local function centralDirectory()store.invalidate(DIRECTORY)local value=store.read(DIRECTORY,{})return type(value)==\"table\"and type(value.users)==\"table\"and value or{users={}}end function M.acceptAuthority(record)assert(type(record)==\"table\"and type(record.id)==\"string\"and#record.id<=64,\"invalid auth authority\")local public={schema=1,active=true,id=record.id,term=math.max(0,math.floor(tonumber(record.term)or 0)),revision=math.max(0,math.floor(tonumber(record.revision)or 0)),seen=now()}assert(store.write(AUTHORITY,public),\"could not save auth authority\")if type(record.directory)==\"table\"then assert(store.write(DIRECTORY,{schema=1,revision=public.revision,users=record.directory}),\"could not save account directory\")end local loaded,profile=pcall(require,\"ceetos.lib.profile\")if not loaded or not profile.is(\"auth-server\")then if fs.exists(USERS)then fs.delete(USERS)end if fs.exists(TOMBSTONES)then fs.delete(TOMBSTONES)end sessionPathDelete()end return public end function M.updateDirectory(directory,revision)if type(directory)~=\"table\"then return false,\"invalid account directory\"end return store.write(DIRECTORY,{schema=1,revision=math.max(0,math.floor(tonumber(revision)or 0)),users=directory})end function M.saveCentralSession(value)if type(value)~=\"table\"or not accountName(value.name)or type(value.role)~=\"string\"then return false,\"invalid central session\"end local session={sessionVersion=3,name=value.name,role=value.role,token=value.token,issued=value.issued,expires=value.expires,accountRevision=value.accountRevision,authority=value.authority}if type(session.token)~=\"string\"or#session.token<16 then return false,\"invalid central session token\"end store.write(CENTRAL_SESSION,session)M.current=nil return true end local function safeAudit(action,detail)pcall(audit.log,\"auth\",action,detail or{})end local function stamp(account)account.updated=now()account.origin=tostring(os.getComputerID())account.revision=math.max(0,math.floor(tonumber(account.revision)or 0))+1 return account end local function makeAccount(role,plainPassword,context)local record,err=password.record(plainPassword,password.newSalt(context),configuredWorkFactor)assert(record,err)record.role=role return stamp(record)end sessionPathDelete=function()if fs.exists(SESSION)then fs.delete(SESSION)end store.invalidate(SESSION)end local function saveSession()if M.current==nil then sessionPathDelete();return end local durable={sessionVersion=2,name=M.current.name,nonce=M.current.nonce,issued=M.current.issued,expires=M.current.expires,accountRevision=M.current.accountRevision,}store.write(SESSION,durable)end local function makeSession(name,account)local issued=now()M.current={name=name,role=account.role,nonce=password.newSalt(\"session:\"..name),issued=issued,expires=issued+M.SESSION_TTL_MS,accountRevision=tonumber(account.revision)or 0,}saveSession()return M.current end local function liveAccount(name)local all=users()return all[name],all end local function normaliseSession(saved,account)if type(saved)~=\"table\"or not account or account.disabled then return nil end if saved.sessionVersion==2 then local issued,expires,revision=tonumber(saved.issued),tonumber(saved.expires),tonumber(saved.accountRevision)if type(saved.nonce)~=\"string\"or#saved.nonce<16 or not issued or not expires or not revision then return nil end if expires<=now()or revision~=(tonumber(account.revision)or 0)then return nil end return{name=saved.name,role=account.role,nonce=saved.nonce,issued=issued,expires=expires,accountRevision=revision}end if saved.sessionVersion==nil and type(saved.role)==\"string\"then return\"legacy\"end return nil end function M.refreshSession()local central=authority()if central then store.invalidate(CENTRAL_SESSION)local saved=store.read(CENTRAL_SESSION,nil)local entry=type(saved)==\"table\"and centralDirectory().users[saved.name]or nil if type(saved)~=\"table\"or saved.sessionVersion~=3 or saved.authority~=central.id or type(saved.token)~=\"string\"or(tonumber(saved.expires)or 0)<=now()or type(entry)~=\"table\"or entry.disabled==true or saved.accountRevision~=entry.revision then M.current=nil if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end return nil end M.current={name=saved.name,role=entry.role,nonce=saved.token,issued=saved.issued,expires=saved.expires,accountRevision=saved.accountRevision,authority=central.id,central=true}return M.current end store.invalidate(SESSION)local saved=store.read(SESSION,nil)if type(saved)~=\"table\"or not accountName(saved.name)then M.current=nil;return nil end local account=liveAccount(saved.name)local session=normaliseSession(saved,account)if session==\"legacy\"then return makeSession(saved.name,account)end if not session then M.current=nil sessionPathDelete()return nil end M.current=session return M.current end local function throttleState()store.invalidate(THROTTLE)local data=store.read(THROTTLE,{})return type(data)==\"table\"and data or{}end local function saveThrottle(data)local entries={}for name,entry in pairs(data)do if accountName(name)and type(entry)==\"table\"and type(entry.last)==\"number\"then entries[#entries+1]={name=name,last=entry.last}end end table.sort(entries,function(a,b)return a.last>b.last end)local kept={}for index,entry in ipairs(entries)do if index<=M.LOGIN_THROTTLE.maxEntries then kept[entry.name]=data[entry.name]end end store.write(THROTTLE,kept)end local function locked(name)if not accountName(name)then return false end local entry=throttleState()[name]return entry and(tonumber(entry.lockedUntil)or 0)>now()or false end local function noteFailure(name,reason)if not accountName(name)then return end local data,entry,time=throttleState(),nil,now()entry=data[name]or{failures=0,first=time}if time-(tonumber(entry.first)or 0)>M.LOGIN_THROTTLE.windowMs then entry.failures,entry.first=0,time end entry.failures=math.max(0,math.floor(tonumber(entry.failures)or 0))+1 entry.last=time if entry.failures>=M.LOGIN_THROTTLE.failures then entry.lockedUntil=time+M.LOGIN_THROTTLE.lockMs end data[name]=entry saveThrottle(data)safeAudit(\"login.failure\",{account=name,reason=reason or\"invalid\",throttled=(entry.lockedUntil or 0)>time})end local function clearFailures(name)local data=throttleState()if data[name]~=nil then data[name]=nil;saveThrottle(data)end end function M.throttleStatus(name)local entry=accountName(name)and throttleState()[name]or nil if not entry then return{failures=0,lockedUntil=0}end return{failures=tonumber(entry.failures)or 0,lockedUntil=tonumber(entry.lockedUntil)or 0}end function M.setPasswordWorkFactor(value)local work,err=password.normaliseWorkFactor(value)assert(work,err)configuredWorkFactor=work return work end function M.passwordWorkFactor()return configuredWorkFactor end function M.bootstrap(initialPassword)if authority()then return false end local all=users()if next(all)then return false end local plainPassword=initialPassword if plainPassword==nil then term.write(\"Create CeetOS admin password: \");plainPassword=read(\"*\")end local account=makeAccount(\"admin\",plainPassword,\"admin\")all.admin=account assert(save(all),\"could not save administrator account\")makeSession(\"admin\",account)safeAudit(\"bootstrap\",{account=\"admin\"})return true end function M.login(name,plainPassword)if authority()then local client=require((\"ceetos.lib.auth_client\"))return client.login(name,plainPassword)end if not accountName(name)or type(plainPassword)~=\"string\"then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if locked(name)then safeAudit(\"login.failure\",{account=name,reason=\"throttled\",throttled=true})return false,\"too many failed attempts; try again later\"end local account,all=liveAccount(name)if not account or account.disabled then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end local valid,state=password.verify(account,plainPassword)if not valid then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if state==\"legacy\"then local upgraded=makeAccount(account.role,plainPassword,\"upgrade:\"..name)upgraded.updated=account.updated or upgraded.updated upgraded.origin=account.origin or upgraded.origin upgraded.revision=math.max(tonumber(account.revision)or 0,upgraded.revision)stamp(upgraded)all[name]=upgraded assert(save(all),\"could not upgrade password record\")account=upgraded safeAudit(\"password.upgraded\",{account=name})end clearFailures(name)makeSession(name,account)safeAudit(\"login.success\",{account=name})return true end function M.logout()M.current=nil sessionPathDelete()if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end end function M.add(name,role,plainPassword)if authority()then assert(rank[role]and accountName(name),\"invalid user or role\")local record,err=makeAccount(role,plainPassword,\"central:\"..name)assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"add\",{name=name,role=role,record=record})end M.require(\"operator\")assert(rank[role],\"invalid role\")if role==\"admin\"then M.require(\"admin\")end assert(accountName(name),\"invalid user name\")local all=users()assert(not all[name],\"user exists\")all[name]=makeAccount(role,plainPassword,name)assert(save(all),\"could not save user\")safeAudit(\"user.add\",{account=name,role=role})end local function adminCount(all)local count=0 for _,account in pairs(all)do if account.role==\"admin\"and not account.disabled then count=count+1 end end return count end function M.setRole(name,role)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"role\",{name=name,role=role})end M.require(\"operator\")assert(accountName(name)and rank[role],\"invalid user or role\")local all,account=users(),users()[name]assert(account,\"unknown user\")if role==\"admin\"or account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot change the active account role\")assert(not(account.role==\"admin\"and role~=\"admin\"and adminCount(all)<=1),\"cannot remove the last administrator\")account.role=role stamp(account)all[name]=account assert(save(all),\"could not save account role\")safeAudit(\"user.role\",{account=name,role=role})end function M.setDisabled(name,disabled)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"disable\",{name=name,disabled=disabled==true})end M.require(\"admin\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")assert(not(M.current and M.current.name==name),\"cannot disable the active account\")if disabled then assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot disable the last administrator\")end account.disabled=disabled==true stamp(account)all[name]=account assert(save(all),\"could not save account state\")safeAudit(\"user.disabled\",{account=name,disabled=account.disabled})end function M.remove(name)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"remove\",{name=name})end M.require(\"operator\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot delete the active account\")assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot delete the last administrator\")all[name]=nil local removed=tombstones()removed[name]=now()assert(saveTombstones(removed),\"could not save account tombstone\")assert(save(all),\"could not remove account\")safeAudit(\"user.remove\",{account=name})end local function recoveryActive()store.invalidate(RECOVERY)local recovery=store.read(RECOVERY,{})return type(recovery)==\"table\"and(tonumber(recovery.until_ts)or 0)>now()end local function setPassword(name,plainPassword)assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")local replacement=makeAccount(account.role,plainPassword,\"reset:\"..name)replacement.updated=account.updated or replacement.updated replacement.origin=account.origin or replacement.origin replacement.revision=math.max(tonumber(account.revision)or 0,replacement.revision)replacement.disabled=account.disabled==true stamp(replacement)all[name]=replacement assert(save(all),\"could not save password\")if M.current and M.current.name==name then M.current=nil;sessionPathDelete()end safeAudit(\"password.reset\",{account=name})return true end function M.resetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end if not M.allowed(\"admin\")and not recoveryActive()then error(\"permission denied (requires admin or active recovery window)\",2)end return setPassword(name,plainPassword)end function M.adminResetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end M.require(\"operator\")local account=users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end return setPassword(name,plainPassword)end function M.allowed(role)if not rank[role]then return false end local current=M.refreshSession()return current~=nil and rank[current.role]>=rank[role]end function M.require(role)if not M.allowed(role)then error(\"permission denied (requires \"..tostring(role)..\")\",2)end end function M.list()local out={}local source=authority()and centralDirectory().users or users()for name,account in pairs(source)do out[#out+1]={name=name,role=account.role,disabled=account.disabled==true,revision=account.revision}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.snapshot()if authority()then return{users={},tombstones={},source=tostring(os.getComputerID()),schema=3,central=true}end return M.authoritySnapshot()end function M.authoritySnapshot()local copy={users={},tombstones={},source=tostring(os.getComputerID()),schema=2}for name,account in pairs(users())do copy.users[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=tonumber(account.revision)or 0,disabled=account.disabled==true,updated=account.updated or 0,origin=account.origin or copy.source,}end for name,removed in pairs(tombstones())do copy.tombstones[name]=removed end return copy end local function validIncomingPassword(account)if password.isModern(account)then local work=password.normaliseWorkFactor(account.workFactor)return work~=nil and type(account.verifier)==\"string\"and#account.verifier==64 and account.verifier:match(\"^[0-9a-f]+$\")~=nil end return type(account.salt)==\"string\"and#account.salt>0 and#account.salt<=256 and type(account.verifier)==\"string\"and account.verifier:match(\"^[0-9a-fA-F]+$\")~=nil and#account.verifier==8 end function M.merge(snapshot,authoritySeed)if authority()and authoritySeed~=true then return false,\"distributed account sync is disabled by central authority\"end if type(snapshot)~=\"table\"or type(snapshot.users)~=\"table\"then return false,\"invalid account sync\"end local all,removed,changed=users(),tombstones(),false for name,deletedAt in pairs(snapshot.tombstones or{})do if accountName(name)and type(deletedAt)==\"number\"and deletedAt>(removed[name]or 0)then local localAccount=all[name]if not localAccount or(localAccount.updated or 0)<=deletedAt then all[name],removed[name],changed=nil,deletedAt,true end end end for name,account in pairs(snapshot.users)do if accountName(name)and type(account)==\"table\"and rank[account.role]and validIncomingPassword(account)then local updated=tonumber(account.updated)or 0 local localAccount,incomingOrigin=all[name],tostring(account.origin or snapshot.source or\"\")local localOrigin=localAccount and tostring(localAccount.origin or os.getComputerID())or\"\"local wins=not localAccount or updated>(localAccount.updated or 0)or(updated==(localAccount.updated or 0)and incomingOrigin~=\"\"and incomingOrigin<localOrigin)if(removed[name]==nil or updated>removed[name])and wins then all[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=math.max(0,math.floor(tonumber(account.revision)or 0)),disabled=account.disabled==true,updated=updated,origin=incomingOrigin,}changed=true end end end if changed then assert(save(all),\"could not save account sync\")assert(saveTombstones(removed),\"could not save account tombstones\")M.refreshSession()end return changed end function M.authorityAccount(name)if not accountName(name)then return nil end return users()[name]end function M.authorityDirectory()local out={}for name,account in pairs(users())do out[name]={role=account.role,disabled=account.disabled==true,revision=tonumber(account.revision)or 0}end return out end function M.authorityMutate(action,fields)fields=type(fields)==\"table\"and fields or{}local name=fields.name assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]if action==\"add\"then assert(not account,\"user exists\")assert(rank[fields.role],\"invalid role\")local record=fields.record assert(type(record)==\"table\"and password.isModern(record),\"central account mutation requires a verifier record\")record.role,record.disabled=fields.role,false;all[name]=stamp(record);assert(save(all),\"could not save user\")elseif action==\"role\"then assert(account and rank[fields.role],\"unknown user or invalid role\")if account.role==\"admin\"and fields.role~=\"admin\"then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot demote the last active admin\")end account.role=fields.role;stamp(account);all[name]=account;assert(save(all),\"could not save role\")elseif action==\"disable\"then if account and account.role==\"admin\"and fields.disabled==true then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot disable the last active admin\")end assert(account,\"unknown user\");account.disabled=fields.disabled==true;stamp(account);all[name]=account;assert(save(all),\"could not save user state\")elseif action==\"remove\"then assert(account,\"unknown user\")if account.role==\"admin\"and not account.disabled then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot remove the last active admin\")end all[name]=nil;local removed=tombstones();removed[name]=now();assert(saveTombstones(removed),\"could not save tombstone\");assert(save(all),\"could not remove user\")elseif action==\"reset\"then assert(account,\"unknown user\")local replacement=fields.record assert(type(replacement)==\"table\"and password.isModern(replacement),\"central password reset requires a verifier record\")replacement.role,replacement.disabled=account.role,account.disabled==true;all[name]=stamp(replacement);assert(save(all),\"could not save password\")else error(\"unsupported account mutation\")end safeAudit(\"authority.\"..action,{account=name})return M.authorityDirectory()end M.refreshSession()return M",
  ["ceetos/lib/password.lua"] = "local M={}M.SCHEME=\"pbkdf2-hmac-sha256\"M.PASSWORD_VERSION=2 M.DEFAULT_WORK_FACTOR=256 M.MIN_WORK_FACTOR=64 M.MAX_WORK_FACTOR=2048 M.MIN_LENGTH=8 M.MAX_LENGTH=128 local MOD=4294967296 local band,bor,bxor,bnot=bit32.band,bit32.bor,bit32.bxor,bit32.bnot local rshift,lshift=bit32.rshift,bit32.lshift local unpack=table.unpack or unpack local K={0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,}local initial={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19,}local function add(...)local value=0 for i=1,select(\"#\",...)do value=(value+(select(i,...)or 0))%MOD end return value end local function rrotate(value,amount)if bit32.rrotate then return bit32.rrotate(value,amount)end return bor(rshift(value,amount),lshift(value,32-amount))end local function word(bytes,index)return bytes:byte(index)*16777216+bytes:byte(index+1)*65536+bytes:byte(index+2)*256+bytes:byte(index+3)end local function packWord(value)return string.char(band(rshift(value,24),0xff),band(rshift(value,16),0xff),band(rshift(value,8),0xff),band(value,0xff))end local function sha256Raw(value)local bitLength=#value*8 value=value..string.char(0x80)value=value..string.rep(\"\\0\",(56-(#value%64))%64)value=value..packWord(math.floor(bitLength/MOD))..packWord(bitLength%MOD)local h={unpack(initial)}for offset=1,#value,64 do if#value>16384 and offset>1 and((offset-1)/64)%128==0 and type(sleep)==\"function\"then sleep(0)end local w={}for i=1,16 do w[i]=word(value,offset+(i-1)*4)end for i=17,64 do local x,y=w[i-15],w[i-2]local s0=bxor(rrotate(x,7),rrotate(x,18),rshift(x,3))local s1=bxor(rrotate(y,17),rrotate(y,19),rshift(y,10))w[i]=add(w[i-16],s0,w[i-7],s1)end local a,b,c,d,e,f,g,hh=unpack(h)for i=1,64 do local s1=bxor(rrotate(e,6),rrotate(e,11),rrotate(e,25))local choice=bxor(band(e,f),band(bnot(e),g))local t1=add(hh,s1,choice,K[i],w[i])local s0=bxor(rrotate(a,2),rrotate(a,13),rrotate(a,22))local majority=bxor(band(a,b),band(a,c),band(b,c))local t2=add(s0,majority)hh,g,f,e,d,c,b,a=g,f,e,add(d,t1),c,b,a,add(t1,t2)end h[1],h[2],h[3],h[4]=add(h[1],a),add(h[2],b),add(h[3],c),add(h[4],d)h[5],h[6],h[7],h[8]=add(h[5],e),add(h[6],f),add(h[7],g),add(h[8],hh)end local result={}for i=1,8 do result[i]=packWord(h[i])end return table.concat(result)end local function hmac(key,message)if#key>64 then key=sha256Raw(key)end key=key..string.rep(\"\\0\",64-#key)local inner,outer={},{}for i=1,64 do local byte=key:byte(i)inner[i],outer[i]=string.char(bxor(byte,0x36)),string.char(bxor(byte,0x5c))end return sha256Raw(table.concat(outer)..sha256Raw(table.concat(inner)..message))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function cooperate(round)if round%32~=0 or not(os and os.queueEvent and os.pullEvent)then return end os.queueEvent(\"ceetos_password_yield\")os.pullEvent(\"ceetos_password_yield\")end local function toHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function constantEqual(left,right)if type(left)~=\"string\"or type(right)~=\"string\"then return false end local differing=bxor(#left,#right)local length=math.max(#left,#right)for i=1,length do differing=bor(differing,bxor(left:byte(i)or 0,right:byte(i)or 0))end return differing==0 end function M.hmacSha256(key,message)if type(key)~=\"string\"or type(message)~=\"string\"then return nil,\"HMAC key and message must be strings\"end return toHex(hmac(key,message))end function M.sha256(value)if type(value)~=\"string\"then return nil,\"SHA-256 input must be a string\"end return toHex(sha256Raw(value))end function M.constantTimeEqual(left,right)return constantEqual(left,right)end function M.legacyDigest(value)local h=2166136261 for i=1,#value do h=bxor(h,value:byte(i))h=(h*16777619)%MOD end return string.format(\"%08x\",h)end function M.normaliseWorkFactor(value)value=tonumber(value)if not value or value%1~=0 then return nil,\"invalid password work factor\"end if value<M.MIN_WORK_FACTOR or value>M.MAX_WORK_FACTOR then return nil,\"password work factor must be \"..M.MIN_WORK_FACTOR..\"-\"..M.MAX_WORK_FACTOR end return value end function M.policy(password)if type(password)~=\"string\"then return false,\"password is required\"end if#password<M.MIN_LENGTH or#password>M.MAX_LENGTH then return false,\"password must contain \"..M.MIN_LENGTH..\"-\"..M.MAX_LENGTH..\" characters\"end if password:find(\"[%z\\1-\\31\\127]\")then return false,\"password contains control characters\"end return true end function M.derive(password,salt,workFactor)local work,err=M.normaliseWorkFactor(workFactor)if not work then return nil,err end if type(password)~=\"string\"or type(salt)~=\"string\"or#salt<16 or#salt>256 then return nil,\"invalid password record\"end local block=string.char(0,0,0,1)local value=hmac(password,salt..block)local result=value for _=2,work do value=hmac(password,value)result=xorBytes(result,value)cooperate(_)end return toHex(result)end local saltCounter=0 function M.newSalt(context)saltCounter=saltCounter+1 local now=os.epoch and os.epoch(\"utc\")or 0 local computer=os.getComputerID and os.getComputerID()or 0 local label=os.getComputerLabel and os.getComputerLabel()or\"\"local random=math.random and math.random(0,2147483647)or 0 return toHex(sha256Raw(table.concat({tostring(now),tostring(computer),tostring(label),tostring(context or\"\"),tostring(saltCounter),tostring(random)},\":\"))):sub(1,32)end function M.record(password,salt,workFactor)local valid,err=M.policy(password)if not valid then return nil,err end local work,workErr=M.normaliseWorkFactor(workFactor or M.DEFAULT_WORK_FACTOR)if not work then return nil,workErr end salt=salt or M.newSalt()local verifier,deriveErr=M.derive(password,salt,work)if not verifier then return nil,deriveErr end return{passwordVersion=M.PASSWORD_VERSION,scheme=M.SCHEME,salt=salt,verifier=verifier,workFactor=work,}end function M.isModern(record)return type(record)==\"table\"and record.passwordVersion==M.PASSWORD_VERSION and record.scheme==M.SCHEME end function M.verify(record,password)if type(record)~=\"table\"or type(password)~=\"string\"or type(record.salt)~=\"string\"or type(record.verifier)~=\"string\"then return false,\"invalid password record\"end if M.isModern(record)then local verifier,err=M.derive(password,record.salt,record.workFactor)if not verifier then return false,err end return constantEqual(record.verifier,verifier),nil end return constantEqual(record.verifier,M.legacyDigest(record.salt..password)),\"legacy\"end return M",
  ["ceetos/lib/release_keys.lua"] = "return{algorithm=\"lamport-sha256-v1\",roots={[\"router-server-release-0.16.9\"]={public=\"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\",profile=\"router-server\"},[\"router-server-release-0.17.0\"]={public=\"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\",profile=\"router-server\"},},}",
  ["ceetos/lib/release_verify.lua"] = "local password=require(\"ceetos.lib.password\")local roots=require(\"ceetos.lib.release_keys\")local profile=require(\"ceetos.lib.profile\")local M={}M.CACHE_ROOT=\"/ceetos-updates\"M.CACHE_FILE=\"/ceetos-updates/release.lua\"M.META_FILE=\"/ceetos-updates/cache.lua\"M.PART_FILE=\"/ceetos-updates/release.part\"M.PENDING_FILE=\"/ceetos-updates/pending.lua\"M.MAX_PACKAGE_BYTES=1024*1024 M.MAX_MANIFEST_BYTES=48*1024 M.CHUNK_BYTES=3072 M.KEY_PARTS=256 local alphabet=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"local decodeMap={}for i=1,#alphabet do decodeMap[alphabet:sub(i,i)]=i-1 end local function read(path)if not fs.exists(path)or fs.isDir(path)then return nil end local handle=fs.open(path,\"r\")if not handle then return nil end local value=handle.readAll();handle.close()return value end local function write(path,value)local parent=fs.getDir(path)if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary=path..\".tmp\"if fs.exists(temporary)then fs.delete(temporary)end local handle=assert(fs.open(temporary,\"w\"),\"could not create temporary release state\")handle.write(value);handle.close()if fs.exists(path)then fs.delete(path)end fs.move(temporary,path)end local function encode(value)local out,index={},1 while index<=#value do local a,b,c=value:byte(index,index+2)local n=(a or 0)*65536+(b or 0)*256+(c or 0)out[#out+1]=alphabet:sub(math.floor(n/262144)%64+1,math.floor(n/262144)%64+1)out[#out+1]=alphabet:sub(math.floor(n/4096)%64+1,math.floor(n/4096)%64+1)out[#out+1]=b and alphabet:sub(math.floor(n/64)%64+1,math.floor(n/64)%64+1)or\"=\"out[#out+1]=c and alphabet:sub(n%64+1,n%64+1)or\"=\"index=index+3 end return table.concat(out)end local function decode(value)if type(value)~=\"string\"or#value%4~=0 or#value>M.MAX_MANIFEST_BYTES*2 then return nil,\"invalid base64\"end local out={}for index=1,#value,4 do local a,b,c,d=value:sub(index,index),value:sub(index+1,index+1),value:sub(index+2,index+2),value:sub(index+3,index+3)if not decodeMap[a]or not decodeMap[b]or(c~=\"=\"and not decodeMap[c])or(d~=\"=\"and not decodeMap[d])then return nil,\"invalid base64\"end if(c==\"=\"and d~=\"=\")or((c==\"=\"or d==\"=\")and index+3~=#value)then return nil,\"invalid base64 padding\"end local n=decodeMap[a]*262144+decodeMap[b]*4096+(decodeMap[c]or 0)*64+(decodeMap[d]or 0)out[#out+1]=string.char(math.floor(n/65536)%256)if c~=\"=\"then out[#out+1]=string.char(math.floor(n/256)%256)end if d~=\"=\"then out[#out+1]=string.char(n%256)end end return table.concat(out)end local function unhex(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function semver(value)if type(value)~=\"string\"then return nil end local major,minor,patch=value:match(\"^(%d+)%.(%d+)%.(%d+)$\")if not major then return nil end return tonumber(major),tonumber(minor),tonumber(patch)end function M.compareVersions(left,right)local a,b,c=semver(left);local x,y,z=semver(right)if not a or not x then return nil,\"invalid semantic version\"end if a~=x then return a<x and-1 or 1 end if b~=y then return b<y and-1 or 1 end if c~=z then return c<z and-1 or 1 end return 0 end local function canonical(manifest)if manifest._legacyProfile==true then return table.concat({\"ceetos-release-v1\",tostring(manifest.channel),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end return table.concat({\"ceetos-release-v2\",tostring(manifest.channel),tostring(manifest.profile),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end local function unpackKey(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*2*32 then return nil,err or\"invalid public key\"end local parts={}for index=1,M.KEY_PARTS*2 do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end function M.validPublicKey(value)return unpackKey(value)end local function lookupKey(keyId)local saved=M.trustedKeys()local value=saved[keyId]if value then return unpackKey(value)end value=roots.roots and roots.roots[keyId]if type(value)==\"table\"and type(value.public)==\"string\"then value=value.public end return unpackKey(value)end local function bitAt(digest,index)local byte=digest:byte(math.floor((index-1)/8)+1)return bit32.band(bit32.rshift(byte,7-((index-1)%8)),1)end local function decodeSignature(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*32 then return nil,err or\"invalid signature\"end local parts={}for index=1,M.KEY_PARTS do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end local function verifySignature(manifest,signature)if roots.algorithm~=\"lamport-sha256-v1\"then return false,\"unsupported release signing algorithm\"end local public,publicErr=lookupKey(manifest.key_id)local parts,signatureErr=decodeSignature(signature)if not public or not parts then local prefix=not public and\"invalid release public key: \"or\"invalid release signature: \"return false,prefix..tostring(publicErr or signatureErr or\"unknown release key\")end local digest=unhex(password.sha256(canonical(manifest))or\"\")if not digest then return false,\"could not hash release manifest\"end for index=1,M.KEY_PARTS do local expected=public[(index-1)*2+bitAt(digest,index)+1]local candidate=unhex(password.sha256(parts[index])or\"\")if not candidate or not password.constantTimeEqual(candidate,expected)then return false,\"invalid release signature\"end end return true end local function validateManifest(manifest)if type(manifest)~=\"table\"or manifest.channel~=\"release\"then return nil,\"only signed release packages are accepted\"end if manifest.profile==nil then manifest.profile,manifest._legacyProfile=\"desktop\",true end if type(manifest.profile)~=\"string\"or not profile.IDS[manifest.profile]then return nil,\"invalid release profile\"end if not semver(manifest.version)or type(manifest.size)~=\"number\"or manifest.size<1 or manifest.size>M.MAX_PACKAGE_BYTES then return nil,\"invalid release manifest size or version\"end if type(manifest.digest)~=\"string\"or#manifest.digest~=64 or manifest.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if type(manifest.key_id)~=\"string\"or#manifest.key_id<1 or#manifest.key_id>64 then return nil,\"invalid release key id\"end if type(manifest.next_key_id)~=\"string\"or#manifest.next_key_id<1 or#manifest.next_key_id>64 then return nil,\"invalid next release key id\"end local nextKey=unpackKey(manifest.next_public)if not nextKey then return nil,\"invalid successor release key\"end return manifest end function M.parse(source)if type(source)~=\"string\"or#source>M.MAX_PACKAGE_BYTES then return nil,\"release package is too large\"end local encodedManifest,encodedSignature=source:match(\"^%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")if not encodedManifest then encodedManifest,encodedSignature=source:match(\"^%-%- CeetOS signed release%. Generated; do not edit%.[\\r\\n]+%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")end local first=source:find(\"%-%- CEETOS_RELEASE_PAYLOAD_BEGIN[\\r\\n]+\")if not encodedManifest or not encodedSignature or not first then return nil,\"not a signed CeetOS release package\"end local decoded,decodeErr=decode(encodedManifest)if not decoded then return nil,\"invalid release manifest encoding: \"..tostring(decodeErr)end local loader=load(\"return \"..decoded,\"=release-manifest\",\"t\",{})if not loader then return nil,\"invalid release manifest\"end local ok,manifest=pcall(loader)if not ok then return nil,\"invalid release manifest\"end local valid,manifestErr=validateManifest(manifest)if not valid then return nil,manifestErr end local start=source:find(\"\\n\",first)+1 local finish=start+valid.size-1 local payload=source:sub(start,finish)local suffix=source:sub(finish+1)if suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\\n\"and suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\\r\\n\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\"then return nil,\"release payload boundary mismatch\"end if#payload~=valid.size or not password.constantTimeEqual(password.sha256(payload)or\"\",valid.digest)then return nil,\"release payload digest mismatch\"end local signed,signatureErr=verifySignature(valid,encodedSignature)if not signed then return nil,signatureErr end return{manifest=valid,signature=encodedSignature,payload=payload,source=source}end function M.trustedKeys()local raw=read(M.CACHE_ROOT..\"/trusted-keys.lua\")if not raw then return{}end local loader=load(raw,\"=trusted-release-keys\",\"t\",{})if not loader then return{}end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or{}end local function saveKeys(value)local encoded=textutils.serialise(value,{compact=true})write(M.CACHE_ROOT..\"/trusted-keys.lua\",\"return \"..encoded)end function M.metadata()local raw=read(M.META_FILE)if not raw then return nil end local loader=load(raw,\"=release-cache\",\"t\",{})if not loader then return nil end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or nil end function M.cache(source,provider)local package,err=M.parse(source)if not package then return nil,err end if fs.exists(M.CACHE_ROOT)and fs.isDir(M.CACHE_ROOT)then if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end elseif not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end write(M.CACHE_FILE,package.source)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))local keys=M.trustedKeys();keys[package.manifest.next_key_id]=package.manifest.next_public;saveKeys(keys)return metadata end function M.promotePart(path,provider)if type(path)~=\"string\"or path~=M.PART_FILE then return nil,\"invalid release staging path\"end local source=read(path)local package,err=M.parse(source)if not package then return nil,err end if not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end fs.move(M.PART_FILE,M.CACHE_FILE)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))M.adopt(package)return metadata end function M.adopt(package)if type(package)~=\"table\"or type(package.manifest)~=\"table\"then return false,\"invalid verified package\"end local keys=M.trustedKeys()keys[package.manifest.next_key_id]=package.manifest.next_public saveKeys(keys)return true end function M.cachedPackage()local source,metadata=read(M.CACHE_FILE),M.metadata()if not source then return nil end local package,err=M.parse(source)if not package then return nil,err end if not metadata then metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=\"local installer\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))end M.adopt(package)return package,metadata end function M.clear()if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end if fs.exists(M.META_FILE)then fs.delete(M.META_FILE)end return true end function M.encode(value)return encode(value)end function M.decode(value)return decode(value)end function M.canonical(manifest)return canonical(manifest)end return M",
  ["ceetos/lib/updater.lua"] = "local store=require(\"ceetos.lib.store\")local release=require(\"ceetos.lib.release_verify\")local version=require(\"ceetos.lib.version\")local net=require(\"ceetos.lib.net\")local profile=require(\"ceetos.lib.profile\")local M={}local STATE_PATH=\"/ceetos/data/update-status.lua\"local OFFER_LIMIT,HISTORY_LIMIT=20,16 local BEACON_INTERVAL,REQUEST_TIMEOUT,REQUEST_LIMIT=30000,3500,3 local MAX_OFFER_AGE=5*60*1000 local CLOUD_RELEASE_ORIGIN=\"https://releases.ceet.uk\"local CLOUD_MANIFEST_URL=CLOUD_RELEASE_ORIGIN..\"/manifest.json\"local CLOUD_SOURCE_ID=\"cloud.releases.ceet.uk\"local state=nil local lastBeacon,lastCacheRead=0,0 local cached=nil local function now()return os.epoch(\"utc\")end local function localId()return tostring(os.getComputerID())end local function localLabel()return os.getComputerLabel()or(\"Computer \"..localId())end local function defaults()return{schema=1,offers={},history={},revision=0,status=\"idle\",message=nil,transfer=nil,cache=nil}end local function loadState()if state then return state end state=store.read(STATE_PATH,defaults())for key,value in pairs(defaults())do if state[key]==nil then state[key]=value end end state.offers=type(state.offers)==\"table\"and state.offers or{}state.history=type(state.history)==\"table\"and state.history or{}return state end local function save()local value=loadState()value.revision=(tonumber(value.revision)or 0)+1 store.write(STATE_PATH,value)end local function record(kind,fields)local value=loadState()local row={at=now(),kind=tostring(kind):sub(1,48)}for key,item in pairs(fields or{})do if key~=\"data\"and key~=\"source\"and key~=\"signature\"then row[key]=item end end value.history[#value.history+1]=row while#value.history>HISTORY_LIMIT do table.remove(value.history,1)end end local function setStatus(status,message)local value=loadState()value.status,value.message=status,message and tostring(message):sub(1,180)or nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=96 end local function releaseFilename(profileId,releaseVersion)if profileId==\"desktop\"then return\"desktop/ceetos-release\"..releaseVersion..\".lua\"end return profileId..\"/ceetos-\"..profileId..\"-release\"..releaseVersion..\".lua\"end local function readHttp(url,limit)if not http or type(http.get)~=\"function\"then return nil,\"HTTP is unavailable; enable it to check releases.ceet.uk\"end local ok,response,requestErr=pcall(http.get,url,{[\"Accept\"]=\"application/json\"})if not ok or not response then return nil,tostring(requestErr or\"release server request failed\")end local chunks,total={},0 while true do local part=response.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then pcall(response.close);return nil,\"release server response is too large\"end chunks[#chunks+1]=part end pcall(response.close)return table.concat(chunks)end local function validOffer(body)if type(body)~=\"table\"or type(body.version)~=\"string\"or type(body.size)~=\"number\"or type(body.digest)~=\"string\"or type(body.keyId)~=\"string\"or type(body.profile)~=\"string\"then return nil,\"malformed release offer\"end if body.profile~=profile.id()then return nil,\"release profile does not match this installation\"end local compare=release.compareVersions(body.version,version.string)if compare==nil then return nil,\"invalid release version\"end if body.size<1 or body.size>release.MAX_PACKAGE_BYTES then return nil,\"invalid release size\"end if#body.digest~=64 or body.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if#body.keyId<1 or#body.keyId>64 then return nil,\"invalid release key ID\"end local filename=body.filename if filename~=nil and filename~=releaseFilename(body.profile,body.version)then return nil,\"invalid release filename\"end return{profile=body.profile,version=body.version,size=math.floor(body.size),digest=body.digest:lower(),keyId=body.keyId,filename=filename,fingerprint=body.digest:sub(1,16),newer=compare>0}end local function refreshCached()local timestamp=now()if cached and timestamp-lastCacheRead<5000 then return cached end lastCacheRead=timestamp local value=loadState()local previous=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil local package,metadata=release.cachedPackage()if package and package.manifest.profile==profile.id()then cached={package=package,metadata=metadata,offer={version=package.manifest.version,size=#package.source,digest=package.manifest.digest,profile=package.manifest.profile,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),}}value.cache={profile=package.manifest.profile,version=package.manifest.version,size=#package.source,digest=package.manifest.digest,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),source=metadata and metadata.source or\"local\",verifiedAt=timestamp}else cached=nil value.cache=nil end local current=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil if current~=previous then save()end return cached end local function providerOffer()local available=refreshCached()if not available then return nil end return{version=available.offer.version,size=available.offer.size,digest=available.offer.digest,profile=available.offer.profile,keyId=available.offer.keyId,label=localLabel(),id=localId(),}end local function upsertOffer(source,body,transport,distance)source=tostring(source)if source==localId()then return false,\"ignored own release offer\"end local offer,err=validOffer(body)if not offer then return false,err end if not offer.newer then return false,\"offered release is not newer\"end local value=loadState()local key=source..\":\"..offer.version..\":\"..offer.digest:sub(1,16)value.offers[key]={id=source,label=tostring(body.label or(\"Computer \"..source)):sub(1,96),version=offer.version,profile=offer.profile,size=offer.size,digest=offer.digest,fingerprint=offer.fingerprint,keyId=offer.keyId,filename=offer.filename,transport=transport,distance=tonumber(distance),seen=now(),key=key,}local rows={}for entryKey,item in pairs(value.offers)do rows[#rows+1]={key=entryKey,seen=tonumber(item.seen)or 0}end table.sort(rows,function(a,b)return a.seen>b.seen end)while#rows>OFFER_LIMIT do value.offers[table.remove(rows).key]=nil end setStatus(\"offers\",\"Signed release \"..offer.version..\" available from \"..tostring(body.label or source))record(\"offer\",{id=source,version=offer.version,transport=transport,distance=distance})save()return true end local function checkCloudManifest()local raw,readErr=readHttp(CLOUD_MANIFEST_URL,release.MAX_MANIFEST_BYTES)if not raw then return 0,readErr end local ok,catalogue=pcall(textutils.unserialiseJSON,raw)if not ok or type(catalogue)~=\"table\"or catalogue.schema~=1 or type(catalogue.releases)~=\"table\"or#catalogue.releases>OFFER_LIMIT then return 0,\"invalid signed-release catalogue\"end local count=0 for index=1,#catalogue.releases do local entry=catalogue.releases[index]if type(entry)==\"table\"and entry.profile==profile.id()then local accepted=upsertOffer(CLOUD_SOURCE_ID,entry,\"cloud\")if accepted then count=count+1 end end end return count end local function offers()local value,timestamp,rows=loadState(),now(),{}for key,item in pairs(value.offers)do if type(item)==\"table\"and timestamp-(tonumber(item.seen)or 0)<=MAX_OFFER_AGE then rows[#rows+1]=item else value.offers[key]=nil end end table.sort(rows,function(left,right)local compare=release.compareVersions(left.version,right.version)or 0 if compare~=0 then return compare>0 end return tostring(left.id)<tostring(right.id)end)return rows end local function findOffer(source)source=tostring(source)for _,item in ipairs(offers())do if item.key==source or tostring(item.id)==source then return item end end return nil,\"release source is unavailable; run update check first\"end local function removePart()if fs.exists(release.PART_FILE)then fs.delete(release.PART_FILE)end end local function appendPart(data)local handle,err=fs.open(release.PART_FILE,\"a\")if not handle then return false,err or\"could not open update staging file\"end handle.write(data);handle.close()return true end local function cachedSource()local available=refreshCached()return available and available.package and available.package.source end local function transferRequest(transfer)local length=math.min(release.CHUNK_BYTES,transfer.size-transfer.offset+1)if length<1 then return false,\"transfer is already complete\"end transfer.awaiting,transfer.requestedAt=true,now()local body={transfer=transfer.id,offset=transfer.offset,length=length}local sent,err if transfer.transport==\"routed\"then sent,err=net.request(transfer.source,\"update_chunk_request\",body,{safe=true})else sent,err=net.publicSend(transfer.source,\"update_chunk_request\",body)end if not sent then transfer.awaiting=false;return false,err end return true end local function beginDownload(source)local offer,err=findOffer(source)if not offer then return false,err end local compare=release.compareVersions(offer.version,version.string)if not compare or compare<=0 then return false,\"refusing a downgrade or current release\"end local free=fs.getFreeSpace and fs.getFreeSpace(\"/\")or nil if type(free)==\"number\"and free<offer.size+4096 then return false,\"not enough free space for one verified release cache\"end removePart()release.clear();cached=nil local value=loadState()if offer.transport==\"cloud\"then setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from releases.ceet.uk\")save()local sourceText,readErr=readHttp(CLOUD_RELEASE_ORIGIN..\"/\"..tostring(offer.filename or\"\"),release.MAX_PACKAGE_BYTES)if not sourceText then setStatus(\"error\",readErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=readErr});save();return false,readErr end local parsed,parseErr=release.parse(sourceText)if not parsed or parsed.manifest.profile~=offer.profile or parsed.manifest.version~=offer.version or parsed.manifest.digest:lower()~=offer.digest or parsed.manifest.key_id~=offer.keyId then local reason=parseErr or\"verified package did not match selected release offer\"setStatus(\"error\",reason);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=reason});save();return false,reason end local metadata,cacheErr=release.cache(sourceText,\"releases.ceet.uk\")if not metadata then setStatus(\"error\",cacheErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=cacheErr});save();return false,cacheErr end cached=nil;refreshCached()setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=CLOUD_SOURCE_ID,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end value.transfer={id=\"update-\"..localId()..\"-\"..tostring(now())..\"-\"..tostring(math.random(1000,9999)),source=tostring(offer.id),label=offer.label,transport=offer.transport==\"routed\"and\"routed\"or\"direct\",profile=offer.profile,version=offer.version,size=offer.size,digest=offer.digest,keyId=offer.keyId,offset=1,received=0,retries=0,awaiting=false,started=now(),}setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from \"..offer.label)record(\"download_started\",{id=offer.id,version=offer.version,transport=value.transfer.transport})local sent,sendErr=transferRequest(value.transfer)if not sent then value.transfer=nil;setStatus(\"error\",sendErr);record(\"download_failed\",{id=offer.id,error=sendErr})end save()return sent,sendErr end local function finishTransfer(transfer)local handle=fs.open(release.PART_FILE,\"r\")local source=handle and handle.readAll()or nil if handle then handle.close()end if not source or#source~=transfer.size then return false,\"download size did not match offer\"end local parsed,parseErr=release.parse(source)if not parsed then return false,parseErr end if parsed.manifest.profile~=profile.id()or parsed.manifest.profile~=transfer.profile or parsed.manifest.version~=transfer.version or parsed.manifest.digest:lower()~=transfer.digest:lower()or parsed.manifest.key_id~=transfer.keyId then return false,\"verified package did not match selected release offer\"end local metadata,promoteErr=release.promotePart(release.PART_FILE,transfer.label)if not metadata then return false,promoteErr end cached=nil;refreshCached()local value=loadState();value.transfer=nil setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=transfer.source,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end local function acceptChunk(source,body,transport)local value,transfer=loadState(),loadState().transfer if not transfer or transfer.transport~=transport or tostring(source)~=tostring(transfer.source)then return false,\"unexpected update chunk\"end if type(body)~=\"table\"or body.transfer~=transfer.id or math.floor(tonumber(body.offset)or 0)~=transfer.offset or type(body.data)~=\"string\"then return false,\"malformed update chunk\"end local remaining=transfer.size-transfer.offset+1 if#body.data<1 or#body.data>math.min(release.CHUNK_BYTES,remaining)then return false,\"invalid update chunk length\"end local ok,err=appendPart(body.data)if not ok then transfer.awaiting=false;setStatus(\"error\",err);record(\"download_failed\",{error=err});save();return false,err end transfer.offset,transfer.received,transfer.awaiting,transfer.retries=transfer.offset+#body.data,(transfer.received or 0)+#body.data,false,0 if transfer.offset>transfer.size then local complete,result=finishTransfer(transfer)if not complete then removePart();value.transfer=nil;setStatus(\"error\",result);record(\"download_failed\",{id=source,error=result});save()end return complete,result end local sent,sendErr=transferRequest(transfer)if not sent then setStatus(\"error\",sendErr);record(\"download_failed\",{id=source,error=sendErr});value.transfer=nil;removePart()end save()return sent,sendErr end local function serveChunk(target,body,routed,request)if type(body)~=\"table\"or not validId(body.transfer)or math.floor(tonumber(body.offset)or 0)<1 or math.floor(tonumber(body.length)or 0)<1 or tonumber(body.length)>release.CHUNK_BYTES then return false,\"invalid update chunk request\"end local source=cachedSource()if not source then return false,\"no verified newer signed release is cached\"end local offset,length=math.floor(body.offset),math.floor(body.length)if offset>#source then return false,\"requested update offset is beyond package\"end local data=source:sub(offset,math.min(#source,offset+length-1))local response={transfer=body.transfer,offset=offset,data=data}if routed then return net.reply(request,\"update_chunk\",response,{safe=true})end return net.publicSend(target,\"update_chunk\",response)end function M.publicPacket(packet,distance)local source,body=tostring(packet.from),packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then net.publicSend(source,\"update_offer\",offer)end return elseif packet.type==\"update_offer\"then return upsertOffer(source,body,\"direct\",distance)elseif packet.type==\"update_chunk_request\"then return serveChunk(source,body,false)elseif packet.type==\"update_chunk\"then return acceptChunk(source,body,\"direct\")end end function M.authenticatedPacket(from,peer,packet)local body=packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then return net.reply(packet,\"update_offer\",offer,{safe=true})end elseif packet.type==\"update_offer\"then return upsertOffer(from,body,\"routed\")elseif packet.type==\"update_chunk_request\"then return serveChunk(from,body,true,packet)elseif packet.type==\"update_chunk\"then return acceptChunk(from,body,\"routed\")end end function M.check()local value=loadState()for key in pairs(value.offers)do value.offers[key]=nil end setStatus(\"checking\",\"Looking for newer signed releases\")local cloudOffers,cloudErr=checkCloudManifest()local sent,err=net.publicBroadcast(\"update_query\",{version=version.string,profile=profile.id()})local routed=0 for _,peer in ipairs(net.peers())do if not peer.rekeyRequired then local ok=net.request(peer.id,\"update_query\",{version=version.string,profile=profile.id()},{safe=true})if ok then routed=routed+1 end end end if cloudErr then setStatus(\"warning\",\"Cloud release check failed: \"..tostring(cloudErr):sub(1,120))elseif cloudOffers==0 and not(sent or routed>0)then setStatus(\"idle\",\"No newer signed release is available\")elseif cloudOffers>0 then setStatus(\"offers\",tostring(cloudOffers)..\" signed cloud release offer\"..(cloudOffers==1 and\"\"or\"s\")..\" available\")end record(\"check\",{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr,error=sent and nil or err})save()if cloudErr and not sent and routed==0 then return false,cloudErr end return true,{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr}end function M.download(source)return beginDownload(source)end function M.installLatest()local checked,err=M.check()if not checked then return false,err end local rows=offers()if#rows==0 then return false,\"no newer compatible signed release is available\"end table.sort(rows,function(a,b)local comparison=release.compareVersions(a.version,b.version)or 0 return comparison==0 and tostring(a.id)<tostring(b.id)or comparison>0 end)return beginDownload(rows[1].id)end function M.cancel()local value=loadState()if not value.transfer then return false,\"no update transfer is active\"end record(\"download_cancelled\",{id=value.transfer.source,version=value.transfer.version})value.transfer=nil;removePart();setStatus(\"cancelled\",\"Update download cancelled\");save()return true end function M.clearCache()local value=loadState()if value.transfer then return false,\"cancel the active download first\"end release.clear();cached=nil;value.cache=nil;setStatus(\"idle\",\"Verified release cache cleared\");record(\"cache_cleared\");save()return true end function M.prepareApply()local package,metadata=release.cachedPackage()if not package then return false,metadata or\"no verified signed release is cached\"end local compare=release.compareVersions(package.manifest.version,version.string)if not compare or compare<=0 then return false,\"cached release is not newer than this CeetOS installation\"end if package.manifest.profile~=profile.id()then return false,\"cached release profile does not match this installation\"end local marker={schema=2,state=\"apply\",profile=package.manifest.profile,version=package.manifest.version,digest=package.manifest.digest,keyId=package.manifest.key_id,approvedAt=now()}store.write(release.PENDING_FILE,marker)local value=loadState();setStatus(\"applying\",\"Applying verified release \"..package.manifest.version..\" after reboot\");record(\"apply_approved\",{version=package.manifest.version,digest=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id});save()return true,{version=package.manifest.version,fingerprint=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id}end function M.recover()local marker=store.read(release.PENDING_FILE,nil)if type(marker)~=\"table\"or marker.state~=\"verify\"then return end local value=loadState()if marker.version==version.string and(marker.profile==nil or marker.profile==profile.id())then if fs.exists(release.PENDING_FILE)then fs.delete(release.PENDING_FILE)end setStatus(\"applied\",\"Verified release \"..version.string..\" is now active\")record(\"apply_verified\",{version=version.string})else setStatus(\"error\",\"Update installed but running version did not match \"..tostring(marker.version))record(\"apply_version_mismatch\",{expected=marker.version,actual=version.string})end save()end function M.tick()local value,timestamp=loadState(),now()local offer=providerOffer()if offer and timestamp-lastBeacon>=BEACON_INTERVAL then net.publicBroadcast(\"update_offer\",offer)lastBeacon=timestamp end local transfer=value.transfer if transfer and transfer.awaiting and timestamp-(transfer.requestedAt or timestamp)>=REQUEST_TIMEOUT then transfer.awaiting,transfer.retries=false,(transfer.retries or 0)+1 if transfer.retries>REQUEST_LIMIT then record(\"download_timeout\",{id=transfer.source,version=transfer.version})value.transfer=nil;removePart();setStatus(\"error\",\"Update source timed out\");save()else local sent,err=transferRequest(transfer)if not sent then value.transfer=nil;removePart();setStatus(\"error\",err);record(\"download_failed\",{id=transfer.source,error=err});save()end end end end function M.status()local value=loadState()return{profile=profile.id(),version=version.string,status=value.status,message=value.message,revision=value.revision,offers=offers(),transfer=value.transfer,cache=value.cache,history=value.history,cacheRoot=release.CACHE_ROOT,maxPackageBytes=release.MAX_PACKAGE_BYTES,}end return M",
  ["ceetos/lib/release_broker.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local crypto=require(\"ceetos.lib.mesh_crypto\")local cloud=require(\"ceetos.lib.cloud\")local net=require(\"ceetos.lib.net\")local profile=require(\"ceetos.lib.profile\")local M={}local PATH,LIMIT,LIFE=\"/ceetos/data/release-broker.lua\",8,120000 local pending={}local function now()return os.epoch(\"utc\")end local function localId()return tostring(os.getComputerID())end local function localLabel()return os.getComputerLabel()or(\"Computer \"..localId())end local function clean(v,n)return type(v)==\"string\"and#v>0 and#v<=n and not v:find(\"[%z\\1-\\31\\127]\")end local function state()local value=store.read(PATH,{})return{schema=1,enabled=value.enabled==true,promotedAt=tonumber(value.promotedAt)}end local function save(value)return store.write(PATH,value)end local function key(session,target,targetNonce,phrase)return password.hmacSha256(phrase,table.concat({\"ceetos/release-broker/v1\",session,target,localId(),targetNonce},\"|\"))end local function mac(secret,label,value)return password.hmacSha256(secret,label..\"|\"..value)end local function expiry()return now()+LIFE end local function pendingCount()local count=0 for _,row in pairs(pending)do if row.expires>now()then count=count+1 end end return count end function M.status()local value,cloudState=state(),cloud.publicStatus()local rows={}for id,row in pairs(pending)do if row.expires>now()then rows[#rows+1]={id=id,target=row.target,label=row.label,profile=row.profile,expires=row.expires,state=row.state}end end table.sort(rows,function(a,b)return a.expires<b.expires end)return{enabled=value.enabled,enrolled=cloudState.enrolled,pending=rows}end function M.promote(ownerKey)if not clean(ownerKey,256)then return false,\"owner enrollment key is required\"end local result,err=cloud.call(\"auth\",\"/v1/broker/promote\",{ownerKey=ownerKey})if not result then return false,err end save({schema=1,enabled=true,promotedAt=now()})return true,result end function M.revoke(ownerKey)if not clean(ownerKey,256)then return false,\"owner enrollment key is required\"end local result,err=cloud.call(\"auth\",\"/v1/broker/revoke\",{ownerKey=ownerKey})if not result then return false,err end save({schema=1,enabled=false})for id in pairs(pending)do pending[id]=nil end return true,result end function M.handle(packet)local body,source=packet.body or{},tostring(packet.from or\"\")if packet.type==\"broker_query\"then if not state().enabled or not cloud.publicStatus().enrolled then return end if not clean(body.session,96)or not clean(body.nonce,128)or not clean(body.profile,32)or not clean(body.label,96)or body.profile~=profile.id()then return end if pendingCount()>=LIMIT and not pending[body.session]then return end pending[body.session]={session=body.session,target=source,targetNonce=body.nonce,profile=body.profile,label=body.label,expires=expiry(),state=\"waiting\"}return net.publicSend(source,\"broker_offer\",{session=body.session,broker=localId(),label=localLabel(),profile=profile.id(),expires=pending[body.session].expires})elseif packet.type==\"broker_proof\"then local row=pending[body.session]if not row or row.expires<=now()or row.target~=source or row.state~=\"challenged\"or not clean(body.proof,128)then return end if not password.constantTimeEqual(row.expected,body.proof)then pending[body.session]=nil;return net.publicSend(source,\"broker_reject\",{session=body.session,reason=\"phrase proof rejected\"})end local result,err=cloud.call(\"auth\",\"/v1/broker/enroll\",{session=row.session,targetComputerId=row.target,targetLabel=row.label,targetProfile=row.profile,expires=row.expires})if not result or type(result.node)~=\"table\"then pending[body.session]=nil;return net.publicSend(source,\"broker_reject\",{session=body.session,reason=tostring(err or\"cloud provisioning failed\"):sub(1,96)})end local aad=\"ceetos/release-broker/grant/v1|\"..row.session..\"|\"..row.target..\"|\"..localId()local nonce=crypto.nonce(row.key,1,aad)local envelope=nonce and crypto.seal(row.key,nonce,aad,textutils.serialise({node=result.node,urls=cloud.publicStatus().urls}))pending[body.session]=nil if not envelope then return net.publicSend(source,\"broker_reject\",{session=body.session,reason=\"could not secure enrollment\"})end return net.publicSend(source,\"broker_grant\",{session=body.session,broker=localId(),envelope=envelope})end end function M.approve(session,phrase)local row=pending[tostring(session or\"\")]if not row or row.expires<=now()then return false,\"bootstrap session is unavailable or expired\"end if not clean(phrase,128)then return false,\"invalid bootstrap phrase\"end row.key=key(row.session,row.target,row.targetNonce,phrase)row.brokerNonce=password.newSalt(\"broker:\"..row.session)row.expected=mac(row.key,\"proof\",row.brokerNonce)row.state,row.expires=\"challenged\",expiry()local challenge=mac(row.key,\"challenge\",row.brokerNonce)local sent,err=net.publicSend(row.target,\"broker_challenge\",{session=row.session,broker=localId(),nonce=row.brokerNonce,mac=challenge,expires=row.expires})if not sent then row.state=\"waiting\";return false,err end return true end function M.tick()for id,row in pairs(pending)do if row.expires<=now()then pending[id]=nil end end end return M",
  ["ceetos/lib/broker_bootstrap.lua"] = "local password=require(\"ceetos.lib.password\")local crypto=require(\"ceetos.lib.mesh_crypto\")local M={}local CHANNEL,LIFE=45731,120 local function label()return os.getComputerLabel()or(\"Computer \"..tostring(os.getComputerID()))end local function valid(v,n)return type(v)==\"string\"and#v>0 and#v<=n end local function modem()for _,name in ipairs(peripheral.getNames())do if peripheral.getType(name)==\"modem\"then local wrapped=peripheral.wrap(name)if wrapped and wrapped.isWireless and wrapped.isWireless()then return wrapped end end end end local function random(context)return password.newSalt(context..\":\"..tostring(os.epoch(\"utc\")))end function M.enroll(profile)local link=modem()if not link then return nil,\"No wireless modem is attached; a trusted release broker must be directly reachable.\"end link.open(CHANNEL)local session,target,targetNonce=random(\"session\"),tostring(os.getComputerID()),random(\"target\")local phrase=random(\"phrase\"):sub(1,20)print(\"Trusted broker enrollment required.\")print(\"On an enrolled broker run: nx broker approve \"..session..\" \"..phrase)link.transmit(CHANNEL,CHANNEL,{protocol=\"ceetos/update/1\",type=\"broker_query\",from=target,to=\"0\",body={session=session,nonce=targetNonce,profile=profile,label=label()}})local deadline,broker,linkKey=os.epoch(\"utc\")+LIFE*1000,nil,nil while os.epoch(\"utc\")<deadline do local timer=os.startTimer(2)local event={os.pullEventRaw()}if event[1]==\"timer\"and event[2]==timer then link.transmit(CHANNEL,CHANNEL,{protocol=\"ceetos/update/1\",type=\"broker_query\",from=target,to=\"0\",body={session=session,nonce=targetNonce,profile=profile,label=label()}})elseif event[1]==\"modem_message\"and event[3]==CHANNEL and type(event[5])==\"table\"then local packet,body=event[5],event[5].body or{}if packet.protocol==\"ceetos/update/1\"and tostring(packet.to)==target and body.session==session then if packet.type==\"broker_offer\"then broker=tostring(body.broker)elseif packet.type==\"broker_challenge\"and broker and tostring(body.broker)==broker and valid(body.nonce,128)and valid(body.mac,128)then linkKey=password.hmacSha256(phrase,table.concat({\"ceetos/release-broker/v1\",session,target,broker,targetNonce},\"|\"))if password.constantTimeEqual(password.hmacSha256(linkKey,\"challenge|\"..body.nonce),body.mac)then link.transmit(CHANNEL,CHANNEL,{protocol=\"ceetos/update/1\",type=\"broker_proof\",from=target,to=broker,body={session=session,proof=password.hmacSha256(linkKey,\"proof|\"..body.nonce)}})end elseif packet.type==\"broker_grant\"and linkKey and tostring(body.broker)==broker then local aad=\"ceetos/release-broker/grant/v1|\"..session..\"|\"..target..\"|\"..broker local opened=crypto.open(linkKey,body.envelope,aad)local grant=opened and textutils.unserialise(opened)if type(grant)==\"table\"and type(grant.node)==\"table\"and valid(grant.node.id,96)and valid(grant.node.secret,192)then return grant end elseif packet.type==\"broker_reject\"then return nil,tostring(body.reason or\"broker rejected enrollment\")end end end end return nil,broker and\"Broker did not complete enrollment in time.\"or\"No trusted release broker answered. Installation was not changed.\"end return M",
  ["ceetos/lib/mesh_crypto.lua"] = "local password=require(\"ceetos.lib.password\")local M={}local band,bor,bxor=bit32.band,bit32.bor,bit32.bxor local lshift,rshift=bit32.lshift,bit32.rshift local MOD32,LIMB=4294967296,67108864 local function add32(...)local n=0 for i=1,select(\"#\",...)do n=(n+(select(i,...)or 0))%MOD32 end return n end local function rotl(v,bits)return bor(lshift(v,bits),rshift(v,32-bits))end local function le32(data,index)local a,b,c,d=data:byte(index,index+3)return(a or 0)+(b or 0)*256+(c or 0)*65536+(d or 0)*16777216 end local function put32(value)value=value%MOD32 return string.char(value%256,math.floor(value/256)%256,math.floor(value/65536)%256,math.floor(value/16777216)%256)end local function le64(value)value=math.max(0,math.floor(tonumber(value)or 0))local low,high=value%MOD32,math.floor(value/MOD32)%MOD32 return put32(low)..put32(high)end local function hexToRaw(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function rawToHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function quarter(x,a,b,c,d)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),16)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),12)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),8)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),7)end local function chachaBlock(key,counter,nonce)local state={0x61707865,0x3320646e,0x79622d32,0x6b206574}for i=1,8 do state[4+i]=le32(key,(i-1)*4+1)end state[13],state[14],state[15],state[16]=counter%MOD32,le32(nonce,1),le32(nonce,5),le32(nonce,9)local x={}for i=1,16 do x[i]=state[i]end for _=1,10 do quarter(x,1,5,9,13);quarter(x,2,6,10,14);quarter(x,3,7,11,15);quarter(x,4,8,12,16)quarter(x,1,6,11,16);quarter(x,2,7,12,13);quarter(x,3,8,9,14);quarter(x,4,5,10,15)end local out={}for i=1,16 do out[i]=put32(add32(x[i],state[i]))end return table.concat(out)end local function chachaXor(key,nonce,counter,plaintext)local out,position={},1 while position<=#plaintext do local block=chachaBlock(key,counter,nonce)local part=plaintext:sub(position,position+63)out[#out+1]=xorBytes(part,block:sub(1,#part))position,counter=position+#part,(counter+1)%MOD32 end return table.concat(out)end local function poly1305(message,key)local function zero(length)local out={};for i=1,length do out[i]=0 end;return out end local function normalise(value)local carry=0 for i=1,#value do local n=(value[i]or 0)+carry value[i],carry=n%256,math.floor(n/256)end while carry>0 do value[#value+1],carry=carry%256,math.floor(carry/256)end return value end local function add(left,right)local out=zero(math.max(#left,#right)+1)for i=1,#left do out[i]=out[i]+left[i]end for i=1,#right do out[i]=out[i]+right[i]end return normalise(out)end local function multiply(left,right)local out=zero(#left+#right+1)for i=1,#left do for j=1,#right do out[i+j-1]=out[i+j-1]+left[i]*right[j]end end return normalise(out)end local function high130(value)local out={}for i=1,#value-16 do local low=value[i+16]or 0 local high=value[i+17]or 0 out[i]=math.floor(low/4)+(high%4)*64 end return normalise(out)end local function hasHigh(value)if#value>17 then for i=18,#value do if value[i]~=0 then return true end end end return(value[17]or 0)>=4 end local function reduce(value)while hasHigh(value)do local low,high=zero(17),high130(value)for i=1,17 do low[i]=value[i]or 0 end low[17]=low[17]%4 for i=1,#high do high[i]=high[i]*5 end value=add(low,high)end local prime={251}for i=2,16 do prime[i]=255 end prime[17]=3 local greater=false for i=17,1,-1 do if(value[i]or 0)~=prime[i]then greater=(value[i]or 0)>prime[i];break end end if greater then local borrow=0 for i=1,17 do local n=(value[i]or 0)-prime[i]-borrow if n<0 then n,borrow=n+256,1 else borrow=0 end value[i]=n end end return value end local r,h=zero(17),zero(17)for i=1,16 do r[i]=key:byte(i)end r[4],r[8],r[12],r[16]=band(r[4],15),band(r[8],15),band(r[12],15),band(r[16],15)r[5],r[9],r[13]=band(r[5],252),band(r[9],252),band(r[13],252)for at=1,#message,16 do local part,n=message:sub(at,at+15),zero(17)for i=1,#part do n[i]=part:byte(i)end n[#part+1]=1 h=reduce(multiply(add(h,n),r))end local pad,out,carry={},{},0 for i=1,16 do pad[i]=key:byte(i+16)end for i=1,16 do local n=(h[i]or 0)+pad[i]+carry out[i],carry=n%256,math.floor(n/256)end return string.char(table.unpack(out))end local function padded(value)return value..string.rep(\"\\0\",(16-(#value%16))%16)end local function derive(linkKey)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-key/v1\")or\"\")return raw end function M.nonce(linkKey,counter,context)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-nonce/v1|\"..tostring(counter)..\"|\"..tostring(context or\"\"))or\"\")return raw and raw:sub(1,12)or nil end function M.seal(linkKey,nonce,aad,plaintext)if type(linkKey)~=\"string\"or type(nonce)~=\"string\"or#nonce~=12 or type(aad)~=\"string\"or type(plaintext)~=\"string\"then return nil,\"invalid mesh envelope input\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local ciphertext=chachaXor(key,nonce,1,plaintext)local tag=poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey)return{nonce=rawToHex(nonce),ciphertext=rawToHex(ciphertext),tag=rawToHex(tag)}end function M.open(linkKey,envelope,aad)if type(linkKey)~=\"string\"or type(envelope)~=\"table\"or type(aad)~=\"string\"then return nil,\"invalid mesh envelope\"end local nonce,ciphertext,tag=hexToRaw(envelope.nonce or\"\"),hexToRaw(envelope.ciphertext or\"\"),hexToRaw(envelope.tag or\"\")if not nonce or#nonce~=12 or not ciphertext or not tag or#tag~=16 then return nil,\"invalid mesh envelope encoding\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local expected=rawToHex(poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey))if not password.constantTimeEqual(expected,envelope.tag)then return nil,\"mesh envelope authentication failed\"end return chachaXor(key,nonce,1,ciphertext)end function M.selfTest()local key=hexToRaw(\"85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b\")local tag=poly1305(\"Cryptographic Forum Research Group\",key)return rawToHex(tag)==\"a8061dc1305136c6c22b8baf0c0127a9\"end return M",
  ["ceetos/lib/audit.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/audit.log\"M.LIMITS={maxEntries=250,maxBytes=64*1024}function M.log(actor,action,detail)return store.append(PATH,{ts=os.epoch(\"utc\"),actor=actor or\"system\",action=action,detail=detail,},M.LIMITS)end function M.recent(limit)limit=math.max(1,math.min(50,tonumber(limit)or 10))local raw=store.readAppend(PATH)local result={}for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local entry=textutils.unserialise(line)if entry then result[#result+1]=entry if#result>limit then table.remove(result,1)end end end end return result end return M",
  ["ceetos/lib/net.lua"] = "local store=require(\"ceetos.lib.store\")local audit=require(\"ceetos.lib.audit\")local password=require(\"ceetos.lib.password\")local meshCrypto=require(\"ceetos.lib.mesh_crypto\")local M={handler=nil,publicHandler=nil}local PATH=\"/ceetos/data/network.lua\"local SECURITY_PATH=\"/ceetos/data/network-security.lua\"local SEEN_PATH=\"/ceetos/data/seen-peers.lua\"local CHANNEL,PROTOCOL=45731,\"ceetos/2\"local PUBLIC_UPDATE_PROTOCOL=\"ceetos/update/1\"local PUBLIC_UPDATE_TYPES={update_query=true,update_offer=true,update_chunk_request=true,update_chunk=true,broker_query=true,broker_offer=true,broker_challenge=true,broker_proof=true,broker_grant=true,broker_reject=true,}local DISCOVERY_CHANNEL=CHANNEL local DISCOVERY_TTL,ROUTE_TTL,PACKET_TTL=120000,120000,8 local DISCOVERY_INTERVAL,PAIR_RETRY,ROUTE_INTERVAL=2000,2000,15000 local MESH_BEACON_INTERVAL,MESH_FULL_INTERVAL=15000,30000 local PROBE_INTERVAL,PROBE_DEGRADED,PROBE_OFFLINE,PROBE_RECOVERY=5000,3,6,10000 local ROUTE_CANDIDATE_LIMIT,ROUTE_BUCKET_LIMIT=4,96 local SAFE_READ_WINDOW,SAFE_READ_LIMIT=1000,16 local MAX_PACKET_STRING,MAX_PACKET_TABLE,MAX_PACKET_DEPTH=8192,128,6 local COUNTER_RESERVATION,MAX_RX_EPOCHS,MAX_REVERSE_ROUTES=64,3,128 local routes,discovered,confirmations,seenPackets,reverseRoutes={},{},{},{},{}local routeSequence,lastRouteAdvertisement,routesDirty=0,0,false local discovery,lastDiscovery=nil,{state=\"inactive\"}local security={tx={},rx={}}local autoEdges,linkHealth,meshOffers,meshSeen,advertisedRoutes,meshEnrollmentSends={},{},{},{},{},{}local lastMeshBeacon,lastMeshFull,meshDirty=0,0,false local transport={modem=false,wireless=false,name=nil,channels={},lastTransmit=nil,lastReceive=nil,lastDistance=nil,lastError=nil,rejected=0,}local traces={discovery={},routing={},transport={}}local TRACE_LIMIT=48 local MESH_STATE_LIMIT=128 local rejectPacket local function now()return os.epoch(\"utc\")end local function id()return tostring(os.getComputerID())end local function label()return os.getComputerLabel()or(\"Computer \"..id())end local function isBroadcast(value)return tostring(value)==\"0\"end local function isForUs(value)return tostring(value)==id()end local function copy(value,depth)if type(value)~=\"table\"then return value end if(depth or 0)>MAX_PACKET_DEPTH then return nil end local out={}for k,v in pairs(value)do out[k]=copy(v,(depth or 0)+1)end return out end local function trace(kind,phase,fields)local bucket=traces[kind]or traces.transport local row={time=now(),phase=phase}for key,value in pairs(fields or{})do if key~=\"phrase\"and key~=\"proof\"and key~=\"key\"and key~=\"secret\"and key~=\"mac\"and key~=\"packet\"and key~=\"tag\"then row[key]=value end end bucket[#bucket+1]=row while#bucket>TRACE_LIMIT do table.remove(bucket,1)end end local function read(path,fallback)if store.invalidate then store.invalidate(path)end return store.read(path,fallback)end local function config()local value=read(PATH,{peers={},channel=CHANNEL})value.peers=type(value.peers)==\"table\"and value.peers or{}value.channel=tonumber(value.channel)or CHANNEL return value end local function save(value)local ok,err=store.write(PATH,value)if ok==false then error(err or\"could not save network configuration\",0)end end local function migrateV1Links()local value,changed=config(),false for _,peer in pairs(value.peers)do if peer.protocol~=2 or peer.rekeyRequired or type(peer.key)~=\"string\"or#peer.key<32 then peer.protocol,peer.rekeyRequired,peer.key=1,true,nil peer.secret=nil changed=true end end if changed then save(value)end return value end local function activePeer(value,peerId)local peer=value.peers[tostring(peerId)]if peer and peer.protocol==2 and peer.rekeyRequired~=true and type(peer.key)==\"string\"and#peer.key>=32 then return peer end return nil end local function activeLink(value,peerId)local manual=activePeer(value,peerId)if manual then return manual,\"direct\"end local edge=autoEdges[tostring(peerId)]if edge and type(edge.key)==\"string\"and#edge.key>=32 and(edge.expires or 0)>now()then return edge,\"mesh\"end return nil end local function healthFor(peerId)peerId=tostring(peerId)local state=linkHealth[peerId]if not state then state={state=\"healthy\",successes=0,misses=0,lastAuthenticated=now(),stableSince=now(),inFlight=0}linkHealth[peerId]=state end return state end local function linkState(peerId)return healthFor(peerId).state or\"healthy\"end local function currentInFlight(state,timestamp)state.inFlightUntil=type(state.inFlightUntil)==\"table\"and state.inFlightUntil or{}local kept={}for _,expires in ipairs(state.inFlightUntil)do if expires>timestamp then kept[#kept+1]=expires end end state.inFlightUntil,state.inFlight=kept,#kept return state.inFlight end local function markInFlight(state)local timestamp=now()currentInFlight(state,timestamp)state.inFlightUntil[#state.inFlightUntil+1]=timestamp+SAFE_READ_WINDOW table.sort(state.inFlightUntil)while#state.inFlightUntil>SAFE_READ_LIMIT do table.remove(state.inFlightUntil,1)end state.inFlight=#state.inFlightUntil end local function linkUsable(value,peerId,allowDegraded)if not activeLink(value,peerId)then return false end local state=linkState(peerId)return state==\"healthy\"or(allowDegraded and state==\"degraded\")end local function touchLink(peerId,distance,source)local state,timestamp=healthFor(peerId),now()state.lastAuthenticated,state.lastDistance,state.lastSource=timestamp,distance,source or\"traffic\"state.misses,state.awaiting,state.probeToken=0,false,nil state.loss=math.max(0,(state.loss or 0)*0.5)if state.state~=\"healthy\"then state.successes=(state.successes or 0)+1 if state.successes>=2 then state.state,state.stableSince,state.recoveredAt=\"healthy\",timestamp,timestamp routesDirty=true trace(\"routing\",\"link_recovered\",{peer=peerId,source=source})end else state.successes=math.min(2,(state.successes or 0)+1)end end local function allDirectLinks(value)local out,seen={},{}for peerId in pairs(value.peers)do if activePeer(value,peerId)then out[#out+1],seen[peerId]=tostring(peerId),true end end for peerId,edge in pairs(autoEdges)do if not seen[peerId]and edge.expires>now()then out[#out+1]=tostring(peerId)end end table.sort(out,function(a,b)return tonumber(a)<tonumber(b)end)return out end local function remember(peer,peerLabel,extra)local value=read(SEEN_PATH,{})local old=value[tostring(peer)]or{}old.label,old.seen=peerLabel or old.label or(\"Computer \"..tostring(peer)),now()if extra then for key,item in pairs(extra)do if key~=\"tag\"and key~=\"proof\"then old[key]=item end end end value[tostring(peer)]=old store.write(SEEN_PATH,value)end local function modem(requireWireless)local candidates,used={},{}local sides=rs and rs.getSides and rs.getSides()or{}for _,name in ipairs(sides)do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end if peripheral.getNames then for _,name in ipairs(peripheral.getNames())do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end end local fallback for _,name in ipairs(candidates)do local wrapped=peripheral.wrap(name)if wrapped then fallback=fallback or wrapped local ok,wireless=pcall(function()return not wrapped.isWireless or wrapped.isWireless()end)if ok and wireless then return wrapped end end end return requireWireless and nil or fallback end local function modems()local out,seen={},{}local function add(name)if not seen[name]and peripheral.getType(name)==\"modem\"then local wrapped=peripheral.wrap(name)if wrapped then out[#out+1],seen[name]={name=name,modem=wrapped},true end end end for _,name in ipairs(rs and rs.getSides and rs.getSides()or{})do add(name)end for _,name in ipairs(peripheral.getNames and peripheral.getNames()or{})do add(name)end return out end local function wirelessModems()local out={}for _,item in ipairs(modems())do local ok,wireless=pcall(function()return not item.modem.isWireless or item.modem.isWireless()end)if ok and wireless then out[#out+1]=item end end return out end local function openChannels(value)local channels={value.channel or CHANNEL}if channels[1]~=DISCOVERY_CHANNEL then channels[#channels+1]=DISCOVERY_CHANNEL end transport.channels=channels local all=modems()if#all==0 then transport.lastError=\"no modem attached\";trace(\"transport\",\"modem_missing\");return channels end for _,item in ipairs(all)do for _,channel in ipairs(channels)do local ok,err=pcall(item.modem.open,channel)if not ok then transport.lastError=tostring(err)trace(\"transport\",\"channel_open_failed\",{channel=channel,error=transport.lastError,modem=item.name})end end end return channels end local function canonical(value,depth)depth=depth or 0 local kind=type(value)if kind==\"nil\"then return\"n\"end if kind==\"boolean\"then return value and\"b1\"or\"b0\"end if kind==\"number\"then if value~=value or value==math.huge or value==-math.huge then return nil,\"invalid numeric packet value\"end return\"d\"..string.format(\"%.17g\",value)..\";\"end if kind==\"string\"then if#value>MAX_PACKET_STRING then return nil,\"packet string exceeds limit\"end return\"s\"..tostring(#value)..\":\"..value end if kind~=\"table\"then return nil,\"unsupported packet value\"end if depth>=MAX_PACKET_DEPTH then return nil,\"packet nesting exceeds limit\"end local entries={}for key,item in pairs(value)do if#entries>=MAX_PACKET_TABLE then return nil,\"packet table exceeds limit\"end local encodedKey,keyErr=canonical(key,depth+1);if not encodedKey then return nil,keyErr end local encodedValue,valueErr=canonical(item,depth+1);if not encodedValue then return nil,valueErr end entries[#entries+1]=encodedKey..\"=\"..encodedValue end table.sort(entries)return\"t\"..tostring(#entries)..\"{\"..table.concat(entries,\",\")..\"}\"end local function packetMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,origin=packet.origin,destination=packet.destination,ttl=packet.ttl,request_id=packet.request_id,timestamp=packet.timestamp,reply_to=packet.reply_to,auth=packet.auth and{epoch=packet.auth.epoch,counter=packet.auth.counter}or nil,confidential=packet.confidential==true,body=packet.body,})end local function confidentialAad(packet)return table.concat({\"ceetos/confidential/v1\",tostring(packet.type),tostring(packet.origin),tostring(packet.destination),tostring(packet.request_id)},\"|\")end local function sealBody(peer,packet)local encoded=textutils.serialise(packet.body or{},{compact=true})if#encoded>6144 then return nil,\"confidential payload exceeds limit\"end local nonce=meshCrypto.nonce(peer.key,password.newSalt(\"confidential:\"..tostring(packet.request_id)),confidentialAad(packet))if not nonce then return nil,\"could not create confidential nonce\"end local envelope,err=meshCrypto.seal(peer.key,nonce,confidentialAad(packet),encoded)if not envelope then return nil,err end return{envelope=envelope}end local function openBody(peer,packet)if type(packet.body)~=\"table\"or type(packet.body.envelope)~=\"table\"then return nil,\"malformed confidential envelope\"end local decoded,err=meshCrypto.open(peer.key,packet.body.envelope,confidentialAad(packet))if not decoded or#decoded>6144 then return nil,err or\"invalid confidential payload\"end local ok,value=pcall(textutils.unserialise,decoded)if not ok or type(value)~=\"table\"then return nil,\"invalid confidential payload\"end return value end local function loadSecurity()security=read(SECURITY_PATH,{tx={},rx={}})security.tx=type(security.tx)==\"table\"and security.tx or{}security.rx=type(security.rx)==\"table\"and security.rx or{}end local function saveSecurity()local ok,err=store.write(SECURITY_PATH,security)if ok==false then error(err or\"could not persist peer replay state\",0)end end local function counter(peerId)local key=tostring(peerId)local tx=security.tx[key]if not tx then tx={epoch=password.newSalt(\"peer-tx:\"..key),reserved=0};security.tx[key]=tx end tx.next=tonumber(tx.next)or((tonumber(tx.reserved)or 0)+1)if tx.next>(tonumber(tx.reserved)or 0)then tx.reserved=tx.next+COUNTER_RESERVATION-1 saveSecurity()end local value=tx.next;tx.next=value+1 return tx.epoch,value end local function verifyReplay(from,auth)if type(auth)~=\"table\"or type(auth.epoch)~=\"string\"or#auth.epoch<16 or#auth.epoch>128 then return false,\"invalid packet epoch\"end local sequence=tonumber(auth.counter)if not sequence or sequence<1 or sequence%1~=0 then return false,\"invalid packet counter\"end local key=tostring(from)local row=security.rx[key]or{epochs={}}row.epochs=type(row.epochs)==\"table\"and row.epochs or{}local old=tonumber(row.epochs[auth.epoch])if old and sequence<=old then return false,\"replayed packet counter\"end row.epochs[auth.epoch]=sequence local order={}for epoch,max in pairs(row.epochs)do order[#order+1]={epoch=epoch,max=tonumber(max)or 0}end table.sort(order,function(a,b)return a.max>b.max end)while#order>MAX_RX_EPOCHS do row.epochs[table.remove(order).epoch]=nil end security.rx[key]=row saveSecurity()return true end local function newRequestId()return id()..\":\"..password.newSalt(\"peer-request\")end local function sign(peerId,peer,packet)local epoch,sequence=counter(peerId)packet.auth={epoch=epoch,counter=sequence}local material,err=packetMaterial(packet)if not material then return false,err end local mac,macErr=password.hmacSha256(peer.key,material)if not mac then return false,macErr end packet.auth.mac=mac return true end local function verifyPacket(packet,value)if type(packet)~=\"table\"then return false,\"packet is not a table\"end if packet.protocol~=PROTOCOL then return false,packet.protocol==\"ceetos/1\"and\"v1 packet rejected; rekey required\"or\"invalid packet protocol\"end if type(packet.type)~=\"string\"or#packet.type==0 or#packet.type>64 then return false,\"invalid packet type\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid packet sender\"end local from=tostring(packet.from)local peer=activeLink(value,from)if not peer then return false,\"sender is not an active direct or mesh peer\"end if not isForUs(packet.to)then return false,\"packet addressed to another hop\"end if type(packet.origin)~=\"string\"and type(packet.origin)~=\"number\"then return false,\"invalid packet origin\"end if type(packet.destination)~=\"string\"and type(packet.destination)~=\"number\"then return false,\"invalid packet destination\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 or#packet.request_id>128 then return false,\"invalid packet request ID\"end if packet.reply_to~=nil and(type(packet.reply_to)~=\"string\"or#packet.reply_to==0 or#packet.reply_to>128)then return false,\"invalid reply correlation ID\"end local ttl=tonumber(packet.ttl)if not ttl or ttl%1~=0 or ttl<1 or ttl>PACKET_TTL then return false,\"invalid packet TTL\"end local timestamp=tonumber(packet.timestamp)if not timestamp or math.abs(now()-timestamp)>ROUTE_TTL then return false,\"stale packet timestamp\"end if type(packet.auth)~=\"table\"or type(packet.auth.mac)~=\"string\"or#packet.auth.mac~=64 then return false,\"missing packet MAC\"end local receivedMac=packet.auth.mac packet.auth.mac=nil local material,materialErr=packetMaterial(packet)packet.auth.mac=receivedMac if not material then return false,materialErr end local expected,macErr=password.hmacSha256(peer.key,material)if not expected or not password.constantTimeEqual(expected,receivedMac)then return false,macErr or\"invalid packet MAC\"end local replayOk,replayErr=verifyReplay(from,packet.auth)if not replayOk then return false,replayErr end return true,peer end local function routeBucket(targetId)local bucket=routes[tostring(targetId)]if bucket and bucket.next then bucket={candidates={{next=tostring(bucket.next),hops=tonumber(bucket.hops)or PACKET_TTL,expires=tonumber(bucket.expires)or 0,label=bucket.label,mode=bucket.mode,masterId=bucket.masterId,legacy=true,loss=1,}},primary=tostring(bucket.next),changedAt=now(),reason=\"legacy route\"}routes[tostring(targetId)]=bucket end if not bucket then bucket={candidates={},changedAt=now(),reason=\"new\"}routes[tostring(targetId)]=bucket end bucket.candidates=type(bucket.candidates)==\"table\"and bucket.candidates or{}return bucket end local function candidateHealth(candidate)local state=healthFor(candidate.next)local rank=state.state==\"healthy\"and 0 or(state.state==\"degraded\"and 1 or 2)return rank,state end local function directCandidate(value,targetId)local link,kind=activeLink(value,targetId)if link then return{next=targetId,hops=1,expires=now()+ROUTE_TTL,kind=kind,direct=true,label=link.label,mode=link.mode,masterId=link.masterId}end end local function validCandidates(targetId,value)local timestamp,out,seen=now(),{},{}local direct=directCandidate(value,targetId)if direct then out[#out+1],seen[direct.next..\":\"..direct.kind]=direct,true end local bucket=routes[tostring(targetId)]if bucket then for _,candidate in ipairs(routeBucket(targetId).candidates)do local key=tostring(candidate.next)..\":\"..tostring(candidate.kind or\"route\")if not seen[key]and candidate.expires>timestamp and candidate.hops>=1 and candidate.hops<=PACKET_TTL and activeLink(value,candidate.next)then out[#out+1],seen[key]=candidate,true end end end return out end local function compareCandidates(a,b)local ar,ah=candidateHealth(a)local br,bh=candidateHealth(b)if ar~=br then return ar<br end if(a.hops or PACKET_TTL)~=(b.hops or PACKET_TTL)then return(a.hops or PACKET_TTL)<(b.hops or PACKET_TTL)end if(ah.loss or 0)~=(bh.loss or 0)then return(ah.loss or 0)<(bh.loss or 0)end if(ah.rtt or 0)~=(bh.rtt or 0)then return(ah.rtt or 0)<(bh.rtt or 0)end return tostring(a.next)<tostring(b.next)end local function primaryCandidate(targetId,value,safe)local candidates=validCandidates(targetId,value)if#candidates==0 then return nil end table.sort(candidates,compareCandidates)local target,bucket,selected=tostring(targetId),routeBucket(targetId),candidates[1]local existing for _,item in ipairs(candidates)do if tostring(item.next)==tostring(bucket.primary)then existing=item;break end end if existing then local oldRank,newRank=candidateHealth(existing),candidateHealth(selected)if oldRank<newRank then selected=existing elseif oldRank==newRank and oldRank==0 and(selected.hops or 99)<(existing.hops or 99)then local health=healthFor(selected.next)if(health.successes or 0)<2 or(health.recoveredAt and now()-(health.stableSince or now())<PROBE_RECOVERY)then selected=existing end end end if safe then local rank,_,choices=candidateHealth(selected),nil,{}for _,item in ipairs(candidates)do local itemRank=candidateHealth(item)if itemRank==rank and item.hops==selected.hops then choices[#choices+1]=item end end if#choices>1 then table.sort(choices,function(a,b)local ah,bh=healthFor(a.next),healthFor(b.next)local aLoad,bLoad=currentInFlight(ah,now()),currentInFlight(bh,now())if aLoad~=bLoad then return aLoad<bLoad end return tostring(a.next)<tostring(b.next)end)selected=choices[1]end end if bucket.primary~=tostring(selected.next)then bucket.primary,bucket.changedAt,bucket.reason=tostring(selected.next),now(),existing and\"health/hop selection\"or\"initial selection\"trace(\"routing\",\"route_selected\",{destination=target,next=selected.next,hops=selected.hops,reason=bucket.reason})end return selected end local function nextHop(target,safe)local candidate=primaryCandidate(target,config(),safe)if candidate then local health=healthFor(candidate.next)if safe then markInFlight(health)end health.lastSelected=now()return candidate.next,candidate end routes[tostring(target)]=nil end local function transmit(items,channel,packet)if#items==0 then return false,\"no compatible modem attached\"end local sent,lastError=false,nil for _,item in ipairs(items)do local ok,err=pcall(item.modem.transmit,channel,channel,packet)if ok then sent=true else lastError=tostring(err)end end if not sent then transport.lastError=lastError or\"modem transmit failed\"end return sent,transport.lastError end local function send(target,input,forcedHop)local hop=forcedHop or nextHop(target,input.routeSafe==true and input.balanceSafe==true)if not hop then return false,\"peer is unreachable or requires rekey\"end local value,peer=config(),activeLink(config(),hop)if not peer then return false,\"direct route is unavailable\"end local packet=copy(input)packet.auth,packet.protocol,packet.from,packet.to=nil,PROTOCOL,id(),hop packet.origin,packet.destination=tostring(packet.origin or id()),tostring(packet.destination or target)packet.ttl=math.floor(tonumber(packet.ttl)or PACKET_TTL)packet.timestamp=now()if packet.ttl<1 or packet.ttl>PACKET_TTL then return false,\"invalid packet TTL\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 then packet.request_id=newRequestId()end if packet.confidential==true then local sealed,sealErr=sealBody(peer,packet)if not sealed then return false,sealErr end packet.body=sealed end local signed,signErr=sign(hop,peer,packet)if not signed then return false,signErr end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if not sent then trace(\"transport\",\"transmit_failed\",{type=packet.type,to=hop,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil healthFor(hop).lastTransmit=now()trace(\"routing\",\"packet_sent\",{type=packet.type,to=hop,destination=packet.destination,links=#links})return true end local function rememberReverse(packet,previousHop)if type(packet)~=\"table\"or type(packet.request_id)~=\"string\"or#packet.request_id==0 then return false end local requestId,origin=packet.request_id,tostring(packet.origin)local existing=reverseRoutes[requestId]if existing and(existing.previous~=tostring(previousHop)or existing.origin~=origin)then return false,\"reverse route collision\"end reverseRoutes[requestId]={previous=tostring(previousHop),origin=origin,expires=now()+ROUTE_TTL}local entries={}for key,route in pairs(reverseRoutes)do entries[#entries+1]={id=key,expires=route.expires or 0}end table.sort(entries,function(a,b)return a.expires<b.expires end)while#entries>MAX_REVERSE_ROUTES do reverseRoutes[table.remove(entries,1).id]=nil end return true end local function broadcast(packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";trace(\"discovery\",\"wireless_missing\");return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to=PROTOCOL,id(),0 out.timestamp=now()openChannels(config())local sent,err=transmit(links,DISCOVERY_CHANNEL,out)if not sent then trace(\"discovery\",\"transmit_failed\",{type=out.type,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil trace(\"discovery\",out.type==\"discover\"and\"announcement_sent\"or\"discovery_packet_sent\",{type=out.type})return true end local function publicTransmit(target,typeName,body)if not PUBLIC_UPDATE_TYPES[typeName]then return false,\"invalid public update packet type\"end local encoded,encodeErr=canonical(body or{})if not encoded then return false,encodeErr or\"invalid public update body\"end local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end openChannels(config())local packet={protocol=PUBLIC_UPDATE_PROTOCOL,type=typeName,from=id(),to=tostring(target),timestamp=now(),request_id=newRequestId(),body=body or{},}local sent,err=transmit(links,DISCOVERY_CHANNEL,packet)if not sent then transport.lastError=err or\"public update transmit failed\"trace(\"transport\",\"public_update_transmit_failed\",{type=typeName,to=target,error=transport.lastError})return false,transport.lastError end transport.lastTransmit,transport.lastError=now(),nil trace(\"transport\",\"public_update_sent\",{type=typeName,to=target,bytes=#encoded})return true end function M.publicSend(target,typeName,body)if tostring(target)==\"0\"or tostring(target)==\"\"then return false,\"public update target must be a computer ID\"end return publicTransmit(target,typeName,body)end function M.publicBroadcast(typeName,body)return publicTransmit(\"0\",typeName,body)end local function handshake(target,packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to,out.timestamp=PROTOCOL,id(),tostring(target),now()out.destination,out.ttl=tostring(target),1 openChannels(config())local sent,err=transmit(links,config().channel or CHANNEL,out)if not sent then trace(\"discovery\",\"handshake_transmit_failed\",{type=out.type,to=target,error=err});return false,err end transport.lastTransmit=now()trace(\"discovery\",out.type..\"_sent\",{to=target})return true end local function phraseTag(phrase,sessionId,hostId)return password.hmacSha256(phrase,\"ceetos/discovery/v2|\"..sessionId..\"|\"..tostring(hostId))end local function joinProof(phrase,sessionId,hostId,joinerId,nonce)return password.hmacSha256(phrase,\"ceetos/pair/join/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce)end local function confirmProof(phrase,sessionId,hostId,joinerId,nonce,mode,master)return password.hmacSha256(phrase,\"ceetos/pair/confirm/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce..\"|\"..tostring(mode)..\"|\"..tostring(master or\"\"))end local function linkKey(phrase,sessionId,hostId,joinerId,nonce)return password.derive(phrase,\"ceetos/link/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce,64)end local function keyId(key)local value=password.hmacSha256(key,\"ceetos/key-id/v2\")return value and value:sub(1,16)or\"\"end local function activeSession()return discovery and(discovery.state==\"hosting\"or discovery.state==\"searching\"or discovery.state==\"candidate\"or discovery.state==\"confirming\")end local function setLast(state,message)lastDiscovery={state=state,message=message,at=now()}end local function persistPair(peerId,key,metadata,masterId)local value=config()value.peers[tostring(peerId)]={protocol=2,rekeyRequired=false,key=key,keyId=keyId(key),role=\"operator\",mode=metadata.mode or\"peer\",master=tostring(masterId or\"\")==id(),masterId=tostring(masterId or\"\"),label=metadata.label,}save(value)remember(peerId,metadata.label,{mode=metadata.mode,masterId=masterId})routes[tostring(peerId)]=nil routesDirty=true audit.log(\"local\",\"peer.rekeyed\",{peer=peerId,mode=metadata.mode})end local function markRejected(reason)if discovery then discovery=nil end setLast(\"cancelled\",reason)end local function discoveryAnnouncement()if not discovery or discovery.state~=\"hosting\"then return false,\"no active host discovery\"end return broadcast({type=\"discover\",session=discovery.id,tag=discovery.tag,label=discovery.label,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,})end local function queueConfirmation(peerId,host)confirmations[host.id]=host local sent,err=handshake(peerId,{type=\"pair_confirm\",session=host.id,nonce=host.joinNonce,proof=host.confirmProof,label=host.label,mode=host.mode,master=host.masterId,})host.lastSent,host.retries=now(),0 if not sent then host.error=err end return sent,err end local function expireState(timestamp)if discovery and discovery.expires<=timestamp then local old=discovery.state discovery=nil setLast(\"expired\",old==\"searching\"and\"no matching discovery announcement received\"or\"discovery session expired\")trace(\"discovery\",\"session_expired\",{previous=old})end end local function boundMap(value,limit,timestamp)local entries={}for key,row in pairs(value)do entries[#entries+1]={key=key,at=type(row)==\"number\"and row or(type(row)==\"table\"and(row.expires or row.time or row.seen or row.lastAuthenticated or 0)or 0)}end table.sort(entries,function(a,b)if a.at~=b.at then return a.at<b.at end return tostring(a.key)<tostring(b.key)end)while#entries>limit do value[table.remove(entries,1).key]=nil end end local function pruneRouteBuckets(timestamp)local value=config()local entries={}for peerId,bucket in pairs(routes)do local latest=tonumber(bucket.changedAt)or 0 for _,candidate in ipairs(type(bucket.candidates)==\"table\"and bucket.candidates or{})do latest=math.max(latest,tonumber(candidate.expires)or 0)end entries[#entries+1]={peer=peerId,latest=latest}end table.sort(entries,function(a,b)if a.latest~=b.latest then return a.latest<b.latest end return tostring(a.peer)<tostring(b.peer)end)while#entries>ROUTE_BUCKET_LIMIT do local old=table.remove(entries,1)routes[old.peer],routesDirty=nil,true trace(\"routing\",\"route_bucket_evicted\",{destination=old.peer})end for peerId,state in pairs(linkHealth)do if not activeLink(value,peerId)and not routes[peerId]then linkHealth[peerId]=nil end end for peerId in pairs(advertisedRoutes)do if not activeLink(value,peerId)then advertisedRoutes[peerId]=nil end end boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)end local function controller(value)value=value or config()if value.controller and tostring(value.controller)~=\"\"then local chosen=tostring(value.controller)if chosen==id()or activeLink(value,chosen)then return chosen end local known=routes[chosen]if known then if known.expires and known.expires>now()then return chosen end if type(known.candidates)==\"table\"then for _,candidate in ipairs(known.candidates)do if(candidate.expires or 0)>now()and activeLink(value,candidate.next)then return chosen end end end end trace(\"routing\",\"controller_unreachable\",{controller=chosen})end local selected=tonumber(id())or 0 for peerId in pairs(value.peers)do if activePeer(value,peerId)then local n=tonumber(peerId);if n and n<selected then selected=n end end end for peerId,route in pairs(routes)do local reachable=route.expires and route.expires>now()if type(route.candidates)==\"table\"then reachable=false for _,candidate in ipairs(route.candidates)do if(candidate.expires or 0)>now()then reachable=true;break end end end if reachable then local n=tonumber(peerId);if n and n<selected then selected=n end end end return tostring(selected)end local function meshConfig(value)value=value or config()local mesh=value.mesh if type(mesh)==\"table\"and type(mesh.id)==\"string\"and#mesh.id>=16 and type(mesh.root)==\"string\"and#mesh.root>=32 and tonumber(mesh.epoch)then return mesh end return nil end local function meshMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,mesh=packet.mesh,epoch=packet.epoch,nonce=packet.nonce,offer=packet.offer,timestamp=packet.timestamp})end local function meshTag(mesh,packet)local material=meshMaterial(packet)return material and password.hmacSha256(mesh.root,material)or nil end local function meshPacket(typeName,target,fields)local value,mesh=config(),meshConfig()if not mesh then return false,\"mesh enrollment is pending\"end local packet=copy(fields or{})packet.protocol,packet.type,packet.from,packet.to=PROTOCOL,typeName,id(),target and tostring(target)or 0 packet.mesh,packet.epoch,packet.timestamp=mesh.id,mesh.epoch,now()packet.tag=meshTag(mesh,packet)if not packet.tag then return false,\"could not authenticate mesh packet\"end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if sent then trace(\"routing\",typeName..\"_sent\",{to=packet.to,mesh=mesh.id:sub(1,8)})end return sent,err end local function deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)local left,right=tostring(id()),tostring(peerId)if left>right then left,right=right,left end return password.hmacSha256(mesh.root,\"ceetos/mesh-edge/v1|\"..tostring(mesh.epoch)..\"|\"..left..\"|\"..right..\"|\"..tostring(firstNonce)..\"|\"..tostring(secondNonce))end local function ownsMeshOffer(peerId)local ours,theirs=tonumber(id()),tonumber(peerId)if ours and theirs then return ours<theirs end return tostring(id())<tostring(peerId)end local function installAutoEdge(mesh,peerId,firstNonce,secondNonce,peerLabel)peerId=tostring(peerId)local value=config()if activePeer(value,peerId)then return false,\"manual direct link already exists\"end local key=deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)if not key then return false,\"could not derive mesh edge\"end autoEdges[peerId]={key=key,label=peerLabel,mesh=mesh.id,epoch=mesh.epoch,expires=now()+ROUTE_TTL,firstNonce=firstNonce,secondNonce=secondNonce}local state=healthFor(peerId)state.state,state.successes,state.misses,state.lastAuthenticated,state.stableSince=\"healthy\",2,0,now(),now()routesDirty,meshDirty=true,true trace(\"routing\",\"mesh_edge_active\",{peer=peerId,mesh=mesh.id:sub(1,8)})return true end local function meshEnrollmentAad(from,to,meshId,epoch,nonceCounter)return canonical({protocol=PROTOCOL,type=\"mesh_enroll\",from=tostring(from),to=tostring(to),mesh=meshId,epoch=tonumber(epoch),counter=tonumber(nonceCounter)})end local function sendEnrollment(peerId)local value,mesh,peer=config(),meshConfig(),activePeer(config(),peerId)if not mesh or not peer then return false,\"mesh or direct link unavailable\"end local _,nonceCounter=counter(peerId)local aad=meshEnrollmentAad(id(),peerId,mesh.id,mesh.epoch,nonceCounter)local nonce=meshCrypto.nonce(peer.key,nonceCounter,\"mesh-enroll|\"..id()..\"|\"..tostring(peerId))local plaintext=textutils.serialise({id=mesh.id,epoch=mesh.epoch,root=mesh.root},{compact=true})local envelope,err=meshCrypto.seal(peer.key,nonce,aad,plaintext)if not envelope then return false,err end local sent,sendErr=send(peerId,{type=\"mesh_enroll\",body={mesh=mesh.id,epoch=mesh.epoch,counter=nonceCounter,envelope=envelope},request_id=newRequestId()},peerId)if sent then trace(\"routing\",\"mesh_enrollment_sent\",{to=peerId,epoch=mesh.epoch})end return sent,sendErr end local function acceptEnrollment(from,peer,packet)if not activePeer(config(),from)then return rejectPacket(\"mesh enrollment requires a manual direct link\",packet)end local body=packet.body if type(body)~=\"table\"or type(body.mesh)~=\"string\"or type(body.envelope)~=\"table\"or not tonumber(body.epoch)or not tonumber(body.counter)then return rejectPacket(\"malformed_mesh_enrollment\",packet)end local aad=meshEnrollmentAad(from,id(),body.mesh,body.epoch,body.counter)local plaintext,err=meshCrypto.open(peer.key,body.envelope,aad)if not plaintext then return rejectPacket(err or\"mesh enrollment authentication failed\",packet)end local ok,mesh=pcall(textutils.unserialise,plaintext)if not ok or type(mesh)~=\"table\"or mesh.id~=body.mesh or tonumber(mesh.epoch)~=tonumber(body.epoch)or type(mesh.root)~=\"string\"or#mesh.root<32 then return rejectPacket(\"invalid_mesh_enrollment\",packet)end local value,existing=config(),meshConfig()if existing and existing.id==mesh.id and tonumber(existing.epoch)>tonumber(mesh.epoch)then return end value.mesh={id=mesh.id,epoch=tonumber(mesh.epoch),root=mesh.root,enrolledAt=now(),enrolledBy=tostring(from)}save(value)meshDirty,routesDirty=true,true trace(\"routing\",\"mesh_enrolled\",{from=from,mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end local function ensureMeshEnrollment(timestamp)local value,mesh=config(),meshConfig()if not mesh then if(M._meshBootstrapAt or 0)>timestamp or controller(value)~=id()then return end value.mesh={id=password.newSalt(\"mesh-id:\"..id()),root=password.newSalt(\"mesh-root:\"..id()),epoch=1,createdAt=timestamp,controller=id()}save(value);mesh,meshDirty,routesDirty=value.mesh,true,true trace(\"routing\",\"mesh_created\",{mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end for _,peerId in ipairs(allDirectLinks(value))do if activePeer(value,peerId)then local previous=meshEnrollmentSends[peerId]if not previous or previous.epoch~=mesh.epoch or timestamp-previous.at>=MESH_FULL_INTERVAL then local sent=sendEnrollment(peerId)if sent then meshEnrollmentSends[peerId]={epoch=mesh.epoch,at=timestamp}end end end end end local function meshBeacon(timestamp)local mesh=meshConfig()if not mesh or timestamp-lastMeshBeacon<MESH_BEACON_INTERVAL then return end lastMeshBeacon=timestamp meshPacket(\"mesh_beacon\",nil,{nonce=password.newSalt(\"mesh-beacon:\"..id()),label=label()})end local function verifyMeshPacket(packet)local mesh=meshConfig()if not mesh or type(packet)~=\"table\"or packet.protocol~=PROTOCOL or packet.mesh~=mesh.id or tonumber(packet.epoch)~=tonumber(mesh.epoch)then return false,\"mesh membership proof failed\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid mesh sender\"end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 then return false,\"invalid mesh nonce\"end if math.abs(now()-(tonumber(packet.timestamp)or 0))>ROUTE_TTL then return false,\"stale mesh packet\"end local material,tag=meshMaterial(packet),packet.tag local expected=material and password.hmacSha256(mesh.root,material)if type(tag)~=\"string\"or not expected or not password.constantTimeEqual(expected,tag)then return false,\"invalid mesh packet tag\"end local replay=tostring(packet.from)..\"|\"..tostring(packet.type)..\"|\"..tostring(packet.nonce)..\"|\"..tostring(packet.offer or\"\")if meshSeen[replay]and meshSeen[replay]+ROUTE_TTL>now()then return false,\"replayed mesh packet\"end meshSeen[replay]=now()return true,mesh end local function handleMeshPacket(packet,distance)local valid,meshOrErr=verifyMeshPacket(packet)if not valid then return rejectPacket(meshOrErr,packet,nil,distance)end local mesh,from=meshOrErr,tostring(packet.from)if from==id()then return end if packet.type==\"mesh_beacon\"then remember(from,packet.label,{mesh=mesh.id})if not activePeer(config(),from)and not autoEdges[from]and ownsMeshOffer(from)then local nonce=password.newSalt(\"mesh-offer:\"..from)meshOffers[from]={offer=nonce,expires=now()+DISCOVERY_TTL}meshPacket(\"mesh_edge_offer\",from,{nonce=nonce,label=label()})end return end if not isForUs(packet.to)then return rejectPacket(\"mesh packet addressed to another peer\",packet,nil,distance)end if packet.type==\"mesh_edge_offer\"then if activePeer(config(),from)then return end local response=password.newSalt(\"mesh-accept:\"..from)installAutoEdge(mesh,from,packet.nonce,response,packet.label)return meshPacket(\"mesh_edge_accept\",from,{nonce=response,offer=packet.nonce,label=label()})end if packet.type==\"mesh_edge_accept\"then local offer=meshOffers[from]if not offer or offer.expires<=now()or offer.offer~=packet.offer then return rejectPacket(\"unexpected mesh edge acceptance\",packet,nil,distance)end meshOffers[from]=nil return installAutoEdge(mesh,from,offer.offer,packet.nonce,packet.label)end end local function probeLinks(timestamp)local value=config()for _,peerId in ipairs(allDirectLinks(value))do local health=healthFor(peerId)local interval=health.state==\"offline\"and PROBE_INTERVAL*3 or PROBE_INTERVAL if timestamp-(health.lastAuthenticated or 0)>=interval and timestamp-(health.lastProbe or 0)>=interval then if health.awaiting then health.misses=(health.misses or 0)+1 health.loss=math.min(1,((health.loss or 0)*3+1)/4)local nextState=health.misses>=PROBE_OFFLINE and\"offline\"or(health.misses>=PROBE_DEGRADED and\"degraded\"or health.state)if nextState~=health.state then health.state,health.successes,health.recoveredAt=nextState,0,nil trace(\"routing\",\"link_\"..nextState,{peer=peerId,misses=health.misses})end routesDirty=true end health.awaiting,health.lastProbe,health.probeToken=true,timestamp,password.newSalt(\"mesh-probe:\"..peerId)send(peerId,{type=\"mesh_probe\",body={token=health.probeToken},request_id=newRequestId()},peerId)end end end local function advertisedMembers(value,peerId,timestamp)local members={}for other,manual in pairs(value.peers)do if other~=peerId and activeLink(value,other)and linkState(other)==\"healthy\"then members[other]={label=manual.label,mode=manual.mode,masterId=manual.masterId,hops=1,kind=\"direct\"}end end for other,edge in pairs(autoEdges)do if other~=peerId and edge.expires>timestamp and linkState(other)==\"healthy\"then members[other]={label=edge.label,mode=\"peer\",hops=1,kind=\"mesh\"}end end for other in pairs(routes)do if other~=peerId and not members[other]then local candidate=primaryCandidate(other,value,false)if candidate and candidate.next~=peerId and linkState(candidate.next)==\"healthy\"then members[other]={label=candidate.label,mode=candidate.mode,masterId=candidate.masterId,hops=candidate.hops,kind=candidate.kind or\"route\"}end end end return members end local function sameAdvertisement(left,right)local leftValue,leftErr=canonical(left)local rightValue,rightErr=canonical(right)return leftValue~=nil and rightValue~=nil and not leftErr and not rightErr and leftValue==rightValue end local function advertiseRoutes(force)local timestamp,value=now(),config()if not force and not routesDirty and timestamp-lastRouteAdvertisement<ROUTE_INTERVAL then return end lastRouteAdvertisement,routesDirty=timestamp,false local full=timestamp-lastMeshFull>=MESH_FULL_INTERVAL if full then lastMeshFull=timestamp end for _,peerId in ipairs(allDirectLinks(value))do if linkUsable(value,peerId,false)then local desired,previous=advertisedMembers(value,peerId,timestamp),advertisedRoutes[peerId]or{}local members,withdrawals={},{}if full then members=desired else for target,meta in pairs(desired)do if not sameAdvertisement(meta,previous[target])then members[target]=meta end end for target in pairs(previous)do if not desired[target]then withdrawals[#withdrawals+1]=target end end end table.sort(withdrawals,function(a,b)return tostring(a)<tostring(b)end)if full or next(members)~=nil or#withdrawals>0 then routeSequence=routeSequence+1 local body={sequence=routeSequence,routeVersion=2,full=full,controller=controller(value),members=members,withdrawals=withdrawals}if send(peerId,{type=\"route_advertise\",body=body,routeSafe=true,request_id=newRequestId()})then advertisedRoutes[peerId]=copy(desired)trace(\"routing\",full and\"route_snapshot_sent\"or\"route_delta_sent\",{to=peerId,changes=(full and 0 or#withdrawals)})end end else advertisedRoutes[peerId]=nil end end end function M.start()migrateV1Links()loadSecurity()assert(meshCrypto.selfTest(),\"CeetOS mesh cryptography self-test failed\")openChannels(config())local status=M.transportStatus()trace(\"transport\",status.wireless and\"wireless_modem_detected\"or\"wireless_modem_missing\",{name=status.name})routesDirty,M._meshBootstrapAt=true,now()end function M.transportStatus()local wireless=wirelessModems()transport.modem,transport.wireless=#modems()>0,#wireless>0 transport.name=wireless[1]and wireless[1].name or nil local out=copy(transport)out.wirelessLinks,out.wirelessLinkCount={},#wireless for _,item in ipairs(wireless)do out.wirelessLinks[#out.wirelessLinks+1]=item.name end out.usesAllWirelessLinks,out.protocol=true,2 out.directPeers,out.manualDirectPeers,out.meshPeers,out.rekeyRequiredPeers,out.routedPeers=0,0,0,0,0 out.healthyLinks,out.degradedLinks,out.offlineLinks=0,0,0 local value=config()for peerId,peer in pairs(value.peers)do if activePeer(value,peerId)then out.directPeers,out.manualDirectPeers=out.directPeers+1,out.manualDirectPeers+1 elseif peer.rekeyRequired then out.rekeyRequiredPeers=out.rekeyRequiredPeers+1 end end for peerId,edge in pairs(autoEdges)do if edge.expires>now()then out.meshPeers,out.directPeers=out.meshPeers+1,out.directPeers+1 end end for peerId,health in pairs(linkHealth)do if health.state==\"healthy\"then out.healthyLinks=out.healthyLinks+1 elseif health.state==\"degraded\"then out.degradedLinks=out.degradedLinks+1 elseif health.state==\"offline\"then out.offlineLinks=out.offlineLinks+1 end end for peerId,bucket in pairs(routes)do local usable=primaryCandidate(peerId,value,false)if usable and not value.peers[peerId]and not autoEdges[peerId]then out.routedPeers=out.routedPeers+1 end end local mesh=meshConfig(value)out.mesh=mesh and{id=mesh.id:sub(1,8),epoch=mesh.epoch,enrolled=true}or{enrolled=false}out.health={healthy=out.healthyLinks,degraded=out.degradedLinks,offline=out.offlineLinks}return out end function M.transportTrace(kind)if kind==\"discovery\"or kind==\"routing\"or kind==\"transport\"then return copy(traces[kind])end return{discovery=copy(traces.discovery),routing=copy(traces.routing),transport=copy(traces.transport)}end function M.discovery()expireState(now())return copy(discovery)end function M.discoveryStatus()expireState(now())local candidate=discovery and discovery.candidate and{id=discovery.candidate.from,label=discovery.candidate.label,mode=discovery.candidate.mode,master=discovery.candidate.master,}or nil local session=discovery and{session=discovery.id,state=discovery.state,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,retries=discovery.retries or 0,candidate=candidate and copy(candidate)or nil,}or nil local state=session and session.state or(lastDiscovery and lastDiscovery.state or\"inactive\")return{state=state,active=session~=nil,lastState=lastDiscovery and lastDiscovery.state or\"inactive\",lastMessage=lastDiscovery and lastDiscovery.message or nil,session=session,searching=session and session.state==\"searching\"or false,candidate=candidate,discovered=#M.seenPeers(),transport=M.transportStatus(),message=(discovery and discovery.error)or(lastDiscovery and lastDiscovery.message),}end function M.startDiscovery(mode,masterSide,phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end mode=mode==\"master\"and\"master\"or\"peer\"masterSide=masterSide==\"joiner\"and\"joiner\"or\"initiator\"local sessionId=password.newSalt(\"discovery:\"..id())discovery={id=sessionId,state=\"hosting\",phrase=normalized,tag=phraseTag(normalized,sessionId,id()),mode=mode,masterSide=masterSide,label=label(),initiator=id(),expires=now()+DISCOVERY_TTL,retries=0,lastBroadcast=0,}local sent,err=discoveryAnnouncement()if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastBroadcast=now()setLast(\"hosting\")return true,{state=\"hosting\",session=sessionId,expires=discovery.expires}end function M.joinDiscovery(phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end local candidate for _,item in pairs(discovered)do if item.expires>now()and password.constantTimeEqual(item.tag or\"\",phraseTag(normalized,item.session,item.from))then candidate=item;break end end discovery={state=\"searching\",phrase=normalized,expires=now()+DISCOVERY_TTL,retries=0,lastQuery=0}if candidate then discovery.state,discovery.candidate=\"candidate\",candidate return true,{state=\"candidate\",candidate={id=candidate.from,label=candidate.label,mode=candidate.mode,master=candidate.master}}end local sent,err=broadcast({type=\"discover_query\"})if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastQuery=now()setLast(\"searching\",\"waiting for matching discovery announcement\")return true,{state=\"searching\"}end function M.confirmDiscovery()if not discovery or discovery.state~=\"candidate\"or not discovery.candidate then return false,\"no discovery candidate is awaiting confirmation\"end local candidate,value=discovery.candidate,config()local existing=value.peers[tostring(candidate.from)]if existing and not existing.rekeyRequired then return false,\"computer is already a network member\"end if routes[tostring(candidate.from)]and not existing then return false,\"computer is already a routed network member\"end local nonce=password.newSalt(\"pair-join:\"..candidate.session)local proof=joinProof(discovery.phrase,candidate.session,candidate.from,id(),nonce)discovery.state,discovery.joinNonce,discovery.joinProof,discovery.lastSent,discovery.retries=\"confirming\",nonce,proof,now(),0 local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=nonce,proof=proof,label=label()})if not sent then discovery.error=err;return false,err end trace(\"discovery\",\"pair_confirmation_requested\",{peer=candidate.from})return true end function M.cancelDiscovery()if discovery and discovery.state==\"hosting\"then broadcast({type=\"discover_cancel\",session=discovery.id})end discovery=nil setLast(\"cancelled\",\"discovery cancelled\")trace(\"discovery\",\"session_cancelled\")return true end function M.normalizePhrase(value)if type(value)~=\"string\"then return nil,\"phrase is required\"end if value:find(\"[%z\\1-\\31\\127]\")then return nil,\"phrase contains control characters\"end value=value:gsub(\"^%s+\",\"\"):gsub(\"%s+$\",\"\")if#value<8 then return nil,\"phrase must be at least 8 characters\"end if#value>128 then return nil,\"phrase must be at most 128 characters\"end return value end function M.tick()local timestamp=now()expireState(timestamp)if discovery then if discovery.state==\"hosting\"and timestamp-(discovery.lastBroadcast or 0)>=math.min(30000,DISCOVERY_INTERVAL*(2^math.min(discovery.retries or 0,4)))then local sent,err=discoveryAnnouncement()discovery.lastBroadcast=timestamp discovery.retries=(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"searching\"and timestamp-(discovery.lastQuery or 0)>=DISCOVERY_INTERVAL then local sent,err=broadcast({type=\"discover_query\"})discovery.lastQuery,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"confirming\"and timestamp-(discovery.lastSent or 0)>=PAIR_RETRY then local candidate=discovery.candidate local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=discovery.joinNonce,proof=discovery.joinProof,label=label()})discovery.lastSent,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end end end for sessionId,item in pairs(discovered)do if item.expires<=timestamp then discovered[sessionId]=nil end end for sessionId,record in pairs(confirmations)do if record.expires<=timestamp then confirmations[sessionId]=nil elseif timestamp-(record.lastSent or 0)>=PAIR_RETRY then queueConfirmation(record.peer,record)end end for peerId,bucket in pairs(routes)do local kept={}for _,candidate in ipairs(routeBucket(peerId).candidates)do if candidate.expires>timestamp then kept[#kept+1]=candidate end end bucket.candidates=kept if#kept==0 and not activeLink(config(),peerId)then routes[peerId],routesDirty=nil,true end end for peerId,edge in pairs(autoEdges)do if edge.expires<=timestamp then autoEdges[peerId],routesDirty=nil,true;trace(\"routing\",\"mesh_edge_expired\",{peer=peerId})end end for key,seenAt in pairs(meshSeen)do if seenAt+ROUTE_TTL<=timestamp then meshSeen[key]=nil end end for peerId,offer in pairs(meshOffers)do if offer.expires<=timestamp then meshOffers[peerId]=nil end end for requestId,seenAt in pairs(seenPackets)do if seenAt+ROUTE_TTL<=timestamp then seenPackets[requestId]=nil end end for requestId,route in pairs(reverseRoutes)do if route.expires<=timestamp then reverseRoutes[requestId]=nil end end boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)pruneRouteBuckets(timestamp)ensureMeshEnrollment(timestamp)meshBeacon(timestamp)probeLinks(timestamp)advertiseRoutes(false)end function M.peers()local out,value,seen={},config(),read(SEEN_PATH,{})for peerId,peer in pairs(value.peers)do out[#out+1]={id=peerId,label=peer.label or(seen[peerId]and seen[peerId].label),role=peer.role or\"operator\",mode=peer.mode or\"peer\",master=peer.master==true,masterId=peer.masterId,direct=true,active=activePeer(value,peerId)~=nil,rekeyRequired=peer.rekeyRequired==true or peer.protocol~=2,health=linkState(peerId),auto=false,}end for peerId,edge in pairs(autoEdges)do if not value.peers[peerId]and edge.expires>now()then out[#out+1]={id=peerId,label=edge.label or(seen[peerId]and seen[peerId].label),role=\"mesh\",mode=\"peer\",direct=true,auto=true,active=true,health=linkState(peerId)}end end for peerId in pairs(routes)do if not value.peers[peerId]and not autoEdges[peerId]then local route=primaryCandidate(peerId,value,false)if route then out[#out+1]={id=peerId,label=route.label or(seen[peerId]and seen[peerId].label),role=\"routed\",mode=route.mode or\"peer\",masterId=route.masterId,routed=true,hops=route.hops,next=route.next,health=linkState(route.next),alternates=#routeBucket(peerId).candidates-1}end end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.directPeers()local out={}for _,peer in ipairs(M.peers())do if peer.direct and peer.active then out[#out+1]=peer end end return out end function M.seenPeers()local out={}for peerId,item in pairs(read(SEEN_PATH,{}))do if not item.seen or item.seen+DISCOVERY_TTL*2>now()then out[#out+1]={id=peerId,label=item.label,seen=item.seen,session=item.session}end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.routeStatus(target)local value,out=config(),{}local function row(peerId)local selected=primaryCandidate(peerId,value,false)if not selected then return end local health=healthFor(selected.next)local alternates={}for _,candidate in ipairs(validCandidates(peerId,value))do if tostring(candidate.next)~=tostring(selected.next)then local state=healthFor(candidate.next)alternates[#alternates+1]={next=candidate.next,hops=candidate.hops,kind=candidate.kind or\"route\",health=state.state,loss=state.loss or 0,rtt=state.rtt,distance=state.lastDistance}end end table.sort(alternates,compareCandidates)while#alternates>ROUTE_CANDIDATE_LIMIT-1 do table.remove(alternates)end out[#out+1]={id=tostring(peerId),label=selected.label,next=selected.next,hops=selected.hops,kind=selected.kind or\"route\",health=health.state,loss=health.loss or 0,rtt=health.rtt,distance=health.lastDistance,selectedAt=routeBucket(peerId).changedAt,reason=routeBucket(peerId).reason,alternates=alternates,}end if target then row(tostring(target))else local ids,seen={},{}for peerId in pairs(value.peers)do ids[#ids+1],seen[peerId]=peerId,true end for peerId in pairs(autoEdges)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end for peerId in pairs(routes)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)for _,peerId in ipairs(ids)do row(peerId)end end return out end function M.statusSnapshot()return{protocol=2,transport=M.transportStatus(),discovery=M.discoveryStatus(),peers=M.peers(),routes=M.routeStatus(),trace=M.transportTrace(),controller=M.controller()}end function M.controller()return controller()end function M.isDirectController(from,packet)return tostring(from)==tostring(controller())and type(packet)==\"table\"and tostring(packet.origin or\"\")==tostring(from)end function M.setController(value)assert(tonumber(value),\"controller must be a computer ID\")local saved=config();saved.controller=tostring(value);save(saved);routesDirty=true audit.log(\"local\",\"jobs.controller\",{controller=saved.controller})return saved.controller end function M.request(target,typeName,body,options)if type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid request type\"end local destination=tostring(target)local value=config()if not primaryCandidate(destination,value,options and options.safe==true)then return false,\"peer is unreachable, degraded, or requires rekey\"end return send(destination,{type=typeName,body=body or{},origin=id(),routeSafe=options and options.safe==true,balanceSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId()})end function M.reply(request,typeName,body,options)if type(request)~=\"table\"or type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid reply\"end local requestId,destination=request.request_id,tostring(request.origin or\"\")local reverse=type(requestId)==\"string\"and reverseRoutes[requestId]or nil if destination==\"\"or not reverse or reverse.expires<=now()or reverse.origin~=destination then return false,\"reverse reply route is unavailable\"end return send(destination,{type=typeName,body=body or{},origin=id(),destination=destination,reply_to=requestId,routeSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId(),},reverse.previous)end function M.offer()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.accept()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.discover()return broadcast({type=\"discover_query\"})end rejectPacket=function(reason,packet,channel,distance)transport.rejected=transport.rejected+1 trace(\"transport\",\"packet_rejected\",{reason=reason,type=type(packet)==\"table\"and packet.type or nil,channel=channel,distance=distance,from=type(packet)==\"table\"and packet.from or nil})end local function handleDiscovery(packet,channel,distance)local from=tostring(packet.from)if packet.type==\"discover_cancel\"and isBroadcast(packet.to)then discovered[tostring(packet.session)]=nil trace(\"discovery\",\"cancel_received\",{from=from,distance=distance})return end if packet.type==\"discover_query\"and isBroadcast(packet.to)and discovery and discovery.state==\"hosting\"then discoveryAnnouncement()trace(\"discovery\",\"query_answered\",{from=from,distance=distance})return end if packet.type==\"discover\"and isBroadcast(packet.to)and from~=id()then if type(packet.session)~=\"string\"or#packet.session<16 or type(packet.tag)~=\"string\"or#packet.tag~=64 then return rejectPacket(\"malformed_discovery\",packet,channel,distance)end local expires=tonumber(packet.expires)or(now()+DISCOVERY_TTL)discovered[packet.session]={session=packet.session,from=from,tag=packet.tag,label=tostring(packet.label or(\"Computer \"..from)):sub(1,128),mode=packet.mode==\"master\"and\"master\"or\"peer\",master=packet.master==\"joiner\"and\"joiner\"or\"initiator\",expires=math.min(expires,now()+DISCOVERY_TTL)}remember(from,packet.label,{session=packet.session})trace(\"discovery\",\"announcement_received\",{from=from,label=packet.label,distance=distance})if discovery and discovery.state==\"searching\"and password.constantTimeEqual(packet.tag,phraseTag(discovery.phrase,packet.session,from))then local value,existing=config(),config().peers[from]if existing and not existing.rekeyRequired then markRejected(\"computer is already a direct peer\")elseif routes[from]and not existing then markRejected(\"computer is already a routed network member\")else discovery.state,discovery.candidate,discovery.error=\"candidate\",discovered[packet.session],nil setLast(\"candidate\",\"matching computer found; confirm pairing\")trace(\"discovery\",\"candidate_found\",{from=from,label=packet.label,distance=distance})end end return end end local function handlePairJoin(packet,distance)if not discovery or discovery.state~=\"hosting\"or packet.session~=discovery.id then return end local from=tostring(packet.from)local value,existing=config(),config().peers[from]if(existing and not existing.rekeyRequired)or(routes[from]and not existing)then handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"already_network_member\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"already_network_member\"})return end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 or type(packet.proof)~=\"string\"or#packet.proof~=64 then return rejectPacket(\"malformed_pair_join\",packet,nil,distance)end local expected=joinProof(discovery.phrase,discovery.id,id(),from,packet.nonce)if not password.constantTimeEqual(expected,packet.proof)then discovery.failures=(discovery.failures or 0)+1 if discovery.failures>=5 then markRejected(\"too many invalid pairing proofs\")end handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"phrase_mismatch\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"phrase_mismatch\"})return end local masterId=discovery.mode==\"master\"and(discovery.masterSide==\"initiator\"and id()or from)or\"\"local key,keyErr=linkKey(discovery.phrase,discovery.id,id(),from,packet.nonce)if not key then return markRejected(keyErr)end persistPair(from,key,{mode=discovery.mode,label=packet.label},masterId)local record={id=discovery.id,peer=from,joinNonce=packet.nonce,mode=discovery.mode,masterId=masterId,label=label(),expires=now()+DISCOVERY_TTL}record.confirmProof=confirmProof(discovery.phrase,record.id,id(),from,record.joinNonce,record.mode,record.masterId)discovery=nil setLast(\"paired\",\"awaiting pairing acknowledgement\")trace(\"discovery\",\"pair_join_verified\",{from=from,distance=distance})return queueConfirmation(from,record)end local function handlePairConfirm(packet,distance)if not discovery or discovery.state~=\"confirming\"or not discovery.candidate or packet.session~=discovery.candidate.session then return end local from=tostring(packet.from)if from~=tostring(discovery.candidate.from)or packet.nonce~=discovery.joinNonce then return rejectPacket(\"unexpected_pair_confirmation\",packet,nil,distance)end local expected=confirmProof(discovery.phrase,packet.session,from,id(),discovery.joinNonce,packet.mode==\"master\"and\"master\"or\"peer\",packet.master or\"\")if not password.constantTimeEqual(expected,packet.proof or\"\")then return markRejected(\"pair confirmation proof did not match\")end local key,err=linkKey(discovery.phrase,packet.session,from,id(),discovery.joinNonce)if not key then return markRejected(err)end persistPair(from,key,{mode=packet.mode,label=packet.label},packet.master)local sessionId=packet.session discovery=nil setLast(\"paired\",\"paired with \"..tostring(packet.label or from))handshake(from,{type=\"pair_ack\",session=sessionId,proof=password.hmacSha256(key,\"ceetos/pair/ack/v2|\"..sessionId)})trace(\"discovery\",\"pair_confirmed\",{from=from,distance=distance})return true end local function handlePairAck(packet)local record=confirmations[packet.session]if not record or tostring(record.peer)~=tostring(packet.from)then return end local value,peer=config(),activePeer(config(),record.peer)if not peer then return end local expected=password.hmacSha256(peer.key,\"ceetos/pair/ack/v2|\"..packet.session)if password.constantTimeEqual(expected,packet.proof or\"\")then confirmations[packet.session]=nil setLast(\"paired\",\"paired with \"..tostring(record.peer))routesDirty=true trace(\"discovery\",\"pair_acknowledged\",{from=packet.from})end end local function handleRouteAdvertisement(from,packet)local body=packet.body if type(body)~=\"table\"or type(body.sequence)~=\"number\"or type(body.members)~=\"table\"or(body.withdrawals~=nil and type(body.withdrawals)~=\"table\")then return rejectPacket(\"malformed_route_advertisement\",packet)end local key=tostring(from)M._routeSequences=M._routeSequences or{}if(M._routeSequences[key]or-1)>=body.sequence then return end M._routeSequences[key]=body.sequence local value,changed,count=config(),false,0 if body.controller and not value.controller then value.controller,changed=tostring(body.controller),true end local announced={}for advertisedId,meta in pairs(body.members)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local peerId=tostring(advertisedId)announced[peerId]=true if peerId~=id()and peerId~=key and type(meta)==\"table\"then local hops=math.floor(tonumber(meta.hops)or 0)+1 if hops>1 and hops<=PACKET_TTL and type(meta.label)~=\"table\"and type(meta.mode)~=\"table\"then local bucket,found=routeBucket(peerId),nil for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)==key then found=candidate;break end end if found then local metadataChanged=found.hops~=hops or found.label~=meta.label or found.mode~=meta.mode or tostring(found.masterId or\"\")~=tostring(meta.masterId or\"\")or found.kind~=(meta.kind or\"route\")found.hops,found.expires=hops,now()+ROUTE_TTL found.label,found.mode,found.masterId,found.kind=meta.label,meta.mode,meta.masterId,meta.kind or\"route\"if metadataChanged then changed=true end else bucket.candidates[#bucket.candidates+1]={next=key,hops=hops,expires=now()+ROUTE_TTL,label=type(meta.label)==\"string\"and meta.label:sub(1,128)or nil,mode=meta.mode==\"master\"and\"master\"or\"peer\",masterId=meta.masterId and tostring(meta.masterId)or nil,kind=meta.kind==\"mesh\"and\"mesh\"or\"route\"}table.sort(bucket.candidates,compareCandidates)while#bucket.candidates>ROUTE_CANDIDATE_LIMIT do table.remove(bucket.candidates)end changed=true end end end end local withdrawals=body.withdrawals or{}for _,withdrawnId in pairs(withdrawals)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local bucket=routes[tostring(withdrawnId)]if bucket and type(bucket.candidates)==\"table\"then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end if body.full==true then for peerId,bucket in pairs(routes)do if type(bucket.candidates)==\"table\"and not announced[tostring(peerId)]then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end end if changed then if value.controller then save(value)end;routesDirty=true;trace(\"routing\",\"route_table_updated\",{from=from})end end local function handleProbe(from,packet)local token=type(packet.body)==\"table\"and packet.body.token if type(token)~=\"string\"or#token<16 or#token>128 then return rejectPacket(\"malformed link probe\",packet)end touchLink(from,nil,\"probe\")return send(from,{type=\"mesh_probe_ack\",body={token=token},request_id=newRequestId()},from)end local function handleProbeAck(from,packet)local health,token=healthFor(from),type(packet.body)==\"table\"and packet.body.token if not health.awaiting or token~=health.probeToken then return rejectPacket(\"unexpected link probe acknowledgement\",packet)end local sample=math.max(0,now()-(health.lastProbe or now()))health.rtt=health.rtt and math.floor((health.rtt*3+sample)/4)or sample health.awaiting,health.misses,health.probeToken=false,0,nil touchLink(from,health.lastDistance,\"probe_ack\")end function M.handle(event)if event[1]~=\"modem_message\"then return end local channel,packet,distance=event[3],event[5],event[6]local expected=false for _,item in ipairs(transport.channels or{})do if channel==item then expected=true;break end end if not expected then return rejectPacket(\"unexpected_channel\",packet,channel,distance)end transport.lastReceive,transport.lastDistance=now(),distance if type(packet)~=\"table\"then return rejectPacket(\"packet_not_table\",packet,channel,distance)end if packet.protocol==PUBLIC_UPDATE_PROTOCOL then if channel~=DISCOVERY_CHANNEL or not PUBLIC_UPDATE_TYPES[packet.type]or type(packet.from)~=\"string\"and type(packet.from)~=\"number\"or not(isForUs(packet.to)or isBroadcast(packet.to))then return rejectPacket(\"invalid_public_update_packet\",packet,channel,distance)end local encoded,encodeErr=canonical(packet.body or{})if not encoded then return rejectPacket(\"invalid_public_update_body:\"..tostring(encodeErr),packet,channel,distance)end trace(\"transport\",\"public_update_received\",{type=packet.type,from=packet.from,distance=distance,bytes=#encoded})if M.publicHandler then return M.publicHandler(packet,distance)end return end local discoveryPacket=packet.type==\"discover\"or packet.type==\"discover_query\"or packet.type==\"discover_cancel\"local handshakePacket=packet.type==\"pair_join\"or packet.type==\"pair_confirm\"or packet.type==\"pair_ack\"or packet.type==\"pair_reject\"local meshPacketType=packet.type==\"mesh_beacon\"or packet.type==\"mesh_edge_offer\"or packet.type==\"mesh_edge_accept\"if discoveryPacket then if packet.protocol~=PROTOCOL or channel~=DISCOVERY_CHANNEL then return rejectPacket(\"invalid_discovery_transport\",packet,channel,distance)end return handleDiscovery(packet,channel,distance)end if handshakePacket then if not isForUs(packet.to)then return end if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid_handshake_transport\",packet,channel,distance)end if packet.type==\"pair_join\"then return handlePairJoin(packet,distance)elseif packet.type==\"pair_confirm\"then return handlePairConfirm(packet,distance)elseif packet.type==\"pair_ack\"then return handlePairAck(packet)elseif packet.type==\"pair_reject\"and discovery then markRejected(\"pairing rejected: \"..tostring(packet.reason or\"remote peer rejected it\"));return end return end if meshPacketType then if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid mesh transport\",packet,channel,distance)end if packet.type~=\"mesh_beacon\"and not isForUs(packet.to)then return end return handleMeshPacket(packet,distance)end if not isForUs(packet.to)then return end local value=config()local valid,peerOrReason=verifyPacket(packet,value)if not valid then return rejectPacket(peerOrReason,packet,channel,distance)end local peer,from=peerOrReason,tostring(packet.from)if packet.confidential==true then local opened,openErr=openBody(peer,packet)if not opened then return rejectPacket(openErr or\"could not open confidential packet\",packet,channel,distance)end packet.body=opened end touchLink(from,distance,\"authenticated_packet\")if autoEdges[from]then autoEdges[from].expires=now()+ROUTE_TTL end trace(\"routing\",\"packet_received\",{type=packet.type,from=from,destination=packet.destination,distance=distance})if packet.type==\"mesh_enroll\"then return acceptEnrollment(from,peer,packet)end if packet.type==\"mesh_probe\"then return handleProbe(from,packet)end if packet.type==\"mesh_probe_ack\"then return handleProbeAck(from,packet)end if packet.type==\"route_advertise\"then return handleRouteAdvertisement(from,packet)end if packet.reply_to and packet.destination and tostring(packet.destination)~=id()then local reverse=reverseRoutes[packet.reply_to]if not reverse or reverse.expires<=now()or reverse.origin~=tostring(packet.destination)then return rejectPacket(\"reverse reply route unavailable\",packet,channel,distance)end local requestId=tostring(packet.request_id or\"\")if seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 trace(\"routing\",\"reverse_reply_forwarded\",{from=from,to=reverse.previous,type=packet.type})return send(packet.destination,packet,reverse.previous)end if packet.destination and tostring(packet.destination)~=id()then local requestId=tostring(packet.request_id or\"\")if requestId==\"\"or seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 return send(packet.destination,packet)end local requestId=tostring(packet.request_id or\"\")if requestId==\"\"then return rejectPacket(\"missing request ID\",packet,channel,distance)end if seenPackets[requestId]then return trace(\"routing\",\"destination_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end packet.authenticatedHop,packet.originVerified=from,false if M.handler then return M.handler(from,peer,packet)end end return M",
  ["ceetos/lib/network_ipc.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local ROOT=\"/ceetos/data/network-ipc\"local COMMANDS=ROOT..\"/commands\"local RESULTS=ROOT..\"/results\"local function ensure(path)if not fs.exists(path)then fs.makeDir(path)end end local function safeId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=160 end local function path(directory,requestId)return fs.combine(directory,requestId..\".lua\")end function M.submit(request)if type(request)~=\"table\"or not safeId(request.id)then return false,\"invalid IPC request ID\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local target=path(COMMANDS,request.id)if fs.exists(target)then return false,\"IPC request already exists\"end return store.write(target,request)end function M.take()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local names=fs.list(COMMANDS)table.sort(names)for _,name in ipairs(names)do local requestId=name:match(\"^([%w_%-%.]+)%.lua$\")if requestId and safeId(requestId)then local target=fs.combine(COMMANDS,name)store.invalidate(target)local request=store.readFresh(target,nil)fs.delete(target)if type(request)==\"table\"and request.id==requestId then return request end end end end function M.reply(requestId,value)if not safeId(requestId)or type(value)~=\"table\"then return false,\"invalid IPC result\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)return store.write(path(RESULTS,requestId),value)end function M.poll(requestId,consume)if not safeId(requestId)then return nil,\"invalid IPC request ID\"end local target=path(RESULTS,requestId)if not fs.exists(target)then return nil end local handle=fs.open(target,\"r\")if not handle then return nil end local raw=handle.readAll()handle.close()local ok,result=pcall(textutils.unserialise,raw)if not ok or type(result)~=\"table\"or result.id~=requestId then return nil,\"invalid IPC result\"end if consume then fs.delete(target)end return result end function M.prune(limit)ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)limit=math.max(1,math.floor(tonumber(limit)or 32))local names={}for _,name in ipairs(fs.list(RESULTS))do if name:match(\"^[%w_%-%.]+%.lua$\")then names[#names+1]=name end end table.sort(names)while#names>limit do fs.delete(fs.combine(RESULTS,table.remove(names,1)))end end function M.status()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local function count(directory)local total=0 for _,name in ipairs(fs.list(directory))do if name:match(\"^[%w_%-%.]+%.lua$\")then total=total+1 end end return total end return{commands=count(COMMANDS),results=count(RESULTS)}end return M",
  ["ceetos/lib/auth_client.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local networkIpc=require(\"ceetos.lib.network_ipc\")local M={}local REPLIES=\"/ceetos/data/auth-replies.lua\"local sequence=0 local function now()return os.epoch(\"utc\")end local function authority()store.invalidate(\"/ceetos/data/auth-authority.lua\")local value=store.read(\"/ceetos/data/auth-authority.lua\",nil)return type(value)==\"table\"and value.active==true and value or nil end local function requestId(kind)sequence=sequence+1 return table.concat({\"auth\",kind,tostring(os.getComputerID()),tostring(now()),tostring(sequence)},\"-\")end local function take(id)store.invalidate(REPLIES)local replies=store.read(REPLIES,{})local row=replies[id]if row then replies[id]=nil;store.write(REPLIES,replies)end return row end function M.receive(body)if type(body)~=\"table\"or type(body.request_id)~=\"string\"or#body.request_id>160 then return false,\"invalid authority reply\"end local replies=store.read(REPLIES,{})replies[body.request_id]={ok=body.ok==true,result=body.result,error=body.error,at=now()}local rows={}for id,row in pairs(replies)do rows[#rows+1]={id=id,at=tonumber(row.at)or 0}end table.sort(rows,function(a,b)return a.at>b.at end)while#rows>32 do replies[table.remove(rows).id]=nil end return store.write(REPLIES,replies)end local function send(typeName,body,timeout)local server=authority()if not server then return nil,\"no Auth Server is reachable\"end local id=body.request_id or requestId(typeName)body.request_id=id local command={id=\"auth-\"..id,action=\"auth_send\",target=server.id,type=typeName,body=body}local ok,err=networkIpc.submit(command)if not ok then return nil,err or\"could not reach CeetOS network service\"end local deadline=now()+(timeout or 6000)while now()<deadline do local ack=networkIpc.poll(command.id,true)if ack and ack.ok~=true then return nil,ack.error or\"Auth Server request was not sent\"end local reply=take(id)if reply then return reply.ok and reply.result or nil,reply.error or\"Auth Server rejected request\"end sleep(0.05)end return nil,\"Auth Server did not respond\"end local function loginProof(verifier,server,request,challenge,expires)return password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(os.getComputerID()),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.login(name,plainPassword)end local request=requestId(\"begin\")local begin,beginErr=send(\"auth_login_begin\",{request_id=request,username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=loginProof(verifier,begin.authority,request,begin.challenge,begin.expires)local result,proofErr=send(\"auth_login_proof\",{request_id=request,username=name,node=tostring(os.getComputerID()),challenge=begin.challenge,proof=proof})if not result then return false,proofErr end local auth=require((\"ceetos.lib.auth\"))local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require((\"ceetos.lib.auth\"))local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.mutate(action,fields)end local current,server=auth.refreshSession(),authority()if not current or not current.central or not server then return false,\"an Auth Server login is required\"end local result,err=send(\"auth_mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end return M",
  ["ceetos/lib/telemetry.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/config.lua\"local activity=\"desktop\"local function text(value,limit)if type(value)~=\"string\"then return nil end value=value:gsub(\"[%z\\1-\\31\\127]\",\" \")if value==\"\"then return nil end return value:sub(1,limit)end local function config()local value=store.read(PATH,{})if type(value)~=\"table\"then value={}end if value.telemetry==nil then value.telemetry=true store.write(PATH,value)end return value end function M.setEnabled(value)assert(type(value)==\"boolean\",\"telemetry state must be boolean\")require(\"ceetos.lib.auth\").require(\"admin\")local valueForSave=config()valueForSave.telemetry=value return store.write(PATH,valueForSave)end function M.status()return config().telemetry==true end function M.configuration()return{enabled=M.status()}end function M.markActivity(value)activity=text(value,48)or activity return activity end function M.activity()return activity end function M.snapshot(currentActivity)if currentActivity then M.markActivity(currentActivity)end local data={ts=os.epoch(\"utc\"),id=os.getComputerID(),label=text(os.getComputerLabel(),96),activity=activity,}if turtle and type(turtle.getFuelLevel)==\"function\"then local ok,fuel=pcall(turtle.getFuelLevel)if ok and type(fuel)==\"number\"then data.fuel=fuel end end if gps and type(gps.locate)==\"function\"then local ok,x,y,z=pcall(gps.locate,0.2)if ok and type(x)==\"number\"and type(y)==\"number\"and type(z)==\"number\"then data.gps={x=x,y=y,z=z}end end return data end return M",
  ["ceetos/lib/cloud.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local M={}M.PATH=\"/ceetos/data/cloud.lua\"M.MAX_BODY=48*1024 M.MAX_RESPONSE=64*1024 M.DEFAULTS={auth=\"https://auth.ceet.uk\",recipe=\"https://recipe.ceet.uk\",dashboard=\"https://dash.ceet.uk\",}local function now()return os.epoch(\"utc\")end local function validUrl(value)if type(value)~=\"string\"or#value>160 then return false end return value:match(\"^https://[%w%-%.]+%.ceet%.uk$\")~=nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_.%-]+$\")~=nil and#value<=96 end local function copy(value)local out={}for key,item in pairs(value or{})do out[key]=item end return out end local function normalise(value)value=type(value)==\"table\"and value or{}local urls=type(value.urls)==\"table\"and value.urls or{}local result={schema=1,enabled=value.enabled==true,urls={auth=validUrl(urls.auth)and urls.auth or M.DEFAULTS.auth,recipe=validUrl(urls.recipe)and urls.recipe or M.DEFAULTS.recipe,dashboard=validUrl(urls.dashboard)and urls.dashboard or M.DEFAULTS.dashboard,},node=type(value.node)==\"table\"and copy(value.node)or nil,}if result.node and(not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 or#result.node.secret>192)then result.node=nil end return result end function M.load()store.invalidate(M.PATH)return normalise(store.read(M.PATH,{}))end function M.save(value)local clean=normalise(value)return store.write(M.PATH,clean)end function M.configure(urls)local value=M.load()urls=type(urls)==\"table\"and urls or{}for key in pairs(M.DEFAULTS)do if urls[key]~=nil then if not validUrl(urls[key])then return false,\"invalid \"..key..\" cloud URL\"end value.urls[key]=urls[key]end end return M.save(value)end function M.clear()local value=M.load();value.enabled,value.node=false,nil return M.save(value)end function M.publicStatus()local value=M.load()return{enabled=value.enabled,enrolled=value.node~=nil,node=value.node and value.node.id or nil,urls=copy(value.urls),profile=profile.id()}end local function readBounded(handle,limit)local chunks,total={},0 while true do local part=handle.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then return nil,\"cloud response is too large\"end chunks[#chunks+1]=part end return table.concat(chunks)end local function json(value)local ok,result=pcall(textutils.unserialiseJSON,value)return ok and type(result)==\"table\"and result or nil end local function canonical(node,timestamp,nonce,method,path,body)local digest=assert(password.sha256(body))return table.concat({\"ceetos-cloud-node-v1\",node,tostring(timestamp),nonce,method,path,digest},\"\\n\")end local nonceCounter=0 local function nonce()nonceCounter=nonceCounter+1 return password.newSalt(\"cloud:\"..tostring(nonceCounter))end local function perform(url,method,path,body,headers)if not http or type(http.post)~=\"function\"then return nil,\"HTTP is unavailable\"end local response local ok,err=pcall(function()response=http.post(url..path,body,headers)end)if not ok or not response then return nil,tostring(err or\"cloud request failed\")end local raw,readErr=readBounded(response,M.MAX_RESPONSE)pcall(response.close)if not raw then return nil,readErr end local decoded=json(raw)if not decoded then return nil,\"cloud returned invalid JSON\"end if decoded.ok==false then return nil,tostring(decoded.error or\"cloud rejected request\"):sub(1,180)end return decoded end function M.enroll(code)if type(code)~=\"string\"or#code<12 or#code>128 or code:find(\"[%z\\1-\\31\\127]\")then return nil,\"invalid enrollment code\"end local value=M.load()local payload=textutils.serialiseJSON({code=code,profile=profile.id(),label=os.getComputerLabel()or(\"Computer \"..tostring(os.getComputerID())),computerId=tostring(os.getComputerID())})if#payload>M.MAX_BODY then return nil,\"enrollment request is too large\"end local result,err=perform(value.urls.auth,\"POST\",\"/v1/nodes/enroll\",payload,{[\"Content-Type\"]=\"application/json\"})if not result then return nil,err end if type(result.node)~=\"table\"or not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 then return nil,\"cloud returned invalid enrollment\"end value.enabled,value.node=true,{id=result.node.id,secret=result.node.secret,enrolledAt=now()}local saved,saveErr=M.save(value)if not saved then return nil,saveErr or\"could not save cloud enrollment\"end return M.publicStatus()end function M.call(service,path,payload)local value=M.load()if not value.enabled or not value.node then return nil,\"cloud node is not enrolled\"end if not M.DEFAULTS[service]or type(path)~=\"string\"or not path:match(\"^/v1/[%w%-%._/]+$\")or#path>128 then return nil,\"invalid cloud endpoint\"end local body=textutils.serialiseJSON(type(payload)==\"table\"and payload or{})if#body>M.MAX_BODY then return nil,\"cloud request is too large\"end local timestamp,requestNonce=now(),nonce()local signature=password.hmacSha256(value.node.secret,canonical(value.node.id,timestamp,requestNonce,\"POST\",path,body))if not signature then return nil,\"could not sign cloud request\"end return perform(value.urls[service],\"POST\",path,body,{[\"Content-Type\"]=\"application/json\",[\"X-CeetOS-Node\"]=value.node.id,[\"X-CeetOS-Time\"]=tostring(timestamp),[\"X-CeetOS-Nonce\"]=requestNonce,[\"X-CeetOS-Signature\"]=signature,})end return M",
  ["ceetos/lib/cloud_sync.lua"] = "local cloud=require(\"ceetos.lib.cloud\")local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local telemetryService=require(\"ceetos.lib.telemetry\")local RECIPE_SERVICE_MODULE=\"ceetos.lib.\"..\"recipe_service\"local M={}local STATE=\"/ceetos/data/cloud-state.lua\"local INTERVALS={telemetry=24*60*60*1000,authority=30000,recipes=30000}local TELEMETRY_RETRIES={15*60*1000,60*60*1000,4*60*60*1000}local function now()return os.epoch(\"utc\")end local function defaults()return{schema=2,revision=0,auth={online=false,next=0},recipe={online=false,next=0,revision=0},telemetry={enabled=nil,next=0,lastSuccess=nil,failures=0,lastError=nil},lastError=nil}end local function state()store.invalidate(STATE)local value=store.read(STATE,defaults())if type(value)~=\"table\"then value=defaults()end if type(value.auth)~=\"table\"then value.auth={}end if type(value.recipe)~=\"table\"then value.recipe={}end if type(value.telemetry)~=\"table\"then value.telemetry={}end for key,fallback in pairs(defaults())do if value[key]==nil then value[key]=fallback end end for key,fallback in pairs(defaults().recipe)do if value.recipe[key]==nil then value.recipe[key]=fallback end end for key,fallback in pairs(defaults().telemetry)do if value.telemetry[key]==nil then value.telemetry[key]=fallback end end return value end local function save(value)value.revision=(tonumber(value.revision)or 0)+1 return store.write(STATE,value)end local function errorState(value,message)value.lastError=tostring(message or\"cloud request failed\"):sub(1,180)end function M.status()local value,cfg=state(),cloud.publicStatus()return{enabled=cfg.enabled,enrolled=cfg.enrolled,node=cfg.node,urls=cfg.urls,authOnline=value.auth.online==true,recipeOnline=value.recipe.online==true,telemetryNext=tonumber(value.telemetry and value.telemetry.next)or 0,telemetryInterval=INTERVALS.telemetry,telemetryEnabled=telemetryService.status(),telemetryLastSuccess=value.telemetry and value.telemetry.lastSuccess or nil,telemetryLastError=value.telemetry and value.telemetry.lastError or nil,telemetryFailures=math.max(0,math.floor(tonumber(value.telemetry and value.telemetry.failures)or 0)),lastSync=value.lastSync,lastError=value.lastError,}end function M.configure(urls)return cloud.configure(urls)end function M.enroll(code)local enrolled,err=cloud.enroll(code)if not enrolled then return nil,err end local value=state()value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=0,0,nil save(value)return enrolled end function M.clear()local ok,err=cloud.clear();if ok then store.write(STATE,defaults())end return ok,err end function M.authOnline()return M.status().authOnline==true end function M.recipeOnline()return M.status().recipeOnline==true end local function cloudAuthority(result)local auth=require(\"ceetos.lib.auth\")if type(result)~=\"table\"or type(result.directory)~=\"table\"then return false,\"invalid cloud authority response\"end local cfg=cloud.publicStatus()local record={id=\"cloud:\"..tostring(cfg.urls.auth),term=tonumber(result.term)or 0,revision=tonumber(result.revision)or 0,directory=result.directory}return pcall(auth.acceptAuthority,record)end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local begin,beginErr=cloud.call(\"auth\",\"/v1/auth/login/begin\",{username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end if type(begin.salt)~=\"string\"or type(begin.workFactor)~=\"number\"or type(begin.challenge)~=\"string\"or type(begin.expires)~=\"number\"then return false,\"invalid cloud login challenge\"end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(begin.authority),tostring(os.getComputerID()),tostring(begin.requestId),tostring(begin.challenge),tostring(begin.expires)},\"|\"))local result,resultErr=cloud.call(\"auth\",\"/v1/auth/login/proof\",{username=name,node=tostring(os.getComputerID()),requestId=begin.requestId,challenge=begin.challenge,proof=proof})if not result then return false,resultErr end local auth=require(\"ceetos.lib.auth\")local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require(\"ceetos.lib.auth\")local current=auth.refreshSession()if not current or not current.central then return false,\"cloud login is required\"end local result,err=cloud.call(\"auth\",\"/v1/auth/mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.recipePlan(item,quantity,stock)if not M.recipeOnline()then return nil,\"cloud Recipe Server is unavailable\"end local result,err=cloud.call(\"recipe\",\"/v1/recipe/plan\",{item=item,quantity=quantity,stock=stock})if not result then return nil,err end return result.plan,result.error end local function telemetry()local snapshot=telemetryService.snapshot()local net=require(\"ceetos.lib.net\")local transport=net.statusSnapshot and net.statusSnapshot().transport or{}snapshot.health={profile=profile.id(),version=require(\"ceetos.lib.version\").string,uptime=os.clock(),freeSpace=fs.getFreeSpace(\"/\"),peers=#(net.peers and net.peers()or{}),healthyLinks=transport and transport.healthyLinks or 0,lastError=M.status().lastError,}local result,err=cloud.call(\"dashboard\",\"/v1/telemetry/ingest\",snapshot)return result~=nil,err end local function syncAuth()if profile.is(\"auth-server\")then local auth=require(\"ceetos.lib.auth\")local snapshot=auth.authoritySnapshot()local pushed,pushErr=cloud.call(\"auth\",\"/v1/auth/replica/merge\",{snapshot=snapshot,source=\"mesh\"})if not pushed then return false,pushErr end if type(pushed.snapshot)==\"table\"then auth.merge(pushed.snapshot,true)end local ok,authErr=cloudAuthority(pushed)if not ok then return false,authErr end return true end local result,err=cloud.call(\"auth\",\"/v1/auth/directory\",{})if not result then return false,err end local ok,authErr=cloudAuthority(result)if not ok then return false,authErr end return true end local function syncRecipes()if not profile.is(\"recipe-server\")then local result,err=cloud.call(\"recipe\",\"/v1/recipe/status\",{})return result~=nil,err end local service=require(RECIPE_SERVICE_MODULE)if type(service.exportOverlay)~=\"function\"then return false,\"recipe export unavailable\"end local payload,exportErr=service.exportOverlay()if not payload then return false,exportErr end local value=state()value.recipe=value.recipe or{revision=0}local result,err=cloud.call(\"recipe\",\"/v1/recipe/replica/merge\",{overlay=payload,baseRevision=math.max(0,math.floor(tonumber(value.recipe.revision)or 0)),})if not result then return false,err end if type(result.overlay)==\"table\"and type(service.replaceOverlay)==\"function\"then local applied,applyErr=service.replaceOverlay(result.overlay)if not applied then return false,applyErr end end return true,nil,math.max(0,math.floor(tonumber(result.revision)or 0))end function M.tick(activity,timestampOverride)local cfg=cloud.publicStatus();if not cfg.enabled or not cfg.enrolled then return false,\"cloud node is not enrolled\"end local value,timestamp=state(),tonumber(timestampOverride)or now()local changed=false if timestamp>=(tonumber(value.auth.next)or 0)then local ok,err=syncAuth();value.auth.online,value.auth.next=ok==true,timestamp+INTERVALS.authority if not ok then errorState(value,err)else value.lastError=nil end changed=true end if timestamp>=(tonumber(value.recipe.next)or 0)then local ok,err,recipeRevision=syncRecipes();value.recipe.online,value.recipe.next=ok==true,timestamp+INTERVALS.recipes if recipeRevision~=nil then value.recipe.revision=recipeRevision end if not ok then errorState(value,err)end changed=true end local telemetryEnabled=telemetryService.status()if not telemetryEnabled then if value.telemetry.enabled~=false or value.telemetry.next~=0 then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=false,0,0,nil changed=true end elseif value.telemetry.enabled~=true then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=true,0,0,nil changed=true elseif timestamp>=(tonumber(value.telemetry.next)or 0)then local ok,err=telemetry()if ok then value.telemetry.next,value.telemetry.lastSuccess,value.telemetry.failures,value.telemetry.lastError=timestamp+INTERVALS.telemetry,timestamp,0,nil else local failures=math.max(0,math.floor(tonumber(value.telemetry.failures)or 0))+1 value.telemetry.failures,value.telemetry.lastError=failures,tostring(err or\"telemetry upload failed\"):sub(1,180)value.telemetry.next=timestamp+(TELEMETRY_RETRIES[failures]or INTERVALS.telemetry)errorState(value,value.telemetry.lastError)end changed=true end if changed then value.lastSync=timestamp;save(value)end return true end return M",
  ["ceetos/lib/version.lua"] = "return{major=0,minor=17,patch=1,string=\"0.17.1\"}",
  ["ceetos/lib/crafting.lua"] = "local M={}M.RECIPE_PACK_MAX_BYTES=64*1024 function M.isLocalPeer(peer,computerId)return tostring(peer)==tostring(computerId)end function M.normalise(rows)local out={}for _,row in pairs(type(rows)==\"table\"and rows or{})do if type(row)==\"table\"then local name,count=row.name or row.id,tonumber(row.count or row.amount or row.quantity or 0)or 0 if type(name)==\"string\"and count>0 then out[name]=(out[name]or 0)+math.floor(count)end end end return out end function M.rows(stock,query,filter,recipes)local output,needle,available={},tostring(query or\"\"):lower(),M.normalise(stock)local names={}for name in pairs(available)do names[name]=true end for name in pairs(type(recipes)==\"table\"and recipes or{})do names[name]=true end for name in pairs(names)do local count=available[name]or 0 local craftable=type(recipes)==\"table\"and recipes[name]~=nil local include=needle==\"\"or name:lower():find(needle,1,true)if filter==\"craftable\"then include=include and craftable elseif filter==\"stocked\"then include=include and count>0 end if include then output[#output+1]={name=name,count=count,craftable=craftable,stocked=count>0}end end table.sort(output,function(a,b)return a.name<b.name end)return output end function M.addToCart(cart,name,count)if type(cart)~=\"table\"or type(name)~=\"string\"or name==\"\"then return nil,\"invalid cart item\"end count=tonumber(count)if not count or count<1 then return nil,\"invalid cart quantity\"end count=math.floor(count)for _,row in ipairs(cart)do if row.name==name then row.count=(tonumber(row.count)or 0)+count;return row end end local row={name=name,count=count}cart[#cart+1]=row return row end function M.cartTotals(cart)local items,quantity=0,0 for _,row in ipairs(type(cart)==\"table\"and cart or{})do items=items+1 quantity=quantity+math.max(0,math.floor(tonumber(row.count)or 0))end return items,quantity end function M.acceptedCount(result,requested)local accepted=tonumber(result)requested=tonumber(requested)if not accepted or not requested or requested<1 then return nil,\"invalid request result\"end accepted=math.floor(accepted)if accepted<1 then return nil,\"Stock Ticker accepted no items\"end return math.min(accepted,math.floor(requested))end function M.displayRow(name,count,width)local suffix=\" x\"..tostring(count)width=math.max(#suffix+1,math.floor(tonumber(width)or#suffix+1))if#name+#suffix<=width then return name..suffix end return name:sub(1,math.max(1,width-#suffix-1))..\"…\"..suffix end function M.cancellationStatus(issued)return issued and\"cancelled-unconfirmed\"or\"cancelled\"end local function validReference(name)return type(name)==\"string\"and name:match(\"^#?[%w_.:%-]+$\")~=nil and not name:find(\"##\",1,true)end local function recipeIngredients(recipe,batches)local combined={}local declared=type(recipe.ingredients)==\"table\"and#recipe.ingredients>0 if declared then for _,ingredient in ipairs(recipe.ingredients)do local name=type(ingredient)==\"table\"and ingredient.id or ingredient local count=type(ingredient)==\"table\"and tonumber(ingredient.count or 1)or 1 if validReference(name)then combined[name]=(combined[name]or 0)+batches*math.max(1,math.floor(count or 1))end end else for slot=1,9 do local name=recipe.grid and recipe.grid[slot]if name and name~=false then combined[name]=(combined[name]or 0)+batches end end end local out={}for name,count in pairs(combined)do out[#out+1]={name=name,count=count}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.recipeInputs(recipe,batches)return recipeIngredients(recipe or{},math.max(1,math.floor(tonumber(batches)or 1)))end function M.validateRecipes(recipes)if type(recipes)~=\"table\"then return nil,\"recipes must return a table\"end for name,recipe in pairs(recipes)do if type(name)~=\"string\"or not name:match(\"^[%w_.:%-]+$\")or type(recipe)~=\"table\"then return nil,\"invalid recipe item id\"end if type(recipe.alternatives)==\"table\"then if#recipe.alternatives<1 then return nil,\"recipe \"..name..\" has no alternatives\"end for _,alternative in ipairs(recipe.alternatives)do local valid,err=M.validateRecipes({[name]=alternative});if not valid then return nil,err end end else if recipe.mode~=\"crafting\"then return nil,\"recipe \"..name..\" must use mode = crafting\"end if type(recipe.address)~=\"string\"or recipe.address==\"\"or#recipe.address>64 then return nil,\"recipe \"..name..\" requires an address\"end local crafter=recipe.address==\"Crafter\"if crafter and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires a 9-slot grid for Crafter\"end if not crafter and type(recipe.ingredients)~=\"table\"and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires ingredients\"end local output=tonumber(recipe.output or 1)if not output or output<1 or output~=math.floor(output)then return nil,\"invalid output for \"..name end for slot=1,9 do local value=recipe.grid and recipe.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid grid slot in \"..name end end for _,ingredient in ipairs(type(recipe.ingredients)==\"table\"and recipe.ingredients or{})do local id,count=type(ingredient)==\"table\"and ingredient.id or ingredient,type(ingredient)==\"table\"and ingredient.count or 1 if not validReference(id)or not tonumber(count)or tonumber(count)<1 then return nil,\"invalid ingredient in \"..name end end end end return recipes end local function dataParser(source,maximum)if type(source)~=\"string\"then return nil,\"recipe data must be text\"end if#source==0 or#source>(maximum or M.RECIPE_PACK_MAX_BYTES)then return nil,\"recipe data exceeds the 64 KiB import limit\"end local state={source=source,index=1,length=#source,depth=0,nodes=0}local function skip()while state.index<=state.length do local char=state.source:sub(state.index,state.index)if char:match(\"%s\")then state.index=state.index+1 elseif state.source:sub(state.index,state.index+1)==\"--\"then local ending=state.source:find(\"\\n\",state.index+2,true)state.index=ending and ending+1 or state.length+1 else return true end end return true end local function fail(message)return nil,message..\" near byte \"..tostring(state.index)end local function identifier()local name=state.source:match(\"^[%a_][%w_]*\",state.index)if name then state.index=state.index+#name end return name end local parseValue local function parseString()local quote=state.source:sub(state.index,state.index);state.index=state.index+1 local out={}while state.index<=state.length do local char=state.source:sub(state.index,state.index);state.index=state.index+1 if char==quote then return table.concat(out)end if char==\"\\\\\"then local escaped=state.source:sub(state.index,state.index);state.index=state.index+1 local values={n=\"\\n\",r=\"\\r\",t=\"\\t\",[\"\\\\\"]=\"\\\\\",[\"\\\"\"]=\"\\\"\",[\"'\"]=\"'\"}if not values[escaped]then return fail(\"unsupported string escape\")end out[#out+1]=values[escaped]elseif char:byte()<32 then return fail(\"control character in string\")else out[#out+1]=char end end return fail(\"unterminated string\")end local function parseTable()state.depth=state.depth+1 if state.depth>32 then return fail(\"recipe data is nested too deeply\")end state.index=state.index+1 local out,nextIndex,keys={},1,{}skip()while state.index<=state.length and state.source:sub(state.index,state.index)~=\"}\"do state.nodes=state.nodes+1 if state.nodes>4096 then return fail(\"recipe data has too many values\")end local key,value,err local start=state.index if state.source:sub(state.index,state.index)==\"[\"then state.index=state.index+1;key,err=parseValue();if err then return nil,err end skip();if state.source:sub(state.index,state.index)~=\"]\"then return fail(\"missing closing recipe key bracket\")end state.index=state.index+1;skip();if state.source:sub(state.index,state.index)~=\"=\"then return fail(\"missing recipe key assignment\")end state.index=state.index+1;skip();value,err=parseValue();if err then return nil,err end else local named=identifier();skip()if named and state.source:sub(state.index,state.index)==\"=\"then key,state.index=named,state.index+1;skip();value,err=parseValue();if err then return nil,err end else state.index=start;value,err=parseValue();if err then return nil,err end key,nextIndex=nextIndex,nextIndex+1 end end if type(key)~=\"string\"and type(key)~=\"number\"then return fail(\"recipe table key must be text or a number\")end local signature=type(key)..\":\"..tostring(key)if keys[signature]then return fail(\"duplicate recipe table key\")end keys[signature],out[key]=true,value skip();local separator=state.source:sub(state.index,state.index)if separator==\",\"or separator==\";\"then state.index=state.index+1;skip()elseif separator~=\"}\"then return fail(\"expected recipe table separator\")end end if state.source:sub(state.index,state.index)~=\"}\"then return fail(\"unterminated recipe table\")end state.index,state.depth=state.index+1,state.depth-1 return out end parseValue=function()skip();local char=state.source:sub(state.index,state.index)if char==\"{\"then return parseTable()end if char==\"\\\"\"or char==\"'\"then return parseString()end local number=state.source:match(\"^-?%d+\",state.index)if number then state.index=state.index+#number;return tonumber(number)end local name=identifier()if name==\"true\"then return true elseif name==\"false\"then return false elseif name==\"nil\"then return nil elseif name then return fail(\"bare recipe values are not allowed\")end return fail(\"invalid recipe value\")end skip()if identifier()~=\"return\"then return fail(\"recipe data must start with return\")end local value,err=parseValue();if err then return nil,err end skip();if state.index<=state.length then return fail(\"unexpected content after recipe table\")end return value end local function validTags(tags)if tags==nil then return{}end if type(tags)~=\"table\"then return nil,\"recipe tags must be a table\"end local out={}for tag,members in pairs(tags)do local key=tostring(tag):gsub(\"^#\",\"\")if not key:match(\"^[%w_.:%-]+$\")or type(members)~=\"table\"or#members<1 then return nil,\"invalid recipe tag \"..tostring(tag)end out[key]={}for _,member in ipairs(members)do if not validReference(member)or tostring(member):sub(1,1)==\"#\"then return nil,\"invalid member of #\"..key end out[key][#out[key]+1]=member end table.sort(out[key])end return out end function M.validateRecipeGraph(recipes,tags)local tagMap,tagErr=validTags(tags);if not tagMap then return nil,tagErr end local visiting,complete={},{}local function visit(name)if complete[name]then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=recipes[name]if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end if not recipe then return true end visiting[name]=true for _,input in ipairs(recipeIngredients(recipe,1))do local ingredient=input.name local members=ingredient:sub(1,1)==\"#\"and tagMap[ingredient:sub(2)]or{ingredient}for _,member in ipairs(members or{})do if recipes[member]then local ok,err=visit(member);if not ok then return nil,err end end end end visiting[name],complete[name]=nil,true return true end for name in pairs(recipes)do local ok,err=visit(name);if not ok then return nil,err end end return true end function M.parseRecipeOverlay(source)local value,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not value then return nil,err end if type(value)~=\"table\"then return nil,\"recipe overlay must return a table\"end local recipes,tags if value.schema==1 and type(value.recipes)==\"table\"then recipes,tags=value.recipes,value.tags or{}else recipes,tags=value,{}end local valid,validationErr=M.validateRecipes(recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(tags);if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=recipes,tags=tagMap}end function M.parseRecipeFile(source)local overlay,err=M.parseRecipeOverlay(source)return overlay and overlay.recipes or nil,err end function M.parseRecipePack(source)local pack,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not pack then return nil,err end if type(pack)~=\"table\"or pack.schema~=1 or type(pack.recipes)~=\"table\"then return nil,\"recipe pack must return { schema = 1, recipes = { ... } }\"end local valid,validationErr=M.validateRecipes(pack.recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(pack.tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(pack.recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=pack.recipes,tags=tagMap}end function M.recipeEqual(left,right)if type(left)~=\"table\"or type(right)~=\"table\"then return false end if type(left.alternatives)==\"table\"then left=left.alternatives[1]end if type(right.alternatives)==\"table\"then right=right.alternatives[1]end if not left or not right or left.mode~=right.mode or left.kind~=right.kind or left.output~=right.output or left.address~=right.address then return false end for slot=1,9 do if left.grid and right.grid and left.grid[slot]~=right.grid[slot]then return false end end local a,b=recipeIngredients(left,1),recipeIngredients(right,1)if#a~=#b then return false end for index=1,#a do if a[index].name~=b[index].name or a[index].count~=b[index].count then return false end end return true end function M.reviewRecipePack(existing,incoming)local validExisting,existingErr=M.validateRecipes(existing)if not validExisting then return nil,existingErr end local validIncoming,incomingErr=M.validateRecipes(incoming)if not validIncoming then return nil,incomingErr end local rows,counts={},{new=0,unchanged=0,conflict=0,invalid=0}for name,recipe in pairs(incoming)do local prior=existing[name]local status=not prior and\"new\"or(M.recipeEqual(prior,recipe)and\"unchanged\"or\"conflict\")counts[status]=counts[status]+1 rows[#rows+1]={name=name,status=status,incoming=recipe,existing=prior,selected=status==\"new\"}end table.sort(rows,function(a,b)return a.name<b.name end)return{rows=rows,counts=counts}end local function cloneRecipe(recipe)if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end local copy={mode=recipe.mode,kind=recipe.kind,output=recipe.output,address=recipe.address,grid={},ingredients={}}for slot=1,9 do copy.grid[slot]=recipe.grid and recipe.grid[slot]end for _,input in ipairs(recipe.ingredients or{})do copy.ingredients[#copy.ingredients+1]={id=input.id,count=input.count,tag=input.tag}end return copy end function M.mergeRecipePack(existing,review,existingTags,incomingTags)if type(existing)~=\"table\"or type(review)~=\"table\"or type(review.rows)~=\"table\"then return nil,\"invalid recipe import review\"end local merged,imported={},0 for name,recipe in pairs(existing)do merged[name]=cloneRecipe(recipe)end for _,row in ipairs(review.rows)do if row.status==\"new\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 elseif row.status==\"conflict\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 end end local tags={}for name,members in pairs(existingTags or{})do tags[name]=members end for name,members in pairs(incomingTags or{})do tags[name]=members end local valid,err=M.validateRecipes(merged);if not valid then return nil,err end local graphOk,graphErr=M.validateRecipeGraph(merged,tags);if not graphOk then return nil,graphErr end return merged,imported,tags end function M.encodeRecipeFile(recipes,tags)local valid,err=M.validateRecipes(recipes);if not valid then return nil,err end local tagMap,tagsErr=validTags(tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap);if not graphOk then return nil,graphErr end local ok,encoded=pcall(textutils.serialise,{schema=1,recipes=recipes,tags=tagMap},{compact=true})if not ok or type(encoded)~=\"string\"then return nil,\"could not serialise recipes\"end return\"return \"..encoded..\"\\n\"end function M.writeRecipeFile(path,recipes,tags)if type(path)~=\"string\"or path==\"\"then return false,\"invalid recipe file path\"end local raw,encodeErr=M.encodeRecipeFile(recipes,tags);if not raw then return false,encodeErr end local parent=fs.getDir(path);if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary,backup=path..\".new\",path..\".bak\"if fs.exists(temporary)then fs.delete(temporary)end local handle=fs.open(temporary,\"w\");if not handle then return false,\"could not stage recipes\"end handle.write(raw);handle.close()local check=fs.open(temporary,\"r\");local staged=check and check.readAll()or nil;if check then check.close()end if not M.parseRecipeOverlay(staged or\"\")then if fs.exists(temporary)then fs.delete(temporary)end;return false,\"could not validate staged recipes\"end if fs.exists(backup)then fs.delete(backup)end if fs.exists(path)then fs.move(path,backup)end local moved,moveErr=pcall(fs.move,temporary,path)if not moved then if fs.exists(backup)and not fs.exists(path)then fs.move(backup,path)end;if fs.exists(temporary)then fs.delete(temporary)end;return false,tostring(moveErr)end if fs.exists(backup)then fs.delete(backup)end return true end local function selectedRecipe(entry)if type(entry)==\"table\"and type(entry.alternatives)==\"table\"then return entry.alternatives[1]end return entry end local function tagMembers(tags,reference)if reference:sub(1,1)~=\"#\"then return{reference}end local members=tags[reference:sub(2)]if type(members)~=\"table\"or#members==0 then return nil,\"no known members for \"..reference end return members end local function chooseMember(reference,tags,available,recipes)local members,err=tagMembers(tags,reference);if not members then return nil,err end local best for _,member in ipairs(members)do if(available[member]or 0)>0 then return member end if recipes[member]and not best then best=member end end return best,best and nil or(\"no stocked or craftable member for \"..reference)end local function requesterGrid(recipe,resolved,tags,available,recipes)local grid={}for slot=1,9 do local value=recipe.grid and recipe.grid[slot]if type(value)==\"string\"and value:sub(1,1)==\"#\"then local concrete=resolved[value]if not concrete then concrete=select(1,chooseMember(value,tags,available,recipes))end if not concrete then return nil,\"no concrete item available for requester tag \"..value end grid[slot]=concrete else grid[slot]=value end end return grid end function M.plan(recipes,stock,item,quantity,options)quantity=tonumber(quantity)if type(item)~=\"string\"or item==\"\"or not quantity or quantity<1 or quantity~=math.floor(quantity)then return nil,\"invalid item or quantity\"end local valid,errorText=M.validateRecipes(recipes)if not valid then return nil,errorText end options=type(options)==\"table\"and options or{}local available,plan,visiting,tags=M.normalise(stock),{},{},type(options.tags)==\"table\"and options.tags or{}local function requireItem(name,needed)local used=options.forceRoot==true and name==item and 0 or math.min(available[name]or 0,needed)available[name]=(available[name]or 0)-used local missing=needed-used if missing<=0 then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=selectedRecipe(recipes[name])if not recipe then return nil,\"missing recipe for \"..name..\" (need \"..tostring(missing)..\")\"end if recipe.special or not recipe.output or not recipe.address then return nil,\"recipe \"..name..\" is not supported by Crafting Queue\"end visiting[name]=true local batches=math.ceil(missing/recipe.output)local inputs,resolved={},{}for _,ingredient in ipairs(recipeIngredients(recipe,batches))do local concrete,resolveErr=chooseMember(ingredient.name,tags,available,recipes)if not concrete then return nil,resolveErr end inputs[#inputs+1]={name=concrete,count=ingredient.count,source=ingredient.name,tag=ingredient.name:sub(1,1)==\"#\"and ingredient.name or nil}if ingredient.name:sub(1,1)==\"#\"then resolved[ingredient.name]=concrete end local ok,err=requireItem(concrete,ingredient.count)if not ok then return nil,err end end visiting[name]=nil local produced=batches*recipe.output available[name]=(available[name]or 0)+produced-missing local dispatch=recipe.address==\"Crafter\"and\"requester\"or\"package\"if dispatch==\"requester\"and type(recipe.grid)~=\"table\"then return nil,\"Crafter recipe \"..name..\" has no 3x3 grid\"end local grid,gridErr=recipe.grid,nil if dispatch==\"requester\"then grid,gridErr=requesterGrid(recipe,resolved,tags,available,recipes)if not grid then return nil,gridErr end end plan[#plan+1]={name=name,batches=batches,produced=produced,requested=missing,address=recipe.address,kind=recipe.kind,dispatch=dispatch,grid=grid,sourceGrid=recipe.grid,inputs=inputs,}return true end local ok,err=requireItem(item,quantity)return ok and plan or nil,err end function M.validateExecutionPlan(plan)if type(plan)~=\"table\"or#plan<1 or#plan>96 then return nil,\"invalid remote recipe plan\"end for _,step in ipairs(plan)do if type(step)~=\"table\"or not validReference(step.name)or tostring(step.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe output\"end if type(step.address)~=\"string\"or step.address==\"\"or#step.address>64 or step.address:find(\"[%c]\")then return nil,\"invalid remote recipe address\"end if step.dispatch~=\"requester\"and step.dispatch~=\"package\"then return nil,\"invalid remote recipe route\"end if(step.address==\"Crafter\")~=(step.dispatch==\"requester\")then return nil,\"invalid remote recipe executor\"end for _,field in ipairs({\"batches\",\"produced\",\"requested\"})do local value=tonumber(step[field])if not value or value<1 or value~=math.floor(value)or value>65536 then return nil,\"invalid remote recipe quantity\"end end if step.dispatch==\"requester\"then if type(step.grid)~=\"table\"then return nil,\"remote Crafter recipe has no grid\"end for slot=1,9 do local value=step.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid remote recipe grid\"end if type(value)==\"string\"and value:sub(1,1)==\"#\"then return nil,\"remote requester grid contains unresolved tag\"end end end if type(step.inputs)~=\"table\"or#step.inputs>64 then return nil,\"invalid remote recipe inputs\"end for _,input in ipairs(step.inputs)do if type(input)~=\"table\"or not validReference(input.name)or tostring(input.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe input\"end local count=tonumber(input.count)if not count or count<1 or count~=math.floor(count)or count>65536 then return nil,\"invalid remote recipe input quantity\"end if input.source~=nil and not validReference(input.source)then return nil,\"invalid remote recipe input source\"end end end return plan end return M",
  ["ceetos/server.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local net=require(\"ceetos.lib.net\")local audit=require(\"ceetos.lib.audit\")local updater=require(\"ceetos.lib.updater\")local networkIpc=require(\"ceetos.lib.network_ipc\")local version=require(\"ceetos.lib.version\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local authority=profile.is(\"auth-server\")and require((\"ceetos.lib.auth_authority\"))or nil local authClient=require(\"ceetos.lib.auth_client\")local cloudSync=require(\"ceetos.lib.cloud_sync\")local releaseBroker=require(\"ceetos.lib.release_broker\")local function replyIpc(command,ok,result)networkIpc.reply(command.id,{id=command.id,ok=ok==true,result=ok and result or nil,error=ok and nil or tostring(result)})end local function command()local request=networkIpc.take()if not request then return end local ok,result=pcall(function()if request.action==\"server_status\"then return{profile=profile.id(),version=version.string,network=net.statusSnapshot(),authority=authority and authority.status()or auth.authority(),recipes=recipe and recipe.status()or nil}elseif request.action==\"server_discovery_start\"then auth.require(\"admin\");return net.startDiscovery(request.mode or\"peer\",request.master or\"initiator\",request.phrase)elseif request.action==\"server_discovery_join\"then auth.require(\"admin\");return net.joinDiscovery(request.phrase)elseif request.action==\"server_discovery_confirm\"then auth.require(\"admin\");return net.confirmDiscovery()elseif request.action==\"server_update_status\"then return updater.status()elseif request.action==\"server_update_apply\"then auth.require(\"admin\");return updater.prepareApply()elseif request.action==\"broker_status\"then auth.require(\"operator\");return releaseBroker.status()elseif request.action==\"broker_promote\"then auth.require(\"admin\");return releaseBroker.promote(request.ownerKey)elseif request.action==\"broker_revoke\"then auth.require(\"admin\");return releaseBroker.revoke(request.ownerKey)elseif request.action==\"broker_approve\"then auth.require(\"admin\");return releaseBroker.approve(request.session,request.phrase)elseif request.action==\"auth_send\"then local sent,err=net.request(request.target,request.type,request.body or{},{safe=true,confidential=true})if not sent then error(err or\"could not contact Auth Server\")end return true end error(\"unknown protected server command\")end)replyIpc(request,ok and result~=false,ok and result or result)end net.handler=function(from,peer,packet)if packet.type==\"update_query\"or packet.type==\"update_offer\"or packet.type==\"update_chunk_request\"or packet.type==\"update_chunk\"then return updater.authenticatedPacket(from,peer,packet)end if packet.type==\"profile_query\"then return net.reply(packet,\"profile_status\",{profile=profile.id(),version=version.string},{safe=true})end if packet.type==\"recipe_plan_request\"and recipe then return recipe.handle(packet,net)end if packet.type==\"auth_login_begin_result\"or packet.type==\"auth_login_proof_result\"or packet.type==\"auth_mutate_result\"then return authClient.receive(packet.body)end if packet.type==\"auth_seed_request\"then return net.reply(packet,\"auth_seed\",{snapshot=auth.authoritySnapshot(),request_id=packet.body and packet.body.request_id},{safe=true,confidential=true})end if packet.type==\"auth_authority\"then return auth.acceptAuthority(packet.body)end if authority then return authority.handle(from,peer,packet,net)end end net.publicHandler=function(packet,distance)if tostring(packet.type or\"\"):match(\"^broker_\")then return releaseBroker.handle(packet,distance)end return updater.publicPacket(packet,distance)end local function service()net.start()if authority then authority.start()end local tick,update,cloud,advertised=os.startTimer(1),os.startTimer(1),os.startTimer(5),0 while true do local event={os.pullEventRaw()}local ok,err=pcall(net.handle,event)if not ok then audit.log(\"server\",\"network.error\",{error=tostring(err):sub(1,120)})end pcall(command)if event[1]==\"timer\"and event[2]==tick then pcall(net.tick);pcall(releaseBroker.tick);if authority then pcall(authority.tick,net)end if os.epoch(\"utc\")-advertised>=30000 then for _,peer in ipairs(net.peers())do net.request(peer.id,\"profile_status\",{profile=profile.id(),version=version.string},{safe=true})end advertised=os.epoch(\"utc\")end tick=os.startTimer(1)end if event[1]==\"timer\"and event[2]==update then pcall(updater.tick);update=os.startTimer(1)end if event[1]==\"timer\"and event[2]==cloud then pcall(cloudSync.tick);cloud=os.startTimer(5)end end end local function console()shell.run(\"/ceetos/bin/ceetserver.lua\")while true do sleep(1);shell.run(\"/ceetos/bin/ceetserver.lua\")end end local function recoveryHealthProof()local path=\"/ceetos-dev/recovery/transaction.lua\"if not fs.exists(path)then return end local handle=fs.open(path,\"r\")local transaction=handle and textutils.unserialise(handle.readAll())or nil if handle then handle.close()end if type(transaction)~=\"table\"or transaction.state~=\"candidate\"or transaction.expectedVersion~=version.string then return end local temporary=\"/ceetos-dev/recovery/candidate-health.lua.tmp\"local output=fs.open(temporary,\"w\")if output then output.write(textutils.serialise({transaction=transaction.id,version=version.string,profile=profile.id(),at=os.epoch(\"utc\")}))output.close()if fs.exists(\"/ceetos-dev/recovery/candidate-health.lua\")then fs.delete(\"/ceetos-dev/recovery/candidate-health.lua\")end fs.move(temporary,\"/ceetos-dev/recovery/candidate-health.lua\")end end recoveryHealthProof()local function devBridge()local path=\"/ceetos-dev/connection.lua\"while true do if fs.exists(\"/ceetos/bin/ceetdev.lua\")and fs.exists(path)then local handle=fs.open(path,\"r\")local cfg=handle and textutils.unserialise(handle.readAll())or nil if handle then handle.close()end if type(cfg)==\"table\"and type(cfg.url)==\"string\"then local token=type(cfg.token)==\"string\"and cfg.token or\"\"if token~=\"\"then pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url,token,\"--background\")else pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url,\"--background\")end sleep(3)else sleep(5)end else sleep(5)end end end parallel.waitForAny(service,console,devBridge)",
  ["ceetos/bin/ceetserver.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local version=require(\"ceetos.lib.version\")local store=require(\"ceetos.lib.store\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local function draw(message)term.setBackgroundColor(colors.black);term.setTextColor(colors.white);term.clear();term.setCursorPos(1,1)term.setBackgroundColor(colors.blue);term.clearLine();term.setCursorPos(2,1);term.write(\"CeetOS \"..profile.id()..\" server\")term.setBackgroundColor(colors.black);term.setCursorPos(2,3);term.write(\"Version: \"..version.string)local authority=auth.authority()term.setCursorPos(2,4);term.write(authority and(\"Auth authority: \"..authority.id)or\"Auth authority: distributed / waiting\")local current=auth.refreshSession()term.setCursorPos(2,6);term.write(current and(\"Signed in: \"..current.name..\" (\"..current.role..\")\")or\"Not signed in\")term.setTextColor(colors.lightGray);term.setCursorPos(2,8)if not current then term.write(\"L Login  |  E first-time enrolment  |  Backspace refresh\")elseif current.role==\"admin\"then local actions=recipe and\"I import pack  |  P pair  |  U updates  |  B broker\"or\"P pair  |  U updates  |  B broker\"term.write(actions..\"  |  L logout  |  Backspace refresh\")else term.write(\"L logout  |  Backspace refresh\")end if message then term.setTextColor(colors.red);term.setCursorPos(2,10);term.write(tostring(message):sub(1,48))end end local function login()term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Username: \");local user=read()term.setCursorPos(2,13);term.write(\"Password: \");local pass=read(\"*\")local ok,err=auth.login(user,pass);return ok and\"Logged in.\"or err end local function enrol()if#auth.list()>0 or auth.centralActive()then return\"Enrollment is already complete.\"end term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Create local admin password: \")local pass=read(\"*\")if type(pass)~=\"string\"or#pass<8 then return\"Enrollment password must contain at least 8 characters.\"end local ok,err=pcall(auth.bootstrap,pass)return ok and\"Enrollment complete.\"or err end local function importRecipePack(event)if not recipe then return\"This server has no recipe service.\"end if not auth.allowed(\"admin\")then return\"Recipe import requires an admin session.\"end local files=event and event.getFiles and event.getFiles()or nil if type(files)~=\"table\"or#files~=1 or type(files[1].read)~=\"function\"then return\"Drop exactly one data-only recipe pack.\"end local chunks,total={},0 while true do local part=files[1].read(4096)if not part then break end if type(part)~=\"string\"then return\"Dropped recipe pack has invalid data.\"end total=total+#part if total>64*1024 then return\"Recipe pack exceeds 64 KiB.\"end chunks[#chunks+1]=part end local ok,result=recipe.import(table.concat(chunks))if not ok then return tostring(result)end return\"Imported \"..tostring(result.imported or 0)..\" new recipes; conflicts kept.\"end local message while true do draw(message);message=nil local event,code=os.pullEventRaw()if event==\"key\"then local key=keys.getName(code)if key==\"l\"then if auth.refreshSession()then auth.logout();message=\"Logged out.\"else message=login()end elseif key==\"e\"then message=enrol()elseif key==\"backspace\"then elseif key==\"p\"and auth.allowed(\"admin\")then message=\"Use the Peers page on a desktop to pair; server pairing IPC is available to administrators.\"elseif key==\"u\"and auth.allowed(\"admin\")then message=\"Use nx update latest or the desktop Updates page; apply remains local.\"elseif key==\"b\"and auth.allowed(\"admin\")then message=\"Use nx broker status|enable <owner-key>|approve <session> <phrase>.\"elseif key==\"i\"and recipe and auth.allowed(\"admin\")then message=\"Drop one recipe pack into this console.\"end elseif event==\"file_transfer\"then message=importRecipePack(code)end end",
}
local CEETOS_RELEASE_INSTALLER = true
local CEETOS_PROFILE = "router-server"

-- `wget --install` may run inside a deliberately restricted CeetShell child
-- environment. Self-cleaning is optional there: never require the shell API
-- merely to install the runtime.
local args = { ... }
local automated = args[1] == "--ceetos-apply"
local self = shell and shell.getRunningProgram and shell.getRunningProgram()
local cache = "/ceetos-updates/release.lua"
-- A signed release launched directly is retained outside the replaceable
-- runtime tree for verified recovery. Development installers deliberately do
-- not become propagation sources. Do this before removing the downloaded
-- program itself, but avoid copying the cache onto itself during recovery.
if CEETOS_RELEASE_INSTALLER and not automated and self and fs.exists(self) and self ~= cache then
  if not fs.exists("/ceetos-updates") then fs.makeDir("/ceetos-updates") end
  if fs.exists(cache) then fs.delete(cache) end
  pcall(fs.copy, self, cache)
end
if self and self ~= cache and fs.exists(self) then pcall(fs.delete, self) end

local bytes = 0
for _, contents in pairs(files) do bytes = bytes + #contents end
print("CeetOS " .. CEETOS_PROFILE .. " installer (" .. bytes .. " bytes)")
if not automated then
  print("This will replace /ceetos and /startup.lua. Continue? [y/N]")
  if read():lower() ~= "y" then print("Cancelled."); return end
end

local backup, migrate, migrationData = nil, false, {}
-- Public signed installers intentionally do not create an enrolled Cloud node
-- by themselves. A completely fresh computer must obtain its one-use node
-- credential from a nearby, explicitly promoted broker before any runtime is
-- replaced. The tiny temporary module tree is removed on every outcome.
if CEETOS_RELEASE_INSTALLER and not automated and not fs.exists("ceetos") then
  local temporary = "/ceetos-bootstrap"
  if fs.exists(temporary) then fs.delete(temporary) end
  fs.makeDir(temporary); fs.makeDir(temporary .. "/ceetos"); fs.makeDir(temporary .. "/ceetos/lib")
  for _, path in ipairs({ "ceetos/lib/password.lua", "ceetos/lib/mesh_crypto.lua", "ceetos/lib/broker_bootstrap.lua" }) do
    local contents = files[path]
    if not contents then fs.delete(temporary); error("installer is missing bootstrap dependency " .. path, 0) end
    local handle = assert(fs.open(temporary .. "/" .. path, "w")); handle.write(contents); handle.close()
  end
  local oldPath = package.path
  package.path = temporary .. "/?.lua;" .. temporary .. "/?/init.lua;" .. package.path
  local loaded, bootstrap = pcall(require, "ceetos.lib.broker_bootstrap")
  local grant, bootstrapErr
  if loaded then grant, bootstrapErr = bootstrap.enroll(CEETOS_PROFILE) else bootstrapErr = bootstrap end
  package.loaded["ceetos.lib.broker_bootstrap"], package.loaded["ceetos.lib.mesh_crypto"], package.loaded["ceetos.lib.password"] = nil, nil, nil
  package.path = oldPath
  if fs.exists(temporary) then fs.delete(temporary) end
  if not grant then printError(tostring(bootstrapErr or "trusted broker enrollment failed")); return end
  migrationData["cloud.lua"] = textutils.serialize({ schema = 1, enabled = true, urls = grant.urls, node = grant.node })
  migrate = true
  print("Trusted broker enrollment received. Installing signed release...")
end
-- Clean stale full-tree backups from older installers before measuring space.
for _, name in ipairs(fs.list(".")) do
  if name:match("^ceetos%.backup") or name == "ceetos-migrate" then fs.delete(name) end
end
-- Development transactions can be much larger than the runtime. Preserve
-- only the reconnect record; staged payloads, test data, and rollback trees
-- are disposable and must not prevent an install from starting.
for _, name in ipairs({ "staging", "backups", "test-data" }) do
  local path = fs.combine("ceetos-dev", name)
  if fs.exists(path) then fs.delete(path) end
end
if fs.exists("ceetos") then
  if automated then migrate = true else
    print("Migrate saved CeetOS configuration? [Y/n]")
    local choice = read():lower()
    migrate = choice ~= "n" and choice ~= "no"
  end
  -- Copy only durable configuration to a small migration area, then remove
  -- the old tree before writing the new one. This works on nearly-full CC
  -- drives where retaining a complete backup would make installation fail.
  if migrate then
    local durable = { "users.lua", "network.lua", "shares.lua", "config.lua", "owner-service.lua", "seen-peers.lua", "jobs.lua", "job-workers.lua", "crafting-state.lua", "auth-authority.lua", "auth-authority-state.lua", "auth-directory.lua", "auth-session.lua", "cloud.lua", "cloud-state.lua" }
    if CEETOS_PROFILE == "recipe-server" then durable[#durable + 1] = "recipes.lua" end
    for _, name in ipairs(durable) do
      local source = fs.combine("ceetos/data", name)
      if fs.exists(source) then
        local input = fs.open(source, "r")
        if input then migrationData[name] = input.readAll(); input.close() end
      end
    end
  end
  fs.delete("ceetos")
end

for path, contents in pairs(files) do
  local parent = fs.getDir(path)
  if parent ~= "" and not fs.exists(parent) then fs.makeDir(parent) end
  local handle = assert(fs.open(path, "w"))
  handle.write(contents)
  handle.close()
end

if migrate then
  -- Preserve durable configuration, but never preserve an active session,
  -- temporary recovery window, remote result cache, or stale audit entries.
  local durable = { "users.lua", "network.lua", "shares.lua", "config.lua", "owner-service.lua", "seen-peers.lua", "jobs.lua", "job-workers.lua", "crafting-state.lua", "auth-authority.lua", "auth-authority-state.lua", "auth-directory.lua", "auth-session.lua", "cloud.lua", "cloud-state.lua" }
  if CEETOS_PROFILE == "recipe-server" then durable[#durable + 1] = "recipes.lua" end
  for _, name in ipairs(durable) do
    local contents = migrationData[name]
    if contents then
      if not fs.exists("ceetos/data") then fs.makeDir("ceetos/data") end
      local output = assert(fs.open(fs.combine("ceetos/data", name), "w"))
      output.write(contents); output.close()
    end
  end
  print("Saved CeetOS configuration migrated. Please log in again.")
end

-- The installer is intentionally transactional while it runs, but retaining
-- a full tree backup after a successful install quickly exhausts small CC
-- drives. Durable data has already been copied, so remove the old tree.
if automated then
  -- The root startup launcher sees this marker and boots the freshly written
  -- runtime rather than replaying the installer. The runtime verifies its
  -- loaded version before clearing it.
  if not fs.exists("/ceetos-updates") then fs.makeDir("/ceetos-updates") end
  local marker = fs.open("/ceetos-updates/pending.lua", "w")
  if marker then marker.write("return {state='verify',version=" .. "0.17.1" .. ",profile=" .. "\"router-server\"" .. "}"); marker.close() end
  print("CeetOS installed. Rebooting to verify the update.")
  os.reboot()
end
print("CeetOS installed. Reboot to start it.")

-- CEETOS_RELEASE_PAYLOAD_END