PyMemoryEditor 3.0.2__tar.gz → 3.2.0__tar.gz

{pymemoryeditor-3.0.2 → pymemoryeditor-3.2.0}/CONTRIBUTING.md

@@ -22,9 +22,15 @@ 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                   # pytest tests -v
+make test-fast              # pytest tests -m "not slow"  (~20 s: unit, property and GUI 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.
+
 ## Linting
 
 ```bash
@@ -46,11 +52,13 @@ make pre-commit             # lint + type-check + test
 ```
 
 The CI pipeline runs the same lint, mypy and tests, and blocks merges on failure.
-The test matrix runs on Ubuntu, Windows and macOS across multiple Python versions, so
-all three platform backends are exercised on every push. A dedicated job also
-runs the suite with the `speed` extra (NumPy) to keep the vectorized scan path
-covered. Even so, contributors touching a specific backend are encouraged to
-run `pytest tests` locally on that platform before submitting.
+The library matrix runs Python 3.10–3.15 on Ubuntu and Windows plus a single
+Python 3.12 cell 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
 
@@ -63,6 +71,7 @@ PyMemoryEditor/
 ├── 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
 ```
 
@@ -84,6 +93,12 @@ The public alias `OpenProcess` is chosen at import time in `__init__.py` based o
 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`.
 
 ## Reporting bugs
 

{pymemoryeditor-3.0.2 → pymemoryeditor-3.2.0}/Makefile

@@ -30,7 +30,9 @@ help:
 	@echo "  $(YELLOW)install-app$(NC)      - Install dependencies to run the PyMemoryEditor App"
 	@echo "  $(YELLOW)run-app$(NC)          - Run the PyMemoryEditor App"
 	@echo "  $(YELLOW)install-dev$(NC)      - Install development dependencies"
-	@echo "  $(YELLOW)test$(NC)             - Run tests"
+	@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-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"
 	@echo "  $(YELLOW)lint$(NC)             - Run linter (flake8)"
@@ -40,8 +42,9 @@ 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"
+	@echo "  $(YELLOW)publish$(NC)          - Publish to PyPI by token (emergency path; releases go through GitHub Releases)"
 	@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"
 	@echo "  $(YELLOW)check-deps$(NC)       - Check for outdated dependencies"
 	@echo "  $(YELLOW)update-deps$(NC)      - Update dependencies"
@@ -103,13 +106,30 @@ install:
 	$(PIP) install -e .
 	@echo "$(GREEN)Package installed successfully!$(NC)"
 
