List data layers in load order with source timestamps and entry counts.

Re-index layers whose sources changed. force: a layer name, or 'all', to rebuild regardless.

Register a mod layer: an unpacked mod folder (containing Public/ and Mods/) or a .pak file. position: 1-based slot among mod layers (default: on top). The layer is indexed immediately.

Unregister a mod layer (base cannot be removed).

Resolve a stats entry (spell, status, passive, character, object, weapon, ...) through inheritance across the selected layers. Shows the using chain and, per field, the layer/source that set it.

Find stats entries whose name or any field contains text. type: SpellData, StatusData, PassiveData, Character, Object, Weapon, Armor, InterruptData... field: restrict to one field. defined_in: only entries that this layer itself defines or overrides (e.g. 'dnd55e' = what dnd55e adds).

Everything that mentions token (entry name, status, passive, GUID...) in stats, templates, progressions and lists.

What layer changes about stats entry NAME compared with the layers below it.

Look up a localization handle (e.g. h1a950eaag...), or search localized text.

Resolve a root template (MapKey GUID or Name) through its ParentTemplateId chain.

Progression nodes for a class/subclass (Name, e.g. 'Soulknife', or TableUUID), merged by node UUID so a higher layer's node replaces a lower one's.

Static game data by UUID or Name (highest layer wins): kind = ClassDescription (classes/subclasses, with ProgressionTableUUID), LevelMapSeries (e.g. SuperiorityDie, per-level values), ActionResourceDefinition (resources: MaxValue, ReplenishType), Feat. A partial key lists matches.

A spell/passive/skill list by UUID or Name (highest layer wins).

The visual/audio kit of a spell: effects, animations, sounds, icon - for reusing vanilla VFX.

Spells matching damage type / school / spell type (Target, Projectile, Shout, Zone...) / level / name keyword, with their visual kits - to borrow effects and animations for new spells.

Resolve an effect GUID: a MultiEffectInfo (the value of stats *Effect fields) with its component effect resources (names, bones, duration, looping, .lsfx file), or a single effect resource. Also lists the stats entries that use it.

Find effects by what they're called (e.g. 'Necrotic', 'Impact_BodyFX', 'Radiant_Beam'): MultiEffectInfos whose name, or any component effect's name, matches. Returns the GUID to put in a stats *Effect field, what matched, and sample spells/statuses already using it.

Is the game running, which Script Extender log belongs to this run, and the latest game state.

Run Lua inside the RUNNING game via Script Extender and return its printed output plus the return value (JSON). context: 'server' (game logic, Osi.*, Ext.Stats) or 'client' (UI/visuals). delay: seconds to wait first (e.g. for a cast or boost to resolve). The test harness, once staged, is available as the global BG3T. This executes code in the user's live game session.

Send one Script Extender console line to the running game (e.g. '!apofeature Barbarian_PersistentRage') and return the log lines it produced within wait seconds (max 60).

Tail the current game run's Script Extender runtime log, optionally only lines containing filter (e.g. '[Apotheosis]', 'error', 'FAILED').

Ground truth: compare a stats entry as the running game actually loaded it with the index's resolution for layers. Pick layers matching what's deployed. Shows each field as MATCH or DIFF.

HOT-LOAD a mod layer into the RUNNING game without restarting: mirrors its stats .txt files as loose files under /Data/Public/BG3DataHot_/, loads them with Ext.Stats.LoadStatsFile(…, true) (overwriting existing entries), Syncs every entry to the client, and (loca=True) pushes its English strings. files: only these stats files (e.g. ['Passive.txt']). Progressions/lists/templates can't be hot-loaded (restart with a pak). Test-only: don't save the game while relying on hot-loaded entries. Clean up with bg3_se_hot_clean.

Remove the loose hot-load folders (Data/Public/BG3DataHot_*) from the game install. Entries already hot-loaded stay in the running session until restart.

Reload Script Extender Lua (console reset): re-runs every loaded mod's Bootstrap scripts from its pak/loose files. Only affects mods that were loaded at game start.

