PyMemoryEditor 2.1.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

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__ = "2.1.0"
+__version__ = "2.2.0"
 
 import logging
 import sys

PyMemoryEditor/app/cheat_table.py

@@ -48,7 +48,12 @@ from PyMemoryEditor import AbstractProcess
 from ._widgets import parse_hex_address, shutdown_worker_thread
 from .cheat_entry import CheatEntry
 from .cheat_poll_worker import TICK_INTERVAL_MS, _CheatPollWorker
-from .value_types import VALUE_TYPES, ValueTypeSpec, find_spec, parse_value
+from .value_types import (
+    VALUE_TYPES,
+    ValueTypeSpec,
+    find_spec,
+    parse_value_for_write,
+)
 
 
 # Re-exported for backward compatibility with callers that imported the
@@ -197,10 +202,25 @@ class CheatTable(QWidget):
         delete_shortcut.activated.connect(self._on_remove_selected)
 
     def add_entry(self, entry: CheatEntry) -> None:
+        # Every entry enters here, whichever way it was created — promoted from
+        # a scan, from a pointer dialog, added by hand, or loaded from JSON. A
+        # zero-width buffer reads back empty on every poll tick and can't be
+        # 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))
+
         # If the address already exists, just refresh its description/type.
         for existing in self._entries:
             if existing.address == entry.address:
                 existing.description = entry.description or existing.description
+                # Re-promoting an address that is already in the table is the
+                # third place a spec_label changes, and the cached value has to
+                # go with it here too — _rebuild formats it through the new
+                # spec on the way out of this method.
+                if entry.spec_label != existing.spec_label:
+                    _forget_value_read_as_another_type(existing)
                 existing.spec_label = entry.spec_label
                 existing.length = entry.length
                 self._rebuild()
@@ -257,7 +277,11 @@ class CheatTable(QWidget):
         self._table.setItem(row, self.COL_ADDRESS, addr)
 
         type_label = entry.spec_label
-        if entry.spec.accepts_length_override:
+        # Show the width whenever it belongs to the entry rather than to the
+        # spec. An IDA pattern declares none (length 0) yet carries a real one
+        # here — writes are refused against it — so hiding it left the user
+        # told to "widen the entry" with no way to see what it holds.
+        if entry.spec.accepts_length_override or not entry.spec.length:
             type_label += f"  · {entry.length}B"
         type_item = QTableWidgetItem(type_label)
         type_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
@@ -312,7 +336,9 @@ class CheatTable(QWidget):
                 # Treat empty as "unfreeze and clear" — no-op.
                 return
             try:
-                value, _length = parse_value(entry.spec, text, entry.length)
+                value, _length = parse_value_for_write(
+                    entry.spec, text, entry.length, entry.last_value
+                )
             except ValueError as exc:
                 QMessageBox.warning(self, "Invalid Value", str(exc))
                 self._suspend_signals = True
@@ -390,6 +416,13 @@ class CheatTable(QWidget):
                     continue
                 entry = self._entries[row]
                 entry.last_value = value
+                # A frozen row whose baseline was dropped — its type changed,
+                # so what the old spec had read no longer means anything —
+                # re-adopts the first value read under the new one. The poll
+                # worker skips a frozen entry with no frozen_value, so without
+                # this the Active box stays ticked while nothing is written.
+                if entry.frozen and entry.frozen_value is None:
+                    entry.frozen_value = value
                 self._update_value_cell(row, entry)
         finally:
             self._suspend_signals = False
@@ -528,16 +561,40 @@ class CheatTable(QWidget):
                 if plan.description is not None:
                     entry.description = plan.description
 
-                if plan.spec is not None:
+                # What the row was showing before this plan touched it. A type
+                # change forgets it, but a write in the same pass still needs
+                # it: an IDA '?' keeps the byte that is already there, and
+                # Byte Array → AOB doesn't change what those bytes mean.
+                # parse_value_for_write ignores it when the type genuinely
+                # changed shape, so a stale int can't be misread as bytes.
+                current = entry.last_value
+                retyped = False
+                if plan.spec is not None and plan.spec.label != entry.spec_label:
+                    retyped = True
                     entry.spec_label = plan.spec.label
+                    _forget_value_read_as_another_type(entry)
+                if plan.spec is not None:
                     if not plan.spec.accepts_length_override:
-                        entry.length = plan.spec.length
+                        # `or entry.length`: the AOB pattern spec declares a
+                        # length of 0 — the scanner derives a match's width from
+                        # the pattern, and an entry has none to derive from — so
+                        # keep the width it already has.
+                        entry.length = plan.spec.length or entry.length
 
                 if plan.value_text is not None:
                     spec = entry.spec
+                    # A retype to a variable-width spec re-sizes the entry from
+                    # the value, rather than inheriting the width of the type it
+                    # replaced. Otherwise three Int32 rows retyped to String
+                    # with "hello" all fail on "the entry holds 4 — widen it
+                    # first", and the bulk dialog has no width field, nor does
+                    # a multi-row selection offer one: a dead end.
+                    cap: Optional[int] = entry.length
+                    if retyped and spec.accepts_length_override:
+                        cap = None
                     try:
-                        value, effective_length = parse_value(
-                            spec, plan.value_text, entry.length
+                        value, effective_length = parse_value_for_write(
+                            spec, plan.value_text, cap, current
                         )
                     except ValueError as exc:
                         failures.append((entry.address, str(exc)))
@@ -665,10 +722,15 @@ class CheatTable(QWidget):
         )
         if not ok:
             return
-        self._entries[row].spec_label = chosen
+        entry = self._entries[row]
+        if chosen != entry.spec_label:
+            entry.spec_label = chosen
+            _forget_value_read_as_another_type(entry)
         spec = find_spec(chosen) or VALUE_TYPES[0]
         if not spec.accepts_length_override:
-            self._entries[row].length = spec.length
+            # Same as the bulk edit: the AOB pattern spec declares no width of
+            # its own, so the entry keeps the one it has.
+            entry.length = spec.length or entry.length
         self._rebuild()
 
     def _change_length(self, row: int) -> None:
@@ -678,7 +740,9 @@ class CheatTable(QWidget):
             "Length (bytes):",
             value=self._entries[row].length,
             minValue=1,
-            maxValue=1024,
+            # An entry already wider than the cap can still be shrunk from here;
+            # it just can't grow past it.
+            maxValue=max(MAX_ENTRY_LENGTH, self._entries[row].length),
         )
         if not ok:
             return
@@ -736,6 +800,41 @@ class CheatTable(QWidget):
                 QMessageBox.warning(self, "Import", f"Skipped a bad entry: {exc}")
 
 
