rosotacom-dev 2.5.dev29__tar.gz → 2.5.dev33__tar.gz

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev29
+Version: 2.5.dev33
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/session-configuration.md

@@ -477,15 +477,31 @@ Given a base topic like `/tf`, stages are applied in this order:
 
 1) base topic (e.g. `/tf`)
 2) restamp → `+ shared.processing_suffixes.restamped` (default `/restamped`)
-3) drop → `+ /drop{drop_count}of{window_size}` (e.g. `/drop2of3`)
-4) throttle → `+ /max{hz}hz`
-5) pixel cap → `+ /{preset}`
-6) framebridge:
+3) latch → `+ shared.processing_suffixes.latched` (default `/latched`)
+4) drop → `+ /drop{drop_count}of{window_size}` (e.g. `/drop2of3`)
+5) throttle → `+ /max{hz}hz`
+6) pixel cap → `+ /{preset}`
+7) framebridge:
    - `local_to_global`: appended to the current topic state via `+ /globalframe`
    - `global_to_local`: appended to the base topic via `+ /globalframe` (configured inbound-side)
-7) compress → `+ /<algorithm>` (default `/bz2`)
-8) transport → `+ /<type>` (e.g. `/ffmpeg`, `/foxglove`, `/compressed`)
-9) optional `local_republish: true` triggers reverse-transport configuration.
+8) compress → `+ /<algorithm>` (default `/bz2`)
+9) transport → `+ /<type>` (e.g. `/ffmpeg`, `/foxglove`, `/compressed`)
+10) OTA wrapper → `+ /ota_stamped`
+
+The wrapper is **always last**. Its `seq` and send stamp are read as a statement
+about the traffic on the link, so it has to wrap exactly what crosses it — an
+encoded stream is wrapped as `<base>/<type>/ota_stamped`, not the other way
+round. Nothing may append a suffix after it, or the delivered topic would be
+renamed under a receiver that subscribes by a fixed name.
+
+The receiver undoes the chain in reverse, and every stage there is computed from
+the delivered topic rather than from the OTA topic:
+
+1) unwrap → republishes on the pre-wrap name (so wrapping renames nothing)
+2) `local_republish: true` → reverse transport decodes into `+ /raw`
+3) decompress → republishes on the pre-compress name
+4) framebridge `global_to_local` → the local base topic
+5) trickle → `+ /trickle`, the only receiver-side stage that adds a suffix
 
 #### Transport parameters
 `type: ffmpeg` supports:

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom/resources/examples/ros2docker.json

@@ -27,15 +27,23 @@
   // The base is ros-base, not desktop-full: 299 MB compressed against 1422 MB,
   // and nothing here runs a GUI (enable_gui_forwarding is false above). The
   // e2e suite was run against both to find out what desktop-full had been
-  // providing without anyone declaring it — one package, ros-kilted-gps-msgs,
-  // which the anonymized remote-assist session needs for gps_msgs/msg/GPSFix.
-  // It is declared below. Add rviz2 or a simulator here if you want them; that
-  // is a project's decision, not a default.
+  // providing without anyone declaring it. It named ros-kilted-gps-msgs, for
+  // the gps_msgs/msg/GPSFix the anonymized remote-assist session publishes.
+  //
+  // It could not name ros-kilted-compressed-image-transport, and that one is
+  // why this list is not just an inventory: no e2e session has a /compressed
+  // input topic, so the suite never loaded compressed_sub. A vehicle camera
+  // does, on both ends of the link — the sender republishes compressed to
+  // ffmpeg, the receiver decodes back to the CompressedImage twin. Declaring
+  // ros-kilted-image-transport alone gets you raw and nothing else.
+  //
+  // Add rviz2 or a simulator here if you want them; that is a project's
+  // decision, not a default.
   "build_args": {
     "BASE_IMAGE": "ros:kilted-ros-base-noble",
     "DIGEST": "@sha256:4ca53d5b084bdbe92a7a7d7186f56db6a716a6c7c33ad401ddb0ec82d6e9e479",
     "INSTALL_ZENOH":                 "1",
-    "APT_PACKAGES":                  "iputils-ping psmisc net-tools snmp iw nload iftop iproute2 tshark ros-kilted-domain-bridge ros-kilted-rmw-cyclonedds-cpp ros-kilted-rmw-zenoh-cpp ros-kilted-topic-tools ros-kilted-image-transport ros-kilted-ffmpeg-image-transport ros-kilted-ffmpeg-image-transport-msgs ros-kilted-gps-msgs",
+    "APT_PACKAGES":                  "iputils-ping psmisc net-tools snmp iw nload iftop iproute2 tshark ros-kilted-domain-bridge ros-kilted-rmw-cyclonedds-cpp ros-kilted-rmw-zenoh-cpp ros-kilted-topic-tools ros-kilted-image-transport ros-kilted-compressed-image-transport ros-kilted-ffmpeg-image-transport ros-kilted-ffmpeg-image-transport-msgs ros-kilted-gps-msgs",
     "PIP_PACKAGES":                  "numpy>=1.26,<2 lz4 pysnmp speedtest-cli psutil zstandard opencv-python"
   }
 }

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom/resources/examples/sessions/17_synthetic_camera_quality/session-definition.yaml

