//! `aura-engine` — the headless, UI-agnostic reactive SoA engine.
//!
//! Delivered across cycles 0003-0004 — the harness and its deterministic run
//! loop:
//!
//! - [`Harness`] — the closed root graph that runs (a flat node array + an index
//!   edge table, topologically ordered) and its deterministic `run` loop: a
//!   k-way merge of timestamped sources (C3/C4) driven through a wired DAG of
//!   nodes, cycle by cycle, with freshness-gated recompute and the two firing
//!   policies (C5/C6) deciding when each node re-evaluates and what it holds.
//! - [`Edge`] / [`Target`] / [`SourceSpec`] — producer->consumer wiring,
//!   source->consumer wiring, and a declared source (its kind + target slots).
//! - [`BootstrapError`] — wiring faults caught once, at bootstrap (kind
//!   mismatch, bad index, directed cycle).
//!
//! Delivered in cycle 0009 — the run report surface:
//!
//! - [`RunMetrics`] / [`RunManifest`] / [`RunReport`] — the `(manifest, metrics)`
//!   pair C18 mandates per run, with [`RunReport::to_json`] for the structured
//!   C14 face;
//! - [`summarize`] — the post-run pure reduction over a run's recorded
//!   pip-equity + exposure streams into [`RunMetrics`]; [`f64_field`] bridges a
//!   recording sink's `Vec<Scalar>` rows to it.
//!
//! Orchestration families of the atomic sim unit
//! (`(topology + params + data-window + seed)`) ship along three of C12's axes: the
//! **grid** axis via [`sweep`] over a [`GridSpace`] into a [`SweepFamily`], the
//! **window** axis via [`walk_forward`] over a [`WindowRoller`] into a
//! [`WalkForwardResult`] (C12 axis 3: rolling in-sample/out-of-sample splits, the
//! in-sample optimize closure-supplied), and
//! the **seed** axis via [`monte_carlo`] over a seed set into an [`McFamily`]
//! (C12 axis 4: Monte-Carlo *is* a sweep over seeds; both drive one shared
//! disjoint-parallel executor). The **seed** input itself ships too:
//! [`SyntheticSpec`] is a seeded `Source` producer (`Fn(u64) -> impl Source`,
//! C12 seed-as-input) whose stream is fully seed-determined, making
//! [`RunManifest`]'s seed a live captured input; the atomic unit's `-> metrics`
//! reduction ships via [`summarize`].
//!
//! Still to come (subsequent cycles): the broker-independent position-event
//! output and downstream broker nodes (C10), the random param-sweep
//! orchestration axis, and registry lineage across a family.
//!
//! Visualization is never here: it is a downstream consumer node on the streams.

mod blueprint;
mod builder;
mod graph_model;
mod harness;
mod mc;
mod report;
mod sweep;
mod walkforward;

pub use blueprint::{
    BindError, Binder, BlueprintNode, CompileError, Composite, OutField, RandomBinder,
    Role, SweepBinder,
};
pub use builder::{BuildError, GraphBuilder, InPort, NodeHandle, OutPort, RoleHandle};
pub use graph_model::model_to_json;
pub use harness::{
    window_of, BootstrapError, Edge, FlatGraph, Harness, Source, SourceSpec, SplitMix64,
    SyntheticSpec, Target, VecSource,
};
pub use report::{
    derive_position_events, expected_max_of_normals, f64_field, inv_norm_cdf, join_on_ts,
    r_metrics_from_rs, summarize, summarize_r, ColumnarTrace, FamilySelection, JoinedRow,
    PositionAction, PositionEvent, RMetrics, RunManifest, RunMetrics, RunReport, SelectionMode,
};
pub use sweep::{
    sweep, GridSpace, ParamRange, RandomSpace, Space, SweepError, SweepFamily, SweepPoint,
};
pub use mc::{
    monte_carlo, r_bootstrap, resample_block, McAggregate, McDraw, McFamily, MetricStats,
    RBootstrap,
};
pub use walkforward::{
    param_stability, walk_forward, RollMode, WalkForwardError, WalkForwardResult,
    WindowBounds, WindowOutcome, WindowRoller, WindowRun,
};
// #29: re-export the core scalar vocabulary a Blueprint builder needs
// (SourceSpec.kind is a ScalarKind; sources/Recorder columns are Scalar /
// Firing / Timestamp) so a graph builder has one import surface, not two.
pub use aura_core::{Firing, NodeSchema, ParamSpec, PortSpec, Scalar, ScalarKind, Timestamp};

#[cfg(test)]
mod test_fixtures;

#[cfg(test)]
mod reexport_tests {
    // #29: the core scalar vocabulary a Blueprint builder needs is reachable
    // from aura-engine alone (crate::X == external aura_engine::X), so a
    // downstream author does not add a second aura-core import for ScalarKind.
    #[test]
    fn core_scalar_vocabulary_is_reexported_from_crate_root() {
        use crate::{Firing, Scalar, ScalarKind, Timestamp};
        let _k: ScalarKind = ScalarKind::F64;
        let _f: Firing = Firing::Any;
        let _s: Scalar = Scalar::f64(0.0);
        let _t: Timestamp = Timestamp(0);
    }
}