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

{rosotacom_dev-2.5.dev27 → rosotacom_dev-2.5.dev33}/.github/workflows/nightly-e2e.yml

@@ -19,25 +19,43 @@ concurrency:
 
 jobs:
   smoke-e2e:
-    # The same six slices the merge gate and the release run, instead of one
+    # The same diagnostic slices the merge gate and the release run, instead of one
     # sequential `just test-e2e-smoke` over the whole suite (#198). Keeping the
     # monolith here was deliberate while the slices were hand-maintained `-k`
     # expressions that had silently stopped covering three files; #197's
     # test_e2e_slices_partition_the_whole_suite closed that, so the union is
     # now guaranteed to be the monolith.
     #
-    # The gain is diagnosis: a red monolith says "e2e broke", six slices say
-    # which area did. It also removes a load-induced flake. On 2026-08-11 the
+    # The gain is diagnosis: a red monolith says "e2e broke"; a named slice says
+    # which area and, where relevant, which transport or behavior failed. It
+    # also removes a load-induced flake. On 2026-08-11 the
     # nightly failed with nine "Timed out waiting for container readiness"
     # errors after 1h12m on one runner, while the same tests on the same commit
-    # passed in the merge gate — where they are spread over six.
+    # passed in the merge gate — where they were spread over six at the time.
     name: smoke-e2e-${{ matrix.slice }}
     runs-on: ubuntu-latest
     timeout-minutes: 90
     strategy:
       fail-fast: false
       matrix:
-        slice: [heartbeat, chatter, occupancy-grid, sized-payload, remote-assist, remote-assist-streams, runtime-tools, media, concurrency, benchmark-ab, benchmark-replay, benchmark-capacity, benchmark-capacity-cases]
+        slice:
+          - heartbeat
+          - chatter
+          - occupancy-grid-dds
+          - occupancy-grid-zenoh
+          - sized-payload-fastdds
+          - sized-payload-zenoh
+          - remote-assist
+          - remote-assist-costmap
+          - remote-assist-camera
+          - runtime-tools
+          - media
+          - concurrency-parallel
+          - concurrency-conflict
+          - benchmark-ab
+          - benchmark-replay
+          - benchmark-capacity
+          - benchmark-capacity-cases
 
     steps:
       - name: Check out repository

{rosotacom_dev-2.5.dev27 → rosotacom_dev-2.5.dev33}/.github/workflows/pr-merge-gate.yml

@@ -159,7 +159,7 @@ jobs:
   quick-gate:
     # Everything `e2e` waits for that is not the image, and deliberately no
     # more. It exists to answer one question — is the tree obviously broken,
-    # such that thirteen slices would burn seventy runner-minutes to say so.
+    # such that seventeen slices would burn roughly 73 runner-minutes to say so.
     #
     # It replaced a `needs: preflight-success` edge that made e2e wait for the
     # whole five-version matrix. That barrier cost 2.15 min of every gate run
@@ -199,12 +199,12 @@ jobs:
 
   image:
     # Publish the images the e2e suite builds, once per set of build inputs,
-    # instead of rebuilding them in each of thirteen jobs. #236 measured that
-    # build at 154s per job: 57s pulling the multi-GB ROS base from Docker Hub,
-    # 40s exporting layers, 47s of apt and pip. A pull from GHCR — co-located
-    # with the runners, no Hub rate limit, one transfer instead of a transfer
-    # plus a build — replaces all of it, and takes twelve of the thirteen Hub
-    # pulls off the merge gate's critical path.
+    # instead of rebuilding them in every job. #236 measured that build at
+    # 154s per job when the matrix had thirteen jobs: 57s pulling the multi-GB
+    # ROS base from Docker Hub, 40s exporting layers, 47s of apt and pip. A pull
+    # from GHCR — co-located with the runners, no Hub rate limit, one transfer
+    # instead of a transfer plus a build — replaces all of it. The benefit
+    # grows with the diagnostic matrix; seventeen jobs still build only once.
     #
     # The tag is a hash of everything that decides the image (base digest,
     # package lists, Dockerfile, entrypoint, ros2docker version, build UID):
@@ -295,12 +295,12 @@ jobs:
     # tests/contract/test_workflow_contracts.py keeps the three workflows and
     # the justfile agreeing.
     #
