diff --git a/ClockReceiver/JustInTime.hpp b/ClockReceiver/JustInTime.hpp
index 6d5a89583..35edfae7f 100644
--- a/ClockReceiver/JustInTime.hpp
+++ b/ClockReceiver/JustInTime.hpp
@@ -10,6 +10,7 @@
 #define JustInTime_h
 
 #include "../Concurrency/AsyncTaskQueue.hpp"
+#include "ClockingHintSource.hpp"
 #include "ForceInline.hpp"
 
 /*!
@@ -24,29 +25,69 @@
 
 	If the held object implements get_next_sequence_point() then it'll be used to flush implicitly
 	as and when sequence points are hit. Callers can use will_flush() to predict these.
+
+	If the held object is a subclass of ClockingHint::Source, this template will register as an
+	observer and potentially stop clocking or stop delaying clocking until just-in-time references
+	as directed.
+
+	TODO: incorporate and codify AsyncJustInTimeActor.
 */
-template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = HalfCycles, class TargetTimeScale = LocalTimeScale> class JustInTimeActor {
+template <class T, class LocalTimeScale = HalfCycles, int multiplier = 1, int divider = 1> class JustInTimeActor:
+	public ClockingHint::Observer {
 	private:
+		/*!
+			A std::unique_ptr deleter which causes an update_sequence_point to occur on the actor supplied
+			to it at construction if it implements get_next_sequence_point(). Otherwise destruction is a no-op.
+
+			**Does not delete the object.**
+
+			This is used by the -> operators below, which provide a unique pointer to the enclosed object and
+			update their sequence points upon its destruction — i.e. after the caller has made whatever call
+			or calls as were relevant to the enclosed object.
+		*/
 		class SequencePointAwareDeleter {
 			public:
-				explicit SequencePointAwareDeleter(JustInTimeActor<T, multiplier, divider, LocalTimeScale, TargetTimeScale> *actor) : actor_(actor) {}
+				explicit SequencePointAwareDeleter(JustInTimeActor<T, LocalTimeScale, multiplier, divider> *actor) noexcept
+					: actor_(actor) {}
 
-				void operator ()(const T *const) const {
+				forceinline void operator ()(const T *const) const {
 					if constexpr (has_sequence_points<T>::value) {
 						actor_->update_sequence_point();
 					}
 				}
 
 			private:
-				JustInTimeActor<T, multiplier, divider, LocalTimeScale, TargetTimeScale> *const actor_;
+				JustInTimeActor<T, LocalTimeScale, multiplier, divider> *const actor_;
 		};
 
+		// This block of SFINAE determines whether objects of type T accepts Cycles or HalfCycles.
+		using HalfRunFor = void (T::*const)(HalfCycles);
+		static uint8_t half_sig(...);
+		static uint16_t half_sig(HalfRunFor);
+		using TargetTimeScale =
+			std::conditional_t<
+				sizeof(half_sig(&T::run_for)) == sizeof(uint16_t),
+				HalfCycles,
+				Cycles>;
+
 	public:
 		/// Constructs a new JustInTimeActor using the same construction arguments as the included object.
-		template<typename... Args> JustInTimeActor(Args&&... args) : object_(std::forward<Args>(args)...) {}
+		template<typename... Args> JustInTimeActor(Args&&... args) : object_(std::forward<Args>(args)...) {
+			if constexpr (std::is_base_of<ClockingHint::Source, T>::value) {
+				object_.set_clocking_hint_observer(this);
+			}
+		}
 
 		/// Adds time to the actor.
-		forceinline void operator += (LocalTimeScale rhs) {
+		///
+		/// @returns @c true if adding time caused a flush; @c false otherwise.
+		forceinline bool operator += (LocalTimeScale rhs) {
+			if constexpr (std::is_base_of<ClockingHint::Source, T>::value) {
+				if(clocking_preference_ == ClockingHint::Preference::None) {
+					return false;
+				}
+			}
+
 			if constexpr (multiplier != 1) {
 				time_since_update_ += rhs * multiplier;
 			} else {
@@ -54,20 +95,29 @@ template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = H
 			}
 			is_flushed_ = false;
 
+			if constexpr (std::is_base_of<ClockingHint::Source, T>::value) {
+				if (clocking_preference_ == ClockingHint::Preference::RealTime) {
+					flush();
+					return true;
+				}
+			}
+
 			if constexpr (has_sequence_points<T>::value) {
 				time_until_event_ -= rhs;
 				if(time_until_event_ <= LocalTimeScale(0)) {
 					flush();
-					update_sequence_point();
+					return true;
 				}
 			}
+
+			return false;
 		}
 
 		/// Flushes all accumulated time and returns a pointer to the included object.
 		///
 		/// If this object provides sequence points, checks for changes to the next
 		/// sequence point upon deletion of the pointer.
-		forceinline auto operator->() {
+		[[nodiscard]] forceinline auto operator->() {
 			flush();
 			return std::unique_ptr<T, SequencePointAwareDeleter>(&object_, SequencePointAwareDeleter(this));
 		}
@@ -75,19 +125,19 @@ template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = H
 		/// Acts exactly as per the standard ->, but preserves constness.
 		///
 		/// Despite being const, this will flush the object and, if relevant, update the next sequence point.
-		forceinline auto operator -> () const {
-			auto non_const_this = const_cast<JustInTimeActor<T, multiplier, divider, LocalTimeScale, TargetTimeScale> *>(this);
+		[[nodiscard]] forceinline auto operator -> () const {
+			auto non_const_this = const_cast<JustInTimeActor<T, LocalTimeScale, multiplier, divider> *>(this);
 			non_const_this->flush();
 			return std::unique_ptr<const T, SequencePointAwareDeleter>(&object_, SequencePointAwareDeleter(non_const_this));
 		}
 
 		/// @returns a pointer to the included object, without flushing time.
-		forceinline T *last_valid() {
+		[[nodiscard]] forceinline T *last_valid() {
 			return &object_;
 		}
 
 		/// @returns the amount of time since the object was last flushed, in the target time scale.
-		forceinline TargetTimeScale time_since_flush() const {
+		[[nodiscard]] forceinline TargetTimeScale time_since_flush() const {
 			// TODO: does this handle conversions properly where TargetTimeScale != LocalTimeScale?
 			if constexpr (divider == 1) {
 				return time_since_update_;
@@ -113,7 +163,7 @@ template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = H
 		}
 
 		/// Indicates whether a flush has occurred since the last call to did_flush().
-		forceinline bool did_flush() {
+		[[nodiscard]] forceinline bool did_flush() {
 			const bool did_flush = did_flush_;
 			did_flush_ = false;
 			return did_flush;
@@ -121,12 +171,12 @@ template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = H
 
 		/// @returns the number of cycles until the next sequence-point-based flush, if the embedded object
 		/// supports sequence points; @c LocalTimeScale() otherwise.
-		LocalTimeScale cycles_until_implicit_flush() const {
+		[[nodiscard]] LocalTimeScale cycles_until_implicit_flush() const {
 			return time_until_event_;
 		}
 
 		/// Indicates whether a sequence-point-caused flush will occur if the specified period is added.
-		forceinline bool will_flush(LocalTimeScale rhs) const {
+		[[nodiscard]] forceinline bool will_flush(LocalTimeScale rhs) const {
 			if constexpr (!has_sequence_points<T>::value) {
 				return false;
 			}
@@ -149,52 +199,15 @@ template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = H
 
 		template <typename S, typename = void> struct has_sequence_points : std::false_type {};
 		template <typename S> struct has_sequence_points<S, decltype(void(std::declval<S &>().get_next_sequence_point()))> : std::true_type {};
-};
 
-/*!
-	A RealTimeActor presents the same interface as a JustInTimeActor but doesn't defer work.
-	Time added will be performed immediately.
-
-	Its primary purpose is to allow consumers to remain flexible in their scheduling.
-*/
-template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = HalfCycles, class TargetTimeScale = LocalTimeScale> class RealTimeActor {
-	public:
-		template<typename... Args> RealTimeActor(Args&&... args) : object_(std::forward<Args>(args)...) {}
-
-		forceinline void operator += (const LocalTimeScale &rhs) {
-			if constexpr (multiplier == 1 && divider == 1) {
-				object_.run_for(TargetTimeScale(rhs));
-				return;
-			}
-
-			if constexpr (multiplier == 1) {
-				accumulated_time_ += rhs;
-			} else {
-				accumulated_time_ += rhs * multiplier;
-			}
-
-			if constexpr (divider == 1) {
-				const auto duration = accumulated_time_.template flush<TargetTimeScale>();
-				object_.run_for(duration);
-			} else {
-				const auto duration = accumulated_time_.template divide<TargetTimeScale>(LocalTimeScale(divider));
-				if(duration > TargetTimeScale(0))
-					object_.run_for(duration);
-			}
+		ClockingHint::Preference clocking_preference_ = ClockingHint::Preference::JustInTime;
+		void set_component_prefers_clocking(ClockingHint::Source *, ClockingHint::Preference clocking) {
+			clocking_preference_ = clocking;
 		}
-
-		forceinline T *operator->()				{	return &object_;	}
-		forceinline const T *operator->() const	{	return &object_;	}
-		forceinline T *last_valid() 			{	return &object_;	}
-		forceinline void flush()				{}
-
-	private:
-		T object_;
-		LocalTimeScale accumulated_time_;
 };
 
 /*!
-	A AsyncJustInTimeActor acts like a JustInTimeActor but additionally contains an AsyncTaskQueue.
+	An AsyncJustInTimeActor acts like a JustInTimeActor but additionally contains an AsyncTaskQueue.
 	Any time the amount of accumulated time crosses a threshold provided at construction time,
 	the object will be updated on the AsyncTaskQueue.
 */
diff --git a/Machines/Apple/AppleIIgs/AppleIIgs.cpp b/Machines/Apple/AppleIIgs/AppleIIgs.cpp
index 7c0d8ccc5..218da7d9e 100644
--- a/Machines/Apple/AppleIIgs/AppleIIgs.cpp
+++ b/Machines/Apple/AppleIIgs/AppleIIgs.cpp
@@ -1093,10 +1093,10 @@ class ConcreteMachine:
 		// MARK: - Other components.
 
 		Apple::Clock::ParallelClock clock_;
-		JustInTimeActor<Apple::IIgs::Video::Video, 1, 2, Cycles> video_;	// i.e. run video at 7Mhz.
-		JustInTimeActor<Apple::IIgs::ADB::GLU, 1, 4, Cycles> adb_glu_;		// i.e. 3,579,545Mhz.
+		JustInTimeActor<Apple::IIgs::Video::Video, Cycles, 1, 2> video_;	// i.e. run video at 7Mhz.
+		JustInTimeActor<Apple::IIgs::ADB::GLU, Cycles, 1, 4> adb_glu_;		// i.e. 3,579,545Mhz.
  		Zilog::SCC::z8530 scc_;
- 		JustInTimeActor<Apple::IWM, 1, 2, Cycles> iwm_;
+ 		JustInTimeActor<Apple::IWM, Cycles, 1, 2> iwm_;
  		Cycles cycles_since_clock_tick_;
 		Apple::Macintosh::DoubleDensityDrive drives35_[2];
 		Apple::Disk::DiskIIDrive drives525_[2];
diff --git a/Machines/Apple/Macintosh/Macintosh.cpp b/Machines/Apple/Macintosh/Macintosh.cpp
index 6f16cd1fb..1d8ca3b35 100644
--- a/Machines/Apple/Macintosh/Macintosh.cpp
+++ b/Machines/Apple/Macintosh/Macintosh.cpp
@@ -647,7 +647,7 @@ template <Analyser::Static::Macintosh::Target::Model model> class ConcreteMachin
 			return mouse_;
 		}
 
-		using IWMActor = JustInTimeActor<IWM, 1, 1, HalfCycles, Cycles>;
+		using IWMActor = JustInTimeActor<IWM>;
 
 		class VIAPortHandler: public MOS::MOS6522::PortHandler {
 			public:
diff --git a/Machines/Atari/ST/AtariST.cpp b/Machines/Atari/ST/AtariST.cpp
index 17800a525..1c3f496e0 100644
--- a/Machines/Atari/ST/AtariST.cpp
+++ b/Machines/Atari/ST/AtariST.cpp
@@ -479,9 +479,9 @@ class ConcreteMachine:
 		JustInTimeActor<Video> video_;
 
 		// The MFP runs at 819200/2673749ths of the CPU clock rate.
-		JustInTimeActor<Motorola::MFP68901::MFP68901, 819200, 2673749> mfp_;
-		JustInTimeActor<Motorola::ACIA::ACIA, 16> keyboard_acia_;
-		JustInTimeActor<Motorola::ACIA::ACIA, 16> midi_acia_;
+		JustInTimeActor<Motorola::MFP68901::MFP68901, HalfCycles, 819200, 2673749> mfp_;
+		JustInTimeActor<Motorola::ACIA::ACIA, HalfCycles, 16> keyboard_acia_;
+		JustInTimeActor<Motorola::ACIA::ACIA, HalfCycles, 16> midi_acia_;
 
 		Concurrency::DeferringAsyncTaskQueue audio_queue_;
 		GI::AY38910::AY38910<false> ay_;
diff --git a/Machines/ColecoVision/ColecoVision.cpp b/Machines/ColecoVision/ColecoVision.cpp
index 7f048d1ba..1f483fbb2 100644
--- a/Machines/ColecoVision/ColecoVision.cpp
+++ b/Machines/ColecoVision/ColecoVision.cpp
@@ -384,7 +384,7 @@ class ConcreteMachine:
 		}
 
 		CPU::Z80::Processor<ConcreteMachine, false, false> z80_;
-		JustInTimeActor<TI::TMS::TMS9918, 1, 1, HalfCycles> vdp_;
+		JustInTimeActor<TI::TMS::TMS9918> vdp_;
 
 		Concurrency::DeferringAsyncTaskQueue audio_queue_;
 		TI::SN76489 sn76489_;
diff --git a/Machines/Electron/Electron.cpp b/Machines/Electron/Electron.cpp
index 076547ff1..edc0c9807 100644
--- a/Machines/Electron/Electron.cpp
+++ b/Machines/Electron/Electron.cpp
@@ -25,6 +25,8 @@
 #include "../Utility/Typer.hpp"
 #include "../../Analyser/Static/Acorn/Target.hpp"
 
+#include "../../ClockReceiver/JustInTime.hpp"
+
 #include "Interrupts.hpp"
 #include "Keyboard.hpp"
 #include "Plus3.hpp"
@@ -54,7 +56,7 @@ template <bool has_scsi_bus> class ConcreteMachine:
 				scsi_bus_(4'000'000),
 				hard_drive_(scsi_bus_, 0),
 				scsi_device_(scsi_bus_.add_device()),
-				video_output_(ram_),
+				video_(ram_),
 				sound_generator_(audio_queue_),
 				speaker_(sound_generator_) {
 			memset(key_states_, 0, sizeof(key_states_));
@@ -230,13 +232,15 @@ template <bool has_scsi_bus> class ConcreteMachine:
 				if(isReadOperation(operation)) {
 					*value = ram_[address];
 				} else {
-					if(address >= video_access_range_.low_address && address <= video_access_range_.high_address) update_display();
+					if(address >= video_access_range_.low_address && address <= video_access_range_.high_address) {
+						video_.flush();
+					}
 					ram_[address] = *value;
 				}
 
-				// for the entire frame, RAM is accessible only on odd cycles; in modes below 4
-				// it's also accessible only outside of the pixel regions
-				cycles += video_output_.get_cycles_until_next_ram_availability(int(cycles_since_display_update_.as_integral()) + 1);
+				// For the entire frame, RAM is accessible only on odd cycles; in modes below 4
+				// it's also accessible only outside of the pixel regions.
+				cycles += video_.last_valid()->get_cycles_until_next_ram_availability(video_.time_since_flush().template as<int>() + 1);
 			} else {
 				switch(address & 0xff0f) {
 					case 0xfe00:
@@ -274,10 +278,8 @@ template <bool has_scsi_bus> class ConcreteMachine:
 					case 0xfe08: case 0xfe09: case 0xfe0a: case 0xfe0b:
 					case 0xfe0c: case 0xfe0d: case 0xfe0e: case 0xfe0f:
 						if(!isReadOperation(operation)) {
-							update_display();
-							video_output_.write(address, *value);
-							video_access_range_ = video_output_.get_memory_access_range();
-							queue_next_display_interrupt();
+							video_->write(address, *value);
+							video_access_range_ = video_.last_valid()->get_memory_access_range();
 						}
 					break;
 					case 0xfe04:
@@ -425,14 +427,14 @@ template <bool has_scsi_bus> class ConcreteMachine:
 										(address == 0xf0a8)								// 0xf0a8 is from where a service call would normally be
 																						// dispatched; we can check whether it would be call 14
 																						// (i.e. read byte) and, if so, whether the OS was about to
-																						// issue a read byte call to a ROM despite being the tape
+																						// issue a read byte call to a ROM despite the tape
 																						// FS being selected. If so then this is a get byte that
 																						// we should service synthetically. Put the byte into Y
 																						// and set A to zero to report that action was taken, then
 																						// allow the PC read to return an RTS.
 									)
 								) {
-									uint8_t service_call = uint8_t(m6502_.get_value_of_register(CPU::MOS6502::Register::X));
+									const auto service_call = uint8_t(m6502_.get_value_of_register(CPU::MOS6502::Register::X));
 									if(address == 0xf0a8) {
 										if(!ram_[0x247] && service_call == 14) {
 											tape_.set_delegate(nullptr);
@@ -441,7 +443,7 @@ template <bool has_scsi_bus> class ConcreteMachine:
 											tape_.clear_interrupts(Interrupt::ReceiveDataFull);
 											while(!tape_.get_tape()->is_at_end()) {
 												tape_.run_for_input_pulse();
-												cycles_left_while_plausibly_in_data--;
+												--cycles_left_while_plausibly_in_data;
 												if(!cycles_left_while_plausibly_in_data) fast_load_is_in_data_ = false;
 												if(	(tape_.get_interrupt_status() & Interrupt::ReceiveDataFull) &&
 													(fast_load_is_in_data_ || tape_.get_data_register() == 0x2a)
@@ -483,18 +485,14 @@ template <bool has_scsi_bus> class ConcreteMachine:
 				}
 			}
 
-			cycles_since_display_update_ += Cycles(int(cycles));
+			if(video_ += Cycles(int(cycles))) {
+				signal_interrupt(video_.last_valid()->get_interrupts());
+			}
+
 			cycles_since_audio_update_ += Cycles(int(cycles));
 			if(cycles_since_audio_update_ > Cycles(16384)) update_audio();
 			tape_.run_for(Cycles(int(cycles)));
 
-			cycles_until_display_interrupt_ -= cycles;
-			if(cycles_until_display_interrupt_ < 0) {
-				signal_interrupt(next_display_interrupt_);
-				update_display();
-				queue_next_display_interrupt();
-			}
-
 			if(typer_) typer_->run_for(Cycles(int(cycles)));
 			if(plus3_) plus3_->run_for(Cycles(4*int(cycles)));
 			if(shift_restart_counter_) {
@@ -517,25 +515,25 @@ template <bool has_scsi_bus> class ConcreteMachine:
 		}
 
 		forceinline void flush() {
-			update_display();
+			video_.flush();
 			update_audio();
 			audio_queue_.perform();
 		}
 
 		void set_scan_target(Outputs::Display::ScanTarget *scan_target) final {
-			video_output_.set_scan_target(scan_target);
+			video_->set_scan_target(scan_target);
 		}
 
 		Outputs::Display::ScanStatus get_scaled_scan_status() const final {
-			return video_output_.get_scaled_scan_status();
+			return video_->get_scaled_scan_status();
 		}
 
 		void set_display_type(Outputs::Display::DisplayType display_type) final {
-			video_output_.set_display_type(display_type);
+			video_->set_display_type(display_type);
 		}
 
 		Outputs::Display::DisplayType get_display_type() const final {
-			return video_output_.get_display_type();
+			return video_->get_display_type();
 		}
 
 		Outputs::Speaker::Speaker *get_speaker() final {
@@ -693,18 +691,6 @@ template <bool has_scsi_bus> class ConcreteMachine:
 		}
 
 		// MARK: - Work deferral updates.
-		inline void update_display() {
-			if(cycles_since_display_update_ > 0) {
-				video_output_.run_for(cycles_since_display_update_.flush<Cycles>());
-			}
-		}
-
-		inline void queue_next_display_interrupt() {
-			VideoOutput::Interrupt next_interrupt = video_output_.get_next_interrupt();
-			cycles_until_display_interrupt_ = next_interrupt.cycles;
-			next_display_interrupt_ = next_interrupt.interrupt;
-		}
-
 		inline void update_audio() {
 			speaker_.run_for(audio_queue_, cycles_since_audio_update_.divide(Cycles(SoundGenerator::clock_rate_divider)));
 		}
@@ -754,10 +740,7 @@ template <bool has_scsi_bus> class ConcreteMachine:
 		Electron::KeyboardMapper keyboard_mapper_;
 
 		// Counters related to simultaneous subsystems
-		Cycles cycles_since_display_update_ = 0;
 		Cycles cycles_since_audio_update_ = 0;
-		int cycles_until_display_interrupt_ = 0;
-		Interrupt next_display_interrupt_ = Interrupt::RealTimeClock;
 		VideoOutput::Range video_access_range_ = {0, 0xffff};
 
 		// Tape
@@ -794,7 +777,7 @@ template <bool has_scsi_bus> class ConcreteMachine:
 		}
 
 		// Outputs
-		VideoOutput video_output_;
+		JustInTimeActor<VideoOutput, Cycles> video_;
 
 		Concurrency::DeferringAsyncTaskQueue audio_queue_;
 		SoundGenerator sound_generator_;
diff --git a/Machines/Electron/Video.cpp b/Machines/Electron/Video.cpp
index 461057ebf..31f69fad6 100644
--- a/Machines/Electron/Video.cpp
+++ b/Machines/Electron/Video.cpp
@@ -234,7 +234,23 @@ void VideoOutput::output_pixels(int number_of_cycles) {
 
 void VideoOutput::run_for(const Cycles cycles) {
 	int number_of_cycles = int(cycles.as_integral());
+	const auto start_position = output_position_;
 	output_position_ = (output_position_ + number_of_cycles) % cycles_per_frame;
+
+	if(
+		(start_position < real_time_clock_interrupt_1 && output_position_ >= real_time_clock_interrupt_1) ||
+		(start_position < real_time_clock_interrupt_2 && output_position_ >= real_time_clock_interrupt_2)
+	) {
+		interrupts_ = Electron::Interrupt(interrupts_ | Electron::Interrupt::RealTimeClock);
+	}
+
+	if(
+		(start_position < display_end_interrupt_1 && output_position_ >= display_end_interrupt_1) ||
+		(start_position < display_end_interrupt_2 && output_position_ >= display_end_interrupt_2)
+	) {
+		interrupts_ = Electron::Interrupt(interrupts_ | Electron::Interrupt::DisplayEnd);
+	}
+
 	while(number_of_cycles) {
 		int draw_action_length = screen_map_[screen_map_pointer_].length;
 		int time_left_in_action = std::min(number_of_cycles, draw_action_length - cycles_into_draw_action_);
@@ -354,36 +370,30 @@ void VideoOutput::setup_base_address() {
 
 // MARK: - Interrupts
 
-VideoOutput::Interrupt VideoOutput::get_next_interrupt() {
-	VideoOutput::Interrupt interrupt;
-
+Cycles VideoOutput::get_next_sequence_point() {
 	if(output_position_ < real_time_clock_interrupt_1) {
-		interrupt.cycles = real_time_clock_interrupt_1 - output_position_;
-		interrupt.interrupt = RealTimeClock;
-		return interrupt;
+		return real_time_clock_interrupt_1 - output_position_;
 	}
 
 	if(output_position_ < display_end_interrupt_1) {
-		interrupt.cycles = display_end_interrupt_1 - output_position_;
-		interrupt.interrupt = DisplayEnd;
-		return interrupt;
+		return display_end_interrupt_1 - output_position_;
 	}
 
 	if(output_position_ < real_time_clock_interrupt_2) {
-		interrupt.cycles = real_time_clock_interrupt_2 - output_position_;
-		interrupt.interrupt = RealTimeClock;
-		return interrupt;
+		return real_time_clock_interrupt_2 - output_position_;
 	}
 
 	if(output_position_ < display_end_interrupt_2) {
-		interrupt.cycles = display_end_interrupt_2 - output_position_;
-		interrupt.interrupt = DisplayEnd;
-		return interrupt;
+		return display_end_interrupt_2 - output_position_;
 	}
 
-	interrupt.cycles = real_time_clock_interrupt_1 + cycles_per_frame - output_position_;
-	interrupt.interrupt = RealTimeClock;
-	return interrupt;
+	return real_time_clock_interrupt_1 + cycles_per_frame - output_position_;
+}
+
+Electron::Interrupt VideoOutput::get_interrupts() {
+	const auto interrupts = interrupts_;
+	interrupts_ = Electron::Interrupt(0);
+	return interrupts;
 }
 
 // MARK: - RAM timing and access information
diff --git a/Machines/Electron/Video.hpp b/Machines/Electron/Video.hpp
index 38507a6c2..db6a4e617 100644
--- a/Machines/Electron/Video.hpp
+++ b/Machines/Electron/Video.hpp
@@ -54,15 +54,6 @@ class VideoOutput {
 		*/
 		void write(int address, uint8_t value);
 
-		/*!
-			Describes an interrupt the video hardware will generate by its identity and scheduling time.
-		*/
-		struct Interrupt {
-			/// The interrupt that will be signalled.
-			Electron::Interrupt interrupt;
-			/// The number of cycles until it is signalled.
-			int cycles;
-		};
 		/*!
 			@returns the next interrupt that should be generated as a result of the video hardware.
 			The time until signalling returned is the number of cycles after the final one triggered
@@ -70,7 +61,12 @@ class VideoOutput {
 
 			This result may be mutated by calls to @c write.
 		*/
-		Interrupt get_next_interrupt();
+		Cycles get_next_sequence_point();
+
+		/*!
+			@returns a bit mask of all interrupts that have been triggered since the last call to get_interrupt().
+		*/
+		Electron::Interrupt get_interrupts();
 
 		/*!
 			@returns the number of cycles after (final cycle of last run_for batch + @c from_time)
@@ -136,6 +132,8 @@ class VideoOutput {
 		void emplace_pixel_line();
 		std::size_t screen_map_pointer_ = 0;
 		int cycles_into_draw_action_ = 0;
+
+		Electron::Interrupt interrupts_ = Electron::Interrupt(0);
 };
 
 }
diff --git a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp
index f8c568c96..7d58d1d66 100644
--- a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp
+++ b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp
@@ -85,7 +85,6 @@ template<Model model> class ConcreteMachine:
 			memcpy(rom_.data(), roms[0]->data(), std::min(rom_.size(), roms[0]->size()));
 
 			// Register for sleeping notifications.
-			fdc_->set_clocking_hint_observer(this);
 			tape_player_.set_clocking_hint_observer(this);
 
 			// Set up initial memory map.
@@ -397,7 +396,7 @@ template<Model model> class ConcreteMachine:
 			}
 
 			if constexpr (model == Model::Plus3) {
-				if(!fdc_is_sleeping_) fdc_ += Cycles(duration.as_integral());
+				fdc_ += Cycles(duration.as_integral());
 			}
 
 			if(typer_) typer_->run_for(duration);
@@ -462,7 +461,6 @@ template<Model model> class ConcreteMachine:
 		// MARK: - ClockingHint::Observer.
 
 		void set_component_prefers_clocking(ClockingHint::Source *, ClockingHint::Preference) override {
-			fdc_is_sleeping_ = fdc_.last_valid()->preferred_clocking() == ClockingHint::Preference::None;
 			tape_player_is_sleeping_ = tape_player_.preferred_clocking() == ClockingHint::Preference::None;
 		}
 
@@ -679,8 +677,7 @@ template<Model model> class ConcreteMachine:
 		}
 
 		// MARK: - Disc.
-		JustInTimeActor<Amstrad::FDC, 1, 1, Cycles> fdc_;
-		bool fdc_is_sleeping_ = false;
+		JustInTimeActor<Amstrad::FDC, Cycles> fdc_;
 
 		// MARK: - Automatic startup.
 		Cycles duration_to_press_enter_;
diff --git a/Processors/Z80/State/State.cpp b/Processors/Z80/State/State.cpp
index bcba268f9..c9b90f2de 100644
--- a/Processors/Z80/State/State.cpp
+++ b/Processors/Z80/State/State.cpp
@@ -19,6 +19,7 @@ State::State(const ProcessorBase &src): State() {
 	registers.bc = src.bc_.full;
 	registers.de = src.de_.full;
 	registers.hl = src.hl_.full;
+	registers.afDash = src.afDash_.full;
 	registers.bcDash = src.bcDash_.full;
 	registers.deDash = src.deDash_.full;
 	registers.hlDash = src.hlDash_.full;
@@ -107,6 +108,7 @@ void State::apply(ProcessorBase &target) {
 	target.bc_.full = registers.bc;
 	target.de_.full = registers.de;
 	target.hl_.full = registers.hl;
+	target.afDash_.full = registers.afDash;
 	target.bcDash_.full = registers.bcDash;
 	target.deDash_.full = registers.deDash;
 	target.hlDash_.full = registers.hlDash;
@@ -177,6 +179,7 @@ State::Registers::Registers() {
 		DeclareField(bc);
 		DeclareField(de);
 		DeclareField(hl);
+		DeclareField(afDash);
 		DeclareField(bcDash);
 		DeclareField(deDash);
 		DeclareField(hlDash);
diff --git a/Processors/Z80/State/State.hpp b/Processors/Z80/State/State.hpp
index 3a9aa838f..f5676aa60 100644
--- a/Processors/Z80/State/State.hpp
+++ b/Processors/Z80/State/State.hpp
@@ -31,7 +31,7 @@ struct State: public Reflection::StructImpl<State> {
 		uint8_t a;
 		uint8_t flags;
 		uint16_t bc, de, hl;
-		uint16_t bcDash, deDash, hlDash;
+		uint16_t afDash, bcDash, deDash, hlDash;
 		uint16_t ix, iy, ir;
 		uint16_t program_counter, stack_pointer;
 		uint16_t memptr;
diff --git a/README.md b/README.md
index 800358073..ba6d6cc21 100644
--- a/README.md
+++ b/README.md
@@ -24,15 +24,21 @@ It currently contains emulations of the:
 * Sinclair ZX80/81; and
 * Sinclair ZX Spectrum +2a/+3.
 
-## Single-click Loading
+## Single-step Loading
 
 Through static and runtime analysis CLK seeks automatically to select and configure the appropriate machine to run any provided disk, tape or ROM; to issue any commands necessary to run the software contained on the disk, tape or ROM; and to provide accelerated loading where feasible.
 
-The full process of loading a title — even if you've never used the emulated machine before — is therefore:
+With CLK installed the full process of loading a piece of software — even if you've never used the machine it runs on before — is therefore:
 
 1. locate it in your OS;
 2. double click it.
 
+![Loading a piece of software](READMEImages/JustDoubleClick.gif)
+
+So there's no need to wade through creating a new machine, inserting media into it or figuring out which loading command goes with this piece of software, and no import procedure — CLK does not attempt to take ownership of your files or to usurp your OS.
+
+Keep your emulated titles on your desktop, in your dock, or wherever else you usually prefer to launch software from, and launch in a single step. Just like you'd expect from any other piece of desktop software.
+
 ## Signal Processing
 
 Consider an ordinary, unmodified Commodore Vic-20. Its only video output is composite. Therefore the emulated machine's only video output is composite. In order to display the video output, your GPU must decode composite video. Therefore composite video artefacts are present and correct not because of a post hoc filter but because the real signal is really being processed.
diff --git a/READMEImages/JustDoubleClick.gif b/READMEImages/JustDoubleClick.gif
new file mode 100644
index 000000000..b90d97564
Binary files /dev/null and b/READMEImages/JustDoubleClick.gif differ
diff --git a/Storage/Tape/Formats/TapeUEF.cpp b/Storage/Tape/Formats/TapeUEF.cpp
index 7e169406f..b98211811 100644
--- a/Storage/Tape/Formats/TapeUEF.cpp
+++ b/Storage/Tape/Formats/TapeUEF.cpp
@@ -12,6 +12,7 @@
 #include <cstdlib>
 #include <cmath>
 
+#define LOG_PREFIX "[UEF] "
 #include "../../../Outputs/Log.hpp"
 
 // MARK: - ZLib extensions
@@ -155,7 +156,7 @@ void UEF::get_next_pulses() {
 			break;
 
 			default:
-				LOG("!!! Skipping " << std::hex << next_chunk.id << std::endl);
+				LOG("Skipping chunk of type " << PADHEX(4) << next_chunk.id);
 			break;
 		}