testprotocols 0.7.2__tar.gz → 0.8.0__tar.gz

{testprotocols-0.7.2/src/testprotocols.egg-info → testprotocols-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testprotocols
-Version: 0.7.2
+Version: 0.8.0
 Summary: Common Test Resource Layer — capability and device protocols for telco testing.
 Author-email: Alottabits <rjvisser@alottabits.com>
 Maintainer-email: Alottabits <rjvisser@alottabits.com>

{testprotocols-0.7.2 → testprotocols-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "testprotocols"
-version = "0.7.2"
+version = "0.8.0"
 description = "Common Test Resource Layer — capability and device protocols for telco testing."
 requires-python = ">=3.12"
 dependencies = []

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/__init__.py

@@ -1,6 +1,6 @@
 """testprotocols — capability and device Protocols for telco resources under test."""
 
-__version__ = "0.7.2"
+__version__ = "0.8.0"
 
 from testprotocols.aftr_gateway import AftrGateway
 from testprotocols.appliance_nat import ApplianceNat
@@ -8,8 +8,10 @@ from testprotocols.appliance_uplinks import ApplianceUplinks
 from testprotocols.appliance_vlans import ApplianceVlans
 from testprotocols.arp_client import ArpClient
 from testprotocols.bgp import Bgp
+from testprotocols.config_ownership import ConfigOwnership
 from testprotocols.conntrack import Conntrack, ConntrackWhiteBox
 from testprotocols.content_filtering import ContentFiltering
+from testprotocols.device_info import DeviceInfo
 from testprotocols.device_lifecycle import DeviceLifecycle
 from testprotocols.device_management import DeviceManagement
 from testprotocols.devices.base import BaseDeviceProtocol
@@ -60,6 +62,7 @@ from testprotocols.mac_table import MacTable
 from testprotocols.multicast_client import MulticastClient
 from testprotocols.nat import Nat
 from testprotocols.netem_controller import NetemController
+from testprotocols.network_attachment import NetworkAttachment
 from testprotocols.nmap_scanner import NmapScanner
 from testprotocols.ntp_client import NtpClient
 from testprotocols.ntp_config import NtpConfig
@@ -67,6 +70,7 @@ from testprotocols.ospf import Ospf
 from testprotocols.packet_filter import PacketFilter, PacketFilterWhiteBox
 from testprotocols.pcap_capture import PcapCapture
 from testprotocols.pdu_controller import PduController
+from testprotocols.placement import PlacementPipe, PlacementPorts
 from testprotocols.port_poe import PortPoe
 from testprotocols.port_security import PortSecurity
 from testprotocols.port_status import PortStatus
@@ -116,10 +120,12 @@ __all__ = [
     "ArpClient",
     "BaseDeviceProtocol",
     "Bgp",
+    "ConfigOwnership",
     "Conntrack",
     "ConntrackWhiteBox",
     "ContentFiltering",
     "CpeDevice",
+    "DeviceInfo",
     "DeviceLifecycle",
     "DeviceManagement",
     "DhcpClient",
@@ -153,6 +159,7 @@ __all__ = [
     "MulticastClient",
     "Nat",
     "NetemController",
+    "NetworkAttachment",
     "NmapScanner",
     "NtpClient",
     "NtpConfig",
@@ -161,6 +168,8 @@ __all__ = [
     "PacketFilterWhiteBox",
     "PcapCapture",
     "PduController",
+    "PlacementPipe",
+    "PlacementPorts",
     "PortPoe",
     "PortSecurity",
     "PortStatus",

testprotocols-0.8.0/src/testprotocols/config_ownership.py

@@ -0,0 +1,21 @@
+"""Config ownership template.
+
+Defines the abstract contract for session write-ownership of a device's
+network configuration — e.g. a warm-spare member whose primary owns the
+writes. The natural home for future redundancy-role facts.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ConfigOwnership(Protocol):
+    """Abstract contract for network-config write ownership."""
+
+    @property
+    def manages_network(self) -> bool:
+        """Whether this session owns the device's network configuration.
+        False for a warm-spare member whose primary owns the writes."""
+        ...

testprotocols-0.8.0/src/testprotocols/device_info.py

@@ -0,0 +1,22 @@
+"""Device info template.
+
+Defines the abstract contract for a device's inventory identity — today the
+hardware model. Vendor-neutral metadata the driver resolves from its
+management API, inventory config, or class knowledge; the coverage axis for
+model-parameterised tests. Extensible with further identity facts (serial,
+firmware version) when a consumer needs them.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class DeviceInfo(Protocol):
+    """Abstract contract for device inventory identity."""
+
+    @property
+    def model(self) -> str:
+        """Hardware model identifier (e.g. ``"MX250"``)."""
+        ...

testprotocols-0.8.0/src/testprotocols/devices/__init__.py

@@ -0,0 +1,80 @@
+"""Device archetype registry — maps inventory device_type strings to Protocols."""
+
+from __future__ import annotations
+
+import importlib
+from dataclasses import dataclass
+from typing import Any, cast, get_type_hints
+
+_registry: dict[str, DeviceTypeSpec] = {}
+
+#: The sole sanctioned non-capability members — BaseDeviceProtocol's universal
+#: identity pair (see devices/base.py).
+IDENTITY_MEMBERS = frozenset({"device_name", "device_type"})
+
+
+def non_capability_members(protocol: type) -> frozenset[str]:
+    """Members of *protocol* that are neither capability Protocols nor identity.
+
+    A capability member is annotated with a ``typing.Protocol`` class. Scalar
+    annotations (``str``, ``bool``, ``tuple``…) and property-declared members
+    (which carry no annotation at all) are both offenders. ``__protocol_attrs__``
+    is the CPython 3.12 runtime detail ``typing.get_protocol_members``
+    supersedes in 3.13; one cast keeps that knowledge here.
+    """
+    hints = get_type_hints(protocol)
+    members: frozenset[str] = frozenset(cast("Any", protocol).__protocol_attrs__)
+    return frozenset(
+        member
+        for member in members - IDENTITY_MEMBERS
+        if not getattr(hints.get(member), "_is_protocol", False)
+    )
+
+
+@dataclass(frozen=True)
+class DeviceTypeSpec:
+    """Registration record: inventory string -> @runtime_checkable Protocol class."""
+
+    name: str
+    protocol: type
+
+
+def register_device_type(name: str, protocol: type) -> DeviceTypeSpec:
+    """Register *protocol* as the contract for inventory devices typed *name*.
+
+    Fails closed on archetype drift: every member must be a capability
+    Protocol (the BaseDeviceProtocol identity pair excepted) — see
+    docs/architecture/capability-only-archetypes.md. Returns the spec; also
+    stored in the module-level registry so ``get_device_type(name)`` can look
+    it up by inventory string.
+    """
+    offenders = non_capability_members(protocol)
+    if offenders:
+        raise TypeError(
+            f"device archetype {protocol.__name__!r} ({name!r}) declares "
+            f"non-capability members {sorted(offenders)}; archetypes compose "
+            "capability protocols only — move these into a capability protocol "
+            "(docs/architecture/capability-only-archetypes.md)"
+        )
+    spec = DeviceTypeSpec(name=name, protocol=protocol)
+    _registry[name] = spec
+    return spec
+
+
+def get_device_type(name: str) -> DeviceTypeSpec | None:
+    """Return the spec for inventory *name*, or None if not registered."""
+    return _registry.get(name)
+
+
+def all_device_types() -> dict[str, DeviceTypeSpec]:
+    """Return a copy of the full registry."""
+    return dict(_registry)
+
+
+# Auto-import all archetype modules to trigger registration as a side effect.
+# ``importlib.import_module`` avoids the unused-import / out-of-order-import
+# friction that direct ``from … import …`` statements would create here, and
+# keeps the import section at the top of the file as PEP 8 prefers.
+for _mod in ("client", "cpe", "infra", "sdwan", "switch", "traffic", "voice", "wan"):
+    importlib.import_module(f"testprotocols.devices.{_mod}")
+del _mod

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/devices/base.py

@@ -21,7 +21,9 @@ class BaseDeviceProtocol(Protocol):
     Deliberately scoped to the universal pair — name + type. Anything a
     specific framework wants to expose (vitro's ``config`` /
     ``get_interactive_consoles``, boardfarm's lifecycle hooks, etc.) is
-    the framework's own concern. Frameworks declare a connector Protocol
+    the framework's own concern. Every other archetype member must be a
+    capability Protocol — enforced by ``register_device_type``; see
+    docs/architecture/capability-only-archetypes.md. Frameworks declare a connector Protocol
     on their side that extends this base; testbed plugins compose
     archetype + framework-connector into a combined Protocol where step
     defs need both.

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/devices/client.py

@@ -17,12 +17,14 @@ from testprotocols.ip_routing import IpRouting
 from testprotocols.iperf_client import IperfClient
 from testprotocols.iperf_server import IperfServer
 from testprotocols.multicast_client import MulticastClient
+from testprotocols.network_attachment import NetworkAttachment
 from testprotocols.network_endpoint import NetworkEndpoint
 from testprotocols.network_probe import NetworkProbe
 from testprotocols.nmap_scanner import NmapScanner
 from testprotocols.ntp_client import NtpClient
 from testprotocols.packet_filter import PacketFilter
 from testprotocols.pcap_capture import PcapCapture
+from testprotocols.placement import PlacementPipe
 from testprotocols.qoe_browser import QoeBrowser
 from testprotocols.reachability_responder import ReachabilityResponder
 from testprotocols.syslog_config import SyslogConfig
@@ -128,37 +130,14 @@ class QoeMeasurementClientDevice(QoeClientDevice, Protocol):
     responder: ReachabilityResponder
     pcap: PcapCapture
 
-    test_ip: str
-    """The client's test-plane address as a CIDR (e.g. ``"10.1.30.50/24"``), empty
-    if the client is not homed to a test segment. Vendor-neutral metadata the
-    driver resolves from its homing config — read it here rather than reaching into
-    a framework-specific config object."""
-
-    attachment_segment: str
-    """The declared segment LABEL of a guest-attached client (a client whose
-    test leg sits on a segment the testbed does not manage), empty for managed
-    homing or when undeclared. A stable role name (e.g. ``"provider-vpn"``),
-    never an address: it lets tests resolve "the client on segment X" by
-    declaration when address facts are foreign-owned or discovered late.
-    Vendor-neutral metadata from the driver's attachment config."""
-
-    attachment_subnet: str
-    """The declared subnet (CIDR) of a guest attachment, empty when undeclared.
-    Vendor-neutral metadata from the driver's attachment config — read it here
-    rather than reaching into a framework-specific config object."""
-
-    mgmt_ip: str
-    """The client's management-plane address, empty when undeclared. Published
-    by the driver from its own config so isolation checks never consume a
-    framework-specific config object."""
-
-    pipe_switch: str
-    """Name of the switch carrying this client's dedicated access port (its
-    placement pipe), empty when the client has no declared pipe."""
-
-    pipe_port: str
-    """The dedicated access port whose VLAN is this client's placement knob,
-    empty when the client has no declared pipe."""
+    attachment: NetworkAttachment
+    """Homing metadata — test/mgmt plane addresses and the declared guest
+    attachment (segment label + subnet). See ``NetworkAttachment`` for the
+    boundary against ``NetworkEndpoint``."""
+
+    pipe: PlacementPipe
+    """This client's declared placement pipe (dedicated access port on a
+    managed switch); counterpart of the switch's ``placement`` authorization."""
 
 
 register_device_type("linux_lan_client", LanClientDevice)

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/devices/sdwan.py

@@ -8,8 +8,10 @@ from testprotocols.appliance_nat import ApplianceNat
 from testprotocols.appliance_uplinks import ApplianceUplinks
 from testprotocols.appliance_vlans import ApplianceVlans
 from testprotocols.bgp import Bgp
+from testprotocols.config_ownership import ConfigOwnership
 from testprotocols.conntrack import Conntrack
 from testprotocols.content_filtering import ContentFiltering
+from testprotocols.device_info import DeviceInfo
 from testprotocols.devices import register_device_type
 from testprotocols.devices.base import BaseDeviceProtocol
 from testprotocols.ip_interface import IpInterface
@@ -93,17 +95,14 @@ class SdwanApplianceDevice(BaseDeviceProtocol, Protocol):
     lan: ApplianceVlans
     syslog: SyslogConfig
 
-    model: str
-    """Hardware model identifier (e.g. ``"MX250"``) — vendor-neutral metadata the
-    driver resolves from its management API / inventory. The coverage axis for
-    model-parameterised tests; read it here rather than reaching into a
-    framework-specific config object."""
-
-    manages_network: bool
-    """Whether this session owns the device's network configuration. False for
-    a warm-spare member whose primary owns the writes. Vendor-neutral metadata
-    from the driver's config — read it here rather than reaching into a
-    framework-specific config object."""
+    info: DeviceInfo
+    """Inventory identity (hardware model, e.g. ``"MX250"``) — the coverage
+    axis for model-parameterised tests, resolved by the driver from its
+    management API / inventory."""
+
+    ownership: ConfigOwnership
+    """Whether this session owns the appliance's network configuration —
+    False for a warm-spare member whose primary owns the writes."""
 
 
 register_device_type("sdwan_appliance", SdwanApplianceDevice)

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/devices/switch.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 from typing import Protocol, runtime_checkable
 
 from testprotocols.bgp import Bgp
+from testprotocols.device_info import DeviceInfo
 from testprotocols.devices import register_device_type
 from testprotocols.devices.base import BaseDeviceProtocol
 from testprotocols.discovery import Discovery
@@ -22,6 +23,7 @@ from testprotocols.link_aggregation import LinkAggregation
 from testprotocols.mac_table import MacTable
 from testprotocols.ntp_config import NtpConfig
 from testprotocols.ospf import Ospf
+from testprotocols.placement import PlacementPorts
 from testprotocols.port_poe import PortPoe
 from testprotocols.port_security import PortSecurity
 from testprotocols.port_status import PortStatus
@@ -68,11 +70,13 @@ class L2Switch(BaseDeviceProtocol, Protocol):
     syslog: SyslogConfig
     ntp: NtpConfig
 
-    placement_ports: tuple[str, ...]
-    """Designated ports a testbed may re-VLAN to place a client; empty means
-    no placement write is permitted on this switch. Independent of which
-    device's pipe enters a port: pipe ownership is topology, this is write
-    authorization — declared by the switch, the resource's owner."""
+    placement: PlacementPorts
+    """Placement-write authorization — which ports a testbed may re-VLAN to
+    place a client; counterpart of a client's ``pipe`` declaration."""
+
+    info: DeviceInfo
+    """Inventory identity (hardware model) — the coverage axis for
+    model-parameterised switch tests."""
 
 
 register_device_type("managed_switch_l2", L2Switch)

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/devices/voice.py

@@ -21,20 +21,8 @@ class SipPhoneDevice(BaseDeviceProtocol, Protocol):
     Used to drive call-control scenarios (register / invite / cancel / bye) and
     media-plane verification against a SIP server under test.
 
-    A phone has one or more SIP accounts (lines). Most testbeds run single-line
-    phones; multi-line phones expose additional entries in ``aors``.
-
-    ``aors`` is the list of registered SIP URIs in RFC 3261 §6 address-of-record
-    form (``sip:user@host`` with optional ``;params``). ``host`` may be an FQDN,
-    an IPv4 literal (``10.0.0.5``), or an IPv6 bracketed literal
-    (``[2001:db8::5]``) — the driver decides which form matches its testbed's
-    address-resolution context. The list is never empty; ``aors[0]`` is the
-    primary line that single-line operations (``sip_phone.dial``,
-    ``sip_phone.answer``, MWI subscriptions, …) act on.
-
-    ``number`` is the user-part of ``aors[0]`` — the SIP phone's E.164 /
-    dial-string identifier for its primary line. Provided as a convenience so
-    single-line callers don't have to parse SIP URIs.
+    Line identity — ``number`` / ``aors`` — lives on the ``SipPhone``
+    capability protocol.
 
     ``device_name`` / ``device_type`` come from :class:`BaseDeviceProtocol`.
     """
@@ -42,8 +30,6 @@ class SipPhoneDevice(BaseDeviceProtocol, Protocol):
     sip_phone: SipPhone
     ip_interface: IpInterface
     dhcp_client: DhcpClient
-    number: str
-    aors: list[str]
 
 
 @runtime_checkable
@@ -53,16 +39,13 @@ class SipServerDevice(BaseDeviceProtocol, Protocol):
     Provides the server-side SIP surface plus packet capture and file transfer
     for inspecting and exporting signalling exchanges.
 
-    ``aor_domain`` is the host part that callers should embed in SIP AORs
-    targeting this server (``sip:user@<aor_domain>``). May be an FQDN, an
-    IPv4 literal, or an IPv6 bracketed literal — the driver decides which
-    form matches its testbed's address-resolution context.
+    The AOR host part — ``aor_domain`` — lives on the ``SipServer``
+    capability protocol.
     """
 
     sip_server: SipServer
     pcap: PcapCapture
     file_transfer: FileTransfer
-    aor_domain: str
 
 
 register_device_type("linux_sip_phone", SipPhoneDevice)

testprotocols-0.8.0/src/testprotocols/network_attachment.py

@@ -0,0 +1,56 @@
+"""Network attachment template.
+
+Defines the abstract contract for an endpoint's *declared or discovered
+homing* onto the testbed's network planes: its test-plane address, its
+management-plane address, and — for a guest-attached endpoint (one whose
+test leg sits on a segment the testbed does not manage) — the declared
+segment label and subnet.
+
+Distinct from ``NetworkEndpoint``: that is the live role-address query
+("give me the WAN address, now"), answered by whatever means the driver
+chooses. ``NetworkAttachment`` is homing *metadata* the driver resolves
+from its own config or discovers at attach time (e.g. a DHCP lease),
+published so consumers never reach into a framework-specific config
+object. Archetypes whose drivers already answer addressing via
+``NetworkEndpoint`` should not also compose this; it earns its place
+where declared homing (segment labels, plane separation) is the
+mechanism under test.
+
+All values are vendor-neutral; empty string means undeclared/not homed.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class NetworkAttachment(Protocol):
+    """Abstract contract for an endpoint's homing metadata."""
+
+    @property
+    def test_ip(self) -> str:
+        """The endpoint's test-plane address as a CIDR (e.g. ``"10.1.30.50/24"``),
+        empty if not homed to a test segment. May be discovered at attach time
+        (e.g. from a DHCP lease) rather than declared."""
+        ...
+
+    @property
+    def mgmt_ip(self) -> str:
+        """The endpoint's management-plane address, empty when undeclared.
+        Published so isolation checks never consume a framework-specific
+        config object."""
+        ...
+
+    @property
+    def segment(self) -> str:
+        """Declared segment LABEL of a guest attachment — a stable role name
+        (e.g. ``"provider-vpn"``), never an address — empty for managed homing
+        or when undeclared. Lets tests resolve "the endpoint on segment X" by
+        declaration when address facts are foreign-owned or discovered late."""
+        ...
+
+    @property
+    def subnet(self) -> str:
+        """Declared subnet (CIDR) of a guest attachment, empty when undeclared."""
+        ...

testprotocols-0.8.0/src/testprotocols/placement.py

@@ -0,0 +1,44 @@
+"""Client-placement templates — both halves of the placement mechanism.
+
+A *placement pipe* is a client's dedicated access port on a managed switch:
+re-VLANing that port is the client's placement knob. The mechanism has two
+sides owned by two devices: the **client** declares which switch/port carries
+its pipe (``PlacementPipe`` — topology fact), and the **switch** declares
+which ports a testbed may re-VLAN at all (``PlacementPorts`` — write
+authorization, owned by the resource's owner). Pipe ownership and write
+authorization are deliberately independent declarations.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class PlacementPipe(Protocol):
+    """Abstract contract for a client's declared placement pipe."""
+
+    @property
+    def switch(self) -> str:
+        """Name of the switch carrying this client's dedicated access port,
+        empty when the client has no declared pipe."""
+        ...
+
+    @property
+    def port(self) -> str:
+        """The dedicated access port whose VLAN is this client's placement
+        knob, empty when the client has no declared pipe."""
+        ...
+
+
+@runtime_checkable
+class PlacementPorts(Protocol):
+    """Abstract contract for a switch's placement-write authorization."""
+
+    @property
+    def ports(self) -> tuple[str, ...]:
+        """Designated ports a testbed may re-VLAN to place a client; empty
+        means no placement write is permitted on this switch. Independent of
+        which device's pipe enters a port: pipe ownership is topology, this is
+        write authorization — declared by the switch, the resource's owner."""
+        ...

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/sip_phone.py

@@ -13,6 +13,24 @@ from typing import Protocol, runtime_checkable
 class SipPhone(Protocol):
     """Abstract contract for SIP phone operations."""
 
+    @property
+    def number(self) -> str:
+        """The user-part of ``aors[0]`` — the phone's E.164 / dial-string
+        identifier for its primary line. A convenience so single-line callers
+        don't have to parse SIP URIs."""
+        ...
+
+    @property
+    def aors(self) -> list[str]:
+        """Registered SIP URIs in RFC 3261 §6 address-of-record form
+        (``sip:user@host`` with optional ``;params``). ``host`` may be an FQDN,
+        an IPv4 literal, or an IPv6 bracketed literal — the driver decides
+        which form matches its testbed's address-resolution context. Never
+        empty once configured; ``aors[0]`` is the primary line that single-line
+        operations (``dial``, ``answer``, MWI subscriptions, …) act on.
+        Multi-line phones expose additional entries."""
+        ...
+
     def phone_start(self) -> None:
         """Start the SIP phone software."""
         ...

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols/sip_server.py

@@ -32,6 +32,14 @@ class SipServer(Protocol):
         """IPv6 address of the SIP server, or None if not configured."""
         ...
 
+    @property
+    def aor_domain(self) -> str:
+        """The host part callers should embed in SIP AORs targeting this
+        server (``sip:user@<aor_domain>``). May be an FQDN, an IPv4 literal,
+        or an IPv6 bracketed literal — the driver decides which form matches
+        its testbed's address-resolution context."""
+        ...
+
     # ------------------------------------------------------------------
     # Abstract methods
     # ------------------------------------------------------------------

{testprotocols-0.7.2 → testprotocols-0.8.0/src/testprotocols.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testprotocols
-Version: 0.7.2
+Version: 0.8.0
 Summary: Common Test Resource Layer — capability and device protocols for telco testing.
 Author-email: Alottabits <rjvisser@alottabits.com>
 Maintainer-email: Alottabits <rjvisser@alottabits.com>

{testprotocols-0.7.2 → testprotocols-0.8.0}/src/testprotocols.egg-info/SOURCES.txt

@@ -9,8 +9,10 @@ src/testprotocols/appliance_uplinks.py
 src/testprotocols/appliance_vlans.py
 src/testprotocols/arp_client.py
 src/testprotocols/bgp.py
+src/testprotocols/config_ownership.py
 src/testprotocols/conntrack.py
 src/testprotocols/content_filtering.py
+src/testprotocols/device_info.py
 src/testprotocols/device_lifecycle.py
 src/testprotocols/device_management.py
 src/testprotocols/dhcp_client.py
@@ -38,6 +40,7 @@ src/testprotocols/mac_table.py
 src/testprotocols/multicast_client.py
 src/testprotocols/nat.py
 src/testprotocols/netem_controller.py
+src/testprotocols/network_attachment.py
 src/testprotocols/network_endpoint.py
 src/testprotocols/network_probe.py
 src/testprotocols/nmap_scanner.py
@@ -47,6 +50,7 @@ src/testprotocols/ospf.py
 src/testprotocols/packet_filter.py
 src/testprotocols/pcap_capture.py
 src/testprotocols/pdu_controller.py
+src/testprotocols/placement.py
 src/testprotocols/port_poe.py
 src/testprotocols/port_security.py
 src/testprotocols/port_status.py
@@ -120,6 +124,8 @@ src/testprotocols/models/traffic.py
 src/testprotocols/models/wan_edge.py
 src/testprotocols/models/wifi.py
 tests/test_appliance_vlans.py
+tests/test_archetype_purity.py
+tests/test_boundary_capability_templates.py
 tests/test_cpe_templates.py
 tests/test_device_types.py
 tests/test_dhcp_templates.py

testprotocols-0.8.0/tests/test_archetype_purity.py

@@ -0,0 +1,59 @@
+"""Archetype-purity drift gate.
+
+Device archetypes must compose capability protocols only; the sole sanctioned
+exception is the BaseDeviceProtocol identity pair. Enforced twice: here (the
+merge gate — parametrized over the registry, so every future archetype is
+covered the moment it is registered) and in register_device_type itself (the
+import-time gate that also covers plugin-local archetypes downstream). See
+docs/architecture/capability-only-archetypes.md.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+import pytest
+from testprotocols.devices import (
+    DeviceTypeSpec,
+    all_device_types,
+    get_device_type,
+    non_capability_members,
+    register_device_type,
+)
+from testprotocols.devices.base import BaseDeviceProtocol
+
+
+@pytest.mark.parametrize(
+    ("name", "spec"),
+    sorted(all_device_types().items()),
+    ids=lambda v: v if isinstance(v, str) else "",
+)
+def test_archetype_members_are_capability_protocols(name: str, spec: DeviceTypeSpec) -> None:
+    offenders = non_capability_members(spec.protocol)
+    assert not offenders, (
+        f"{name}: non-capability members {sorted(offenders)} — archetypes compose "
+        "capability protocols only (docs/architecture/capability-only-archetypes.md)"
+    )
+
+
+def test_checker_detects_scalar_members() -> None:
+    """The checker flags annotated scalars AND property-declared scalars."""
+
+    @runtime_checkable
+    class _Rogue(BaseDeviceProtocol, Protocol):
+        rogue_scalar: str
+
+        @property
+        def rogue_property(self) -> int: ...
+
+    assert non_capability_members(_Rogue) == {"rogue_scalar", "rogue_property"}
+
+
+def test_register_rejects_non_capability_archetype() -> None:
+    @runtime_checkable
+    class _Rogue(BaseDeviceProtocol, Protocol):
+        rogue_scalar: str
+
+    with pytest.raises(TypeError, match="rogue_scalar"):
+        register_device_type("_rogue_purity_probe", _Rogue)
+    assert get_device_type("_rogue_purity_probe") is None, "must not register on failure"