fix: Debug cleanup

Author: tmathern

src/c2pa/c2pa.py

@@ -2001,6 +2001,7 @@ def close(self):
             return
         if is_foreign_process(self):
             self._closed = True
+            self._initialized = False
             return
 
         try:

src/c2pa/lib.py

@@ -314,10 +314,12 @@ def is_foreign_process(obj):
     absent in the child -> any lock() call deadlocks. Callers must skip native frees
     when this returns True.
 
-    Skipping the free does not cause a cumulative memory leak: the child either calls exec()
-    (replacing the address space entirely) or exits shortly after fork. In both cases
-    the OS should reclaim all process memory. The skipped allocation lives only until child
-    process termination.
+    Skipping the free does not cause a cumulative leak. If the child calls exec() the
+    address space is replaced entirely; if it exits, the OS reclaims all process memory.
+    Even a long-lived fork child (e.g. a multiprocessing fork-start worker) leaks at most
+    the objects inherited at fork time — a one-time, bounded amount reclaimed when the
+    child terminates. Objects the child creates itself carry the child's PID and are
+    freed normally.
 
     Defensive default: if _owner_pid was never set, returns False (no regression)."""
     owner = getattr(obj, '_owner_pid', None)

tests/perf/scenarios.py

@@ -541,9 +541,16 @@ def scenario_fork_contended_mutex(iterations: int = 100) -> None:
     """Fork safety benchmark scenario:
     8 threads create/close Readers in a tight loop while the main thread
     forks 5× per iteration (500 total forks). Maximises the probability that
-    the registry Mutex is held at the instant of fork(). If pthread_atfork
-    didn't reinit the Rust mutex the first cimpl_free in the child would
-    deadlock; the Python guard is also exercised by child GC.
+    the registry Mutex is held at the instant of fork(). Each fork inherits
+    a Reader created by the main thread; the child explicitly closes it
+    (then runs GC), so the PID guard is exercised on every fork — without
+    the guard the close would call into the native library and could
+    deadlock on a mutex left locked by a vanished worker thread. The parent
+    closes the same Reader after the child exits (its own PID: real free).
+
+    Note: the workers' Readers are pinned by frozen thread frames in the
+    child, so child gc.collect() alone would free nothing — hence the
+    explicit close of an inherited object.
     """
     if not hasattr(os, "fork"):
         return
@@ -562,7 +569,15 @@ def _worker():
     try:
         for _ in _iterate(iterations):
             for _ in range(5):
-                _fork_wait(lambda: gc.collect())
+                with open(SIGNED_JPEG, "rb") as f:
+                    reader = Reader("image/jpeg", f)
+
+                def _child(r=reader):
+                    r.close()
+                    gc.collect()
+
+                _fork_wait(_child)
+                reader.close()
     finally:
         stop.set()
         for t in threads:

tests/test_unit_tests_threaded.py

@@ -163,11 +163,13 @@ def test_already_closed_is_noop_via_close(self):
         mock_lib.c2pa_release_stream.assert_not_called()
 
     def test_foreign_pid_close_marks_closed(self):
-        """close() in forked child must set _closed=True to prevent re-entry."""
+        """close() in forked child must set _closed=True to prevent re-entry,
+        and _initialized=False so the public properties report a closed stream."""
         obj = _make_stream(pid_offset=1)
         with patch('c2pa.c2pa._lib'):
             obj.close()
         self.assertTrue(obj._closed)
+        self.assertFalse(obj._initialized)
 
 
 class TestHelpers(unittest.TestCase):