PyMemoryEditor 3.2.0__tar.gz → 3.3.1__tar.gz

pymemoryeditor-3.3.1/CONTRIBUTING.md

@@ -0,0 +1,199 @@
+# Contributing to PyMemoryEditor
+
+Thanks for your interest in contributing!
+
+## Development setup
+
+```bash
+python -m venv venv
+source venv/bin/activate    # On Windows: venv\Scripts\activate
+make install-dev            # pip install -e ".[dev]"
+```
+
+The `dev` extra installs the full toolchain and the GUI deps.
+
+The `Makefile` is the single source of truth for the dev commands below — run
+`make help` to see every target (docs, build, coverage, etc.). The raw command
+each target wraps is shown in parentheses if you'd rather run it directly.
+
+## Running the test suite
+
+The tests read and write the memory of the test process itself; they should run
+on any supported platform without elevated privileges.
+
+```bash
+make test-fast              # pytest tests -m "not slow"  (~20 s: unit, GUI and MCP tests)
+make test                   # pytest tests -v             (everything, incl. live whole-process scans)
+make test-mcp               # pytest tests/mcp_server     (the MCP server suite, ~10 s)
+```
+
+`test-fast` is the loop to iterate on; the `slow` and `scan_heavy` markers
+(defined in `pyproject.toml`) hold the tests that scan the test process's whole
+address space, which takes minutes on CI runners. The scan property tests
+(`tests/scan/test_scan_properties.py`) are marked `slow` too, so run them
+directly when you touch the scan kernels:
+
+```bash
+pytest tests/scan/test_scan_properties.py
+```
+
+On CI the Hypothesis tests run under a derandomized `ci` profile (selected
+automatically when `CI` is set, or with `HYPOTHESIS_PROFILE=ci`), so a failure
+reproduces on re-run; locally they keep exploring new examples.
+
+### Testing one platform
+
+The suite always exercises the backend of the OS it runs on (`win32/`,
+`linux/` or `macos/`); tests written for another platform's backend skip
+themselves.
+So testing a platform means running the suite on it -- locally, in a VM, or
+by opening a PR and reading that OS's CI cells. To mirror one CI cell on its
+own OS:
+
+```bash
+QT_QPA_PLATFORM=offscreen pytest tests --ignore=tests/mcp_server   # build / build-macos
+pytest tests/mcp_server -p no:pytest-qt                            # build-mcp (Linux)
+pytest tests/mcp_server -p no:pytest-qt -m "not scan_heavy"        # build-mcp (Windows, macOS)
+```
+
+`pytest tests/platforms` runs only the platform-specific regression tests;
+add `-k linux` (or `win32`, `macos`, `bitness`) to narrow them further. The
+`speed` extra (NumPy) switches the scans to the vectorized path, which is what
+the `build-speed` and macOS jobs run; leave it out to test the pure-Python one.
+
+`tests/process/test_foreign_process.py` attaches to a child process. On macOS
+that needs the `com.apple.security.cs.debugger` entitlement (see below), which
+CI runners do not have, so it skips there: run it locally on a signed Python
+before changing how the macOS backend opens a foreign task.
+
+## Linting
+
+```bash
+make lint                   # flake8 PyMemoryEditor tests
+```
+
+## Type checking
+
+```bash
+make type-check             # mypy PyMemoryEditor
+```
+
+## Before you push
+
+Run lint, type-check and the test suite in one go:
+
+```bash
+make pre-commit             # lint + type-check + test
+```
+
+The CI pipeline runs the same lint, mypy and tests, and blocks merges on failure.
+The library matrix runs Python 3.10–3.15 on Ubuntu and Windows plus Python
+3.10, 3.12 and 3.14 on macOS, so all three platform backends are exercised on
+every push. Dedicated jobs also run the suite with the `speed` extra (NumPy) to keep
+the vectorized scan path covered, and the MCP server suite once per OS. Even so,
+contributors touching a specific backend are encouraged to run `pytest tests`
+locally on that platform before submitting. `make ci` runs the same lint,
+type-check and coverage-gated test invocations the workflow does.
+
+## Project layout
+
+```
+PyMemoryEditor/
+├── __init__.py          # Public API + platform dispatch
+├── enums.py             # ScanTypesEnum (cross-platform)
+├── process/             # Abstract base, errors, process info, util
+├── util/                # Cross-platform helpers: scan and type conversion
+├── win32/               # Windows implementation (kernel32, user32)
+├── linux/               # Linux implementation (process_vm_readv/writev, /proc/<pid>/maps)
+├── macos/               # macOS implementation (task_for_pid, mach_vm_*)
+├── mcp/                 # Model Context Protocol server exposed as `pymemoryeditor-mcp`
+└── app/                 # PySide6 (Qt) demo app exposed as `pymemoryeditor` CLI
+```
+
+The three platform packages implement `AbstractProcess` from `process/abstract.py`.
+The public alias `OpenProcess` is chosen at import time in `__init__.py` based on
+`sys.platform`.
+
+### Platform-specific test notes
+- **Linux**: requires `/proc/sys/kernel/yama/ptrace_scope=0` to attach to processes
+  not descended from the test runner. Self-process tests work without changes.
+- **macOS**: opening another process requires the Python binary to be signed with
+  the `com.apple.security.cs.debugger` entitlement (or SIP off + root). Self-
+  process tests work without changes.
+- **Windows**: no special privileges needed for self-process tests.
+
+## Submitting changes
+
+1. Open an issue first for bug reports or substantial features.
+2. Branch from `main`. Keep commits focused.
+3. Run `make pre-commit` (lint + type-check + tests) locally before pushing.
+4. Open a PR describing the change and how it was tested.
+5. Give the PR a [Conventional Commits](https://www.conventionalcommits.org/) title,
+   e.g. `fix: reject empty search targets` or `docs(mcp): document --allow-write`.
+   A required check lints it: the type must be one of `feat`, `fix`, `perf`,
+   `refactor`, `revert`, `docs`, `ci`, `build`, `chore`, `test`, `style`, and
+   the subject must start lowercase and not end with a period. PRs are
+   squash-merged, so the title becomes the commit message on `main`.
+
+## Versioning
+
+PyMemoryEditor follows [Semantic Versioning](https://semver.org/). The public
+API is everything documented on Read the Docs, and its *behaviour* counts as
+much as its signatures: a call that keeps its name and arguments but returns
+a different value, accepts or rejects different input, or touches different
+memory is a breaking change.
+
+- **Major** (`4.0.0`): any breaking change, including a behaviour change to a
+  documented default -- even when the old behaviour was a bug that someone
+  could reasonably depend on (3.0.0's signed 3-byte reads are the model: the
+  release notes lead with it, show the before/after and the way back).
+- **Minor** (`3.3.0`): new features, and behaviour changes that only reject
+  what was memory-unsafe or meaningless before. When a minor release does
+  change a default (an opt-out such as `aligned=False` must exist), its
+  release notes say **Behaviour change** in bold.
+- **Patch** (`3.2.1`): fixes that make the code do what the docs already
+  said.
+
+The changelog is the
+[GitHub Releases](https://github.com/JeanExtreme002/PyMemoryEditor/releases)
+page: describe every user-visible change in the PR so it can be carried into
+the release notes.
+
+## Release process
+
+Releases are cut by publishing a GitHub Release; nothing is uploaded from a
+laptop.
+
+1. Open a `chore: bump version to X.Y.Z` PR that sets the version in five
+   places: `__version__` in `PyMemoryEditor/__init__.py`, the fallback
+   `release` in `docs/conf.py`, and in `server.json` both `version` fields
+   plus the `PyMemoryEditor[mcp]==X.Y.Z` pin in the package arguments.
+   `tests/mcp_server/test_registry.py` fails if the package and `server.json`
+   disagree.
+2. Merge it and wait for the `Python Package` run on `main` to go green.
+3. Publish a GitHub Release with the tag `vX.Y.Z` on that commit; its notes
+   are the changelog for the version.
+   `.github/workflows/publish.yml` then checks that the tag matches
+   `__version__` and that the commit has a green `Python Package` run (it
+   waits for one still in progress), builds and `twine check --strict`s the
+   distributions, uploads them to PyPI by trusted publishing (no token), and
+   lists the version on the MCP Registry.
+
+If the CI gate fails because `main`'s run was cancelled by a later push, run
+`gh workflow run python-package.yml --ref vX.Y.Z` and re-run the release
+workflow once it is green. `make publish` is a manual fallback for when the
+workflow itself is unavailable: it refuses to run outside a clean checkout of
+the `v<__version__>` tag, but it uploads by API token and does not update the
+MCP Registry.
+
+## Reporting bugs
+
+Please include:
+- Operating system and architecture (e.g. Windows 11 x64, Ubuntu 22.04 x64).
+- Python version (`python --version`).
+- A minimal reproducer if possible.
+- For Linux: whether `/proc/sys/kernel/yama/ptrace_scope` is `0` or `1`.
+
+## Security
+
+If you find a security issue, please see [`SECURITY.md`](https://github.com/JeanExtreme002/PyMemoryEditor/blob/main/SECURITY.md). **Do not** report via GitHub issues.

{pymemoryeditor-3.2.0 → pymemoryeditor-3.3.1}/Makefile

@@ -31,7 +31,7 @@ help:
 	@echo "  $(YELLOW)run-app$(NC)          - Run the PyMemoryEditor App"
 	@echo "  $(YELLOW)install-dev$(NC)      - Install development dependencies"
 	@echo "  $(YELLOW)test$(NC)             - Run the full test suite (incl. live whole-process scans)"
-	@echo "  $(YELLOW)test-fast$(NC)        - Run the fast lane only (-m \"not slow\", ~20 s)"
+	@echo "  $(YELLOW)test-fast$(NC)        - Run the fast lane only (-m \"not slow\", ~20 s; skips the scan property tests)"
 	@echo "  $(YELLOW)test-mcp$(NC)         - Run the MCP server suite"
 	@echo "  $(YELLOW)test-verbose$(NC)     - Run tests with verbose output"
 	@echo "  $(YELLOW)test-coverage$(NC)    - Run tests with coverage report"
@@ -42,7 +42,8 @@ help:
 	@echo "  $(YELLOW)build-wheel$(NC)      - Build wheel package"
 	@echo "  $(YELLOW)build-sdist$(NC)      - Build source distribution"
 	@echo "  $(YELLOW)validate$(NC)         - Validate package"
-	@echo "  $(YELLOW)publish$(NC)          - Publish to PyPI by token (emergency path; releases go through GitHub Releases)"
+	@echo "  $(YELLOW)publish$(NC)          - MANUAL FALLBACK: upload to PyPI by token from a checkout of the release tag"
+	@echo "                     (releases go through GitHub Releases; see CONTRIBUTING.md)"
 	@echo "  $(YELLOW)publish-test$(NC)     - Publish to Test PyPI"
 	@echo "  $(YELLOW)ci$(NC)               - Mirror the CI workflow: lint, type-check, both coverage-gated test runs"
 	@echo "  $(YELLOW)version$(NC)          - Show current version"
@@ -56,6 +57,7 @@ help:
 	@echo "  $(YELLOW)venv$(NC)             - Create virtual environment"
 	@echo "  $(YELLOW)venv-activate$(NC)    - Show command to activate venv"
 	@echo "  $(YELLOW)all$(NC)              - Run full pipeline (install, lint, test, build)"
+	@echo "  $(YELLOW)release$(NC)          - MANUAL FALLBACK: pre-publish checks, then publish (same tag guard)"
 
 # Create virtual environment
 .PHONY: venv
@@ -113,8 +115,11 @@ test:
 	$(PYTHON) -m pytest $(TEST_DIR) -v
 	@echo "$(GREEN)Tests completed!$(NC)"
 
-# Fast lane: unit, property and GUI tests only (~20 s). The markers are
-# defined in pyproject.toml.
+# Fast lane: unit, GUI and MCP tests (~20 s: ~13 s for the library and app,
+# ~5 s for the MCP suite). Everything marked `slow` is left out, which
+# includes the scan property tests in tests/scan/test_scan_properties.py --
+# run `make test` or `pytest tests/scan/test_scan_properties.py` for those.
+# The markers are defined in pyproject.toml.
 .PHONY: test-fast
 test-fast:
 	@echo "$(GREEN)Running the fast test lane (-m \"not slow\")...$(NC)"
@@ -202,15 +207,34 @@ build-sdist: clean
 .PHONY: validate
 validate: build
 	@echo "$(GREEN)Validating package...$(NC)"
-	$(PYTHON) -m twine check $(DIST_DIR)/*
+	$(PYTHON) -m twine check --strict $(DIST_DIR)/*
 	@echo "$(GREEN)Package validation completed!$(NC)"
 
-# Publish to PyPI by API token. This is the emergency path only: releases are
-# cut by publishing a GitHub Release, which .github/workflows/publish.yml
-# uploads to PyPI via trusted publishing (OIDC, no token) and then lists on
-# the MCP Registry. Use this target only if that workflow is unavailable.
+# Refuse to upload anything but a clean checkout of the tag `v<__version__>`.
+# publish.yml checks the tag against the version before its upload; this is
+# the same guard for the manual path, plus a clean tree so the files built are
+# the files tagged. It does not replace the workflow's other gate (a green
+# python-package.yml run on the commit): check that by hand.
+.PHONY: check-release-tag
+check-release-tag:
+	@version=$$($(PYTHON) -c "import $(PACKAGE_NAME); print($(PACKAGE_NAME).__version__)") && \
+	tag="v$$version" ; \
+	found=$$(git tag --points-at HEAD | xargs) ; \
+	if ! git tag --points-at HEAD | grep -qx "$$tag"; then \
+		echo "$(RED)HEAD is not tagged $$tag (found: $${found:-no tag}). Check out the release tag first.$(NC)"; exit 1; \
+	fi; \
+	if [ -n "$$(git status --porcelain --untracked-files=no)" ]; then \
+		echo "$(RED)The working tree has uncommitted changes; publish from a clean checkout of $$tag.$(NC)"; exit 1; \
+	fi; \
+	echo "$(GREEN)HEAD is $$tag, matching __version__ $$version.$(NC)"
+
+# Publish to PyPI by API token. MANUAL FALLBACK only: releases are cut by
+# publishing a GitHub Release, which .github/workflows/publish.yml uploads to
+# PyPI via trusted publishing (OIDC, no token) and then lists on the MCP
+# Registry. Use this target only if that workflow is unavailable, and note it
+# does not list the release on the MCP Registry.
 .PHONY: publish
-publish: validate
+publish: check-release-tag validate
 	@echo "$(YELLOW)Are you sure you want to publish to PyPI? [y/N]$(NC)" && read ans && [ $${ans:-N} = y ]
 	@echo "$(GREEN)Publishing to PyPI...$(NC)"
 	$(PYTHON) -m twine upload $(DIST_DIR)/*
@@ -332,9 +356,10 @@ info:
 	@echo "$(GREEN)Installed packages:$(NC)"
 	@$(PIP) list | grep -E "($(PACKAGE_NAME)|pytest|flake8|mypy|twine|build)"
 
-# Quick release workflow
+# Manual release (fallback for publish.yml; see `publish`). The tag guard runs
+# first so a mismatched checkout fails before the full pre-publish pipeline.
 .PHONY: release
-release: pre-publish publish
+release: check-release-tag pre-publish publish
 	@echo "$(GREEN)Release completed!$(NC)"
 
 .PHONY: release-test

{pymemoryeditor-3.2.0 → pymemoryeditor-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyMemoryEditor
-Version: 3.2.0
+Version: 3.3.1
 Summary: Read, write and scan process memory in a few lines of Python — Cheat Engine-style scans, pointer chains and AOB search on Windows, Linux and macOS.
 Project-URL: Homepage, https://github.com/JeanExtreme002/PyMemoryEditor
 Project-URL: Documentation, https://pymemoryeditor.readthedocs.io
@@ -37,27 +37,33 @@ Classifier: Topic :: System :: Monitoring
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Provides-Extra: app
-Requires-Dist: psutil<7,>=5.9; extra == 'app'
-Requires-Dist: pyside6>=6.5; extra == 'app'
+Requires-Dist: psutil<8,>=5.9; extra == 'app'
+Requires-Dist: pyside6<7,>=6.5; extra == 'app'
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: flake8; extra == 'dev'
 Requires-Dist: hypothesis; extra == 'dev'
 Requires-Dist: mcp<3,>=2; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: psutil<7,>=5.9; extra == 'dev'
-Requires-Dist: pyside6>=6.5; extra == 'dev'
+Requires-Dist: psutil<8,>=5.9; extra == 'dev'
+Requires-Dist: pyside6<7,>=6.5; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-qt; extra == 'dev'
 Requires-Dist: pytest-xdist; extra == 'dev'
-Requires-Dist: twine; extra == 'dev'
+Requires-Dist: twine>=7; extra == 'dev'
 Provides-Extra: mcp
 Requires-Dist: mcp<3,>=2; extra == 'mcp'
 Provides-Extra: speed
 Requires-Dist: numpy>=1.24; extra == 'speed'
 Provides-Extra: tests
+Requires-Dist: hypothesis; extra == 'tests'
+Requires-Dist: mcp<3,>=2; extra == 'tests'
+Requires-Dist: psutil<8,>=5.9; extra == 'tests'
+Requires-Dist: pyside6<7,>=6.5; extra == 'tests'
 Requires-Dist: pytest; extra == 'tests'
+Requires-Dist: pytest-cov; extra == 'tests'
+Requires-Dist: pytest-qt; extra == 'tests'
 Requires-Dist: pytest-xdist; extra == 'tests'
 Description-Content-Type: text/markdown
 

{pymemoryeditor-3.2.0 → pymemoryeditor-3.3.1}/PyMemoryEditor/__init__.py

@@ -8,7 +8,7 @@ Supported platforms: Windows, Linux and macOS (32-bit and 64-bit).
 """
 
 __author__ = "Jean Loui Bernard Silva de Jesus"
-__version__ = "3.2.0"
+__version__ = "3.3.1"
 
 import logging
 import sys

{pymemoryeditor-3.2.0 → pymemoryeditor-3.3.1}/PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -3,13 +3,12 @@
 Shared base for the read-only, auto-refreshing table dialogs (Memory Map,
 Modules, Threads).
 
-All three did the same dance — run a one-shot read off the UI thread, repopulate
+All three do the same dance — run a one-shot read off the UI thread, repopulate
 a sortable table when it returns, poll on a timer, and tear the worker down
-safely on close — each with its own near-identical ``_*Worker(QThread)`` and
-lifecycle boilerplate. That triplicated the fiddly bits (the in-flight guard
-that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
-copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
-only what differs: how to fetch the data, and how to render it.
+safely on close. This owns that lifecycle once, so the fiddly bits (the
+in-flight guard that self-throttles the poll, the detach-on-shutdown safety)
+live in one place; subclasses provide only what differs: how to fetch the
+data, and how to render it.
 
 It also owns *when* a failure is worth interrupting the user — see
 :meth:`AutoRefreshTableDialog._handle_failed`.
@@ -182,7 +181,7 @@ class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
         Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
         dialog. A modal runs a nested event loop, so the timer fires again while
         it is up and the failures stack — hundreds of focus-stealing dialogs the
-        user could only escape by killing the app from another TTY (issue #74).
+        user could only escape by killing the app from another TTY.
 
         Reporting is therefore tied to the two moments where a failure changes
         what the user sees: the **first** fetch (empty window) and the one that

{pymemoryeditor-3.2.0 → pymemoryeditor-3.3.1}/PyMemoryEditor/app/_widgets.py

@@ -2,8 +2,8 @@
 
 """Small Qt widgets shared between dialogs.
 
-Centralises tiny helpers (numeric sort items, hex address parsing) that
-previously appeared duplicated across several dialog modules.
+Centralises tiny helpers (numeric sort items, hex address parsing) shared by
+several dialog modules.
 """
 
 import threading
@@ -46,9 +46,9 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
         cancel()
     try:
         # The four-argument static form on purpose: bare `worker.disconnect()`
-        # raises TypeError in PySide6 (so this except swallowed it and nothing
-        # was disconnected), and `worker.disconnect(worker)` only drops
-        # connections whose *receiver* is the worker — ours belong to the dialog.
+        # raises TypeError in PySide6, and `worker.disconnect(worker)` only
+        # drops connections whose *receiver* is the worker — ours belong to the
+        # dialog.
         QObject.disconnect(worker, None, None, None)
     except (RuntimeError, TypeError):
         pass
@@ -141,8 +141,8 @@ class TearsDownOnClose:
     ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
     "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
     ``done()``, which hides the dialog and emits ``finished`` *without* any
-    close event — so a teardown living in ``closeEvent`` never ran, and the
-    dialog kept polling, hidden and unreachable.
+    close event — so a teardown living in ``closeEvent`` would never run, and
+    the dialog would keep polling, hidden and unreachable.
 
     Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
     whichever way the dialog is dismissed, and must precede ``QDialog`` in the

{pymemoryeditor-3.2.0 → pymemoryeditor-3.3.1}/PyMemoryEditor/app/application.py

@@ -542,8 +542,7 @@ def main(argv=None):
 
     ``argv`` defaults to ``sys.argv`` so packaging tools (which call
     ``main()`` with no arguments) keep working. Tests and embedders can pass
-    an explicit list — previously a positional ``*args`` was accepted but
-    ignored, which made the parameter meaningless.
+    an explicit list.
 
     Terminal users want Ctrl+C to kill the app, which takes a process-wide
     signal change — see :func:`main_cli`, the console-script entry point.
@@ -602,8 +601,8 @@ def main(argv=None):
                 # Change Process… released that one and attached the window
                 # to another.
                 window.process.close()
-            except Exception:
-                pass
+            except Exception:  # noqa: BLE001 — exiting anyway; keep the cause
+                _LOG.debug("Closing the process handle on exit failed", exc_info=True)
 
 
 def main_cli(argv=None):
@@ -611,9 +610,9 @@ def main_cli(argv=None):
     Entry point for the ``pymemoryeditor`` console script and ``python -m``.
 
     Qt's event loop blocks inside C++, so Python's default SIGINT handler only
-    runs once the interpreter next regains control. In practice it raised
+    runs once the interpreter next regains control. In practice it raises
     KeyboardInterrupt inside our own _PointerCursorFilter.eventFilter override,
-    where PySide6 swallows it and merely prints a traceback (#76). Hand SIGINT
+    where PySide6 swallows it and merely prints a traceback. Hand SIGINT
     back to the OS for the duration of the run so Ctrl+C from a terminal
     terminates the app immediately.
 

{pymemoryeditor-3.2.0 → pymemoryeditor-3.3.1}/PyMemoryEditor/app/cheat_poll_worker.py

@@ -56,8 +56,8 @@ class _CheatPollWorker(QThread):
     with the current ``{key: "ErrorType: message"}`` map. The signal fires only
     when that set *changes* (a freeze starts or stops failing), so the UI gets a
     persistent cue without 10 Hz spam, and the first failure of each entry is
-    logged once. Previously the exception was swallowed silently, so a freeze
-    that never landed looked identical to one that did.
+    logged once. Swallowing the exception instead would make a freeze that
+    never landed look identical to one that did.
     """
 
     values_ready = Signal(object)  # list[tuple[int, type, int, Any]]
@@ -96,9 +96,9 @@ class _CheatPollWorker(QThread):
     ) -> None:
         """Queue a one-shot manual write to be performed on the worker thread.
 
-        The cheat table's inline value edits used to call
-        ``write_process_memory`` directly on the UI thread, freezing the UI when
-        the target was slow or the page faulted. Routing them here keeps the
+        The cheat table's inline value edits come through here: calling
+        ``write_process_memory`` directly on the UI thread would freeze the UI
+        when the target is slow or the page faults. Routing them here keeps the
         syscall off the UI thread; a write that fails comes back via the
         ``write_failed`` signal. Latency is at most one tick (~100 ms), which is
         imperceptible for a manual edit.
@@ -115,20 +115,21 @@ class _CheatPollWorker(QThread):
         with QMutexLocker(self._mutex):
             self._stop = True
 
-    def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
-        """Perform and clear every queued manual write.
+    def _take_pending_writes(self) -> List[Tuple[int, type, int, Any]]:
+        """Detach the queued writes. The caller holds ``self._mutex``."""
+        pending = self._pending_writes
+        self._pending_writes = []
+        return pending
+
+    def _perform_writes(
+        self, pending: List[Tuple[int, type, int, Any]]
+    ) -> List[Tuple[int, type, int, str]]:
+        """Perform manual writes taken with :meth:`_take_pending_writes`.
 
         Returns one ``(address, pytype, length, message)`` tuple per write that
-        failed, so ``run`` can surface it via ``write_failed``. Reads and clears
-        the queue under the lock, then runs the syscalls outside it so a slow
-        write never blocks a UI thread enqueuing the next edit.
+        failed, so ``run`` can surface it via ``write_failed``. Runs outside the
+        lock, so a slow write never blocks a UI thread enqueuing the next edit.
         """
-        with QMutexLocker(self._mutex):
-            if not self._pending_writes:
-                return []
-            pending = self._pending_writes
-            self._pending_writes = []
-
         failures: List[Tuple[int, type, int, str]] = []
         for address, pytype, length, value in pending:
             if self._stopping():
@@ -146,10 +147,15 @@ class _CheatPollWorker(QThread):
 
     def run(self) -> None:
         while True:
+            # Snapshot and queued writes are taken together, under one lock:
+            # an inline edit on a frozen row publishes the new frozen value and
+            # queues its write back to back, and a snapshot copied before that
+            # pair would re-freeze the old value over the write just drained.
             with QMutexLocker(self._mutex):
                 if self._stop:
                     return
                 snapshot = list(self._snapshot)
+                pending = self._take_pending_writes()
 
             # Never let an exception escape the loop body: a QThread whose
             # run() raises dies silently, and the table would then stop
@@ -158,7 +164,7 @@ class _CheatPollWorker(QThread):
             try:
                 # Apply queued manual writes before reading, so a just-typed
                 # value lands and is read back as the new current value this tick.
-                for failure in self._drain_pending_writes():
+                for failure in self._perform_writes(pending):
                     self.write_failed.emit(failure)
 
                 if snapshot: