Builds, limits and errors

validate_code and commit build the game and run its unit tests. This section lists what a build accepts, every error code an agent can meet, the limits of a test run, and the limits of a match.

Studio code editor

The studio's Code tab highlights Rust and saves each file automatically. After a save, Boardweaver builds the game logic, runs its unit tests, and bundles the client against the generated game types.

The build strip shows pending changes, running builds, errors and warnings. Expand it to read the diagnostics. Select a diagnostic with a file location to open that file. When Boardweaver cannot build, the strip shows a build error.

The editor does not let you rename or delete /src/lib.rs or /src/frontend.tsx. Create, rename and delete other Rust modules under /src/. The editor has no Rust autocomplete or formatting.

Run validate_code before you commit: only it type-checks the client.

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. The build reports it only when the game logic builds without an error and its tests compile.
• A module only the tests declare, such as #[cfg(test)] mod tests;, counts as reached when the game has a #[test]. The build then compiles the tests too.
• A .rs path uses lowercase letters, digits and _, starts each name with a letter or _, and sits at most 7 directories below /src/.
• JSON the game logic reads goes in /src/data/ (Data files).
• The build also reads the catalog of the game's default locale, such as /src/i18n/en.json, so it can check each msg! against it (Log lines). A change to that catalog builds the game again. A change to another locale's catalog does not.
• The build takes 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 change the build could never accept, with UNBUILDABLE_RUST_SOURCE: a .rs or data file path outside these rules, or a file, file count or total over these limits. A change to the default catalog counts toward the limits too.

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 uses 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:

The build also refuses 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. Boardweaver records each failure as a match error, which the game's studio lists.