-- CeetOS signed release. Generated; do not edit.
-- CEETOS_RELEASE_MANIFEST:{channel="release",profile="router-server",version="0.16.8",size=254946,digest="fb5be24dfa35fc65d69418d123c0d349e10b2d97bf9558ae4b594feea6b3d9b8",key_id="router-server-release-0.16.7",next_key_id="router-server-release-0.16.8",next_public="E3mRWsZZkVH93KvDG4XnJv4qYW1R39O3XBmDi3Qgs77cfRORoyELPXEdpPEgj5cVmtJ8GdYNvl8zP6yTnHGLC1oMD1t6m4OU127EO1/2nSwxmcPJtjuAraiQ6qrgvD9qTTH1w31hb3tVaOVas3GaQ/b7jb0ob64NRxSuu0Z+fral7I9SaYNnkwZzaKeO+dOqzSEuW+2vnhL6Ha+jM+Nj+cmOKdZ5EakiPIQp4DbNv+SOCqpf4HFuPNQH+J/0Kj0OubCncxM/DVB9CAS5kgrQsMQm2WXk2gyUa8UQOjzs0AXa+A3R1h5Uq/jIVB+C4QPXkUOu4/g3jta+BJSKKwOfbhoZvWAX6kSeoBAQOlTu59N3iFOEw9gvn64SJJjzMYMKaWjSvy7zaeATecNoCqKZIc5pfu0zeQuDZ5H5bINMTXhykOu6OnRgKF0S0/GU4PwnmT4bPRdC9AUlTwUVSHvo8LwSDHOmTIh6G0jZ1de+w6K2CYUSx/b4GrDobXRvsOKw9QPfK9I69AiL9zaEaFaWVLfKRugFBsF6aX+WC9tsral0a6ClY+RNfp0JKRsWHfmlWzgsWcZeURwnaO0HmK7/1MqK5+SssYdlu/F4DBwfjRjSyazkYRHuRfWjlGL7udcfFzSM+Yct6VazhRjYLMNiRAbu9rz/ztCaB2iCNyAh4RQ2q8kDKVmRtMFeoiSagNOuVJv+GLW4evOCkQHigRnQ2KfV31xcTFSu7WoUKVCaie05fEdFmJOuCg9oiBEEWeoIInaH5Ul0VjhwKwtWRHapgGf4GcmhUyxvkJA080ic/jDyC23mkvPmt8kNmir+3HrV0xhOkkuDFvfcZf2rhZGtfBAC6yqYnePQJK52BjqFkh2PiQE4/kvGRRBdWFsRwwqh7gLjav4wyyfWvwXKE6fcjUGHBRRmaP/fPfwAPkxmqYmbwsRfmgQ5D1MoocHGUBwYRBd+czlQV6Nk9qi1h//IMhYPOzmLWrwQauSemx3RNpUGmBIm6pLihDAfY2kewR/W63jQtpeG4Qzhmg7fLlr/z9qjqgtwok4+83Lh1aIPtgCt4okBjggvcOrydFHiVsqxdgeHrLSY6I2v4fk2e7LksVj5gvIXP7lF7T2/pDvfFeXQsG1FvRYrrlyGskZUjfoCuKGRSjf1HfO3UzsPvmhWn21vJ0wrS6dB8BYxsMaeZdZXG04bS9gXkapVkba8Kzx91XAvOBvqcBNwGdFu/EAI4cofkHyNCT1QF9Pg0C+s9VaaAeY/CjsU3M4sKCNF3PLR4xKNGg/Yglm0Bj1Mb2ZSVb9i0nCT9qP0s8sQSK1mTcBW8BEQAlKRclZn77g2jiAUthweTnZu2jrHh4yC8u5Hh6PEodjppJpMZEV8GzBHFUSldfOBrKBDOSONanulX+YMYpRvwuEl+cyjF9jbNZKzJsaYd5Lmq9lCBoVGv8AyRXaWXekH0b/gAtKx99Qyqg0Ta1woFLxTpV3oV5ehJhwbEM6VVCG2MvUvbg7c95HvYg+gnxUxowiFr09CfemBts6LBEe9O0OGRt82hNfXKToWGlqUaFbeYVag4oL7K9KIyEETzLJdjTSM38X1Qj8ITK5zwiIE4IEwHZPVK/9qsKdatERXdZCs6IjM2vVWZ3Bnf3rrhCn4pcErwab1k6WuIeinzNFwkdmlxZPG+YnlAQdd2CiNNS+45fXLywue2Hmpkp8y4KP5Cj3sAvbLZJuyMu6twojq37caWxAzyXGb2o7JxBTMwJtccxt1cxlskikz00/n4pQC+BSejweqp14mt0BeEqsFTQt6UDZwDhXBgFCdWJTbsSBNoIUNg4qlJjtFC3SvvkdYcriILsEay4lUJbzcM6TMGugAun4SuMgq59nHV+q69zlt+FK0xazdfBxRAatvjiBIwAGwvr2dsY9vihz+0mqF3m/hD2fJbCM6Pl9A9KyJfQpXTdYESfjxtXm/SgrTC+vO3kbl3RKIqk1SUdc0Hm5Uz1STvGieR/Sq4BGmAdzPsm/g9z3sEtNvOI+JQKNGqFHTrQ47n3gmilB8NP0X0iVUN7eH3Luid7qhdcRNhjUjyg4qy75yoDmBOzHRoh0SPxZbu2M9HHcqqznQ6x+8BSnsNBtKFz5gzzBYIzS9iyXP6zCc2JIHpnQ8o1nECp6BO39fztGPTPnQooChvyt2UNPbLc9E9F30uydSZ4JHZMFNGf9aNa1C5GIAErOEsMGBDIU4KWpkQToMqfSbHmBp1tQmQ7na0UYBM5LcwBDjmFeUVsZhWX/HWPDZHrn9+T+XKuSrWmrV1FfpbaqqUYXH/flMJMMzbq9ZBEQdycbhmQnsUnrQcZV0A6xrMNVHzfQMShMoCnASAlnbD4TUciKGrVmTy/33hvfD/gBGyW/jL+SgpnGDOVExdhUBr2iittXJ/0eFgsCFvXwjin6Nwb84JzfpFx0HIkR0zKzs67BzurIU3SBs0hE+3FwWgSHzsWoB5ejOkM5HqUucHFOXzbQDSNItpHuM+55+L2+0f4s7cxC5lhrxtwjXERGhQxMJ6QLKZNZWriryzJztoxHqjIKOB0CGsjQ+2bjup/SbHqq+mwBFrb+5dDQ5bc8Zs6hVwrWrNh3SUEUuo3bNk9u5E9MatPx2mnwygutj5SrTrEMwgMVrWnJbyabVCJbxUrMiVzG9mstei5d45HUXVfR/LDzRLp+ZVceWw8HYgZDIhWH9zeFGzjYfG65nLM78v7zUJfVXQIOOOJbiWCoy5U++T4rmHfwrbtBhD6eIS4ieB/lHv16JvvW6eZikBlHf/4I/dGc7RPQqYT280ccXly3HAEtILL953r80AfjhUKsYq/l0jhO1Ctpp3Ko69UXbIiQW+U+BiLxe0xAHCFCL69krg5MJzCbDlUcRhbmK37oLVMrQ17D4phSP9711Dc7urRRaGnnOBcMERKWGr7Mp0e+s0ZGsRCocYjBlxh9r7mIOZpHFsa7K0QoG5XZyl2Xo2hzpgs+KIZSnBf9hZahi2FmB0dcKE1PJN82BOqHtmFTOBLAEIycO8bbnn4CLZDfgTjwLy1jZtxZXts6UO8oNaxTtulaprFV+RahB/3xijDpxQ1IbhHOTENPgR3wW6A/fpTGQK4odesFsOnY9XEyfLYGcLEscGz9iDcHPi9T8zSGRte4cQfrPt7rUpluv//VKKhQyeungWesLXcF7SRZlXRrEGZZAWdCUmnr2iCzEALkso41CD3XNqtcntUnlEYTuXEgwATRr8Sywv6x6GtxGL1AzrG3PVeKjrO8Oj8hTocU2KhfCwY9t4FzrobH5cpzt5X9xldCuY9I8b8KvsFVvBUuO3OO4f/HmI85PyQvMPv+qCMRBkGEoIO1kuuC8VlnU2V6ldfmz4eviDrnlHQaYFhkJfGkefU/hPhhTAuN8Bc8zg95TR2glduoquriCbKlILdDrhPSiCVTnxxFjCgX4pawj2yYF3rEfHzwUkUnFXTp72vheLTfiKo0WKIjvXFd0gh13RWavo0V+XWLrXmtrFOdxn8A/aX57qdV62i226kLCbHyVWtEXN59PA9yDQPy7OuNUDjtYFQ3mSpb6eZwWQJqhS6zp4sF4ljg2/qfQLrqngtVr1plyHux5D7XXhb7YNLO+qMkBI413sQZNyqSe9DNPscLofudfekh094zyvmKF+uz8qN2aEcDoEweu+4fIdx18AiSx7Zl5+cuW/l/VRppS3KgF4KnSKNMVJ2dOPpZa1xSt5agbj7L62Km7AssQTTnNW9ttdK25IEafXtcFNMCUNXcwtRKuA8AxvZipJmgC6rb0NY1Kv0K9fSSfUKX/K8IEvRfysWqFszlvDyCW16DKS1vSbW0hdYLHodGTyg4NbR0W9cm6BrdyPmz6t+q73PeXBEjAvTclJvdYLH0rlb2I3XHTdCS8A0IKW/k7Jg6t3IPd6tMZtb59DtIAdJILRkCKqdPj4Ban0Zquup/rdL3xrfDMlLl3Gj7O3lF4z6haiclA8qUW0UKaGYDS4K7zcuDprCxg62oPS13VSh5JmfTW84FwLmoL3XFuyQYqQ5FICcESRzIflHPQDjfFbjLBl+sibtkvsDUv2H2WqMa/QVvAR8eHuAHP4fBOHcf2/dEyfX9Im70g5RiiYfnaHmhaOoMa6SnHIIh587eCWppbIwVfd0/yxRZBjf+0T6g/MpTb9q7RajLt3I6KmDKum1xdt1xPH5uZoWEqGpQIewyOp8YHLzg0RyKop0b74iuFXEsgD1ime43iYe/ViB8ZZo4yQiXx7/WJ2vCR+gL+o349MM1V5ODSc3nAzhCIBUCkHZWitD94NFKbLKLaeSQ3Vv3qJRw9ItNyGEiUyRDjgrWT/NW1saPvagd66Zfa6CgWNabB3QaKu/RxAWxGUJ7yZzmTk0gKrH4d1p7vmSPz3R7GsOBnXVr2u0UwekOtyTvROObEkHTo/FHPME3ycRTwtT5aeokVn1nYVXVmX/8MrKENW8ccntowJ8ymT3L2L6cjAs6YKU8xJNO2j0sazfz0EQkpMnSDRzjpJSWxET9bJqwa0a/xfjKrPA6AjmXuXqUUhE9JFmRXPmsgREDx28aXHBoFGU+HhthQbHlfmM0PvFn6FgejP+JalwL58SCpUleg40KZQx8Oh5Ukns4N8j3zi3GQ7C7yu9k7x9n521h+THRXqEztHVuu+bpa1R/CVfntrDPaQ2uMllJfHetGns1eEPiswwDrECOeTe5Isp3kPU3pvopPP36VFQh/tR5rTqu63ue4b2Ts3phCAyi7I4sMG1htt+mqZWEmN82n2DMb8xg7gwOEaHu4eDmpJr3/UX0vWcE/v+2ErDSepp7U32GsrzwfOQ1QWBoby0tDYSSdKCS2Rn7NSxy4YB1n6N9D2EI0spKNH2g3nVmwf+lf73Hcm79Ca1hH4/C/UMOtsbLw0hhVp6cj9qPGbKoy5ryues+/aBRdmjZik0wjgEKVjrlzOcBQ3uvi/o40zo8QsMgrgm2SBedRHHs3KstkOS2VTvEcC1fC12futsVN1VP1hQ4Lcoq24ru8YeTtey0xGG2NkywUJLZZJK+/05JjyPArKvzgyjr2gid9lACQ3jjSK1yEd7K+VW2VqOGQB6in/hlGyKLIbXkt6iF03fRZCs319Zsg/nR4gIGGuaQzdranUKc7+ajOqtJdfwtPUpaD0LoG4nDqZoC9kwG6RNbL/ir/vJqFSEYYpx9kSWbMsjXP2SBAgTFxvamesLuWCLCRCtVsyQd1bRpNwUIA4eroAiw8JTI4Odu3URrZHSBBHRYg2NTTdtBz1KqXdBBN5M1M2Il7RbdFfEtVxLXGu9zO1Xsew/R6w7MkMimrDZ0TNPvZd2TbCRsz6kx1Vt3ri/EgICfYe2SLOBzRsZg1nKNTyC5SuZSBAwyvfL9ikf6lXcafJFlNOfZRl2vKTRuIpKokaOaIaIb3JBOHdqLjdCjG94rxtAI8h0iGYiFQxsRfgMIZF3pW2OQ6vQA4zrrUyQbLTqReio4kQUr50Mf5Im/VligIqJ7ABtX1Q2lhIu38oTOJBIvZe8ePSp7fQhb83pLWuvXpKf0rMI7mOrwxPhq9kHIgZ+OTFEukLiAWqWlfXNfJG3C8l3Veey/xzp9/M66h78dsWtZy/3NI9tMnnRPJBdTA6Uvip4CRiCrOuES+afNUI3S89wluxolbT6ADJTygCB46zYHxSYY/1aB7nF05fBxs/2FbZNYfpZEPEyL+O/Z13wm9Jqtf11oGqXIIm5EvdMrCvRrfzQcwwoEi+ekAStUH1TnCPyz7VVdVWOyraWMa2wHvOIgTBXohHCx6FjNN26JNDSBmRLt5askWnm8UgLbMGd+cZwnjLihhNO8abn+BkLuxKPcuTViJhKQrJRMwFK1KRKOhI2JcLetF1V3K70/xDTHR0aAjuU8LM0YBt2J5VgBRz72GV7bd8z0gpXHYN0QzPcOCjfIQ0pADeo0NTQK/3g0BVFWBm8Qi0ossQJ7ViStBxa//jj5s7Mj6KaWPRLKwjtqG/ZfXGQ89TBoK0RYnIcRghUFnONcnsnutzuPSTH5CrE2ukCl3+W3jm7UAXwxXKAn5inPW1Ik8JPTE8ax6EyoxIIqTlYEUPTHYdccdH9oE2eoi4tB/YoeHhc7uTB5dxgN2pxyLMMtIOvLDHs5wABvKlyCJoff+ZR8RisF938hBGf9omozHvw9q3DXVTXRhiZRBCjKdXCsX3uMEPQM2Ny3rgdSLjjZk1Dh/oqVKRPNzPEQWoCo/bGAmnssWcB55e2IDHJVhEGT6PZE8fTdtZei0KKikQuvWYiPt5If0SGwsLwKl5cv/tASXe6UcnawISJXjioJO1Pb1eEdzS2Y1vZ/HqRB6vPQGi7fgqxYJSXws+N8yw/eOV3+iewjMAQeCR75V5A4g/IepGetuZ+99uUmo+lhzeEPzqUESpuw+wwzXrnD6ztDVGGrx2leyAgvpnp3P+AKdV+B7bzTMCs/6SvYs2S6olTchD9AUmcoybA5LOSXJohVwou7yusvbxJalD6W0aDxqMRt//fTCnqxaXaUCBSl85XbAO+vRfROVCGgzW/q5vbB+/Sxwd1iQfnukMHByLikfTF1ypF0DKhXAbgNfBxE9ySK80W52ocod/veUJ2wGx4UNtgjHDS4Hsf20r93+U+P2o+HWiWdzXvA3dTgG3LPr9pZn3mfrDy58pINU7WUujGKlHDuTz7jNTGuLBwF4Um/WJL7VvTjVFzHjD2b6oZX1bfIJbV3rCZ5oHo0xTXX/OB41yP35COd5WA4knEcSNXtHVTHp8Gp0kfm8fece+V4NwQA+wCHThVsZP3oHc56hQxcJWanuOo22m43izJV30LZIgxAQutfHDmrYwVm8YuZyL0X9GnQwhVMGpB/a8M/p+60VFZKVBjSDIKkQI8u2qrLQ1lxqw0rOYmPGGf92ADFX+dkxRM9a1Lycoy29h+KZLK9PJdsRWDp0jJwfKsH+sSqoDvkDL3aH41o8OIXRHnvYIeq+LAPBaZizK5VRkVpDO/MbPcS2QxYp1GAaTNmMvLPpFnSJH/eVgvt03S6pumSnn5u2ydJ/C18sqtya3Jo0c/D4Vgq5sMEQpoVms6Un11NT4u9UdmRtuOBvgVtMLcv6Wuc5hQKwS/rWWrdDnAAj3u+kUYSlHrrP3Zz83ZoRwc7ZCFRNLszhFNZNO/90Q6sCoJmk07ZuH/FxU5FdU299AbSVJ4AOuDWAhNqdng5WDwvpbKum1fUNPhVw5xmjjqCLdrenGqBGzfm4nSO7aQI18ruHqNDYE7KCP0CMf4q8YdLFGucQAbQkZDmh6n2JxZDa4IgCJlZX+IuXm/PhNXwsspmV0v1lsgtEeG1kmgIcVvWUfDY0v5aGQcBeeve5pkq0l0vRtTXZq9T2tvEAZAFUVbc09uMGglCoDdeOtMsBAhZN+zudqLBq4oVn+pSwOU0fkrBqnelDK/QHsumjJ4dsNEbJLVOhxAFRFu4LbON4qDDbIg3qzDl/e+mGtncZPjuMSYDTPt6CQMuwxRDaPdmQN9NQWImdP8pph2GABBO9jm1yUKK14FtARrdbqLDYMjxqX5cBRhxe2tOXsfNpqi21YJnIy9B1nprZG/KliLg8GmohnZx5PpPBqm4pCOA6pjXlkYovdMguZRbzy7lEWCb1KYt+xU9Bs9rz7K32ZQZmNsdD2scQFiNOE+eq+wQRYGAqMUUjiRmzZzObiIkR4D28NqNPRRM3elT3P5EW58bCKc5KGlQgQHWZXw3r6/QbekwFMOjpJphMzxmoVhYqXJuyq1IhjtQlgTRc4dDEEyo3HhsOSda2BxcHgVea67gek3zqXi2nm7F1FLPgKDkuFbXGTOkUlozh4cgZIGnyRkmFkGvsdO3+DLSRU7yFz9mbU4MIyfFJQVj/y6GeHqGusofVl/PSZG3ETyuPS2IGHQFlky4NH96RK9KAnoI+X/R4y8uwWHluv6z3lnQYC/OqjLWNrtRAwIzSM6h3coTTbMZ4bsmNwqdoERc1wPDIP/NnqX7kjZ38wPXrVLM7Za4chXZPoQU0CdaBNl8/+y8ckHS8fiIYoI90wmR3dALXwf/JrfI/RLqsT0wBGxgnZUVpzF5Vb1wx0xgfLy2fG5wdocKftj2WXpDSLA/wH6y94pUwe5b4G6IEf4p8RKJymoumxTO4M3WCSEyVn+fo13JUgTbyHLFHXfYfCS9ibyWI22wDY2AUkj8HLCj/1Rh9CdTFuCglBCXzjTZbsiaLaEhM6J6yfeLcsGoHO0xEw+SvGnydmd1uWvV4TsUHiSGiLX69NmL11kWEML2uPGTaNhvp2cLKbBijQJ7AfSktDzVs+ZbiRXGzua2eTnm5X+ImrgsHIy8gc/TSiOlt1zABtpVCAPc02r+kmwNa3ZwhYdtpZCZWzNrKV1eZHs/s4sJ13y9LiysLQ0cs2x4h7T6Icv29im28zWTJfw6WPZ8+w24aY9HvSveGeTBjne/3658UA4xi0H6+w8qpVytIZKzRXqC3Bh2W+GICU1o4Rp4wNXlOANQRhzemaHZsvzOq+BC5fSt6tEWApn0HnTZuZDvG8SRWwwxmc9XpXJQjeZa0jp3aBiK22/LBIVnwLMAWBl5NlUATN44GiawtM/F8nC6O9zB2twc7XVZMEJY9x2vPzWJt15z9gRt/9jDQT/T8LqthiOmHLg6yhEB/PZINYRP8BtzQ0BPMephsJe5sozEFSPsP+3ZH/7tiWqybqPIhEWAlDLjcN7AcLCR8BE9wnPlFMpnRkjkh6uCVtt/8Vd6m3Jhvn7ytxHVcOQCJe7z9JjzcSfsXrhZ+3cUKbtbyRJc7wEvpwtIjnF6Z+5meFPi92UM13aC0tIZDFSg0gnYZR4/4V46LliVq8HGDKk0RXHL7b4x5xxbehe06GYlGd9nESgDQvtLhuIyWNTDt35NZa4Ohyp/UsyDmmK/qHDIXLXzqU8zzLvKEZdcpgU5ewD0U3aYdl9AROrSWBiBnzKC6fR3iogkvaSjZoSRFEHev64zs0vlICW79bj3ic+TXO2rrlc//bRUUBiwZsEKR9lulPvkUIY2EXPJZReTqgeIdxHPlAkU7FF54qS1DGs65e5AdH0JEphuirS3e3jawlY4BIvtYKDks+Aazr4IcG/P0RRVSXkkUjyo9ZaRWQSvStA+587tbhlP1l9A6zf4+mDmsu41ZzwkQWIcm2ZeVfLBwRlrnaB6oglmRleYmRnWT0GzZv9+54dOIbakkpw6C3+6WFMmHZL49B39pkM8mfW4VeCbRy9Jz3EhNhfRn/Tco54IhRnGu9BfGjZZyi/cCNT7ZPEMk1ftFb0gIt9DqfgAkWQCN5+yfrUu+SaHriCnfDZ1GRD0zZ63yhTHN9ISNvflcFZ2qzdJPa7EigTWQ9g1bLIx9i/6iefqMbwGx5U10ShCTBF5yLsMf3ZBIjCasBFu6NS3jltp+Av7n71FFuYbYJJ3lcaPGGeQnACy/AO7okVsF8M8CWItX7mztVyUNeW8VijKLGc4i8mH3RTp/BfyayWuNQLM5bHw3Ey4BsPU+H7xR1Hzmq65b29NW8IryVyt7dtFmmME6vV9CCVOUCqz8DZg+wwPXSMZ/oY02/KVWbbtbLAmZsiQhWv0gx3CJyK31soh7jfLtEUlxoai1NEWwFaJbC4wHtWXpUWNsbBIlZLwd+CKEhPDDWEsZbft4Ew6ArTgWCRn65F9l2eLHrZMbkUkWo/N4676y5n5zPwE4DO2XPxgF0fv+ZPn2Dxz7zyrYjwepO3jk/bbNe/l2PCsH/4m2fWwpv8yJlXysa7Bxl0JRcIAGazU34hsPgg9Z3dllBC+/IVf7EPHs3s+hOnyfIwgH4+Ekpe/nWrVQVnb0ZOIKt26kqdX9qCxc3FxbBck3koGrKo4H+1bK+niF1gvNmvkuus07h7t1GkUvPCIZAdBjl72F8WIGVQIDnm28OMvYSzcKjinJTlNEtWwdwGdrtrNTKUCKboJXuerpPcBFIsjaixbU6sRV6OkAaaZZuk8y6orOf3PvzQYODAf2+hlCUsAYIPiljlJXnDsRl1/U6d1Bf1IVjp6qB63Nfim+KRYG6g+0CAgCXybSpJqvTB86bquXM32F0Rc+M1+UBAys28zVft/HY+rtj2hE59JxlOxRxoga/dcsdsxCn2OmorhlbGHJWFq18hECvruLbz+/Owf2+782MTnNkPU5t44yltBJAYO7Zke4fkfrTa6j6erinC+6rzcRfRm/yLEEbVkBJsa8QnMqxnSTDSjAMYW5dLMG/8F1BOoImEV53/87K0CnMEeRIthudHSMBaFFs/xwtXTXgDoiBQ3g9DhLWaf63R9pMxrc+qQVTUe1sdE7kWtQkA+eVjRQhMQsBQwvEbTHyp80otwuChWZrUe9TS1aMCnn/YwiSpzDezHINIX1yPeGbkmW8NvKHgnFHSXYnLdGOvLRhajMMbPKYcEjir3pBrzKH9T04dRkilbOf7+YyS0OheeYb28wqXUBNm6f1HJjhdpezzVjWyRS7qfLiZLma6SFxXqCvSOqgel/MREHpWr+/uVmRnXHy9Zf50UZPzo8u+7rKOVAHKrP1qhbmHXZEpwlkLfcY40aUIrJ+etaDIEyDp055hO32aB2bloLEoRAY4tV12LTspru7QSbl11gjIsNn3wZrj1i4BJwhwAO+FGTcfrnVGcWqxTVaAKVDZ3J6qsXln0NCKkOnnhTNtUmZPDrzalmCSU0OtSz0r5qBvHLk8hfho4i8dUdmC5+eHZdpg5/IoUTXmjdiOM0wNMExo0iNM43ueZMopxScC1dTrqzTvgLSPXMRb9N5L9kgyd/vss2q/3fVWGy/6ugx6qIk/RMet6eKDeiMGuN/j607XLqd/1WAHuSISkdw9bCkxO1WGXtj++l6HC7Zzll7BPhnJTtJjb+klZOgXOVPjHIMSzRF5Cc5gzDEQpwOjtZNk0SkOYdfZePEjslDenUSQGKGL19pCyIINrUzRo20523+e87qPpMSDI3+5NFlfjJACgcL3u9Bg935N9Tn1sAby3OaI2eOEY8U3EvGihJyjBvMylO9bnhUyyHwFfGms1IDPeqkD4fyOUWurQiGnqiuQ4pW7vVFUcesExltJTXfWxkytHSl3bDvTly92BzeUGzoPe7fDYusreLvLIZfcnG0kh3m8c2KWU/AtaWka6GCW1P/WCr8wy4t5KCr9P5HBBHPhcMMejJtspriZcPOheSmB8kGg6WZ9h+BJSRZftJFHGUjtzHC4AaYMaoGZBnJA4DIigoy3J9ZjuTD/0ksFsA+IJ7zw4U0/QFtM1sdJ3ooSwk9qVaPku8X83Com9ofn1UeWQS0qt3V7I5+IknYwq42J9NHZmUPpRBclV928kuOisOBeGDikJbNBYJjQl++p5b84N8xFYZcXbP4myZ683J4+iXgcTuMTCloyMKBcBytoexC7OZihWVggIEqZbxOEaD2mktzI6233TIfG0bfVwkEEdFYXwzYvP+Jx99UNv2zd7qnl+PR1cXvXm5GhsRBxUcvbOO78f83SjD4UbtjskfG6+usUMdyswW9xYJdCs9sKR9srSOO31oz01KrgBIr4C9XGsjM+8hxBgBvhbt5O+VyQx0lUqlqXHqqjinbaSx5avNRYfrs7IyAxEipnEuPdCOb1Dh+y5d70TnyQUR6SCsfO/vlouvI0zA9FvyY2H3lBnEnnqWJ3qHnGthQbtZ4BPEGklrWXeknTnJgImrDZlfjfoqUwlzpAEQmFRtYz4zO4XEPF4meq3ytuNbFS9ayu9b5+byxEimGhg6XQ1ylxCuKCKaKoHrFPymHOlqn2xd1c6n3PHuzT1zvzaEYhSup6Vw3KS1CZ7WjJoxpYeCv9mYO4J8psL6YlbIP937POHHyMKDkAv6o2pJa8iiiEgQsSCaAYsEGYd9blqeWmXN6xHPFfqHVMX9FQ0NDDfAVsOk6evtaFFtijks1rv8pIhFSRPe/EP5ZJqjqh2WEcgLhuhBBQUevpq2cr+BsRBbTQg6BgahBiF2pGwhSoZd7SOQDQIFPMHOvF1u7zT1d+10t00OWu1JpAiuIsH+Gkqj0D7me9gW6n9uE78IB8VwV4iYJbNXvkYC+wWi2E8HZQpPUk8TWmizbwfCRSizg48o/HgBPu1+BgA2nEYGNm+bhsGfcK6oDvrOjaVZ+zanMbAGLXgNpC01EN4Mj2IkeFWWCQoY9DJ+acqyZU5Ua5UwUKKcGVlWrYQB04I37g+WYiIbtE4tIGrZbwQB1pEBgcHJz8y8JBhy5/OdDLAmHRrEfdT17SSJseFCqvEkj1zeF++8B3zWy5OD0gGf/nrMqlNR+kK8dnwbPBcn/jdoBpjdrTfMJMtSs370XN/eQW4SUL8GO7DpwuXK8dDbZ6n2wLfMExTIyNLbOTSghoeqvI2A6YElyL4LYD5yWEXywiqQwqaqswLHQzK/VIfnPwh/HEHdO/Sx+Pv+hhArM6GTmRpsCbRrEO8hsiiHdqrxohwHFkmBFJzOd/meDt2v2LSA7u+AJ1w1ledTVf/piYwoDYa5B6iWsWpusWHYFhMtRhlu3wi/VHkI1gdRVf16INWazyRsRgoswSRm+Ym4SLCuWTu7T/j+mcqOrEzfK8xEHc5TnXnPImVs2tQW1Zo63s7JCZ6qFRkjw0qF0azJZB0G2dbFK5Mnw+lJGBRpYbAc+jus7KkNtzh2gzeOLzkFS/VIxIDUj+KV6ajB/cT4bw+Gvdxx3zmaezmGgr4IYoTvUSXAmJTzC6ZjMcHuxxTsr9UNnXFWD1mKB0O39yatPjf1vIEA6MzUfhgpXOJ1KG3m5EiUcMbxdkapnryBPFhULSePuSonxxeji9WjwaQLuI7Fe3myPPojaV2yXcgtbRP77Ge8N87QOG/G4NVkf4wbdEM6REygoj5Vi0jUdbV7dxzG00dHV+OSa4ztuNnbNxK819udPpvOy6da9aieGv7IivYrydb3+ljEV3Z8nzpWllzR4QiFp6iTTKjrVD31AVwA4aUG5D9eiD2yFciNu/1+Go79FqjCb11UfgUeWqvMeIia/td7DEEHHm4HDxBIeCxNCHb/hAXq6gvkq9Ut3zPTy3DP9GFZUnvArWCc1j2bigmacp0WKzyvjomImhKI7XsyyNDhZ/8YBrIJe8L5u31BFt8DWqLZkUtnqP0zdHmiJ9u4m2jZhspZ4ilv2zGPE1O3oNa92uw8HAfM9XolGM69g1CLMRFYkQ4E668gguLLakNsU39LHLyMq1DrOoJSy3WIFzLzl+du/gck0+lT777pSOq9bl+9ngYfXFPB/pXpTgMu7Z0DspYnUlWdi+wA/pJ3vVSXxsjrrQMKu61fDTlAJD/3oTDBAY0lKnkKLAo4e7xv8vKZWwEp61js4KAHqG0pHeiwbaItGzJ9M8ODHlNo17xr/7pJNCly7fsKBlSjx9skOte7nIaNmhs0yVdaawztpsCeTecINeQWJoIKuVyFHoZOSFMoMJArw9FzaSrHhTk7UnYh71cBW+y9QoQqRlL4gi2GzgAm+gIIm0TrGjAil6iiwAtQ4wQ2SBfpdNSDME05Y/eDr7DNnbTJWkFIGI8LIRpQ/+oOOppDyxdPzpmNXVwAarcxGSa/nNyjYCCBrdLifWvRouoJsgtHzxzsYl1//L5Mv6A0SfNkBJfWU7x1aslS291K16QjeeS8vdA/fYPCJGHZqBZ/2uU+dyHzPLnncX6uussV3FCZrsfowJeMe4jzcK+NErvIU6t6j6MerJfXZNrjrQ7cNqEBmEWUAyxhNs66HBwG0tixhLeWRGBcewrJuo/obeUs4r/ONiRokYBe3T9n9sD4mkLMnOBSg/ICw6MzfX30Cg7b+eQpOFDkNyT4mkR69FxRpdyKK8XNzRZl+g2mcH+Pt2tbAyAMjjRsYXI9ONS41ouKm9jryaQ2ygrCYhPUJ2hXe7zCVJs14v7d9e/vGnnfevPkHxti3ecN8KBxnWZ/nPigGpr/gDHhih6mH64p9fQhJqyNJBgqwDmy7WLBNKxaIVuoJYLAOfwDnI2Q1PidlXcohPWnVwUKEts7k/y6GVS4ZM3SyK4gvu5qKUDFREf2nQQHoA5rJOJe3BzIe6Z/U4lDXw8eesmkchECL+iQUiK83fDkSwtnFtAt0rIPyv4PsC7bJ+sOtopRvBpdxOZ39g4NozL7OuM29FwuqyrwiSgz+Xy5XgyK1aXJr4pcVbXGzI955yl2+QvxrMi1OuY9qOvn4nx4VYWUrg9OLwYr2/zCE9JYg672rWXxi6qvZQbNaRb1rPKU8Ye28eYPWHc4LS6c98EU1NnFRTrS7A1IwxQ63vk/cQC0v3hIVGJ4vxYBHJ2MERDsrCYzl7oULsy1i/mUMnHIdAxRon+f1d+Iyp2z54ENnzIHYRa2+VLsV3nwcvBXlCN+rY8/tuFqQlahUt+EZh2lJJrQyeJWQlCw5b698UNHG2pgdch4NT/LYqAz8y5aR1i40wGWmoieZ/JsDTVpfKQAq2kRdbP0DBb/IrDOt74rFCs9f2O9QheE6uWyxxzgNXC3+EfrHi0keWleqF+m2Ep8x9ibecmm75RTXkaLcdgDpKACOHpi6nQeoieV8EHE+pYDgLvhJWHWIC1Gy1wjzusGJoXqr4yH4NAuZSuWybR0urhWNFWyNaL2J1VvijcFaTEG4d6c5NMy+AbND5Zsy/zcwQ0ftlBJuOQB7PCqjlyYJ14LFVAjU1uKdk/utnCrDmhVoHFdKOD/tOVISgTV7asVudDZvZtlRvTaHFJXKXmxCL4mZaK55iiOlkUzBm7ErbT5rGj2fPmGjtbaRLu7ctltoMalwQ8szIyBeZWek8ChhDFh0+vZv66ZcPtbwmCGmU+V2idiP6FfMNPPSMeAGtJ/Kv+uI0k4SZzy7V4UDEvMcexuDjnEX9zdp6EwaLme6niWpgDwLA5VV8Z67LtuKyFaDW9IFZXO5RDVJoc80NQEfg9JBQG71KwjvzhbTBCX1IWZ1g0e9JNTWVditbJT8i0STOrM8OCuo8Y15Iad7dVBYyJJ+i8vOhcn/IHkFPWdh7bwg7a4PrUrk5mvdGFObSThzoArAhxWE6qQIzYh4lZpS8qLMOjEZhl7JNDW2warh00dVXgCgIPNOA2ovDlKOT5sbIShFcMyzHOTtX0KSPKFUwprsWqTjru6EcTZt6IcdTV5PVzzv4PMpexFk2LVeSw9tEieeYv9L3CNZPcfeCeJZfYbQun1zuidzi+jwPGPyPmjVZoNTVfr7zWmmx11k0DH96T/2NL21iAMvFZemObHadwCyv5ECQcwd8FRg4/cl7QZNNEGLM9dOECXy/Nf29etw80HEPatqiIHMVQGOVlV/TZruSO4bLSk6OM2jGq9HCbuQOkmAeW97KY/kiONSke6+KZenb4aRAU/ZUwLfdyTPa2uJgkEOO9+ATrpFvOXtAHLbuPx7FqbYFlGzO3OXJu1iFMQRAYOLaea+zx+juURuH1U6zjXdcHE6OiQw3Ck8s3Dd1r76JU67960wD6vUq8uv6BSk7ce0QsU8jUyeuby80HT+9krnJoKUlh3RRF+ieyk43tvlZISx0GdakyXlZl9BXLiPcUtx6+pJy07wZj4YaRO82/scHn/robpRRKj3Q2vPwLr9Ib414jMpK59I1mReNY4clYuBYDQULES2KSlw3SU9IZ66OLm63M/F4VjhDS3NbJzFkxD9OYFhVE87azTym1LcCe2FnGpAdifOR4cABfatqeGXbll+SnEp/UhBQgoDaePehVSGfFsj+jz0sSz+LelO+Z5Mo8PpvJckl/6FQ4kFd8ypHAt+FdT3DpyQZK8/Mp+0vrrXMcGUOauNfT6dyxga2M8Atyt7RTy5icnmw+4IIBOc2YNw35ngWGTqRqgaiMuS2NTOidFPhaGQ9P9vU9CY5Q4TLF7HemAij+Ty53+PBZ2ap3fOLSsa2ze3XeVf9BOHHLLgQfPg8rFEZkAk/kj8fJOZfKpt8r93eKsXIHI8io0i+KLFe63F11aw+9Qj89Mhk19uz5r+ELp6d6R+RpM9R00DIRDDYB7NS/4TViJwna+yF7sUyyXsAKnCRYFGJZX/H3Bec8+fwRSJGwNaaHaIA88T4UuUo3AfY/ziEWaa187BHMGbK02N71IU927dWHhpymszw2PgmkLryxTr+2e4S3FFQoWMJij98DoZaENYTEpx5E5zoM6ltjrhuWMpLUanXbVJVY0iHz0ihNccA0dKn7WNDYuf0s7GyNwJuJGxEyMVqfD60y5ga4KYdTeztYTaojyTfYaIZU4rgup3ix16QFKyb38m2l+jP2BxQ/ZrIEgPVN54uzS21k/49TVuEAxHTwkCgAadVXgKZYdipvItd8NrlLtMABhpw16LNdFREX8/cISPADjFYGRNKt+Sj8YLJ/5tb4yvL1eYIo6llzvCzClgNXQUxamKP2aeamb3k8fVRr3sl98C68oZKZ8ypeE0k3QpSiYvhfMj9t8zrsBic4XXTmwl84IbBcLdOID3ToF6hk/KOViJKsDgJSA73jk/gAov6Nk0BXYIWA/2eOwpDpb44yRqpt6N/24pY3PQPJyE+thjnSdZMwF8Wvyb5VSoQq7Yz43U9RFuayCU0jVcyaQgjuUTBChhIVj9ndDYkCkYgDxxCDsbm1+xhehGsY3DwtjRRe6WYukGKUG1Q0P9QSJhL4O3Lp1PTdPGkAMgrQCVosbKaCmRR0lbQmcQmVLnU6fAi3bEjHhRpu12C8kpBLz3tqogFpuo43HIAE58sXIkW9oFsLJMnbYm5SlvnnxIQohg5V8UHcB/KvVeVsq8B6wb+0fdgL3rXFS5FFjrxvmOdqKrUCVYfEG4/DscuitWMB5jcwwL117Y3YOkt7Hrf+iy6D64hqmTig1l3jCepNELWWgYuFura5EG0Ufx0PCc1wP8j/ZWYMW8WcGNJcGlxxSw+6DdAHy/Pmuzd1tQvqGZrTgvhhsabCoy2AC3Qb/8RVWlcWDtLN16Ja862Za71DZlYP3mHa1PToNV77D7HHthAUrlYk/Z63fFN3MdJRId9KuhvyshY6ububZi0P0nBdw6+gxHyssdmRCcPT4MIzUd/SRMJNXm28ptmzSKnII6wKropbRvC2p6+fA5LlP+VPn/Lxll4Dac8HLnpGy9p9iNNEcASgU2ZSki99cZqwz2Z+x8Tik9+0440TDq1wwRCpP5fPZCxen2WaqCUPUA97iwIIFCMTe5TQcHuvd3dlyyXJEV0hrT97waI29aqibrLAWLnxqUIHDR/NpWLXAYTDeb4VcduhRGsGEuMsMiHEeVB4EL05d9l4ViPEWxjR3+imIQOcnHTIJY4KYDWEcuzyBjV0jTTtVy6YMAqzbXHi28At5HwTT8gzg2cG7t6GaCL+g0ShJ/nBPxCk/Mm3dA7g0EQlMP5UcDzcEHskPa6Ea0NkW9+HznK7h/FFnabEWW+jGKjxLR5qScF1BcStbsWUjuXT8+LzATJkMSXBjJHPivz2E9QTGGHvRysmRw6i2ctwZ6fxSIh+RFRWCccXObhhDTX3qQgVSxrDCaA8rkUnm4QfanAqLkZVU50+CHUIsBeMNE/Zpi1MNJSAL1S743USacQDfFOjSHwXfIPZl6cAJ99NkngsZMKn6aqbGNVB+QvdqxjLkavZ6vNod8JWVz1X4sgTREmAnKMpoBe5o2NNnSlVHg5aernEAobBGjPc+BGEjRymY9ulXK4iPn31kbbZ6ouIyNuYYCWLXVQNSJ7dG4o9IUiAXn7UFcdS1mzFI5+uCs6g5OJ+ohvOZJtk0nJuK3m40bpINaeowDBQUOD5L31SdU4X7rVC1JcVp4Lmb+Clopq2CWhFnqYqLzXtYLAy7VlsTHKI/cWSmbk5Q6EPu4LwqTg1Om3FY24CByZkYyAkQYLlZrM7oSKDnaOEm92W8l5W/uB43Bhs0iZDBS/xrdOgy+7LpxnusqgwAqdVBs+mJvRQRc6Wio9xU2WGdCiV2sF+TKfLt7ZQBNaGz2H9ZVyyQNK/vxVWskM5SDL3SzyWKXAN2458l0TdX4qXbz/+0cfwMmLTO/MWwH3lCT7iPBZwtzYlr1h2WNNm4Rsbwvf/3aoIhp92XWfHgRSyS4qfQ2WpBHyIbjOTftEvguIfwSxK9sTyPhW2t2k47M9LKDWpoOfocuRAwTLto/csdzNh6Ct6KhLKdnUbt4WjbewCiT+2MfelLSEF2C24CkgP6IB/NyLb/DRf4/bTggccaAOGpk0HVIo863SnBgYx+mFLiI1m6DS8pYx2wnVefErlClpZGowR88GH1FP3TSl3MhPt6lEFtZCRknz0WZIklAPJPegnUaHm4homrSQEwuTL5QS14VNlw/dWO1KozgpMyavX47Xgvmx3yAJBLEKBWqc2bM8ZeIoWHq34KS12gLtd5Q3i6Q5ilAvPUt1RV/iu6BvCZHwglw9x7lcm6zRRL6ZM2kui4uUfT3ISj1CaTwfk5aA+WffWLsXNAvXsbMN5b+7rPGHo8XQfMNsvRdfYL39+yWT4NYj9e9L/EIDxkOVkmzNO6NIGFkuPdxNZW5Di1jVEjvipX7zWHTVT3bIGGP8VoZWxLjFlOeh0kQH885ZcWNwC2Ie2cE3LBi2SwlylslPW7fggVJ4JCw312d7pOGdW/9ggItTEu9pTQcyGuRfIl38RY5mZXskitn/redJ822hhwy2NtbaEXCK6o6jHXkdRwmJKHCb0GtRRVD6EnrcSCx6nyVnvgo0tr81YdF4xfiG2ZqP+DmLRL3njYRRv7bAxNjXq6xyjx8KLw434YoLZ9NR0MQ+SusZ/4ryaeI7JsmYFqINGBVuJC085A66GKs+53c4AsiEpYRn45bM2lmF99qdcBDpQforrS47SeXtvZmIscp8LdcOMEL9gVfJ27umXEVF5icWLJZDCjdn6qlyb7IgOWr0x5nNJ/to4mWH2Grfz/tG4tDYe2toT7q8szuydHxkbSePeSHNWRGrqT0ayoWT4ov5WbWkhOUvHT6ksnHOni5Y6Fjqvh12lTH0P9KgTp+WvNXC+MCIrD6217SAOjmt4xZzbwfs0z9mR+o1UuRiIj2qVFL9IkkDkTC4mKAWhUflcl3uciPVCtuePcIC5hGex3lCUbruZd0EDH5MBb1EkJYY16C3ppFb7zbpiSGRVMjXoCHKYg/Cmf40GELbf4+fk4JeO2yy7K4f+acMyz4Iu6tA8dwdU1y82QCNMqr/gsRIShf4XBz+3WdADWrudRKH52hRf3oO8T8l7jcUzSKLH7GXc284PtDT0MLj6YiB9sxixxw2ICWwiivXcpf43kvDs7uTwrRWqgx8pOSi/OtYznJyfOEwFZE9eRZPIyGiwO4f4RBaxYnaRpMywGrQM1VqaGdXZ0DTuo6v9UBWGASn6SieKYvgcjuwfuEPb6Ye7lKPmKsJmMHHxx7sVFVy39pzWwSJHU+Of8BOckSteW69cZZF2aF4EsnwUFKDN593JLvmsCaLn91rR+56pxD/SO1VcP0/dwqe4eyCy0mIRwX8GVcsD4xIUYH5kHjjhHv4WtGEFw0ZXuqtlzXhEV1gdGWboaN6Gp+yGf1wZ/+63QQ4uVQ5b/vP7FRJCSPHr4wZwtq8z8mox70S1sp29iktjVkihne1/JtIS5tgXvvcRqNCz0P8FqqM4+WgqI3am+bm+Xn+7aWxm7/pgvLMuPoQ51d/jYrMMAoD0Q0zgDjMqRC6wM6EYtt/jjebdtlcqmwDmElY/Geo45fkGZ+bUgk0UPUz+E9TCMwbejQfEPE0s4IB9yFeQNKFszi0l9y4dnegOoDo9MlpzcKWGUvXiNMwir9+xNt0caONyRiYzfameme9+yoMxMQ/59wOKalI4PqgKQVqMJC4iMXU59qE6BQ7zrOEr00C5JayHSV+3ITGRgutpd4a3XjtYa68Y/OANgxesqBNuCenakbUmCjH0HII7zfc2oFc18enVaKxrYsHshvia3UZX9kwQtJ4gljkK1kZjieatChkzTlY8i9R7z0AohG5x+8Hl5QabI0urDsQYh8V94+54QGSVrU4mwU3xOYK9KB4oOCL+6zvG2+d1T7eeyM4dXYEBfpFVZqHB4NC+1SuqKrFXNUnh5k8zOB4tcQp4tbU9EdpKM/7Er8ZB1gHK4S7RSON4i7vPECbUXj6h5K40sX9qm2tHwNwE/hpl6Ae7aBVNb07AYYcBkioRfavx1X7XXaICcr8ImKS7IIWzyZW19/AW/JlUgk7QpPtH7o1lamIFy8VlJB7+bY8IjWmv7HSf0bmCU8HxYi9ec24Q3sRn2tS8NWEyM7LVwdG9gF4PGwNwwnqAdyCcvk6xFJTLmdhEcOnNwYTY+/mqkCt+Zq2ykPg4dvn0dj92s2mG5tT94K675Iw/yqRBnIuXjVvAuOk2MtWxH/z3Tn1Q6gKpxBhRNxGq/yv6IjvR+Ypw1bolMpJfPT1UsFsffcHWV5u2fWN/TqOCEENLJRFo88Y0RkloiAUuTpSnQrE4GfxfRFERbq0Af1+0100yjIJ0gp4oGdwppS1CXE0+cyMEudB4GyIwVoZR3UgoL8Dye/HsDye5FCEWstBEK52MyGpWJFU3DDWH24cG7H7ttS4iy3hgdGuAmUJOfSuklx9s0G94Acz0ymZFiXAYOBTxrAbW2VJo01U2LdQ7nwLZg3MJ0MAj4dd9rXGWNGolOJJIWJbYAvNTg3OkHrrQKp2F9ZqlzlIT7N/XPa57oMzaM7iWW7czIMaploJAV/zWw2CRGlbF4UWpde4D7k01OkK2zBQqiTDhn/KD72sPXgVNrKimLbjBtyfHTIXqpMj/4nayU+QXtRYaIiNtFHpX71ipAprW6qruQMnQn76nX/q3njwvQxvrBfYcvv5qZ7jem4HEER93zpkx2ogfjEg/l5jRBo/KsUoX6AjehTzgHuzKkslvAiPviJtdIWHqhyD6hNJ+0tw+wsxbt//GT0NJsPhcio4nA2gQeRWth5dAkh26TdNNIdiVtjEIJFc+gWFJOk4Tll+az0CuvJPSx9e6os5NK6/KiZktp6wL1dK4RbjDlGh4b20RSUFqlMUaVw9ip8/Itox882GiXGz54u3J/7psnxTc30fBSqRlT/FIaauT+30ASjpwwSDi0nPcAKbU8H/IKm+UbG2pilcO3kJ5FdixKUnDWOoraQwJG9VxMphejVa6fIml4W1lJ/TMqbVtRGiOpN+WC8v4NYyGbXsNxnbAMYTx+DVvWxeYpyC3EoimX19eIBriiLWRLcHBh+IPDX/LxMImVntvX9AftQr7+Y9xCpdo+UiSEqhKCUFbY0Q9fPr6nQCpgvLl+1t9++9aAT+j21BtVlrqxlrNGdBJBCAg1cd7Nxa61x1N+V7MlOJd30Jld7FrPHXOnWuIoedPX5WTroc4C/88WEaaMDwZoCDIJwM47/veMPUl0AH8DsotCO50wlMKXfe4btdXRKKVydV+BzHqee6zZEjDxyFwzQizIwKD4mCxPoOTmSPhT7VH34k1J8DtEYhGbkajnbOVxKsE3mWO8onEkuPqqH7+PHmKtIYTz2SqUpgGU5SQjWdOCo+PnehMWqQrM0z+6Cx1gHIJzBRApHYo6JDB1uRWxpjohTiE1yjLM5X9MopIZSHDZTbx2NiUO++wOhY7FO/qW/cKDq7Lt6j24S34WtXg8fiyT9gkJYhJzsr+1Lsu5Vv/FL2PXuYfnX3S0NxdPwxEmHdfUqlqdHEhLqryGLR1XXxWl2qLF70khHMXtDHy5mPJRVWXc3mlwwBNA5LU1KC9BHGht2yGuOJTX5Y2ZfIZ9knAgzrzbkjP9vHLxDqQFSs/6NHLn2sfi1bbKsuGyKCpQqz62jHfa1bqg8HjYvJAU0zTtl4vlMQ=="}
-- CEETOS_RELEASE_SIGNATURE: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
-- 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=\"router-server\"}",
  ["ceetos/lib/store.lua"] = "local M={}local cache={}local function internalPath(path)return type(path)~=\"string\"or path:sub(-4)==\".new\"or path:sub(-4)==\".bak\"end local function call(fn,...)local result={pcall(fn,...)}if not result[1]then return false,tostring(result[2])end if result[2]==false then return false,tostring(result[3]or\"operation failed\")end return true,result[2],result[3]end local function exists(path)local ok,value=call(fs.exists,path)return ok and value==true end local function remove(path)if not exists(path)then return true end local ok,err=call(fs.delete,path)return ok,err end local function ensureDirectory(path)local dir=fs.getDir(path)if dir==\"\"or exists(dir)then return true end local ok,err=call(fs.makeDir,dir)return ok,err end local function readRaw(path)local ok,handleOrErr=call(fs.open,path,\"r\")if not ok or not handleOrErr then return false,nil,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local readOk,content=call(handle.readAll)local closeOk,closeErr=call(handle.close)if not readOk then return false,nil,content end if not closeOk then return false,nil,closeErr end return true,content end local function writeRaw(path,content)local ok,handleOrErr=call(fs.open,path,\"w\")if not ok or not handleOrErr then return false,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local writeOk,writeErr=call(handle.write,content)local closeOk,closeErr=call(handle.close)if not writeOk then return false,writeErr end if not closeOk then return false,closeErr end return true end local function move(source,destination)local ok,err=call(fs.move,source,destination)return ok,err end local function decode(raw)local ok,value=pcall(textutils.unserialise,raw)if not ok or value==nil then return false,nil,\"invalid serialised value\"end return true,value end local function readValue(path)local ok,raw,err=readRaw(path)if not ok then return false,nil,err end return decode(raw)end local function recoverValue(path)local activeOk,activeValue=false,nil if exists(path)then activeOk,activeValue=readValue(path)end if activeOk then remove(path..\".new\")remove(path..\".bak\")return true,activeValue end local backupOk,backupValue=false,nil if exists(path..\".bak\")then backupOk,backupValue=readValue(path..\".bak\")end if backupOk then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,backupValue end remove(path..\".new\")return false,nil end local function validLines(raw)for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local ok,value=pcall(textutils.unserialise,line)if not ok or value==nil then return false,\"invalid appended value\"end end end return true end local function recoverAppend(path)if exists(path)then local activeOk,raw=readRaw(path)if activeOk then local valid=validLines(raw)if valid then remove(path..\".new\")remove(path..\".bak\")return true,raw end end end if exists(path..\".bak\")then local backupOk,raw=readRaw(path..\".bak\")if backupOk and validLines(raw)then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,raw end end remove(path..\".new\")return false,\"no valid appended value\"end local function commitRaw(path,raw,validator)local dirOk,dirErr=ensureDirectory(path)if not dirOk then return false,dirErr end local temporary,backup=path..\".new\",path..\".bak\"local removeOk,removeErr=remove(temporary)if not removeOk then return false,removeErr end local writeOk,writeErr=writeRaw(temporary,raw)if not writeOk then remove(temporary);return false,writeErr end local checkOk,checkedRaw,checkErr=readRaw(temporary)if not checkOk then remove(temporary);return false,checkErr end local valid,validErr=validator(checkedRaw)if not valid then remove(temporary);return false,validErr or\"temporary validation failed\"end local backupRemoveOk,backupRemoveErr=remove(backup)if not backupRemoveOk then remove(temporary);return false,backupRemoveErr end if exists(path)then local backupOk,backupErr=move(path,backup)if not backupOk then remove(temporary);return false,backupErr end local activateOk,activateErr=move(temporary,path)if not activateOk then if not exists(path)then move(backup,path)end remove(temporary)return false,activateErr end else local activateOk,activateErr=move(temporary,path)if not activateOk then remove(temporary);return false,activateErr end end return true end function M.readCached(path,fallback)if internalPath(path)then return fallback end local entry=cache[path]if entry~=nil then return entry.value end return M.readFresh(path,fallback)end function M.readFresh(path,fallback)if internalPath(path)then return fallback end local ok,value=recoverValue(path)if not ok then value=fallback end cache[path]={value=value}return value end function M.read(path,fallback)return M.readCached(path,fallback)end function M.writeAtomic(path,value)if internalPath(path)then return false,\"cannot write store temporary or backup path\"end if value==nil then return false,\"cannot store nil\"end local serialisedOk,raw=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(raw)~=\"string\"then return false,tostring(raw or\"could not serialise value\")end local valid=decode(raw)if not valid then return false,\"could not validate serialised value\"end recoverValue(path)local ok,err=commitRaw(path,raw,decode)if ok then cache[path]={value=value}end return ok,err end function M.write(path,value)return M.writeAtomic(path,value)end function M.append(path,value,limits)if internalPath(path)then return false,\"cannot append to store temporary or backup path\"end if value==nil then return false,\"cannot append nil\"end local serialisedOk,line=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(line)~=\"string\"then return false,tostring(line or\"could not serialise value\")end local valid=validLines(line..\"\\n\")if not valid then return false,\"could not validate appended value\"end local recovered,current=recoverAppend(path)if not recovered then if exists(path)or exists(path..\".bak\")then return false,current end current=\"\"end local lines={}for existing in(current..\"\\n\"):gmatch(\"(.-)\\n\")do if existing~=\"\"then lines[#lines+1]=existing end end lines[#lines+1]=line local maxEntries=limits and tonumber(limits.maxEntries)local maxBytes=limits and tonumber(limits.maxBytes)if maxEntries then maxEntries=math.max(1,math.floor(maxEntries))end if maxBytes then maxBytes=math.max(1,math.floor(maxBytes))end while maxEntries and#lines>maxEntries do table.remove(lines,1)end local raw=table.concat(lines,\"\\n\")if#raw>0 then raw=raw..\"\\n\"end while maxBytes and#raw>maxBytes and#lines>1 do table.remove(lines,1)raw=table.concat(lines,\"\\n\")..\"\\n\"end if maxBytes and#raw>maxBytes then return false,\"appended value exceeds byte limit\"end local ok,err=commitRaw(path,raw,validLines)if ok then cache[path]=nil end return ok,err end function M.readAppend(path)if internalPath(path)then return\"\"end local ok,raw=recoverAppend(path)return ok and raw or\"\"end function M.invalidate(path)cache[path]=nil end return M",
  ["ceetos/lib/profile.lua"] = "local store=require(\"ceetos.lib.store\")local M={}M.PATH=\"/ceetos/profile.lua\"M.IDS={desktop=true,[\"recipe-server\"]=true,[\"router-server\"]=true,[\"auth-server\"]=true}local cache local function normalise(value)if type(value)~=\"table\"then value={}end local id=tostring(value.id or value.profile or\"desktop\")if not M.IDS[id]then id=\"desktop\"end return{schema=1,id=id,installedAt=tonumber(value.installedAt)or 0}end function M.current()if not cache then cache=normalise(store.read(M.PATH,{id=\"desktop\"}))end return cache end function M.id()return M.current().id end function M.is(id)return M.id()==id end function M.isServer()return M.id()~=\"desktop\"end function M.set(id)assert(M.IDS[id],\"invalid CeetOS profile\")cache={schema=1,id=id,installedAt=os.epoch(\"utc\")}return store.write(M.PATH,cache)end function M.capability(name)local id=M.id()local tableFor={desktop={desktop=true,craftingClient=true,orders=true},[\"recipe-server\"]={server=true,recipes=true,recipeImport=true,recipePlan=true},[\"router-server\"]={server=true,routing=true},[\"auth-server\"]={server=true,authAuthority=true},}return tableFor[id][name]==true end return M",
  ["ceetos/lib/auth.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local audit=require(\"ceetos.lib.audit\")local M={current=nil}local USERS=\"/ceetos/data/users.lua\"local SESSION=\"/ceetos/data/session.lua\"local TOMBSTONES=\"/ceetos/data/user-tombstones.lua\"local THROTTLE=\"/ceetos/data/login-throttle.lua\"local RECOVERY=\"/ceetos/data/recovery.lua\"local AUTHORITY=\"/ceetos/data/auth-authority.lua\"local CENTRAL_SESSION=\"/ceetos/data/auth-session.lua\"local DIRECTORY=\"/ceetos/data/auth-directory.lua\"local rank={viewer=1,operator=2,admin=3}M.SESSION_TTL_MS=8*60*60*1000 M.LOGIN_THROTTLE={failures=5,windowMs=5*60*1000,lockMs=60*1000,maxEntries=64}local configuredWorkFactor=password.DEFAULT_WORK_FACTOR local sessionPathDelete local function now()return os.epoch(\"utc\")end local function accountName(name)return type(name)==\"string\"and name:match(\"^[%w_%-]+$\")and#name<=32 end local function users()store.invalidate(USERS);return store.read(USERS,{})end local function save(value)return store.write(USERS,value)end local function tombstones()store.invalidate(TOMBSTONES);return store.read(TOMBSTONES,{})end local function saveTombstones(value)return store.write(TOMBSTONES,value)end local function authority()store.invalidate(AUTHORITY)local value=store.read(AUTHORITY,nil)return type(value)==\"table\"and value.active==true and type(value.id)==\"string\"and value or nil end function M.authority()return authority()end function M.centralActive()return authority()~=nil end local function centralDirectory()store.invalidate(DIRECTORY)local value=store.read(DIRECTORY,{})return type(value)==\"table\"and type(value.users)==\"table\"and value or{users={}}end function M.acceptAuthority(record)assert(type(record)==\"table\"and type(record.id)==\"string\"and#record.id<=64,\"invalid auth authority\")local public={schema=1,active=true,id=record.id,term=math.max(0,math.floor(tonumber(record.term)or 0)),revision=math.max(0,math.floor(tonumber(record.revision)or 0)),seen=now()}assert(store.write(AUTHORITY,public),\"could not save auth authority\")if type(record.directory)==\"table\"then assert(store.write(DIRECTORY,{schema=1,revision=public.revision,users=record.directory}),\"could not save account directory\")end local loaded,profile=pcall(require,\"ceetos.lib.profile\")if not loaded or not profile.is(\"auth-server\")then if fs.exists(USERS)then fs.delete(USERS)end if fs.exists(TOMBSTONES)then fs.delete(TOMBSTONES)end sessionPathDelete()end return public end function M.updateDirectory(directory,revision)if type(directory)~=\"table\"then return false,\"invalid account directory\"end return store.write(DIRECTORY,{schema=1,revision=math.max(0,math.floor(tonumber(revision)or 0)),users=directory})end function M.saveCentralSession(value)if type(value)~=\"table\"or not accountName(value.name)or type(value.role)~=\"string\"then return false,\"invalid central session\"end local session={sessionVersion=3,name=value.name,role=value.role,token=value.token,issued=value.issued,expires=value.expires,accountRevision=value.accountRevision,authority=value.authority}if type(session.token)~=\"string\"or#session.token<16 then return false,\"invalid central session token\"end store.write(CENTRAL_SESSION,session)M.current=nil return true end local function safeAudit(action,detail)pcall(audit.log,\"auth\",action,detail or{})end local function stamp(account)account.updated=now()account.origin=tostring(os.getComputerID())account.revision=math.max(0,math.floor(tonumber(account.revision)or 0))+1 return account end local function makeAccount(role,plainPassword,context)local record,err=password.record(plainPassword,password.newSalt(context),configuredWorkFactor)assert(record,err)record.role=role return stamp(record)end sessionPathDelete=function()if fs.exists(SESSION)then fs.delete(SESSION)end store.invalidate(SESSION)end local function saveSession()if M.current==nil then sessionPathDelete();return end local durable={sessionVersion=2,name=M.current.name,nonce=M.current.nonce,issued=M.current.issued,expires=M.current.expires,accountRevision=M.current.accountRevision,}store.write(SESSION,durable)end local function makeSession(name,account)local issued=now()M.current={name=name,role=account.role,nonce=password.newSalt(\"session:\"..name),issued=issued,expires=issued+M.SESSION_TTL_MS,accountRevision=tonumber(account.revision)or 0,}saveSession()return M.current end local function liveAccount(name)local all=users()return all[name],all end local function normaliseSession(saved,account)if type(saved)~=\"table\"or not account or account.disabled then return nil end if saved.sessionVersion==2 then local issued,expires,revision=tonumber(saved.issued),tonumber(saved.expires),tonumber(saved.accountRevision)if type(saved.nonce)~=\"string\"or#saved.nonce<16 or not issued or not expires or not revision then return nil end if expires<=now()or revision~=(tonumber(account.revision)or 0)then return nil end return{name=saved.name,role=account.role,nonce=saved.nonce,issued=issued,expires=expires,accountRevision=revision}end if saved.sessionVersion==nil and type(saved.role)==\"string\"then return\"legacy\"end return nil end function M.refreshSession()local central=authority()if central then store.invalidate(CENTRAL_SESSION)local saved=store.read(CENTRAL_SESSION,nil)local entry=type(saved)==\"table\"and centralDirectory().users[saved.name]or nil if type(saved)~=\"table\"or saved.sessionVersion~=3 or saved.authority~=central.id or type(saved.token)~=\"string\"or(tonumber(saved.expires)or 0)<=now()or type(entry)~=\"table\"or entry.disabled==true or saved.accountRevision~=entry.revision then M.current=nil if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end return nil end M.current={name=saved.name,role=entry.role,nonce=saved.token,issued=saved.issued,expires=saved.expires,accountRevision=saved.accountRevision,authority=central.id,central=true}return M.current end store.invalidate(SESSION)local saved=store.read(SESSION,nil)if type(saved)~=\"table\"or not accountName(saved.name)then M.current=nil;return nil end local account=liveAccount(saved.name)local session=normaliseSession(saved,account)if session==\"legacy\"then return makeSession(saved.name,account)end if not session then M.current=nil sessionPathDelete()return nil end M.current=session return M.current end local function throttleState()store.invalidate(THROTTLE)local data=store.read(THROTTLE,{})return type(data)==\"table\"and data or{}end local function saveThrottle(data)local entries={}for name,entry in pairs(data)do if accountName(name)and type(entry)==\"table\"and type(entry.last)==\"number\"then entries[#entries+1]={name=name,last=entry.last}end end table.sort(entries,function(a,b)return a.last>b.last end)local kept={}for index,entry in ipairs(entries)do if index<=M.LOGIN_THROTTLE.maxEntries then kept[entry.name]=data[entry.name]end end store.write(THROTTLE,kept)end local function locked(name)if not accountName(name)then return false end local entry=throttleState()[name]return entry and(tonumber(entry.lockedUntil)or 0)>now()or false end local function noteFailure(name,reason)if not accountName(name)then return end local data,entry,time=throttleState(),nil,now()entry=data[name]or{failures=0,first=time}if time-(tonumber(entry.first)or 0)>M.LOGIN_THROTTLE.windowMs then entry.failures,entry.first=0,time end entry.failures=math.max(0,math.floor(tonumber(entry.failures)or 0))+1 entry.last=time if entry.failures>=M.LOGIN_THROTTLE.failures then entry.lockedUntil=time+M.LOGIN_THROTTLE.lockMs end data[name]=entry saveThrottle(data)safeAudit(\"login.failure\",{account=name,reason=reason or\"invalid\",throttled=(entry.lockedUntil or 0)>time})end local function clearFailures(name)local data=throttleState()if data[name]~=nil then data[name]=nil;saveThrottle(data)end end function M.throttleStatus(name)local entry=accountName(name)and throttleState()[name]or nil if not entry then return{failures=0,lockedUntil=0}end return{failures=tonumber(entry.failures)or 0,lockedUntil=tonumber(entry.lockedUntil)or 0}end function M.setPasswordWorkFactor(value)local work,err=password.normaliseWorkFactor(value)assert(work,err)configuredWorkFactor=work return work end function M.passwordWorkFactor()return configuredWorkFactor end function M.bootstrap(initialPassword)if authority()then return false end local all=users()if next(all)then return false end local plainPassword=initialPassword if plainPassword==nil then term.write(\"Create CeetOS admin password: \");plainPassword=read(\"*\")end local account=makeAccount(\"admin\",plainPassword,\"admin\")all.admin=account assert(save(all),\"could not save administrator account\")makeSession(\"admin\",account)safeAudit(\"bootstrap\",{account=\"admin\"})return true end function M.login(name,plainPassword)if authority()then local client=require((\"ceetos.lib.auth_client\"))return client.login(name,plainPassword)end if not accountName(name)or type(plainPassword)~=\"string\"then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if locked(name)then safeAudit(\"login.failure\",{account=name,reason=\"throttled\",throttled=true})return false,\"too many failed attempts; try again later\"end local account,all=liveAccount(name)if not account or account.disabled then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end local valid,state=password.verify(account,plainPassword)if not valid then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if state==\"legacy\"then local upgraded=makeAccount(account.role,plainPassword,\"upgrade:\"..name)upgraded.updated=account.updated or upgraded.updated upgraded.origin=account.origin or upgraded.origin upgraded.revision=math.max(tonumber(account.revision)or 0,upgraded.revision)stamp(upgraded)all[name]=upgraded assert(save(all),\"could not upgrade password record\")account=upgraded safeAudit(\"password.upgraded\",{account=name})end clearFailures(name)makeSession(name,account)safeAudit(\"login.success\",{account=name})return true end function M.logout()M.current=nil sessionPathDelete()if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end end function M.add(name,role,plainPassword)if authority()then assert(rank[role]and accountName(name),\"invalid user or role\")local record,err=makeAccount(role,plainPassword,\"central:\"..name)assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"add\",{name=name,role=role,record=record})end M.require(\"operator\")assert(rank[role],\"invalid role\")if role==\"admin\"then M.require(\"admin\")end assert(accountName(name),\"invalid user name\")local all=users()assert(not all[name],\"user exists\")all[name]=makeAccount(role,plainPassword,name)assert(save(all),\"could not save user\")safeAudit(\"user.add\",{account=name,role=role})end local function adminCount(all)local count=0 for _,account in pairs(all)do if account.role==\"admin\"and not account.disabled then count=count+1 end end return count end function M.setRole(name,role)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"role\",{name=name,role=role})end M.require(\"operator\")assert(accountName(name)and rank[role],\"invalid user or role\")local all,account=users(),users()[name]assert(account,\"unknown user\")if role==\"admin\"or account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot change the active account role\")assert(not(account.role==\"admin\"and role~=\"admin\"and adminCount(all)<=1),\"cannot remove the last administrator\")account.role=role stamp(account)all[name]=account assert(save(all),\"could not save account role\")safeAudit(\"user.role\",{account=name,role=role})end function M.setDisabled(name,disabled)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"disable\",{name=name,disabled=disabled==true})end M.require(\"admin\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")assert(not(M.current and M.current.name==name),\"cannot disable the active account\")if disabled then assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot disable the last administrator\")end account.disabled=disabled==true stamp(account)all[name]=account assert(save(all),\"could not save account state\")safeAudit(\"user.disabled\",{account=name,disabled=account.disabled})end function M.remove(name)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"remove\",{name=name})end M.require(\"operator\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot delete the active account\")assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot delete the last administrator\")all[name]=nil local removed=tombstones()removed[name]=now()assert(saveTombstones(removed),\"could not save account tombstone\")assert(save(all),\"could not remove account\")safeAudit(\"user.remove\",{account=name})end local function recoveryActive()store.invalidate(RECOVERY)local recovery=store.read(RECOVERY,{})return type(recovery)==\"table\"and(tonumber(recovery.until_ts)or 0)>now()end local function setPassword(name,plainPassword)assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")local replacement=makeAccount(account.role,plainPassword,\"reset:\"..name)replacement.updated=account.updated or replacement.updated replacement.origin=account.origin or replacement.origin replacement.revision=math.max(tonumber(account.revision)or 0,replacement.revision)replacement.disabled=account.disabled==true stamp(replacement)all[name]=replacement assert(save(all),\"could not save password\")if M.current and M.current.name==name then M.current=nil;sessionPathDelete()end safeAudit(\"password.reset\",{account=name})return true end function M.resetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end if not M.allowed(\"admin\")and not recoveryActive()then error(\"permission denied (requires admin or active recovery window)\",2)end return setPassword(name,plainPassword)end function M.adminResetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end M.require(\"operator\")local account=users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end return setPassword(name,plainPassword)end function M.allowed(role)if not rank[role]then return false end local current=M.refreshSession()return current~=nil and rank[current.role]>=rank[role]end function M.require(role)if not M.allowed(role)then error(\"permission denied (requires \"..tostring(role)..\")\",2)end end function M.list()local out={}local source=authority()and centralDirectory().users or users()for name,account in pairs(source)do out[#out+1]={name=name,role=account.role,disabled=account.disabled==true,revision=account.revision}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.snapshot()if authority()then return{users={},tombstones={},source=tostring(os.getComputerID()),schema=3,central=true}end return M.authoritySnapshot()end function M.authoritySnapshot()local copy={users={},tombstones={},source=tostring(os.getComputerID()),schema=2}for name,account in pairs(users())do copy.users[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=tonumber(account.revision)or 0,disabled=account.disabled==true,updated=account.updated or 0,origin=account.origin or copy.source,}end for name,removed in pairs(tombstones())do copy.tombstones[name]=removed end return copy end local function validIncomingPassword(account)if password.isModern(account)then local work=password.normaliseWorkFactor(account.workFactor)return work~=nil and type(account.verifier)==\"string\"and#account.verifier==64 and account.verifier:match(\"^[0-9a-f]+$\")~=nil end return type(account.salt)==\"string\"and#account.salt>0 and#account.salt<=256 and type(account.verifier)==\"string\"and account.verifier:match(\"^[0-9a-fA-F]+$\")~=nil and#account.verifier==8 end function M.merge(snapshot,authoritySeed)if authority()and authoritySeed~=true then return false,\"distributed account sync is disabled by central authority\"end if type(snapshot)~=\"table\"or type(snapshot.users)~=\"table\"then return false,\"invalid account sync\"end local all,removed,changed=users(),tombstones(),false for name,deletedAt in pairs(snapshot.tombstones or{})do if accountName(name)and type(deletedAt)==\"number\"and deletedAt>(removed[name]or 0)then local localAccount=all[name]if not localAccount or(localAccount.updated or 0)<=deletedAt then all[name],removed[name],changed=nil,deletedAt,true end end end for name,account in pairs(snapshot.users)do if accountName(name)and type(account)==\"table\"and rank[account.role]and validIncomingPassword(account)then local updated=tonumber(account.updated)or 0 local localAccount,incomingOrigin=all[name],tostring(account.origin or snapshot.source or\"\")local localOrigin=localAccount and tostring(localAccount.origin or os.getComputerID())or\"\"local wins=not localAccount or updated>(localAccount.updated or 0)or(updated==(localAccount.updated or 0)and incomingOrigin~=\"\"and incomingOrigin<localOrigin)if(removed[name]==nil or updated>removed[name])and wins then all[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=math.max(0,math.floor(tonumber(account.revision)or 0)),disabled=account.disabled==true,updated=updated,origin=incomingOrigin,}changed=true end end end if changed then assert(save(all),\"could not save account sync\")assert(saveTombstones(removed),\"could not save account tombstones\")M.refreshSession()end return changed end function M.authorityAccount(name)if not accountName(name)then return nil end return users()[name]end function M.authorityDirectory()local out={}for name,account in pairs(users())do out[name]={role=account.role,disabled=account.disabled==true,revision=tonumber(account.revision)or 0}end return out end function M.authorityMutate(action,fields)fields=type(fields)==\"table\"and fields or{}local name=fields.name assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]if action==\"add\"then assert(not account,\"user exists\")assert(rank[fields.role],\"invalid role\")local record=fields.record assert(type(record)==\"table\"and password.isModern(record),\"central account mutation requires a verifier record\")record.role,record.disabled=fields.role,false;all[name]=stamp(record);assert(save(all),\"could not save user\")elseif action==\"role\"then assert(account and rank[fields.role],\"unknown user or invalid role\")if account.role==\"admin\"and fields.role~=\"admin\"then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot demote the last active admin\")end account.role=fields.role;stamp(account);all[name]=account;assert(save(all),\"could not save role\")elseif action==\"disable\"then if account and account.role==\"admin\"and fields.disabled==true then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot disable the last active admin\")end assert(account,\"unknown user\");account.disabled=fields.disabled==true;stamp(account);all[name]=account;assert(save(all),\"could not save user state\")elseif action==\"remove\"then assert(account,\"unknown user\")if account.role==\"admin\"and not account.disabled then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot remove the last active admin\")end all[name]=nil;local removed=tombstones();removed[name]=now();assert(saveTombstones(removed),\"could not save tombstone\");assert(save(all),\"could not remove user\")elseif action==\"reset\"then assert(account,\"unknown user\")local replacement=fields.record assert(type(replacement)==\"table\"and password.isModern(replacement),\"central password reset requires a verifier record\")replacement.role,replacement.disabled=account.role,account.disabled==true;all[name]=stamp(replacement);assert(save(all),\"could not save password\")else error(\"unsupported account mutation\")end safeAudit(\"authority.\"..action,{account=name})return M.authorityDirectory()end M.refreshSession()return M",
  ["ceetos/lib/password.lua"] = "local M={}M.SCHEME=\"pbkdf2-hmac-sha256\"M.PASSWORD_VERSION=2 M.DEFAULT_WORK_FACTOR=256 M.MIN_WORK_FACTOR=64 M.MAX_WORK_FACTOR=2048 M.MIN_LENGTH=8 M.MAX_LENGTH=128 local MOD=4294967296 local band,bor,bxor,bnot=bit32.band,bit32.bor,bit32.bxor,bit32.bnot local rshift,lshift=bit32.rshift,bit32.lshift local unpack=table.unpack or unpack local K={0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,}local initial={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19,}local function add(...)local value=0 for i=1,select(\"#\",...)do value=(value+(select(i,...)or 0))%MOD end return value end local function rrotate(value,amount)if bit32.rrotate then return bit32.rrotate(value,amount)end return bor(rshift(value,amount),lshift(value,32-amount))end local function word(bytes,index)return bytes:byte(index)*16777216+bytes:byte(index+1)*65536+bytes:byte(index+2)*256+bytes:byte(index+3)end local function packWord(value)return string.char(band(rshift(value,24),0xff),band(rshift(value,16),0xff),band(rshift(value,8),0xff),band(value,0xff))end local function sha256Raw(value)local bitLength=#value*8 value=value..string.char(0x80)value=value..string.rep(\"\\0\",(56-(#value%64))%64)value=value..packWord(math.floor(bitLength/MOD))..packWord(bitLength%MOD)local h={unpack(initial)}for offset=1,#value,64 do if#value>16384 and offset>1 and((offset-1)/64)%128==0 and type(sleep)==\"function\"then sleep(0)end local w={}for i=1,16 do w[i]=word(value,offset+(i-1)*4)end for i=17,64 do local x,y=w[i-15],w[i-2]local s0=bxor(rrotate(x,7),rrotate(x,18),rshift(x,3))local s1=bxor(rrotate(y,17),rrotate(y,19),rshift(y,10))w[i]=add(w[i-16],s0,w[i-7],s1)end local a,b,c,d,e,f,g,hh=unpack(h)for i=1,64 do local s1=bxor(rrotate(e,6),rrotate(e,11),rrotate(e,25))local choice=bxor(band(e,f),band(bnot(e),g))local t1=add(hh,s1,choice,K[i],w[i])local s0=bxor(rrotate(a,2),rrotate(a,13),rrotate(a,22))local majority=bxor(band(a,b),band(a,c),band(b,c))local t2=add(s0,majority)hh,g,f,e,d,c,b,a=g,f,e,add(d,t1),c,b,a,add(t1,t2)end h[1],h[2],h[3],h[4]=add(h[1],a),add(h[2],b),add(h[3],c),add(h[4],d)h[5],h[6],h[7],h[8]=add(h[5],e),add(h[6],f),add(h[7],g),add(h[8],hh)end local result={}for i=1,8 do result[i]=packWord(h[i])end return table.concat(result)end local function hmac(key,message)if#key>64 then key=sha256Raw(key)end key=key..string.rep(\"\\0\",64-#key)local inner,outer={},{}for i=1,64 do local byte=key:byte(i)inner[i],outer[i]=string.char(bxor(byte,0x36)),string.char(bxor(byte,0x5c))end return sha256Raw(table.concat(outer)..sha256Raw(table.concat(inner)..message))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function cooperate(round)if round%32~=0 or not(os and os.queueEvent and os.pullEvent)then return end os.queueEvent(\"ceetos_password_yield\")os.pullEvent(\"ceetos_password_yield\")end local function toHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function constantEqual(left,right)if type(left)~=\"string\"or type(right)~=\"string\"then return false end local differing=bxor(#left,#right)local length=math.max(#left,#right)for i=1,length do differing=bor(differing,bxor(left:byte(i)or 0,right:byte(i)or 0))end return differing==0 end function M.hmacSha256(key,message)if type(key)~=\"string\"or type(message)~=\"string\"then return nil,\"HMAC key and message must be strings\"end return toHex(hmac(key,message))end function M.sha256(value)if type(value)~=\"string\"then return nil,\"SHA-256 input must be a string\"end return toHex(sha256Raw(value))end function M.constantTimeEqual(left,right)return constantEqual(left,right)end function M.legacyDigest(value)local h=2166136261 for i=1,#value do h=bxor(h,value:byte(i))h=(h*16777619)%MOD end return string.format(\"%08x\",h)end function M.normaliseWorkFactor(value)value=tonumber(value)if not value or value%1~=0 then return nil,\"invalid password work factor\"end if value<M.MIN_WORK_FACTOR or value>M.MAX_WORK_FACTOR then return nil,\"password work factor must be \"..M.MIN_WORK_FACTOR..\"-\"..M.MAX_WORK_FACTOR end return value end function M.policy(password)if type(password)~=\"string\"then return false,\"password is required\"end if#password<M.MIN_LENGTH or#password>M.MAX_LENGTH then return false,\"password must contain \"..M.MIN_LENGTH..\"-\"..M.MAX_LENGTH..\" characters\"end if password:find(\"[%z\\1-\\31\\127]\")then return false,\"password contains control characters\"end return true end function M.derive(password,salt,workFactor)local work,err=M.normaliseWorkFactor(workFactor)if not work then return nil,err end if type(password)~=\"string\"or type(salt)~=\"string\"or#salt<16 or#salt>256 then return nil,\"invalid password record\"end local block=string.char(0,0,0,1)local value=hmac(password,salt..block)local result=value for _=2,work do value=hmac(password,value)result=xorBytes(result,value)cooperate(_)end return toHex(result)end local saltCounter=0 function M.newSalt(context)saltCounter=saltCounter+1 local now=os.epoch and os.epoch(\"utc\")or 0 local computer=os.getComputerID and os.getComputerID()or 0 local label=os.getComputerLabel and os.getComputerLabel()or\"\"local random=math.random and math.random(0,2147483647)or 0 return toHex(sha256Raw(table.concat({tostring(now),tostring(computer),tostring(label),tostring(context or\"\"),tostring(saltCounter),tostring(random)},\":\"))):sub(1,32)end function M.record(password,salt,workFactor)local valid,err=M.policy(password)if not valid then return nil,err end local work,workErr=M.normaliseWorkFactor(workFactor or M.DEFAULT_WORK_FACTOR)if not work then return nil,workErr end salt=salt or M.newSalt()local verifier,deriveErr=M.derive(password,salt,work)if not verifier then return nil,deriveErr end return{passwordVersion=M.PASSWORD_VERSION,scheme=M.SCHEME,salt=salt,verifier=verifier,workFactor=work,}end function M.isModern(record)return type(record)==\"table\"and record.passwordVersion==M.PASSWORD_VERSION and record.scheme==M.SCHEME end function M.verify(record,password)if type(record)~=\"table\"or type(password)~=\"string\"or type(record.salt)~=\"string\"or type(record.verifier)~=\"string\"then return false,\"invalid password record\"end if M.isModern(record)then local verifier,err=M.derive(password,record.salt,record.workFactor)if not verifier then return false,err end return constantEqual(record.verifier,verifier),nil end return constantEqual(record.verifier,M.legacyDigest(record.salt..password)),\"legacy\"end return M",
  ["ceetos/lib/release_keys.lua"] = "return{algorithm=\"lamport-sha256-v1\",roots={[\"router-server-release-0.16.6\"]={public=\"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\",profile=\"router-server\"},[\"router-server-release-0.16.7\"]={public=\"4rCcQ1vP5WOcEPK6TvqRI7Fxbz/vCDjyQrzqTpPAibAqS7VveTUdkSdlQLIIwnk1K/knq/k7ulrZMEhwB4zNDAtWYVaCSh8g6y0qxkixirxKZGjPN9w9CzDeC5SWwXSaR53P9lxY7Msb5H+Q6d+T8545bag20EOy/7xS4WrKdld8lfGYeHOIo8SJJHWMeFOsYWkGXDiWBxM/gawkStQxD45r4SwhEOWvO1j2C0wGncUc5SAfNmjT44HjKudShRuA0e9209Ln0av5FII44lg4DQ9Pgbsl84skwfDCGZrmpmZq/7kNS8I5fqbChZQMXvFObTYappaOQo4f9PJJHersX3pDQEgJKXYLKROjh8CdtWYgT1rAc0uleMwTATfjfekOaeIAz9t+nvjJocH6KmehdU57kMcdB9Nx+oK4VF2nRrR1NCltWc4GKSBEUFIj4AeDEsSzTDlXzI9l42CM0/vg9ETfsPmGGFARgm1qgPrFDZ+4qnqqGWoQYc51Ghpcy5tDiKxl4BWpoh9a32C4taCe42jkqpyhQOC06YjZUnuSmKgZs8PMMc95wgPcrmCs6DRpvD7ll7wpog/NB7siTJNYtAecNQgItCWG7n86l8uSSPjrAiJhYzDsBjgRtst2G6zQ2vr8EHeZTqhPjwYHHwpKMLpzkZ/jU4JSwXPs2JRatFuB88l34KB8Q5g7X+G5w2/ksvlCkVmsuHHdE3jtPjXKOqJmg6P9D8fDbNCfRauoS0lbzU8F0n8K5QIlNXIWqOp31SnJX5NPiZHYhoCxOS2HjHdBBQEFXIuAENSu922/uXRpjr9WkBxJYe3v0HDSUJtcUSLThtaYcNlpXxmre/6DIbF/QVM101H1xZtcsQgq7jRusrXX3mzKmCUamAoaLEOhJ9vloVY+d8UFLKcEFBPBN2m4CX9Ck6Vh0wCZJJJ5APxXeVrsIOOLnfy8KOcKLe7imMQ5jAicS9FWie5pJ1ApzW9y7oQnLRMWLYssjbvqNG3tDsgDlnicqstqa5MO6EO9ZsmqbrZhSTckT4O9gfa8EEdTLNtGsnxSZFUkeeunXHsR2+APg6dePAP7RFu7L8BoWNJ2QoWcN9+u6++qQZhgzaIMSuirkcOYBIIajtOG4Qb1lRf+cAFzEwKH0XaPhbOH0FSu3xfPk007yKvjHrLm1IaeBfYporzJZDmcHgBoDXqJ89LIchuB7pZFQk7npSQRC5JvM/Dq0x0+Mgs1p07G+8S+A0Xco24NTie8H6D5H/hpxvM8mrClH0PJmXh2Vem4EYUar/HnNEbdjGX0Bek2sZDUENebSeay6iTmserQqnf+O3MD/dmuzexewJpJvjTFRWv9zeGyzrQVPiWe4gvUUYcQgBvXobWVWj/FrujH9Pi2voNeAibcvBDnF2nI9hOnQTpOZrgjBRgZ3sRnfSNzNBNe0cYRwuQ6mkDEmEKjsw315ndqLcjbGPeRzOC08nYxZKyFQMJ8yZHNA8P0aYfaT88HTH66wjZuUKHVlCeWMdnL1KVMp/DQgnJ+r1rIOt+ouv5S2iBWyW0k4RX6hWcog+rlysY5aNGF4reSAqTiYwEMPJTBJlxOD44FehYxQ0AHueqZAcnNiDJYk4rL0YTISSE6ATtetTYc5Vm0vaxJfXDzn+4Tg4t1I5hLsLhiOUNbiz6hac3Zn6n6ORO37YPMsslmOASN9CNdHNyGH+k/XtHr6MmYue4+sQvU8Cwmyv5mQR3EqCkEnJxs6h4zaqig4vKlKe8mQOWrggsi7K0YfVWR7YPiBvlcRYudF6NgH62+aKg0aJoBtLlWTiPOdv6689paYrp/igPIJI9de06uMnOZAiKyR5Ktt3w3v2GT4BGg7wDeCajN/631aJwLSM5eqKv3QUoMsgPlF2nksAyVsfGeEyPRTjvnNRddpkGfMG5Z+V7wZuuvyzZB3c0/ZZYMxYJT25nt3TT3Xlbtp08Ao9Y/U2SXhdYrmF6co5a+U2S0ZBHsQedAs+XoAhHXfoA7Xkbo9hHAvAs+AtqxDme7KLFzrJT0+DvbyscAL8PGvtgo2UAC3d8OIIFEUzkYRGVFzO+yqA9nhRioptqv48RLITO2OaQi5G3DYpM3bIbllNZu3Z2zxJxuqGPJvUl/dqPnJ/8IJcleyNS8fSIBTFCphzh+1DB/YPrb/aDz3WNOzYgJlvU7qr0UF1HtjmC1txVwAhKZ55Ab4qJ/0nRS1ZhiG9XLIqnoviTpvxNfqblSizB0sCJ7oUqI4gDzyoX9SEUZF7OUkpb3udgekzmu7fDds/E96opN3mBSs4LpWfwjwT/D6yGdxjmpVgMH1pOA33l8yI7CssBjhlwusidEmRGAAHfx/ETVTX31tRR5vhY/DpqyZRFJL2/yEsMbf5b3yMwnWguARYCc8mEmCqmE+k8AZd6rkFAmibriMEZrUQZGyjZSEfuz8Dt6om3XMg/DJISg9wtncdu4hmPbRQxMx1PmfzLB5p+wd4jrvT55bm+jbjAuMObptG/AEPQ6CBHpB9lX+pjDQOGZLHdgj31tDY4cyrEMXLUxA+N7sFjdJKOWjVnlS/g+rzEmUPmWEnnI9pt5X+34iwSgJMBLKtWOW69OVXWEcrhz0WNE/Sdqab+k4gkr6sKEX4u/ya63eN7Xg7JRKH9y8veySFit9CK5Vm6syVIdll8jFdPP4rawviFKIuFmibTo/71ELAsHC4quO4WwljR4+1O6J6V7gEeBqIpWMaEMoE0sSVtnIk3xXnKqlsbS8f4nYh0O+rLN/ggO+a6GNDFmqYJg7F1BEW/NRQsg71DvlpC/eRwr7if9xrDogB6f9DOFPj0bi4xjxzEuqgwpNGKGoY9KitD31Tn2jc9bgq+9F2kmMF/pb/HmZ2hwO4HtZbMxAH1FCsYeCScmzPUV0ye9v1zuzhq0tk1hbdBqvM5GN0RYg+iFDij/A7lrnsrAJIi3Q0mL8AdZ6MWu597XH1R7xPpsDvq29ku3waX7ZBRehUsAlkKN0gKbT1ZIlmf8iwqHEo+qnHKqxciV3f7f9MLQmYFwu7DPrqO6ZDEUhC4QSoNaPEkYJOxY6qsP2w3HGXH+NensPDC9aqsiashnusNCi4ZJ0yVAZQt4KtNO6vANWaL35UVhzDcmTSnRvfIRZV6qef7k9g3TEGcHN4+T9ZB3f2KVQzXoOnI6mjuWzLm6BVEvGQ2kV/4QvCREtd1fX41K1/Br8yaRl0qdXIUZHDfgnKoy3tNkgT9wFfmmwVpoFckek0M699JiPmvyql93flVewIYeUbp1ivJBd13d+aUV8KowXrNCHS+mQoMFHEysTXHmk+7YAZTnZP/ag4yrw9s1X6xTQ/EZD3kD24bIUCcccqXL6kPtZWguhGncGsLfiSITFUHqklXlDCeNjIIAypNCtkisduUFKFSgAyUuxvnRY/3cLtQozvfXfiHK6/Id8sTaXHgr7Jyw4AMKthOGe3I/x+rPhBanYC7S7hOxiqdhWadJoyncMSXK4YqQtNQfQO8TMFzY8YBU1U6RdZo4XjfD9QWr2aOLOcrTV10u2dCW1SH84cDsgLyveoDMMzKuMG71geyKMXbpkUq8T5xbUjrIb2KjNU5miwXOXjVYGP3SJnYHpaL/0fheMEeDtyaemiTP7LkVFSzM+Q1V4VkHWrxj2D0QXbIw0oA2jyZud4vgsvQ0TOSACOLSJlmIvmyXoF87RnCN9eVPII2MBFazvCvn4AmM1hpGw3UFjSu8vEv4g7v/7Tmke4yK3wDnGiP0ihk3iCEvWmvROSajlu2e52qC9zHKTl/J1MDRyRBBIyNDpAwORtnlVuHja61w9C1VSy3Yg/MPzlnfptry+8MDEtpXTCPZ4/bctXX4ebH1gpOWI0WMlUMXJK4eLTEaRYFQgIa4/D/Itjq+yZb+rW5+CHDDaVme3Ku8ANIibHjPE/zK7C25w75jXAKMfrjWCwjS7z7lKkpTacVSieKGGgkMSWZEOff6WNtjShkTBraIMavAh9mfmv10WFqxB9rNxSYn1dKn+UKXWRkaKw5IJZrSGbXSAeFkhx2psgl1Xg1a+m24ra0yjHD3gq2B0EqUAn0eEcrxXPg8P5/cg02M5ZWR4/DqSmsxADt4JxMi8XI7MskPBncW62xcG9s6ieap+ZUSLD/yDyYmxHGJ3Da/iRvuhV+sYE9k4VVDnmGkT9ME21z9+87edkQb9IgmuAD4DSydeSMcHAMUqdwfgahrT2aJ1YSAowFjSCqloaRdLBPcRSgtNh9a3/1AJFHQBZJYQtBkQLbZ83V+qmrFs4jykyWgMViWrlneaphO5Sn3nW7S7GYIfj2+HaGQP72RqUdwQL/DiZhR3TCqCnztlIwrsYPp7MhD1qYyVEoePfZ3B3gNlF7Hti+cz+yjhy4/bulisnEflxLOQHzqn/9bROkVcfm27CKHYgQAiXIvkxLdWn9aELGgytmOA9ogZ1628mLSnRn4jcM6u7OdwwB25UI2oWZnXbwEPIGb//1/B6R2G8Kpl2VaZJQofS3d9FQ0jKv2qP6PzDo/pcBCn8StDuKWx43iF9p/YLZqijPn18rMkwLcGy4pyjlgRcZ9cWRAV/T6P/zVDC7OThxFnY18GN964sGH3xfCKzwRFDabJTdyvQDVxE1Av0MgG0/Z7HCgMlVx+Xc6wMvLihnCC4xDN77XXMgWO8571RljjMG4hW5L9HeU1G3nwXKVHai7qspEP+m8CAJFcTctNgg/rVBRDKNx4JquSUWzdZ+F6i6kewY/GERe7R4gRfPcaUMdtisMK77P9Bdhv8SwAiuVMhGktT26hSm0vQuJ/JPyyzqwQmnoQbg9wecHBnSauJKZs2QD4rw8A/ACS5TmXzMoF+7k/EZoVGY36QSfysy5AFlaCIiZy5qGQXRK7GeX9ushK4P/IaiJS1/2H9k+e1tJMEkr7/MSp3Ocovz82iUN2nrL/gokPRaLzhwgh7TaEYYdxC8Rgja//c/0E6PN9tNKiJ4K7B2KCwGy74/KbUmzxc/LYsBTp291TfCCVE23lGioM119640BwSy2Vr3T+nFAyt7kNAcOAkJId1T/ijmZ6T2roZ60h1IFZM9Xy5BDiUiU0FOwHpd1x/SUnYcey07OWjlvABsal+KrpWUf5s0UOhViod5OCdXCA9qaHE2r2INT6FYFQ5FBn0GsUCbSp/OPtwW7V6fzKPlYfFI1e3vSMZCzBAikXzQYzkj8Clr21P3Q6rK51NEuLwdjX2I5/K8+fq+xEGphXBrTjL6oUybxax2WmUfDisv9ds+5cgarBMIq+X6te+wuIbHegL1LuVL82867dtyO1JtU4ltU1rYFKmNByw/JuolKO29+Qp1JOhon9yV0QaW0HQSI8qPTFbf+qWYocyZN2NUjYgzKLOh08F5xSfA503RroyLltp6yvC5wiXssuVo5m6EySGTvqFO1rkP+Fa7HA7k4/z6gKSZh8orAldK2M5fVuyq5eqEvl5V7YBXqexoAZLdNUW6f358bQebFLcICvk+jOt/tMjpiLs6JcUU2LVvabIq9BTHGAv9bZphUihMLlFMhARKeS0oOQyojfo9JUrcJgvZ969gYgacvtvHW/I+JyztsEVr2cUKV/yTPunQaF1mLEo/Co2vF/8ieXsGuvNyRyxE1BEASDPon9DU8CjunzkOd/cA3AegSdFq6Dff3eUNwLrAWk1F+10THGe0f2phvvMn6cjtvn/efrjAAilupWOpFsFtuD0AbnwozyOWEKMehoEy0959NcI1o44/Nb3nUSqUh7+BMktpULImpN7yeFVwdWG9db9qPBtMBcZokyaKGXIkPwafuogB7usv+uwXwnkpWrLhwoZy5Lw5I33SR8xy+qpld/MH8fkJivoIEtWaj7AY0WwAorVL86rflEPb4awvv+VW/ofgPr+pXo69CRhs3z7ZZ+WkcoIVtWLX0b0Q3MucR/tVAL3eovZk9xyUIQaAJSPJzQJ9WhEAX9hjWWc+5y+eTdMQ3UYB1PLk9HyYnkNGd/lMGJQXIRDmVbgv2PtvRKpXRwdZQABb3btfCD4/0ySovX9pDwwOYwwmloPsNaig/skMJwLxlwSjjs5hLuaw0XYTd8pXsoc43MFOVL18Pbx90QZjBonJmVUHpEdTJ7ad1wxSih6WT7tTe/wZlN03pgQRvbkSZx8mUtHooEtTmHZ86VPPLSsOXfjc/0Fchz70FQ05RRXZPESdh2kwUBorccKMq2ug4xv/X5YNwbA9lWH0ntHsOCwjDp4qEzFU6CZvmMQ9G2HSKGcciSZF3vZL8wv5oHICBpZStVPp3Itv0OKfoz8WzY705T6ivqtOQSHWPNX9u5+dO/sC1qGtCOzoBZm2No2RixIo/JS1Bswilh677cdw5KPg2gA5vnRjBLhdcHQ0wkJTO6QWhukU76xKtN4+T01Hz4a46uChAJvraoQ17Ee3nPLzk94vWmiWL7qdpzOEG8DdYr1UYE7uNP4D9+8AugD+m02ENBIgQzAUd0nGPllZ6kuHQXriGGyxA/aYG7kdnkObrPPZ/ZbWOSku9780pHiPIT+eLl/Rpu4se69+ywwt+8J+wrEs/+WGL+2qDLglN0KMIK5LwmFliAy9WFzhdQaTdV6p0mbVjbSPD9Oih6MX94PjLq6TWXkth2jy3LdeC7twHc+bPOI9kZ+kiP7BqIDBBeepj6nL3YBs386lyXdW+3h21KPnB3ImdAV/3Ygd4NF/ENYVei2AU1oExUDpibyR3gwzleYCzDSzNQCxlJu/3Az12fUio0EoUEPauYLkukC3/FUoA/Lt8MgKqeEuf2UOB3LSBwk2xK94HTOKPlN061vqaA27/P4QotH0h2PG07MHnjHWBUZRpj+cNyUnd3vCk5usGY2OjEdXuTaTxQTNs0Cxh6YM79MkMIriRToGSu/3rlYWXRcB3cRePpn5HMsKLjeBF7jTk2RdKn8f53nXHn+QsddR2TvHc6EdqzQ7Ys6T3B44SQwOxbmUzy2qgTQWlw53l+LNTvfNMfkWzYjzYTOoOhCJZaYCf3f5iSeAiQQu/5KJiFGiN4/0ubm4LicVFnAGMipBYz+ry/8vXcda1C6al8RjbGzJSaH2PCsLEmeXcl3V6nRIsUMbO99Lf/lZpVrYSGhvLJh4cGwdzTOA1vV6oyv7FC/DMjP9hHcJp8uVKUbrF6Yz8NeRye7gQWprJz2NbcHFICwmXvyP9MB+Hv0A3wYys4NLWe53KjngqWrcpTJoBUSHPpgYaG1+26OVH1eYCRJOrxWdQ4rDwn7EfRt5cFsORu5F6Mwu1jNhApELkZnicVZNvWmaj0QmkN0afXRfqvT+/n1VBZ1Dk07N7ylQAnW+8/lkSt6NZmnHY5RQGo07aVjJ2KDk4QKrglCAFeviH3ows99i+hiU2tJfMom4/VkPiWLdOslTQw1kMemL7Vhp21TX1SfXzxjmC0KwAseseFiS6wrUOnMB5JB0d8CmuxJzyRbIWt/VjdaHNkTON40IQp1IMZ1Qo2G2HVt/X89jYdkzvIP7HMbISM7ovKrrAC1HyxfE9rbvGSFO4ouEpFTx3XRm5/HSvV0oo6j8V8RLS6Z8ymM0NGl0TEuRCC8na6vbuGV6j7OjZG2CuO0SYYWVZm2oT4yt0+fic/NA0nR7gj+oHVi231ucv82byONOWFhzYV/botd4X1JPOdvLm6mHVih/T7e2gu8yUma0pPrInNWPL68+xBwJzSAToOY/JnFWRNoiN7CkO7pSpUZhwsoajFM0Wrd8bQp/mPpIws9rEgiC92HX22SU9V+Lfs8qHCG6nqxVpYUxLOux8eQFvnbmQd6wDVJH6LAGTKKHfQQ7R+rYIYhujlM4/NMPW78KcGG2sWLcgdb1oi1tcPwkcH8wSICeGRhFzcBCO923MMXvdzyWbc84UpcRy4NsyIyNaXe79FOiniU6tCT4vAyYq9mXooOxjLtO+8VGZoxMFCOuncjGYYPyFmUex0c/wiIl5tNeYs6HdP5KhJgBUiLhsuQq+PX/vZKYAsGhLa8XQ0XmdTYpzLHARJUUyWrHULBhOwvIXyxrgLFGUOZn2GGUcsj//7FZcOXzG9ns13TgvnfrTvnwBno2zNktliyiSQecA1OW98hEs86GnFqVcSn19BKfF/8JVgEEJeMsosACFo5BWB7kKGBd+mdhhMYAQ0GI9UtqdNolf40ROSJNZKbAVLnm1HIH4DJoER2jObKLICf+4bq97wOwHIGuyd9MkkoFodYZcW2K06LpZMKwPZKRp4++OVL3h4y3b9A776Wa6e4lWXEb3b/wYatjuCVTidcJOToKdnqF1M3nr9xzYlSyi+xHXRMDk5LhHAbAZw+uCyE38Lmrql4MLeg5Axmr9Y9Z9Sw3LI6oXppRDGNdwcqiJ5EbexnwQzM2EcTHV0rcuVkWnvGXAh21vhxhNBzz0Yr1pwzOqZU0MEu5S5SuItdPXdfHKm/T1OYp9P1LXJaSHwlyFChEMGH9C27awRtgUYcE8j+FiMnO96VYEekYU6ssf7Vf4EdUTo8sJ7NC8Q10v9sNvjZbtQDADgX8eAmpatKOXOajy8JnkTqzlRJeuAYQq4zPtoJ2LEs1C8z+na81FJhaH80IA0djnpbqObih36Si2Squ8r86OTjqu6H7Q3mJisCkD/4mRUH2ZjLCgHzTaaTm3Ninp8E2+NZm0QnvwuwhUuyzjcOG6IQF6XO+AUzSr/wq03DP5IBaBIrJ1ysw9FwzgFadLztTUP4UERkCj07tfwuRjf0iLBKBVnbFcxCXvUiXCllBK//IdZ6/Us+Y3/6a9JLkfOQFeXOpRSBBbyGXo3AJCDdLAmBq0m1CW/8/57ZYLLYJjCqPtppjLzwZWmWnY2i0YAkXAhOLex+IQEGWAlwt/JWTtUYnv1PMyKe6esNqjVQb6fU9eQCACb/FgEgO3dI2PVer1q3xi0/8mhXQl5A1Uyz3n6TmioHOEwpBICYI8JijMf8h6Aqk6IPg54OF2PCKvXzu2vo7RiEPG7JpfGT3D1SRNGvbjW6ja/3UuhXYN2K7zG3Pc/hUYQSPOEVZLKXhwOFR+9LK5d5V2OUZTpEEakNb0o/qaKX9kwhmA0nzl7Xn+sOrp1JHIawqTKp3vmHz1CiP2So6NS1FYCJLfHAcfhwR523uCLHMyljrSzqajdOGYl3DKAS5898w7XP/2eqTIW6B2oHhSUDRHrG/IFcHQcrZTkqNXHlLTlRSXeX8ooHGZZ37sqqywgk6RUeHHeZwixCUJzD2w2T1WoCel4r2N3Lj7KwATqerGKaCXJ5HPCc3WncrXSnF7Ug+mfCt7/cDuNl8Uku0eA+mMtkOwuSZNVt4h7HZdGAvb4I3fHWQYo+/ZsRzDNucYUoV2P98AbOdfU+sA4Ob1M+jTFSHwYsGdO0turyNLeEbddZMJNaxBk3QRL5ugW6ll0zJFDyckL2vYNQizRrokzibT1da/V0HT5Z9bDZpxbpcd0y/u9Rb25V7gQ93QQXeephY09Lwx5Vxjs1iHDXUaPMVnDBmcKMguLMDRbolgaQzlBKXTBqT7k4rFmJNHAnoTA+BbqkWZTuK0Re1bvBQeczCtF5WskaawUtSZtrvCrKfkG80m3SdgeAz8Ff+Q4ZimxUV+3LpzCdGUzlYYdYASDveEUwqdAZ5cDtntiVwExyCgHavCXK/JMMDIxl9neMxG/T3OBj6KDeNgP3jWHadrTcy69k4Q0hQMsL8ypLYuXsJd6jeJSPRkOv8VcrFPgFvsJd75M7O10wbwATv0WVeXqv6GPAdFxintp2oGD4iJA095mFwNgR5qMFV5Q9zmYm661ySqQAMacQOXC3uQP5MyB31LkP1b2S5ItlBFJPFzTzBbn2RV8BEQZTaYbUL1BHes79xGGPXAsxnRndOa5ySWSFCN1hEv5eNMYcxOJRNXaeBgQgKKmMnGL+jFvdv7z/Q4Z1zv8VCo/iFVweSaO5ahY0QreyioGaUZPHB5TjsHdOiS6FmKZLEAyj/N4JikR/9xAMMPr+hUp4G4+WR7wLIPkAMjarrpxBDb16jBBG/sryAu/VHSt8+FmCyingpCFC5Ldk8KVjcsWGW96/iB2zveMgnUfavB95PsxHlI/xrXCXdhj1aJkSTX53C7noWvbdKKEVLztQmNgJcLqGbRJ0x5teynPDIjPb5LEZxD02G6/6ibHz6H/cHO3X5/szMtXAcJlYptE+FV05vPJ+K456765xp0rR+/dGeFduxGiAy0jQY5Shij8CWp4JiE7bxipfF0ojW4cbFV/uR3CdPelePBWUq6ooymFDzDdef9JfpCaLZng0IfmrF4cp/AX5w95IYC7Lbn1NQ3DTy1CmtdkGtoKXYThqgUIYPEUUWQYdbELenJXRmOZdKa3mrYsmgJb39n3PXmM1o57ArCC74IVATXRS/NTWgMu7gG6Vw4adUshnOWq6i08AwTBFb7OggaW5FBIFMYpWSDHI0TODjlwIdqHQJrj4IyIv9G7sHzEfi7LycQXDfQtESG0ZN8Fnk9XuErh8zNri+CaOoJ3/bMzJtdS4Ccfen2k4RnaWgfODKVo7Tcjjf5lY8uVGJB8ghY1WddjLpm4aQjEnYJ0CVdCzVq3/KzJN7elt/kmuaccPKDZuRbUniSd5CGfKuBzr9WU6D1Yu7mvUKOe+kl3b0MMq6n+rx3kw4Imh4XHc5PUbl01gO7HKsXm2UZ2VxFP3K1QBP2VJ2aD3iIwk0fCYQr6Ei2Dt/uRhjQM/q7T+lkaWCO9mf3aJhPvE4uOSwQqIhGR55O1fpk0NCmV1GhBigZzLMD/dZesQL65UBSwAQ1OoMidN5bjbPH79kXDmorTiXw3+agqMv8Z+TSY3Gxm7dmHAjWyshVgNoWhQX1UU5KCedTIT9kpkisJZML3K0w9zm4YHcY5If33fnCK9xBjhSso6vBgCenRVnFwsRCnKSp8X7bylfCe/I0DzqvweqTUGXBqE+tEYbnwgFSc9wb+YIMWto0PxRksEnL1yHFPB4N2cSZhPA6krRNNeOFtAApaqtaw+pfvdRuB00/DfFf2JNLckpjTIdHuGc2p/XOg8nE2A+miZt8PZ+vj5Hg97OheupDfT0dibc4kdDfYVZClJrnn1iFRyGVsfv6LM6eDxiKeLIENhldNHFkf+Ti55pC2u6kyd5JSwZRmV1awCYo4F9dLyQrWzCwEKncWvOiPep1hW10Sz195pA3dFTXfH9zg4Om5XHhPM3jONVY8kX+PHWXa3vzBSLsrv0ewJK4w8olYoVLAkBtSn2q4dlt61ZkAmNZiM4S+pzbiSoy2o48ON1ZZMfa1wiYanKIfJPvCnJmqROs1PI0BMvKRf1Qu7+x+aM42fVZs0YpXmb4A18vwYwIW9f7C8DTyi6vc+hrQ30+3ZhyR2fclz1HNGFQH3IzG5La1bSa48VvEqX30xaSS/aao+VRxkbEy09WCGNfA3L23IyQJWGIj9NdvvzDLjTZ54t0vvmDVuAYTtlUxxM1gUPb6E/+QY0nlDumQqjd2RAtgYLnUNbd7tNWgmkqqaQkHm9qsphepybHMqM5jHPaQukQWQov1R9mrDoPUMF8WAKMFdITEX16ANblOx+E7MVXM217DgIvoxKe66a/GLwyBBCn5lDM6j1ccQFv9jUVBxl66R/mIvrCC8yxYfiuqlfKfkM3thF5MTDpaWGVPI8WUvKWSGKuWDIEa73OaYdYQhqlDBon67IibHpv8HMEifz1sxd4/KcgxVR1WXnmaS4vz6TZWLDR03PybLQBEtTvaJKyjZ6kNncj/a9/XxNTTfBYgnmGBjXx2PxM/xT+L5SkFQIU5bQozbWfX5uTAPPUkdd5FMysZzjorb3dohFw1STaIdRlgMN/lrfHri0V4Z+jytMcXg8tRytz3IT5aFtfjI/tN1qu8QDr9vFol+IYj491gusBLC25HOwvutgX1SNIw5fKXRMTmsXlYAAiBXt1UnVL53rmXiMawBvYwZOPl4KtONMAXPIIabcmWIFfi3GsnfpKP9KZShaSbrpVpEeFtXBXFhqNLkptUDP+IF0pOln33FhjRGDiAtQkPibEroWzgKtQcmPevmQJ6aYnKfJHrn9heUyvSBM507FT7i+j9UpDR0a+1pS/lX+JIALulAo7Xe1OWJ5/N/6Ksyj7mL2JLLFE4EGUPPOTW8KbwJKdTB0nvnB6/nyR5OQqyjWgx0Em+j25JWHkXVEfe3zpU24Xgp3lnjRzmTkzwQtQ55J0zsG0gjQr8eblVM/EW+Paslm1lxKCzBJzng4SOQdE6/lGqWRx3adxf0xXpYfcJAaF2RhtfAc+qltS3hvySM+mm4ou/S1ujz4Tp3z5IMgvQ+P0NyLr7+NW0J39p8X8AzK43HoNv2Tp++J3eMuOPyF3DJVhU71kzKc3aT8wYGYNPM/kcCJbZYQH+AeJLyKuwkIjHd+D3bUj2zA3/SsLeV5nhMym/xH4M4JRFbSWD3UkRcY1UF1QpHrXBkQnqHcTIOxCfhs2ukO/nwbdCU2qg6f9T6Bk66a1wsMbS/eXWPd2giDOXfIjqdP4cCSMJFLYF2vCsvzhkuGQqPaUm0ybqBiaEybgispFB5Epp+3IgD70OITvDqAnr5SBYlnrsNBIrEnjg0k1LKypUAjt7bdHlwrMu4YGaPZPdK4M7eL1Tl0O+xnxYeFWP4xA0c5xkcQwABwSQdRUhlMAl0oOhY06+GqC4pjbZyU37HdHrGEPAgEpoVZ7ub1aopq7X1zaxjn6cOU+CQTG/9hYFn8ZLinon9yfgLLoLIB4WSZidcKejOLBy7QOFlsxZAq6ASMqPOguQM7BGcG412uAkmZJCqHaF8jyYudSwg5r1W4bsadHFLy+dtLb49za4OgmovPNRA0BMEJmCCf040LuQA/9iR1ionVH+2Lztc/S+oNMtso6H95k3lnM4ZxgcQ6mseWbvjBzNBMYGAAdJPbtSay3UcPbMWPChMNcTc6tWmxv0x11xJoUQrBystea48SG63Uwcv0/QmW0ClYhYCTPupJDYwHSM+xxJgN9o02DE6ALTo1MTClD15WVq8soqDIMD9AqXTBdbjbBMxzZBgMR4PD9UqVSGKLtvADKaGW+lzXF+C1lRg8sOVENZGYQqM+KHthta+QV6fsinToXm+7xTdqjJfSR6G5R2Rls9yx1h1vyl3W3T3omCSU4KTMq7EhFIFoZ3cJ0ThbCXPqcM6xt33Y75VeSlWB0fEUfdKDuvrCBKaBArG3w+YLmLOWqlPUtbuyEpmEkEC0eweJ0h0wo9seN/7avzPramxbHRysjGuWs7Sq/JTLNlBIYaidzAVPoEr/5Y4qwtUPV8FMljss2paHqV12soCGOm85snElqJkvZiTMKeOooGu/sRu84T7G78RYbdRVgCXXthU6eLGvMDKspo+uAkCRXgxwW3b/kuqj9mJpyBmlzjP4Iptnp8F1HQRsVuyVYuLn45yUwQGcvvsRI9e8mP/fwEi7dbdfZQmyjQGTyYlzXX4DnnG0X673xRce8IxphzctP1ZRbASFVtFW1EtjLfn65p7Od9FVBDC5IJyewIVv0m9Qcdc+D+QMVebqOkNBZ6Zrym6q5EFAmqLQL3G61PczYELljpYNmGv2lnqLpxsQmaQ78zMPSp8PJJutgjmh9Kn3ATqPYBbJeAL4PNgixbqoPkStuEfSf+JFJPNqaGixeX1WtLhQRDOz/zM3GDLkrpZI1NZMlsVIQheukTdfcYo1kTV8Jg8gtieeA7cc3ZifUuzpSGAiyR/BLHxPskpKjmpaCewY5hTEMYIFvOnOofxBj4/fNFZo3iAI6GouQoMh+jwhHftDtkYPir1GMg7VhiWL0j8E/DinF9kAp8jvX48BSr3dOquALkha0td6bZU4Z2xryX2BCEq8WajtfkgY6rahFozXAcc+4q1T6n9xYDLpMizD6GmumQHYOQmbSvfRMppehtWoEOJjFXvm4hjbYi7bepzWHcZK5HqMpy9vxQlDDftoyZ3F8PtnowePVEnkmwUQdeu2AbtoqRH/QcMwmfwQ7pR0Af1CR1UYgbCqZDpJ+0L3EnFoJNG6LHb0D9fqoDG9cXLvOetG9pwJ5O+KyAnVSSnQtvXjkaG0RQgzpnYQYpj9+CNSSnaEllQdSiVOg2wEiAhc8ySzhpum73H0DHtwftttdZfwvBWrMPe0x2hAH/PjZZEjst08dH5qS5z6ZEUAkoJxJes+PQ1PGOOhbi1HRq45xP9CTsYQWAd/T9AEd4I9tn/JUh1PCgIfISaSuGfVoTDbDBQCFicToY5qExSJZxMqg8piBykhcxK0dELzvMaSHa+yZyfZIEm5K78BMYCMEdr4IT5KxJWv+B/pGldNUv6I8IxMHbPJS4LTQzfnBTLiYit6KJnitTwz0SOu1hnK4gHdCi/vWYrzwcij5eWHZsxTyA+IXoFmvQKJd0HnwMoOVWeeo8x8rzuF+dpB4ndRxUjSbtGBz/EsqPpG6DdfWT2/iaepr5ettvbGM3X5KFyR09Sqtbk5EbnT1eQT1e8EDcKy+QHpl/8/cLIZMMCzznrP+mtbN3HP1mdvJL2e9ZT4KrAWUVXFYRCCJ8KzXpBz4qXQtAmaivFAN515r6bmPF8uVc7kvmCfRiW+ca+acCO1WUApQCbydI2z4hTmEAAV3h3eucnd8wzdX1PAbr5g63LSeIBWxFt0fJL1092mhpOkV9ws/MgQolmpj4AKqhNXYz5n6ZnzlLzMLOi1/M1g9gf/OmlVLD8wq1UHwhzCyPgyVYic3xLY5ez2aOZlIT+NF5tG4y0GEWnpq4xMWT2VcJ3FN403pia2P3QMPeY8FufCzX+FUYOnIesAxF6mCD11KEAxB3olIqwUDfK8EOuaQLykKjdx58nW7+VR9A1JLwv678l8c7rhj2oH8vdGrjk6es8pn8TeuUzIDyDsNkb+PVsCKCF4+cHVLseA4+gXghfvyS0k8mcEcvBGtoe3Nhc2mouG/vZGvx35fDuJcPLS3EshRluOmVXLwPgmz+tw5os+qpnrpcQzKYEaHFFjUQuNQg6r4D0d54koJwPS10gC5daR1o4/Tl5inHDep086Y0xzGjKEMEHBCJFcHaciVqG3uXbHSZJLZzVfZqO5tGo0qDk4s+ZMSSBIhxjiRa32jRBWW+iy9EsWN3rWvLEan5aTsqiUArxCiz1HjRRGZlR3OcLPpSXwIkotPwaZAPIh4eoIwkPByNrVfX0kISpmJ9B9ztZF+0XDyyhZaomyoC9N+i/nU1pSMhxQJBlYex7NhhJEC+bkb/rEZo9NkRItqQdXnnTc/lbt6A816EKhzLv2HS9SJW7I5zeLUFn4zcu6TswL5QXMT7xZTTuLbgbsPa+3y/b0TE3A7Da+IY8nXiyJpVp/r/0lbiGMt4QGdZy7yIguYevQwImhGVy/OgDPvJYC0/zyNW0502v60TKfoQMxvtUOm33cYeX1DrHtiS3MGz1ydt3CxZruIUbLdJcOxDT9h1F3fgwfAPIVq0Os/AqYrPAjA/MF+rwIsIGbTX+qTgePusgjhSGE1xS1V1fMc4yXmnfKBtkYDEpwGww2kHsHsImqFkZb3lLDg9QOe3FxqXAYK3GRq99s9OYCFfQMbuV9fkH8IlwF8Vg9tuIBpR3GQBpXQmh18gGPCupJKCerJm2hz+21uYP8YxmI4IK1q6neNwf244ST6lGR14kvM9k5ZrBNd58FnrC9JLH33mKatgFmhSNQ8balt2qIcEJy4RNrpDIP95BmAp8V3ZriSISOkpbHbsAOWrwejiMyo7D8uHUAWqftn0Davha8n8jS2qhdOqRAScFvRI8CWo8LZo/xatkAwOTX9BtsgFZzhxyskaByJxnuCHiWCRUdIttThM3QgzXNu7VJ9o5bjvvSYN7Zu5R4CoC2GdfRZMhO7MBqkfUWnm9wwhgbTWxgroMnpJ7+jsrD/axYlkIiLPzHnKkvoh6ZdZrHl3SRTft3mu6GBU0ClrXy1lxGk+YQJSg5k2PMYZOEA5kObETyRDNryJDfzDngwesUD5UM3IPKoWHyUy12lvYbd9R2IG1+G0LiV2uu+iEJ+a0PfGAAGFF+xeiapKF7jga+5wigPV10yRGW+KzXqDvF/bRBcFdbARZpm2Jp/DFXCHR5Gg/nFBQyJPHBdb+Ak9NXDS+0dhar33bTlEOVI5apXcTQguaCLSY3N0pFNH3ELMsYdu9v5cNOFW8qCpUtPkb7d2R6rLMuvZ7THpuYHdoMlpACUK8V8NvXtTvA5+VM0Ewgtdzp9cHhBzDIwCebn5jzZ/Pla9rWSxEGMCu6vSvud+027QfMISeXMoM1Z7nXD9pfMrDQ/7E0IyBX0Q41TvPjYoLTSdJGAXlP9lb+3e9pV0iCy49q/d8GJsow7XaHgKpXApleYt9pK4WvdyYIpjm7nKgNBe9VZg+Cwfd8zT5WorZKv7FYyalxAVOjMJaEf4IrxJ/przG954ukk4LwAUFYBFU7ilnYWR0KXgB6DW9ZCV4ZWEjb2rFD3LPBe2eeX12aivCTW2sGE+44XZSa6Vpo36uWTJFVP0lM7AM8ePlvdtoN54mJl/UsDhMTCU9Z0sn8AXe3gCvyIjK/ycY7qifYpo/msVMPk8tYa84ci2KyEOuqoisH3d8nXbAAwftA/BPCUC7OAFwrdjgckm6MLZ3JOuDtASauzTjGtzbtDtdqrQFf3ABmI5Gn3iGXDpTJWQmAYA2kgRsudnAl0i349PjtDP5FrQiJFDUDECINrokx+2z8PYmTCcAMeeKwYhU13yh6oJW3Q4AIra7uKH2mxp79eOH4wWMkyc7sBQV7R00FBqQRfssuvDKCMAiPPTnDGdGtlPFuilytmgzs4nhKTmZWodbyuMDCHlSGKYWtjC7XuKar5yn+lae26ViJNBFtTd5egU17uFEwgV0mfcms5vUmZicjRH09DNLuPr658OrzfN7iBs6jqEjxipqg29KAt5wOWH1naEoM7i1ATXddpuB02XpcP7go4Pix2VZVc6g92Oakjw4io059cZaKFztrVRO8yyDFxMHexfg4UxHAoskAM+MZOwCMV6Itp62Oyz3yafjet+wmhBziwWQfJ0oOElMhsmdqVElVr1S8PZEip06jIhycs7xlNr9flU6FOl8+wLy2rRDBt8/7TYsJNV46WwIQxLgVrfsZy2oIWEhva3Qd1R424cwg79rqkhRWGfBDhM303vOs3QsRySD2Vd9xTDdjbIK5TabvJcDpiI+qzzN2cHRAUBmaAONW+74SLD+FckfBjUU1PYTBvUHgIoEbfeR8cs9AxGWeCj6+x3aHbCse6gFFSFAo9v0/kPi/mhrJcmkic/m2xStqri4p9RB9JbouLwzJccOWBZCJkGi11nrGSBgq2Rsyib6DuJpSK5Vvw1TuNDdU/7zcxM1fF1fJoXMfGiZ5B1rpWpiKZeKhjhuiY7F+isE21mdRZdXWzXRKc/pbxF+c/hseNmdYO7b3Jl3ykhaZu0gveODPSghg3+OozXxrDKFDC4y+k/2PRk9cn9LdCTCOC7Ita1erzK9L0gMEYHEhXEM0knxZnpG10xA0rtgQYhy5woec6HgtUbHESQiZVp4hJsPXtqtfc1FUhckhBWwbdUPIh553CZzyZ4YEtq6m8Vt2qN/JuKWMqSXZwQhkoyYfN1Ue7FFMVn9j4pm7S+ODXDwDjuqp0997iOkptAMtJZKrBX5OJp71lh3enjISUDGDbSyMW6dIiqP7fuxiZXGu5eOENF+N66C8UGKBaD1f4rTA6odSsfOSkzMEynC87JLY+lP1uX+BsXVODZbL4sLdOTE4PRsRufbbpqGHssx8gYdpTDv5r3ISSGaPRGnN6dApgfZFseDXecu2G0xi57+qUocOApeDWMlrs8nyqcuSn8zCzWSCdWx1adrt/gSEgVGRoQuqULjM2kyobPpLwD22KAkXKYb28a6iuCsA3Gxi70CAn4COnxno/mlTLtnsGh5oPpCBzfh+5PIQK/O0RRr/V1nJpauX2I9EVU9y+zJoXvXapfrNWCbn+4ZFUWUHehZo0aynA5Cs4pvDWswe142PgzlSu2B50iVKMSmBxArzta2gtYpVKzS2Eyk9Mnzogutnj2wnPd1uQOIAmbOp4a+x8j57LAmXG0trTJazeVUiT2QjcS/VeYUyiE53kV31Ho4ATvThTCvyCedYgkqcQn4ciOEP6fJRvsNOSRIxy5LE5vL3ElmypeuJ1dl26pTzDFd2xG0CFWo58MAn4eXwosX26VnvXeSavK9MM9YbIoho/YlEtahGxoijLY3LsS6r82j2Jsxm7CztrCr4HFTKqvFzSRKLQVOpxej6RYXK+g/YG2OIjpKramuH3wF5+kR271a/bFDYrjH5ugVClPEJN/JXxVHj/PycqVYkrrwLCIS9TgnzWuoeZwwd1E5ZyUflOiABUzC915kiuGwBBVL4tEEnB+EDStanBG+uTGJmV/kJn1vVDuXonGngL+mKjdq7C4BVu94iLUHsYQkxFqxCejNA2Fn0W0i09OcCWMvdnEFyqHRwnNKHWRkeANhAGbWr3XcME1GjtLqFIWNze1h4aK704dZmftdqam4u2TLgpGBrGbH49zVIZVp3cnKIw/H1bhr4IMhCaE2tgCeMbTog1L4ezKiDDcPjaVw8cfGiYYzq61ni4/OiP3+g16+2z3SD0iU44bcIvXTaOFaDYLj8kW1UPcCapG/Os3/b/1g9hmt82SNzphJdOn37816EnxDnqIj/QD4jLS5kz8j6AJbNhYZ6EonkCLCXhcI+l0G+qHdsHfApaE0XzzRLJEvudZzqgDPNLk6SnXiA6zDta8rBCpDUVSTuq7goCQPrtnoZLUAoqmbzR1/VlriJA+9OIRtNmz66izpu4FgbrhIMmb2G2T0PFGICgrK14BN4NqGCztr/l3WSojzsrar7LPs73I03hHOMdEzff2j8eu4eic5ybnMlCMRQ/ZBbCNIYACoGdCIkpa4oWpWb3Lgi92sNx4BPbf/Qbt6g6VtOiuuFzbyxDT9mp4ZiHJe7VTleX2ZqSNZFpkWdr/QuqTGZQBuYcAAnkVVI99FxkI12+1ikfyFX3ZSc68W7e2DY7jlbZLTvoTutMd5iK3ZqN0E3INfY8da140bQTaP395Vm6hDTd0ZcsNjmWdlYlNtzYc7Z+f2MvCkGTtupteACih8JVuG3Z/5y/ed4swgvyxX+wR7f0qqGkvf0/8mKFLUch3wakxDtUUGtPNxaOQGdeDih8WpTjbjCu/aPKbeAX3LceW/3Wx6MKmgs3aaOpj/+9Shd6QErTehKi6Ni3wIdjAAdIf2wNGv9d0k4mRXoP7sEJI53vMu/J6qAthD+xt7Cn5yKTHxRw/CkRlWjV5VoIKXIuychGSOQQdJH1dKjTURR8X6E9L9WidUdLVVQB1brQY8JvqNaLr7LasQHijRbDMT3rwoDAEGUmFyY7BZrxSsNvVS8ed4w+ADLJUqrqO9W1wR4YkaJSbrxPmo5KEi2OX4yFOwJ1jRJbW8AyS4dXrUAJ9OPiRPUhYUVU1LkTJCG9ylZ7YTWLlqwjWcbk1NV+RkMCoIF7iVXAapLzGbR6vY7aC9zuM3PNjRjHyc55W76gCo3SXcIxtYE/9eTu58EkJtGmqnGjmzI+10dATfo+k7A4c3Noc/DkvGe2jJNK3rOAVkrI1FtZ44A7K5aFjVPKBRbBtxYnpzSbMoKBrYO2A4q2zbjpME8JKnM9uG2D1VUK+PwQos3nh9dE2/H61Otv0T+QdN9dbvHt3cxPJRyIG+torPCj0XBhgAawKQbBj9BwDxAtwjBphLmd0GIp64UYZQdkvUTCO+n5rcLaMvNElpzjOn0wCSujfOfWjCrHysFrqEptcO4ztl4CgiYiMD+Jdfykwj44SmUkj/ZaODt8BqOf9uTgZbgR7ttlxYIJe/VGonl+QZb7EUc7JHA7nD0VYzqjZ2sSjJZocdlDtjfXi8T12Gi/heJaxuc26MoJ27v1z3EGGEMFkJP1zNnRAu7YrMPkkgTQXw3MmZLLkjq3v7TosG965KTMSx0iC7+AFPJuAY2LBWvnJKQo1q6Kb5ERKO63jnhKakTtYLNnCEcjQq6qabf2eX3m3dtfGBky4poExGiaZnWj3V2rO17/emGIUgx/qMXuHNVqoxuKtXcO9KsxDJD3HQ4XPeIcJD3ELLba/fLLmbDiYJze6NMhC1684hiw/m7yMxx3TENZvXo7Ugw9wA7G0dnLixsvVKXPmKwSKYvAjtG39UkW+eV8eVppKrDL0sywfhVCVFa4z36QzuckpAM+FZYGiBTIAMmTWMH1QK9l6KwkXR9NJthh3n+9N46MfKtJ5FnCj1fnCvO1F5aRQLpgvQddLR/uLC5UNf0i2PGnCp7lrxy6Rxe/I/MviU2VzGStg+Yap+QJgXmwcoTUr5JXs/vvhd1+FDrn4ZqMC4QC6MuTPTuSul8KMTlRYuGI1sRb8+TPASPA5sAxmTSTg4nK2pqkZotHVnAmIszc1HmnrrQ40VUDn7ZpbKHZY44Nuv0F604Gen5w1uKrw2jyX6hrjsV7yLL6j2fpuagcK18/PlRxougBAyzdozfDwCHcJykcD5E6UB1U3UWhm/DCt/I6g56UI7EVWe6YdbakBzOI7xm2BlapBMx8VmIs4X6+LLG7uy6FXiCADEnFdeZSrRKhQxc4xOuerDXw9j4lxbhsG1jk0IubGRxowXJfmsASoP+2f8RVFxyJbDnlXHdW9lPcIOkzT+UTKlgVj8dSvdUu8mtgVIGh899En7JM55pQNpAJOCvBX9Fv0gP11Z1HmELy/I/79DwnyWjyL0kr3GEDuGqFJ9tO8qv4AX4P7sMPuYBDKUUh5kTYZMpimhUZ2UdkhxOe/hkRJI3dujyGmbjgZ82Pc89bcgx6V/pXtvDc5DTTSOeTpLdhk+P5Uet9G3CglNWAO4SGDI+PHjaL04DjUOkUYlPCSvegCINO2Hj3avHCsqZJVKZ4kHIPPPqDO2Kuh1WqjUvBd22v0IS/T7YBJfS1jpqGs2ahQe8rjf5tQz46v0WZVj/g1Kq4xf6cLyusiSUhaHWkOMf7stwsCP4FLLlQitu7zaZWg3jAzfhf5AwoCBTl62mDyceyA0nYW9joQBJK+Og9XqLnY1iJ2Qt/8dXIocVc1McMtA4n8a/ZgeVMv+uXV/uGfRSDMnynthc1XTbuEESRyWl9QyHO4x6YY9Qchb8b5jURWLpXhzPTwjKWVQiPmBoYnp/jPh9MD5ISDy3MFLbvXS3Q1MjtCPY1Ga8l7+yCSzWXfeBxkFvOfX14IqIGnq+Q/1PIEVlVZPTZ1VDSeFqmbih4jgE2SFbMh+WQcRJTQkANlgdpHnPqDhDpQ7nROZgoWQU7VXf8IjrPX+UlJ2qMlPIt0ZMY4Ekmwk5NmjiYX1unpBrv9RJpzNCQAtH5AFgUxZ0sEzMIhWUfOAzVlxsIB0vvkErMxtxmVWWmjK0KquOCUL5gUj8KfipDhxwV4Kzu5Qd8oVdlxILZIH3qgHJt8JnpDOr18stAh5gfIZktsV481Tu5s60GzwRErCR4b0xsUgQ+AKs3P8QZAbaD88l68xx24Nj6fO0aAF/V+ZLGKjSyG3Q8ETAyzix4BStKhSYUh7Q6HdOllxiz9WromxR0tYOMdhY37l9j9r5ssDJoW8xe1T/hKjYmqIl0Esn7oy/KKyyUmL4EIhowgk21pMEQvJ/AjJrbda4UugABzrj7D6o+pFBwzEtifpDGCJRZlX3Mx4ppvvtbhz+imGBf2/k6aiP3Sn/zlvJPvodwta4cPNLSRP57/bZKFsdTMhjT3UURcc63Zerh+VnyAiFKJWnpBE50UNqTIIh+R9dnP/kfuXkoo0WFYryZXA==\",profile=\"router-server\"},},}",
  ["ceetos/lib/release_verify.lua"] = "local password=require(\"ceetos.lib.password\")local roots=require(\"ceetos.lib.release_keys\")local profile=require(\"ceetos.lib.profile\")local M={}M.CACHE_ROOT=\"/ceetos-updates\"M.CACHE_FILE=\"/ceetos-updates/release.lua\"M.META_FILE=\"/ceetos-updates/cache.lua\"M.PART_FILE=\"/ceetos-updates/release.part\"M.PENDING_FILE=\"/ceetos-updates/pending.lua\"M.MAX_PACKAGE_BYTES=1024*1024 M.MAX_MANIFEST_BYTES=48*1024 M.CHUNK_BYTES=3072 M.KEY_PARTS=256 local alphabet=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"local decodeMap={}for i=1,#alphabet do decodeMap[alphabet:sub(i,i)]=i-1 end local function read(path)if not fs.exists(path)or fs.isDir(path)then return nil end local handle=fs.open(path,\"r\")if not handle then return nil end local value=handle.readAll();handle.close()return value end local function write(path,value)local parent=fs.getDir(path)if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary=path..\".tmp\"if fs.exists(temporary)then fs.delete(temporary)end local handle=assert(fs.open(temporary,\"w\"),\"could not create temporary release state\")handle.write(value);handle.close()if fs.exists(path)then fs.delete(path)end fs.move(temporary,path)end local function encode(value)local out,index={},1 while index<=#value do local a,b,c=value:byte(index,index+2)local n=(a or 0)*65536+(b or 0)*256+(c or 0)out[#out+1]=alphabet:sub(math.floor(n/262144)%64+1,math.floor(n/262144)%64+1)out[#out+1]=alphabet:sub(math.floor(n/4096)%64+1,math.floor(n/4096)%64+1)out[#out+1]=b and alphabet:sub(math.floor(n/64)%64+1,math.floor(n/64)%64+1)or\"=\"out[#out+1]=c and alphabet:sub(n%64+1,n%64+1)or\"=\"index=index+3 end return table.concat(out)end local function decode(value)if type(value)~=\"string\"or#value%4~=0 or#value>M.MAX_MANIFEST_BYTES*2 then return nil,\"invalid base64\"end local out={}for index=1,#value,4 do local a,b,c,d=value:sub(index,index),value:sub(index+1,index+1),value:sub(index+2,index+2),value:sub(index+3,index+3)if not decodeMap[a]or not decodeMap[b]or(c~=\"=\"and not decodeMap[c])or(d~=\"=\"and not decodeMap[d])then return nil,\"invalid base64\"end if(c==\"=\"and d~=\"=\")or((c==\"=\"or d==\"=\")and index+3~=#value)then return nil,\"invalid base64 padding\"end local n=decodeMap[a]*262144+decodeMap[b]*4096+(decodeMap[c]or 0)*64+(decodeMap[d]or 0)out[#out+1]=string.char(math.floor(n/65536)%256)if c~=\"=\"then out[#out+1]=string.char(math.floor(n/256)%256)end if d~=\"=\"then out[#out+1]=string.char(n%256)end end return table.concat(out)end local function unhex(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function semver(value)if type(value)~=\"string\"then return nil end local major,minor,patch=value:match(\"^(%d+)%.(%d+)%.(%d+)$\")if not major then return nil end return tonumber(major),tonumber(minor),tonumber(patch)end function M.compareVersions(left,right)local a,b,c=semver(left);local x,y,z=semver(right)if not a or not x then return nil,\"invalid semantic version\"end if a~=x then return a<x and-1 or 1 end if b~=y then return b<y and-1 or 1 end if c~=z then return c<z and-1 or 1 end return 0 end local function canonical(manifest)if manifest._legacyProfile==true then return table.concat({\"ceetos-release-v1\",tostring(manifest.channel),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end return table.concat({\"ceetos-release-v2\",tostring(manifest.channel),tostring(manifest.profile),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end local function unpackKey(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*2*32 then return nil,err or\"invalid public key\"end local parts={}for index=1,M.KEY_PARTS*2 do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end function M.validPublicKey(value)return unpackKey(value)end local function lookupKey(keyId)local saved=M.trustedKeys()local value=saved[keyId]if value then return unpackKey(value)end value=roots.roots and roots.roots[keyId]if type(value)==\"table\"and type(value.public)==\"string\"then value=value.public end return unpackKey(value)end local function bitAt(digest,index)local byte=digest:byte(math.floor((index-1)/8)+1)return bit32.band(bit32.rshift(byte,7-((index-1)%8)),1)end local function decodeSignature(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*32 then return nil,err or\"invalid signature\"end local parts={}for index=1,M.KEY_PARTS do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end local function verifySignature(manifest,signature)if roots.algorithm~=\"lamport-sha256-v1\"then return false,\"unsupported release signing algorithm\"end local public,publicErr=lookupKey(manifest.key_id)local parts,signatureErr=decodeSignature(signature)if not public or not parts then local prefix=not public and\"invalid release public key: \"or\"invalid release signature: \"return false,prefix..tostring(publicErr or signatureErr or\"unknown release key\")end local digest=unhex(password.sha256(canonical(manifest))or\"\")if not digest then return false,\"could not hash release manifest\"end for index=1,M.KEY_PARTS do local expected=public[(index-1)*2+bitAt(digest,index)+1]local candidate=unhex(password.sha256(parts[index])or\"\")if not candidate or not password.constantTimeEqual(candidate,expected)then return false,\"invalid release signature\"end end return true end local function validateManifest(manifest)if type(manifest)~=\"table\"or manifest.channel~=\"release\"then return nil,\"only signed release packages are accepted\"end if manifest.profile==nil then manifest.profile,manifest._legacyProfile=\"desktop\",true end if type(manifest.profile)~=\"string\"or not profile.IDS[manifest.profile]then return nil,\"invalid release profile\"end if not semver(manifest.version)or type(manifest.size)~=\"number\"or manifest.size<1 or manifest.size>M.MAX_PACKAGE_BYTES then return nil,\"invalid release manifest size or version\"end if type(manifest.digest)~=\"string\"or#manifest.digest~=64 or manifest.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if type(manifest.key_id)~=\"string\"or#manifest.key_id<1 or#manifest.key_id>64 then return nil,\"invalid release key id\"end if type(manifest.next_key_id)~=\"string\"or#manifest.next_key_id<1 or#manifest.next_key_id>64 then return nil,\"invalid next release key id\"end local nextKey=unpackKey(manifest.next_public)if not nextKey then return nil,\"invalid successor release key\"end return manifest end function M.parse(source)if type(source)~=\"string\"or#source>M.MAX_PACKAGE_BYTES then return nil,\"release package is too large\"end local encodedManifest,encodedSignature=source:match(\"^%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")if not encodedManifest then encodedManifest,encodedSignature=source:match(\"^%-%- CeetOS signed release%. Generated; do not edit%.[\\r\\n]+%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")end local first=source:find(\"%-%- CEETOS_RELEASE_PAYLOAD_BEGIN[\\r\\n]+\")if not encodedManifest or not encodedSignature or not first then return nil,\"not a signed CeetOS release package\"end local decoded,decodeErr=decode(encodedManifest)if not decoded then return nil,\"invalid release manifest encoding: \"..tostring(decodeErr)end local loader=load(\"return \"..decoded,\"=release-manifest\",\"t\",{})if not loader then return nil,\"invalid release manifest\"end local ok,manifest=pcall(loader)if not ok then return nil,\"invalid release manifest\"end local valid,manifestErr=validateManifest(manifest)if not valid then return nil,manifestErr end local start=source:find(\"\\n\",first)+1 local finish=start+valid.size-1 local payload=source:sub(start,finish)local suffix=source:sub(finish+1)if suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\\n\"and suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\\r\\n\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\"then return nil,\"release payload boundary mismatch\"end if#payload~=valid.size or not password.constantTimeEqual(password.sha256(payload)or\"\",valid.digest)then return nil,\"release payload digest mismatch\"end local signed,signatureErr=verifySignature(valid,encodedSignature)if not signed then return nil,signatureErr end return{manifest=valid,signature=encodedSignature,payload=payload,source=source}end function M.trustedKeys()local raw=read(M.CACHE_ROOT..\"/trusted-keys.lua\")if not raw then return{}end local loader=load(raw,\"=trusted-release-keys\",\"t\",{})if not loader then return{}end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or{}end local function saveKeys(value)local encoded=textutils.serialise(value,{compact=true})write(M.CACHE_ROOT..\"/trusted-keys.lua\",\"return \"..encoded)end function M.metadata()local raw=read(M.META_FILE)if not raw then return nil end local loader=load(raw,\"=release-cache\",\"t\",{})if not loader then return nil end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or nil end function M.cache(source,provider)local package,err=M.parse(source)if not package then return nil,err end if fs.exists(M.CACHE_ROOT)and fs.isDir(M.CACHE_ROOT)then if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end elseif not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end write(M.CACHE_FILE,package.source)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))local keys=M.trustedKeys();keys[package.manifest.next_key_id]=package.manifest.next_public;saveKeys(keys)return metadata end function M.promotePart(path,provider)if type(path)~=\"string\"or path~=M.PART_FILE then return nil,\"invalid release staging path\"end local source=read(path)local package,err=M.parse(source)if not package then return nil,err end if not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end fs.move(M.PART_FILE,M.CACHE_FILE)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))M.adopt(package)return metadata end function M.adopt(package)if type(package)~=\"table\"or type(package.manifest)~=\"table\"then return false,\"invalid verified package\"end local keys=M.trustedKeys()keys[package.manifest.next_key_id]=package.manifest.next_public saveKeys(keys)return true end function M.cachedPackage()local source,metadata=read(M.CACHE_FILE),M.metadata()if not source then return nil end local package,err=M.parse(source)if not package then return nil,err end if not metadata then metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=\"local installer\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))end M.adopt(package)return package,metadata end function M.clear()if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end if fs.exists(M.META_FILE)then fs.delete(M.META_FILE)end return true end function M.encode(value)return encode(value)end function M.decode(value)return decode(value)end function M.canonical(manifest)return canonical(manifest)end return M",
  ["ceetos/lib/updater.lua"] = "local store=require(\"ceetos.lib.store\")local release=require(\"ceetos.lib.release_verify\")local version=require(\"ceetos.lib.version\")local net=require(\"ceetos.lib.net\")local profile=require(\"ceetos.lib.profile\")local M={}local STATE_PATH=\"/ceetos/data/update-status.lua\"local OFFER_LIMIT,HISTORY_LIMIT=20,16 local BEACON_INTERVAL,REQUEST_TIMEOUT,REQUEST_LIMIT=30000,3500,3 local MAX_OFFER_AGE=5*60*1000 local CLOUD_RELEASE_ORIGIN=\"https://releases.ceet.uk\"local CLOUD_MANIFEST_URL=CLOUD_RELEASE_ORIGIN..\"/manifest.json\"local CLOUD_SOURCE_ID=\"cloud.releases.ceet.uk\"local state=nil local lastBeacon,lastCacheRead=0,0 local cached=nil local function now()return os.epoch(\"utc\")end local function localId()return tostring(os.getComputerID())end local function localLabel()return os.getComputerLabel()or(\"Computer \"..localId())end local function defaults()return{schema=1,offers={},history={},revision=0,status=\"idle\",message=nil,transfer=nil,cache=nil}end local function loadState()if state then return state end state=store.read(STATE_PATH,defaults())for key,value in pairs(defaults())do if state[key]==nil then state[key]=value end end state.offers=type(state.offers)==\"table\"and state.offers or{}state.history=type(state.history)==\"table\"and state.history or{}return state end local function save()local value=loadState()value.revision=(tonumber(value.revision)or 0)+1 store.write(STATE_PATH,value)end local function record(kind,fields)local value=loadState()local row={at=now(),kind=tostring(kind):sub(1,48)}for key,item in pairs(fields or{})do if key~=\"data\"and key~=\"source\"and key~=\"signature\"then row[key]=item end end value.history[#value.history+1]=row while#value.history>HISTORY_LIMIT do table.remove(value.history,1)end end local function setStatus(status,message)local value=loadState()value.status,value.message=status,message and tostring(message):sub(1,180)or nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=96 end local function releaseFilename(profileId,releaseVersion)if profileId==\"desktop\"then return\"desktop/ceetos-release\"..releaseVersion..\".lua\"end return profileId..\"/ceetos-\"..profileId..\"-release\"..releaseVersion..\".lua\"end local function readHttp(url,limit)if not http or type(http.get)~=\"function\"then return nil,\"HTTP is unavailable; enable it to check releases.ceet.uk\"end local ok,response,requestErr=pcall(http.get,url,{[\"Accept\"]=\"application/json\"})if not ok or not response then return nil,tostring(requestErr or\"release server request failed\")end local chunks,total={},0 while true do local part=response.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then pcall(response.close);return nil,\"release server response is too large\"end chunks[#chunks+1]=part end pcall(response.close)return table.concat(chunks)end local function validOffer(body)if type(body)~=\"table\"or type(body.version)~=\"string\"or type(body.size)~=\"number\"or type(body.digest)~=\"string\"or type(body.keyId)~=\"string\"or type(body.profile)~=\"string\"then return nil,\"malformed release offer\"end if body.profile~=profile.id()then return nil,\"release profile does not match this installation\"end local compare=release.compareVersions(body.version,version.string)if compare==nil then return nil,\"invalid release version\"end if body.size<1 or body.size>release.MAX_PACKAGE_BYTES then return nil,\"invalid release size\"end if#body.digest~=64 or body.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if#body.keyId<1 or#body.keyId>64 then return nil,\"invalid release key ID\"end local filename=body.filename if filename~=nil and filename~=releaseFilename(body.profile,body.version)then return nil,\"invalid release filename\"end return{profile=body.profile,version=body.version,size=math.floor(body.size),digest=body.digest:lower(),keyId=body.keyId,filename=filename,fingerprint=body.digest:sub(1,16),newer=compare>0}end local function refreshCached()local timestamp=now()if cached and timestamp-lastCacheRead<5000 then return cached end lastCacheRead=timestamp local value=loadState()local previous=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil local package,metadata=release.cachedPackage()if package and package.manifest.profile==profile.id()then cached={package=package,metadata=metadata,offer={version=package.manifest.version,size=#package.source,digest=package.manifest.digest,profile=package.manifest.profile,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),}}value.cache={profile=package.manifest.profile,version=package.manifest.version,size=#package.source,digest=package.manifest.digest,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),source=metadata and metadata.source or\"local\",verifiedAt=timestamp}else cached=nil value.cache=nil end local current=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil if current~=previous then save()end return cached end local function providerOffer()local available=refreshCached()if not available then return nil end return{version=available.offer.version,size=available.offer.size,digest=available.offer.digest,profile=available.offer.profile,keyId=available.offer.keyId,label=localLabel(),id=localId(),}end local function upsertOffer(source,body,transport,distance)source=tostring(source)if source==localId()then return false,\"ignored own release offer\"end local offer,err=validOffer(body)if not offer then return false,err end if not offer.newer then return false,\"offered release is not newer\"end local value=loadState()local key=source..\":\"..offer.version..\":\"..offer.digest:sub(1,16)value.offers[key]={id=source,label=tostring(body.label or(\"Computer \"..source)):sub(1,96),version=offer.version,profile=offer.profile,size=offer.size,digest=offer.digest,fingerprint=offer.fingerprint,keyId=offer.keyId,filename=offer.filename,transport=transport,distance=tonumber(distance),seen=now(),key=key,}local rows={}for entryKey,item in pairs(value.offers)do rows[#rows+1]={key=entryKey,seen=tonumber(item.seen)or 0}end table.sort(rows,function(a,b)return a.seen>b.seen end)while#rows>OFFER_LIMIT do value.offers[table.remove(rows).key]=nil end setStatus(\"offers\",\"Signed release \"..offer.version..\" available from \"..tostring(body.label or source))record(\"offer\",{id=source,version=offer.version,transport=transport,distance=distance})save()return true end local function checkCloudManifest()local raw,readErr=readHttp(CLOUD_MANIFEST_URL,release.MAX_MANIFEST_BYTES)if not raw then return 0,readErr end local ok,catalogue=pcall(textutils.unserialiseJSON,raw)if not ok or type(catalogue)~=\"table\"or catalogue.schema~=1 or type(catalogue.releases)~=\"table\"or#catalogue.releases>OFFER_LIMIT then return 0,\"invalid signed-release catalogue\"end local count=0 for index=1,#catalogue.releases do local entry=catalogue.releases[index]if type(entry)==\"table\"and entry.profile==profile.id()then local accepted=upsertOffer(CLOUD_SOURCE_ID,entry,\"cloud\")if accepted then count=count+1 end end end return count end local function offers()local value,timestamp,rows=loadState(),now(),{}for key,item in pairs(value.offers)do if type(item)==\"table\"and timestamp-(tonumber(item.seen)or 0)<=MAX_OFFER_AGE then rows[#rows+1]=item else value.offers[key]=nil end end table.sort(rows,function(left,right)local compare=release.compareVersions(left.version,right.version)or 0 if compare~=0 then return compare>0 end return tostring(left.id)<tostring(right.id)end)return rows end local function findOffer(source)source=tostring(source)for _,item in ipairs(offers())do if item.key==source or tostring(item.id)==source then return item end end return nil,\"release source is unavailable; run update check first\"end local function removePart()if fs.exists(release.PART_FILE)then fs.delete(release.PART_FILE)end end local function appendPart(data)local handle,err=fs.open(release.PART_FILE,\"a\")if not handle then return false,err or\"could not open update staging file\"end handle.write(data);handle.close()return true end local function cachedSource()local available=refreshCached()return available and available.package and available.package.source end local function transferRequest(transfer)local length=math.min(release.CHUNK_BYTES,transfer.size-transfer.offset+1)if length<1 then return false,\"transfer is already complete\"end transfer.awaiting,transfer.requestedAt=true,now()local body={transfer=transfer.id,offset=transfer.offset,length=length}local sent,err if transfer.transport==\"routed\"then sent,err=net.request(transfer.source,\"update_chunk_request\",body,{safe=true})else sent,err=net.publicSend(transfer.source,\"update_chunk_request\",body)end if not sent then transfer.awaiting=false;return false,err end return true end local function beginDownload(source)local offer,err=findOffer(source)if not offer then return false,err end local compare=release.compareVersions(offer.version,version.string)if not compare or compare<=0 then return false,\"refusing a downgrade or current release\"end local free=fs.getFreeSpace and fs.getFreeSpace(\"/\")or nil if type(free)==\"number\"and free<offer.size+4096 then return false,\"not enough free space for one verified release cache\"end removePart()release.clear();cached=nil local value=loadState()if offer.transport==\"cloud\"then setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from releases.ceet.uk\")save()local sourceText,readErr=readHttp(CLOUD_RELEASE_ORIGIN..\"/\"..tostring(offer.filename or\"\"),release.MAX_PACKAGE_BYTES)if not sourceText then setStatus(\"error\",readErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=readErr});save();return false,readErr end local parsed,parseErr=release.parse(sourceText)if not parsed or parsed.manifest.profile~=offer.profile or parsed.manifest.version~=offer.version or parsed.manifest.digest:lower()~=offer.digest or parsed.manifest.key_id~=offer.keyId then local reason=parseErr or\"verified package did not match selected release offer\"setStatus(\"error\",reason);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=reason});save();return false,reason end local metadata,cacheErr=release.cache(sourceText,\"releases.ceet.uk\")if not metadata then setStatus(\"error\",cacheErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=cacheErr});save();return false,cacheErr end cached=nil;refreshCached()setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=CLOUD_SOURCE_ID,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end value.transfer={id=\"update-\"..localId()..\"-\"..tostring(now())..\"-\"..tostring(math.random(1000,9999)),source=tostring(offer.id),label=offer.label,transport=offer.transport==\"routed\"and\"routed\"or\"direct\",profile=offer.profile,version=offer.version,size=offer.size,digest=offer.digest,keyId=offer.keyId,offset=1,received=0,retries=0,awaiting=false,started=now(),}setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from \"..offer.label)record(\"download_started\",{id=offer.id,version=offer.version,transport=value.transfer.transport})local sent,sendErr=transferRequest(value.transfer)if not sent then value.transfer=nil;setStatus(\"error\",sendErr);record(\"download_failed\",{id=offer.id,error=sendErr})end save()return sent,sendErr end local function finishTransfer(transfer)local handle=fs.open(release.PART_FILE,\"r\")local source=handle and handle.readAll()or nil if handle then handle.close()end if not source or#source~=transfer.size then return false,\"download size did not match offer\"end local parsed,parseErr=release.parse(source)if not parsed then return false,parseErr end if parsed.manifest.profile~=profile.id()or parsed.manifest.profile~=transfer.profile or parsed.manifest.version~=transfer.version or parsed.manifest.digest:lower()~=transfer.digest:lower()or parsed.manifest.key_id~=transfer.keyId then return false,\"verified package did not match selected release offer\"end local metadata,promoteErr=release.promotePart(release.PART_FILE,transfer.label)if not metadata then return false,promoteErr end cached=nil;refreshCached()local value=loadState();value.transfer=nil setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=transfer.source,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end local function acceptChunk(source,body,transport)local value,transfer=loadState(),loadState().transfer if not transfer or transfer.transport~=transport or tostring(source)~=tostring(transfer.source)then return false,\"unexpected update chunk\"end if type(body)~=\"table\"or body.transfer~=transfer.id or math.floor(tonumber(body.offset)or 0)~=transfer.offset or type(body.data)~=\"string\"then return false,\"malformed update chunk\"end local remaining=transfer.size-transfer.offset+1 if#body.data<1 or#body.data>math.min(release.CHUNK_BYTES,remaining)then return false,\"invalid update chunk length\"end local ok,err=appendPart(body.data)if not ok then transfer.awaiting=false;setStatus(\"error\",err);record(\"download_failed\",{error=err});save();return false,err end transfer.offset,transfer.received,transfer.awaiting,transfer.retries=transfer.offset+#body.data,(transfer.received or 0)+#body.data,false,0 if transfer.offset>transfer.size then local complete,result=finishTransfer(transfer)if not complete then removePart();value.transfer=nil;setStatus(\"error\",result);record(\"download_failed\",{id=source,error=result});save()end return complete,result end local sent,sendErr=transferRequest(transfer)if not sent then setStatus(\"error\",sendErr);record(\"download_failed\",{id=source,error=sendErr});value.transfer=nil;removePart()end save()return sent,sendErr end local function serveChunk(target,body,routed,request)if type(body)~=\"table\"or not validId(body.transfer)or math.floor(tonumber(body.offset)or 0)<1 or math.floor(tonumber(body.length)or 0)<1 or tonumber(body.length)>release.CHUNK_BYTES then return false,\"invalid update chunk request\"end local source=cachedSource()if not source then return false,\"no verified newer signed release is cached\"end local offset,length=math.floor(body.offset),math.floor(body.length)if offset>#source then return false,\"requested update offset is beyond package\"end local data=source:sub(offset,math.min(#source,offset+length-1))local response={transfer=body.transfer,offset=offset,data=data}if routed then return net.reply(request,\"update_chunk\",response,{safe=true})end return net.publicSend(target,\"update_chunk\",response)end function M.publicPacket(packet,distance)local source,body=tostring(packet.from),packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then net.publicSend(source,\"update_offer\",offer)end return elseif packet.type==\"update_offer\"then return upsertOffer(source,body,\"direct\",distance)elseif packet.type==\"update_chunk_request\"then return serveChunk(source,body,false)elseif packet.type==\"update_chunk\"then return acceptChunk(source,body,\"direct\")end end function M.authenticatedPacket(from,peer,packet)local body=packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then return net.reply(packet,\"update_offer\",offer,{safe=true})end elseif packet.type==\"update_offer\"then return upsertOffer(from,body,\"routed\")elseif packet.type==\"update_chunk_request\"then return serveChunk(from,body,true,packet)elseif packet.type==\"update_chunk\"then return acceptChunk(from,body,\"routed\")end end function M.check()local value=loadState()for key in pairs(value.offers)do value.offers[key]=nil end setStatus(\"checking\",\"Looking for newer signed releases\")local cloudOffers,cloudErr=checkCloudManifest()local sent,err=net.publicBroadcast(\"update_query\",{version=version.string,profile=profile.id()})local routed=0 for _,peer in ipairs(net.peers())do if not peer.rekeyRequired then local ok=net.request(peer.id,\"update_query\",{version=version.string,profile=profile.id()},{safe=true})if ok then routed=routed+1 end end end if cloudErr then setStatus(\"warning\",\"Cloud release check failed: \"..tostring(cloudErr):sub(1,120))elseif cloudOffers==0 and not(sent or routed>0)then setStatus(\"idle\",\"No newer signed release is available\")elseif cloudOffers>0 then setStatus(\"offers\",tostring(cloudOffers)..\" signed cloud release offer\"..(cloudOffers==1 and\"\"or\"s\")..\" available\")end record(\"check\",{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr,error=sent and nil or err})save()if cloudErr and not sent and routed==0 then return false,cloudErr end return true,{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr}end function M.download(source)return beginDownload(source)end function M.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_client.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local networkIpc=require(\"ceetos.lib.network_ipc\")local M={}local REPLIES=\"/ceetos/data/auth-replies.lua\"local sequence=0 local function now()return os.epoch(\"utc\")end local function authority()store.invalidate(\"/ceetos/data/auth-authority.lua\")local value=store.read(\"/ceetos/data/auth-authority.lua\",nil)return type(value)==\"table\"and value.active==true and value or nil end local function requestId(kind)sequence=sequence+1 return table.concat({\"auth\",kind,tostring(os.getComputerID()),tostring(now()),tostring(sequence)},\"-\")end local function take(id)store.invalidate(REPLIES)local replies=store.read(REPLIES,{})local row=replies[id]if row then replies[id]=nil;store.write(REPLIES,replies)end return row end function M.receive(body)if type(body)~=\"table\"or type(body.request_id)~=\"string\"or#body.request_id>160 then return false,\"invalid authority reply\"end local replies=store.read(REPLIES,{})replies[body.request_id]={ok=body.ok==true,result=body.result,error=body.error,at=now()}local rows={}for id,row in pairs(replies)do rows[#rows+1]={id=id,at=tonumber(row.at)or 0}end table.sort(rows,function(a,b)return a.at>b.at end)while#rows>32 do replies[table.remove(rows).id]=nil end return store.write(REPLIES,replies)end local function send(typeName,body,timeout)local server=authority()if not server then return nil,\"no Auth Server is reachable\"end local id=body.request_id or requestId(typeName)body.request_id=id local command={id=\"auth-\"..id,action=\"auth_send\",target=server.id,type=typeName,body=body}local ok,err=networkIpc.submit(command)if not ok then return nil,err or\"could not reach CeetOS network service\"end local deadline=now()+(timeout or 6000)while now()<deadline do local ack=networkIpc.poll(command.id,true)if ack and ack.ok~=true then return nil,ack.error or\"Auth Server request was not sent\"end local reply=take(id)if reply then return reply.ok and reply.result or nil,reply.error or\"Auth Server rejected request\"end sleep(0.05)end return nil,\"Auth Server did not respond\"end local function loginProof(verifier,server,request,challenge,expires)return password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(os.getComputerID()),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.login(name,plainPassword)end local request=requestId(\"begin\")local begin,beginErr=send(\"auth_login_begin\",{request_id=request,username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=loginProof(verifier,begin.authority,request,begin.challenge,begin.expires)local result,proofErr=send(\"auth_login_proof\",{request_id=request,username=name,node=tostring(os.getComputerID()),challenge=begin.challenge,proof=proof})if not result then return false,proofErr end local auth=require((\"ceetos.lib.auth\"))local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require((\"ceetos.lib.auth\"))local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.mutate(action,fields)end local current,server=auth.refreshSession(),authority()if not current or not current.central or not server then return false,\"an Auth Server login is required\"end local result,err=send(\"auth_mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end return M",
  ["ceetos/lib/telemetry.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/config.lua\"local activity=\"desktop\"local function text(value,limit)if type(value)~=\"string\"then return nil end value=value:gsub(\"[%z\\1-\\31\\127]\",\" \")if value==\"\"then return nil end return value:sub(1,limit)end local function config()local value=store.read(PATH,{})if type(value)~=\"table\"then value={}end if value.telemetry==nil then value.telemetry=true store.write(PATH,value)end return value end function M.setEnabled(value)assert(type(value)==\"boolean\",\"telemetry state must be boolean\")require(\"ceetos.lib.auth\").require(\"admin\")local valueForSave=config()valueForSave.telemetry=value return store.write(PATH,valueForSave)end function M.status()return config().telemetry==true end function M.configuration()return{enabled=M.status()}end function M.markActivity(value)activity=text(value,48)or activity return activity end function M.activity()return activity end function M.snapshot(currentActivity)if currentActivity then M.markActivity(currentActivity)end local data={ts=os.epoch(\"utc\"),id=os.getComputerID(),label=text(os.getComputerLabel(),96),activity=activity,}if turtle and type(turtle.getFuelLevel)==\"function\"then local ok,fuel=pcall(turtle.getFuelLevel)if ok and type(fuel)==\"number\"then data.fuel=fuel end end if gps and type(gps.locate)==\"function\"then local ok,x,y,z=pcall(gps.locate,0.2)if ok and type(x)==\"number\"and type(y)==\"number\"and type(z)==\"number\"then data.gps={x=x,y=y,z=z}end end return data end return M",
  ["ceetos/lib/cloud.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local M={}M.PATH=\"/ceetos/data/cloud.lua\"M.MAX_BODY=48*1024 M.MAX_RESPONSE=64*1024 M.DEFAULTS={auth=\"https://auth.ceet.uk\",recipe=\"https://recipe.ceet.uk\",dashboard=\"https://dash.ceet.uk\",}local function now()return os.epoch(\"utc\")end local function validUrl(value)if type(value)~=\"string\"or#value>160 then return false end return value:match(\"^https://[%w%-%.]+%.ceet%.uk$\")~=nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_.%-]+$\")~=nil and#value<=96 end local function copy(value)local out={}for key,item in pairs(value or{})do out[key]=item end return out end local function normalise(value)value=type(value)==\"table\"and value or{}local urls=type(value.urls)==\"table\"and value.urls or{}local result={schema=1,enabled=value.enabled==true,urls={auth=validUrl(urls.auth)and urls.auth or M.DEFAULTS.auth,recipe=validUrl(urls.recipe)and urls.recipe or M.DEFAULTS.recipe,dashboard=validUrl(urls.dashboard)and urls.dashboard or M.DEFAULTS.dashboard,},node=type(value.node)==\"table\"and copy(value.node)or nil,}if result.node and(not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 or#result.node.secret>192)then result.node=nil end return result end function M.load()store.invalidate(M.PATH)return normalise(store.read(M.PATH,{}))end function M.save(value)local clean=normalise(value)return store.write(M.PATH,clean)end function M.configure(urls)local value=M.load()urls=type(urls)==\"table\"and urls or{}for key in pairs(M.DEFAULTS)do if urls[key]~=nil then if not validUrl(urls[key])then return false,\"invalid \"..key..\" cloud URL\"end value.urls[key]=urls[key]end end return M.save(value)end function M.clear()local value=M.load();value.enabled,value.node=false,nil return M.save(value)end function M.publicStatus()local value=M.load()return{enabled=value.enabled,enrolled=value.node~=nil,node=value.node and value.node.id or nil,urls=copy(value.urls),profile=profile.id()}end local function readBounded(handle,limit)local chunks,total={},0 while true do local part=handle.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then return nil,\"cloud response is too large\"end chunks[#chunks+1]=part end return table.concat(chunks)end local function json(value)local ok,result=pcall(textutils.unserialiseJSON,value)return ok and type(result)==\"table\"and result or nil end local function canonical(node,timestamp,nonce,method,path,body)local digest=assert(password.sha256(body))return table.concat({\"ceetos-cloud-node-v1\",node,tostring(timestamp),nonce,method,path,digest},\"\\n\")end local nonceCounter=0 local function nonce()nonceCounter=nonceCounter+1 return password.newSalt(\"cloud:\"..tostring(nonceCounter))end local function perform(url,method,path,body,headers)if not http or type(http.post)~=\"function\"then return nil,\"HTTP is unavailable\"end local response local ok,err=pcall(function()response=http.post(url..path,body,headers)end)if not ok or not response then return nil,tostring(err or\"cloud request failed\")end local raw,readErr=readBounded(response,M.MAX_RESPONSE)pcall(response.close)if not raw then return nil,readErr end local decoded=json(raw)if not decoded then return nil,\"cloud returned invalid JSON\"end if decoded.ok==false then return nil,tostring(decoded.error or\"cloud rejected request\"):sub(1,180)end return decoded end function M.enroll(code)if type(code)~=\"string\"or#code<12 or#code>128 or code:find(\"[%z\\1-\\31\\127]\")then return nil,\"invalid enrollment code\"end local value=M.load()local payload=textutils.serialiseJSON({code=code,profile=profile.id(),label=os.getComputerLabel()or(\"Computer \"..tostring(os.getComputerID())),computerId=tostring(os.getComputerID())})if#payload>M.MAX_BODY then return nil,\"enrollment request is too large\"end local result,err=perform(value.urls.auth,\"POST\",\"/v1/nodes/enroll\",payload,{[\"Content-Type\"]=\"application/json\"})if not result then return nil,err end if type(result.node)~=\"table\"or not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 then return nil,\"cloud returned invalid enrollment\"end value.enabled,value.node=true,{id=result.node.id,secret=result.node.secret,enrolledAt=now()}local saved,saveErr=M.save(value)if not saved then return nil,saveErr or\"could not save cloud enrollment\"end return M.publicStatus()end function M.call(service,path,payload)local value=M.load()if not value.enabled or not value.node then return nil,\"cloud node is not enrolled\"end if not M.DEFAULTS[service]or type(path)~=\"string\"or not path:match(\"^/v1/[%w%-%._/]+$\")or#path>128 then return nil,\"invalid cloud endpoint\"end local body=textutils.serialiseJSON(type(payload)==\"table\"and payload or{})if#body>M.MAX_BODY then return nil,\"cloud request is too large\"end local timestamp,requestNonce=now(),nonce()local signature=password.hmacSha256(value.node.secret,canonical(value.node.id,timestamp,requestNonce,\"POST\",path,body))if not signature then return nil,\"could not sign cloud request\"end return perform(value.urls[service],\"POST\",path,body,{[\"Content-Type\"]=\"application/json\",[\"X-CeetOS-Node\"]=value.node.id,[\"X-CeetOS-Time\"]=tostring(timestamp),[\"X-CeetOS-Nonce\"]=requestNonce,[\"X-CeetOS-Signature\"]=signature,})end return M",
  ["ceetos/lib/cloud_sync.lua"] = "local cloud=require(\"ceetos.lib.cloud\")local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local telemetryService=require(\"ceetos.lib.telemetry\")local RECIPE_SERVICE_MODULE=\"ceetos.lib.\"..\"recipe_service\"local M={}local STATE=\"/ceetos/data/cloud-state.lua\"local INTERVALS={telemetry=24*60*60*1000,authority=30000,recipes=30000}local TELEMETRY_RETRIES={15*60*1000,60*60*1000,4*60*60*1000}local function now()return os.epoch(\"utc\")end local function defaults()return{schema=2,revision=0,auth={online=false,next=0},recipe={online=false,next=0,revision=0},telemetry={enabled=nil,next=0,lastSuccess=nil,failures=0,lastError=nil},lastError=nil}end local function state()store.invalidate(STATE)local value=store.read(STATE,defaults())if type(value)~=\"table\"then value=defaults()end if type(value.auth)~=\"table\"then value.auth={}end if type(value.recipe)~=\"table\"then value.recipe={}end if type(value.telemetry)~=\"table\"then value.telemetry={}end for key,fallback in pairs(defaults())do if value[key]==nil then value[key]=fallback end end for key,fallback in pairs(defaults().recipe)do if value.recipe[key]==nil then value.recipe[key]=fallback end end for key,fallback in pairs(defaults().telemetry)do if value.telemetry[key]==nil then value.telemetry[key]=fallback end end return value end local function save(value)value.revision=(tonumber(value.revision)or 0)+1 return store.write(STATE,value)end local function errorState(value,message)value.lastError=tostring(message or\"cloud request failed\"):sub(1,180)end function M.status()local value,cfg=state(),cloud.publicStatus()return{enabled=cfg.enabled,enrolled=cfg.enrolled,node=cfg.node,urls=cfg.urls,authOnline=value.auth.online==true,recipeOnline=value.recipe.online==true,telemetryNext=tonumber(value.telemetry and value.telemetry.next)or 0,telemetryInterval=INTERVALS.telemetry,telemetryEnabled=telemetryService.status(),telemetryLastSuccess=value.telemetry and value.telemetry.lastSuccess or nil,telemetryLastError=value.telemetry and value.telemetry.lastError or nil,telemetryFailures=math.max(0,math.floor(tonumber(value.telemetry and value.telemetry.failures)or 0)),lastSync=value.lastSync,lastError=value.lastError,}end function M.configure(urls)return cloud.configure(urls)end function M.enroll(code)local enrolled,err=cloud.enroll(code)if not enrolled then return nil,err end local value=state()value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=0,0,nil save(value)return enrolled end function M.clear()local ok,err=cloud.clear();if ok then store.write(STATE,defaults())end return ok,err end function M.authOnline()return M.status().authOnline==true end function M.recipeOnline()return M.status().recipeOnline==true end local function cloudAuthority(result)local auth=require(\"ceetos.lib.auth\")if type(result)~=\"table\"or type(result.directory)~=\"table\"then return false,\"invalid cloud authority response\"end local cfg=cloud.publicStatus()local record={id=\"cloud:\"..tostring(cfg.urls.auth),term=tonumber(result.term)or 0,revision=tonumber(result.revision)or 0,directory=result.directory}return pcall(auth.acceptAuthority,record)end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local begin,beginErr=cloud.call(\"auth\",\"/v1/auth/login/begin\",{username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end if type(begin.salt)~=\"string\"or type(begin.workFactor)~=\"number\"or type(begin.challenge)~=\"string\"or type(begin.expires)~=\"number\"then return false,\"invalid cloud login challenge\"end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(begin.authority),tostring(os.getComputerID()),tostring(begin.requestId),tostring(begin.challenge),tostring(begin.expires)},\"|\"))local result,resultErr=cloud.call(\"auth\",\"/v1/auth/login/proof\",{username=name,node=tostring(os.getComputerID()),requestId=begin.requestId,challenge=begin.challenge,proof=proof})if not result then return false,resultErr end local auth=require(\"ceetos.lib.auth\")local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require(\"ceetos.lib.auth\")local current=auth.refreshSession()if not current or not current.central then return false,\"cloud login is required\"end local result,err=cloud.call(\"auth\",\"/v1/auth/mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.recipePlan(item,quantity,stock)if not M.recipeOnline()then return nil,\"cloud Recipe Server is unavailable\"end local result,err=cloud.call(\"recipe\",\"/v1/recipe/plan\",{item=item,quantity=quantity,stock=stock})if not result then return nil,err end return result.plan,result.error end local function telemetry()local snapshot=telemetryService.snapshot()local net=require(\"ceetos.lib.net\")local transport=net.statusSnapshot and net.statusSnapshot().transport or{}snapshot.health={profile=profile.id(),version=require(\"ceetos.lib.version\").string,uptime=os.clock(),freeSpace=fs.getFreeSpace(\"/\"),peers=#(net.peers and net.peers()or{}),healthyLinks=transport and transport.healthyLinks or 0,lastError=M.status().lastError,}local result,err=cloud.call(\"dashboard\",\"/v1/telemetry/ingest\",snapshot)return result~=nil,err end local function syncAuth()if profile.is(\"auth-server\")then local auth=require(\"ceetos.lib.auth\")local snapshot=auth.authoritySnapshot()local pushed,pushErr=cloud.call(\"auth\",\"/v1/auth/replica/merge\",{snapshot=snapshot,source=\"mesh\"})if not pushed then return false,pushErr end if type(pushed.snapshot)==\"table\"then auth.merge(pushed.snapshot,true)end local ok,authErr=cloudAuthority(pushed)if not ok then return false,authErr end return true end local result,err=cloud.call(\"auth\",\"/v1/auth/directory\",{})if not result then return false,err end local ok,authErr=cloudAuthority(result)if not ok then return false,authErr end return true end local function syncRecipes()if not profile.is(\"recipe-server\")then local result,err=cloud.call(\"recipe\",\"/v1/recipe/status\",{})return result~=nil,err end local service=require(RECIPE_SERVICE_MODULE)if type(service.exportOverlay)~=\"function\"then return false,\"recipe export unavailable\"end local payload,exportErr=service.exportOverlay()if not payload then return false,exportErr end local value=state()value.recipe=value.recipe or{revision=0}local result,err=cloud.call(\"recipe\",\"/v1/recipe/replica/merge\",{overlay=payload,baseRevision=math.max(0,math.floor(tonumber(value.recipe.revision)or 0)),})if not result then return false,err end if type(result.overlay)==\"table\"and type(service.replaceOverlay)==\"function\"then local applied,applyErr=service.replaceOverlay(result.overlay)if not applied then return false,applyErr end end return true,nil,math.max(0,math.floor(tonumber(result.revision)or 0))end function M.tick(activity)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 local telemetryEnabled=telemetryService.status()if not telemetryEnabled then if value.telemetry.enabled~=false or value.telemetry.next~=0 then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=false,0,0,nil changed=true end elseif value.telemetry.enabled~=true then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=true,0,0,nil changed=true elseif timestamp>=(tonumber(value.telemetry.next)or 0)then local ok,err=telemetry()if ok then value.telemetry.next,value.telemetry.lastSuccess,value.telemetry.failures,value.telemetry.lastError=timestamp+INTERVALS.telemetry,timestamp,0,nil else local failures=math.max(0,math.floor(tonumber(value.telemetry.failures)or 0))+1 value.telemetry.failures,value.telemetry.lastError=failures,tostring(err or\"telemetry upload failed\"):sub(1,180)value.telemetry.next=timestamp+(TELEMETRY_RETRIES[failures]or INTERVALS.telemetry)errorState(value,value.telemetry.lastError)end changed=true end if changed then value.lastSync=timestamp;save(value)end return true end return M",
  ["ceetos/lib/version.lua"] = "return{major=0,minor=16,patch=8,string=\"0.16.8\"}",
  ["ceetos/lib/crafting.lua"] = "local M={}M.RECIPE_PACK_MAX_BYTES=64*1024 function M.isLocalPeer(peer,computerId)return tostring(peer)==tostring(computerId)end function M.normalise(rows)local out={}for _,row in pairs(type(rows)==\"table\"and rows or{})do if type(row)==\"table\"then local name,count=row.name or row.id,tonumber(row.count or row.amount or row.quantity or 0)or 0 if type(name)==\"string\"and count>0 then out[name]=(out[name]or 0)+math.floor(count)end end end return out end function M.rows(stock,query,filter,recipes)local output,needle,available={},tostring(query or\"\"):lower(),M.normalise(stock)local names={}for name in pairs(available)do names[name]=true end for name in pairs(type(recipes)==\"table\"and recipes or{})do names[name]=true end for name in pairs(names)do local count=available[name]or 0 local craftable=type(recipes)==\"table\"and recipes[name]~=nil local include=needle==\"\"or name:lower():find(needle,1,true)if filter==\"craftable\"then include=include and craftable elseif filter==\"stocked\"then include=include and count>0 end if include then output[#output+1]={name=name,count=count,craftable=craftable,stocked=count>0}end end table.sort(output,function(a,b)return a.name<b.name end)return output end function M.addToCart(cart,name,count)if type(cart)~=\"table\"or type(name)~=\"string\"or name==\"\"then return nil,\"invalid cart item\"end count=tonumber(count)if not count or count<1 then return nil,\"invalid cart quantity\"end count=math.floor(count)for _,row in ipairs(cart)do if row.name==name then row.count=(tonumber(row.count)or 0)+count;return row end end local row={name=name,count=count}cart[#cart+1]=row return row end function M.cartTotals(cart)local items,quantity=0,0 for _,row in ipairs(type(cart)==\"table\"and cart or{})do items=items+1 quantity=quantity+math.max(0,math.floor(tonumber(row.count)or 0))end return items,quantity end function M.acceptedCount(result,requested)local accepted=tonumber(result)requested=tonumber(requested)if not accepted or not requested or requested<1 then return nil,\"invalid request result\"end accepted=math.floor(accepted)if accepted<1 then return nil,\"Stock Ticker accepted no items\"end return math.min(accepted,math.floor(requested))end function M.displayRow(name,count,width)local suffix=\" x\"..tostring(count)width=math.max(#suffix+1,math.floor(tonumber(width)or#suffix+1))if#name+#suffix<=width then return name..suffix end return name:sub(1,math.max(1,width-#suffix-1))..\"…\"..suffix end function M.cancellationStatus(issued)return issued and\"cancelled-unconfirmed\"or\"cancelled\"end local function validReference(name)return type(name)==\"string\"and name:match(\"^#?[%w_.:%-]+$\")~=nil and not name:find(\"##\",1,true)end local function recipeIngredients(recipe,batches)local combined={}local declared=type(recipe.ingredients)==\"table\"and#recipe.ingredients>0 if declared then for _,ingredient in ipairs(recipe.ingredients)do local name=type(ingredient)==\"table\"and ingredient.id or ingredient local count=type(ingredient)==\"table\"and tonumber(ingredient.count or 1)or 1 if validReference(name)then combined[name]=(combined[name]or 0)+batches*math.max(1,math.floor(count or 1))end end else for slot=1,9 do local name=recipe.grid and recipe.grid[slot]if name and name~=false then combined[name]=(combined[name]or 0)+batches end end end local out={}for name,count in pairs(combined)do out[#out+1]={name=name,count=count}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.recipeInputs(recipe,batches)return recipeIngredients(recipe or{},math.max(1,math.floor(tonumber(batches)or 1)))end function M.validateRecipes(recipes)if type(recipes)~=\"table\"then return nil,\"recipes must return a table\"end for name,recipe in pairs(recipes)do if type(name)~=\"string\"or not name:match(\"^[%w_.:%-]+$\")or type(recipe)~=\"table\"then return nil,\"invalid recipe item id\"end if type(recipe.alternatives)==\"table\"then if#recipe.alternatives<1 then return nil,\"recipe \"..name..\" has no alternatives\"end for _,alternative in ipairs(recipe.alternatives)do local valid,err=M.validateRecipes({[name]=alternative});if not valid then return nil,err end end else if recipe.mode~=\"crafting\"then return nil,\"recipe \"..name..\" must use mode = crafting\"end if type(recipe.address)~=\"string\"or recipe.address==\"\"or#recipe.address>64 then return nil,\"recipe \"..name..\" requires an address\"end local crafter=recipe.address==\"Crafter\"if crafter and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires a 9-slot grid for Crafter\"end if not crafter and type(recipe.ingredients)~=\"table\"and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires ingredients\"end local output=tonumber(recipe.output or 1)if not output or output<1 or output~=math.floor(output)then return nil,\"invalid output for \"..name end for slot=1,9 do local value=recipe.grid and recipe.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid grid slot in \"..name end end for _,ingredient in ipairs(type(recipe.ingredients)==\"table\"and recipe.ingredients or{})do local id,count=type(ingredient)==\"table\"and ingredient.id or ingredient,type(ingredient)==\"table\"and ingredient.count or 1 if not validReference(id)or not tonumber(count)or tonumber(count)<1 then return nil,\"invalid ingredient in \"..name end end end end return recipes end local function dataParser(source,maximum)if type(source)~=\"string\"then return nil,\"recipe data must be text\"end if#source==0 or#source>(maximum or M.RECIPE_PACK_MAX_BYTES)then return nil,\"recipe data exceeds the 64 KiB import limit\"end local state={source=source,index=1,length=#source,depth=0,nodes=0}local function skip()while state.index<=state.length do local char=state.source:sub(state.index,state.index)if char:match(\"%s\")then state.index=state.index+1 elseif state.source:sub(state.index,state.index+1)==\"--\"then local ending=state.source:find(\"\\n\",state.index+2,true)state.index=ending and ending+1 or state.length+1 else return true end end return true end local function fail(message)return nil,message..\" near byte \"..tostring(state.index)end local function identifier()local name=state.source:match(\"^[%a_][%w_]*\",state.index)if name then state.index=state.index+#name end return name end local parseValue local function parseString()local quote=state.source:sub(state.index,state.index);state.index=state.index+1 local out={}while state.index<=state.length do local char=state.source:sub(state.index,state.index);state.index=state.index+1 if char==quote then return table.concat(out)end if char==\"\\\\\"then local escaped=state.source:sub(state.index,state.index);state.index=state.index+1 local values={n=\"\\n\",r=\"\\r\",t=\"\\t\",[\"\\\\\"]=\"\\\\\",[\"\\\"\"]=\"\\\"\",[\"'\"]=\"'\"}if not values[escaped]then return fail(\"unsupported string escape\")end out[#out+1]=values[escaped]elseif char:byte()<32 then return fail(\"control character in string\")else out[#out+1]=char end end return fail(\"unterminated string\")end local function parseTable()state.depth=state.depth+1 if state.depth>32 then return fail(\"recipe data is nested too deeply\")end state.index=state.index+1 local out,nextIndex,keys={},1,{}skip()while state.index<=state.length and state.source:sub(state.index,state.index)~=\"}\"do state.nodes=state.nodes+1 if state.nodes>4096 then return fail(\"recipe data has too many values\")end local key,value,err local start=state.index if state.source:sub(state.index,state.index)==\"[\"then state.index=state.index+1;key,err=parseValue();if err then return nil,err end skip();if state.source:sub(state.index,state.index)~=\"]\"then return fail(\"missing closing recipe key bracket\")end state.index=state.index+1;skip();if state.source:sub(state.index,state.index)~=\"=\"then return fail(\"missing recipe key assignment\")end state.index=state.index+1;skip();value,err=parseValue();if err then return nil,err end else local named=identifier();skip()if named and state.source:sub(state.index,state.index)==\"=\"then key,state.index=named,state.index+1;skip();value,err=parseValue();if err then return nil,err end else state.index=start;value,err=parseValue();if err then return nil,err end key,nextIndex=nextIndex,nextIndex+1 end end if type(key)~=\"string\"and type(key)~=\"number\"then return fail(\"recipe table key must be text or a number\")end local signature=type(key)..\":\"..tostring(key)if keys[signature]then return fail(\"duplicate recipe table key\")end keys[signature],out[key]=true,value skip();local separator=state.source:sub(state.index,state.index)if separator==\",\"or separator==\";\"then state.index=state.index+1;skip()elseif separator~=\"}\"then return fail(\"expected recipe table separator\")end end if state.source:sub(state.index,state.index)~=\"}\"then return fail(\"unterminated recipe table\")end state.index,state.depth=state.index+1,state.depth-1 return out end parseValue=function()skip();local char=state.source:sub(state.index,state.index)if char==\"{\"then return parseTable()end if char==\"\\\"\"or char==\"'\"then return parseString()end local number=state.source:match(\"^-?%d+\",state.index)if number then state.index=state.index+#number;return tonumber(number)end local name=identifier()if name==\"true\"then return true elseif name==\"false\"then return false elseif name==\"nil\"then return nil elseif name then return fail(\"bare recipe values are not allowed\")end return fail(\"invalid recipe value\")end skip()if identifier()~=\"return\"then return fail(\"recipe data must start with return\")end local value,err=parseValue();if err then return nil,err end skip();if state.index<=state.length then return fail(\"unexpected content after recipe table\")end return value end local function validTags(tags)if tags==nil then return{}end if type(tags)~=\"table\"then return nil,\"recipe tags must be a table\"end local out={}for tag,members in pairs(tags)do local key=tostring(tag):gsub(\"^#\",\"\")if not key:match(\"^[%w_.:%-]+$\")or type(members)~=\"table\"or#members<1 then return nil,\"invalid recipe tag \"..tostring(tag)end out[key]={}for _,member in ipairs(members)do if not validReference(member)or tostring(member):sub(1,1)==\"#\"then return nil,\"invalid member of #\"..key end out[key][#out[key]+1]=member end table.sort(out[key])end return out end function M.validateRecipeGraph(recipes,tags)local tagMap,tagErr=validTags(tags);if not tagMap then return nil,tagErr end local visiting,complete={},{}local function visit(name)if complete[name]then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=recipes[name]if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end if not recipe then return true end visiting[name]=true for _,input in ipairs(recipeIngredients(recipe,1))do local ingredient=input.name local members=ingredient:sub(1,1)==\"#\"and tagMap[ingredient:sub(2)]or{ingredient}for _,member in ipairs(members or{})do if recipes[member]then local ok,err=visit(member);if not ok then return nil,err end end end end visiting[name],complete[name]=nil,true return true end for name in pairs(recipes)do local ok,err=visit(name);if not ok then return nil,err end end return true end function M.parseRecipeOverlay(source)local value,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not value then return nil,err end if type(value)~=\"table\"then return nil,\"recipe overlay must return a table\"end local recipes,tags if value.schema==1 and type(value.recipes)==\"table\"then recipes,tags=value.recipes,value.tags or{}else recipes,tags=value,{}end local valid,validationErr=M.validateRecipes(recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(tags);if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=recipes,tags=tagMap}end function M.parseRecipeFile(source)local overlay,err=M.parseRecipeOverlay(source)return overlay and overlay.recipes or nil,err end function M.parseRecipePack(source)local pack,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not pack then return nil,err end if type(pack)~=\"table\"or pack.schema~=1 or type(pack.recipes)~=\"table\"then return nil,\"recipe pack must return { schema = 1, recipes = { ... } }\"end local valid,validationErr=M.validateRecipes(pack.recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(pack.tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(pack.recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=pack.recipes,tags=tagMap}end function M.recipeEqual(left,right)if type(left)~=\"table\"or type(right)~=\"table\"then return false end if type(left.alternatives)==\"table\"then left=left.alternatives[1]end if type(right.alternatives)==\"table\"then right=right.alternatives[1]end if not left or not right or left.mode~=right.mode or left.kind~=right.kind or left.output~=right.output or left.address~=right.address then return false end for slot=1,9 do if left.grid and right.grid and left.grid[slot]~=right.grid[slot]then return false end end local a,b=recipeIngredients(left,1),recipeIngredients(right,1)if#a~=#b then return false end for index=1,#a do if a[index].name~=b[index].name or a[index].count~=b[index].count then return false end end return true end function M.reviewRecipePack(existing,incoming)local validExisting,existingErr=M.validateRecipes(existing)if not validExisting then return nil,existingErr end local validIncoming,incomingErr=M.validateRecipes(incoming)if not validIncoming then return nil,incomingErr end local rows,counts={},{new=0,unchanged=0,conflict=0,invalid=0}for name,recipe in pairs(incoming)do local prior=existing[name]local status=not prior and\"new\"or(M.recipeEqual(prior,recipe)and\"unchanged\"or\"conflict\")counts[status]=counts[status]+1 rows[#rows+1]={name=name,status=status,incoming=recipe,existing=prior,selected=status==\"new\"}end table.sort(rows,function(a,b)return a.name<b.name end)return{rows=rows,counts=counts}end local function cloneRecipe(recipe)if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end local copy={mode=recipe.mode,kind=recipe.kind,output=recipe.output,address=recipe.address,grid={},ingredients={}}for slot=1,9 do copy.grid[slot]=recipe.grid and recipe.grid[slot]end for _,input in ipairs(recipe.ingredients or{})do copy.ingredients[#copy.ingredients+1]={id=input.id,count=input.count,tag=input.tag}end return copy end function M.mergeRecipePack(existing,review,existingTags,incomingTags)if type(existing)~=\"table\"or type(review)~=\"table\"or type(review.rows)~=\"table\"then return nil,\"invalid recipe import review\"end local merged,imported={},0 for name,recipe in pairs(existing)do merged[name]=cloneRecipe(recipe)end for _,row in ipairs(review.rows)do if row.status==\"new\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 elseif row.status==\"conflict\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 end end local tags={}for name,members in pairs(existingTags or{})do tags[name]=members end for name,members in pairs(incomingTags or{})do tags[name]=members end local valid,err=M.validateRecipes(merged);if not valid then return nil,err end local graphOk,graphErr=M.validateRecipeGraph(merged,tags);if not graphOk then return nil,graphErr end return merged,imported,tags end function M.encodeRecipeFile(recipes,tags)local valid,err=M.validateRecipes(recipes);if not valid then return nil,err end local tagMap,tagsErr=validTags(tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap);if not graphOk then return nil,graphErr end local ok,encoded=pcall(textutils.serialise,{schema=1,recipes=recipes,tags=tagMap},{compact=true})if not ok or type(encoded)~=\"string\"then return nil,\"could not serialise recipes\"end return\"return \"..encoded..\"\\n\"end function M.writeRecipeFile(path,recipes,tags)if type(path)~=\"string\"or path==\"\"then return false,\"invalid recipe file path\"end local raw,encodeErr=M.encodeRecipeFile(recipes,tags);if not raw then return false,encodeErr end local parent=fs.getDir(path);if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary,backup=path..\".new\",path..\".bak\"if fs.exists(temporary)then fs.delete(temporary)end local handle=fs.open(temporary,\"w\");if not handle then return false,\"could not stage recipes\"end handle.write(raw);handle.close()local check=fs.open(temporary,\"r\");local staged=check and check.readAll()or nil;if check then check.close()end if not M.parseRecipeOverlay(staged or\"\")then if fs.exists(temporary)then fs.delete(temporary)end;return false,\"could not validate staged recipes\"end if fs.exists(backup)then fs.delete(backup)end if fs.exists(path)then fs.move(path,backup)end local moved,moveErr=pcall(fs.move,temporary,path)if not moved then if fs.exists(backup)and not fs.exists(path)then fs.move(backup,path)end;if fs.exists(temporary)then fs.delete(temporary)end;return false,tostring(moveErr)end if fs.exists(backup)then fs.delete(backup)end return true end local function selectedRecipe(entry)if type(entry)==\"table\"and type(entry.alternatives)==\"table\"then return entry.alternatives[1]end return entry end local function tagMembers(tags,reference)if reference:sub(1,1)~=\"#\"then return{reference}end local members=tags[reference:sub(2)]if type(members)~=\"table\"or#members==0 then return nil,\"no known members for \"..reference end return members end local function chooseMember(reference,tags,available,recipes)local members,err=tagMembers(tags,reference);if not members then return nil,err end local best for _,member in ipairs(members)do if(available[member]or 0)>0 then return member end if recipes[member]and not best then best=member end end return best,best and nil or(\"no stocked or craftable member for \"..reference)end local function requesterGrid(recipe,resolved,tags,available,recipes)local grid={}for slot=1,9 do local value=recipe.grid and recipe.grid[slot]if type(value)==\"string\"and value:sub(1,1)==\"#\"then local concrete=resolved[value]if not concrete then concrete=select(1,chooseMember(value,tags,available,recipes))end if not concrete then return nil,\"no concrete item available for requester tag \"..value end grid[slot]=concrete else grid[slot]=value end end return grid end function M.plan(recipes,stock,item,quantity,options)quantity=tonumber(quantity)if type(item)~=\"string\"or item==\"\"or not quantity or quantity<1 or quantity~=math.floor(quantity)then return nil,\"invalid item or quantity\"end local valid,errorText=M.validateRecipes(recipes)if not valid then return nil,errorText end options=type(options)==\"table\"and options or{}local available,plan,visiting,tags=M.normalise(stock),{},{},type(options.tags)==\"table\"and options.tags or{}local function requireItem(name,needed)local used=options.forceRoot==true and name==item and 0 or math.min(available[name]or 0,needed)available[name]=(available[name]or 0)-used local missing=needed-used if missing<=0 then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=selectedRecipe(recipes[name])if not recipe then return nil,\"missing recipe for \"..name..\" (need \"..tostring(missing)..\")\"end if recipe.special or not recipe.output or not recipe.address then return nil,\"recipe \"..name..\" is not supported by Crafting Queue\"end visiting[name]=true local batches=math.ceil(missing/recipe.output)local inputs,resolved={},{}for _,ingredient in ipairs(recipeIngredients(recipe,batches))do local concrete,resolveErr=chooseMember(ingredient.name,tags,available,recipes)if not concrete then return nil,resolveErr end inputs[#inputs+1]={name=concrete,count=ingredient.count,source=ingredient.name,tag=ingredient.name:sub(1,1)==\"#\"and ingredient.name or nil}if ingredient.name:sub(1,1)==\"#\"then resolved[ingredient.name]=concrete end local ok,err=requireItem(concrete,ingredient.count)if not ok then return nil,err end end visiting[name]=nil local produced=batches*recipe.output available[name]=(available[name]or 0)+produced-missing local dispatch=recipe.address==\"Crafter\"and\"requester\"or\"package\"if dispatch==\"requester\"and type(recipe.grid)~=\"table\"then return nil,\"Crafter recipe \"..name..\" has no 3x3 grid\"end local grid,gridErr=recipe.grid,nil if dispatch==\"requester\"then grid,gridErr=requesterGrid(recipe,resolved,tags,available,recipes)if not grid then return nil,gridErr end end plan[#plan+1]={name=name,batches=batches,produced=produced,requested=missing,address=recipe.address,kind=recipe.kind,dispatch=dispatch,grid=grid,sourceGrid=recipe.grid,inputs=inputs,}return true end local ok,err=requireItem(item,quantity)return ok and plan or nil,err end function M.validateExecutionPlan(plan)if type(plan)~=\"table\"or#plan<1 or#plan>96 then return nil,\"invalid remote recipe plan\"end for _,step in ipairs(plan)do if type(step)~=\"table\"or not validReference(step.name)or tostring(step.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe output\"end if type(step.address)~=\"string\"or step.address==\"\"or#step.address>64 or step.address:find(\"[%c]\")then return nil,\"invalid remote recipe address\"end if step.dispatch~=\"requester\"and step.dispatch~=\"package\"then return nil,\"invalid remote recipe route\"end if(step.address==\"Crafter\")~=(step.dispatch==\"requester\")then return nil,\"invalid remote recipe executor\"end for _,field in ipairs({\"batches\",\"produced\",\"requested\"})do local value=tonumber(step[field])if not value or value<1 or value~=math.floor(value)or value>65536 then return nil,\"invalid remote recipe quantity\"end end if step.dispatch==\"requester\"then if type(step.grid)~=\"table\"then return nil,\"remote Crafter recipe has no grid\"end for slot=1,9 do local value=step.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid remote recipe grid\"end if type(value)==\"string\"and value:sub(1,1)==\"#\"then return nil,\"remote requester grid contains unresolved tag\"end end end if type(step.inputs)~=\"table\"or#step.inputs>64 then return nil,\"invalid remote recipe inputs\"end for _,input in ipairs(step.inputs)do if type(input)~=\"table\"or not validReference(input.name)or tostring(input.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe input\"end local count=tonumber(input.count)if not count or count<1 or count~=math.floor(count)or count>65536 then return nil,\"invalid remote recipe input quantity\"end if input.source~=nil and not validReference(input.source)then return nil,\"invalid remote recipe input source\"end end end return plan end return M",
  ["ceetos/server.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local net=require(\"ceetos.lib.net\")local audit=require(\"ceetos.lib.audit\")local updater=require(\"ceetos.lib.updater\")local networkIpc=require(\"ceetos.lib.network_ipc\")local version=require(\"ceetos.lib.version\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local authority=profile.is(\"auth-server\")and require((\"ceetos.lib.auth_authority\"))or nil local authClient=require(\"ceetos.lib.auth_client\")local cloudSync=require(\"ceetos.lib.cloud_sync\")local 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);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 = "router-server"

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

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

local backup, migrate, migrationData = nil, false, {}
-- 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.8" .. ",profile=" .. "\"router-server\"" .. "}"); marker.close() end
  print("CeetOS installed. Rebooting to verify the update.")
  os.reboot()
end
print("CeetOS installed. Reboot to start it.")

-- CEETOS_RELEASE_PAYLOAD_END