What this machine looks like to bg3-data: Windows or WSL, the discovered game install (Steam library, GOG or configured), game exe, Divine.exe, the Larian user folder (Mods, modsettings.lsx, Script Extender logs), Script Extender presence, detected mod managers (Vortex, BG3 Mod Manager, in-game) and what they mean for hand-deployed paks, and each mod layer's deploy/enable state.

Pack a mod layer (Mods/ + Public/, via Divine), deploy the pak to the user Mods folder (refused while the game runs; previous pak backed up) and enable it in the active profile's modsettings.lsx after its dependencies. Works for any mod; no per-mod scripts. Re-run after a mod manager rewrites the load order.

Kill the game, optionally deploy a mod layer (its layers.json deploy command, else the built-in bg3_deploy), relaunch (Steam -applaunch, or the game exe for GOG/other installs; --skip-launcher -continueGame loads the NEWEST save) and wait until a host character is loaded. Unsaved progress is lost.

Grant the host exactly enough XP (from the layers' XPData) to reach levels more levels. The user then levels up in the UI, so every feature and spell is class-sourced; follow with bg3_level_check.

Compare the host with its class/subclass progressions up to its current level: passives added and removed, AddSpells lists (with the spell's source), ActionResource boosts, and this level's choices.

Test cases a mod layer defines (TOML under /tests/bg3, or layers.json tests), validated against the index (spells, statuses, templates, aliases).

Write the human test script (step-by-step reading script per level and case) to /docs/test-scripts/ and return it.

Set up one test case in the running game: preconditions (class level, spell learned through the class, not in combat), spawns, HP/status setup, host-first initiative, safety watch, event recorder. mode="script" cases are cast immediately. Then the user acts; finish with bg3_test_verify.

Evaluate the staged case's expectations (before/after snapshots + recorded events), report PASS/FAIL per check with its fidelity, then remove every spawn, test boost and applied status.

Run one auto/script case end to end: stage (real combat, host acts first), scripted cast, verify, cleanup. Effects come from recorded events; costs are checked against the spell's loaded UseCosts (a scripted cast never charges them). player-mode cases need bg3_test_stage + a hotbar cast instead.

Run every automated case for a level, one after another, and summarise: the cases assigned to build (see bg3_test_plan), or all of class_name's cases at that level. Lists the player-mode cases that still need a hotbar cast.

Static stats lint for a mod layer, before the game ever loads it: enum values (Cooldown, StatsFunctorContext, RemoveEvents, SpellFlags, TickType...) and functor/condition/boost names that no other layer uses (the engine silently drops what it doesn't know), plus missing referenced entries (statuses, unlocked spells/interrupts, using, containers) and unknown action resources.

Static progression checks for a mod layer: invalid node UUIDs (the game silently drops those nodes), selectors referencing lists no layer defines, and same table+level nodes from different layers (both load, so their choices/feats stack).

The step-by-step plan for a test build ([[build]] in the suite TOML): for every level the exact level-up choices (subclass, which spells, feat), chosen so every spell a test needs is learned by its test level, plus the tests that run there. Written to /docs/test-scripts/plan-.md.

Remove every test spawn, boost (tag BG3Test) and applied status, and stop recording.

Compare EVERY stats entry a mod layer defines with what the running game loaded (the engine drops invalid values silently). layers = what's deployed (default: all).

Where the Larian Toolkit expects this mod (Data/Projects, Mods, Public, Editor/Mods): present or missing, linked to the repo or a separate copy, file counts, and the meta.lsx version (mod.io readiness).

Compare the mod's Toolkit editor copy (dest='toolkit': /Data/Editor/Mods/; 'repo': /Editor/Mods/) with an export of its game-ready files: missing/extra objects and differing fields per file. Run before publishing; 0 problems = both copies say the same.

Generate the Toolkit editor copy (.stats for stats, .tbl for lists/progressions/resources/classes/ level maps/feats) from the mod's game-ready files. Existing editor UUIDs are kept. write=False is a dry run listing files, object counts and warnings; write=True writes them (dest 'toolkit' or 'repo'). Close the Toolkit first: it overwrites files it has open.