-- CeetOS signed release. Generated; do not edit.
-- CEETOS_RELEASE_MANIFEST:{channel="release",profile="auth-server",version="0.16.8",size=264279,digest="8e1a0eb4b0c38cbaa2bbf827f22a0537f4a2111870c4e4222a5198f6bc89291b",key_id="auth-server-release-0.16.7",next_key_id="auth-server-release-0.16.8",next_public="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"}
-- CEETOS_RELEASE_SIGNATURE:OZ3qOEdb1SXzEv/YjW8qopd8fgBJS6Dl+b89zscn6hZDF+chdj3NsrRvPhVJdSJ8te9lnaYQRK2EkmIvz8KncSYOqv8vuZrPp8H+VlkYEDJAzXfENfQ7/gEDNbI1qy8CtiTDki7BoT+HsyJOjOk/R0ov+p9GbQCMFcHVva+6U0+Km3czvjkkT/5E9NiLqv/X9jCIXRW/weAOfB3MbdmKbiPTYHApYZM+0drRTHLsHPF0rQ8S1xfI6JPAbz4VHw9c1FYgjyB/q4XrWfEOy1FZPn2hkoQd5Cp3HmQL1PKYOEz3zwiHloBwlmql9zeMJOOluab/QowZQUPRUxR+kBJffg00ZTsU+vXXp9TgCEdkSCbEKwGD7XhnzN1qfi0/Ny1/neVgr2RzryFGK8QbW/dypOKLvsbgGWSL80KkZqVutjRJC4yqINb+akZRimfN6+erQCqilsGB0ieqx5uPh3yuOScqmlxwEnQMCZ/ANpWGGsIDFG2+YwlblgRVK3YxUDNueaHrF+IhU8SX4rwoq/8SxLxkVW+JYNoB0UeLnoQRV7m15ZEjBlidgeZQfVqt+ZWZ/ORCbE4g3HsnUR4qyq8Outp2l9PNbW3LbB1mV9W4h7Imxum5lN4jFdVaie1E8OfH89MP2/63dznNq6fgLlNSAVhkunz1qznVGhK2V5U7Ok22UfV7z4x/WA4bISYoM/XakbVSRQzFBrcX7PCg5i5dWE23Dr7gK/fB1O1FnBbaFLuCF3zGhB3fXxoSJAfywSjgZ8FgjpDlb51m19L3gJeqmgQCyAVm+AVUen/aBvSFs6EWmr9Xj4USNzKqjSchjJ9byNMl6GO8c/dTCyCvwL3Ea5ucFuTXUtccApppnNj0RTCXie5TkHJHjsS75A8nxFB6/BZQI66hIRr7gBzZX++JGEmxiYKIu+4MyyvQPK8qQVmrtCliU/qlHXyP3FWaZNtuNVN5bumq/VN+1KFrEZNpM78NSgDvVtrdJItC49XtSx/PtmVxKVlnLM2QNJsj2KFKusisIddxcogiNPqwkon2+bYquSVO3jt6vSiyIdmlcN/5WpcB8dgy9ii4rfpotd8U846J/wqHFpmc1I6tQs3Aq3hNNX6n0UNBWumyyzWEdE4HBaDk13yRN0OgNKjx8DNVtpi9e5qI8WETZ0mFNLXupz8CJdQVdhblWtzWYTlOllpbS3gSl38D2cxkUXGwXnV+ILcxk60zIbEvSr0La/Zyr+vdmdOIMFm5PE7PnehYkLlf3wTL/3+YACata6X9iQ1gbEcScTPvsjsUp4dNc6FNEedxhYB6fnSEewQpxGuxk0hsQWxQSmB3WHXn4eV/ST04leYAdyhxWUkANSM4VsKYapGlHdyDUSVeX+U1TdzkKNVlrgJtm1oUOu6Co5dG9n6S5T7AJrJQSLnaVArmXbvQzw0wwrhr73+8goH5Gk5EwZuNJHHFjuR4g6rdtEyFg1M1c90bk9cylDELeUo5Q03KdwXOhHZ50O/wPvUh4LZWPHvc1+Z8B3rnD2Z1J9A3aQD7qgE7ny/nl7YWYhDDKZiuifKfCV4ShSnzlv48ERd23IAMyg1RGrjDiJVC2r1NuGVVmEL9J/9hE43Wa6KyRsuoXDt1SR8erOlPGEtT3CNH19cHgKz9bTaRf2qdx0YfZ80GW7qx6QRx130ajB8eH/60eAS1MyHe4p07v+A928BRKz4JkRvuM6J+pSzq6/3NtOM6p3mtoEmyuQ0aJlgYffEQGQInU6tReyv7/f5sPuQdJWlITy6apCDe5hStOju7C3gbbhyN3MDglZWntFL7qlH2ZLLXca7ub/RqsDnQEIezTY4nrD06V3IVWRu4YLz7YquAXguDFdIkVch2ZT7EDhc3tcvG88WtJ4hbg5+RtOctZgjhf3AS3QNMZ6TlQDWo+nAcMPSaHomJNeOq2wSATjq/ZhXPD+gvruOqZf0d8rfA21ktOwlk2A+7Yd/o+0P5n0xZsDiCsqu6ef7DEKOGkm8EhOXVTXD9eXinFc/+z6UUVDTu8j9pLLEPGxRAiwdODjRUDlTbOH9ozlUk9ol4fy+8TLPa1fvqppmWegFUVH26U/QFk3XZbWAst8DW3QVJdzW6wsTfOrtmu+B2nlloiDuJzq3RkM9RT3vNdsxG4zURF23IZt6E34Oap3INbjShmF4B1IAoFBN8XDkkLlZN0LyL7fSveSvj8m7AbPvKoGTqa97oPpAWWuN6NyqX2OqtHj2l4yC5Npkn0e8TbKEsWk5jRECc02jkik83n0Nhi6qQ+2Z/ifR3ofBPUpBNhoYAcYUBtRtpKWFHT6V8CKShLe3nH0wK91sfS0WmhE61feHj5+fwv+l5THuoskfqIhRyGpA5HJ9jnpUgtlFlk7c72hO+Wjs/NsYCQNWGuy7oJDnCMqUMhMZjVjyXJPhWV80ObIwLTecXEBpaeKIVijpT3rdAw+VFZRmPoaPdEnm6nkLPzTgSusIhYdBmarlSShSwOa803FIpd2IWJSWnqmwcDE83ZNsdYGlEo5M2QsKQHjFXy9lfTXDSb5j6eK1eb3m6hxKqXwjEoTHWPs2GLu0XolPSWpFk7WbuE0W9RNSrNVFbm7mcjQ1cSS+CKDvZZSr3Lk+62dzmzD/MPZLCynt1GvbLz7HkmObIpCsfMlajylzWyXDg1wDdGsCnxGeKu9IX1hIvnOhLYqS9CLoGJcJaCnpRY9/qw6n0op8fkCLp7Sp9cKzEKDG1Juv34j/ZsJmKNvnHqoRpgnd2EKApIxxpaaRZ1wX3b8YPpdNDxVZ+RxkEBoHqjbR5UwMHaVOxfmD3lLT4DNk1N9qSRpbMdb+zrwxIWDRGvb4w/BIG69dVx3meTcjfm2T7963lllykivnfhNYkMe2NnB5uqOgzkuB90g5qr+L1vH9Qyn4z0HTQVYPAZfu/Hp/R5tkJIrapGsnmuHywpd70EQ3a5L+iIyt02RnR0h9rf1vgUD1kP8jUe9YqhKfI73kkWlb0cIVTTPZhf5TiyiUNkM01Tk0EfCFttNrkliC9BT2ZCi0Syo2bceo05/mknFeH5T9h0FhoiNf3XVUNMIoQfU+TMHjsTxVkDXbiUw9KfqF8SRJcx5eQLKyewYGLf295tdwaFoU7HQCTXWIJn5wP9vlIaqK/rphNGjegHtZZjZH3e4jRXA9WfyABpvPybjkGKN9ORzA80zn07lo4E6hQ62S6coAgjut2p6TmwaCJHBMhNfTHszuOhoMp9FZiEbFNv/np/TGWtKpaqR/PBKL6tu21yVEvY8KIclYcgi2JjlY1f++/BBes8DYyEgpExlyA08Ivu2eZuRbYIOASZCvw3yFlUnGX1rOkDFiaYv9ooqlVwriqDJcCWIbRgq8OuB246er3qYcTGYkKtJxdSueM5UQQT7uTn11VZdReUeoDRCsSWqgaJlKsFIa8wIpKgjy9Ik22+eQWt3G4veGS+19p4DJzMoZfhsLaVqdZQeCD9LpAHpPWwxARScoke09sw2j9cGVJl1tJPB3bz2HK0QLAuqWSEsUUNB9KSshDY9pNpat/EYQP1YLZ0I7pnF7sTHvHPNT4NUo72Plh4fN65PlacxG08y/lxbERfsbWXK9THwawuVGTyJjtT/qAdWo4t/e8dTRgf83iQUDFqDnF2XaM+SxT24kgyiD7mBscf++eE8AHZ3L/2fbI+j1oxIPlRVHDinCLpQYAldsAp8v05GSPZ2qu6VK8Ct5hTCS4XsZ2vnMiB98JYqyn8PCaMw400eO6BjqJdvcuKbziWEruajtsxgd6jWn5ODotkEMjqZw6gIuyxSs+ORsIVAGZvx0TfmC6kQdjbAohed4OQoMA+dwZs1tHU7dhuJtmKTc16YB102heWFsYn35y1JCFsPse0xSoceDMcNvLCuxDid0PqmETcn85vh4/jeZ4hQGVOkzaK4s1r5H2AwncEzMrUxuX2fVDBnMkI59oRLdqcVev2daKpWhGTKf+rSwyhSS9A7jKwRUx5oo+sZ/aSvSc3RI3zuhnweG0E5+H6ETogA+yQQ5aoIswQxY483+4XwVlHl5RxI2Mh5H6wYbQoHqFCYkdO6f0ZGprQJ/dnAXgA06RkOJtjr47UmHJOfrbgFrjDwTn9FKjmNapiX+Ty5fIkNcLSnKLjlShXTkw05R1I4NoQ1eyqDnbLeybUHRwuQQo7CXvy3C7Uc9HfZZs9TZheD8QR/GO4SlxvUDhrRniZNa6UXoNKZ2XkcJhLXJUfHvqzl72IJLExbAlD6VsyXe5gJTJ1aXkTiRCGBGkbjlCAdvyiB/TQbkai8gqjafmLlhNXarwbWjVtIrYDKjpFoyWp4Tojohdv6pSyfrNYEdKlW8dS+iY+cUGZkQLtZDhCzkRtrGjgI9l3cpVGjwZgHLmG6r2016TO25PDuxkvjytuY5CYNvkmzRprS6kuwcpRyhFwAs1JGe0ZoR0KAHoNBRjmYd6XPJTl7snbO6qFLKaNu3jg5GR9sEtylcUb1+nwvmKqyqwnj16+yNPj9TX/6hsiLf0vznS/CSvWuskKR7NZXkBW4wNfphPL3tjLnibEhpkXSkb5Pg08ck0+zjUoJwgQlSaw0XNMPG7CtnNRXRrguD1TbliwiR0fiFR104jNmSKj1qDC6gvq0gP9BJwiWXWdy9Abumqyk8SW+AgazCnEE428tSkvIjS7vEH8ZE0MW9b+peaFPYcUDuqQYG8Cf7Axde+qRJtBWyUl5yY+YYlTX6MHrya0alrba5gmJ3hcCDWgRDO+kgGItwp5mZ6cW17PlNUZhw93XqWlDgFIc+3Q4HAVs8/fPRkZZ1LtkseE5iyPVv/kSmrW8IRPfhpC2M9ij3brCK6fnQioCtl3wNPHFXhEUF0e+yz04rhlKTyzaQvYhyD5ICuPnV4r78kET0Vhs0bsXNfwPSS1NXfwXU0mG+Gq6mtPt21L8afZKHS1mOsFvDUjTUhSzCX27wkkG7K60m6SS8jZ24yb7PfgvAwbhKqkf59ptLNbp/Dq18kRlXzYiG2EHCw7EZRK/pdYDAdgW/MXEZid/B9OCYyf/+MgXfSlCL8KXwXBv/iASS79xMAqZbUHto9bXuiZvUksh90S7Ke7jijTFMXd8Jft0su2QD/6WAI8iKnWWJyKDonbCAkJNAn3E+J9fFyl81kGwqZJPZ4B7BHYamgCbq+WiWvialyVSo5K3RC8MXkiIOo+JAnCpxWVBp4E2a4wa167wywOFUt2ygQco9187H4DgE6prU0MAG8o+R4EnCPIz26jYUEkMXfA9srvLMUyvCJCInDM6vuCwLFeWKfYAE92F3Tpt15gwrWqrU2bJuv/KBCeAhDFM0uqb6zlarz6FKogKUrTHUNfK2nmHMd2ZAoomAjwna3iemxnGLt2t06Z/l0cKEnlchnDCJeQc+1AMuWm3CYvxbaY+CwQXNYJ72SJUG0e8+Inw8KfUOHv+YxdhNObqOyp/bEN+A1Hlwv910cSSGRPzJcGtDvtYUwonzo/pnxvHZWdndTTO/mZymlbDpDivOpgxndgVVx3s0t6yzZp2ipIwPPxqGnM42xo2z1FicClvdO2A80zuF7iuN14kt9/cCNorD29CtlOMy2f09UL+j6x4tToxCApDOs/vK6+B7WnRRpzMiWdr+LBzHUoyWKxFEZJ3Tw2hrmSfqQMNMjy/YJvULIDutahJPCCw64/0Sl+ml75s3477cy5/iPEGa/hjgZJfo3YEK8gmm4OWl9dt+/jD/yvrpP2OWnVhqLg/LXNGs6I8Gw83iLZxXrCgCIWwaT+phsoX/HJY/SjQImB4ZaBnXPHl5ilC5YND5Ns8K4O0OPZeO7uiGWjUYuXrJQtfIexMGAmAujX0j07D5ZBto7fMqZWeisPZ7hjjlDQhy7SXO5MBa49Efb8Oy8bfSacAUjzB5yotzmWWxzj/8WURbhHT6KKRSH3hQdCfubTU0PM6Xwbgrpmhs6WVfvm71O+eP9gX2GrfrsUfpdS4AryKZ6SGtvJT9oyRhqIDvgUT4cqys40JL+6+HrmPccFin47KBZDFcu4aRNl549Ondc24WgpFM2QjgzVtNPJA+DMN3U0gF4DWwcYOKbMZ7P/VI+Its6X6VruQcleuK5ekjpPmJGBy9onRKpjz2E4SrPD3dosgjA7bmz48d7qfcAlcWDbvjvDUX8XgU4jWDXlghfA/4xHXWcytawHBpdnEI/gyPNYPihbSmp+u0gcUqLyZPJzQDCAhZfcPNCZ7YMDb+JVqAhmHTJBm8tAHCyqWFySegUxoECkx3wBuSKkkSJrA3mcWgF4+Jzs0Jzj/OMqAqvvYJ8kP0P8oRT/1O9NVYLodHzwgjI9V6QK+KTuopdCCz0OAySRoCSiQJLEdAgeUmH6dVSbySP6y6qnRgYuNIYa/3Fe+PMp0lITwPzIwFU1E6+sXt48V73zCkpxjM8l3eGNOJpytPg5LVzpQYKml896mn+CoxeCtooKWcPsJriRN1BeRQtg4XRiH77tdmb8iX/T7EYH3mL5EYqai6OAfd2PcGOiMNpYctNY4OkIaPsldAZpYpco64yphT6a3lvk/IUhA6nSMUPd60bBPxMUNUV85EKwr0+VzQ5fCLgWBl795TLaenr+/svUum43uHeVjwSGbiRo9eQv5ecQfvZD1D1Kf130Q5xfj0b7dj/BLuwSV78leCjZA8VVmxzdcG7M/ZdYNaff16UXw9JqFwZjyrS7gRjnzlX05AAF1Vq0F0xS/wHpEsDOQnWEcoG+6mfbrCexVdvPsqMvZLzFvToaDx+qRpvZ3TOr6ut1W0ANy6Bm+kjdLzqGUsYrWnj7XrcGWrKLbN28DZ8ZQoiQNEFqvLJmQkl/gdd1cBIs0K5zvzCH39IR6M/imqivQy/B19shfvh/FGRm3km6lP88mUuN/qwdW9M6BLMOBh+onHajWSmL13S+VWHNcTP8PFPeDCxDs+8xc7zkI1CqNliW1DFUVandexdJ+oWsQVSbP8HnPhArPMlMOvxuQkqNGZf2cqOtAXNMIv3CWCj1Z3vm3kQ2g7IVc1R6Vnr5Pwh54xc+ATlUpVFgkXWY3WA9kOCOicDdnIPCNJdNMw984hKH1UCsGmiBX/O3x/Jhn0BS8Ix3AGsdrS7hXm/4Dpz0lxlFGd1ZLYMePC4Jhhdd4OFkff/xjYVXvqQRDt8ChMD7jk4Zj+XyGN61YuojAfGy996W5PFEnpNVGJtm5ZeXuBqMcAWPcJxB8kM15xLXcRvUf8VKXWYvr5CA/bhUBOiiXxxPVNEJlPHXvPNhXfcSwj2kDb0eP0JBYZsX0V5Sy1L88TleFsxk8jbj3VCr9YNToszLG/28++dUTio67/iOZhHWbucoLFjNUQ9m0/1bvLjm2BvpZlgPIw+Z63ueovel//4f5090+zzECt+Mid3G0YVD6l4/bpgxRwjWhCSl6h0UHpdAoJQC6nhlOPxGggoF4a81Csz2h/TUHpZRZhcfOBYV0QnfUHmgOJVUPlsYund0CB4BK/EMf+wDFr/8a8YqQUfEPaxdcKPmx2gO056Yf+eaDl1VIeLJtAN8E5K6wysGbNaOAXz9E7s+OIeXJXfZLnX4hgG0S2gikagirq6h/mtRqMjJgDmO/Of4C5LFi3uLDI6orcrcHjbXaNAyRVqAXt7VzaP/ec+qESQFInjCCDEVh9t18Sh2JpiEWG6JwlLNzkB1q3ydxWKF6ufIh8ijAhM0yHBtD03yAd3OmpvGGHCg+Iwukf9C9HkYR+vIYDb0WJ5v159DpYcuQfvA22V84B1fPONDzvqlHnXKKh+Jj77ni9LY+x20tcFcGz7oV1gF52Tv5FxLhb/x+o8vlXSHwywfCOS/enMMi4k+W5cdP2NQiaVecEwsmKL7VKBBz6lYLd/EgbA+HUygw5+zWsvUsJ5DmUAa3VNT7pbpa6Kcbdrce2FVYOC7fFhA3OV5pJME62UtZQDXok/gKb3oOtgbQ2ygt9fr/boAEyITqOAUs9VgY/6e0dwmLRK4V3Ew79phymHizs9SUhNxJt5/Faz51SK1PHWWxiielfexZqmI+bacLFLfgzGO4ImWGcW3OUyd2//ck3JNv/kYMIgLGI5YhtsVhAq2oHOalq3OV2yAUvN0801xc14vMTJ0xWLYeRMupUqodfR+hRuDRYllroHxOAgcqo5XkY5WIbnhXWUbofytWdUVGV7/uoyA+GTg9YzS07mZBZR54UIQlrm/5OORdvTsv3SuSI96plwGgeT60/+4SJCAVPiaBqtd73R7ydeAikPj4dhY+ZiY1B7EZ3V6/WVCuTo7Q2/N3m0rOhankuHLzJhJLNBjPyFjn3Cmh4OTKa6Sy6piBjBlkOcn4gfYOy49mDqqB/ywoh3/VD4FiaFXoga+TdPWbpdcrGZbsgEUPfZlvMuSz0PHofOqsUD78IDvAiuwHyQhx2k+DNnF2OLJKKatFmL5NKJwG0p011mJ4ZI/RtQXTGuqycscFuygEqL7ajJRhYSLxQRObgXICGQAuEw1JjTMBIXKHXy6bnzaVue/hksYQ4uBJYluWgCNiHSmffvEqvJiF981oNpv9yJerWr2qxs/Vs32Gt47pJrFBfEu9GpbBXsZF9SsZRBPmWobmIQ8EeAm/F4YwbhQKVPcN1j57Oj6C9nsm5bqmm2rA3e/NfNdBIH+li+Olt2lgtuvQYKquGDKkWrz8OucUf10ePvS7sKjfP82JNHiIasK4RNlAj4pRi+ZitX9dJeso6IVjYdHgydh1KYEf06wSXfqvMxB6oNpQPfuo1GERUQXkM0gHisdUMBXYAuvUTRIP3TUvcjiL7Ar9Pg5Kl+4TLAeILAHcYfpgooQ4pdmyIsRVz7HN0pnSemkgxxEYdTP5hKZRap57j5pWvT+cpMIc8bE/7QeYBGBsU4yRuiXE7nFr+ZBr4xXow2F3HaMzvVh6HAMBMcZUjO3nPZ2YuvG88rvLvYyL0QBrNajr7YmushY2HcpRCqRU3Ye1WX4jIvCI2tefrrGf3vZiQEULEJBrZBrhsDX6g3NTWek770jQe5G2mb6k/n75H6MXMH/2iR4Yl+TNAoxvsvtbiI3bymfEHQnzeKYyEhf9h364BvwvC6nQ9AfaK8n/PRnobinedNADShhJsS4KGvDThxpdpNGmmaRt36ONjZ+TYbuf51pPVRK+HA2Q+h+PgNinrNPGg0WDvn41PkfaoeqZIn63XXQGHarbAtKIGYzeBfXzTYNVH0ykOFE5On0Zpna0B7Z8PIV51zVtoRC3dAMxWpNA1Bn/Tnsc4x69RHiL3qGQDWOiMUtIHFOWMDLeGsrlNqPsgWF2oIUpKcc/inzze+x4CR+Ii7JkTdwkw8I9mTL0fRHbuDbqbCDWXVNMY7b+xGVsY3Nx1Zg7YCfNSe3KYla5S4Ngk93xPbKMr3VF10IEYhEdusfagId+hN3i4jp2hXT0yGmqi3/kzNizxR9Y5MnOm+Gh14wo96a8yJPCyVlP0mJt4gmcSvPZFDWKM+k2ilQa3tfP3WA/2p8elGQ9VywW/d4s4nRlSH3li0UYWX0dn7v48o4BAFKWT/eJiifZPIQPGEgjjW/BgMbs1UUktKNLCqcstuiAJFFT8nhpb/TrqNSixj3uKNy/L4BjKUGc4JglB99TkBFD7mVv8hkxIMu+M3smrWYIHM8DK0x0ATh3vMQ1PlCJNo0oqBfAzaEDCw5QlFmwwSYIJAPyJ46OzMu0L3iYV0LUgZxgDAPyvDbVgajgk8D+JmMT7krwzMXl1vkbX650Sk3Qnf8fYq3HU6K5yjWAqEXOKCq/bRg7G1eKKJu17vV4w2yRvQH7IyHPX4dihrTqRT5XPIzltTguKFa2NALDRq6fckKWm4U7GWEFU1TMLPiI8uxhRwr5MTaaS7P4BliCEPlpFuWf+vd906X2ZPIQCRMbpVvp7I910C4GHZC9AVMY2uDuA4Yi+aOVZnenb9WNuz8CGgDyvD/m/Abw+Cffrl1kDAc7ZXGf3WDLIVyLgYri0RDSdGXuunALuDb/PZBqavauIxIP1LSK3VIncaGzZP52XTXSnd4yAn4BnDQPVZGQ8a8GJSBJrfL9Quwf2ObMOUYQl+wd8Eu5/q8qkoN70W4dtAWTcr77PLvKgVHI3pdffANUA3GkiXAbqJ3k0tdgWqJmEpslz5YYZxtmY1iUZzHxoYZJgLBaawq5bzIYGnGcNyZygRMtFf95fMcTl3P7gpKWzQxwtHddKW37LyPr9Q27tlcz0CLthDpo3QV0zyLaCl+xlYeI+8XDQ7c5pkBJvUTy7iOA/fFyo6I6oYiv0ms8tcLoWFnXq/SHJSPLF7D1vVMlOQdGCfalSnkUIO4Q0gKWtih9qY/1gybUxJuBAZgPqWC/x+b7E4MaU6IbXSzMg2UUT5wmEGiD7aiKcLcTbWjzfMMqrENOf4NNUDI4zOefTpg2D6uPTeKtT/dG2qbJAMfBEXpeEwL4XpPEIC9xRy6bZ8/SFlGz/m2qKlUD3Umx5e3H3djhKlXzx4O8rCdmTESQ2w17a+kVzbuYTnOlqJMIcs0r+KTXbRsoHxeJi0bwmQxAbxcGIt/bDvwBl/08RF0PKE0z57p1OD6EDayj1aBfIWQ9cydNo6wFzPt9aPmsh4BxCIWYalSpB2ODiKXF0b0lnVhvWrUhsmBEhLZf+v4SGR+5SCutgTDl38AYWm9Oj7CcskYp/n+0iDfuB3CdGTVqutHx0EW8HCMTfiVv1Mkz1DepHDgDfwZDS/hj1968J5nmAsNwwijN0ebZc+51k8d7x69ycDuobWZmlKFNYxMca5137Si1GvB6YQBNQhlFkuLqF4tjV82r1wofFc4ZSiNAKx5sc9Dp4TkgfnbSmV70v2GXrZXV7yvW0Jicfqo2pLL98KrVhOH4zmYIFCc0k4JN5F6PGeoil9UAlA4QVu1k1IPwD0rEHOQ/U=
-- CEETOS_RELEASE_PAYLOAD_BEGIN
-- CeetOS installer. Generated; do not edit.
local files = {
  ["startup.lua"] = "local pendingPath,releasePath=\"/ceetos-updates/pending.lua\",\"/ceetos-updates/release.lua\"local pending if fs.exists(pendingPath)then local loader=loadfile(pendingPath)if loader then local ok,value=pcall(loader)if ok and type(value)==\"table\"then pending=value end end end if pending and pending.state==\"apply\"and fs.exists(releasePath)then shell.run(releasePath,\"--ceetos-apply\")elseif fs.exists(\"/ceetos/startup.lua\")then shell.run(\"/ceetos/startup.lua\")else shell.run(\"shell\")end",
  ["ceetos/startup.lua"] = "local root=\"/ceetos\"local profile={id=\"desktop\"}if fs.exists(root..\"/profile.lua\")then local loader=loadfile(root..\"/profile.lua\")if loader then local ok,value=pcall(loader);if ok and type(value)==\"table\"then profile=value end end end if profile.id~=\"desktop\"and fs.exists(root..\"/server.lua\")then shell.run(root..\"/server.lua\")elseif fs.exists(root..\"/ceet.lua\")then shell.run(root..\"/ceet.lua\")else printError(\"CeetOS is incomplete; starting CraftOS shell.\")shell.run(\"shell\")end",
  ["ceetos/profile.lua"] = "return {schema=1,id=\"auth-server\"}",
  ["ceetos/lib/store.lua"] = "local M={}local cache={}local function internalPath(path)return type(path)~=\"string\"or path:sub(-4)==\".new\"or path:sub(-4)==\".bak\"end local function call(fn,...)local result={pcall(fn,...)}if not result[1]then return false,tostring(result[2])end if result[2]==false then return false,tostring(result[3]or\"operation failed\")end return true,result[2],result[3]end local function exists(path)local ok,value=call(fs.exists,path)return ok and value==true end local function remove(path)if not exists(path)then return true end local ok,err=call(fs.delete,path)return ok,err end local function ensureDirectory(path)local dir=fs.getDir(path)if dir==\"\"or exists(dir)then return true end local ok,err=call(fs.makeDir,dir)return ok,err end local function readRaw(path)local ok,handleOrErr=call(fs.open,path,\"r\")if not ok or not handleOrErr then return false,nil,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local readOk,content=call(handle.readAll)local closeOk,closeErr=call(handle.close)if not readOk then return false,nil,content end if not closeOk then return false,nil,closeErr end return true,content end local function writeRaw(path,content)local ok,handleOrErr=call(fs.open,path,\"w\")if not ok or not handleOrErr then return false,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local writeOk,writeErr=call(handle.write,content)local closeOk,closeErr=call(handle.close)if not writeOk then return false,writeErr end if not closeOk then return false,closeErr end return true end local function move(source,destination)local ok,err=call(fs.move,source,destination)return ok,err end local function decode(raw)local ok,value=pcall(textutils.unserialise,raw)if not ok or value==nil then return false,nil,\"invalid serialised value\"end return true,value end local function readValue(path)local ok,raw,err=readRaw(path)if not ok then return false,nil,err end return decode(raw)end local function recoverValue(path)local activeOk,activeValue=false,nil if exists(path)then activeOk,activeValue=readValue(path)end if activeOk then remove(path..\".new\")remove(path..\".bak\")return true,activeValue end local backupOk,backupValue=false,nil if exists(path..\".bak\")then backupOk,backupValue=readValue(path..\".bak\")end if backupOk then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,backupValue end remove(path..\".new\")return false,nil end local function validLines(raw)for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local ok,value=pcall(textutils.unserialise,line)if not ok or value==nil then return false,\"invalid appended value\"end end end return true end local function recoverAppend(path)if exists(path)then local activeOk,raw=readRaw(path)if activeOk then local valid=validLines(raw)if valid then remove(path..\".new\")remove(path..\".bak\")return true,raw end end end if exists(path..\".bak\")then local backupOk,raw=readRaw(path..\".bak\")if backupOk and validLines(raw)then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,raw end end remove(path..\".new\")return false,\"no valid appended value\"end local function commitRaw(path,raw,validator)local dirOk,dirErr=ensureDirectory(path)if not dirOk then return false,dirErr end local temporary,backup=path..\".new\",path..\".bak\"local removeOk,removeErr=remove(temporary)if not removeOk then return false,removeErr end local writeOk,writeErr=writeRaw(temporary,raw)if not writeOk then remove(temporary);return false,writeErr end local checkOk,checkedRaw,checkErr=readRaw(temporary)if not checkOk then remove(temporary);return false,checkErr end local valid,validErr=validator(checkedRaw)if not valid then remove(temporary);return false,validErr or\"temporary validation failed\"end local backupRemoveOk,backupRemoveErr=remove(backup)if not backupRemoveOk then remove(temporary);return false,backupRemoveErr end if exists(path)then local backupOk,backupErr=move(path,backup)if not backupOk then remove(temporary);return false,backupErr end local activateOk,activateErr=move(temporary,path)if not activateOk then if not exists(path)then move(backup,path)end remove(temporary)return false,activateErr end else local activateOk,activateErr=move(temporary,path)if not activateOk then remove(temporary);return false,activateErr end end return true end function M.readCached(path,fallback)if internalPath(path)then return fallback end local entry=cache[path]if entry~=nil then return entry.value end return M.readFresh(path,fallback)end function M.readFresh(path,fallback)if internalPath(path)then return fallback end local ok,value=recoverValue(path)if not ok then value=fallback end cache[path]={value=value}return value end function M.read(path,fallback)return M.readCached(path,fallback)end function M.writeAtomic(path,value)if internalPath(path)then return false,\"cannot write store temporary or backup path\"end if value==nil then return false,\"cannot store nil\"end local serialisedOk,raw=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(raw)~=\"string\"then return false,tostring(raw or\"could not serialise value\")end local valid=decode(raw)if not valid then return false,\"could not validate serialised value\"end recoverValue(path)local ok,err=commitRaw(path,raw,decode)if ok then cache[path]={value=value}end return ok,err end function M.write(path,value)return M.writeAtomic(path,value)end function M.append(path,value,limits)if internalPath(path)then return false,\"cannot append to store temporary or backup path\"end if value==nil then return false,\"cannot append nil\"end local serialisedOk,line=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(line)~=\"string\"then return false,tostring(line or\"could not serialise value\")end local valid=validLines(line..\"\\n\")if not valid then return false,\"could not validate appended value\"end local recovered,current=recoverAppend(path)if not recovered then if exists(path)or exists(path..\".bak\")then return false,current end current=\"\"end local lines={}for existing in(current..\"\\n\"):gmatch(\"(.-)\\n\")do if existing~=\"\"then lines[#lines+1]=existing end end lines[#lines+1]=line local maxEntries=limits and tonumber(limits.maxEntries)local maxBytes=limits and tonumber(limits.maxBytes)if maxEntries then maxEntries=math.max(1,math.floor(maxEntries))end if maxBytes then maxBytes=math.max(1,math.floor(maxBytes))end while maxEntries and#lines>maxEntries do table.remove(lines,1)end local raw=table.concat(lines,\"\\n\")if#raw>0 then raw=raw..\"\\n\"end while maxBytes and#raw>maxBytes and#lines>1 do table.remove(lines,1)raw=table.concat(lines,\"\\n\")..\"\\n\"end if maxBytes and#raw>maxBytes then return false,\"appended value exceeds byte limit\"end local ok,err=commitRaw(path,raw,validLines)if ok then cache[path]=nil end return ok,err end function M.readAppend(path)if internalPath(path)then return\"\"end local ok,raw=recoverAppend(path)return ok and raw or\"\"end function M.invalidate(path)cache[path]=nil end return M",
  ["ceetos/lib/profile.lua"] = "local store=require(\"ceetos.lib.store\")local M={}M.PATH=\"/ceetos/profile.lua\"M.IDS={desktop=true,[\"recipe-server\"]=true,[\"router-server\"]=true,[\"auth-server\"]=true}local cache local function normalise(value)if type(value)~=\"table\"then value={}end local id=tostring(value.id or value.profile or\"desktop\")if not M.IDS[id]then id=\"desktop\"end return{schema=1,id=id,installedAt=tonumber(value.installedAt)or 0}end function M.current()if not cache then cache=normalise(store.read(M.PATH,{id=\"desktop\"}))end return cache end function M.id()return M.current().id end function M.is(id)return M.id()==id end function M.isServer()return M.id()~=\"desktop\"end function M.set(id)assert(M.IDS[id],\"invalid CeetOS profile\")cache={schema=1,id=id,installedAt=os.epoch(\"utc\")}return store.write(M.PATH,cache)end function M.capability(name)local id=M.id()local tableFor={desktop={desktop=true,craftingClient=true,orders=true},[\"recipe-server\"]={server=true,recipes=true,recipeImport=true,recipePlan=true},[\"router-server\"]={server=true,routing=true},[\"auth-server\"]={server=true,authAuthority=true},}return tableFor[id][name]==true end return M",
  ["ceetos/lib/auth.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local audit=require(\"ceetos.lib.audit\")local M={current=nil}local USERS=\"/ceetos/data/users.lua\"local SESSION=\"/ceetos/data/session.lua\"local TOMBSTONES=\"/ceetos/data/user-tombstones.lua\"local THROTTLE=\"/ceetos/data/login-throttle.lua\"local RECOVERY=\"/ceetos/data/recovery.lua\"local AUTHORITY=\"/ceetos/data/auth-authority.lua\"local CENTRAL_SESSION=\"/ceetos/data/auth-session.lua\"local DIRECTORY=\"/ceetos/data/auth-directory.lua\"local rank={viewer=1,operator=2,admin=3}M.SESSION_TTL_MS=8*60*60*1000 M.LOGIN_THROTTLE={failures=5,windowMs=5*60*1000,lockMs=60*1000,maxEntries=64}local configuredWorkFactor=password.DEFAULT_WORK_FACTOR local sessionPathDelete local function now()return os.epoch(\"utc\")end local function accountName(name)return type(name)==\"string\"and name:match(\"^[%w_%-]+$\")and#name<=32 end local function users()store.invalidate(USERS);return store.read(USERS,{})end local function save(value)return store.write(USERS,value)end local function tombstones()store.invalidate(TOMBSTONES);return store.read(TOMBSTONES,{})end local function saveTombstones(value)return store.write(TOMBSTONES,value)end local function authority()store.invalidate(AUTHORITY)local value=store.read(AUTHORITY,nil)return type(value)==\"table\"and value.active==true and type(value.id)==\"string\"and value or nil end function M.authority()return authority()end function M.centralActive()return authority()~=nil end local function centralDirectory()store.invalidate(DIRECTORY)local value=store.read(DIRECTORY,{})return type(value)==\"table\"and type(value.users)==\"table\"and value or{users={}}end function M.acceptAuthority(record)assert(type(record)==\"table\"and type(record.id)==\"string\"and#record.id<=64,\"invalid auth authority\")local public={schema=1,active=true,id=record.id,term=math.max(0,math.floor(tonumber(record.term)or 0)),revision=math.max(0,math.floor(tonumber(record.revision)or 0)),seen=now()}assert(store.write(AUTHORITY,public),\"could not save auth authority\")if type(record.directory)==\"table\"then assert(store.write(DIRECTORY,{schema=1,revision=public.revision,users=record.directory}),\"could not save account directory\")end local loaded,profile=pcall(require,\"ceetos.lib.profile\")if not loaded or not profile.is(\"auth-server\")then if fs.exists(USERS)then fs.delete(USERS)end if fs.exists(TOMBSTONES)then fs.delete(TOMBSTONES)end sessionPathDelete()end return public end function M.updateDirectory(directory,revision)if type(directory)~=\"table\"then return false,\"invalid account directory\"end return store.write(DIRECTORY,{schema=1,revision=math.max(0,math.floor(tonumber(revision)or 0)),users=directory})end function M.saveCentralSession(value)if type(value)~=\"table\"or not accountName(value.name)or type(value.role)~=\"string\"then return false,\"invalid central session\"end local session={sessionVersion=3,name=value.name,role=value.role,token=value.token,issued=value.issued,expires=value.expires,accountRevision=value.accountRevision,authority=value.authority}if type(session.token)~=\"string\"or#session.token<16 then return false,\"invalid central session token\"end store.write(CENTRAL_SESSION,session)M.current=nil return true end local function safeAudit(action,detail)pcall(audit.log,\"auth\",action,detail or{})end local function stamp(account)account.updated=now()account.origin=tostring(os.getComputerID())account.revision=math.max(0,math.floor(tonumber(account.revision)or 0))+1 return account end local function makeAccount(role,plainPassword,context)local record,err=password.record(plainPassword,password.newSalt(context),configuredWorkFactor)assert(record,err)record.role=role return stamp(record)end sessionPathDelete=function()if fs.exists(SESSION)then fs.delete(SESSION)end store.invalidate(SESSION)end local function saveSession()if M.current==nil then sessionPathDelete();return end local durable={sessionVersion=2,name=M.current.name,nonce=M.current.nonce,issued=M.current.issued,expires=M.current.expires,accountRevision=M.current.accountRevision,}store.write(SESSION,durable)end local function makeSession(name,account)local issued=now()M.current={name=name,role=account.role,nonce=password.newSalt(\"session:\"..name),issued=issued,expires=issued+M.SESSION_TTL_MS,accountRevision=tonumber(account.revision)or 0,}saveSession()return M.current end local function liveAccount(name)local all=users()return all[name],all end local function normaliseSession(saved,account)if type(saved)~=\"table\"or not account or account.disabled then return nil end if saved.sessionVersion==2 then local issued,expires,revision=tonumber(saved.issued),tonumber(saved.expires),tonumber(saved.accountRevision)if type(saved.nonce)~=\"string\"or#saved.nonce<16 or not issued or not expires or not revision then return nil end if expires<=now()or revision~=(tonumber(account.revision)or 0)then return nil end return{name=saved.name,role=account.role,nonce=saved.nonce,issued=issued,expires=expires,accountRevision=revision}end if saved.sessionVersion==nil and type(saved.role)==\"string\"then return\"legacy\"end return nil end function M.refreshSession()local central=authority()if central then store.invalidate(CENTRAL_SESSION)local saved=store.read(CENTRAL_SESSION,nil)local entry=type(saved)==\"table\"and centralDirectory().users[saved.name]or nil if type(saved)~=\"table\"or saved.sessionVersion~=3 or saved.authority~=central.id or type(saved.token)~=\"string\"or(tonumber(saved.expires)or 0)<=now()or type(entry)~=\"table\"or entry.disabled==true or saved.accountRevision~=entry.revision then M.current=nil if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end return nil end M.current={name=saved.name,role=entry.role,nonce=saved.token,issued=saved.issued,expires=saved.expires,accountRevision=saved.accountRevision,authority=central.id,central=true}return M.current end store.invalidate(SESSION)local saved=store.read(SESSION,nil)if type(saved)~=\"table\"or not accountName(saved.name)then M.current=nil;return nil end local account=liveAccount(saved.name)local session=normaliseSession(saved,account)if session==\"legacy\"then return makeSession(saved.name,account)end if not session then M.current=nil sessionPathDelete()return nil end M.current=session return M.current end local function throttleState()store.invalidate(THROTTLE)local data=store.read(THROTTLE,{})return type(data)==\"table\"and data or{}end local function saveThrottle(data)local entries={}for name,entry in pairs(data)do if accountName(name)and type(entry)==\"table\"and type(entry.last)==\"number\"then entries[#entries+1]={name=name,last=entry.last}end end table.sort(entries,function(a,b)return a.last>b.last end)local kept={}for index,entry in ipairs(entries)do if index<=M.LOGIN_THROTTLE.maxEntries then kept[entry.name]=data[entry.name]end end store.write(THROTTLE,kept)end local function locked(name)if not accountName(name)then return false end local entry=throttleState()[name]return entry and(tonumber(entry.lockedUntil)or 0)>now()or false end local function noteFailure(name,reason)if not accountName(name)then return end local data,entry,time=throttleState(),nil,now()entry=data[name]or{failures=0,first=time}if time-(tonumber(entry.first)or 0)>M.LOGIN_THROTTLE.windowMs then entry.failures,entry.first=0,time end entry.failures=math.max(0,math.floor(tonumber(entry.failures)or 0))+1 entry.last=time if entry.failures>=M.LOGIN_THROTTLE.failures then entry.lockedUntil=time+M.LOGIN_THROTTLE.lockMs end data[name]=entry saveThrottle(data)safeAudit(\"login.failure\",{account=name,reason=reason or\"invalid\",throttled=(entry.lockedUntil or 0)>time})end local function clearFailures(name)local data=throttleState()if data[name]~=nil then data[name]=nil;saveThrottle(data)end end function M.throttleStatus(name)local entry=accountName(name)and throttleState()[name]or nil if not entry then return{failures=0,lockedUntil=0}end return{failures=tonumber(entry.failures)or 0,lockedUntil=tonumber(entry.lockedUntil)or 0}end function M.setPasswordWorkFactor(value)local work,err=password.normaliseWorkFactor(value)assert(work,err)configuredWorkFactor=work return work end function M.passwordWorkFactor()return configuredWorkFactor end function M.bootstrap(initialPassword)if authority()then return false end local all=users()if next(all)then return false end local plainPassword=initialPassword if plainPassword==nil then term.write(\"Create CeetOS admin password: \");plainPassword=read(\"*\")end local account=makeAccount(\"admin\",plainPassword,\"admin\")all.admin=account assert(save(all),\"could not save administrator account\")makeSession(\"admin\",account)safeAudit(\"bootstrap\",{account=\"admin\"})return true end function M.login(name,plainPassword)if authority()then local client=require((\"ceetos.lib.auth_client\"))return client.login(name,plainPassword)end if not accountName(name)or type(plainPassword)~=\"string\"then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if locked(name)then safeAudit(\"login.failure\",{account=name,reason=\"throttled\",throttled=true})return false,\"too many failed attempts; try again later\"end local account,all=liveAccount(name)if not account or account.disabled then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end local valid,state=password.verify(account,plainPassword)if not valid then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if state==\"legacy\"then local upgraded=makeAccount(account.role,plainPassword,\"upgrade:\"..name)upgraded.updated=account.updated or upgraded.updated upgraded.origin=account.origin or upgraded.origin upgraded.revision=math.max(tonumber(account.revision)or 0,upgraded.revision)stamp(upgraded)all[name]=upgraded assert(save(all),\"could not upgrade password record\")account=upgraded safeAudit(\"password.upgraded\",{account=name})end clearFailures(name)makeSession(name,account)safeAudit(\"login.success\",{account=name})return true end function M.logout()M.current=nil sessionPathDelete()if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end end function M.add(name,role,plainPassword)if authority()then assert(rank[role]and accountName(name),\"invalid user or role\")local record,err=makeAccount(role,plainPassword,\"central:\"..name)assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"add\",{name=name,role=role,record=record})end M.require(\"operator\")assert(rank[role],\"invalid role\")if role==\"admin\"then M.require(\"admin\")end assert(accountName(name),\"invalid user name\")local all=users()assert(not all[name],\"user exists\")all[name]=makeAccount(role,plainPassword,name)assert(save(all),\"could not save user\")safeAudit(\"user.add\",{account=name,role=role})end local function adminCount(all)local count=0 for _,account in pairs(all)do if account.role==\"admin\"and not account.disabled then count=count+1 end end return count end function M.setRole(name,role)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"role\",{name=name,role=role})end M.require(\"operator\")assert(accountName(name)and rank[role],\"invalid user or role\")local all,account=users(),users()[name]assert(account,\"unknown user\")if role==\"admin\"or account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot change the active account role\")assert(not(account.role==\"admin\"and role~=\"admin\"and adminCount(all)<=1),\"cannot remove the last administrator\")account.role=role stamp(account)all[name]=account assert(save(all),\"could not save account role\")safeAudit(\"user.role\",{account=name,role=role})end function M.setDisabled(name,disabled)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"disable\",{name=name,disabled=disabled==true})end M.require(\"admin\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")assert(not(M.current and M.current.name==name),\"cannot disable the active account\")if disabled then assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot disable the last administrator\")end account.disabled=disabled==true stamp(account)all[name]=account assert(save(all),\"could not save account state\")safeAudit(\"user.disabled\",{account=name,disabled=account.disabled})end function M.remove(name)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"remove\",{name=name})end M.require(\"operator\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot delete the active account\")assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot delete the last administrator\")all[name]=nil local removed=tombstones()removed[name]=now()assert(saveTombstones(removed),\"could not save account tombstone\")assert(save(all),\"could not remove account\")safeAudit(\"user.remove\",{account=name})end local function recoveryActive()store.invalidate(RECOVERY)local recovery=store.read(RECOVERY,{})return type(recovery)==\"table\"and(tonumber(recovery.until_ts)or 0)>now()end local function setPassword(name,plainPassword)assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")local replacement=makeAccount(account.role,plainPassword,\"reset:\"..name)replacement.updated=account.updated or replacement.updated replacement.origin=account.origin or replacement.origin replacement.revision=math.max(tonumber(account.revision)or 0,replacement.revision)replacement.disabled=account.disabled==true stamp(replacement)all[name]=replacement assert(save(all),\"could not save password\")if M.current and M.current.name==name then M.current=nil;sessionPathDelete()end safeAudit(\"password.reset\",{account=name})return true end function M.resetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end if not M.allowed(\"admin\")and not recoveryActive()then error(\"permission denied (requires admin or active recovery window)\",2)end return setPassword(name,plainPassword)end function M.adminResetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end M.require(\"operator\")local account=users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end return setPassword(name,plainPassword)end function M.allowed(role)if not rank[role]then return false end local current=M.refreshSession()return current~=nil and rank[current.role]>=rank[role]end function M.require(role)if not M.allowed(role)then error(\"permission denied (requires \"..tostring(role)..\")\",2)end end function M.list()local out={}local source=authority()and centralDirectory().users or users()for name,account in pairs(source)do out[#out+1]={name=name,role=account.role,disabled=account.disabled==true,revision=account.revision}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.snapshot()if authority()then return{users={},tombstones={},source=tostring(os.getComputerID()),schema=3,central=true}end return M.authoritySnapshot()end function M.authoritySnapshot()local copy={users={},tombstones={},source=tostring(os.getComputerID()),schema=2}for name,account in pairs(users())do copy.users[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=tonumber(account.revision)or 0,disabled=account.disabled==true,updated=account.updated or 0,origin=account.origin or copy.source,}end for name,removed in pairs(tombstones())do copy.tombstones[name]=removed end return copy end local function validIncomingPassword(account)if password.isModern(account)then local work=password.normaliseWorkFactor(account.workFactor)return work~=nil and type(account.verifier)==\"string\"and#account.verifier==64 and account.verifier:match(\"^[0-9a-f]+$\")~=nil end return type(account.salt)==\"string\"and#account.salt>0 and#account.salt<=256 and type(account.verifier)==\"string\"and account.verifier:match(\"^[0-9a-fA-F]+$\")~=nil and#account.verifier==8 end function M.merge(snapshot,authoritySeed)if authority()and authoritySeed~=true then return false,\"distributed account sync is disabled by central authority\"end if type(snapshot)~=\"table\"or type(snapshot.users)~=\"table\"then return false,\"invalid account sync\"end local all,removed,changed=users(),tombstones(),false for name,deletedAt in pairs(snapshot.tombstones or{})do if accountName(name)and type(deletedAt)==\"number\"and deletedAt>(removed[name]or 0)then local localAccount=all[name]if not localAccount or(localAccount.updated or 0)<=deletedAt then all[name],removed[name],changed=nil,deletedAt,true end end end for name,account in pairs(snapshot.users)do if accountName(name)and type(account)==\"table\"and rank[account.role]and validIncomingPassword(account)then local updated=tonumber(account.updated)or 0 local localAccount,incomingOrigin=all[name],tostring(account.origin or snapshot.source or\"\")local localOrigin=localAccount and tostring(localAccount.origin or os.getComputerID())or\"\"local wins=not localAccount or updated>(localAccount.updated or 0)or(updated==(localAccount.updated or 0)and incomingOrigin~=\"\"and incomingOrigin<localOrigin)if(removed[name]==nil or updated>removed[name])and wins then all[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=math.max(0,math.floor(tonumber(account.revision)or 0)),disabled=account.disabled==true,updated=updated,origin=incomingOrigin,}changed=true end end end if changed then assert(save(all),\"could not save account sync\")assert(saveTombstones(removed),\"could not save account tombstones\")M.refreshSession()end return changed end function M.authorityAccount(name)if not accountName(name)then return nil end return users()[name]end function M.authorityDirectory()local out={}for name,account in pairs(users())do out[name]={role=account.role,disabled=account.disabled==true,revision=tonumber(account.revision)or 0}end return out end function M.authorityMutate(action,fields)fields=type(fields)==\"table\"and fields or{}local name=fields.name assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]if action==\"add\"then assert(not account,\"user exists\")assert(rank[fields.role],\"invalid role\")local record=fields.record assert(type(record)==\"table\"and password.isModern(record),\"central account mutation requires a verifier record\")record.role,record.disabled=fields.role,false;all[name]=stamp(record);assert(save(all),\"could not save user\")elseif action==\"role\"then assert(account and rank[fields.role],\"unknown user or invalid role\")if account.role==\"admin\"and fields.role~=\"admin\"then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot demote the last active admin\")end account.role=fields.role;stamp(account);all[name]=account;assert(save(all),\"could not save role\")elseif action==\"disable\"then if account and account.role==\"admin\"and fields.disabled==true then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot disable the last active admin\")end assert(account,\"unknown user\");account.disabled=fields.disabled==true;stamp(account);all[name]=account;assert(save(all),\"could not save user state\")elseif action==\"remove\"then assert(account,\"unknown user\")if account.role==\"admin\"and not account.disabled then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot remove the last active admin\")end all[name]=nil;local removed=tombstones();removed[name]=now();assert(saveTombstones(removed),\"could not save tombstone\");assert(save(all),\"could not remove user\")elseif action==\"reset\"then assert(account,\"unknown user\")local replacement=fields.record assert(type(replacement)==\"table\"and password.isModern(replacement),\"central password reset requires a verifier record\")replacement.role,replacement.disabled=account.role,account.disabled==true;all[name]=stamp(replacement);assert(save(all),\"could not save password\")else error(\"unsupported account mutation\")end safeAudit(\"authority.\"..action,{account=name})return M.authorityDirectory()end M.refreshSession()return M",
  ["ceetos/lib/password.lua"] = "local M={}M.SCHEME=\"pbkdf2-hmac-sha256\"M.PASSWORD_VERSION=2 M.DEFAULT_WORK_FACTOR=256 M.MIN_WORK_FACTOR=64 M.MAX_WORK_FACTOR=2048 M.MIN_LENGTH=8 M.MAX_LENGTH=128 local MOD=4294967296 local band,bor,bxor,bnot=bit32.band,bit32.bor,bit32.bxor,bit32.bnot local rshift,lshift=bit32.rshift,bit32.lshift local unpack=table.unpack or unpack local K={0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,}local initial={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19,}local function add(...)local value=0 for i=1,select(\"#\",...)do value=(value+(select(i,...)or 0))%MOD end return value end local function rrotate(value,amount)if bit32.rrotate then return bit32.rrotate(value,amount)end return bor(rshift(value,amount),lshift(value,32-amount))end local function word(bytes,index)return bytes:byte(index)*16777216+bytes:byte(index+1)*65536+bytes:byte(index+2)*256+bytes:byte(index+3)end local function packWord(value)return string.char(band(rshift(value,24),0xff),band(rshift(value,16),0xff),band(rshift(value,8),0xff),band(value,0xff))end local function sha256Raw(value)local bitLength=#value*8 value=value..string.char(0x80)value=value..string.rep(\"\\0\",(56-(#value%64))%64)value=value..packWord(math.floor(bitLength/MOD))..packWord(bitLength%MOD)local h={unpack(initial)}for offset=1,#value,64 do if#value>16384 and offset>1 and((offset-1)/64)%128==0 and type(sleep)==\"function\"then sleep(0)end local w={}for i=1,16 do w[i]=word(value,offset+(i-1)*4)end for i=17,64 do local x,y=w[i-15],w[i-2]local s0=bxor(rrotate(x,7),rrotate(x,18),rshift(x,3))local s1=bxor(rrotate(y,17),rrotate(y,19),rshift(y,10))w[i]=add(w[i-16],s0,w[i-7],s1)end local a,b,c,d,e,f,g,hh=unpack(h)for i=1,64 do local s1=bxor(rrotate(e,6),rrotate(e,11),rrotate(e,25))local choice=bxor(band(e,f),band(bnot(e),g))local t1=add(hh,s1,choice,K[i],w[i])local s0=bxor(rrotate(a,2),rrotate(a,13),rrotate(a,22))local majority=bxor(band(a,b),band(a,c),band(b,c))local t2=add(s0,majority)hh,g,f,e,d,c,b,a=g,f,e,add(d,t1),c,b,a,add(t1,t2)end h[1],h[2],h[3],h[4]=add(h[1],a),add(h[2],b),add(h[3],c),add(h[4],d)h[5],h[6],h[7],h[8]=add(h[5],e),add(h[6],f),add(h[7],g),add(h[8],hh)end local result={}for i=1,8 do result[i]=packWord(h[i])end return table.concat(result)end local function hmac(key,message)if#key>64 then key=sha256Raw(key)end key=key..string.rep(\"\\0\",64-#key)local inner,outer={},{}for i=1,64 do local byte=key:byte(i)inner[i],outer[i]=string.char(bxor(byte,0x36)),string.char(bxor(byte,0x5c))end return sha256Raw(table.concat(outer)..sha256Raw(table.concat(inner)..message))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function cooperate(round)if round%32~=0 or not(os and os.queueEvent and os.pullEvent)then return end os.queueEvent(\"ceetos_password_yield\")os.pullEvent(\"ceetos_password_yield\")end local function toHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function constantEqual(left,right)if type(left)~=\"string\"or type(right)~=\"string\"then return false end local differing=bxor(#left,#right)local length=math.max(#left,#right)for i=1,length do differing=bor(differing,bxor(left:byte(i)or 0,right:byte(i)or 0))end return differing==0 end function M.hmacSha256(key,message)if type(key)~=\"string\"or type(message)~=\"string\"then return nil,\"HMAC key and message must be strings\"end return toHex(hmac(key,message))end function M.sha256(value)if type(value)~=\"string\"then return nil,\"SHA-256 input must be a string\"end return toHex(sha256Raw(value))end function M.constantTimeEqual(left,right)return constantEqual(left,right)end function M.legacyDigest(value)local h=2166136261 for i=1,#value do h=bxor(h,value:byte(i))h=(h*16777619)%MOD end return string.format(\"%08x\",h)end function M.normaliseWorkFactor(value)value=tonumber(value)if not value or value%1~=0 then return nil,\"invalid password work factor\"end if value<M.MIN_WORK_FACTOR or value>M.MAX_WORK_FACTOR then return nil,\"password work factor must be \"..M.MIN_WORK_FACTOR..\"-\"..M.MAX_WORK_FACTOR end return value end function M.policy(password)if type(password)~=\"string\"then return false,\"password is required\"end if#password<M.MIN_LENGTH or#password>M.MAX_LENGTH then return false,\"password must contain \"..M.MIN_LENGTH..\"-\"..M.MAX_LENGTH..\" characters\"end if password:find(\"[%z\\1-\\31\\127]\")then return false,\"password contains control characters\"end return true end function M.derive(password,salt,workFactor)local work,err=M.normaliseWorkFactor(workFactor)if not work then return nil,err end if type(password)~=\"string\"or type(salt)~=\"string\"or#salt<16 or#salt>256 then return nil,\"invalid password record\"end local block=string.char(0,0,0,1)local value=hmac(password,salt..block)local result=value for _=2,work do value=hmac(password,value)result=xorBytes(result,value)cooperate(_)end return toHex(result)end local saltCounter=0 function M.newSalt(context)saltCounter=saltCounter+1 local now=os.epoch and os.epoch(\"utc\")or 0 local computer=os.getComputerID and os.getComputerID()or 0 local label=os.getComputerLabel and os.getComputerLabel()or\"\"local random=math.random and math.random(0,2147483647)or 0 return toHex(sha256Raw(table.concat({tostring(now),tostring(computer),tostring(label),tostring(context or\"\"),tostring(saltCounter),tostring(random)},\":\"))):sub(1,32)end function M.record(password,salt,workFactor)local valid,err=M.policy(password)if not valid then return nil,err end local work,workErr=M.normaliseWorkFactor(workFactor or M.DEFAULT_WORK_FACTOR)if not work then return nil,workErr end salt=salt or M.newSalt()local verifier,deriveErr=M.derive(password,salt,work)if not verifier then return nil,deriveErr end return{passwordVersion=M.PASSWORD_VERSION,scheme=M.SCHEME,salt=salt,verifier=verifier,workFactor=work,}end function M.isModern(record)return type(record)==\"table\"and record.passwordVersion==M.PASSWORD_VERSION and record.scheme==M.SCHEME end function M.verify(record,password)if type(record)~=\"table\"or type(password)~=\"string\"or type(record.salt)~=\"string\"or type(record.verifier)~=\"string\"then return false,\"invalid password record\"end if M.isModern(record)then local verifier,err=M.derive(password,record.salt,record.workFactor)if not verifier then return false,err end return constantEqual(record.verifier,verifier),nil end return constantEqual(record.verifier,M.legacyDigest(record.salt..password)),\"legacy\"end return M",
  ["ceetos/lib/release_keys.lua"] = "return{algorithm=\"lamport-sha256-v1\",roots={[\"auth-server-release-0.16.6\"]={public=\"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\",profile=\"auth-server\"},[\"auth-server-release-0.16.7\"]={public=\"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\",profile=\"auth-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_authority.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local auth=require(\"ceetos.lib.auth\")local M={}local PATH=\"/ceetos/data/auth-authority-state.lua\"local CHALLENGE_TTL,PRESENCE_INTERVAL,SERVER_TTL,SEED_WINDOW=30000,3000,15000,5000 local state,challenges,sessions,lastPresence,seededAt,lastSeed=nil,{},{},0,0,0 local function now()return os.epoch(\"utc\")end local function selfId()return tostring(os.getComputerID())end local function defaults()return{schema=1,term=1,sequence=0,active=false,primary=nil,servers={},members={},seeded=false,revision=0}end local function load()if state then return state end state=store.read(PATH,defaults())for key,value in pairs(defaults())do if state[key]==nil then state[key]=value end end state.servers=type(state.servers)==\"table\"and state.servers or{}state.members=type(state.members)==\"table\"and state.members or{}return state end local function save()store.write(PATH,load())end local function directory()return auth.authorityDirectory()end local function primary()local ids={selfId()}for id,entry in pairs(load().servers)do if type(entry)==\"table\"and(tonumber(entry.seen)or 0)+SERVER_TTL>now()then ids[#ids+1]=tostring(id)end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)return ids[1],ids end local function knownVoters()local ids,value={selfId()},load()for id in pairs(value.members)do if tostring(id)~=selfId()then ids[#ids+1]=tostring(id)end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)return ids end local function onlineVoters()local count=1 for id,entry in pairs(load().servers)do if tostring(id)~=selfId()and type(entry)==\"table\"and(tonumber(entry.seen)or 0)+SERVER_TTL>now()then count=count+1 end end return count end local function announce(net)local value,chosen=load(),primary()value.primary=chosen for _,peer in ipairs(net.peers())do net.request(peer.id,\"auth_presence\",{id=selfId(),term=value.term,sequence=value.sequence,primary=chosen,revision=value.revision},{safe=true,confidential=true})if value.active then net.request(peer.id,\"auth_authority\",{id=chosen,term=value.term,revision=value.revision,directory=directory()},{safe=true,confidential=true})end end end local function challengeProof(record,server,node,request,challenge,expires)return password.hmacSha256(record.verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(node),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end local function sessionFor(name,account)local issued=now()return{name=name,role=account.role,token=password.newSalt(\"central-session:\"..name),issued=issued,expires=issued+auth.SESSION_TTL_MS,accountRevision=tonumber(account.revision)or 0,authority=selfId()}end local function reply(net,packet,typeName,body)return net.reply(packet,typeName,body,{safe=true,confidential=true})end function M.start()local value=load();value.servers[selfId()]={seen=now(),term=value.term};value.members[selfId()]=true;value.primary=primary();save()end function M.status()local value,chosen,voters=load(),primary(),knownVoters()return{active=value.active==true,primary=chosen,localPrimary=chosen==selfId(),term=value.term,sequence=value.sequence,voters=#voters,onlineVoters=onlineVoters(),quorum=math.floor(#voters/2)+1,revision=value.revision}end function M.tick(net)local value,timestamp=load(),now()for id,entry in pairs(value.servers)do if(tonumber(entry.seen)or 0)+SERVER_TTL<=timestamp then value.servers[id]=nil end end local chosen,voters=primary(),knownVoters()if value.primary~=chosen then value.primary,value.term=chosen,math.max(1,(tonumber(value.term)or 0)+1)end if not value.seeded then if timestamp-lastSeed>=1000 then for _,peer in ipairs(net.peers())do net.request(peer.id,\"auth_seed_request\",{authority=selfId()},{safe=true,confidential=true})end lastSeed=timestamp end if seededAt==0 then seededAt=timestamp end if timestamp-seededAt>=SEED_WINDOW then value.seeded,value.active,value.revision=true,chosen==selfId(),(tonumber(value.revision)or 0)+1 end else local quorum=math.floor(#voters/2)+1 value.active=chosen==selfId()and onlineVoters()>=quorum end if timestamp-lastPresence>=PRESENCE_INTERVAL then announce(net);lastPresence=timestamp end save()end function M.handle(from,peer,packet,net)local body=type(packet.body)==\"table\"and packet.body or{}local value=load()if packet.type:sub(1,5)==\"auth_\"and packet.confidential~=true then return false,\"authority packets must be confidential\"end if packet.type==\"auth_presence\"then if type(body.id)==\"string\"and body.id==tostring(packet.origin or from)then value.servers[body.id]={seen=now(),term=tonumber(body.term)or 0,revision=tonumber(body.revision)or 0};value.members[body.id]=true;save()end return true elseif packet.type==\"auth_seed_request\"then return reply(net,packet,\"auth_seed\",{snapshot=auth.authoritySnapshot(),request_id=body.request_id})elseif packet.type==\"auth_seed\"or packet.type==\"auth_replica\"then if type(body.snapshot)==\"table\"then auth.merge(body.snapshot,true);value.revision=math.max(tonumber(value.revision)or 0,tonumber(body.revision)or 0)+(packet.type==\"auth_seed\"and 1 or 0);save()end return true elseif packet.type==\"auth_authority\"then if type(body.id)==\"string\"and type(body.directory)==\"table\"then return auth.acceptAuthority(body)end return false,\"invalid authority advertisement\"end if not value.active or value.primary~=selfId()then if body.request_id then return reply(net,packet,packet.type..\"_result\",{request_id=body.request_id,ok=false,error=\"Auth Server is standby or lacks quorum\"})end return false,\"authority is unavailable\"end if packet.type==\"auth_login_begin\"then if body.node~=tostring(packet.origin or from)then return reply(net,packet,\"auth_login_begin_result\",{request_id=body.request_id,ok=false,error=\"node binding failed\"})end local account=auth.authorityAccount(body.username)if not account or account.disabled or type(body.node)~=\"string\"or type(body.request_id)~=\"string\"then return reply(net,packet,\"auth_login_begin_result\",{request_id=body.request_id,ok=false,error=\"invalid credentials\"})end local expires,nonce=now()+CHALLENGE_TTL,password.newSalt(\"auth-challenge:\"..body.username)challenges[body.request_id]={name=body.username,node=body.node,nonce=nonce,expires=expires}return reply(net,packet,\"auth_login_begin_result\",{request_id=body.request_id,ok=true,result={authority=selfId(),salt=account.salt,workFactor=account.workFactor,challenge=nonce,expires=expires}})elseif packet.type==\"auth_login_proof\"then if body.node~=tostring(packet.origin or from)then return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=false,error=\"node binding failed\"})end local challenge,account=challenges[body.request_id],auth.authorityAccount(body.username)challenges[body.request_id]=nil if not challenge or challenge.expires<=now()or challenge.name~=body.username or challenge.node~=body.node or not account or account.disabled then return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=false,error=\"expired or invalid login challenge\"})end local expected=challengeProof(account,selfId(),body.node,body.request_id,challenge.nonce,challenge.expires)if not password.constantTimeEqual(expected or\"\",body.proof or\"\")then return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=false,error=\"invalid credentials\"})end local session=sessionFor(body.username,account)M.rememberSession(session,body.node)return reply(net,packet,\"auth_login_proof_result\",{request_id=body.request_id,ok=true,result={session=session,directory=directory(),revision=value.revision}})elseif packet.type==\"auth_mutate\"then local allowed=false local session=sessions[body.session]if session and session.expires>now()and session.node==body.node then allowed=session.role==\"admin\"or(session.role==\"operator\"and body.action~=\"remove\"and body.fields and body.fields.role~=\"admin\")end if not allowed then return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=false,error=\"authority session is not allowed\"})end if type(body.fields)==\"table\"and body.fields.password~=nil then return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=false,error=\"plaintext passwords are not accepted\"})end local ok,result=pcall(auth.authorityMutate,body.action,body.fields)if ok then value.revision,value.sequence=(tonumber(value.revision)or 0)+1,(tonumber(value.sequence)or 0)+1 save();announce(net)for _,target in ipairs(net.peers())do net.request(target.id,\"auth_replica\",{snapshot=auth.authoritySnapshot(),revision=value.revision},{safe=true,confidential=true})end return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=true,result={directory=result,revision=value.revision}})end return reply(net,packet,\"auth_mutate_result\",{request_id=body.request_id,ok=false,error=tostring(result)})end return false,\"unknown authority packet\"end function M.rememberSession(session,node)sessions[session.token]={node=node,role=session.role,expires=session.expires,name=session.name,revision=session.accountRevision}local total=0 for token,item in pairs(sessions)do total=total+1;if item.expires<=now()or total>128 then sessions[token]=nil end end end return M",
  ["ceetos/lib/auth_client.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local networkIpc=require(\"ceetos.lib.network_ipc\")local M={}local REPLIES=\"/ceetos/data/auth-replies.lua\"local sequence=0 local function now()return os.epoch(\"utc\")end local function authority()store.invalidate(\"/ceetos/data/auth-authority.lua\")local value=store.read(\"/ceetos/data/auth-authority.lua\",nil)return type(value)==\"table\"and value.active==true and value or nil end local function requestId(kind)sequence=sequence+1 return table.concat({\"auth\",kind,tostring(os.getComputerID()),tostring(now()),tostring(sequence)},\"-\")end local function take(id)store.invalidate(REPLIES)local replies=store.read(REPLIES,{})local row=replies[id]if row then replies[id]=nil;store.write(REPLIES,replies)end return row end function M.receive(body)if type(body)~=\"table\"or type(body.request_id)~=\"string\"or#body.request_id>160 then return false,\"invalid authority reply\"end local replies=store.read(REPLIES,{})replies[body.request_id]={ok=body.ok==true,result=body.result,error=body.error,at=now()}local rows={}for id,row in pairs(replies)do rows[#rows+1]={id=id,at=tonumber(row.at)or 0}end table.sort(rows,function(a,b)return a.at>b.at end)while#rows>32 do replies[table.remove(rows).id]=nil end return store.write(REPLIES,replies)end local function send(typeName,body,timeout)local server=authority()if not server then return nil,\"no Auth Server is reachable\"end local id=body.request_id or requestId(typeName)body.request_id=id local command={id=\"auth-\"..id,action=\"auth_send\",target=server.id,type=typeName,body=body}local ok,err=networkIpc.submit(command)if not ok then return nil,err or\"could not reach CeetOS network service\"end local deadline=now()+(timeout or 6000)while now()<deadline do local ack=networkIpc.poll(command.id,true)if ack and ack.ok~=true then return nil,ack.error or\"Auth Server request was not sent\"end local reply=take(id)if reply then return reply.ok and reply.result or nil,reply.error or\"Auth Server rejected request\"end sleep(0.05)end return nil,\"Auth Server did not respond\"end local function loginProof(verifier,server,request,challenge,expires)return password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(os.getComputerID()),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.login(name,plainPassword)end local request=requestId(\"begin\")local begin,beginErr=send(\"auth_login_begin\",{request_id=request,username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=loginProof(verifier,begin.authority,request,begin.challenge,begin.expires)local result,proofErr=send(\"auth_login_proof\",{request_id=request,username=name,node=tostring(os.getComputerID()),challenge=begin.challenge,proof=proof})if not result then return false,proofErr end local auth=require((\"ceetos.lib.auth\"))local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require((\"ceetos.lib.auth\"))local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.mutate(action,fields)end local current,server=auth.refreshSession(),authority()if not current or not current.central or not server then return false,\"an Auth Server login is required\"end local result,err=send(\"auth_mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end return M",
  ["ceetos/lib/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 = "auth-server"

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

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

local backup, migrate, migrationData = nil, false, {}
-- Clean stale full-tree backups from older installers before measuring space.
for _, name in ipairs(fs.list(".")) do
  if name:match("^ceetos%.backup") or name == "ceetos-migrate" then fs.delete(name) end
end
-- Development transactions can be much larger than the runtime. Preserve
-- only the reconnect record; staged payloads, test data, and rollback trees
-- are disposable and must not prevent an install from starting.
for _, name in ipairs({ "staging", "backups", "test-data" }) do
  local path = fs.combine("ceetos-dev", name)
  if fs.exists(path) then fs.delete(path) end
end
if fs.exists("ceetos") then
  if automated then migrate = true else
    print("Migrate saved CeetOS configuration? [Y/n]")
    local choice = read():lower()
    migrate = choice ~= "n" and choice ~= "no"
  end
  -- Copy only durable configuration to a small migration area, then remove
  -- the old tree before writing the new one. This works on nearly-full CC
  -- drives where retaining a complete backup would make installation fail.
  if migrate then
    local durable = { "users.lua", "network.lua", "shares.lua", "config.lua", "owner-service.lua", "seen-peers.lua", "jobs.lua", "job-workers.lua", "crafting-state.lua", "auth-authority.lua", "auth-authority-state.lua", "auth-directory.lua", "auth-session.lua", "cloud.lua", "cloud-state.lua" }
    if CEETOS_PROFILE == "recipe-server" then durable[#durable + 1] = "recipes.lua" end
    for _, name in ipairs(durable) do
      local source = fs.combine("ceetos/data", name)
      if fs.exists(source) then
        local input = fs.open(source, "r")
        if input then migrationData[name] = input.readAll(); input.close() end
      end
    end
  end
  fs.delete("ceetos")
end

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

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

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

-- CEETOS_RELEASE_PAYLOAD_END