@@ -129,6 +129,8 @@ var snapshot = await _virtualize.GetSnapshot();
 var measurements = await _virtualize.TakeSnapshot();
 ```
 
+These are safe to fire off without awaiting while the component may be going away. Called after disposal they do nothing, and one still in flight when the component is disposed completes without throwing: a query returns its default, and the failure is logged - at Debug when the JS side simply went away.
+
 ### Two-phase rendering
 
 ### Directional overscan
 
@@ -290,7 +290,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
         if (!ReferenceEquals(_lastOptionsRef, Options))
         {
             _lastOptionsRef = Options;
-            await _jsInstance.InvokeVoidAsync("setOptions", Options);
+            await InvokeInstance("setOptions", Options);
 
             // The component can be disposed during any await here, and disposal releases the
             // instance. Every call this render made after that point would fail on the render path.
@@ -310,7 +310,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
             // setItems.
             _lastItemsRef = Items;
             BuildDescriptors();
-            await _jsInstance.InvokeVoidAsync("setItems", _itemKeys, _itemSizes);
+            await InvokeInstance("setItems", _itemKeys, _itemSizes);
 
             if (_isDisposed)
             {
@@ -346,7 +346,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
         _lastMeasuredFirstIndex = firstIndex;
         _lastMeasuredLastIndex = lastIndex;
 
-        await _jsInstance.InvokeVoidAsync("measureRenderedRows");
+        await InvokeInstance("measureRenderedRows");
 
         if (_isDisposed)
         {
@@ -479,24 +479,47 @@ public async Task<VirtualItem[]> TakeSnapshot()
         return await QueryInstance<VirtualItem[]>("takeSnapshot") ?? [];
     }
 
+    /// <summary>Calls a method on the JS instance; a call made after disposal does nothing.</summary>
+    /// <remarks>
+    /// A call still in flight when the component is disposed can fail once the JS side goes away -
+    /// in a reloaded BlazorWebView the page no longer holds the instance - and is then logged rather
+    /// than thrown: the list it was meant for is gone, and a caller that fired it off without
+    /// awaiting would see it only as an unobserved task exception, a render as an unhandled one.
+    /// </remarks>
     private async Task InvokeInstance(string method, params object?[] args)
     {
         if (_jsInstance is null)
         {
             return;
         }
 
-        await _jsInstance.InvokeVoidAsync(method, args);
+        try
+        {
+            await _jsInstance.InvokeVoidAsync(method, args);
+        }
+        catch (Exception exception) when (_isDisposed)
+        {
+            LogTeardownFailure(exception, $"calling {method}");
+        }
     }
 
+    /// <summary>Like <see cref="InvokeInstance"/>; a query cut off by disposal returns the default.</summary>
     private async Task<TResult?> QueryInstance<TResult>(string method, params object?[] args)
     {
         if (_jsInstance is null)
         {
             return default;
         }
 
-        return await _jsInstance.InvokeAsync<TResult>(method, args);
+        try
+        {
+            return await _jsInstance.InvokeAsync<TResult>(method, args);
+        }
+        catch (Exception exception) when (_isDisposed)
+        {
+            LogTeardownFailure(exception, $"calling {method}");
+            return default;
+        }
     }
 
     /// <summary>
 
@@ -193,10 +193,13 @@ public async Task DisposeAsync_JSObjectAlreadyGoneFromThePage_DoesNotThrow()
 	}
 
 	[Theory]
-	[InlineData("setOptions")]
-	[InlineData("setItems")]
-	[InlineData("measureRenderedRows")]
-	public async Task DisposeAsync_WhileARenderAwaitsTheJSInstance_ThatRenderGoesNoFurther(string callInFlight)
+	[InlineData("setOptions", false)]
+	[InlineData("setItems", false)]
+	[InlineData("measureRenderedRows", false)]
+	[InlineData("setOptions", true)]
+	[InlineData("setItems", true)]
+	[InlineData("measureRenderedRows", true)]
+	public async Task DisposeAsync_WhileARenderAwaitsTheJSInstance_ThatRenderGoesNoFurther(string callInFlight, bool callFails)
 	{
 		// Arrange
 		using var context = CreateContext();
@@ -221,7 +224,15 @@ public async Task DisposeAsync_WhileARenderAwaitsTheJSInstance_ThatRenderGoesNoF
 
 		// Act
 		var disposal = component.InvokeAsync(async () => await component.Instance.DisposeAsync());
-		heldCall.SetVoidResult();
+		// In a reloaded BlazorWebView the call fails: the page it reaches no longer holds the instance.
+		if (callFails)
+		{
+			heldCall.SetException(new JSException("JS object instance with ID 20 does not exist (has it been disposed?)"));
+		}
+		else
+		{
+			heldCall.SetVoidResult();
+		}
 		// The render's continuation was queued on the renderer's dispatcher by the line above, so a
 		// no-op behind it only completes once that continuation has run.
 		await component.InvokeAsync(() => { });
@@ -242,6 +253,81 @@ public async Task DisposeAsync_WhileARenderAwaitsTheJSInstance_ThatRenderGoesNoF
 		context.Renderer.UnhandledException.IsCompleted.ShouldBeFalse();
 	}
 
+	[Theory]
+	[InlineData(typeof(JSException), LogLevel.Debug)]
+	[InlineData(typeof(JSDisconnectedException), LogLevel.Debug)]
+	[InlineData(typeof(ObjectDisposedException), LogLevel.Debug)]
+	[InlineData(typeof(TaskCanceledException), LogLevel.Debug)]
+	[InlineData(typeof(InvalidOperationException), LogLevel.Warning)]
+	public async Task ScrollToTop_StillInFlightWhenTheComponentIsDisposed_CompletesWithoutThrowing(Type failure, LogLevel expectedLogLevel)
+	{
+		// Arrange
+		using var context = CreateContext();
+		var log = new CapturingLogger();
+		context.Services.AddSingleton<ILogger<AdaptiveVirtualize<string>>>(log);
+		var instance = new FakeJS().Throwing("scrollToIndex", (Exception) Activator.CreateInstance(failure, "scroll failed")!);
+		instance.Hold("scrollToIndex");
+		var module = new FakeJS().Returning("create", instance);
+		context.Services.AddSingleton<IJSRuntime>(new FakeJS().Returning("import", module));
+		var component = RenderWith(context, ["a"]);
+
+		// Act
+		// Fired off and not awaited, the way an app scrolls a list back to the top after a filter change.
+		Task scroll = null!;
+		await component.InvokeAsync(() => { scroll = component.Instance.ScrollToTop(); });
+		await component.InvokeAsync(async () => await component.Instance.DisposeAsync());
+		instance.Answer("scrollToIndex");
+		await component.InvokeAsync(() => { });
+
+		// Assert
+		// Thrown, it would reach a caller that did not await it only as an unobserved task exception.
+		// Checked by status: Should.NotThrowAsync lets a canceled task through as "did not throw".
+		scroll.Status.ShouldBe(TaskStatus.RanToCompletion);
+		log.Entries.ShouldContain(entry => entry.Level == expectedLogLevel && entry.Exception != null && entry.Exception.GetType() == failure);
+	}
+
+	[Fact]
+	public async Task GetSnapshot_StillInFlightWhenTheComponentIsDisposed_ReturnsNothing()
+	{
+		// Arrange
+		using var context = CreateContext();
+		var instance = new FakeJS().Throwing("getSnapshot", new JSException("JS object instance with ID 20 does not exist (has it been disposed?)"));
+		instance.Hold("getSnapshot");
+		var module = new FakeJS().Returning("create", instance);
+		context.Services.AddSingleton<IJSRuntime>(new FakeJS().Returning("import", module));
+		var component = RenderWith(context, ["a"]);
+
+		// Act
+		Task<VirtualizerSnapshot?> query = null!;
+		await component.InvokeAsync(() => { query = component.Instance.GetSnapshot(); });
+		await component.InvokeAsync(async () => await component.Instance.DisposeAsync());
+		instance.Answer("getSnapshot");
+		await component.InvokeAsync(() => { });
+
+		// Assert
+		// The same answer as a query made after disposal.
+		query.Status.ShouldBe(TaskStatus.RanToCompletion);
+		(await query).ShouldBeNull();
+	}
+
+	[Fact]
+	public async Task ScrollToTop_JSFailsWhileTheComponentIsAlive_Throws()
+	{
+		// Arrange
+		using var context = CreateContext();
+		var instance = new FakeJS().Throwing("scrollToIndex", new JSException("scroll failed"));
+		var module = new FakeJS().Returning("create", instance);
+		context.Services.AddSingleton<IJSRuntime>(new FakeJS().Returning("import", module));
+		var component = RenderWith(context, ["a"]);
+
+		// Act
+		var scroll = () => component.InvokeAsync(() => component.Instance.ScrollToTop());
+
+		// Assert
+		// Only disposal makes a failure expected; before it, it may be a genuine bug.
+		await Should.ThrowAsync<JSException>(scroll);
+	}
+
 	[Fact]
 	public async Task DisposeAsync_WhileTheModuleIsBeingImported_ReleasesItAndNeverCreatesAnInstance()
 	{