class

Crowbar::Core::CorpusRunner

Inherits Reference < Object

Tier 1 Core Engine: Deterministic seed replay and crash regression verification runner operating under a strict <= 60-second watchdog budget.

Constructors

new(name : String = "Corpus Regression Gate", seeds : Array(CorpusSeed) = [] of CorpusSeed, deterministic_seeds : Array(UInt64) = [] of UInt64, base_seed : UInt64 = 42_u64, iterations : Int32 = 0, mutations_per_seed : Int32 = 0, rules : Array(Rule) = [] of Rule, expected_errors : Array(Exception.class) = [] of Exception.class, per_seed_timeout : Time::Span = DEFAULT_SEED_TIMEOUT, watchdog_budget : Time::Span = DEFAULT_WATCHDOG_BUDGET, watchdog_interval : Time::Span = DEFAULT_WATCHDOG_INTERVAL, auto_shrink : Bool = true, fail_fast : Bool = false, verify_determinism : Bool = false, execution : Proc(Buffer, Nil) | Nil = nil)

Instance methods

add_assertion(name : String = "assertion_#{@assertions.size + 1}", &block : Buffer -> Nil) : Nil

add_base64_seed(b64 : String, id : String | Nil = nil, seed : UInt64 | Nil = nil, mutations : Int32 = 0) : CorpusSeed

Registers a Base64-encoded crash reproducer or seed payload

add_crash_record(record : Campaign::CrashRecord) : CorpusSeed

Imports a CrashRecord (minimized or full reproducer) from a Campaign run

add_deterministic_seed(seed_val : UInt64) : Nil

Registers an explicit PRNG seed for deterministic mutation replay across corpus baselines

add_expected_error(err_class : Exception.class) : Nil

add_fixup

add_forbidden_error(err_class : Exception.class) : Nil

add_hex_seed(hex : String, id : String | Nil = nil, seed : UInt64 | Nil = nil, mutations : Int32 = 0) : CorpusSeed

Registers a hex-encoded crash reproducer or seed payload

add_invariant(name : String = "invariant_#{@invariants.size + 1}", &block : Buffer -> Bool) : Nil

add_replay(seed_val : UInt64, payload : Buffer | Bytes | String, id : String | Nil = nil, mutations : Int32 = 1) : CorpusSeed

Registers a deterministic (PRNG seed, baseline input) mutation replay pair

add_rule(rule : Rule) : Nil

add_scope(scope : Scope) : Nil

add_seed(payload : Buffer | Bytes | String, id : String | Nil = nil, seed : UInt64 | Nil = nil, mutations : Int32 = 0, replay_verbatim : Bool = true, expected_errors : Array(Exception.class) = [] of Exception.class) : CorpusSeed

Registers a corpus seed or crash reproducer for deterministic replay

assertions

assertions=(assertions : Array(Tuple(String, Proc(Buffer, Nil))))

auto_shrink

auto_shrink=(auto_shrink : Bool)

base_seed

base_seed=(base_seed : UInt64)

deterministic_seeds

deterministic_seeds=(deterministic_seeds : Array(UInt64))

execution

execution=(execution : Proc(Buffer, Nil) | Nil)

expected_error?(ex : Exception, seed_expected : Array(Exception.class) = [] of Exception.class) : Bool

expected_errors

expected_errors=(expected_errors : Array(Exception.class))

fail_fast

fail_fast=(fail_fast : Bool)

fixups

fixups=(fixups : Array(Proc(Buffer, Nil)))

forbidden_errors

forbidden_errors=(forbidden_errors : Array(Exception.class))

generate_deterministic_mutant(input : Buffer | Bytes | String, seed_val : UInt64, steps : Int32 = 1) : Tuple(Buffer, Array(String))

Generates the deterministic mutation of input for a given seed_val and step count

invariants

invariants=(invariants : Array(Tuple(String, Proc(Buffer, Bool))))

iterations

iterations=(iterations : Int32)

load_directory(dir_path : String, pattern : String = "*") : Int32

Deterministically loads corpus files from a directory (sorted lexicographically)

load_session(session : Session) : Int32

Loads corpus candidates and recorded session items from a persistent Crowbar::Session

mutations_per_seed

mutations_per_seed=(mutations_per_seed : Int32)

name

name=(name : String)

on_heartbeat

Telemetry and lifecycle callbacks

on_heartbeat=(on_heartbeat : Proc(Int32, Float64, Nil) | Nil)

Telemetry and lifecycle callbacks

on_regression

on_regression=(on_regression : Proc(SeedResult, Nil) | Nil)

on_seed_complete

on_seed_complete=(on_seed_complete : Proc(SeedResult, Nil) | Nil)

pattern

pattern=(pattern : Pattern)

per_seed_timeout

per_seed_timeout=(per_seed_timeout : Time::Span)

replay(seed_val : UInt64, input : Buffer | Bytes | String, steps : Int32 = 1) : SeedResult

Replays a single deterministic (seed, input) mutation on demand

rules

rules=(rules : Array(Rule))

run

Executes the full corpus regression gate under the <= 60s watchdog budget

run!

Executes the full corpus regression gate and raises RegressionError if not clean

scopes

scopes=(scopes : Array(Scope))

seeds

seeds=(seeds : Array(CorpusSeed))

timeout

timeout=(span : Time::Span) : Time::Span

verify_determinism

verify_determinism=(verify_determinism : Bool)

watchdog_budget

watchdog_budget=(budget : Time::Span) : Time::Span

Enforces the Inviolable 60-Second Watchdog Law (0 < budget <= 60s)

watchdog_interval

watchdog_interval=(watchdog_interval : Time::Span)