-    # The slices are chosen by measured cost, not grouped by theme (#226):
-    # themed slices spanned 7m39s to 18m31s, and one test ran in two of them.
-    # Thirteen rather than six because the model that predicted the balanced
-    # six within 25s also says twelve reaches the floor and more buys nothing
-    # (#235). Which tests a slice owns and what each costs is E2E_SLICES in
-    # tests/e2e/conftest.py — change that, not this line, to move a test.
+    # Slice names are diagnostic boundaries, not cost buckets. Costs tell us
+    # when a theme needs another runner; they never justify packing unrelated
+    # tests together. Seventeen is the smallest theme-preserving partition that
+    # reaches the measured floor: #253 split the four overloaded themes along
+    # transport, stream, or concurrency semantics. Which tests a slice owns and
+    # what each costs is E2E_SLICES in tests/e2e/conftest.py.
     name: e2e-${{ matrix.slice }}
     runs-on: ubuntu-latest
     timeout-minutes: 90
@@ -312,7 +312,24 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        slice: [heartbeat, chatter, occupancy-grid, sized-payload, remote-assist, remote-assist-streams, runtime-tools, media, concurrency, benchmark-ab, benchmark-replay, benchmark-capacity, benchmark-capacity-cases]
+        slice:
+          - heartbeat
+          - chatter
+          - occupancy-grid-dds
+          - occupancy-grid-zenoh
+          - sized-payload-fastdds
+          - sized-payload-zenoh
+          - remote-assist
+          - remote-assist-costmap
+          - remote-assist-camera
+          - runtime-tools
+          - media
+          - concurrency-parallel
+          - concurrency-conflict
+          - benchmark-ab
+          - benchmark-replay
+          - benchmark-capacity
+          - benchmark-capacity-cases
 
     steps:
       - name: Check out repository

{rosotacom_dev-2.5.dev27 → rosotacom_dev-2.5.dev33}/.github/workflows/release.yml

@@ -110,7 +110,7 @@ jobs:
           retention-days: 30
 
   e2e:
-    # The same five slices the merge gate runs, in parallel, instead of one
+    # The same diagnostic slices the merge gate runs, in parallel, instead of one
     # sequential `just test-e2e-smoke` over the whole suite. That target is
     # identical to nightly-e2e.yml's smoke-e2e job, so the release used to be
     # the third sequential run of the same tests against the same tree; it
@@ -121,7 +121,24 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        slice: [heartbeat, chatter, occupancy-grid, sized-payload, remote-assist, remote-assist-streams, runtime-tools, media, concurrency, benchmark-ab, benchmark-replay, benchmark-capacity, benchmark-capacity-cases]
+        slice:
+          - heartbeat
+          - chatter
+          - occupancy-grid-dds
+          - occupancy-grid-zenoh
+          - sized-payload-fastdds
+          - sized-payload-zenoh
+          - remote-assist
+          - remote-assist-costmap
+          - remote-assist-camera
+          - runtime-tools
+          - media
+          - concurrency-parallel
+          - concurrency-conflict
+          - benchmark-ab
+          - benchmark-replay
+          - benchmark-capacity
+          - benchmark-capacity-cases
 
     steps:
       - name: Check out repository

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

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

{rosotacom_dev-2.5.dev27 → rosotacom_dev-2.5.dev33}/docs/ci.md

