Module lab 

Deterministic lab runtime for testing.

The lab runtime provides:

• Virtual time (no wall-clock dependencies)
• Deterministic scheduling (same seed → same execution)
• Trace capture and replay
• Schedule exploration (DPOR-style)
• Test oracles for invariant verification
• Await point tracking for cancellation injection
• Integrated cancellation injection with oracle verification
• Chaos testing with configurable failure injection

Quick Start

use asupersync::lab::{LabConfig, LabRuntime};
use asupersync::types::Budget;

let mut runtime = LabRuntime::new(LabConfig::new(42));
let region = runtime.state.create_root_region(Budget::INFINITE);

let (task_id, _handle) = runtime
    .state
    .create_task(region, Budget::INFINITE, async { 42 })
    .expect("create task");

runtime.scheduler.lock().schedule(task_id, 0);
runtime.run_until_quiescent();

Chaos Testing

Enable chaos injection to stress-test error handling:

// Light chaos for CI (1% cancel, 5% delay)
let config = LabConfig::new(42).with_light_chaos();
let mut runtime = LabRuntime::new(config);

// ... run tests ...

// Check injection statistics
let stats = runtime.chaos_stats();
println!("Injections: {} delays, {} cancellations", stats.delays, stats.cancellations);

See the chaos module for detailed documentation on chaos testing.

Re-exports

pub use crate::util::StrictEntropyGuard;

pub use crate::util::disable_strict_entropy;

pub use crate::util::enable_strict_entropy;

pub use crate::util::strict_entropy_enabled;

pub use atp_lab::ATP_LAB_MODEL_SCHEMA_VERSION;

pub use atp_lab::AtpLabArtifact;

pub use atp_lab::AtpLabAttachment;

pub use atp_lab::AtpLabEvent;

pub use atp_lab::AtpLabFailure;

pub use atp_lab::AtpLabFault;

pub use atp_lab::AtpLabOracleConfig;

pub use atp_lab::AtpLabRegime;

pub use atp_lab::AtpLabReplayMetadata;

pub use atp_lab::AtpLabScenario;

pub use atp_lab::AtpLabTransferSpec;

pub use atp_lab::AtpTransferLabPlan;

pub use config::LabConfig;

pub use conformal::CalibrationReport;

pub use conformal::ConformalCalibrator;

pub use conformal::ConformalConfig;

pub use conformal::ConformityScore;

pub use conformal::CoverageTracker;

pub use conformal::PredictionSet;

pub use crashpack::ATP_CRASHPACK_SCHEMA_VERSION;

pub use crashpack::AtpCrashpack;

pub use crashpack::AtpEvidenceLedger;

pub use crashpack::AtpOracleResult;

pub use crashpack::AtpTransferOracle;

pub use crashpack::AtpTransferState;

pub use crashpack::CrashpackBuilder;

pub use crashpack::CrashpackError;

pub use crashpack::ReplayError;

pub use crashpack::TraceMinimizer;

pub use crashpack::TraceMinimizerConfig;

pub use crashpack::TransferOracle;

pub use crashpack::TransferOracleResult;

pub use crashpack::TransferState;

pub use crashpack::TransferViolation;

pub use crashpack::ViolationSeverity;

pub use deadlock_radar::DEADLOCK_RADAR_SCHEMA_VERSION;

pub use deadlock_radar::DeadlockRadarCandidate;

pub use deadlock_radar::DeadlockRadarEvidence;

pub use deadlock_radar::DeadlockRadarFinding;

pub use deadlock_radar::DeadlockRadarHazardClass;

pub use deadlock_radar::DeadlockRadarInterleavingStep;

pub use deadlock_radar::DeadlockRadarLockRank;

pub use deadlock_radar::DeadlockRadarProofStatus;

pub use deadlock_radar::DeadlockRadarReport;

pub use deadlock_radar::DeadlockRadarVerdict;

pub use deadlock_radar::run_deadlock_radar;

pub use dual_run::CancelTerminalPhase;

pub use dual_run::CancellationRecord;

pub use dual_run::CaptureAnnotation;

pub use dual_run::CaptureManifest;

pub use dual_run::ComparisonVerdict;

pub use dual_run::CounterTolerance;

pub use dual_run::DUAL_RUN_SCHEMA_VERSION;

