refactor!: consolidate Lua registry sources and the Package API (#1498)

**This removes the following APIs:**
- `Package:check_new_version()`. Instead use the new `Package:get_latest_version()`.

**This has a breaking change in the following APIs:**
- `Package:get_installed_version()` now no longer takes a callback but instead returns the installed version or `nil` if
  not installed.

<details>
<summary>To handle these breaking changes in plugins, leverage the `mason.version` module, for example:</summary>

```lua
local mason_version = require("mason.version")
local registry = require("mason-registry")
local pkg = registry.get_package("rust-analyzer")

if mason_version.MAJOR_VERSION < 2 then
    -- before
    pkg:check_new_version(function (success, new_version)
        -- …
    end)
    pkg:get_installed_version(function (success, installed_version)
        -- …
    end)
else
    -- after
    local new_version = pkg:get_latest_version()
    local installed_version = pkg:get_installed_version()
fi
```

</details>

---

<details>
<summary>This change also introduces breaking changes for Lua registry sources, by consolidating the package schema with the
registry.</summary>

The following is an example of a package defined in a Lua registry, following the new schema:

```lua
local Pkg = require("mason-core.package")

return Pkg.new {
    schema = "registry+v1",
    name = "ripgrep",
    description = "ripgrep recursively searches directories for a regex pattern while respecting your gitignore.",
    homepage = "https://github.com/BurntSushi/ripgrep",
    licenses = { Pkg.License.MIT },
    languages = {},
    categories = {},
    source = {
        id = "pkg:mason/ripgrep@13.0.0",
        ---@param ctx InstallContext
        ---@param purl Purl
        install = function(ctx, purl)
            -- Arbitrary installation code.
        end,
    },
    bin = {
        rg = "./bin/rg",
    },
}
```

</details>

11 files changed, 145 insertions, 270 deletions

diff --git a/lua/mason-core/installer/context.lua b/lua/mason-core/installer/context.lua
index 21c9c26f..a991cd9f 100644
--- a/lua/mason-core/installer/context.lua
+++ b/lua/mason-core/installer/context.lua
@@ -202,7 +202,7 @@ function InstallContext.new(handle, opts)
     local cwd_manager = CwdManager.new(path.install_prefix())
     return setmetatable({
         cwd = cwd_manager,
-        spawn = ContextualSpawn.new(cwd_manager, handle, not handle.package:is_registry_spec()),
+        spawn = ContextualSpawn.new(cwd_manager, handle, false),
         handle = handle,
         package = handle.package, -- for convenience
         fs = ContextualFs.new(cwd_manager),
diff --git a/lua/mason-core/installer/init.lua b/lua/mason-core/installer/init.lua
index 994ab847..961c5c47 100644
--- a/lua/mason-core/installer/init.lua
+++ b/lua/mason-core/installer/init.lua
@@ -74,6 +74,7 @@ end
 ---@async
 ---@param context InstallContext
 function M.prepare_installer(context)
+    local installer = require "mason-core.installer.registry"
     return Result.try(function(try)
         local package_build_prefix = path.package_build_prefix(context.package.name)
         if fs.async.dir_exists(package_build_prefix) then
@@ -82,12 +83,7 @@ function M.prepare_installer(context)
         try(Result.pcall(fs.async.mkdirp, package_build_prefix))
         context.cwd:set(package_build_prefix)
 
-        if context.package:is_registry_spec() then
-            local registry_installer = require "mason-core.installer.registry"
-            return try(registry_installer.compile(context.handle.package.spec, context.opts))
-        else
-            return context.package.spec.install
-        end
+        return try(installer.compile(context.handle.package.spec, context.opts))
     end)
 end
 
diff --git a/lua/mason-core/installer/registry/init.lua b/lua/mason-core/installer/registry/init.lua
index e7c796e9..961e94ea 100644
--- a/lua/mason-core/installer/registry/init.lua
+++ b/lua/mason-core/installer/registry/init.lua
@@ -35,9 +35,10 @@ M.register_provider("nuget", _.lazy_require "mason-core.installer.registry.provi
 M.register_provider("opam", _.lazy_require "mason-core.installer.registry.providers.opam")
 M.register_provider("openvsx", _.lazy_require "mason-core.installer.registry.providers.openvsx")
 M.register_provider("pypi", _.lazy_require "mason-core.installer.registry.providers.pypi")
+M.register_provider("mason", _.lazy_require "mason-core.installer.registry.providers.mason")
 
 ---@param purl Purl
-local function get_provider(purl)
+function M.get_provider(purl)
     return Optional.of_nilable(PROVIDERS[purl.type]):ok_or(("Unknown purl type: %s"):format(purl.type))
 end
 
@@ -127,7 +128,7 @@ function M.parse(spec, opts)
         end
 
         ---@type InstallerProvider
-        local provider = try(get_provider(purl))
+        local provider = try(M.get_provider(purl))
         log.trace("Found provider for purl.", source.id)
         local parsed_source = try(provider.parse(source, purl, opts))
         log.trace("Parsed source for purl.", source.id, parsed_source)
@@ -213,16 +214,4 @@ function M.compile(spec, opts)
     end)
 end
 
----@async
----@param spec RegistryPackageSpec
-function M.get_versions(spec)
-    return Result.try(function(try)
-        ---@type Purl
-        local purl = try(Purl.parse(spec.source.id))
-        ---@type InstallerProvider
-        local provider = try(get_provider(purl))
-        return provider.get_versions(purl, spec.source)
-    end)
-end
-
 return M
diff --git a/lua/mason-core/installer/registry/providers/mason.lua b/lua/mason-core/installer/registry/providers/mason.lua
new file mode 100644
index 00000000..3490ebaa
--- /dev/null
+++ b/lua/mason-core/installer/registry/providers/mason.lua
@@ -0,0 +1,43 @@
+local Result = require "mason-core.result"
+local _ = require "mason-core.functional"
+
+local M = {}
+
+---@param source RegistryPackageSource
+---@param purl Purl
+function M.parse(source, purl)
+    if type(source.install) ~= "function" and type((getmetatable(source.install) or {}).__call) ~= "function" then
+        return Result.failure "source.install is not a function."
+    end
+
+    ---@class ParsedMasonSource : ParsedPackageSource
+    local parsed_source = {
+        purl = purl,
+        ---@type async fun(ctx: InstallContext, purl: Purl)
+        install = source.install,
+    }
+
+    return Result.success(parsed_source)
+end
+
+---@async
+---@param ctx InstallContext
+---@param source ParsedMasonSource
+function M.install(ctx, source)
+    ctx.spawn.strict_mode = true
+    return Result.pcall(source.install, ctx, source.purl)
+        :on_success(function()
+            ctx.spawn.strict_mode = false
+        end)
+        :on_failure(function()
+            ctx.spawn.strict_mode = false
+        end)
+end
+
+---@async
+---@param purl Purl
+function M.get_versions(purl)
+    return Result.failure "Unimplemented."
+end
+
+return M
diff --git a/lua/mason-core/package/init.lua b/lua/mason-core/package/init.lua
index 899370fa..4a7f3d70 100644
--- a/lua/mason-core/package/init.lua
+++ b/lua/mason-core/package/init.lua
@@ -10,13 +10,9 @@ local path = require "mason-core.path"
 local platform = require "mason-core.platform"
 local registry = require "mason-registry"
 
-local is_not_nil = _.complement(_.is_nil)
-local is_registry_schema_id = _.matches "^registry%+v[1-9]+$"
-local is_registry_spec = _.prop_satisfies(_.all_pass { is_not_nil, is_registry_schema_id }, "schema")
-
 ---@class Package : EventEmitter
 ---@field name string
----@field spec RegistryPackageSpec | PackageSpec
+---@field spec RegistryPackageSpec
 ---@field private handle InstallHandle The currently associated handle.
 local Package = setmetatable({}, { __index = EventEmitter })
 
@@ -47,15 +43,17 @@ Package.Cat = {
     Formatter = "Formatter",
 }
 
-local PackageMt = { __index = Package }
+---@alias PackageLicense string
 
----@class PackageSpec
----@field name string
----@field desc string
----@field homepage string
----@field categories PackageCategory[]
----@field languages PackageLanguage[]
----@field install async fun(ctx: InstallContext)
+---@type table<PackageLicense, PackageLicense>
+Package.License = setmetatable({}, {
+    __index = function(s, license)
+        s[license] = license
+        return s[license]
+    end,
+})
+
+local PackageMt = { __index = Package }
 
 ---@class RegistryPackageSourceVersionOverride : RegistryPackageSource
 ---@field constraint string
@@ -86,32 +84,24 @@ local PackageMt = { __index = Package }
 ---@field share table<string, string>?
 ---@field opt table<string, string>?
 
----@param spec PackageSpec | RegistryPackageSpec
+---@param spec RegistryPackageSpec
 local function validate_spec(spec)
     if platform.cached_features["nvim-0.11"] ~= 1 then
         return
     end
-    if is_registry_spec(spec) then
-        vim.validate("name", spec.name, "string")
-        vim.validate("description", spec.description, "string")
-        vim.validate("homepage", spec.homepage, "string")
-        vim.validate("licenses", spec.licenses, "table")
-        vim.validate("categories", spec.categories, "table")
-        vim.validate("languages", spec.languages, "table")
-        vim.validate("source", spec.source, "table")
-        vim.validate("bin", spec.bin, { "table", "nil" })
-        vim.validate("share", spec.share, { "table", "nil" })
-    else
-        vim.validate("name", spec.name, "string")
-        vim.validate("desc", spec.desc, "string")
-        vim.validate("homepage", spec.homepage, "string")
-        vim.validate("categories", spec.categories, "table")
-        vim.validate("languages", spec.languages, "table")
-        vim.validate("install", spec.install, "function")
-    end
+    vim.validate("schema", spec.schema, _.equals "registry+v1", "registry+v1")
+    vim.validate("name", spec.name, "string")
+    vim.validate("description", spec.description, "string")
+    vim.validate("homepage", spec.homepage, "string")
+    vim.validate("licenses", spec.licenses, "table")
+    vim.validate("categories", spec.categories, "table")
+    vim.validate("languages", spec.languages, "table")
+    vim.validate("source", spec.source, "table")
+    vim.validate("bin", spec.bin, { "table", "nil" })
+    vim.validate("share", spec.share, { "table", "nil" })
 end
 
----@param spec PackageSpec | RegistryPackageSpec
+---@param spec RegistryPackageSpec
 function Package.new(spec)
     validate_spec(spec)
     return EventEmitter.init(setmetatable({
@@ -241,67 +231,40 @@ function Package:get_receipt()
     return Optional.empty()
 end
 
----@param callback fun(success: boolean, version_or_err: string)
-function Package:get_installed_version(callback)
-    self:get_receipt()
-        :if_present(
+---@return string?
+function Package:get_installed_version()
+    return self:get_receipt()
+        :and_then(
             ---@param receipt InstallReceipt
             function(receipt)
-                if is_registry_schema_id(receipt.primary_source.type) then
-                    local resolve = _.curryN(callback, 2)
-                    Purl.parse(receipt.primary_source.id)
-                        :map(_.prop "version")
-                        :on_success(resolve(true))
-                        :on_failure(resolve(false))
-                else
-                    a.run(function()
-                        local version_checks = require "mason-core.package.version-check"
-                        return version_checks.get_installed_version(receipt, self:get_install_path()):get_or_throw()
-                    end, callback)
-                end
+                return Purl.parse(receipt.primary_source.id):map(_.prop "version"):ok()
             end
         )
-        :if_not_present(function()
-            callback(false, "Unable to get receipt.")
-        end)
+        :or_else(nil)
 end
 
----@param callback fun(success: boolean, result_or_err: NewPackageVersion)
-function Package:check_new_version(callback)
-    if self:is_registry_spec() then
-        self:get_installed_version(_.scheduler_wrap(function(success, installed_version)
-            if not success then
-                return callback(false, installed_version)
-            end
-            local resolve = _.curryN(callback, 2)
-            Result.try(function(try)
-                -- This is a bit goofy, but it's done to verify that a new version is supported by the
-                -- current platform (parse fails if it's not). We don't want to surface new versions that
-                -- are unsupported.
-                try(require("mason-core.installer.registry").parse(self.spec, {}))
+---@return string
+function Package:get_latest_version()
+    return Purl.parse(self.spec.source.id)
+        :map(_.prop "version")
+        :get_or_throw(("Unable to retrieve version from malformed purl: %s."):format(self.spec.source.id))
+end
 
-                ---@type Purl
-                local purl = try(Purl.parse(self.spec.source.id))
-                if purl.version and installed_version ~= purl.version then
-                    return {
-                        name = purl.name,
-                        current_version = installed_version,
-                        latest_version = purl.version,
-                    }
-                else
-                    return Result.failure "Package is not outdated."
-                end
-            end)
-                :on_success(resolve(true))
-                :on_failure(resolve(false))
-        end))
-    else
-        a.run(function()
-            local receipt = self:get_receipt():or_else_throw "Unable to get receipt."
-            local version_checks = require "mason-core.package.version-check"
-            return version_checks.get_new_version(receipt, self:get_install_path()):get_or_throw()
-        end, callback)
-    end
+---@param opts? PackageInstallOpts
+function Package:is_installable(opts)
+    return require("mason-core.installer.registry").parse(self.spec, opts or {}):is_success()
+end
+
+---@return Result # Result<string[]>
+function Package:get_all_versions()
+    local registry_installer = require "mason-core.installer.registry"
+    return Result.try(function(try)
+        ---@type Purl
+        local purl = try(Purl.parse(self.spec.source.id))
+        ---@type InstallerProvider
+        local provider = try(registry_installer.get_provider(purl))
+        return provider.get_versions(purl, self.spec.source)
+    end)
 end
 
 function Package:get_lsp_settings_schema()
@@ -314,11 +277,6 @@ function Package:get_lsp_settings_schema()
     return Optional.empty()
 end
 
----@return boolean
-function Package:is_registry_spec()
-    return is_registry_spec(self.spec)
-end
-
 function PackageMt.__tostring(self)
     return ("Package(name=%s)"):format(self.name)
 end
diff --git a/lua/mason-core/package/version-check.lua b/lua/mason-core/package/version-check.lua
deleted file mode 100644
index 66d9ad13..00000000
--- a/lua/mason-core/package/version-check.lua
+++ /dev/null
@@ -1,80 +0,0 @@
-local Result = require "mason-core.result"
-local cargo = require "mason-core.managers.cargo"
-local composer = require "mason-core.managers.composer"
-local gem = require "mason-core.managers.gem"
-local git = require "mason-core.managers.git"
-local github = require "mason-core.managers.github"
-local go = require "mason-core.managers.go"
-local log = require "mason-core.log"
-local luarocks = require "mason-core.managers.luarocks"
-local npm = require "mason-core.managers.npm"
-local pip3 = require "mason-core.managers.pip3"
-
----@param field_name string
-local function version_in_receipt(field_name)
-    ---@param receipt InstallReceipt
-    ---@return Result
-    return function(receipt)
-        return Result.success(receipt.primary_source[field_name])
-    end
-end
-
----@type table<InstallReceiptSourceType, async fun(receipt: InstallReceipt, install_dir: string): Result>
-local get_installed_version_by_type = {
-    ["npm"] = npm.get_installed_primary_package_version,
-    ["pip3"] = pip3.get_installed_primary_package_version,
-    ["gem"] = gem.get_installed_primary_package_version,
-    ["cargo"] = cargo.get_installed_primary_package_version,
-    ["composer"] = composer.get_installed_primary_package_version,
-    ["git"] = git.get_installed_revision,
-    ["go"] = go.get_installed_primary_package_version,
-    ["luarocks"] = luarocks.get_installed_primary_package_version,
-    ["github_release_file"] = version_in_receipt "release",
-    ["github_release"] = version_in_receipt "release",
-    ["github_tag"] = version_in_receipt "tag",
-}
-
----@class NewPackageVersion
----@field name string
----@field current_version string
----@field latest_version string
-
-local get_new_version_by_type = {
-    ["npm"] = npm.check_outdated_primary_package,
-    ["pip3"] = pip3.check_outdated_primary_package,
-    ["git"] = git.check_outdated_git_clone,
-    ["cargo"] = cargo.check_outdated_primary_package,
-    ["composer"] = composer.check_outdated_primary_package,
-    ["gem"] = gem.check_outdated_primary_package,
-    ["go"] = go.check_outdated_primary_package,
-    ["luarocks"] = luarocks.check_outdated_primary_package,
-    ["github_release_file"] = github.check_outdated_primary_package_release,
-    ["github_release"] = github.check_outdated_primary_package_release,
-    ["github_tag"] = github.check_outdated_primary_package_tag,
-}
-
----@param provider_mapping table<string, async fun(receipt: InstallReceipt, install_dir: string): Result>
-local function version_check(provider_mapping)
-    ---@param receipt InstallReceipt
-    ---@param install_dir string
-    return function(receipt, install_dir)
-        local check = provider_mapping[receipt.primary_source.type]
-        if not check then
-            return Result.failure(
-                ("Packages installed via %s does not yet support version check."):format(receipt.primary_source.type)
-            )
-        end
-        return check(receipt, install_dir)
-            :on_success(function(version)
-                log.debug("Version check", version)
-            end)
-            :on_failure(function(failure)
-                log.debug("Version check failed", tostring(failure))
-            end)
-    end
-end
-
-return {
-    get_installed_version = version_check(get_installed_version_by_type),
-    get_new_version = version_check(get_new_version_by_type),
-}
diff --git a/lua/mason-registry/sources/lua.lua b/lua/mason-registry/sources/lua.lua
index 1675f232..1ca88a8d 100644
--- a/lua/mason-registry/sources/lua.lua
+++ b/lua/mason-registry/sources/lua.lua
@@ -39,7 +39,7 @@ function LuaRegistrySource:get_all_package_names()
     return vim.tbl_keys(index)
 end
 
----@return PackageSpec[]
+---@return RegistryPackageSpec[]
 function LuaRegistrySource:get_all_package_specs()
     return _.filter_map(function(name)
         return Optional.of_nilable(self:get_package(name)):map(_.prop "spec")
diff --git a/lua/mason-registry/sources/util.lua b/lua/mason-registry/sources/util.lua
index 262cbef2..80d5f16f 100644
--- a/lua/mason-registry/sources/util.lua
+++ b/lua/mason-registry/sources/util.lua
@@ -15,18 +15,19 @@ function M.map_registry_spec(spec)
         return Optional.empty()
     end
 
-    -- XXX: this is for compatibilty with the PackageSpec structure
-    spec.desc = spec.description
     return Optional.of(spec)
 end
 
 ---@param buffer table<string, Package>
 ---@param spec RegistryPackageSpec
 M.hydrate_package = _.curryN(function(buffer, spec)
-    -- hydrate Pkg.Lang index
+    -- hydrate Pkg.Lang/License index
     _.each(function(lang)
         local _ = Pkg.Lang[lang]
     end, spec.languages)
+    _.each(function(lang)
+        local _ = Pkg.License[lang]
+    end, spec.licenses)
 
     local pkg = buffer[spec.name]
     if pkg then
diff --git a/lua/mason/api/command.lua b/lua/mason/api/command.lua
index 65c1ee84..38b1742b 100644
--- a/lua/mason/api/command.lua
+++ b/lua/mason/api/command.lua
@@ -163,30 +163,26 @@ end, {
             if not ok then
                 return {}
             end
-            if pkg:is_registry_spec() then
-                local a = require "mason-core.async"
-                local registry_installer = require "mason-core.installer.registry"
-                return a.run_blocking(function()
-                    return a.wait_first {
-                        function()
-                            return registry_installer
-                                .get_versions(pkg.spec --[[@as RegistryPackageSpec]])
-                                :map(
-                                    _.compose(
-                                        _.map(_.concat(arg_lead)),
-                                        _.map(_.strip_prefix(version)),
-                                        _.filter(_.starts_with(version))
-                                    )
+            local a = require "mason-core.async"
+            return a.run_blocking(function()
+                return a.wait_first {
+                    function()
+                        return pkg:get_all_versions()
+                            :map(
+                                _.compose(
+                                    _.map(_.concat(arg_lead)),
+                                    _.map(_.strip_prefix(version)),
+                                    _.filter(_.starts_with(version))
                                 )
-                                :get_or_else {}
-                        end,
-                        function()
-                            a.sleep(4000)
-                            return {}
-                        end,
-                    }
-                end)
-            end
+                            )
+                            :get_or_else {}
+                    end,
+                    function()
+                        a.sleep(4000)
+                        return {}
+                    end,
+                }
+            end)
         end
 
         local all_pkg_names = registry.get_all_package_names()
diff --git a/lua/mason/ui/components/main/package_list.lua b/lua/mason/ui/components/main/package_list.lua
index 455a8196..62d654af 100644
--- a/lua/mason/ui/components/main/package_list.lua
+++ b/lua/mason/ui/components/main/package_list.lua
@@ -57,18 +57,17 @@ local function ExpandedPackageInfo(state, pkg, is_installed)
         end),
         Ui.HlTextNode(_.map(function(line)
             return { p.Comment(line) }
-        end, _.split("\n", pkg.spec.desc))),
+        end, _.split("\n", pkg.spec.description))),
         Ui.EmptyLine(),
         Ui.Table(_.concat(
             _.filter(_.identity, {
                 is_installed and {
                     p.muted "installed version",
-                    pkg_state.version and p.Bold(pkg_state.version)
-                        or (pkg_state.is_checking_version and p.muted "Loading…" or p.muted "-"),
+                    pkg_state.version and p.Bold(pkg_state.version) or p.muted "-",
                 },
                 pkg_state.new_version and {
                     p.muted "latest version",
-                    p.muted(pkg_state.new_version.latest_version),
+                    p.muted(pkg_state.new_version),
                 },
                 {
                     p.muted "homepage",
@@ -154,18 +153,11 @@ local function PackageComponent(state, pkg, opts)
                 source = ("Deprecated since version %s"):format(pkg.spec.deprecation.since),
             }
         end),
-        Ui.When(pkg_state.is_checking_new_version, function()
-            return Ui.VirtualTextNode { p.Comment " checking for new version…" }
-        end),
         Ui.Keybind(settings.current.ui.keymaps.check_package_version, "CHECK_NEW_PACKAGE_VERSION", pkg),
         Ui.When(pkg_state.new_version ~= nil, function()
             return Ui.DiagnosticsNode {
-                message = ("new version available: %s -> %s"):format(
-                    pkg_state.new_version.current_version,
-                    pkg_state.new_version.latest_version
-                ),
+                message = ("new version available: %s -> %s"):format(pkg_state.version or "-", pkg_state.new_version),
                 severity = vim.diagnostic.severity.INFO,
-                source = pkg_state.new_version.name,
             }
         end),
         Ui.Node(opts.keybinds),
diff --git a/lua/mason/ui/instance.lua b/lua/mason/ui/instance.lua
index c8f7856b..92cfc587 100644
--- a/lua/mason/ui/instance.lua
+++ b/lua/mason/ui/instance.lua
@@ -42,15 +42,13 @@ end
 ---@field expanded_json_schemas table<string, boolean>
 ---@field has_expanded_before boolean
 ---@field has_transitioned boolean
----@field is_checking_new_version boolean
----@field is_checking_version boolean
 ---@field is_terminated boolean
 ---@field is_log_expanded boolean
 ---@field has_failed boolean
 ---@field latest_spawn string?
 ---@field linked_executables table<string, string>?
 ---@field lsp_settings_schema table?
----@field new_version NewPackageVersion?
+---@field new_version string?
 ---@field short_tailed_output string?
 ---@field tailed_output string[]
 ---@field version string?
@@ -212,8 +210,6 @@ local function create_initial_package_state()
         expanded_json_schemas = {},
         has_expanded_before = false,
         has_transitioned = false,
-        is_checking_new_version = false,
-        is_checking_version = false,
         is_terminated = false,
         is_log_expanded = false,
         has_failed = false,
@@ -300,20 +296,11 @@ end
 ---@param pkg Package
 local function hydrate_detailed_package_state(pkg)
     mutate_state(function(state)
-        state.packages.states[pkg.name].is_checking_version = true
         -- initialize expanded keys table
         state.packages.states[pkg.name].expanded_json_schema_keys["lsp"] = state.packages.states[pkg.name].expanded_json_schema_keys["lsp"]
             or {}
         state.packages.states[pkg.name].lsp_settings_schema = pkg:get_lsp_settings_schema():or_else(nil)
-    end)
-
-    pkg:get_installed_version(function(success, version_or_err)
-        mutate_state(function(state)
-            state.packages.states[pkg.name].is_checking_version = false
-            if success then
-                state.packages.states[pkg.name].version = version_or_err
-            end
-        end)
+        state.packages.states[pkg.name].version = pkg:get_installed_version()
     end)
 
     pkg:get_receipt():if_present(
@@ -443,29 +430,22 @@ end
 ---@async
 ---@param pkg Package
 local function check_new_package_version(pkg)
-    if get_state().packages.states[pkg.name].is_checking_new_version then
-        return
-    end
+    local installed_version = pkg:get_installed_version()
     mutate_state(function(state)
-        state.packages.states[pkg.name].is_checking_new_version = true
+        state.packages.states[pkg.name].version = installed_version
     end)
-    return a.wait(function(resolve, reject)
-        pkg:check_new_version(function(success, new_version)
-            mutate_state(function(state)
-                state.packages.states[pkg.name].is_checking_new_version = false
-                if success then
-                    state.packages.states[pkg.name].new_version = new_version
-                else
-                    state.packages.states[pkg.name].new_version = nil
-                end
-            end)
-            if success then
-                resolve(new_version)
-            else
-                reject(new_version)
-            end
+    local latest_version = pkg:get_latest_version()
+    if latest_version ~= installed_version and pkg:is_installable { version = latest_version } then
+        mutate_state(function(state)
+            state.packages.states[pkg.name].new_version = latest_version
         end)
-    end)
+        return true
+    else
+        mutate_state(function(state)
+            state.packages.states[pkg.name].new_version = nil
+        end)
+        return false
+    end
 end
 
 ---@async
@@ -511,16 +491,16 @@ local function check_new_visible_package_versions()
     end
 
     local sem = Semaphore.new(5)
-    a.wait_all(_.map(function(package)
+    a.wait_all(_.map(function(pkg)
         return function()
             local permit = sem:acquire()
-            local has_new_version = pcall(check_new_package_version, package)
+            local has_new_version = check_new_package_version(pkg)
             mutate_state(function(state)
                 state.packages.new_versions_check.current = state.packages.new_versions_check.current + 1
                 state.packages.new_versions_check.percentage_complete = state.packages.new_versions_check.current
                     / state.packages.new_versions_check.total
                 if has_new_version then
-                    table.insert(state.packages.outdated_packages, package)
+                    table.insert(state.packages.outdated_packages, pkg)
                 end
             end)
             permit:forget()