oaknut-econet-core 13.6.0__tar.gz

oaknut_econet_core-13.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Smallshire
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

oaknut_econet_core-13.6.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: oaknut-econet-core
+Version: 13.6.0
+Summary: Core abstractions for Econet networking in the oaknut family: packet types, addressing, the EconetTransport interface, capabilities, and an in-process test transport.
+Author-email: Robert Smallshire <robert@smallshire.org.uk>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rob-smallshire/oaknut/tree/master/packages/oaknut-econet-core
+Project-URL: Repository, https://github.com/rob-smallshire/oaknut
+Project-URL: Issues, https://github.com/rob-smallshire/oaknut/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: oaknut-exception>=10.0
+Requires-Dist: oaknut-extension>=10.0
+Dynamic: license-file
+
+# oaknut-econet-core
+
+The core abstractions for Econet networking in the `oaknut` package family.
+
+Econet was Acorn's networking technology for the BBC Micro, Master, and
+Archimedes, built around the Motorola MC68B54 ADLC. This package provides the
+foundation on which transports and applications are built:
+
+- **`EconetPacket`** and **`PacketKind`** — the logical-packet currency shared by
+  every transport (modelled on the AUN packet).
+- **`Address`** — `(network, station)` addressing, with the well-known values
+  (broadcast station, local network, immediate port).
+- **`TransmitResult`** / **`TransmitOutcome`** — the fine-grained delivery outcome
+  of a transmission (acknowledged, not-listening, no-clock, line-jammed, …).
+- **`EconetTransport`** — the abstract, `asyncio`-native interface a transport
+  implements, plus **`TransportCapability`** flags describing what a given
+  transport supports.
+- **`TestTransport`** — an in-process loopback transport for testing Econet
+  applications without hardware or a network.
+
+Concrete transports live in sibling packages (`oaknut-econet-aun`,
+`oaknut-econet-piconet`, `oaknut-econet-hat`) and plug in through the
+`oaknut.econet.transport` extension axis. Higher-level applications — a file
+server, a bridge — build on this interface.
+
+This package sits at the **logical-packet** level: the Econet four-way handshake
+is resolved below the transport boundary, so applications work in whole packets,
+not ADLC frames. See `docs/dev/econet-design.md` in the repository root for the
+full design.

oaknut_econet_core-13.6.0/README.md

@@ -0,0 +1,29 @@
+# oaknut-econet-core
+
+The core abstractions for Econet networking in the `oaknut` package family.
+
+Econet was Acorn's networking technology for the BBC Micro, Master, and
+Archimedes, built around the Motorola MC68B54 ADLC. This package provides the
+foundation on which transports and applications are built:
+
+- **`EconetPacket`** and **`PacketKind`** — the logical-packet currency shared by
+  every transport (modelled on the AUN packet).
+- **`Address`** — `(network, station)` addressing, with the well-known values
+  (broadcast station, local network, immediate port).
+- **`TransmitResult`** / **`TransmitOutcome`** — the fine-grained delivery outcome
+  of a transmission (acknowledged, not-listening, no-clock, line-jammed, …).
+- **`EconetTransport`** — the abstract, `asyncio`-native interface a transport
+  implements, plus **`TransportCapability`** flags describing what a given
+  transport supports.
+- **`TestTransport`** — an in-process loopback transport for testing Econet
+  applications without hardware or a network.
+
+Concrete transports live in sibling packages (`oaknut-econet-aun`,
+`oaknut-econet-piconet`, `oaknut-econet-hat`) and plug in through the
+`oaknut.econet.transport` extension axis. Higher-level applications — a file
+server, a bridge — build on this interface.
+
+This package sits at the **logical-packet** level: the Econet four-way handshake
+is resolved below the transport boundary, so applications work in whole packets,
+not ADLC frames. See `docs/dev/econet-design.md` in the repository root for the
+full design.

