@@ -422,6 +422,25 @@ def _register_name(protocol: 'Type[ProtocolBase]', *targets: 'tuple[type, Any]')
     Enum_LinkType: (Frame, PCAPNG),
 }
 
+#: Key type of each ``__proto__`` dispatch registry a ``code=`` target can name.
+#:
+#: Maps the class owning the registry to the enum its typed registrar checks
+#: ``code`` against, and whether a bare :class:`int` is a valid key there too --
+#: the same :func:`_check_code` arguments that registrar passes. A destination is
+#: looked up by the class it inherits ``__proto__`` from, so a subclass sharing
+#: :class:`Link`'s registry is checked as :class:`Link` is, while one keeping a
+#: registry of its own, such as :class:`~pcapkit.protocols.link.loopback.Loopback`,
+#: names no entry here and is not checked (:issue:`2268`).
+_DESTINATION_KINDS: 'dict[type, tuple[type, bool]]' = {
+    Link: (Enum_EtherType, False),
+    Internet: (Enum_TransType, False),
+    Frame: (Enum_LinkType, False),
+    PCAPNG: (Enum_LinkType, False),
+    TCP: (Enum_AppType, True),
+    UDP: (Enum_AppType, True),
+    SCTP: (Enum_PayloadProtocolIdentifier, True),
+}
+
 
 def _iter_code_targets(code: 'Any') -> 'Iterator[tuple[Type[ProtocolBase], Any]]':
     """Flatten a ``code=`` argument into ``(destination, key)`` pairs.
@@ -527,10 +546,22 @@ def register_protocol_code(protocol: 'Type[ProtocolBase]', code: 'Any') -> 'None
         RegistryError: If a bare :class:`int` (or any other non-enum,
             non-mapping value) is given without an explicit destination, or if
             an enum member's type names no known destination registry --
-            inference refuses rather than guesses.
+            inference refuses rather than guesses; or if a key is not of the
+            type its destination's registry is keyed by, as its typed registrar
+            would reject it, e.g. ``{Frame: TransType.ICMP}``. Every target is
+            checked before any is registered, so a rejected ``code`` leaves
+            every registry as it was (:issue:`2268`).
 
     """
-    for destination, key in _iter_code_targets(code):
+    targets = list(_iter_code_targets(code))
+    for destination, key in targets:
+        owner = next((klass for klass in getattr(destination, '__mro__', ())
+                      if '__proto__' in vars(klass)), None)
+        if owner in _DESTINATION_KINDS:
+            kind, number = _DESTINATION_KINDS[owner]
+            _check_code(key, kind, number=number)
+
+    for destination, key in targets:
         destination.register(key, protocol)
         logger.debug('registered %s into %s.__proto__: %s', protocol.__name__,
                      destination.__name__, key)
 
@@ -31,10 +31,15 @@
 import importlib.util
 import sys
 import unittest
+import warnings
+from typing import TYPE_CHECKING
 from unittest import mock
 
 from tests._support import reimport_once_per_class
 
+if TYPE_CHECKING:
+    from typing import Any
+
 #: Test tier (#1958): branches on the running interpreter's version or implementation.
 __tier__ = 'ALL'
 
@@ -407,5 +412,118 @@ def test_backward_compatible_dispatch_tables_are_unaffected(self) -> None:
                          ('pcapkit.protocols.internet.ipv4', 'IPv4'))
 
 
