@@ -284,6 +284,44 @@ describe("PanelExtensionAdapter telemetry", () => {
     expect(counterCalls(telemetry, PANEL_TELEMETRY_METRICS.renderCount)).toHaveLength(0);
   });
 
+  it("should not count a tick without messages as skipped while a render is pending", async () => {
+    // GIVEN - an enabled sink, a pipeline that does not wait for the panel, and a panel watching
+    // frames that never calls done()
+    const telemetry = TelemetryBuilder.mockTelemetry();
+    setTelemetrySink(telemetry);
+    const initPanel = (context: PanelExtensionContext) => {
+      context.watch("currentFrame");
+      context.subscribe([{ topic: "/x" }]);
+      context.onRender = jest.fn();
+    };
+    const handle = render(
+      <Wrapper
+        currentTime={{ sec: 1, nsec: 0 }}
+        frame={{ "/x": [buildMessage(10)] }}
+        initPanel={initPanel}
+        pauseFrame={nonBlockingPauseFrame}
+      />,
+    );
+    await flush();
+    const skippedBefore = counterCalls(telemetry, PANEL_TELEMETRY_METRICS.renderSkipped).length;
+
+    // WHEN - a player-state update carrying no messages for the panel arrives while the render is
+    // still pending
+    handle.rerender(
+      <Wrapper
+        currentTime={{ sec: 2, nsec: 0 }}
+        initPanel={initPanel}
+        pauseFrame={nonBlockingPauseFrame}
+      />,
+    );
+    await flush();
+
+    // THEN - no skipped frame is recorded
+    expect(counterCalls(telemetry, PANEL_TELEMETRY_METRICS.renderSkipped)).toHaveLength(
+      skippedBefore,
+    );
+  });
+
   it("should not record telemetry from a stale done() called after the panel re-initialised", async () => {
     // GIVEN - a first panel instance whose render is still pending (done() captured, not called)
     const telemetry = TelemetryBuilder.mockTelemetry();
 
@@ -352,8 +352,13 @@ function PanelExtensionAdapter(
 
     if (renderingRef.current) {
       setSlowRender(true);
-      // Only a new frame input counts as skipped, not a re-run caused by another input.
-      if (telemetryEnabled && messageEvents !== lastAccountedFrameRef.current) {
+      // Only a new, non-empty frame input counts as skipped, not a re-run caused by another input
+      // nor a player-state update that carried no messages for this panel.
+      if (
+        telemetryEnabled &&
+        messageEvents != undefined &&
+        messageEvents !== lastAccountedFrameRef.current
+      ) {
         lastAccountedFrameRef.current = messageEvents;
         recordRenderSkipped(telemetry, telemetryLabels);
       }
 
@@ -41,6 +41,10 @@ export const PANEL_TELEMETRY_METRICS = {
    * `useSubscribeMessageRange` batches or through new entries in `renderState.allFrames`
    */
   rangeMessagesDelivered: "panel.rangeMessages.delivered",
-  /** counter: sum of `sizeInBytes` of those preloaded message events */
+  /**
+   * counter: sum of `sizeInBytes` of those preloaded message events. Approximate for `allFrames`:
+   * when new data is merged into the middle of `allFrames` only the appended tail is summed
+   * (re-summing the whole array on every block update is too expensive). The count is exact.
+   */
   rangeMessagesDeliveredBytes: "panel.rangeMessages.deliveredBytes",
 } as const;
@@ -108,6 +108,19 @@ class FailingTerminateSource extends TelemetryTestSource {
   }
 }
 
+// Counts terminate() calls and signals the second one (a close() after the close completed).
+class CountingTerminateSource extends TelemetryTestSource {
+  public readonly secondTerminate = signal();
+  #terminateCalls = 0;
+
+  public async terminate(): Promise<void> {
+    this.#terminateCalls++;
+    if (this.#terminateCalls === 2) {
+      this.secondTerminate.resolve();
+    }
+  }
+}
+
 function setupSink(onEvent?: (event: TelemetryEvent) => void): {
   sink: BufferedTelemetrySink;
   events: TelemetryEvent[];
@@ -321,6 +334,26 @@ describe("IterablePlayer telemetry", () => {
     ]);
   });
 
+  it("should end preload with reason 'cancelled' when the last full-preload subscription is removed while loading", async () => {
+    // Given: a source whose full (block loader) read is held, so the preload phase stays active
+    const { events } = setupSink();
+    const source = new GatedPreloadSource();
+    const player = new IterablePlayer({ source, enablePreload: true, sourceId: SOURCE_ID });
+    player.setSubscriptions([{ topic: TOPIC, preloadType: "full" }]);
+    player.setListener(async () => {});
+    await source.fullReadStarted;
+
+    // When
+    player.setSubscriptions([{ topic: TOPIC }]);
+    const preloadAfterRemoval = summarize(events).filter((entry) => entry.startsWith("preload"));
+    player.close();
+    source.gate.resolve();
+    await player.isClosed;
+
+    // Then
+    expect(preloadAfterRemoval).toEqual(["preload:start", "preload:end:cancelled"]);
+  });
+
   it("should end preload with reason 'error' when the block loader fails", async () => {
     // Given: a source whose full (block loader) read rejects
     const preloadEnded = signal();
@@ -458,6 +491,25 @@ describe("IterablePlayer telemetry", () => {
     expect(close).toEqual(["datasource.close:start", "datasource.close:end"]);
   });
 
+  it("close() after close completed emits no second close pair", async () => {
+    // Given: a player whose close phase already completed
+    const { events } = setupSink();
+    const source = new CountingTerminateSource();
+    const player = new IterablePlayer({ source, enablePreload: false, sourceId: SOURCE_ID });
+    await waitForInitialFrame(player);
+    player.close();
+    await player.isClosed;
+
+    // When: close() is called again and the close state runs again
+    player.close();
+    await source.secondTerminate;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Then
+    const close = summarize(events).filter((entry) => entry.startsWith("datasource.close"));
+    expect(close).toEqual(["datasource.close:start", "datasource.close:end"]);
+  });
+
   it("should emit datasource.firstMessage only once per player", async () => {
     // Given
     const { events } = setupSink();
 
@@ -233,12 +233,13 @@ export class IterablePlayer implements Player {
   // --- Phase telemetry. Every emit is guarded by getTelemetry().isEnabled().
   // #firstMessageSeen and #blockLoadingStarted are cheap booleans set unconditionally (no
   // allocation); only the event emission that reads them is gated. The #telemetryPlaybackActive /
-  // #telemetryCloseActive / #telemetryPreload markers pair start/end events and only leave their
-  // initial value once a start event has been emitted, i.e. while telemetry is enabled. ---
+  // #telemetryClose / #telemetryPreload markers pair start/end events and only leave their
+  // initial value once a start event has been emitted, i.e. while telemetry is enabled. Close and
+  // preload are emitted at most once per player. ---
   #telemetryLabels?: TelemetryLabels;
   #firstMessageSeen = false;
   #telemetryPlaybackActive = false;
-  #telemetryCloseActive = false;
+  #telemetryClose: "pending" | "active" | "done" = "pending";
   #telemetryPreload: "pending" | "active" | "done" = "pending";
   #blockLoadingStarted = false;
 
@@ -428,7 +429,12 @@ export class IterablePlayer implements Player {
     this.#preloadTopics = preloadTopics;
 
     this.#blockLoader?.setTopics(this.#preloadTopics);
-    this.#maybeStartPreloadTelemetry();
+    if (this.#preloadTopics.size === 0) {
+      // The last full-preload subscription is gone: nothing is left to preload.
+      this.#onPreloadEnded("cancelled");
+    } else {
+      this.#maybeStartPreloadTelemetry();
+    }
 
     // If the player is playing, the playing state will detect any subscription changes and adjust
     // iterators accordingly. However if we are idle or already seeking then we need to manually
@@ -489,8 +495,10 @@ export class IterablePlayer implements Player {
   }
 
   public close(): void {
-    if (!this.#telemetryCloseActive && getTelemetry().isEnabled()) {
-      this.#telemetryCloseActive = true;
+    // Telemetry only: a close() after the close phase completed re-runs the close state but does
+    // not emit a second start/end pair.
+    if (this.#telemetryClose === "pending" && getTelemetry().isEnabled()) {
+      this.#telemetryClose = "active";
       this.#emitPhase("datasource.close", "start");
     }
     this.#setState("close");
@@ -1449,19 +1457,19 @@ export class IterablePlayer implements Player {
   }
 
   #onCloseEnded(reason: string | undefined): void {
-    if (!this.#telemetryCloseActive) {
+    if (this.#telemetryClose !== "active") {
       return;
     }
-    this.#telemetryCloseActive = false;
+    this.#telemetryClose = "done";
     this.#emitPhase("datasource.close", "end", reason);
   }
 
   /**
    * `preload` start: once per player, when block loading is running AND at least one
    * `preloadType: "full"` subscription exists (otherwise the BlockLoader has nothing to load).
    * `preload` end: when the BlockLoader progress first covers the full [0, 1] range; if loading
-   * stops first, end is emitted with reason "cancelled" (close) or "error". Later topic changes
-   * do not restart the phase.
+   * stops first, end is emitted with reason "cancelled" (close, or the last `preloadType: "full"`
+   * subscription removed while loading) or "error". Later topic changes do not restart the phase.
    */
   #maybeStartPreloadTelemetry(): void {
     if (
 
@@ -10,6 +10,7 @@ import {
 import { TelemetryBuilder } from "@lichtblick/suite-base/util/telemetry/builders/TelemetryBuilder";
 
 import { WorkerSerializedIterableSource } from "./WorkerSerializedIterableSource";
+import { TELEMETRY_FINAL_DRAIN_TIMEOUT_MS } from "./constants";
 
 jest.mock("@lichtblick/den/worker", () => ({
   ComlinkWrap: jest.fn(),
@@ -326,6 +327,72 @@ describe("WorkerSerializedIterableSource", () => {
       expect(jest.getTimerCount()).toBe(0);
     });
 
+    it("enable failure stops the timer", async () => {
+      // Given
+      setTelemetrySink(mainSink);
+      const remote = makeMockRemote({
+        enableTelemetry: jest.fn().mockRejectedValue(new Error("no telemetry")),
+      });
+      const dispose = mockWorker(remote);
+      const source = makeSource();
+
+      // When
+      await source.initialize();
+      const timersAfterInitialize = jest.getTimerCount();
+      await jest.advanceTimersByTimeAsync(5000);
+      await source.terminate();
+
+      // Then: no periodic drain ran, only terminate()'s final drain, and the worker is disposed.
+      expect(timersAfterInitialize).toBe(0);
+      expect(remote.drainTelemetry).toHaveBeenCalledTimes(1);
+      expect(dispose).toHaveBeenCalledTimes(1);
+    });
+
+    it("should still dispose the worker when a periodic drain in flight never settles", async () => {
+      // Given: a periodic drain that never settles (dead worker)
+      setTelemetrySink(mainSink);
+      const remote = makeMockRemote({
+        drainTelemetry: jest.fn().mockReturnValue(new Promise<never>(() => {})),
+      });
+      const dispose = mockWorker(remote);
+      const source = makeSource();
+      await source.initialize();
+      await jest.advanceTimersByTimeAsync(1000);
+      expect(remote.drainTelemetry).toHaveBeenCalledTimes(1);
+
+      // When
+      const terminating = source.terminate();
+      await jest.advanceTimersByTimeAsync(TELEMETRY_FINAL_DRAIN_TIMEOUT_MS);
+      await terminating;
+
+      // Then: the worker is disposed, no final drain was started after the deadline and no timer
+      // is left running.
+      expect(dispose).toHaveBeenCalledTimes(1);
+      expect(remote.drainTelemetry).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+    });
+
+    it("should still dispose the worker when the final drain never settles", async () => {
+      // Given: a worker whose drain never settles (dead worker), and no periodic drain in flight
+      setTelemetrySink(mainSink);
+      const remote = makeMockRemote({
+        drainTelemetry: jest.fn().mockReturnValue(new Promise<never>(() => {})),
+      });
+      const dispose = mockWorker(remote);
+      const source = makeSource();
+      await source.initialize();
+
+      // When
+      const terminating = source.terminate();
+      await jest.advanceTimersByTimeAsync(TELEMETRY_FINAL_DRAIN_TIMEOUT_MS);
+      await terminating;
+
+      // Then
+      expect(dispose).toHaveBeenCalledTimes(1);
+      expect(remote.drainTelemetry).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+    });
+
     it("should ingest an in-flight periodic batch before the final batch on terminate", async () => {
       // Given
       setTelemetrySink(mainSink);
@@ -388,8 +455,10 @@ describe("WorkerSerializedIterableSource", () => {
       await initializing;
       await jest.advanceTimersByTimeAsync(5000);
 
-      // Then: the stale worker is not bridged nor published as the active remote.
+      // Then: the stale worker is not bridged nor published as the active remote; its initialize()
+      // still runs once so the pending initialize() call settles.
       expect(dispose).toHaveBeenCalledTimes(1);
+      expect(remote.initialize).toHaveBeenCalledTimes(1);
       expect(remote.enableTelemetry).not.toHaveBeenCalled();
       expect(remote.drainTelemetry).not.toHaveBeenCalled();
       expect(jest.getTimerCount()).toBe(0);
 
@@ -23,7 +23,7 @@ import type {
 } from "./IIterableSource";
 import type { SourceWorkerRemote, TelemetryBridge } from "./WorkerSerializedIterableSource.types";
 import type { WorkerSerializedIterableSourceWorker } from "./WorkerSerializedIterableSourceWorker";
-import { TELEMETRY_DRAIN_INTERVAL_MS } from "./constants";
+import { TELEMETRY_DRAIN_INTERVAL_MS, TELEMETRY_FINAL_DRAIN_TIMEOUT_MS } from "./constants";
 
 Comlink.transferHandlers.set("abortsignal", abortSignalTransferHandler);
 
@@ -65,6 +65,34 @@ async function drainBridge(bridge: TelemetryBridge): Promise<void> {
   await bridge.inFlight;
 }
 
+// Final drain on terminate(): wait for any periodic drain in flight (so batches are ingested in
+// order), then drain once more. Both waits share one deadline because a dead worker never answers
+// and the caller must still dispose it; no drain is started once the deadline has expired.
+async function finalDrainBridge(bridge: TelemetryBridge): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<"expired">((resolve) => {
+    timer = setTimeout(() => {
+      resolve("expired");
+    }, TELEMETRY_FINAL_DRAIN_TIMEOUT_MS);
+  });
+  let outcome: "drained" | "expired" = "drained";
+  try {
+    if (bridge.inFlight != undefined) {
+      outcome = await Promise.race([bridge.inFlight.then(() => "drained" as const), deadline]);
+    }
+    if (outcome === "drained") {
+      outcome = await Promise.race([drainBridge(bridge).then(() => "drained" as const), deadline]);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+  if (outcome === "expired") {
+    log.debug(
+      `Worker telemetry final drain timed out after ${TELEMETRY_FINAL_DRAIN_TIMEOUT_MS} ms`,
+    );
+  }
+}
+
 function stopBridgeTimer(bridge: TelemetryBridge | undefined): void {
   if (bridge?.timer != undefined) {
     clearInterval(bridge.timer);
@@ -128,6 +156,9 @@ export class WorkerSerializedIterableSource implements ISerializedIterableSource
       await remote.enableTelemetry(`worker:${++nextWorkerRealmOrdinal}`);
     } catch (err: unknown) {
       log.debug("Failed to enable worker telemetry", err);
+      // Stop polling a worker without telemetry; the bridge stays registered so terminate() still
+      // performs its (bounded) final drain.
+      stopBridgeTimer(bridge);
     }
     if (this.#telemetryBridge !== bridge) {
       // terminate()/re-initialize() replaced this bridge during the await: make sure it stays
@@ -236,10 +267,9 @@ export class WorkerSerializedIterableSource implements ISerializedIterableSource
       try {
         if (telemetryBridge != undefined) {
           // Final drain (after the worker flushed its final pool counters, before the worker is
-          // killed). Wait for any periodic drain in flight so batches are ingested in order.
+          // killed), bounded so a dead worker cannot block the disposal below.
           stopBridgeTimer(telemetryBridge);
-          await telemetryBridge.inFlight;
-          await drainBridge(telemetryBridge);
+          await finalDrainBridge(telemetryBridge);
         }
       } finally {
         // Always dispose the captured worker, even if its graceful terminate() rejected.
 
@@ -89,7 +89,7 @@ describe("WorkerSerializedIterableSourceWorker telemetry", () => {
     ]);
   });
 
-  it("lets a pool created during initialize() report through the worker sink, flushes on terminate and disposes on the final drain", async () => {
+  it("lets a pool created during initialize() report through the worker sink and publishes and disposes it on the final drain", async () => {
     // Given: telemetry enabled before initialize(), as done by WorkerSerializedIterableSource.
     const worker = new WorkerSerializedIterableSourceWorker(new PoolBackedSource());
     worker.enableTelemetry("worker:1");