@@ -355,12 +355,25 @@ class AquamotoWindow {
 		// handle's re-show), and it runs before the file's grids are built.
 		sceneSetAquaWindow(scene, true);
 		AquamotoWindow *w = registry().value(scene, nullptr);
-		if (!w || !w->win) {
+		const bool fresh = !w || !w->win;
+		if (fresh) {
 			w = new AquamotoWindow(parent, scene);
 			if (!w->win) { delete w; return; }
 			registry().insert(scene, w);
 		}
 		w->win->show();
+		// A NEW Aquamoto window pops up against the RIGHT side of its iGMT window, tops level, kept on
+		// that window's screen. A re-shown one stays wherever the user put it.
+		if (fresh && scene && scene->win) {
+			const QRect vf = scene->win->frameGeometry();
+			const QRect af = w->win->frameGeometry();
+			QScreen *scr = scene->win->screen();
+			const QRect avail = scr ? scr->availableGeometry() : QRect(vf.right() + 1, vf.top(), af.width(), af.height());
+			int x = vf.right() + 1, y = vf.top();
+			if (x + af.width() > avail.right() + 1) x = avail.right() + 1 - af.width();
+			if (y + af.height() > avail.bottom() + 1) y = avail.bottom() + 1 - af.height();
+			w->win->move(std::max(x, avail.left()), std::max(y, avail.top()));
+		}
 		w->win->raise();
 		w->win->activateWindow();
 		// Compile the slice path while the user is still choosing a file / reaching for the slider.
@@ -629,10 +642,16 @@ class AquamotoWindow {
 				rightBtn->setAutoRepeat(true);
 				row->insertWidget(idx, leftBtn);
 				row->insertWidget(idx + 2, rightBtn);   // sliceSlider shifted to idx+1 by the insert above
+				// ONE LAYER PER DRAWN SLICE. A repeat that lands while a slice is still drawing (busy_) or
+				// waiting to be caught up (sliceDirty_) is dropped: moving the slider then made the catch-up
+				// jump straight to wherever the repeats had got to, skipping every layer in between on any
+				// tank slower to draw than the repeat interval. The hold steps at the speed slices draw.
 				QObject::connect(leftBtn,  &QToolButton::clicked, sliceSlider, [this, leftBtn]() {
+					if (busy_ || sliceDirty_) return;
 					if (sliceSlider && arrowStillHeld(leftBtn)) sliceSlider->setValue(sliceSlider->value() - 1);
 				});
 				QObject::connect(rightBtn, &QToolButton::clicked, sliceSlider, [this, rightBtn]() {
+					if (busy_ || sliceDirty_) return;
 					if (sliceSlider && arrowStillHeld(rightBtn)) sliceSlider->setValue(sliceSlider->value() + 1);
 				});
 			}
@@ -2437,6 +2456,15 @@ class AquamotoWindow {
 		// button makes, after the slice is up. It runs INSIDE the transport's disabled window: it is
 		// the long half of the step, and a < / > auto-repeating through it is the stall.
 		if (ok && renderedImageCheck && renderedImageCheck->isChecked()) runCombinedImage(/*perSlice=*/true);
+		// THE SLICE REACHES THE SCREEN BEFORE THE NEXT ONE STARTS. Render() only draws into the view's
+		// offscreen buffer and SCHEDULES the paint that puts it on the monitor; the catch-up below can
+		// start the next slice before that paint is ever delivered, and then the screen skips layers
+		// (measured on a 765x476 tank: slices 2..15 all drawn, only 2,4,5,7,8,10,15 painted). Paint now.
+		if (ok && scene_ && sceneAlive(scene_) && scene_->widget) scene_->widget->repaint();
+		// …and so do the slider and the layer number box: their repaints are queued the same way and
+		// were starved the same way, so during a hold neither moved on screen.
+		if (sliceSlider) sliceSlider->repaint();
+		if (sliceSpin)   sliceSpin->repaint();
 		transportEnable(true);
 		// Requests that came in while this one was running: ONE catch-up redraw, on the next turn of
 		// the loop (never a recursive call), at whatever slice the slider ended up on.
 
@@ -10897,6 +10897,40 @@ GMTVTK_API int gmtvtk_aqua_arrow_press_test(void *scene, int dir, int down) {
 // i.e. how many pictures actually reached the screen. `reset` != 0 zeroes it (installing the observer
 // on first use). A slice that is read and pushed but never rendered is invisible to every Julia-side
 // count; this is the count of what the user sees. -1 no widget/render window.
+// test hook: what the 3-D view really PAINTS while Aquamoto's < / > is held. Every Paint event the
+// view widget receives is logged with the slice slider's value at that moment, so "each layer was
+// shown in turn" is read from the frames themselves, not from the host's state. mode 1 = start (and
+// clear) the log; mode 0 = copy up to `cap` logged slider values into `out`, return how many.
+struct PaintLogFilter : QObject {
+	QScrollBar *slider = nullptr;
+	std::vector<int> log;
+	bool eventFilter(QObject *o, QEvent *e) override {
+		if (e->type() == QEvent::Paint || e->type() == QEvent::UpdateRequest)
+			log.push_back(slider ? slider->value() : -1);
+		return QObject::eventFilter(o, e);
+	}
+};
+GMTVTK_API int gmtvtk_paint_log_test(void *scene, int mode, int *out, int cap) {
+	static std::map<void *, PaintLogFilter *> filters;
+	Scene *s = (Scene*)scene;
+	if (!s || !s->widget) return -1;
+	PaintLogFilter *&f = filters[s->widget];
+	if (!f) {
+		f = new PaintLogFilter;
+		s->widget->installEventFilter(f);
+	}
+	if (mode == 1) {
+		f->log.clear();
+		f->slider = nullptr;
+		for (QWidget *tl : QApplication::topLevelWidgets())
+			if (QScrollBar *sb = tl->findChild<QScrollBar *>("sliceSlider")) { f->slider = sb; break; }
+		return 0;
+	}
+	const int n = (int)std::min<size_t>(f->log.size(), (size_t)cap);
+	for (int i = 0; i < n; ++i) out[i] = f->log[(size_t)i];
+	return n;
+}
+
 GMTVTK_API int gmtvtk_render_count_test(void *scene, int reset) {
 	static std::map<void *, int> counts;
 	static std::set<void *> hooked;
 
@@ -193,12 +193,18 @@ end
 # the REPL does, with the REPL's own call, before its first command.
 const _CONSOLE_IUTILS = Ref(false)
 
+# A call a TOOL makes through this door (every Aquamoto slice, every dialog request) is spelled
+# `InteractiveGMT.<function>(...)`. Those run exactly as they always did; the REPL-only extras below
+# (InteractiveUtils, `ans`) are for what the user TYPES -- a slice call must not overwrite `ans`.
+_console_typed(code::String)::Bool = !startswith(lstrip(code), "InteractiveGMT.")
+
 function _console_eval_run(scene::Ptr{Cvoid}, cmd::Cstring, buf::Ptr{UInt8}, cap::Cint)::Cint
-	if !_CONSOLE_IUTILS[]
+	code = unsafe_string(cmd)
+	typed = _console_typed(code)
+	if typed && !_CONSOLE_IUTILS[]
 		try Base.load_InteractiveUtils(Main) catch end
 		_CONSOLE_IUTILS[] = true
 	end
-	code = unsafe_string(cmd)
 	fig  = get(_FIGREG, scene, nothing)
 	fig !== nothing && Core.eval(Main, :(fig = $fig))   # console's `fig` = this window
 	# Capture the command's stdout through a real pipe (redirect_stdout rejects an IOBuffer);
@@ -219,7 +225,7 @@ function _console_eval_run(scene::Ptr{Cvoid}, cmd::Cstring, buf::Ptr{UInt8}, cap
 		# `ans` = the last result, as the REPL keeps it (another REPL-only thing a session with no
 		# REPL never has). Only on success: a failed command leaves the previous `ans` alone, as
 		# there. QuoteNode so a Symbol or Expr result is stored, not evaluated.
-		Core.eval(Main, Expr(:(=), :ans, QuoteNode(val)))
+		typed && Core.eval(Main, Expr(:(=), :ans, QuoteNode(val)))
 	catch e
 		err = e
 	finally
 
@@ -117,7 +117,10 @@ end
 function _craft_release(a::CraftApp)::Tuple{String,String,Int,String}
 	suf = _craft_asset_suffix()
 	isempty(suf) && error("$(a.title) has no download for this system ($(Sys.KERNEL) $(Sys.ARCH)).")
-	json = _github_json("https://api.github.com/repos/$(a.repo)/releases/latest")   # gmtplugin.jl
+	io = IOBuffer()
+	GMT.Downloads.download("https://api.github.com/repos/$(a.repo)/releases/latest", io;
+	                       headers = ["Accept" => "application/vnd.github+json"], timeout = 20)
+	json = String(take!(io))
 	m = match(r"\"tag_name\"\s*:\s*\"([^\"]+)\"", json)
 	m === nothing && error("GitHub did not report a release of $(a.title) (github.com/$(a.repo)).")
 	tag = String(m.captures[1])
 
@@ -125,39 +125,31 @@ function _plugin_local_time(dir::String)::Union{Nothing,GMT.Dates.DateTime}
 	return tryparse(GMT.Dates.DateTime, strip(read(f, String)), GMT.Dates.dateformat"yyyy-mm-ddTHH:MM:SS")
 end
 
-# A GitHub API reply (release JSON). The start-up update checks (plugins here, VectorCraft/PhotoCraft
-# in craftapps.jl) fetch it on a background task, and Julia 1.10's Downloads CRASHES the process at
-# exit (ACCESS VIOLATION in curl_multi_cleanup) when a transfer is still in flight then. So every
-# fetch takes _BG_DL_STOP, and _bg_check's atexit hook fires it and waits for the checks to end
-# before Downloads' own cleanup runs.
-const _BG_DL_STOP  = Base.Event()
+# The start-up update checks (plugins here, VectorCraft/PhotoCraft in craftapps.jl) download on a
+# background task, and Julia 1.10's Downloads CRASHES the process at exit (ACCESS VIOLATION in
+# curl_multi_cleanup) when a transfer is still in flight then. So the atexit hook WAITS for a check
+# still running (each download has a 20 s timeout) before Downloads' own cleanup runs. Nothing else:
+# while the session runs, a check is the same plain download it always was -- an `interrupt` Event
+# on it made Aquamoto's < > hold freeze on one layer and jump ten (2026-10-26).
 const _BG_DL_TASKS = Task[]
 
-function _github_json(url::String)::String
-	io = IOBuffer()
-	r = GMT.Downloads.request(url; output = io, headers = ["Accept" => "application/vnd.github+json"],
-	                          timeout = 20, interrupt = _BG_DL_STOP)
-	200 <= r.status < 300 || error("$url: HTTP $(r.status)")
-	return String(take!(io))
-end
-
-# Run a start-up update check `f` in the background, stopped at exit (see _github_json).
 function _bg_check(f::Function)
 	isempty(_BG_DL_TASKS) && atexit(_bg_stop_checks)
 	push!(_BG_DL_TASKS, @async f())
 	return nothing
 end
 
 function _bg_stop_checks()
-	notify(_BG_DL_STOP)
-	foreach(t -> timedwait(() -> istaskdone(t), 5.0), _BG_DL_TASKS)
+	foreach(t -> timedwait(() -> istaskdone(t), 25.0), _BG_DL_TASKS)
 	return nothing
 end
 
 # The release asset's updated_at (UTC), from GitHub's API; nothing when it cannot be had.
 function _plugin_remote_time(p::GmtPlugin, asset::String)::Union{Nothing,GMT.Dates.DateTime}
-	json = _github_json("https://api.github.com/repos/$(p.repo)/releases/tags/$(_plugin_tag(p))")
-	return _plugin_asset_time(json, asset)
+	io = IOBuffer()
+	GMT.Downloads.download("https://api.github.com/repos/$(p.repo)/releases/tags/$(_plugin_tag(p))", io;
+	                       headers = ["Accept" => "application/vnd.github+json"], timeout = 20)
+	return _plugin_asset_time(String(take!(io)), asset)
 end
 
 # The updated_at of asset `asset` in a GitHub release JSON: the first one after its "name".
 
@@ -250,7 +250,9 @@ elseif Sys.isapple()
 		aqf_cg_post(UInt32(5))                  # kCGEventMouseMoved
 	end
 	aqf_os_button(down) = aqf_cg_post(UInt32(down ? 1 : 2))    # kCGEventLeftMouseDown / Up
-	aqf_cf_key(name) = unsafe_load(cglobal((name, AQF_CG), Ptr{Cvoid}))
+	# the key's name is a runtime value, so dlsym it: cglobal((name, lib)) with a local name is a
+	# lowering error on Julia >= 1.14, for the whole file, on every system
+	aqf_cf_key(name) = unsafe_load(Ptr{Ptr{Cvoid}}(Base.Libc.Libdl.dlsym(Base.Libc.Libdl.dlopen(AQF_CG), name)))
 	function aqf_cf_string(s::Ptr{Cvoid})
 		s == C_NULL && return ""
 		buf = zeros(UInt8, 512)
 
@@ -73,6 +73,7 @@ const _TEST_SYMBOLS = (
 	:gmtvtk_aqua_arrow_press_test,    # press / release an arrow, no pumping (the app's pump drives it)
 	:gmtvtk_aqua_slider_value_test,   # the slice slider's value, no pumping
 	:gmtvtk_render_count_test,        # renders that reached the screen since the last reset
+	:gmtvtk_paint_log_test,           # slider value at every paint of the 3-D view
 	:gmtvtk_axes_sets_test,           # EVERY axes set: name|shown|onscreen|zlock|z0|z1 per line
 	:gmtvtk_image_tex_hash_test,      # hash + dims of an image extra's texture bytes
 	:gmtvtk_aqua_arrow_screen_test,   # screen pos of an arrow, for REAL OS mouse input
 
@@ -28,9 +28,18 @@
 	renders(h, reset = false) = Int(ccall(GmtvtkTest._test_fn(:gmtvtk_render_count_test), Cint,
 	                                      (Ptr{Cvoid}, Cint), h, Cint(reset)))
 
+	# The slider's value at every paint of the 3-D view since the last start: what reached the screen.
+	paintlog(h, start) = start ? (ccall(GmtvtkTest._test_fn(:gmtvtk_paint_log_test), Cint,
+	                                    (Ptr{Cvoid}, Cint, Ptr{Cint}, Cint), h, 1, C_NULL, 0); Int[]) :
+	                     (buf = zeros(Cint, 100_000);
+	                      n = ccall(GmtvtkTest._test_fn(:gmtvtk_paint_log_test), Cint,
+	                                (Ptr{Cvoid}, Cint, Ptr{Cint}, Cint), h, 0, buf, Cint(length(buf)));
+	                      Int.(buf[1:max(n, 0)]))
+
 	# Hold for `secs` by SLEEPING (the Timer pump runs), then release and let it settle `settle` s.
 	function hold(h, st, dir, secs; settle = 3.0)
 		renders(h, true)
+		paintlog(h, true)
 		v0 = aqf_realpress(h, dir, true)
 		@assert v0 >= 0 "arrow press hook failed: $v0"
 		drawn = Int[]; gap = 0.0; tl = time(); t0 = tl
@@ -45,22 +54,30 @@
 			sleep(0.01); t = time(); gap = max(gap, t - tl); tl = t
 			push!(marks, slider(h))
 		end
-		(; v0, vrel, ndrawn = length(unique(drawn)), nr, gap,
+		pl = paintlog(h, false)
+		painted = [pl[i] for i in eachindex(pl) if i == 1 || pl[i] != pl[i-1]]   # each layer once, in order
+		(; v0, vrel, ndrawn = length(unique(drawn)), nr, gap, painted,
 		   vmid = marks[max(1, length(marks) ÷ 2)], vend = slider(h), cur = st.cur + 1)
 	end
 
 	aqf_on_screen() do                     # the real mouse needs the window on the screen
 	mktempdir() do dir
+	# The small tank, one of a real model's size (765x476), and a big one whose slice takes longer than
+	# the arrow's repeat interval -- where the repeats used to run the slider ahead of the drawing.
+	for (nx, ny) in ((128, 96), (765, 476), (2000, 1500))
 		# 40 steps: enough that a working hold cannot run out of slices inside the hold window.
-		nc = aqf_make_tsunami_nc(joinpath(dir, "tsu_transport.nc"); nt = 40)
+		nc = aqf_make_tsunami_nc(joinpath(dir, "tsu_transport_$nx.nc"); nx, ny, nt = 40)
 		f = iview()
 		try
 			IG._on_drop(f.h, nc);  aqf_pump(80)
 			st = IG._AQUA[f.h]
 			for dir in (+1, -1)
 				r = hold(f.h, st, dir, 2.0)
-				@info "hold dir=$dir" r
-				isdefined(Main, :_log) && Main._log("    hold dir=", dir, ": ", r)
+				@info "hold $(nx)x$ny dir=$dir" r
+				isdefined(Main, :_log) && Main._log("    hold ", nx, "x", ny, " dir=", dir, ": ", r)
+				# SMOOTH: every layer the slider passed was PAINTED, one after the other, in order. A
+				# hold that freezes on one layer and then jumps ten skips the ones in between.
+				@test filter(!=(r.v0), r.painted) == collect(r.v0 + dir:dir:r.vrel)
 				# Moves in the asked direction, several DRAWN slices (a healthy 2 s hold draws 10+).
 				@test dir * (r.vrel - r.v0) > 3
 				@test r.ndrawn > 3
@@ -79,6 +96,7 @@
 		end
 	end
 	end
+	end
 end
 
 # THE SAME HOLD WITH "Sat img" ON, ON A REAL-SIZE TANK. With the satellite drape on, every slice also
 
@@ -102,11 +102,11 @@ end
 	# The start-up update checks fetch GitHub's release JSON on a background task. Julia 1.10's
 	# Downloads crashed the process at exit (ACCESS VIOLATION in curl_multi_cleanup) whenever that
 	# transfer was still in flight, e.g. a short test run, or a session closed right after start.
-	# _bg_check stops it at exit. In a CHILD, exiting a moment after the check starts.
+	# _bg_check waits for it at exit. In a CHILD, exiting a moment after the check starts.
 	script = """
 	using InteractiveGMT
 	IG = InteractiveGMT
-	IG._bg_check(() -> try IG._github_json("https://api.github.com/repos/GenericMappingTools/GMT.jl/releases/latest") catch end)
+	IG._bg_check(() -> try IG.GMT.Downloads.download("https://api.github.com/repos/GenericMappingTools/GMT.jl/releases/latest", IOBuffer(); timeout = 20) catch end)
 	sleep(0.05)
 	print(stderr, "EXITING")
 	"""