Mod API levels: refuse a mod made for a newer Horizon, list each version's level

Every function the game offers mods has the API level it arrived at
(crates/horizon-mods/src/api_level.rs): level 0 is the contract of
Horizon 0.2.67 and 0.2.68, level 1 adds render.set-minimap. A mod needs
the level of the newest function it imports, read from its component.

- The game refuses a mod that calls a function it doesn't have with
  "made for a newer Horizon (it uses ...): update Horizon to run it"
  instead of wasmtime's linking error.
- The registry index lists each mod version's level (api_level, read
  from the file by CI); check_file compares it when the entry has one,
  and the moved extras' installer takes the newest version this game
  can run.
- cargo horizon-mod check prints the level.
- The api_reference test fails until a new WIT function has a level.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-26 10:38:57 +01:00
parent 45bc45b396
commit 8cc8c6180d
17 changed files with 412 additions and 16 deletions
Generated
+24
View File
@@ -1443,6 +1443,7 @@ dependencies = [
"serde_json",
"sha2",
"toml",
"wasmparser",
"wasmtime",
"wit-component",
"wit-parser",
@@ -4147,6 +4148,28 @@ dependencies = [
"wit-parser",
]
[[package]]
name = "wast"
version = "254.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "febc59cde513fc8f39b8ffd487893723c555fdd024e2e3dc7d165181e6397ea0"
dependencies = [
"bumpalo",
"leb128fmt",
"memchr",
"unicode-width",
"wasm-encoder",
]
[[package]]
name = "wat"
version = "1.254.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7db96351e51a3a1bbe6812f029e1100b4d9a5e02161fb63104bd2271fc847e7e"
dependencies = [
"wast",
]
[[package]]
name = "wayland-backend"
version = "0.3.17"
@@ -5005,6 +5028,7 @@ dependencies = [
"wasm-encoder",
"wasm-metadata",
"wasmparser",
"wat",
"wit-parser",
]
+4
View File
@@ -46,6 +46,7 @@ impl Report {
"api": self.facts.api,
"side": self.facts.side,
"capabilities": self.facts.capabilities,
"api_level": self.facts.api_level,
"game": self.facts.game,
"requires": requires,
"sha256": self.sha256,
@@ -84,6 +85,9 @@ impl Report {
")\n {} bytes, SHA-256 {}, {signed}\n",
self.size, self.sha256
);
if let Some(level) = f.api_level {
out += &format!(" needs mod API level {level} or newer\n");
}
for c in &f.capabilities {
out += &format!(" may {}\n", c.describe());
}
+11 -11
View File
@@ -149,21 +149,21 @@ pub fn fetch_index() -> Result<Index, String> {
/// Installs `m` into the game folder `dir` (where `options.txt` is), for a
/// player whose extras were `e`: its newest version for this game that
/// wasn't taken down, checked against the index (size, SHA-256, signature,
/// manifest), as `horizon-mods/<id>.hmod`, turned on, with the extra's
/// settings in its storage unless the mod has its own already.
/// wasn't taken down and that this Horizon's mod API level runs, checked
/// against the index (size, SHA-256, signature, manifest), as
/// `horizon-mods/<id>.hmod`, turned on, with the extra's settings in its
/// storage unless the mod has its own already.
pub fn install(index: &Index, m: &Moved, e: &Extras, dir: &Path) -> Result<(), String> {
let project = index
.project(m.id)
.ok_or_else(|| format!("{} isn't in Horizon's registry yet", m.id))?;
let version = project
.versions
.iter()
.find(|v| {
v.game == horizon_core::version::VERSION_ID
&& index.revoked(&project.id, &v.file.sha256).is_none()
})
.ok_or_else(|| format!("{} has no version for this game", m.id))?;
let version = index
.installable(
project,
horizon_core::version::VERSION_ID,
horizon_mods::api_level::LEVEL,
)
.ok_or_else(|| format!("{} has no version this Horizon can run", m.id))?;
let mods = dir.join(crate::mod_list::DIR);
fs::create_dir_all(&mods).map_err(|e| format!("{}: {e}", mods.display()))?;
let target = mods.join(format!("{}.hmod", m.id));
+9 -2
View File
@@ -17,18 +17,25 @@ wasmtime = { version = "48.0.7", default-features = false, features = ["runtime"
# Turns a mod's core module into a component (cargo horizon-mod build, the tests).
wit-component = { version = "0.254", optional = true }
wit-parser = { version = "0.254", optional = true }
# The functions a mod imports, for its API level (src/api_level.rs): the game and the registry index.
wasmparser = { version = "0.254", optional = true }
# The registry index's checks (feature `index`): SHA-256, and minisign signatures (no dependencies of its own).
sha2 = { version = "0.10", optional = true }
minisign-verify = { version = "0.3", optional = true }
[dev-dependencies]
# A component made for a newer Horizon, from the WIT alone (tests/sandbox.rs).
wit-component = { version = "0.254", features = ["dummy-module"] }
wit-parser = "0.254"
[features]
# Loads and runs mods (the game's `mods` feature); without it only manifests,
# content and packaging. Off by default so builds that don't run mods (the
# game's tests and probes) skip wasmtime and cranelift.
runtime = ["dep:wasmtime"]
runtime = ["dep:wasmtime", "dep:wasmparser"]
pack = ["dep:wit-component", "dep:wit-parser"]
# The mod registry's index (docs/api/mod-index.md): the launcher, the registry server and its CI.
index = ["dep:sha2", "dep:minisign-verify"]
index = ["dep:sha2", "dep:minisign-verify", "dep:wasmparser"]
# Runs real mods: `cargo test -p horizon-mods --features runtime,pack`.
[[test]]
+151
View File
@@ -0,0 +1,151 @@
//! Mod API levels: which of the WIT contract's functions a Horizon has
//! (`docs/api/stability.md`). Every function the game offers mods has the
//! level it arrived at; a Horizon serves every level up to its [`LEVEL`].
//! A mod needs the level of the newest function it imports, so a mod that
//! calls a function this Horizon doesn't have is refused with "update
//! Horizon" instead of a linking error, and the registry lists each
//! version's level so the launcher can tell before it installs.
/// The newest level this Horizon serves.
pub const LEVEL: u32 = 1;
/// Every function the game offers mods, as `interface.function`, with its
/// level. Level 0 is the contract of Horizon 0.2.67 and 0.2.68. A new
/// function takes the next level and raises [`LEVEL`] (the `api_reference`
/// test fails until it is listed here).
pub const FUNCTIONS: [(&str, u32); 29] = [
("log.write", 0),
("game.get-player", 0),
("game.get-clock", 0),
("chat.show", 0),
("hud.set-panel", 0),
("hud.clear", 0),
("storage.get", 0),
("storage.set", 0),
("storage.delete", 0),
("command.run", 0),
("ui.open-screen", 0),
("ui.close-screen", 0),
("ui.set-settings", 0),
("input.claim-items", 0),
("input.register-key", 0),
("input.held", 0),
("input.poll", 0),
("input.claim-wheel", 0),
("input.mapping", 0),
("input.clicks-per-second", 0),
("render.set-hud", 0),
("render.gui-size", 0),
("render.shake", 0),
("render.set-corner", 0),
("render.clear-corner", 0),
("render.text-width", 0),
("render.frame-stats", 0),
("render.set-zoom", 0),
("render.set-minimap", 1),
];
/// A function's level; None for one this Horizon doesn't have.
pub fn level_of(function: &str) -> Option<u32> {
FUNCTIONS
.iter()
.find(|(name, _)| *name == function)
.map(|&(_, level)| level)
}
/// The level a mod needs, from the functions it imports (as [`imports`]
/// names them): its newest function's. A function this Horizon doesn't
/// know comes from a newer one, so it needs more than [`LEVEL`]; that
/// function is returned with it, for the message.
pub fn needed<'a>(imports: impl IntoIterator<Item = &'a str>) -> (u32, Option<&'a str>) {
let mut needed = (0, None);
for name in imports {
match level_of(name) {
Some(level) if level > needed.0 => needed = (level, Some(name)),
Some(_) => {}
None => return (LEVEL + 1, Some(name)),
}
}
needed
}
/// Why this Horizon can't run a mod that needs `level`, or None when it can.
pub fn too_new(level: u32, function: Option<&str>) -> Option<String> {
(level > LEVEL).then(|| {
let uses = function.map_or(String::new(), |f| format!(" (it uses {f})"));
format!("made for a newer Horizon{uses}: update Horizon to run it")
})
}
/// The functions a mod's component imports from Horizon (`horizon:mods/*`),
/// as `interface.function`, in the component's order.
#[cfg(any(feature = "runtime", feature = "index"))]
pub fn imports(wasm: &[u8]) -> Result<Vec<String>, String> {
use wasmparser::{
Parser, Payload, Validator, WasmFeatures, component_types::ComponentEntityType,
};
let types = Validator::new_with_features(WasmFeatures::all())
.validate_all(wasm)
.map_err(|e| format!("not a component: {e}"))?;
let types = types.as_ref();
let mut out = Vec::new();
for payload in Parser::new(0).parse_all(wasm) {
let Payload::ComponentImportSection(section) = payload.map_err(|e| e.to_string())? else {
continue;
};
for import in section {
let name = import.map_err(|e| e.to_string())?.name.name;
// `horizon:mods/render@0.1.0` → `render`.
let Some(interface) = name.strip_prefix("horizon:mods/") else {
continue;
};
let interface = interface.split('@').next().unwrap_or(interface);
let Some(item) = types.component_item_for_import(name) else {
continue;
};
if let ComponentEntityType::Instance(id) = item.ty {
for (function, export) in &types[id].exports {
if matches!(export.ty, ComponentEntityType::Func(_)) {
out.push(format!("{interface}.{function}"));
}
}
}
}
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn levels_are_listed_once_and_up_to_this_horizons() {
for (i, (name, level)) in FUNCTIONS.iter().enumerate() {
assert!(*level <= LEVEL, "{name}");
assert!(
FUNCTIONS[..i].iter().all(|(other, _)| other != name),
"{name} twice"
);
}
assert!(FUNCTIONS.iter().any(|&(_, level)| level == LEVEL));
}
#[test]
fn a_mod_needs_its_newest_function() {
assert_eq!(needed(["log.write", "hud.set-panel"]), (0, None));
assert_eq!(
needed(["log.write", "render.set-minimap", "hud.clear"]),
(1, Some("render.set-minimap"))
);
assert_eq!(
needed(["render.set-minimap", "render.set-sky"]),
(LEVEL + 1, Some("render.set-sky"))
);
assert_eq!(too_new(LEVEL, None), None);
assert_eq!(
too_new(LEVEL + 1, Some("render.set-sky")).as_deref(),
Some("made for a newer Horizon (it uses render.set-sky): update Horizon to run it")
);
}
}
+32 -1
View File
@@ -137,6 +137,11 @@ pub struct Version {
pub side: Option<Side>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub capabilities: Vec<Capability>,
/// The mod API level a mod's code needs ([`crate::api_level`]), read
/// from its file; none for content and other kinds, and in indexes
/// built before levels.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub api_level: Option<u32>,
/// The Minecraft version it is for.
pub game: String,
/// A modpack's mods, as its manifest lists them.
@@ -316,6 +321,21 @@ impl Index {
Ok(())
}
/// A project's newest version for Minecraft `game` that wasn't taken
/// down and that a Horizon serving mod API `level` can run (an unknown
/// level counts as runnable: the game still checks when it starts it).
pub fn installable<'a>(
&self,
project: &'a Project,
game: &str,
level: u32,
) -> Option<&'a Version> {
project.versions.iter().find(|v| {
v.game == game
&& v.api_level.is_none_or(|l| l <= level)
&& self.revoked(&project.id, &v.file.sha256).is_none()
})
}
pub fn project(&self, id: &str) -> Option<&Project> {
self.projects.iter().find(|p| p.id == id)
}
@@ -471,6 +491,8 @@ pub struct Facts {
pub side: Option<Side>,
/// In the manifest's order.
pub capabilities: Vec<Capability>,
/// The mod API level a mod's code needs, from the functions it imports.
pub api_level: Option<u32>,
/// The Minecraft version, when the file names one (a modpack does).
pub game: Option<String>,
pub requires: Vec<Requirement>,
@@ -487,6 +509,7 @@ impl Facts {
|| self.api != version.api
|| self.side != version.side
|| caps != listed
|| version.api_level.is_some() && self.api_level != version.api_level
|| self.game.as_ref().is_some_and(|g| *g != version.game)
|| self.requires != version.requires;
if !differs {
@@ -514,9 +537,17 @@ impl Facts {
pub fn inspect(kind: &Kind, path: &Path) -> Result<Facts, String> {
match kind {
Kind::Mod => {
let m = Package::read(path)?.manifest;
let Package { manifest: m, wasm } = Package::read(path)?;
crate::Content::read(path, &m)?;
let api_level = match wasm {
Some(wasm) => {
let functions = crate::api_level::imports(&wasm)?;
Some(crate::api_level::needed(functions.iter().map(String::as_str)).0)
}
None => None,
};
Ok(Facts {
api_level,
capabilities: m.capabilities,
id: Some(m.id),
version: Some(m.version),
@@ -283,6 +283,7 @@ fn version(entry: &Entry, v: &EntryVersion, src: &Sources) -> Result<Version, St
api: facts.api,
side: facts.side,
capabilities: facts.capabilities,
api_level: facts.api_level,
game: v.game.clone(),
requires: facts.requires,
file: File {
+33
View File
@@ -73,6 +73,15 @@ fn a_changed_file_key_or_manifest_is_refused() {
let e = check(&more_caps, "coords_hud", &hmod).unwrap_err();
assert!(e.contains("isn't what the index lists"), "{e}");
let mut other_level = index.clone();
other_level.projects[0].versions[0].api_level = Some(1);
let e = check(&other_level, "coords_hud", &hmod).unwrap_err();
assert!(e.contains("isn't what the index lists"), "{e}");
// An index built before levels lists none: the file still passes.
let mut no_level = index.clone();
no_level.projects[0].versions[0].api_level = None;
assert_eq!(check(&no_level, "coords_hud", &hmod), Ok(Trust::Verified));
let mut revoked = index.clone();
revoked.revoked.push(Revoked {
id: "coords_hud".into(),
@@ -163,3 +172,27 @@ fn resource_packs_need_a_pack_mcmeta() {
assert!(e.contains("plain path"), "{e}");
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn the_newest_version_this_horizon_runs_is_installed() {
let mut index = sample();
let mut newer = index.projects[0].versions[0].clone();
newer.version = "0.2.0".into();
newer.file.sha256 = "2".repeat(64);
newer.api_level = Some(crate::api_level::LEVEL + 1);
index.projects[0].versions.insert(0, newer);
let p = index.project("coords_hud").unwrap();
let pick = |level| {
index
.installable(p, "26.3", level)
.map(|v| v.version.as_str())
};
assert_eq!(pick(crate::api_level::LEVEL), Some("0.1.0"));
assert_eq!(pick(crate::api_level::LEVEL + 1), Some("0.2.0"));
assert_eq!(index.installable(p, "26.4", crate::api_level::LEVEL), None);
// No level listed: runnable as far as the index knows.
index.projects[0].versions[0].api_level = None;
let p = index.project("coords_hud").unwrap();
let v = index.installable(p, "26.3", 0).unwrap();
assert_eq!(v.version, "0.2.0");
}
+1
View File
@@ -5,6 +5,7 @@
//!
//! Nothing here runs unless a mod is installed and turned on: an empty
//! [`Mods`] makes no engine and every hook returns at once.
pub mod api_level;
pub mod content;
#[cfg(feature = "index")]
pub mod index;
+6
View File
@@ -327,6 +327,12 @@ impl Mods {
.map(|(name, _)| name.to_string())
.collect();
m.check_imports(imports.iter().map(String::as_str))?;
// A function this Horizon doesn't have: say so, not wasmtime's linking error.
let functions = crate::api_level::imports(wasm)?;
let (level, function) = crate::api_level::needed(functions.iter().map(String::as_str));
if let Some(why) = crate::api_level::too_new(level, function) {
return Err(why);
}
let data_dir = path
.parent()
.unwrap_or(Path::new("."))
@@ -302,3 +302,38 @@ fn every_capability_with_an_interface_is_in_the_contract() {
}
}
}
/// Every function the game offers (an interface some world imports and none
/// exports) has an API level, and the levels list nothing else.
#[test]
fn every_function_has_an_api_level() {
let mut resolve = Resolve::default();
let package = resolve.push_file(root().join(WIT)).unwrap();
let package = &resolve.packages[package];
let exported: Vec<_> = package
.worlds
.values()
.flat_map(|&w| resolve.worlds[w].exports.values())
.filter_map(|item| match item {
WorldItem::Interface { id, .. } => Some(*id),
_ => None,
})
.collect();
let mut offered = Vec::new();
for (name, &id) in &package.interfaces {
if !exported.contains(&id) {
for function in resolve.interfaces[id].functions.keys() {
offered.push(format!("{name}.{function}"));
}
}
}
for f in &offered {
assert!(
horizon_mods::api_level::level_of(f).is_some(),
"{f} has no level in crates/horizon-mods/src/api_level.rs: add it at the next level"
);
}
for (f, _) in horizon_mods::api_level::FUNCTIONS {
assert!(offered.iter().any(|o| o == f), "{f} isn't in the WIT");
}
}
@@ -29,6 +29,7 @@
"hud",
"chat"
],
"api_level": 0,
"game": "26.3",
"file": {
"name": "coords_hud-0.1.0.hmod",
+59
View File
@@ -193,6 +193,65 @@ fn undeclared_capabilities_are_refused() {
assert_eq!(mods.entries()[0].status, refused);
}
/// A mod calling a function this Horizon doesn't have is refused with
/// "update Horizon", not a linking error; the test mods' levels are read
/// from the functions they import.
#[test]
fn a_mod_for_a_newer_horizon_is_refused() {
use horizon_mods::api_level::{LEVEL, imports, needed};
use wit_parser::{ManglingAndAbi, Resolve};
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
let wit = std::fs::read_to_string(root.join("crates/horizon-mod-sdk/wit/horizon.wit"))
.unwrap()
.replace(
" set-minimap: func(minimap: option<minimap>);",
" set-minimap: func(minimap: option<minimap>);\n set-sky: func(on: bool);",
);
let mut resolve = Resolve::default();
let package = resolve.push_str("horizon.wit", &wit).unwrap();
let world = resolve
.select_world(&[package], Some("horizon-ui-mod"))
.unwrap();
let mut module = wit_component::dummy_module(&resolve, world, ManglingAndAbi::Standard32);
wit_component::embed_component_metadata(
&mut module,
&resolve,
world,
wit_component::StringEncoding::UTF8,
)
.unwrap();
let wasm = wit_component::ComponentEncoder::default()
.module(&module)
.unwrap()
.encode()
.unwrap();
let functions = imports(&wasm).unwrap();
assert!(functions.iter().any(|f| f == "render.set-sky"));
let dir = mods_dir().join("too_new");
std::fs::create_dir_all(&dir).unwrap();
let manifest = r#"
id = "too_new"
name = "Too New"
version = "0.1.0"
api = "0.1"
capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input"]
experimental = ["ui", "render", "input"]
"#;
std::fs::write(dir.join("horizon-mod.toml"), manifest).unwrap();
std::fs::write(dir.join("mod.wasm"), wasm).unwrap();
let mods = Mods::load(&[dir], |_| true, |_| false);
let refused = "made for a newer Horizon (it uses render.set-sky): update Horizon to run it";
assert_eq!(mods.entries()[0].status, Status::Failed(refused.into()));
let level = |file: &str| {
let wasm = Package::read(&mods_dir().join(file)).unwrap().wasm.unwrap();
needed(imports(&wasm).unwrap().iter().map(String::as_str)).0
};
assert_eq!(level("coords_hud.hmod"), 0);
// The UI guest shows a minimap (`render.set-minimap`).
assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL);
}
#[test]
fn vanilla_commands_win() {
let mods = Mods::load(
+4 -2
View File
@@ -21,7 +21,7 @@ Level: preview ([stability.md](stability.md)). Schema 1.
"license": "MIT", "source": "https://github.com/...", "icon": "https://...png", "key": "RWT...",
"versions": [{
"version": "0.1.0", "published": "2026-10-24", "changelog": "",
"api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "game": "26.3",
"api": "0.1", "side": "client", "capabilities": ["game-read", "hud", "chat"], "api_level": 0, "game": "26.3",
"file": { "name": "coords_hud-0.1.0.hmod", "url": "https://github.com/ludovic111/horizon-mods/releases/download/...",
"size": 438, "sha256": "e113...", "signature": "untrusted comment: ...\n...\ntrusted comment: ...\n...\n" }
}]
@@ -43,6 +43,7 @@ Level: preview ([stability.md](stability.md)). Schema 1.
| `versions` | Newest first, at least one. |
| `api` | A mod's API line (its manifest's `api`); a modpack's manifest format (`1`). |
| `side`, `capabilities` | A mod's, read from its manifest by CI, never typed by hand. |
| `api_level` | The mod API level a mod's code needs ([stability.md](stability.md#mod-api-levels)): its newest imported function's, read from the file by CI. Absent for content-only mods and in indexes built before levels. Installers take the newest version whose level the running game serves. |
| `game` | The Minecraft version it is for. |
| `requires` | A modpack's mods: `{ id, version, sha256 }`, each a version in this index with that hash. |
| `file` | A plain name with the kind's extension (`.hmod`, `.hpack`, `.zip`), an `https://` URL, the size (at most 64 MiB), the lowercase hex SHA-256, and the `.minisig` text when the project has a key. |
@@ -57,7 +58,8 @@ changing what one means, makes schema 2.
1. Its size and SHA-256 are the ones the entry lists, and it isn't revoked.
2. With a project key: its signature verifies with that key (minisign's prehashed and legacy signatures both).
3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities) and its
3. What the file says matches the entry: a mod's `horizon-mod.toml` (id, version, API, side, capabilities), its API
level when the entry lists one, and its
content's fence ([mods.md](../mods.md#content-mods-api-02)); a modpack's manifest (id, version, format, game,
mods); a resource pack's `pack.mcmeta`.
4. A kind this build can't install is refused with "this Horizon can't install a … yet".
+16
View File
@@ -34,6 +34,22 @@ Not breaking: a new function, interface, capability, command, endpoint, tool or
argument or JSON field (readers must ignore fields they don't know); a new WIT function or type (mods built earlier
don't import it); faster, or fixing behaviour to what the reference already says.
### Mod API levels
A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
level 0 is the contract of Horizon 0.2.67 and 0.2.68, level 1 adds `render.set-minimap`. A mod needs the level of
the newest function it imports (a component imports only the functions it calls). The level is read from the file,
never declared:
- the game refuses a mod that needs a function it doesn't have, with "made for a newer Horizon (it uses
render.set-minimap): update Horizon to run it", instead of a linking error;
- the registry's CI writes each mod version's level into the index (`api_level`), and installers take the newest
version the running game can run.
A pull request that adds a function lists it in `api_level.rs` at the next level and raises `LEVEL`; the
`api_reference` test fails until it does.
## Stability levels
Every part of an API has one level, shown in its reference and its surface page.
+6
View File
@@ -501,6 +501,12 @@ so the same rustc and `Cargo.lock` give the same file.
release cycle, so existing mods keep working while authors move.
- The manifest's `api` names the line it needs (`0.1`); the game refuses a
line it does not serve with a clear message.
- Within a line, each function has an API level, the one it arrived at
([stability](api/stability.md#mod-api-levels)). A mod needs the level of
the newest function it calls, read from its file: an older Horizon refuses
it with "made for a newer Horizon: update Horizon", and the registry lists
the level so installers take a version the game can run.
`cargo horizon-mod check` prints it ("needs mod API level 1 or newer").
- Horizon follows Minecraft releases; the mod API does not have to. Vanilla
concepts mods see (dimensions, block and item ids) are the game's own ids,
so a version port changes the data, not the API.
+19
View File
@@ -2560,6 +2560,11 @@ name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
dependencies = [
"foldhash 0.2.0",
"serde",
"serde_core",
]
[[package]]
name = "heck"
@@ -2706,6 +2711,7 @@ dependencies = [
"serde_json",
"sha2 0.10.9",
"toml 1.1.8+spec-1.1.0",
"wasmparser",
"zip",
]
@@ -6516,6 +6522,19 @@ dependencies = [
"web-sys",
]
[[package]]
name = "wasmparser"
version = "0.254.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c5ff8685b587722894b6f25958fc608d315b93b8d23647bfb567664e7006d757"
dependencies = [
"bitflags 2.13.2",
"hashbrown 0.17.1",
"indexmap",
"semver",
"serde",
]
[[package]]
name = "wayland-backend"
version = "0.3.17"