@@ -43,23 +43,22 @@ check is:
 ci-success
 ```
 
-The merge gate runs workflow lint, dependency/security review, runtime/build asset lint, Python 3.10 through 3.14 non-Docker checks, package validation, and the Docker single-machine smoke matrix (one matrix job per slice, thirteen in parallel):
+The merge gate runs workflow lint, dependency/security review, runtime/build asset lint, Python 3.10 through 3.14 non-Docker checks, package validation, and the Docker single-machine smoke matrix (one matrix job per slice, seventeen in parallel):
 
 Python 3.10–3.14 are supported for the host CLI; Python 3.12 is the reference
 interpreter for packaging and Docker E2E jobs.
 
 ### What the e2e slices wait for
 
-Every job in the gate starts at once — there is no runner contention — so the
-only thing that decides when the thirteen slices start is their `needs`. They
+The only explicit barriers before the seventeen slices are their `needs`. They
 wait for exactly two jobs:
 
 - **`image`**, because a slice adopts the published image rather than building
   it, so it cannot start before that image is known to exist. On a hit this is
   two manifest inspections, and it is what sets the floor.
 - **`quick-gate`**, `just lint && just typecheck` on one interpreter: the
-  cheapest signal that the tree is not obviously broken, so thirteen runners do
-  not spend seventy minutes discovering a syntax error. Four seconds of work,
+  cheapest signal that the tree is not obviously broken, so seventeen runners
+  do not spend roughly 73 minutes discovering a syntax error. Four seconds of work,
   sized to finish inside `image` and therefore free.
 
 They used to wait for `preflight-success`, which meant the whole five-version
@@ -84,13 +83,17 @@ just package
 # Parallel E2E lanes, one per slice:
 just test-e2e-slice heartbeat
 just test-e2e-slice chatter
-just test-e2e-slice occupancy-grid
-just test-e2e-slice sized-payload
+just test-e2e-slice occupancy-grid-dds
+just test-e2e-slice occupancy-grid-zenoh
+just test-e2e-slice sized-payload-fastdds
+just test-e2e-slice sized-payload-zenoh
 just test-e2e-slice remote-assist
-just test-e2e-slice remote-assist-streams
+just test-e2e-slice remote-assist-costmap
+just test-e2e-slice remote-assist-camera
 just test-e2e-slice runtime-tools
 just test-e2e-slice media
-just test-e2e-slice concurrency
+just test-e2e-slice concurrency-parallel
+just test-e2e-slice concurrency-conflict
 just test-e2e-slice benchmark-ab
 just test-e2e-slice benchmark-replay
 just test-e2e-slice benchmark-capacity
@@ -102,7 +105,7 @@ Docker E2E is not collected for coverage.
 
 ## Docker E2E
 
-`just test-e2e-smoke` runs the entire local single-machine smoke matrix through Docker. In the CI merge gate, the same collection runs as thirteen parallel
+`just test-e2e-smoke` runs the entire local single-machine smoke matrix through Docker. In the CI merge gate, the same collection runs as seventeen parallel
 jobs, one per slice, named `e2e-<slice>`. Each smoke run writes generated
 config, catmux pane logs, Docker logs when available, and the smoke verification
 log under `session-instances/`; collect that directory as the first debugging
@@ -112,8 +115,9 @@ artifact when an E2E job fails.
 
 Every e2e job used to build the project image from scratch. #236 measured that
 at 154s per job — 57s pulling the multi-GB ROS base from Docker Hub, 40s
-exporting layers, 47s of apt and pip — which at thirteen slices is 33 minutes of
-runner time and thirteen Hub pulls on the critical path of every merge gate.
+exporting layers, 47s of apt and pip — which was 33 minutes of runner time and
+thirteen Hub pulls with the matrix at that time. The image is still published
+only once now that the diagnostic matrix has seventeen jobs.
 
 The `image` job now publishes those images to
 `ghcr.io/<owner>/rosotacom-e2e` and each slice pulls instead of building. GHCR
@@ -165,14 +169,13 @@ Content-addressed tags accumulate in the GHCR package — one per distinct set o
 build inputs, so roughly one per change to the base digest or package lists.
 Nothing prunes them yet.
 
-### Balancing the e2e slices
+### Diagnostic e2e slices
 
 A slice is not its own pytest invocation. `just test-e2e-slice <name>` runs the
 monolith's collection with `--e2e-slice=<name>`, and everything the named slice
 does not own is deselected. Which tests a slice owns, and what each one costs,
 is `E2E_SLICES` in `tests/e2e/conftest.py`; `just e2e-slice-costs` prints the
-resulting balance. Moving a test between slices is one line there — the
-workflow matrices only name slices.
+resulting costs. The workflow matrices only name slices.
 
 That shape exists because the previous one, per-slice file lists and `-k`
 filters, could not say what it ran. `-k "remote_assist"` silently missed the
@@ -182,11 +185,17 @@ twice a run. A partition can do neither: an unowned test fails every slice job
 with a usage error, and a test owned twice fails
 `test_e2e_slices_partition_the_whole_suite`.
 
+The slice name is an advisor: it states the subsystem and, where that is the
+useful first distinction, the transport, stream, or behavior that failed.
+Costs decide when one such theme needs another runner. They do not justify
+moving a test behind an unrelated name just because its duration fits there.
+
 The costs are warm pytest `call` durations — medians over seven merge-gate runs
 of 2026-08-11/12. On top of them each job pays a fixed
 `RUNNER_SETUP_SECONDS + IMAGE_BUILD_SECONDS` (1m19s: 46s outside the tests, then
 the project image obtained inside whichever test runs first). Because that
-constant is per job and not per test, balancing warm costs balances wall clock.
+constant is per job and not per test, the cost model predicts wall clock and
+shows when a diagnostic group has become too large.
 
 `IMAGE_BUILD_SECONDS` models the merge gate, where that image is pulled rather
 than built (see above); the release and nightly lanes still build and pay the
@@ -206,26 +215,25 @@ cost like every other. It is currently **5m47s**, of which 33s is the image
 (7m56s before #236 published it instead of rebuilding it per job, 6m32s before
 #245 shrank it).
 
-Thirteen slices sit at 6m26s, **1.12x** the floor. That is the point of choosing
-N from the numbers rather than from taste: six balanced slices were 13m37s,
-twelve reach the floor, and past twelve every extra job is pure cost. Note that
-1.12x is now a partition problem rather than a count problem — thirteen slices
-*can* reach 1.00x, and the current assignment does not, because `occupancy-grid`
-holds two 150s tests. The fixed cost falling twice is what exposed it: the same
-partition was 1.11x of a floor that was a minute and a half higher. The
-contract test asserts distance to the floor rather than the spread between
-slices — spread is compressed toward 1.0 by the fixed cost as N grows, so it
-keeps reading fine while the gate stops improving.
-
-Runner minutes are not the constraint here (this repository is public, so
-standard GitHub-hosted runners are free); the concurrent-job cap is, and
-thirteen stays under it.
+Thirteen diagnostic slices sat at 6m26s, **1.12x** the floor. Four groups were
+over the 267s warm target: occupancy grid, sized payload, the two remote-assist
+single-stream cuts, and the two concurrency guarantees. Each has a real seam —
+transport, stream, or behavior — so each became two explicitly named jobs.
+
+The resulting seventeen slices reach **1.00x**, without cross-theme packing.
+Seventeen is also the smallest theme-preserving count that can do so: each of
+the four overloaded groups needs at least one additional runner. Splitting
+every test into its own job would add runner cost without improving the critical
+path; keeping thirteen would save runner setup but leave 42s on every gate run.
+This is the balance: use the fewest runners that preserve diagnostic ownership
+and reach the floor, rather than optimizing either runner count or time alone.
 
 To refresh the numbers, read a merge-gate run: every e2e invocation runs
 `--durations=0`, so each job prints the cost of every test it ran. A test that
 ran first in its job carries the image build and needs `IMAGE_BUILD_SECONDS`
 subtracted. `tests/contract/test_workflow_contracts.py::test_e2e_slices_stay_close_to_the_floor`
-fails when the slowest slice passes 1.25x the floor.
+fails as soon as a grouped slice becomes slower than the floor. Split that
+slice on a diagnostic boundary; do not fill spare time with unrelated tests.
 
 ## Performance Regression Gate
 

{rosotacom_dev-2.5.dev27 → rosotacom_dev-2.5.dev33}/docs/testing.md

@@ -127,24 +127,29 @@ from one-host smoke.
 
 - `just test-e2e-slice heartbeat`: the heartbeat matrix (and the opt-in RMW matrix).
 - `just test-e2e-slice chatter`: the native chatter scenario, smoke, and debug rig.
-- `just test-e2e-slice occupancy-grid`: compressed occupancy grid over both transports.
-- `just test-e2e-slice sized-payload`: sized payload over both transports.
+- `just test-e2e-slice occupancy-grid-dds`: compressed occupancy grid over direct DDS.
+- `just test-e2e-slice occupancy-grid-zenoh`: compressed occupancy grid over Zenoh.
+- `just test-e2e-slice sized-payload-fastdds`: sized payload over Fast DDS.
+- `just test-e2e-slice sized-payload-zenoh`: sized payload over Zenoh.
 - `just test-e2e-slice remote-assist`: the full anonymized remote-assist rig.
-- `just test-e2e-slice remote-assist-streams`: its costmap and camera single-stream cuts.
+- `just test-e2e-slice remote-assist-costmap`: its costmap single-stream cut.
+- `just test-e2e-slice remote-assist-camera`: its camera single-stream cut.
 - `just test-e2e-slice runtime-tools`: link latency and live timeline stepping.
 - `just test-e2e-slice media`: anonymization and video quality.
-- `just test-e2e-slice concurrency`: the concurrency/isolation gate.
+- `just test-e2e-slice concurrency-parallel`: independent smoke runs coexist.
+- `just test-e2e-slice concurrency-conflict`: a conflicting smoke run is rejected safely.
 - `just test-e2e-slice benchmark-ab`: the A/B reliability verdict.
 - `just test-e2e-slice benchmark-replay`: loss boundaries against costmap replay.
 - `just test-e2e-slice benchmark-capacity`: the band-asserted capacity rows.
 - `just test-e2e-slice benchmark-capacity-cases`: the capacity good/bad-case verdicts.
 - `just test-e2e-node <nodeid>`: Reruns a specific pytest node ID directly.
-- `just e2e-slice-costs`: prints what each slice costs and how balanced the six are.
+- `just e2e-slice-costs`: prints what each slice costs and its distance to the floor.
 
-The slices are chosen by measured cost, and split where the tests already
-differ so a red job names an area. `E2E_SLICES` in `tests/e2e/conftest.py`
-decides which slice owns which test; see
-[ci.md](ci.md#balancing-the-e2e-slices) before moving one.
+The slices are grouped by diagnostic theme and split where transport, stream,
+or behavior gives a useful first failure distinction. Measured cost decides
+when a theme needs another runner, not which unrelated tests should share one.
+`E2E_SLICES` in `tests/e2e/conftest.py` decides which slice owns which test;
+see [ci.md](ci.md#diagnostic-e2e-slices) before changing one.
 
 The generated RMW matrix is available as an opt-in full local slice:
 

{rosotacom_dev-2.5.dev27 → rosotacom_dev-2.5.dev33}/justfile

@@ -46,7 +46,7 @@ test-e2e-fast: test-e2e-smoke
 # with everything the slice does not own deselected — so a slice cannot miss a
 # test or run one twice, which per-slice file lists and `-k` filters both did.
 # Which tests a slice owns, and what each costs, is E2E_SLICES in
-# tests/e2e/conftest.py; `just e2e-slice-costs` prints the balance.
+# tests/e2e/conftest.py; `just e2e-slice-costs` prints the cost model.
 test-e2e-slice slice:
 	ROSOTACOM_RUN_E2E=1 {{python}} -m pytest -q --durations=0 tests/e2e/ -m e2e --e2e-slice={{slice}}
 

{rosotacom_dev-2.5.dev27 → 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.dev27 → rosotacom_dev-2.5.dev33}/src/rosotacom/cli.py

@@ -3661,14 +3661,29 @@ def _ota_wait_for_running_container_suffix_script(suffix: str, label: str, timeo
     )
 
 
+def _ota_communication_wait_suffix(runtime: RuntimeConfig, remote_peer_name: str) -> str:
+    """What the application windows wait for, following `_container_name`.
+
+    The wait must make the same naming decision the start makes, or it waits
+    forever for a name that will never exist: a project with
+    `com_container_prefix` names its com container `<prefix>_com-to-<peer>`,
+    and the instance-scoped `_com_to_<peer>` suffix matches nothing (#254).
+    """
+    fixed = _fixed_com_container_name(runtime, remote_peer_name)
+    if fixed is not None:
+        return fixed
+    return _sanitize_docker_name(f"_com_to_{remote_peer_name}")
+
+
 def _ota_application_run_script(
     plan: OtaSmokePlan,
     target: InteractiveSmokeTarget,
     peer_name: str,
     application: ScenarioApplication,
     instance_id: str,
+    runtime: RuntimeConfig,
 ) -> str:
-    communication_suffix = _sanitize_docker_name(f"_com_to_{_remote_peer_name(target.cfg, peer_name)}")
+    communication_suffix = _ota_communication_wait_suffix(runtime, _remote_peer_name(target.cfg, peer_name))
     label = f"{peer_name}:{application.name}"
     command = _ota_rosotacom_command(
         plan, _ota_application_parts(target, peer_name, application, instance_id), plan.peers[peer_name]
@@ -3825,7 +3840,7 @@ def _ota_create_tmux(
         for peer in peers:
             for application in target.scenario_definition.applications.get(peer.name, ()):
                 application_script = _ota_application_run_script(
-                    plan, target, peer.name, application, instance.instance_id
+                    plan, target, peer.name, application, instance.instance_id, runtime
                 )
                 created_application = subprocess.run(
                     _tmux_command(

{rosotacom_dev-2.5.dev27 → rosotacom_dev-2.5.dev33}/src/rosotacom/image_cache.py

@@ -1,10 +1,10 @@
 """Content-addressed names for the images this project builds.
 
-Every e2e job rebuilds the same project image from scratch, and #236 measured
-what that costs: 154s per job, thirteen jobs per merge-gate run. Publishing the
-built image once and adopting it in each job removes the build — but only if
-"adopt" can never mean "adopt something else". A cached image that no longer
-matches its build inputs is a silent wrong-result machine, which is why #226
+Every e2e job used to rebuild the same project image from scratch, and #236
+measured what that cost: 154s per job across the thirteen jobs in that run.
+Publishing the built image once and adopting it in each job removes the build —
+but only if "adopt" can never mean "adopt something else". A cached image that
+no longer matches its build inputs is a silent wrong-result machine, which is why #226
 declined to do this inline.
 
 So the name of a published image is a hash of everything that determines it:

{rosotacom_dev-2.5.dev27 → 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.dev27 → 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.dev27 → 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.dev27 → 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.dev27 → 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: