-- CeetOS signed release. Generated; do not edit.
-- CEETOS_RELEASE_MANIFEST:{channel="release",profile="router-server",version="0.16.0",size=377896,digest="a842154da42842f32d294a4b2bdf8065c5f8d739809fc55ca5427876ebfac136",key_id="router-server-release-0.15.3",next_key_id="router-server-release-0.16.0",next_public="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"}
-- CEETOS_RELEASE_SIGNATURE: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
-- CEETOS_RELEASE_PAYLOAD_BEGIN
-- CeetOS installer. Generated; do not edit.
local files = {
  ["startup.lua"] = "local pendingPath,releasePath=\"/ceetos-updates/pending.lua\",\"/ceetos-updates/release.lua\"local pending if fs.exists(pendingPath)then local loader=loadfile(pendingPath)if loader then local ok,value=pcall(loader)if ok and type(value)==\"table\"then pending=value end end end if pending and pending.state==\"apply\"and fs.exists(releasePath)then shell.run(releasePath,\"--ceetos-apply\")elseif fs.exists(\"/ceetos/startup.lua\")then shell.run(\"/ceetos/startup.lua\")else shell.run(\"shell\")end",
  ["ceetos/startup.lua"] = "local root=\"/ceetos\"local profile={id=\"desktop\"}if fs.exists(root..\"/profile.lua\")then local loader=loadfile(root..\"/profile.lua\")if loader then local ok,value=pcall(loader);if ok and type(value)==\"table\"then profile=value end end end if profile.id~=\"desktop\"and fs.exists(root..\"/server.lua\")then shell.run(root..\"/server.lua\")elseif fs.exists(root..\"/ceet.lua\")then shell.run(root..\"/ceet.lua\")else printError(\"CeetOS is incomplete; starting CraftOS shell.\")shell.run(\"shell\")end",
  ["ceetos/profile.lua"] = "return {schema=1,id=\"router-server\"}",
  ["ceetos/lib/store.lua"] = "local M={}local cache={}local function internalPath(path)return type(path)~=\"string\"or path:sub(-4)==\".new\"or path:sub(-4)==\".bak\"end local function call(fn,...)local result={pcall(fn,...)}if not result[1]then return false,tostring(result[2])end if result[2]==false then return false,tostring(result[3]or\"operation failed\")end return true,result[2],result[3]end local function exists(path)local ok,value=call(fs.exists,path)return ok and value==true end local function remove(path)if not exists(path)then return true end local ok,err=call(fs.delete,path)return ok,err end local function ensureDirectory(path)local dir=fs.getDir(path)if dir==\"\"or exists(dir)then return true end local ok,err=call(fs.makeDir,dir)return ok,err end local function readRaw(path)local ok,handleOrErr=call(fs.open,path,\"r\")if not ok or not handleOrErr then return false,nil,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local readOk,content=call(handle.readAll)local closeOk,closeErr=call(handle.close)if not readOk then return false,nil,content end if not closeOk then return false,nil,closeErr end return true,content end local function writeRaw(path,content)local ok,handleOrErr=call(fs.open,path,\"w\")if not ok or not handleOrErr then return false,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local writeOk,writeErr=call(handle.write,content)local closeOk,closeErr=call(handle.close)if not writeOk then return false,writeErr end if not closeOk then return false,closeErr end return true end local function move(source,destination)local ok,err=call(fs.move,source,destination)return ok,err end local function decode(raw)local ok,value=pcall(textutils.unserialise,raw)if not ok or value==nil then return false,nil,\"invalid serialised value\"end return true,value end local function readValue(path)local ok,raw,err=readRaw(path)if not ok then return false,nil,err end return decode(raw)end local function recoverValue(path)local activeOk,activeValue=false,nil if exists(path)then activeOk,activeValue=readValue(path)end if activeOk then remove(path..\".new\")remove(path..\".bak\")return true,activeValue end local backupOk,backupValue=false,nil if exists(path..\".bak\")then backupOk,backupValue=readValue(path..\".bak\")end if backupOk then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,backupValue end remove(path..\".new\")return false,nil end local function validLines(raw)for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local ok,value=pcall(textutils.unserialise,line)if not ok or value==nil then return false,\"invalid appended value\"end end end return true end local function recoverAppend(path)if exists(path)then local activeOk,raw=readRaw(path)if activeOk then local valid=validLines(raw)if valid then remove(path..\".new\")remove(path..\".bak\")return true,raw end end end if exists(path..\".bak\")then local backupOk,raw=readRaw(path..\".bak\")if backupOk and validLines(raw)then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,raw end end remove(path..\".new\")return false,\"no valid appended value\"end local function commitRaw(path,raw,validator)local dirOk,dirErr=ensureDirectory(path)if not dirOk then return false,dirErr end local temporary,backup=path..\".new\",path..\".bak\"local removeOk,removeErr=remove(temporary)if not removeOk then return false,removeErr end local writeOk,writeErr=writeRaw(temporary,raw)if not writeOk then remove(temporary);return false,writeErr end local checkOk,checkedRaw,checkErr=readRaw(temporary)if not checkOk then remove(temporary);return false,checkErr end local valid,validErr=validator(checkedRaw)if not valid then remove(temporary);return false,validErr or\"temporary validation failed\"end local backupRemoveOk,backupRemoveErr=remove(backup)if not backupRemoveOk then remove(temporary);return false,backupRemoveErr end if exists(path)then local backupOk,backupErr=move(path,backup)if not backupOk then remove(temporary);return false,backupErr end local activateOk,activateErr=move(temporary,path)if not activateOk then if not exists(path)then move(backup,path)end remove(temporary)return false,activateErr end else local activateOk,activateErr=move(temporary,path)if not activateOk then remove(temporary);return false,activateErr end end return true end function M.readCached(path,fallback)if internalPath(path)then return fallback end local entry=cache[path]if entry~=nil then return entry.value end return M.readFresh(path,fallback)end function M.readFresh(path,fallback)if internalPath(path)then return fallback end local ok,value=recoverValue(path)if not ok then value=fallback end cache[path]={value=value}return value end function M.read(path,fallback)return M.readCached(path,fallback)end function M.writeAtomic(path,value)if internalPath(path)then return false,\"cannot write store temporary or backup path\"end if value==nil then return false,\"cannot store nil\"end local serialisedOk,raw=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(raw)~=\"string\"then return false,tostring(raw or\"could not serialise value\")end local valid=decode(raw)if not valid then return false,\"could not validate serialised value\"end recoverValue(path)local ok,err=commitRaw(path,raw,decode)if ok then cache[path]={value=value}end return ok,err end function M.write(path,value)return M.writeAtomic(path,value)end function M.append(path,value,limits)if internalPath(path)then return false,\"cannot append to store temporary or backup path\"end if value==nil then return false,\"cannot append nil\"end local serialisedOk,line=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(line)~=\"string\"then return false,tostring(line or\"could not serialise value\")end local valid=validLines(line..\"\\n\")if not valid then return false,\"could not validate appended value\"end local recovered,current=recoverAppend(path)if not recovered then if exists(path)or exists(path..\".bak\")then return false,current end current=\"\"end local lines={}for existing in(current..\"\\n\"):gmatch(\"(.-)\\n\")do if existing~=\"\"then lines[#lines+1]=existing end end lines[#lines+1]=line local maxEntries=limits and tonumber(limits.maxEntries)local maxBytes=limits and tonumber(limits.maxBytes)if maxEntries then maxEntries=math.max(1,math.floor(maxEntries))end if maxBytes then maxBytes=math.max(1,math.floor(maxBytes))end while maxEntries and#lines>maxEntries do table.remove(lines,1)end local raw=table.concat(lines,\"\\n\")if#raw>0 then raw=raw..\"\\n\"end while maxBytes and#raw>maxBytes and#lines>1 do table.remove(lines,1)raw=table.concat(lines,\"\\n\")..\"\\n\"end if maxBytes and#raw>maxBytes then return false,\"appended value exceeds byte limit\"end local ok,err=commitRaw(path,raw,validLines)if ok then cache[path]=nil end return ok,err end function M.readAppend(path)if internalPath(path)then return\"\"end local ok,raw=recoverAppend(path)return ok and raw or\"\"end function M.invalidate(path)cache[path]=nil end return M",
  ["ceetos/lib/profile.lua"] = "local store=require(\"ceetos.lib.store\")local M={}M.PATH=\"/ceetos/profile.lua\"M.IDS={desktop=true,[\"recipe-server\"]=true,[\"router-server\"]=true,[\"auth-server\"]=true}local cache local function normalise(value)if type(value)~=\"table\"then value={}end local id=tostring(value.id or value.profile or\"desktop\")if not M.IDS[id]then id=\"desktop\"end return{schema=1,id=id,installedAt=tonumber(value.installedAt)or 0}end function M.current()if not cache then cache=normalise(store.read(M.PATH,{id=\"desktop\"}))end return cache end function M.id()return M.current().id end function M.is(id)return M.id()==id end function M.isServer()return M.id()~=\"desktop\"end function M.set(id)assert(M.IDS[id],\"invalid CeetOS profile\")cache={schema=1,id=id,installedAt=os.epoch(\"utc\")}return store.write(M.PATH,cache)end function M.capability(name)local id=M.id()local tableFor={desktop={desktop=true,craftingClient=true,orders=true},[\"recipe-server\"]={server=true,recipes=true,recipeImport=true,recipePlan=true},[\"router-server\"]={server=true,routing=true},[\"auth-server\"]={server=true,authAuthority=true},}return tableFor[id][name]==true end return M",
  ["ceetos/lib/auth.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local audit=require(\"ceetos.lib.audit\")local M={current=nil}local USERS=\"/ceetos/data/users.lua\"local SESSION=\"/ceetos/data/session.lua\"local TOMBSTONES=\"/ceetos/data/user-tombstones.lua\"local THROTTLE=\"/ceetos/data/login-throttle.lua\"local RECOVERY=\"/ceetos/data/recovery.lua\"local AUTHORITY=\"/ceetos/data/auth-authority.lua\"local CENTRAL_SESSION=\"/ceetos/data/auth-session.lua\"local DIRECTORY=\"/ceetos/data/auth-directory.lua\"local rank={viewer=1,operator=2,admin=3}M.SESSION_TTL_MS=8*60*60*1000 M.LOGIN_THROTTLE={failures=5,windowMs=5*60*1000,lockMs=60*1000,maxEntries=64}local configuredWorkFactor=password.DEFAULT_WORK_FACTOR local sessionPathDelete local function now()return os.epoch(\"utc\")end local function accountName(name)return type(name)==\"string\"and name:match(\"^[%w_%-]+$\")and#name<=32 end local function users()store.invalidate(USERS);return store.read(USERS,{})end local function save(value)return store.write(USERS,value)end local function tombstones()store.invalidate(TOMBSTONES);return store.read(TOMBSTONES,{})end local function saveTombstones(value)return store.write(TOMBSTONES,value)end local function authority()store.invalidate(AUTHORITY)local value=store.read(AUTHORITY,nil)return type(value)==\"table\"and value.active==true and type(value.id)==\"string\"and value or nil end function M.authority()return authority()end function M.centralActive()return authority()~=nil end local function centralDirectory()store.invalidate(DIRECTORY)local value=store.read(DIRECTORY,{})return type(value)==\"table\"and type(value.users)==\"table\"and value or{users={}}end function M.acceptAuthority(record)assert(type(record)==\"table\"and type(record.id)==\"string\"and#record.id<=64,\"invalid auth authority\")local public={schema=1,active=true,id=record.id,term=math.max(0,math.floor(tonumber(record.term)or 0)),revision=math.max(0,math.floor(tonumber(record.revision)or 0)),seen=now()}assert(store.write(AUTHORITY,public),\"could not save auth authority\")if type(record.directory)==\"table\"then assert(store.write(DIRECTORY,{schema=1,revision=public.revision,users=record.directory}),\"could not save account directory\")end local loaded,profile=pcall(require,\"ceetos.lib.profile\")if not loaded or not profile.is(\"auth-server\")then if fs.exists(USERS)then fs.delete(USERS)end if fs.exists(TOMBSTONES)then fs.delete(TOMBSTONES)end sessionPathDelete()end return public end function M.updateDirectory(directory,revision)if type(directory)~=\"table\"then return false,\"invalid account directory\"end return store.write(DIRECTORY,{schema=1,revision=math.max(0,math.floor(tonumber(revision)or 0)),users=directory})end function M.saveCentralSession(value)if type(value)~=\"table\"or not accountName(value.name)or type(value.role)~=\"string\"then return false,\"invalid central session\"end local session={sessionVersion=3,name=value.name,role=value.role,token=value.token,issued=value.issued,expires=value.expires,accountRevision=value.accountRevision,authority=value.authority}if type(session.token)~=\"string\"or#session.token<16 then return false,\"invalid central session token\"end store.write(CENTRAL_SESSION,session)M.current=nil return true end local function safeAudit(action,detail)pcall(audit.log,\"auth\",action,detail or{})end local function stamp(account)account.updated=now()account.origin=tostring(os.getComputerID())account.revision=math.max(0,math.floor(tonumber(account.revision)or 0))+1 return account end local function makeAccount(role,plainPassword,context)local record,err=password.record(plainPassword,password.newSalt(context),configuredWorkFactor)assert(record,err)record.role=role return stamp(record)end sessionPathDelete=function()if fs.exists(SESSION)then fs.delete(SESSION)end store.invalidate(SESSION)end local function saveSession()if M.current==nil then sessionPathDelete();return end local durable={sessionVersion=2,name=M.current.name,nonce=M.current.nonce,issued=M.current.issued,expires=M.current.expires,accountRevision=M.current.accountRevision,}store.write(SESSION,durable)end local function makeSession(name,account)local issued=now()M.current={name=name,role=account.role,nonce=password.newSalt(\"session:\"..name),issued=issued,expires=issued+M.SESSION_TTL_MS,accountRevision=tonumber(account.revision)or 0,}saveSession()return M.current end local function liveAccount(name)local all=users()return all[name],all end local function normaliseSession(saved,account)if type(saved)~=\"table\"or not account or account.disabled then return nil end if saved.sessionVersion==2 then local issued,expires,revision=tonumber(saved.issued),tonumber(saved.expires),tonumber(saved.accountRevision)if type(saved.nonce)~=\"string\"or#saved.nonce<16 or not issued or not expires or not revision then return nil end if expires<=now()or revision~=(tonumber(account.revision)or 0)then return nil end return{name=saved.name,role=account.role,nonce=saved.nonce,issued=issued,expires=expires,accountRevision=revision}end if saved.sessionVersion==nil and type(saved.role)==\"string\"then return\"legacy\"end return nil end function M.refreshSession()local central=authority()if central then store.invalidate(CENTRAL_SESSION)local saved=store.read(CENTRAL_SESSION,nil)local entry=type(saved)==\"table\"and centralDirectory().users[saved.name]or nil if type(saved)~=\"table\"or saved.sessionVersion~=3 or saved.authority~=central.id or type(saved.token)~=\"string\"or(tonumber(saved.expires)or 0)<=now()or type(entry)~=\"table\"or entry.disabled==true or saved.accountRevision~=entry.revision then M.current=nil if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end return nil end M.current={name=saved.name,role=entry.role,nonce=saved.token,issued=saved.issued,expires=saved.expires,accountRevision=saved.accountRevision,authority=central.id,central=true}return M.current end store.invalidate(SESSION)local saved=store.read(SESSION,nil)if type(saved)~=\"table\"or not accountName(saved.name)then M.current=nil;return nil end local account=liveAccount(saved.name)local session=normaliseSession(saved,account)if session==\"legacy\"then return makeSession(saved.name,account)end if not session then M.current=nil sessionPathDelete()return nil end M.current=session return M.current end local function throttleState()store.invalidate(THROTTLE)local data=store.read(THROTTLE,{})return type(data)==\"table\"and data or{}end local function saveThrottle(data)local entries={}for name,entry in pairs(data)do if accountName(name)and type(entry)==\"table\"and type(entry.last)==\"number\"then entries[#entries+1]={name=name,last=entry.last}end end table.sort(entries,function(a,b)return a.last>b.last end)local kept={}for index,entry in ipairs(entries)do if index<=M.LOGIN_THROTTLE.maxEntries then kept[entry.name]=data[entry.name]end end store.write(THROTTLE,kept)end local function locked(name)if not accountName(name)then return false end local entry=throttleState()[name]return entry and(tonumber(entry.lockedUntil)or 0)>now()or false end local function noteFailure(name,reason)if not accountName(name)then return end local data,entry,time=throttleState(),nil,now()entry=data[name]or{failures=0,first=time}if time-(tonumber(entry.first)or 0)>M.LOGIN_THROTTLE.windowMs then entry.failures,entry.first=0,time end entry.failures=math.max(0,math.floor(tonumber(entry.failures)or 0))+1 entry.last=time if entry.failures>=M.LOGIN_THROTTLE.failures then entry.lockedUntil=time+M.LOGIN_THROTTLE.lockMs end data[name]=entry saveThrottle(data)safeAudit(\"login.failure\",{account=name,reason=reason or\"invalid\",throttled=(entry.lockedUntil or 0)>time})end local function clearFailures(name)local data=throttleState()if data[name]~=nil then data[name]=nil;saveThrottle(data)end end function M.throttleStatus(name)local entry=accountName(name)and throttleState()[name]or nil if not entry then return{failures=0,lockedUntil=0}end return{failures=tonumber(entry.failures)or 0,lockedUntil=tonumber(entry.lockedUntil)or 0}end function M.setPasswordWorkFactor(value)local work,err=password.normaliseWorkFactor(value)assert(work,err)configuredWorkFactor=work return work end function M.passwordWorkFactor()return configuredWorkFactor end function M.bootstrap(initialPassword)if authority()then return false end local all=users()if next(all)then return false end local plainPassword=initialPassword if plainPassword==nil then term.write(\"Create CeetOS admin password: \");plainPassword=read(\"*\")end local account=makeAccount(\"admin\",plainPassword,\"admin\")all.admin=account assert(save(all),\"could not save administrator account\")makeSession(\"admin\",account)safeAudit(\"bootstrap\",{account=\"admin\"})return true end function M.login(name,plainPassword)if authority()then local client=require((\"ceetos.lib.auth_client\"))return client.login(name,plainPassword)end if not accountName(name)or type(plainPassword)~=\"string\"then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if locked(name)then safeAudit(\"login.failure\",{account=name,reason=\"throttled\",throttled=true})return false,\"too many failed attempts; try again later\"end local account,all=liveAccount(name)if not account or account.disabled then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end local valid,state=password.verify(account,plainPassword)if not valid then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if state==\"legacy\"then local upgraded=makeAccount(account.role,plainPassword,\"upgrade:\"..name)upgraded.updated=account.updated or upgraded.updated upgraded.origin=account.origin or upgraded.origin upgraded.revision=math.max(tonumber(account.revision)or 0,upgraded.revision)stamp(upgraded)all[name]=upgraded assert(save(all),\"could not upgrade password record\")account=upgraded safeAudit(\"password.upgraded\",{account=name})end clearFailures(name)makeSession(name,account)safeAudit(\"login.success\",{account=name})return true end function M.logout()M.current=nil sessionPathDelete()if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end end function M.add(name,role,plainPassword)if authority()then assert(rank[role]and accountName(name),\"invalid user or role\")local record,err=makeAccount(role,plainPassword,\"central:\"..name)assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"add\",{name=name,role=role,record=record})end M.require(\"operator\")assert(rank[role],\"invalid role\")if role==\"admin\"then M.require(\"admin\")end assert(accountName(name),\"invalid user name\")local all=users()assert(not all[name],\"user exists\")all[name]=makeAccount(role,plainPassword,name)assert(save(all),\"could not save user\")safeAudit(\"user.add\",{account=name,role=role})end local function adminCount(all)local count=0 for _,account in pairs(all)do if account.role==\"admin\"and not account.disabled then count=count+1 end end return count end function M.setRole(name,role)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"role\",{name=name,role=role})end M.require(\"operator\")assert(accountName(name)and rank[role],\"invalid user or role\")local all,account=users(),users()[name]assert(account,\"unknown user\")if role==\"admin\"or account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot change the active account role\")assert(not(account.role==\"admin\"and role~=\"admin\"and adminCount(all)<=1),\"cannot remove the last administrator\")account.role=role stamp(account)all[name]=account assert(save(all),\"could not save account role\")safeAudit(\"user.role\",{account=name,role=role})end function M.setDisabled(name,disabled)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"disable\",{name=name,disabled=disabled==true})end M.require(\"admin\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")assert(not(M.current and M.current.name==name),\"cannot disable the active account\")if disabled then assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot disable the last administrator\")end account.disabled=disabled==true stamp(account)all[name]=account assert(save(all),\"could not save account state\")safeAudit(\"user.disabled\",{account=name,disabled=account.disabled})end function M.remove(name)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"remove\",{name=name})end M.require(\"operator\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot delete the active account\")assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot delete the last administrator\")all[name]=nil local removed=tombstones()removed[name]=now()assert(saveTombstones(removed),\"could not save account tombstone\")assert(save(all),\"could not remove account\")safeAudit(\"user.remove\",{account=name})end local function recoveryActive()store.invalidate(RECOVERY)local recovery=store.read(RECOVERY,{})return type(recovery)==\"table\"and(tonumber(recovery.until_ts)or 0)>now()end local function setPassword(name,plainPassword)assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")local replacement=makeAccount(account.role,plainPassword,\"reset:\"..name)replacement.updated=account.updated or replacement.updated replacement.origin=account.origin or replacement.origin replacement.revision=math.max(tonumber(account.revision)or 0,replacement.revision)replacement.disabled=account.disabled==true stamp(replacement)all[name]=replacement assert(save(all),\"could not save password\")if M.current and M.current.name==name then M.current=nil;sessionPathDelete()end safeAudit(\"password.reset\",{account=name})return true end function M.resetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end if not M.allowed(\"admin\")and not recoveryActive()then error(\"permission denied (requires admin or active recovery window)\",2)end return setPassword(name,plainPassword)end function M.adminResetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end M.require(\"operator\")local account=users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end return setPassword(name,plainPassword)end function M.allowed(role)if not rank[role]then return false end local current=M.refreshSession()return current~=nil and rank[current.role]>=rank[role]end function M.require(role)if not M.allowed(role)then error(\"permission denied (requires \"..tostring(role)..\")\",2)end end function M.list()local out={}local source=authority()and centralDirectory().users or users()for name,account in pairs(source)do out[#out+1]={name=name,role=account.role,disabled=account.disabled==true,revision=account.revision}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.snapshot()if authority()then return{users={},tombstones={},source=tostring(os.getComputerID()),schema=3,central=true}end return M.authoritySnapshot()end function M.authoritySnapshot()local copy={users={},tombstones={},source=tostring(os.getComputerID()),schema=2}for name,account in pairs(users())do copy.users[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=tonumber(account.revision)or 0,disabled=account.disabled==true,updated=account.updated or 0,origin=account.origin or copy.source,}end for name,removed in pairs(tombstones())do copy.tombstones[name]=removed end return copy end local function validIncomingPassword(account)if password.isModern(account)then local work=password.normaliseWorkFactor(account.workFactor)return work~=nil and type(account.verifier)==\"string\"and#account.verifier==64 and account.verifier:match(\"^[0-9a-f]+$\")~=nil end return type(account.salt)==\"string\"and#account.salt>0 and#account.salt<=256 and type(account.verifier)==\"string\"and account.verifier:match(\"^[0-9a-fA-F]+$\")~=nil and#account.verifier==8 end function M.merge(snapshot,authoritySeed)if authority()and authoritySeed~=true then return false,\"distributed account sync is disabled by central authority\"end if type(snapshot)~=\"table\"or type(snapshot.users)~=\"table\"then return false,\"invalid account sync\"end local all,removed,changed=users(),tombstones(),false for name,deletedAt in pairs(snapshot.tombstones or{})do if accountName(name)and type(deletedAt)==\"number\"and deletedAt>(removed[name]or 0)then local localAccount=all[name]if not localAccount or(localAccount.updated or 0)<=deletedAt then all[name],removed[name],changed=nil,deletedAt,true end end end for name,account in pairs(snapshot.users)do if accountName(name)and type(account)==\"table\"and rank[account.role]and validIncomingPassword(account)then local updated=tonumber(account.updated)or 0 local localAccount,incomingOrigin=all[name],tostring(account.origin or snapshot.source or\"\")local localOrigin=localAccount and tostring(localAccount.origin or os.getComputerID())or\"\"local wins=not localAccount or updated>(localAccount.updated or 0)or(updated==(localAccount.updated or 0)and incomingOrigin~=\"\"and incomingOrigin<localOrigin)if(removed[name]==nil or updated>removed[name])and wins then all[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=math.max(0,math.floor(tonumber(account.revision)or 0)),disabled=account.disabled==true,updated=updated,origin=incomingOrigin,}changed=true end end end if changed then assert(save(all),\"could not save account sync\")assert(saveTombstones(removed),\"could not save account tombstones\")M.refreshSession()end return changed end function M.authorityAccount(name)if not accountName(name)then return nil end return users()[name]end function M.authorityDirectory()local out={}for name,account in pairs(users())do out[name]={role=account.role,disabled=account.disabled==true,revision=tonumber(account.revision)or 0}end return out end function M.authorityMutate(action,fields)fields=type(fields)==\"table\"and fields or{}local name=fields.name assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]if action==\"add\"then assert(not account,\"user exists\")assert(rank[fields.role],\"invalid role\")local record=fields.record assert(type(record)==\"table\"and password.isModern(record),\"central account mutation requires a verifier record\")record.role,record.disabled=fields.role,false;all[name]=stamp(record);assert(save(all),\"could not save user\")elseif action==\"role\"then assert(account and rank[fields.role],\"unknown user or invalid role\")if account.role==\"admin\"and fields.role~=\"admin\"then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot demote the last active admin\")end account.role=fields.role;stamp(account);all[name]=account;assert(save(all),\"could not save role\")elseif action==\"disable\"then if account and account.role==\"admin\"and fields.disabled==true then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot disable the last active admin\")end assert(account,\"unknown user\");account.disabled=fields.disabled==true;stamp(account);all[name]=account;assert(save(all),\"could not save user state\")elseif action==\"remove\"then assert(account,\"unknown user\")if account.role==\"admin\"and not account.disabled then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot remove the last active admin\")end all[name]=nil;local removed=tombstones();removed[name]=now();assert(saveTombstones(removed),\"could not save tombstone\");assert(save(all),\"could not remove user\")elseif action==\"reset\"then assert(account,\"unknown user\")local replacement=fields.record assert(type(replacement)==\"table\"and password.isModern(replacement),\"central password reset requires a verifier record\")replacement.role,replacement.disabled=account.role,account.disabled==true;all[name]=stamp(replacement);assert(save(all),\"could not save password\")else error(\"unsupported account mutation\")end safeAudit(\"authority.\"..action,{account=name})return M.authorityDirectory()end M.refreshSession()return M",
  ["ceetos/lib/password.lua"] = "local M={}M.SCHEME=\"pbkdf2-hmac-sha256\"M.PASSWORD_VERSION=2 M.DEFAULT_WORK_FACTOR=256 M.MIN_WORK_FACTOR=64 M.MAX_WORK_FACTOR=2048 M.MIN_LENGTH=8 M.MAX_LENGTH=128 local MOD=4294967296 local band,bor,bxor,bnot=bit32.band,bit32.bor,bit32.bxor,bit32.bnot local rshift,lshift=bit32.rshift,bit32.lshift local unpack=table.unpack or unpack local K={0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,}local initial={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19,}local function add(...)local value=0 for i=1,select(\"#\",...)do value=(value+(select(i,...)or 0))%MOD end return value end local function rrotate(value,amount)if bit32.rrotate then return bit32.rrotate(value,amount)end return bor(rshift(value,amount),lshift(value,32-amount))end local function word(bytes,index)return bytes:byte(index)*16777216+bytes:byte(index+1)*65536+bytes:byte(index+2)*256+bytes:byte(index+3)end local function packWord(value)return string.char(band(rshift(value,24),0xff),band(rshift(value,16),0xff),band(rshift(value,8),0xff),band(value,0xff))end local function sha256Raw(value)local bitLength=#value*8 value=value..string.char(0x80)value=value..string.rep(\"\\0\",(56-(#value%64))%64)value=value..packWord(math.floor(bitLength/MOD))..packWord(bitLength%MOD)local h={unpack(initial)}for offset=1,#value,64 do if#value>16384 and offset>1 and((offset-1)/64)%128==0 and type(sleep)==\"function\"then sleep(0)end local w={}for i=1,16 do w[i]=word(value,offset+(i-1)*4)end for i=17,64 do local x,y=w[i-15],w[i-2]local s0=bxor(rrotate(x,7),rrotate(x,18),rshift(x,3))local s1=bxor(rrotate(y,17),rrotate(y,19),rshift(y,10))w[i]=add(w[i-16],s0,w[i-7],s1)end local a,b,c,d,e,f,g,hh=unpack(h)for i=1,64 do local s1=bxor(rrotate(e,6),rrotate(e,11),rrotate(e,25))local choice=bxor(band(e,f),band(bnot(e),g))local t1=add(hh,s1,choice,K[i],w[i])local s0=bxor(rrotate(a,2),rrotate(a,13),rrotate(a,22))local majority=bxor(band(a,b),band(a,c),band(b,c))local t2=add(s0,majority)hh,g,f,e,d,c,b,a=g,f,e,add(d,t1),c,b,a,add(t1,t2)end h[1],h[2],h[3],h[4]=add(h[1],a),add(h[2],b),add(h[3],c),add(h[4],d)h[5],h[6],h[7],h[8]=add(h[5],e),add(h[6],f),add(h[7],g),add(h[8],hh)end local result={}for i=1,8 do result[i]=packWord(h[i])end return table.concat(result)end local function hmac(key,message)if#key>64 then key=sha256Raw(key)end key=key..string.rep(\"\\0\",64-#key)local inner,outer={},{}for i=1,64 do local byte=key:byte(i)inner[i],outer[i]=string.char(bxor(byte,0x36)),string.char(bxor(byte,0x5c))end return sha256Raw(table.concat(outer)..sha256Raw(table.concat(inner)..message))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function cooperate(round)if round%32~=0 or not(os and os.queueEvent and os.pullEvent)then return end os.queueEvent(\"ceetos_password_yield\")os.pullEvent(\"ceetos_password_yield\")end local function toHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function constantEqual(left,right)if type(left)~=\"string\"or type(right)~=\"string\"then return false end local differing=bxor(#left,#right)local length=math.max(#left,#right)for i=1,length do differing=bor(differing,bxor(left:byte(i)or 0,right:byte(i)or 0))end return differing==0 end function M.hmacSha256(key,message)if type(key)~=\"string\"or type(message)~=\"string\"then return nil,\"HMAC key and message must be strings\"end return toHex(hmac(key,message))end function M.sha256(value)if type(value)~=\"string\"then return nil,\"SHA-256 input must be a string\"end return toHex(sha256Raw(value))end function M.constantTimeEqual(left,right)return constantEqual(left,right)end function M.legacyDigest(value)local h=2166136261 for i=1,#value do h=bxor(h,value:byte(i))h=(h*16777619)%MOD end return string.format(\"%08x\",h)end function M.normaliseWorkFactor(value)value=tonumber(value)if not value or value%1~=0 then return nil,\"invalid password work factor\"end if value<M.MIN_WORK_FACTOR or value>M.MAX_WORK_FACTOR then return nil,\"password work factor must be \"..M.MIN_WORK_FACTOR..\"-\"..M.MAX_WORK_FACTOR end return value end function M.policy(password)if type(password)~=\"string\"then return false,\"password is required\"end if#password<M.MIN_LENGTH or#password>M.MAX_LENGTH then return false,\"password must contain \"..M.MIN_LENGTH..\"-\"..M.MAX_LENGTH..\" characters\"end if password:find(\"[%z\\1-\\31\\127]\")then return false,\"password contains control characters\"end return true end function M.derive(password,salt,workFactor)local work,err=M.normaliseWorkFactor(workFactor)if not work then return nil,err end if type(password)~=\"string\"or type(salt)~=\"string\"or#salt<16 or#salt>256 then return nil,\"invalid password record\"end local block=string.char(0,0,0,1)local value=hmac(password,salt..block)local result=value for _=2,work do value=hmac(password,value)result=xorBytes(result,value)cooperate(_)end return toHex(result)end local saltCounter=0 function M.newSalt(context)saltCounter=saltCounter+1 local now=os.epoch and os.epoch(\"utc\")or 0 local computer=os.getComputerID and os.getComputerID()or 0 local label=os.getComputerLabel and os.getComputerLabel()or\"\"local random=math.random and math.random(0,2147483647)or 0 return toHex(sha256Raw(table.concat({tostring(now),tostring(computer),tostring(label),tostring(context or\"\"),tostring(saltCounter),tostring(random)},\":\"))):sub(1,32)end function M.record(password,salt,workFactor)local valid,err=M.policy(password)if not valid then return nil,err end local work,workErr=M.normaliseWorkFactor(workFactor or M.DEFAULT_WORK_FACTOR)if not work then return nil,workErr end salt=salt or M.newSalt()local verifier,deriveErr=M.derive(password,salt,work)if not verifier then return nil,deriveErr end return{passwordVersion=M.PASSWORD_VERSION,scheme=M.SCHEME,salt=salt,verifier=verifier,workFactor=work,}end function M.isModern(record)return type(record)==\"table\"and record.passwordVersion==M.PASSWORD_VERSION and record.scheme==M.SCHEME end function M.verify(record,password)if type(record)~=\"table\"or type(password)~=\"string\"or type(record.salt)~=\"string\"or type(record.verifier)~=\"string\"then return false,\"invalid password record\"end if M.isModern(record)then local verifier,err=M.derive(password,record.salt,record.workFactor)if not verifier then return false,err end return constantEqual(record.verifier,verifier),nil end return constantEqual(record.verifier,M.legacyDigest(record.salt..password)),\"legacy\"end return M",
  ["ceetos/lib/release_keys.lua"] = "return{algorithm=\"lamport-sha256-v1\",roots={[\"auth-server-release-0.15.2\"]={public=\"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\",profile=\"auth-server\"},[\"auth-server-release-0.15.3\"]={public=\"7YyBcrWJDQyP1z8+SRGhivrSjBorL5mN1FO3kqR59k1Y5VoPXAbnIwuMAoOi04pHKjndXj4dP26nyNCEQYwlRzfMRcbrPvh/O99M1+D8eQjHkOTRE3z2R/6aRMhbNFDlJuKvsRYphloVLK5iX+qafhbC4zPNdcYwewnyBOvL9aWntajrLQyT5buSCzTXbjQNe/5ZOscrLSBn1818O0OhZJgOZkXYvdTLsiluZCQ8BFaxHsRflu0SgmINPn/zq7+D2b14/gjbNevEzSkefgJSaU+SM+l/zeFnFZkRbyPK6+yTJ7Gb7WuBhURe++vtzgAQvfwlL2afyv2KzW7/JOF91S7AhOXOLEZZ1MmrwFz6Lj1DP1w80mCIEEAR5+c6ggs7/WgHAGMeX2y/dw8BllblBZk96ddBSg+sZEczQhSdF0PkPrZzYq27g/ypK7jPaQeTCoog16DvAlRBa5F6mMtuEExLodP/qmuf3V2zqeLND0a+OcVO4AcPgmFmoDxcxbV4bIoKuiBhifu3WqP4jrMQicSPYar1F7c4mrQZ3LlmtHk5VGm+E4XKSbaCm7sVFw+sLeBClq3xpyefalzWovfvUyVGOh4GaAX0viYgETi6R8HhsgtpBhDAgR3WVq1Yxbv+dlHbBnu6r/35JrmLArgjmSjF1lyuWTZca7PYUroRupyDESJuBkdfHyfEw5RRKEcVu7BsyTV7cX9WNVPw60ph2eN87i5rCna4dCznFmJpUHJpg/2oF9kmIMbC6MJxoT3VJ4r0eivvfYJ2wY67g8bzlC062N1Vp7XlnuVJiI2ZMP22mvIcdGYAuSFUXWsVZrqrNOx+GlvqDhdYZOWHLMCmFIXm9VRKPzlbadgKVMiwjwoIlBKbzYsZB13drU4TGfgNGwkPdKckxS/fqcfx3gwQW63kQgArEuEEMIV48z7vSY9QqlFABX1Xa6WDE/uJKOteW0P5nSRKFSNZeU3sJGbZmA4nJ3H5Jz9QY7G+wmT3JARiOPc3CA5TdGtMMG3gqOG9Ya5w3XzHICaoPVPymjV638UcJL29MeVfr6zRAvo+3EWzCp/Nl/UYx6p6erayTr2jYA4zH0eAm7WB6BZtodOyX8tIjMOWoz/EqSDI+DGIkH4mMB9upplEQM+T0zfheewxpjDjJQfdDitAiPxaLx3+dNnii9xd765+KwTDK29io0TtfX7iDgs/tLBwgsLb6/0qk/82/CBNRvXjazzdl6JziJYheX2T6BL+S2UC/Q/dtEKnPnMB6VwjULu1lbyvVc5QabgEDDETPiQgBWJblOFmJhUSCE71f9DEpw4r2xV6teAbT1pnMSHNaBRdN4CmQ9kbcAvCFeFgFu4vJ9uOs4MFVaNDvlJRb90LPraPJhxWAobn1fMD3/m8CUZnyIZ4dB4LdS3Nb7NglwGafuEplKnXCRFGUuckCnFM66ZzvJ3tRdrx3VFNbg6FOf9yMBw4iNbVoNjJ2goHHxhgbZV9DSsR3Wvlt421EXHpecBgALFqedtC+oqgVzj1jt6fOEY2SfFAUyikeKLPVTHhX++LIDTPtD6NspT1vrOM7OuEwhcTMi4DieqPThK0elS75u5bC1TquEq8xK0M9lIOk743tC4XQ8kJppJAB6IkJsd0NevAQGDEo5ETLTFd/J1XfQpVha1bFaVoGXr1iVAeyxoXCpG/uCikopzb8AqvIuVCVbsTM+02P+NpWKBNKP8qFHdfgrdLNZTVfzum0IZEdBt910gGnVUk4g64dIB9l0ZvzSUAkY3Dekxw1B9CzfrugopN7qHeQxXW0P4uVCoKSdn/PbtCNGrx+Alj+bGFEej5Ie+LT+dSloA8pSbFtyhBW51fIu4JWnfwBjFBzkKtnwcBtcTn2smhksqvrl9pDBwFwLJQXi53TjmFvj8eCM+5ZDixxpPIfpXY12Q+fwYOtksSKZw2QW1/r5ltrL0N31Wo3FHax88vajayK/SukBKfScupB7eGLNRVpl4XK8W6g+H2NhLYGtKuFltf6gBKPs2IdMMTk0pNuGF2ajhs33BY+HS/XDMFGzqwNUeYf26H/inDSVZ4a2h/FJyamcOu97FZR0ntZ3Pwgz4aKkZF8jNtNzVreTzRT5H/WcnKGCL9F1GiT002NruEq3LbJqpAw/I9myNLjCQuaEmKi3ZHiH1d5w7wwd0S0VFCMYTo20VcsBhTssIELnBDK8YN1NoIMwjIDJCkXUi6f/05lEiRXd0PrBHNbuaGM3Qsu9Z/JMD7eVo+gluUoaQEyVgVkRqwNU3n8De6jHlnB4ce1EQ6inmXLkFy6+pCV/BjyHweX6cR/86K8bGQlvMPHOS4AT+urlLASzFSHlcQKV1PNDRIgQTn9PdkeeJ/EmVj0xVPwnewkm8do8eHlFQQwcrdzMG1TH/YyaJ5ar3UC87ufN7i8Yu3VmWIiFOU9RrpjD/6sItASeZ6FlL+XmpXb+dR5tK8fSq/ZqNgMcjuKKa9JwifO+p9EbGgoNiOFM30w0E9UjvdQi/S25wuLTr33TK4YUJ85SqNtl3YKY5+8hXRpCWbuvmtHh1NGiJfZOMKLc56cZZMHAlsIDlcko2kD79gUzv7SkkBhlzwJClhU1PvPxgm6jp29bmnwD1Nt6Kt/dramdobaIEl0jsw16Q+oWGo6Ss7IZ5HmEoikhTLSZ7dT3XZ46HlfC0G1KIjb/ZoAD+w5MllAVBhn55kPCAiK/t3ruqdiowGU0BIU344H1F76xhoVzU9B1H46pynlJoTQp/82Yb+qima1jmBwYnUXymdJN4aTy4Ni75nwNjzFdsljNSD82AeMqVTds1POQHquk8P8bi8sIVlMAIYYEC93sKjlbcHkmcCmoMPEXcivgerdfH5QPJmw5pPavzuiSXXadhNvX0qpejI69sT3kYyfx5KClvNdEideFEtq1xbuPmYcRb8yPa98DTZPRDa4vpxCiW1kM/o2DJopzdCkCgfi634D56qXlotCXLXQ4iafnur5HX080HdCwlZbMy2wadu+xNY1W8btkF1D7bb2ZsR+X8celVnVGNtM+x4q98e+Mu8upcv2rgnzO+LZ+zH5qRwrzF8QuCENZXS2KPyQVzcxdXHTDRBfQdZqMRrhoTVT1CW4g6mXNUHSNJpnQf4Bz+PQEdY5sXxTEbmgo+9/SnVfPZ2MkehaXrIplh7M8ZMI9NSSyc4ruYFphSvyv6IGQL0QqBWYw7X3tnBnxC4bQaLsWzYT7xwVwxAM9hsvRZP2PJYlM+ZdtB3Zyug1RKg2iM/SQoz7ccImaAg357DC3rQ7D/uZ1YUMlZQDOB6BPTXlNkaR197cOCsiqD9B5K9kunGn8jGS9ED8cBuCchToXhDYnEBHChTAdZ6+yKrEsfj236f340YzkA/hISE2C3X5MsK3etF2NzGTH2PcRUJZ40D/mF2ga32TzdBVTknZ1XyNm/XGffD7DkmNSw/XQ25v+XZwSLZQpnNq8BRHEQDvzmF5SnE1tJ+1mx26kuEqx+4x7RzsU0N+rtDqtbbzDOySH7hRfzO4FRS47HkoxnTX9e9G3EQeS/EDjbDc5YsCh/LM4wJTcQvlHzmMihudHUAIA8ZvmD1wCRCS/7wAKB+cLLw3lvb7wHczRYxAkdq8ougK1R/mGszkWNmi+QOSMYfTiEBqVJjkyWgexW/NqoBkKjebweJ02MJRxRyZEAk1RhaKcU2lPTC2v50+ERvs7XX+LRX0D5o2JRFRz6Di94mjhRt7kYrKd6r/Ty7AqzdjphMYwTzGDPP44MSGhe3zfCb1jNMnuxemO84Gsmxpm4WAL7XFPglisHeNaDtn1fVRh9ipuSWZ78w75l0gDoCzcIZsqGZlbIW+ZNaaQiurp5b9BYjDEMBC8sl+jWZcv//UkXD0S7s94W2Tdr9FibGP5+LkamC/8pmBPVuUVMcdFKtcIumYqVksrU1V5Ffrhv8CMb7EUqfTcY8TzhY/h/i6sWR8t3WAWTc9QiqU9HH+KLv1jACtQAmwwDEk7OeBTaSnoR4Wrug2FlSmOrqqEPc3tN+QlqouInM5Lbus/fcEAnG0Ws0ZG39spb3xLDi3wG2cYbPvLoG6uIIcnxcWVpOAMgqvt6N08VigERBbuKkcUUrygTz95udP1MhxiOaBb9ygejYIe4pC1FZeiefb/LloOS6cnvSl6SL00vonTjYaP4h6SGqSlD3FE9Z0sWvHKjjNhfQqbDv4UWL+gXSuGEBc2MMt7mtSEucOlbiAIH1bNldPzYW9X2Pi/CsA0ZBgewYCvCP2jsMSrzzmNToTnxfMpmIAE90+YxtOu0JW+EdQlaGU/t7cNVw5TdZEAVYpd4ZtgfRAVQyH1VBqR6411gESaxAQCTq9re8q+KgM0W2InQ+lK0b1s5JRHbHPgv4h7mg5uxr1FIRFa8jMiCpfxpRB73pBe0TrkiTNgZvRGPrtxrw5JRiirEMkBznlKGAjxaKPiCjvNpWnr7p+Nip6NDLSsthj+EYvig6ieIRiK3YrP7bDcdf/JwwGSBEIUaZqpOEv5O8JMqkqhjON2e3sBn037l3BWvqhCubgKm+ej6e8+3knFzlXXwgbo7f5r0ICxiKQrPvwBNMlmmL+qTHWsbIo1H+NTJAwe2yKr9PfDtrLsUNzby8avoYmIwD07h42M1om7Gei4Sghk4I00xy/joWk/M5ElyO2pHyzXUFbbGWSP0xrNOB36paCgkjfwY6B0Yzsi+W9W3SGPAv2tzZfqfTyLqI96AcjvyCFeumfyXclI/xm3un0KyxpsWsP+o0zLPwt5PMeEQW6hRpQH/gHY/42fv1hLhNHyyBVwxbvBt7+z2NJRh0bano0PYivV9wEuwNJ6blgYRQa0+1e2IexHcLRkySs0g5Hg6bOW5vhVeDRWs0c8vauVdvJBWeDpt/rGr27/87fPcU81krU0bp47rqyypbcum8WwtQ7OuhiPeD7Rx1HobPyck0mi6u9YIirzrcnLWM8zYU+vLC4iG3DgUtR+VW3t+Z9djbSRcSjY3Zho3v2k+QFJrZGSegU8ItCw793t/gAe9NeMvirdDGIf7MxTVFbuKa8SzWdPC7pasL+URAdGcsdnT4bmaPoA7gvSjAjP8GpQNsxbuv/QcKZGaHBzcjNV8goBaObXlrDEnfqnVviF0USE/xkbkzsaOOugKeaHD1zvaDWxV3oJwaAy8tJEjptdU19cZus0gPTdQYWvA19LjG3Ly1yYbRvZerU62hwQ/8A37f4FcTEp1rce1S0h7VVgybNsT4j44d97d5LjXIGfVBxS3+/Avcnp6NP11px4VJE1eBpinzLGeQBklXTIeoZ1yxWYpAkml5EE1ejdfsiPnsv0hfTdAHdElkHRlN/qmaap7C+D4cJVohHGkcLDiMiR/Fq1OWnKsW0+25LS9IgW5O/m2kCGdOhwx27Q9Qnn7F7dMoHx65S6bKxog7pW0tmywZMS+q3jTYXH1Im2CzY+eQ4p6s7xgkkfk1ZGW4HmZIMD+nDow158gKZH+uZ4mfw43NMVJlKKy+oXgghtWqA9OMLvEJHH3K2PBmFZ461DQvlTmuG9zdwv9ARSBUkwugqvxcqqKNubOTEWO5k0S4e4egZ0YU5M8tgKpy+yUzl/GkYB9RS4Olxdg558YeyEXOtsJkrdKfzmQ+NFi+wER6VaQWh7orUFCImFHD1NCVD7Wwuzt91xAr81ht+ExGixXznXJnydkQvNJFsvmPiU+4d3wf+zzC67DroqnO3BPw5Q5z4gdInvft+FpxwgPTumHZPgzJsTs70hJcFOFAT7Vfz6yI2YQxOe82RHI03eOEu8S1XTDX/+dZSptENFpWkKEo7UFINDB+nL5bNpjxif+hbFgom6c4TLz/7kWKCN/WeqGAe3+a1kmxccVjtC9zbndFj9vuXWfoe9D6BLk/GNQ9Cv1RxSUbi82XBEjkFP7yiBBxPsnUcKGWiZKv1nw9W0PX4F+pQ17jeLqGMReSJ12AfvSEZNnn8+9Yao8HXblBWa6rLUcZpa5kEP7KeLk4WUQ007//A63MqQFX1c4YFxoK/I0zJdld2MmfQHLunsZzdh6zNmHzN3/fcuixoEFD/liZoxl7qwJj5u45C+n2lb3DYLsOG97duRR/lnvULB3YuT0+f3ZH5Ve9npVbzDWUdvu7qoe9kCmjCcYhYwBo1Ld/goLf8vg/xGQQLhuXUUwHnTRszhiK4aB9cNGMID7gnVPQ/TyuxEP942Km3AvEd3gkRyz3/aeA/L1iuOP9BeWOdihb8g/u39A2re+6RH3xXP9JsFUOPQDHbXL9ra1qNtsAn37b6OlKUG41JKt160jDL3ogVRZbOQuuhYVEUx4MBFG0oQK55I1vUmLsYc8utaXtUGZPQN3GbnAmvLTVJtVJG3kiAM1qFwxbUOPoOPMhfeEDNkRx2jXATxbvW8dXlhIQk12qbslQWDNUfW7oC2rax2CPe88e54v7KuDWbdCQFhqWploE28+xhD9M1/uDwZhwm/ediRnclpoyEdNn5rxSa2tKEzGc1X8lLAfjB42OWtysSumua7DaDMdtqHnAcTMRlmwY7cv1m53dR+kKfXhZClbS8xkA0vwI4PEnFFhLB+pRXwyS1PZYpotfRjxknu/+eAoLfFHfJQq8xaj+mI+8GI4B9n1rKCFD3kZUn0DjROPbdAI1ZsznwMBEtpjMChUWGXRE9K0yxWwkNQeMP5lFxaJIA/Hl/ZhVAf/WldAeUJmOum1uVj3zaANTqth4JiDY0dP6FOfB//wuVOpTpbPfhYfWjmub+BZ4aCLXWzSPmEuScdthDzz76/BJX2947KnIjNX3YRB4GztlDdN+S4jrcx6PgkxeOM4Nt36eIoLGDKFhAiFz2Rj5KGIbkiCohUDGmJ8/xQdyWO8UnUjPGlwMHiAOMw1cWyF2CBYwt8qTpBqlANkB4JhPLqOc0Nn9xwhFNq5ZLX8m9ijrnwzSn2B62v74eUTHEMFAWouGRORg+X22R+8mCD/B2JFaQgSFSQJzGVppHvk4weZAF2lEKi8c6URGBEc1p+5i/NoJzU38v93dlgkesTcnwhd3lRjPkCyjCl7vE/WHiaB0DnvVqumKtDGr9BZcMnywrkvOx9Z9D1GEpC2PF+O10TIWt4GZSyA8ynH/Whge072S4u/c7qvIbu64VixK+VRLFmjjMKAZJq64wgSSLyaa5+yoo1VyR5FVCw+/UnKXZRl/aqXzRjWK8njf3Yc1LuN0+95HT4iVBgdz25BIYjTOqfJ7tH2ewlTk5OeJpmRmsGKkoeOeKf6iNzoURTORnjPU5rWiqnyf5gcRwlkHQ7AmFPuLIlTk8wbfc35hnkvgy7iUEW4rE93yIeAjPH6ESCqE3ItSoul4MqVwjxfspsbnEhS5sx7sAR0N5OV/hjIx3Mj0P9mP18k/s9kZBz19zfMOWtgw8eqQQKZE/BHvJ/38y+FTt3ZSX5GmHMbIdgMJwZ1WZvJNNZwyk4iLY3conBvKEwW8pt31+S8bl+8uEnhGrTeXU6HE67i35LBHT8NhPA7hwUaEouAHheA2HHPAe8IqEGezjZNVVsvFG/siiJMk6iNw77gorM5F6JP0Hi4HipkdxZRYwF5iHW7sgVN3+6Xh//TpU1zWNeenoh1THPiiJdxYIbr1D9470ObCnFSsAmZqYUTYnQYhZPoTpQz8nl2sWSAJup4wpit3lg7l8Ho4CIT4DHgqnRijsoAsydfHOaOgYQMM5tCebQsn7gvSVcsrLnOwAD0mdQzFTVdKulgs9hkbF0j8FNHsGJudX+gTkRWPU9evjLpQA0TWTctVEidKN1d3qtfk/4QEqBQ69j+j7jaxJpOZRbRRwBti7V23zbM0aDkYe0zidqxNN02QIxtqhTQHdckseWaICpOkO84/CsrkexD6/UimX0igFSDX8J6MQc1riur9jgs141+RheOB7EjI3CCAGcncBzYljlHaR33Et+wvDGmKgWP7Gm4+u55ap/jDrol6dcYHqFe8R7gTtNPEBvkGDMxuX9rUKLuHSHdELc3EgGU2iDkOeKlInVrYVYpepjnxnVfU+jYTju4qx7B6cpBOdcpmj78gj0YkoBp6npYZF3JGp7RR+94g2z+IMkp2+FrqpT6BHkMP1dm7/HxJngScTSCPhnaaxqYmv+vhLTbK5LD27tuCSCe11MEkV9uAmmuHEkUCyMPL3EUL7LsrWZTPKL00MxO2WrRXIOyy9Gk1WdjbcFqWS8tY6P+/1g03VeLZYknR/vA5cxoQGukitAIDewON3S2SeGrNS8EorBDRQjKKvSErqwAtlGF4aXhHpZYuVbcdMSUrTglueLjrwct8HcNAnbPep/FDY795m5lYD4zvbWSttLnBvlkKKYOVBQM9ViJ/ak+AwJQQUPh/S2IpjfGix40YHPoU2ElrKk8PNH83CHyvzywUDfVbzDUvJ6z0u8+oMVpPt1mAD6lD6MbD+puGtVjPSsWTwSf6SeaYO5DzwZlkFpw/bmNLKKS4HcjDYXYvAR1AlNtTzw1aXWpwosZOgoGydyL67Kl1St8qsv3R1lRK0MF7ISoNGorAiRsw1tVnogKWxl+F0yhqPxPEgu9yxfN/LJEjuA6t/1SSedD0UysdOvaAFBsB8w6hXGeS4jc5jTjo1i2YSEpNba0bP8PC/oIpBOqzq/wm4xX3ahFRlOaiqrOm/+BNzOTaZifM0qj0cBzmvbc6yM72UjXfqvUssdXbGsBtd3Y87V485TEuvdJ6/atCzZjlyeV/vqFi7j/PHWpG/tt8qRaMm4XSXlgniYqeRK11Kz8juZnKUynVgwfiiP1yoXaTkzF6Q7Jy4FA+MrKX2pr57a3/KTLq93ZN0kYMHw8s9qNFfhtfunK8rA448tyBlnEGwxp5MPjnq1uPpt0SL/p5Gj9NMoyawzAT+6uSns2jk9hi1tdEERUFaiplR0Ki0z8Gafgx7ljQ3KRDkcD+XfjARt7QZw5EDYYAqBKZd7if7W06X+sCAwz7AxKsmelvQQPDvTGtIiNVBiUmbBkvaHVwdnkw//IXvhM/C4KGVxeLsDql+gWSmWta6gBbq6DWd0xWeq2mhfYx5BhdUv9gJuuh+leykvE3IIuXOfQBZn5pbk1Fqw36f3yz/pyHxznYQyrwbVShiU8ecXodVc8pTuPVrAsvD76NXlCOWe5VW6asaltWR7dHFBje3Cdr+e1Qq0WNMk/7Z4YX5462/MFahPTvTFH9aqt/9zSOqXIAL/khyCNPxISJhUtTk88XIZwANiYEPltEjxI82Kj8nFGjKAutU83rkXCSktNY74iIYgSUB1NAqOEWfZXb5QIOd+9tUZ1GBrTxd+dyaJrxSp9tQrdzcvQ0eVGImxcz2fJ2o4vJDSbKoHi0YA2Ppq8wsH/LdLR0FgYrIHyam0+HLX7XcAeRK2HwYBjdVOby5p1FxWyLYiAJHKOwUUZeEvmgM5Eg4U8e1IoRGQfUz/SjZHy9/SGq3p7FIvxb3KZUsoJskqGiENwFoQ2jeqqI8O47200+kNZHb28zPrze8zd5NwMiOe+8H4w/6bXDUKXTzSHThMw0ldbad1ZtOyBAojpWHGO8bJBlUj1DSAiAEw8ICtYUlSwO1hNegvbywSdnWpTBjGGjdMrQ7cX1oLrD9SUvxo8V7suwjPhPNJBHcvRljRPPAcoAXomCwSTixFXrsNMxCe+/2VCbknpTkaveeWMBEockIoKZ29Pqbapk1s6+KJHbTvcceui7gFylZigEnrJa4no1imU4O1xQyC/xN0jq+drIu+iUJHbH6QlvctT/EbM+bLYNf/TuOIpuvsdWyhK3DEq+R+T7xRG7zxpbr+noCyXEsOE+tTWyh+Gtov5+84uduSyNij3hp9spWrE+SrrYir2lHOhB1kO8p+0/fWOi6jIi4Fts7Bo+XKq/hVMnKer3vHi+YwWxyP+iT8ghanjb++q/0EfyTTJuwyxawgvQ+YNjbpIVpuyMbHREd6yhy/ivNnAc42R49RTUBT+LqIKSEFlNNNsuXQ3H+1/EcZdu9C8LBjOkb4/hTkvX4LnpvJNi0e3OzJmxVV7zgkdVHSzjA+M0jaualcQIXaBFiVt2oD/3sxqEV4TSN6kQs4AuvMqrBqilYF1TTywW4KOUso4ds9SDP6SO9d1ilVJsiyNySg08ICYyHS7x7gld5peY/PZKoqAKbw5iz0F9IiLoFyvGx9PaOq2+ZciCN5qQeKqrsZ6aSjwaEtM/82sx+xH/5q6uRP10QYqgBXcF0Nu9nhvE4ln/Ww7s0iFQwnm9OsFH1uw7vQ+CT0Pl7MnN5mSeWLU6Ai+VyhH3EuCKd/tq1ZwyDcvBhWptdVuzyYWQUreiHlYP974Q8nFKyF4252kQPboRjcaJ2aQVsc5sewjgcB8cVm2dKoyT8WgH5q3xVlyK03nS0rSMZ91ixzcq/DxMXsrPhnwR7q0BsoBgCruRz+7WoZ2o5TM32AUsywkEL2a6NPVzRl6b1vX3CFDkNjCAktug5RYSVZJikmMGTb7MgamddCExGe/+CxzGFRCU5AUtmInB1hrwgdv2lxAMSMzfRQGP+j96EYRbWr852mCbr2p+/UnVV4Tu3QG6vN13JYXm8TtVSANK5UGwGrvV+Hzm4TVPFmiFjTTspY339HuVB+E+6bng41GAIsiCcZR3gJXDu1+2s9KQj9rlKTOduPdH3pm2QODMbfwRpnBPbrN47xvLRGYpsDfvzvqYWsOmA50GON9cK5NJYFCYpknTkP92afXiO7v/dtc0vDSjy9EOAAmkBz/rVy7I/3sV3xgBAQzbolZ70HFcy20ombz1Ycfyj2ZtQ8zCCWWZw40QJEdWZBYBTb4IeWWdvKYLSyDLkOSTJ3vc1WellyCAAROFYrolJQC7/PqA00G62OnbwfMqpkhmbc04yQUHz0yk5J86sQQ2ZHG9iEeL6rOg8IxWpVmYayHRShZM7CPr4XjFJAvmDqhXoHF2sAWI07T3NjMhp6aR5G872g5HqITw2CXgcWu84SUhg056PR290DvX4H9Hwzpjkl/fPDZXrSl4O8uwKgMh5i4NoVroMWiYulPBL1ADYWXe1uXPE1vYots4n7DaMlyINfeHqw4/d0AFd1xB/2Bd60cIMEWYsyxFAF44XcygNSK2Ij4JbJA4E2SL786BRPAERZMVOFMbnF4iaubMMr2iNKyXdcJVIKEMCQLlX4adm75eul1rdbsUk8NTouKQFIsrz28aV67G5xWtOGLZyhkvtsiT9rr4e2E/lGahPgXRjUie+8H88OPOz1bbs7X5ShOgvwXncRWtnNcsIJSBjqdv3Oafu+zSlDngbv8xEIcMQerIUPMkC4AT4T+ToP/XKh3/PF+0oLeksuBilC1f+ksdl2bS9q8q3FlI0/Io4hW6G+O7G4CJuKY9feL+Zp1mbVd0ElcPByD3WRZCuX98iN2IY1JYudrNv1wpyUg6B/LXFJMX5Cm6I1CLp4378FvyXcQkVFm1eUyLk42rFOrx6xaNHEPMLqTsKMBdYaf66q6Xhd5pkzCFMTN6lWEKw7KtFqkjeZYaEqmRxTqkhYpH6Sz2GB4QciU48xYeMtmmhhiutV/0Sh5SNlTfSc8nXWyWuMq0ny17Mnf9Eeca6daT+Kg4GluWpl7FcJkJRkkJLnYEL68QPwZ581DSmTP2aIOBbYbb4LB8IiMXF0NW1KYqYywkUteZIEKh1QqA0COZ2odpys/wts7gcg4Z29f5PRxSbj/pwiFIDI461XxqRCz8st2axL5W9eRV+AvJVnHpIghWVWfTmFoDbaMYY1Y+kE1zq7SeMgPcE/oNY0mZiKD++qAV1Bvha+ZtMvXEtJOhmzd2g192XKZzwOQtC49YG2mkAWxNLSbXPz4007jyDxIEG7cclLsiNR4KXHi/sQnD/ngcey/JOJp0DhC4XKkTp/TMLX7FSqDprzpCHXckHdwP6gvJFAd3flyBiBJVUSKGA8I+WPdeqt7wMmA7R5Ln2TQzOY81iUX8+2eNiJYFOKXEaDASiIT5WAVNgeGZjmts03YqQWvoRJRan8XIM0f3V0s0BTBzXZYel67e6MWfuj3GIN1NEj6EY/K+DgmrGccifQHI2HijPPN1Hcd/zuMCsFxW2xoNxQ41P5G9eu/+IN9p7fpuJuSs1Y9zOOeWDkXm27NLy5LndoEsw0ECUys895sYq1MwGfPgbUoPZr83Ar7f41pl6fMv1PemGHmoiALjkRrtf8wxn38B8i5VU1Dj+x9anktPPJEGlIVFv68zxkXJMo/rntuu3Fy+TL6D5GyT8lkIMIesMLpVHH1VEhUwIKLqPvk7cm0iHTF48iQVVGCj0UnrdGyBjwl/c1CHPp6k+JYUkC/DPpUCG1eMzGIo+K/zqfN2UktGVKMgioDr7oJpDzpzFF+JsINMbkisQv7Z9eVW4VtOr6ribbNn0Opyp7ZtNv3UkTieY2bycRKpoLDvdH+SKZgPTdOZRqW+2+HAguTI9w1sJgbTtlX6YAtLrBCg5R3odrcYwny+U/j7m1jKfl/S6fsXmWQfRTya0xHevHS6cKVQ7lsqG2J4L9BibYSiEMDWsE0+1nqgzRJ6oTeTHssJYIeh55m3qumdPImFQTEiTmTC4vF6lYsjEBeX6v5Bek9+qFtWbCSYRJbcwqn5XasCu36HjuaCVqBbBn9V80jZ9hJRHMuJBc0Ty7a0MoPkm1SdIr45xLw0/YcmBheey0Ugqvp87G1ls9dtozdCcuYJltdlZtsuMAgq1r25SELZnS0F5X84KPZJnL0a3F5i2BnxEpHUs9DfUzNW16KZ7uyWD0DSRMyDjIODNDnh4b1E9oR4fnBNtGE7wKaHAClj785JP6NQmchsflLJjQePTQt4z3KD/0hnfGgnBM5POybprgJyRTE0pUhes160eWo8UEuh2B+smhsVPvi94Xu/wPN0Bt/sFq68T73TR8jSD3or54MMTYMf03D/n5xMWlT2h8R/THZi9IFjK3FocUq0NxoT6CUrmFoEErfKc3Y7KWkCD1ruW45Y7YWseqd2jGbsraEstPTelxjEne1aQFDqPBK2vdFZZmr/dAscuI6sbzO/go9U0nAaI7aJ1OaHPFckKRAUXCnyTNewvhon90rroOKBNrhL9vOXjmkQnZyXk7DtLEEuQUn1CKUCy8ZqOarHSxozn2ar07f34iPWinEtGAsGkTAZtnwnvLNMnLun0x7MMRz3pxlHx9ajW6Z9lilBDWpkvipOz1oEsSzcdSDacZ7ZcV3DGI4fNbFDuzhsYOSDl3jaDa092i9ElG5skDOksx3YDJFRbncjrbnNg5ESkoZfJJooYuc56kvpHM+P70s1TftgkipslAOqyxuxHLgmzS7FGycEOJHgabhctACQOBwP9+6A0wP4ebgjEWjosfL2ls4B/bqK0G+Whig1qs3sHoREOmhyWY3JIgdIO4nJBYvOUzEQXy6ztCNxOb1ZI/rOeOwvfsYxnP6wfNnTLOoM76c+xRfLE/ZAjM9HYYfCm5NMKPvoRRFxNLVueafRHg4embmiXx0gFI9RjTa783rkFxM9yG/bQhIgNnHxc4H9vMqwp7zS6j+PihRrTkzwgV1a0Dm/Vh4ubFDmHnrxnvGjtDWtRQurQrqpvxfmNDt5KFCpYxlBReIGpH2SXSBwjCnECzOPNwQjU0vs0672W4anWQzA6pIusiRCCM0Zm7YcUc/oHhBvBGOTwIBwU+U+FVKeD7WEXiZali95BzmhsSGDOZs+aUY6kquGYc4epksHZ1mZhvW0jf2Fc1mhF+iE39eZmWWCLRXxTuKB9Xl57PXly4sFlIvltEOC6e/SsamCZJ9Yqi43IntmPGizVtYMUWnGL9CICBkIZvTbZpgXhLYisMTDbwRhyEft/whm6cSe8K47SKHUFLicOLIzF/iFtffP7nbHJPaM8F6F8Iq63edLcj93jQHIhxazArOaedP7DwCfENHD8TVaKlRqmpDQNZbI6TKGCPpdf+QBn4/Q6FjreO7cv4LLY2RpEE01IPxXZ/iKB2qxldNirDFexkrhJwUWxNoQUnjvwPezhkFJ4dekskzgwVmrHaGHBvnyUvchRUkp3XJCKOxnUMKt1AKKlAMnLV8g4TebQ5pS3YwvbpswOKNrxwhDTYkESgQamILiVHYdac+1zUPm0N3J4ntJugT0Bky0edZRU9Z5kZ2GyqsqZAYmfWFsS5m/+X5K/7bWtYwCBc4HpOrtUc9UOYl3bu0XBarPZrKVPHcMtXWt/XsBZFKbDfS9G8O9j+2DlSbTNYFeYS+RauBRB1PEEwj1xAhUbXbQu1eGXtDU0orfPtjuutlLyt6Iua97ZlohUxNI0H4N0txspC23Nmk/M/Sz2l+u+RJHWsJGh+VGQbh0UiW7Dcz447BPp8hJ3XuDH7BvYoPy0BW9F8A2hd8132ZLJnUeXxavoIWFWhCbp4D3zb2KRLZUZoot2E8Y7RLGdSAJoYWH7tnHt5c3VLrg+J/fbh0bODHbCudMq/4J8qarJN+cakV68yj91YYjyavco5jXR0+CzhAaAK4xcFcLOykArXxarqz08D5tnbrUKWjOnEmw8+lslTjwPzxoLW5p+FcGcErVcF+dN7X9xhhLHjwYQaFg2gws17oaGLdQvfmjCCKwJXvOTbrlDWo4IjWbibmLASVv6dl4XuTr5K2Yrnh4de7VMuejm9ZbySmqyDdfiRLGlsgUIX/leYU31Klx7EWZiRSaPyZanWiaC5AYLx6aZ3Z2+nm9azcQltFIbk9OTQaFQ/Ql1C/7EHGtb4bfy19TmNHc0Yp1g1URTJQOhEShRMJs3pBGETwRD15PuRf1mGVLpW20/rKKJKgoGqtjFHuiYr2FSbDEWpG+hZA6+dzw6ASR7SgIkdtuLCo1ZS/qFjtGDdFGG+h+U2Ix3C9i1Qw9fLEiZh9ued81YJbcTG4nLlu0cuz5ilhwp4j4zdAhf5vobOfBIa+0uqkr0JaO46Rpq4RlijnIWBvyKP+sgynZyC8iSgdACMPcJyXaNfekOWDZ4pxp6hVeZT3IhJahCjaTGbY3tgk8aOZMM5nxxqI/Z3z4b8ASyjVLpZbj3ZpCp2YbEYtBjx1lQP62TQfDd/M0+26kgwi0m9zHKxrDOT3REX5H7gNUJ6qDGbYm52TC+w1Vf8aO/vkDnznejJ2HKPqA8gZq8wTMUevuRrBWPY9c5qbUPQUTlTZygYZq4hLK7MhoCiadgGpnbu9jBl4ZArh1kCmHg+yD7m4ouoAXSTUkkrl/RGIMK74IfxIjiJh4Z3Q7+/ghJK9O+ajVYyvYsv1/uyT+DFRlviTMpulxdbxTkvXqGKZucmUiQxdaCPFUjA1TZn3SUKGt0BeJy33I1yo30ocU8qzHxLdN5w3xneSoTbQ8yzjsWJMlZRtqTb14+IosNqlqbWuMxNYoJOOG/a/CE8EbQ/WTW08zHldbWXsTWy3J352hcefAIwahQqhPDBt6HpZ9joR9NZ01IChZdBSjchQPPNXvC7JR51GbUWLjoboUQ3V07r/QY2tcfXWwOemAYrIoNQhVxlHjdqvzx5Hg5XsOhF/U6kXf8xexpglv6TbnCyjnKNRwQ+Or62FmT/SxKdbUOqYyeDySkjN4ZH36WsTMhVre/eC5gk+Bl+Bn/27DIzbEPRhpoE1bChOi2oeEk5fQbEGpdJaTAEbCn7vgghmfc5dwRtqCpnsdhouaxk5vSwKUUDBzCKBjOVcWq21BJ8GStvv3L14YnxXTVVu1Xc9LLU8D0WuBSS+Hp6UXzTY7WDyRvtOQPH/IjyMEtSV+wQxjHbDFn3cOgGn6dGZQUq2D+R9U+LWreDpOBZc8HIlnx7RhZDFiVN4O78/ocA5SnDDiTNTCNrMvAUG5swTNPoFnR3LLogl69KVH/TGmOJrupxzfq1zO8H9jShlS1T1354Q6+sG3VYrt0tcr3ywdKbvQU84uLcMpjKNlT0PGm4zku2cpO1mfnooR+Db3FBx3EuYiL3X5KlKSo9AgYp7WyMsZ6RabFtZLZqE2GPqlXzB35vg9UFw6Zum5YV0kCEDv7sS2cuUvQ8uybmt1mFGKMQGc1qmvFgqg9fWk+u0zLj212o+zvToln5VlJUQfJ8KfHvkDgf8ocppFZSmvyYhga7xDNOmUmmUEjcqYuYy8dmNJaPZq5l3/Ij2vDCJ++1mwxLCU8rLxpRLHtZB8tN7PorWE8mDTfXVIEjauY7yAyLrxXMroLWACf/ueVLn+/tH4G31NCgL/WKvac7xHbhV4Aj0l7gfkbph+X6uF05EOSn9nAagNPe0NOmPQzl+iGaIXVkWIM7KmqbOrKPAptwYTfh5jarje81wCjuvYzKOT5rUm8qtWZk19htwTMhhivgf9KquUKacpiYsbslBfSPBrsIpV6Dox/kFLSmV/8hs+R7Bookyt1lGCOC38M0XkD4JUT1QOa5izcfjJi6eoveglk8M8KLpxKdHdp1KMF91XFcYUUkQ5lJVftrHL+J+G678kjDv700EbjJ5/Ay8i2AgyHV7hsApN7zrk9IiLZcIqPAjxJIxaDRVrEl1XyZb2ogL7A+7/xEatpkB6owdfTR+Klibc118ausZHs4zN6MRYlF5yCYWAeeUIPOrK5YNy+RAuMx/NtUUkIKGGM4DU5u30T7IyLRvKSNsZ1xLDtRZ/EdGlxYvm09WzS7zd51Afa+RtPz11uhmUp99hiylfeO3MTAnb/Su/h/MiMNmGD99rigEErBajmdKKq0rFoIwax3DEPFMQbPEsTYz75rDJ0DNnz5BpYrAikZajN/bEh60pw6p2N13AguJWEV1ULSON2qdLl4acLrKXaxkYfL2/eNjq2HIbfuUZc6Rpzf9ypH1u5sOL3YOD2TMZQ7dLOSWnzlRj/jS6huDXAztipxtVrFxwosb1HpD36OddEUTh4r4cSPY7KHw7HEWDEBcBhOwUR7cWRfjGUVwHKOw4AZcYvs0BClKvIMCghRAEehgpNTKZpUk/ekrwpd24ifokNVzRgIqQarjcswYxXPyhqRhqkgBTFOZ1xhHllEe44ZmhxqOtcEwn2W1Axtf4zawDOVeiDYALq4cj8uZI1rKUCgaPd87gDZg3lyNHDOyVmZldGQ5aMaPXOeyOF/m5oiy9Y1KgjwMr/waODlepMA+5LZr6+EbH4GdhdY2cMX2ZgbtCo6Mnjn0nuzuSfEBruZHGdtuSDJ+WLyevN6t8ibt6Fd3gOSMsmNfsCohKYBdL+Mwt5uSM1aihrdE0cwDeC50EmSmzPNYs06gv4QFAHE2XqCL70+/ZbJhT3hKXETGus59AcxufxTXLmyLL47XHp8QkRwGOs0gVGmY+anWj5sEyR4/dOy1WdHGTwJn6lrPUU8OcI1rwoVM82sOhqSE+sjxBqsUfS87gNGhZyYcDIT8h4xkPej1amzRq2lJw0My7CqvC0xnwYBmIs/wmAcjB0xpA3B5zDD8e260tX7HD7qbR3l/tQ98GezVdQyuDBnprWa5pHq9Twp8+wLKmZ5+yptyuzuKzadtSaGf5df2Mg50faa5+CanqmnkqUCIVYXVPWKYf5qZj5zpYcQxV+Zsada5fykDWhyGMU5mR0o0RCGaeaybVLC4DK8zc6RLriv4/RR0PNuXhXxoxg4KIR+mQmft2diPdfODYJaH00fbRxRXj251+2fNRy1KCmlK1gjXDVyU5sX8ez5XvodgDQ7yQDxvdRN1pTtR8g3KDoJXZRa6taW0Y2PotwZ2S2f6XX42LHfuWjpUmDX/PncJaYSHciyN/j47k1kW+ZIuxgmFdI2iomuTYbvtTbV1HvJ7acb/4Tky1uuRvPgX3OcRK169l+3FuScHVVQvLnG5ABHFDSCMRhHsXObgsty1MZq11uiBgQ3jHjD4XiGuUQBVSpDDW0j/Md7xX3MZoCAm73VEJgJwt0BVeUKUn+/MbmSrBJZF8daqmUj47+iHJmQj+RgnwZFg0L1nNqLGuwmuuo0VPUBn8HakJ/8JD0O1eyDbPKM8TkAIBKBOhx4B6MGJUZ7nnmF4WsP1jWPdmF9d5pYkC1LZCXp+gUt92pzaupTXjLwP6Gh14HJ0bk4lKXCOcH12FwZFJEzbRD/8MBYI/1OMGIYw8xDLiTzV7F3P7GzoIRBZ0ZUhMLwt3l0s23gyB0ac9sYUirPnnWVhRc2UY3o6YkZUtzd0g1oSSqvEmNseTpA3ZZE0U8oE/a10e/1X0BbaEwCCKmQA+oNhwirOCGVoYxflLbNPLGuUigCbF3tgNYzWFvA55BgoQ9yoNjBIv8ctTs9fPRaoduSc0AEa1N+Ix9BxuV7S7zYpJ0AwCpP3hA6r7D0SN+BrEsP0EvMZ6Qpzmkt1qckAt5LBlqnuVunS5zxoYZ7NawFRFlJkCuusJT6HAHfWS9woLIwt0x7XcWbpd7D65CxMQY+IAoSi39n8RIpJ3Vm1jl9cBefcRDO0Z1tJf+o+D9HcoLY3nPitIV8RsoOgDg1ds6K9agWlvk5FYK6rYQUf4B0q7x0CU+1swv5Tn+PO4CjpJNoJuZFsUY8X8dr7yv8rAYvVak+3RLaVPbXFZAFfuXlFzpD4/jaAG7EsKhYM1ZQZ+Yw7UoBbX/ruxXnFeuUs/gEeZ8/QazQ18JbG5VoTNXcLJJodWePO3sZUh6npvB7D0nThmERRCSxs4bN7Mvi8hdfiTsfJKe50MTxbrLAyjSMXcIz+byQ2QrHPNZ0IE+tOosV74g+ublVftGdlg2lfPq2NYXalIsuHBtQAj5uiFa/ZJFU0skZ+IENyRf3AHqtp+LbABnGuVIcY58ZRCgVpJqhOLhCVXWXyct3lTYwuclYDm4+EnNb87yerKMA4j8RrOpuPaZm/BmmtuswEmOauh18WEMPRmZ/8orCH55+JX4WYB+PmcnXaEzMQP2qiCx3qIGcqI3NY55dGnO+X2TAhuHb/PfBnBUFYrIsCZ/m3cBjmDKQHRS4vVWutEvQ3OvrfrtKwBCq+cld1mKEGIW59aDHGDDZCSkOSYEll4Mky/MkxnTuHHx0P0dHq6k8FCoxz76mfzNK7L8FwEFmvyhD7wSg/cdnYEFc0HZUSSPkW4bO5qjQUhwS3qxOgfjaezm0OdxAg96Rnyqzv25sHr5lkuQt9tO9nW+uqt11fBM52aEFf6uscVa14GRonZpKyVKpShM6GpST55ZJbOFbphA1G9nExw4RfU6bPAquZpRbeq9EtNprhfnQB3G68DCDmIQ0d1KZ/Uum/54kj499vnyxy2WU5botxkiDwEDv5sixjqq7xMYOsl2iQSFR+F6JGUYEeNcHPMEl9LHGWLqhT94rMuKRQNmJFf5D0TeGgSLaeAZdEF9MhicPOEaMVB4FxYNUxX5MZDRYzNk1fV0YVtzy6XT7y6MN1CsrKgCXSlQulR67g9hqRgO4ZI9mDotHcOJqoLqnwu2NNYGlczi28hLlR6qCWcjbb0VWDFtijnDSuNddQZmDpDTdzGJhxcIPviDgSp0nw+aDt/1k9p/12USI7JsRKj0gr92WXIJI/nCXXwekhUp4bw4i3hafiN98whkZ+Owu6S8xzp93g2yGVE3fE0HhIdMhCeJFmZfsX/sDet0vXVaQuLjJnpglEysRzdPNQKbG5KRiZ1uCK8PSAvEgExGcFwCLA7Yf4lRNSPs+wF69ViBytnD6XFVcS8cKDHzJ8+cPaOgNw+deGabLA8L7FsG5bKYu1PQSHjHo4oMGsWKTA6OX9rxNhpF5Cz3szUL34bW/ttSkH1eka5EY1nDt4E4yvAW5QDH5OypWWh7nSdOz/bKaGb43fOgRo/bMhvnJmOTa0aqc33hPRE457antSmxuwIE9RE0bd+WJgfL1z2NXQJv86rUG2RkO8wO3WLJMYZn5zQPHj2wlo3XDnjBNWHxU26WrUCzUqn09coZL/fwQvaUEcVQlQWCurfoaP71Lqf4Tun488X03Nw0D1NIoBk8skgEM3wjFAnLWSUDFoLqRTPGDfgRMuGY0tTrybT3Rs9uB2XS8YgAAif/i3Af1iWf7W2eVj4OzuVAGxdVs9ZOWrWKireWmBXLDgzLGNjiSsC4Z2c/odvrXlaBSxa4Zzl21X8OtCgeps9VpZGt2vBGja9B92cks5ONuChQ/fLnYtP1fFXNfW1E3x+JJI0WMY6L3lTsb5CxYD99NiKz7I4SDuOZvwHHm2w+hzxHuS46rfNgaoFFSZDvvQcrn4piJgQf7XzZQk+DFa0CWLQxzWGKuq0EgckdJthCn8gvAGAtqwr5cCcV7B5sdaMvu6oLV51NmmVQ4RpwN08HgpPUEke5AM1Ew9FsHI+1kWnbzE0pin/Ic33i5QZFPBBOnIZ88IQBS2e4+I3S5Ck6aq8ofzY8MdEhwTKGffpC7KdamRErxGgQDwi3ceLdcMKlEPTNavOjwR0PYamllTKLzJ8JE1wPpJhs+s+HxRxCeOoQy5r8gmXScEGlhr1T1uiTN+w4NaXebPg7KgnEdCCSG1uVYDfehw1v6nz6XM2hJ3YzCbX1DzhC+SkY6M1QYlhLw4NIptN4wQ4ht+fe0E3ZXbM75z+M53MvP2CSrSUs5noL7bjL+XwRnB8BawQfz/2FpnzpRX6pCGoUkyt1l6J6R/NFEhy4gvEoGc5x7EfZDhqWuk00uT4LMqgvqengdSTUhF2rlb0C2qQsE8nVFp8r8HozoK8lynFcJOhlTthzPQrRGXMOIuPBWPRe4GBqJCJWD00bEske0emEsQU1MkUvEPR6EVobWJu94UavLaMGleTiIe0LZm3oxcNM2Wx+wzSuFY02I6yC74F5o0rji5mFV8voPxthg7Dt2MHgqPoXDuHfKCTp65/OAInTc7YB0i8yT9QaUq2jJkr6Qr+Y0qsDU1GgQKkYvRlYJA2emWeNT9j5/bcBKcDaiimuzUbRa1r4w6zgCYTKtYotnuDwnQtD1MzBqNdKFicmF68eFifN+lS91aKZmGb/WfJezy8dLE0zoKf44SIbSIjEh5G1at2iJjNFmzoqXrx658XVhxCJAzNDzuwlulpqXeeLQDfKqO5ReHwaYe5JPKto5qXg4n6l/SwQKG2Y0wL+a4mc4Re8wsyNLOASPEGIPYlUAN7tA1Ppp9vEua5U/gGWYjYFxlBgrENJE7wlcdtlfEfAwrO7V0fjS1Bbx4aGQFH/VsUS4ufj75etd7eESbbBuKchNLx2vd7ABLVv/+p7Ix+hy/jiAS8oLcoL+DDG04NaIYNOclClpbbJULj5QxTMhwB9TJSd8CZAgkQ13zTwop9e6nV3WY8PaFe1U6EYuYmY0XjxYWrrt6DyNePwf8NgKBrQ19Deuxtzx406+BAOg8iEnTynRck4tK9ShHhElZGXuF1xqmik/iuG5g9GbOy8D3dX2Gms+a8N1SP4t7Bd+ozLSwZzqd0HyyVO8ChxW2M0p9zTecQergZBmeLln2CJ9BrKV9byLagjwfbXirIGw2Y6QjVMl2vAXhsVIQZ8qXNb8ZV3S245csmUnK6YkpAAyU4kFmqZndPgJ9/jEAMZ0qRLizkyfu7XsL+06N7SC29OPlmRK+FOaOFO2iER7J4ceecu/mlUJ9OS6N8rmGR0a53uiAyydkkUVp523KOLj9bhUrdoPIAmDwa/aiTSO0kw2dfzTof8wF8v7h42yGIESvVvh1siW1K99aiqKIxtIDlbWW1lhR1qR7DzNVHKZJL2vW2lLbfKtheexU4HlUJLtAvx/SusQD8d19W1XcESozRjysgFyrbnwEMwFgMNEOPFHwKNh/h6b1fTT3MfoHKZr6hQ7tn1v7MX6GSEXqXJBbdiNADF+enkV3CaBK6LKFuUoC4W1ywsdqFFk/BbXvjbqp+38JzbS87jdz1ZaPQJYvFq7f5T3ONmGA1v4gF3+wDpw==\",profile=\"auth-server\"},[\"desktop-release-0.15.3\"]={public=\"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\",profile=\"desktop\"},[\"desktop-release-0.16.0\"]={public=\"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\",profile=\"desktop\"},[\"recipe-server-release-0.15.3\"]={public=\"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\",profile=\"recipe-server\"},[\"recipe-server-release-0.16.0\"]={public=\"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\",profile=\"recipe-server\"},[\"router-server-release-0.15.2\"]={public=\"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\",profile=\"router-server\"},[\"router-server-release-0.15.3\"]={public=\"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\",profile=\"router-server\"},},}",
  ["ceetos/lib/release_verify.lua"] = "local password=require(\"ceetos.lib.password\")local roots=require(\"ceetos.lib.release_keys\")local profile=require(\"ceetos.lib.profile\")local M={}M.CACHE_ROOT=\"/ceetos-updates\"M.CACHE_FILE=\"/ceetos-updates/release.lua\"M.META_FILE=\"/ceetos-updates/cache.lua\"M.PART_FILE=\"/ceetos-updates/release.part\"M.PENDING_FILE=\"/ceetos-updates/pending.lua\"M.MAX_PACKAGE_BYTES=1024*1024 M.MAX_MANIFEST_BYTES=48*1024 M.CHUNK_BYTES=3072 M.KEY_PARTS=256 local alphabet=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"local decodeMap={}for i=1,#alphabet do decodeMap[alphabet:sub(i,i)]=i-1 end local function read(path)if not fs.exists(path)or fs.isDir(path)then return nil end local handle=fs.open(path,\"r\")if not handle then return nil end local value=handle.readAll();handle.close()return value end local function write(path,value)local parent=fs.getDir(path)if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary=path..\".tmp\"if fs.exists(temporary)then fs.delete(temporary)end local handle=assert(fs.open(temporary,\"w\"),\"could not create temporary release state\")handle.write(value);handle.close()if fs.exists(path)then fs.delete(path)end fs.move(temporary,path)end local function encode(value)local out,index={},1 while index<=#value do local a,b,c=value:byte(index,index+2)local n=(a or 0)*65536+(b or 0)*256+(c or 0)out[#out+1]=alphabet:sub(math.floor(n/262144)%64+1,math.floor(n/262144)%64+1)out[#out+1]=alphabet:sub(math.floor(n/4096)%64+1,math.floor(n/4096)%64+1)out[#out+1]=b and alphabet:sub(math.floor(n/64)%64+1,math.floor(n/64)%64+1)or\"=\"out[#out+1]=c and alphabet:sub(n%64+1,n%64+1)or\"=\"index=index+3 end return table.concat(out)end local function decode(value)if type(value)~=\"string\"or#value%4~=0 or#value>M.MAX_MANIFEST_BYTES*2 then return nil,\"invalid base64\"end local out={}for index=1,#value,4 do local a,b,c,d=value:sub(index,index),value:sub(index+1,index+1),value:sub(index+2,index+2),value:sub(index+3,index+3)if not decodeMap[a]or not decodeMap[b]or(c~=\"=\"and not decodeMap[c])or(d~=\"=\"and not decodeMap[d])then return nil,\"invalid base64\"end if(c==\"=\"and d~=\"=\")or((c==\"=\"or d==\"=\")and index+3~=#value)then return nil,\"invalid base64 padding\"end local n=decodeMap[a]*262144+decodeMap[b]*4096+(decodeMap[c]or 0)*64+(decodeMap[d]or 0)out[#out+1]=string.char(math.floor(n/65536)%256)if c~=\"=\"then out[#out+1]=string.char(math.floor(n/256)%256)end if d~=\"=\"then out[#out+1]=string.char(n%256)end end return table.concat(out)end local function unhex(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function semver(value)if type(value)~=\"string\"then return nil end local major,minor,patch=value:match(\"^(%d+)%.(%d+)%.(%d+)$\")if not major then return nil end return tonumber(major),tonumber(minor),tonumber(patch)end function M.compareVersions(left,right)local a,b,c=semver(left);local x,y,z=semver(right)if not a or not x then return nil,\"invalid semantic version\"end if a~=x then return a<x and-1 or 1 end if b~=y then return b<y and-1 or 1 end if c~=z then return c<z and-1 or 1 end return 0 end local function canonical(manifest)if manifest._legacyProfile==true then return table.concat({\"ceetos-release-v1\",tostring(manifest.channel),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end return table.concat({\"ceetos-release-v2\",tostring(manifest.channel),tostring(manifest.profile),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end local function unpackKey(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*2*32 then return nil,err or\"invalid public key\"end local parts={}for index=1,M.KEY_PARTS*2 do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end function M.validPublicKey(value)return unpackKey(value)end local function lookupKey(keyId)local saved=M.trustedKeys()local value=saved[keyId]if value then return unpackKey(value)end value=roots.roots and roots.roots[keyId]if type(value)==\"table\"and type(value.public)==\"string\"then value=value.public end return unpackKey(value)end local function bitAt(digest,index)local byte=digest:byte(math.floor((index-1)/8)+1)return bit32.band(bit32.rshift(byte,7-((index-1)%8)),1)end local function decodeSignature(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*32 then return nil,err or\"invalid signature\"end local parts={}for index=1,M.KEY_PARTS do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end local function verifySignature(manifest,signature)if roots.algorithm~=\"lamport-sha256-v1\"then return false,\"unsupported release signing algorithm\"end local public,publicErr=lookupKey(manifest.key_id)local parts,signatureErr=decodeSignature(signature)if not public or not parts then local prefix=not public and\"invalid release public key: \"or\"invalid release signature: \"return false,prefix..tostring(publicErr or signatureErr or\"unknown release key\")end local digest=unhex(password.sha256(canonical(manifest))or\"\")if not digest then return false,\"could not hash release manifest\"end for index=1,M.KEY_PARTS do local expected=public[(index-1)*2+bitAt(digest,index)+1]local candidate=unhex(password.sha256(parts[index])or\"\")if not candidate or not password.constantTimeEqual(candidate,expected)then return false,\"invalid release signature\"end end return true end local function validateManifest(manifest)if type(manifest)~=\"table\"or manifest.channel~=\"release\"then return nil,\"only signed release packages are accepted\"end if manifest.profile==nil then manifest.profile,manifest._legacyProfile=\"desktop\",true end if type(manifest.profile)~=\"string\"or not profile.IDS[manifest.profile]then return nil,\"invalid release profile\"end if not semver(manifest.version)or type(manifest.size)~=\"number\"or manifest.size<1 or manifest.size>M.MAX_PACKAGE_BYTES then return nil,\"invalid release manifest size or version\"end if type(manifest.digest)~=\"string\"or#manifest.digest~=64 or manifest.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if type(manifest.key_id)~=\"string\"or#manifest.key_id<1 or#manifest.key_id>64 then return nil,\"invalid release key id\"end if type(manifest.next_key_id)~=\"string\"or#manifest.next_key_id<1 or#manifest.next_key_id>64 then return nil,\"invalid next release key id\"end local nextKey=unpackKey(manifest.next_public)if not nextKey then return nil,\"invalid successor release key\"end return manifest end function M.parse(source)if type(source)~=\"string\"or#source>M.MAX_PACKAGE_BYTES then return nil,\"release package is too large\"end local encodedManifest,encodedSignature=source:match(\"^%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")if not encodedManifest then encodedManifest,encodedSignature=source:match(\"^%-%- CeetOS signed release%. Generated; do not edit%.[\\r\\n]+%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")end local first=source:find(\"%-%- CEETOS_RELEASE_PAYLOAD_BEGIN[\\r\\n]+\")if not encodedManifest or not encodedSignature or not first then return nil,\"not a signed CeetOS release package\"end local decoded,decodeErr=decode(encodedManifest)if not decoded then return nil,\"invalid release manifest encoding: \"..tostring(decodeErr)end local loader=load(\"return \"..decoded,\"=release-manifest\",\"t\",{})if not loader then return nil,\"invalid release manifest\"end local ok,manifest=pcall(loader)if not ok then return nil,\"invalid release manifest\"end local valid,manifestErr=validateManifest(manifest)if not valid then return nil,manifestErr end local start=source:find(\"\\n\",first)+1 local finish=start+valid.size-1 local payload=source:sub(start,finish)local suffix=source:sub(finish+1)if suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\\n\"and suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\\r\\n\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\"then return nil,\"release payload boundary mismatch\"end if#payload~=valid.size or not password.constantTimeEqual(password.sha256(payload)or\"\",valid.digest)then return nil,\"release payload digest mismatch\"end local signed,signatureErr=verifySignature(valid,encodedSignature)if not signed then return nil,signatureErr end return{manifest=valid,signature=encodedSignature,payload=payload,source=source}end function M.trustedKeys()local raw=read(M.CACHE_ROOT..\"/trusted-keys.lua\")if not raw then return{}end local loader=load(raw,\"=trusted-release-keys\",\"t\",{})if not loader then return{}end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or{}end local function saveKeys(value)local encoded=textutils.serialise(value,{compact=true})write(M.CACHE_ROOT..\"/trusted-keys.lua\",\"return \"..encoded)end function M.metadata()local raw=read(M.META_FILE)if not raw then return nil end local loader=load(raw,\"=release-cache\",\"t\",{})if not loader then return nil end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or nil end function M.cache(source,provider)local package,err=M.parse(source)if not package then return nil,err end if fs.exists(M.CACHE_ROOT)and fs.isDir(M.CACHE_ROOT)then if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end elseif not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end write(M.CACHE_FILE,package.source)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))local keys=M.trustedKeys();keys[package.manifest.next_key_id]=package.manifest.next_public;saveKeys(keys)return metadata end function M.promotePart(path,provider)if type(path)~=\"string\"or path~=M.PART_FILE then return nil,\"invalid release staging path\"end local source=read(path)local package,err=M.parse(source)if not package then return nil,err end if not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end fs.move(M.PART_FILE,M.CACHE_FILE)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))M.adopt(package)return metadata end function M.adopt(package)if type(package)~=\"table\"or type(package.manifest)~=\"table\"then return false,\"invalid verified package\"end local keys=M.trustedKeys()keys[package.manifest.next_key_id]=package.manifest.next_public saveKeys(keys)return true end function M.cachedPackage()local source,metadata=read(M.CACHE_FILE),M.metadata()if not source then return nil end local package,err=M.parse(source)if not package then return nil,err end if not metadata then metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=\"local installer\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))end M.adopt(package)return package,metadata end function M.clear()if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end if fs.exists(M.META_FILE)then fs.delete(M.META_FILE)end return true end function M.encode(value)return encode(value)end function M.decode(value)return decode(value)end function M.canonical(manifest)return canonical(manifest)end return M",
  ["ceetos/lib/updater.lua"] = "local store=require(\"ceetos.lib.store\")local release=require(\"ceetos.lib.release_verify\")local version=require(\"ceetos.lib.version\")local net=require(\"ceetos.lib.net\")local profile=require(\"ceetos.lib.profile\")local M={}local STATE_PATH=\"/ceetos/data/update-status.lua\"local OFFER_LIMIT,HISTORY_LIMIT=20,16 local BEACON_INTERVAL,REQUEST_TIMEOUT,REQUEST_LIMIT=30000,3500,3 local MAX_OFFER_AGE=5*60*1000 local state=nil local lastBeacon,lastCacheRead=0,0 local cached=nil local function now()return os.epoch(\"utc\")end local function localId()return tostring(os.getComputerID())end local function localLabel()return os.getComputerLabel()or(\"Computer \"..localId())end local function defaults()return{schema=1,offers={},history={},revision=0,status=\"idle\",message=nil,transfer=nil,cache=nil}end local function loadState()if state then return state end state=store.read(STATE_PATH,defaults())for key,value in pairs(defaults())do if state[key]==nil then state[key]=value end end state.offers=type(state.offers)==\"table\"and state.offers or{}state.history=type(state.history)==\"table\"and state.history or{}return state end local function save()local value=loadState()value.revision=(tonumber(value.revision)or 0)+1 store.write(STATE_PATH,value)end local function record(kind,fields)local value=loadState()local row={at=now(),kind=tostring(kind):sub(1,48)}for key,item in pairs(fields or{})do if key~=\"data\"and key~=\"source\"and key~=\"signature\"then row[key]=item end end value.history[#value.history+1]=row while#value.history>HISTORY_LIMIT do table.remove(value.history,1)end end local function setStatus(status,message)local value=loadState()value.status,value.message=status,message and tostring(message):sub(1,180)or nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=96 end local function validOffer(body)if type(body)~=\"table\"or type(body.version)~=\"string\"or type(body.size)~=\"number\"or type(body.digest)~=\"string\"or type(body.keyId)~=\"string\"or type(body.profile)~=\"string\"then return nil,\"malformed release offer\"end if body.profile~=profile.id()then return nil,\"release profile does not match this installation\"end local compare=release.compareVersions(body.version,version.string)if compare==nil then return nil,\"invalid release version\"end if body.size<1 or body.size>release.MAX_PACKAGE_BYTES then return nil,\"invalid release size\"end if#body.digest~=64 or body.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if#body.keyId<1 or#body.keyId>64 then return nil,\"invalid release key ID\"end return{profile=body.profile,version=body.version,size=math.floor(body.size),digest=body.digest:lower(),keyId=body.keyId,fingerprint=body.digest:sub(1,16),newer=compare>0}end local function refreshCached()local timestamp=now()if cached and timestamp-lastCacheRead<5000 then return cached end lastCacheRead=timestamp local value=loadState()local previous=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil local package,metadata=release.cachedPackage()if package and package.manifest.profile==profile.id()then cached={package=package,metadata=metadata,offer={version=package.manifest.version,size=#package.source,digest=package.manifest.digest,profile=package.manifest.profile,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),}}value.cache={profile=package.manifest.profile,version=package.manifest.version,size=#package.source,digest=package.manifest.digest,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),source=metadata and metadata.source or\"local\",verifiedAt=timestamp}else cached=nil value.cache=nil end local current=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil if current~=previous then save()end return cached end local function providerOffer()local available=refreshCached()if not available then return nil end return{version=available.offer.version,size=available.offer.size,digest=available.offer.digest,profile=available.offer.profile,keyId=available.offer.keyId,label=localLabel(),id=localId(),}end local function upsertOffer(source,body,transport,distance)source=tostring(source)if source==localId()then return false,\"ignored own release offer\"end local offer,err=validOffer(body)if not offer then return false,err end if not offer.newer then return false,\"offered release is not newer\"end local value=loadState()local key=source..\":\"..offer.version..\":\"..offer.digest:sub(1,16)value.offers[key]={id=source,label=tostring(body.label or(\"Computer \"..source)):sub(1,96),version=offer.version,profile=offer.profile,size=offer.size,digest=offer.digest,fingerprint=offer.fingerprint,keyId=offer.keyId,transport=transport,distance=tonumber(distance),seen=now(),key=key,}local rows={}for entryKey,item in pairs(value.offers)do rows[#rows+1]={key=entryKey,seen=tonumber(item.seen)or 0}end table.sort(rows,function(a,b)return a.seen>b.seen end)while#rows>OFFER_LIMIT do value.offers[table.remove(rows).key]=nil end setStatus(\"offers\",\"Signed release \"..offer.version..\" available from \"..tostring(body.label or source))record(\"offer\",{id=source,version=offer.version,transport=transport,distance=distance})save()return true end local function offers()local value,timestamp,rows=loadState(),now(),{}for key,item in pairs(value.offers)do if type(item)==\"table\"and timestamp-(tonumber(item.seen)or 0)<=MAX_OFFER_AGE then rows[#rows+1]=item else value.offers[key]=nil end end table.sort(rows,function(left,right)local compare=release.compareVersions(left.version,right.version)or 0 if compare~=0 then return compare>0 end return tostring(left.id)<tostring(right.id)end)return rows end local function findOffer(source)source=tostring(source)for _,item in ipairs(offers())do if item.key==source or tostring(item.id)==source then return item end end return nil,\"release source is unavailable; run update check first\"end local function removePart()if fs.exists(release.PART_FILE)then fs.delete(release.PART_FILE)end end local function appendPart(data)local handle,err=fs.open(release.PART_FILE,\"a\")if not handle then return false,err or\"could not open update staging file\"end handle.write(data);handle.close()return true end local function cachedSource()local available=refreshCached()return available and available.package and available.package.source end local function transferRequest(transfer)local length=math.min(release.CHUNK_BYTES,transfer.size-transfer.offset+1)if length<1 then return false,\"transfer is already complete\"end transfer.awaiting,transfer.requestedAt=true,now()local body={transfer=transfer.id,offset=transfer.offset,length=length}local sent,err if transfer.transport==\"routed\"then sent,err=net.request(transfer.source,\"update_chunk_request\",body,{safe=true})else sent,err=net.publicSend(transfer.source,\"update_chunk_request\",body)end if not sent then transfer.awaiting=false;return false,err end return true end local function beginDownload(source)local offer,err=findOffer(source)if not offer then return false,err end local compare=release.compareVersions(offer.version,version.string)if not compare or compare<=0 then return false,\"refusing a downgrade or current release\"end local free=fs.getFreeSpace and fs.getFreeSpace(\"/\")or nil if type(free)==\"number\"and free<offer.size+4096 then return false,\"not enough free space for one verified release cache\"end removePart()release.clear();cached=nil local value=loadState()value.transfer={id=\"update-\"..localId()..\"-\"..tostring(now())..\"-\"..tostring(math.random(1000,9999)),source=tostring(offer.id),label=offer.label,transport=offer.transport==\"routed\"and\"routed\"or\"direct\",profile=offer.profile,version=offer.version,size=offer.size,digest=offer.digest,keyId=offer.keyId,offset=1,received=0,retries=0,awaiting=false,started=now(),}setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from \"..offer.label)record(\"download_started\",{id=offer.id,version=offer.version,transport=value.transfer.transport})local sent,sendErr=transferRequest(value.transfer)if not sent then value.transfer=nil;setStatus(\"error\",sendErr);record(\"download_failed\",{id=offer.id,error=sendErr})end save()return sent,sendErr end local function finishTransfer(transfer)local handle=fs.open(release.PART_FILE,\"r\")local source=handle and handle.readAll()or nil if handle then handle.close()end if not source or#source~=transfer.size then return false,\"download size did not match offer\"end local parsed,parseErr=release.parse(source)if not parsed then return false,parseErr end if parsed.manifest.profile~=profile.id()or parsed.manifest.profile~=transfer.profile or parsed.manifest.version~=transfer.version or parsed.manifest.digest:lower()~=transfer.digest:lower()or parsed.manifest.key_id~=transfer.keyId then return false,\"verified package did not match selected release offer\"end local metadata,promoteErr=release.promotePart(release.PART_FILE,transfer.label)if not metadata then return false,promoteErr end cached=nil;refreshCached()local value=loadState();value.transfer=nil setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=transfer.source,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end local function acceptChunk(source,body,transport)local value,transfer=loadState(),loadState().transfer if not transfer or transfer.transport~=transport or tostring(source)~=tostring(transfer.source)then return false,\"unexpected update chunk\"end if type(body)~=\"table\"or body.transfer~=transfer.id or math.floor(tonumber(body.offset)or 0)~=transfer.offset or type(body.data)~=\"string\"then return false,\"malformed update chunk\"end local remaining=transfer.size-transfer.offset+1 if#body.data<1 or#body.data>math.min(release.CHUNK_BYTES,remaining)then return false,\"invalid update chunk length\"end local ok,err=appendPart(body.data)if not ok then transfer.awaiting=false;setStatus(\"error\",err);record(\"download_failed\",{error=err});save();return false,err end transfer.offset,transfer.received,transfer.awaiting,transfer.retries=transfer.offset+#body.data,(transfer.received or 0)+#body.data,false,0 if transfer.offset>transfer.size then local complete,result=finishTransfer(transfer)if not complete then removePart();value.transfer=nil;setStatus(\"error\",result);record(\"download_failed\",{id=source,error=result});save()end return complete,result end local sent,sendErr=transferRequest(transfer)if not sent then setStatus(\"error\",sendErr);record(\"download_failed\",{id=source,error=sendErr});value.transfer=nil;removePart()end save()return sent,sendErr end local function serveChunk(target,body,routed,request)if type(body)~=\"table\"or not validId(body.transfer)or math.floor(tonumber(body.offset)or 0)<1 or math.floor(tonumber(body.length)or 0)<1 or tonumber(body.length)>release.CHUNK_BYTES then return false,\"invalid update chunk request\"end local source=cachedSource()if not source then return false,\"no verified newer signed release is cached\"end local offset,length=math.floor(body.offset),math.floor(body.length)if offset>#source then return false,\"requested update offset is beyond package\"end local data=source:sub(offset,math.min(#source,offset+length-1))local response={transfer=body.transfer,offset=offset,data=data}if routed then return net.reply(request,\"update_chunk\",response,{safe=true})end return net.publicSend(target,\"update_chunk\",response)end function M.publicPacket(packet,distance)local source,body=tostring(packet.from),packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then net.publicSend(source,\"update_offer\",offer)end return elseif packet.type==\"update_offer\"then return upsertOffer(source,body,\"direct\",distance)elseif packet.type==\"update_chunk_request\"then return serveChunk(source,body,false)elseif packet.type==\"update_chunk\"then return acceptChunk(source,body,\"direct\")end end function M.authenticatedPacket(from,peer,packet)local body=packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then return net.reply(packet,\"update_offer\",offer,{safe=true})end elseif packet.type==\"update_offer\"then return upsertOffer(from,body,\"routed\")elseif packet.type==\"update_chunk_request\"then return serveChunk(from,body,true,packet)elseif packet.type==\"update_chunk\"then return acceptChunk(from,body,\"routed\")end end function M.check()local value=loadState()for key in pairs(value.offers)do value.offers[key]=nil end setStatus(\"checking\",\"Looking for newer signed releases\")local sent,err=net.publicBroadcast(\"update_query\",{version=version.string,profile=profile.id()})local routed=0 for _,peer in ipairs(net.peers())do if not peer.rekeyRequired then local ok=net.request(peer.id,\"update_query\",{version=version.string,profile=profile.id()},{safe=true})if ok then routed=routed+1 end end end record(\"check\",{direct=sent==true,routed=routed,error=sent and nil or err})save()return sent or routed>0,sent and nil or err end function M.download(source)return beginDownload(source)end function M.cancel()local value=loadState()if not value.transfer then return false,\"no update transfer is active\"end record(\"download_cancelled\",{id=value.transfer.source,version=value.transfer.version})value.transfer=nil;removePart();setStatus(\"cancelled\",\"Update download cancelled\");save()return true end function M.clearCache()local value=loadState()if value.transfer then return false,\"cancel the active download first\"end release.clear();cached=nil;value.cache=nil;setStatus(\"idle\",\"Verified release cache cleared\");record(\"cache_cleared\");save()return true end function M.prepareApply()local package,metadata=release.cachedPackage()if not package then return false,metadata or\"no verified signed release is cached\"end local compare=release.compareVersions(package.manifest.version,version.string)if not compare or compare<=0 then return false,\"cached release is not newer than this CeetOS installation\"end if package.manifest.profile~=profile.id()then return false,\"cached release profile does not match this installation\"end local marker={schema=2,state=\"apply\",profile=package.manifest.profile,version=package.manifest.version,digest=package.manifest.digest,keyId=package.manifest.key_id,approvedAt=now()}store.write(release.PENDING_FILE,marker)local value=loadState();setStatus(\"applying\",\"Applying verified release \"..package.manifest.version..\" after reboot\");record(\"apply_approved\",{version=package.manifest.version,digest=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id});save()return true,{version=package.manifest.version,fingerprint=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id}end function M.recover()local marker=store.read(release.PENDING_FILE,nil)if type(marker)~=\"table\"or marker.state~=\"verify\"then return end local value=loadState()if marker.version==version.string and(marker.profile==nil or marker.profile==profile.id())then if fs.exists(release.PENDING_FILE)then fs.delete(release.PENDING_FILE)end setStatus(\"applied\",\"Verified release \"..version.string..\" is now active\")record(\"apply_verified\",{version=version.string})else setStatus(\"error\",\"Update installed but running version did not match \"..tostring(marker.version))record(\"apply_version_mismatch\",{expected=marker.version,actual=version.string})end save()end function M.tick()local value,timestamp=loadState(),now()local offer=providerOffer()if offer and timestamp-lastBeacon>=BEACON_INTERVAL then net.publicBroadcast(\"update_offer\",offer)lastBeacon=timestamp end local transfer=value.transfer if transfer and transfer.awaiting and timestamp-(transfer.requestedAt or timestamp)>=REQUEST_TIMEOUT then transfer.awaiting,transfer.retries=false,(transfer.retries or 0)+1 if transfer.retries>REQUEST_LIMIT then record(\"download_timeout\",{id=transfer.source,version=transfer.version})value.transfer=nil;removePart();setStatus(\"error\",\"Update source timed out\");save()else local sent,err=transferRequest(transfer)if not sent then value.transfer=nil;removePart();setStatus(\"error\",err);record(\"download_failed\",{id=transfer.source,error=err});save()end end end end function M.status()local value=loadState()return{profile=profile.id(),version=version.string,status=value.status,message=value.message,revision=value.revision,offers=offers(),transfer=value.transfer,cache=value.cache,history=value.history,cacheRoot=release.CACHE_ROOT,maxPackageBytes=release.MAX_PACKAGE_BYTES,}end return M",
  ["ceetos/lib/mesh_crypto.lua"] = "local password=require(\"ceetos.lib.password\")local M={}local band,bor,bxor=bit32.band,bit32.bor,bit32.bxor local lshift,rshift=bit32.lshift,bit32.rshift local MOD32,LIMB=4294967296,67108864 local function add32(...)local n=0 for i=1,select(\"#\",...)do n=(n+(select(i,...)or 0))%MOD32 end return n end local function rotl(v,bits)return bor(lshift(v,bits),rshift(v,32-bits))end local function le32(data,index)local a,b,c,d=data:byte(index,index+3)return(a or 0)+(b or 0)*256+(c or 0)*65536+(d or 0)*16777216 end local function put32(value)value=value%MOD32 return string.char(value%256,math.floor(value/256)%256,math.floor(value/65536)%256,math.floor(value/16777216)%256)end local function le64(value)value=math.max(0,math.floor(tonumber(value)or 0))local low,high=value%MOD32,math.floor(value/MOD32)%MOD32 return put32(low)..put32(high)end local function hexToRaw(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function rawToHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function quarter(x,a,b,c,d)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),16)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),12)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),8)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),7)end local function chachaBlock(key,counter,nonce)local state={0x61707865,0x3320646e,0x79622d32,0x6b206574}for i=1,8 do state[4+i]=le32(key,(i-1)*4+1)end state[13],state[14],state[15],state[16]=counter%MOD32,le32(nonce,1),le32(nonce,5),le32(nonce,9)local x={}for i=1,16 do x[i]=state[i]end for _=1,10 do quarter(x,1,5,9,13);quarter(x,2,6,10,14);quarter(x,3,7,11,15);quarter(x,4,8,12,16)quarter(x,1,6,11,16);quarter(x,2,7,12,13);quarter(x,3,8,9,14);quarter(x,4,5,10,15)end local out={}for i=1,16 do out[i]=put32(add32(x[i],state[i]))end return table.concat(out)end local function chachaXor(key,nonce,counter,plaintext)local out,position={},1 while position<=#plaintext do local block=chachaBlock(key,counter,nonce)local part=plaintext:sub(position,position+63)out[#out+1]=xorBytes(part,block:sub(1,#part))position,counter=position+#part,(counter+1)%MOD32 end return table.concat(out)end local function poly1305(message,key)local function zero(length)local out={};for i=1,length do out[i]=0 end;return out end local function normalise(value)local carry=0 for i=1,#value do local n=(value[i]or 0)+carry value[i],carry=n%256,math.floor(n/256)end while carry>0 do value[#value+1],carry=carry%256,math.floor(carry/256)end return value end local function add(left,right)local out=zero(math.max(#left,#right)+1)for i=1,#left do out[i]=out[i]+left[i]end for i=1,#right do out[i]=out[i]+right[i]end return normalise(out)end local function multiply(left,right)local out=zero(#left+#right+1)for i=1,#left do for j=1,#right do out[i+j-1]=out[i+j-1]+left[i]*right[j]end end return normalise(out)end local function high130(value)local out={}for i=1,#value-16 do local low=value[i+16]or 0 local high=value[i+17]or 0 out[i]=math.floor(low/4)+(high%4)*64 end return normalise(out)end local function hasHigh(value)if#value>17 then for i=18,#value do if value[i]~=0 then return true end end end return(value[17]or 0)>=4 end local function reduce(value)while hasHigh(value)do local low,high=zero(17),high130(value)for i=1,17 do low[i]=value[i]or 0 end low[17]=low[17]%4 for i=1,#high do high[i]=high[i]*5 end value=add(low,high)end local prime={251}for i=2,16 do prime[i]=255 end prime[17]=3 local greater=false for i=17,1,-1 do if(value[i]or 0)~=prime[i]then greater=(value[i]or 0)>prime[i];break end end if greater then local borrow=0 for i=1,17 do local n=(value[i]or 0)-prime[i]-borrow if n<0 then n,borrow=n+256,1 else borrow=0 end value[i]=n end end return value end local r,h=zero(17),zero(17)for i=1,16 do r[i]=key:byte(i)end r[4],r[8],r[12],r[16]=band(r[4],15),band(r[8],15),band(r[12],15),band(r[16],15)r[5],r[9],r[13]=band(r[5],252),band(r[9],252),band(r[13],252)for at=1,#message,16 do local part,n=message:sub(at,at+15),zero(17)for i=1,#part do n[i]=part:byte(i)end n[#part+1]=1 h=reduce(multiply(add(h,n),r))end local pad,out,carry={},{},0 for i=1,16 do pad[i]=key:byte(i+16)end for i=1,16 do local n=(h[i]or 0)+pad[i]+carry out[i],carry=n%256,math.floor(n/256)end return string.char(table.unpack(out))end local function padded(value)return value..string.rep(\"\\0\",(16-(#value%16))%16)end local function derive(linkKey)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-key/v1\")or\"\")return raw end function M.nonce(linkKey,counter,context)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-nonce/v1|\"..tostring(counter)..\"|\"..tostring(context or\"\"))or\"\")return raw and raw:sub(1,12)or nil end function M.seal(linkKey,nonce,aad,plaintext)if type(linkKey)~=\"string\"or type(nonce)~=\"string\"or#nonce~=12 or type(aad)~=\"string\"or type(plaintext)~=\"string\"then return nil,\"invalid mesh envelope input\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local ciphertext=chachaXor(key,nonce,1,plaintext)local tag=poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey)return{nonce=rawToHex(nonce),ciphertext=rawToHex(ciphertext),tag=rawToHex(tag)}end function M.open(linkKey,envelope,aad)if type(linkKey)~=\"string\"or type(envelope)~=\"table\"or type(aad)~=\"string\"then return nil,\"invalid mesh envelope\"end local nonce,ciphertext,tag=hexToRaw(envelope.nonce or\"\"),hexToRaw(envelope.ciphertext or\"\"),hexToRaw(envelope.tag or\"\")if not nonce or#nonce~=12 or not ciphertext or not tag or#tag~=16 then return nil,\"invalid mesh envelope encoding\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local expected=rawToHex(poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey))if not password.constantTimeEqual(expected,envelope.tag)then return nil,\"mesh envelope authentication failed\"end return chachaXor(key,nonce,1,ciphertext)end function M.selfTest()local key=hexToRaw(\"85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b\")local tag=poly1305(\"Cryptographic Forum Research Group\",key)return rawToHex(tag)==\"a8061dc1305136c6c22b8baf0c0127a9\"end return M",
  ["ceetos/lib/audit.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/audit.log\"M.LIMITS={maxEntries=250,maxBytes=64*1024}function M.log(actor,action,detail)return store.append(PATH,{ts=os.epoch(\"utc\"),actor=actor or\"system\",action=action,detail=detail,},M.LIMITS)end function M.recent(limit)limit=math.max(1,math.min(50,tonumber(limit)or 10))local raw=store.readAppend(PATH)local result={}for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local entry=textutils.unserialise(line)if entry then result[#result+1]=entry if#result>limit then table.remove(result,1)end end end end return result end return M",
  ["ceetos/lib/net.lua"] = "local store=require(\"ceetos.lib.store\")local audit=require(\"ceetos.lib.audit\")local password=require(\"ceetos.lib.password\")local meshCrypto=require(\"ceetos.lib.mesh_crypto\")local M={handler=nil,publicHandler=nil}local PATH=\"/ceetos/data/network.lua\"local SECURITY_PATH=\"/ceetos/data/network-security.lua\"local SEEN_PATH=\"/ceetos/data/seen-peers.lua\"local CHANNEL,PROTOCOL=45731,\"ceetos/2\"local PUBLIC_UPDATE_PROTOCOL=\"ceetos/update/1\"local PUBLIC_UPDATE_TYPES={update_query=true,update_offer=true,update_chunk_request=true,update_chunk=true,}local DISCOVERY_CHANNEL=CHANNEL local DISCOVERY_TTL,ROUTE_TTL,PACKET_TTL=120000,120000,8 local DISCOVERY_INTERVAL,PAIR_RETRY,ROUTE_INTERVAL=2000,2000,15000 local MESH_BEACON_INTERVAL,MESH_FULL_INTERVAL=15000,30000 local PROBE_INTERVAL,PROBE_DEGRADED,PROBE_OFFLINE,PROBE_RECOVERY=5000,3,6,10000 local ROUTE_CANDIDATE_LIMIT,ROUTE_BUCKET_LIMIT=4,96 local SAFE_READ_WINDOW,SAFE_READ_LIMIT=1000,16 local MAX_PACKET_STRING,MAX_PACKET_TABLE,MAX_PACKET_DEPTH=8192,128,6 local COUNTER_RESERVATION,MAX_RX_EPOCHS,MAX_REVERSE_ROUTES=64,3,128 local routes,discovered,confirmations,seenPackets,reverseRoutes={},{},{},{},{}local routeSequence,lastRouteAdvertisement,routesDirty=0,0,false local discovery,lastDiscovery=nil,{state=\"inactive\"}local security={tx={},rx={}}local autoEdges,linkHealth,meshOffers,meshSeen,advertisedRoutes,meshEnrollmentSends={},{},{},{},{},{}local lastMeshBeacon,lastMeshFull,meshDirty=0,0,false local transport={modem=false,wireless=false,name=nil,channels={},lastTransmit=nil,lastReceive=nil,lastDistance=nil,lastError=nil,rejected=0,}local traces={discovery={},routing={},transport={}}local TRACE_LIMIT=48 local MESH_STATE_LIMIT=128 local rejectPacket local function now()return os.epoch(\"utc\")end local function id()return tostring(os.getComputerID())end local function label()return os.getComputerLabel()or(\"Computer \"..id())end local function isBroadcast(value)return tostring(value)==\"0\"end local function isForUs(value)return tostring(value)==id()end local function copy(value,depth)if type(value)~=\"table\"then return value end if(depth or 0)>MAX_PACKET_DEPTH then return nil end local out={}for k,v in pairs(value)do out[k]=copy(v,(depth or 0)+1)end return out end local function trace(kind,phase,fields)local bucket=traces[kind]or traces.transport local row={time=now(),phase=phase}for key,value in pairs(fields or{})do if key~=\"phrase\"and key~=\"proof\"and key~=\"key\"and key~=\"secret\"and key~=\"mac\"and key~=\"packet\"and key~=\"tag\"then row[key]=value end end bucket[#bucket+1]=row while#bucket>TRACE_LIMIT do table.remove(bucket,1)end end local function read(path,fallback)if store.invalidate then store.invalidate(path)end return store.read(path,fallback)end local function config()local value=read(PATH,{peers={},channel=CHANNEL})value.peers=type(value.peers)==\"table\"and value.peers or{}value.channel=tonumber(value.channel)or CHANNEL return value end local function save(value)local ok,err=store.write(PATH,value)if ok==false then error(err or\"could not save network configuration\",0)end end local function migrateV1Links()local value,changed=config(),false for _,peer in pairs(value.peers)do if peer.protocol~=2 or peer.rekeyRequired or type(peer.key)~=\"string\"or#peer.key<32 then peer.protocol,peer.rekeyRequired,peer.key=1,true,nil peer.secret=nil changed=true end end if changed then save(value)end return value end local function activePeer(value,peerId)local peer=value.peers[tostring(peerId)]if peer and peer.protocol==2 and peer.rekeyRequired~=true and type(peer.key)==\"string\"and#peer.key>=32 then return peer end return nil end local function activeLink(value,peerId)local manual=activePeer(value,peerId)if manual then return manual,\"direct\"end local edge=autoEdges[tostring(peerId)]if edge and type(edge.key)==\"string\"and#edge.key>=32 and(edge.expires or 0)>now()then return edge,\"mesh\"end return nil end local function healthFor(peerId)peerId=tostring(peerId)local state=linkHealth[peerId]if not state then state={state=\"healthy\",successes=0,misses=0,lastAuthenticated=now(),stableSince=now(),inFlight=0}linkHealth[peerId]=state end return state end local function linkState(peerId)return healthFor(peerId).state or\"healthy\"end local function currentInFlight(state,timestamp)state.inFlightUntil=type(state.inFlightUntil)==\"table\"and state.inFlightUntil or{}local kept={}for _,expires in ipairs(state.inFlightUntil)do if expires>timestamp then kept[#kept+1]=expires end end state.inFlightUntil,state.inFlight=kept,#kept return state.inFlight end local function markInFlight(state)local timestamp=now()currentInFlight(state,timestamp)state.inFlightUntil[#state.inFlightUntil+1]=timestamp+SAFE_READ_WINDOW table.sort(state.inFlightUntil)while#state.inFlightUntil>SAFE_READ_LIMIT do table.remove(state.inFlightUntil,1)end state.inFlight=#state.inFlightUntil end local function linkUsable(value,peerId,allowDegraded)if not activeLink(value,peerId)then return false end local state=linkState(peerId)return state==\"healthy\"or(allowDegraded and state==\"degraded\")end local function touchLink(peerId,distance,source)local state,timestamp=healthFor(peerId),now()state.lastAuthenticated,state.lastDistance,state.lastSource=timestamp,distance,source or\"traffic\"state.misses,state.awaiting,state.probeToken=0,false,nil state.loss=math.max(0,(state.loss or 0)*0.5)if state.state~=\"healthy\"then state.successes=(state.successes or 0)+1 if state.successes>=2 then state.state,state.stableSince,state.recoveredAt=\"healthy\",timestamp,timestamp routesDirty=true trace(\"routing\",\"link_recovered\",{peer=peerId,source=source})end else state.successes=math.min(2,(state.successes or 0)+1)end end local function allDirectLinks(value)local out,seen={},{}for peerId in pairs(value.peers)do if activePeer(value,peerId)then out[#out+1],seen[peerId]=tostring(peerId),true end end for peerId,edge in pairs(autoEdges)do if not seen[peerId]and edge.expires>now()then out[#out+1]=tostring(peerId)end end table.sort(out,function(a,b)return tonumber(a)<tonumber(b)end)return out end local function remember(peer,peerLabel,extra)local value=read(SEEN_PATH,{})local old=value[tostring(peer)]or{}old.label,old.seen=peerLabel or old.label or(\"Computer \"..tostring(peer)),now()if extra then for key,item in pairs(extra)do if key~=\"tag\"and key~=\"proof\"then old[key]=item end end end value[tostring(peer)]=old store.write(SEEN_PATH,value)end local function modem(requireWireless)local candidates,used={},{}local sides=rs and rs.getSides and rs.getSides()or{}for _,name in ipairs(sides)do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end if peripheral.getNames then for _,name in ipairs(peripheral.getNames())do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end end local fallback for _,name in ipairs(candidates)do local wrapped=peripheral.wrap(name)if wrapped then fallback=fallback or wrapped local ok,wireless=pcall(function()return not wrapped.isWireless or wrapped.isWireless()end)if ok and wireless then return wrapped end end end return requireWireless and nil or fallback end local function modems()local out,seen={},{}local function add(name)if not seen[name]and peripheral.getType(name)==\"modem\"then local wrapped=peripheral.wrap(name)if wrapped then out[#out+1],seen[name]={name=name,modem=wrapped},true end end end for _,name in ipairs(rs and rs.getSides and rs.getSides()or{})do add(name)end for _,name in ipairs(peripheral.getNames and peripheral.getNames()or{})do add(name)end return out end local function wirelessModems()local out={}for _,item in ipairs(modems())do local ok,wireless=pcall(function()return not item.modem.isWireless or item.modem.isWireless()end)if ok and wireless then out[#out+1]=item end end return out end local function openChannels(value)local channels={value.channel or CHANNEL}if channels[1]~=DISCOVERY_CHANNEL then channels[#channels+1]=DISCOVERY_CHANNEL end transport.channels=channels local all=modems()if#all==0 then transport.lastError=\"no modem attached\";trace(\"transport\",\"modem_missing\");return channels end for _,item in ipairs(all)do for _,channel in ipairs(channels)do local ok,err=pcall(item.modem.open,channel)if not ok then transport.lastError=tostring(err)trace(\"transport\",\"channel_open_failed\",{channel=channel,error=transport.lastError,modem=item.name})end end end return channels end local function canonical(value,depth)depth=depth or 0 local kind=type(value)if kind==\"nil\"then return\"n\"end if kind==\"boolean\"then return value and\"b1\"or\"b0\"end if kind==\"number\"then if value~=value or value==math.huge or value==-math.huge then return nil,\"invalid numeric packet value\"end return\"d\"..string.format(\"%.17g\",value)..\";\"end if kind==\"string\"then if#value>MAX_PACKET_STRING then return nil,\"packet string exceeds limit\"end return\"s\"..tostring(#value)..\":\"..value end if kind~=\"table\"then return nil,\"unsupported packet value\"end if depth>=MAX_PACKET_DEPTH then return nil,\"packet nesting exceeds limit\"end local entries={}for key,item in pairs(value)do if#entries>=MAX_PACKET_TABLE then return nil,\"packet table exceeds limit\"end local encodedKey,keyErr=canonical(key,depth+1);if not encodedKey then return nil,keyErr end local encodedValue,valueErr=canonical(item,depth+1);if not encodedValue then return nil,valueErr end entries[#entries+1]=encodedKey..\"=\"..encodedValue end table.sort(entries)return\"t\"..tostring(#entries)..\"{\"..table.concat(entries,\",\")..\"}\"end local function packetMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,origin=packet.origin,destination=packet.destination,ttl=packet.ttl,request_id=packet.request_id,timestamp=packet.timestamp,reply_to=packet.reply_to,auth=packet.auth and{epoch=packet.auth.epoch,counter=packet.auth.counter}or nil,confidential=packet.confidential==true,body=packet.body,})end local function confidentialAad(packet)return table.concat({\"ceetos/confidential/v1\",tostring(packet.type),tostring(packet.origin),tostring(packet.destination),tostring(packet.request_id)},\"|\")end local function sealBody(peer,packet)local encoded=textutils.serialise(packet.body or{},{compact=true})if#encoded>6144 then return nil,\"confidential payload exceeds limit\"end local nonce=meshCrypto.nonce(peer.key,password.newSalt(\"confidential:\"..tostring(packet.request_id)),confidentialAad(packet))if not nonce then return nil,\"could not create confidential nonce\"end local envelope,err=meshCrypto.seal(peer.key,nonce,confidentialAad(packet),encoded)if not envelope then return nil,err end return{envelope=envelope}end local function openBody(peer,packet)if type(packet.body)~=\"table\"or type(packet.body.envelope)~=\"table\"then return nil,\"malformed confidential envelope\"end local decoded,err=meshCrypto.open(peer.key,packet.body.envelope,confidentialAad(packet))if not decoded or#decoded>6144 then return nil,err or\"invalid confidential payload\"end local ok,value=pcall(textutils.unserialise,decoded)if not ok or type(value)~=\"table\"then return nil,\"invalid confidential payload\"end return value end local function loadSecurity()security=read(SECURITY_PATH,{tx={},rx={}})security.tx=type(security.tx)==\"table\"and security.tx or{}security.rx=type(security.rx)==\"table\"and security.rx or{}end local function saveSecurity()local ok,err=store.write(SECURITY_PATH,security)if ok==false then error(err or\"could not persist peer replay state\",0)end end local function counter(peerId)local key=tostring(peerId)local tx=security.tx[key]if not tx then tx={epoch=password.newSalt(\"peer-tx:\"..key),reserved=0};security.tx[key]=tx end tx.next=tonumber(tx.next)or((tonumber(tx.reserved)or 0)+1)if tx.next>(tonumber(tx.reserved)or 0)then tx.reserved=tx.next+COUNTER_RESERVATION-1 saveSecurity()end local value=tx.next;tx.next=value+1 return tx.epoch,value end local function verifyReplay(from,auth)if type(auth)~=\"table\"or type(auth.epoch)~=\"string\"or#auth.epoch<16 or#auth.epoch>128 then return false,\"invalid packet epoch\"end local sequence=tonumber(auth.counter)if not sequence or sequence<1 or sequence%1~=0 then return false,\"invalid packet counter\"end local key=tostring(from)local row=security.rx[key]or{epochs={}}row.epochs=type(row.epochs)==\"table\"and row.epochs or{}local old=tonumber(row.epochs[auth.epoch])if old and sequence<=old then return false,\"replayed packet counter\"end row.epochs[auth.epoch]=sequence local order={}for epoch,max in pairs(row.epochs)do order[#order+1]={epoch=epoch,max=tonumber(max)or 0}end table.sort(order,function(a,b)return a.max>b.max end)while#order>MAX_RX_EPOCHS do row.epochs[table.remove(order).epoch]=nil end security.rx[key]=row saveSecurity()return true end local function newRequestId()return id()..\":\"..password.newSalt(\"peer-request\")end local function sign(peerId,peer,packet)local epoch,sequence=counter(peerId)packet.auth={epoch=epoch,counter=sequence}local material,err=packetMaterial(packet)if not material then return false,err end local mac,macErr=password.hmacSha256(peer.key,material)if not mac then return false,macErr end packet.auth.mac=mac return true end local function verifyPacket(packet,value)if type(packet)~=\"table\"then return false,\"packet is not a table\"end if packet.protocol~=PROTOCOL then return false,packet.protocol==\"ceetos/1\"and\"v1 packet rejected; rekey required\"or\"invalid packet protocol\"end if type(packet.type)~=\"string\"or#packet.type==0 or#packet.type>64 then return false,\"invalid packet type\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid packet sender\"end local from=tostring(packet.from)local peer=activeLink(value,from)if not peer then return false,\"sender is not an active direct or mesh peer\"end if not isForUs(packet.to)then return false,\"packet addressed to another hop\"end if type(packet.origin)~=\"string\"and type(packet.origin)~=\"number\"then return false,\"invalid packet origin\"end if type(packet.destination)~=\"string\"and type(packet.destination)~=\"number\"then return false,\"invalid packet destination\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 or#packet.request_id>128 then return false,\"invalid packet request ID\"end if packet.reply_to~=nil and(type(packet.reply_to)~=\"string\"or#packet.reply_to==0 or#packet.reply_to>128)then return false,\"invalid reply correlation ID\"end local ttl=tonumber(packet.ttl)if not ttl or ttl%1~=0 or ttl<1 or ttl>PACKET_TTL then return false,\"invalid packet TTL\"end local timestamp=tonumber(packet.timestamp)if not timestamp or math.abs(now()-timestamp)>ROUTE_TTL then return false,\"stale packet timestamp\"end if type(packet.auth)~=\"table\"or type(packet.auth.mac)~=\"string\"or#packet.auth.mac~=64 then return false,\"missing packet MAC\"end local receivedMac=packet.auth.mac packet.auth.mac=nil local material,materialErr=packetMaterial(packet)packet.auth.mac=receivedMac if not material then return false,materialErr end local expected,macErr=password.hmacSha256(peer.key,material)if not expected or not password.constantTimeEqual(expected,receivedMac)then return false,macErr or\"invalid packet MAC\"end local replayOk,replayErr=verifyReplay(from,packet.auth)if not replayOk then return false,replayErr end return true,peer end local function routeBucket(targetId)local bucket=routes[tostring(targetId)]if bucket and bucket.next then bucket={candidates={{next=tostring(bucket.next),hops=tonumber(bucket.hops)or PACKET_TTL,expires=tonumber(bucket.expires)or 0,label=bucket.label,mode=bucket.mode,masterId=bucket.masterId,legacy=true,loss=1,}},primary=tostring(bucket.next),changedAt=now(),reason=\"legacy route\"}routes[tostring(targetId)]=bucket end if not bucket then bucket={candidates={},changedAt=now(),reason=\"new\"}routes[tostring(targetId)]=bucket end bucket.candidates=type(bucket.candidates)==\"table\"and bucket.candidates or{}return bucket end local function candidateHealth(candidate)local state=healthFor(candidate.next)local rank=state.state==\"healthy\"and 0 or(state.state==\"degraded\"and 1 or 2)return rank,state end local function directCandidate(value,targetId)local link,kind=activeLink(value,targetId)if link then return{next=targetId,hops=1,expires=now()+ROUTE_TTL,kind=kind,direct=true,label=link.label,mode=link.mode,masterId=link.masterId}end end local function validCandidates(targetId,value)local timestamp,out,seen=now(),{},{}local direct=directCandidate(value,targetId)if direct then out[#out+1],seen[direct.next..\":\"..direct.kind]=direct,true end local bucket=routes[tostring(targetId)]if bucket then for _,candidate in ipairs(routeBucket(targetId).candidates)do local key=tostring(candidate.next)..\":\"..tostring(candidate.kind or\"route\")if not seen[key]and candidate.expires>timestamp and candidate.hops>=1 and candidate.hops<=PACKET_TTL and activeLink(value,candidate.next)then out[#out+1],seen[key]=candidate,true end end end return out end local function compareCandidates(a,b)local ar,ah=candidateHealth(a)local br,bh=candidateHealth(b)if ar~=br then return ar<br end if(a.hops or PACKET_TTL)~=(b.hops or PACKET_TTL)then return(a.hops or PACKET_TTL)<(b.hops or PACKET_TTL)end if(ah.loss or 0)~=(bh.loss or 0)then return(ah.loss or 0)<(bh.loss or 0)end if(ah.rtt or 0)~=(bh.rtt or 0)then return(ah.rtt or 0)<(bh.rtt or 0)end return tostring(a.next)<tostring(b.next)end local function primaryCandidate(targetId,value,safe)local candidates=validCandidates(targetId,value)if#candidates==0 then return nil end table.sort(candidates,compareCandidates)local target,bucket,selected=tostring(targetId),routeBucket(targetId),candidates[1]local existing for _,item in ipairs(candidates)do if tostring(item.next)==tostring(bucket.primary)then existing=item;break end end if existing then local oldRank,newRank=candidateHealth(existing),candidateHealth(selected)if oldRank<newRank then selected=existing elseif oldRank==newRank and oldRank==0 and(selected.hops or 99)<(existing.hops or 99)then local health=healthFor(selected.next)if(health.successes or 0)<2 or(health.recoveredAt and now()-(health.stableSince or now())<PROBE_RECOVERY)then selected=existing end end end if safe then local rank,_,choices=candidateHealth(selected),nil,{}for _,item in ipairs(candidates)do local itemRank=candidateHealth(item)if itemRank==rank and item.hops==selected.hops then choices[#choices+1]=item end end if#choices>1 then table.sort(choices,function(a,b)local ah,bh=healthFor(a.next),healthFor(b.next)local aLoad,bLoad=currentInFlight(ah,now()),currentInFlight(bh,now())if aLoad~=bLoad then return aLoad<bLoad end return tostring(a.next)<tostring(b.next)end)selected=choices[1]end end if bucket.primary~=tostring(selected.next)then bucket.primary,bucket.changedAt,bucket.reason=tostring(selected.next),now(),existing and\"health/hop selection\"or\"initial selection\"trace(\"routing\",\"route_selected\",{destination=target,next=selected.next,hops=selected.hops,reason=bucket.reason})end return selected end local function nextHop(target,safe)local candidate=primaryCandidate(target,config(),safe)if candidate then local health=healthFor(candidate.next)if safe then markInFlight(health)end health.lastSelected=now()return candidate.next,candidate end routes[tostring(target)]=nil end local function transmit(items,channel,packet)if#items==0 then return false,\"no compatible modem attached\"end local sent,lastError=false,nil for _,item in ipairs(items)do local ok,err=pcall(item.modem.transmit,channel,channel,packet)if ok then sent=true else lastError=tostring(err)end end if not sent then transport.lastError=lastError or\"modem transmit failed\"end return sent,transport.lastError end local function send(target,input,forcedHop)local hop=forcedHop or nextHop(target,input.routeSafe==true and input.balanceSafe==true)if not hop then return false,\"peer is unreachable or requires rekey\"end local value,peer=config(),activeLink(config(),hop)if not peer then return false,\"direct route is unavailable\"end local packet=copy(input)packet.auth,packet.protocol,packet.from,packet.to=nil,PROTOCOL,id(),hop packet.origin,packet.destination=tostring(packet.origin or id()),tostring(packet.destination or target)packet.ttl=math.floor(tonumber(packet.ttl)or PACKET_TTL)packet.timestamp=now()if packet.ttl<1 or packet.ttl>PACKET_TTL then return false,\"invalid packet TTL\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 then packet.request_id=newRequestId()end if packet.confidential==true then local sealed,sealErr=sealBody(peer,packet)if not sealed then return false,sealErr end packet.body=sealed end local signed,signErr=sign(hop,peer,packet)if not signed then return false,signErr end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if not sent then trace(\"transport\",\"transmit_failed\",{type=packet.type,to=hop,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil healthFor(hop).lastTransmit=now()trace(\"routing\",\"packet_sent\",{type=packet.type,to=hop,destination=packet.destination,links=#links})return true end local function rememberReverse(packet,previousHop)if type(packet)~=\"table\"or type(packet.request_id)~=\"string\"or#packet.request_id==0 then return false end local requestId,origin=packet.request_id,tostring(packet.origin)local existing=reverseRoutes[requestId]if existing and(existing.previous~=tostring(previousHop)or existing.origin~=origin)then return false,\"reverse route collision\"end reverseRoutes[requestId]={previous=tostring(previousHop),origin=origin,expires=now()+ROUTE_TTL}local entries={}for key,route in pairs(reverseRoutes)do entries[#entries+1]={id=key,expires=route.expires or 0}end table.sort(entries,function(a,b)return a.expires<b.expires end)while#entries>MAX_REVERSE_ROUTES do reverseRoutes[table.remove(entries,1).id]=nil end return true end local function broadcast(packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";trace(\"discovery\",\"wireless_missing\");return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to=PROTOCOL,id(),0 out.timestamp=now()openChannels(config())local sent,err=transmit(links,DISCOVERY_CHANNEL,out)if not sent then trace(\"discovery\",\"transmit_failed\",{type=out.type,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil trace(\"discovery\",out.type==\"discover\"and\"announcement_sent\"or\"discovery_packet_sent\",{type=out.type})return true end local function publicTransmit(target,typeName,body)if not PUBLIC_UPDATE_TYPES[typeName]then return false,\"invalid public update packet type\"end local encoded,encodeErr=canonical(body or{})if not encoded then return false,encodeErr or\"invalid public update body\"end local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end openChannels(config())local packet={protocol=PUBLIC_UPDATE_PROTOCOL,type=typeName,from=id(),to=tostring(target),timestamp=now(),request_id=newRequestId(),body=body or{},}local sent,err=transmit(links,DISCOVERY_CHANNEL,packet)if not sent then transport.lastError=err or\"public update transmit failed\"trace(\"transport\",\"public_update_transmit_failed\",{type=typeName,to=target,error=transport.lastError})return false,transport.lastError end transport.lastTransmit,transport.lastError=now(),nil trace(\"transport\",\"public_update_sent\",{type=typeName,to=target,bytes=#encoded})return true end function M.publicSend(target,typeName,body)if tostring(target)==\"0\"or tostring(target)==\"\"then return false,\"public update target must be a computer ID\"end return publicTransmit(target,typeName,body)end function M.publicBroadcast(typeName,body)return publicTransmit(\"0\",typeName,body)end local function handshake(target,packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to,out.timestamp=PROTOCOL,id(),tostring(target),now()out.destination,out.ttl=tostring(target),1 openChannels(config())local sent,err=transmit(links,config().channel or CHANNEL,out)if not sent then trace(\"discovery\",\"handshake_transmit_failed\",{type=out.type,to=target,error=err});return false,err end transport.lastTransmit=now()trace(\"discovery\",out.type..\"_sent\",{to=target})return true end local function phraseTag(phrase,sessionId,hostId)return password.hmacSha256(phrase,\"ceetos/discovery/v2|\"..sessionId..\"|\"..tostring(hostId))end local function joinProof(phrase,sessionId,hostId,joinerId,nonce)return password.hmacSha256(phrase,\"ceetos/pair/join/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce)end local function confirmProof(phrase,sessionId,hostId,joinerId,nonce,mode,master)return password.hmacSha256(phrase,\"ceetos/pair/confirm/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce..\"|\"..tostring(mode)..\"|\"..tostring(master or\"\"))end local function linkKey(phrase,sessionId,hostId,joinerId,nonce)return password.derive(phrase,\"ceetos/link/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce,64)end local function keyId(key)local value=password.hmacSha256(key,\"ceetos/key-id/v2\")return value and value:sub(1,16)or\"\"end local function activeSession()return discovery and(discovery.state==\"hosting\"or discovery.state==\"searching\"or discovery.state==\"candidate\"or discovery.state==\"confirming\")end local function setLast(state,message)lastDiscovery={state=state,message=message,at=now()}end local function persistPair(peerId,key,metadata,masterId)local value=config()value.peers[tostring(peerId)]={protocol=2,rekeyRequired=false,key=key,keyId=keyId(key),role=\"operator\",mode=metadata.mode or\"peer\",master=tostring(masterId or\"\")==id(),masterId=tostring(masterId or\"\"),label=metadata.label,}save(value)remember(peerId,metadata.label,{mode=metadata.mode,masterId=masterId})routes[tostring(peerId)]=nil routesDirty=true audit.log(\"local\",\"peer.rekeyed\",{peer=peerId,mode=metadata.mode})end local function markRejected(reason)if discovery then discovery=nil end setLast(\"cancelled\",reason)end local function discoveryAnnouncement()if not discovery or discovery.state~=\"hosting\"then return false,\"no active host discovery\"end return broadcast({type=\"discover\",session=discovery.id,tag=discovery.tag,label=discovery.label,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,})end local function queueConfirmation(peerId,host)confirmations[host.id]=host local sent,err=handshake(peerId,{type=\"pair_confirm\",session=host.id,nonce=host.joinNonce,proof=host.confirmProof,label=host.label,mode=host.mode,master=host.masterId,})host.lastSent,host.retries=now(),0 if not sent then host.error=err end return sent,err end local function expireState(timestamp)if discovery and discovery.expires<=timestamp then local old=discovery.state discovery=nil setLast(\"expired\",old==\"searching\"and\"no matching discovery announcement received\"or\"discovery session expired\")trace(\"discovery\",\"session_expired\",{previous=old})end end local function boundMap(value,limit,timestamp)local entries={}for key,row in pairs(value)do entries[#entries+1]={key=key,at=type(row)==\"number\"and row or(type(row)==\"table\"and(row.expires or row.time or row.seen or row.lastAuthenticated or 0)or 0)}end table.sort(entries,function(a,b)if a.at~=b.at then return a.at<b.at end return tostring(a.key)<tostring(b.key)end)while#entries>limit do value[table.remove(entries,1).key]=nil end end local function pruneRouteBuckets(timestamp)local value=config()local entries={}for peerId,bucket in pairs(routes)do local latest=tonumber(bucket.changedAt)or 0 for _,candidate in ipairs(type(bucket.candidates)==\"table\"and bucket.candidates or{})do latest=math.max(latest,tonumber(candidate.expires)or 0)end entries[#entries+1]={peer=peerId,latest=latest}end table.sort(entries,function(a,b)if a.latest~=b.latest then return a.latest<b.latest end return tostring(a.peer)<tostring(b.peer)end)while#entries>ROUTE_BUCKET_LIMIT do local old=table.remove(entries,1)routes[old.peer],routesDirty=nil,true trace(\"routing\",\"route_bucket_evicted\",{destination=old.peer})end for peerId,state in pairs(linkHealth)do if not activeLink(value,peerId)and not routes[peerId]then linkHealth[peerId]=nil end end for peerId in pairs(advertisedRoutes)do if not activeLink(value,peerId)then advertisedRoutes[peerId]=nil end end boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)end local function controller(value)value=value or config()if value.controller and tostring(value.controller)~=\"\"then local chosen=tostring(value.controller)if chosen==id()or activeLink(value,chosen)then return chosen end local known=routes[chosen]if known then if known.expires and known.expires>now()then return chosen end if type(known.candidates)==\"table\"then for _,candidate in ipairs(known.candidates)do if(candidate.expires or 0)>now()and activeLink(value,candidate.next)then return chosen end end end end trace(\"routing\",\"controller_unreachable\",{controller=chosen})end local selected=tonumber(id())or 0 for peerId in pairs(value.peers)do if activePeer(value,peerId)then local n=tonumber(peerId);if n and n<selected then selected=n end end end for peerId,route in pairs(routes)do local reachable=route.expires and route.expires>now()if type(route.candidates)==\"table\"then reachable=false for _,candidate in ipairs(route.candidates)do if(candidate.expires or 0)>now()then reachable=true;break end end end if reachable then local n=tonumber(peerId);if n and n<selected then selected=n end end end return tostring(selected)end local function meshConfig(value)value=value or config()local mesh=value.mesh if type(mesh)==\"table\"and type(mesh.id)==\"string\"and#mesh.id>=16 and type(mesh.root)==\"string\"and#mesh.root>=32 and tonumber(mesh.epoch)then return mesh end return nil end local function meshMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,mesh=packet.mesh,epoch=packet.epoch,nonce=packet.nonce,offer=packet.offer,timestamp=packet.timestamp})end local function meshTag(mesh,packet)local material=meshMaterial(packet)return material and password.hmacSha256(mesh.root,material)or nil end local function meshPacket(typeName,target,fields)local value,mesh=config(),meshConfig()if not mesh then return false,\"mesh enrollment is pending\"end local packet=copy(fields or{})packet.protocol,packet.type,packet.from,packet.to=PROTOCOL,typeName,id(),target and tostring(target)or 0 packet.mesh,packet.epoch,packet.timestamp=mesh.id,mesh.epoch,now()packet.tag=meshTag(mesh,packet)if not packet.tag then return false,\"could not authenticate mesh packet\"end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if sent then trace(\"routing\",typeName..\"_sent\",{to=packet.to,mesh=mesh.id:sub(1,8)})end return sent,err end local function deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)local left,right=tostring(id()),tostring(peerId)if left>right then left,right=right,left end return password.hmacSha256(mesh.root,\"ceetos/mesh-edge/v1|\"..tostring(mesh.epoch)..\"|\"..left..\"|\"..right..\"|\"..tostring(firstNonce)..\"|\"..tostring(secondNonce))end local function ownsMeshOffer(peerId)local ours,theirs=tonumber(id()),tonumber(peerId)if ours and theirs then return ours<theirs end return tostring(id())<tostring(peerId)end local function installAutoEdge(mesh,peerId,firstNonce,secondNonce,peerLabel)peerId=tostring(peerId)local value=config()if activePeer(value,peerId)then return false,\"manual direct link already exists\"end local key=deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)if not key then return false,\"could not derive mesh edge\"end autoEdges[peerId]={key=key,label=peerLabel,mesh=mesh.id,epoch=mesh.epoch,expires=now()+ROUTE_TTL,firstNonce=firstNonce,secondNonce=secondNonce}local state=healthFor(peerId)state.state,state.successes,state.misses,state.lastAuthenticated,state.stableSince=\"healthy\",2,0,now(),now()routesDirty,meshDirty=true,true trace(\"routing\",\"mesh_edge_active\",{peer=peerId,mesh=mesh.id:sub(1,8)})return true end local function meshEnrollmentAad(from,to,meshId,epoch,nonceCounter)return canonical({protocol=PROTOCOL,type=\"mesh_enroll\",from=tostring(from),to=tostring(to),mesh=meshId,epoch=tonumber(epoch),counter=tonumber(nonceCounter)})end local function sendEnrollment(peerId)local value,mesh,peer=config(),meshConfig(),activePeer(config(),peerId)if not mesh or not peer then return false,\"mesh or direct link unavailable\"end local _,nonceCounter=counter(peerId)local aad=meshEnrollmentAad(id(),peerId,mesh.id,mesh.epoch,nonceCounter)local nonce=meshCrypto.nonce(peer.key,nonceCounter,\"mesh-enroll|\"..id()..\"|\"..tostring(peerId))local plaintext=textutils.serialise({id=mesh.id,epoch=mesh.epoch,root=mesh.root},{compact=true})local envelope,err=meshCrypto.seal(peer.key,nonce,aad,plaintext)if not envelope then return false,err end local sent,sendErr=send(peerId,{type=\"mesh_enroll\",body={mesh=mesh.id,epoch=mesh.epoch,counter=nonceCounter,envelope=envelope},request_id=newRequestId()},peerId)if sent then trace(\"routing\",\"mesh_enrollment_sent\",{to=peerId,epoch=mesh.epoch})end return sent,sendErr end local function acceptEnrollment(from,peer,packet)if not activePeer(config(),from)then return rejectPacket(\"mesh enrollment requires a manual direct link\",packet)end local body=packet.body if type(body)~=\"table\"or type(body.mesh)~=\"string\"or type(body.envelope)~=\"table\"or not tonumber(body.epoch)or not tonumber(body.counter)then return rejectPacket(\"malformed_mesh_enrollment\",packet)end local aad=meshEnrollmentAad(from,id(),body.mesh,body.epoch,body.counter)local plaintext,err=meshCrypto.open(peer.key,body.envelope,aad)if not plaintext then return rejectPacket(err or\"mesh enrollment authentication failed\",packet)end local ok,mesh=pcall(textutils.unserialise,plaintext)if not ok or type(mesh)~=\"table\"or mesh.id~=body.mesh or tonumber(mesh.epoch)~=tonumber(body.epoch)or type(mesh.root)~=\"string\"or#mesh.root<32 then return rejectPacket(\"invalid_mesh_enrollment\",packet)end local value,existing=config(),meshConfig()if existing and existing.id==mesh.id and tonumber(existing.epoch)>tonumber(mesh.epoch)then return end value.mesh={id=mesh.id,epoch=tonumber(mesh.epoch),root=mesh.root,enrolledAt=now(),enrolledBy=tostring(from)}save(value)meshDirty,routesDirty=true,true trace(\"routing\",\"mesh_enrolled\",{from=from,mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end local function ensureMeshEnrollment(timestamp)local value,mesh=config(),meshConfig()if not mesh then if(M._meshBootstrapAt or 0)>timestamp or controller(value)~=id()then return end value.mesh={id=password.newSalt(\"mesh-id:\"..id()),root=password.newSalt(\"mesh-root:\"..id()),epoch=1,createdAt=timestamp,controller=id()}save(value);mesh,meshDirty,routesDirty=value.mesh,true,true trace(\"routing\",\"mesh_created\",{mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end for _,peerId in ipairs(allDirectLinks(value))do if activePeer(value,peerId)then local previous=meshEnrollmentSends[peerId]if not previous or previous.epoch~=mesh.epoch or timestamp-previous.at>=MESH_FULL_INTERVAL then local sent=sendEnrollment(peerId)if sent then meshEnrollmentSends[peerId]={epoch=mesh.epoch,at=timestamp}end end end end end local function meshBeacon(timestamp)local mesh=meshConfig()if not mesh or timestamp-lastMeshBeacon<MESH_BEACON_INTERVAL then return end lastMeshBeacon=timestamp meshPacket(\"mesh_beacon\",nil,{nonce=password.newSalt(\"mesh-beacon:\"..id()),label=label()})end local function verifyMeshPacket(packet)local mesh=meshConfig()if not mesh or type(packet)~=\"table\"or packet.protocol~=PROTOCOL or packet.mesh~=mesh.id or tonumber(packet.epoch)~=tonumber(mesh.epoch)then return false,\"mesh membership proof failed\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid mesh sender\"end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 then return false,\"invalid mesh nonce\"end if math.abs(now()-(tonumber(packet.timestamp)or 0))>ROUTE_TTL then return false,\"stale mesh packet\"end local material,tag=meshMaterial(packet),packet.tag local expected=material and password.hmacSha256(mesh.root,material)if type(tag)~=\"string\"or not expected or not password.constantTimeEqual(expected,tag)then return false,\"invalid mesh packet tag\"end local replay=tostring(packet.from)..\"|\"..tostring(packet.type)..\"|\"..tostring(packet.nonce)..\"|\"..tostring(packet.offer or\"\")if meshSeen[replay]and meshSeen[replay]+ROUTE_TTL>now()then return false,\"replayed mesh packet\"end meshSeen[replay]=now()return true,mesh end local function handleMeshPacket(packet,distance)local valid,meshOrErr=verifyMeshPacket(packet)if not valid then return rejectPacket(meshOrErr,packet,nil,distance)end local mesh,from=meshOrErr,tostring(packet.from)if from==id()then return end if packet.type==\"mesh_beacon\"then remember(from,packet.label,{mesh=mesh.id})if not activePeer(config(),from)and not autoEdges[from]and ownsMeshOffer(from)then local nonce=password.newSalt(\"mesh-offer:\"..from)meshOffers[from]={offer=nonce,expires=now()+DISCOVERY_TTL}meshPacket(\"mesh_edge_offer\",from,{nonce=nonce,label=label()})end return end if not isForUs(packet.to)then return rejectPacket(\"mesh packet addressed to another peer\",packet,nil,distance)end if packet.type==\"mesh_edge_offer\"then if activePeer(config(),from)then return end local response=password.newSalt(\"mesh-accept:\"..from)installAutoEdge(mesh,from,packet.nonce,response,packet.label)return meshPacket(\"mesh_edge_accept\",from,{nonce=response,offer=packet.nonce,label=label()})end if packet.type==\"mesh_edge_accept\"then local offer=meshOffers[from]if not offer or offer.expires<=now()or offer.offer~=packet.offer then return rejectPacket(\"unexpected mesh edge acceptance\",packet,nil,distance)end meshOffers[from]=nil return installAutoEdge(mesh,from,offer.offer,packet.nonce,packet.label)end end local function probeLinks(timestamp)local value=config()for _,peerId in ipairs(allDirectLinks(value))do local health=healthFor(peerId)local interval=health.state==\"offline\"and PROBE_INTERVAL*3 or PROBE_INTERVAL if timestamp-(health.lastAuthenticated or 0)>=interval and timestamp-(health.lastProbe or 0)>=interval then if health.awaiting then health.misses=(health.misses or 0)+1 health.loss=math.min(1,((health.loss or 0)*3+1)/4)local nextState=health.misses>=PROBE_OFFLINE and\"offline\"or(health.misses>=PROBE_DEGRADED and\"degraded\"or health.state)if nextState~=health.state then health.state,health.successes,health.recoveredAt=nextState,0,nil trace(\"routing\",\"link_\"..nextState,{peer=peerId,misses=health.misses})end routesDirty=true end health.awaiting,health.lastProbe,health.probeToken=true,timestamp,password.newSalt(\"mesh-probe:\"..peerId)send(peerId,{type=\"mesh_probe\",body={token=health.probeToken},request_id=newRequestId()},peerId)end end end local function advertisedMembers(value,peerId,timestamp)local members={}for other,manual in pairs(value.peers)do if other~=peerId and activeLink(value,other)and linkState(other)==\"healthy\"then members[other]={label=manual.label,mode=manual.mode,masterId=manual.masterId,hops=1,kind=\"direct\"}end end for other,edge in pairs(autoEdges)do if other~=peerId and edge.expires>timestamp and linkState(other)==\"healthy\"then members[other]={label=edge.label,mode=\"peer\",hops=1,kind=\"mesh\"}end end for other in pairs(routes)do if other~=peerId and not members[other]then local candidate=primaryCandidate(other,value,false)if candidate and candidate.next~=peerId and linkState(candidate.next)==\"healthy\"then members[other]={label=candidate.label,mode=candidate.mode,masterId=candidate.masterId,hops=candidate.hops,kind=candidate.kind or\"route\"}end end end return members end local function sameAdvertisement(left,right)local leftValue,leftErr=canonical(left)local rightValue,rightErr=canonical(right)return leftValue~=nil and rightValue~=nil and not leftErr and not rightErr and leftValue==rightValue end local function advertiseRoutes(force)local timestamp,value=now(),config()if not force and not routesDirty and timestamp-lastRouteAdvertisement<ROUTE_INTERVAL then return end lastRouteAdvertisement,routesDirty=timestamp,false local full=timestamp-lastMeshFull>=MESH_FULL_INTERVAL if full then lastMeshFull=timestamp end for _,peerId in ipairs(allDirectLinks(value))do if linkUsable(value,peerId,false)then local desired,previous=advertisedMembers(value,peerId,timestamp),advertisedRoutes[peerId]or{}local members,withdrawals={},{}if full then members=desired else for target,meta in pairs(desired)do if not sameAdvertisement(meta,previous[target])then members[target]=meta end end for target in pairs(previous)do if not desired[target]then withdrawals[#withdrawals+1]=target end end end table.sort(withdrawals,function(a,b)return tostring(a)<tostring(b)end)if full or next(members)~=nil or#withdrawals>0 then routeSequence=routeSequence+1 local body={sequence=routeSequence,routeVersion=2,full=full,controller=controller(value),members=members,withdrawals=withdrawals}if send(peerId,{type=\"route_advertise\",body=body,routeSafe=true,request_id=newRequestId()})then advertisedRoutes[peerId]=copy(desired)trace(\"routing\",full and\"route_snapshot_sent\"or\"route_delta_sent\",{to=peerId,changes=(full and 0 or#withdrawals)})end end else advertisedRoutes[peerId]=nil end end end function M.start()migrateV1Links()loadSecurity()assert(meshCrypto.selfTest(),\"CeetOS mesh cryptography self-test failed\")openChannels(config())local status=M.transportStatus()trace(\"transport\",status.wireless and\"wireless_modem_detected\"or\"wireless_modem_missing\",{name=status.name})routesDirty,M._meshBootstrapAt=true,now()end function M.transportStatus()local wireless=wirelessModems()transport.modem,transport.wireless=#modems()>0,#wireless>0 transport.name=wireless[1]and wireless[1].name or nil local out=copy(transport)out.wirelessLinks,out.wirelessLinkCount={},#wireless for _,item in ipairs(wireless)do out.wirelessLinks[#out.wirelessLinks+1]=item.name end out.usesAllWirelessLinks,out.protocol=true,2 out.directPeers,out.manualDirectPeers,out.meshPeers,out.rekeyRequiredPeers,out.routedPeers=0,0,0,0,0 out.healthyLinks,out.degradedLinks,out.offlineLinks=0,0,0 local value=config()for peerId,peer in pairs(value.peers)do if activePeer(value,peerId)then out.directPeers,out.manualDirectPeers=out.directPeers+1,out.manualDirectPeers+1 elseif peer.rekeyRequired then out.rekeyRequiredPeers=out.rekeyRequiredPeers+1 end end for peerId,edge in pairs(autoEdges)do if edge.expires>now()then out.meshPeers,out.directPeers=out.meshPeers+1,out.directPeers+1 end end for peerId,health in pairs(linkHealth)do if health.state==\"healthy\"then out.healthyLinks=out.healthyLinks+1 elseif health.state==\"degraded\"then out.degradedLinks=out.degradedLinks+1 elseif health.state==\"offline\"then out.offlineLinks=out.offlineLinks+1 end end for peerId,bucket in pairs(routes)do local usable=primaryCandidate(peerId,value,false)if usable and not value.peers[peerId]and not autoEdges[peerId]then out.routedPeers=out.routedPeers+1 end end local mesh=meshConfig(value)out.mesh=mesh and{id=mesh.id:sub(1,8),epoch=mesh.epoch,enrolled=true}or{enrolled=false}out.health={healthy=out.healthyLinks,degraded=out.degradedLinks,offline=out.offlineLinks}return out end function M.transportTrace(kind)if kind==\"discovery\"or kind==\"routing\"or kind==\"transport\"then return copy(traces[kind])end return{discovery=copy(traces.discovery),routing=copy(traces.routing),transport=copy(traces.transport)}end function M.discovery()expireState(now())return copy(discovery)end function M.discoveryStatus()expireState(now())local candidate=discovery and discovery.candidate and{id=discovery.candidate.from,label=discovery.candidate.label,mode=discovery.candidate.mode,master=discovery.candidate.master,}or nil local session=discovery and{session=discovery.id,state=discovery.state,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,retries=discovery.retries or 0,candidate=candidate and copy(candidate)or nil,}or nil local state=session and session.state or(lastDiscovery and lastDiscovery.state or\"inactive\")return{state=state,active=session~=nil,lastState=lastDiscovery and lastDiscovery.state or\"inactive\",lastMessage=lastDiscovery and lastDiscovery.message or nil,session=session,searching=session and session.state==\"searching\"or false,candidate=candidate,discovered=#M.seenPeers(),transport=M.transportStatus(),message=(discovery and discovery.error)or(lastDiscovery and lastDiscovery.message),}end function M.startDiscovery(mode,masterSide,phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end mode=mode==\"master\"and\"master\"or\"peer\"masterSide=masterSide==\"joiner\"and\"joiner\"or\"initiator\"local sessionId=password.newSalt(\"discovery:\"..id())discovery={id=sessionId,state=\"hosting\",phrase=normalized,tag=phraseTag(normalized,sessionId,id()),mode=mode,masterSide=masterSide,label=label(),initiator=id(),expires=now()+DISCOVERY_TTL,retries=0,lastBroadcast=0,}local sent,err=discoveryAnnouncement()if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastBroadcast=now()setLast(\"hosting\")return true,{state=\"hosting\",session=sessionId,expires=discovery.expires}end function M.joinDiscovery(phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end local candidate for _,item in pairs(discovered)do if item.expires>now()and password.constantTimeEqual(item.tag or\"\",phraseTag(normalized,item.session,item.from))then candidate=item;break end end discovery={state=\"searching\",phrase=normalized,expires=now()+DISCOVERY_TTL,retries=0,lastQuery=0}if candidate then discovery.state,discovery.candidate=\"candidate\",candidate return true,{state=\"candidate\",candidate={id=candidate.from,label=candidate.label,mode=candidate.mode,master=candidate.master}}end local sent,err=broadcast({type=\"discover_query\"})if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastQuery=now()setLast(\"searching\",\"waiting for matching discovery announcement\")return true,{state=\"searching\"}end function M.confirmDiscovery()if not discovery or discovery.state~=\"candidate\"or not discovery.candidate then return false,\"no discovery candidate is awaiting confirmation\"end local candidate,value=discovery.candidate,config()local existing=value.peers[tostring(candidate.from)]if existing and not existing.rekeyRequired then return false,\"computer is already a network member\"end if routes[tostring(candidate.from)]and not existing then return false,\"computer is already a routed network member\"end local nonce=password.newSalt(\"pair-join:\"..candidate.session)local proof=joinProof(discovery.phrase,candidate.session,candidate.from,id(),nonce)discovery.state,discovery.joinNonce,discovery.joinProof,discovery.lastSent,discovery.retries=\"confirming\",nonce,proof,now(),0 local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=nonce,proof=proof,label=label()})if not sent then discovery.error=err;return false,err end trace(\"discovery\",\"pair_confirmation_requested\",{peer=candidate.from})return true end function M.cancelDiscovery()if discovery and discovery.state==\"hosting\"then broadcast({type=\"discover_cancel\",session=discovery.id})end discovery=nil setLast(\"cancelled\",\"discovery cancelled\")trace(\"discovery\",\"session_cancelled\")return true end function M.normalizePhrase(value)if type(value)~=\"string\"then return nil,\"phrase is required\"end if value:find(\"[%z\\1-\\31\\127]\")then return nil,\"phrase contains control characters\"end value=value:gsub(\"^%s+\",\"\"):gsub(\"%s+$\",\"\")if#value<8 then return nil,\"phrase must be at least 8 characters\"end if#value>128 then return nil,\"phrase must be at most 128 characters\"end return value end function M.tick()local timestamp=now()expireState(timestamp)if discovery then if discovery.state==\"hosting\"and timestamp-(discovery.lastBroadcast or 0)>=math.min(30000,DISCOVERY_INTERVAL*(2^math.min(discovery.retries or 0,4)))then local sent,err=discoveryAnnouncement()discovery.lastBroadcast=timestamp discovery.retries=(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"searching\"and timestamp-(discovery.lastQuery or 0)>=DISCOVERY_INTERVAL then local sent,err=broadcast({type=\"discover_query\"})discovery.lastQuery,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"confirming\"and timestamp-(discovery.lastSent or 0)>=PAIR_RETRY then local candidate=discovery.candidate local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=discovery.joinNonce,proof=discovery.joinProof,label=label()})discovery.lastSent,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end end end for sessionId,item in pairs(discovered)do if item.expires<=timestamp then discovered[sessionId]=nil end end for sessionId,record in pairs(confirmations)do if record.expires<=timestamp then confirmations[sessionId]=nil elseif timestamp-(record.lastSent or 0)>=PAIR_RETRY then queueConfirmation(record.peer,record)end end for peerId,bucket in pairs(routes)do local kept={}for _,candidate in ipairs(routeBucket(peerId).candidates)do if candidate.expires>timestamp then kept[#kept+1]=candidate end end bucket.candidates=kept if#kept==0 and not activeLink(config(),peerId)then routes[peerId],routesDirty=nil,true end end for peerId,edge in pairs(autoEdges)do if edge.expires<=timestamp then autoEdges[peerId],routesDirty=nil,true;trace(\"routing\",\"mesh_edge_expired\",{peer=peerId})end end for key,seenAt in pairs(meshSeen)do if seenAt+ROUTE_TTL<=timestamp then meshSeen[key]=nil end end for peerId,offer in pairs(meshOffers)do if offer.expires<=timestamp then meshOffers[peerId]=nil end end for requestId,seenAt in pairs(seenPackets)do if seenAt+ROUTE_TTL<=timestamp then seenPackets[requestId]=nil end end for requestId,route in pairs(reverseRoutes)do if route.expires<=timestamp then reverseRoutes[requestId]=nil end end boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)pruneRouteBuckets(timestamp)ensureMeshEnrollment(timestamp)meshBeacon(timestamp)probeLinks(timestamp)advertiseRoutes(false)end function M.peers()local out,value,seen={},config(),read(SEEN_PATH,{})for peerId,peer in pairs(value.peers)do out[#out+1]={id=peerId,label=peer.label or(seen[peerId]and seen[peerId].label),role=peer.role or\"operator\",mode=peer.mode or\"peer\",master=peer.master==true,masterId=peer.masterId,direct=true,active=activePeer(value,peerId)~=nil,rekeyRequired=peer.rekeyRequired==true or peer.protocol~=2,health=linkState(peerId),auto=false,}end for peerId,edge in pairs(autoEdges)do if not value.peers[peerId]and edge.expires>now()then out[#out+1]={id=peerId,label=edge.label or(seen[peerId]and seen[peerId].label),role=\"mesh\",mode=\"peer\",direct=true,auto=true,active=true,health=linkState(peerId)}end end for peerId in pairs(routes)do if not value.peers[peerId]and not autoEdges[peerId]then local route=primaryCandidate(peerId,value,false)if route then out[#out+1]={id=peerId,label=route.label or(seen[peerId]and seen[peerId].label),role=\"routed\",mode=route.mode or\"peer\",masterId=route.masterId,routed=true,hops=route.hops,next=route.next,health=linkState(route.next),alternates=#routeBucket(peerId).candidates-1}end end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.directPeers()local out={}for _,peer in ipairs(M.peers())do if peer.direct and peer.active then out[#out+1]=peer end end return out end function M.seenPeers()local out={}for peerId,item in pairs(read(SEEN_PATH,{}))do if not item.seen or item.seen+DISCOVERY_TTL*2>now()then out[#out+1]={id=peerId,label=item.label,seen=item.seen,session=item.session}end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.routeStatus(target)local value,out=config(),{}local function row(peerId)local selected=primaryCandidate(peerId,value,false)if not selected then return end local health=healthFor(selected.next)local alternates={}for _,candidate in ipairs(validCandidates(peerId,value))do if tostring(candidate.next)~=tostring(selected.next)then local state=healthFor(candidate.next)alternates[#alternates+1]={next=candidate.next,hops=candidate.hops,kind=candidate.kind or\"route\",health=state.state,loss=state.loss or 0,rtt=state.rtt,distance=state.lastDistance}end end table.sort(alternates,compareCandidates)while#alternates>ROUTE_CANDIDATE_LIMIT-1 do table.remove(alternates)end out[#out+1]={id=tostring(peerId),label=selected.label,next=selected.next,hops=selected.hops,kind=selected.kind or\"route\",health=health.state,loss=health.loss or 0,rtt=health.rtt,distance=health.lastDistance,selectedAt=routeBucket(peerId).changedAt,reason=routeBucket(peerId).reason,alternates=alternates,}end if target then row(tostring(target))else local ids,seen={},{}for peerId in pairs(value.peers)do ids[#ids+1],seen[peerId]=peerId,true end for peerId in pairs(autoEdges)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end for peerId in pairs(routes)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)for _,peerId in ipairs(ids)do row(peerId)end end return out end function M.statusSnapshot()return{protocol=2,transport=M.transportStatus(),discovery=M.discoveryStatus(),peers=M.peers(),routes=M.routeStatus(),trace=M.transportTrace(),controller=M.controller()}end function M.controller()return controller()end function M.isDirectController(from,packet)return tostring(from)==tostring(controller())and type(packet)==\"table\"and tostring(packet.origin or\"\")==tostring(from)end function M.setController(value)assert(tonumber(value),\"controller must be a computer ID\")local saved=config();saved.controller=tostring(value);save(saved);routesDirty=true audit.log(\"local\",\"jobs.controller\",{controller=saved.controller})return saved.controller end function M.request(target,typeName,body,options)if type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid request type\"end local destination=tostring(target)local value=config()if not primaryCandidate(destination,value,options and options.safe==true)then return false,\"peer is unreachable, degraded, or requires rekey\"end return send(destination,{type=typeName,body=body or{},origin=id(),routeSafe=options and options.safe==true,balanceSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId()})end function M.reply(request,typeName,body,options)if type(request)~=\"table\"or type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid reply\"end local requestId,destination=request.request_id,tostring(request.origin or\"\")local reverse=type(requestId)==\"string\"and reverseRoutes[requestId]or nil if destination==\"\"or not reverse or reverse.expires<=now()or reverse.origin~=destination then return false,\"reverse reply route is unavailable\"end return send(destination,{type=typeName,body=body or{},origin=id(),destination=destination,reply_to=requestId,routeSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId(),},reverse.previous)end function M.offer()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.accept()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.discover()return broadcast({type=\"discover_query\"})end rejectPacket=function(reason,packet,channel,distance)transport.rejected=transport.rejected+1 trace(\"transport\",\"packet_rejected\",{reason=reason,type=type(packet)==\"table\"and packet.type or nil,channel=channel,distance=distance,from=type(packet)==\"table\"and packet.from or nil})end local function handleDiscovery(packet,channel,distance)local from=tostring(packet.from)if packet.type==\"discover_cancel\"and isBroadcast(packet.to)then discovered[tostring(packet.session)]=nil trace(\"discovery\",\"cancel_received\",{from=from,distance=distance})return end if packet.type==\"discover_query\"and isBroadcast(packet.to)and discovery and discovery.state==\"hosting\"then discoveryAnnouncement()trace(\"discovery\",\"query_answered\",{from=from,distance=distance})return end if packet.type==\"discover\"and isBroadcast(packet.to)and from~=id()then if type(packet.session)~=\"string\"or#packet.session<16 or type(packet.tag)~=\"string\"or#packet.tag~=64 then return rejectPacket(\"malformed_discovery\",packet,channel,distance)end local expires=tonumber(packet.expires)or(now()+DISCOVERY_TTL)discovered[packet.session]={session=packet.session,from=from,tag=packet.tag,label=tostring(packet.label or(\"Computer \"..from)):sub(1,128),mode=packet.mode==\"master\"and\"master\"or\"peer\",master=packet.master==\"joiner\"and\"joiner\"or\"initiator\",expires=math.min(expires,now()+DISCOVERY_TTL)}remember(from,packet.label,{session=packet.session})trace(\"discovery\",\"announcement_received\",{from=from,label=packet.label,distance=distance})if discovery and discovery.state==\"searching\"and password.constantTimeEqual(packet.tag,phraseTag(discovery.phrase,packet.session,from))then local value,existing=config(),config().peers[from]if existing and not existing.rekeyRequired then markRejected(\"computer is already a direct peer\")elseif routes[from]and not existing then markRejected(\"computer is already a routed network member\")else discovery.state,discovery.candidate,discovery.error=\"candidate\",discovered[packet.session],nil setLast(\"candidate\",\"matching computer found; confirm pairing\")trace(\"discovery\",\"candidate_found\",{from=from,label=packet.label,distance=distance})end end return end end local function handlePairJoin(packet,distance)if not discovery or discovery.state~=\"hosting\"or packet.session~=discovery.id then return end local from=tostring(packet.from)local value,existing=config(),config().peers[from]if(existing and not existing.rekeyRequired)or(routes[from]and not existing)then handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"already_network_member\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"already_network_member\"})return end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 or type(packet.proof)~=\"string\"or#packet.proof~=64 then return rejectPacket(\"malformed_pair_join\",packet,nil,distance)end local expected=joinProof(discovery.phrase,discovery.id,id(),from,packet.nonce)if not password.constantTimeEqual(expected,packet.proof)then discovery.failures=(discovery.failures or 0)+1 if discovery.failures>=5 then markRejected(\"too many invalid pairing proofs\")end handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"phrase_mismatch\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"phrase_mismatch\"})return end local masterId=discovery.mode==\"master\"and(discovery.masterSide==\"initiator\"and id()or from)or\"\"local key,keyErr=linkKey(discovery.phrase,discovery.id,id(),from,packet.nonce)if not key then return markRejected(keyErr)end persistPair(from,key,{mode=discovery.mode,label=packet.label},masterId)local record={id=discovery.id,peer=from,joinNonce=packet.nonce,mode=discovery.mode,masterId=masterId,label=label(),expires=now()+DISCOVERY_TTL}record.confirmProof=confirmProof(discovery.phrase,record.id,id(),from,record.joinNonce,record.mode,record.masterId)discovery=nil setLast(\"paired\",\"awaiting pairing acknowledgement\")trace(\"discovery\",\"pair_join_verified\",{from=from,distance=distance})return queueConfirmation(from,record)end local function handlePairConfirm(packet,distance)if not discovery or discovery.state~=\"confirming\"or not discovery.candidate or packet.session~=discovery.candidate.session then return end local from=tostring(packet.from)if from~=tostring(discovery.candidate.from)or packet.nonce~=discovery.joinNonce then return rejectPacket(\"unexpected_pair_confirmation\",packet,nil,distance)end local expected=confirmProof(discovery.phrase,packet.session,from,id(),discovery.joinNonce,packet.mode==\"master\"and\"master\"or\"peer\",packet.master or\"\")if not password.constantTimeEqual(expected,packet.proof or\"\")then return markRejected(\"pair confirmation proof did not match\")end local key,err=linkKey(discovery.phrase,packet.session,from,id(),discovery.joinNonce)if not key then return markRejected(err)end persistPair(from,key,{mode=packet.mode,label=packet.label},packet.master)local sessionId=packet.session discovery=nil setLast(\"paired\",\"paired with \"..tostring(packet.label or from))handshake(from,{type=\"pair_ack\",session=sessionId,proof=password.hmacSha256(key,\"ceetos/pair/ack/v2|\"..sessionId)})trace(\"discovery\",\"pair_confirmed\",{from=from,distance=distance})return true end local function handlePairAck(packet)local record=confirmations[packet.session]if not record or tostring(record.peer)~=tostring(packet.from)then return end local value,peer=config(),activePeer(config(),record.peer)if not peer then return end local expected=password.hmacSha256(peer.key,\"ceetos/pair/ack/v2|\"..packet.session)if password.constantTimeEqual(expected,packet.proof or\"\")then confirmations[packet.session]=nil setLast(\"paired\",\"paired with \"..tostring(record.peer))routesDirty=true trace(\"discovery\",\"pair_acknowledged\",{from=packet.from})end end local function handleRouteAdvertisement(from,packet)local body=packet.body if type(body)~=\"table\"or type(body.sequence)~=\"number\"or type(body.members)~=\"table\"or(body.withdrawals~=nil and type(body.withdrawals)~=\"table\")then return rejectPacket(\"malformed_route_advertisement\",packet)end local key=tostring(from)M._routeSequences=M._routeSequences or{}if(M._routeSequences[key]or-1)>=body.sequence then return end M._routeSequences[key]=body.sequence local value,changed,count=config(),false,0 if body.controller and not value.controller then value.controller,changed=tostring(body.controller),true end local announced={}for advertisedId,meta in pairs(body.members)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local peerId=tostring(advertisedId)announced[peerId]=true if peerId~=id()and peerId~=key and type(meta)==\"table\"then local hops=math.floor(tonumber(meta.hops)or 0)+1 if hops>1 and hops<=PACKET_TTL and type(meta.label)~=\"table\"and type(meta.mode)~=\"table\"then local bucket,found=routeBucket(peerId),nil for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)==key then found=candidate;break end end if found then local metadataChanged=found.hops~=hops or found.label~=meta.label or found.mode~=meta.mode or tostring(found.masterId or\"\")~=tostring(meta.masterId or\"\")or found.kind~=(meta.kind or\"route\")found.hops,found.expires=hops,now()+ROUTE_TTL found.label,found.mode,found.masterId,found.kind=meta.label,meta.mode,meta.masterId,meta.kind or\"route\"if metadataChanged then changed=true end else bucket.candidates[#bucket.candidates+1]={next=key,hops=hops,expires=now()+ROUTE_TTL,label=type(meta.label)==\"string\"and meta.label:sub(1,128)or nil,mode=meta.mode==\"master\"and\"master\"or\"peer\",masterId=meta.masterId and tostring(meta.masterId)or nil,kind=meta.kind==\"mesh\"and\"mesh\"or\"route\"}table.sort(bucket.candidates,compareCandidates)while#bucket.candidates>ROUTE_CANDIDATE_LIMIT do table.remove(bucket.candidates)end changed=true end end end end local withdrawals=body.withdrawals or{}for _,withdrawnId in pairs(withdrawals)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local bucket=routes[tostring(withdrawnId)]if bucket and type(bucket.candidates)==\"table\"then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end if body.full==true then for peerId,bucket in pairs(routes)do if type(bucket.candidates)==\"table\"and not announced[tostring(peerId)]then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end end if changed then if value.controller then save(value)end;routesDirty=true;trace(\"routing\",\"route_table_updated\",{from=from})end end local function handleProbe(from,packet)local token=type(packet.body)==\"table\"and packet.body.token if type(token)~=\"string\"or#token<16 or#token>128 then return rejectPacket(\"malformed link probe\",packet)end touchLink(from,nil,\"probe\")return send(from,{type=\"mesh_probe_ack\",body={token=token},request_id=newRequestId()},from)end local function handleProbeAck(from,packet)local health,token=healthFor(from),type(packet.body)==\"table\"and packet.body.token if not health.awaiting or token~=health.probeToken then return rejectPacket(\"unexpected link probe acknowledgement\",packet)end local sample=math.max(0,now()-(health.lastProbe or now()))health.rtt=health.rtt and math.floor((health.rtt*3+sample)/4)or sample health.awaiting,health.misses,health.probeToken=false,0,nil touchLink(from,health.lastDistance,\"probe_ack\")end function M.handle(event)if event[1]~=\"modem_message\"then return end local channel,packet,distance=event[3],event[5],event[6]local expected=false for _,item in ipairs(transport.channels or{})do if channel==item then expected=true;break end end if not expected then return rejectPacket(\"unexpected_channel\",packet,channel,distance)end transport.lastReceive,transport.lastDistance=now(),distance if type(packet)~=\"table\"then return rejectPacket(\"packet_not_table\",packet,channel,distance)end if packet.protocol==PUBLIC_UPDATE_PROTOCOL then if channel~=DISCOVERY_CHANNEL or not PUBLIC_UPDATE_TYPES[packet.type]or type(packet.from)~=\"string\"and type(packet.from)~=\"number\"or not(isForUs(packet.to)or isBroadcast(packet.to))then return rejectPacket(\"invalid_public_update_packet\",packet,channel,distance)end local encoded,encodeErr=canonical(packet.body or{})if not encoded then return rejectPacket(\"invalid_public_update_body:\"..tostring(encodeErr),packet,channel,distance)end trace(\"transport\",\"public_update_received\",{type=packet.type,from=packet.from,distance=distance,bytes=#encoded})if M.publicHandler then return M.publicHandler(packet,distance)end return end local discoveryPacket=packet.type==\"discover\"or packet.type==\"discover_query\"or packet.type==\"discover_cancel\"local handshakePacket=packet.type==\"pair_join\"or packet.type==\"pair_confirm\"or packet.type==\"pair_ack\"or packet.type==\"pair_reject\"local meshPacketType=packet.type==\"mesh_beacon\"or packet.type==\"mesh_edge_offer\"or packet.type==\"mesh_edge_accept\"if discoveryPacket then if packet.protocol~=PROTOCOL or channel~=DISCOVERY_CHANNEL then return rejectPacket(\"invalid_discovery_transport\",packet,channel,distance)end return handleDiscovery(packet,channel,distance)end if handshakePacket then if not isForUs(packet.to)then return end if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid_handshake_transport\",packet,channel,distance)end if packet.type==\"pair_join\"then return handlePairJoin(packet,distance)elseif packet.type==\"pair_confirm\"then return handlePairConfirm(packet,distance)elseif packet.type==\"pair_ack\"then return handlePairAck(packet)elseif packet.type==\"pair_reject\"and discovery then markRejected(\"pairing rejected: \"..tostring(packet.reason or\"remote peer rejected it\"));return end return end if meshPacketType then if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid mesh transport\",packet,channel,distance)end if packet.type~=\"mesh_beacon\"and not isForUs(packet.to)then return end return handleMeshPacket(packet,distance)end if not isForUs(packet.to)then return end local value=config()local valid,peerOrReason=verifyPacket(packet,value)if not valid then return rejectPacket(peerOrReason,packet,channel,distance)end local peer,from=peerOrReason,tostring(packet.from)if packet.confidential==true then local opened,openErr=openBody(peer,packet)if not opened then return rejectPacket(openErr or\"could not open confidential packet\",packet,channel,distance)end packet.body=opened end touchLink(from,distance,\"authenticated_packet\")if autoEdges[from]then autoEdges[from].expires=now()+ROUTE_TTL end trace(\"routing\",\"packet_received\",{type=packet.type,from=from,destination=packet.destination,distance=distance})if packet.type==\"mesh_enroll\"then return acceptEnrollment(from,peer,packet)end if packet.type==\"mesh_probe\"then return handleProbe(from,packet)end if packet.type==\"mesh_probe_ack\"then return handleProbeAck(from,packet)end if packet.type==\"route_advertise\"then return handleRouteAdvertisement(from,packet)end if packet.reply_to and packet.destination and tostring(packet.destination)~=id()then local reverse=reverseRoutes[packet.reply_to]if not reverse or reverse.expires<=now()or reverse.origin~=tostring(packet.destination)then return rejectPacket(\"reverse reply route unavailable\",packet,channel,distance)end local requestId=tostring(packet.request_id or\"\")if seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 trace(\"routing\",\"reverse_reply_forwarded\",{from=from,to=reverse.previous,type=packet.type})return send(packet.destination,packet,reverse.previous)end if packet.destination and tostring(packet.destination)~=id()then local requestId=tostring(packet.request_id or\"\")if requestId==\"\"or seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 return send(packet.destination,packet)end local requestId=tostring(packet.request_id or\"\")if requestId==\"\"then return rejectPacket(\"missing request ID\",packet,channel,distance)end if seenPackets[requestId]then return trace(\"routing\",\"destination_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end packet.authenticatedHop,packet.originVerified=from,false if M.handler then return M.handler(from,peer,packet)end end return M",
  ["ceetos/lib/network_ipc.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local ROOT=\"/ceetos/data/network-ipc\"local COMMANDS=ROOT..\"/commands\"local RESULTS=ROOT..\"/results\"local function ensure(path)if not fs.exists(path)then fs.makeDir(path)end end local function safeId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=160 end local function path(directory,requestId)return fs.combine(directory,requestId..\".lua\")end function M.submit(request)if type(request)~=\"table\"or not safeId(request.id)then return false,\"invalid IPC request ID\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local target=path(COMMANDS,request.id)if fs.exists(target)then return false,\"IPC request already exists\"end return store.write(target,request)end function M.take()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local names=fs.list(COMMANDS)table.sort(names)for _,name in ipairs(names)do local requestId=name:match(\"^([%w_%-%.]+)%.lua$\")if requestId and safeId(requestId)then local target=fs.combine(COMMANDS,name)store.invalidate(target)local request=store.readFresh(target,nil)fs.delete(target)if type(request)==\"table\"and request.id==requestId then return request end end end end function M.reply(requestId,value)if not safeId(requestId)or type(value)~=\"table\"then return false,\"invalid IPC result\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)return store.write(path(RESULTS,requestId),value)end function M.poll(requestId,consume)if not safeId(requestId)then return nil,\"invalid IPC request ID\"end local target=path(RESULTS,requestId)if not fs.exists(target)then return nil end local handle=fs.open(target,\"r\")if not handle then return nil end local raw=handle.readAll()handle.close()local ok,result=pcall(textutils.unserialise,raw)if not ok or type(result)~=\"table\"or result.id~=requestId then return nil,\"invalid IPC result\"end if consume then fs.delete(target)end return result end function M.prune(limit)ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)limit=math.max(1,math.floor(tonumber(limit)or 32))local names={}for _,name in ipairs(fs.list(RESULTS))do if name:match(\"^[%w_%-%.]+%.lua$\")then names[#names+1]=name end end table.sort(names)while#names>limit do fs.delete(fs.combine(RESULTS,table.remove(names,1)))end end function M.status()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local function count(directory)local total=0 for _,name in ipairs(fs.list(directory))do if name:match(\"^[%w_%-%.]+%.lua$\")then total=total+1 end end return total end return{commands=count(COMMANDS),results=count(RESULTS)}end return M",
  ["ceetos/lib/auth_client.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local networkIpc=require(\"ceetos.lib.network_ipc\")local M={}local REPLIES=\"/ceetos/data/auth-replies.lua\"local sequence=0 local function now()return os.epoch(\"utc\")end local function authority()store.invalidate(\"/ceetos/data/auth-authority.lua\")local value=store.read(\"/ceetos/data/auth-authority.lua\",nil)return type(value)==\"table\"and value.active==true and value or nil end local function requestId(kind)sequence=sequence+1 return table.concat({\"auth\",kind,tostring(os.getComputerID()),tostring(now()),tostring(sequence)},\"-\")end local function take(id)store.invalidate(REPLIES)local replies=store.read(REPLIES,{})local row=replies[id]if row then replies[id]=nil;store.write(REPLIES,replies)end return row end function M.receive(body)if type(body)~=\"table\"or type(body.request_id)~=\"string\"or#body.request_id>160 then return false,\"invalid authority reply\"end local replies=store.read(REPLIES,{})replies[body.request_id]={ok=body.ok==true,result=body.result,error=body.error,at=now()}local rows={}for id,row in pairs(replies)do rows[#rows+1]={id=id,at=tonumber(row.at)or 0}end table.sort(rows,function(a,b)return a.at>b.at end)while#rows>32 do replies[table.remove(rows).id]=nil end return store.write(REPLIES,replies)end local function send(typeName,body,timeout)local server=authority()if not server then return nil,\"no Auth Server is reachable\"end local id=body.request_id or requestId(typeName)body.request_id=id local command={id=\"auth-\"..id,action=\"auth_send\",target=server.id,type=typeName,body=body}local ok,err=networkIpc.submit(command)if not ok then return nil,err or\"could not reach CeetOS network service\"end local deadline=now()+(timeout or 6000)while now()<deadline do local ack=networkIpc.poll(command.id,true)if ack and ack.ok~=true then return nil,ack.error or\"Auth Server request was not sent\"end local reply=take(id)if reply then return reply.ok and reply.result or nil,reply.error or\"Auth Server rejected request\"end sleep(0.05)end return nil,\"Auth Server did not respond\"end local function loginProof(verifier,server,request,challenge,expires)return password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(os.getComputerID()),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.login(name,plainPassword)end local request=requestId(\"begin\")local begin,beginErr=send(\"auth_login_begin\",{request_id=request,username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=loginProof(verifier,begin.authority,request,begin.challenge,begin.expires)local result,proofErr=send(\"auth_login_proof\",{request_id=request,username=name,node=tostring(os.getComputerID()),challenge=begin.challenge,proof=proof})if not result then return false,proofErr end local auth=require((\"ceetos.lib.auth\"))local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require((\"ceetos.lib.auth\"))local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.mutate(action,fields)end local current,server=auth.refreshSession(),authority()if not current or not current.central or not server then return false,\"an Auth Server login is required\"end local result,err=send(\"auth_mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end return M",
  ["ceetos/lib/cloud.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local M={}M.PATH=\"/ceetos/data/cloud.lua\"M.MAX_BODY=48*1024 M.MAX_RESPONSE=64*1024 M.DEFAULTS={auth=\"https://auth.ceet.uk\",recipe=\"https://recipe.ceet.uk\",dashboard=\"https://dash.ceet.uk\",}local function now()return os.epoch(\"utc\")end local function validUrl(value)if type(value)~=\"string\"or#value>160 then return false end return value:match(\"^https://[%w%-%.]+%.ceet%.uk$\")~=nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_.%-]+$\")~=nil and#value<=96 end local function copy(value)local out={}for key,item in pairs(value or{})do out[key]=item end return out end local function normalise(value)value=type(value)==\"table\"and value or{}local urls=type(value.urls)==\"table\"and value.urls or{}local result={schema=1,enabled=value.enabled==true,urls={auth=validUrl(urls.auth)and urls.auth or M.DEFAULTS.auth,recipe=validUrl(urls.recipe)and urls.recipe or M.DEFAULTS.recipe,dashboard=validUrl(urls.dashboard)and urls.dashboard or M.DEFAULTS.dashboard,},node=type(value.node)==\"table\"and copy(value.node)or nil,}if result.node and(not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 or#result.node.secret>192)then result.node=nil end return result end function M.load()store.invalidate(M.PATH)return normalise(store.read(M.PATH,{}))end function M.save(value)local clean=normalise(value)return store.write(M.PATH,clean)end function M.configure(urls)local value=M.load()urls=type(urls)==\"table\"and urls or{}for key in pairs(M.DEFAULTS)do if urls[key]~=nil then if not validUrl(urls[key])then return false,\"invalid \"..key..\" cloud URL\"end value.urls[key]=urls[key]end end return M.save(value)end function M.clear()local value=M.load();value.enabled,value.node=false,nil return M.save(value)end function M.publicStatus()local value=M.load()return{enabled=value.enabled,enrolled=value.node~=nil,node=value.node and value.node.id or nil,urls=copy(value.urls),profile=profile.id()}end local function readBounded(handle,limit)local chunks,total={},0 while true do local part=handle.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then return nil,\"cloud response is too large\"end chunks[#chunks+1]=part end return table.concat(chunks)end local function json(value)local ok,result=pcall(textutils.unserialiseJSON,value)return ok and type(result)==\"table\"and result or nil end local function canonical(node,timestamp,nonce,method,path,body)local digest=assert(password.sha256(body))return table.concat({\"ceetos-cloud-node-v1\",node,tostring(timestamp),nonce,method,path,digest},\"\\n\")end local nonceCounter=0 local function nonce()nonceCounter=nonceCounter+1 return password.newSalt(\"cloud:\"..tostring(nonceCounter))end local function perform(url,method,path,body,headers)if not http or type(http.post)~=\"function\"then return nil,\"HTTP is unavailable\"end local response local ok,err=pcall(function()response=http.post(url..path,body,headers)end)if not ok or not response then return nil,tostring(err or\"cloud request failed\")end local raw,readErr=readBounded(response,M.MAX_RESPONSE)pcall(response.close)if not raw then return nil,readErr end local decoded=json(raw)if not decoded then return nil,\"cloud returned invalid JSON\"end if decoded.ok==false then return nil,tostring(decoded.error or\"cloud rejected request\"):sub(1,180)end return decoded end function M.enroll(code)if type(code)~=\"string\"or#code<12 or#code>128 or code:find(\"[%z\\1-\\31\\127]\")then return nil,\"invalid enrollment code\"end local value=M.load()local payload=textutils.serialiseJSON({code=code,profile=profile.id(),label=os.getComputerLabel()or(\"Computer \"..tostring(os.getComputerID())),computerId=tostring(os.getComputerID())})if#payload>M.MAX_BODY then return nil,\"enrollment request is too large\"end local result,err=perform(value.urls.auth,\"POST\",\"/v1/nodes/enroll\",payload,{[\"Content-Type\"]=\"application/json\"})if not result then return nil,err end if type(result.node)~=\"table\"or not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 then return nil,\"cloud returned invalid enrollment\"end value.enabled,value.node=true,{id=result.node.id,secret=result.node.secret,enrolledAt=now()}local saved,saveErr=M.save(value)if not saved then return nil,saveErr or\"could not save cloud enrollment\"end return M.publicStatus()end function M.call(service,path,payload)local value=M.load()if not value.enabled or not value.node then return nil,\"cloud node is not enrolled\"end if not M.DEFAULTS[service]or type(path)~=\"string\"or not path:match(\"^/v1/[%w%-%._/]+$\")or#path>128 then return nil,\"invalid cloud endpoint\"end local body=textutils.serialiseJSON(type(payload)==\"table\"and payload or{})if#body>M.MAX_BODY then return nil,\"cloud request is too large\"end local timestamp,requestNonce=now(),nonce()local signature=password.hmacSha256(value.node.secret,canonical(value.node.id,timestamp,requestNonce,\"POST\",path,body))if not signature then return nil,\"could not sign cloud request\"end return perform(value.urls[service],\"POST\",path,body,{[\"Content-Type\"]=\"application/json\",[\"X-CeetOS-Node\"]=value.node.id,[\"X-CeetOS-Time\"]=tostring(timestamp),[\"X-CeetOS-Nonce\"]=requestNonce,[\"X-CeetOS-Signature\"]=signature,})end return M",
  ["ceetos/lib/cloud_sync.lua"] = "local cloud=require(\"ceetos.lib.cloud\")local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local TELEMETRY_MODULE=\"ceetos.lib.\"..\"telemetry\"local RECIPE_SERVICE_MODULE=\"ceetos.lib.\"..\"recipe_service\"local M={}local STATE=\"/ceetos/data/cloud-state.lua\"local INTERVALS={telemetry=60000,authority=30000,recipes=30000}local function now()return os.epoch(\"utc\")end local function defaults()return{schema=1,revision=0,auth={online=false,next=0},recipe={online=false,next=0},telemetry={next=0},lastError=nil}end local function state()store.invalidate(STATE)local value=store.read(STATE,defaults())for key,fallback in pairs(defaults())do if value[key]==nil then value[key]=fallback end end return value end local function save(value)value.revision=(tonumber(value.revision)or 0)+1 return store.write(STATE,value)end local function errorState(value,message)value.lastError=tostring(message or\"cloud request failed\"):sub(1,180)end function M.status()local value,cfg=state(),cloud.publicStatus()return{enabled=cfg.enabled,enrolled=cfg.enrolled,node=cfg.node,urls=cfg.urls,authOnline=value.auth.online==true,recipeOnline=value.recipe.online==true,lastSync=value.lastSync,lastError=value.lastError}end function M.configure(urls)return cloud.configure(urls)end function M.enroll(code)return cloud.enroll(code)end function M.clear()local ok,err=cloud.clear();if ok then store.write(STATE,defaults())end return ok,err end function M.authOnline()return M.status().authOnline==true end function M.recipeOnline()return M.status().recipeOnline==true end local function cloudAuthority(result)local auth=require(\"ceetos.lib.auth\")if type(result)~=\"table\"or type(result.directory)~=\"table\"then return false,\"invalid cloud authority response\"end local cfg=cloud.publicStatus()local record={id=\"cloud:\"..tostring(cfg.urls.auth),term=tonumber(result.term)or 0,revision=tonumber(result.revision)or 0,directory=result.directory}return pcall(auth.acceptAuthority,record)end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local begin,beginErr=cloud.call(\"auth\",\"/v1/auth/login/begin\",{username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end if type(begin.salt)~=\"string\"or type(begin.workFactor)~=\"number\"or type(begin.challenge)~=\"string\"or type(begin.expires)~=\"number\"then return false,\"invalid cloud login challenge\"end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(begin.authority),tostring(os.getComputerID()),tostring(begin.requestId),tostring(begin.challenge),tostring(begin.expires)},\"|\"))local result,resultErr=cloud.call(\"auth\",\"/v1/auth/login/proof\",{username=name,node=tostring(os.getComputerID()),requestId=begin.requestId,challenge=begin.challenge,proof=proof})if not result then return false,resultErr end local auth=require(\"ceetos.lib.auth\")local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require(\"ceetos.lib.auth\")local current=auth.refreshSession()if not current or not current.central then return false,\"cloud login is required\"end local result,err=cloud.call(\"auth\",\"/v1/auth/mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.recipePlan(item,quantity,stock)if not M.recipeOnline()then return nil,\"cloud Recipe Server is unavailable\"end local result,err=cloud.call(\"recipe\",\"/v1/recipe/plan\",{item=item,quantity=quantity,stock=stock})if not result then return nil,err end return result.plan,result.error end local function telemetry(activity)local snapshot={ts=now(),id=os.getComputerID(),label=os.getComputerLabel(),activity=activity}if profile.is(\"desktop\")then local loaded,telemetryService=pcall(require,TELEMETRY_MODULE)if loaded and telemetryService.status()then snapshot=telemetryService.snapshot(activity)end end local net=require(\"ceetos.lib.net\")local transport=net.statusSnapshot and net.statusSnapshot().transport or{}snapshot.health={profile=profile.id(),version=require(\"ceetos.lib.version\").string,uptime=os.clock(),freeSpace=fs.getFreeSpace(\"/\"),peers=#(net.peers and net.peers()or{}),healthyLinks=transport and transport.healthyLinks or 0,lastError=M.status().lastError,}local result,err=cloud.call(\"dashboard\",\"/v1/telemetry/ingest\",snapshot)return result~=nil,err end local function syncAuth()if profile.is(\"auth-server\")then local auth=require(\"ceetos.lib.auth\")local snapshot=auth.authoritySnapshot()local pushed,pushErr=cloud.call(\"auth\",\"/v1/auth/replica/merge\",{snapshot=snapshot,source=\"mesh\"})if not pushed then return false,pushErr end if type(pushed.snapshot)==\"table\"then auth.merge(pushed.snapshot,true)end local ok,authErr=cloudAuthority(pushed)if not ok then return false,authErr end return true end local result,err=cloud.call(\"auth\",\"/v1/auth/directory\",{})if not result then return false,err end local ok,authErr=cloudAuthority(result)if not ok then return false,authErr end return true end local function syncRecipes()if not profile.is(\"recipe-server\")then local result,err=cloud.call(\"recipe\",\"/v1/recipe/status\",{})return result~=nil,err end local service=require(RECIPE_SERVICE_MODULE)if type(service.exportOverlay)~=\"function\"then return false,\"recipe export unavailable\"end local payload,exportErr=service.exportOverlay()if not payload then return false,exportErr end local result,err=cloud.call(\"recipe\",\"/v1/recipe/replica/merge\",{overlay=payload})return result~=nil,err 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=syncRecipes();value.recipe.online,value.recipe.next=ok==true,timestamp+INTERVALS.recipes if not ok then errorState(value,err)end changed=true end if timestamp>=(tonumber(value.telemetry.next)or 0)then local ok,err=telemetry(activity or\"desktop\");value.telemetry.next=timestamp+INTERVALS.telemetry if not ok then errorState(value,err)end changed=true end if changed then value.lastSync=timestamp;save(value)end return true end return M",
  ["ceetos/lib/version.lua"] = "return{major=0,minor=16,patch=0,string=\"0.16.0\"}",
  ["ceetos/lib/crafting.lua"] = "local M={}M.RECIPE_PACK_MAX_BYTES=64*1024 function M.isLocalPeer(peer,computerId)return tostring(peer)==tostring(computerId)end function M.normalise(rows)local out={}for _,row in pairs(type(rows)==\"table\"and rows or{})do if type(row)==\"table\"then local name,count=row.name or row.id,tonumber(row.count or row.amount or row.quantity or 0)or 0 if type(name)==\"string\"and count>0 then out[name]=(out[name]or 0)+math.floor(count)end end end return out end function M.rows(stock,query,filter,recipes)local output,needle,available={},tostring(query or\"\"):lower(),M.normalise(stock)local names={}for name in pairs(available)do names[name]=true end for name in pairs(type(recipes)==\"table\"and recipes or{})do names[name]=true end for name in pairs(names)do local count=available[name]or 0 local craftable=type(recipes)==\"table\"and recipes[name]~=nil local include=needle==\"\"or name:lower():find(needle,1,true)if filter==\"craftable\"then include=include and craftable elseif filter==\"stocked\"then include=include and count>0 end if include then output[#output+1]={name=name,count=count,craftable=craftable,stocked=count>0}end end table.sort(output,function(a,b)return a.name<b.name end)return output end function M.addToCart(cart,name,count)if type(cart)~=\"table\"or type(name)~=\"string\"or name==\"\"then return nil,\"invalid cart item\"end count=tonumber(count)if not count or count<1 then return nil,\"invalid cart quantity\"end count=math.floor(count)for _,row in ipairs(cart)do if row.name==name then row.count=(tonumber(row.count)or 0)+count;return row end end local row={name=name,count=count}cart[#cart+1]=row return row end function M.cartTotals(cart)local items,quantity=0,0 for _,row in ipairs(type(cart)==\"table\"and cart or{})do items=items+1 quantity=quantity+math.max(0,math.floor(tonumber(row.count)or 0))end return items,quantity end function M.acceptedCount(result,requested)local accepted=tonumber(result)requested=tonumber(requested)if not accepted or not requested or requested<1 then return nil,\"invalid request result\"end accepted=math.floor(accepted)if accepted<1 then return nil,\"Stock Ticker accepted no items\"end return math.min(accepted,math.floor(requested))end function M.displayRow(name,count,width)local suffix=\" x\"..tostring(count)width=math.max(#suffix+1,math.floor(tonumber(width)or#suffix+1))if#name+#suffix<=width then return name..suffix end return name:sub(1,math.max(1,width-#suffix-1))..\"…\"..suffix end function M.cancellationStatus(issued)return issued and\"cancelled-unconfirmed\"or\"cancelled\"end local function validReference(name)return type(name)==\"string\"and name:match(\"^#?[%w_.:%-]+$\")~=nil and not name:find(\"##\",1,true)end local function recipeIngredients(recipe,batches)local combined={}local declared=type(recipe.ingredients)==\"table\"and#recipe.ingredients>0 if declared then for _,ingredient in ipairs(recipe.ingredients)do local name=type(ingredient)==\"table\"and ingredient.id or ingredient local count=type(ingredient)==\"table\"and tonumber(ingredient.count or 1)or 1 if validReference(name)then combined[name]=(combined[name]or 0)+batches*math.max(1,math.floor(count or 1))end end else for slot=1,9 do local name=recipe.grid and recipe.grid[slot]if name and name~=false then combined[name]=(combined[name]or 0)+batches end end end local out={}for name,count in pairs(combined)do out[#out+1]={name=name,count=count}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.recipeInputs(recipe,batches)return recipeIngredients(recipe or{},math.max(1,math.floor(tonumber(batches)or 1)))end function M.validateRecipes(recipes)if type(recipes)~=\"table\"then return nil,\"recipes must return a table\"end for name,recipe in pairs(recipes)do if type(name)~=\"string\"or not name:match(\"^[%w_.:%-]+$\")or type(recipe)~=\"table\"then return nil,\"invalid recipe item id\"end if type(recipe.alternatives)==\"table\"then if#recipe.alternatives<1 then return nil,\"recipe \"..name..\" has no alternatives\"end for _,alternative in ipairs(recipe.alternatives)do local valid,err=M.validateRecipes({[name]=alternative});if not valid then return nil,err end end else if recipe.mode~=\"crafting\"then return nil,\"recipe \"..name..\" must use mode = crafting\"end if type(recipe.address)~=\"string\"or recipe.address==\"\"or#recipe.address>64 then return nil,\"recipe \"..name..\" requires an address\"end local crafter=recipe.address==\"Crafter\"if crafter and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires a 9-slot grid for Crafter\"end if not crafter and type(recipe.ingredients)~=\"table\"and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires ingredients\"end local output=tonumber(recipe.output or 1)if not output or output<1 or output~=math.floor(output)then return nil,\"invalid output for \"..name end for slot=1,9 do local value=recipe.grid and recipe.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid grid slot in \"..name end end for _,ingredient in ipairs(type(recipe.ingredients)==\"table\"and recipe.ingredients or{})do local id,count=type(ingredient)==\"table\"and ingredient.id or ingredient,type(ingredient)==\"table\"and ingredient.count or 1 if not validReference(id)or not tonumber(count)or tonumber(count)<1 then return nil,\"invalid ingredient in \"..name end end end end return recipes end local function dataParser(source,maximum)if type(source)~=\"string\"then return nil,\"recipe data must be text\"end if#source==0 or#source>(maximum or M.RECIPE_PACK_MAX_BYTES)then return nil,\"recipe data exceeds the 64 KiB import limit\"end local state={source=source,index=1,length=#source,depth=0,nodes=0}local function skip()while state.index<=state.length do local char=state.source:sub(state.index,state.index)if char:match(\"%s\")then state.index=state.index+1 elseif state.source:sub(state.index,state.index+1)==\"--\"then local ending=state.source:find(\"\\n\",state.index+2,true)state.index=ending and ending+1 or state.length+1 else return true end end return true end local function fail(message)return nil,message..\" near byte \"..tostring(state.index)end local function identifier()local name=state.source:match(\"^[%a_][%w_]*\",state.index)if name then state.index=state.index+#name end return name end local parseValue local function parseString()local quote=state.source:sub(state.index,state.index);state.index=state.index+1 local out={}while state.index<=state.length do local char=state.source:sub(state.index,state.index);state.index=state.index+1 if char==quote then return table.concat(out)end if char==\"\\\\\"then local escaped=state.source:sub(state.index,state.index);state.index=state.index+1 local values={n=\"\\n\",r=\"\\r\",t=\"\\t\",[\"\\\\\"]=\"\\\\\",[\"\\\"\"]=\"\\\"\",[\"'\"]=\"'\"}if not values[escaped]then return fail(\"unsupported string escape\")end out[#out+1]=values[escaped]elseif char:byte()<32 then return fail(\"control character in string\")else out[#out+1]=char end end return fail(\"unterminated string\")end local function parseTable()state.depth=state.depth+1 if state.depth>32 then return fail(\"recipe data is nested too deeply\")end state.index=state.index+1 local out,nextIndex,keys={},1,{}skip()while state.index<=state.length and state.source:sub(state.index,state.index)~=\"}\"do state.nodes=state.nodes+1 if state.nodes>4096 then return fail(\"recipe data has too many values\")end local key,value,err local start=state.index if state.source:sub(state.index,state.index)==\"[\"then state.index=state.index+1;key,err=parseValue();if err then return nil,err end skip();if state.source:sub(state.index,state.index)~=\"]\"then return fail(\"missing closing recipe key bracket\")end state.index=state.index+1;skip();if state.source:sub(state.index,state.index)~=\"=\"then return fail(\"missing recipe key assignment\")end state.index=state.index+1;skip();value,err=parseValue();if err then return nil,err end else local named=identifier();skip()if named and state.source:sub(state.index,state.index)==\"=\"then key,state.index=named,state.index+1;skip();value,err=parseValue();if err then return nil,err end else state.index=start;value,err=parseValue();if err then return nil,err end key,nextIndex=nextIndex,nextIndex+1 end end if type(key)~=\"string\"and type(key)~=\"number\"then return fail(\"recipe table key must be text or a number\")end local signature=type(key)..\":\"..tostring(key)if keys[signature]then return fail(\"duplicate recipe table key\")end keys[signature],out[key]=true,value skip();local separator=state.source:sub(state.index,state.index)if separator==\",\"or separator==\";\"then state.index=state.index+1;skip()elseif separator~=\"}\"then return fail(\"expected recipe table separator\")end end if state.source:sub(state.index,state.index)~=\"}\"then return fail(\"unterminated recipe table\")end state.index,state.depth=state.index+1,state.depth-1 return out end parseValue=function()skip();local char=state.source:sub(state.index,state.index)if char==\"{\"then return parseTable()end if char==\"\\\"\"or char==\"'\"then return parseString()end local number=state.source:match(\"^-?%d+\",state.index)if number then state.index=state.index+#number;return tonumber(number)end local name=identifier()if name==\"true\"then return true elseif name==\"false\"then return false elseif name==\"nil\"then return nil elseif name then return fail(\"bare recipe values are not allowed\")end return fail(\"invalid recipe value\")end skip()if identifier()~=\"return\"then return fail(\"recipe data must start with return\")end local value,err=parseValue();if err then return nil,err end skip();if state.index<=state.length then return fail(\"unexpected content after recipe table\")end return value end local function validTags(tags)if tags==nil then return{}end if type(tags)~=\"table\"then return nil,\"recipe tags must be a table\"end local out={}for tag,members in pairs(tags)do local key=tostring(tag):gsub(\"^#\",\"\")if not key:match(\"^[%w_.:%-]+$\")or type(members)~=\"table\"or#members<1 then return nil,\"invalid recipe tag \"..tostring(tag)end out[key]={}for _,member in ipairs(members)do if not validReference(member)or tostring(member):sub(1,1)==\"#\"then return nil,\"invalid member of #\"..key end out[key][#out[key]+1]=member end table.sort(out[key])end return out end function M.validateRecipeGraph(recipes,tags)local tagMap,tagErr=validTags(tags);if not tagMap then return nil,tagErr end local visiting,complete={},{}local function visit(name)if complete[name]then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=recipes[name]if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end if not recipe then return true end visiting[name]=true for _,input in ipairs(recipeIngredients(recipe,1))do local ingredient=input.name local members=ingredient:sub(1,1)==\"#\"and tagMap[ingredient:sub(2)]or{ingredient}for _,member in ipairs(members or{})do if recipes[member]then local ok,err=visit(member);if not ok then return nil,err end end end end visiting[name],complete[name]=nil,true return true end for name in pairs(recipes)do local ok,err=visit(name);if not ok then return nil,err end end return true end function M.parseRecipeOverlay(source)local value,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not value then return nil,err end if type(value)~=\"table\"then return nil,\"recipe overlay must return a table\"end local recipes,tags if value.schema==1 and type(value.recipes)==\"table\"then recipes,tags=value.recipes,value.tags or{}else recipes,tags=value,{}end local valid,validationErr=M.validateRecipes(recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(tags);if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=recipes,tags=tagMap}end function M.parseRecipeFile(source)local overlay,err=M.parseRecipeOverlay(source)return overlay and overlay.recipes or nil,err end function M.parseRecipePack(source)local pack,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not pack then return nil,err end if type(pack)~=\"table\"or pack.schema~=1 or type(pack.recipes)~=\"table\"then return nil,\"recipe pack must return { schema = 1, recipes = { ... } }\"end local valid,validationErr=M.validateRecipes(pack.recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(pack.tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(pack.recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=pack.recipes,tags=tagMap}end function M.recipeEqual(left,right)if type(left)~=\"table\"or type(right)~=\"table\"then return false end if type(left.alternatives)==\"table\"then left=left.alternatives[1]end if type(right.alternatives)==\"table\"then right=right.alternatives[1]end if not left or not right or left.mode~=right.mode or left.kind~=right.kind or left.output~=right.output or left.address~=right.address then return false end for slot=1,9 do if left.grid and right.grid and left.grid[slot]~=right.grid[slot]then return false end end local a,b=recipeIngredients(left,1),recipeIngredients(right,1)if#a~=#b then return false end for index=1,#a do if a[index].name~=b[index].name or a[index].count~=b[index].count then return false end end return true end function M.reviewRecipePack(existing,incoming)local validExisting,existingErr=M.validateRecipes(existing)if not validExisting then return nil,existingErr end local validIncoming,incomingErr=M.validateRecipes(incoming)if not validIncoming then return nil,incomingErr end local rows,counts={},{new=0,unchanged=0,conflict=0,invalid=0}for name,recipe in pairs(incoming)do local prior=existing[name]local status=not prior and\"new\"or(M.recipeEqual(prior,recipe)and\"unchanged\"or\"conflict\")counts[status]=counts[status]+1 rows[#rows+1]={name=name,status=status,incoming=recipe,existing=prior,selected=status==\"new\"}end table.sort(rows,function(a,b)return a.name<b.name end)return{rows=rows,counts=counts}end local function cloneRecipe(recipe)if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end local copy={mode=recipe.mode,kind=recipe.kind,output=recipe.output,address=recipe.address,grid={},ingredients={}}for slot=1,9 do copy.grid[slot]=recipe.grid and recipe.grid[slot]end for _,input in ipairs(recipe.ingredients or{})do copy.ingredients[#copy.ingredients+1]={id=input.id,count=input.count,tag=input.tag}end return copy end function M.mergeRecipePack(existing,review,existingTags,incomingTags)if type(existing)~=\"table\"or type(review)~=\"table\"or type(review.rows)~=\"table\"then return nil,\"invalid recipe import review\"end local merged,imported={},0 for name,recipe in pairs(existing)do merged[name]=cloneRecipe(recipe)end for _,row in ipairs(review.rows)do if row.status==\"new\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 elseif row.status==\"conflict\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 end end local tags={}for name,members in pairs(existingTags or{})do tags[name]=members end for name,members in pairs(incomingTags or{})do tags[name]=members end local valid,err=M.validateRecipes(merged);if not valid then return nil,err end local graphOk,graphErr=M.validateRecipeGraph(merged,tags);if not graphOk then return nil,graphErr end return merged,imported,tags end function M.encodeRecipeFile(recipes,tags)local valid,err=M.validateRecipes(recipes);if not valid then return nil,err end local tagMap,tagsErr=validTags(tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap);if not graphOk then return nil,graphErr end local ok,encoded=pcall(textutils.serialise,{schema=1,recipes=recipes,tags=tagMap},{compact=true})if not ok or type(encoded)~=\"string\"then return nil,\"could not serialise recipes\"end return\"return \"..encoded..\"\\n\"end function M.writeRecipeFile(path,recipes,tags)if type(path)~=\"string\"or path==\"\"then return false,\"invalid recipe file path\"end local raw,encodeErr=M.encodeRecipeFile(recipes,tags);if not raw then return false,encodeErr end local parent=fs.getDir(path);if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary,backup=path..\".new\",path..\".bak\"if fs.exists(temporary)then fs.delete(temporary)end local handle=fs.open(temporary,\"w\");if not handle then return false,\"could not stage recipes\"end handle.write(raw);handle.close()local check=fs.open(temporary,\"r\");local staged=check and check.readAll()or nil;if check then check.close()end if not M.parseRecipeOverlay(staged or\"\")then if fs.exists(temporary)then fs.delete(temporary)end;return false,\"could not validate staged recipes\"end if fs.exists(backup)then fs.delete(backup)end if fs.exists(path)then fs.move(path,backup)end local moved,moveErr=pcall(fs.move,temporary,path)if not moved then if fs.exists(backup)and not fs.exists(path)then fs.move(backup,path)end;if fs.exists(temporary)then fs.delete(temporary)end;return false,tostring(moveErr)end if fs.exists(backup)then fs.delete(backup)end return true end local function selectedRecipe(entry)if type(entry)==\"table\"and type(entry.alternatives)==\"table\"then return entry.alternatives[1]end return entry end local function tagMembers(tags,reference)if reference:sub(1,1)~=\"#\"then return{reference}end local members=tags[reference:sub(2)]if type(members)~=\"table\"or#members==0 then return nil,\"no known members for \"..reference end return members end local function chooseMember(reference,tags,available,recipes)local members,err=tagMembers(tags,reference);if not members then return nil,err end local best for _,member in ipairs(members)do if(available[member]or 0)>0 then return member end if recipes[member]and not best then best=member end end return best,best and nil or(\"no stocked or craftable member for \"..reference)end function M.plan(recipes,stock,item,quantity,options)quantity=tonumber(quantity)if type(item)~=\"string\"or item==\"\"or not quantity or quantity<1 or quantity~=math.floor(quantity)then return nil,\"invalid item or quantity\"end local valid,errorText=M.validateRecipes(recipes)if not valid then return nil,errorText end options=type(options)==\"table\"and options or{}local available,plan,visiting,tags=M.normalise(stock),{},{},type(options.tags)==\"table\"and options.tags or{}local function requireItem(name,needed)local used=options.forceRoot==true and name==item and 0 or math.min(available[name]or 0,needed)available[name]=(available[name]or 0)-used local missing=needed-used if missing<=0 then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=selectedRecipe(recipes[name])if not recipe then return nil,\"missing recipe for \"..name..\" (need \"..tostring(missing)..\")\"end if recipe.special or not recipe.output or not recipe.address then return nil,\"recipe \"..name..\" is not supported by Crafting Queue\"end visiting[name]=true local batches=math.ceil(missing/recipe.output)local inputs={}for _,ingredient in ipairs(recipeIngredients(recipe,batches))do local concrete,resolveErr=chooseMember(ingredient.name,tags,available,recipes)if not concrete then return nil,resolveErr end inputs[#inputs+1]={name=concrete,count=ingredient.count,source=ingredient.name,tag=ingredient.name:sub(1,1)==\"#\"and ingredient.name or nil}local ok,err=requireItem(concrete,ingredient.count)if not ok then return nil,err end end visiting[name]=nil local produced=batches*recipe.output available[name]=(available[name]or 0)+produced-missing local dispatch=recipe.address==\"Crafter\"and\"requester\"or\"package\"if dispatch==\"requester\"and type(recipe.grid)~=\"table\"then return nil,\"Crafter recipe \"..name..\" has no 3x3 grid\"end plan[#plan+1]={name=name,batches=batches,produced=produced,requested=missing,address=recipe.address,kind=recipe.kind,dispatch=dispatch,grid=recipe.grid,inputs=inputs,}return true end local ok,err=requireItem(item,quantity)return ok and plan or nil,err end function M.validateExecutionPlan(plan)if type(plan)~=\"table\"or#plan<1 or#plan>96 then return nil,\"invalid remote recipe plan\"end for _,step in ipairs(plan)do if type(step)~=\"table\"or not validReference(step.name)or tostring(step.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe output\"end if type(step.address)~=\"string\"or step.address==\"\"or#step.address>64 or step.address:find(\"[%c]\")then return nil,\"invalid remote recipe address\"end if step.dispatch~=\"requester\"and step.dispatch~=\"package\"then return nil,\"invalid remote recipe route\"end if(step.address==\"Crafter\")~=(step.dispatch==\"requester\")then return nil,\"invalid remote recipe executor\"end for _,field in ipairs({\"batches\",\"produced\",\"requested\"})do local value=tonumber(step[field])if not value or value<1 or value~=math.floor(value)or value>65536 then return nil,\"invalid remote recipe quantity\"end end if step.dispatch==\"requester\"then if type(step.grid)~=\"table\"then return nil,\"remote Crafter recipe has no grid\"end for slot=1,9 do local value=step.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid remote recipe grid\"end end end if type(step.inputs)~=\"table\"or#step.inputs>64 then return nil,\"invalid remote recipe inputs\"end for _,input in ipairs(step.inputs)do if type(input)~=\"table\"or not validReference(input.name)or tostring(input.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe input\"end local count=tonumber(input.count)if not count or count<1 or count~=math.floor(count)or count>65536 then return nil,\"invalid remote recipe input quantity\"end if input.source~=nil and not validReference(input.source)then return nil,\"invalid remote recipe input source\"end end end return plan end return M",
  ["ceetos/server.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local net=require(\"ceetos.lib.net\")local audit=require(\"ceetos.lib.audit\")local updater=require(\"ceetos.lib.updater\")local networkIpc=require(\"ceetos.lib.network_ipc\")local version=require(\"ceetos.lib.version\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local authority=profile.is(\"auth-server\")and require((\"ceetos.lib.auth_authority\"))or nil local authClient=require(\"ceetos.lib.auth_client\")local cloudSync=require(\"ceetos.lib.cloud_sync\")local function replyIpc(command,ok,result)networkIpc.reply(command.id,{id=command.id,ok=ok==true,result=ok and result or nil,error=ok and nil or tostring(result)})end local function command()local request=networkIpc.take()if not request then return end local ok,result=pcall(function()if request.action==\"server_status\"then return{profile=profile.id(),version=version.string,network=net.statusSnapshot(),authority=authority and authority.status()or auth.authority(),recipes=recipe and recipe.status()or nil}elseif request.action==\"server_discovery_start\"then auth.require(\"admin\");return net.startDiscovery(request.mode or\"peer\",request.master or\"initiator\",request.phrase)elseif request.action==\"server_discovery_join\"then auth.require(\"admin\");return net.joinDiscovery(request.phrase)elseif request.action==\"server_discovery_confirm\"then auth.require(\"admin\");return net.confirmDiscovery()elseif request.action==\"server_update_status\"then return updater.status()elseif request.action==\"server_update_apply\"then auth.require(\"admin\");return updater.prepareApply()elseif request.action==\"auth_send\"then local sent,err=net.request(request.target,request.type,request.body or{},{safe=true,confidential=true})if not sent then error(err or\"could not contact Auth Server\")end return true end error(\"unknown protected server command\")end)replyIpc(request,ok and result~=false,ok and result or result)end net.handler=function(from,peer,packet)if packet.type==\"update_query\"or packet.type==\"update_offer\"or packet.type==\"update_chunk_request\"or packet.type==\"update_chunk\"then return updater.authenticatedPacket(from,peer,packet)end if packet.type==\"profile_query\"then return net.reply(packet,\"profile_status\",{profile=profile.id(),version=version.string},{safe=true})end if packet.type==\"recipe_plan_request\"and recipe then return recipe.handle(packet,net)end if packet.type==\"auth_login_begin_result\"or packet.type==\"auth_login_proof_result\"or packet.type==\"auth_mutate_result\"then return authClient.receive(packet.body)end if packet.type==\"auth_seed_request\"then return net.reply(packet,\"auth_seed\",{snapshot=auth.authoritySnapshot(),request_id=packet.body and packet.body.request_id},{safe=true,confidential=true})end if packet.type==\"auth_authority\"then return auth.acceptAuthority(packet.body)end if authority then return authority.handle(from,peer,packet,net)end end net.publicHandler=function(packet,distance)return updater.publicPacket(packet,distance)end local function service()net.start()if authority then authority.start()end local tick,update,cloud,advertised=os.startTimer(1),os.startTimer(1),os.startTimer(5),0 while true do local event={os.pullEventRaw()}local ok,err=pcall(net.handle,event)if not ok then audit.log(\"server\",\"network.error\",{error=tostring(err):sub(1,120)})end pcall(command)if event[1]==\"timer\"and event[2]==tick then pcall(net.tick);if authority then pcall(authority.tick,net)end if os.epoch(\"utc\")-advertised>=30000 then for _,peer in ipairs(net.peers())do net.request(peer.id,\"profile_status\",{profile=profile.id(),version=version.string},{safe=true})end advertised=os.epoch(\"utc\")end tick=os.startTimer(1)end if event[1]==\"timer\"and event[2]==update then pcall(updater.tick);update=os.startTimer(1)end if event[1]==\"timer\"and event[2]==cloud then pcall(cloudSync.tick,\"server\");cloud=os.startTimer(5)end end end local function console()shell.run(\"/ceetos/bin/ceetserver.lua\")while true do sleep(1);shell.run(\"/ceetos/bin/ceetserver.lua\")end end local function devBridge()local path=\"/ceetos-dev/connection.lua\"while true do if fs.exists(\"/ceetos/bin/ceetdev.lua\")and fs.exists(path)then local handle=fs.open(path,\"r\")local cfg=handle and textutils.unserialise(handle.readAll())or nil if handle then handle.close()end if type(cfg)==\"table\"and type(cfg.url)==\"string\"then local token=type(cfg.token)==\"string\"and cfg.token or\"\"if token~=\"\"then pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url,token)else pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url)end sleep(3)else sleep(5)end else sleep(5)end end end parallel.waitForAny(service,console,devBridge)",
  ["ceetos/bin/ceetserver.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local version=require(\"ceetos.lib.version\")local store=require(\"ceetos.lib.store\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local function draw(message)term.setBackgroundColor(colors.black);term.setTextColor(colors.white);term.clear();term.setCursorPos(1,1)term.setBackgroundColor(colors.blue);term.clearLine();term.setCursorPos(2,1);term.write(\"CeetOS \"..profile.id()..\" server\")term.setBackgroundColor(colors.black);term.setCursorPos(2,3);term.write(\"Version: \"..version.string)local authority=auth.authority()term.setCursorPos(2,4);term.write(authority and(\"Auth authority: \"..authority.id)or\"Auth authority: distributed / waiting\")local current=auth.refreshSession()term.setCursorPos(2,6);term.write(current and(\"Signed in: \"..current.name..\" (\"..current.role..\")\")or\"Not signed in\")term.setTextColor(colors.lightGray);term.setCursorPos(2,8)if not current then term.write(\"L Login  |  E first-time enrolment  |  Backspace refresh\")elseif current.role==\"admin\"then local actions=recipe and\"I import pack  |  P pair  |  U updates\"or\"P pair  |  U updates\"term.write(actions..\"  |  L logout  |  Backspace refresh\")else term.write(\"L logout  |  Backspace refresh\")end if message then term.setTextColor(colors.red);term.setCursorPos(2,10);term.write(tostring(message):sub(1,48))end end local function login()term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Username: \");local user=read()term.setCursorPos(2,13);term.write(\"Password: \");local pass=read(\"*\")local ok,err=auth.login(user,pass);return ok and\"Logged in.\"or err end local function enrol()if#auth.list()>0 or auth.centralActive()then return\"Enrollment is already complete.\"end term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Create local admin password: \")local pass=read(\"*\")if type(pass)~=\"string\"or#pass<8 then return\"Enrollment password must contain at least 8 characters.\"end local ok,err=pcall(auth.bootstrap,pass)return ok and\"Enrollment complete.\"or err end local function importRecipePack(event)if not recipe then return\"This server has no recipe service.\"end if not auth.allowed(\"admin\")then return\"Recipe import requires an admin session.\"end local files=event and event.getFiles and event.getFiles()or nil if type(files)~=\"table\"or#files~=1 or type(files[1].read)~=\"function\"then return\"Drop exactly one data-only recipe pack.\"end local chunks,total={},0 while true do local part=files[1].read(4096)if not part then break end if type(part)~=\"string\"then return\"Dropped recipe pack has invalid data.\"end total=total+#part if total>64*1024 then return\"Recipe pack exceeds 64 KiB.\"end chunks[#chunks+1]=part end local ok,result=recipe.import(table.concat(chunks))if not ok then return tostring(result)end return\"Imported \"..tostring(result.imported or 0)..\" new recipes; conflicts kept.\"end local message while true do draw(message);message=nil local event,code=os.pullEventRaw()if event==\"key\"then local key=keys.getName(code)if key==\"l\"then if auth.refreshSession()then auth.logout();message=\"Logged out.\"else message=login()end elseif key==\"e\"then message=enrol()elseif key==\"backspace\"then elseif key==\"p\"and auth.allowed(\"admin\")then message=\"Use the Peers page on a desktop to pair; server pairing IPC is available to administrators.\"elseif key==\"u\"and auth.allowed(\"admin\")then message=\"Signed updates are managed locally; no remote apply is permitted.\"elseif key==\"i\"and recipe and auth.allowed(\"admin\")then message=\"Drop one recipe pack into this console.\"end elseif event==\"file_transfer\"then message=importRecipePack(code)end end",
}
local CEETOS_RELEASE_INSTALLER = true
local CEETOS_PROFILE = "router-server"

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

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

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

-- CEETOS_RELEASE_PAYLOAD_END