-- CeetOS signed release. Generated; do not edit.
-- CEETOS_RELEASE_MANIFEST:{channel="release",profile="auth-server",version="0.16.3",size=387924,digest="beff4894304b48a9eaedf777a50c078f72ca8ee7ab6f5e7c2be654975611ceb6",key_id="auth-server-release-0.16.2",next_key_id="auth-server-release-0.16.3",next_public="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"}
-- CEETOS_RELEASE_SIGNATURE:UxXvfYCn+xzfDvjo7jrUbfaAcusNde31I1OM4YmJR4BUwvFV1Zh1gj0N6oVypif4udgIGe6BntIhyPwjZ+HBv3SWFwg4Zo/3kl3t1oU8ToFQyUMcAx2KdQjdf0doxffgeCnQBhC2AFLURrJgl3xr71yveBb/m0fKISyWDLhLAMmDJDmNrNcTirIQDGUiJ7zpPwKnrMg2s4RzCAKqkZ9v9X82cEbeMz+I5vXkQJUwxvF7sMBe6U+EdOxpyTHbwuEyJqZjDBIx7B/Blp0MRLIvI6vu9P6VMjjv3eCn+kN+D5QQhY8Hqgv8rA12lkS9MhQs71I+3AiB14Y8IjauLo+ODFAazDSKH66r9qUzZ/N7MAMMWMod8qXTTJJdeJzFAmERuZA6/pkcG4jICMSD+DYGJo1/aNkl89xHERac/KsuOKQLH3JNfoUH8AgaTw/hWXSk3TXt7wxK4LMWkTha3xeG2P0/kSXzPorrOcWy+NL8P13WN2qH+OlRDNCOM6QuOQvp53Pm87zaKQvC8pOhssYqVRD+jELrTUl/65wAKqAC2ZiDNqhChgEA6+0TRkArsAmAWKNf5FSBg6jUyRj4uXn/epFqKxxTk8rpOBUsdQ+mmk+FixKFOwlK/avsoRDJd+Ka8oIcv/k+ONIM62Jcv4uCOjyhoczaRj9spbEksPt+4Jdq5uFr0EOJa1WXEsmVQUraL3MXVeQbvpALXFz/ICakPx4Ij93+C+d1+n9C+RYdddGFJ6Qra9mn9/z3fbi/QzpTj/HXpq7w42mey1v1xKyvhnbTHsszGXRKlaUlijGEiQwbPqFbcmN9DmCbpkgPUODKUFpzMaGeMFIk8wj8Yvdx69bxwItyETA89Alk0JdcyfK0+V8escdyviSaAm6BoZpWTO64ZyV7paz74loNB12exdI8Fdly9y1Vk+gkKc4QBTDFfUeex0QmHr6wnnX2Lq9BSC6hmnFCODnY3BaJzpNgjiI811OH1CPirtWaTemRjrNk1Ow4yGYxOOz3MiNDw/vfD2PWUoacXrFzV1FMNJXZUgqEkhTXL5KrVX+1LP+kBqdP1hSh4/cOitC8MfAte8dEU7Xw1Qvl7nJNS7xA8XvTqBf13R4UFFwZ9PjzqRi2koCRZVYWIanWGSUVNYIC9dnfAnDH1F3a8CcBUnzCpdDvPfXu5BJ4o8VNaCK9j9P5IrD19tttgeyEyGEY921TcJbmwLdHOYaB6GvHQzI9vUMkaEoDi9GcOw8U6P+d+CYIkZBXLs7wUFuW6eCJYqUDmi6PZXpjFuXI365PWDs6+zE+KDCb5dzof46fhmOoIykv64FMSfgOi5iscjNRQ4d98Y/Kk6M78Ooc2kHrlZTOM+8n5u1csP7SoGiwlS4RIq4nNi2GKWMIjy0PGT6enffen8F0lV9lIyaTPGd5O9JsCML5E7H7N+L8Z2O4aRaQZbcpOobug7qhBpSRY/ozpLIlF6HE93eRIEU7ZPg3Ouv6fj7nmuOHHm4+n6jj5BJVJwxQNCEoib51lU47RCPY8h644+9SHhZdv54+OaDmPM2aIp6f2Z5tnutbbG1Yd2me3KS4/w8I8OD3I2WtX1u6y6ysq4JvWGueh+f58zqt0g6KnZB+fTQHt9vylkfCq6h/tkvabQUzPwYvIiduFlz2FKk7uWKNVWm6vwG+o5jepW7gezpG/h2WZocf35Wn+2AnuKpW20arzw49nvHSj83Z99dLADCD+BDgMMt+1ckc19970wB2J3/pCI4F9wAV4O1mQzcGGWzmc+brYftIMRhXngkwMUdDNeV0cYbESzbxSRnoBQCVsPPyEIhgHovyEVSddlm0xsmBOuPlzJh1jnYq4ggHm6xfvst8D7uAmqGj/a0dVY4QwuJbjAqJfWq3qQouzo4fSFv6w7oxD40Um+3EPyTJUj9h6uF2B9eEylA83bobYtfZgID6hMT1gNBBfZicXPDlkKIYaOLMCZLZb8fqsfVVzesRMBn/bzJVk2wQd71IBSNlyuvPM5Iq/L2onETobVekXQIQs2K8gJfrYzb6wXa2b3tTZ/Hm7owt+AAlw7DoBMgF8S+4V15z19qrrzvLQR4SN3UbuOVCvWnn/smu9xPxKotjSh668eQo44A0wrZfYBwQOCbzjXftNBpLim9EndywN5glZiQtKPvA7kqhA6p8rSM+gtSu8AtTFS7TpiLmhraQBkYOfRifRmp0ROkqvlvXuRs9OVgcWg4XAXb3uiwJNz7tIR/l8JaU4OCy5mR5o9IySdcx5RhU9d3EIsaSaz7eRBOgbCZZe6vU+8R4is8wAekIm/V0Nm7iw0ryLfLJlZ/7wWbrkP5fadoLuI348JtcEl6kS792CW3bts8BWmKtzntLgFhcAaUVgIuJVA4dbvf5ZMBVxuDKtTrwPghjLiMtAHz7ALIyGE9aZeH58X+z/2CepxnhXe3RBHeX0siRYY28D2ZbwvElOZWK+kgXn+1h2h9Nc4XFC0/GTAXUNlhq8APw3LyBHHoUFcnAOIU2TMNxWfITJBL4xnHuYxSw5sCRazkUr+6TiC4FroLvcw8xrGk7OMQ+JigeuAc3owwWhN6/3L7VSeJfBdNraE7D9FPVNM4ZvNHrahfV8T/I7hbni6xAWKAlFjoc1e77ZLsfRCH50XeFVUzl/dwtY/nqLT7nqYSnLlMbfDbKETK/pfyQCMoIF4PqIOIk5oAm/WLZcuvbxWRLLljSAM4lPx7gWr06DsMEVDfwHr/0ospMgAyh2pTmV9Bcdsor9FFIyhnXNB5Hj3blEbm88349tRlv3fY9Yrko+LnXCUgAF5JxgSMQRVMEM4dxDxvwZR6+tBQXedKFZTSozjaUMQhqDucJIHv4Liov+hhlhnAY29Img8svwSj3+pRtvCmpmARC9EmhfXyb4WiBOPC6q0XzL0K+VT/qsc7wYrV9Uq6ie9dqfVF/bdERE0gzrW38vJTQrOF6wqBCZN6Ap0yZHFXEKl7Oa5ilxAkyHIV0AmzL8V50BrzIQPnFyjZBeBEXalKj6pWnqG06QiR+yUXsE5rV5Ef11x2imhdf0UhXn4o6C995TbA3iuzsNyDnOWJy9BDJOwryPSHdhXVVTAhKp+vUxiJCvT+2QKEgAapcTChD2Ryd7LV3KQkiqPNWGZBTLOlk7IKJcQKQS1HNRcfQ11r2YpOIuSToy2RR29q2huzR9N4uhM1I6tFKx3sVKhUhGuMIczQDWB00XZW8Oc55REnAdIywit7dVG0tYXYfs3/MGuSpbFrk4sH2nvNQKwMut5N11H6rAvKlUBcWGRjaj+5m9q+opt5KyUUMRq4rDgvpFzGXSVsBnVdGTEtZfqY5DGCdnOLF21e8kufBahvZqRiJJTKyT7h6YEGzqV/YhUOoBFRs24Vj+Sam3755jRIlGMaNstbta3TSatx/yZSVJSPayE8+kHixiZuwVROMnQRXf3GCL61q9vtwxEIcIwBse9ZBo32og7lZD8peRmLchT4zK9jxa1WQrgOl9sFnwnWlcyQUmgzBK/5W2vDVi+2uG0FsReNo1MDrSySYImMJoxdo2UgCxzHMEtVgidHkTF9r16aK2RXeYBBl88FK1m1/YX5t4R22bYTZUkpaEesIEjDsyy3/jF9r0S8LAsdGpUlGg14qHOwYjSyLIJis6wn50AQiKnBepb6fRmysIMGAh+QFTpcyBsBb9Zsra/8fYMMMk/tG8KgaoW+qTAzchK3J4+3gpvdJKMs9/hLJQFPWQaAOFpNdjcjaW5YSRrnrXWfbf3GOPSjQKCSLCX9qNvnqXg4K922F1YARephHXV+5ysnlHkcD19Ne371c8KDko6UYNKDoRueuRER0GxdUBc2Ug6vvjOeJkOOCqyzRdZMxFck6bZJAL7hiWRTzb34AGtuBj2BxsL4yO59IfPd6xNaiM3ULEEZ5zXv3OHKTRWt97Jo9OggaoLBVgwdNCTvFNTZLlsZNOVZqUkHiNH3qtOLfEBV4EwI5XaeHs3qz1koRUi0z5LGOyDA8Ree8yRntShSDXnZkPWTMCzZORFEbbp3fapTJRdD7AEaPlVgD5ulIY8Ei7j7Nln1ApIICcHYPBuQmC3VpU3sOAoJsGHfxo/tl87QWifkGavT5lrBmqX7XgM/PLkLCPT9NG0T5CfF+lcz83ZIFPKCMMnS2Ac2D0CPBEDw3Pzns2ptERyslPt2MRz9fBwPzToCzxKNuaIOb7CBcgJe/HjgRXqgm8tLmePK/30ZMO3LgnMjokLdko/IRzx0CahBE6toEzDNFyYUzvbKisDj8dxs7XGwKAwovNx0PxNORjEiEBxUo1R5HLL1XrT5p6UMqWz1Vh5RSHAjWz28/lqu7AP7Oew9dtVl1tCGLe8RfN/h7CXLuKifCLaYtSLrrVgEJzk2wopeGbRLIsOhVCNbEj/FN/m7Np3gOi6t2FALcKbp5MrvhNcn1fcKtDMuy2bv/sd+VRgtPv6rWEySamykL08nQtywQ3skEF1nVB2w/+DVbgnvfC5VuiXY8OsBF5TCIfPvF6UiXtxtj0NvGIY63Q4/t/v7HV34x63zFglxpyXXP2rh4/PIRHGfu9M1ANkX9yDZr8c3gX4ydeNJ26grC+D0q8bY/TGKgYoNReETZ5yDOxyoZW+nQhY17p9mW5mzlq6RmL2/Wcnd5UglHvzQ9OT5PuoBTIR3i7IRkl4PswsZKDVCWkbjLeuiFa6dV9RK8rvbar9hzJeekKLQuyOHH8xXSRXjlEdlYE9kx86TfrCCEgolm1REp4fXzFeU216JUcG0YrsZMuFUi6WCO0rrGzwdv0pvVeFplFh+npgyxmGcY76zh1l0EnlxDsAU+BXbVHB6WDhr6sMkcZqnQeIOF/AzXQ1/pbYLhT6f43S4Q9SYH6athESVYGK9j9uppQ79ILbP+hMwx7kg+Vf+0DxTZp+ruzQETATMzAM6tMvvRaRl8NL8agd864uiKweCAmdR2djmNuSj5wgv4EQTx3maF2gbwGAnTo8fAbNVEF9baSqzq+z8DOaTTPg6K+ai8KSnefuZffxH4Ny/ahLEqNtN8WmGFJe0cTr7B88VaTBtICcteMSxZwIaQyjLFPzEGgwrhwOQNLsUt96bZFUuJRNl9j6IG/kGQdnoFOZP1KsKA7ewul6a5n2as8ZRwxx20RVbFgEakcoDXXiHRdIT9MTRjfQDyZ+CmDd+a9MQSTugAaVpmxLQnGXH0iqcAv1/Lq4N34tK/rYXi+Wqu8dqdw3ICdVU22yWl7/MoRpc8pxZEmLGKCgxdqJWRz+UMbZAL8EEsiN2K1y/8lBL9IYWAW7SZhhadjFJWhHM3d18AUca2MwQazpUW2ESI5vm9qisOd5bfdYaXPeTvnLElq19XDe7wLoYPijrdK/IEhqR7SEbXK9oKLKLPFrSh07pT2AMWrtK/jw+1VioJ0l15pYWbNPHs321pvQzd/bMyGlaHrAdsDrW4lkuQac5b2RaWaTbZkVDN8WLMevJx2Gjlh4m2ffwVoNK94YRLWOwyj/t8mcjhMxG5eGRO4q66f8S7PabXDxi8iLYXC/oEYz+7ry6mdedmN+ASa+FM+HxmALqLkHUY1G64ghuAEW1+GzzqyRRnUG2eoR1G8thacl3vtI9E2Bkhl4c3sjlVjcJfN1VDSClbL/ydoKJL5nY87fdTUWiXdmdyFWOmVtahzzNpVDrydU9xrZsg5Tv+GCtU9l97bQ5R1U2Uj+/8u/XeKI1jT1PP2Vlc1jl7s7x8DvsXjBQOIxouAfp4TYYxGFi5XB3IhWPH3R9BSIGiuGEiC0IWvDpgELpe+lqxHWpXjRTL4Pfx/safkmoa4BNxlRRGFd1z+x3iPILZwd1s9qlgVHGPqsluDDIurFUG3Va7kPOkGVFVfZh6cG3DiILi3zBVO0TpSpRqdv91g672vi8m5cbVXaMEzfFARsmAwF2NwcnigXuPJtvn1WbdaXEhwZ8Bl6boy7iQVCPCeGrdBwx9DLUHxCOeBzz6uiUx+1coswGxm2J3vtpZTQpzfZzlC9LMl4iJogRtBN1+Zbq07jdePOCjWFnY2yiLjyOfcdorQUCJNgFtgEeRMM/7gKSVf0AFiWTIm7j6yLGtl8viBedS0AzQlbiEmO5spLJjvT3APQUQ+oaupygm/+7CZtH9oAan+jExB5eYhDttiPRLdCSXsZaBe+NcQlNZCZUCDb1HAOO0z05r8SSh7663BTOWtKuYTJ75ILhLfEvqDrIi0IvIRr+Uhqo5+K2SkxUBWlEogisCJoYPfiY26CNu5o5t5T0FgZJh7n2o4czCi+ek8ZSfAOGjFo3vjMk6gUB+9lHKDq/36agoA2DA0V/I5se7NMssUWoXGCmI42wpCUIjtsdOdaks8w377KGlvDgOJluUbt8j3Z51KeaFwNHjhfeQoZeYndYH2QsptYSgTo9Lc3cdKkgU1xyKH3olQIenzYdxiPZHCUxPk5MTavsugMBehvnUENwr86g47Zsty700o7KKxLcFAJFAU/2Yfb5J3n22JktOCWiXiyiGQlc9fYq15l38gAp9fijOVqy3qh6R1VISAjgJULjD8N7YKumcJSCuEqzhysaUStPKJsTTjDDJPubaOpg8mO67ThUgKeop7WM5cMzJ7/dvAIiafLyjnlJVSaf0amxJNV9sGqp4i8sWzliC2NCYm91coRoduWs3cS3VMwspIZnEknSmK9I427GyOvE7XRlVa2BMi0gaR3x/aubHBnE0aR1CB1PD9uMXWnjw8L/Yuj1O4btsxJFlXXE41hlCb5iQ9tejV+QXaSCvoP9OrBogszKn1GHwo6yEfpr80j/OO4UVj6t8rxPtV99XjvN3AqTblobOgKcJHdCsj5ysSny8pphuVOsvYxNfctLSQD92Z2GsUuu/e3EiyvGxDQI2GVngVbhHn2BhfwpFRvJPDe8RLv5Nwm+4SVmScGBiYVbI6PiS6mDwn6DOvpcA84YxgoC+arr0NDJ7uq417QZQbpUESLkgObDULNiePTLqPUbC2SsK4VVDBfi0lXCH5AeWN2ZKq7h1VB8k+hMhw8cXb3jQv2otMOeMq8+/V6c8IFeVHKqt+6w/Vxt5EXpZHFZCWy3IkD4mQRcvNxgrpW9snhJXu9BzgrHngQ+a+1PzFW1omZgoyAMRQ2wMoaJ5lg8yF5xOyi4DkxEI+sF4UV4DJA2HQL0c+T3Nd1qogjiD8oYxYAVynQOg9j6S7Rjm/8OlMsBCFE77Z6CKEsE2DcgjBEh30UJPPNTb0Y52j8nT3bEl4jDvpmvZrk0/FKrk0eLLzTii18iHfq8SGxU4FbIIau64rRg/XAxHaJN1Rpxz7WQLo3BfwcbBh0p70nfFoe1SrkM2eBonUJLKLXOy5nHodHWvXiUHjHQw+zGPbn5Jphg/9YOpemgW35i82GaOV1mjDmpCbtbDcbaMhW9epQi68/lolQLUVgbTwSYiZ8otHwXU/SKhaXgYoYhDolXnWpLRJ8qjv0Ti/YXa5Ddq5Ca/1eSbc+UX6dSafNL95sq2fIIQS2Oz1lPiCJ8S0ZZD6g8im0MI3avF/zUe9llNIW9nlJi6KDota3zyYPxVDKPoIQgwqqW/6TCbW9gBFkseZXdxk71guYt4SafnDiZFL2wrOBhJI24BQIpAoXfhLirp32xXeSrwaScbwWvGnJoHXsMTXs1HwXI7CKtCOW0hE7MC2so92mp5kQkGMX8QJRTVeuxWgX/1rF/ZRfL9Az6LihGym+D9VYMrizjczWDOAyMv4DoA1Cit4Nh6KpwVm1zA3ueLyBDlsQeustPfeRhJbK8Y0y/KF2xUtcybGBsLRkTdNpSTuBtMojAtaEZE10ARm7vHmJkgEx8OGoz1OYST9k8OnljVi5uI8xkT/upd0HFrJPVATdAZvF+5E31r/t0WN1gFgsMJIiY+zgmGqoBZubfCdwzen+SaaiN08ZR9enSJFtL9rN9Z11TaPrqeN5Owkx+nM1IaHZAAZ94cKFgFSaHcFZ35yzPdL+uogMZSkxW9r0qe4YZ8KCci7zKBtkCWwiTFNHg5eZHZFj6/txDDMEylurip2IGoJ8BsWCaxOZTuLJW30ELi/I//VeisN01e/poilWx8ges8jqtqcTTnVNycOjrd6GcYCjTzmDMS6NVV7r39CnGYjBAuH4CUJmmj6FbQb+CpID2hp1ME1n9ljVAvOAH+LIlH9iK2ilJRk967vblMt6e2Limv4Rr1v6lCRItMnDlAScUSEldocDcYl008yERmRWlAXtQkY4lAYISU1zJS7vs2BKoohCzSNOSI1/kX6U9clD5hAs3D5UhC7HjXIKXYiHbZXL3DjQ+j5ZLEA4Tan476VhT8bd+cCkXuxnTyRkVFRQ0k8AUa6hGjKyChFTZpY6TzNKgYWblQSeYo2URO8sRQxrwZ8xaIpvJCFS7+Pa+Ue177o9UiEHXIVfKz7bg2Fr1RgE+7tO6n6PUW3aS746Hcfk3p5r9Ff03fMAffnk/8HwnTU6S5MS3QCKqs3o0rKakVhoIqquARogdOQVmP5h78ukczA6ZK9lPg0/m31CUTwu3z7fx21OO8ZuEUNWNHhzhg2R8mXmQtm1Rn0u/1PaeLnfQB/rA8sT/HyAuDvv5OqDi/8IP9kSb3fN7BK3d6j5QwblBIae3F6fsxtIincP4iInj4/Bk7q+B+qw/ytHvKywsHTKH7PYuGNU51o0nX4a7WJOqx6H8dn0FEzu5jS9lPcGXMy0MZ9uuPBDsAIQDDyRRkbPEm/CmrFD6smNQKIWfwTWOTmieE20mDZ2BogYIgF5bo9geckykih7vG+E8zGnd7yoJVn3WliMgBCltYMofuXVtLGX/C7nTk6GE4E7SGboN5o9y37MFIxv/vW6SpWYdpI4y/SkmNo+PzHj87Cc8vNvv4UILZzTgRubG2gSg7Nl7xnXPBzw3cI6rWoxzwU8GYYYaJMk5/gGvv+9ZQS9NeWUHy2pi0bynreQQumUWGs/NwQT37e3T1LQAgfHQVpIFEMzZO67HjPzvcCMt0z2MgX1QGhkR2NfAR//BI8mOlAYcpEiOODhx+6WrRNnt2hgUKzLWEjkfI8sLRva3db2KyMAV4PxEm4ZdItPtPh8iuy3uU6Ej6Ybr8qBMVPeiqQOtOOWzJujHyTYW25fiwAaLC8NTuOOPjiHtW/tvBmhl5jkUxhfo95xin+hPg4e4GO6H5Zy3Rcjpu1oo7/Ws1zyF4ZWbhCqQ6XM0IwRIFB/3U0/2Noe87KS8f21UpIXgpFNolSfTyyQ4bmrrK8eBpFcoKy9wqGy8vQywg0vEepU6GaCECbwR0NkHqZ+nvRrwhd4JfxLn6/D9dYDZg6hIrh9pnaiAdUZ+ascf7+mi569wE4ESRqSvcFESkuGZvAzRtDZUwAEmfWGW+ce3+yB1WCi7BspxSeBZzn8vHbi+pewVHGYjGAVpR3xnjvIv5hFYtqysXXIgU0W0TI9n1SnheZPHnDZfl0uVZGFLoOjRblPhXXcuo0dfrq19hote0SAjzFROFIAf/sLT0CvLuV7t9CvjVMGQWjZbGHBeEe6L2P5fgyZRRpZLxVvBVUaj8ESeTp/neM1UmtExX5cLpRv2KAWQvSIOM4R/jQLIC+vT+Y17OFi8vkeOGc4P2SR+15nxjB/QfSYn3YuJT45/0SXxrg/ASTnpQeZ5rfoI3AIGRjKed02mOiLGSQ3ed4pTV3Aej8FnnERCwHmnza05Q6HPNmBu0XbfuUIbE5iKBS7OXCQWmENzv1V8ALKGzJ+FgmWgrmniVs5tRCQ8dsDqZ2/Ftk017tIdKsQwxPQewIZNyC9H2BUyTFe2J3sxLcnYC6LWINZsKQjpSmQdSz/H1sY2HVl7GTAd7miEhaO1S2nlh++1hAVPsF1WakttK1OQvsOxZWZF7Pj1D80OPEKFrskoJtRaY+IuAbZQJavYWwDap+zcs8HahkQ98Y/IZr+QhGoJRtufQKnN2eoSOVeaAa+o8c7zv8ilBBIPp13Z4XoeZHykrY8Gx4iuWeupuDyB+g/5MuXtaLqO8uNGt1oEZTJY4TiCtfEHuhZKBi+ynhtKUpvzCz7Sdb1Tom873YDPsJXd01tSOAkJ3nqDZopWIu3YK9hqcpYmkBA9c0lZrM+toPFaUXzK6M9xdWV+fDMZQsLqtC4DUutn/ZRaBwrP8+TiIPrvMSBcM6+cjdqMawctC/iZ9VIEPPs6GFT6ZBOP3JaROxfb8X0ixpGxeRWRmLkbJIvLSr0/0YQIn4qzW1NZ/uISeyqRkadry5+xMoHe0hBBitTXEllSMLo+5DzW02v0PCWknIMWaHxJP/vdtdjBvNg7Bkga9MjUnkDF3FSf5cSKpZ0I824vPIWbKPBfPWuS337QWtktSzQP//HGEo5kqgADwwDTv4PjktFx+Fkm/Fw5glTMcCVYvCjRHhldLx11ZK9t8HgbL20POPvoXLjT0wqC+dKJ54nriCqK8D4t9VpTzGoWC4IkZpADvdGFbyC8uEoCOUM8O3kxhAzQJ5vHBX+FS20XnrdtpA150/GnVyfQKBQYxc/5J27RTaIhk++FO9wUcNXc7bQSFF5sQNgQX7OFLewSxOu+CqsL3Bw2ujnXtbPSGZCjoO7ACR98d21o9A7+bKEV6O32Ppqt0gnSj3/q340GOpEMqLESlPi/A6tmkFEmI+oDHGzHe/9DUg+Y06lMxXLq4wSF96r7Uko2nldb6U2PHyiQqXgJA8r0XpDwg9GQH6gpGTak7d996adqo9xKpFJifDh5xOBiFXQltd6nFdRN/TKdASwyZKiy5TicIQIukAlDYOkbJSx1nS+JkUyoCKJdTD9f59C35Qtc5x8xmparOkxdIJSdqMCRkBlnwfGKW3Dm8zObN/p9sxIHj6jRkIBZKLTvYUN1lvlYLCnO4dwJpE7S/dCgILVEYZ9CTbYsmaaohLis=
-- 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 if pending and pending.state==\"apply\"and fs.exists(releasePath)then shell.run(releasePath,\"--ceetos-apply\")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=\"auth-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={[\"auth-server-release-0.16.1\"]={public=\"je8/RRCrH9+xgk8frtvZXgKgFdrAQiYSfdIHvoSu6h9as1oFV+alPcDcQz2D25yS3gKlEcfsl6Gwm4P2P0OxBlVC6xiBubjlzrdOBOBKDB9Hwirb7roQ1dL6mjRI1ETZwRsTyUvHyKTtaG3V8ieU9TELfOWrr3b50bGud5d12I3lgP3n933kH8RvpuBgs/ko35DdJaaNimR3m8sKAAY+oJqxKtv/bUJCe91kP/dlW2ii1eiUwqAH4ixamQLPCv99gsy6O0JmGk+AERANPyoFyFd0Hp/baGnqiHrfjW6k9cRj/GbKvyOZrXCQDbfdHA/LLKMoDv08hXFTophZ4XvIjxp1Dnx1L7AP1B9MOJiRBFgHQhGIMrxRVTT0dv8+pWqr5fwRPMrhzz29pqpSN/j9N5JNQSeNSgtyfUMYoLWssR7/B9JYruO5Aiu67tO4QY1qUSvJ/NQIyWgb940cXscvwNwvES68Gr2sthcnzecOdZNM5/6Ji1AH9W5cExFr2cW215/2WbczJpqsRGy6JcKC5jcAUXH5QLX36oFsDOGhha/zia6O6F1bB1OtyeAzCgooSxWOz1kRi5uv2ffw3IAKH1YlEYyhzH88oxWgKQk2vIuW6kxacBr+uylD17tCgPZkk4rKxugynLrEtXrbYXJNfH3quJWiTc4JQijoBSCX4b6BdUZSd9JIDUC1tCUHQsMEX/E2v1n2oaHgwF5n9lK+WaX9HLwmyiqNdcO2vctYY08JYmOy1YVXL0QlJYfN+ljBaADBOHEZMXqyBlIoqKHbZ8gRYecXY55r1+Z1gD66QD7pmM+0DnGvzfE7OorCuA/YDFgJRGUwK0REfhbSuKHEfyXVaUu7bsCfXudZ19uFz5cslHzeUQsgMpdO85KPqoK6T0AUKFYBPR0HNv9GaRLcJr0tMQTesOr6vIVHqe1w7bXrRsdJu017bqPp/I/F0Zxi6S5WiUhDmYMbO8PXAvwddpjK7389RwGvBkekCbwcCBZP6vxFjql8xYHocajJM+MHdj1tI/UYp6iKiKyaSXe3PgMdom2fg1uvKW+c5+859VEcqi+8ksvgbHxC+KSiN7Btn6GY2QNaGYEhtZaRJ+L/nlrpSCgIKwvQ2K93zHBlkMgXiABvqWZgxJYhdGyVJw99B6mkmzSIxC0dcMJSKM0pYKau03bs8l2/m/oy+O5oyvJVIKUM08hivEXQH+7UXsN/xXAEXxHVhntOO2hdGMH65uBt2VfD/cs0MbnTFCAbWgraPKrBjkfepmhMQz9b3QB2Z3GUF0be7xC8Wy36jmX092il1djqa3IEXQ6jUUWSCVelRnu3dF7T06Za3N0ojEudGbKwU2Cp5+AyAX/Med0Rqn1LSrxLOJo6OXqU+kd87Plcty4eRi2z067Js+Sci1lCylo7487pLxbCXCWTZ2Lhf403Xa2K7sIzHGJ16Z8/kmqJFHKi3N0yLJ/jplOIPb24b1ebngSOSDjoQz7/4lvVWa5CEVJE2279/+Gjo24imasMMOpmh1YOViDT6AelQqsO5fZsLESI+te8+caXhL2r9T7OwxRpBrGnKIHG2Um6YqBGA9Ryy3xFB68DZIc0bgPD6wHs05vf6w9DSvZ7xtmMRU9bbhYX1GMOEFW8R/cgtuDzV5q2fYsWM6jzbSsbqm0UcVow21AVEJJYUUMjx3p72Xq5AKBPiYZ8TjCdKrNRlDu48mOLudHSQFU/GdMktiRzIpSe4tk+sv4zN7jXwTI6zySPyUUlL9uC/AWtSlUJlWGAIR0RlSt/U0BxC//++U+U48Fewn5l/L76QrDFWdQjt5/mMXCePf5xoWFb/5HnihCamfdgcEsFjgC+PrfYuUBL0lFlc1ypk0FN4m7e/wnxHLB5qRh45ZVXTFnu5quKUTeamVQs1jNtniqTbnWuXo9sgMHMoMitrKxINWxcbpIyqz505QRAOjN+wFJ8IxN06f3rAvGQssdfNXiBFkQ7KIo0Ykw9UjbK2QcEQVqs9BVTJvEtQkbqHZF+l0BJtB4YgF2z4d0Y3f2gue6uDALvRz0E1JjnEu5kATTQ7bc6ahF0ugpKrL80XKCVzQ59QIInIhAbbXtkoE5ZuunLcuJvs8yPiKkfcNySk8TGBrnGs7ZswGA3NSqRDajyPmeACwp2C/BZnwTZDymWGaZ6ZywEoJBxPjgOwXDt21sCYeYTWi4qeG7XR7RQXzHaXRwlfUgu+NRa6R4SLTjydHOocA384BnD6n0T9Xjp7Pe2+HsjFXOTOHJMGym0JgLgAMn7cRXmPoR7fhmNvoaN2HlNvGCF0E0mJS173cctygAhBDnXNj88Tlm7fZtymdx4USq0U62sJZYSCRPucR/3uQfNwXwG1OThKHdhhDTP6YtTLkdsSJhF8L+5tPTkjZ0+KEnYlcMNfnyP+GWR3sUbZotcggrbCRXRRDnwHYNe4reZrNWn0yX/XAbIdQLP3uV1ixk65JVAsrPAURMeRMYgE9oeY9WZD1VXGiVPic6r/FWnJQdf3RGFPnvgiXgTGnG8/AmnSJZKy1aBY8+wbxlOEsMh1dhju1JRgiQMgMYUyWB1MuTv5/rYKONNDgbJqPllobpEE8/5O8vO9/G3WVukR8EhAJ5q5nZnbejJzf1h/wqRnTj5T6jb7UofZnUkSDQjk8v9qBpkMfswDOJHs7HilQLhgqNLg4POQshG2Gm0yM4etAvF3T220nGtw07ORHIRqb8zBr+OEnJerQaQMmCRlGf7PodIqj5bC7aHQ/DzPZWnsXWGMN83HTGlOtCLEDyWdJx+vxLrQ4k5sgB5gaPJVxoRo2otnMBILdKOp7HSRTl/QYzhpBYZb0ABYg+7ELEIfHy9kK666oYSiO0eF8xAhWow3JA3FjRzdC3t8uOLJ6pbHwmcyhrn02EF+Uir1D8qVCG08ALdlEQyx3Ai+oAWBWz6xEFaVf2oy9y1Hig0XdtJGBhfGe2UtdW1FVVlFhsv5wwUx3yUWKAKd0UxIpyZ+BAJ/JEYqe9uK9vJ9oP0PAURbllM8bMxzP8IP58Y0w15++KYzHau58ESOe0NxuntDz3MGhyHrILO6I9mX8DBuBy5+9rEiXVBepf0IV18cekTlgLmHRUwpeXnr+WzMjOqTqwz3PJQ7yPecMUvzS9vk1wiRwOKPI6H/vEm5kWdtmpWH39ztIuOvOhp7JLrGNzXZVA6on8KVWscyG0qAx9gCTdoRKHX+nXT7E9WMKbJH49akcL7YCHCgkQ/DoYiu2qrrKc6MH8WHcVGIFGGQRNyfENtk4pGmQitp8+IZByUDJzz0/A1vNq7/jqyqqrWAA0ijL5ox8P3v5Y/GYcKAroHTYG3Kjccbh+zckFvrPDVjPXHr4A5ALsEV5sLu3SCYfQG5c9TaOGqzgYVQ8W2AjaszcdHYhtagJGxRWDRXG7Q/OE6zkI3tCqxy6LOij6NDrqbCxL3BKPB36nJ7UxhaAvt+lLhQIIu4wpPRW3UtAfUAzB7/jy76AEawcNB6BIx1grgYxM7bWfyoVGaPLUidwa1b44rLrQO/7UMOTU/Ry+3AKJVMqqBRRNwOgIbG9vQZeZ8tJcJzeFQB8bsd5lP87OC/fua+Cjv5WGAoOSbJQyuZNvcpw6fyelCXk9S6bV85+xhHd8u2NJnyiAT4sjFRKKUJwrhmU6tXNrLMbO/EmWitMoynaRebvjOIkMCzrGXqcrVJMupF7RjXrRTuEJgZP75IZadKB1BSDtJ8EZIpNcIEWjShk1/ZZJT8o96y40vmTHbMaCk1RYe34NoAwWIN1an8oMX8BRYFeepNuCO489I8JfTivVYgix+xk9z2accgFXY5yoihNQYnnWK+ouVwslOeFIQchBOppmdfd3MtLrxVOf/MuoglITDecXlppJPiKimUMEyvW0s24pF2xo7LZrN9RpB7KBiyC/qE1LXgRF8wond3qYT5aCP4ucbCRZ6dM5Lw11uQLTAV4Vanf3YHyicQdx5O/0L8Ic4Go3iVYi/gnexPs8K/c+ZewKf6lBdNH6v2pydtZxRau8TkC/gZfJNLfii4LGE/fl2X95CuwU+n5oTammKa+gwREvS+hJxBe9upPSqJRxP1yFY4X5xcxCJfclfutf7bOfXqcrOdgftgoujKtT3JLqTzAL1NBJ0Y/Gr7CVLhGmYY+REvSROo71MXkQGwNNqLFwTJDUrmKyanHSjLjK2pQq7jALw8/BWW6uGr1ZdcBQ+VAqSPS22t9j5/SPvTlyH2ja+uN5+l/x9UofGicEX/lHCu5bZ1SZglS/aOgYlcypdllXA8DfcOflHcOMw7AthgDr6/jWM/ZALPg6gj+bff6uzhd4YJvXcolws5h5qX404mtpRb3crZu7dQ6j+EG0fLO6UkTIf2+MZ1LX93uQjmTFHLD8DBX/E9oSTbKJUUwj3RBaP7V55C1ODVrKiA7mjIzTvm4tXIG/WUp2DbnX4tJATxYWk/NNTYC0H2muWV8/VOXEfzJ0gECqz89yaqCgx03iZiZBMBrdjmYMcI9JBy4YDW+P1CH+xyl0K97PeQJ+8nLkVmsNmSBvnjnNt6pWzM0UI6oKtieKRQeE5yDgGigr5/9HUd/Gis5agOCFBxb2MkD0JZauHYIWvLSPXUMYAt/i5C3hD3VcABv7yB/y07TNyUOy7HJ9LJzIt+5d2gYbJQ9vWFT36uvmWaALpbkH7sKWqPjP6eZZbvwH7KdmdVY+ZiRFuOSJWvgarIJeaquCinFoNCh78O4crzayASOxuDseiac4rCaQFuZa+BvVvX4Vp2lBqRbHVZimy3dxLnh8T6FvJtmx5AXzA3Yfz4+UO5cX+vkuDeeoVAqDwbfw3tHKCYVYWOVxpUMKMMXEoTwlewh6ASlCLMsf1HKWHVCwHb6SDi5sXI9Xx9LEvBaCYkt8OqdeyP6Ae4yzoNbiHhAPmClsAiiNkty2IPSCT8cWwbSjVql99awawRJPNCvKv0ZTgPosUnuGwYxu7hSFnJd0P8nyXcNGXFGWP3bDqb1d2ZV8hNAOZ99bmZ5/v2DnOse+JI3BW60r/GE/3UzgSh6S54l2YfSIgPgHLdAM3mNtNx9vxc78sBcGm1ubYufbG5uZpJEBJsY9FXjun59DwVElSg7/iPZJMcFvsqzsiV3RrxAT/CqhZRwxteE/Kgp6ctAUFsRfWww5OIcRCSxgMfsX9wGu4dubdq1G3c754599z1msCLD494isncByH5ntF9sWzf4P7PgLX6Q73xbQqj+vrL6kRWhIL0rH7FtTcXmIT0BjDCpopxOwFFFiU3fqAw19uealjq44szdWV85OcaMKfUyfaCzTf60WurMrN2s6oNl/BMHDUPOHbytpyA3hr0UM1p9IRb/4tSmidLwMnWBQigJTJ+0dQv+nHE10Ex4XE1xVLQX40oZ5W9D3fjSRTP3C7BNVBKok12JMPaB05W4K7ZSdsOmTeZYHBmiwRcjs1Mo9SIg2TJcXvSJSqn3fgVcolIrxTD56DVwoPWi8qEGkBvrNW9Yt+qnYQp0Ye8CeUuJ7drud0ZP/GhThttCqdRWJnagq7oVyVsb4Pk3KB1ixkuZbWRRHknMPYARqj/L3xyTz402/GIDu/X9puPlzYnHpyeAdxgUSBzMdNPpx20Jq2PAmgZPbdKNsQ+/TTZvcQlvxv9FIIojX/Wgsn3SoDFwfowHAxQNHsb/S36/n1n7k6WfJqUHRB/8EpefEg0/l2GzGUPAv31q3Xx7jpS/stVXjfgFYhoVtG8TJhH2dUkn8qxLhIhCH+YyOBMgrA0xUnIS3YIUmelmzSkhfwV32NO0IWLiyOTkTnlo6N11+lEOFW/rgU9Y3gaxLskVwpfdl1LSWCI5Ux6bYNvBnRkNt58PWuHDrsbdMGiUfPU6Qagi6tCpk24l9XFeXsLgY+HgYOHJfic9W3DfXHDvE6bjj2sfZoSu0C5uKBPlHV7PrEAQcYe9ZS2FjeEg/Xy5cENw72S7ZaKQ3a+Dx1XawyzFg0ioyKPtCY5+2VmINFa4+p7OA0TqMTxADqUf/JdVZWE3fH552Qp/MCXAmems9Wb8iji981kG5DS28g2LFZtcw2EKzdlCVNmvwUb3ll5ng6uLrotWTnXVUiJsqHvhjGXCCAJKFY7GdoA/T2fNWdEUCBa8uXBWEnXSqHQHZQnok3CGVnp8AltSDRlPkaHoEkchqlpfy2031Ml2KBagy1CJS6vRqdW7VbEWYqs5cmCX3eIYMtltYsXfRq3fs1WBNsuopSaoKejQUzjpWsDmzU8uEzDb8e4q9c7aEGRHr1otCRCRHRwQaMzTKaiAAEoasY5hsEniFeyikvu1zVtyyzF847Wa7PmmUegtrrYYLpYJBSRjk3C+e0DTv0MMF///mFoRpVfC8nBiEq8yMUhZAGBF3lkhaNTvQfrLRz8ZkFubyy3FXyx706IggtKoc3EDKp7QxxckGAoyIKJAE2cZcxwHDW6+0cZe6amjBHH6cMfUF8lsz8VuxxcDMFi6Af/SDCtOzcvDvWb0/q+gMUdYW95oW2LmQh6dOibK09yN+yItXE7T0aD9ZK0ME0em5L1ApLhmHswxrfIolMGWpzxIPTJqEVGjztLAdgD0WkYkP+yqhbMoGIXPocwKpwpewBuSgBuR7U4bxZTET8RpbXPM0n16UzRTGe+lZHMvbl9RQJWEog4zpKqJl8X7nz5H2bbKIjQxnYPWKVCE6ChHWxy0Ryk9PWiFRX7CB7vvzp/nFr0eChTjFdnUJyrsMg5yd/2gcj+wuCtP0OME0OA2XNFObEGJh2yQ/O8GfOVc71zDtEZ0ItCYetfHYgVRLHM5EShTTo7Yk76ctmts4GOmcl20mavaJNiz8DpXhRMUAqJc2Vd7ZAJuOh7Fb0X8P7gkAUIQ2l0Z3a9hgh76xb54zHJyfoR8A+5dXbRRvei9hCRxQavgvl35XGYMlwgDPNEQnFgmildD5gXz9yXUR+kmyBe18mE2OgUxk/EBPKrvDk+tgHtNs9W4DLXoW6n+EYvqLVuwv6/Neu7dGkoVoZ1DSbfTUUQRpqu2khIL2OrePXvUYkx5TaJmse7OOi8jdX12FrsmgaRUra5skhUZhGelmaom4cc32psoINuey6DnyfekvHQm0xE/QeLEW1/a0SglTY46IqerWEnwU66HO+Bw8Fx6EIFHX8iolD/rcBwwY6juGKQKrBFgqT3nTxisDRuuddHXO+QHVx79D2EyOe+UBGcImozANFbsdRQweA0ksky1KONs59AtPVvbh9vX3PS7Yz+xOFzV1vkVe+YAYrRHvK4bjp7KSod0WoS7cv+qtddceM4pRfoj0W1XjTKyKLe0WXPYeF9aYfj1TH63r+RyNNzLr7VjVBBMtpiiXC8p1kGieKUbzDac0pSqJ4r4wZGPcSAmamOYpYaTOM/NxXCEgKIFULcryb3R+fuNpL35S49H0CyUeOut/E7NcogdxliuBWyDDEArDF4NeEwKmISqhmoJfQPRtFokb+HGVFEHFmiMUF6uPk1bFUfxBPdtCg6f4PhnWKE9w+y2r0npeAmbUHclk2lPvkYjWPhhdiKXiFYyq+/QR4JayfMltVlHYX0vs7m5SDb7ftZfCA2/mka6M9t8+CRHaIvFIBhbTNyEU/t7hE98iOIK1UiM+QEMu2sqjV2Cx1/nDsAZOqwmoMHLFsUHh1aRibmEJckUHL8CsB8s70Zy9RrT1zvOtJTOX6JS9EWtGkLNQiYXI42PN1xYAQT595OjcI+csZa0oRGLFtHirK71CghC/L9OYLDHqcQm9UhejPf27/dV/zs7YcUydAIFuU/jpNIPYogAf2/5nfcfrJbMwmn8Ma8giX8PjzUJvrkbaDOvjZGO8l8mr+3DWpH3zumRQYygDRYNYHnf8s65ca8Tm4fgLbI8n0X/7nRQQ1nW8NgAI7ukt8dTGUNslDQkaAxyP0YslGqIDCjpTc2Xhj5QlTj++kuoygDHlUP3jjHENp6gii6dbM2eB3UofEppVUXvpWyb/Zm6AszJBKIaTpGDUKWXEsxMWwuXwSeRub3fFqCCQ1a3+m8BYVANPtbtRRJUxlD6OaNuTUSCbE7bQiYY9Q0UC8fioRODQN/L3tHg2SaR530IOvikOotS8X6LXn6T/s9tLQ8Jp47DaEvUykBNSFi89A7L5GU5+8X13IFF+7zxxhHv0b2sV5+77kucE79ABrb+HOWbTnNo70jDURkaNvOyofbv2ZdAL1ZFiQmUPK29/AKP4SR3jnOsxY+DiTCXe6vEd4HwWv8QLHcrYAnV11wddu4oyhxTcvwzlPn0CDFv2zD6LkECgKDcHgoQ0iwf3k4RhUpnjtfjPsls3h3Y2ynKa4rlCTOXcmdvng6pnX/KsfiI4O4wvjwPvZREpzaIfu9uqPeDeEC1zWHP7JlNtPTdmEvFgwWVELlXP8eColYAyT9sYS6RijCjtvARGaOHnHWKA02CUObKpgSen20FUGuwPETULGJ3e0bu+3nZpOp6iPl4JF/IGbAdoym2cciEnoR6SfCh14mcvk34hMSYBuQ5ny0uoLve/ogvuwvIGp2n5AMmOip76cA1piR7cmn9xE06JY7zBxD8QjVViXg+BsJE1CBsR4lSRebbMwMMn32AfcRC6Qb2zTcNj2WEs1PuIjjqQY0ksmMhoWQnLOgL1nP0SSeEUBt1yNPpJab9dEz0gvwjXAJBxiKaGEtbnMuTTky/7lovp9sAk8bTcuaBnW0jUd1JOrVPnEYOa/pcqlqAT4dahafKJSZnlBUt2MzjD99Ta4hYhbuTiHvgY9/u+jMmcJZYBrKxJ/T3EoR9nw/ZNpJmfgzQlboxHhJlDUu4CI4XJZVfRlSvQ3TEvXKEma7iFeeQHaiywLi5YB8ySSTPuB5NTSBwrvy8rifgTt7ff2QbJ5xUhCBqyuSwW3LlJgUXwJW+xck3aZA7EypV77dbSO6/AoUiYDBmIu7bBnmohFdHNvuPtfnw32MMtaHavOzRq9ETgNrkbeOVXMqk/eeWjQUSAUZdSY7qR3d5mx0qhgHY8mKWKQtMer/w4qBvC33r2YGnV2gv8DQ3Tu0RjAV5UYwvgss2zMt3cJAIPDSG9w+LpiREYjqVtbbybcrox0vsJ8io9Vpqj+MWkQmGGrMsqyjOlBJybClUCvCbYsHRVqQsiEenDtcxrt+CoziNlI/0g5zIXcFdbZLYUgKx46LNCkUoQPMJLGk7Oqb3HRodb5gV9QVY0Vfq6cyM/+RHQ0lh9vRwBFtqZMPcre1ZCxEz+RkwPVIIQ4o+cPyUuRkUprUgOgMrc2AJddK+0YXvGBAe/vhk50hgu/ttUK0ERRRPAwnDSob2sD2008bbLQ4wzMEjK3VRlUdKbtaU8pSFZwTCx0AZPfUmyGh1F8ho3hz76ii4jslAe4dric35VgJkN8r2wIOXfmkWxD+NywtBxdJb1H/9y9En0IsHyNXMCFsZsKrglO7ZgR6iYIQR/KxFFU09ioHseILKtf1AX2x3g2w3gaSWoEE6lCRy5eQ5txXF+KjuxzlBiq/X+y3UcGcPtx7opXOKHnCFTO3qJiyYg8SMNcJok97WFWIbQNgspc042h88WiwUoP8/MTY5snMITa8nWk2gDWkqKnzZODU/FYs+3MtTo/SO1JXZ0r9PcIxKbU8AJQfxZjM3uCPp9zGFZ/vygctJ0qHb7QvZLZBZuEpFemWdMzZf7qZbJQeH0/xpwQ1E75B/5IgzIvMOdD1cH8WSso+48iTN2k6+1zlkeOS5ChR1uFc9hsZfSJXHtLC3hHHkOZ3+gJw3PanDKc9OieDTplWk3iX+mYLzN2+WCmAbPNYzoBts5t1qBU6pdiYQjlFOE6KlYnmAZYp49jc8XyuPZMYos+92i/W2n4yrxR/0vUeUQEB3D2N9FJCBdm0Pv4AYpCwaKiCO6OaFgxroamLhwmJkfJexZAVmqv143mSKOhN3LAOZKB7cB5M5UPaYVHXYjX/J6a9vC9uS9uqwXh/IX9v7Lw1wsQsIBhh+K2IR6a85PObwfJxitAhygpocE+qrXIqD9ehoKp93xQXMUyBZRbsxciW10pQSVpksgRCkiueipeJQKk1L1/MBI5lh94RDZqFqE1wHf0KyHRmgltZP5cPpQCxsdGMUHHZFrId+5lSE9iZls8mqu2V+f7fgzkxlaYD8AQX5TtgAl0GaQm+8d+nbljc+we8g2RFPwuA/lyj//vAcgubJHmPaLGGLLtt2TESFVj/tcuAH578zpguK7UjcMpc2uuUcQPXm2uz9Z18YSpx/qRfOF3mKISrKLqB67dbncAWsWv9svEShTU5r+jHaJBBqvnDwf1uW5PscpAyeaYjCaH31np+M3+EtxW08t1cFyxxp9s5PGCJH57NGYDuBKiV82kTG1xFFTKPa1KUURPeW9xfY13oXAYKSKWzCB7tXZ8Gxcf3PQlN4SVPYPt8OZAoC8SdVdS64ocHWz03xcE39EsfLdHByPdkYDTp4GGAzk1fP9cAjSUOrWW55UT9ODW/oQt8aPPLFOIuzIQXRsquODRzg3RIpP7FnFekz3cPk83r+xhdKtJDBS/AK/cleXeCfyLHWDLQDDl2UcgxjESoBj++rj8ow4rTYuArFQn8xA18RRblif3XLnV1KQ207/iYgzRET2a46naiUeNckzkXNcMPCHwd//4GxIqEgFcZ6uj1UvaVnUPLP6oLL+fTU7RrhG6/STuwGPlHxnwt0U8k9CmOxBXSw5e3H4Rb2R06NOxXvYswXc/X0/fAr4YiQvonuRzIazvu6MDADjXfQTQlzkzQZ8Jli4yKVUi6SK47BU7Y5pupQ2ReIUQaVO9zDw54hn4wK4pSa2RfAPDLjHa47z86XtuEV6LcE3isC/gqSH3pOk5SwGi0nOFjg4kkllYvpOPaY51mm/9bzHdfmMw08rla12Td5aBIstm1OT6qpwlqlE7nlNUTAP2EjyhCIAaYCmSKmet+RZKHEyRsxK8vlj2p2g/rL6UfdEqiBHwZv4KwI962n1Q5MFUeUoI5AXN828c4y1ZSUBpF8uJ5QelElgQH0I7xjx0m+vXFkvbm3nY/6RAegv8viPpTxXK4NsS6qNTmoY+kzdXpAgK68AZml8o7cyqakHZ5kXgX4Drvw4xGv6BsGJxYGmeoYSPuN22iKtb3etnrwoby7cTQPuE6yJLmwfIz1lgCr7u4aQCX4Lu9/dnvqLLha7dgRyF3tZECVdDxHj9pscShdw7fpRvMOrt4+iyFkgYv77SzrdEVIB6d+RDJqFh/vrix92FFwWu5bPNo0eum55Q0/2QsewUUwIwcJelR4U9Tc2k8vsNTyX3YTmr3evxO0yDyvnZzsLbhu/Jh+mNqTfPUe7lny9HhHtopf8Tws+qrHW8BELN4FASqqnn5p92L4fuu+V6eMsxKXW3s375//I8JDMJ55eGbUU6t5xnZeTbQmSx2/rJxMSHmvlEwOVnhvqpzLfzuMwN5BrOnF7vppp8EnSdy/ZD508VQVsnOIN61xW1dMvNzcczdMZXWogZf0g2G7mmIIMinMiWW14K5lXljQiGU7iPKI3Hc0ZM6Qxfg+nC5mOHEqWlcORb7mipAt182qJ05aJrp6EseDhOKkjVQrxe9G/bJct+z1E9KkCsBf0MagQtvyfHGZxXMsZ8WzXZVP+7blQz6L4gL152b9X3pSBu/eXEP2Q9VYoj5EHp62yBPAv2hFOVMQ/D+BHCCuzyJEEZBQJzz9Bye6l5HgGXMQyw4QqisdzrzQPBArjJO9rW5lwNRpSumNOak3E14w7SK4Q8fv1Nm1QAb+ddMziE0JMBHqvhj25AcnEfpkbJHsdXeCFTEsbq055+n1p4eKHt+7v0Tu4CzoK1spVCEhleOcOHF2ASgHja9NTebbheDhqACd3f5MgXDMzQO1NqtOHvq7VT8Tu5WpCxJ6Pkw2TG/a1uGJIAa6ljSZ1aqSE8XM4yxtVLFir7VVCyJ3q2cRW71EoH2dHdsA5MmfYXvliltuYDzN1G7c/E6Wc+LImjIT2hBFZj+7OatYfjmQ9vJX6M4v8+aSwAJ//UMPIos/aRg6atHJ2pARENuOID9w8TXrLxMm+D7KYeQDMHYOEfJKGrQEjROj9wgbvn3yRxTHzzVT7RYslUOaltbqUAmeXuHrNjxgdQu6hBsT1oY9wL1ugnlohL2BKimVolTDB4YrOn35qr7+IQhfWUAe16lxrCbbUZuY/O3NRwLoTdU+ZnvehrWGiEDZMl5KtRpj5tTYLrMgCkz6p4M8tg20e2fG54hVJy9YLbTg4fwf1JRwlVaij1VqsYimydUi7ARWWYbOQFz7hjhzYbKc0l17rp6d5vTWvljLRZKpyJbMdzobclDilfoDdheNXpk2DBEBoNXp52cy2OmVMoIxrLgZVd3Kl6tu95knvZfYLx5C560XETzjpGRu4mKOoJ+sQIiesyDHu58Cc2VfmQzESgMlFLT0ewxZf1bf3DyBjlArNrQqcvmn0jk08WVKVuoa2xGFFclEv1DJhrXVByvu1Fhtq9Jsjq+twWywc0H31turEd+Z46eA4HWxUh2BCHcGhPBa8GrHvm+w1yDrq0s+etHPnjLuoY4iwtOkMne/I8vB4bm9GjyY3C5xBjlEIkbG1HY6EQwa/nUVvIjuUAGUCjKIMjiRJxDQM5PD444gjRXNo43pRcuZR9h99sVmUmb56k72MNVPwWRKXR/fYvcX5kE5Xv03WIhRcMtjLTf+NACkiyUIw9xNu3vQTnL+ndHWYNB+0iliOilkvcjllmgCy5DhnhNzKYzxBhbxGCy7jo/K84nqdQM5PCklC7jlGTFQcXuMJyrCF4gwpO3TxTQ9RFeFkUsEeSUpPSUMiwU8EsqHaJTNy55kvpaFC3d8zREO1wP9XIkcRtTlkHrVw0RE1URiQ7Ew8zjk0nd1E+rHH4WY7GdjRXpDdLDe7Wi9aZa7R6GMKMM0itF+KbVcbjaGBnPf1uk8rIbPA4yw+f5ybwJ+toJgM416/zB2x9JDx6zMbylL8mhbcbP5RjWDgRWpnGOjnFNztKnSneJaJS5P2vcEHnm1ExSu5IH4UmEHzI0XQymBmm2x3g+zwspHN+GY4QfgGcKm0wZtXgRT5yiGNBXQYeXDFSYiPHSnVo+UHecsetIHOlqM46P9OczcGMSKLA4QF7Py8ewyes8YWfVRmCHxFXp3YxhMx8l70Izgp0uwYOy9JQMaZkLiy1R7ExRPOcWkd7cpDQSzwmGcpu5wqoBMrPCTvy7PDr38oQAfsAL0Ff9NcDg+mFnluTjc/FKCIwdBLoKj+7D4bGmN6QTV+0nXp7M0ZXnsb12VNDsc+r8qWQoY58DQokyaEqQzqKjs0McGLw6q2cdwsrYolBjHVmr/NMINHIPCQA9syXKBiDR7oqZMY+MpbrafEBrJWaNo6pHnhDdGJpqV9Nut79PxNEirogeK7U45sw+BNs+e/NprOFk5UnMQuEIfmUcUwu9P8HdzI3s0cd5hzvwE2QH+311ak+fqUGZF38Maxm/3MF8a4lwU+Nh2omSZ2Jo2mLv3Ss/ThnqlbG8m4GocaDF2k+TBgmk2R36ZAqGWdEyVH7HBZLKi++Er5LAEA64xPzb9NMGo0baTH8LqYCF2VUvTTI5BSSN1xQHX/uAqw/6CVJTiGdZBNtBFd4GUjH1qwxFKbdAkLmCm4ZQw74Uggk8qa2e7wBMLKETm9dmJJe5/vuwNkFQwzkTAk8qVGXnMjxNEDGpZRLi6JIWd7SHsETO3EKWFn9olYiQyu7SwL3DS/nFit3sIWf4TIfN1cFLlPq1+ZJN6kVECNuAfyUfxvxpu78eXVDxQbBYhYl2OoELGeZ7jNHHsnns3VBcpxOl0vvbIVGAOls85wBQWJGfRkb7ydwn1Qoay4UeSpWu9D1eW61SFzCVg9hq3LBkjMqYat6AHLWJ01aUQqg/TG2nHTR8CDQ5EbRV0kgTo4hzsNS3HxG0ExX6rnG7Ev6z5mTnWkLmIPxQJSznu1ZBmH3i5j93K3YffQgLQ5Hj9qmav8B1YKzXomO0vDIU7qJreBNo/aSA1N6fpPu8jzgZ3uK7T7Le/os6/crntemDSIkEy+1BJTLiUod8DxGjcgpH0yvwCWzWBB/HbfC+J6ENHSKilvSuPjVa+1vXC8edBhZDmG+SnZbwNn9mZ+PtBloFE0L69hfDZd3MhDe1RtlK1IgrL2irkGzzWKIiw9TKyBb6XrylpEPF9jtAzz2i2nXu8S0bBtpHAM1Yu3bBuxIL/7klzKDpSkHYAgRnHcKOLfiCCC0ix1swG7RarIkrsvmRq7U3Yes9oW9FTS2ewxunF1MYCE7i2nLilXc8fj5Iy7Fz6Lw7SfALak0mAYKLzhHL94eGCPIhNtXIUE5AAdgYJApocdAy3rg74XXWeH4g/KhG+mWXe02aQ9KliEzPf+ImQE+jCXY1KMMpoUQxKOePTBybKpWoFDX7mQ6ld2CVAogLVdKcoOvsf02Q1Y3o+Xh0o3c+0HPje/nRX6ZA5eGPkeR3fNFa3aNEHV3BOzB3RjlNhZTLqHInEAGwoZvSe++1Y3IOGAj+7jAOjFcDCqVTiJtMfMCWDkOgkjGl8OS3Mb/3nVFu+Z7bBd0J93BDw6OPNMiceVysAHvMrqowx4Zpz+K65QWcz80mYj9oKKmwJsG8wFmx6v2gP1SFCvzHFKcQSigLi2rqLUlqfhL97WoHbATMUxFAc0FLvwa6akdxVtAk9whky8CZFUykIDL/PkRwl6o9eYKRL4SvmFlKcz5Gv/bF5SWZEYe0CfG3CM9too76Ak5KwZnHUGFZKzZ4Q1/N13U6GcMCy1fV2RpCv1Kn4mgXsu39IjIchkZtnl8JTnBpUQXObD4YMcXy+BheG94McIqnqEv63NiTrttxZdnGHS2tVDSOGFwBPv5PlVDAYeG0tQ4ZTKuN6J8FBT5w4JTXoRQfv1/8Q3oQEGetBB7mBNFYn3puXIJtx46DuOJK3g6GCCVyBgAtKbk5p21hJg1Kn7CVUYZhfvo7y1LYHjlPemWyHeY5XKOQ9zCdUNxqf2UZhmoM28V4KgXHbHKFOuClZaPtZtlH+V0ITDHUdyjY6DSRzxM5UTmWcqtpGhGKQoDa4fMtnhkcgNkgw3GbJcmhabF3yQLkee8gyjzbSn+x3qlEvqZbooZtN48Lc7cVCKSeiVxNbBQYXehzBVmt2hxCjlVim5coZs0hEdQvmTzR+7Q/VbUPGCSGkFcJys+0zR3rr43nSq21sh5s7pLTb41/URK07SKpvocr0ZKmuzA1UZNdE51+/FWxIWZNSsb4wqcfFc8BTCUU6+tJeBlE4uVCfojjWaGdaXDHxep4KbwfqMvwcEFoJm/K+CP+oYs0duin+20uCt2FXDJ5Re22pbGexadf+pNHEZAyBUcPc53xvHhVk7S8i9eWODdNXwz6jxSnDwOxZRHvRgujgrO2dZLxKJ6JNY7ts3NFa6zY5j4wJqZfRWjWpWgzejT6Z54ZWhjyzEoddcP6H7MCpuqI1WitPl8plWYeQ1d3Sy8JjmyDi/BKvXrKaqVuoBLMvHP9rs4gnOmsnAnSbgoBxt2+dhgcTY/kMUPYK6oT/TVdx/yJKxgOy8hVI0IuX7xckM2OGgySs5aEj9pLikdLYdzG6xrcQ9LAPztWjOrK/CvMxQbg6yrmdl2A+b3OFT4xHMc4nt+GHZJZ6xHKLtaDMJt9byeoJi3IUsxRi0LoOyKI75mYls0HbfyPBD16E35JP2z1FAjIFO7qHd/PAyiaHZr5DGOO3K5TVkT+oSzUVJDwtnonmzwP22T05cXYG5daZv+3m7L4yJYCNkf+uJvP8jnnKoca/2aIGVtIqVlyyIbAJ+m/W+n+rTvnkoFX/pPJwZvMZjZLYBzRfeBqLZHmcYY34BzgJzKICXs7gA77g3AKZ16i0/uSir/rgudmqwfTWZBVvuW+6zoBmqwbg6FhiPQicu8lbD/O1RMoSl3DbvfU9ynGGi4o8biKE7ef1/++wHDXkKZxvdsLYMabB4RtQXWIteCp4kNrfKZUOiQfGenDJLtMgsZbj3eI/d8rvG9IUVSbgqANonlSpzRcCaScCCzrFlz1w/wnZLGfTdj/znnUbDOpKcYQLGBKXUeAql3vVBzOE12z6JQ/8HuD3gatMJhOQ2XZoSp+eXS80SONSl6g0wh0qy+vRKyd8HNdixHSB6nWk4Hyv3wjZwJOGHABEfm//YLwlsf6YknLc9Zq+IEMlu+zH5y3UqgDH7CaQtgcdEgwHnobPKL0aDDSPYpwcc6zt+8l32risfCJ6i6namAHI3fuPxau93635qeq2gJxMfqGxbi2FoShvtqL0m4Pgyy6Lt4S8DDIOaNY6mIuHDfmhUSlBdBsAiyg62wK20XB/vwK72s3Wd2ftKoCWuBIM/khjQRn/xpzEyUK13Ad8MrQRycBFaZAxwY1nUxQ8hywo9zYUdxkvh3qBDU5D4L0ZoQCMJ9K5TZ54VIqu2HMQFxeFOaJbwMxWLte7cSZv55U4HQ5nP1rv2Ejz1s3wVtQ9FsZt75AwcVXTPsnd3Ck7tWdvcRdIIc/by0+Kbrl3ObNO7KfuVzpF1m/SVjRUewlWU1lzbhFbfTrBRccA/ZxHN2bm+rWBeSX5ny6eKyFzuy+WIU7mz+JT7HHgOkSyjNzREmyIAVarnj5x+4xehsUuRNISvndajTT4C0KtF01xImOteR4vqXXXDW71Ms1YbRkz4aZnXBdazZ5L+bj4xOWacwFeNUitMWdQF7SSKA5+JIxlVdroIJIumJ7wsxGN0+EXYtrxDO6YcKDMbhmaXTTHHhjVJdFR1PdeUQANQMkL9EeLvU6txsZTb9MY5tCr4RTvvQp+EPi1eVT2C0wpcj+1I3qaIvFD8EyvDuNCLiuiI/+1tAeWWl2FZYmBvcB1hOzVRkDSIxSvMaSP2CDWHbPy62Ht9QpzdZAKp0087v3vcHGIAFDDlH7CulxYbDAIV+oCBoutZCigJ9GgTUfshjBpBaCMBt/wNg5eyyS/jBEGPzrILk6cL5pB3l5dk5w5LNyRFSyo5kPSy7HmCpFSwgeXNLJkUMmnSouPbWzS8/mxWrOw0FZSwWMxbqC6TbkK8hDngwmPSybnKst5P2/VeabNFubNE294vvBZrVJE2yBYceTLJtqwjtQSMnMOFmQk/q9aOfnP8qW3A10Fju35XJjl2HNMWa1sjMxXulJ71+GUbPeX86BuzFq22x15gvQVxZpLinF8T1dgnjN/CvNr8eGmJgH7lHWIXFXk+QUB7urThnQT/VUlQugGRkCZZh2u0a6mKFUDTpfJ5/UAbUu/l5PzZu3H/IRZtW5reJMNAicadKvgperN+t47pNFfbLmwszn8Y4sBrHzuu7rgUfUmzERxqevLfuohFbhLqVRqljUzwZDRLdYpZEcDuI6AR/8aPRie1YmfkJhZJIHp+dQWK7EBNYOLD9B8V7TB6pfFhqNfUuuCzSLo6dvAA9PG+wsXKuOzcACzh3hU4PM/EOV9+zB3Ps5MiqctBb/beQRZHtF1YeldvpfbeN1fBFZF11xXStxkelrcuKQE8fJelp9xrWMzJ0OCV0rSTS62gM9E0ZzljYXSbYj1D9ErDb1F2BPFy88fzX3ijyly4wJPsqOhfzOVKeFCgIKkaDe/zq56/+aWTn9LpHir69/q4N13cgq8ouMUMUkeF5/EYqEkP75FlflEPDofHCjaEgh5NdiG7UnW+ywQTOhoAmjwisz+WU4VaBAcDgXg8zvuORZrCDLigwqBNTBAjPAIFcE6+nVH6vgxYHkVS3ytul32o/LhggoIXcknrvu/Te7AkI1Hw8iWDZ++TM4LWc7sTFVCELAAQY2aL69NrZbhEm83iPpHP+neT9fIppnJXtLc8AHCx/bmYNoIfuypJwvjeTtJcggtVdT0vQR9b9fWjLdfuqGYRNvDxO823lE0ZItXIrB9FumnF12Z0S7whm63LE84jGQd9BhPvx7F5AtQcSWyHoNUm2rd3Jci0jGtodeBicQSdgyIJeiF5jgwq7fnEd5p/7Odrlygxk7HIOTrPLsHgX79mF0QSWMAEIDSJgj2GkUCA+ptZFCwGP3SggQBO7CshKMA96W0ziV+xn8mw1EGw5HS/ghXdpIEU1/4ydo92yJCB2+IX4hIpOAasJFgEOsrWmQ6RfP0ORYWF6ZXN4j14V9LHQZAYpDX9cAKruVN8K5u684qa+o9KfR23pSwtWX7QuwuRadETqSlFJD/mtyo5bvfR8Wr8+hE5tLMPtXq8bnhPoTvEzCB4F7PfLpXUI74IHm1cBEmca5evfnpcB/r3bVqAGr+jajEd/wdMaM2090in0Csj1zbqb7rcEBVLaXI7T+1W5WLmeSVMtzl4PHWoGNaPj7IkbvGNsUYR93NAUDiq1jhIsQhdCwKBXYehfmR169UCloHX72NymVt6R3udLzxGMNHf13Nmw/5BV8P5rEpQ27v2ldJ8j0U2zIA3fMQyY2BDsZXDDuYNtSwWKaxNXoFoLqrqMUeXT4eeRMVEQWsZiass3UbAO1ys1Ekck8i3dIqRb/bkGuWa8xZ4ERmt47COM72eu0RluiUKKBMTB+Ya0w6EHRGS22LzLLFfmhcgQpnMbypVB2lKMHn6TOkTR5VKD59OW1jVuZNLdcnO3Od1+Mp+kA6uUzqwagX2AA3caR2g0dg3w7H04DYWGYLXc0C/T1jcj8nTogbzWpx+X6RMKloZWE9sjViqiA023EbDlBaaGdNXzFlUixQk02yttqUSsfo7vn4LMcoz6WwjybTVRJlQQat+xARpwXKWerF9F0DBzy5Wu6t6nCjj0N5TujM89bOkAueKiPQYDhsPzeLF2EVPAtvbu24M/45mg6DnXlT229SLVLnNmcZxPDH8iKHxDeIzY7UMwA2qxYbcRf+WWja2RXwefhXNsZv1PjG2gR0kVM6/LvkHygvB1MtzMA0TPRlPL514GRf+06G8CoLGkJwtX4Yjhr6ExOYtkQDjszkXJc2HXIn/zdOCPJj2aWVrxzGB3fu5FVh9QUmclQtxN5RYKCLHxiqBhGhnJmms+/iSFQk/9RJrkDRqDZu3ulLRHzBvUZPmhuaWqi6wh6sK1m/k3l+9WXKU4FiehvtFEhWmYtOXHYNQ0ONt4tL5PBmxsEGUK3Ie9EwVLb+Sb3Wm7B1XDL2Z7/dmIjozET2XZY2xmrNjj4IOpZ43+1MzWlYvkVpnOUPIXwZqQuFn2+4OSgQvkqgoLwDu9nYOmz32fu0TCLT7+zSKOqxLMCovCl4RPubjS5+mrIipu+qYOIhbl5H69njmKN0GjXchNJIcXO6HA3ArofgOgTl/MBI2xwoTy7/JQtvg7V5TwZB5Q8kAgR2eYYp+5DYbih0cjG4xXHjmBnrolOBnxq3YEseXhlENQVPRyHZCmiEMAkoz+n7T7rOkYJjxnmEtbEvwnx9FWtP9u66AljeEqU0m46GAPEk/KSFyZPpm+2X6baLsLe83MkBMHogqJx5QqOu/a/M4HCdbbncsdf6PamceWPRyinW8NlRcJR69eKzRQ1DGOir6lI1mCOhLKzHKO3ES3Uf2vnPCG6rF6xCL1OiHdLsZUuPl0FifLSxTWZMVJ8LkMSIzTwQ6RgpJX4FuaxNgvQQ197k8nLBlhxggajPYwk3IjIJXmS6kwKGjs6SSwOexqeKFeNtVL+pw3Xh+I621ahpQT2r9ZVzvUYRfZd3K2I0hmI75bIUYvqCnUg3+I80AQd58uTS6cGRoKhdYLg6gjS0kmpMbWrLhW17vLc0Iu/zJHnFXmRE70Ak4dCbvKWdUh42C8UHmXYK+WUH8yj4sirWWw1LoK39plES8yoI133l+vPbX2EetyX2DMn7Y0furZWIGr5VYUUYlk32X1nZSC69VCPT70WkAjLvruLilOFa0QUQ5jgb9YBBlk5L6omnwL/EyUt5vElg5IQ++DyAq/8rpGtx95Y+i1Xk3sYhC4rwjYwZq4rviS4cse5LcD6bzg3tBhOmDmBXuL5n2OzU4blJIcKv3u5GeMMwBuV+0r+iob0rTOQuWulkPVRQ7jGj25Ku1BxWpgBnjbF92Wg8OZo89tew+Veyo3bTEJd+WJJBllHSH+g7CRMvhOVd4FyPZG9iaZHhk1VPbK2aWwJyOZ4Ku6+I89WF9Yjq2A3EnSaKJl2rG/k9YVKT6ma1sRnnM4RNG/m1xYq8o5kKunZAU5/pVvn/UBNWauCD4HBVckowNLng9K043DRzY9aOtwgco/qU5uhvG2AVajJ7DKfNpqTx17qrUAZkIjczd6ym90gz+t7rhH+2RAToEb8iPaFzUVo8kjAXW9TwJEMjQdakQLdPh6SJJvTpAZm4kUWRHy+WOY8YCCKNMnQrpIJJ0mqqqED0PCU/dgRqfiiZ20L1lmI7vWHff8IdSiNmNtal1o+Y6PqCvWYmhyhD6uekE4b7FQb3EUjYozn8INAOkRBxgXtw35IsaPczfzXSStnil730wWE8G3uaB6a+Yqd4vD9f+ovnb3HBm0d8RNph7hs1MiAfEuNBtFgOhbBw6o+XYGBBoaSV14qWO5h/JWp/VbckJy4ZsIM2nQ107jIT+MPPgd1tr2udFwLDm1ZjZ1OInZ5FI7+mskULBa+D+GoZzfqgzx+nz4VA3WJuio7ZviUy6I5OFB4fVdS2KqQs9h5Ca0xLP3rKTCT9hvW42gfkDge08CxVV3bFbHCQG1/npNuPG/KZDdWCPtTlBa9PvLOk4K5luGj/YKX7MmCIbN4GcKZJLLUPQlL67Ok5kYosBB7oDwiZwEUpx1RLbIZEHYyBn1+avM9LCPPd1Q/jjen2zIanQNUa4FSbVxZnMntjrk5kd8ZYPFxfB0Zq8UbsV7iSgcvlYL0eMCRToX78IPg8rl94EaIyEYlQDrm4Dz6R4NUYiqE7Y0rLPGVxv88zJDdUM0+5fjY2wzndtVQssKDenBBvkgaBC2P0cv5XCIhD8J1EQGwF2bCyY5FCw1HdjFZt85nwTQAAPX4KuMuPUqZbTRP3iBpZUnCVbRJkRBDP7UW+wgkZo7cNKG+F62GAcPuZRVpOMy4CwmOPkMZ+4LjEljAYkemg5y9r5geBbZZd4JAiBUAHz29YLXNUVoNyUQkKDOrtldQfFp1FLl4UUCIYv7u+HfP0tDB7Li5nXKCrMDvjH3cIaWfR9WM46HgI72qTc015xfRuA3Y8nTn+17MpNMKmjY9g9nBGLczPoHoVfIJpsrUAMTMQGqRJN5nYuJruPlErhaHR6qZ5soscmCHKN5YHjarhW4zs9vR1bW3PViiv7CVZWXM5PNbSqzRuXqWZcGLIh15RyvfvQzaNZAZ6Uifvd2wog8cyhJ/qNCYNu/brMgLUwjqWYYLJHuq+DFhfgVUSu1JNrA9XRvXYglwFEvX39KzYT9f7GlRxIKzCSwY17+KnKPdXvIXOY4KVpV+ScmSiGAsKGZRv5rDRh9hw9xCiT03qUb9BuXNya7k7XucTopNF6xQ7SgKU+F2CSW4vK/QmLECd1D+mT9p5xr//ljj6F81vEa5fA3k9RdqG22TiiWy2e3Vtd5xq9U8HDE+6zmi+imsn3QMmQly0KjcNy2Tu0Qa5tGTK5m4d/V0Z8dKYpBcxQztZ3SLePCoq+1uqQxriByz5y+YcYGJkNBlUG9tE2p7uI7knM6Y7cha7+VSiYWgEgwrRsVBxJaEMsKnV9AeDBoiM4j2ec3okaG1fmaD6CF3bbYqFp/lndnVAoH3/7RlLvWJypbw2jnD78iB6DSYZfHstTnf1VaOXbhsQ6ckpvCGuby8mVr4OhxV8ygjoubdmSWZGH3tV0cMiSCT8OeUh3iqhtFfrRGjjKp2Kzz3OKy0kSxOw==\",profile=\"auth-server\"},[\"auth-server-release-0.16.2\"]={public=\"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\",profile=\"auth-server\"},[\"desktop-release-0.16.2\"]={public=\"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\",profile=\"desktop\"},[\"desktop-release-0.16.3\"]={public=\"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\",profile=\"desktop\"},[\"recipe-server-release-0.16.2\"]={public=\"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\",profile=\"recipe-server\"},[\"recipe-server-release-0.16.3\"]={public=\"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\",profile=\"recipe-server\"},[\"router-server-release-0.16.2\"]={public=\"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\",profile=\"router-server\"},[\"router-server-release-0.16.3\"]={public=\"Ri6cEYeSPCGsLmFM2saHueNHxFqoMMh3UWv1mOkXwQSQiAEu8ohn8Y/QZMHEslrfg4wVCB42Ms8XAdPErGSqGv7rKYagviyM+qFKI7qf+zorfRc+yf66/Ju2CAmhUH/OnjL00IVPaRyhhqubT3eQUh3vfn3vI/YeIpbmedUwaxIx4BNq8MxwaDW6NxMGyfGTfoMric4EMh+jxJUm8Od2KEO6LS/6zDbGBnqIxXZc+Tnj7ZEfq6FOMYMttgFi4EXp+UUA3ABataMZhpo74N9s6SWoHdUav0fpwFfUoRuhMjPBc+VS8lplEosBCRLf6hznB0iPHsV5MW5jjMxEOjqLBL8s72xEuV37NviogfgPipXizCGZTX983WtY00qhqpA+xzsm6Ra21IChnyTexL22ry4CVAMXfJmZH1DTL+VXw43D+9RC9O26FeHu3mpvm+FuTgSJv/dEL+5rff7GqwkRo4KHbCqP0NA/QaKrhn6G8bCSXrI5KAtOIsx1GB/HgkmskrzKLs5780yz9tkpCDgjCSowFKHmkLDpDWPAlHRU/+syxZzVENS6dYZRAh102nXMdkvjrDZ1ZF9rkDAqnoTh5DFZnmWXgckmN0vx9tF/kcx67LhWfa+cmDUww0dCSG6CwBG6/GuPhc3P7l/8sCNWcY1VDC4gEVIEUxMGAwkqvtwO77QE98xNstB8qysYkxgTwld70mXIE/JUM7IasdS38DNRRKhqcUcUEW9Nx8Z1vnhx7m27P6QUO5Bnns+hr8HgLWhvgsYMT+7FNEMN32FgWb8JDpFHlQIIOOs35cgV7AczI0LD44DljoV1uk++EOoJR7G+LbU4EKnQuR/+xAxt/qmnvmp+oiJMTxB37rXbA0cfbDDvdvhoN1qs4Rabi85I+sZygx2nhRLee48iVRBiKxv/DdC46kA2vXR1peqyyyyJEa3nlcXWS0Ywctt1zQGnB550RhXr4diGmQvsN7NVIXa8oGgogW153tBYfCteuiizvYrfLngJy2/qGy40ljw3UBpeSqxC2lXkXyEQE3sriZwiF0vBvRR/bp9Q0Pyayr4L9/fKHJf4+zS1obPAtrK7H0O7wcd3ugT4agwHJ7jnJ04z/CgtCAZTCKtwGhpH71H4L9fTZMpnWTZFnYV2m+HzZNfOEM9eaiy4xYqi1X+SRpsluNbRMaD4e/CXiIPCl+BetKRETUfVYfMyzFbh8Ccgr0SaSo5l9SewzjXiDKlKECGXFbmSWh1YB9IRA19V59NMvSO+v5tttynKICmuJmOWpa5K+32NAq7h3Ij8ToMQ5tcOsOQAM+qsZRIPujwWbTa5D1OLBOdcAavnh3c1LkWLtJzl66vR+C3k38DuGXQbD+MpqcL0pJ2quNWfH1ieouTzTmH64CLQUsqEPYKrGtOSamiVICeWPjemlwR97Rl4oIp8fYyOeJdxx4+x2SzZCF24GHC3wUwxxTBmDn1d9wz9btE/YSVDi1zQJaTWPE3J0BhUOYLtvmKusdH/lOHZiYGpHU0DlfG7WITCyqHjxPU+EjsH6LonisXzroF+WNk24jaPyduxsYXnQA50yUM4RO4gLlTCy83RPU2LGt9oMUHmc5MO/zi/CBXO0l8AKyBa91UPB4FpLDXbsotIISs4dSK55CFwwJUMPYiqIGnufsP1nQtGNjoizhlvUQK1RQE9kyRFx7B9UEDGmw2aw18PJb1XtHGdZ6okP9APmrw5remdzAE3odHLqqQbudKkqSd6X7hp5yEo22Bq0QE+1dypzd7avcp3kb0XRx6w6KIMOgrAtK3ID0+WGuB89vG9CrV2kjS6mHjqinmzkZ4w8k/eU/mGyKV5Bixe+2NmkPIpuwD8YI5jP0PgYkKhnV26Z6jTKMcLS3VeR9ibeAz+dixSG/LJ2mX2+6O9VlEVLNNnnaLQu3YcE/UjmHY5hXNuZQDHM/wve3UUY4IPxZEQ9H8YbijPnXKT4o7U6RtIiIV7IC+dMZUtWSXvBhI67UHjo9NsSi65cQwHRcFDfzds3w5sy53jiuABzEX4QL4Uys0u4bKvnp31KJKQjBGaMVobhXEtLt92pA/zss5yBWR+L4/S5tfEuUxvmcZGYCqOJgs7Jl+2Lq01L9jl53I1aSHBFgh+oUs1ZN2Sr5Svq0yrcuuaUSlpfvBbtq2K/AOZ1kchinzZYyhYr2W7J9qkQnqg5p3SWOkflsRfKrPA1+A9GrguXcLXcwia9wOrtlEtqy79aiH85fN4BQ5JV/oMStqMmiHa+NZGe7PFP/AzaK+mPVkIOXNKemt9QXPvmypYuBAlh2vK2nLURCAPkf9+DwYypcsyrpFQ+Xcb5/yhE/HRCFHj2aidTa1qQYgQPt1GrpbQKa8Ff58iPDDZcvsgaI4W1FA/r2/INpiVzR7Zq3iakTRiu8yBHgYxaALpYqhFQ34SYWSY/eAxdVAmmO++yorQAeIRWX5HTpVqTN/SpF4cfn/Sn9emMatKYy5itvjTfLK5q0aUkRKXvHljxQiAXM/B1Bx5udIaIydaqUaXJuiFaetwpMm13M1e0e7Sew2l2rsG1uiIw7f+ceiXagsboDPaIXq/Ii5frUBUPCFbgC2xMJhLrWazdZbjG1bviJyiSFx3U6uLUGnn+yxdA9FH7q6mcQeWka+5A7M7AyUZuwev+qExirUAaZDbbdICpzupp+lon1myzAGZBISiiPnq7a54HJjTKnraUf7+u3HkE3AuG7OlmMcqZALs1oz1vcKNIXbCe1aTF7U8RDInYFc1pOg/rKu7I/M5zFO/Ff9cPqxfVfG9NHZ+tjcro5ABDNqQnmfSssDYQ99y6QUBTjSA5JmSd4hlbkYpbs1zQNdt8kbqms8VhoSd7TpZbTjsSRZTKEvZtsIn3qco51ikm8xnwnNhAMbsfNNB7OAmhxdqUkmVv/u3Bv/tSv/eLsGcbTTkyuOMgKEe8TRvPp7Vt+gwnXVGDmtQjUVuVe8WHDxKcoJ0AvYluyJsDvsfVTkfyEWkHWADCXpDSY3oHCJhfU+B03Xq0UBF9yIqFR1eY3AbqfUqexFsao723pZpGmemVkbAOxtmUp2G+4MPTUNxzk30glYq2b5rZxGKxlDId/qOP/JTn/3lAtzRvnwu4Pzm9ns9FxORJHguTDSvpdZkO6ebsjK802XrAMiV/Jf2LohZozMBzWdu+rlO2W5cE6WWglFUZA/tv3pd53AX/87nXHQJYo+aBSf90cvmT17W/PTQaIKAEN5K3b56J98Ub4JuGExBAjpuKrrVu0Fq81pj/dVo0NBYzP64QxZVb5iwioUijIlutlcGNprL4fM7dcdaRHVujK6MrOmNLxCf5MBQPAzwm+SpZy5gzVQbbZ1uGv9/+K/guwMMx9iaHi/eIODPERj0t3ZJ5p895GvjjeuL5NkrdTHbyTvYne1M5UtFvd/92sgRwF9J4+zwiNJHLYiAsGtsiur/DWJ0PEkjfIJdZCHaKI8pETS0bWQrI62a95bLyNFElFWwotlv9d13GTijYZ437kA3otA8gEYD68twyAKbFK4CJthboz1rDcA3y6b3cwGU65dBjmR58WrsOtPQCI6eQ8YLwy4Xxg40mtEKJxQYkQ+DbEjoAhSVzDZ9L/4Pgq82sQsBx6v9WCD8GZH/GFtWYNoOrQIK4pWtlmb+41NDfs+q7w//44tEZt8vxJPsMCi/ADNuE6UFQQ9zyIlWDIlTDtaSkoHeyVxY/vl1tqVqEUmuWVqGnVOzzslHkiw4ftlcntX1kUbAG+fE4q2h2dZ4CyYaHAE05loHPVYALREYgV54RXxgYDKWE6saql/u5rURy5A9GV0KJAF5PCn4uR8NvXZHc9dISoFB+466e1wnWVg9FkV6PU37iYpWoWHJHaQGO6+yb7f7AiTrKvtpWvkYt9WsQZ+42BfjBW2Ns4gBHnxpPBe5X2OUiSub0c8lYGb3mGlFve/NI45ojFnFlDGROShR75RX2lJMmGspZS78qc2QIkGgDHDLgVP65MftsdPQl0QQCdM6X46e2/k2IjynDoJ2poXRgUhjGjcl0Zlm/k07CLuj5oinPNzicedpLHy0AINkF3xsZU3iXg721Gi0LsutE2z7MCmMd+OMB9AJ2xHp5BNM64sUFGe64q8WxeTzSB3jkOQVQ+UuEZAAOmb6ewdGRRsObMyys5nXzzvZ1ljpWmqkI4lYGLzS4BM5+qMe6PXA/v2vIMy3vkJZ6j0U5HcsSKTSlFKmvXMc/OV2mbvNgPM5Nu4vqgIWd/BehqS6Ny7mVFQ8yd25soMJ/p2MsPhfCr1oKavfzBnBVosvmTRZMnjUJnPfxzdnfl0cYWTh8q7wh9RlYS7LZxw9EZF42UtCRJD1R14+ih8Q/M1hL5anHnVMI5wnrTQUkXYFnsmRHQvgAhWJ76T7JCPltwT+I4IyOKarI+vh3KsAQP/KVUWJNiJgpLVQZgm6K5V2Ew5I2jGl7kLk83usD+QguBQGDo57l8JLsvj0KGgtMtn3tCy/78NgKTWEFATL1Uvs0APMkurR9+uQDyXPWwbhXmwa9suawvMSw2ppipDW14zcgxS8StggnDlpmL0m3gUs0SOdfWVm4Xd82X3KAAK9bzj+58HbPYms06024pTt/HEDQEcLxI+Umeb+GofdCQofJ9mDrBLfg/VkZgvIit44fIUq1VBg/4iDNCCv5YTThOuUUFycoFmSafx08LTc0LeOo4O6dH17eXwgdT4f90w8koE7UFP61XZRfuiVazC5C4ksTmbXGSZgKYQzNW504MtkTT2gtQfDD8QVfcXAMopy4vnwvM6i100Grc42EAoi95IUfKkhPPauEXcgEo+ZpmJtcBPfnrXR6L8OrRxTOrnYW7VnxmK7+3ibP3khkH418krPGiRDRCbx0ixW/UnA/9iltRdTu1PREf4F+DV6j3nkM8okINofRmP3X9wg2fjnPElpSeXwBNuWVxgjkGf/rANpDO85DuEtaQL/fIXc+QooX7qe8gt3MErS2bDhNqRQk6M0O9gQEJbjWZCFbv/3GnaNLWJq3Wfe73JLsl3U85x0ulWRGDQ6hPyqyhZnBVP7Q2gxY1OkkZao+ARCaMx47fk2Xpk2F2iPOh+EcLU3czG0aPKHQWUqDxSf4gsRkW/7b0SXZwM7KLWj9n3Nsp5TzCWQHFADtftvVC6F2piaR3Yu83mi3aLOX7/YwTeD88m4oxdVkZUys+whZxOF7QE4dChe9Duo+fr375uWtn7L59+b8hCAM8eDajSqBYcZdFTgd0mthsvXDj4EN2PqtNrPSr9FozQTu/90ftf1kWP+ru4+zBFps6YF8bYXNvaXuzBHG9h0+3P2Rw9TGC+0gfeZCw/owpncmVVNr+BkyKgDnjTpLdaK3r3VZJs7OniiG4Tq354vrCS/xTTU60e8qAy1fTPU4nw9jNLL81S2lmoG5ToVatd+2cwmpq8e6q2JFIGDynR5FW+EWHSt8G8Cegxu4y17fUsALHFAs0A7DdhNqrLdCewPtX1RiDNGOo+5A1KLNvBnK6dD7fonfsnm/El+RkHuMwmwPDpmt5pmPBHUYr6WSOQbkIza8sAceHc/R1Yk/WXZc+Qf4ecUGOX4PGI6gQ2Z2fLAzU3G46ofbVQpHBg3L88CnGYy9/5+Cgzw1sda0pV0BweKP22Rny4CjGvJnLH6Cjmretk3jlDHk9LSAKLH/UvDGfTTwWtkkKt4wbm+fJP44GFCbekMH+SFe35R8wLL5mMEBONBiw+diPvzQDc1yg1aB3LXlDN19RLWURqziKPw9zA8QcaJ1hzZJ3uxQMDZ6BJp9bBxko8SF0oIZTpq+sFy0uTJ2O177rNMhNWDhaHQAECSwld8dUdO1QLrVmk3PHbgLB/Pzz71zkTuJpKNg9Av2fVpPePQWpvO8BxPIlvcwUngt/UZ5UJbhQpdO2Hht7eo8/zUE62+R4JXjoP8rv3VpImQOB1nq2zin5j/7t6VdGLChq5VDrzDomizmvrj2z69SFPxRkmJyvNEPZUBhxHss5MSw66/uOqJplM/maKw1Et+nERcJuafVmNFsR1pihT9Di9UPMEqWm4y7GJ+gA8BL5Y8qDKfaSdSvY/FXEy+tS931WBF4+ppzh271IdNT+1GP3oL+LQ6L+AQ3KJbMkBGizWAlYqOG9QG18+ymED6DsCh7+pNWJJQBlZRrQgd8dC/jb7kLrOq3N6FArFTpAKafJzr2Ng+Ep9+YevqURwj9MUrBpuUtlJXeSCOP9rvV+fANTaW5zMoQZzh+osekSHMbK10DwgsJgHEuOqVnWL6nUxP5nlD1tT91jiiCt/lKrLq/B/AMpeXACtmCnFXONB7avmftaRJ4XMw/YrPfRn6j6iKqC2tV070d2PZ5Vrd4r0QWMKmLTqyrD3Lm3ae52ygW0u4A0ZtJLIMS4htZEugIhjKBJxNd9Uf9rmH/KAUWrxI5nIufpFUSmQUq8Or2PkGq0Rs2D6QE1HLkuV9LKsSBFCpqIcIwC0UFtFdfytO5O6Cj1VyIpOPk+n/X52UcRB5hHEsHEuk2hNuoRnDLm7I4UgyK1C9AhHOqEEpJPu4mshlYZ9Ki4l9V1wFO3LIrGQpuXUb9A2nSv2Hy1kHzgvvlj8mugHOUKR02CREbBWOZZYj1SGKCoN/xmv638BloGgEE599ckmzqWu3CdmOdJ1uG7P5uMosF4oMT5B2C3XF0e7a1JVfpn1jF1dsHIbi7AqLfL0zvh8VLWPbGubDPwClqSeS2BWyHnvoRg6oqOxF5ZoX1pDG6ceMj6QavfQelMoJuajNbW7cWWTFwEBVHtxRHQWVyIa4LgYEemUVtNQbnP0Fyy6mIGMkKpe9QQkj/sbheCuSXb/xakGrdUC8+mAkyPlonbcR+/5QM7GOGvWqG5juWRCPg9iG57YklEf7/xpTmtF1H4ycYUMwZbAyGy8JyofWFugYStksVsJ3NIZN7mHkGtRhvKAUi2JH1g7fqr5YDtbdtXm9CT3PYYgxhZHaER6I5TMDTDOoci+omSAsMRXt97PQltWyNL9ese7hsBZ+od9smRnpPMqG0JiaoiZpok16+8kdu3nNp5K5MuL/kqlGmYAtOXtfL0OlSpG6TsWwtbbbMiG2leNTjVyaUQ9kSD9KJGjb7e/SpmzlJ1la09c4B/t7+oIGYLwn15ebddHzTWgAnPZIpu/08qv2FLaBCkb3qO9CcTlB9lfFsmDUI4ZIb2kd0vFJzsmIGFFBFKfp+e6R4QHSqgpABWMHU8an5P60hR6xxqpxlOqNXXys2ySc5fn2FP86jQQ7FyLuNHKf0yO0x+CX2aCbmFPyP8PxeuKorfa1q/TG/AtHeBnAKVMspjr1sS+id1SbGP5/B4mPNZ3FZ/5LYJZ0YwLIZ7ErR4KTTbRfqI0z1rZdsDI/ALVZilyWoTT1oyDLdVTTJM/2ncR1OYnjjbC6CYp6dscySJLNmntyQUyJqflXFiwNO55v1NMoDkOw1OpSP7PnDxwEA0wHXtuoZOPDS8V3xxEZ95koNj5bx9dUEqGm+FwvA2pjU4Sua9GnBSuwPH2OZcnLDjicOLN0zaBXjihd9H+xEsdeYjIoVo6iWUmOjhsCCZ+NBtHim+Uh8IjQMIb4laKLalJnHAqq6YEAfOu8xP0nGQkHFvylSWkyXgXipN+QIrkWOS+Dk/zkuNWuKD1S9WR68vq2MCdwWcT3XvWEkcSliEp/AlpRsIEl1hW/joN3zuIy7KJ1Yiur6gWWv2CvOKCOEtlInNwriXT1pCnB1nrBXxoaODVUEw4qqddBqyWVzA98kcGrEgLnYU2HtcenF1rSuTUUZHj+GhZE/7qSOUJbKlA+oZMHzbaCFB8U9b1/zGj19a0u6MeTzBZv9AW5LnFt5+Pb/Jf7FQHJGLW3KK7m10iDARsxKzG3iFVupPYdpjdZuHDTF/BluynVy04gpP1YteunGyNg/0ijg+nus5t3iuA+8ApINdWDEwtRURlUbBW/RCJ9+oJqg4qRaM6gmmJn3MvzmnANQGGGmZYpUZQBFtJH/LwPnW3EeI96rAdU8CR+w3+lHlHU377/QftBWc468eVt+m6s1Xf3I4g0rIhWogPRwyGyzJ9eXx3nxuMn8NkXeJEMUWwjRVm6j0NMe7etW4aeZSq9m6HqgjNbpvBZgGlcwaVLfniEq5btZDSf7xhUQnFic+7sc/Nmw9Gjm9L9AaWcccrSGXuRg9S+Gn+7IP2NKYsKcV08awHfq/SSrFH2nm1JCn0QyeFPcgA+g+0Mu96hdQtI0e9yzaqXS+x3xwT0zuuLFdFigkYXwPQgeDi7OUCyJZqa+0m5SQlhYocYy8QsIcAg20IF8u4FzDbPJceeTFSQ0jHwNYT3aWn2uMf6rJ4E9ygh1FzPr/UJdVtHjd9MQ7PKOlaphajAQ6Y+BJMPQpLVCYDqbIsIOBYtagntMb4YpL/qdwJ045Y5c6rrWoDs8m5DxRvZtgE4gs0SLOvvRWc45CNkFUqM/6B9rdHgW/Cev8D9MTy/ni5bdDvkRxAvPSpxUCrKaYjBawRjNwXxdr2ULPNKrRicGs1R+Nv+DYU8xymGkSVQItphNuRscmLi6Y48huWR4ZOfSoUB/aE/xkgSPXatlT+aabAc+GenGRHrzmiPt3R5MngBl7at0opQyuFoaB0Y+UjJACcfLgd1/rj62Yh3EYFITB8IjvPJ886tB87rgOpwRo9xWa0QhCrOakfOTecfedXlSmazlc68ZY3awu28z2H1Bbwe4B9ysz1il1BuJxGv3FI9/6r456pglY1jZ3LTCUWsJTDg8+U1Efm8K8o1+BmaXyDBAkmn+7UfBpLAjlAw10PsZ9Z8eIob13HkWWN6lRcTjreFXyepceBmbtpE46oiRjdzQj33G7U9ZqsxYrJvK8fM9rIGw9HcvQ0sGs2LK5pyVBcnCLC5YxWe/u8DMC1muWBgw4X09UdjH+NSqjKGwTHMb3IHm5lNXbJcNpZrMG6coQESME8ntUWTwkQo0NA7GqKEPRQopO6BDeZH47uG+J2fnRqcAVM/X+5jkTLuDVu5z78EtqM7p5YT2bSb07WqbXhT2ByVKqk4s/T0q3L0tEBRIcIDohiMlsfxbf6Ss6R7eQ8TMgZRsHOn4n+ZXdSHSXp8E7jbnJMyf7hs8CCyzOZkMmPjT/O3RkALgyFs/yXkfva0+kN2FzcLmuogI8b3Rh71Dznj7VliNu7eS4p0gh2dsajFeHm8Z5dRjFd58QtHUdJ+qXPk8Te7AoSMpeC8IHFE+BvEGDf+xDXfl+IIsq++6rHPMmNq4rMma9yLkfg1n23+ZZVkFRtWB3IjmuUIaUP1PmOKSwL5YHItmEwhbzKRUPoI6KooQCsa4LQ9lrm6JR88ZURcvaGvkYx1S30s7YP8WFcafE0yyZtbIyHP2amYfZNFdOzuv725eDIk97uYO6HccZco9IZntBRSyaFRhqQnQsJewUQhN38iXIxQHt3OAj6uw29PUfBlSON231AXW1xxr+kdFzjmqpDjC5scZVxRGoNYbf3No6UHohegFGb5z4dv6HsXnWRFlNLK04Np1G/netJVJlO2mK16ehK0ljpurZPLvkHIZiL5H/tP0yVExt1mw3D9gGet2T/eG9pW6N/dNcRbusvsUlyDm8eKtS/ggxuj3lYSAPlbyeYwOy2A8lTmt5LBqYbA6rcLPVmdxDlKHbWygVlOMdFQIrdxmfTozHYZ4FQjtM/1NEvo8zh3YEegXSRl54Rs/sfwwEZ3P4flQG+JOFbqhL47OmXK1f8h7N4rQNjXqXNtizOvLjPz0Iv/UoV1FfI6O9sDDhtDrj20lh0S/E+7d+a+gGe0VwWMB+cMfs/0/XBAqpR88dUOb1p1irEoXHDqUW9KZBr0MCxHWwpC/CM+L+1/gRhVTuhItHQ4yzj4Wai346pFfKQQNw+LvIWOVrVihGk0xONC4xR8o55Eh3tvTWqxJjPMRxw23vF1gwKvQOWN06Ijt1JnPHsy8vPE9Y9oDwynzuHCCS3AywI4fh9xkkt5K78H4jXRh0N9bfrlR0eLyDLdUQDueruTnf0TV/CzDfi9AGRvL0O6fogbrg4cRS/omml3pLQkZICoOZCsO+/xgWvLArZocdN17wHQj0ZLlXnSFJ0XhoqhwgmQg9vBJDGh2Ph9xdSeSh3t+42+DdsAOhkY+E0dtRn95GX2EN/9gnZlPHhqkb4fZshSwal4ZM8+yQpCxWGP+FI9zaemWil4UPuyg4quQjQuLDs5cGPAYVPzyy30LiA1WNyYcNQLqFtyQPI4LUD5NOSQhAcRP1yLa3JRkswEoKJJpaBKHdVq/nXxysD5g4Ek5RYgXXtzvpK96j/x0ppKjeVI2dnNse3z0vkuI58lwmyEr+LW+QKHWFsgek6n7Di3NwFHEyP7yNep17Z5djK8HL3U4Qm83hDra4k2Gg+KY5afmBDTeAiKOrjh4Mx8ZJacrc7jVwCfRBZBmL2zP7dIfL7R84sBsDkgGNhbanf9So16WJ5sekBRPGNtURZxoTFNP4mR+Gc3nTFAJE8fkF2uZzUcuM7f6Lt2F5hkVoYvpAaBOUdPLeT81ZG/O6Re9XJ5/1GUz0JHPD9YxX0EBV2kXciPzGO7IuOGlbRk9geX8S1lW5xxq4IEtHD+WujPjlZj2OSwRFNJTRqbujzXooJVoi4YEt3DC9REFAs6AAAiN4NsKYih3WIWdSUP0vtjRlhTq0pYyjYbCE5Ox1EOTvnwuixaJ6RmseF+gAAVHmJnaa5Tca+emYzfn7RRQJvqtfqJ+5NA3oEMeg0p5fzJhF2KHjA+GWYFw4NFC8sdSpqbX6+chV8si9/aaJcMC6ylTIvIZLLoZ00ZfV7fO+A1QBXuPm20b76n1b+3JKzp7PPmcNqtVrd0RZEwUt8dNFAH3Y3MINmTzPT1sK6CJZzhITJwma0b0uOmQolfhBYZdA1OaWndoZ73jk7TVyuPJC2NyuenE8OZlp9BqOFZaeEwXwCC6mXjHhXFmlFztSPIqEklEGmjC42SvuwQ+/HcK3MXi4bzqU178m4/Bj/zYAbCXxGBnqznSPCNr3V7e0MAcqVwDQWB4ZQJrl70r7t3fpni382w4nL90bqNBOXX0JabvO8shZ5rlixMdefZSsnt63jmP6vrJPQmAw0jyCz8qY0BntYXBPfJQVtbxKqlBIueX27fNC6U86AjgCV0kw0H+/dMWKXhrv8fxf5Yf0z+mYIP24Yz7N2GL2brGZvwhEdt/qEFikmfDS4lFUaCZ9XqyDc2F7hwwX4kszkxdTFTuRUKb/K+jEexGrIavBxufSTmjC4JuejVri5q+XD5vkAS/479q8aMfeE82FyTC9aG9MV37uSiJUF3npxwPnyQtDJoGALkNlCGbwLDXU90i0pU5G0gfFIwAcwLcJ8flpgjHItRImxRfP21WmUEN1RLFd9BrjGEftcZ8kaiHqLIFvusd/DVdI4MOrBTFDEBTw9WlOYKSOgktLLV5AZPVtVADnJvbFGExjh5qgmR0K1IaqaOygCPz5xcSo4+yx1PTYwgjhau1IlH60+EfVE7WqXJK8aYQaN3rQoo5VCAkk38foR+ahCi1ckvWk2ue5tEZ8aFu4klDCJP4HYjS4dzCNckB/rzYo013Y40SWUVHG1eAsq7rYZPuiWXSa6DZw0Cg/8w5tMYq+A6aYT0Z9Dq/ftS4WRccCf6DfICn8TKgDmYuhrHaVPKfGSNb5p01FSj8yb9obapfyQZ0kwaxpcD5CjiWZQAYyPfp7Da/2VEYVMQ0H0zUx/EpZQx1snAq8bD5mFINnp9QoC+ThJ+cWO0MrSOsx56ynspNQ6NWAydT9AfvbTqhTVwR3gCZvjaX78dvzqJGBPPGCaSKXSnjSiEOaWggbn6GlJQaBbY17BFUtWMgsEg6ZYOHnfkyobtLwGYqmRTfzmWGilbGWdI8lzPrZiiMetoydjn6SD5Gkyjzh92E4NqzpMB5DPy+SXr8ZHr9njRA7dRfGbCXgO6g0iOk/pxxbzWv2bT8UP7e4nZYJEbR1y8w1KZ3psg0M+QMwj+fo3h1a0XPge7x9fYI35I+05UAiqX401dM2P8NyfcJnqJWRZj8k60uKt6CM8c3psi3yjw1H1EEHsKgIy3H+SPIQDSjEvZ9dy3ut7yEtIHcrSFRoWGIiBjsXU2vpdude0+Joi5ZfzOXZZ40wHheYPaconBTGo1C/CJBHKh38YjS2/4Qe5ugYTwA1oE0//ZCEJqXKc8ht1xHnpD4B566HUq5pwpCu8yZDC5jk8/ogHOwofl1sbbU/kG1mBIP3e4alMMLxGYfgC57bcmtQYBjMICv9BnYsxCsDbzjlkbkNPQ4mL/7vIXYkeWPSvb3rxsy9bh/xSgALy2Yx6rxsh3ipBPJ9jnbgQNOFUFYlaSvBuyieCe2ba5YvAbhKV3pI8ir99NnJR5MVyVlLvxgCbM7S7zLIxATFvnWEhA6b7HwrJ4+EDx8UYocVTtNtAWrh5dFAYZBKPbGp7ZoOZhfgfwhHU3kYdqUEhXmfWNgNUEkHSML1r13fKTp1jObyqPbBxPyODXOKEJLcm4lmGST69rgWaMc9oLOT2oDw4jhiUBESke/Z5tjL1cXg2YWnpiOCAAQaPB09UqoyMPx4B0cUtPLR2ywxjWFgiOZL8RKtIe4k0zXOnCOs9fdGlql1XzwUtlcaMnwsJeM+JWAEYTyJcxHcjBuwTFYA1EEKJUUWKfgCJbgK3JP1opCY8IK0EDnzk+Jg7WEClEygbrl5fuFOrXbPTXNg2BsAhcUmRCOWTDVef8si/uja9vN/lyzB5T/UpEWDuTCNBi+Pp7R/AUl4ue/IMY8pogeZs7cNgZVHxybQ04zq6VK8/8KJKpkzhBbjLdANouKaOGnXa0ajdJPU3H5jDcHcJ4uI0EAqJFUix0o1kr4yNqDSmhLF8UmIlTG6MN9LOeGrSiTC9epQsE6W0qDlMKMTuudB/EOnbNTJsq7ATsxlUq1Bjo7daEFKtBA/80j1l7WJ5mNA6TWRRU4YoYOEKSWNHjpZBChyT2zqtwnLPlsbrYSlTQUzmn+zIuMTakzNQU4V6YDW2GP2X2uLgL82gU1SMd3jSvQ8Fkhv9kqLzQveUMk7t58mWaIqDOAlZBdY8UaTPsJynklPDQNxrvF0r3pMDU8PeBXHNlFnk1wAS07Dfi6VeZOnZDxt6FriyLmrcFMrS0d7Rwf2hNKDdIaXqfloAWdb1EI/IGUbRILU621bxIu28C+TJ55eqGMhJrXpO7O7QnPrINEOj69pUBT6aHuJ9thHQBGJSZOToI/i59ZJnV1fLN3SOCCcARoqj7mylYv7X6CM80q90tefsoPGpmoY9gu7nuzcGQMg3FDRxVFh7TPn1MOeNuHSMkBr4OIvt31Ach7d/34xKYhinH/T/OiisiuFIo5xyUj2onm5r4EtKngEsDq13OGVADu2HWVLTarTk/nAZuqjr9ran8Vtnb/hmnfgmtmiTu9STqnSsquxFIc2iksx5Aug9HLzNsnakpqbAgV4h7WOmQahCm/+F5oBekUYedF4WGH4tk9mz4Ane56HbpRq6EFQw1o9t6PXfH7dYTBRGyCAEeazqBx4svjBAz7nQykeQQFUWF4hSkciulz7p/m1nla4SjhtjHFOJa0DZ9eUyZxWLw9jQ0D3RXYgHufVxvhBolfdRvuv+6DWLb7Lx3zmfdaMWJczl9Wn8fEmhu9oyVFbZM6sUM+5Hh798tGLr/zaYplKf3lAFqs6CnjMm8bbaj6nrQo2WGDkzANtOm+HRB+4lkCRzWTRa6KmFHcYL/UfP+CB9w4YuLjO5cZ2QaqriQE1aaCCspIIbWtQpBIFEHTpLOxY839lLpKXz6BCgunUTCWMDuVES2AoQuXX71SiFbpLK+cNk/UKlAvNEwgvT6s291ZZqTttoUrwYlf4e2QMAtJkovAzrtTCJ9DfFePv1roe0EsPV7Chp7G7HGqtLqng+lv8bf9gOLK5uMusgKL2QUBPFEH0gwYHSpWovCcquRV8RU9YT94ZT7bbpENEUpECVoQzoS6yZJE4DjtXNp8nUzWTa6sBiCje59xP0jCgQ9vgClM8Lplj6+dte9Jb3+NhsgwEWtP7jiEWsvcmJ8OPJUfG0/pziH24XAdXHTu88t1pR7emzQZlrRvs5KLZ++0h9/5IicSpsgBxQKAmyZookIX6GhNOndVpUV+VIHnBkIcVImjrDERduUZEDb1e4PDGaxH7moINRcubtE9ZNobTt/VRLZBXOwKRAiqsgaoPrTOxxwgttlDJ+J9vKFmBSXNeo2fD/we08gNL7iXEQPzONUprSclnZtjBdFUVhDIBNCVl2wPe1eniT/d0u6tWPCFdNUBXle5mzUqHGJEMersvQ9yCjMTtIvtYqsyTuuGTzf2SV/rkJ+oSrBjO2SdCVSRtMQNhg4HUFGkP0H1wdOYbRzpoFCTln8EXWok5aCJab5lpLpYK9fYFE+p0XyTjksWMqc6ov2gPvj0eVLOl7q5xg41/y6lhde0A0+YsN0ZASNiKefhJMSmTBLV99jW/NdtL4ZTkQQPJxa8VAg0JV2ndvITXhf2S4WIYySpp70Y8aQAJnyTvNmW8yShPvpq/9N5uoOADeLQUL5bkIrw+77TZQ+hS309ycMi205//hKUohTIvV32JZ8U0Lh7QAT45z9CwPA2Gxtlq4Ol/hfTGYoBjzd5KuPEzb2w/Ti0MVL2JB0Y8XmEv5ICv0DFjySO8sGMfK50OHkpczJkVAymQ3qkYJasHJpryeqUN/bFoLxeFqTY5NW851/OhAhMV99Ypi0OtPp8EI82k6KOB0GqLgbKeaP8NLcG14K1qTTyRFiFxCPbL+ZKjkKfWwlhfjWzVMKeaEZEJQmXrtAVOqs//9JUB35oDrpw+mt2g4P6HMrK5Ltw50ONlPL1cvX7a/WvpupIjlprFtzxinK8DjFYSE4JgfcVvCVk/f720jAVwGph2J40g0N3r7bn7Yt6azEQya5Up3CGXA+kNzXMJ+N99ZlO+6Kf38rGTg2cedwwM8538xoai3PGoyxBQoUC8n33TmQF88HahoV8M7y71jPx8EaoSwBhT1vJQQO9GQpFr57CebAJsqxKeijiOIPGnaA32eTC3tkWb8khXI62SVrCYB8tOcah2DK3gsNOeJYwvIOTJUatV8lkcSbggZ+b4praScyEBki66cNDmp9jYQNtEnKjQAjfuYr9245UFGY1JeyE3tE0Hb6ANoWGMedClvfCBZVu8TFysS1RymWjfUJyIVaoBGLMf6LHuT7QjdjW/b3yh/8i0ujc5xM6kSkc/KtivntCjHhUsu3fveice4RLdJ6Cx0+lc6869hi3AMCpfwxoIYjOKY6Pqeiy3hb93V3WT1zmqKu7hrsaO4ZK0cWRJUMqz4OLHqrMxR2bYA6zb0MCqTaoW1cWq5hTV5ZKqDNdhnGz/6wePMCfFHqnbwRGO5JtwEoNTuf8m4SKKNPacnH91H/OORewR4dFMeS96VyI7lL9+ODXgCEyRuMv/mKhjovbvhSktuGJZnYo5MpAAsnT0/VSDcITFEAOVOR8pwKD29w0VUw3pB8gzP28M6docR5JJeUFwKOsg3M8BPTKW4wIFFLsoofi7VHapy7HR2l1D7Dlqp2QVdwhhAqiIT81wqvDtMrGaIV/fQydlbOtZx8sXZg/df+Zj3Fe+YC6cXf5PBOR2+cVERbFVLnb49PnXXvMDFGc0Roxtg+GSZ7duv4UZeJg0RGXRkpgA8IG4o208aI+3f5ULyaqYQnQmZebfhqEmuwcFN7LFEBTp0N8SRkKgZdQl+z+z/V1S1wiSLGb+jUdrdGkAMwqvueH95hSZB3npsnMdwYlyeOerla8yY3MBPGTPa7eOFEQWjPlTagKZuOkH+l0cpvNmtT+XrjFHS7hTHbZRGLqcu7aGcZhz0Qh9KBy6xZD6aal3YzbMy8wQemMAq5ivsjbI9cUmK81zIM93MQZF8vLBupIaX7Ca0mDqRHMjDvvh2U0IbkNzZfYZgT5VUrmcd5rE5B0nBevN1XB38u6NIXvPXXFeFDvoYKIqwFOPN4UjcK+IuT86R3bh0htHyTW1T/OO+CHQfXpRIiZN7sgCEYEF6fWRWAdCkP7NSgdO9dBw5DqGW8tkFEVcEtkx3F6Ve6MRkN1g7YLGcquSlaEAYMGwbEo/2WnxLaZw9AhNAqa/B5cSTcVlVjfZKiKdBUdxG4zgRMx3GQKjCpYJ+7rOKNbgfMnQRYpix2/fi/yM/93Q3PFzpYjLnYorSyY1mwlCKiRtAfmpIdhxoR/VgrbTnSIEUnjLS9MQ4Fd+BXiOt8tAwdNbfhs8XfdmA2arP8XB1b+IF7NO+mt9V7nWMCgu5/Kh6QH1qUpJMqhsicMcY84yTL13CvY+fspb+f7BDmL109tJaX4rZrp6dIx6MYsL3pIX7SjtcaGii/ajyq2QdguMGu7pBsDW7mc+LMg4M1cr2l1JDfRc91KxAhQh3VLgmPLZLlCaORC/oaoHKgSHpMv5qqyFGMaPnjqXtIINxzK3CURJPY5bSbmER2kw4Wmr0spQBQ0VMj4ojafaccf55Z09Get9QQhTwrDMgkFf2+P7NUXiiYY1qmh63Y0ajwrGN+qw36jClyT4nfKLCngCGicGHc2MifP5M2ylMBJHSIT7VGcHlLmO92liePTMWdxaZEznCUZfMMgML/h7FURwHY2y3CgBUwSRC6a5vzrketzZtXBuY+eufmiDv0557PDz2WMuq11APepWzclOxhaSEaOOb/+CqYRflI3PHRI6NRfNika+WFOd6IMJRLy5bJRysfvqz/WgmTa2Dzi0x9cr1wvNhGukfB6gC1v0A5Gx1s7MjRI4w85yBAVvi86JiDrsKH4VGekZRpjjTU7VhHLPcSGoKHoOY9HYBeDsdIcFCfLo/UFByDABjCJ504/nSNPv8iI5tH++mBkTAddH9LcQVjYmJm87iGt5AN5Zzk6oa8tl5DgJZDOtZ6n2noVya6DM1EzIW+NM0X/ot5QmHl3q1IT+3umLHSMKWZ+nfF9s/FI7tpGcoYZgnX1Cuf9Yi1MsnFqjznWu9XaI3UBVD+IlZ+KE4mIX6c12uCEfHOCd8p6LkEvYiG5Ma0Z2Tio/+CgPBpeQNFKgQQAaqpjgOgWCEYuwu4IIljghDP8BxV2oJXTtk7dbwxFuScst4QW5IGj2pUs5i6+L7Q/SVU7x0oPyOuepGlLTAJ7KGzyqKya0Wth2WGxbDmeFi69Zy0VMml2V0NdA2EzDmxxXDItSPDVvigU1YyhMVuQQ5NgLDJSS99rYWjzKikQ+jjzwG+tx91Wko9cKuCaLSM5Q2qwGaJxuM/x/jSc42H9WgGwdzWOD0YpN9uAYDD158yc4C2wbwiGKrS3EwbMKBNZvX3mbhm83J0n1E9u9J1jox718V/hM5FBX4GXEFuKBpie38T5At9mE5j+5amCwP2hlFAOSqi/AXy9cUh2PHx/AhOVH8ZUdEppvaYw+0QrFnLU9O8a6MI7qbJLDsgv/UsMo48Up3PpK73fJXaWcyv8bhBOgCHwumm75ks1wGp6fPSeuw3+ckWaivQ9R72Eo18j2XR9D+OLt6NZ9OkQ8Trk9uw9TJtFFOAxM3nBPwvpPn4L5XEm+BvUTYWaujWMBFbpuVTl2iILmKzNqIRrUHy0SDMnyJxrF7oBltPZvgRdnK+qX6WEwFc2nmxPmNGUjPvs7EmvZz27Zf4eivy9dyz6BmUQ9IBcd6YatnA1c6dEPsmmKegwBAcX2RdxAL0jA3k67bnkOKpJOXHigwFJmcwwHYl+MkXQddvlGqki9P2X1qwTmdxPXTe0XTPrMi6/8QR59Qqy55gMe54IuD3xBEKY1uPsF/qMXqKOMLKtk1j0j82ePC/dyHji/bwNRtrbw4y2zl+Tz/E31nqj0y67gCFb4+Yizs5vPq3qsnfVLbQ0uDMAKwGpPS7l0GEigz1WldcSK8hbU7yjiT/UqfWhlmnC4d1RzEd00COi5uik1fe2E7PONPWPUE7cA+X5ZRmuv+vskGHeSyDRSiTNztRgKi52444Sl4S3CSrF46DAUcjjMxxvLQCEKZcwiAzvT/FTtufaI0Cw3zfU4V6REWZ99ZESX81pCQkF2yxgsjShWmso6qLXlGPJXGiV7im1d716miMSIlFq3THKkqejNAKukhw2eGKFiqlqEc3/L2oCbjCdXraZJrcMjgdmJ5hYkRsrxSuHIAaetKyrjvnMu3Q8RB60sVAMkckBrNXjKdWMkmR00Vlrc8STAY+fsfveKx2FCCF7EvDa0ZCtQi1nBYzgjIIsxrRUD5Z8vgd6e/EQdi2g5gsH6y8iP2Mppt5rfz6KZAShGpWkB+wi8nx7gyCFgGmLVuN/om1bjNAUud73xgr+YNDsZppqvQOHV7zLcJOqrpe8TR5YiBupcQqfm5cPSjVLJ/ZxfKF+lhNM5bS4/IAucbWtJxQocDT/EdQlCZwsruvamg0WYmQ2ZkQVkRpiBtQ2TQO3QRPrfmsvLzA5DMux3l4aQxL8lo7DPnJSLDDotTryS68ZbChby4p9As4e5+D2yxvd+NO5WTb8b6K71YMQUUazx3BWu8z3r/BFeQ2b9tt6vwOkaUuRuo9MVQ8DXP09FISJ3fJ82JKiwhDsacgZUVCcw/Dz/MgEqNRvKDWUvSoZghVExBD/tJtvxC7nXiCn722hB5cCIlgI8dkLW+YNr3Cw+SI9/OFFJ7t+z3ZZqdAFRI5Eo8Gsqz98Mr8KvJy2TWWz2k2QtDabFcRD2CAcjXwjrYb5W/+veYYIfqbDwAL9XLAmK5uoAalRFUx9qXcOe5qYvdRXoCdG16eDmkUl+xdFR8IpFVRQZej7sWPjYHqE+Sa227+jTfZofR1lpZuZlOtblKObEV1UbFF3qVqyCJ1EFIXVbGw0NRbZzMt7i0UaSAvYcZHyQiE0HCcVBOSPO1RrVKjKVQ2WKNxkLNJN40iDX7h0GpKQlbHsiVFhXI+IK4+Lz5dZTq9QsBqkiRfuKPf0amcUMqmKxc+xLg6o5xlgQmbIQXSVOWeNzgPvof3xSki0NkvZkMrwW2Q+PIVvGLx/gP8Bld4Y08H9CQX+XhqkH9Z47LXlx/l6WPMPUNspdydjxO76nW97wGZI+Kmoo9stAg+6W6AgRXFgy3woaoH2z5igwLonikDLyXhQDpc95YjMlhg0fJZFtzdE2BWsz5l24Z/g4wgSMi2NPwJ+DWP4DgWLBmVCvtmJEn/48TVMcd9XLcVJx2QzKZ217iFRKoEx7tXvPnOs70+bS+CBRfJtDF+Ea4u7B1OATrWtmTabMdFrqnSdWEKPb+d3s17hLZm7dr6Biu+evDZGvwmOVeSsn2JIUIu3+L1pUNsvNItqVfO8CidybvqE3dfOzk8HqZTz8rcwk4jeRcrpx/KgNMFVHy8IzjWfzxV/x+tacBAo9zdqHiQKASRQvjHi9UNNK+RoyHVK5CldU4A6I9VEdEDnM9O7v5FnlN3UiH71c3OoF0fVFBU2nwlXFLR62ZHC8BUizbR17BQxdWKQ+3UP+upG9izCIfc1dgUNDaNhHotYbiveFcuualaLlr8Es4hs36ypONSC3IJnPWFJO3JJAAp80bp9B/KnDB74dhduez6zMFW7qdGcT+JWwu0bvtuxxpNl0VPaXAk0TJsimpgjwvGByNjtf/BN08H4FCoWEaaVe4YyWVXbTng5zXcuzZHWXLVwRjvw1+k5iQF6qfU+D0Y+wbBDrzW2ShiAJoeYjZGnzTZI/hdpQlNkDOxtbejMh/SRIaoRlHiVHVBaFEoid82wp7+uso2gfq8raseIJlOsLermTlqOLQEzkpDjgWoh+tkKeboL++nNHLKupGC2NsUIkRx/Eqd/d9qWq8zxPHlN1l645B1d8d6SPNwY1yDiL6UH/zaWxH0MRQtjuh2ZRyVntBk9NGklQREtapZRj4h6VAYb4MtHIH33Boa3YFKlTcnO3N9pHuWf6LOrCtKCF01u9/VRIjixACMBd7WiKNOWNPvyfzf9iWjqnrNg/lpbHYIrHXQTion7bJmDuMA6zCu6Dx9A+txEpk0M9TNq4oGrt13az0FN05UjOhlraq4WOj75LPE4vqlqTlhxVng3I7En3kKwTBRT28sKk8LtPo6N35BbT8CwrqEI3QlnaI8v/AI4Q7QwoBNyQ7a1XNJWY21q8JDs3iqvQTKrSoV1N0diKMjDfYrf9VGV10L5lecgml03VTOyklWZbXAUUt7FsFGv8cyNY6hBCdPTi6bNnBekqA0UFwQzF/nKvCh1z2Ub5lwx6fIgvv+OZAJD2bGNvoZn9O8TIXEvOyLQ4XhX6m4nE/9C1uI7NqDK1v7Os32zH+9KhH59cZsB3D6sKApgQ/yM3X9uY6nkpF9XAnYiK0Ps7yqvc1QbT+UfdH2i0kpvpFFkDMZRU5M/edsJMiOIYrymypEScoR/XpgEPOPlxO1CGXb3F8BW2gwVT7GmmZCXIRlDWwg24yXQsopMb0jPDgLeiEjm6mpsMzapFdQ1h9P4INfUXhUrzhVSEnkEn8fZSWCfvw9Rmhtk7MsHP5C+4gHLqQTvi3QnoFnuL6Xcu/u6zNczjf9+LcDzUDbBcKPz6YWFY9j8GPblx/oWPVEZwpQIsKc5AU93ERMkeyP9QiYQ8CamWOZWrpdpenAwfND/DU8Q87t32/ZXTRjKRcBCnShKZQ4YQxBCj97DVdf5NTJ8TA4G3UnQhA/raNT5mqGVdEVtpY1Mmxr7wdRRXJSinWUHvAdsAwZZtJYFt/5XnRDOtAPArjTmoQZGuuXFkjkwhgnSFRPyf+jxm/UbSIC0Hm6G0xW4to/q3i90BsvyTAVKCakHmIONPWqml5/D/cXnY955gFZqvYnsQCJR6Y/S2AuR+cdI35C5Uoft28pVbq6rwi4n1j5PkJ09hK0nkqLmkJZhW0B9pENqmomt9f6NHZDNvHvN0t0VUgf+9iuxcqwy7GexL0om8LMFrZs//KGnjc3C3+l6eAU/EXF6aN6YbGYuIuK5CAPsnSe2TLHT06JoY7iLCvtONfU9eIuZBUWknbZpmiy1aPlkEjdGPBKMXazvFlQkTad4rBx6gtEHknu1jvHxbQNlKkEYiL4h2Nj0daFoUiC4gvH1AYO7Um+IQjCF4j8j9060xOmt34hss2xLBNXZbOFgEIj1djk5PCpv82GK9vsvZIORIrCsuSXxbGtaRojvSmA/msvsNyQdJ4dDL6UUvVdkDACYZmDYqzkpgjeP3Gi6NgKPQhYIDaAmCdchBhxkBi+BAW/h0jl45DF6xHFlVBLc/aGuOfQY7BtxhQS1ba2fd5SPDJz4nRTXJfj6Vp8skpi9ZeAYBXsVDNXllvEq9ayTL7e+stO8Wj4/cYkopdbwmzn4S/rv1xL/I1qpL2+Snm4FMLXpFvsOUNvUDqnt9iBEKu213SGsW9f7NR/wX8idhZCilL/P0kW/mEvququceCdHfGZeTtqqmbnkssUQgdSWpVukn+qxKZsiuSzIZBGC2s9qt/Yipg0HByJcaqFoLt93hMSfrntu//z3d68oughi2LccDnrglp4bd5LIivZKNo9hUlgB/Ao7nTu0l6CBP0WA+61saTbg9sAl9OdhXkgAmfMvBFaTfqfCeAeQJVw7zRupyzGZ6NxU/yj855gfxNk3okC5W9CKwgER/K5jol3DmaCRttf/POt7ts1R1gry5bbtkeQHg43vuZSQ8bvIqK1rkiIZ7YLxHT1I0gXVzSYIS0JOOwEbWw8EqwNn7K0Y4mG/T3dKMin6iDrbZt9jz/tL/62esiiXNo4t5mHDFn7fZVs5iQz4vq8h4NZO6q9/Tga+8Zgt6Gc+w==\",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 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 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 return{profile=body.profile,version=body.version,size=math.floor(body.size),digest=body.digest:lower(),keyId=body.keyId,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,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 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()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 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 record(\"check\",{direct=sent==true,routed=routed,error=sent and nil or err})save()return sent or routed>0,sent and nil or err end function M.download(source)return beginDownload(source)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/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,}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_authority.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local auth=require(\"ceetos.lib.auth\")local M={}local PATH=\"/ceetos/data/auth-authority-state.lua\"local CHALLENGE_TTL,PRESENCE_INTERVAL,SERVER_TTL,SEED_WINDOW=30000,3000,15000,5000 local state,challenges,sessions,lastPresence,seededAt,lastSeed=nil,{},{},0,0,0 local function now()return os.epoch(\"utc\")end local function selfId()return tostring(os.getComputerID())end local function defaults()return{schema=1,term=1,sequence=0,active=false,primary=nil,servers={},members={},seeded=false,revision=0}end local function load()if state then return state end state=store.read(PATH,defaults())for key,value in pairs(defaults())do if state[key]==nil then state[key]=value end end state.servers=type(state.servers)==\"table\"and state.servers or{}state.members=type(state.members)==\"table\"and state.members or{}return state end local function save()store.write(PATH,load())end local function directory()return auth.authorityDirectory()end local function primary()local ids={selfId()}for id,entry in pairs(load().servers)do if type(entry)==\"table\"and(tonumber(entry.seen)or 0)+SERVER_TTL>now()then ids[#ids+1]=tostring(id)end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)return ids[1],ids end local function knownVoters()local ids,value={selfId()},load()for id in pairs(value.members)do if tostring(id)~=selfId()then ids[#ids+1]=tostring(id)end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)return ids end local function onlineVoters()local count=1 for id,entry in pairs(load().servers)do if tostring(id)~=selfId()and type(entry)==\"table\"and(tonumber(entry.seen)or 0)+SERVER_TTL>now()then count=count+1 end end return count end local function announce(net)local value,chosen=load(),primary()value.primary=chosen for _,peer in ipairs(net.peers())do net.request(peer.id,\"auth_presence\",{id=selfId(),term=value.term,sequence=value.sequence,primary=chosen,revision=value.revision},{safe=true,confidential=true})if value.active then net.request(peer.id,\"auth_authority\",{id=chosen,term=value.term,revision=value.revision,directory=directory()},{safe=true,confidential=true})end end end local function challengeProof(record,server,node,request,challenge,expires)return password.hmacSha256(record.verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(node),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end local function sessionFor(name,account)local issued=now()return{name=name,role=account.role,token=password.newSalt(\"central-session:\"..name),issued=issued,expires=issued+auth.SESSION_TTL_MS,accountRevision=tonumber(account.revision)or 0,authority=selfId()}end local function reply(net,packet,typeName,body)return net.reply(packet,typeName,body,{safe=true,confidential=true})end function M.start()local value=load();value.servers[selfId()]={seen=now(),term=value.term};value.members[selfId()]=true;value.primary=primary();save()end function M.status()local value,chosen,voters=load(),primary(),knownVoters()return{active=value.active==true,primary=chosen,localPrimary=chosen==selfId(),term=value.term,sequence=value.sequence,voters=#voters,onlineVoters=onlineVoters(),quorum=math.floor(#voters/2)+1,revision=value.revision}end function M.tick(net)local value,timestamp=load(),now()for id,entry in pairs(value.servers)do if(tonumber(entry.seen)or 0)+SERVER_TTL<=timestamp then value.servers[id]=nil end end local chosen,voters=primary(),knownVoters()if value.primary~=chosen then value.primary,value.term=chosen,math.max(1,(tonumber(value.term)or 0)+1)end if not value.seeded then if timestamp-lastSeed>=1000 then for _,peer in ipairs(net.peers())do net.request(peer.id,\"auth_seed_request\",{authority=selfId()},{safe=true,confidential=true})end lastSeed=timestamp end if seededAt==0 then seededAt=timestamp end if timestamp-seededAt>=SEED_WINDOW then value.seeded,value.active,value.revision=true,chosen==selfId(),(tonumber(value.revision)or 0)+1 end else local quorum=math.floor(#voters/2)+1 value.active=chosen==selfId()and onlineVoters()>=quorum end if timestamp-lastPresence>=PRESENCE_INTERVAL then announce(net);lastPresence=timestamp end save()end function M.handle(from,peer,packet,net)local body=type(packet.body)==\"table\"and packet.body or{}local value=load()if packet.type:sub(1,5)==\"auth_\"and packet.confidential~=true then return false,\"authority packets must be confidential\"end if packet.type==\"auth_presence\"then if type(body.id)==\"string\"and body.id==tostring(packet.origin or from)then value.servers[body.id]={seen=now(),term=tonumber(body.term)or 0,revision=tonumber(body.revision)or 0};value.members[body.id]=true;save()end return true elseif packet.type==\"auth_seed_request\"then return reply(net,packet,\"auth_seed\",{snapshot=auth.authoritySnapshot(),request_id=body.request_id})elseif packet.type==\"auth_seed\"or packet.type==\"auth_replica\"then if type(body.snapshot)==\"table\"then auth.merge(body.snapshot,true);value.revision=math.max(tonumber(value.revision)or 0,tonumber(body.revision)or 0)+(packet.type==\"auth_seed\"and 1 or 0);save()end return true elseif packet.type==\"auth_authority\"then if type(body.id)==\"string\"and type(body.directory)==\"table\"then return auth.acceptAuthority(body)end return false,\"invalid authority advertisement\"end if not value.active or value.primary~=selfId()then if body.request_id then return reply(net,packet,packet.type..\"_result\",{request_id=body.request_id,ok=false,error=\"Auth Server is standby or lacks quorum\"})end return false,\"authority is unavailable\"end if packet.type==\"auth_login_begin\"then if body.node~=tostring(packet.origin or from)then return reply(net,packet,\"auth_login_begin_result\",{request_id=body.request_id,ok=false,error=\"node binding failed\"})end local account=auth.authorityAccount(body.username)if not account or account.disabled or type(body.node)~=\"string\"or type(body.request_id)~=\"string\"then return reply(net,packet,\"auth_login_begin_result\",{request_id=body.request_id,ok=false,error=\"invalid credentials\"})end local expires,nonce=now()+CHALLENGE_TTL,password.newSalt(\"auth-challenge:\"..body.username)challenges[body.request_id]={name=body.username,node=body.node,nonce=nonce,expires=expires}return reply(net,packet,\"auth_login_begin_result\",{request_id=body.request_id,ok=true,result={authority=selfId(),salt=account.salt,workFactor=account.workFactor,challenge=nonce,expires=expires}})elseif packet.type==\"auth_login_proof\"then if body.node~=tostring(packet.origin or from)then return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=false,error=\"node binding failed\"})end local challenge,account=challenges[body.request_id],auth.authorityAccount(body.username)challenges[body.request_id]=nil if not challenge or challenge.expires<=now()or challenge.name~=body.username or challenge.node~=body.node or not account or account.disabled then return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=false,error=\"expired or invalid login challenge\"})end local expected=challengeProof(account,selfId(),body.node,body.request_id,challenge.nonce,challenge.expires)if not password.constantTimeEqual(expected or\"\",body.proof or\"\")then return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=false,error=\"invalid credentials\"})end local session=sessionFor(body.username,account)M.rememberSession(session,body.node)return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=true,result={session=session,directory=directory(),revision=value.revision}})elseif packet.type==\"auth_mutate\"then local allowed=false local session=sessions[body.session]if session and session.expires>now()and session.node==body.node then allowed=session.role==\"admin\"or(session.role==\"operator\"and body.action~=\"remove\"and body.fields and body.fields.role~=\"admin\")end if not allowed then return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=false,error=\"authority session is not allowed\"})end if type(body.fields)==\"table\"and body.fields.password~=nil then return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=false,error=\"plaintext passwords are not accepted\"})end local ok,result=pcall(auth.authorityMutate,body.action,body.fields)if ok then value.revision,value.sequence=(tonumber(value.revision)or 0)+1,(tonumber(value.sequence)or 0)+1 save();announce(net)for _,target in ipairs(net.peers())do net.request(target.id,\"auth_replica\",{snapshot=auth.authoritySnapshot(),revision=value.revision},{safe=true,confidential=true})end return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=true,result={directory=result,revision=value.revision}})end return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=false,error=tostring(result)})end return false,\"unknown authority packet\"end function M.rememberSession(session,node)sessions[session.token]={node=node,role=session.role,expires=session.expires,name=session.name,revision=session.accountRevision}local total=0 for token,item in pairs(sessions)do total=total+1;if item.expires<=now()or total>128 then sessions[token]=nil end end 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/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 TELEMETRY_MODULE=\"ceetos.lib.\"..\"telemetry\"local RECIPE_SERVICE_MODULE=\"ceetos.lib.\"..\"recipe_service\"local M={}local STATE=\"/ceetos/data/cloud-state.lua\"local INTERVALS={telemetry=60000,authority=30000,recipes=30000}local function now()return os.epoch(\"utc\")end local function defaults()return{schema=1,revision=0,auth={online=false,next=0},recipe={online=false,next=0,revision=0},telemetry={next=0},lastError=nil}end local function state()store.invalidate(STATE)local value=store.read(STATE,defaults())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 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,lastSync=value.lastSync,lastError=value.lastError}end function M.configure(urls)return cloud.configure(urls)end function M.enroll(code)return cloud.enroll(code)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(activity)local snapshot={ts=now(),id=os.getComputerID(),label=os.getComputerLabel(),activity=activity}if profile.is(\"desktop\")then local loaded,telemetryService=pcall(require,TELEMETRY_MODULE)if loaded and telemetryService.status()then snapshot=telemetryService.snapshot(activity)end end 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)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(),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 if timestamp>=(tonumber(value.telemetry.next)or 0)then local ok,err=telemetry(activity or\"desktop\");value.telemetry.next=timestamp+INTERVALS.telemetry if not ok then errorState(value,err)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=16,patch=3,string=\"0.16.3\"}",
  ["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 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={}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}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 plan[#plan+1]={name=name,batches=batches,produced=produced,requested=missing,address=recipe.address,kind=recipe.kind,dispatch=dispatch,grid=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 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 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==\"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)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);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,\"server\");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 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)else pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url)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\"or\"P pair  |  U updates\"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=\"Signed updates are managed locally; no remote apply is permitted.\"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 = "auth-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, {}
-- 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.16.3" .. ",profile=" .. "\"auth-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