Builds, limits and errors

validate_code and commit build the game and run its unit tests. This section lists what a build accepts, the errors it answers, the limits of a test run, and the limits of a match.

Source files

• The crate root is /src/lib.rs. Without it the build fails with bw::no-crate-root.
• Every other Rust file is a module the crate declares with mod name;: /src/cards.rs for mod cards;, /src/cards/deck.rs for mod deck; inside cards. A file no mod reaches is warning bw::unused-file. A module only the tests declare, such as #[cfg(test)] mod tests;, is reached when the game has a #[test]. The build then compiles the tests too. The build reports bw::unused-file only when the game logic builds without an error and its tests compile.
• Paths use lowercase letters, digits and _, start with a letter or _, end in .rs, and are at most 8 directories deep.
• JSON the game logic reads goes in /src/data/. See Data files.
• The catalog of the game's default locale, such as /src/i18n/en.json, goes into the build too, so msg! can check each message against it (Log lines). A change to it builds the game again. The other locales' catalogs never do.
• At most 200 files, 256 KiB per file and 2 MiB in total, data files and the default catalog included.

write_file, patch_file and rename_file refuse a .rs path, a data file path or a size the build can never accept, with UNBUILDABLE_RUST_SOURCE. A change to the default catalog that takes the build sources over the file count or the total is refused the same way.

Catalogs

A game's catalogs, /src/i18n/<locale>.json, hold its messages in each locale. Their paths, limits and checks are in Translations.

Crates

A game may use exactly three crates: boardweaver_sdk, serde and serde_json. They are already in scope by name. Use serde's derive through the SDK:

use boardweaver_sdk::serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
#[serde(crate = "boardweaver_sdk::serde")]
struct Hand {
    cards: Vec<String>,
}

There is no Cargo.toml to edit. Write Rust 1.98.1, edition 2024.

Words the build refuses

The build refuses these words anywhere in a .rs file, tests included, even as your own names:

Also refused: mod inside a macro, #[path], #[should_panic], crate-level #![...] attributes other than allow, warn, deny, forbid, expect and doc, and brackets nested deeper than 256. The 'static lifetime is allowed.

Reading a build error

validate_code answers errors and warnings as text in the Rust compiler's format, with paths as you wrote them:

error[bw::refused]: a game may not declare a `static`
 --> /src/lib.rs:12:1
   |
12 | static COUNT: u32 = 0;
   | ^^^^^^
   = help: A game is a pure function of its state, the action and the seed, so nothing may outlive a call. Keep the value in a field of the match's state, or use a `const` or a function; for a lookup table, build a `BTreeMap` where you need it rather than caching it

Every bw::refused error ends with a help line that says what to write instead.

A failed commit answers BUILD_FAILED with the first 20 errors. Fix them from the top: later errors often follow from the first.

Tool errors

Test limits

Every build runs the unit tests with these limits:

bw::test-fuel names the test that ran out. Every step a test applies, and every bot call, uses fuel. Play fewer decisions or fewer games in that test, or split it into several tests.

Limits in a match

Each call to a game function has these limits:

A panic in the game logic is GAME_FAILED, with the panic message and any text the game logic printed. Each failure is recorded as a match error, which the game's studio lists.