@@ -91,6 +91,8 @@ Two traps in the one-shot version (`get_nowait()` once, then `return None`):
 - **Stranded results.** With two jobs in flight, the drain stops after the first result and the second sits in the queue with no timer to read it. Measured: with the drain returning `None` after one result, one of two results was applied. Count pending jobs and unregister only at 0.
 - **Endless polling.** A worker whose job raises dies without `put()`. Measured: the pending count stayed at 1 and the drain was still registered seconds later, and no error was reported anywhere but the thread's traceback. Wrap the job and put the exception, so the main thread can report it.
 
+A third trap appears when the user opens another file while jobs run. File → Open drops the plain drain timer, but the worker threads keep running and keep putting results. The next `start()` registers the drain again, and that drain applies every queued result, including the old file's, to the new file's `bpy.data`. Measured on 5.2.1 and 4.5.14: a job started before `wm.read_homefile` wrote its result onto the new file's `Target` object. The snippet tags each job with an epoch, and a `@persistent` `load_post` handler bumps the epoch and resets `pending`. The drain then discards results from older epochs: with the epoch check in place, the stale result was dropped and a job started after the load still applied. Register that handler in `register()` and remove it in `unregister()`. Making the drain `persistent=True` is the wrong fix here: it keeps the timer alive across the load, but still applies the old file's results.
+
 Measured with three concurrent jobs, one raising `ValueError`: both results were applied, the error was reported, the pending count reached 0, and the drain unregistered itself. Every result was handled on the script's main-thread `threading.get_ident()`, which no worker shared. Compare idents to prove that: `threading.current_thread() is threading.main_thread()` checked inside a timer is always true, because timers only run on the main thread. Use `daemon=True` so a hung worker cannot keep Blender from quitting. For network work, check `bpy.app.online_access` first (see `extension-runtime-and-packaging`).
 
 ## Modal operators: `event_timer_add` plus `modal()`
 
@@ -3,14 +3,11 @@
 # touches it; a timer (main thread) drains the queue.
 #
 # - Timers need the event loop: in `blender --background` they never run.
-# - Return None from a timer to stop it, a float to run again; returning 0
-#   means "again on the next pass", not "stop".
-# - Count pending jobs: stop the drain only when every job has reported, or
-#   a second job's result sits in the queue with no timer to read it.
-# - The worker always puts, even when the job raises; otherwise the drain
-#   waits for a result that never comes and polls forever.
-# - persistent=True keeps the timer across File > Open; plain timers are
-#   dropped by a file load.
+# - A timer returning None stops; a float (0 included) runs it again.
+# - Count pending jobs and stop the drain only at 0, or a second result is
+#   stranded; the worker always puts, even on error, or the drain never stops.
+# - File > Open drops the plain drain timer but not the threads: jobs carry an
+#   epoch that load_post bumps, so an old file's results are discarded.
 #
 # Reference:
 #   https://docs.blender.org/api/current/bpy.app.timers.html
@@ -20,49 +17,59 @@
 import threading
 
 import bpy
+from bpy.app.handlers import persistent
 
 _results = queue.Queue()
-_pending = 0  # jobs started but not yet drained; read and written on the main thread only
+_pending = 0  # this file's jobs not yet drained; main thread only
+_epoch = 0  # bumped on every file load
 
 
-def _worker(job):
-    # No bpy in here: compute, download, read files.
-    try:
-        _results.put((True, job()))
+def _worker(job, epoch):
+    try:  # no bpy in here: compute, download, read files
+        _results.put((epoch, True, job()))
     except BaseException as e:
-        _results.put((False, e))  # report the failure; never leave the drain waiting
+        _results.put((epoch, False, e))  # never leave the drain waiting
 
 
 def _drain():
     global _pending
     while True:  # take everything that has landed this tick
         try:
-            ok, value = _results.get_nowait()
+            epoch, ok, value = _results.get_nowait()
         except queue.Empty:
             break
+        if epoch != _epoch:
+            continue  # started for a file that is no longer open
         _pending -= 1
-        if ok:
-            apply_result(value)  # main thread: bpy is safe here
-        else:
+        obj = bpy.data.objects.get("Target")  # main thread: bpy is safe here
+        if not ok:
             print(f"background job failed: {value!r}")
+        elif obj is not None:
+            obj["result"] = value
     return 0.1 if _pending else None  # unregister only once every job is in
 
 
-def apply_result(value):
-    obj = bpy.data.objects.get("Target")
-    if obj is not None:
-        obj["result"] = value
+@persistent
+def _on_load(_):
+    global _pending, _epoch
+    _epoch, _pending = _epoch + 1, 0  # old jobs' results are now stale
 
 
 def run_in_background(job):
     """Start `job` on a worker thread and apply its result when it lands."""
     global _pending
     _pending += 1
-    threading.Thread(target=_worker, args=(job,), daemon=True).start()
+    threading.Thread(target=_worker, args=(job, _epoch), daemon=True).start()
     if not bpy.app.timers.is_registered(_drain):
         bpy.app.timers.register(_drain, first_interval=0.1)
 
 
+def register():
+    bpy.app.handlers.load_post.append(_on_load)
+
+
 def unregister():
+    if _on_load in bpy.app.handlers.load_post:
+        bpy.app.handlers.load_post.remove(_on_load)
     if bpy.app.timers.is_registered(_drain):
         bpy.app.timers.unregister(_drain)