@@ -52,6 +52,17 @@ topics:
           local_republish: true
           gop_size: 4
           bit_rate: 2000000
+        # Wrapping an encoded stream: the wrapper runs after the encoder, so the
+        # envelope carries the FFMPEGPacket that actually crosses the link, and
+        # the unwrapper republishes onto `/camera/image/ffmpeg` -- the name the
+        # reverse republish already decodes from. Nothing downstream is renamed,
+        # which is what this example proves end to end.
+        use_ota_wrapper: true
       expect:
         hz: { min: 3, max: 8 }
         latency_ms: { max: 1000 }
+        # The bound is the same 30% the video-quality check tolerates on this
+        # synthetic link; the assertion's purpose is that the number exists at
+        # all. Without the wrapper an encoded stream has no per-message
+        # accounting, and `loss_pct` on a topic that cannot report it fails.
+        loss_pct: { max: 30 }

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom/resources/ros2docker.json.example

@@ -27,15 +27,23 @@
   // The base is ros-base, not desktop-full: 299 MB compressed against 1422 MB,
   // and nothing here runs a GUI (enable_gui_forwarding is false above). The
   // e2e suite was run against both to find out what desktop-full had been
-  // providing without anyone declaring it — one package, ros-kilted-gps-msgs,
-  // which the anonymized remote-assist session needs for gps_msgs/msg/GPSFix.
-  // It is declared below. Add rviz2 or a simulator here if you want them; that
-  // is a project's decision, not a default.
+  // providing without anyone declaring it. It named ros-kilted-gps-msgs, for
+  // the gps_msgs/msg/GPSFix the anonymized remote-assist session publishes.
+  //
+  // It could not name ros-kilted-compressed-image-transport, and that one is
+  // why this list is not just an inventory: no e2e session has a /compressed
+  // input topic, so the suite never loaded compressed_sub. A vehicle camera
+  // does, on both ends of the link — the sender republishes compressed to
+  // ffmpeg, the receiver decodes back to the CompressedImage twin. Declaring
+  // ros-kilted-image-transport alone gets you raw and nothing else.
+  //
+  // Add rviz2 or a simulator here if you want them; that is a project's
+  // decision, not a default.
   "build_args": {
     "BASE_IMAGE":                    "ros:kilted-ros-base-noble",
     "DIGEST":                        "@sha256:4ca53d5b084bdbe92a7a7d7186f56db6a716a6c7c33ad401ddb0ec82d6e9e479",
     "INSTALL_ZENOH":                 "1",
-    "APT_PACKAGES":                  "iputils-ping psmisc net-tools snmp iw nload iftop iproute2 tshark ros-kilted-domain-bridge ros-kilted-rmw-cyclonedds-cpp ros-kilted-rmw-zenoh-cpp ros-kilted-topic-tools ros-kilted-image-transport ros-kilted-ffmpeg-image-transport ros-kilted-ffmpeg-image-transport-msgs ros-kilted-gps-msgs",
+    "APT_PACKAGES":                  "iputils-ping psmisc net-tools snmp iw nload iftop iproute2 tshark ros-kilted-domain-bridge ros-kilted-rmw-cyclonedds-cpp ros-kilted-rmw-zenoh-cpp ros-kilted-topic-tools ros-kilted-image-transport ros-kilted-compressed-image-transport ros-kilted-ffmpeg-image-transport ros-kilted-ffmpeg-image-transport-msgs ros-kilted-gps-msgs",
     "PIP_PACKAGES":                  "numpy>=1.26,<2 lz4 pysnmp speedtest-cli psutil zstandard opencv-python"
   }
 }

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom/resources/ws/ros2src/com_py/com_py/status_overview.py

@@ -75,6 +75,7 @@ from com_py.status_overview_core import (
     StatusAggregator,
     collect_stage_metadata,
     collect_stage_topics,
+    stamp_delay,
 )
 
 ECHO_HEARTBEAT_TYPE = "com_msgs/msg/EchoHeartbeat"
@@ -274,12 +275,26 @@ class StageObserver(Node):
                 stamp = getattr(header, "stamp", None) if header is not None else None
                 if stamp is not None:
                     try:
-                        msg_time = rclpy.time.Time.from_msg(stamp)
-                        d = (now_ros - msg_time).nanoseconds / 1e9
-                        if -1.0 < d < 1000.0:  # guard unsynced clocks / zero stamps
-                            delay_s = d
+                        stamp_s = _stamp_seconds(stamp)
                     except Exception:
-                        delay_s = None
+                        stamp_s = None
+                    if stamp_s is not None:
+                        d = now_ros_s - stamp_s
+                        # An inbound stage carries a stamp written by the peer's
+                        # clock, so it is comparable to ours only once the offset
+                        # the heartbeat measures is applied -- exactly what the
+                        # OtaStamped branch above does with `t_wrap`. A local
+                        # stage was stamped by this machine and must stay raw.
+                        contexts = self._stage_metadata.get(topic, [])
+                        peer_stamped = any(
+                            context.get("direction") == "inbound" for context in contexts
+                        )
+                        estimate = self.clock_estimator.estimate() if peer_stamped else None
+                        if estimate is not None:
+                            clock_offset_s = estimate["offset_s"]
+                            rtt_s = estimate["rtt_s"]
+                            raw_delay_s = d
+                        delay_s = stamp_delay(d, clock_offset_s)
 
             obs.record(
                 size,

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom/resources/ws/ros2src/com_py/com_py/status_overview_core.py

@@ -148,6 +148,33 @@ class ClockOffsetEstimator:
             }
 
 
+#: Plausibility window (seconds) for a latency derived from a message header
+#: stamp. Outside it the number is not a latency but an unset stamp (epoch 0) or
+#: a clock difference no offset estimate explains.
+STAMP_DELAY_MIN_S = -1.0
+STAMP_DELAY_MAX_S = 1000.0
+
+
+def stamp_delay(raw_delay_s: float, clock_offset_s: Optional[float] = None) -> Optional[float]:
+    """Latency from a header stamp, corrected by the estimated peer clock offset.
+
+    ``raw_delay_s`` is ``local_now - stamp``. ``clock_offset_s`` is peer clock
+    minus local clock (as ``ClockOffsetEstimator`` reports it), so the corrected
+    delay is their sum -- the same arithmetic the OtaStamped path uses on its
+    ``t_wrap``.
+
+    Returns ``None`` when the result falls outside the plausibility window. The
+    guard is applied to the corrected value on purpose: a topic whose stamp is
+    written by the peer used to be dropped for an offset this node has already
+    measured, which reads as "no latency available" instead of "latency, once
+    the clocks are reconciled".
+    """
+    corrected = raw_delay_s if clock_offset_s is None else raw_delay_s + clock_offset_s
+    if STAMP_DELAY_MIN_S < corrected < STAMP_DELAY_MAX_S:
+        return corrected
+    return None
+
+
 # --- Link overhead (session-level) -----------------------------------------
 
 def _payload_kbps(stage: Optional[Dict[str, Any]]) -> float:

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom/resources/ws/ros2src/com_py/com_py/universal_ota_wrapper.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+import array
 import re
 from threading import Lock
 
@@ -139,7 +140,12 @@ class UniversalOtaWrapperNode(Node):
                 out_msg.header.frame_id = header.frame_id
             out_msg.seq = self._next_sequence(source_topic)
             out_msg.msg_type = msg_type_str