oaknut_econet_core-13.6.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oaknut-econet-core"
+dynamic = ["version"]
+authors = [{ name = "Robert Smallshire", email = "robert@smallshire.org.uk" }]
+description = "Core abstractions for Econet networking in the oaknut family: packet types, addressing, the EconetTransport interface, capabilities, and an in-process test transport."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Networking",
+]
+dependencies = [
+    "oaknut-exception>=10.0",
+    "oaknut-extension>=10.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/rob-smallshire/oaknut/tree/master/packages/oaknut-econet-core"
+Repository = "https://github.com/rob-smallshire/oaknut"
+Issues = "https://github.com/rob-smallshire/oaknut/issues"
+
+[dependency-groups]
+test = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+]
+dev = [
+    "bump-my-version>=0.28.0",
+    "pre-commit>=3.0",
+    {include-group = "test"},
+]
+
+[tool.setuptools.dynamic]
+version = { attr = "oaknut.econet.core.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

oaknut_econet_core-13.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

oaknut_econet_core-13.6.0/src/oaknut/econet/core/__init__.py

@@ -0,0 +1,62 @@
+"""Core abstractions for Econet networking in the oaknut family.
+
+This package is the foundation of the ``oaknut-econet-*`` family. It defines
+the logical-packet currency every transport speaks and the abstract interface
+every transport implements:
+
+- :class:`Address` — ``(network, station)`` addressing.
+- :class:`EconetPacket` / :class:`PacketKind` — the AUN-modelled logical packet.
+- :class:`TransmitResult` / :class:`TransmitOutcome` — delivery outcomes.
+- :class:`EconetTransport` — the ``asyncio``-native transport interface, with
+  :class:`TransportCapability` flags.
+- :class:`TestTransport` — an in-process loopback transport for hardware-free
+  testing.
+
+The abstraction sits at the *logical-packet* level: the Econet four-way
+handshake (scout / scout-ack / data / final-ack) is resolved below the
+transport boundary, so callers work in whole packets rather than ADLC frames.
+See ``docs/dev/econet-design.md`` for the design rationale.
+
+Concrete transports (AUN, Piconet, PiEconetHAT) live in sibling distributions
+and register on the ``oaknut.econet.transport`` extension axis.
+"""
+
+from __future__ import annotations
+
+from oaknut.econet.core.addressing import (
+    BROADCAST_ADDRESS,
+    BROADCAST_STATION,
+    IMMEDIATE_PORT,
+    LOCAL_NET,
+    Address,
+)
+from oaknut.econet.core.capability import TransportCapability
+from oaknut.econet.core.conformance import EconetTransportConformance
+from oaknut.econet.core.errors import EconetError, TransportConfigurationError
+from oaknut.econet.core.outcome import TransmitOutcome, TransmitResult
+from oaknut.econet.core.packet import EconetPacket, PacketKind
+from oaknut.econet.core.testing import TestTransport
+from oaknut.econet.core.transport import EconetTransport
+from oaknut.econet.core.wellknown import ImmediateOp, Port
+
+__version__ = "13.6.0"
+
+__all__ = [
+    "Address",
+    "BROADCAST_ADDRESS",
+    "BROADCAST_STATION",
+    "EconetError",
+    "EconetPacket",
+    "EconetTransport",
+    "EconetTransportConformance",
+    "IMMEDIATE_PORT",
+    "ImmediateOp",
+    "LOCAL_NET",
+    "PacketKind",
+    "Port",
+    "TestTransport",
+    "TransmitOutcome",
+    "TransmitResult",
+    "TransportCapability",
+    "TransportConfigurationError",
+]

oaknut_econet_core-13.6.0/src/oaknut/econet/core/addressing.py

@@ -0,0 +1,65 @@
+"""Econet addressing: the (network, station) pair and well-known values."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+#: Station number reserved for broadcasts (0xFF). A frame addressed to this
+#: station is delivered to every listening station on the segment.
+BROADCAST_STATION = 0xFF
+
+#: Network number meaning "this network" — the local Econet segment. A frame
+#: addressed with network 0 stays on the segment it was sent from.
+LOCAL_NET = 0x00
+
+#: The port carrying immediate operations (PEEK, POKE, JSR, MachinePeek, ...).
+#: Port 0 is not a normal data port; it is serviced by the receiver's NMI.
+IMMEDIATE_PORT = 0x00
+
+_BYTE_RANGE = range(0x00, 0x100)
+
+
+@dataclass(frozen=True, slots=True)
+class Address:
+    """An Econet station address: an 8-bit network and 8-bit station number.
+
+    Network ``0`` (:data:`LOCAL_NET`) means "this network". Station ``255``
+    (:data:`BROADCAST_STATION`) is the broadcast station.
+    """
+
+    network: int
+    station: int
+
+    def __post_init__(self) -> None:
+        if self.network not in _BYTE_RANGE:
+            raise ValueError(f"network must be 0..255, got {self.network!r}")
+        if self.station not in _BYTE_RANGE:
+            raise ValueError(f"station must be 0..255, got {self.station!r}")
+
+    @property
+    def is_broadcast(self) -> bool:
+        """True if this addresses the broadcast station."""
+        return self.station == BROADCAST_STATION
+
+    @property
+    def is_local_net(self) -> bool:
+        """True if the network is the local segment (network 0)."""
+        return self.network == LOCAL_NET
+
+    @classmethod
+    def parse(cls, text: str) -> Address:
+        """Parse a ``"net.station"`` string (e.g. ``"0.254"``), the inverse of str()."""
+        network, separator, station = text.partition(".")
+        if separator != "." or not network or not station:
+            raise ValueError(f"address must be 'net.station', got {text!r}")
+        try:
+            return cls(int(network), int(station))
+        except ValueError as exc:
+            raise ValueError(f"invalid address {text!r}: {exc}") from exc
+
+    def __str__(self) -> str:
+        return f"{self.network}.{self.station}"
+
+
+#: The full broadcast address, 255.255.
+BROADCAST_ADDRESS = Address(network=0xFF, station=BROADCAST_STATION)

oaknut_econet_core-13.6.0/src/oaknut/econet/core/capability.py

@@ -0,0 +1,25 @@
+"""Capability flags describing what a transport supports."""
+
+from __future__ import annotations
+
+from enum import Enum, auto
+
+
+class TransportCapability(Enum):
+    """A feature a transport may or may not provide.
+
+    Applications branch on capabilities rather than on transport identity
+    (never ``isinstance(transport, AunTransport)``). A transport exposes the
+    set it supports via :attr:`EconetTransport.capabilities`.
+    """
+
+    #: Promiscuous receive of all traffic on the segment, not just our station.
+    MONITOR = auto()
+    #: Can send host-generated replies to inbound immediate operations.
+    IMMEDIATE_REPLY = auto()
+    #: Can originate broadcasts.
+    BROADCAST = auto()
+    #: Honours network numbers beyond the local net.
+    MULTI_NET = auto()
+    #: Participates in mDNS advertise/discover.
+    DISCOVERY = auto()

oaknut_econet_core-13.6.0/src/oaknut/econet/core/conformance.py

@@ -0,0 +1,94 @@
+"""A reusable conformance suite for EconetTransport implementations.
+
+Subclass :class:`EconetTransportConformance` in a transport package's test
+suite, implement :meth:`make_transport`, and pytest will run the inherited
+contract checks against your transport. The checks assert the *shape* of the
+contract — types and lifecycle — not transport-specific outcomes, so they hold
+for any transport (the in-process :class:`TestTransport`, AUN, Piconet, the
+HAT).
+
+This module deliberately imports no test framework, so it is safe to import
+anywhere; the concrete subclass lives in a test module that pytest collects.
+"""
+
+from __future__ import annotations
+
+from oaknut.econet.core.addressing import Address
+from oaknut.econet.core.capability import TransportCapability
+from oaknut.econet.core.outcome import TransmitOutcome, TransmitResult
+from oaknut.econet.core.packet import EconetPacket, PacketKind
+from oaknut.econet.core.transport import EconetTransport
+
+
+class EconetTransportConformance:
+    """The contract every :class:`EconetTransport` implementation must satisfy.
+
+    Concrete subclasses implement :meth:`make_transport` to return a fresh,
+    unopened transport set up so that a unicast transmit resolves promptly. For
+    the loopback :class:`TestTransport` that is automatic; a real transport's
+    test subclass wires it to a controllable peer.
+    """
+
+    def make_transport(self) -> EconetTransport:
+        """Return a fresh, unopened transport to exercise. Override this."""
+        raise NotImplementedError
+
+    @staticmethod
+    def _unicast() -> EconetPacket:
+        return EconetPacket(
+            PacketKind.UNICAST,
+            Address(0, 254),
+            Address(0, 1),
+            control=0x80,
+            port=0x99,
+            payload=b"conformance",
+        )
+
+    def test_kind_is_econet_transport(self):
+        assert type(self.make_transport()).kind() == "econet.transport"
+
+    def test_capabilities_is_a_frozenset_of_capabilities(self):
+        capabilities = self.make_transport().capabilities
+        assert isinstance(capabilities, frozenset)
+        assert all(isinstance(capability, TransportCapability) for capability in capabilities)
+
+    def test_local_station_is_address_or_none(self):
+        local_station = self.make_transport().local_station
+        assert local_station is None or isinstance(local_station, Address)
+
+    async def test_context_manager_yields_self(self):
+        transport = self.make_transport()
+        async with transport as entered:
+            assert entered is transport
+
+    async def test_transmit_returns_a_transmit_result(self):
+        async with self.make_transport() as transport:
+            result = await transport.transmit(self._unicast())
+            assert isinstance(result, TransmitResult)
+            assert isinstance(result.outcome, TransmitOutcome)
+
+    async def test_immediate_returns_a_transmit_result(self):
+        async with self.make_transport() as transport:
+            immediate = EconetPacket(
+                PacketKind.IMMEDIATE,
+                Address(0, 254),
+                Address(0, 1),
+                control=0x88,
+                port=0x00,
+            )
+            result = await transport.immediate(immediate)
+            assert isinstance(result, TransmitResult)
+            assert isinstance(result.outcome, TransmitOutcome)
+
+    async def test_broadcast_when_supported_does_not_raise(self):
+        async with self.make_transport() as transport:
+            if TransportCapability.BROADCAST not in transport.capabilities:
+                return
+            assert await transport.broadcast(b"\x00", port=0x9C, control=0x82) is None
+
+    async def test_inbound_iteration_stops_after_close(self):
+        transport = self.make_transport()
+        async with transport:
+            pass
+        received = [packet async for packet in transport]
+        assert received == []

oaknut_econet_core-13.6.0/src/oaknut/econet/core/errors.py

@@ -0,0 +1,22 @@
+"""The oaknut-econet error hierarchy, slotted into oaknut.exception."""
+
+from __future__ import annotations
+
+from oaknut.exception import ConfigurationError, DataError
+
+
+class EconetError(DataError):
+    """Base for Econet wire/protocol data faults.
+
+    A malformed AUN datagram, an unparseable serial frame, or any other bad
+    data arriving from the network is a :class:`~oaknut.exception.DataError`.
+    """
+
+
+class TransportConfigurationError(ConfigurationError):
+    """A transport could not be configured or opened.
+
+    An unknown transport name, a missing or unopenable device, or an invalid
+    station number is an environment/setup problem rather than bad input or a
+    library bug — hence a :class:`~oaknut.exception.ConfigurationError`.
+    """

oaknut_econet_core-13.6.0/src/oaknut/econet/core/outcome.py

@@ -0,0 +1,42 @@
+"""The outcome of attempting to transmit an Econet packet."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+
+from oaknut.econet.core.packet import EconetPacket
+
+
+class TransmitOutcome(Enum):
+    """How a transmission resolved.
+
+    The union of the failure modes the transports actually report — AUN
+    ack/nack/timeout, Piconet ``TX_RESULT`` codes, and PiEconetHAT TX status —
+    normalised into one set so applications need not know the transport.
+    """
+
+    ACKNOWLEDGED = auto()
+    NOT_LISTENING = auto()
+    NO_CLOCK = auto()
+    LINE_JAMMED = auto()
+    TIMEOUT = auto()
+    HANDSHAKE_FAILED = auto()
+    NETWORK_ERROR = auto()
+
+
+@dataclass(frozen=True, slots=True)
+class TransmitResult:
+    """The result of a transmit or immediate operation.
+
+    ``reply`` carries the inline reply for an immediate operation that returns
+    one; it is ``None`` otherwise.
+    """
+
+    outcome: TransmitOutcome
+    reply: EconetPacket | None = None
+
+    @property
+    def acknowledged(self) -> bool:
+        """True if the transmission was acknowledged by the destination."""
+        return self.outcome is TransmitOutcome.ACKNOWLEDGED

oaknut_econet_core-13.6.0/src/oaknut/econet/core/packet.py

@@ -0,0 +1,51 @@
+"""The Econet logical packet — the currency every transport speaks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+
+from oaknut.econet.core.addressing import Address
+
+_BYTE_RANGE = range(0x00, 0x100)
+
+
+class PacketKind(Enum):
+    """The kind of an Econet packet at the logical (post-handshake) level.
+
+    ``ACK``/``NACK`` are deliberately absent: inbound packets are already
+    acknowledged below the transport boundary, so acknowledgement is a
+    transmit *outcome*, not a packet a caller receives.
+    """
+
+    BROADCAST = auto()
+    UNICAST = auto()
+    IMMEDIATE = auto()
+    IMMEDIATE_REPLY = auto()
+
+
+@dataclass(frozen=True, slots=True)
+class EconetPacket:
+    """A logical Econet packet: a completed transaction's worth of data.
+
+    Modelled on the AUN packet. The four-way handshake (scout / scout-ack /
+    data / final-ack) is resolved below the transport boundary, so this is the
+    unit applications send and receive.
+
+    ``seq`` is the transport-managed sequence/handle used for AUN reply
+    correlation; it is normally ``None`` at the application layer.
+    """
+
+    kind: PacketKind
+    dst: Address
+    src: Address
+    control: int
+    port: int
+    payload: bytes = b""
+    seq: int | None = None
+
+    def __post_init__(self) -> None:
+        if self.control not in _BYTE_RANGE:
+            raise ValueError(f"control must be 0..255, got {self.control!r}")
+        if self.port not in _BYTE_RANGE:
+            raise ValueError(f"port must be 0..255, got {self.port!r}")

oaknut_econet_core-13.6.0/src/oaknut/econet/core/testing.py

@@ -0,0 +1,155 @@
+"""An in-process loopback EconetTransport for hardware-free testing."""
+
+from __future__ import annotations
+
+import asyncio
+from collections import deque
+from collections.abc import AsyncIterator
+
+from oaknut.econet.core.addressing import BROADCAST_ADDRESS, Address
+from oaknut.econet.core.capability import TransportCapability
+from oaknut.econet.core.outcome import TransmitOutcome, TransmitResult
+from oaknut.econet.core.packet import EconetPacket, PacketKind
+from oaknut.econet.core.transport import EconetTransport
+
+_DEFAULT_CAPABILITIES = frozenset(
+    {TransportCapability.BROADCAST, TransportCapability.IMMEDIATE_REPLY}
+)
+
+
+class _Closed:
+    """Sentinel queued by close() to terminate inbound iteration."""
+
+
+_CLOSED = _Closed()
+
+
+class TestTransport(EconetTransport):
+    """An in-process EconetTransport for testing applications without hardware.
+
+    Two ways to use it:
+
+    - *Standalone*: script transmit/immediate outcomes with
+      :meth:`script_results` / :meth:`script_immediate_replies`, inject inbound
+      packets with :meth:`feed`, and inspect :attr:`transmitted`,
+      :attr:`broadcasts`, and :attr:`immediates`.
+    - *Paired*: :meth:`link` two transports so each one's transmits and
+      broadcasts arrive as inbound packets on the other — a toy client and
+      server talking entirely in memory.
+    """
+
+    # Despite the "Test" prefix this is a helper, not a pytest test case.
+    __test__ = False
+
+    def __init__(
+        self,
+        name: str = "test",
+        *,
+        local_station: Address | None = None,
+        capabilities: frozenset[TransportCapability] | None = None,
+        default_outcome: TransmitOutcome = TransmitOutcome.ACKNOWLEDGED,
+    ) -> None:
+        super().__init__(name=name)
+        self._local_station = local_station
+        self._capabilities = (
+            _DEFAULT_CAPABILITIES if capabilities is None else frozenset(capabilities)
+        )
+        self._default_outcome = default_outcome
+        self._inbound: asyncio.Queue = asyncio.Queue()
+        self._peer: TestTransport | None = None
+        self._opened = False
+        self._closed = False
+        self._scripted_results: deque[TransmitResult] = deque()
+        self._scripted_immediate_replies: deque[TransmitResult] = deque()
+        self.transmitted: list[EconetPacket] = []
+        self.broadcasts: list[EconetPacket] = []
+        self.immediates: list[EconetPacket] = []
+
+    # -- introspection -------------------------------------------------
+
+    @property
+    def capabilities(self) -> frozenset[TransportCapability]:
+        return self._capabilities
+
+    @property
+    def local_station(self) -> Address | None:
+        return self._local_station
+
+    @property
+    def is_open(self) -> bool:
+        return self._opened and not self._closed
+
+    @property
+    def is_closed(self) -> bool:
+        return self._closed
+
+    # -- lifecycle -----------------------------------------------------
+
+    async def open(self) -> None:
+        self._opened = True
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._inbound.put_nowait(_CLOSED)
+
+    # -- outbound ------------------------------------------------------
+
+    async def transmit(self, packet: EconetPacket) -> TransmitResult:
+        self.transmitted.append(packet)
+        if self._peer is not None:
+            self._peer.feed(packet)
+        if self._scripted_results:
+            return self._scripted_results.popleft()
+        return TransmitResult(self._default_outcome)
+
+    async def broadcast(self, payload: bytes, *, port: int, control: int) -> None:
+        source = self._local_station or Address(0, 0)
+        packet = EconetPacket(
+            PacketKind.BROADCAST,
+            BROADCAST_ADDRESS,
+            source,
+            control=control,
+            port=port,
+            payload=payload,
+        )
+        self.broadcasts.append(packet)
+        if self._peer is not None:
+            self._peer.feed(packet)
+
+    async def immediate(self, packet: EconetPacket) -> TransmitResult:
+        self.immediates.append(packet)
+        if self._scripted_immediate_replies:
+            return self._scripted_immediate_replies.popleft()
+        return TransmitResult(self._default_outcome)
+
+    # -- inbound -------------------------------------------------------
+
+    def __aiter__(self) -> AsyncIterator[EconetPacket]:
+        return self
+
+    async def __anext__(self) -> EconetPacket:
+        item = await self._inbound.get()
+        if item is _CLOSED:
+            raise StopAsyncIteration
+        return item
+
+    # -- test helpers --------------------------------------------------
+
+    def feed(self, packet: EconetPacket) -> None:
+        """Inject *packet* as an inbound packet for iteration."""
+        self._inbound.put_nowait(packet)
+
+    def script_results(self, *results: TransmitResult) -> None:
+        """Queue the results :meth:`transmit` will return, in order."""
+        self._scripted_results.extend(results)
+
+    def script_immediate_replies(self, *results: TransmitResult) -> None:
+        """Queue the results :meth:`immediate` will return, in order."""
+        self._scripted_immediate_replies.extend(results)
+
+    def link(self, other: TestTransport) -> None:
+        """Cross-wire two transports so each delivers to the other's inbound."""
+        self._peer = other
+        other._peer = self