pub use dual_run::DrainStatus;

pub use dual_run::DualRunHarness;

pub use dual_run::DualRunResult;

pub use dual_run::DualRunScenarioIdentity;

pub use dual_run::ExecutionInstanceId;

pub use dual_run::FieldObservability;

pub use dual_run::LiveExecutionProfile;

pub use dual_run::LiveRunMetadata;

pub use dual_run::LiveRunResult;

pub use dual_run::LiveRunnerConfig;

pub use dual_run::LiveWitnessCollector;

pub use dual_run::LoserDrainRecord;

pub use dual_run::NORMALIZED_OBSERVABLE_SCHEMA_VERSION;

pub use dual_run::NormalizedObservable;

pub use dual_run::NormalizedSemantics;

pub use dual_run::ObligationBalanceRecord;

pub use dual_run::OutcomeClass;

pub use dual_run::Phase;

pub use dual_run::PromotedExplorationScenario;

pub use dual_run::PromotedFuzzScenario;

pub use dual_run::RegionCloseRecord;

pub use dual_run::RegionState as DualRunRegionState;

pub use dual_run::ReplayMetadata;

pub use dual_run::ReplayPolicy;

pub use dual_run::ResourceSurfaceRecord;

pub use dual_run::RuntimeKind;

pub use dual_run::ScenarioFamilyId;

pub use dual_run::SeedLineageRecord;

pub use dual_run::SeedMode;

pub use dual_run::SeedPlan;

pub use dual_run::SemanticMismatch;

pub use dual_run::TerminalOutcome;

pub use dual_run::assert_dual_run_passes;

pub use dual_run::assert_semantics;

pub use dual_run::capture_cancellation;

pub use dual_run::capture_loser_drain;

pub use dual_run::capture_obligation_balance;

pub use dual_run::capture_region_close;

pub use dual_run::capture_terminal_from_result;

pub use dual_run::capture_terminal_outcome;

pub use dual_run::check_core_invariants;

pub use dual_run::compare_observables;

pub use dual_run::normalize_lab_observable;

pub use dual_run::normalize_lab_report;

pub use dual_run::normalize_live_observable;

pub use dual_run::promote_exploration_report;

pub use dual_run::promote_fuzz_finding;

pub use dual_run::promote_regression_case;

pub use dual_run::promote_regression_corpus;

pub use dual_run::run_live_adapter;

pub use explorer::CoverageMetrics;

pub use explorer::DporCoverageMetrics;

pub use explorer::DporExplorer;

pub use explorer::ExplorationReport;

pub use explorer::ExplorerConfig;

pub use explorer::RunResult;

pub use explorer::ScheduleExplorer;

pub use explorer::TopologyExplorer;

pub use explorer::ViolationReport;

pub use fixtures::E2eReport;

pub use fixtures::ExpectedOutcome;

pub use fixtures::PerformanceImpact;

pub use fixtures::ProofArtifactRef;

pub use fixtures::RegimeSummary;

pub use fixtures::RepairDecisionLog;

pub use fixtures::RepairRoiE2eHarness;

pub use fixtures::RepairRoiE2eResult;

pub use fixtures::RepairRoiE2eScenario;

pub use fixtures::TransferConfig;

pub use fixtures::TransferResult;

pub use fuzz::FuzzConfig;

pub use fuzz::FuzzFinding;

pub use fuzz::FuzzHarness;

pub use fuzz::FuzzRegressionCase;

pub use fuzz::FuzzRegressionCorpus;

pub use fuzz::FuzzReport;

pub use fuzz::fuzz_quick;

pub use http::RequestBuilder;

pub use http::RequestTrace;

pub use http::TestHarness;

pub use http::TraceEntry;

pub use http::VirtualClient;

pub use http::VirtualServer;

pub use injection::LabBuilder;

pub use injection::LabInjectionConfig;

pub use injection::LabInjectionReport;

pub use injection::LabInjectionResult;

pub use injection::LabInjectionRunner;

pub use injection::lab;

pub use instrumented_future::AwaitPoint;

pub use instrumented_future::CancellationInjector;

pub use instrumented_future::InjectionMode;

pub use instrumented_future::InjectionOutcome;

pub use instrumented_future::InjectionReport;

pub use instrumented_future::InjectionResult;

pub use instrumented_future::InjectionRunner;

pub use instrumented_future::InjectionStrategy;

pub use instrumented_future::InstrumentedFuture;

pub use instrumented_future::InstrumentedPollResult;

pub use meta::ALL_ORACLE_INVARIANTS;

pub use meta::BuiltinMutation;

pub use meta::MetaCoverageEntry;

pub use meta::MetaCoverageReport;

pub use meta::MetaReport;

pub use meta::MetaResult;

pub use meta::MetaRunner;

pub use meta::builtin_mutations;

pub use meta::invariant_from_violation;

pub use network::DeterministicNetwork;

pub use network::Fault as NetworkFault;

pub use network::JitterModel;

pub use network::LatencyModel;

pub use network::NetworkConditions;

pub use network::NetworkConfig;

pub use network::NetworkMetrics;

pub use network::NetworkTraceEvent;

pub use network::NetworkTraceKind;

pub use network::Packet;

pub use numa::NumaCachePressureInput;

pub use numa::NumaCachePressureProjection;

pub use numa::NumaPressureClass;

pub use numa::project_numa_cache_pressure;

pub use oracle::ActorLeakOracle;

pub use oracle::ActorLeakViolation;

pub use oracle::BayesFactor;

pub use oracle::DetectionModel;

pub use oracle::DeterminismOracle;

pub use oracle::DeterminismViolation;

pub use oracle::DownOrderOracle;

pub use oracle::DownOrderViolation;

pub use oracle::EProcess;

pub use oracle::EProcessConfig;

pub use oracle::EProcessMonitor;

pub use oracle::EValue;

pub use oracle::EvidenceEntry;

pub use oracle::EvidenceLedger;

pub use oracle::EvidenceLine;

pub use oracle::EvidenceStrength;

pub use oracle::EvidenceSummary;

pub use oracle::FinalizerId;

pub use oracle::FinalizerOracle;

pub use oracle::FinalizerViolation;

pub use oracle::LogLikelihoodContributions;

pub use oracle::LoserDrainOracle;

pub use oracle::LoserDrainViolation;

pub use oracle::MailboxOracle;

pub use oracle::MailboxViolation;

pub use oracle::MailboxViolationKind;

pub use oracle::MonitorResult;

pub use oracle::ObligationLeakOracle;

pub use oracle::ObligationLeakViolation;

pub use oracle::Oracle;

pub use oracle::OracleEntryReport;

pub use oracle::OracleReport;

pub use oracle::OracleStats;

pub use oracle::OracleSuite;

pub use oracle::OracleViolation;

pub use oracle::QuiescenceOracle;

pub use oracle::QuiescenceViolation;

pub use oracle::RegistryLeaseOracle;

pub use oracle::RegistryLeaseViolation;

pub use oracle::ReplyLinearityOracle;

pub use oracle::ReplyLinearityViolation;

pub use oracle::SupervisionOracle;

pub use oracle::SupervisionViolation;

pub use oracle::SupervisionViolationKind;

pub use oracle::SupervisorQuiescenceOracle;

pub use oracle::SupervisorQuiescenceViolation;

pub use oracle::TaskLeakOracle;

pub use oracle::TaskLeakViolation;

pub use oracle::TraceEventSummary;

pub use oracle::assert_deterministic;

pub use oracle::assert_deterministic_multi;

pub use replay::ExplorationFingerprintClass as ReplayExplorationFingerprintClass;

pub use replay::ExplorationReport as ReplayExplorationReport;

pub use replay::ExplorationRunSummary as ReplayExplorationRunSummary;

pub use replay::NormalizationResult;

pub use replay::ReplayValidation;

pub use replay::SporkExplorationReport;

pub use replay::SporkExplorationRunSummary;

pub use replay::TraceDivergence;

pub use replay::TraceSummary;

pub use replay::classify_fingerprint_classes;

pub use replay::compare_normalized;

pub use replay::explore_scenario_runner_seed_space;

pub use replay::explore_seed_space;

pub use replay::explore_spork_seed_space;

pub use replay::normalize_for_replay;

pub use replay::normalize_for_replay_with_config;

pub use replay::summarize_spork_reports;

pub use replay::traces_equivalent;

pub use runtime::AutoAdvanceTermination;

pub use runtime::HarnessAttachmentKind;

pub use runtime::HarnessAttachmentRef;

pub use runtime::LabConfigSummary;

pub use runtime::LabRunReport;

pub use runtime::LabRuntime;

pub use runtime::LabTraceCertificateSummary;

pub use runtime::SporkHarnessReport;

pub use runtime::VirtualTimeReport;

pub use scenario::CancellationSection;

pub use scenario::CancellationStrategy;

pub use scenario::ChaosSection;

pub use scenario::FaultAction;

pub use scenario::FaultEvent;

pub use scenario::IncludeRef;

pub use scenario::LabSection;

pub use scenario::LatencySpec;

pub use scenario::LinkConditions;

pub use scenario::NetworkPreset;

pub use scenario::NetworkSection;

pub use scenario::Participant;

pub use scenario::SCENARIO_SCHEMA_VERSION;

pub use scenario::Scenario;

pub use scenario::ValidationError as ScenarioValidationError;

pub use scenario_runner::ExplorationRunSummary;

pub use scenario_runner::FilteredOracleReport;

pub use scenario_runner::ScenarioExplorationResult;

pub use scenario_runner::ScenarioRunResult;

pub use scenario_runner::ScenarioRunner;

pub use scenario_runner::ScenarioRunnerError as FrankenLabRunnerError;

pub use scenario_runner::TraceCertificateSnapshot;

pub use snapshot_restore::RestorableSnapshot;

pub use snapshot_restore::RestoreError;

pub use snapshot_restore::SnapshotRestore;

pub use snapshot_restore::SnapshotStats;

pub use snapshot_restore::ValidationResult;

pub use spork_harness::HarnessError;

pub use spork_harness::ScenarioRunnerError;

pub use spork_harness::SporkAppHarness;

pub use spork_harness::SporkScenarioConfig;

pub use spork_harness::SporkScenarioResult;

pub use spork_harness::SporkScenarioRunner;

pub use spork_harness::SporkScenarioSpec;

pub use swarm_replay::SWARM_AGENT_RUN_SCHEMA_VERSION;

pub use swarm_replay::SWARM_CONTENTION_HEATMAP_LEDGER_SCHEMA_VERSION;

pub use swarm_replay::SWARM_FAILURE_MINIMIZER_SCHEMA_VERSION;

pub use swarm_replay::SWARM_HANDOFF_VERIFICATION_SCHEMA_VERSION;

pub use swarm_replay::SWARM_OPERATOR_COCKPIT_REPORT_SCHEMA_VERSION;

pub use swarm_replay::SWARM_PRESSURE_SCHEMA_VERSION;

pub use swarm_replay::SWARM_PRESSURE_TRACE_SUMMARY_SCHEMA_VERSION;

pub use swarm_replay::SWARM_PROOF_LANE_ATLAS_REPORT_SCHEMA_VERSION;

pub use swarm_replay::SWARM_PROOF_LANE_PLAN_SCHEMA_VERSION;

pub use swarm_replay::SWARM_REPLAY_SCHEMA_VERSION;

pub use swarm_replay::SWARM_WHAT_IF_PLAN_SCHEMA_VERSION;

pub use swarm_replay::SwarmAgentRunEvent;

pub use swarm_replay::SwarmAgentRunEventKind;

pub use swarm_replay::SwarmAgentRunForbiddenActions;

pub use swarm_replay::SwarmAgentRunScenario;

pub use swarm_replay::SwarmAgentRunSummary;

pub use swarm_replay::SwarmContentionHeatmapInput;

pub use swarm_replay::SwarmContentionHeatmapLedger;

pub use swarm_replay::SwarmContentionHeatmapVerdict;

pub use swarm_replay::SwarmContentionHotSpot;

pub use swarm_replay::SwarmContentionHotspotKind;

pub use swarm_replay::SwarmContentionLockMetric;

pub use swarm_replay::SwarmContentionSchedulerLaneMetric;

pub use swarm_replay::SwarmContentionSeverity;

pub use swarm_replay::SwarmDiskPressureLevel;

pub use swarm_replay::SwarmDiskPressureTransition;

pub use swarm_replay::SwarmFailureBundle;

pub use swarm_replay::SwarmFailureInvariantClass;

pub use swarm_replay::SwarmFailureMinimizerInput;

pub use swarm_replay::SwarmFailureMinimizerReport;

pub use swarm_replay::SwarmFailureMinimizerStopReason;

pub use swarm_replay::SwarmFailureMinimizerVerdict;

pub use swarm_replay::SwarmFailureReductionStep;

pub use swarm_replay::SwarmHandoffCapsule;

pub use swarm_replay::SwarmHandoffCommit;

pub use swarm_replay::SwarmHandoffDecision;

pub use swarm_replay::SwarmHandoffDirtyOwner;

pub use swarm_replay::SwarmHandoffDirtyPath;

pub use swarm_replay::SwarmHandoffInboxAck;

pub use swarm_replay::SwarmHandoffProofCommand;

pub use swarm_replay::SwarmHandoffReservation;

pub use swarm_replay::SwarmHandoffVerification;

pub use swarm_replay::SwarmHandoffVerifierReason;

pub use swarm_replay::SwarmOperatorCockpitInput;

pub use swarm_replay::SwarmOperatorCockpitMemoryDecision;

pub use swarm_replay::SwarmOperatorCockpitObligationVerdict;

pub use swarm_replay::SwarmOperatorCockpitOutcome;

pub use swarm_replay::SwarmOperatorCockpitProofLaneSummary;

pub use swarm_replay::SwarmOperatorCockpitReport;

pub use swarm_replay::SwarmPressureEvent;

pub use swarm_replay::SwarmPressureEventKind;

pub use swarm_replay::SwarmPressureLane;

pub use swarm_replay::SwarmPressureScenario;

pub use swarm_replay::SwarmPressureSummary;

pub use swarm_replay::SwarmPressureTraceAdmission;

pub use swarm_replay::SwarmPressureTraceCancellation;

pub use swarm_replay::SwarmPressureTraceCleanup;

pub use swarm_replay::SwarmPressureTraceDrainHotSpot;

pub use swarm_replay::SwarmPressureTraceHotRegion;

pub use swarm_replay::SwarmPressureTraceObligationLeakSuspect;

pub use swarm_replay::SwarmPressureTraceObligations;

pub use swarm_replay::SwarmPressureTraceQueueHotSpot;

pub use swarm_replay::SwarmPressureTraceQueuePressure;

pub use swarm_replay::SwarmPressureTraceRegionLifecycle;

pub use swarm_replay::SwarmPressureTraceSourceKind;

pub use swarm_replay::SwarmPressureTraceSummary;

pub use swarm_replay::SwarmPressureTraceTaskLifecycle;

pub use swarm_replay::SwarmPressureTraceVerdict;

pub use swarm_replay::SwarmProofLaneAdmissionDecision;

pub use swarm_replay::SwarmProofLaneAtlasAdmissionContext;

pub use swarm_replay::SwarmProofLaneAtlasReport;

pub use swarm_replay::SwarmProofLaneDecision;

pub use swarm_replay::SwarmProofLaneFallbackPolicy;

pub use swarm_replay::SwarmProofLaneFinding;

pub use swarm_replay::SwarmProofLaneFindingSeverity;

pub use swarm_replay::SwarmProofLanePeerReservationOverlapStatus;

pub use swarm_replay::SwarmProofLanePlan;

pub use swarm_replay::SwarmProofLaneRchProvenance;

pub use swarm_replay::SwarmProofLaneRequest;

pub use swarm_replay::SwarmProofLaneTargetDirIsolationStatus;

pub use swarm_replay::SwarmProofLaneTrappedCycleWitnessStatus;

pub use swarm_replay::SwarmRchWorkerEvent;

pub use swarm_replay::SwarmRchWorkerEventKind;

pub use swarm_replay::SwarmReplayAdmissionDecision;

pub use swarm_replay::SwarmReplayAdmissionDrainResult;

pub use swarm_replay::SwarmReplayAdmissionRecord;

pub use swarm_replay::SwarmReplayBudgetClass;

pub use swarm_replay::SwarmReplayError;

pub use swarm_replay::SwarmReplayEvent;

pub use swarm_replay::SwarmReplayEventKind;

pub use swarm_replay::SwarmReplayScenario;

pub use swarm_replay::SwarmReplayShrinkHint;

pub use swarm_replay::SwarmReplaySummary;

pub use swarm_replay::SwarmReplayTaskOutcome;

pub use swarm_replay::SwarmReplayTaskStatus;

pub use swarm_replay::SwarmWhatIfInputFreshness;

pub use swarm_replay::SwarmWhatIfPlan;

pub use swarm_replay::SwarmWhatIfPriority;

pub use swarm_replay::SwarmWhatIfRecommendation;

pub use swarm_replay::SwarmWhatIfScenario;

pub use swarm_replay::SwarmWhatIfStarvationRisk;

pub use swarm_replay::SwarmWhatIfWorkClass;

pub use swarm_replay::SwarmWhatIfWorkload;

pub use swarm_replay::build_swarm_contention_heatmap;

pub use swarm_replay::build_swarm_operator_cockpit_report;

pub use swarm_replay::build_swarm_proof_lane_atlas_report;

pub use swarm_replay::minimize_swarm_failure;

pub use swarm_replay::plan_swarm_admission_wave;

pub use swarm_replay::plan_swarm_proof_lane;

pub use swarm_replay::render_swarm_contention_heatmap_text;

pub use swarm_replay::render_swarm_failure_minimizer_text;

pub use swarm_replay::render_swarm_operator_cockpit_text;

pub use swarm_replay::render_swarm_pressure_trace_text;

pub use swarm_replay::render_swarm_proof_lane_agent_mail_summary;

pub use swarm_replay::render_swarm_proof_lane_atlas_report_json;

pub use swarm_replay::render_swarm_proof_lane_atlas_report_markdown;

pub use swarm_replay::run_swarm_agent_run_scenario;

pub use swarm_replay::run_swarm_pressure_scenario;

pub use swarm_replay::run_swarm_replay_scenario;

pub use swarm_replay::scheduler_feedback_metrics_from_swarm_replay;

pub use swarm_replay::summarize_swarm_agent_run_trace;

pub use swarm_replay::summarize_swarm_pressure_trace;

pub use swarm_replay::summarize_swarm_replay_trace;

pub use swarm_replay::summarize_swarm_trace_artifact_json;

pub use swarm_replay::verify_swarm_handoff_capsule;

pub use util::StackTraceConfig;

pub use util::capture_stack_trace;

pub use util::capture_stack_trace_default;

pub use util::capture_stack_trace_depth;

pub use util::capture_stack_trace_minimal;

pub use virtual_time_wheel::ExpiredTimer;

pub use virtual_time_wheel::VirtualTimerHandle;

pub use virtual_time_wheel::VirtualTimerWheel;

Modules

atp_lab

atp_path

ATP Path Graph lab harness for deterministic NAT/path validation.

chaos

Chaos testing configuration and injection hooks for the Lab runtime.

config

Configuration for the lab runtime.

conformal

Distribution-free conformal calibration for lab metrics.

crashpack

ATP transfer oracles and crashpack infrastructure.

deadlock_radar

Deterministic deadlock-radar evidence model.

dual_run

Dual-run scenario types for lab-vs-live differential testing.

explorer

DPOR-style schedule exploration engine.

fixtures

Lab test fixtures and E2e scenarios for deterministic testing.

fuzz

Deterministic fuzz harness for structured concurrency invariants.

http

Virtual HTTP components for deterministic testing.

injection

Cancellation injection integration with Lab runtime and Oracles.

instrumented_future

Instrumented future wrapper for await point tracking.

meta

Meta-testing infrastructure for verifying the test oracles themselves.

network

Deterministic network simulation for distributed testing.

numa

Deterministic NUMA-aware pressure projection for artifact-cache lab runs.

opportunity

Opportunity scoring and performance PR gate logic.

oracle

Test oracles for verifying runtime invariants.

replay

Replay and diff utilities for trace analysis.

runtime

Lab runtime for deterministic execution.

scenario

FrankenLab scenario format (bd-1hu19.1).

scenario_runner

Scenario runner for FrankenLab deterministic testing (bd-1hu19.2).

snapshot_restore

Snapshot/restore functionality with quiescence proof.

spork_harness

Integrated Spork application test harness.

swarm_replay

Deterministic swarm replay scenarios for multi-agent pressure tests.

util

Utility modules for the lab runtime.

virtual_time_wheel

Virtual time wheel for deterministic Lab runtime.