+# Ceiling for an entry's buffer width. Entries are promoted at the width of the
+# value scanned for, which the scanner doesn't cap, so 1024 was too tight — but
+# the poll worker allocates this many bytes per entry on every 100 ms tick, so
+# an unbounded field turns one typo into a multi-gigabyte allocation the tick's
+# blanket except swallows and retries forever. A megabyte is far past any real
+# value and still cheap to read ten times a second.
+MAX_ENTRY_LENGTH = 1_048_576
+
+
+def _forget_value_read_as_another_type(entry: CheatEntry) -> None:
+    """Drop the cached value when ``new_spec`` can't read what produced it.
+
+    ``last_value`` and ``frozen_value`` hold whatever the *previous* spec
+    decoded — an int, a str, raw bytes. Nothing waits for a fresh poll tick
+    before the new spec is used on them, and a spec's ``format`` only accepts
+    what its own ``pytype`` produces: ``_fmt_bytes(1234)`` raises TypeError from
+    inside a Qt slot, and a frozen entry would be re-published to the poll
+    worker to write the old type's value through the new type's ``pytype``.
+    The next tick refills both, so forgetting them costs a single frame.
+
+    Unconditional: even a switch that keeps the ``pytype`` can change the
+    width, and a value decoded at the old one means nothing at the new. A
+    caller that still needs the bytes — the bulk edit writes a value in the
+    same pass — must capture them before calling.
+
+    The freeze is released with it. Leaving the box ticked with no target would
+    make the next poll tick adopt whatever the address happens to hold, pinning
+    a value the user never chose; a released box is visible and re-arming it is
+    one click.
+    """
+    entry.last_value = None
+    entry.frozen_value = None
+    entry.frozen = False
+
+
 def prompt_for_manual_entry(parent) -> Optional[CheatEntry]:
     """Sequential QInputDialog flow for the "Add Address Manually" button."""
     description, ok = QInputDialog.getText(
@@ -763,13 +862,16 @@ def prompt_for_manual_entry(parent) -> Optional[CheatEntry]:
         return None
     spec = find_spec(spec_label) or VALUE_TYPES[0]
 
+    # The AOB pattern spec declares a length of 0 (the scanner derives a match's
+    # width from the pattern), and an address added by hand has no pattern to
+    # measure — so ask for the width instead of minting a zero-byte buffer.
     length = spec.length
-    if spec.accepts_length_override:
+    if spec.accepts_length_override or not spec.length:
         length, ok = QInputDialog.getInt(
             parent,
             "Add address",
             "Buffer length (bytes):",
-            value=spec.length,
+            value=spec.length or 4,
             minValue=1,
             maxValue=1024,
         )

PyMemoryEditor/app/pointer_chain_dialog.py

@@ -47,7 +47,12 @@ from PySide6.QtWidgets import (
 from PyMemoryEditor import AbstractProcess
 
 from ._widgets import parse_hex_address, parse_offsets, resolve_base_address
-from .value_types import VALUE_TYPES, ValueTypeSpec, find_spec
+from .value_types import (
+    VALUE_TYPES,
+    ValueTypeSpec,
+    find_spec,
+    has_readable_width,
+)
 
 
 # Child of "PyMemoryEditor" — surfaced by the Log Console via propagation.
@@ -216,6 +221,13 @@ class PointerChainDialog(QDialog):
 
         self._value_type_combo = QComboBox()
         for spec in VALUE_TYPES:
+            # The address is already known here, so the only spec that can't be
+            # offered is the one with no width of its own — an IDA pattern,
+            # which would read zero bytes. A regex is welcome: its width comes
+            # from the Length field and it renders the bytes as text up to the
+            # first NUL, which "String (UTF-8)" doesn't do.
+            if not has_readable_width(spec):
+                continue
             self._value_type_combo.addItem(spec.label)
         form.addRow("Read value as:", self._value_type_combo)
 

PyMemoryEditor/app/pointer_scan_dialog.py

@@ -59,7 +59,12 @@ from ._widgets import (
     parse_hex_address,
     shutdown_worker_thread,
 )
-from .value_types import VALUE_TYPES, ValueTypeSpec, find_spec
+from .value_types import (
+    VALUE_TYPES,
+    ValueTypeSpec,
+    find_spec,
+    has_readable_width,
+)
 
 
 _LOG = logging.getLogger(__name__)
@@ -409,8 +414,13 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         # type into the cheat table on promotion.
         self._value_type_combo = QComboBox()
         for spec in VALUE_TYPES:
-            if spec.is_pattern:
-                continue  # reading a value "as a pattern" is meaningless here
+            # The address is already known here, so the only spec that can't be
+            # offered is the one with no width of its own — an IDA pattern,
+            # which would read zero bytes. A regex is welcome: its width comes
+            # from the Length field and it renders the bytes as text up to the
+            # first NUL, which "String (UTF-8)" doesn't do.
+            if not has_readable_width(spec):
+                continue
             self._value_type_combo.addItem(spec.label)
         self._value_type_combo.currentTextChanged.connect(self._on_value_type_changed)
         form.addRow("Read value as:", self._value_type_combo)

PyMemoryEditor/app/scan_worker.py

@@ -22,7 +22,12 @@ from PySide6.QtCore import QThread, Signal
 
 from PyMemoryEditor import AbstractProcess, MemoryRegion, ScanTypesEnum
 
-from .scan_types import NextScanType, NO_VALUE_SCAN_TYPES, ScanType
+from .scan_types import (
+    DELTA_SCAN_TYPES,
+    NextScanType,
+    NO_VALUE_SCAN_TYPES,
+    ScanType,
+)
 from .value_types import parse_value, ValueTypeSpec
 
 
@@ -85,6 +90,7 @@ def build_scan_request(
     value_text: str,
     second_value_text: str = "",
     length_spin_value: Optional[int] = None,
+    previous_scan_length: Optional[int] = None,
     writeable_only: bool = False,
     with_value: bool = True,
 ) -> ScanRequest:
@@ -93,11 +99,19 @@ def build_scan_request(
 
     This is the pure core of ``ScannerPanel._build_request`` lifted out of the
     widget so the request-assembly rules (pattern short-circuit, the
-    str-ignores-length override, range parsing, the no-value scan types) can be
-    unit-tested without a ``QApplication``. The widget keeps only the bits that
-    are genuinely UI: reading the fields and showing a ``QMessageBox`` on the
-    ``ValueError`` raised here.
-
+    value-derived width for str / bytes, range parsing, the no-value scan types)
+    can be unit-tested without a ``QApplication``. The widget keeps only the
+    bits that are genuinely UI: reading the fields and showing a ``QMessageBox``
+    on the ``ValueError`` raised here.
+
+    :param length_spin_value: the Length field. Only the regex type reads it
+        (as ``byte_length``) — every other type derives its width from the spec
+        or from the value itself.
+    :param previous_scan_length: the width the scan that produced the current
+        results used. Only the no-value comparisons read it, and only for the
+        variable-width types, whose baseline is meaningless at another width.
+        (The ``*_BY`` deltas compare against the baseline too, but they are
+        rejected outright for those types — see below.)
     :raises ValueError: if a value/pattern fails to parse (message is
         user-facing — the caller picks the dialog title from ``spec.is_pattern``).
     """
@@ -116,19 +130,35 @@ def build_scan_request(
             writeable_only=writeable_only,
         )
 
-    # String (UTF-8) ignores the length field: pass None so parse_value derives
-    # the buffer width from the typed text's UTF-8 byte length. Byte Array still
-    # honours the user-set override.
-    length_override = (
-        length_spin_value
-        if spec.accepts_length_override and spec.pytype is not str
-        else None
-    )
+    # "Increased/Decreased value BY" adds the delta to the baseline, which only
+    # means anything for a number: on str/bytes ``prev + exp`` concatenates (so
+    # the comparison is never true) and ``prev - exp`` raises TypeError, which
+    # the refine worker swallows into "doesn't match". Either way every address
+    # is dropped and the user is told nothing, so reject the combination with a
+    # message instead. Checked *after* the pattern short-circuit above: the
+    # pattern specs are bytes-typed too, but they force EXACT regardless of the
+    # scan type passed, and the comparisons this message points at are disabled
+    # in pattern mode anyway.
+    if scan_type in DELTA_SCAN_TYPES and spec.pytype in (str, bytes):
+        raise ValueError(
+            "Increased/Decreased Value By adds a numeric amount to the previous "
+            "value, which doesn't apply to %s. Use Changed Value or Unchanged "
+            "Value to compare against the previous scan." % spec.label
+        )
 
-    # Increased/Decreased/Changed/Unchanged compare current vs previous and need
-    # no target value — just the value shape (type + length).
+    # Increased/Decreased/Changed/Unchanged compare the value read now against
+    # the one the *previous* scan recorded, so they need no target value — but
+    # they must re-read at the width that baseline was recorded with. Reading
+    # 16 bytes where the first scan recorded 4 yields "olá\0\0…" against "olá",
+    # which never compares equal, so every address would report as Changed.
+    # ``previous_scan_length`` carries that width for the variable-width types;
+    # the fixed-width types own theirs and ignore it.
     if scan_type in NO_VALUE_SCAN_TYPES:
-        length = length_override if length_override is not None else spec.length
+        length = (
+            previous_scan_length
+            if spec.accepts_length_override and previous_scan_length
+            else spec.length
+        )
         return ScanRequest(
             spec=spec,
             length=int(length),
@@ -137,14 +167,22 @@ def build_scan_request(
             writeable_only=writeable_only,
         )
 
+    # Every scan that carries a value sizes its buffer from that value: the
+    # numeric types have a fixed width, and str / bytes derive theirs in
+    # parse_value (the text's UTF-8 byte length / the number of hex bytes
+    # entered). So no length override is passed here. Letting the Length field
+    # win could only break the scan — a width below the value's raises
+    # "byte string too long" from the fixed-width ctypes buffer, and a width
+    # above it NUL-pads the target, silently searching for "the value followed
+    # by zeros". Partial matching has its own value type (AOB Pattern).
     value: Any
     if scan_type in (ScanTypesEnum.VALUE_BETWEEN, ScanTypesEnum.NOT_VALUE_BETWEEN):
-        lo, lo_len = parse_value(spec, value_text, length_override)
-        hi, hi_len = parse_value(spec, second_value_text, length_override)
+        lo, lo_len = parse_value(spec, value_text)
+        hi, hi_len = parse_value(spec, second_value_text)
         length = max(lo_len, hi_len)
         value = (lo, hi)
     else:
-        value, length = parse_value(spec, value_text, length_override)
+        value, length = parse_value(spec, value_text)
 
     if not with_value:
         value = None  # Used by callers that only need spec/length/scan_type.

PyMemoryEditor/app/scanner_panel.py

@@ -6,7 +6,7 @@ Inputs:
 * primary value (and a second value for "Value Between" / "Not Value Between")
 * value type
 * scan type
-* explicit byte length for str / bytes
+* byte length (fixed per numeric type; derived from the value for str / bytes)
 * "writable regions only" toggle (passed to PyMemoryEditor as ``writeable_only``)
 
 Outputs (signals):
@@ -44,7 +44,30 @@ from .scan_types import (
     is_next_scan_type,
 )
 from .scan_worker import build_scan_request, ScanRequest
-from .value_types import VALUE_TYPES, find_spec
+from .value_types import parse_value, ValueTypeSpec, VALUE_TYPES, find_spec
+
+
+# Shown in the (read-only) Length field of String / Byte Array before a value
+# has been entered: those types take their width from the value itself, so
+# there is genuinely no number to report yet.
+EMPTY_LENGTH_TEXT = "—  (set by the value)"
+
+
+def is_sized_by_value(spec: ValueTypeSpec) -> bool:
+    """True for the types whose buffer width comes from the value entered.
+
+    String (UTF-8) and Byte Array (Hex) only. The numeric types have a fixed
+    width, an IDA pattern derives one from the pattern, and a regex's Length
+    field is a genuine user-set ``byte_length`` — none of them may have their
+    width taken from a scan's value.
+    """
+    return spec.pytype in (str, bytes) and not spec.is_pattern
+
+
+# The two scan types that take a second value; their width is max(lo, hi).
+RANGE_SCAN_TYPES = frozenset(
+    (ScanTypesEnum.VALUE_BETWEEN, ScanTypesEnum.NOT_VALUE_BETWEEN)
+)
 
 
 SCAN_TYPE_CHOICES = (
@@ -79,6 +102,17 @@ class ScannerPanel(QWidget):
         self._has_results = False
         self._busy = False
         self._initial_focus_done = False
+        # Width the scan that produced the current results ran at. The no-value
+        # comparisons (Increased / Changed / …) must re-read at exactly this
+        # width or they compare against a baseline recorded at another one; the
+        # Length readout can't stand in, since it tracks whatever value is in
+        # the field right now, which the user is free to edit between scans.
+        self._last_scan_length: Optional[int] = None
+        # Width of a scan that has been dispatched but hasn't landed yet. It is
+        # promoted above only when the owner reports results, so a scan that
+        # errors out or finds nothing leaves the values on screen described by
+        # the width they were actually read at.
+        self._pending_scan_length: Optional[int] = None
         self._build_ui()
         self._refresh_buttons()
 
@@ -119,14 +153,17 @@ class ScannerPanel(QWidget):
         self._value_edit = QLineEdit()
         self._value_edit.setPlaceholderText("e.g. 100  or  0x64  or  Hello")
         self._value_edit.returnPressed.connect(self._on_value_submitted)
-        # For String (UTF-8) the length is dictated by the typed text, so keep
-        # the (disabled) length field in sync as the user types.
+        # For String (UTF-8) and Byte Array (Hex) the length is dictated by the
+        # typed value, so keep the (disabled) length field in sync as the user types.
         self._value_edit.textChanged.connect(self._on_value_text_changed)
         value_form.addRow("Value:", self._value_edit)
 
         self._second_value_edit = QLineEdit()
         self._second_value_edit.setPlaceholderText("Upper bound (for ranges only)")
         self._second_value_edit.returnPressed.connect(self._on_value_submitted)
+        # A range scan sizes with max(lo, hi), so the upper bound moves the
+        # readout just as the primary value does.
+        self._second_value_edit.textChanged.connect(self._on_value_text_changed)
         self._second_value_label = QLabel("Up to:")
         value_form.addRow(self._second_value_label, self._second_value_edit)
         self._second_value_edit.hide()
@@ -205,7 +242,7 @@ class ScannerPanel(QWidget):
 
         self._cancel_btn = QPushButton("Cancel scan")
         self._cancel_btn.setObjectName("danger")
-        self._cancel_btn.clicked.connect(self.cancel_requested.emit)
+        self._cancel_btn.clicked.connect(self._on_cancel)
         buttons.addWidget(self._cancel_btn)
 
         layout.addWidget(buttons_box)
@@ -216,11 +253,34 @@ class ScannerPanel(QWidget):
         self._on_scan_type_changed(0)
 
     def set_has_results(self, has_results: bool) -> None:
+        """Report whether the results table currently holds anything.
+
+        Called by the owner once a scan has actually finished, which is what
+        makes it the right moment to adopt that scan's width as the baseline.
+        """
         self._has_results = has_results
+        if has_results:
+            if self._pending_scan_length:
+                self._last_scan_length = self._pending_scan_length
+        else:
+            self._last_scan_length = None
+        self._pending_scan_length = None
         self._refresh_buttons()
 
     def set_busy(self, busy: bool) -> None:
+        """Report whether a scan is running.
+
+        The falling edge ends the scan cycle, which is where a pending width
+        that was never adopted gets dropped. The owner emits it after the
+        completion signal (``finished`` follows ``finished_ok``), so a scan that
+        landed has already had its width promoted by ``set_has_results``; one
+        that errored out never will, and must not leave the width behind for
+        an unrelated later completion — an "Update Values" refresh reports
+        results too — to pick up.
+        """
         self._busy = busy
+        if not busy:
+            self._pending_scan_length = None
         self._refresh_buttons()
 
     def use_snapshot_cache(self) -> bool:
@@ -253,7 +313,7 @@ class ScannerPanel(QWidget):
 
         is_pattern = spec.is_pattern
         is_regex = spec.is_regex
-        is_string = spec.pytype is str and not is_pattern
+        sized_by_value = is_sized_by_value(spec)
 
         # Pattern modes reuse the "Value" line for the pattern and force the
         # scan-type combo to EXACT (Bigger/Smaller/Between don't apply). The
@@ -261,15 +321,15 @@ class ScannerPanel(QWidget):
         # token count), but a *regex* has no inferable width, so its Length
         # field stays enabled and supplies search_by_pattern's byte_length.
         #
-        # String (UTF-8) also locks the length field: the buffer width is the
-        # UTF-8 byte length of the typed text (multi-byte aware), so letting the
-        # user override it would only allow truncating or over-allocating the
-        # value they entered. The field stays visible as a read-only readout
-        # kept in sync by _sync_string_length / _on_value_text_changed.
-        self._length_spin.setEnabled(
-            (spec.accepts_length_override and not is_pattern and not is_string)
-            or is_regex
-        )
+        # Regex is the one spec whose width is genuinely the user's to set (its
+        # byte_length is the max match width, which nothing can infer). String /
+        # Byte Array mirror the value they were given — overriding that could
+        # only truncate it, which the fixed-width ctypes buffer rejects, or
+        # over-allocate it, which NUL-pads the target into a silent search for
+        # "the value followed by zeros". Everything else is fixed by its spec.
+        # The field stays visible as a read-only readout throughout, kept in
+        # sync by _sync_value_length / _on_value_text_changed.
+        self._length_spin.setEnabled(is_regex)
 
         if is_regex:
             self._value_edit.setPlaceholderText(
@@ -282,6 +342,13 @@ class ScannerPanel(QWidget):
         else:
             self._value_edit.setPlaceholderText("e.g. 100  or  0x64  or  Hello")
 
+        # Every type but the value-sized pair owns a real number here, so clear
+        # the "no width yet" slot the previous type may have opened (0 would
+        # otherwise render as EMPTY_LENGTH_TEXT for e.g. "1 Byte (Int8)").
+        if not sized_by_value:
+            self._length_spin.setSpecialValueText("")
+            self._length_spin.setMinimum(1)
+
         if is_regex:
             # Length = the regex's max match width in bytes (byte_length); it
             # drives the chunk overlap so a match straddling a chunk boundary is
@@ -294,16 +361,22 @@ class ScannerPanel(QWidget):
             self._length_spin.setMaximum(1024)
             self._length_spin.setValue(1)
             self._length_spin.setSuffix("  bytes")
-        elif is_string:
-            # Length tracks the typed text — raise the ceiling so long strings
-            # aren't visually clamped, then mirror the current text's byte size.
+        elif sized_by_value:  # String (UTF-8) / Byte Array (Hex)
+            # Length tracks the typed value — raise the ceiling so long strings
+            # aren't visually clamped, then mirror the current value's byte size.
+            #
+            # Until a value has been entered there is no width to report, and
+            # the readout is read-only, so the user can't correct a number we
+            # invent. Open a 0 slot rendered as EMPTY_LENGTH_TEXT for that
+            # state rather than seeding the spec default (which would show
+            # "4 bytes" for an empty byte array and then jump to "1 byte" on
+            # the first hex digit) or keeping a width the previous type wrote.
+            self._length_spin.setMinimum(0)
+            self._length_spin.setSpecialValueText(EMPTY_LENGTH_TEXT)
             self._length_spin.setMaximum(2_147_483_647)
             self._length_spin.setSuffix("  bytes")
-            self._sync_string_length()
-        elif spec.accepts_length_override:  # Byte Array (Hex)
-            self._length_spin.setMaximum(1024)
-            self._length_spin.setValue(max(4, self._length_spin.value()))
-            self._length_spin.setSuffix("  bytes")
+            self._length_spin.setValue(0)
+            self._sync_value_length()
         else:
             self._length_spin.setMaximum(1024)
             self._length_spin.setValue(spec.length)
@@ -332,30 +405,62 @@ class ScannerPanel(QWidget):
         self._refresh_buttons()
 
     def _on_value_text_changed(self, text: str) -> None:
-        # Only String (UTF-8) derives its length from the value text; every
-        # other type owns its length field independently.
+        # _sync_value_length ignores the types that own their length field.
+        self._sync_value_length(text)
+
+    def _sync_value_length(self, text: Optional[str] = None) -> None:
+        """Mirror the byte size of the value text into the length field.
+
+        Matches ``parse_value``'s rules for the two variable-width types so the
+        read-only readout shows exactly the buffer width the scan will use: the
+        UTF-8 byte length for a string (byte length, not character count) and
+        the number of parsed hex bytes for a byte array.
+
+        The readout is exactly what the current value sizes to, and nothing
+        else: an empty field, or a half-typed byte array ("00 1"), reports no
+        width at all (EMPTY_LENGTH_TEXT) rather than a number no scan would
+        use. A range scan sizes with ``max(lo, hi)``, so both bounds count.
+        The "Next Scan" comparisons that carry no value of their own don't read
+        this field — they refine at ``_last_scan_length``, the width the scan
+        holding the current results actually ran at.
+
+        ``text`` is accepted (and ignored) so the method can sit directly on a
+        ``textChanged`` signal; the width always comes from reading the fields,
+        since either of the two can be the one that sets it.
+        """
+        del text  # Both fields are read below; see the docstring.
         spec = find_spec(self._type_combo.currentText())
-        if spec is not None and spec.pytype is str and not spec.is_pattern:
-            self._sync_string_length(text)
+        # Only the value-sized types have a width to mirror; every other type
+        # owns the field (a fixed width, or the regex's editable match width)
+        # and must not have it overwritten from here.
+        if spec is None or not is_sized_by_value(spec):
+            return
 
-    def _sync_string_length(self, text: Optional[str] = None) -> None:
-        """Mirror the UTF-8 byte length of the value text into the length field.
+        texts = [self._value_edit.text()]
+        # Read the scan type rather than the widget's visibility: a child of a
+        # panel that hasn't been shown yet reports isVisible() False even after
+        # setVisible(True), which would silently drop the upper bound.
+        _, scan_type = SCAN_TYPE_CHOICES[self._scan_combo.currentIndex()]
+        if scan_type in RANGE_SCAN_TYPES:
+            texts.append(self._second_value_edit.text())
 
-        Matches ``parse_value``'s str rule (byte length, not character count)
-        so the read-only readout shows exactly the buffer width the scan uses.
-        """
-        if text is None:
-            text = self._value_edit.text()
-        self._length_spin.setValue(max(1, len(text.encode("utf-8"))))
+        length = 0
+        for candidate in texts:
+            try:
+                _, candidate_length = parse_value(spec, candidate)
+            except ValueError:
+                continue
+            length = max(length, candidate_length)
+
+        self._length_spin.setValue(length)
 
     def _on_scan_type_changed(self, index: int) -> None:
         _, scan_type = SCAN_TYPE_CHOICES[index]
-        ranged = scan_type in (
-            ScanTypesEnum.VALUE_BETWEEN,
-            ScanTypesEnum.NOT_VALUE_BETWEEN,
-        )
+        ranged = scan_type in RANGE_SCAN_TYPES
         self._second_value_edit.setVisible(ranged)
         self._second_value_label.setVisible(ranged)
+        # Entering or leaving a range changes which fields size the scan.
+        self._sync_value_length()
 
         # In pattern mode the Value field holds the AOB pattern and the
         # scan-type combo is forced to EXACT, so leave its value field alone.
@@ -393,6 +498,7 @@ class ScannerPanel(QWidget):
                 value_text=self._value_edit.text(),
                 second_value_text=self._second_value_edit.text(),
                 length_spin_value=self._length_spin.value(),
+                previous_scan_length=self._last_scan_length,
                 writeable_only=self._writable_check.isChecked(),
                 with_value=with_value,
             )
@@ -415,24 +521,117 @@ class ScannerPanel(QWidget):
             return
         request = self._build_request()
         if request is not None:
+            self._pending_scan_length = self._dispatched_width(request)
             self.first_scan_requested.emit(request)
 
     def _on_next_scan(self) -> None:
         request = self._build_request()
         if request is not None:
+            # The refine rewrites every kept value at this width, so it becomes
+            # the baseline the next no-value comparison has to match — once it
+            # has actually run.
+            self._pending_scan_length = self._dispatched_width(request)
             self.next_scan_requested.emit(request)
 
+    def _dispatched_width(self, request: ScanRequest) -> int:
+        """Width the rows this request finds will have been read at.
+
+        Normally the request's own length. An IDA pattern is the exception: it
+        reports 0, because the scanner derives a match's width from the pattern
+        rather than from a field — so the width one hit occupies is the token
+        count, which is what a promoted row has to be read at.
+        """
+        if request.spec.is_pattern and not request.spec.is_regex:
+            return self._pattern_byte_length()
+        return request.length
+
+    def _on_cancel(self) -> None:
+        # Both workers still report results after a cancel — they break out of
+        # the loop and emit finished_ok with what they have — so what the
+        # partial results are worth depends on which scan was running.
+        #
+        # A refine re-read only the rows it reached at the new width; the rest
+        # still hold values recorded at the old one, so neither width describes
+        # the table and the previous one (which most rows match) stands.
+        #
+        # A first scan is the opposite: every address it did find, it found at
+        # its own width, and there is no earlier width to fall back on. Dropping
+        # it would send the next Changed/Unchanged refine to the spec default —
+        # 16 for a String scanned at 4 — which is the failure this whole branch
+        # exists to fix. _has_results tells the two apart: a first scan only
+        # runs when there are none yet.
+        if self._has_results:
+            self._pending_scan_length = None
+        self.cancel_requested.emit()
+
     def _on_update_values(self) -> None:
-        request = self._build_request()
-        if request is not None:
-            self.update_values_requested.emit(request)
+        # A read-only refresh of the rows already on screen. RefineScanWorker
+        # applies no comparison when filter_only is False, so this needs no
+        # target value — and must not parse one: the Value box may be empty
+        # (a no-value scan type clears it outright), which would abort the
+        # refresh with "Invalid value" instead of refreshing.
+        spec, length = self.current_spec_and_length()
+        # The refresh re-reads and patches every row at this width, so it is the
+        # width the table holds once it lands — the same one it was scanned at,
+        # recorded here so that a width left behind by a request the owner
+        # rejected before the busy cycle began (an early return in its handler)
+        # is overwritten rather than adopted in its place.
+        self._pending_scan_length = length
+        self.update_values_requested.emit(
+            ScanRequest(
+                spec=spec,
+                length=length,
+                scan_type=ScanTypesEnum.EXACT_VALUE,
+                value=None,
+                writeable_only=self._writable_check.isChecked(),
+            )
+        )
 
     def current_spec_and_length(self):
-        """Return the active (spec, length) pair for the Promote-to-Cheat-Table path."""
+        """Return the (spec, width) the rows currently on screen were read at.
+
+        Used by the Promote-to-Cheat-Table path and by the "Update Values"
+        refresh — both act on those rows, so both need the width their scan
+        ran at rather than anything the Value box says now. An IDA hit keeps
+        this spec: a pattern-typed entry reads and writes correctly now (see
+        ``parse_value_for_write``), and only its width has to come from the
+        pattern, since the spec declares none.
+        """
         spec = find_spec(self._type_combo.currentText())
         if spec is None:
             spec = VALUE_TYPES[0]
+        # An IDA pattern has no Length field and a spec length of 0 — the width
+        # of one match is the pattern's own, one token per byte. Prefer the
+        # width the scan ran at: the Value box stays editable in pattern mode,
+        # so re-deriving it here would read at a width the hits were never
+        # found at, which is the staleness _last_scan_length exists to avoid.
+        if spec.is_pattern and not spec.is_regex:
+            return spec, self._last_scan_length or self._pattern_byte_length()
+
+        # The rows being promoted were read at the width their scan ran at, so
+        # that is the width the cheat entry has to keep. The Length readout
+        # can't stand in: it follows the Value box, which a no-value scan type
+        # clears outright (a 4-byte "olá" scan would promote at the spec's 16,
+        # and the entry would read 12 bytes of neighbouring memory into the
+        # cell on every poll tick).
+        if is_sized_by_value(spec) and self._last_scan_length:
+            return spec, self._last_scan_length
+
         length = (
             self._length_spin.value() if spec.accepts_length_override else spec.length
         )
-        return spec, int(length)
+        # No scan has run yet and no value is entered (readout 0): a cheat entry
+        # can't have a zero-width buffer, so the spec default stands in.
+        return spec, int(length) or spec.length
+
+    def _pattern_byte_length(self) -> int:
+        """Width of one match of the AOB pattern currently in the Value field."""
+        from PyMemoryEditor.util.pattern import compile_pattern
+
+        try:
+            return max(1, compile_pattern(self._value_edit.text().strip())[1])
+        except ValueError:
+            # The results being promoted came from a pattern that compiled, so
+            # this only happens if the field was edited afterwards. One byte is
+            # a harmless entry the user can widen from the cheat table.
+            return 1

PyMemoryEditor/app/value_types.py

@@ -35,6 +35,15 @@ class ValueTypeSpec:
     # ``byte_length`` (the number of bytes one match consumes) that
     # ``search_by_pattern`` requires for regex input.
     is_regex: bool = False
+    # How cell text becomes the bytes to write back, for the types whose
+    # ``parse`` answers a different question — "what am I searching for?"
+    # rather than "what value is this?". Receives the text and the bytes last
+    # read at the address, so a wildcard can mean "leave that byte alone".
+    # ``None`` means ``parse`` already answers both, which is the case for
+    # every type that isn't a pattern.
+    parse_write: Optional[
+        Callable[[str, Optional[bytes], Optional[int]], Any]
+    ] = None
 
 
 def _parse_bool(text: str) -> bool:
@@ -86,6 +95,23 @@ def _parse_bytes(text: str) -> bytes:
         raise ValueError(f"Invalid byte array: {exc}")
 
 
+def _parse_str(text: str) -> str:
+    """Return the value text verbatim, rejecting an empty one.
+
+    An empty string sizes to a 1-byte NUL buffer, so *scanning* for it matches
+    every zeroed byte in the target, and *writing* it is a no-op (``prepare_write``
+    truncates to the value and never pads). Neither is what the user meant.
+    ``_parse_bytes`` already rejects its own empty input; this keeps the two
+    variable-width types consistent.
+
+    The wording stays neutral because this runs on the cheat table's write
+    paths too, not only on a scan.
+    """
+    if not text:
+        raise ValueError("Empty value.")
+    return text
+
+
 def _parse_pattern(text: str) -> str:
     """Validate an IDA-style AOB pattern and return it verbatim.
 
@@ -143,6 +169,69 @@ def _parse_regex(text: str) -> bytes:
     return pattern
 
 
+def _parse_pattern_write(
+    text: str, current: Optional[bytes], length_override: Optional[int] = None
+) -> bytes:
+    """Turn an IDA pattern typed into a value cell into the bytes to write.
+
+    ``_parse_pattern`` answers the scanner's question and hands back the
+    pattern *text*, which is not something that can be written anywhere — the
+    cell would store the ASCII spelling of the hex it displays. Here the same
+    tokens are resolved to the bytes they name.
+
+    A ``?`` keeps whatever byte is already at that offset. That mirrors its
+    search meaning ("any byte") and is what makes a signature patchable: you
+    name the bytes you mean to change and leave the operands alone. It needs
+    the current contents, so a wildcard only works once the entry has been
+    read at least one poll tick.
+    """
+    from PyMemoryEditor.util.pattern import tokenize_pattern
+
+    tokens = tokenize_pattern(text)
+    wildcards = [index for index, token in enumerate(tokens) if token is None]
+
+    if wildcards:
+        # `current` is whatever the entry's spec produced when it was last
+        # polled, and a type change doesn't wait for a fresh tick — so it can
+        # still be the int/str/float the *previous* type read. Anything but
+        # bytes is treated as "nothing read yet" rather than reaching len()
+        # and raising a TypeError the callers' `except ValueError` won't catch.
+        if not isinstance(current, (bytes, bytearray)):
+            current = None
+        if current is None:
+            raise ValueError(
+                "A '?' keeps the byte that is already there, so it can't be "
+                "used before the value has been read at least once."
+            )
+        if len(current) < wildcards[-1] + 1:
+            raise ValueError(
+                "'?' at byte %d has nothing to keep: the last read of this "
+                "address returned %d byte(s). Wait for the next refresh, or "
+                "spell the byte out." % (wildcards[-1] + 1, len(current))
+            )
+
+    return bytes(
+        current[index] if token is None else token  # type: ignore[index]
+        for index, token in enumerate(tokens)
+    )
+
+
+def _parse_regex_write(
+    text: str, current: Optional[bytes], length_override: Optional[int] = None
+) -> bytes:
+    """Turn a value cell's text into bytes for a regex-typed entry.
+
+    A regex names a *set* of byte strings, so the pattern itself can't be
+    written back. What the cell shows is the text read at the address
+    (``_fmt_regex_match``), so an edit is taken literally — the same rule as
+    String (UTF-8) — and writes exactly the characters typed.
+    """
+    del current, length_override  # A literal write depends on neither.
+    if not text:
+        raise ValueError("Empty value.")
+    return text.encode("utf-8")
+
+
 def _fmt_bytes(value: bytes) -> str:
     if value is None:
         return ""
@@ -231,7 +320,7 @@ VALUE_TYPES = (
         "String (UTF-8)",
         str,
         16,
-        lambda s: s,
+        _parse_str,
         lambda v: "" if v is None else str(v),
         accepts_length_override=True,
     ),
@@ -254,6 +343,7 @@ VALUE_TYPES = (
         lambda v: "" if v is None else (v if isinstance(v, str) else _fmt_bytes(v)),
         accepts_length_override=False,
         is_pattern=True,
+        parse_write=_parse_pattern_write,
     ),
     # Text-regex scan — the "Value" input becomes a string regex (e.g.
     # ``Player[0-9]+``) UTF-8 encoded into the bytes pattern, and the Length
@@ -269,6 +359,7 @@ VALUE_TYPES = (
         accepts_length_override=True,
         is_pattern=True,
         is_regex=True,
+        parse_write=_parse_regex_write,
     ),
 )
 
@@ -310,3 +401,83 @@ def parse_value(
         # under-allocating would silently truncate the value the user typed.
         length = max(1, len(value.encode("utf-8")))
     return value, length
+
+
+def _written_width(value: Any) -> int:
+    """Bytes ``value`` occupies once written, or 0 when its spec sets the size.
+
+    ``str`` is measured encoded: the entry's width is a byte count, so counting
+    characters would let a multibyte value overflow it.
+    """
+    if isinstance(value, str):
+        return len(value.encode("utf-8"))
+    if isinstance(value, (bytes, bytearray)):
+        return len(value)
+    return 0
+
+
+def has_readable_width(spec: ValueTypeSpec) -> bool:
+    """True when the spec can size a read at an address the caller already has.
+
+    Every spec but the IDA pattern can: the numeric types declare a width, and
+    str / bytes / regex take one from the caller. An IDA pattern derives a
+    match's width from the pattern itself, so at a bare address it has none —
+    it declares a length of 0 *and* refuses a length override, which is exactly
+    the combination this tests. Offering it where the address is already known
+    would read zero bytes and display nothing forever.
+
+    Note this says nothing about a *cheat entry*, which carries its own width
+    and so can hold an IDA pattern quite happily (see ``parse_value_for_write``).
+    """
+    return spec.length > 0 or spec.accepts_length_override
+
+
+def parse_value_for_write(
+    spec: ValueTypeSpec,
+    text: str,
+    length_override: Optional[int] = None,
+    current: Optional[bytes] = None,
+) -> Tuple[Any, int]:
+    """Parse ``text`` as the value to **write** at an address.
+
+    :func:`parse_value` answers the scanner's question ("what am I looking
+    for?"). For every type but the two pattern ones that is the same answer,
+    but a pattern's ``parse`` yields search syntax — an IDA pattern's text, or
+    a regex — which is not a value any address can hold. Those specs supply a
+    ``parse_write`` that resolves the cell text to concrete bytes instead,
+    given ``current``: the bytes last read there, which a ``?`` wildcard keeps.
+
+    Used by the cheat table, whose cells are read *and* written; the scanner
+    only ever searches, so it stays on :func:`parse_value`.
+
+    The returned width follows :func:`parse_value`'s rule — an explicit
+    ``length_override`` wins for the types that accept one. Writing a value to
+    an entry must not resize it: the cheat table stores this width back onto the
+    entry, and the entry's width is how many bytes it *reads* on every poll
+    tick, which the user set and the write has no business shrinking.
+    """
+    if spec.parse_write is None:
+        value, length = parse_value(spec, text, length_override)
+    else:
+        value = spec.parse_write(text, current, length_override)
+        length = (
+            max(1, int(length_override))
+            if spec.accepts_length_override and length_override is not None
+            else max(1, _written_width(value))
+        )
+
+    # One guard for every path that reaches an address. An entry's length is a
+    # *byte* width — it is the bufflength each poll tick reads — while
+    # prepare_write treats it as a hard cap and truncates past it, counting
+    # characters for str. So a wider value was written short with no word said
+    # while the cell kept showing all of it, and a multibyte str could slip the
+    # other way: "ábc" is 3 characters but 4 bytes, one past a 3-byte entry.
+    # Measuring what actually goes on the wire covers both.
+    written = _written_width(value)
+    if length_override is not None and written > length_override:
+        raise ValueError(
+            "Value is %d bytes but the entry holds %d. Widen the entry first, "
+            "or the extra would be dropped without warning."
+            % (written, length_override)
+        )
+    return value, length

PyMemoryEditor/macos/functions.py

@@ -38,6 +38,7 @@ from .libsystem import PROC_ALL_PIDS, libsystem, mach_error_message, mach_task_s
 from .types import (
     KERN_INVALID_ADDRESS,
     KERN_INVALID_ARGUMENT,
+    KERN_MEMORY_ERROR,
     KERN_NO_ACCESS,
     KERN_PROTECTION_FAILURE,
     KERN_SUCCESS,
@@ -294,10 +295,20 @@ def get_memory_regions(task: int, pid: int = 0) -> Generator[MemoryRegion, None,
 # KERN_NO_ACCESS / KERN_INVALID_ARGUMENT can also surface for guard pages and
 # freshly-unmapped pages on modern macOS; treating them as fatal aborts a scan
 # that should just skip the page.
+#
+# KERN_MEMORY_ERROR is the same story one level down: the pager backing a page
+# declined to produce its data. The kernel header calls that failure
+# "temporary" in as many words, in explicit contrast with the permanent
+# KERN_MEMORY_FAILURE beside it (the pair is spelled out in types.py). It is
+# what file-backed, read-only mappings (code segments, dylibs, the dyld shared
+# cache) return, so any scan that walks them — every pattern scan, and any value
+# scan with "writable regions only" turned off — hits it routinely, and used to
+# abort on the first one.
 _PAGE_GONE_KRS = (
     KERN_INVALID_ADDRESS,
     KERN_NO_ACCESS,
     KERN_INVALID_ARGUMENT,
+    KERN_MEMORY_ERROR,
 )
 
 

PyMemoryEditor/macos/types.py

@@ -65,6 +65,18 @@ KERN_PROTECTION_FAILURE = 2
 KERN_INVALID_ARGUMENT = 4
 KERN_FAILURE = 5
 KERN_NO_ACCESS = 8
+# These two are neighbours in mach/kern_return.h and are the line between a page
+# a scan may walk past and one it may not, so they are defined together:
+#
+#   9  "the target address refers to a memory object that has been destroyed.
+#       This failure is permanent."
+#  10  "the memory object indicated that the data could not be returned. This
+#       failure may be temporary; future attempts to access this same data may
+#       succeed, as defined by the memory object."
+#
+# Only the second belongs in functions._PAGE_GONE_KRS.
+KERN_MEMORY_FAILURE = 9
+KERN_MEMORY_ERROR = 10
 
 
 class vm_region_basic_info_64(Structure):

PyMemoryEditor/util/pattern.py

@@ -26,7 +26,7 @@ The function returns a compiled ``re.Pattern[bytes]`` ready to be used with
 """
 
 import re
-from typing import Pattern, Tuple, Union
+from typing import List, Optional, Pattern, Tuple, Union
 
 
 PatternLike = Union[str, bytes, "re.Pattern[bytes]"]
@@ -84,33 +84,58 @@ def compile_pattern(
             "compiled re.Pattern, not %r" % type(pattern).__name__
         )
 
-    tokens = pattern.split()
-    if not tokens:
-        raise ValueError("Empty pattern.")
+    tokens = tokenize_pattern(pattern)
 
     parts = []
     for token in tokens:
-        if token in ("?", "??"):
+        if token is None:
             # Single-byte wildcard. ``.`` together with re.DOTALL matches any
             # byte 0x00-0xFF without special-casing 0x0A.
             parts.append(b".")
             continue
+        # Escape the byte so e.g. 0x5C (backslash) or 0x28 ('(') don't get
+        # interpreted as regex meta chars.
+        parts.append(re.escape(bytes((token,))))
+
+    return re.compile(b"".join(parts), re.DOTALL), len(tokens)
+
+
+def tokenize_pattern(pattern: str) -> List[Optional[int]]:
+    """Split an IDA-style hex pattern into one entry per byte.
+
+    Each entry is the byte's value, or ``None`` for a ``?`` / ``??`` wildcard.
+    ``compile_pattern`` turns these into a regex; the app's cheat table uses
+    them to write a signature back, where a wildcard means "leave the byte
+    that is already there alone". Both need the same token rules and the same
+    error messages, so they share this.
+
+    :raises ValueError: on an empty pattern or a malformed token.
+    """
+    tokens = pattern.split()
+    if not tokens:
+        raise ValueError("Empty pattern.")
+
+    parsed: List[Optional[int]] = []
+    for token in tokens:
+        if token in ("?", "??"):
+            parsed.append(None)
+            continue
         if len(token) != 2:
             raise ValueError(
                 "Pattern token %r is not two hex digits or a '?' wildcard. "
                 "Example of a valid pattern: '48 8B ? ? 00'." % token
             )
         try:
-            byte = bytes.fromhex(token)
+            parsed.append(bytes.fromhex(token)[0])
         except ValueError as exc:
             raise ValueError(
                 "Pattern token %r is not valid hex: %s" % (token, exc)
             )
-        # Escape the byte so e.g. 0x5C (backslash) or 0x28 ('(') don't get
-        # interpreted as regex meta chars.
-        parts.append(re.escape(byte))
-
-    return re.compile(b"".join(parts), re.DOTALL), len(tokens)
+    return parsed
 
 
+# tokenize_pattern is deliberately absent: it exists so the scan and write
+# paths share one set of token rules, and nothing outside the package consumes
+# it. Exporting it would promise a documented, supported surface that neither
+# the guide nor the API reference describes.
 __all__ = ("compile_pattern", "PatternLike")

{pymemoryeditor-2.1.0.dist-info → pymemoryeditor-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyMemoryEditor
-Version: 2.1.0
+Version: 2.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
@@ -138,32 +138,6 @@ That's it — read, write or scan another process in three lines, the same way o
 
 ---
 
-## What's inside
-
-### 🐍 The Python library
-
-Full control over another process's memory — in a few lines of Python:
-
-- ✅ **Read & write** values (`int`, `float`, `bool`, `str`, `bytes`)
-- 🔍 **Value scan** with eight comparison modes
-- 🎯 **Pattern scan** (IDA-style AOB & regex)
-- 🔗 **Pointer chains** + a live `RemotePointer` handle
-- 🧭 **Pointer scan** — find static pointers that survive ASLR
-- 🗺️ **Memory map**, **modules**, **threads**
-- 🧱 **Allocate & free** remote memory (Windows / macOS)
-
-### 🖥️ The bundled GUI app
-
-All the library's power — no code required:
-- ⚡ **Zero setup** — attach to a process and start scanning in seconds
-- 🧲 **Refine workflow** — First Scan → Next Scan with live visual feedback
-- 📋 **Cheat table** — freeze / write values on the fly, JSON import/export
-- 🔬 **Hex viewer** — browse raw memory and write back inline
-- 🧩 **Pointer scan UI** — scan, export & rescan across sessions with a few clicks
-- 🎨 **One-click access** — every feature at your fingertips, no code needed
-
----
-
 ## 📖 Documentation
 
 Full documentation lives at **[pymemoryeditor.readthedocs.io](https://pymemoryeditor.readthedocs.io)** — installation, the Cheat Engine workflow, every method and parameter, the GUI app guide, platform notes and troubleshooting.

{pymemoryeditor-2.1.0.dist-info → pymemoryeditor-2.2.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-PyMemoryEditor/__init__.py,sha256=NcdtGiiw7F8_CkPcd9eelPSp2xr-1SHFl0bggsbdAA4,3234
+PyMemoryEditor/__init__.py,sha256=7y6oSpnE3E7iBrwEFhKwUq3cE36-hrNyK1gWL8xY9do,3234
 PyMemoryEditor/__main__.py,sha256=xukvvLjQ0BnYnnxMZda1cvyZ-BurSUk8dAGQybIqMD4,95
 PyMemoryEditor/enums.py,sha256=q_SWQYgh4F7yyAa7sZvNo2Sw91TSm3aTqPfTA7OqldM,322
 PyMemoryEditor/app/__init__.py,sha256=DGCYWpqGKPSeBa7cvzL7GmmhIfDDgF6vtim0VtLcfOo,357
@@ -8,30 +8,30 @@ PyMemoryEditor/app/_widgets.py,sha256=Xsu3DXUtlUa_zUR4WyXt7bGDyvKr9uKYY7Ki7lLPXq
 PyMemoryEditor/app/application.py,sha256=1S98I-wkccq1-8to6aLLlburgDvvmapbCQplk_ALEe8,16830
 PyMemoryEditor/app/cheat_entry.py,sha256=KOLcams-xkVEkV7rfrzhEI7IrsVvmGwsIr8cGcWdLM0,2841
 PyMemoryEditor/app/cheat_poll_worker.py,sha256=clkUklvuOVxbPfo_EJRjs8dfj_4RQk-3uusYhLcTtYM,12281
-PyMemoryEditor/app/cheat_table.py,sha256=vkQjgf1SFuVgMQ8e5h3Gn1NUN8asq9EwQbmRACD3gWk,34813
+PyMemoryEditor/app/cheat_table.py,sha256=TzZ4F2r_k19KQXdi_xOBPud0h-601v9nRaDIFwlTxJY,40843
 PyMemoryEditor/app/log_console_dialog.py,sha256=VpYXxECepcbrtcKNheO0xwSoB63RsP_s7DuQnzyDf_g,7153
 PyMemoryEditor/app/main_window.py,sha256=H-TjgY77PTWYMN-TYOJFAGAq3SnsoI4M1w-B3wpvx-c,41619
 PyMemoryEditor/app/memory_map_dialog.py,sha256=WBhitNAShpektV8o6hUgxroc7T_BnRhQdeX3OhHdy4E,23236
 PyMemoryEditor/app/memory_viewer_dialog.py,sha256=DoR5poOu0xNCI1myOv9K-I-1Hx1PVFZDSUrDFzYZZiQ,12472
 PyMemoryEditor/app/modules_dialog.py,sha256=AaEnTgYC1cP-YJ1XUrDsw1eaF1cE16YRlzTjoTvJMMw,11715
 PyMemoryEditor/app/open_process_dialog.py,sha256=KtqxW16GqAwMVcTKZ6oj3v--eLagEbwWMuXWIarVIKo,17139
-PyMemoryEditor/app/pointer_chain_dialog.py,sha256=mKFgWkrHyVVaPkYjzHy2khCWQfGeUroPmGa1gTjowgw,19974
-PyMemoryEditor/app/pointer_scan_dialog.py,sha256=kzZjsWopIKC7xq6X5Rmgp_qUJbJql0RPoWeAH-1hLqQ,38241
+PyMemoryEditor/app/pointer_chain_dialog.py,sha256=dUt832Wa3ruzWYpL-WDT_RiAQd1AhsdQmHSC5hHbysI,20461
+PyMemoryEditor/app/pointer_scan_dialog.py,sha256=p-4p919YWoE0qXCMbnHKFlAD7ylPac0SaMWJrqXoyY0,38617
 PyMemoryEditor/app/results_view.py,sha256=mrCJquUL3vJwlka5an8_YUXr8ycWgav4uO4c4pxTktk,11763
 PyMemoryEditor/app/scan_types.py,sha256=QYAERatT169A3QhXYzu1MS5hclHGJ9tbB3BYsP_q_-4,2078
-PyMemoryEditor/app/scan_worker.py,sha256=Tf_87Ad__OimeUDzTnBSKYMnlrVxomGOGQh6NnDnvNQ,17160
-PyMemoryEditor/app/scanner_panel.py,sha256=Z4BcN4WYL8_LVZ_7lUGZcqsCSCcTgAR3PNo-FNw8wjQ,18381
+PyMemoryEditor/app/scan_worker.py,sha256=9t4f-ih-G2MhU9vrtiud9_mzWCerv9Ce83PNkq_XDCI,19499
+PyMemoryEditor/app/scanner_panel.py,sha256=J3jBlPEPYp1L6Qd1CkEitHYP5aTlgCsxgtAZizftmJw,29352
 PyMemoryEditor/app/threads_dialog.py,sha256=HnPS7Mte6CboM0DaoqkTqnEg8Ck65L1FKW-eX8m2OEA,7509
-PyMemoryEditor/app/value_types.py,sha256=3Yq5ms7mb31nLKsvVO8VyyxpEdp6pTdsK1j3ul8ayek,10621
+PyMemoryEditor/app/value_types.py,sha256=eCImnr8nJEFcCBLTBD3PzmV1Ms4irQnurZIguVZUkho,18383
 PyMemoryEditor/linux/functions.py,sha256=raBILyavPlliEzM4r3z6qEcOWG_G7GUd_d1aWHF9K5U,21681
 PyMemoryEditor/linux/libc.py,sha256=U4yOpHJ48OAaDxcVk_s57GGXlvmyakInwM2liegf3OA,1431
 PyMemoryEditor/linux/process.py,sha256=_PafbkQHAcwsQlbwcUFd6ERHN_c4wQ3Qcgyt82Gz2Zw,8636
 PyMemoryEditor/linux/types.py,sha256=sOgO-s9oqKrKKCHMG4N-Pe7sNw49V06PeMENSNnNFl8,1924
 PyMemoryEditor/macos/__init__.py,sha256=85mOA4U5i9EW2r1ggKqRJkqRq0e9bV3I2HdfHIvox10,72
-PyMemoryEditor/macos/functions.py,sha256=C9_Cg4njd_1pCz-6cDNosnLN1DSRIeF4AK58WNyyNNc,42279
+PyMemoryEditor/macos/functions.py,sha256=zL8jylondbDAj7UUuLmU8Fg8wVTCWkmEEpTzAu_384c,42894
 PyMemoryEditor/macos/libsystem.py,sha256=H9p72IqO0C5CrMFCAjnY_iQCzi_AQgw6ZN6CXsopceo,8683
 PyMemoryEditor/macos/process.py,sha256=06zgLaTKIyc1DQZFgS-9lqT2imB_IYFTOs4xEfSgftg,13259
-PyMemoryEditor/macos/types.py,sha256=gttewVsWwwQKzhOhMkkjUTg0_ipH3kKkkQhxmv7oiUE,4855
+PyMemoryEditor/macos/types.py,sha256=bwPbYRZAOflITeNy0jeEXqFu-M5SVYkaFSsbyxz_K2w,5437
 PyMemoryEditor/process/__init__.py,sha256=Xh5jngBqZyNIA9y3uwE49LxK8uH8YYsu6qotx1mP_WE,213
 PyMemoryEditor/process/abstract.py,sha256=hv7eZyl6izTxz9z48X44QLh3g4fQdIBqVlrp8dJBnV0,53835
 PyMemoryEditor/process/errors.py,sha256=485SXkidg9_E_KjuhuF6AsQNuFZlY-Ag-sG1C6NsGMw,2054
@@ -45,7 +45,7 @@ PyMemoryEditor/process/thread_info.py,sha256=GeIpfL9TD0YVV75vlBlCUlseCDUNsTDKmxz
 PyMemoryEditor/process/util.py,sha256=qwh3agrj8B_EDu5LsfMxKFhFSp9YDafXkoUuOUV7owI,3160
 PyMemoryEditor/util/__init__.py,sha256=Lux1_4twAhkzdWDV4xt4INmshKXZAHje_NU2WuwQhoE,512
 PyMemoryEditor/util/convert.py,sha256=CnnJ0wTc8oN5kliAaH4IZJtxI1J0_hS7YKFyVuNyMWU,14399
-PyMemoryEditor/util/pattern.py,sha256=d8PLbTCMwpPiO1HF0tJ0WNXHQ0VG33dJvqAHLGMExf0,4321
+PyMemoryEditor/util/pattern.py,sha256=OKcnTv5v1ny62dutwd850L-yQJMLa8fXybcbwdivcdg,5384
 PyMemoryEditor/util/scan.py,sha256=ZCQP2g_ANFdHNmhXf2CayV8zB44IAqHsG2lA7REMKF0,19811
 PyMemoryEditor/util/scan_numpy.py,sha256=osqZh7hfu9meKGXJPROLqzQ-UdSrCduqkv7EzUfVDp4,5889
 PyMemoryEditor/win32/functions.py,sha256=v-OAHBJZEcmLTCbRuqPpprik_CuvYVEuyVH-POAXlM0,34204
@@ -59,8 +59,8 @@ PyMemoryEditor/win32/enums/process_operations.py,sha256=wn-aMl01VVg-2rFavR9szBNR
 PyMemoryEditor/win32/enums/standard_access_rights.py,sha256=VGWlTagW4hvbm2AjZ4NK56ZrQwRmEl9Kz9GSCG8o-HI,738
 PyMemoryEditor/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 PyMemoryEditor/app/assets/icon.svg,sha256=T7OqR7ldqC_dK2Ib2ntsH2rWO-Z5RzNK4WdD1wFwgM4,7132
-pymemoryeditor-2.1.0.dist-info/METADATA,sha256=M4v5aHIbeFv2QZsQIaULx1z8BQO7ElVZBGZx87NBF5A,9622
-pymemoryeditor-2.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-pymemoryeditor-2.1.0.dist-info/entry_points.txt,sha256=ct14npP5HRKCHdq6-n83KBFi5QwQNSCsWE3MmGaWbzY,75
-pymemoryeditor-2.1.0.dist-info/licenses/LICENSE,sha256=YkOx6Nvkavq36bgiAc3eF85SBG0Qu14KMAvxmv6Ssjc,1089
-pymemoryeditor-2.1.0.dist-info/RECORD,,
+pymemoryeditor-2.2.0.dist-info/METADATA,sha256=hiAocF8rEWox6UUUsnI_PKGgDLD5cbByM03DxF1PofY,8540
+pymemoryeditor-2.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pymemoryeditor-2.2.0.dist-info/entry_points.txt,sha256=ct14npP5HRKCHdq6-n83KBFi5QwQNSCsWE3MmGaWbzY,75
+pymemoryeditor-2.2.0.dist-info/licenses/LICENSE,sha256=YkOx6Nvkavq36bgiAc3eF85SBG0Qu14KMAvxmv6Ssjc,1089
+pymemoryeditor-2.2.0.dist-info/RECORD,,