-- CeetOS signed release. Generated; do not edit.
-- CEETOS_RELEASE_MANIFEST:{channel="release",profile="router-server",version="0.16.6",size=385577,digest="daa4141a49ac8fbbd82b38eeba814f5817e0f4fcf890a2765a9467fd2ad8f622",key_id="router-server-release-0.16.5",next_key_id="router-server-release-0.16.6",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.16.3\"]={public=\"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\",profile=\"auth-server\"},[\"auth-server-release-0.16.5\"]={public=\"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\",profile=\"auth-server\"},[\"desktop-release-0.16.5\"]={public=\"roS6hHIyTJHeB0NjIeqo4WWOsB938PSSOQKZ2rpFjFA2ClRxJI8umSBU0cQXMm3cY6Zvzlqx+w01LjOHwvsCcpnGgHqc3+WBUerSAYDHqgmunmTpwkccpWxr59bsInncR/YaPpWqnNTDUtNxLTf2Um7StmCfDiiYYl7yEkq5UjGo21YIi1+sYfB7ACHsqdNQZ/0ujkDR9YklZCsf9SyRZHGm7uSE19NSu8PvGw/CdtFcM21E4ZvqDAeJpoj/3jMviP1j+jcL347AHTkXoL/mY2N1HCLHCaywuqVM/oLzvUYJREAo4zGnxkFkMeiUcUzTOW5BWbv9P/krNhIXC9jHOceNjBtv2yL02IbPnSiBz93h70C22CziPRPbTMvpAB8rE/aPKMo5FBI+X8ZSlYaMex9OsksvRVvFmqPHOHyLJviWJdJ6b+t3T6SQn+TYBk+oSJNSf08WNCTve32HROjc7X/3IJx4kA9/+2OHlKE1wphfG3tf3cG4aNRfegirHy2HGTY/Hm4lT38efmEhRUo9HAcxdz5CbS9uXv39RbwHHQ6WitXoD5IM/eVXtBvfK0/MhORTwEYbGBFJPlptlbXig4tJiNZXBA4eWu6Yy+eRKOcd3tCLP/hkH1bwXSexwf0DDbCo4nyQHqOvrNI7qsLgiqxbaWOCNT9wfg8/1JkPf+L3b/zziTUz4qHF4jLm6uB10YSdwF/o3WksRDEptLlG0nnchiFEkgyLohcPXQvKR7vQYPQdbLhYLjqhjUaZW4Ss4vrc9PVho4KyuHYBD4xna8i1ag4Q7shn6FJoFN1F2UXyj1kxqe9a+BH5wD4UNFiKoigiyJMGmz65KDIANaZyDxlWITBMe7HSCfyII7jwyTLpLT5lPRZW/uZWxomT9rJH+TbdjXNBj+4ukelI7zEy/vAcVTM9gKzIWyS0h5Gr/cUVyVitSA+aEeS8KqPdxOLyeuYonC1Tnyph6MSkVCJq3d492FY+TZltGqcrqu/BkHdu/jNsqwY+8G7mSCnI9CZXM5B5VmxuMLS4+fVDP0Qnhp685P24pBKCZjyvPh+3Tjp5axzQD2F9cccIoINZlpVHtr18G1pWGi8c+oFtcQOvLTzUmdbRmf0EM63/YdmwCEcrf2dy57EvUbBWGg8GzrKyU30MLr6Flkexrr+CTTqoOfiiqnCMJ2RaFP8h20plqdF/MqID/AarQOzF5sfZYOh5iqnJl7mk859shpEK+RUaT2owoxzWzW5WoTHAri5arzzGcMjYtoY/JYZFKppJIdxgDWPY+/C02rLrmcRiDtOsowYAOxGoLb1aY72ghmxBNO/+qZea4zfL2jz3iD3x2psHxWLLpfXJTj0FcfYk927Vr/kS4R0WFu5fHVCfWaug9Oqb+g1heltjKmjQe7TfdjQWFco0fNmaG955R6ZuqA99tKe2tDyLUhJhEr59Sm3YK2jm/R+8c/6T6mx5wbJaQbJkefP173MDm95pVKe4GbPt1WbyCy47PkQhjWMMl49pYOzofIa4lPmO/RIFdPz35M9qvU7IGyoSW2UtXz/b66pHdnaKBscmqElbmAhF9Yxc9uAJU9IwtJkRHvXsDJbKjnZ9e9vydNfO/yBVhHuoUhiDBfbJ+bjGz9hB5sSaAj1R31vZZxzKF+qmdynw7DUVyCV5TUVqnAD68v8pQOEhKB0zbtMPfzMmCihUgCD65Pnt9UGN+gYISaeqlr/vEpAbk4oJoOlwHbk2Ukc5ir+Y0xRUEy/VusvEYK+5EY30yCFFJ+3SwL8QdOKtJHC5g9EtGqR/EmgMLjzr6DTL/AHqFqTtdG+yKPriFy8CJd4WHGHxGngGkyXdTa9NjPyJbK9XjbRsPHFcLKmFL3J/wCCJfStVTyYgOuUOQ5uKDlq08k76rd7cOBBMEGcoGfcj9VVbPf0sqk+hChwUxz/bsKjq4x7udxoRiXgSz2nWhPWRZSezgIfKrSIOnMGfyaaQXVRC+YK8T5BTFE8VxHVYh1UGyQEL/tsZW/HVu4RPUHwvcM2+i1jrNlLkx0IrQNMwNqtVKglRXhKINA5tW1lna/8Fqaq3KAX7CZ51TQmPI43jYQW+435C+sOrqNIj4qucE0hulGJwnEjcy7jN8s/W9Ine1P3zDQVf+ZIptyVJC73gKJdQ1NKjzkrN5XKYD1q+0vC8lxGHr5xULyo3BTPRs7PsxbuZmCBm8kZ5zHX1S6B6OLkbcLhQbF7wAhp/EeDrg65gb88+fxShPw5z2Idcf/vUj24nWumcDP+CF2laBbyNyZwblSHbn5W+No33PsqUw0gGDo10zzZIwcdnHZeCffWjCmHa+y8S+8DzpXucU3IzTtyK79zRKLAIopDnENHhLLDLBEQlJWdIaYZb9udFig+AKWEDsJZOsEMakcvkKwSyhHh3YRMPGHCU7dSDfZJzhALPKkZILYeYuebTCinkP+PUB7FxCtO7aqPwI8Wv0qwsfPH/KzDDCoXuoCsEOfrcM0lBW4uSMakp1qzCY+AL5xaKIWdypG0aStz9HGFwL3CdJeVdCjwB0dSM8jYKJ3DqXLSN4Wx6GOfvSaWWX2ioSthUYa65G1aieMgkiAmuR/oLgO1PKnrROBMXEL3bi7ioybAwAyyNITeV0JceyAXVJ4Q/+/WdJDXqV6DXZX1bDi4eHrpUz+XuHEZoPtQwS7Hqs7lHKXu9wQPSXXqbBl74YhCnwesYL97nuzlkmD0AJ27OItXp306HUPzG0QYOCvOdqDi1595ORlqa3fdLutMBQfrTFdyWuErQfb3t/Jb8AQIKgxq+AtUZF3QuQfL58CuxZZvcq1DwL0/CnQsZclLf7GI5Q/skPEngWOigc7UNxhBrPRfkzmr81N1EqYHL5SiDxtFY6C8ld57hIItIGFaBfT22OA0nEQVSVErMc4S7gKkUo/wJwpbIGUrvIHbm1fBsqUsOv/9rGXJ2PGKbYEb13PNBWnB1tq32qJ0aJsqa8z4LTlM2ztdPg5t2TnxfdRh6/8eoEjcyvSSPDmWPjtuiz96t5E0pGpzS2vu4CzGCWoC12kUwFYJqNsofIZ8gdC7r7JhsuSi6GBEo3nlFT6Ih87HlRgijZdm6/ulw3Yd9oHvj1xDa3uW1OpsiU7JMjo2GgKr4iTPttxtd9S7Lcco9M/TNRA/rYNLPrr1SxHbuXYyGQ3sEo8f3f51y68bK1QtdAw21vNUstbJeyWc7W1qsrR1+CN0ncpwWN8Z6nN+ohKPHjm2rx8+a5TsvZPOqOsiQkmfSFdqcjf+OOnAze3LZirPkKV1aUH4Dxa7QN14py6q2aJJRhygwQkphDt0CZ7IK5DW3nvU9FFX2RGSw6MmcboaFkRwznv7RxEd/wF18P4Fpm51adCkIx1kkOJr8+3GWZxpRfJYBBP1v6JKiULHY/hNVgJJtHkABDJTdYWLAUIFlZn2v3AxirySxkyg1rCxdD5Wj/Aeq1FAAmYBZOR0Fa6xZZEvxdkR5mRprjkgY+iszSUtsyoV/jSFHtGTl/PlTiYlpnz4dkA5noiPez2XBdtchaKRGLnqVeEnghWumGmw6lVsysIp8MAC8RnvlRhB1gtuWuL+fvRd1EgGhKCMYyzx5JGYs4Nu8IxKZxKnnEB/X/ROyun16iMd+dP2Mfo7iXrWf6Zt6yZWkdTJCVeq/S3RZrD8/BAMtceWz/KXKBFY6GNSTodqam703EOELaA4IqiLU3qW2ZfO6hywuzcYI0m+QialzTZ9pO+z1lXdh86gnV9i6oynvjVATCRXC3A8oAW58o9LzLwPoiX5+iMuLKtv93ppIKA3kn+P3n6PaErL9motRK/yJTjBBrbLD8WuKeoUwvQo19OwD0nGK198kudJbHilwu2/rivhHqhMcgVOoeAgk/5D911pEmNtMvCBO+hRcuhTWgQig2N0g/MiMFT5JJnlOwz8tlG7/7flWjVvdvQAYm1CjTvGledZPzWHNYBLXuOMJ7bGT/QjudE7kyiqsHXP6QagNHkBGwYrnGVi8TDmRMKGAvs1IdHmYjy+1hlosUI1r9uhJvkEbBs9oTj5Jj8PmoleUQRnGzgPSlH2T82nSNQFZdAlLrL8KB2wflKZePxZD9a10kLZ1cfP04SYzKSjioxu0vYjne65jDrgaHcUT21+PJVUJt1BLZXMhP7z9dUrcHfs3pPBiEX/g6DtotRUVdMjkMvUTRkKg50DgBfJaTeAt5Sp8O8DZrT0mG5URqhBfAaoZnedcL/rlnl5/IMerReKubm3Tdo+2S1WDQ11e6eKhsWsAkz/wQdTMoPbUxi7zwcr1HeCoWZdvLMIz2T7N8bOHiT65DtogpMuOODiSzlT2LVFL6s2GPWxMVf/M8B6gFiyauRxFDpYPebAKq0SLtXeUnATWV6PFlzAYF4Gj/e7S9Gal6C3pO6jSmpcYsmQMfiSoy0c7H+UE+wCHU0msBb1f6s8cEVlJTepQ2h4J0bvS1nPX1uslFQb3tE12Q2eIxLmKx+eZenmkJOktiqsak/WwEa7lQmi95jBCoTmeW1YH0DrrouFJed7K5NISz7WIWJcmaPUtRvHsM5RYb4IXf+KzJakNR8u+IPKg4DR7HsEqF6CuOS5hLdNUX6K+Jh/QYZz35gFEEcKyC83xrdCyPUEGlVmehEoYcsE+ze/i1mGl5AZUak0C0etKFBh3U1PWGjoEFypWZEm0MSZGxSWpe0wDg3hGtaFvDE0raMedTWfFrTWXsOJg/+LgwfxGpYLfM74Cg2phtkFaL7CfEvKR8XbdjDjbbfL9dM5Syu52V9trSDQiLxTnhwum8y15wrsC/fDTEJiOwUpty9ZBzQclkC3XFpgc/5oidycBlPrCFUTb9S9ZwE4miVAtfPjpAEDekMrBZNj3gvDSMJfYgR4H/aBY0LkKcHQz98Y9sKeTad10XBMfgX6wacqPtCW8UcPUN7MBx6KoL6IKvEFwsu7/ycCOj7iOzMs3waGE0AksP2SL+um0vI5k0TesP+E0RPxJNBv1U5MoaGNqj2kNEpdqa/RuLWQkXU5SNUe4UY/PsuZCuzmwmT0TkZNqEc4SYdmABhbndgkS93tPD6c6SPW2B/zX4NLiiEFXrwEsrdJpc3eYWm2zQ0CJB2L3RxtvalATCf0moJlDZ4HB662DlxPQ9+Pb3mdDAU2W9D7MM7kHcbXwzN4Ub0qVooYW898p8pWlcE37qVewxZgJIgPyHhznJA5hPLE2QtlngcZdY4PkSkZ64bjd/i053mLi+Xlqbqi1f5fByzKwFn0Vc0HCCZjUy/I9BRKIFarYsf99hlwhOea2uLjbmzVmpwJv/A/ZBF59GMxMzviwWXy4LmsUTADwaGJzmJRpzJ04XjK8xQSddaxukbqv0pS62QiLY2utk0vs2nhZIBQRTzfsOJGN9Hwx0VROKaM4TQyBjfqru1U4KH0bnee2/Vn1nHD17qYiQ7VyEfQ1rO2gtjTUDo8DGJ0gHe0F+p0SwhB32bX0OFMcCDHIFn7mvg81HBfDvsCrwBXR8gTYsXH0fTxn5rgijMUA9yvarOrYDkUAh81asv4jT7s4DH+2bapduFdPnGtJXKvegB66JE1HQlNYXknODZbsccGVYixv/mS31hsCAT6bLA4fz5tpPW+e5DQDUkyZCzWLZJxz2AABbFT7Zx290YvlMI1MdexkxVP6Mlpfo9ux4gJYDoj6C298ekzwRR+w/hHcPBJm1JHdKLPj4M1Ffi88zP72BEwIMlNAS+t5n3W4pcTm+Y2ujm7F4MuVSqI4pcLNVrcMvQfK7TsqfSisrT4lRXJ0i1WqCBmADOdzcOdYFLKCE6N2sNh9E6CHQg5RfZeVWg1FyF9xafeLzIOvGHdLB+uc4ElNxY8DBg4kFE7In0tn6TvGzjr4eApeA2hnIsurrHVZPN7IWajvvr3jgrwJL6JwBNWhQDc06G2YplvwqEbnQA3GAU6Uyz8MYFMrh0FjQwTolisifFG3aCX3UktSvc7JIA4t/bWLqxIJedAZOP//w4eQy2vAjWPZ4y6VmZCbGUbwJ5nHU/+EkGfYEsRYhzyj3ReP5bUexPuH7WzBjTg+mfeElDEihO02Wp4lDJjpDb7NejM93jkqjG1wcDsfUqr/SolwlTmxWkxSKcqT32Xt4VhYFbGxpNrFbK+CPdUR8iA2Mj1J1E7bVunBIqK/W9iCPdUAHxIKjJRQZiYXKBpEnAHQSXoDjbZLtbXyOh5BN+mWbtq/kY65V81NW1wAkrul9S4Ub6RmJMI2Gp+ZuI3pF9sWAEamXimXa0Us81reVCph/Z1SCkJk6OSgfvgNhiLC7SqTNIN7GlOq1/fs2KkeJAODI3EQO/+K1ROv5bg8kDp7MECEVpL2PcygLoSOgf4ysbaeWhDQx00IzBxaBnHuIr8zLVRvdJdR0mzIFCT0rIxQDAmdAuXCPfR8Y+jpsYI8ChCqZiBPMMpz6RsVUL6KbfgsEu1BjiWAo2Wj1xDYQDZKq9NhBfq8HmP8zEwIPiqo5IwLuBzJHYTOVmH7RpxtWTBgOGAI86AjwfXbH65thYGVr9baZrQW3JpUbK3qnsLh6kRoLlGZOytQsCiIeMob2L8I+Dl4fzY/B6c+3qIGSSitxAIEzM7xr3dcJ1w8+AfxQvi5mi0gb422hQp2I480YjiRVuaCny4h5abl4EMik2rk7zaBNFIpQtOvSKCJ2s7iktz9OH8KAx+ctcJdJV/JTFqCJ8EGx/z1PThhZztlbqkYfFir/yxeSqDUTJdFFVYfor+y3bUEjCkxrXA1O0+QKiQomswJZzrd2upKg79U5f2p9lxsFZ7Iv+DE9YuXLbaumUpN4BuKACLnNAjftXN1YHz7WEGbQ7eTPaT9K64RpYWhvo9zMPsO2Ytad4/6gD4AQVd+erz8O+5NlAJLD6ZvhyXk9Tg41eEAtGv4tCC6x6VlX8yd85hhTAO0WmQnHHsI101N9wOByyzNy1XTJP/ZdewOWKIul6DR3Ys06wOTdZRfUxJw6yMu31thBHcKy7n5l8IrjFuNyEupTPHaxD/3Wz41u9YJz7XPw6G6Hj2mAg4B5D4wYsk7jxOE20+Km2e8qQfDdkAMSxqAxTpWcEe9EY2EmcVDJ3eUJkmRIffHla4Xs1/KLLfqp5514YguyJOrkvuzBcdELVKuMmKxOrFmIoHTLE8UlPOSo6LNechlzg+w2AfRSoTGcIoDGXTRUnrjRAyKts5RSI4tGdlh3tRLNJWzY9ENiIFUczIkgxJlV8bCpzdcvvkriYEj7eNCnNTU3SdrI4ohAXpas4q1RZ9DTOwdtEZrsOcsJ+L6BABhD/jtQMyxJ4smlE33ojWjzMwXUrqfZ2W8rKFeddWP9NDUDTP4z+tJ8d7NUSvcSzzh2+ogOTikaDcjOLtekENmP4mSii9t5s/Uggfrdti9nxs/XSQzHG+NqLDIQ2qppyN4Ch84n51wO8pwNQUsaNZBdf3reSiyWRrKxunrAaUrwlWW5dZq845QaWc+KYGmh3lTfym+uuY9VC0iaaLoOz5CQRIkWN/BWxxXr7HuyNyhwPBVJOu9OfH0OclFPUY/3nLtqBKjl0l+gGSSkgfNHZMblon2r08jcBghvX0hSlJ1XGxw0xQL6AFwuqeeS+hcluF0vBVDP4nV589QIahfgT3im2uILCRVOMzFLNe2zPIskATNHZIvMDVqIiruMIcO1IpJ+e+xTVfKiltzNCVdpKjWNuXcTrxPmqG0lO+3R0y15jj9QCxoYrCy/9EgE9JU6GLh+4t+4LYWKy87zyFZQBzknLZ/mECDcOovQWp5WEanke6OrfCOGZTtQM3oEacy94M0+Qb8GfZJxjViyM5KyLhHClT4Mr0eBhngTJ4qN5tLxkZGTD9X4QqmJjx7l4x7kejKDtoo3YKdjVc9YOOjRyiG/2Wl2qQC189XnnIuof1X58qHwmdPkqK9xTD+1Yj+fLfmsdvpwdxX0352tvdjzYxFcPCV6epX8eexrFHiHWyhKpDFg7LimA9N0HNA9qIshNuXly+6pxfzslYnTo+lRH1QkqHdCGDNYFqqLDCQ83PIXZIpmYafxg+L4eYEwt4J+OGZ9S3vj9zR6Vfp+Ux30KvHEdnb6hpTPlcHW7fXc0Q1UQiXn0CAwCweWkGj1IudJzEWAP5lwYUR+4mXupH90ee7nyVpydjsj9hAOzkr/iKbDh2ycyrT0xxdbJewV6n+K47wB4bBh24ZLHHn4S68AR14/2AdoGTAxlaY/QzIKy+TUqUluNoThXJYZJ3nk9HPo9/Y4ZfCgEttBlIaB0ca6VTVLbjlhNEM88f3lQV9UBEDzBs5+WYnMDoMHZfaqTkGRoVSR9m2bb/tmDT4k6cn/7K/pjTtDAIMZM2K/H6XBElIp1Sf+UAtZs5mCg0lTPGKTVjGfaU9HzLxtOAC6KrwiM45Se0vOrMh0MtX/G8Gq2RMd645ko91l+S6/4tBRxeEF25Mo8XhCSLfl1e/+Somi5v2b/5v4qNBZmXZzoR6Ognp40WMslQ9BSfB6XmIwTOe+hV92vKXR4dHHT6WYZeD3c6OwvqwYjeDcTYEQJwwYcvHt4dprYi+gpTGN4XVpXtHEVot58ZkvaFGJD5XhHq1zNbflW3Ikt2jclzSoX/eGJNFz6lwsbkn4P93WR3GB6SGu0BzSVMcLY/GniEBlz8y5uldsxVU/lizYYrZEoeLVG0ssvdw8cfKPjcwmvrOE54I1oFr35epDk8aK3m0KmfVLKZO6bejKzPy0EdwPkd/3DEQYs1+rwUpqUwdMCA8Iytbna07ewXnGunEaK5UJYEbokBvITYgpXOM7fzYJ8C8R6/2Kfs3eQsheWsRjV8pTj4aIhTRZDCLR/omNP3NhZ366tzfgzZg3JxyfNFH7zjL8Hq6iV5ZH453jhNkoVV/QDoWhlD0sIWjZI8lok5I3qYS7dyd4SQoAPz3csXY7tf/biXf/1NPUlN2g5JUXjPP619iaevycZx71OYvMnsWefUMBDmgbVEifYd0lOm8DthHXiKNd4+ZAl0KX33DiCHMBMFgIk75gpiuDkM9Fs7LUuJMsu5gnDwzLUU/NVK19UWMzXVdy0HDDRJ1fXh53QFuhBG4e+S0VVKRbtdUt9VKhjKv55ecP9A0AK956zC0XFgRwOjSwhdpOLnQYuPVtBr58NYpHeDoBPYGiVa8warPAAgwpycaaK8DOYG3cm84zHopJqmj/mzCVpKU3a/LwgVM1g9VkQ8Rgpl9sbDIXLZ4kkYXyRpo5mSxBuZavzga1odrsLKThRpytCJu4eZcRFfe7HYsQPEjzR8ClzoapHeQ3MGUOlxuVqPbJIFc3WsDFfXUkIqzNhIbSQl56uKNEEhBH0eSkP+limv3f7cTbL9nppk6VrI4Ozk9xJ2qKlwUYbmyWh/32UdhKQQESYJbahykwOl9NXFrFibmKLj3dUBVYswCMaHN0GPCBgqyOKZ0lXTQEhwEMv5ryu1A3QPRY5l9h678itJMELGldu+qgm+3QpVZUDWzNTKEq6+6ra/MJDt/rGOkuu1E/mK681bUfEX1BGRCv2X8JEi1yo/X1DBJoIs0ZtI74E/zWxl5kTLuc3yuZ1EFZz+Q849W9KOoqklowLILM0HexDNTjR/OgfaVr0C4jVLo/5LaSbdmR8aCsdl5ysED8Z8lcjMZneJqdCyj+jj/VkS/06iHGrxjF4pQBgRwUvKvnCc8DfHX8+d6H0Vi4VIQCwYO+A6xLxyDag84TONaYeD5qaHviQTTxzu04G/6L1heESRxqsz9rwylMNxOdJKJQzalW4cRLBAV6aquxC/2zmGPcD/qV10aFYojZ3LGl4VPdUyat/JogiUaJtb1PVtfjBYsuFPH6tyTu/tiA08lcDA05NnyyzhwAZimf+LcJ5bYTwE6EE1Vna2kdOE/XkwVSfgWrRCDXvVYkPeICZe2V8iTC9SB8Cg6VZsOVks8pTc3VeDnKD1m9DhocXTdvQAzCgFG6ryVFjl87wPG0u3/mwIfW6vlwljA5swKM/6WoPY3o1iNv5WWrfOOa/RZ2soeraf7RWDV+VVemoX8nSFeU9AEU2uyGdud9YciBzo3t6aPNoBIk8YVKVMmKLoNj4zaoTjpcB1BEqjHirNdnUscW61aLWqY60/0LJy4JfOXKIc+WHH3egNfDapY0DhWtnGBc+McLQ9vlLZ5JNZafFRlW3bAwPcvjyg7VTIwaz8lWr4CeEwp/dl8noxQwSgxJzjKqWHl4KCeKuEPSsub2hcXPM0iVzgyVBjKgITKtFqKn6iSUcFPl8yQ2iTxLLJPKL6OnLw9+ArzORe5xZBVOwj/yInvPV4sEvhmv5oerGzcZ1b5HytrHVSuukKygYiTYxk4Ex0/FK1o0v86nJVmTOmn2hU1UslQaeLxHzkvG5V6wtGG9ad4ru0ZTEssPEXjaJs9iHmfMr0WP56e+CVEsZRIczAML63lQxENI3Kl9KOyRdoc6mX4g7kKTkCv0jEM4D3DnYRXfn8Wm/U4VewNSyhwPknZbEQeEVolwY81Q/x5ptLlHBcK/y52NhOFcucXQ1C9zORZ0yhPBdp1WsW8fR6ounH+TLLO3ap4o6ODJutHR4VNVBrysxHmeAUUBae9gMFvONK/bTxjF2nexv9YDUeXAhscsNg33Scjx4WgsykOLlTkTOH/g2/FTjER4udkdz54Jab/X/3gnHZ7TvBUGqlmZo422CPGcTkTvFdwBxwbFfIBP+UHiBVmTgnAcaHOchIrPcL0Rj5z9NQFsjSWbJF2K6prSSSWzFplIXNKsw3J7v2SJsTk+EPOWJvTZ4SyYLTPUwocX2M+cti9SeehF9a/HmofEpX55lDzLkN+K11Jgzj27XfX9FhxQFLhFciIciq1Whrs5PdHfVZq2a9lOnF/pQVTRK8RdydnfzG9bOWnuKXK7kmsffS2MB0s+I6TBsJHpjQ8/rfvOhu8rg245CLvIRsV5BUqVw2VUUNqa8Y4w1PBZy16C5LcGqpAvJRbBwpd0VBm4vB7v6DtNQxRHtABXcFWggZWDuBfMi6LG1pRdOPzLhkpYZp3cBNsq8jFypZnewgTHlh6vaoWf+yi7xBWB7HVgrK4FUAdNZyB2PBOOJhKLLyqYuqkSaaKxw1urWVPyE8p8o6RqegUPeK7aQ0D3K+JF7fAUeYiOb5P20OdpAlLV5ccP2wUmMtKQY5TDwXYBNxKgrYEysYd8MuWM9HhG3gPj8b0NjUtlcQ95WoV5K6dPGkosIa6IsICoKnSM7ls7+eCEVjrwv4wk2AoLMaTngycIjx5SarAWg/07FQzBBsJGBWMIzOl47kmG8uImq/7bo3fBa2N/HgoxNd1n+QL6FCH39nsLHPJkd3QC2sOou5x9dqAlkdELy4nqxUDmKsq7qQENYQ1NKpUwhB/6vr5q+/GAzQJjMd0SRqpQC2z6n2qkofsQ3YzPUMH4NnzsgiSUiNQZmC7gYERCPdJPCvx+a0CzQJw1GL8pjFrhov3rciTaSZ40LYVA/3TE10L3c+N8m8ym78YGsFSSJd5vINzKrgKeL21F5dHAS2AcQ3IrPYxZtjRb4tJoXcoOInnnoN1O3COdAu7iJzyfv+VEJexWS5gs/RvJcHMsBbQ4uMlr+gSyhpCJ0BGOCSuIjY3LJ1RaMIs507RZsRB15/WMzFVFL7NFJulEPegYp2nYsZC+C3pGnL91DZtdpPCvaxEaSOAAVqROstxPmiOLR0gzjq2SFXuyd10PDZVDmcNVISVSOwQE2OK0ck3MUD0aoOPASSQmxfXmWElQ4MHQDd8W5/uEYZGNn+KhrsF1hdKTfby3BPfQ2iQpZeG8aLhY0+sckSUiGyCbcFYUf0Ao9OECWhxh9AMFlkUT7oAMsQ2ZUOeZg3js0kSs3wsFZHQncjDz5LazkTHHOLOLWaZV0LwusbDsmZ004aUllmtlhYv3NGDc7mz0oKUaN4xUdcNT5E/7kNZRzZx8WpuIwu0j+NiEXVpSUcRqO71u3uSXm13mY0gGJfW/fFWEJqGi48WHdRc/PKOM9zOeKz1H5nH9MdMXV4wVxuMnMuauofMNielXp45i/KwU4RC/+Z37xHV3TnCS8wptXmAEgaEtQ7M9BJg39YncpideV3gWdhrKuU+Nz8zxW0MGxQv+UmsAed1Iw1SFKGC7KZcwMKSSUQztXJO2magAQR2Z42lZKWl1Lpy9zZFKqJPB7ZLvR1ZiHuLLYT2ssg9Lbnu4W2E6hxwMFlWPytJ2VE0hpcysXyLvJGI1wqk11hdxM6HzamkdCoBvYlQILJJjMBY7npF1cJGAsfc1WRkx39S7B+CMHCWq55oF/nQHwaOK+65uyxaB5oBmB3e1WVN+zeRA+05zWxXRCtWaa6EzLKSzsAPTc9oq0iQTFZ0TqwHfoH5ib8PhG9jN3Hdgc04mBA0SQNXcc/eKRWglukkp7B8fv8QzxQ9TK6+aZv4we0pBKtgojj0pKUX7b/X3s7Ru5n8n1lgnVj0eGCvt1KKXFpb6MOqmkLHqvBX0zdzXcL/IAJutce6RA7qYtaKSXaMA3h5b8XirSoRlJDP2+OTDxN+KBuka+fB9HbS7OtJ8wSNy17hoVBQPGs3eQe9gXJAriPdRPn1i58BO25Lez/DnAnozR3N/6+ONMC2vOEVj+zcWJk43x4VvfvZEPQyr63PVoJ5d+jQd5eSsie2VhMdN+GiNZ5s+GfXJJH1DmcvENcvCe1FOzPeIR6+Hruwkc+HpgAEMWP7TCHQW0CfBbo8DIWNi7u+9IFesWgEQdgCjRfaq2joTIKfFA5w3UdrCO1pQJtwJDvTlMnk1xlUuoZgXxFByaSJLE0GSdKZoWi8BEy8m2knMJAdVA96ElnPB34YDFXUv6JMvBGKW40YrbfVhQHq05zV2fU9AdkIey14mFmpuZEcAXS00r+22VZ2SjMymeVlyq00hGbd5iERQJsXm7N3aaYGkYpZt1U9BzcEIxlpxhCIjmP4PR6kQETZ/1SwjLfnp2OgL4Yl9o7f+BDxuQ9yCYQo95Q8PkVzEkgNEA887yT3my65CewkyDtJeLNm7JhpgSuMORBNtWq7PfWcfZufR+SPn5ulpqHJaIi13jYagG5oJL/uYZFhNvBgQv2JoG9mDzfiHPWbRuZu17qPJirKBHe+Bh05Cg6anW5FovnN9xPbvLbjMoqZ65FdPYsFF1T0S0yUzDlnp5TWtWdgVFdaPu0NL0N/ctWEXdAgWKHzC34U4Wu6R2ElKZjcZYyfJg0YtatJTi/2cTmG55jF9vxKRTNuDwfOm98VKId3frSiZT3s46g7TpmnsPG88VWLMns1SyqCxL8HNqn1M1FjBMzXt9xF5UbHpdpgoYvVAjwTRUzGxk99Nm+7Gd6rkFehxdgytrZgYhe6dcIPNQbZ+85t/mJyWqnWefaTPB+SqzORxPFg9pCBAL75NMafJZxgsgCZZKf2SGpw+Ozl5+aUcc4fMHRgSDjWho8r4e+fi44O3q5WExUDmT3dgstnfK5zM54vG/7s/MkCmre7NTnVYAApoPCEiHRS9JAjE5xuGC9VAoac2co7++ZK4aIub9GTKesIQ5KpBd4w/VaklxJiBEk2fN/33B9t3/pepUgxc2fqZMQb/6DdodVthwbyPAXOc5G4i8mPGk0XAaN5tF3qjm7yHoYWIIRhSM6FBeclN3FHegmKop+FnoF2jAEnRo3j0Tium0BBufWNFFTZfKtsX2fHO8W/vfOF72CDjhHSa7M25D85+eK81aH/CQ2VucaXFEAN/g2bVdzEzPGB6gGQFAkObO8dljCDy1bj64jU1rUcfLlxpDpZkiDtJkxAAfEZIebVbY4NX128H0TGVf/7pUrr2he2tU+J9eJcq04Tj6qgBNPpzJuayv8HbKq4JgAx7i0ZEo505HV03DssABfUwwt5BGivb/EokmketDo3AullSEp2ZFsOKARu5lFoUfs+5gIOiERwayKYFPlkI0lFx8dx2O5Gz1FTk+iImnCBstf6PN1iKx4KyFTBP0rW5SwgUEt0BOjYpQFNhHBKrz/n8FfvaIDXmubFHGa7S92YjK/Pd45X/mgY0QTGnnqgzcWhXKAXP5KMnaChoF9VX16SrfA+TTpX7ZHdEW+/NzBJ4SSewgxhrhLlPhtK1eLnhcVuRJSqGTB6dwviD0FsWd6LZnyVKekv3kMkYITtUm+Lz1uouFx+3u+mMTfRqYie7J0/Z84rP1MaMJLSfPXaDzvrSj93NqA0VmCK75aghz8O9uadj3ZIp2e4YlKlu9NbyuKLJstypA4iV106YUukryhgVYaIi/hxJ9UjeQBjDit2iIDOVjtamdPWBXTKwYawipoWYShGkDm1dEhG+PcZpak5wkFRu/JElw7PSPsTzufs8RcoZY0NLt0rMeU4bsqiVcdPUK8Lf8+2hvBI8rYlgfmVkXMn2jLw5G6jisUx7OH92UODbEQuua+52Vi3THsvJDjzR43Xui5lFObh6AvIimpmXzO07wUD1sBMR2T3qO+TDSNWlakzk85WGb6CJ/MjlA2o8J0Ik9ty9bAH3l35cRszVP6U0Rb8rzFcte2QDGz1nZ3ntLaoR2bFfR2bQpr5VGvkfIZYnYVEHLU5284HX9F48iswg7FerNhwhkn2tInG2TKFccRSUFxItJw+C67b5XWfqDozRVHGp/VsgcKqlBW5/wC8bk0hE6yiu4EeAraIVMfKpyCSL1umx1GWGY2tp66SSrpOfFbk0LToay2iY8jQ0BigIyM2O49acchTg0nhQUHfirMhs7/0bc0UooAWa3iu9AclCd9KM92+uMf8PqBeMhoMGMynCVf1iyeoYCCJoEx4Dsyl0YKD6HAxnuUL2xrvW06MIgZoQKkLSiExCUONKmi7RKPOFjLFMhJ6VB+7fekovL6MjQ+75NoUDSOW1M1B4WQrbe9Fb8t0lCm7Auck0UPsD+2pVdCqSfUcPoQ+5Nd6/4fj+78w+obcOMO+0rPwg/9K6fBKyBVT8svM3+mpHNdwFK8mc+w9KFdqtJz6XjRAaAMsf8QdYKKDK6pjgyG+sW0yWxOS111dibEg0IHnRTURL04DQGnbkFdl+tE4f5rZzLnO0i2/WGYKOe7nlYvIR81zf4zne4F2d2k1mHHBbhllN8/t21bZH1wtciTh4ZnPDvKPnBhZYSXpFHL0TnwfL45w6umgJznZX3vz+tHB85q6cP2ZSMB2+J4HigXeuSyaR8JFDNnMfcSWxvIy29LaeUMrGfE0oldvbdHsC36Mizb3CmNetyr15eW7Wl2b9EEvOPTCsdxvC+YchrJNxbVnUHCUUt4laQHDlsWSv9jm/1Q6PaviO6smC3C47pKJyJT/CHvkJWZ4X+bcEzKQBT2Vx4reBZX+OBHu1dwoULWNndTgFrwbMoBEvvavYq8SsvVqmI0HQN63aDKb45QZZ+iF/dQe6P+Ioef17m0TDnxnQ/S4OSzSdOhPbXWDmDN1Wh0nwZBdL37AEw74HX5Veed9ONo+iPtmw4QUs2YmERsah1axdvACPVxy5nMcI67kM4mObPsrSs30q8uHewM8pqkt5VvbXjMT1yiSTm5pRh2z8lWj5BShFt5pJbez/7azCDdhewhqDGJyGg1mu2AYoI7sCGpvO0iUVAjQPCT2+JpKoXcTwZj3CuxGa5ls/jPTwUdRiVLUUVAjK8n43GugCsqCVwVKvB4DuZyCSZyayk5dtDSubIkb9DIr4s0OmnLN0WoZYqY9DyIIN60rz3D+fZDDnJqvnyuqrcZm5Bs1olgma6JxK+oIoAgydC4TehEUfQaz8kwnk8i0AEX3bomQBt82PyM/K8lEwlRWASUb0eAS/T7Uzg7kyTZDPHGAS1DhH2lgMY4PjCPAC9e6na5sgt0uEsE2fK+ld9lknPFiRS5ce51Q9IZhAYebTO1wybzO5hwttFmOQyOYlZfbdKJf7EoQmLDsieKeWci1tzR9SS0lRGsDtoX91jMBX3B3PgV244y0cK2BwJKz7Gq/fVgydWE/tD5o9v62N8JKJR5USSkl2DITuRkw+Wd3ssGsYIhrO4NA3qIAaOyJq6WKtjo/ewzvi56k02IG4TrVLnV0O12q17ZdgkSHwSsOn+g/tikwYRZCrhWpyeUDgW9vlkyij3fNPWFLVcKyNXzuuLT+teMdEeq0SMTpLO4DMf+EWbUJ/kCgCYiF19ahd0GdqxE+2GvCkXdpLzUVBDIsE/5ZWk/FL1iq/o2uJ8bGalRq7PD+1KNwYQTrXneB54Qgwsj2Mxw5F1Fd+d8PPP6aEPlXaFik/86PkpiFWon6/2wAcp1DEVD2d3k4fJJqQNYbV/1xlvkiV56XSRY5z2WQQhStEEgQnSgpyhkYdpSG8ZQxnw6DNvQ2cf9RbXiZfPPQtNw4JFI12TfnApZFXdDp9IfR7WDmnNBMZBbs97vqhNQn3jd5QW3YuARxZQ0+4y4DErl1RDmFjRrMC0sGfC9dRkdHHLP+d96BggZfOGHL17n5AplDtErc9a7eNh6/g8R6oM31XdlwqGdD754vv7OQdsAW2cdlczba/D0k0z4iwlps6IN32Yec6UeKnF98/vLyZZw2losheCbbMxM6UwVZZ4zcO4KS3CfAyT/YdivTm2GWPGCEJwqXYtJPVLvap7X1CIQnJls1lwojsJVhhxhC/3cOuS0sqSr3w3sERNYvmboBOQuLSfzT0nLUD4gbW72B2BNGpxMBT0Y5TA4SdT2Lfy3hg/f+SLhM81hieeQICZ4pv7iAXNnUvL4jcYfZvQyeUbOIwD6tRQplmWrYOBTAwCcAPgnOcEbQf8F0RkEyULlS09OKHHq15GiP/uPW9MdhVuyfHDgBoKF4SzgCSNIz41ImM7XlFceSVb2DlGjQkPCTIKQ7Eh5P1/ng/ZX1Qn1fH3qsvtm010bo4pah+KvvFmX0cGuyws6Jh9GsAkwtlp9Gv0YfRkwOUXKN7+2s+7kP26lgT7nvUr7Tpih1YXzFTJpKHipF+gik2zobEABXEm0fFq3UN+Y8imEgpSXzNovUMJEzLx6PUJR0MaPoiA77Yoxoj5GfHMhTlIVz3At0lMCFDCSPBZ+12dKsbt4TgE2HSMTQqoNS6mUzTXw0pKRmCRl/UydvhDCZL9Wii/QOok8a3aarNLGnXV+t3VJNWVdXDqnwhrr3TQnzA812FGMTzUZqOilt9VMijHL+9Lz++BfkvFmyIgA3ScVpU7v/36WxmyU4Fz9HPUx5N7knwV88oZ7jJKxJBtw7tDEuvyirIsX4HSv4oxrcbEQUMAt1qfsMnpbO009zNlwoUJrobiUY4an+nA3QpRph6/jxGCiqbmCtzhO6Qu7T3Z5pDQrCF3YNVO6cfYB7LIl0jSNApONc+eX7v84r72Kc8HjEdk2jQvefq9kyWEcDSllIxthfBWoPs+6Y/QCH9YYoCSmNNTciFiVJr6iAJlzjWIicnE8lu7HKnCvV8fV76IZw8cXo0fn4p+XzCxk2L8nUSv8WQpW/dHKzy0Hzg94eIfZwxc4gV3K6+d8tnNVSfPExHrLLofaCl1Pc8UsmlX1lxauts5aDXEMZu3hfDn4Za0o3HwBaxFuCZOXoOcmUazQQuGytxKOAZdvAJzawY9ASE0r02zsFSdwYbN3wqG9sj4q6P6kHw5mRR0spJl20W7JB5a18QYsVG+aQLbpx9erveUMBthaU6U0xQmvGM/2mYpg/DhWHq1bJk1tONNigNZMehz5E8hx96duIfUBu4EPnrHqKY4+l/ZjDm9P88nLyvwtufNRHLtk8hI9pU2vQe4Mcsv1dRbi2UqWU0FepWwLZSdVVEMqqgPM0sUZ3Etg2oEL1JLN/sLuGPq+HDkmQ09KR+HgtaF5tgNi4RMdjo90VHlHQ5MzD90IujNFfP4H72GyO5WGGGvkS1BcAzT3SYjF1i2Ug+xGxjR1PVhkq2+vwkakAbq1LReugeXY156N9lraunFli1WM126F01fFMVsbI4m/Ccyq5WqIIHz4GLMnLL0+uOumUaXWAmsO2jyoSKIchCdyIcy1yoQBWxg7JDhRF+o6X9UP737rJm9qa7DHXFyGLu5nG3OObFI1uGC1EV6M5tnGIYd38jan3LqyYm9KdegAHHmZEox6rAWTVuflo2hfjhYh3lw65E+u1addqQc/5z6DYTvwfZz0Sl15bo3E9RsGWVVBaLoR1IymkN9qZHY9bHmqyb/C20wvGkkVhj/VsK3koKlCz9NkeJc60WYIdihrHyofEq8la69OxrkCgch6CtBpnocFmLDQr6l8hhbVp9xXxiVsbsGW46E2u+8gNGFlzvJyK20xlEHhvHWBTXPis672hvrv6K7UVS2gIZM7j0hOMqpVW+20dxAgZbDwcGVC5cO9IsJeb+aFjdDlJbFMq6JDyXMbTwggWGHm51301kidezOYXVAByFVvcUuutXKjlEcniy4FSjpJUC4Zpzal5WKz5EkHjxhwr5Dqmnd9cFLnBPvWS273qke0I5y2zF5WE3BdUwqqkqporfFFjd48olU5sfk1uhCNFK3yVhMUlTwzFbPTVD7MBaq8+7TRqZKU69yYXMpZraLMx5t2VoV9U28jTT1LDLNMu0sLGyYR2IWdmIEbnse2FJhiVTkteknX0xlj6wmFEDiCRW6pCLMkBm+DxIS65moFxxtW81Y1cwWYxd8D3RJWJVJak5JDU7CTddyQ+ftT1VH9wDCuz9PPt0CpPUUa5PhI3rVZXVSERs3VR7HcyI3lTGhgj8v7k1GYPgqP/KGH2K/JsPuWEreaFkSOEExx9NEIKyndsb9y60IdB9JH4z31YjV0589Zzg2kQppuPMIpGDdGbZNc4TAbMsy7doQQXPZFeQP3CzqGILU1iyajLle18BvEuFVm9pSQaysjUgNGXggm1TPZalW6lhT28D7S7lUtXTnCgl0j/edMzmyvoLJfQsMTt6YRlfmF15TbfsiQi4+0Aa1VHY5mUHV7uwpRwy+XeFiWSjAPhFIOdOKU7KAplj/3WtBbXyaMOuz2DDDiiNsgLB2EmBrf0S7khFO/VV2IWx+tjcdVaFeNmDDgb8w+9oEQ2Soa8VxqQsyxEoJA4VnEZKRsmbsodYAev9hm/F69DYs7f87ymZ0QSvf5dZS3DxT0UEfevMVmPJI3Xj9oJeTgznuie9XA9XoZ6Jdeyaa9sQVOCkV8dYEWnaxrcs5idCYGsG1ajG/TKOCuC7u64+DIEqioRR833Y9Q3YaqyOgKoIMCXsuynClFuoJmE9WxXRWpQdEjAiyA/QXTM/WqvUfE0KgwpMDnKSYxrttRCCWsETmoSXj4hKJbwhTkkyIHjgrrQj9Ap2LDckdRVDMcIQ5TTz7xOmevl45bnzELOTQYGKnSyIn4dReSoU6ebesDOXjgW/eCdKUedo/VBGWBfGin5sV1vGsnLM31azDqfC3UkxV/mhyOeD07eI8Ng+i/8lJCi+kOstsX1cnXkmXEZfQal0n742c15s1szTm6af3shvRNKHvHKHWCF0Wriq+VObQZKnsY+iioQBSqgS5P1ylM2KmQs0RxEhayzNt4syNwP6fkzNyoQXGOFThPblZNM8hWxsR5op6072HpS//9XLcfmCUI3/0fPZGrhbNk2f69X2kJSrJBqNB99BXrVs0Qnjo6BLfZQYXb5enzue3LFiU8Pg3yB0tg7q5GkigXcHuOFRwse8Yl/y+YQCuy3KzqVNP5k0/LjhhG+pP/F7lFroycGMGjaILeksim78xNpHYU15MWV0FTBDjluIQpTx6hEOc0SUCz8MXwwvyZSbB8WCHypbEvcSie2kEK5KQnLTypX4n+6OdFuAWziPy7rmO40VLEVmukAFmuPUxVx+SbnS67KqNNsE81Alg61lOGBL4jQ8ys2BBm7l8sQEdXeSEHP0W+3G8wBWyLn02YWy6oEUmiO/IFhAeqFEM2locwBXw1ZCc5724a77NMDzPSAfCS9RSBZDN3FSVd94iGyYlEmTXE2JfA8BTr8hn0S5Z52qevUa+o9U1gkWZ4Es777nv7JnnjOQKNHeM9wDXPvKMk5dqAjTLXBy95AgiUqt3UhXJnz0ms/qsiwMUkVwOSjj89wPcSZn65GeYUbB9eqVsOk/hU6LT+v5otB22f3A9p2MQKNPFi4d0jjLwfRiqLEwaLhZm82Xp3Og9iDfs5AlFMWlJIsaw95LWaVaurGiY9lwjDTR/nygzU18LIgDESw2rLCWkxlP8hxjsxHbuf2QJHwAnYae1HxcP3KSOyp8OkcgxCc3ZCxCrWTg48i5P8naaGZeyUhUfoUY/INVF1HfIvtB3hZvnZlWjBrSU/ZiOJZ9CnV3OtGw1V6+C3yFUjg0dndnX4Z1rxPqWk3ex0lZxtONLfYxfHaDBdg5uM0QCyl3H1G1cVPOjRjEpPO7V790hDQZPEAZEWg+l4/SbXS6h+D8QXbCVUbKygRKhDJjQasPPGV4yGxydV4mCtYGiqwnAPCwP2pUawim9tM7EY85yGzuwkl+nCulnNhQveNfkL0QtWWx558VnyoWOmUF0GSl3/ghItQ7LWdEZ+6srTBW/DBITGVOBHIcDOBxqgK2JamhPwBToTKwMUL/wPROFFKfzps6bA7CU9pSeIvJbaHvMRCFCC1AgbuG6ZA1mC9WpjrO9kswi8aJbMbS77ogStB1ua/ru1bWGro0Q5Lz09ssn3ceqQ2baAc0k29qSj8E+yUzQ48l6uBOn4AVYVZ8yNzOF5q7/OLZOTnJlYT8HG966E+uo0WHFJUQjztsA6YycJAQV/WoKiC3aLBx60gud851iJLzi1qkhar1piy8nGkEMGM70JrBbcufiwG3X4F0Fq9U6bA9TMfmbaIY3BtLK6f10UMN3POOV1s+xTGgUcQO9wyLh9897JkI3w21cNkDo2yBGNyfP5+GDOXhQZ+7jJuHV/SqhEqaBTUug+4SVOFzZylB84Q51F4otGpgWejqncfSbcPTs0EAMmgMqxD3ztmr0x95u+hUH/GCXboP5n+VjwKnL8E9NDdXt2waK3Vre+2jFsSigLVDkNmZReMcZcIr2bPb27CGd/K2pvgj+s8/BC/kH2xQvwL3yE0t9uHPNubLFS6T56km6N3X6iDiPxj4b1xI87DcvtqvYtl5eCrFD85se3UCtfutOVDY6vA4IhDkNz/4QjlxOXxQp0ZzqA9NxRDxn1oLgjc7hFFfz1aefUgRTRMh+K6XyCmsGB1tiYtgBz0DbGzzKhYnzx/92PK1Yx8DZZDsJvGOyzQ4x0nLTkXpNtupSf6s31LxxqsWCQRxmyavg4FIp0pYNXHl7o3evrSyXyErZjJDvclZbxRk7LwYwq8LitQG98XEmZmmAJsiODpQeZzR4V/zSjJNP/5OLA8/dFhro9GvDWeeXXLngFoMk15zsgB8E+6edV8AK2E9XlF3ZiM7v6MUpcQ2FwTJIbvAemLgqa8Bphhyaj9o4vK26OkXv5wL9p19a99SUC6Wa/bBMKUJuRq2hu+Xai7FmBTBf2eB3Z2/aUrcvBJxFmBb9VK1mTxG8WAstSTJZIQSrUMvnyNXho3FjPIQAtdo9p4f4u2PqpCkRE35QtiJ778BmJXSSOzZUe/ES1abze4od7aI1QHuFrj+RcCeOWAU690uQTDO5qV4xpelfei5UTgzdimb/48ZmX6VbCsyXzebBtQjLd87HEUwS+nOsirYV9r4FRruSUY3hUG8lWIkS6QZrO4wUlrFBzsPYQO5ATc3bNw3YJ8vF8k/6otsFlfwozWfuZ/si9shiTW2DdLBi4llOWJgHmjKaQxuM3DHLk4fA14NcKWP2H2P1GSCNOX6N46fO6UMhCOyqjE+iWClplIHFIfqxj+k+B0FvSWzTzQwkxUnHreDDhiy7I2ZkMuGaUyNsshig==\",profile=\"desktop\"},[\"desktop-release-0.16.6\"]={public=\"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\",profile=\"desktop\"},[\"recipe-server-release-0.16.5\"]={public=\"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\",profile=\"recipe-server\"},[\"recipe-server-release-0.16.6\"]={public=\"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\",profile=\"recipe-server\"},[\"router-server-release-0.16.3\"]={public=\"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\",profile=\"router-server\"},[\"router-server-release-0.16.5\"]={public=\"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\",profile=\"router-server\"},},}",
  ["ceetos/lib/release_verify.lua"] = "local password=require(\"ceetos.lib.password\")local roots=require(\"ceetos.lib.release_keys\")local profile=require(\"ceetos.lib.profile\")local M={}M.CACHE_ROOT=\"/ceetos-updates\"M.CACHE_FILE=\"/ceetos-updates/release.lua\"M.META_FILE=\"/ceetos-updates/cache.lua\"M.PART_FILE=\"/ceetos-updates/release.part\"M.PENDING_FILE=\"/ceetos-updates/pending.lua\"M.MAX_PACKAGE_BYTES=1024*1024 M.MAX_MANIFEST_BYTES=48*1024 M.CHUNK_BYTES=3072 M.KEY_PARTS=256 local alphabet=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"local decodeMap={}for i=1,#alphabet do decodeMap[alphabet:sub(i,i)]=i-1 end local function read(path)if not fs.exists(path)or fs.isDir(path)then return nil end local handle=fs.open(path,\"r\")if not handle then return nil end local value=handle.readAll();handle.close()return value end local function write(path,value)local parent=fs.getDir(path)if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary=path..\".tmp\"if fs.exists(temporary)then fs.delete(temporary)end local handle=assert(fs.open(temporary,\"w\"),\"could not create temporary release state\")handle.write(value);handle.close()if fs.exists(path)then fs.delete(path)end fs.move(temporary,path)end local function encode(value)local out,index={},1 while index<=#value do local a,b,c=value:byte(index,index+2)local n=(a or 0)*65536+(b or 0)*256+(c or 0)out[#out+1]=alphabet:sub(math.floor(n/262144)%64+1,math.floor(n/262144)%64+1)out[#out+1]=alphabet:sub(math.floor(n/4096)%64+1,math.floor(n/4096)%64+1)out[#out+1]=b and alphabet:sub(math.floor(n/64)%64+1,math.floor(n/64)%64+1)or\"=\"out[#out+1]=c and alphabet:sub(n%64+1,n%64+1)or\"=\"index=index+3 end return table.concat(out)end local function decode(value)if type(value)~=\"string\"or#value%4~=0 or#value>M.MAX_MANIFEST_BYTES*2 then return nil,\"invalid base64\"end local out={}for index=1,#value,4 do local a,b,c,d=value:sub(index,index),value:sub(index+1,index+1),value:sub(index+2,index+2),value:sub(index+3,index+3)if not decodeMap[a]or not decodeMap[b]or(c~=\"=\"and not decodeMap[c])or(d~=\"=\"and not decodeMap[d])then return nil,\"invalid base64\"end if(c==\"=\"and d~=\"=\")or((c==\"=\"or d==\"=\")and index+3~=#value)then return nil,\"invalid base64 padding\"end local n=decodeMap[a]*262144+decodeMap[b]*4096+(decodeMap[c]or 0)*64+(decodeMap[d]or 0)out[#out+1]=string.char(math.floor(n/65536)%256)if c~=\"=\"then out[#out+1]=string.char(math.floor(n/256)%256)end if d~=\"=\"then out[#out+1]=string.char(n%256)end end return table.concat(out)end local function unhex(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function semver(value)if type(value)~=\"string\"then return nil end local major,minor,patch=value:match(\"^(%d+)%.(%d+)%.(%d+)$\")if not major then return nil end return tonumber(major),tonumber(minor),tonumber(patch)end function M.compareVersions(left,right)local a,b,c=semver(left);local x,y,z=semver(right)if not a or not x then return nil,\"invalid semantic version\"end if a~=x then return a<x and-1 or 1 end if b~=y then return b<y and-1 or 1 end if c~=z then return c<z and-1 or 1 end return 0 end local function canonical(manifest)if manifest._legacyProfile==true then return table.concat({\"ceetos-release-v1\",tostring(manifest.channel),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end return table.concat({\"ceetos-release-v2\",tostring(manifest.channel),tostring(manifest.profile),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end local function unpackKey(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*2*32 then return nil,err or\"invalid public key\"end local parts={}for index=1,M.KEY_PARTS*2 do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end function M.validPublicKey(value)return unpackKey(value)end local function lookupKey(keyId)local saved=M.trustedKeys()local value=saved[keyId]if value then return unpackKey(value)end value=roots.roots and roots.roots[keyId]if type(value)==\"table\"and type(value.public)==\"string\"then value=value.public end return unpackKey(value)end local function bitAt(digest,index)local byte=digest:byte(math.floor((index-1)/8)+1)return bit32.band(bit32.rshift(byte,7-((index-1)%8)),1)end local function decodeSignature(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*32 then return nil,err or\"invalid signature\"end local parts={}for index=1,M.KEY_PARTS do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end local function verifySignature(manifest,signature)if roots.algorithm~=\"lamport-sha256-v1\"then return false,\"unsupported release signing algorithm\"end local public,publicErr=lookupKey(manifest.key_id)local parts,signatureErr=decodeSignature(signature)if not public or not parts then local prefix=not public and\"invalid release public key: \"or\"invalid release signature: \"return false,prefix..tostring(publicErr or signatureErr or\"unknown release key\")end local digest=unhex(password.sha256(canonical(manifest))or\"\")if not digest then return false,\"could not hash release manifest\"end for index=1,M.KEY_PARTS do local expected=public[(index-1)*2+bitAt(digest,index)+1]local candidate=unhex(password.sha256(parts[index])or\"\")if not candidate or not password.constantTimeEqual(candidate,expected)then return false,\"invalid release signature\"end end return true end local function validateManifest(manifest)if type(manifest)~=\"table\"or manifest.channel~=\"release\"then return nil,\"only signed release packages are accepted\"end if manifest.profile==nil then manifest.profile,manifest._legacyProfile=\"desktop\",true end if type(manifest.profile)~=\"string\"or not profile.IDS[manifest.profile]then return nil,\"invalid release profile\"end if not semver(manifest.version)or type(manifest.size)~=\"number\"or manifest.size<1 or manifest.size>M.MAX_PACKAGE_BYTES then return nil,\"invalid release manifest size or version\"end if type(manifest.digest)~=\"string\"or#manifest.digest~=64 or manifest.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if type(manifest.key_id)~=\"string\"or#manifest.key_id<1 or#manifest.key_id>64 then return nil,\"invalid release key id\"end if type(manifest.next_key_id)~=\"string\"or#manifest.next_key_id<1 or#manifest.next_key_id>64 then return nil,\"invalid next release key id\"end local nextKey=unpackKey(manifest.next_public)if not nextKey then return nil,\"invalid successor release key\"end return manifest end function M.parse(source)if type(source)~=\"string\"or#source>M.MAX_PACKAGE_BYTES then return nil,\"release package is too large\"end local encodedManifest,encodedSignature=source:match(\"^%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")if not encodedManifest then encodedManifest,encodedSignature=source:match(\"^%-%- CeetOS signed release%. Generated; do not edit%.[\\r\\n]+%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")end local first=source:find(\"%-%- CEETOS_RELEASE_PAYLOAD_BEGIN[\\r\\n]+\")if not encodedManifest or not encodedSignature or not first then return nil,\"not a signed CeetOS release package\"end local decoded,decodeErr=decode(encodedManifest)if not decoded then return nil,\"invalid release manifest encoding: \"..tostring(decodeErr)end local loader=load(\"return \"..decoded,\"=release-manifest\",\"t\",{})if not loader then return nil,\"invalid release manifest\"end local ok,manifest=pcall(loader)if not ok then return nil,\"invalid release manifest\"end local valid,manifestErr=validateManifest(manifest)if not valid then return nil,manifestErr end local start=source:find(\"\\n\",first)+1 local finish=start+valid.size-1 local payload=source:sub(start,finish)local suffix=source:sub(finish+1)if suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\\n\"and suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\\r\\n\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\"then return nil,\"release payload boundary mismatch\"end if#payload~=valid.size or not password.constantTimeEqual(password.sha256(payload)or\"\",valid.digest)then return nil,\"release payload digest mismatch\"end local signed,signatureErr=verifySignature(valid,encodedSignature)if not signed then return nil,signatureErr end return{manifest=valid,signature=encodedSignature,payload=payload,source=source}end function M.trustedKeys()local raw=read(M.CACHE_ROOT..\"/trusted-keys.lua\")if not raw then return{}end local loader=load(raw,\"=trusted-release-keys\",\"t\",{})if not loader then return{}end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or{}end local function saveKeys(value)local encoded=textutils.serialise(value,{compact=true})write(M.CACHE_ROOT..\"/trusted-keys.lua\",\"return \"..encoded)end function M.metadata()local raw=read(M.META_FILE)if not raw then return nil end local loader=load(raw,\"=release-cache\",\"t\",{})if not loader then return nil end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or nil end function M.cache(source,provider)local package,err=M.parse(source)if not package then return nil,err end if fs.exists(M.CACHE_ROOT)and fs.isDir(M.CACHE_ROOT)then if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end elseif not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end write(M.CACHE_FILE,package.source)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))local keys=M.trustedKeys();keys[package.manifest.next_key_id]=package.manifest.next_public;saveKeys(keys)return metadata end function M.promotePart(path,provider)if type(path)~=\"string\"or path~=M.PART_FILE then return nil,\"invalid release staging path\"end local source=read(path)local package,err=M.parse(source)if not package then return nil,err end if not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end fs.move(M.PART_FILE,M.CACHE_FILE)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))M.adopt(package)return metadata end function M.adopt(package)if type(package)~=\"table\"or type(package.manifest)~=\"table\"then return false,\"invalid verified package\"end local keys=M.trustedKeys()keys[package.manifest.next_key_id]=package.manifest.next_public saveKeys(keys)return true end function M.cachedPackage()local source,metadata=read(M.CACHE_FILE),M.metadata()if not source then return nil end local package,err=M.parse(source)if not package then return nil,err end if not metadata then metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=\"local installer\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))end M.adopt(package)return package,metadata end function M.clear()if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end if fs.exists(M.META_FILE)then fs.delete(M.META_FILE)end return true end function M.encode(value)return encode(value)end function M.decode(value)return decode(value)end function M.canonical(manifest)return canonical(manifest)end return M",
  ["ceetos/lib/updater.lua"] = "local store=require(\"ceetos.lib.store\")local release=require(\"ceetos.lib.release_verify\")local version=require(\"ceetos.lib.version\")local net=require(\"ceetos.lib.net\")local profile=require(\"ceetos.lib.profile\")local M={}local STATE_PATH=\"/ceetos/data/update-status.lua\"local OFFER_LIMIT,HISTORY_LIMIT=20,16 local BEACON_INTERVAL,REQUEST_TIMEOUT,REQUEST_LIMIT=30000,3500,3 local MAX_OFFER_AGE=5*60*1000 local CLOUD_RELEASE_ORIGIN=\"https://releases.ceet.uk\"local CLOUD_MANIFEST_URL=CLOUD_RELEASE_ORIGIN..\"/manifest.json\"local CLOUD_SOURCE_ID=\"cloud.releases.ceet.uk\"local state=nil local lastBeacon,lastCacheRead=0,0 local cached=nil local function now()return os.epoch(\"utc\")end local function localId()return tostring(os.getComputerID())end local function localLabel()return os.getComputerLabel()or(\"Computer \"..localId())end local function defaults()return{schema=1,offers={},history={},revision=0,status=\"idle\",message=nil,transfer=nil,cache=nil}end local function loadState()if state then return state end state=store.read(STATE_PATH,defaults())for key,value in pairs(defaults())do if state[key]==nil then state[key]=value end end state.offers=type(state.offers)==\"table\"and state.offers or{}state.history=type(state.history)==\"table\"and state.history or{}return state end local function save()local value=loadState()value.revision=(tonumber(value.revision)or 0)+1 store.write(STATE_PATH,value)end local function record(kind,fields)local value=loadState()local row={at=now(),kind=tostring(kind):sub(1,48)}for key,item in pairs(fields or{})do if key~=\"data\"and key~=\"source\"and key~=\"signature\"then row[key]=item end end value.history[#value.history+1]=row while#value.history>HISTORY_LIMIT do table.remove(value.history,1)end end local function setStatus(status,message)local value=loadState()value.status,value.message=status,message and tostring(message):sub(1,180)or nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=96 end local function releaseFilename(profileId,releaseVersion)if profileId==\"desktop\"then return\"desktop/ceetos-release\"..releaseVersion..\".lua\"end return profileId..\"/ceetos-\"..profileId..\"-release\"..releaseVersion..\".lua\"end local function readHttp(url,limit)if not http or type(http.get)~=\"function\"then return nil,\"HTTP is unavailable; enable it to check releases.ceet.uk\"end local ok,response,requestErr=pcall(http.get,url,{[\"Accept\"]=\"application/json\"})if not ok or not response then return nil,tostring(requestErr or\"release server request failed\")end local chunks,total={},0 while true do local part=response.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then pcall(response.close);return nil,\"release server response is too large\"end chunks[#chunks+1]=part end pcall(response.close)return table.concat(chunks)end local function validOffer(body)if type(body)~=\"table\"or type(body.version)~=\"string\"or type(body.size)~=\"number\"or type(body.digest)~=\"string\"or type(body.keyId)~=\"string\"or type(body.profile)~=\"string\"then return nil,\"malformed release offer\"end if body.profile~=profile.id()then return nil,\"release profile does not match this installation\"end local compare=release.compareVersions(body.version,version.string)if compare==nil then return nil,\"invalid release version\"end if body.size<1 or body.size>release.MAX_PACKAGE_BYTES then return nil,\"invalid release size\"end if#body.digest~=64 or body.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if#body.keyId<1 or#body.keyId>64 then return nil,\"invalid release key ID\"end local filename=body.filename if filename~=nil and filename~=releaseFilename(body.profile,body.version)then return nil,\"invalid release filename\"end return{profile=body.profile,version=body.version,size=math.floor(body.size),digest=body.digest:lower(),keyId=body.keyId,filename=filename,fingerprint=body.digest:sub(1,16),newer=compare>0}end local function refreshCached()local timestamp=now()if cached and timestamp-lastCacheRead<5000 then return cached end lastCacheRead=timestamp local value=loadState()local previous=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil local package,metadata=release.cachedPackage()if package and package.manifest.profile==profile.id()then cached={package=package,metadata=metadata,offer={version=package.manifest.version,size=#package.source,digest=package.manifest.digest,profile=package.manifest.profile,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),}}value.cache={profile=package.manifest.profile,version=package.manifest.version,size=#package.source,digest=package.manifest.digest,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),source=metadata and metadata.source or\"local\",verifiedAt=timestamp}else cached=nil value.cache=nil end local current=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil if current~=previous then save()end return cached end local function providerOffer()local available=refreshCached()if not available then return nil end return{version=available.offer.version,size=available.offer.size,digest=available.offer.digest,profile=available.offer.profile,keyId=available.offer.keyId,label=localLabel(),id=localId(),}end local function upsertOffer(source,body,transport,distance)source=tostring(source)if source==localId()then return false,\"ignored own release offer\"end local offer,err=validOffer(body)if not offer then return false,err end if not offer.newer then return false,\"offered release is not newer\"end local value=loadState()local key=source..\":\"..offer.version..\":\"..offer.digest:sub(1,16)value.offers[key]={id=source,label=tostring(body.label or(\"Computer \"..source)):sub(1,96),version=offer.version,profile=offer.profile,size=offer.size,digest=offer.digest,fingerprint=offer.fingerprint,keyId=offer.keyId,filename=offer.filename,transport=transport,distance=tonumber(distance),seen=now(),key=key,}local rows={}for entryKey,item in pairs(value.offers)do rows[#rows+1]={key=entryKey,seen=tonumber(item.seen)or 0}end table.sort(rows,function(a,b)return a.seen>b.seen end)while#rows>OFFER_LIMIT do value.offers[table.remove(rows).key]=nil end setStatus(\"offers\",\"Signed release \"..offer.version..\" available from \"..tostring(body.label or source))record(\"offer\",{id=source,version=offer.version,transport=transport,distance=distance})save()return true end local function checkCloudManifest()local raw,readErr=readHttp(CLOUD_MANIFEST_URL,release.MAX_MANIFEST_BYTES)if not raw then return 0,readErr end local ok,catalogue=pcall(textutils.unserialiseJSON,raw)if not ok or type(catalogue)~=\"table\"or catalogue.schema~=1 or type(catalogue.releases)~=\"table\"or#catalogue.releases>OFFER_LIMIT then return 0,\"invalid signed-release catalogue\"end local count=0 for index=1,#catalogue.releases do local entry=catalogue.releases[index]if type(entry)==\"table\"and entry.profile==profile.id()then local accepted=upsertOffer(CLOUD_SOURCE_ID,entry,\"cloud\")if accepted then count=count+1 end end end return count end local function offers()local value,timestamp,rows=loadState(),now(),{}for key,item in pairs(value.offers)do if type(item)==\"table\"and timestamp-(tonumber(item.seen)or 0)<=MAX_OFFER_AGE then rows[#rows+1]=item else value.offers[key]=nil end end table.sort(rows,function(left,right)local compare=release.compareVersions(left.version,right.version)or 0 if compare~=0 then return compare>0 end return tostring(left.id)<tostring(right.id)end)return rows end local function findOffer(source)source=tostring(source)for _,item in ipairs(offers())do if item.key==source or tostring(item.id)==source then return item end end return nil,\"release source is unavailable; run update check first\"end local function removePart()if fs.exists(release.PART_FILE)then fs.delete(release.PART_FILE)end end local function appendPart(data)local handle,err=fs.open(release.PART_FILE,\"a\")if not handle then return false,err or\"could not open update staging file\"end handle.write(data);handle.close()return true end local function cachedSource()local available=refreshCached()return available and available.package and available.package.source end local function transferRequest(transfer)local length=math.min(release.CHUNK_BYTES,transfer.size-transfer.offset+1)if length<1 then return false,\"transfer is already complete\"end transfer.awaiting,transfer.requestedAt=true,now()local body={transfer=transfer.id,offset=transfer.offset,length=length}local sent,err if transfer.transport==\"routed\"then sent,err=net.request(transfer.source,\"update_chunk_request\",body,{safe=true})else sent,err=net.publicSend(transfer.source,\"update_chunk_request\",body)end if not sent then transfer.awaiting=false;return false,err end return true end local function beginDownload(source)local offer,err=findOffer(source)if not offer then return false,err end local compare=release.compareVersions(offer.version,version.string)if not compare or compare<=0 then return false,\"refusing a downgrade or current release\"end local free=fs.getFreeSpace and fs.getFreeSpace(\"/\")or nil if type(free)==\"number\"and free<offer.size+4096 then return false,\"not enough free space for one verified release cache\"end removePart()release.clear();cached=nil local value=loadState()if offer.transport==\"cloud\"then setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from releases.ceet.uk\")save()local sourceText,readErr=readHttp(CLOUD_RELEASE_ORIGIN..\"/\"..tostring(offer.filename or\"\"),release.MAX_PACKAGE_BYTES)if not sourceText then setStatus(\"error\",readErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=readErr});save();return false,readErr end local parsed,parseErr=release.parse(sourceText)if not parsed or parsed.manifest.profile~=offer.profile or parsed.manifest.version~=offer.version or parsed.manifest.digest:lower()~=offer.digest or parsed.manifest.key_id~=offer.keyId then local reason=parseErr or\"verified package did not match selected release offer\"setStatus(\"error\",reason);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=reason});save();return false,reason end local metadata,cacheErr=release.cache(sourceText,\"releases.ceet.uk\")if not metadata then setStatus(\"error\",cacheErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=cacheErr});save();return false,cacheErr end cached=nil;refreshCached()setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=CLOUD_SOURCE_ID,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end value.transfer={id=\"update-\"..localId()..\"-\"..tostring(now())..\"-\"..tostring(math.random(1000,9999)),source=tostring(offer.id),label=offer.label,transport=offer.transport==\"routed\"and\"routed\"or\"direct\",profile=offer.profile,version=offer.version,size=offer.size,digest=offer.digest,keyId=offer.keyId,offset=1,received=0,retries=0,awaiting=false,started=now(),}setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from \"..offer.label)record(\"download_started\",{id=offer.id,version=offer.version,transport=value.transfer.transport})local sent,sendErr=transferRequest(value.transfer)if not sent then value.transfer=nil;setStatus(\"error\",sendErr);record(\"download_failed\",{id=offer.id,error=sendErr})end save()return sent,sendErr end local function finishTransfer(transfer)local handle=fs.open(release.PART_FILE,\"r\")local source=handle and handle.readAll()or nil if handle then handle.close()end if not source or#source~=transfer.size then return false,\"download size did not match offer\"end local parsed,parseErr=release.parse(source)if not parsed then return false,parseErr end if parsed.manifest.profile~=profile.id()or parsed.manifest.profile~=transfer.profile or parsed.manifest.version~=transfer.version or parsed.manifest.digest:lower()~=transfer.digest:lower()or parsed.manifest.key_id~=transfer.keyId then return false,\"verified package did not match selected release offer\"end local metadata,promoteErr=release.promotePart(release.PART_FILE,transfer.label)if not metadata then return false,promoteErr end cached=nil;refreshCached()local value=loadState();value.transfer=nil setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=transfer.source,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end local function acceptChunk(source,body,transport)local value,transfer=loadState(),loadState().transfer if not transfer or transfer.transport~=transport or tostring(source)~=tostring(transfer.source)then return false,\"unexpected update chunk\"end if type(body)~=\"table\"or body.transfer~=transfer.id or math.floor(tonumber(body.offset)or 0)~=transfer.offset or type(body.data)~=\"string\"then return false,\"malformed update chunk\"end local remaining=transfer.size-transfer.offset+1 if#body.data<1 or#body.data>math.min(release.CHUNK_BYTES,remaining)then return false,\"invalid update chunk length\"end local ok,err=appendPart(body.data)if not ok then transfer.awaiting=false;setStatus(\"error\",err);record(\"download_failed\",{error=err});save();return false,err end transfer.offset,transfer.received,transfer.awaiting,transfer.retries=transfer.offset+#body.data,(transfer.received or 0)+#body.data,false,0 if transfer.offset>transfer.size then local complete,result=finishTransfer(transfer)if not complete then removePart();value.transfer=nil;setStatus(\"error\",result);record(\"download_failed\",{id=source,error=result});save()end return complete,result end local sent,sendErr=transferRequest(transfer)if not sent then setStatus(\"error\",sendErr);record(\"download_failed\",{id=source,error=sendErr});value.transfer=nil;removePart()end save()return sent,sendErr end local function serveChunk(target,body,routed,request)if type(body)~=\"table\"or not validId(body.transfer)or math.floor(tonumber(body.offset)or 0)<1 or math.floor(tonumber(body.length)or 0)<1 or tonumber(body.length)>release.CHUNK_BYTES then return false,\"invalid update chunk request\"end local source=cachedSource()if not source then return false,\"no verified newer signed release is cached\"end local offset,length=math.floor(body.offset),math.floor(body.length)if offset>#source then return false,\"requested update offset is beyond package\"end local data=source:sub(offset,math.min(#source,offset+length-1))local response={transfer=body.transfer,offset=offset,data=data}if routed then return net.reply(request,\"update_chunk\",response,{safe=true})end return net.publicSend(target,\"update_chunk\",response)end function M.publicPacket(packet,distance)local source,body=tostring(packet.from),packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then net.publicSend(source,\"update_offer\",offer)end return elseif packet.type==\"update_offer\"then return upsertOffer(source,body,\"direct\",distance)elseif packet.type==\"update_chunk_request\"then return serveChunk(source,body,false)elseif packet.type==\"update_chunk\"then return acceptChunk(source,body,\"direct\")end end function M.authenticatedPacket(from,peer,packet)local body=packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then return net.reply(packet,\"update_offer\",offer,{safe=true})end elseif packet.type==\"update_offer\"then return upsertOffer(from,body,\"routed\")elseif packet.type==\"update_chunk_request\"then return serveChunk(from,body,true,packet)elseif packet.type==\"update_chunk\"then return acceptChunk(from,body,\"routed\")end end function M.check()local value=loadState()for key in pairs(value.offers)do value.offers[key]=nil end setStatus(\"checking\",\"Looking for newer signed releases\")local cloudOffers,cloudErr=checkCloudManifest()local sent,err=net.publicBroadcast(\"update_query\",{version=version.string,profile=profile.id()})local routed=0 for _,peer in ipairs(net.peers())do if not peer.rekeyRequired then local ok=net.request(peer.id,\"update_query\",{version=version.string,profile=profile.id()},{safe=true})if ok then routed=routed+1 end end end if cloudErr then setStatus(\"warning\",\"Cloud release check failed: \"..tostring(cloudErr):sub(1,120))elseif cloudOffers==0 and not(sent or routed>0)then setStatus(\"idle\",\"No newer signed release is available\")elseif cloudOffers>0 then setStatus(\"offers\",tostring(cloudOffers)..\" signed cloud release offer\"..(cloudOffers==1 and\"\"or\"s\")..\" available\")end record(\"check\",{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr,error=sent and nil or err})save()if cloudErr and not sent and routed==0 then return false,cloudErr end return true,{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr}end function M.download(source)return beginDownload(source)end function M.cancel()local value=loadState()if not value.transfer then return false,\"no update transfer is active\"end record(\"download_cancelled\",{id=value.transfer.source,version=value.transfer.version})value.transfer=nil;removePart();setStatus(\"cancelled\",\"Update download cancelled\");save()return true end function M.clearCache()local value=loadState()if value.transfer then return false,\"cancel the active download first\"end release.clear();cached=nil;value.cache=nil;setStatus(\"idle\",\"Verified release cache cleared\");record(\"cache_cleared\");save()return true end function M.prepareApply()local package,metadata=release.cachedPackage()if not package then return false,metadata or\"no verified signed release is cached\"end local compare=release.compareVersions(package.manifest.version,version.string)if not compare or compare<=0 then return false,\"cached release is not newer than this CeetOS installation\"end if package.manifest.profile~=profile.id()then return false,\"cached release profile does not match this installation\"end local marker={schema=2,state=\"apply\",profile=package.manifest.profile,version=package.manifest.version,digest=package.manifest.digest,keyId=package.manifest.key_id,approvedAt=now()}store.write(release.PENDING_FILE,marker)local value=loadState();setStatus(\"applying\",\"Applying verified release \"..package.manifest.version..\" after reboot\");record(\"apply_approved\",{version=package.manifest.version,digest=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id});save()return true,{version=package.manifest.version,fingerprint=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id}end function M.recover()local marker=store.read(release.PENDING_FILE,nil)if type(marker)~=\"table\"or marker.state~=\"verify\"then return end local value=loadState()if marker.version==version.string and(marker.profile==nil or marker.profile==profile.id())then if fs.exists(release.PENDING_FILE)then fs.delete(release.PENDING_FILE)end setStatus(\"applied\",\"Verified release \"..version.string..\" is now active\")record(\"apply_verified\",{version=version.string})else setStatus(\"error\",\"Update installed but running version did not match \"..tostring(marker.version))record(\"apply_version_mismatch\",{expected=marker.version,actual=version.string})end save()end function M.tick()local value,timestamp=loadState(),now()local offer=providerOffer()if offer and timestamp-lastBeacon>=BEACON_INTERVAL then net.publicBroadcast(\"update_offer\",offer)lastBeacon=timestamp end local transfer=value.transfer if transfer and transfer.awaiting and timestamp-(transfer.requestedAt or timestamp)>=REQUEST_TIMEOUT then transfer.awaiting,transfer.retries=false,(transfer.retries or 0)+1 if transfer.retries>REQUEST_LIMIT then record(\"download_timeout\",{id=transfer.source,version=transfer.version})value.transfer=nil;removePart();setStatus(\"error\",\"Update source timed out\");save()else local sent,err=transferRequest(transfer)if not sent then value.transfer=nil;removePart();setStatus(\"error\",err);record(\"download_failed\",{id=transfer.source,error=err});save()end end end end function M.status()local value=loadState()return{profile=profile.id(),version=version.string,status=value.status,message=value.message,revision=value.revision,offers=offers(),transfer=value.transfer,cache=value.cache,history=value.history,cacheRoot=release.CACHE_ROOT,maxPackageBytes=release.MAX_PACKAGE_BYTES,}end return M",
  ["ceetos/lib/mesh_crypto.lua"] = "local password=require(\"ceetos.lib.password\")local M={}local band,bor,bxor=bit32.band,bit32.bor,bit32.bxor local lshift,rshift=bit32.lshift,bit32.rshift local MOD32,LIMB=4294967296,67108864 local function add32(...)local n=0 for i=1,select(\"#\",...)do n=(n+(select(i,...)or 0))%MOD32 end return n end local function rotl(v,bits)return bor(lshift(v,bits),rshift(v,32-bits))end local function le32(data,index)local a,b,c,d=data:byte(index,index+3)return(a or 0)+(b or 0)*256+(c or 0)*65536+(d or 0)*16777216 end local function put32(value)value=value%MOD32 return string.char(value%256,math.floor(value/256)%256,math.floor(value/65536)%256,math.floor(value/16777216)%256)end local function le64(value)value=math.max(0,math.floor(tonumber(value)or 0))local low,high=value%MOD32,math.floor(value/MOD32)%MOD32 return put32(low)..put32(high)end local function hexToRaw(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function rawToHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function quarter(x,a,b,c,d)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),16)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),12)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),8)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),7)end local function chachaBlock(key,counter,nonce)local state={0x61707865,0x3320646e,0x79622d32,0x6b206574}for i=1,8 do state[4+i]=le32(key,(i-1)*4+1)end state[13],state[14],state[15],state[16]=counter%MOD32,le32(nonce,1),le32(nonce,5),le32(nonce,9)local x={}for i=1,16 do x[i]=state[i]end for _=1,10 do quarter(x,1,5,9,13);quarter(x,2,6,10,14);quarter(x,3,7,11,15);quarter(x,4,8,12,16)quarter(x,1,6,11,16);quarter(x,2,7,12,13);quarter(x,3,8,9,14);quarter(x,4,5,10,15)end local out={}for i=1,16 do out[i]=put32(add32(x[i],state[i]))end return table.concat(out)end local function chachaXor(key,nonce,counter,plaintext)local out,position={},1 while position<=#plaintext do local block=chachaBlock(key,counter,nonce)local part=plaintext:sub(position,position+63)out[#out+1]=xorBytes(part,block:sub(1,#part))position,counter=position+#part,(counter+1)%MOD32 end return table.concat(out)end local function poly1305(message,key)local function zero(length)local out={};for i=1,length do out[i]=0 end;return out end local function normalise(value)local carry=0 for i=1,#value do local n=(value[i]or 0)+carry value[i],carry=n%256,math.floor(n/256)end while carry>0 do value[#value+1],carry=carry%256,math.floor(carry/256)end return value end local function add(left,right)local out=zero(math.max(#left,#right)+1)for i=1,#left do out[i]=out[i]+left[i]end for i=1,#right do out[i]=out[i]+right[i]end return normalise(out)end local function multiply(left,right)local out=zero(#left+#right+1)for i=1,#left do for j=1,#right do out[i+j-1]=out[i+j-1]+left[i]*right[j]end end return normalise(out)end local function high130(value)local out={}for i=1,#value-16 do local low=value[i+16]or 0 local high=value[i+17]or 0 out[i]=math.floor(low/4)+(high%4)*64 end return normalise(out)end local function hasHigh(value)if#value>17 then for i=18,#value do if value[i]~=0 then return true end end end return(value[17]or 0)>=4 end local function reduce(value)while hasHigh(value)do local low,high=zero(17),high130(value)for i=1,17 do low[i]=value[i]or 0 end low[17]=low[17]%4 for i=1,#high do high[i]=high[i]*5 end value=add(low,high)end local prime={251}for i=2,16 do prime[i]=255 end prime[17]=3 local greater=false for i=17,1,-1 do if(value[i]or 0)~=prime[i]then greater=(value[i]or 0)>prime[i];break end end if greater then local borrow=0 for i=1,17 do local n=(value[i]or 0)-prime[i]-borrow if n<0 then n,borrow=n+256,1 else borrow=0 end value[i]=n end end return value end local r,h=zero(17),zero(17)for i=1,16 do r[i]=key:byte(i)end r[4],r[8],r[12],r[16]=band(r[4],15),band(r[8],15),band(r[12],15),band(r[16],15)r[5],r[9],r[13]=band(r[5],252),band(r[9],252),band(r[13],252)for at=1,#message,16 do local part,n=message:sub(at,at+15),zero(17)for i=1,#part do n[i]=part:byte(i)end n[#part+1]=1 h=reduce(multiply(add(h,n),r))end local pad,out,carry={},{},0 for i=1,16 do pad[i]=key:byte(i+16)end for i=1,16 do local n=(h[i]or 0)+pad[i]+carry out[i],carry=n%256,math.floor(n/256)end return string.char(table.unpack(out))end local function padded(value)return value..string.rep(\"\\0\",(16-(#value%16))%16)end local function derive(linkKey)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-key/v1\")or\"\")return raw end function M.nonce(linkKey,counter,context)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-nonce/v1|\"..tostring(counter)..\"|\"..tostring(context or\"\"))or\"\")return raw and raw:sub(1,12)or nil end function M.seal(linkKey,nonce,aad,plaintext)if type(linkKey)~=\"string\"or type(nonce)~=\"string\"or#nonce~=12 or type(aad)~=\"string\"or type(plaintext)~=\"string\"then return nil,\"invalid mesh envelope input\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local ciphertext=chachaXor(key,nonce,1,plaintext)local tag=poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey)return{nonce=rawToHex(nonce),ciphertext=rawToHex(ciphertext),tag=rawToHex(tag)}end function M.open(linkKey,envelope,aad)if type(linkKey)~=\"string\"or type(envelope)~=\"table\"or type(aad)~=\"string\"then return nil,\"invalid mesh envelope\"end local nonce,ciphertext,tag=hexToRaw(envelope.nonce or\"\"),hexToRaw(envelope.ciphertext or\"\"),hexToRaw(envelope.tag or\"\")if not nonce or#nonce~=12 or not ciphertext or not tag or#tag~=16 then return nil,\"invalid mesh envelope encoding\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local expected=rawToHex(poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey))if not password.constantTimeEqual(expected,envelope.tag)then return nil,\"mesh envelope authentication failed\"end return chachaXor(key,nonce,1,ciphertext)end function M.selfTest()local key=hexToRaw(\"85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b\")local tag=poly1305(\"Cryptographic Forum Research Group\",key)return rawToHex(tag)==\"a8061dc1305136c6c22b8baf0c0127a9\"end return M",
  ["ceetos/lib/audit.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/audit.log\"M.LIMITS={maxEntries=250,maxBytes=64*1024}function M.log(actor,action,detail)return store.append(PATH,{ts=os.epoch(\"utc\"),actor=actor or\"system\",action=action,detail=detail,},M.LIMITS)end function M.recent(limit)limit=math.max(1,math.min(50,tonumber(limit)or 10))local raw=store.readAppend(PATH)local result={}for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local entry=textutils.unserialise(line)if entry then result[#result+1]=entry if#result>limit then table.remove(result,1)end end end end return result end return M",
  ["ceetos/lib/net.lua"] = "local store=require(\"ceetos.lib.store\")local audit=require(\"ceetos.lib.audit\")local password=require(\"ceetos.lib.password\")local meshCrypto=require(\"ceetos.lib.mesh_crypto\")local M={handler=nil,publicHandler=nil}local PATH=\"/ceetos/data/network.lua\"local SECURITY_PATH=\"/ceetos/data/network-security.lua\"local SEEN_PATH=\"/ceetos/data/seen-peers.lua\"local CHANNEL,PROTOCOL=45731,\"ceetos/2\"local PUBLIC_UPDATE_PROTOCOL=\"ceetos/update/1\"local PUBLIC_UPDATE_TYPES={update_query=true,update_offer=true,update_chunk_request=true,update_chunk=true,}local DISCOVERY_CHANNEL=CHANNEL local DISCOVERY_TTL,ROUTE_TTL,PACKET_TTL=120000,120000,8 local DISCOVERY_INTERVAL,PAIR_RETRY,ROUTE_INTERVAL=2000,2000,15000 local MESH_BEACON_INTERVAL,MESH_FULL_INTERVAL=15000,30000 local PROBE_INTERVAL,PROBE_DEGRADED,PROBE_OFFLINE,PROBE_RECOVERY=5000,3,6,10000 local ROUTE_CANDIDATE_LIMIT,ROUTE_BUCKET_LIMIT=4,96 local SAFE_READ_WINDOW,SAFE_READ_LIMIT=1000,16 local MAX_PACKET_STRING,MAX_PACKET_TABLE,MAX_PACKET_DEPTH=8192,128,6 local COUNTER_RESERVATION,MAX_RX_EPOCHS,MAX_REVERSE_ROUTES=64,3,128 local routes,discovered,confirmations,seenPackets,reverseRoutes={},{},{},{},{}local routeSequence,lastRouteAdvertisement,routesDirty=0,0,false local discovery,lastDiscovery=nil,{state=\"inactive\"}local security={tx={},rx={}}local autoEdges,linkHealth,meshOffers,meshSeen,advertisedRoutes,meshEnrollmentSends={},{},{},{},{},{}local lastMeshBeacon,lastMeshFull,meshDirty=0,0,false local transport={modem=false,wireless=false,name=nil,channels={},lastTransmit=nil,lastReceive=nil,lastDistance=nil,lastError=nil,rejected=0,}local traces={discovery={},routing={},transport={}}local TRACE_LIMIT=48 local MESH_STATE_LIMIT=128 local rejectPacket local function now()return os.epoch(\"utc\")end local function id()return tostring(os.getComputerID())end local function label()return os.getComputerLabel()or(\"Computer \"..id())end local function isBroadcast(value)return tostring(value)==\"0\"end local function isForUs(value)return tostring(value)==id()end local function copy(value,depth)if type(value)~=\"table\"then return value end if(depth or 0)>MAX_PACKET_DEPTH then return nil end local out={}for k,v in pairs(value)do out[k]=copy(v,(depth or 0)+1)end return out end local function trace(kind,phase,fields)local bucket=traces[kind]or traces.transport local row={time=now(),phase=phase}for key,value in pairs(fields or{})do if key~=\"phrase\"and key~=\"proof\"and key~=\"key\"and key~=\"secret\"and key~=\"mac\"and key~=\"packet\"and key~=\"tag\"then row[key]=value end end bucket[#bucket+1]=row while#bucket>TRACE_LIMIT do table.remove(bucket,1)end end local function read(path,fallback)if store.invalidate then store.invalidate(path)end return store.read(path,fallback)end local function config()local value=read(PATH,{peers={},channel=CHANNEL})value.peers=type(value.peers)==\"table\"and value.peers or{}value.channel=tonumber(value.channel)or CHANNEL return value end local function save(value)local ok,err=store.write(PATH,value)if ok==false then error(err or\"could not save network configuration\",0)end end local function migrateV1Links()local value,changed=config(),false for _,peer in pairs(value.peers)do if peer.protocol~=2 or peer.rekeyRequired or type(peer.key)~=\"string\"or#peer.key<32 then peer.protocol,peer.rekeyRequired,peer.key=1,true,nil peer.secret=nil changed=true end end if changed then save(value)end return value end local function activePeer(value,peerId)local peer=value.peers[tostring(peerId)]if peer and peer.protocol==2 and peer.rekeyRequired~=true and type(peer.key)==\"string\"and#peer.key>=32 then return peer end return nil end local function activeLink(value,peerId)local manual=activePeer(value,peerId)if manual then return manual,\"direct\"end local edge=autoEdges[tostring(peerId)]if edge and type(edge.key)==\"string\"and#edge.key>=32 and(edge.expires or 0)>now()then return edge,\"mesh\"end return nil end local function healthFor(peerId)peerId=tostring(peerId)local state=linkHealth[peerId]if not state then state={state=\"healthy\",successes=0,misses=0,lastAuthenticated=now(),stableSince=now(),inFlight=0}linkHealth[peerId]=state end return state end local function linkState(peerId)return healthFor(peerId).state or\"healthy\"end local function currentInFlight(state,timestamp)state.inFlightUntil=type(state.inFlightUntil)==\"table\"and state.inFlightUntil or{}local kept={}for _,expires in ipairs(state.inFlightUntil)do if expires>timestamp then kept[#kept+1]=expires end end state.inFlightUntil,state.inFlight=kept,#kept return state.inFlight end local function markInFlight(state)local timestamp=now()currentInFlight(state,timestamp)state.inFlightUntil[#state.inFlightUntil+1]=timestamp+SAFE_READ_WINDOW table.sort(state.inFlightUntil)while#state.inFlightUntil>SAFE_READ_LIMIT do table.remove(state.inFlightUntil,1)end state.inFlight=#state.inFlightUntil end local function linkUsable(value,peerId,allowDegraded)if not activeLink(value,peerId)then return false end local state=linkState(peerId)return state==\"healthy\"or(allowDegraded and state==\"degraded\")end local function touchLink(peerId,distance,source)local state,timestamp=healthFor(peerId),now()state.lastAuthenticated,state.lastDistance,state.lastSource=timestamp,distance,source or\"traffic\"state.misses,state.awaiting,state.probeToken=0,false,nil state.loss=math.max(0,(state.loss or 0)*0.5)if state.state~=\"healthy\"then state.successes=(state.successes or 0)+1 if state.successes>=2 then state.state,state.stableSince,state.recoveredAt=\"healthy\",timestamp,timestamp routesDirty=true trace(\"routing\",\"link_recovered\",{peer=peerId,source=source})end else state.successes=math.min(2,(state.successes or 0)+1)end end local function allDirectLinks(value)local out,seen={},{}for peerId in pairs(value.peers)do if activePeer(value,peerId)then out[#out+1],seen[peerId]=tostring(peerId),true end end for peerId,edge in pairs(autoEdges)do if not seen[peerId]and edge.expires>now()then out[#out+1]=tostring(peerId)end end table.sort(out,function(a,b)return tonumber(a)<tonumber(b)end)return out end local function remember(peer,peerLabel,extra)local value=read(SEEN_PATH,{})local old=value[tostring(peer)]or{}old.label,old.seen=peerLabel or old.label or(\"Computer \"..tostring(peer)),now()if extra then for key,item in pairs(extra)do if key~=\"tag\"and key~=\"proof\"then old[key]=item end end end value[tostring(peer)]=old store.write(SEEN_PATH,value)end local function modem(requireWireless)local candidates,used={},{}local sides=rs and rs.getSides and rs.getSides()or{}for _,name in ipairs(sides)do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end if peripheral.getNames then for _,name in ipairs(peripheral.getNames())do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end end local fallback for _,name in ipairs(candidates)do local wrapped=peripheral.wrap(name)if wrapped then fallback=fallback or wrapped local ok,wireless=pcall(function()return not wrapped.isWireless or wrapped.isWireless()end)if ok and wireless then return wrapped end end end return requireWireless and nil or fallback end local function modems()local out,seen={},{}local function add(name)if not seen[name]and peripheral.getType(name)==\"modem\"then local wrapped=peripheral.wrap(name)if wrapped then out[#out+1],seen[name]={name=name,modem=wrapped},true end end end for _,name in ipairs(rs and rs.getSides and rs.getSides()or{})do add(name)end for _,name in ipairs(peripheral.getNames and peripheral.getNames()or{})do add(name)end return out end local function wirelessModems()local out={}for _,item in ipairs(modems())do local ok,wireless=pcall(function()return not item.modem.isWireless or item.modem.isWireless()end)if ok and wireless then out[#out+1]=item end end return out end local function openChannels(value)local channels={value.channel or CHANNEL}if channels[1]~=DISCOVERY_CHANNEL then channels[#channels+1]=DISCOVERY_CHANNEL end transport.channels=channels local all=modems()if#all==0 then transport.lastError=\"no modem attached\";trace(\"transport\",\"modem_missing\");return channels end for _,item in ipairs(all)do for _,channel in ipairs(channels)do local ok,err=pcall(item.modem.open,channel)if not ok then transport.lastError=tostring(err)trace(\"transport\",\"channel_open_failed\",{channel=channel,error=transport.lastError,modem=item.name})end end end return channels end local function canonical(value,depth)depth=depth or 0 local kind=type(value)if kind==\"nil\"then return\"n\"end if kind==\"boolean\"then return value and\"b1\"or\"b0\"end if kind==\"number\"then if value~=value or value==math.huge or value==-math.huge then return nil,\"invalid numeric packet value\"end return\"d\"..string.format(\"%.17g\",value)..\";\"end if kind==\"string\"then if#value>MAX_PACKET_STRING then return nil,\"packet string exceeds limit\"end return\"s\"..tostring(#value)..\":\"..value end if kind~=\"table\"then return nil,\"unsupported packet value\"end if depth>=MAX_PACKET_DEPTH then return nil,\"packet nesting exceeds limit\"end local entries={}for key,item in pairs(value)do if#entries>=MAX_PACKET_TABLE then return nil,\"packet table exceeds limit\"end local encodedKey,keyErr=canonical(key,depth+1);if not encodedKey then return nil,keyErr end local encodedValue,valueErr=canonical(item,depth+1);if not encodedValue then return nil,valueErr end entries[#entries+1]=encodedKey..\"=\"..encodedValue end table.sort(entries)return\"t\"..tostring(#entries)..\"{\"..table.concat(entries,\",\")..\"}\"end local function packetMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,origin=packet.origin,destination=packet.destination,ttl=packet.ttl,request_id=packet.request_id,timestamp=packet.timestamp,reply_to=packet.reply_to,auth=packet.auth and{epoch=packet.auth.epoch,counter=packet.auth.counter}or nil,confidential=packet.confidential==true,body=packet.body,})end local function confidentialAad(packet)return table.concat({\"ceetos/confidential/v1\",tostring(packet.type),tostring(packet.origin),tostring(packet.destination),tostring(packet.request_id)},\"|\")end local function sealBody(peer,packet)local encoded=textutils.serialise(packet.body or{},{compact=true})if#encoded>6144 then return nil,\"confidential payload exceeds limit\"end local nonce=meshCrypto.nonce(peer.key,password.newSalt(\"confidential:\"..tostring(packet.request_id)),confidentialAad(packet))if not nonce then return nil,\"could not create confidential nonce\"end local envelope,err=meshCrypto.seal(peer.key,nonce,confidentialAad(packet),encoded)if not envelope then return nil,err end return{envelope=envelope}end local function openBody(peer,packet)if type(packet.body)~=\"table\"or type(packet.body.envelope)~=\"table\"then return nil,\"malformed confidential envelope\"end local decoded,err=meshCrypto.open(peer.key,packet.body.envelope,confidentialAad(packet))if not decoded or#decoded>6144 then return nil,err or\"invalid confidential payload\"end local ok,value=pcall(textutils.unserialise,decoded)if not ok or type(value)~=\"table\"then return nil,\"invalid confidential payload\"end return value end local function loadSecurity()security=read(SECURITY_PATH,{tx={},rx={}})security.tx=type(security.tx)==\"table\"and security.tx or{}security.rx=type(security.rx)==\"table\"and security.rx or{}end local function saveSecurity()local ok,err=store.write(SECURITY_PATH,security)if ok==false then error(err or\"could not persist peer replay state\",0)end end local function counter(peerId)local key=tostring(peerId)local tx=security.tx[key]if not tx then tx={epoch=password.newSalt(\"peer-tx:\"..key),reserved=0};security.tx[key]=tx end tx.next=tonumber(tx.next)or((tonumber(tx.reserved)or 0)+1)if tx.next>(tonumber(tx.reserved)or 0)then tx.reserved=tx.next+COUNTER_RESERVATION-1 saveSecurity()end local value=tx.next;tx.next=value+1 return tx.epoch,value end local function verifyReplay(from,auth)if type(auth)~=\"table\"or type(auth.epoch)~=\"string\"or#auth.epoch<16 or#auth.epoch>128 then return false,\"invalid packet epoch\"end local sequence=tonumber(auth.counter)if not sequence or sequence<1 or sequence%1~=0 then return false,\"invalid packet counter\"end local key=tostring(from)local row=security.rx[key]or{epochs={}}row.epochs=type(row.epochs)==\"table\"and row.epochs or{}local old=tonumber(row.epochs[auth.epoch])if old and sequence<=old then return false,\"replayed packet counter\"end row.epochs[auth.epoch]=sequence local order={}for epoch,max in pairs(row.epochs)do order[#order+1]={epoch=epoch,max=tonumber(max)or 0}end table.sort(order,function(a,b)return a.max>b.max end)while#order>MAX_RX_EPOCHS do row.epochs[table.remove(order).epoch]=nil end security.rx[key]=row saveSecurity()return true end local function newRequestId()return id()..\":\"..password.newSalt(\"peer-request\")end local function sign(peerId,peer,packet)local epoch,sequence=counter(peerId)packet.auth={epoch=epoch,counter=sequence}local material,err=packetMaterial(packet)if not material then return false,err end local mac,macErr=password.hmacSha256(peer.key,material)if not mac then return false,macErr end packet.auth.mac=mac return true end local function verifyPacket(packet,value)if type(packet)~=\"table\"then return false,\"packet is not a table\"end if packet.protocol~=PROTOCOL then return false,packet.protocol==\"ceetos/1\"and\"v1 packet rejected; rekey required\"or\"invalid packet protocol\"end if type(packet.type)~=\"string\"or#packet.type==0 or#packet.type>64 then return false,\"invalid packet type\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid packet sender\"end local from=tostring(packet.from)local peer=activeLink(value,from)if not peer then return false,\"sender is not an active direct or mesh peer\"end if not isForUs(packet.to)then return false,\"packet addressed to another hop\"end if type(packet.origin)~=\"string\"and type(packet.origin)~=\"number\"then return false,\"invalid packet origin\"end if type(packet.destination)~=\"string\"and type(packet.destination)~=\"number\"then return false,\"invalid packet destination\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 or#packet.request_id>128 then return false,\"invalid packet request ID\"end if packet.reply_to~=nil and(type(packet.reply_to)~=\"string\"or#packet.reply_to==0 or#packet.reply_to>128)then return false,\"invalid reply correlation ID\"end local ttl=tonumber(packet.ttl)if not ttl or ttl%1~=0 or ttl<1 or ttl>PACKET_TTL then return false,\"invalid packet TTL\"end local timestamp=tonumber(packet.timestamp)if not timestamp or math.abs(now()-timestamp)>ROUTE_TTL then return false,\"stale packet timestamp\"end if type(packet.auth)~=\"table\"or type(packet.auth.mac)~=\"string\"or#packet.auth.mac~=64 then return false,\"missing packet MAC\"end local receivedMac=packet.auth.mac packet.auth.mac=nil local material,materialErr=packetMaterial(packet)packet.auth.mac=receivedMac if not material then return false,materialErr end local expected,macErr=password.hmacSha256(peer.key,material)if not expected or not password.constantTimeEqual(expected,receivedMac)then return false,macErr or\"invalid packet MAC\"end local replayOk,replayErr=verifyReplay(from,packet.auth)if not replayOk then return false,replayErr end return true,peer end local function routeBucket(targetId)local bucket=routes[tostring(targetId)]if bucket and bucket.next then bucket={candidates={{next=tostring(bucket.next),hops=tonumber(bucket.hops)or PACKET_TTL,expires=tonumber(bucket.expires)or 0,label=bucket.label,mode=bucket.mode,masterId=bucket.masterId,legacy=true,loss=1,}},primary=tostring(bucket.next),changedAt=now(),reason=\"legacy route\"}routes[tostring(targetId)]=bucket end if not bucket then bucket={candidates={},changedAt=now(),reason=\"new\"}routes[tostring(targetId)]=bucket end bucket.candidates=type(bucket.candidates)==\"table\"and bucket.candidates or{}return bucket end local function candidateHealth(candidate)local state=healthFor(candidate.next)local rank=state.state==\"healthy\"and 0 or(state.state==\"degraded\"and 1 or 2)return rank,state end local function directCandidate(value,targetId)local link,kind=activeLink(value,targetId)if link then return{next=targetId,hops=1,expires=now()+ROUTE_TTL,kind=kind,direct=true,label=link.label,mode=link.mode,masterId=link.masterId}end end local function validCandidates(targetId,value)local timestamp,out,seen=now(),{},{}local direct=directCandidate(value,targetId)if direct then out[#out+1],seen[direct.next..\":\"..direct.kind]=direct,true end local bucket=routes[tostring(targetId)]if bucket then for _,candidate in ipairs(routeBucket(targetId).candidates)do local key=tostring(candidate.next)..\":\"..tostring(candidate.kind or\"route\")if not seen[key]and candidate.expires>timestamp and candidate.hops>=1 and candidate.hops<=PACKET_TTL and activeLink(value,candidate.next)then out[#out+1],seen[key]=candidate,true end end end return out end local function compareCandidates(a,b)local ar,ah=candidateHealth(a)local br,bh=candidateHealth(b)if ar~=br then return ar<br end if(a.hops or PACKET_TTL)~=(b.hops or PACKET_TTL)then return(a.hops or PACKET_TTL)<(b.hops or PACKET_TTL)end if(ah.loss or 0)~=(bh.loss or 0)then return(ah.loss or 0)<(bh.loss or 0)end if(ah.rtt or 0)~=(bh.rtt or 0)then return(ah.rtt or 0)<(bh.rtt or 0)end return tostring(a.next)<tostring(b.next)end local function primaryCandidate(targetId,value,safe)local candidates=validCandidates(targetId,value)if#candidates==0 then return nil end table.sort(candidates,compareCandidates)local target,bucket,selected=tostring(targetId),routeBucket(targetId),candidates[1]local existing for _,item in ipairs(candidates)do if tostring(item.next)==tostring(bucket.primary)then existing=item;break end end if existing then local oldRank,newRank=candidateHealth(existing),candidateHealth(selected)if oldRank<newRank then selected=existing elseif oldRank==newRank and oldRank==0 and(selected.hops or 99)<(existing.hops or 99)then local health=healthFor(selected.next)if(health.successes or 0)<2 or(health.recoveredAt and now()-(health.stableSince or now())<PROBE_RECOVERY)then selected=existing end end end if safe then local rank,_,choices=candidateHealth(selected),nil,{}for _,item in ipairs(candidates)do local itemRank=candidateHealth(item)if itemRank==rank and item.hops==selected.hops then choices[#choices+1]=item end end if#choices>1 then table.sort(choices,function(a,b)local ah,bh=healthFor(a.next),healthFor(b.next)local aLoad,bLoad=currentInFlight(ah,now()),currentInFlight(bh,now())if aLoad~=bLoad then return aLoad<bLoad end return tostring(a.next)<tostring(b.next)end)selected=choices[1]end end if bucket.primary~=tostring(selected.next)then bucket.primary,bucket.changedAt,bucket.reason=tostring(selected.next),now(),existing and\"health/hop selection\"or\"initial selection\"trace(\"routing\",\"route_selected\",{destination=target,next=selected.next,hops=selected.hops,reason=bucket.reason})end return selected end local function nextHop(target,safe)local candidate=primaryCandidate(target,config(),safe)if candidate then local health=healthFor(candidate.next)if safe then markInFlight(health)end health.lastSelected=now()return candidate.next,candidate end routes[tostring(target)]=nil end local function transmit(items,channel,packet)if#items==0 then return false,\"no compatible modem attached\"end local sent,lastError=false,nil for _,item in ipairs(items)do local ok,err=pcall(item.modem.transmit,channel,channel,packet)if ok then sent=true else lastError=tostring(err)end end if not sent then transport.lastError=lastError or\"modem transmit failed\"end return sent,transport.lastError end local function send(target,input,forcedHop)local hop=forcedHop or nextHop(target,input.routeSafe==true and input.balanceSafe==true)if not hop then return false,\"peer is unreachable or requires rekey\"end local value,peer=config(),activeLink(config(),hop)if not peer then return false,\"direct route is unavailable\"end local packet=copy(input)packet.auth,packet.protocol,packet.from,packet.to=nil,PROTOCOL,id(),hop packet.origin,packet.destination=tostring(packet.origin or id()),tostring(packet.destination or target)packet.ttl=math.floor(tonumber(packet.ttl)or PACKET_TTL)packet.timestamp=now()if packet.ttl<1 or packet.ttl>PACKET_TTL then return false,\"invalid packet TTL\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 then packet.request_id=newRequestId()end if packet.confidential==true then local sealed,sealErr=sealBody(peer,packet)if not sealed then return false,sealErr end packet.body=sealed end local signed,signErr=sign(hop,peer,packet)if not signed then return false,signErr end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if not sent then trace(\"transport\",\"transmit_failed\",{type=packet.type,to=hop,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil healthFor(hop).lastTransmit=now()trace(\"routing\",\"packet_sent\",{type=packet.type,to=hop,destination=packet.destination,links=#links})return true end local function rememberReverse(packet,previousHop)if type(packet)~=\"table\"or type(packet.request_id)~=\"string\"or#packet.request_id==0 then return false end local requestId,origin=packet.request_id,tostring(packet.origin)local existing=reverseRoutes[requestId]if existing and(existing.previous~=tostring(previousHop)or existing.origin~=origin)then return false,\"reverse route collision\"end reverseRoutes[requestId]={previous=tostring(previousHop),origin=origin,expires=now()+ROUTE_TTL}local entries={}for key,route in pairs(reverseRoutes)do entries[#entries+1]={id=key,expires=route.expires or 0}end table.sort(entries,function(a,b)return a.expires<b.expires end)while#entries>MAX_REVERSE_ROUTES do reverseRoutes[table.remove(entries,1).id]=nil end return true end local function broadcast(packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";trace(\"discovery\",\"wireless_missing\");return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to=PROTOCOL,id(),0 out.timestamp=now()openChannels(config())local sent,err=transmit(links,DISCOVERY_CHANNEL,out)if not sent then trace(\"discovery\",\"transmit_failed\",{type=out.type,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil trace(\"discovery\",out.type==\"discover\"and\"announcement_sent\"or\"discovery_packet_sent\",{type=out.type})return true end local function publicTransmit(target,typeName,body)if not PUBLIC_UPDATE_TYPES[typeName]then return false,\"invalid public update packet type\"end local encoded,encodeErr=canonical(body or{})if not encoded then return false,encodeErr or\"invalid public update body\"end local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end openChannels(config())local packet={protocol=PUBLIC_UPDATE_PROTOCOL,type=typeName,from=id(),to=tostring(target),timestamp=now(),request_id=newRequestId(),body=body or{},}local sent,err=transmit(links,DISCOVERY_CHANNEL,packet)if not sent then transport.lastError=err or\"public update transmit failed\"trace(\"transport\",\"public_update_transmit_failed\",{type=typeName,to=target,error=transport.lastError})return false,transport.lastError end transport.lastTransmit,transport.lastError=now(),nil trace(\"transport\",\"public_update_sent\",{type=typeName,to=target,bytes=#encoded})return true end function M.publicSend(target,typeName,body)if tostring(target)==\"0\"or tostring(target)==\"\"then return false,\"public update target must be a computer ID\"end return publicTransmit(target,typeName,body)end function M.publicBroadcast(typeName,body)return publicTransmit(\"0\",typeName,body)end local function handshake(target,packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to,out.timestamp=PROTOCOL,id(),tostring(target),now()out.destination,out.ttl=tostring(target),1 openChannels(config())local sent,err=transmit(links,config().channel or CHANNEL,out)if not sent then trace(\"discovery\",\"handshake_transmit_failed\",{type=out.type,to=target,error=err});return false,err end transport.lastTransmit=now()trace(\"discovery\",out.type..\"_sent\",{to=target})return true end local function phraseTag(phrase,sessionId,hostId)return password.hmacSha256(phrase,\"ceetos/discovery/v2|\"..sessionId..\"|\"..tostring(hostId))end local function joinProof(phrase,sessionId,hostId,joinerId,nonce)return password.hmacSha256(phrase,\"ceetos/pair/join/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce)end local function confirmProof(phrase,sessionId,hostId,joinerId,nonce,mode,master)return password.hmacSha256(phrase,\"ceetos/pair/confirm/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce..\"|\"..tostring(mode)..\"|\"..tostring(master or\"\"))end local function linkKey(phrase,sessionId,hostId,joinerId,nonce)return password.derive(phrase,\"ceetos/link/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce,64)end local function keyId(key)local value=password.hmacSha256(key,\"ceetos/key-id/v2\")return value and value:sub(1,16)or\"\"end local function activeSession()return discovery and(discovery.state==\"hosting\"or discovery.state==\"searching\"or discovery.state==\"candidate\"or discovery.state==\"confirming\")end local function setLast(state,message)lastDiscovery={state=state,message=message,at=now()}end local function persistPair(peerId,key,metadata,masterId)local value=config()value.peers[tostring(peerId)]={protocol=2,rekeyRequired=false,key=key,keyId=keyId(key),role=\"operator\",mode=metadata.mode or\"peer\",master=tostring(masterId or\"\")==id(),masterId=tostring(masterId or\"\"),label=metadata.label,}save(value)remember(peerId,metadata.label,{mode=metadata.mode,masterId=masterId})routes[tostring(peerId)]=nil routesDirty=true audit.log(\"local\",\"peer.rekeyed\",{peer=peerId,mode=metadata.mode})end local function markRejected(reason)if discovery then discovery=nil end setLast(\"cancelled\",reason)end local function discoveryAnnouncement()if not discovery or discovery.state~=\"hosting\"then return false,\"no active host discovery\"end return broadcast({type=\"discover\",session=discovery.id,tag=discovery.tag,label=discovery.label,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,})end local function queueConfirmation(peerId,host)confirmations[host.id]=host local sent,err=handshake(peerId,{type=\"pair_confirm\",session=host.id,nonce=host.joinNonce,proof=host.confirmProof,label=host.label,mode=host.mode,master=host.masterId,})host.lastSent,host.retries=now(),0 if not sent then host.error=err end return sent,err end local function expireState(timestamp)if discovery and discovery.expires<=timestamp then local old=discovery.state discovery=nil setLast(\"expired\",old==\"searching\"and\"no matching discovery announcement received\"or\"discovery session expired\")trace(\"discovery\",\"session_expired\",{previous=old})end end local function boundMap(value,limit,timestamp)local entries={}for key,row in pairs(value)do entries[#entries+1]={key=key,at=type(row)==\"number\"and row or(type(row)==\"table\"and(row.expires or row.time or row.seen or row.lastAuthenticated or 0)or 0)}end table.sort(entries,function(a,b)if a.at~=b.at then return a.at<b.at end return tostring(a.key)<tostring(b.key)end)while#entries>limit do value[table.remove(entries,1).key]=nil end end local function pruneRouteBuckets(timestamp)local value=config()local entries={}for peerId,bucket in pairs(routes)do local latest=tonumber(bucket.changedAt)or 0 for _,candidate in ipairs(type(bucket.candidates)==\"table\"and bucket.candidates or{})do latest=math.max(latest,tonumber(candidate.expires)or 0)end entries[#entries+1]={peer=peerId,latest=latest}end table.sort(entries,function(a,b)if a.latest~=b.latest then return a.latest<b.latest end return tostring(a.peer)<tostring(b.peer)end)while#entries>ROUTE_BUCKET_LIMIT do local old=table.remove(entries,1)routes[old.peer],routesDirty=nil,true trace(\"routing\",\"route_bucket_evicted\",{destination=old.peer})end for peerId,state in pairs(linkHealth)do if not activeLink(value,peerId)and not routes[peerId]then linkHealth[peerId]=nil end end for peerId in pairs(advertisedRoutes)do if not activeLink(value,peerId)then advertisedRoutes[peerId]=nil end end boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)end local function controller(value)value=value or config()if value.controller and tostring(value.controller)~=\"\"then local chosen=tostring(value.controller)if chosen==id()or activeLink(value,chosen)then return chosen end local known=routes[chosen]if known then if known.expires and known.expires>now()then return chosen end if type(known.candidates)==\"table\"then for _,candidate in ipairs(known.candidates)do if(candidate.expires or 0)>now()and activeLink(value,candidate.next)then return chosen end end end end trace(\"routing\",\"controller_unreachable\",{controller=chosen})end local selected=tonumber(id())or 0 for peerId in pairs(value.peers)do if activePeer(value,peerId)then local n=tonumber(peerId);if n and n<selected then selected=n end end end for peerId,route in pairs(routes)do local reachable=route.expires and route.expires>now()if type(route.candidates)==\"table\"then reachable=false for _,candidate in ipairs(route.candidates)do if(candidate.expires or 0)>now()then reachable=true;break end end end if reachable then local n=tonumber(peerId);if n and n<selected then selected=n end end end return tostring(selected)end local function meshConfig(value)value=value or config()local mesh=value.mesh if type(mesh)==\"table\"and type(mesh.id)==\"string\"and#mesh.id>=16 and type(mesh.root)==\"string\"and#mesh.root>=32 and tonumber(mesh.epoch)then return mesh end return nil end local function meshMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,mesh=packet.mesh,epoch=packet.epoch,nonce=packet.nonce,offer=packet.offer,timestamp=packet.timestamp})end local function meshTag(mesh,packet)local material=meshMaterial(packet)return material and password.hmacSha256(mesh.root,material)or nil end local function meshPacket(typeName,target,fields)local value,mesh=config(),meshConfig()if not mesh then return false,\"mesh enrollment is pending\"end local packet=copy(fields or{})packet.protocol,packet.type,packet.from,packet.to=PROTOCOL,typeName,id(),target and tostring(target)or 0 packet.mesh,packet.epoch,packet.timestamp=mesh.id,mesh.epoch,now()packet.tag=meshTag(mesh,packet)if not packet.tag then return false,\"could not authenticate mesh packet\"end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if sent then trace(\"routing\",typeName..\"_sent\",{to=packet.to,mesh=mesh.id:sub(1,8)})end return sent,err end local function deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)local left,right=tostring(id()),tostring(peerId)if left>right then left,right=right,left end return password.hmacSha256(mesh.root,\"ceetos/mesh-edge/v1|\"..tostring(mesh.epoch)..\"|\"..left..\"|\"..right..\"|\"..tostring(firstNonce)..\"|\"..tostring(secondNonce))end local function ownsMeshOffer(peerId)local ours,theirs=tonumber(id()),tonumber(peerId)if ours and theirs then return ours<theirs end return tostring(id())<tostring(peerId)end local function installAutoEdge(mesh,peerId,firstNonce,secondNonce,peerLabel)peerId=tostring(peerId)local value=config()if activePeer(value,peerId)then return false,\"manual direct link already exists\"end local key=deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)if not key then return false,\"could not derive mesh edge\"end autoEdges[peerId]={key=key,label=peerLabel,mesh=mesh.id,epoch=mesh.epoch,expires=now()+ROUTE_TTL,firstNonce=firstNonce,secondNonce=secondNonce}local state=healthFor(peerId)state.state,state.successes,state.misses,state.lastAuthenticated,state.stableSince=\"healthy\",2,0,now(),now()routesDirty,meshDirty=true,true trace(\"routing\",\"mesh_edge_active\",{peer=peerId,mesh=mesh.id:sub(1,8)})return true end local function meshEnrollmentAad(from,to,meshId,epoch,nonceCounter)return canonical({protocol=PROTOCOL,type=\"mesh_enroll\",from=tostring(from),to=tostring(to),mesh=meshId,epoch=tonumber(epoch),counter=tonumber(nonceCounter)})end local function sendEnrollment(peerId)local value,mesh,peer=config(),meshConfig(),activePeer(config(),peerId)if not mesh or not peer then return false,\"mesh or direct link unavailable\"end local _,nonceCounter=counter(peerId)local aad=meshEnrollmentAad(id(),peerId,mesh.id,mesh.epoch,nonceCounter)local nonce=meshCrypto.nonce(peer.key,nonceCounter,\"mesh-enroll|\"..id()..\"|\"..tostring(peerId))local plaintext=textutils.serialise({id=mesh.id,epoch=mesh.epoch,root=mesh.root},{compact=true})local envelope,err=meshCrypto.seal(peer.key,nonce,aad,plaintext)if not envelope then return false,err end local sent,sendErr=send(peerId,{type=\"mesh_enroll\",body={mesh=mesh.id,epoch=mesh.epoch,counter=nonceCounter,envelope=envelope},request_id=newRequestId()},peerId)if sent then trace(\"routing\",\"mesh_enrollment_sent\",{to=peerId,epoch=mesh.epoch})end return sent,sendErr end local function acceptEnrollment(from,peer,packet)if not activePeer(config(),from)then return rejectPacket(\"mesh enrollment requires a manual direct link\",packet)end local body=packet.body if type(body)~=\"table\"or type(body.mesh)~=\"string\"or type(body.envelope)~=\"table\"or not tonumber(body.epoch)or not tonumber(body.counter)then return rejectPacket(\"malformed_mesh_enrollment\",packet)end local aad=meshEnrollmentAad(from,id(),body.mesh,body.epoch,body.counter)local plaintext,err=meshCrypto.open(peer.key,body.envelope,aad)if not plaintext then return rejectPacket(err or\"mesh enrollment authentication failed\",packet)end local ok,mesh=pcall(textutils.unserialise,plaintext)if not ok or type(mesh)~=\"table\"or mesh.id~=body.mesh or tonumber(mesh.epoch)~=tonumber(body.epoch)or type(mesh.root)~=\"string\"or#mesh.root<32 then return rejectPacket(\"invalid_mesh_enrollment\",packet)end local value,existing=config(),meshConfig()if existing and existing.id==mesh.id and tonumber(existing.epoch)>tonumber(mesh.epoch)then return end value.mesh={id=mesh.id,epoch=tonumber(mesh.epoch),root=mesh.root,enrolledAt=now(),enrolledBy=tostring(from)}save(value)meshDirty,routesDirty=true,true trace(\"routing\",\"mesh_enrolled\",{from=from,mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end local function ensureMeshEnrollment(timestamp)local value,mesh=config(),meshConfig()if not mesh then if(M._meshBootstrapAt or 0)>timestamp or controller(value)~=id()then return end value.mesh={id=password.newSalt(\"mesh-id:\"..id()),root=password.newSalt(\"mesh-root:\"..id()),epoch=1,createdAt=timestamp,controller=id()}save(value);mesh,meshDirty,routesDirty=value.mesh,true,true trace(\"routing\",\"mesh_created\",{mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end for _,peerId in ipairs(allDirectLinks(value))do if activePeer(value,peerId)then local previous=meshEnrollmentSends[peerId]if not previous or previous.epoch~=mesh.epoch or timestamp-previous.at>=MESH_FULL_INTERVAL then local sent=sendEnrollment(peerId)if sent then meshEnrollmentSends[peerId]={epoch=mesh.epoch,at=timestamp}end end end end end local function meshBeacon(timestamp)local mesh=meshConfig()if not mesh or timestamp-lastMeshBeacon<MESH_BEACON_INTERVAL then return end lastMeshBeacon=timestamp meshPacket(\"mesh_beacon\",nil,{nonce=password.newSalt(\"mesh-beacon:\"..id()),label=label()})end local function verifyMeshPacket(packet)local mesh=meshConfig()if not mesh or type(packet)~=\"table\"or packet.protocol~=PROTOCOL or packet.mesh~=mesh.id or tonumber(packet.epoch)~=tonumber(mesh.epoch)then return false,\"mesh membership proof failed\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid mesh sender\"end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 then return false,\"invalid mesh nonce\"end if math.abs(now()-(tonumber(packet.timestamp)or 0))>ROUTE_TTL then return false,\"stale mesh packet\"end local material,tag=meshMaterial(packet),packet.tag local expected=material and password.hmacSha256(mesh.root,material)if type(tag)~=\"string\"or not expected or not password.constantTimeEqual(expected,tag)then return false,\"invalid mesh packet tag\"end local replay=tostring(packet.from)..\"|\"..tostring(packet.type)..\"|\"..tostring(packet.nonce)..\"|\"..tostring(packet.offer or\"\")if meshSeen[replay]and meshSeen[replay]+ROUTE_TTL>now()then return false,\"replayed mesh packet\"end meshSeen[replay]=now()return true,mesh end local function handleMeshPacket(packet,distance)local valid,meshOrErr=verifyMeshPacket(packet)if not valid then return rejectPacket(meshOrErr,packet,nil,distance)end local mesh,from=meshOrErr,tostring(packet.from)if from==id()then return end if packet.type==\"mesh_beacon\"then remember(from,packet.label,{mesh=mesh.id})if not activePeer(config(),from)and not autoEdges[from]and ownsMeshOffer(from)then local nonce=password.newSalt(\"mesh-offer:\"..from)meshOffers[from]={offer=nonce,expires=now()+DISCOVERY_TTL}meshPacket(\"mesh_edge_offer\",from,{nonce=nonce,label=label()})end return end if not isForUs(packet.to)then return rejectPacket(\"mesh packet addressed to another peer\",packet,nil,distance)end if packet.type==\"mesh_edge_offer\"then if activePeer(config(),from)then return end local response=password.newSalt(\"mesh-accept:\"..from)installAutoEdge(mesh,from,packet.nonce,response,packet.label)return meshPacket(\"mesh_edge_accept\",from,{nonce=response,offer=packet.nonce,label=label()})end if packet.type==\"mesh_edge_accept\"then local offer=meshOffers[from]if not offer or offer.expires<=now()or offer.offer~=packet.offer then return rejectPacket(\"unexpected mesh edge acceptance\",packet,nil,distance)end meshOffers[from]=nil return installAutoEdge(mesh,from,offer.offer,packet.nonce,packet.label)end end local function probeLinks(timestamp)local value=config()for _,peerId in ipairs(allDirectLinks(value))do local health=healthFor(peerId)local interval=health.state==\"offline\"and PROBE_INTERVAL*3 or PROBE_INTERVAL if timestamp-(health.lastAuthenticated or 0)>=interval and timestamp-(health.lastProbe or 0)>=interval then if health.awaiting then health.misses=(health.misses or 0)+1 health.loss=math.min(1,((health.loss or 0)*3+1)/4)local nextState=health.misses>=PROBE_OFFLINE and\"offline\"or(health.misses>=PROBE_DEGRADED and\"degraded\"or health.state)if nextState~=health.state then health.state,health.successes,health.recoveredAt=nextState,0,nil trace(\"routing\",\"link_\"..nextState,{peer=peerId,misses=health.misses})end routesDirty=true end health.awaiting,health.lastProbe,health.probeToken=true,timestamp,password.newSalt(\"mesh-probe:\"..peerId)send(peerId,{type=\"mesh_probe\",body={token=health.probeToken},request_id=newRequestId()},peerId)end end end local function advertisedMembers(value,peerId,timestamp)local members={}for other,manual in pairs(value.peers)do if other~=peerId and activeLink(value,other)and linkState(other)==\"healthy\"then members[other]={label=manual.label,mode=manual.mode,masterId=manual.masterId,hops=1,kind=\"direct\"}end end for other,edge in pairs(autoEdges)do if other~=peerId and edge.expires>timestamp and linkState(other)==\"healthy\"then members[other]={label=edge.label,mode=\"peer\",hops=1,kind=\"mesh\"}end end for other in pairs(routes)do if other~=peerId and not members[other]then local candidate=primaryCandidate(other,value,false)if candidate and candidate.next~=peerId and linkState(candidate.next)==\"healthy\"then members[other]={label=candidate.label,mode=candidate.mode,masterId=candidate.masterId,hops=candidate.hops,kind=candidate.kind or\"route\"}end end end return members end local function sameAdvertisement(left,right)local leftValue,leftErr=canonical(left)local rightValue,rightErr=canonical(right)return leftValue~=nil and rightValue~=nil and not leftErr and not rightErr and leftValue==rightValue end local function advertiseRoutes(force)local timestamp,value=now(),config()if not force and not routesDirty and timestamp-lastRouteAdvertisement<ROUTE_INTERVAL then return end lastRouteAdvertisement,routesDirty=timestamp,false local full=timestamp-lastMeshFull>=MESH_FULL_INTERVAL if full then lastMeshFull=timestamp end for _,peerId in ipairs(allDirectLinks(value))do if linkUsable(value,peerId,false)then local desired,previous=advertisedMembers(value,peerId,timestamp),advertisedRoutes[peerId]or{}local members,withdrawals={},{}if full then members=desired else for target,meta in pairs(desired)do if not sameAdvertisement(meta,previous[target])then members[target]=meta end end for target in pairs(previous)do if not desired[target]then withdrawals[#withdrawals+1]=target end end end table.sort(withdrawals,function(a,b)return tostring(a)<tostring(b)end)if full or next(members)~=nil or#withdrawals>0 then routeSequence=routeSequence+1 local body={sequence=routeSequence,routeVersion=2,full=full,controller=controller(value),members=members,withdrawals=withdrawals}if send(peerId,{type=\"route_advertise\",body=body,routeSafe=true,request_id=newRequestId()})then advertisedRoutes[peerId]=copy(desired)trace(\"routing\",full and\"route_snapshot_sent\"or\"route_delta_sent\",{to=peerId,changes=(full and 0 or#withdrawals)})end end else advertisedRoutes[peerId]=nil end end end function M.start()migrateV1Links()loadSecurity()assert(meshCrypto.selfTest(),\"CeetOS mesh cryptography self-test failed\")openChannels(config())local status=M.transportStatus()trace(\"transport\",status.wireless and\"wireless_modem_detected\"or\"wireless_modem_missing\",{name=status.name})routesDirty,M._meshBootstrapAt=true,now()end function M.transportStatus()local wireless=wirelessModems()transport.modem,transport.wireless=#modems()>0,#wireless>0 transport.name=wireless[1]and wireless[1].name or nil local out=copy(transport)out.wirelessLinks,out.wirelessLinkCount={},#wireless for _,item in ipairs(wireless)do out.wirelessLinks[#out.wirelessLinks+1]=item.name end out.usesAllWirelessLinks,out.protocol=true,2 out.directPeers,out.manualDirectPeers,out.meshPeers,out.rekeyRequiredPeers,out.routedPeers=0,0,0,0,0 out.healthyLinks,out.degradedLinks,out.offlineLinks=0,0,0 local value=config()for peerId,peer in pairs(value.peers)do if activePeer(value,peerId)then out.directPeers,out.manualDirectPeers=out.directPeers+1,out.manualDirectPeers+1 elseif peer.rekeyRequired then out.rekeyRequiredPeers=out.rekeyRequiredPeers+1 end end for peerId,edge in pairs(autoEdges)do if edge.expires>now()then out.meshPeers,out.directPeers=out.meshPeers+1,out.directPeers+1 end end for peerId,health in pairs(linkHealth)do if health.state==\"healthy\"then out.healthyLinks=out.healthyLinks+1 elseif health.state==\"degraded\"then out.degradedLinks=out.degradedLinks+1 elseif health.state==\"offline\"then out.offlineLinks=out.offlineLinks+1 end end for peerId,bucket in pairs(routes)do local usable=primaryCandidate(peerId,value,false)if usable and not value.peers[peerId]and not autoEdges[peerId]then out.routedPeers=out.routedPeers+1 end end local mesh=meshConfig(value)out.mesh=mesh and{id=mesh.id:sub(1,8),epoch=mesh.epoch,enrolled=true}or{enrolled=false}out.health={healthy=out.healthyLinks,degraded=out.degradedLinks,offline=out.offlineLinks}return out end function M.transportTrace(kind)if kind==\"discovery\"or kind==\"routing\"or kind==\"transport\"then return copy(traces[kind])end return{discovery=copy(traces.discovery),routing=copy(traces.routing),transport=copy(traces.transport)}end function M.discovery()expireState(now())return copy(discovery)end function M.discoveryStatus()expireState(now())local candidate=discovery and discovery.candidate and{id=discovery.candidate.from,label=discovery.candidate.label,mode=discovery.candidate.mode,master=discovery.candidate.master,}or nil local session=discovery and{session=discovery.id,state=discovery.state,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,retries=discovery.retries or 0,candidate=candidate and copy(candidate)or nil,}or nil local state=session and session.state or(lastDiscovery and lastDiscovery.state or\"inactive\")return{state=state,active=session~=nil,lastState=lastDiscovery and lastDiscovery.state or\"inactive\",lastMessage=lastDiscovery and lastDiscovery.message or nil,session=session,searching=session and session.state==\"searching\"or false,candidate=candidate,discovered=#M.seenPeers(),transport=M.transportStatus(),message=(discovery and discovery.error)or(lastDiscovery and lastDiscovery.message),}end function M.startDiscovery(mode,masterSide,phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end mode=mode==\"master\"and\"master\"or\"peer\"masterSide=masterSide==\"joiner\"and\"joiner\"or\"initiator\"local sessionId=password.newSalt(\"discovery:\"..id())discovery={id=sessionId,state=\"hosting\",phrase=normalized,tag=phraseTag(normalized,sessionId,id()),mode=mode,masterSide=masterSide,label=label(),initiator=id(),expires=now()+DISCOVERY_TTL,retries=0,lastBroadcast=0,}local sent,err=discoveryAnnouncement()if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastBroadcast=now()setLast(\"hosting\")return true,{state=\"hosting\",session=sessionId,expires=discovery.expires}end function M.joinDiscovery(phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end local candidate for _,item in pairs(discovered)do if item.expires>now()and password.constantTimeEqual(item.tag or\"\",phraseTag(normalized,item.session,item.from))then candidate=item;break end end discovery={state=\"searching\",phrase=normalized,expires=now()+DISCOVERY_TTL,retries=0,lastQuery=0}if candidate then discovery.state,discovery.candidate=\"candidate\",candidate return true,{state=\"candidate\",candidate={id=candidate.from,label=candidate.label,mode=candidate.mode,master=candidate.master}}end local sent,err=broadcast({type=\"discover_query\"})if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastQuery=now()setLast(\"searching\",\"waiting for matching discovery announcement\")return true,{state=\"searching\"}end function M.confirmDiscovery()if not discovery or discovery.state~=\"candidate\"or not discovery.candidate then return false,\"no discovery candidate is awaiting confirmation\"end local candidate,value=discovery.candidate,config()local existing=value.peers[tostring(candidate.from)]if existing and not existing.rekeyRequired then return false,\"computer is already a network member\"end if routes[tostring(candidate.from)]and not existing then return false,\"computer is already a routed network member\"end local nonce=password.newSalt(\"pair-join:\"..candidate.session)local proof=joinProof(discovery.phrase,candidate.session,candidate.from,id(),nonce)discovery.state,discovery.joinNonce,discovery.joinProof,discovery.lastSent,discovery.retries=\"confirming\",nonce,proof,now(),0 local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=nonce,proof=proof,label=label()})if not sent then discovery.error=err;return false,err end trace(\"discovery\",\"pair_confirmation_requested\",{peer=candidate.from})return true end function M.cancelDiscovery()if discovery and discovery.state==\"hosting\"then broadcast({type=\"discover_cancel\",session=discovery.id})end discovery=nil setLast(\"cancelled\",\"discovery cancelled\")trace(\"discovery\",\"session_cancelled\")return true end function M.normalizePhrase(value)if type(value)~=\"string\"then return nil,\"phrase is required\"end if value:find(\"[%z\\1-\\31\\127]\")then return nil,\"phrase contains control characters\"end value=value:gsub(\"^%s+\",\"\"):gsub(\"%s+$\",\"\")if#value<8 then return nil,\"phrase must be at least 8 characters\"end if#value>128 then return nil,\"phrase must be at most 128 characters\"end return value end function M.tick()local timestamp=now()expireState(timestamp)if discovery then if discovery.state==\"hosting\"and timestamp-(discovery.lastBroadcast or 0)>=math.min(30000,DISCOVERY_INTERVAL*(2^math.min(discovery.retries or 0,4)))then local sent,err=discoveryAnnouncement()discovery.lastBroadcast=timestamp discovery.retries=(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"searching\"and timestamp-(discovery.lastQuery or 0)>=DISCOVERY_INTERVAL then local sent,err=broadcast({type=\"discover_query\"})discovery.lastQuery,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"confirming\"and timestamp-(discovery.lastSent or 0)>=PAIR_RETRY then local candidate=discovery.candidate local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=discovery.joinNonce,proof=discovery.joinProof,label=label()})discovery.lastSent,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end end end for sessionId,item in pairs(discovered)do if item.expires<=timestamp then discovered[sessionId]=nil end end for sessionId,record in pairs(confirmations)do if record.expires<=timestamp then confirmations[sessionId]=nil elseif timestamp-(record.lastSent or 0)>=PAIR_RETRY then queueConfirmation(record.peer,record)end end for peerId,bucket in pairs(routes)do local kept={}for _,candidate in ipairs(routeBucket(peerId).candidates)do if candidate.expires>timestamp then kept[#kept+1]=candidate end end bucket.candidates=kept if#kept==0 and not activeLink(config(),peerId)then routes[peerId],routesDirty=nil,true end end for peerId,edge in pairs(autoEdges)do if edge.expires<=timestamp then autoEdges[peerId],routesDirty=nil,true;trace(\"routing\",\"mesh_edge_expired\",{peer=peerId})end end for key,seenAt in pairs(meshSeen)do if seenAt+ROUTE_TTL<=timestamp then meshSeen[key]=nil end end for peerId,offer in pairs(meshOffers)do if offer.expires<=timestamp then meshOffers[peerId]=nil end end for requestId,seenAt in pairs(seenPackets)do if seenAt+ROUTE_TTL<=timestamp then seenPackets[requestId]=nil end end for requestId,route in pairs(reverseRoutes)do if route.expires<=timestamp then reverseRoutes[requestId]=nil end end boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)pruneRouteBuckets(timestamp)ensureMeshEnrollment(timestamp)meshBeacon(timestamp)probeLinks(timestamp)advertiseRoutes(false)end function M.peers()local out,value,seen={},config(),read(SEEN_PATH,{})for peerId,peer in pairs(value.peers)do out[#out+1]={id=peerId,label=peer.label or(seen[peerId]and seen[peerId].label),role=peer.role or\"operator\",mode=peer.mode or\"peer\",master=peer.master==true,masterId=peer.masterId,direct=true,active=activePeer(value,peerId)~=nil,rekeyRequired=peer.rekeyRequired==true or peer.protocol~=2,health=linkState(peerId),auto=false,}end for peerId,edge in pairs(autoEdges)do if not value.peers[peerId]and edge.expires>now()then out[#out+1]={id=peerId,label=edge.label or(seen[peerId]and seen[peerId].label),role=\"mesh\",mode=\"peer\",direct=true,auto=true,active=true,health=linkState(peerId)}end end for peerId in pairs(routes)do if not value.peers[peerId]and not autoEdges[peerId]then local route=primaryCandidate(peerId,value,false)if route then out[#out+1]={id=peerId,label=route.label or(seen[peerId]and seen[peerId].label),role=\"routed\",mode=route.mode or\"peer\",masterId=route.masterId,routed=true,hops=route.hops,next=route.next,health=linkState(route.next),alternates=#routeBucket(peerId).candidates-1}end end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.directPeers()local out={}for _,peer in ipairs(M.peers())do if peer.direct and peer.active then out[#out+1]=peer end end return out end function M.seenPeers()local out={}for peerId,item in pairs(read(SEEN_PATH,{}))do if not item.seen or item.seen+DISCOVERY_TTL*2>now()then out[#out+1]={id=peerId,label=item.label,seen=item.seen,session=item.session}end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.routeStatus(target)local value,out=config(),{}local function row(peerId)local selected=primaryCandidate(peerId,value,false)if not selected then return end local health=healthFor(selected.next)local alternates={}for _,candidate in ipairs(validCandidates(peerId,value))do if tostring(candidate.next)~=tostring(selected.next)then local state=healthFor(candidate.next)alternates[#alternates+1]={next=candidate.next,hops=candidate.hops,kind=candidate.kind or\"route\",health=state.state,loss=state.loss or 0,rtt=state.rtt,distance=state.lastDistance}end end table.sort(alternates,compareCandidates)while#alternates>ROUTE_CANDIDATE_LIMIT-1 do table.remove(alternates)end out[#out+1]={id=tostring(peerId),label=selected.label,next=selected.next,hops=selected.hops,kind=selected.kind or\"route\",health=health.state,loss=health.loss or 0,rtt=health.rtt,distance=health.lastDistance,selectedAt=routeBucket(peerId).changedAt,reason=routeBucket(peerId).reason,alternates=alternates,}end if target then row(tostring(target))else local ids,seen={},{}for peerId in pairs(value.peers)do ids[#ids+1],seen[peerId]=peerId,true end for peerId in pairs(autoEdges)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end for peerId in pairs(routes)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)for _,peerId in ipairs(ids)do row(peerId)end end return out end function M.statusSnapshot()return{protocol=2,transport=M.transportStatus(),discovery=M.discoveryStatus(),peers=M.peers(),routes=M.routeStatus(),trace=M.transportTrace(),controller=M.controller()}end function M.controller()return controller()end function M.isDirectController(from,packet)return tostring(from)==tostring(controller())and type(packet)==\"table\"and tostring(packet.origin or\"\")==tostring(from)end function M.setController(value)assert(tonumber(value),\"controller must be a computer ID\")local saved=config();saved.controller=tostring(value);save(saved);routesDirty=true audit.log(\"local\",\"jobs.controller\",{controller=saved.controller})return saved.controller end function M.request(target,typeName,body,options)if type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid request type\"end local destination=tostring(target)local value=config()if not primaryCandidate(destination,value,options and options.safe==true)then return false,\"peer is unreachable, degraded, or requires rekey\"end return send(destination,{type=typeName,body=body or{},origin=id(),routeSafe=options and options.safe==true,balanceSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId()})end function M.reply(request,typeName,body,options)if type(request)~=\"table\"or type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid reply\"end local requestId,destination=request.request_id,tostring(request.origin or\"\")local reverse=type(requestId)==\"string\"and reverseRoutes[requestId]or nil if destination==\"\"or not reverse or reverse.expires<=now()or reverse.origin~=destination then return false,\"reverse reply route is unavailable\"end return send(destination,{type=typeName,body=body or{},origin=id(),destination=destination,reply_to=requestId,routeSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId(),},reverse.previous)end function M.offer()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.accept()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.discover()return broadcast({type=\"discover_query\"})end rejectPacket=function(reason,packet,channel,distance)transport.rejected=transport.rejected+1 trace(\"transport\",\"packet_rejected\",{reason=reason,type=type(packet)==\"table\"and packet.type or nil,channel=channel,distance=distance,from=type(packet)==\"table\"and packet.from or nil})end local function handleDiscovery(packet,channel,distance)local from=tostring(packet.from)if packet.type==\"discover_cancel\"and isBroadcast(packet.to)then discovered[tostring(packet.session)]=nil trace(\"discovery\",\"cancel_received\",{from=from,distance=distance})return end if packet.type==\"discover_query\"and isBroadcast(packet.to)and discovery and discovery.state==\"hosting\"then discoveryAnnouncement()trace(\"discovery\",\"query_answered\",{from=from,distance=distance})return end if packet.type==\"discover\"and isBroadcast(packet.to)and from~=id()then if type(packet.session)~=\"string\"or#packet.session<16 or type(packet.tag)~=\"string\"or#packet.tag~=64 then return rejectPacket(\"malformed_discovery\",packet,channel,distance)end local expires=tonumber(packet.expires)or(now()+DISCOVERY_TTL)discovered[packet.session]={session=packet.session,from=from,tag=packet.tag,label=tostring(packet.label or(\"Computer \"..from)):sub(1,128),mode=packet.mode==\"master\"and\"master\"or\"peer\",master=packet.master==\"joiner\"and\"joiner\"or\"initiator\",expires=math.min(expires,now()+DISCOVERY_TTL)}remember(from,packet.label,{session=packet.session})trace(\"discovery\",\"announcement_received\",{from=from,label=packet.label,distance=distance})if discovery and discovery.state==\"searching\"and password.constantTimeEqual(packet.tag,phraseTag(discovery.phrase,packet.session,from))then local value,existing=config(),config().peers[from]if existing and not existing.rekeyRequired then markRejected(\"computer is already a direct peer\")elseif routes[from]and not existing then markRejected(\"computer is already a routed network member\")else discovery.state,discovery.candidate,discovery.error=\"candidate\",discovered[packet.session],nil setLast(\"candidate\",\"matching computer found; confirm pairing\")trace(\"discovery\",\"candidate_found\",{from=from,label=packet.label,distance=distance})end end return end end local function handlePairJoin(packet,distance)if not discovery or discovery.state~=\"hosting\"or packet.session~=discovery.id then return end local from=tostring(packet.from)local value,existing=config(),config().peers[from]if(existing and not existing.rekeyRequired)or(routes[from]and not existing)then handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"already_network_member\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"already_network_member\"})return end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 or type(packet.proof)~=\"string\"or#packet.proof~=64 then return rejectPacket(\"malformed_pair_join\",packet,nil,distance)end local expected=joinProof(discovery.phrase,discovery.id,id(),from,packet.nonce)if not password.constantTimeEqual(expected,packet.proof)then discovery.failures=(discovery.failures or 0)+1 if discovery.failures>=5 then markRejected(\"too many invalid pairing proofs\")end handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"phrase_mismatch\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"phrase_mismatch\"})return end local masterId=discovery.mode==\"master\"and(discovery.masterSide==\"initiator\"and id()or from)or\"\"local key,keyErr=linkKey(discovery.phrase,discovery.id,id(),from,packet.nonce)if not key then return markRejected(keyErr)end persistPair(from,key,{mode=discovery.mode,label=packet.label},masterId)local record={id=discovery.id,peer=from,joinNonce=packet.nonce,mode=discovery.mode,masterId=masterId,label=label(),expires=now()+DISCOVERY_TTL}record.confirmProof=confirmProof(discovery.phrase,record.id,id(),from,record.joinNonce,record.mode,record.masterId)discovery=nil setLast(\"paired\",\"awaiting pairing acknowledgement\")trace(\"discovery\",\"pair_join_verified\",{from=from,distance=distance})return queueConfirmation(from,record)end local function handlePairConfirm(packet,distance)if not discovery or discovery.state~=\"confirming\"or not discovery.candidate or packet.session~=discovery.candidate.session then return end local from=tostring(packet.from)if from~=tostring(discovery.candidate.from)or packet.nonce~=discovery.joinNonce then return rejectPacket(\"unexpected_pair_confirmation\",packet,nil,distance)end local expected=confirmProof(discovery.phrase,packet.session,from,id(),discovery.joinNonce,packet.mode==\"master\"and\"master\"or\"peer\",packet.master or\"\")if not password.constantTimeEqual(expected,packet.proof or\"\")then return markRejected(\"pair confirmation proof did not match\")end local key,err=linkKey(discovery.phrase,packet.session,from,id(),discovery.joinNonce)if not key then return markRejected(err)end persistPair(from,key,{mode=packet.mode,label=packet.label},packet.master)local sessionId=packet.session discovery=nil setLast(\"paired\",\"paired with \"..tostring(packet.label or from))handshake(from,{type=\"pair_ack\",session=sessionId,proof=password.hmacSha256(key,\"ceetos/pair/ack/v2|\"..sessionId)})trace(\"discovery\",\"pair_confirmed\",{from=from,distance=distance})return true end local function handlePairAck(packet)local record=confirmations[packet.session]if not record or tostring(record.peer)~=tostring(packet.from)then return end local value,peer=config(),activePeer(config(),record.peer)if not peer then return end local expected=password.hmacSha256(peer.key,\"ceetos/pair/ack/v2|\"..packet.session)if password.constantTimeEqual(expected,packet.proof or\"\")then confirmations[packet.session]=nil setLast(\"paired\",\"paired with \"..tostring(record.peer))routesDirty=true trace(\"discovery\",\"pair_acknowledged\",{from=packet.from})end end local function handleRouteAdvertisement(from,packet)local body=packet.body if type(body)~=\"table\"or type(body.sequence)~=\"number\"or type(body.members)~=\"table\"or(body.withdrawals~=nil and type(body.withdrawals)~=\"table\")then return rejectPacket(\"malformed_route_advertisement\",packet)end local key=tostring(from)M._routeSequences=M._routeSequences or{}if(M._routeSequences[key]or-1)>=body.sequence then return end M._routeSequences[key]=body.sequence local value,changed,count=config(),false,0 if body.controller and not value.controller then value.controller,changed=tostring(body.controller),true end local announced={}for advertisedId,meta in pairs(body.members)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local peerId=tostring(advertisedId)announced[peerId]=true if peerId~=id()and peerId~=key and type(meta)==\"table\"then local hops=math.floor(tonumber(meta.hops)or 0)+1 if hops>1 and hops<=PACKET_TTL and type(meta.label)~=\"table\"and type(meta.mode)~=\"table\"then local bucket,found=routeBucket(peerId),nil for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)==key then found=candidate;break end end if found then local metadataChanged=found.hops~=hops or found.label~=meta.label or found.mode~=meta.mode or tostring(found.masterId or\"\")~=tostring(meta.masterId or\"\")or found.kind~=(meta.kind or\"route\")found.hops,found.expires=hops,now()+ROUTE_TTL found.label,found.mode,found.masterId,found.kind=meta.label,meta.mode,meta.masterId,meta.kind or\"route\"if metadataChanged then changed=true end else bucket.candidates[#bucket.candidates+1]={next=key,hops=hops,expires=now()+ROUTE_TTL,label=type(meta.label)==\"string\"and meta.label:sub(1,128)or nil,mode=meta.mode==\"master\"and\"master\"or\"peer\",masterId=meta.masterId and tostring(meta.masterId)or nil,kind=meta.kind==\"mesh\"and\"mesh\"or\"route\"}table.sort(bucket.candidates,compareCandidates)while#bucket.candidates>ROUTE_CANDIDATE_LIMIT do table.remove(bucket.candidates)end changed=true end end end end local withdrawals=body.withdrawals or{}for _,withdrawnId in pairs(withdrawals)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local bucket=routes[tostring(withdrawnId)]if bucket and type(bucket.candidates)==\"table\"then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end if body.full==true then for peerId,bucket in pairs(routes)do if type(bucket.candidates)==\"table\"and not announced[tostring(peerId)]then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end end if changed then if value.controller then save(value)end;routesDirty=true;trace(\"routing\",\"route_table_updated\",{from=from})end end local function handleProbe(from,packet)local token=type(packet.body)==\"table\"and packet.body.token if type(token)~=\"string\"or#token<16 or#token>128 then return rejectPacket(\"malformed link probe\",packet)end touchLink(from,nil,\"probe\")return send(from,{type=\"mesh_probe_ack\",body={token=token},request_id=newRequestId()},from)end local function handleProbeAck(from,packet)local health,token=healthFor(from),type(packet.body)==\"table\"and packet.body.token if not health.awaiting or token~=health.probeToken then return rejectPacket(\"unexpected link probe acknowledgement\",packet)end local sample=math.max(0,now()-(health.lastProbe or now()))health.rtt=health.rtt and math.floor((health.rtt*3+sample)/4)or sample health.awaiting,health.misses,health.probeToken=false,0,nil touchLink(from,health.lastDistance,\"probe_ack\")end function M.handle(event)if event[1]~=\"modem_message\"then return end local channel,packet,distance=event[3],event[5],event[6]local expected=false for _,item in ipairs(transport.channels or{})do if channel==item then expected=true;break end end if not expected then return rejectPacket(\"unexpected_channel\",packet,channel,distance)end transport.lastReceive,transport.lastDistance=now(),distance if type(packet)~=\"table\"then return rejectPacket(\"packet_not_table\",packet,channel,distance)end if packet.protocol==PUBLIC_UPDATE_PROTOCOL then if channel~=DISCOVERY_CHANNEL or not PUBLIC_UPDATE_TYPES[packet.type]or type(packet.from)~=\"string\"and type(packet.from)~=\"number\"or not(isForUs(packet.to)or isBroadcast(packet.to))then return rejectPacket(\"invalid_public_update_packet\",packet,channel,distance)end local encoded,encodeErr=canonical(packet.body or{})if not encoded then return rejectPacket(\"invalid_public_update_body:\"..tostring(encodeErr),packet,channel,distance)end trace(\"transport\",\"public_update_received\",{type=packet.type,from=packet.from,distance=distance,bytes=#encoded})if M.publicHandler then return M.publicHandler(packet,distance)end return end local discoveryPacket=packet.type==\"discover\"or packet.type==\"discover_query\"or packet.type==\"discover_cancel\"local handshakePacket=packet.type==\"pair_join\"or packet.type==\"pair_confirm\"or packet.type==\"pair_ack\"or packet.type==\"pair_reject\"local meshPacketType=packet.type==\"mesh_beacon\"or packet.type==\"mesh_edge_offer\"or packet.type==\"mesh_edge_accept\"if discoveryPacket then if packet.protocol~=PROTOCOL or channel~=DISCOVERY_CHANNEL then return rejectPacket(\"invalid_discovery_transport\",packet,channel,distance)end return handleDiscovery(packet,channel,distance)end if handshakePacket then if not isForUs(packet.to)then return end if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid_handshake_transport\",packet,channel,distance)end if packet.type==\"pair_join\"then return handlePairJoin(packet,distance)elseif packet.type==\"pair_confirm\"then return handlePairConfirm(packet,distance)elseif packet.type==\"pair_ack\"then return handlePairAck(packet)elseif packet.type==\"pair_reject\"and discovery then markRejected(\"pairing rejected: \"..tostring(packet.reason or\"remote peer rejected it\"));return end return end if meshPacketType then if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid mesh transport\",packet,channel,distance)end if packet.type~=\"mesh_beacon\"and not isForUs(packet.to)then return end return handleMeshPacket(packet,distance)end if not isForUs(packet.to)then return end local value=config()local valid,peerOrReason=verifyPacket(packet,value)if not valid then return rejectPacket(peerOrReason,packet,channel,distance)end local peer,from=peerOrReason,tostring(packet.from)if packet.confidential==true then local opened,openErr=openBody(peer,packet)if not opened then return rejectPacket(openErr or\"could not open confidential packet\",packet,channel,distance)end packet.body=opened end touchLink(from,distance,\"authenticated_packet\")if autoEdges[from]then autoEdges[from].expires=now()+ROUTE_TTL end trace(\"routing\",\"packet_received\",{type=packet.type,from=from,destination=packet.destination,distance=distance})if packet.type==\"mesh_enroll\"then return acceptEnrollment(from,peer,packet)end if packet.type==\"mesh_probe\"then return handleProbe(from,packet)end if packet.type==\"mesh_probe_ack\"then return handleProbeAck(from,packet)end if packet.type==\"route_advertise\"then return handleRouteAdvertisement(from,packet)end if packet.reply_to and packet.destination and tostring(packet.destination)~=id()then local reverse=reverseRoutes[packet.reply_to]if not reverse or reverse.expires<=now()or reverse.origin~=tostring(packet.destination)then return rejectPacket(\"reverse reply route unavailable\",packet,channel,distance)end local requestId=tostring(packet.request_id or\"\")if seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 trace(\"routing\",\"reverse_reply_forwarded\",{from=from,to=reverse.previous,type=packet.type})return send(packet.destination,packet,reverse.previous)end if packet.destination and tostring(packet.destination)~=id()then local requestId=tostring(packet.request_id or\"\")if requestId==\"\"or seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 return send(packet.destination,packet)end local requestId=tostring(packet.request_id or\"\")if requestId==\"\"then return rejectPacket(\"missing request ID\",packet,channel,distance)end if seenPackets[requestId]then return trace(\"routing\",\"destination_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end packet.authenticatedHop,packet.originVerified=from,false if M.handler then return M.handler(from,peer,packet)end end return M",
  ["ceetos/lib/network_ipc.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local ROOT=\"/ceetos/data/network-ipc\"local COMMANDS=ROOT..\"/commands\"local RESULTS=ROOT..\"/results\"local function ensure(path)if not fs.exists(path)then fs.makeDir(path)end end local function safeId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=160 end local function path(directory,requestId)return fs.combine(directory,requestId..\".lua\")end function M.submit(request)if type(request)~=\"table\"or not safeId(request.id)then return false,\"invalid IPC request ID\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local target=path(COMMANDS,request.id)if fs.exists(target)then return false,\"IPC request already exists\"end return store.write(target,request)end function M.take()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local names=fs.list(COMMANDS)table.sort(names)for _,name in ipairs(names)do local requestId=name:match(\"^([%w_%-%.]+)%.lua$\")if requestId and safeId(requestId)then local target=fs.combine(COMMANDS,name)store.invalidate(target)local request=store.readFresh(target,nil)fs.delete(target)if type(request)==\"table\"and request.id==requestId then return request end end end end function M.reply(requestId,value)if not safeId(requestId)or type(value)~=\"table\"then return false,\"invalid IPC result\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)return store.write(path(RESULTS,requestId),value)end function M.poll(requestId,consume)if not safeId(requestId)then return nil,\"invalid IPC request ID\"end local target=path(RESULTS,requestId)if not fs.exists(target)then return nil end local handle=fs.open(target,\"r\")if not handle then return nil end local raw=handle.readAll()handle.close()local ok,result=pcall(textutils.unserialise,raw)if not ok or type(result)~=\"table\"or result.id~=requestId then return nil,\"invalid IPC result\"end if consume then fs.delete(target)end return result end function M.prune(limit)ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)limit=math.max(1,math.floor(tonumber(limit)or 32))local names={}for _,name in ipairs(fs.list(RESULTS))do if name:match(\"^[%w_%-%.]+%.lua$\")then names[#names+1]=name end end table.sort(names)while#names>limit do fs.delete(fs.combine(RESULTS,table.remove(names,1)))end end function M.status()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local function count(directory)local total=0 for _,name in ipairs(fs.list(directory))do if name:match(\"^[%w_%-%.]+%.lua$\")then total=total+1 end end return total end return{commands=count(COMMANDS),results=count(RESULTS)}end return M",
  ["ceetos/lib/auth_client.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local networkIpc=require(\"ceetos.lib.network_ipc\")local M={}local REPLIES=\"/ceetos/data/auth-replies.lua\"local sequence=0 local function now()return os.epoch(\"utc\")end local function authority()store.invalidate(\"/ceetos/data/auth-authority.lua\")local value=store.read(\"/ceetos/data/auth-authority.lua\",nil)return type(value)==\"table\"and value.active==true and value or nil end local function requestId(kind)sequence=sequence+1 return table.concat({\"auth\",kind,tostring(os.getComputerID()),tostring(now()),tostring(sequence)},\"-\")end local function take(id)store.invalidate(REPLIES)local replies=store.read(REPLIES,{})local row=replies[id]if row then replies[id]=nil;store.write(REPLIES,replies)end return row end function M.receive(body)if type(body)~=\"table\"or type(body.request_id)~=\"string\"or#body.request_id>160 then return false,\"invalid authority reply\"end local replies=store.read(REPLIES,{})replies[body.request_id]={ok=body.ok==true,result=body.result,error=body.error,at=now()}local rows={}for id,row in pairs(replies)do rows[#rows+1]={id=id,at=tonumber(row.at)or 0}end table.sort(rows,function(a,b)return a.at>b.at end)while#rows>32 do replies[table.remove(rows).id]=nil end return store.write(REPLIES,replies)end local function send(typeName,body,timeout)local server=authority()if not server then return nil,\"no Auth Server is reachable\"end local id=body.request_id or requestId(typeName)body.request_id=id local command={id=\"auth-\"..id,action=\"auth_send\",target=server.id,type=typeName,body=body}local ok,err=networkIpc.submit(command)if not ok then return nil,err or\"could not reach CeetOS network service\"end local deadline=now()+(timeout or 6000)while now()<deadline do local ack=networkIpc.poll(command.id,true)if ack and ack.ok~=true then return nil,ack.error or\"Auth Server request was not sent\"end local reply=take(id)if reply then return reply.ok and reply.result or nil,reply.error or\"Auth Server rejected request\"end sleep(0.05)end return nil,\"Auth Server did not respond\"end local function loginProof(verifier,server,request,challenge,expires)return password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(os.getComputerID()),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.login(name,plainPassword)end local request=requestId(\"begin\")local begin,beginErr=send(\"auth_login_begin\",{request_id=request,username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=loginProof(verifier,begin.authority,request,begin.challenge,begin.expires)local result,proofErr=send(\"auth_login_proof\",{request_id=request,username=name,node=tostring(os.getComputerID()),challenge=begin.challenge,proof=proof})if not result then return false,proofErr end local auth=require((\"ceetos.lib.auth\"))local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require((\"ceetos.lib.auth\"))local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.mutate(action,fields)end local current,server=auth.refreshSession(),authority()if not current or not current.central or not server then return false,\"an Auth Server login is required\"end local result,err=send(\"auth_mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end return M",
  ["ceetos/lib/telemetry.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/config.lua\"local activity=\"desktop\"local function text(value,limit)if type(value)~=\"string\"then return nil end value=value:gsub(\"[%z\\1-\\31\\127]\",\" \")if value==\"\"then return nil end return value:sub(1,limit)end local function config()local value=store.read(PATH,{})if type(value)~=\"table\"then value={}end if value.telemetry==nil then value.telemetry=true store.write(PATH,value)end return value end function M.setEnabled(value)assert(type(value)==\"boolean\",\"telemetry state must be boolean\")require(\"ceetos.lib.auth\").require(\"admin\")local valueForSave=config()valueForSave.telemetry=value return store.write(PATH,valueForSave)end function M.status()return config().telemetry==true end function M.configuration()return{enabled=M.status()}end function M.markActivity(value)activity=text(value,48)or activity return activity end function M.activity()return activity end function M.snapshot(currentActivity)if currentActivity then M.markActivity(currentActivity)end local data={ts=os.epoch(\"utc\"),id=os.getComputerID(),label=text(os.getComputerLabel(),96),activity=activity,}if turtle and type(turtle.getFuelLevel)==\"function\"then local ok,fuel=pcall(turtle.getFuelLevel)if ok and type(fuel)==\"number\"then data.fuel=fuel end end if gps and type(gps.locate)==\"function\"then local ok,x,y,z=pcall(gps.locate,0.2)if ok and type(x)==\"number\"and type(y)==\"number\"and type(z)==\"number\"then data.gps={x=x,y=y,z=z}end end return data end return M",
  ["ceetos/lib/cloud.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local M={}M.PATH=\"/ceetos/data/cloud.lua\"M.MAX_BODY=48*1024 M.MAX_RESPONSE=64*1024 M.DEFAULTS={auth=\"https://auth.ceet.uk\",recipe=\"https://recipe.ceet.uk\",dashboard=\"https://dash.ceet.uk\",}local function now()return os.epoch(\"utc\")end local function validUrl(value)if type(value)~=\"string\"or#value>160 then return false end return value:match(\"^https://[%w%-%.]+%.ceet%.uk$\")~=nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_.%-]+$\")~=nil and#value<=96 end local function copy(value)local out={}for key,item in pairs(value or{})do out[key]=item end return out end local function normalise(value)value=type(value)==\"table\"and value or{}local urls=type(value.urls)==\"table\"and value.urls or{}local result={schema=1,enabled=value.enabled==true,urls={auth=validUrl(urls.auth)and urls.auth or M.DEFAULTS.auth,recipe=validUrl(urls.recipe)and urls.recipe or M.DEFAULTS.recipe,dashboard=validUrl(urls.dashboard)and urls.dashboard or M.DEFAULTS.dashboard,},node=type(value.node)==\"table\"and copy(value.node)or nil,}if result.node and(not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 or#result.node.secret>192)then result.node=nil end return result end function M.load()store.invalidate(M.PATH)return normalise(store.read(M.PATH,{}))end function M.save(value)local clean=normalise(value)return store.write(M.PATH,clean)end function M.configure(urls)local value=M.load()urls=type(urls)==\"table\"and urls or{}for key in pairs(M.DEFAULTS)do if urls[key]~=nil then if not validUrl(urls[key])then return false,\"invalid \"..key..\" cloud URL\"end value.urls[key]=urls[key]end end return M.save(value)end function M.clear()local value=M.load();value.enabled,value.node=false,nil return M.save(value)end function M.publicStatus()local value=M.load()return{enabled=value.enabled,enrolled=value.node~=nil,node=value.node and value.node.id or nil,urls=copy(value.urls),profile=profile.id()}end local function readBounded(handle,limit)local chunks,total={},0 while true do local part=handle.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then return nil,\"cloud response is too large\"end chunks[#chunks+1]=part end return table.concat(chunks)end local function json(value)local ok,result=pcall(textutils.unserialiseJSON,value)return ok and type(result)==\"table\"and result or nil end local function canonical(node,timestamp,nonce,method,path,body)local digest=assert(password.sha256(body))return table.concat({\"ceetos-cloud-node-v1\",node,tostring(timestamp),nonce,method,path,digest},\"\\n\")end local nonceCounter=0 local function nonce()nonceCounter=nonceCounter+1 return password.newSalt(\"cloud:\"..tostring(nonceCounter))end local function perform(url,method,path,body,headers)if not http or type(http.post)~=\"function\"then return nil,\"HTTP is unavailable\"end local response local ok,err=pcall(function()response=http.post(url..path,body,headers)end)if not ok or not response then return nil,tostring(err or\"cloud request failed\")end local raw,readErr=readBounded(response,M.MAX_RESPONSE)pcall(response.close)if not raw then return nil,readErr end local decoded=json(raw)if not decoded then return nil,\"cloud returned invalid JSON\"end if decoded.ok==false then return nil,tostring(decoded.error or\"cloud rejected request\"):sub(1,180)end return decoded end function M.enroll(code)if type(code)~=\"string\"or#code<12 or#code>128 or code:find(\"[%z\\1-\\31\\127]\")then return nil,\"invalid enrollment code\"end local value=M.load()local payload=textutils.serialiseJSON({code=code,profile=profile.id(),label=os.getComputerLabel()or(\"Computer \"..tostring(os.getComputerID())),computerId=tostring(os.getComputerID())})if#payload>M.MAX_BODY then return nil,\"enrollment request is too large\"end local result,err=perform(value.urls.auth,\"POST\",\"/v1/nodes/enroll\",payload,{[\"Content-Type\"]=\"application/json\"})if not result then return nil,err end if type(result.node)~=\"table\"or not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 then return nil,\"cloud returned invalid enrollment\"end value.enabled,value.node=true,{id=result.node.id,secret=result.node.secret,enrolledAt=now()}local saved,saveErr=M.save(value)if not saved then return nil,saveErr or\"could not save cloud enrollment\"end return M.publicStatus()end function M.call(service,path,payload)local value=M.load()if not value.enabled or not value.node then return nil,\"cloud node is not enrolled\"end if not M.DEFAULTS[service]or type(path)~=\"string\"or not path:match(\"^/v1/[%w%-%._/]+$\")or#path>128 then return nil,\"invalid cloud endpoint\"end local body=textutils.serialiseJSON(type(payload)==\"table\"and payload or{})if#body>M.MAX_BODY then return nil,\"cloud request is too large\"end local timestamp,requestNonce=now(),nonce()local signature=password.hmacSha256(value.node.secret,canonical(value.node.id,timestamp,requestNonce,\"POST\",path,body))if not signature then return nil,\"could not sign cloud request\"end return perform(value.urls[service],\"POST\",path,body,{[\"Content-Type\"]=\"application/json\",[\"X-CeetOS-Node\"]=value.node.id,[\"X-CeetOS-Time\"]=tostring(timestamp),[\"X-CeetOS-Nonce\"]=requestNonce,[\"X-CeetOS-Signature\"]=signature,})end return M",
  ["ceetos/lib/cloud_sync.lua"] = "local cloud=require(\"ceetos.lib.cloud\")local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local telemetryService=require(\"ceetos.lib.telemetry\")local RECIPE_SERVICE_MODULE=\"ceetos.lib.\"..\"recipe_service\"local M={}local STATE=\"/ceetos/data/cloud-state.lua\"local INTERVALS={telemetry=24*60*60*1000,authority=30000,recipes=30000}local TELEMETRY_RETRIES={15*60*1000,60*60*1000,4*60*60*1000}local function now()return os.epoch(\"utc\")end local function defaults()return{schema=2,revision=0,auth={online=false,next=0},recipe={online=false,next=0,revision=0},telemetry={enabled=nil,next=0,lastSuccess=nil,failures=0,lastError=nil},lastError=nil}end local function state()store.invalidate(STATE)local value=store.read(STATE,defaults())if type(value)~=\"table\"then value=defaults()end if type(value.auth)~=\"table\"then value.auth={}end if type(value.recipe)~=\"table\"then value.recipe={}end if type(value.telemetry)~=\"table\"then value.telemetry={}end for key,fallback in pairs(defaults())do if value[key]==nil then value[key]=fallback end end for key,fallback in pairs(defaults().recipe)do if value.recipe[key]==nil then value.recipe[key]=fallback end end for key,fallback in pairs(defaults().telemetry)do if value.telemetry[key]==nil then value.telemetry[key]=fallback end end return value end local function save(value)value.revision=(tonumber(value.revision)or 0)+1 return store.write(STATE,value)end local function errorState(value,message)value.lastError=tostring(message or\"cloud request failed\"):sub(1,180)end function M.status()local value,cfg=state(),cloud.publicStatus()return{enabled=cfg.enabled,enrolled=cfg.enrolled,node=cfg.node,urls=cfg.urls,authOnline=value.auth.online==true,recipeOnline=value.recipe.online==true,telemetryNext=tonumber(value.telemetry and value.telemetry.next)or 0,telemetryInterval=INTERVALS.telemetry,telemetryEnabled=telemetryService.status(),telemetryLastSuccess=value.telemetry and value.telemetry.lastSuccess or nil,telemetryLastError=value.telemetry and value.telemetry.lastError or nil,telemetryFailures=math.max(0,math.floor(tonumber(value.telemetry and value.telemetry.failures)or 0)),lastSync=value.lastSync,lastError=value.lastError,}end function M.configure(urls)return cloud.configure(urls)end function M.enroll(code)local enrolled,err=cloud.enroll(code)if not enrolled then return nil,err end local value=state()value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=0,0,nil save(value)return enrolled end function M.clear()local ok,err=cloud.clear();if ok then store.write(STATE,defaults())end return ok,err end function M.authOnline()return M.status().authOnline==true end function M.recipeOnline()return M.status().recipeOnline==true end local function cloudAuthority(result)local auth=require(\"ceetos.lib.auth\")if type(result)~=\"table\"or type(result.directory)~=\"table\"then return false,\"invalid cloud authority response\"end local cfg=cloud.publicStatus()local record={id=\"cloud:\"..tostring(cfg.urls.auth),term=tonumber(result.term)or 0,revision=tonumber(result.revision)or 0,directory=result.directory}return pcall(auth.acceptAuthority,record)end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local begin,beginErr=cloud.call(\"auth\",\"/v1/auth/login/begin\",{username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end if type(begin.salt)~=\"string\"or type(begin.workFactor)~=\"number\"or type(begin.challenge)~=\"string\"or type(begin.expires)~=\"number\"then return false,\"invalid cloud login challenge\"end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(begin.authority),tostring(os.getComputerID()),tostring(begin.requestId),tostring(begin.challenge),tostring(begin.expires)},\"|\"))local result,resultErr=cloud.call(\"auth\",\"/v1/auth/login/proof\",{username=name,node=tostring(os.getComputerID()),requestId=begin.requestId,challenge=begin.challenge,proof=proof})if not result then return false,resultErr end local auth=require(\"ceetos.lib.auth\")local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require(\"ceetos.lib.auth\")local current=auth.refreshSession()if not current or not current.central then return false,\"cloud login is required\"end local result,err=cloud.call(\"auth\",\"/v1/auth/mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.recipePlan(item,quantity,stock)if not M.recipeOnline()then return nil,\"cloud Recipe Server is unavailable\"end local result,err=cloud.call(\"recipe\",\"/v1/recipe/plan\",{item=item,quantity=quantity,stock=stock})if not result then return nil,err end return result.plan,result.error end local function telemetry()local snapshot=telemetryService.snapshot()local net=require(\"ceetos.lib.net\")local transport=net.statusSnapshot and net.statusSnapshot().transport or{}snapshot.health={profile=profile.id(),version=require(\"ceetos.lib.version\").string,uptime=os.clock(),freeSpace=fs.getFreeSpace(\"/\"),peers=#(net.peers and net.peers()or{}),healthyLinks=transport and transport.healthyLinks or 0,lastError=M.status().lastError,}local result,err=cloud.call(\"dashboard\",\"/v1/telemetry/ingest\",snapshot)return result~=nil,err end local function syncAuth()if profile.is(\"auth-server\")then local auth=require(\"ceetos.lib.auth\")local snapshot=auth.authoritySnapshot()local pushed,pushErr=cloud.call(\"auth\",\"/v1/auth/replica/merge\",{snapshot=snapshot,source=\"mesh\"})if not pushed then return false,pushErr end if type(pushed.snapshot)==\"table\"then auth.merge(pushed.snapshot,true)end local ok,authErr=cloudAuthority(pushed)if not ok then return false,authErr end return true end local result,err=cloud.call(\"auth\",\"/v1/auth/directory\",{})if not result then return false,err end local ok,authErr=cloudAuthority(result)if not ok then return false,authErr end return true end local function syncRecipes()if not profile.is(\"recipe-server\")then local result,err=cloud.call(\"recipe\",\"/v1/recipe/status\",{})return result~=nil,err end local service=require(RECIPE_SERVICE_MODULE)if type(service.exportOverlay)~=\"function\"then return false,\"recipe export unavailable\"end local payload,exportErr=service.exportOverlay()if not payload then return false,exportErr end local value=state()value.recipe=value.recipe or{revision=0}local result,err=cloud.call(\"recipe\",\"/v1/recipe/replica/merge\",{overlay=payload,baseRevision=math.max(0,math.floor(tonumber(value.recipe.revision)or 0)),})if not result then return false,err end if type(result.overlay)==\"table\"and type(service.replaceOverlay)==\"function\"then local applied,applyErr=service.replaceOverlay(result.overlay)if not applied then return false,applyErr end end return true,nil,math.max(0,math.floor(tonumber(result.revision)or 0))end function M.tick(activity)local cfg=cloud.publicStatus();if not cfg.enabled or not cfg.enrolled then return false,\"cloud node is not enrolled\"end local value,timestamp=state(),now()local changed=false if timestamp>=(tonumber(value.auth.next)or 0)then local ok,err=syncAuth();value.auth.online,value.auth.next=ok==true,timestamp+INTERVALS.authority if not ok then errorState(value,err)else value.lastError=nil end changed=true end if timestamp>=(tonumber(value.recipe.next)or 0)then local ok,err,recipeRevision=syncRecipes();value.recipe.online,value.recipe.next=ok==true,timestamp+INTERVALS.recipes if recipeRevision~=nil then value.recipe.revision=recipeRevision end if not ok then errorState(value,err)end changed=true end local telemetryEnabled=telemetryService.status()if not telemetryEnabled then if value.telemetry.enabled~=false or value.telemetry.next~=0 then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=false,0,0,nil changed=true end elseif value.telemetry.enabled~=true then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=true,0,0,nil changed=true elseif timestamp>=(tonumber(value.telemetry.next)or 0)then local ok,err=telemetry()if ok then value.telemetry.next,value.telemetry.lastSuccess,value.telemetry.failures,value.telemetry.lastError=timestamp+INTERVALS.telemetry,timestamp,0,nil else local failures=math.max(0,math.floor(tonumber(value.telemetry.failures)or 0))+1 value.telemetry.failures,value.telemetry.lastError=failures,tostring(err or\"telemetry upload failed\"):sub(1,180)value.telemetry.next=timestamp+(TELEMETRY_RETRIES[failures]or INTERVALS.telemetry)errorState(value,value.telemetry.lastError)end changed=true end if changed then value.lastSync=timestamp;save(value)end return true end return M",
  ["ceetos/lib/version.lua"] = "return{major=0,minor=16,patch=6,string=\"0.16.6\"}",
  ["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);cloud=os.startTimer(5)end end end local function console()shell.run(\"/ceetos/bin/ceetserver.lua\")while true do sleep(1);shell.run(\"/ceetos/bin/ceetserver.lua\")end end local function devBridge()local path=\"/ceetos-dev/connection.lua\"while true do if fs.exists(\"/ceetos/bin/ceetdev.lua\")and fs.exists(path)then local handle=fs.open(path,\"r\")local cfg=handle and textutils.unserialise(handle.readAll())or nil if handle then handle.close()end if type(cfg)==\"table\"and type(cfg.url)==\"string\"then local token=type(cfg.token)==\"string\"and cfg.token or\"\"if token~=\"\"then pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url,token)else pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url)end sleep(3)else sleep(5)end else sleep(5)end end end parallel.waitForAny(service,console,devBridge)",
  ["ceetos/bin/ceetserver.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local version=require(\"ceetos.lib.version\")local store=require(\"ceetos.lib.store\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local function draw(message)term.setBackgroundColor(colors.black);term.setTextColor(colors.white);term.clear();term.setCursorPos(1,1)term.setBackgroundColor(colors.blue);term.clearLine();term.setCursorPos(2,1);term.write(\"CeetOS \"..profile.id()..\" server\")term.setBackgroundColor(colors.black);term.setCursorPos(2,3);term.write(\"Version: \"..version.string)local authority=auth.authority()term.setCursorPos(2,4);term.write(authority and(\"Auth authority: \"..authority.id)or\"Auth authority: distributed / waiting\")local current=auth.refreshSession()term.setCursorPos(2,6);term.write(current and(\"Signed in: \"..current.name..\" (\"..current.role..\")\")or\"Not signed in\")term.setTextColor(colors.lightGray);term.setCursorPos(2,8)if not current then term.write(\"L Login  |  E first-time enrolment  |  Backspace refresh\")elseif current.role==\"admin\"then local actions=recipe and\"I import pack  |  P pair  |  U updates\"or\"P pair  |  U updates\"term.write(actions..\"  |  L logout  |  Backspace refresh\")else term.write(\"L logout  |  Backspace refresh\")end if message then term.setTextColor(colors.red);term.setCursorPos(2,10);term.write(tostring(message):sub(1,48))end end local function login()term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Username: \");local user=read()term.setCursorPos(2,13);term.write(\"Password: \");local pass=read(\"*\")local ok,err=auth.login(user,pass);return ok and\"Logged in.\"or err end local function enrol()if#auth.list()>0 or auth.centralActive()then return\"Enrollment is already complete.\"end term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Create local admin password: \")local pass=read(\"*\")if type(pass)~=\"string\"or#pass<8 then return\"Enrollment password must contain at least 8 characters.\"end local ok,err=pcall(auth.bootstrap,pass)return ok and\"Enrollment complete.\"or err end local function importRecipePack(event)if not recipe then return\"This server has no recipe service.\"end if not auth.allowed(\"admin\")then return\"Recipe import requires an admin session.\"end local files=event and event.getFiles and event.getFiles()or nil if type(files)~=\"table\"or#files~=1 or type(files[1].read)~=\"function\"then return\"Drop exactly one data-only recipe pack.\"end local chunks,total={},0 while true do local part=files[1].read(4096)if not part then break end if type(part)~=\"string\"then return\"Dropped recipe pack has invalid data.\"end total=total+#part if total>64*1024 then return\"Recipe pack exceeds 64 KiB.\"end chunks[#chunks+1]=part end local ok,result=recipe.import(table.concat(chunks))if not ok then return tostring(result)end return\"Imported \"..tostring(result.imported or 0)..\" new recipes; conflicts kept.\"end local message while true do draw(message);message=nil local event,code=os.pullEventRaw()if event==\"key\"then local key=keys.getName(code)if key==\"l\"then if auth.refreshSession()then auth.logout();message=\"Logged out.\"else message=login()end elseif key==\"e\"then message=enrol()elseif key==\"backspace\"then elseif key==\"p\"and auth.allowed(\"admin\")then message=\"Use the Peers page on a desktop to pair; server pairing IPC is available to administrators.\"elseif key==\"u\"and auth.allowed(\"admin\")then message=\"Signed updates are managed locally; no remote apply is permitted.\"elseif key==\"i\"and recipe and auth.allowed(\"admin\")then message=\"Drop one recipe pack into this console.\"end elseif event==\"file_transfer\"then message=importRecipePack(code)end end",
}
local CEETOS_RELEASE_INSTALLER = true
local CEETOS_PROFILE = "router-server"

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

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

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

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

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

-- The installer is intentionally transactional while it runs, but retaining
-- a full tree backup after a successful install quickly exhausts small CC
-- drives. Durable data has already been copied, so remove the old tree.
if automated then
  -- The root startup launcher sees this marker and boots the freshly written
  -- runtime rather than replaying the installer. The runtime verifies its
  -- loaded version before clearing it.
  if not fs.exists("/ceetos-updates") then fs.makeDir("/ceetos-updates") end
  local marker = fs.open("/ceetos-updates/pending.lua", "w")
  if marker then marker.write("return {state='verify',version=" .. "0.16.6" .. ",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