@@ -178,6 +178,7 @@ Preceded by `1.5.0a1` (2026-09-15), `1.5.0b1` to `1.5.0b3` (all 2026-09-19) and
 - the number registrars `register_tcp`, `register_udp`, `register_sctp` and `register_apptype` refuse a `bool` code with `RegistryError`, where `register_tcp(True, ...)` registered port 1, since `bool` is an `int` subclass ([#2269](https://github.com/JarryShaw/PyPCAPKit/issues/2269), [#2344](https://github.com/JarryShaw/PyPCAPKit/pull/2344)).
 - IP reassembly reports a datagram that is not itself fragmented but whose BUFID is already buffered: it submits that buffer as incomplete and then reassembles the datagram in a buffer of its own, per [RFC 791 Section 3.2](https://datatracker.ietf.org/doc/html/rfc791#section-3.2), where the datagram was never reported at all. On IPv6 an atomic fragment is reassembled in a buffer of its own and submitted without flushing the datagram already being reassembled, so that one's final fragment still completes it, per [RFC 6946 Section 4](https://datatracker.ietf.org/doc/html/rfc6946#section-4) ([#2270](https://github.com/JarryShaw/PyPCAPKit/issues/2270), [#2345](https://github.com/JarryShaw/PyPCAPKit/pull/2345)).
 - the PyPCAP, pcap-ct and pypcapfile engines warn with `AttributeWarning`, naming the engine, that they ignore a parsing context supplied through `Extractor`'s `context=`, as the dpkt, scapy and pyshark engines already did, where they dropped it silently ([#2313](https://github.com/JarryShaw/PyPCAPKit/issues/2313), [#2332](https://github.com/JarryShaw/PyPCAPKit/pull/2332)).
+- `Deferred` could not be pickled under protocol 0 or 1 -- a slotted class with no `__getstate__` raises `TypeError` there, independent of the `analyze`/`proto` regression [#2417](https://github.com/JarryShaw/PyPCAPKit/issues/2417) fixed. It now defines `__getstate__` and `__setstate__`, mirroring the `(dict_or_None, slots)` pair Python's own default slotted-class reduction already used for every released build, so a `Deferred` pickled by one of those still unpickles; both methods walk `type(self).__mro__` rather than reading `self.__slots__` directly, which would otherwise shadow a base class's slots under a subclass declaring its own ([#2423](https://github.com/JarryShaw/PyPCAPKit/issues/2423), [#2425](https://github.com/JarryShaw/PyPCAPKit/issues/2425), [#2424](https://github.com/JarryShaw/PyPCAPKit/pull/2424)).
 
 ### pcapkit.interface
 
 
@@ -1262,6 +1262,16 @@ Fixed
   naming the engine, that they ignore a parsing context supplied through
   :class:`.Extractor`'s ``context=``, as the dpkt, scapy and pyshark engines already
   did, where they dropped it silently (:issue:`2313`, :pr:`2332`).
+* :class:`~pcapkit.foundation.reassembly.data.data.Deferred` could not be pickled
+  under protocol 0 or 1 -- a slotted class with no ``__getstate__`` raises
+  :exc:`TypeError` there, independent of the ``analyze``/``proto`` regression
+  :issue:`2417` fixed. It now defines ``__getstate__`` and ``__setstate__``,
+  mirroring the ``(dict_or_None, slots)`` pair Python's own default slotted-class
+  reduction already used for every released build, so a ``Deferred`` pickled by
+  one of those still unpickles; both methods walk ``type(self).__mro__`` rather
+  than reading ``self.__slots__`` directly, which would otherwise shadow a base
+  class's slots under a subclass declaring its own (:issue:`2423`, :issue:`2425`,
+  :pr:`2424`).
 
 pcapkit.interface
 -----------------
 
@@ -10,7 +10,7 @@
 __all__ = ['ReassemblyData', 'Completion', 'Deferred']
 
 if TYPE_CHECKING:
-    from typing import Callable, Optional
+    from typing import Any, Callable, Optional
 
     from pcapkit.const.reg.transtype import TransType
     from pcapkit.foundation.reassembly.data.ip import Datagram as IP_Datagram
@@ -206,6 +206,70 @@ def __call__(self) -> 'ProtocolBase':
         """
         return self.analyze(self.proto, self.payload)
 
+    def __getstate__(self) -> 'tuple[Optional[dict[str, Any]], dict[str, Any]]':
+        """Pickling support.
+
+        A slotted class with no ``__dict__`` has nothing for the default
+        :mod:`pickle` reduction to read. :mod:`copyreg` refuses outright with
+        *"cannot be pickled"* under protocol 0 or 1 whenever
+        ``type(self).__getstate__`` is still the inherited default -- which is
+        why defining *any* ``__getstate__`` here, even one that only calls the
+        default, clears protocols 0 and 1 (:issue:`2423`). Protocol 2 and above
+        never needed one: their own ``__reduce_ex__`` already walks
+        ``__slots__`` directly.
+
+        The shape returned -- an instance-``__dict__`` state (or :data:`None`)
+        paired with a slots-state :obj:`dict` -- is deliberately the same one
+        Python's own default state construction produces for a slotted class,
+        rather than a bespoke flat :obj:`dict`. A flat shape would be a *new*
+        pickle format for this class: a ``Deferred`` already pickled by a
+        released version under protocol 2 or above -- every one of them built
+        this same ``(dict_or_None, slots)`` pair -- would fail to unpickle
+        against a flat-shaped :meth:`__setstate__`, and the reverse. Walking
+        ``type(self).__mro__`` rather than reading ``self.__slots__`` directly
+        is what keeps that promise for a subclass that declares its own
+        slots: ``self.__slots__`` resolves through the MRO like any other
+        attribute, so it would silently return only the *subclass's* tuple,
+        dropping every slot ``Deferred`` itself declares (:issue:`2425`).
+
+        """
+        slots: 'dict[str, Any]' = {}
+        for cls in type(self).__mro__:
+            for slot in getattr(cls, '__slots__', ()):
+                # ``__dict__`` and ``__weakref__`` are bookkeeping slots a class
+                # may declare to opt back into one; neither is a real attribute
+                # to carry here -- the instance ``__dict__`` state below covers
+                # the first, and a weak reference cannot survive a pickle round
+                # trip regardless.
+                if slot in ('__dict__', '__weakref__') or slot in slots:
+                    continue
+                if hasattr(self, slot):
+                    slots[slot] = getattr(self, slot)
+        dict_state = dict(self.__dict__) if getattr(self, '__dict__', None) else None
+        return (dict_state, slots)
+
+    def __setstate__(
+        self,
+        state: 'tuple[Optional[dict[str, Any]], dict[str, Any]] | dict[str, Any]',
+    ) -> 'None':
+        """Unpickling support; the counterpart to :meth:`__getstate__`.
+
+        Accepts the ``(dict_or_None, slots)`` pair :meth:`__getstate__` builds
+        above -- the shape every released, pre-:issue:`2423` pickle already
+        used under protocol 2 and above -- and, for a pickle made by this
+        class's own first, unreleased fix for :issue:`2423`, a bare :obj:`dict`
+        of ``{slot: value}`` (:issue:`2425`).
+
+        """
+        if isinstance(state, dict):
+            dict_state, slots = None, state
+        else:
+            dict_state, slots = state
+        if dict_state:
+            self.__dict__.update(dict_state)
+        for slot, value in slots.items():
+            setattr(self, slot, value)
+
 
 @info_final
 class ReassemblyData(Info):