63 lines
3.5 KiB
Rust
63 lines
3.5 KiB
Rust
//! source2rosetta — library crate: the reusable derivation/verification engine behind the CLI.
|
|
//!
|
|
//! The `source2rosetta` binary (`src/main.rs`) is a thin clap front-end over these modules. Keeping the
|
|
//! logic in a library lets the CI pipeline (and tests) link and call it directly instead of shelling
|
|
//! out and scraping stdout.
|
|
//!
|
|
//! # Supported API surface
|
|
//! A fork or embedder calls into these. Every engine entry point that needs game-specific knowledge takes
|
|
//! an explicit `&profile::GameProfile` — there is NO process-global, so CS2 and Dota can be derived in the
|
|
//! same process. (`classify_change_cmd` is the one exception, and takes none because it needs none: it
|
|
//! compares two builds of one named library and reads nothing game-specific.)
|
|
//! - [`pipeline`] — the pure OFFLINE derivation engine (nothing here attaches to a running server):
|
|
//! `corpus_model_cmd` (distill the corpus model, taking a [`pipeline::ClassScope`]), `fold_model_cmd`
|
|
//! (roll model N → N+1, over a [`pipeline::CorpusModel`] that [`pipeline::load_model`] reads off disk —
|
|
//! the only way to build its first argument), `backfill_cmd` (cross-build name/offset timelines). The
|
|
//! derive that consumes a corpus source is reached through `produce::produce_cmd`, which builds one
|
|
//! internally from its `--corpus` / `--corpus-model` arguments — `CorpusSource` itself is crate-private.
|
|
//! - [`produce`] — CI orchestration + the LIVE half (everything that drives a running server): `produce_cmd`
|
|
//! (the whole per-game build — boots its own bots server for validate-live + typed netvars when a game is
|
|
//! given), `integration_test_cmd` (the standalone live oracle), `classify_change_cmd` / `filter_corpus_cmd`
|
|
//! (the CI branch primitives), `unpack_seed`.
|
|
//! - [`profile`] — the per-game knobs: [`profile::GameProfile`] plus the `CS2` / `DOTA` consts. Adding a game is a const here.
|
|
//! - [`model`] / [`render`] (re-exported from `source2rosetta-core`) — the canonical derived-gamedata model and its
|
|
//! format emitters; the standalone `source2rosetta-gen` binary links just `core`.
|
|
//!
|
|
//! # Low-level engine (implementation detail)
|
|
//! The modules below are the building blocks the API composes (ELF/RTTI/SchemaSystem readers, the fingerprint
|
|
//! metric, the sig/abi machinery, the data-parallel primitive). They stay `pub` for the fuzz harness and
|
|
//! advanced embedders, but carry NO stability promise — treat them as internal. The name taxonomy is NOT
|
|
//! among them: it is crate-private, because the knob a fork retunes is the `GameProfile` vocabulary block
|
|
//! those predicates read, not the predicates.
|
|
|
|
// ---- supported API ----
|
|
pub mod pipeline;
|
|
pub mod produce;
|
|
pub mod profile;
|
|
|
|
// ---- low-level engine (implementation detail; `pub` only for the fuzz harness, not a stable surface) ----
|
|
pub mod abi;
|
|
pub mod concmd;
|
|
pub mod elf;
|
|
pub mod emit;
|
|
pub mod fingerprint;
|
|
pub mod live;
|
|
pub mod locate;
|
|
pub mod par;
|
|
pub mod prototypes;
|
|
pub mod pulse;
|
|
pub mod rtti;
|
|
pub mod schema;
|
|
pub mod sig;
|
|
pub mod valvetab;
|
|
pub mod vscript;
|
|
pub mod xref;
|
|
|
|
// ---- crate-private ----
|
|
// The name taxonomy: every item is `pub(crate)`, so publishing the module published an empty page. The
|
|
// per-game vocabulary it reads is the fork-retunable part, and that is already `pub` on `GameProfile`.
|
|
mod taxonomy;
|
|
|
|
// The canonical model + emitters live in the deriver-free `source2rosetta-core` crate; re-export them so
|
|
// existing `source2rosetta::{model, render}` paths keep resolving.
|
|
pub use source2rosetta_core::{model, render};
|