-            out_msg.serialized_msg = list(serialized)
+            # array('B', ...) hits the generated setter's fast path and stores the
+            # buffer as-is. A list would allocate one Python int per payload byte,
+            # inside the interval that `header.stamp` above is meant to measure --
+            # and rule out wrapping anything large (a ~100 kB encoded video packet
+            # at 10 Hz is 1M allocations per second).
+            out_msg.serialized_msg = array.array('B', serialized)
 
             publisher.publish(out_msg)
         except Exception as exc:

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom/resources/ws/session/creation/generate_session_files.py

@@ -1255,11 +1255,15 @@ def _final_topic_type(entry: TopicEntry, pipe: Dict[str, Any]) -> str:
                 f"Unsupported transport type '{transport.type}' for topic '{entry.base}'. "
                 f"Known output type mappings: {sorted(TRANSPORT_OUTPUT_TYPES)}"
             )
-        return TRANSPORT_OUTPUT_TYPES[transport.type]
 
+    # Same order as the pipeline stages themselves: whatever is applied last
+    # decides the type of what crosses the link, and the wrapper is always last.
     if pipe.get("ota_wrap"):
         return OTA_STAMPED_MSG_TYPE
 
+    if transport is not None:
+        return TRANSPORT_OUTPUT_TYPES[transport.type]
+
     if pipe.get("compress"):
         return COMPRESSED_MSG_TYPE
 
@@ -1271,6 +1275,49 @@ def _final_topic_type(entry: TopicEntry, pipe: Dict[str, Any]) -> str:
     return msg_type
 
 
+def _delivered_topic(pipe: Dict[str, Any], final: str) -> str:
+    """The topic the receiver's post-processing chain ends on, before trickle.
+
+    The receiver undoes the sender's stages in reverse order, so this walks the
+    same chain backwards rather than picking one branch: unwrap, decode a
+    transport, decompress, framebridge down.
+    """
+    topic = final
+    if pipe.get("ota_wrap"):
+        # The unwrapper republishes on the pre-wrap name, which is why wrapping
+        # renames nothing downstream of it.
+        topic = str(pipe["ota_in"])
+    transport = pipe.get("transport")
+    if isinstance(transport, TransportSpec) and transport.local_republish:
+        # image_transport reverse republish decodes the encoded topic into
+        # `<encoded>/raw`; PSNR/SSIM and application-level checks need that
+        # decoded sensor_msgs/Image stage, not the encoded packet.
+        topic = str(pipe["irt_in"]) + "/raw"
+    elif pipe.get("compress"):
+        topic = str(pipe["comp_in"])
+    if pipe.get("framebridge") == "global_to_local":
+        # global_to_local runs on the receiver: the OTA `final` is the global
+        # (globalframe) topic, and the framebridge transforms it down to the
+        # local base topic -- that base is the post-framebridge native_in.
+        topic = str(pipe["fb_g2l_base"])
+    return topic
+
+
+def _postprocessed_topic(pipe: Dict[str, Any], final: str) -> str:
+    """The topic the receiving application actually reads."""
+    topic = _delivered_topic(pipe, final)
+    if pipe.get("trickle_hz") is not None:
+        # Receiver-side trickle re-publishes the delivered topic at a fixed rate
+        # to `<delivered>/trickle` (the trickle node's trickle_topic_suffix).
+        # That republished topic is the real delivered output, so it is the
+        # monitored native_in stage -- otherwise the trickle re-publish is an
+        # observability blind spot (its rate cannot be asserted). It republishes
+        # what the application would read, not the envelope: on a wrapped topic
+        # that is the unwrapped one.
+        topic = topic + "/trickle"
+    return topic
+
+
 def _heartbeat_monitor_overrides(heartbeat_expect: Optional[Dict[str, Any]]) -> List[Tuple[str, Any]]:
     """Override the heartbeat_echo status thresholds from a declared
     `shared.heartbeat.expect`. Only latency and loss map cleanly to the monitor's
@@ -1342,31 +1389,6 @@ def _build_status_pipeline_spec(
             return float(pipe["trickle_hz"])
         return None
 
-    def _postprocessed_topic(pipe: Dict[str, Any], final: str) -> str:
-        if pipe.get("trickle_hz") is not None:
-            # Receiver-side trickle re-publishes the delivered OTA `final` at a fixed
-            # rate to `<final>/trickle` (the trickle node's trickle_topic_suffix). That
-            # republished topic is the real delivered output, so it is the monitored
-            # native_in stage -- otherwise the trickle re-publish is an observability
-            # blind spot (its rate cannot be asserted).
-            return final + "/trickle"
-        if pipe.get("compress"):
-            return str(pipe["comp_in"])
-        if pipe.get("ota_wrap"):
-            return str(pipe["ota_in"])
-        if pipe.get("framebridge") == "global_to_local":
-            # global_to_local runs on the receiver: the OTA `final` is the global
-            # (globalframe) topic, and the framebridge transforms it down to the
-            # local base topic -- that base is the post-framebridge native_in.
-            return str(pipe["fb_g2l_base"])
-        transport = pipe.get("transport")
-        if isinstance(transport, TransportSpec) and transport.local_republish:
-            # image_transport reverse republish decodes `<final>` into
-            # `<final>/raw`; PSNR/SSIM and application-level checks need that
-            # decoded sensor_msgs/Image stage, not the encoded packet.
-            return final + "/raw"
-        return final
-
     def _relay_in_local_topic(topic: str) -> str:
         if inbound_keep_source_prefix:
             return f"/{remote_name}{topic}"
@@ -1714,11 +1736,6 @@ def _compute_pipeline(
         comp_in = topic
         topic = topic + comp_alg_suffix
 
-    ota_in = None
-    if ota_wrap:
-        ota_in = topic
-        topic = topic + ota_suffix
-
     it_in = None
     irt_in = None
     if transport:
@@ -1727,6 +1744,15 @@ def _compute_pipeline(
         if transport.local_republish:
             irt_in = topic
 
+    # The wrapper is last, always. Its `seq` and send stamp describe whatever it
+    # wraps, so anything applied after it would be measured by an envelope that
+    # never carried it -- and would append its own suffix to the wrapped name,
+    # renaming the delivered topic under a receiver that subscribes by name.
+    ota_in = None
+    if ota_wrap:
+        ota_in = topic
+        topic = topic + ota_suffix
+
     return {
         "final": topic,
         "restamp": restamp,
@@ -2546,8 +2572,16 @@ def func(
         # Trickle: local-only periodic republisher (receiver side only).
         # Subscribes to inbound final topics (with source-name prefix when applicable)
         # and republishes at a fixed rate for visualization software.
+        # Trickle runs at the very end of the receiver chain, so it republishes
+        # what the local post-processing produced -- not the OTA `final`, which
+        # on a wrapped topic is still the envelope. `_delivered_topic` is the
+        # same computation the status pipeline spec uses for `native_in`, so the
+        # two cannot drift apart.
         trickle_in_items = [
-            (_prefix_with_source_name_if_needed(local, remote, p["final"]), p["trickle_hz"])
+            (
+                _prefix_with_source_name_if_needed(local, remote, _delivered_topic(p, p["final"])),
+                p["trickle_hz"],
+            )
             for p in in_pipes
             if p["trickle_hz"] is not None
         ]
@@ -2599,7 +2633,10 @@ def func(
             if not p["normalize"]:
                 continue
             base = e.base.lstrip("/")
-            suffix_source = p["comp_in"] if p["comp_in"] else p["final"]
+            # Normalization is receiver-side too, so it works on the delivered
+            # topic rather than the OTA `final` (identical unless something is
+            # wrapped, where `final` is still the envelope).
+            suffix_source = _delivered_topic(p, p["final"])
             suffix = suffix_source[len(e.base) :]
             nor_items.append((base, suffix))
 

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev29
+Version: 2.5.dev33
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom_dev.egg-info/SOURCES.txt

@@ -331,11 +331,14 @@ tests/unit/test_link_bytes.py
 tests/unit/test_link_trace.py
 tests/unit/test_network_profiles.py
 tests/unit/test_network_shaper.py
+tests/unit/test_ota_wrapper.py
 tests/unit/test_ota_xml.py
 tests/unit/test_plots.py
+tests/unit/test_session_pipeline.py
 tests/unit/test_stage_latency.py
 tests/unit/test_status_eval.py
 tests/unit/test_status_overview.py
+tests/unit/test_status_overview_observer.py
 tests/unit/test_stream_stats.py
 tests/unit/test_trace_profiles.py
 tests/unit/test_transit.py

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom_dev.egg-info/scm_file_list.json

@@ -326,11 +326,14 @@
     "tests/unit/test_link_trace.py",
     "tests/unit/test_network_profiles.py",
     "tests/unit/test_network_shaper.py",
+    "tests/unit/test_ota_wrapper.py",
     "tests/unit/test_ota_xml.py",
     "tests/unit/test_plots.py",
+    "tests/unit/test_session_pipeline.py",
     "tests/unit/test_stage_latency.py",
     "tests/unit/test_status_eval.py",
     "tests/unit/test_status_overview.py",
+    "tests/unit/test_status_overview_observer.py",
     "tests/unit/test_stream_stats.py",
     "tests/unit/test_trace_profiles.py",
     "tests/unit/test_transit.py",

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/src/rosotacom_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "2.4",
-  "distance": 29,
-  "node": "g5cfc936161d0a8d247634ab00c5437cd6a9f7e99",
+  "distance": 33,
+  "node": "gb8c4f7d4c8e477a7b5fe93fde23f08f838aa1b46",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-13"

{rosotacom_dev-2.5.dev29 → rosotacom_dev-2.5.dev33}/tests/contract/test_packaged_resources.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import os
+import re
 import subprocess
 from importlib import resources
 from pathlib import Path
@@ -108,6 +109,61 @@ def test_default_ros2docker_config_pins_supported_kilted_noble_image() -> None:
         assert "ros-kilted-gps-msgs" in apt_packages
 
 
+# `image_transport republish` resolves a transport name to a pluginlib class at
+# runtime, so a transport nobody installed is not a build failure — it is a
+# container that starts fine and aborts on the first image message. `raw` ships
+# with image_transport itself; every other transport needs its own package.
+IMAGE_TRANSPORT_APT_PACKAGES = {
+    "raw": "ros-kilted-image-transport",
+    "compressed": "ros-kilted-compressed-image-transport",
+    "ffmpeg": "ros-kilted-ffmpeg-image-transport",
+}
+
+
+def _packaged_session_plugin() -> dict:
+    return yaml.safe_load(
+        (cli.WS_DIR / "session" / "content" / "base" / "session_plugin_base.yaml").read_text(encoding="utf-8")
+    )
+
+
+def test_every_image_transport_the_session_plugin_can_select_is_installed() -> None:
+    """The packaged image must carry every transport the packaged session can ask for.
+
+    This is the guard that was missing when the base image moved from
+    desktop-full to ros-base: compressed_image_transport had arrived with
+    desktop-full's perception variant, nothing in this repository declared it,
+    and no e2e session has a /compressed input topic — so the suite stayed green
+    while a vehicle camera link could no longer start. Deriving the transport set
+    from the plugin rather than restating it means a new transport, or a thinner
+    base image, fails here instead of on a vehicle.
+    """
+    plugin = _packaged_session_plugin()
+
+    # Incoming republish: the transport the receiving peer decodes back to.
+    selected = {
+        str(value)
+        for key, value in plugin["parameters"].items()
+        if key.startswith("irt_") and key.endswith("_out_transport") and value
+    }
+    # Outgoing republish: the in-transport is chosen from the source topic name.
+    it_window = next(window for window in plugin["windows"] if window["name"] == "IT")
+    for split in it_window["splits"]:
+        for command in split["commands"]:
+            selected.update(re.findall(r'it_in_transport="([a-z]+)"', command))
+
+    # Both branches of that choice, so a rewrite that drops one is visible here.
+    assert {"raw", "compressed"} <= selected
+
+    unknown = selected - set(IMAGE_TRANSPORT_APT_PACKAGES)
+    assert not unknown, f"no apt package recorded for image transport(s): {sorted(unknown)}"
+
+    required = {IMAGE_TRANSPORT_APT_PACKAGES[transport] for transport in selected}
+    for config_path in (cli.DEFAULT_ROS2DOCKER_CONFIG, cli.EXAMPLE_PROJECT_DIR / "ros2docker.json"):
+        apt_packages = set(str(cli.load_config(config_path)["build_args"]["APT_PACKAGES"]).split())
+        missing = required - apt_packages
+        assert not missing, f"{config_path.name} does not install {sorted(missing)}"
+
+
 def test_external_ros2docker_configs_install_selected_rmw_implementations() -> None:
     configs = sorted(cli.EXAMPLE_PROJECT_DIR.glob("scripts/**/external.ros2docker.json"))
     assert configs