+@unittest.skipUnless(HAS_RUNTIME, 'runtime dependencies not installed')
+class RegisterProtocolCodeKeyCheckTests(unittest.TestCase):
+    """Each ``code=`` key is checked against its destination's key type, all before any registers (#2268).
+
+    The typed registrars reject a member of another enum (#2224), but
+    ``register_protocol_code`` handed every ``{destination: key}`` pair straight
+    to ``destination.register``. The registry enums compare equal to their
+    values, so ``{Frame: TransType.ICMP}`` replaced the shipped entry at
+    ``LinkType.ETHERNET`` with only a warning. It also registered each target as
+    it flattened them, so a bad later target left the earlier ones in place.
+
+    Each case snapshots every dispatch registry and the name registry, expects
+    :exc:`~pcapkit.utilities.exceptions.RegistryError`, compares each registry
+    with its snapshot, and restores the snapshot whatever happened.
+    """
+
+    def setUp(self) -> None:
+        reimport_once_per_class(self)
+
+    def _assert_rejected_unchanged(self, call: 'Any') -> None:
+        from pcapkit.protocols import __proto__ as protocol_registry
+        from pcapkit.protocols.internet.internet import Internet
+        from pcapkit.protocols.link.link import Link
+        from pcapkit.protocols.misc.pcap.frame import Frame
+        from pcapkit.protocols.misc.pcapng import PCAPNG
+        from pcapkit.protocols.transport.sctp import SCTP
+        from pcapkit.protocols.transport.tcp import TCP
+        from pcapkit.protocols.transport.udp import UDP
+        from pcapkit.utilities.exceptions import RegistryError
+
+        tables = {klass.__name__: klass.__proto__
+                  for klass in (Link, Internet, Frame, PCAPNG, TCP, UDP, SCTP)}
+        tables['pcapkit.protocols'] = protocol_registry
+        before = {name: dict(table) for name, table in tables.items()}
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                with self.assertRaises(RegistryError):
+                    call()
+            for name, table in tables.items():
+                if name != 'pcapkit.protocols':
+                    self.assertEqual(dict(table), before[name], f'{name}.__proto__ changed')
+        finally:
+            for name, table in tables.items():
+                table.clear()
+                table.update(before[name])
+
+    def test_mapping_rejects_a_member_of_another_enum(self) -> None:
+        """The issue's example: ``TransType.ICMP`` equals ``LinkType.ETHERNET``."""
+        from pcapkit.const.reg.linktype import LinkType
+        from pcapkit.const.reg.transtype import TransType
+        from pcapkit.foundation.registry.protocols import register_protocol_code
+        from pcapkit.protocols.misc.pcap.frame import Frame
+        from pcapkit.protocols.misc.raw import Raw
+
+        self.assertEqual(TransType.ICMP, LinkType.ETHERNET)
+        self._assert_rejected_unchanged(lambda: register_protocol_code(Raw, {Frame: TransType.ICMP}))
+
+    def test_class_keyword_rejects_a_member_of_another_enum(self) -> None:
+        from pcapkit.const.reg.transtype import TransType
+        from pcapkit.protocols.misc.pcap.frame import Frame
+        from pcapkit.protocols.misc.raw import Raw
+
+        def define() -> None:
+            class Evil(Raw, code={Frame: TransType.ICMP}):
+                pass
+
+        self._assert_rejected_unchanged(define)
+
+    def test_subclass_sharing_a_registry_is_checked_as_its_owner(self) -> None:
+        """``Ethernet`` inherits ``Link.__proto__``, so its keys are ``EtherType``s."""
+        from pcapkit.const.reg.transtype import TransType
+        from pcapkit.foundation.registry.protocols import register_protocol_code
+        from pcapkit.protocols.link.ethernet import Ethernet
+        from pcapkit.protocols.misc.raw import Raw
+
+        self._assert_rejected_unchanged(lambda: register_protocol_code(Raw, {Ethernet: TransType.ICMP}))
+
+    def test_number_destination_rejects_a_member_of_another_enum(self) -> None:
+        from pcapkit.const.reg.linktype import LinkType
+        from pcapkit.foundation.registry.protocols import register_protocol_code
+        from pcapkit.protocols.misc.raw import Raw
+        from pcapkit.protocols.transport.udp import UDP
+
+        self._assert_rejected_unchanged(lambda: register_protocol_code(Raw, {UDP: LinkType(53)}))
+
+    def test_a_bad_later_target_leaves_the_earlier_ones_unregistered(self) -> None:
+        """The issue's list example, and one whose bad target fails the key check instead."""
+        from pcapkit.const.reg.transtype import TransType
+        from pcapkit.foundation.registry.protocols import register_protocol_code
+        from pcapkit.protocols.internet.internet import Internet
+        from pcapkit.protocols.misc.raw import Raw
+
+        for code in ([TransType.L2TP, 5], [TransType.L2TP, {Internet: 115}]):
+            with self.subTest(code=code):
+                self._assert_rejected_unchanged(lambda: register_protocol_code(Raw, code))
+
+    def test_number_and_own_registry_destinations_still_accept_an_int(self) -> None:
+        """A port is a valid ``TCP`` key; ``Loopback`` keeps an unchecked registry of its own."""
+        from pcapkit.foundation.registry.protocols import register_protocol_code
+        from pcapkit.protocols.link.loopback import Loopback
+        from pcapkit.protocols.transport.tcp import TCP
+
+        class FakeProtocol:
+            pass
+
+        with mock.patch.object(TCP, 'register') as reg_tcp, \
+                mock.patch.object(Loopback, 'register') as reg_loopback:
+            register_protocol_code(FakeProtocol, [{TCP: 54324}, {Loopback: 2}])
+        reg_tcp.assert_called_once_with(54324, FakeProtocol)
+        reg_loopback.assert_called_once_with(2, FakeProtocol)
+
+
 if __name__ == '__main__':
     unittest.main()