-# Run tests
+# Run tests (everything, including the live scans marked `slow`/`scan_heavy`)
 .PHONY: test
 test:
 	@echo "$(GREEN)Running tests...$(NC)"
 	$(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.
+.PHONY: test-fast
+test-fast:
+	@echo "$(GREEN)Running the fast test lane (-m \"not slow\")...$(NC)"
+	$(PYTHON) -m pytest $(TEST_DIR) -m "not slow"
+	@echo "$(GREEN)Fast tests completed!$(NC)"
+
+# The MCP server suite. CI runs it as its own job (`build-mcp`), with the
+# pytest-qt plugin disabled because it imports Qt at startup and no test here
+# needs it.
+.PHONY: test-mcp
+test-mcp:
+	@echo "$(GREEN)Running the MCP server tests...$(NC)"
+	$(PYTHON) -m pytest $(TEST_DIR)/mcp_server -p no:pytest-qt
+	@echo "$(GREEN)MCP tests completed!$(NC)"
+
 # Run tests with verbose output
 .PHONY: test-verbose
 test-verbose:
@@ -185,7 +205,10 @@ validate: build
 	$(PYTHON) -m twine check $(DIST_DIR)/*
 	@echo "$(GREEN)Package validation completed!$(NC)"
 
-# Publish to PyPI
+# 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.
 .PHONY: publish
 publish: validate
 	@echo "$(YELLOW)Are you sure you want to publish to PyPI? [y/N]$(NC)" && read ans && [ $${ans:-N} = y ]
@@ -238,11 +261,12 @@ install-docs:
 	$(PIP) install -e .
 	@echo "$(GREEN)Docs dependencies installed!$(NC)"
 
-# Build the HTML documentation. Output lands in $(DOCS_BUILD_DIR).
+# Build the HTML documentation. Output lands in $(DOCS_BUILD_DIR). Warnings
+# are errors, the same as the `docs` job in python-package.yml.
 .PHONY: docs
 docs:
 	@echo "$(GREEN)Building HTML documentation...$(NC)"
-	$(PYTHON) -m sphinx -b html $(DOCS_DIR) $(DOCS_BUILD_DIR)
+	$(PYTHON) -m sphinx -W --keep-going -b html $(DOCS_DIR) $(DOCS_BUILD_DIR)
 	@echo "$(GREEN)Documentation generated at $(DOCS_BUILD_DIR)/index.html$(NC)"
 
 # Live-reload docs server — rebuilds on every save and reloads the browser.
@@ -281,9 +305,19 @@ pre-commit: lint type-check test
 pre-publish: all security
 	@echo "$(GREEN)Pre-publish checks completed!$(NC)"
 
-# CI/CD targets
+# CI/CD targets. Mirrors .github/workflows/python-package.yml: the library
+# and app tests are gated on the library's coverage (.coveragerc-lib), the
+# MCP suite on its own (.coveragerc-mcp), with the same floors as the
+# workflow. Keep the two in sync when either changes.
 .PHONY: ci
-ci: install-dev install lint type-check test build validate
+ci: install-dev install lint type-check
+	@echo "$(GREEN)Running the library/app suite with the CI coverage gate...$(NC)"
+	QT_QPA_PLATFORM=offscreen $(PYTHON) -m pytest $(TEST_DIR) --ignore=$(TEST_DIR)/mcp_server --maxfail=10 \
+		--cov=$(PACKAGE_NAME) --cov-config=.coveragerc-lib --cov-report=term --cov-fail-under=62
+	@echo "$(GREEN)Running the MCP suite with the CI coverage gate...$(NC)"
+	$(PYTHON) -m pytest $(TEST_DIR)/mcp_server -p no:pytest-qt --maxfail=10 \
+		--cov=$(PACKAGE_NAME)/mcp --cov-config=.coveragerc-mcp --cov-report=term --cov-fail-under=85
+	$(MAKE) build validate
 	@echo "$(GREEN)CI pipeline completed!$(NC)"
 
 # Show package info

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyMemoryEditor
-Version: 3.0.2
+Version: 3.2.0
 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
@@ -26,6 +26,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Games/Entertainment
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Security

{pymemoryeditor-3.0.2 → pymemoryeditor-3.2.0}/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.0.2"
+__version__ = "3.2.0"
 
 import logging
 import sys

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

@@ -6,9 +6,10 @@ Centralises tiny helpers (numeric sort items, hex address parsing) that
 previously appeared duplicated across several dialog modules.
 """
 
+import threading
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import QObject, Qt, QThread
+from PySide6.QtCore import QCoreApplication, QObject, Qt, QThread, QTimer
 from PySide6.QtGui import QStandardItem
 
 
@@ -84,6 +85,56 @@ def _reap_detached_worker(worker: QThread) -> None:
     worker.deleteLater()
 
 
+def detached_workers_running() -> bool:
+    """Whether any worker that outlived its owner is still running."""
+    return any(worker.isRunning() for worker in _DETACHED_WORKERS)
+
+
+def run_after_detached_workers(callback: Callable[[], None]) -> None:
+    """Run ``callback`` once every currently detached worker has finished.
+
+    A detached worker can still be inside a backend syscall on the process it
+    was given, so releasing that process (``close()``) must wait for it: on
+    Windows the handle value can be recycled for an unrelated object the moment
+    it is closed, and a late write from the cheat poller would land there.
+    With no worker still running, ``callback`` runs immediately.
+    """
+    pending = [worker for worker in _DETACHED_WORKERS if worker.isRunning()]
+    if not pending:
+        callback()
+        return
+
+    remaining = set(pending)
+    done = False
+    # `finished` can be delivered from the worker's own thread while the
+    # isFinished() sweep below runs on this one: guard the bookkeeping so the
+    # callback (a handle close) runs exactly once.
+    guard = threading.Lock()
+    # Whichever thread notices the last worker finishing, the callback is
+    # posted to the GUI thread (the application object lives there), so it
+    # never runs concurrently with the GUI setting up the next process.
+    gui = QCoreApplication.instance()
+
+    def _on_finished(worker: QThread) -> None:
+        nonlocal done
+        with guard:
+            remaining.discard(worker)
+            if remaining or done:
+                return
+            done = True
+        if gui is None:
+            callback()
+        else:
+            QTimer.singleShot(0, gui, callback)
+
+    for worker in pending:
+        worker.finished.connect(lambda w=worker: _on_finished(w))
+    # Same race as detach_worker: one may have finished before its connect.
+    for worker in pending:
+        if worker.isFinished():
+            _on_finished(worker)
+
+
 class TearsDownOnClose:
     """Mixin that runs a dialog's teardown on *every* way out, not just close.
 
@@ -166,45 +217,76 @@ class NumericItem(QStandardItem):
             return self.text() < other.text()
 
 
+_HEX_DIGITS = frozenset("0123456789abcdefABCDEF")
+
+
+def _parse_hex_digits(text: str) -> Optional[int]:
+    """``text`` as an unsigned hex number, or None. Accepts a ``0x`` prefix."""
+    cleaned = text.strip()
+    if cleaned[:2].lower() == "0x":
+        cleaned = cleaned[2:]
+    # Explicit digit check rather than relying on int(): int(x, 16) also takes
+    # "1_0" (underscore separators) and leading sign/whitespace, none of which
+    # is a hex address a user meant to type.
+    if not cleaned or not _HEX_DIGITS.issuperset(cleaned):
+        return None
+    return int(cleaned, 16)
+
+
 def parse_hex_address(text: str) -> Optional[int]:
     """Parse a hex address string (with or without 0x prefix) into an int.
 
-    Returns None on any parse error. Whitespace is tolerated.
+    Addresses are unsigned: a leading sign makes the string invalid. Returns
+    None on any parse error. Surrounding whitespace is tolerated.
     """
     if not text:
         return None
-    cleaned = text.strip()
-    if not cleaned:
+    return _parse_hex_digits(text)
+
+
+def parse_hex_offset(text: str) -> Optional[int]:
+    """Parse a hex pointer-chain offset, which unlike an address may be negative.
+
+    ``"-0x10"`` → -16, ``"10"`` → 16. Returns None on any parse error.
+    """
+    if not text:
         return None
-    if cleaned.lower().startswith("0x"):
-        cleaned = cleaned[2:]
-    try:
-        return int(cleaned, 16)
-    except (TypeError, ValueError):
+    cleaned = text.strip()
+    negative = cleaned.startswith("-")
+    if negative or cleaned.startswith("+"):
+        cleaned = cleaned[1:]
+    parsed = _parse_hex_digits(cleaned)
+    if parsed is None:
         return None
+    return -parsed if negative else parsed
+
+
+def format_size(size: int) -> str:
+    """Human-readable byte count (``1536`` → ``"1.5 KB"``), binary units."""
+    units = ["B", "KB", "MB", "GB", "TB"]
+    s = float(size)
+    for unit in units:
+        if s < 1024 or unit == units[-1]:
+            return f"{s:,.1f} {unit}" if unit != "B" else f"{int(s):,} B"
+        s /= 1024
+    return f"{size:,} B"
 
 
 def parse_offsets(texts: Iterable[str]) -> Optional[List[int]]:
     """Parse pointer-chain offset tokens (in order) from raw field strings.
 
     Empty tokens are skipped; every remaining token is read as hex (with or
-    without ``0x``). Returns ``None`` if any non-empty token can't be parsed —
-    the caller treats that as "invalid chain, do nothing". Pure (no Qt) so it
-    can be unit-tested directly.
+    without ``0x``, optionally negative). Returns ``None`` if any non-empty
+    token can't be parsed — the caller treats that as "invalid chain, do
+    nothing". Pure (no Qt) so it can be unit-tested directly.
     """
     offsets: List[int] = []
     for text in texts:
         if not text:
             continue
-        parsed = parse_hex_address(text)
+        parsed = parse_hex_offset(text)
         if parsed is None:
-            # parse_hex_address handles the 0x form; fall back to a plain hex
-            # int for ambiguous tokens like "10" (the dialog treats offsets as
-            # hex throughout).
-            try:
-                parsed = int(text, 16)
-            except ValueError:
-                return None
+            return None
         offsets.append(parsed)
     return offsets
 
@@ -230,13 +312,10 @@ def resolve_base_address(
         module_name = name_part.strip().strip('"').strip("'").strip()
         offset = parse_hex_address(offset_part)
         if offset is None:
-            try:
-                offset = int(offset_part.strip(), 16)
-            except ValueError:
-                return None, (
-                    "The offset after '+' must be hex "
-                    '(e.g. "game.exe"+0x10F4F4).'
-                )
+            return None, (
+                "The offset after '+' must be hex "
+                '(e.g. "game.exe"+0x10F4F4).'
+            )
         module_base = module_lookup(module_name)
         if module_base is None:
             return None, (

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

@@ -5,6 +5,7 @@ Entry point for the PyMemoryEditor App.
 A Cheat-Engine-inspired memory scanner built on PySide6 (Qt for Python),
 working on Windows, Linux and macOS.
 """
+import logging
 import sys
 import signal
 import contextlib
@@ -266,11 +267,6 @@ def apply_theme(app, theme_id: str = DEFAULT_THEME_ID) -> None:
     )
 
 
-def apply_dark_theme(app) -> None:
-    """Backward-compatible shim that applies the default dark theme."""
-    apply_theme(app, DEFAULT_THEME_ID)
-
-
 STYLE_SHEET = """
 QToolTip {
     color: %(text)s;
@@ -484,10 +480,66 @@ def _scoped_signal_handler(signalnum, handler):
             signal.signal(signalnum, previous_handler)
 
 
+_LOG = logging.getLogger(__name__)
+
+
+def _qt_excepthook(exc_type, exc_value, exc_tb) -> None:
+    """``sys.excepthook`` for the duration of the Qt event loop.
+
+    PySide6 catches an exception raised inside a slot, hands it to
+    ``sys.excepthook`` and carries on — with the default hook that is a
+    traceback on stderr the user never sees, and the action they clicked
+    silently does nothing. Log it (so the Log Console gets it) and show it.
+    KeyboardInterrupt is left to the interpreter's hook: it is the host's
+    signal, not an app bug.
+    """
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_tb)
+        return
+    _LOG.error(
+        "Unhandled exception in the UI", exc_info=(exc_type, exc_value, exc_tb)
+    )
+    try:
+        from PySide6.QtCore import QThread
+        from PySide6.QtWidgets import QApplication, QMessageBox
+
+        app = QApplication.instance()
+        # Widgets may only be created on the GUI thread. PySide6 routes an
+        # exception escaping a QThread.run() through this same hook, from
+        # that worker thread, so a dialog there would be undefined behaviour.
+        # The log line above is the whole report in that case.
+        if app is None or QThread.currentThread() != app.thread():
+            return
+        QMessageBox.critical(
+            None,
+            "Unexpected error",
+            "%s: %s\n\nThe full traceback is in Tools → Log Console."
+            % (exc_type.__name__, exc_value),
+        )
+    except Exception:  # noqa: BLE001 — a hook must never raise
+        pass
+
+
+@contextlib.contextmanager
+def _scoped_excepthook(hook):
+    """Install ``hook`` as ``sys.excepthook`` for the block, then restore."""
+    previous = sys.excepthook
+    sys.excepthook = hook
+    try:
+        yield
+    finally:
+        sys.excepthook = previous
+
+
 def main(argv=None):
     """
     Run the app. Safe to call in-process: it installs no signal handler.
 
+    While the event loop runs, ``sys.excepthook`` is swapped for one that logs
+    and shows slot exceptions (PySide6 routes them there and continues), and
+    restored on the way out — the loop owns the thread for that time, so an
+    embedder's own hook is not observable from inside it anyway.
+
     ``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
@@ -509,6 +561,7 @@ def main(argv=None):
     from PySide6.QtCore import QSettings
     from PySide6.QtWidgets import QApplication
 
+    from ._widgets import detached_workers_running
     from .main_window import MainWindow
     from .open_process_dialog import OpenProcessDialog
 
@@ -536,14 +589,21 @@ def main(argv=None):
     window = MainWindow(process)
     window.show()
     try:
-        app.exec()
+        with _scoped_excepthook(_qt_excepthook):
+            app.exec()
     finally:
-        try:
-            # `process` is only the handle the picker opened; File → Change
-            # Process… released that one and attached the window to another.
-            window.process.close()
-        except Exception:
-            pass
+        # A worker that blew its join on close is detached, not stopped, and
+        # may still be inside a syscall on this handle; closing it now could
+        # hand its value to an unrelated object mid-write. The process is
+        # exiting, so leave it to the OS, which releases every handle then.
+        if not detached_workers_running():
+            try:
+                # `process` is only the handle the picker opened; File →
+                # Change Process… released that one and attached the window
+                # to another.
+                window.process.close()
+            except Exception:
+                pass
 
 
 def main_cli(argv=None):

{pymemoryeditor-3.0.2 → pymemoryeditor-3.2.0}/PyMemoryEditor/app/cheat_table.py

@@ -56,11 +56,6 @@ from .value_types import (
 )
 
 
-# Re-exported for backward compatibility with callers that imported the
-# poll-interval constant from this module before the split.
-_TICK_INTERVAL_MS = TICK_INTERVAL_MS
-
-
 class CheatTable(QWidget):
     """Bottom pane: saved addresses, freezing, manual edits."""
 
@@ -80,6 +75,14 @@ class CheatTable(QWidget):
         self._suspend_signals = False
         # Before _build_ui(), which connects cellChanged — a path that reads it.
         self._poller_stopped = False
+        # Set while the owner knows the target is gone (see set_polling_paused):
+        # the poller idles on an empty snapshot and edits are refused instead
+        # of being queued against a dead handle.
+        self._paused = False
+        # Write failures reported by the poller since the last flush. They are
+        # shown in one dialog per event-loop burst, so a bulk edit whose every
+        # row fails (target exited) produces one message, not one per row.
+        self._pending_write_failures: List[Tuple[int, str]] = []
 
         self._build_ui()
 
@@ -130,6 +133,31 @@ class CheatTable(QWidget):
         self.shutdown()
         super().closeEvent(event)
 
+    def set_polling_paused(self, paused: bool) -> None:
+        """Idle the poll loop while the target is known to be gone.
+
+        The owning window's heartbeat calls this when the process exits. The
+        publish timer stops and the worker is handed an empty snapshot, so it
+        sleeps through its ticks instead of hitting a dead handle ten times a
+        second (and, on a recycled PID, a stranger's memory). Entries are kept:
+        the table still shows the last values read. Resuming re-publishes.
+        """
+        if self._poller_stopped or paused == self._paused:
+            return
+        self._paused = paused
+        if paused:
+            self._publish_timer.stop()
+            self._poller.update_snapshot([])
+        else:
+            self._publish_snapshot_to_worker()
+            self._publish_timer.start()
+
+    def is_polling_paused(self) -> bool:
+        return self._paused
+
+    def entry_count(self) -> int:
+        return len(self._entries)
+
     def _build_ui(self) -> None:
         layout = QVBoxLayout(self)
         # Small top inset so the toolbar buttons don't sit flush against the
@@ -208,8 +236,17 @@ class CheatTable(QWidget):
         # spotted from the table, so the floor is enforced once, at the door,
         # rather than at each of those call sites. (The AOB pattern spec is the
         # one whose declared length is 0 — the scanner derives its real width
-        # from the pattern.)
-        entry.length = max(1, int(entry.length))
+        # from the pattern.) The ceiling is the same one every other width
+        # field enforces (MAX_ENTRY_LENGTH); only a JSON import can carry more,
+        # and silently resizing its entry would alter what the user exports
+        # next, so that is refused -- the import loop reports and skips it.
+        length = int(entry.length)
+        if length > MAX_ENTRY_LENGTH:
+            raise ValueError(
+                "entry at 0x%X has length %d, over the %d-byte maximum"
+                % (entry.address, length, MAX_ENTRY_LENGTH)
+            )
+        entry.length = max(1, length)
 
         # If the address already exists, just refresh its description/type.
         for existing in self._entries:
@@ -236,7 +273,16 @@ class CheatTable(QWidget):
         length: int,
         description: str = "",
     ) -> None:
-        """Convenience used by the scanner panel to bulk-promote rows."""
+        """Convenience used by the scanner panel to bulk-promote rows.
+
+        :raises ValueError: if ``length`` is over ``MAX_ENTRY_LENGTH`` -- checked
+            once up front so a refusal adds none of the rows rather than some.
+        """
+        if int(length) > MAX_ENTRY_LENGTH:
+            raise ValueError(
+                "length %d is over the %d-byte maximum for a cheat-table entry"
+                % (int(length), MAX_ENTRY_LENGTH)
+            )
         for addr in addresses:
             self.add_entry(
                 CheatEntry(
@@ -356,8 +402,9 @@ class CheatTable(QWidget):
             # next poll tick reads the value back and corrects the cell if the
             # write didn't take, and an outright failure returns via
             # write_failed → _on_write_failed.
-            # Nothing to route it to once shutdown() handed the worker over.
-            if self._poller_stopped:
+            # Nothing to route it to once shutdown() handed the worker over,
+            # and nothing to write to while the target is known to be gone.
+            if self._poller_stopped or self._paused:
                 return
             self._poller.request_write(
                 entry.address, entry.spec.pytype, entry.length, value
@@ -469,13 +516,33 @@ class CheatTable(QWidget):
     def _on_write_failed(self, failure) -> None:
         """Surface a manual value write that failed on the worker thread.
 
-        The write is now async (queued onto the poll worker), so its failure
-        arrives here via the ``write_failed`` signal rather than inline. The
-        optimistic cell update made when the edit was queued is corrected by the
-        next poll tick, which reads back the unchanged value.
+        Writes are async (queued onto the poll worker), so a failure arrives
+        here via the ``write_failed`` signal rather than inline. The optimistic
+        cell update made when the edit was queued is corrected by the next poll
+        tick, which reads back the unchanged value.
+
+        Failures are collected and shown by ``_flush_write_failures`` on the
+        next event-loop pass: the worker drains a bulk edit's queue in one
+        tick, so its failures land here back to back and read as one report.
         """
-        _address, _pytype, _length, message = failure
-        QMessageBox.critical(self, "Write Failed", message)
+        address, _pytype, _length, message = failure
+        if not self._pending_write_failures:
+            QTimer.singleShot(0, self._flush_write_failures)
+        self._pending_write_failures.append((address, message))
+
+    def _flush_write_failures(self) -> None:
+        failures = self._pending_write_failures
+        self._pending_write_failures = []
+        if not failures:
+            return
+        if len(failures) == 1:
+            QMessageBox.critical(self, "Write Failed", failures[0][1])
+            return
+        preview = "\n".join(f"0x{addr:X}: {msg}" for addr, msg in failures[:10])
+        extra = "" if len(failures) <= 10 else f"\n…and {len(failures) - 10} more."
+        QMessageBox.critical(
+            self, "Write Failed", f"{len(failures)} write(s) failed:\n\n{preview}{extra}"
+        )
 
     def _editing_row(self) -> int:
         """Return the row currently being edited, or -1 if none."""
@@ -603,15 +670,20 @@ class CheatTable(QWidget):
                     if spec.accepts_length_override:
                         entry.length = effective_length
 
-                    try:
-                        self._process.write_process_memory(
-                            entry.address, spec.pytype, entry.length, value
-                        )
-                    except Exception as exc:  # noqa: BLE001
+                    # Same path as an inline edit: the syscall runs on the poll
+                    # worker, never on the UI thread (a slow target or a page
+                    # fault would freeze the interface for every row). A write
+                    # that fails comes back via write_failed → one coalesced
+                    # dialog; the optimistic update below is corrected by the
+                    # next tick's read-back.
+                    if self._poller_stopped or self._paused:
                         failures.append(
-                            (entry.address, f"{type(exc).__name__}: {exc}")
+                            (entry.address, "the target process is no longer available")
                         )
                         continue
+                    self._poller.request_write(
+                        entry.address, spec.pytype, entry.length, value
+                    )
 
                     entry.last_value = value
                     if entry.frozen:
@@ -873,7 +945,7 @@ def prompt_for_manual_entry(parent) -> Optional[CheatEntry]:
             "Buffer length (bytes):",
             value=spec.length or 4,
             minValue=1,
-            maxValue=1024,
+            maxValue=MAX_ENTRY_LENGTH,
         )
         if not ok:
             return None