--:Minify:--
local args = {...}
local kernel = args[1]
kernel._G = _G


local function readonly(tbl)
    return setmetatable({}, {
        __index = function(_, key)
            local value = tbl[key]
            if type(value) == "table" then return readonly(value) end
            return value
        end,

        __newindex = function(t, k, v)
            if kernel.config.allowGlobalOverwrites or
                kernel.allowGlobalOverwrites then
                rawset(tbl, k, v)
                return
            end
            error("Attempt to modify global variable '" .. k .. "'", 2)
        end,

        __pairs = function(self)
            local function iter(_, key)
                local nextKey, value = next(tbl, key)
                if type(value) == "table" then
                    value = readonly(value)
                end
                return nextKey, value
            end
            return iter, self, nil
        end,

        __ipairs = function()
            local i = 0
            return function()
                i = i + 1
                local value = tbl[i]
                if value == nil then return end
                if type(value) == "table" then
                    value = readonly(value)
                end
                return i, value
            end
        end,

        __len = function() return #tbl end,

        __metatable = false
    })
end
local origLoad = load

kernel._U = readonly(kernel._G)
kernel._U._G = kernel._U
kernel._U.load = function(a,b,c,d) return origLoad(a,b,c,d or kernel._U) end

function kernel.freshUserEnv()
    local locals = {}
    locals.syscall = _makeSyscallProxy()

    local env = setmetatable(locals, {
        __index    = kernel._U,
        __newindex = function(_, k, v) rawset(locals, k, v) end,
        __metatable=false
    })

    locals._G   = env
    locals.load = function(a, b, c, d) return origLoad(a, b, c, d or env) end

    return env
end