# Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [Unreleased] ### Added - A graph input can set its backpressure in YAML: `backpressure: block` or `drop_oldest`, `depth: N` (1 to 64) and, under `block`, `block_timeout_ms: M`, beside `name` and `source`. A key present wins over the node's `#[input(...)]` attribute. With `block_timeout_ms`, a `block` consumer that stays full and drains nothing for M ms has its slot released: the producer resumes, and the consumer's undrained frames may be evicted from its queue; frames published after the release are not. The key is refused on a topic with more than one in-graph producer or listed in `multi_publisher_topics:`, where a release could leave the slot's count high and release a consumer that keeps up again, and on an edge whose producer runs in another process group or executor unit, where a read and a publish on different threads could leave the count off by a frame after a release; such a consumer's slot is still released when it stops for good. Each release logs a warning naming the producer, the consumer input, the topic and the reason, and counts in `NodeHandle::backpressure_block_slot_releases_count`. A whole-run replay of a lockstep recording judges `block_timeout_ms` again on its own clock, so a release falls at the same step as live; a replay resumed from a mid-run anchor starts from empty slots, and a replay of a free-run recording takes its fires from the recording. - A `network.egress` map entry accepts `backpressure: drop_oldest`, beside `topic`, `reliability`, `external` and `send_queue`. It is what network egress always does, so the entry is put the same with or without it; `backpressure: block` there is refused (see Changed). In 2.0.0 any `backpressure:` key on an egress entry was refused as an unknown field. ### Changed - On Linux aarch64, `rmw_cerulion` now runs the period-learned park by default. Every Linux aarch64 build carries it, the release packages included, with or without the `period-park` Cargo feature. `rmw_wait` learns each subscribed topic's arrival period. Once a topic is regular, a wait sleeps in the kernel until shortly before the topic's next message, then parks on its doorbell, so the publish wakes the subscriber from the park rather than from the kernel. The new `CERULION_RMW_PERIOD_PARK` variable switches it: `0` turns it off and restores the one-rung park of 2.0.0, `1` or unset leaves it on, and any other value warns once and leaves it on. Where the park cannot run (a Linux build without it, macOS, Android, or a CPU without a monitor-wait instruction), `1` warns once. The variable is read when each wait set is created, not on every wait. To keep the 2.0.0 wait on Linux aarch64, set `CERULION_RMW_PERIOD_PARK=0` in the environment of the ROS 2 process before it starts. x86_64, macOS and Android builds are unchanged: there the park stays opt-in through the `period-park` feature, and on macOS and Android the wait never takes it. - An explicit `CERULION_MONITOR_WAIT=0` turns the live-loop park of `cerulion graph run`, `cerulion node run` and `cerulion graph profile` off on every host. On a Linux host whose CPU has a monitor-wait primitive (x86_64 with WAITPKG, or aarch64), an unset `CERULION_DOORBELL` turned the park back on with no message, so the run kept the default park and its CPU cost. An unset `CERULION_DOORBELL` now follows the park, as it already did on hosts without a primitive; `rmw_cerulion`, which never reads `CERULION_DOORBELL`, already treated `CERULION_MONITOR_WAIT=0` as off. `CERULION_DOORBELL=1` turns the park back on only where a monitor-wait primitive exists, and then warns once at startup, naming both variables; on a host without one, `CERULION_MONITOR_WAIT=0` stands even beside it. With the park off, `graph run` and `node run` on Linux apply the automatic C-state cap to a latency-sensitive graph, as they already did after `CERULION_MONITOR_WAIT=0` on hosts without a primitive; add `--no-cpu-dma-lock` or `CERULION_CPU_DMA_LOCK=0` to let the CPU idle deep as well. To keep the park on a primitive host, drop `CERULION_MONITOR_WAIT=0`, or set `CERULION_DOORBELL=1` beside it. - The `--no-monitor-wait` help of `cerulion graph run` and `cerulion node run` says the park is on by default on every target and that the flag turns it off on every target, including the bounded park of a host without a monitor-wait primitive; `node run`'s help said the flag had no effect there. Both now say what each value of `CERULION_MONITOR_WAIT` and `CERULION_DOORBELL` does, and `graph run`'s says the flag has no effect only on a single-process `--time-source virtual` run. - `cerulion_core::MonitorWaitPolicy::new(false, true, ns)` returns a policy with the park and the doorbell both off, where it returned both on. A doorbell never turns the park on by itself; pass `true` for the park to arm both. - `block` now works on a topic that also has `drop_oldest` or `sample(N)` consumers. Each `block` consumer holds its own credit slot and defers the producer while that slot is full; the other consumers keep their policy and receive whatever the producer publishes. Before, every `block` consumer of such a topic became `drop_oldest`, with a warning at build in one process and none across processes. A deferred producer still defers its whole node, other outputs included, so a `drop_oldest` or `sample(N)` consumer of the topic receives frames at the pace the `block` consumers allow, not at the producer's own rate. Graph load logs one warning per such topic, naming the topic, its producer nodes, its `block` consumers slowest declared first with their depth and `block_timeout_ms`, and the consumers they pace; a multi-process run logs it in the worker that runs the producer, naming the consumers of every process group. A partition may now put a `block` topic's non-`block` consumers in any process group; only a split multi-producer `block` edge is still refused. In `cerulion_core`, `TopicFlow::is_all_block` is removed: `TopicFlow::holds_its_producers` says whether a topic's `block` consumers hold its producers. - Graph load refuses a ring of `block` edges (each consumer holding the producer before it, so no node of the ring could tick again), `block` on an input that reads a `network.ingress` topic, `backpressure: block` or `depth:` on an `#[input(accumulate)]` input, and `block_timeout_ms` on an input that is not `block`, set to 0, on a topic with more than one in-graph producer or listed in `multi_publisher_topics:` (naming the topic's producers too), or on an edge whose producer runs in another process group or executor unit (refused before any worker starts, naming both sides), each naming the edge. `backpressure: block` on a `network.egress` entry is refused by name, naming the topic and saying why network egress cannot block, where 2.0.0 refused any `backpressure:` key there as an unknown field. - `cerulion graph validate` writes an `input backpressure` line, once every node library reads and the `graph topology` line passes, when an input sets `backpressure:`, `depth:` or `block_timeout_ms` or when an input's queue fails. It judges the YAML input keys as graph load does, over each node's declaration, and fails with the refusal graph load gives. On a topic listed in `multi_publisher_topics:`, the shared subscriber cap is judged only when the graph is built. `graph validate` checks a declared `process_groups:` block's membership on its `graph topology` line, but not whether the partition can run: a split multi-producer `block` edge and a `block_timeout_ms` on a `block` edge split across the groups are refused by `graph levels`, and by a multi-process `graph run` before any worker starts. - A producer held by a full `block` slot no longer wakes its executor every millisecond to defer again. It waits for the slot's `block_timeout_ms` release, or for the drain that frees it when its consumer runs on the same executor; a producer whose consumer is in another process keeps its earlier wakes. - The `block credit drain removed frames its word never counted` warning reads each `block` consumer's own slot: it fires when a drain removes more frames than that slot has queued, counting the frames a `block_timeout_ms` release forgave that are still queued, so a drain that pays off forgiven frames logs none. - The host's `block` credit word grows from 24 to 32 bytes. It gains its per-consumer release mark and a producer connection count, and its first 64 bits pack four counts: frames queued, frames a timeout release forgave that are still queued, and frames held in the matcher's slots, counted and forgiven. A publish counts its frame on every `block` consumer's slot before the send. When the send fails, a slot whose word still holds the counts that count stored gets back the exact counts it replaced, forgiven frames included; a slot whose word moved in between (its consumer drained it, or a release emptied it) has one queued frame taken back. `BackpressureCounters` gains the release count, and the host reads whether an input is `#[input(accumulate)]` from the accumulate capacity its node library declares for it. - `cerulion_core`: `CreditShared::record_drained` returns a `Drained` where it returned a count. `Drained` holds how many of the removed frames were frames a timeout release forgave and how many it could not take off the word because the word reached zero. `CreditShared` gains `record_published_with_undo`, which counts a frame and returns an `Option` (`None` on a released slot), and `CreditShared::record_unpublished` takes that `PublishUndo`, where it took no argument. `graph::CreditBar` loses the `MixedTopic` variant and the `siblings` method, because a topic whose consumers mix `block` with other policies is no longer barred from a credit word, so a `match` on `CreditBar` drops that arm. `graph::config::InputDef` gains the `backpressure` (an `InputBackpressure`), `depth` and `block_timeout_ms` fields and derives `Default`, so a struct literal that names only `name` and `source` adds `..Default::default()`. Four structs gain a field, so a struct literal names it and a pattern that lists every field adds it or `..`: `graph::node::InputMeta` gains `accumulate`, `graph::topology::ConsumerEdge` gains `block_timeout_ms`, `graph::CreditBinding` gains `producer_nodes` (the edge's producer node ids), and `graph::runtime::BlockCredit` gains `block_timeout`, true on an edge that declares `block_timeout_ms`, where `BlockCredit::conservation_broken` is never true. - `cerulion_cli_engine::multiprocess::CreditEdgePlan` gains `producer_nodes` and `multiprocess::WorkerPlan` gains `paced_topic_warnings`, so a struct literal of either names the new field. A plan file without the key reads as empty. ### Fixed - When a `block` consumer's process dies, the supervisor releases that consumer's slot and the producer resumes; the topic's other `block` consumers keep their slots. The "lost its CONSUMER" warning now says the slot was released and names the producer node. A consumer node that stops with a fatal error releases its own slots the same way, whichever process its producer runs in. A tick panic in a node library leaves the slots armed, because the library catches the panic and the node keeps running. A released slot counts nothing, so a drain of it logs no `block credit drain removed frames its word never counted` warning. Before, the producer stayed deferred for the rest of the run. ### Added - The `--report` JSON of `cerulion bag play --resim all --verify` gains a `difference` object on every `ByteMismatch` violation class: `kind` (`field`, `header`, `schema_hash`, `layout` or `undecoded`), `path`, `recorded`, `replayed`, `field_byte`, `field_char`, `byte_offset`, `region`, `reason` and `more`. `more` is an integer, 0 where nothing else is counted (always on `schema_hash`, `layout` and `undecoded`); any other key the kind does not use is `null`. `path` is the field's path for `field`, the wire-header field for `header` and `schema_hash`, and the framed field for `layout` in `field_framing`. `recorded` and `replayed` are JSON numbers or booleans where the value is one, a string value is the string itself without quotes, and anything else (`.nan`, a byte, a window of a long string) is the line's text. `field_byte` and `field_char` say where inside the field the line points, for a field compared byte by byte or a long string. Every existing key is unchanged; `docs/bag.md` describes each kind. ### Changed - A `byte-mismatch` verdict line of `cerulion bag play --resim all --verify` names the field that differs and both values, spelled as `cerulion topic echo` prints them, where it named only a byte offset: `frame 99 on '' differs at x: recorded 0.3, replayed 0.25 (recorded 64 B, replayed 64 B)` where it read `frame 99 differs at byte 40 on '' (recorded 64 B, replayed 64 B)`. The topic now comes before the verb. A differing wire-header field (`sequence`, `timestamp_ns`, `step_tag`, `offset_table_offset`, `offset_table_count`) is named ahead of the message values, a schema hash mismatch is named as one, and a frame whose values are all equal or that cannot be decoded keeps a byte offset with the part of the frame it sits in or the reason. Other differing values of the frame are counted (`; 2 more value(s) differ`), and a field a `--tolerance` metric judges is never named. A script that matches `differs at byte` matches only those last two forms. The same text is the `detail` of the violation in `--report` and in the `replay: data violation` log line. - `cerulion_cli_engine::replay_engine::ViolationClass::ByteMismatch` gains a `difference` field, so Rust code that matches the variant without `..`, or builds one, needs an edit. ### Deprecated - `CERULION_EXECUTION_MODE=lockstep` is deprecated, and so are `CERULION_BARRIER_SPIN_US` and `CERULION_BARRIER_OS_SYNC`, which tune its barrier and act only under it. Semantic Versioning does not cover the `lockstep` value or the two barrier variables, so a 2.x minor release may change or remove them. The opt-out runs a multi-process `cerulion graph run` in barrier lockstep instead of the free-run default, every rank advancing the same quantum per step behind a shared barrier, and on the real clock it does three more things: it keeps each process as one executor unit, it keeps a `--single-process` run of a graph whose nodes split into several executor units as one level loop, and it makes a partition that `graph run` derives from the graph's profile follow the cost rules alone instead of keeping each linear chain within the per-group budget in one process group. A multi-process run already free-runs by default, so leave `CERULION_EXECUTION_MODE` unset and drop the two barrier variables. To order a split edge between two nodes on the same level, mark the edge `#[input(trigger)]` on a data-triggered consumer (the macro refuses it beside `period_ms`), or co-locate both nodes in one `process_groups:` group that runs as one executor unit (`cerulion graph plan` shows the units; a `graphs/.costs.yaml` profile or an `isolate: true` node can split a group, and a plain `#[input]` between two units is not ordered); to keep every node in one process, run `cerulion graph run --single-process`. Replaying a bag stamped `coordination: lockstep` is not deprecated. ### Fixed - `cerulion bag play --resim all` prints each difference between the shell's environment and the recording's once, and never prints a value or a hash. A `WARNING: environment variable NAME ...` line names each variable that can change the re-execution and differs or is set only now: a `CERULION_` or `IOX2_` setting, `CARGO_TARGET_DIR`, which Cerulion reads to choose the build directory it loads your node libraries from, an `LD_` or `DYLD_` variable the dynamic linker reads, or a `PYTHON` variable the Python interpreter reads. One `NOTE:` line counts every other difference, which `-v` lists, so a shell variable such as `SHLVL` no longer warns on every pass. In the `--report` JSON each `env_divergence` entry gains `read_by` (`cerulion`, `dynamic_linker`, `python` or `null`), and `kind` can be `Added`, for a variable set only at replay. In `cerulion_cli_engine`, `EnvDivergenceKind` gains `Added` and `ResimReport` gains `env_lines`. - A first install on Linux no longer prints a block of Cargo build-script lines (`cargo:rerun-if-env-changed=...` and `... = None`) in the middle of its Rust setup. rustup-init 1.29 prints them on stdout from its default-linker check. The install script, `cerulion-install-rust` and the CLI's own offer to install Rust now run the official rustup installer for rustup alone (`--default-toolchain none`), hold back its stdout and show it in full only when it fails, then add current stable through that rustup, so the toolchain's download progress still shows. Stable is the default afterwards, as before. The command the CLI prints for a manual install is unchanged and still prints those lines with rustup 1.29. - `cerulion connect` stops promptly on a signal while its stdin is a pipe that stays open. SIGINT or SIGTERM sent to `cerulion connect`, or SIGINT sent to `cerulion-connectd connect`, now ends the session with exit 0. Before, `cerulion-connectd` kept waiting on its stdin after it tore the session down, so `cerulion connect` exited 137 once its 5 s grace killed the helper, and `cerulion-connectd connect` did not exit until its stdin closed. - `cerulion bag play --resim all --verify` of a free-run recording (the multi-process default) whose graph has an `external` (driver) node, such as the camera of `examples/v4l2_camera`, no longer fails with `missing-topic` on every topic the driver publishes. A resim never calls a driver's `external_source()`, so the driver has no device to read; its outputs are now recorded inputs, fed from the bag to the nodes that read them, whose own topics are compared, and the verdict's topic tally no longer counts them. `--record-out` still holds every frame a replayed driver tick publishes. A driver topic still fails the run when the bag lost its frames: a record-health stamp that counts lost frames on it is a `record-side-tap-loss` violation on that topic (exit 1), and a replay that feeds reads by their recorded identity refuses a read of a frame the bag does not hold (exit 2, `read_identity_frame_missing`). On a `multi_publisher_topics` topic a driver shares with other nodes, only the other writers' frames are compared, each writer's in the process that runs it, when the replay attributes each recorded frame to its writer; otherwise (for example a bag that labels no writer, a headerless frame, or more recorded frames than the verifier's record budget) every recorded frame is compared, the driver's included, and the verdict says so. A graph whose produced topics are all driver outputs has nothing to re-compute, so its `--verify` passes with `0/0` topics, and a warning says that no topic was compared; a driver topic no node reads is neither fed nor compared, and a warning names it. A recording made with this version records, for every node, whether it was an `external` (driver) node (the `node_external` key of `__cerulion/recorder.json`), and a resim judges drivers by that record: when the build you replay declares any node differently, `--resim all` refuses with exit 2 and names each node. A recording made before this records no such mark, so its driver set comes from the build you replay, and a warning says so. The verdict prints a `NOTE:` line, on a pass and a failure alike, naming the driver nodes and the topics left out of the comparison, the driver topics whose readers were not fed, the driver topics no node reads, and a `0/0` tally that compared nothing, and the `--report` JSON gains `driver_inputs` with the same lists (`nodes`, `declared_by`, `input_topics`, `shared_topics`, `unattributed_topics`, `unfed_topics`, `unread_topics`; absent for a graph with no driver). A run directory's `recorder.json` is now written once the run's nodes load, before any trace ring is declared, and `cerulion bag record --run` reads `run.json` first. A run that cannot write it warns, and a bag `cerulion bag record --run` or the window recorder takes of the run that carries its trace carries no `graph.yaml` either, so it can be viewed but not re-executed; the attached bag's `run.json` names `graph.yaml` as withheld under `artifacts_unreadable`. A resim without `--verify` prints the same `NOTE:` lines under its step count, and its byte-for-byte observation names the driver frames left out. In `cerulion_cli_engine`, `ReplayOutcome` gains `driver_inputs`, a new `DriverInputsReport` with `leaves_driver_frames_out` and `declared_by` (a new `DriverSetSource`), `render_driver_input_lines` renders its `NOTE:` lines, and `ResimReport` gains `driver_lines` and `driver_frames_uncompared`; `ReplayError` gains `DriverSetDrift` (exit 2) carrying a new `DriverDrift`, `RecorderInfo` gains `driver_stamp` (a new `DriverStamp`, admitted from a new `RecordedDriverStamp`), `graph_cmd::render_recorder_json` takes the `node_external` map, `replay_engine::node_external_flags` and `is_external_policy` are new, `run_dir::RunDescriptorSpec` loses `recorder_json`, `run_dir::write_run_recorder` writes the run directory's `recorder.json`, and `bag_cmd::RunArtifacts` gains `graph_yaml_to_embed` and `unreadable_for_bag`, with the reason `bag_cmd::GRAPH_WITHHELD_NO_RECORDER`. A lockstep recording of a graph with a driver is not supported by a resim: a warning names the drivers, the topics they write and the remedy, and `--verify` exits 6 (see `docs/bag.md`). - `cerulion bag play --resim all --verify` of a free-run recording compares a `multi_publisher_topics` topic whose writers run in several processes or executor units in every one of them that runs a writer of it other than a driver. Before, only the last one that writes the topic was compared, so a changed writer in another passed with exit 0, and a last one whose writer published nothing failed the topic as a `missing-topic` the replay produced nothing on. When the replay attributes each recorded frame of the topic to its writer (a bag that labels each frame with its writer, a wire header on every frame, and at most 200000 recorded frames, the verifier's record budget, on the `multi_publisher_topics` topics one process or executor unit writes), each writer is now compared where it runs, and a byte mismatch names it (`from writer /`). The frames a process or executor unit then feeds from the bag to its nodes that read the topic, the recorded frames of the writers that run elsewhere, are left out of the comparison, so a reader that skips frames, such as a node that reads the latest value on a slower period, no longer stops `--resim all`, with or without `--verify`, with exit 5 (`capture tap lost frames`). Otherwise a `--verify` that feeds a node's reads of the topic from a bag that labels no writer refuses with exit 2 when the topic's reads name more than one writer, and a process or executor unit that runs a writer of the topic other than a driver and cannot attribute the frames compares the frames published on the topic there as one stream, a byte mismatch there naming no writer. The only one whose writers published frames of the topic, where it fed none of the topic's recorded frames to its nodes, is compared with every recorded frame of the topic. Otherwise the frames such processes or executor units published are counted together against every recorded frame no attributed writer holds, and so, once, are the recorded frames of a driver none of them runs that any process or executor unit feeds from the bag to its nodes, when the bag labels each frame with its writer, every frame carries a wire header, and the replay does not feed reads by their recorded identity. A replay that does (a `--verify` of a free-run recording at trace format 8 or later) feeds those frames to its nodes off the topic and counts none of them, so there the topic fails with exit 1. One that, in a replay that does not feed reads by their recorded identity, feeds its nodes the other writers' recorded frames compares its stream, the frames it feeds included, with every recorded frame. One whose stream holds its own writers' frames alone, beside another that published frames of the topic, is not compared, so unless something else on the topic fails, the topic is declined, checked and not credited: the verdict's DECLINED note and the `--report` JSON's `declined_frame_comparisons` name it with the cause `split_topic_frames_unattributed`, which `cerulion_cli_engine`'s `DeclinedFrameComparison::code` can now carry. A topic a refused read log declines as well carries one row per cause, is counted once, and never reads as matched. Where one stream holds the frames of two writers, it cannot tell their sequences apart, so the replay stops with exit 5 once a frame skips a sequence the recording holds, and otherwise a frame published in another order than recorded fails the topic with exit 1. A ragged shutdown tail that `--verify` tolerates on such a topic is now bounded by each process or executor unit's own tail: the extra frames of a writer one of them runs and attributes lie within that writer's own window, the tail times the most frames the writer published in one recorded step, so neither another process's tail nor another writer's frames explain them, and the extra frames those that cannot attribute them published lie within the sum of their windows. The note of a tail tolerated over several processes or executor units reads `the tails of ranks explain them: ` where it read `the topic's writers span ranks whose tails add up`. - In the period-learned park of `rmw_cerulion`, a steady topic keeps its learned period when `rmw_wait` finds one of its messages already waiting as a wait starts, because the message arrived while the subscriber was still busy, or when the wait's entry spin catches it. That message now counts as an arrival at the moment the wait reads it, so the topic stays regular as long as that lag is small against its period. Before, it was marked seen with no arrival, the next gap read as two periods, and the topic stopped predicting until it learned its period again. A message less than 200 µs after the topic's last arrival is still only marked seen, as the tail of a burst. ## [2.0.0] - 2026-11-12 Semantic Versioning covers the graph YAML format, the `cerulion` command line and the node macros of `cerulion_macros`. This release changes the command line in ways existing scripts notice, including paired LAN access by default on every platform, the output of `cerulion topic echo` and how `cerulion graph run` runs a graph by default (see Changed), so it is a major version. The lower-level Rust API of `cerulion_core` is not covered by SemVer yet, and neither are the library crates behind the command line and the daemons (`cerulion_cli_engine`, `cerulion_wsd`, `cerulion_netd` and `cerulion_bagd`) or the bag library `cerulion_bag`. This release changes public items in each of them, so Rust code that calls them directly may need edits. Prebuilt node cdylibs are a separate matter: every one must be rebuilt for node ABI 32 (see Changed). ### Migration 1. Sign the robot and desk in to the same account with `cerulion login`. Existing saved pairings continue to work; if you set `CERULION_HOME`, first move `desk.key`, `robots.toml`, `config.toml`, `epochs/` and `ros2/` from `~/.cerulion` into it (see the machine key entry under Changed). Upgrade the CLI and daemons together and restart `cerulion-netd`, whose control protocol is now version 11. 2. To keep unauthenticated LAN access, set `CERULION_LAN_ACCESS=open` for every Cerulion command and daemon on every machine that should send or receive topics over that LAN, and restart `cerulion-netd` on each machine. 3. For zenoh LAN access, `listen` and `connect` locators, `CERULION_NETD_LISTEN`, `CERULION_NETD_CONNECT` and `topic list --connect` take effect only under explicit open access. Account and paired discovery needs none of these settings. 4. In a workspace made by Cerulion 1.0, change `cerulion_core` and `native_ros2_messages` under `[workspace.dependencies]` in the root `Cargo.toml` from `"=1.0.0"` to `"=2.0.0"` (a workspace made from a source checkout points their `path` at a 2.0.0 checkout instead), and add, at the end of that file, the `[patch.crates-io]` block that `cerulion workspace create` writes, so its nodes link the same iceoryx2 build as the CLI. Make its `rust-toolchain.toml` name `stable`, or remove it: the file Cerulion 1.0 wrote names Rust 1.93, and this release needs Rust 1.95 or newer. 5. Rebuild every node library once with `cerulion node build `: a library built by an earlier release is refused at load (see the node ABI entry under Changed). In a node crate, move helper functions that take the node context into the `#[cerulion_node]` node's `#[cerulion_node_impl]` block; helpers that take only data are unchanged. ### Added - `cerulion bag play --resim all --verify --feed-index-budget ` bounds the memory a fed replay's index of the bag's frames takes; the default is 1 GiB (1073741824 bytes). The index holds only the frames the replayed reads consume, up to `--duration` when it is given, one sorted key and one slot per frame, 40 bytes on a 64-bit build, and the budget charges those bytes and 40 bytes for each producer label of the topics the reads consume, which the index build reads to tell a topic's writers apart. A replay whose reads need more is refused with exit 2 after the labels are read and before the bag's frames are walked (`read_identity_feed_index_budget`), and the refusal names the bytes the reads need, the frame identities and labels they are charged for, the budget and `--feed-index-budget`. The flag needs `--resim` and `--verify`: plain playback and a resim without `--verify` feed no reads. - `cerulion_pairing` keeps team credentials in the machine identity directory: `identity/active_team` names the team, and `identity//leaf.der` and `identity//bundle` hold the leaf certificate and the trust bundle (mode 0600). `IdentityLayout::load_team_credentials` accepts them only when the bundle verifies against a trusted root set, the leaf belongs to the bundle's current generation and certifies this machine's key, and a leaf other than a robot's has not expired; each refusal names the file. `TeamTrustBundle` carries `next_ca_der`, the next generation's issuing CA. A release build trusts no root set, so it accepts no team credentials. The `dev-issuer` feature adds a local development issuer and the `cerulion-dev-issuer` program (`init`, `init --import`, `status`) that enrolls machines into one development team; no release binary is built with it, and the release workflow checks that. - `tls/:` is a carrier: TLS 1.3 over TCP, for a path where UDP does not get through. It reads the same `tls:` files as `quic/` (`certificate` and `private_key` for a listener, `root_ca` for a connect) and graph-load validation applies the same file rules to it. - `cerulion_core::NetworkConfig` gains `auth: Option`. `TeamAuth::new` checks a machine key, its team leaf certificate and the team's anchors (`TeamAnchors`: the current issuing CA, retired CAs and, during a rotation, the next or the previous generation's CA) with the `cerulion_pairing::team` profile. A machine opens up to three team sessions on separate listeners, each on `quic/` and `tls/` only, with both ends presenting and verifying a certificate, the keys passed to zenoh in memory and never as files, scouted and gossip-learned peers never dialed in any mode, and a generated zenoh access policy that denies by default and is keyed on the peer certificate's common name. `NetworkAuth::Team` is the data session: a listener accepts only leaves the current issuing CA signed, and the policy admits only current-generation names. A viewer or ci leaf receives data and may query; an operator leaf may also put and answer queries; an owner or robot leaf may send every message. `NetworkAuth::TeamCrossGeneration` carries data with the other live generation during a rotation: it trusts only that generation's CA and admits only that generation's names, so a leaf the next generation's CA signs with a current-generation name fails the data session and is denied every message on the cross session. `NetworkAuth::TeamBundleLane` trusts the retired CAs and the other live generation's CA and admits only the bundle exchange on `cerulion_auth/bundle`, so a leaf a retired CA signs never reaches a data, demand, announce or query key, whatever name it carries; it can still answer a bundle query, whose reply a consumer must check with `cerulion_pairing::team::verify_team_trust_bundle`; nothing in the command line or the daemons consumes a bundle reply. zenoh matches the common name, not its issuer, so a live CA's key can issue any name of its own generation. A dialer also trusts the public Web PKI roots, which zenoh's TLS and QUIC clients always load: a listener whose certificate chains there links, matches no team name and is denied every message, so such a dial stays up and carries nothing. A `tcp/` or `udp/` locator, a datagram-only `quic/...?rel=0` locator, a locator with a `#` endpoint config, or certificate files set beside team credentials fails the session open naming it. Nothing in the command line or the daemons sets `auth`, and `graph run` refuses to hand it to a gateway child. `cerulion_core::transport::test_ca` (feature `test-helpers`) issues test team credentials in memory. - Exact replay of one ROS 2 process over `rmw_cerulion`. `cerulion ros2 run --record-deliveries ...` (also on `ros2 launch`, or `CERULION_RMW_DELIVERY_LOG=` on any launch path) records what each process consumed, in the order it consumed it, into `/-.rdl.mcap`: every take with its payload, every `rmw_wait` return, the answers to five graph queries (`count_publishers`, `count_subscribers`, `service_server_is_available` and the two matched-endpoint counts; every other graph query is answered live during a replay), and a hash of every output. `cerulion ros2 run --replay-deliveries ...` (or `CERULION_RMW_REPLAY=`) runs that process alone against its log: each wait reports the recorded readiness at once, each take is served from the log, and each callback's outputs are compared with the recording; the verdict, `identical` or the first node, topic and window whose outputs diverged although its inputs matched, is written to `.verdict.json`. Several single-threaded executors on several threads replay in the recorded order, and a callback that blocks on another thread is named after 5 s. A log of another process (command line, `ROS_DISTRO` or library build) and both variables set are refused by name at `rmw_init`. A multi-threaded executor or a serialized take seen while recording marks the log not replayable, so its replay is refused at `rmw_init` under that cause; a multi-threaded executor first seen during a replay fails `rmw_wait` there. A replay in which a thread outside every executor publishes ends `refused`, naming the thread's first topic, and the replay of a log torn by a killed recording compares each thread's last surviving segment only as far as the log goes, ending `log_exhausted_early` if everything before the cut matched. A replay writes a `running` verdict when it starts, so a replay that crashes never leaves an earlier verdict (one that cannot write it is refused at `rmw_init`), and it publishes its outputs live, so keep it away from a live robot. With neither variable set, the cost is one check per rmw call; while recording, each take copies its payload into the log and each output is hashed on the calling thread, which lifts a 1 MiB round trip from about 165 µs to 3.0 ms on the test host (`docs/ros2_replay.md`, "What recording costs"). Runtime-tested on Humble with rclpy and rclcpp nodes, rclcpp's `/clock` thread under `use_sim_time` included, and with rclpy and rclcpp service clients and servers; see `docs/ros2_replay.md`. - `rmw_cerulion` gains an opt-in `period-park` Cargo feature that wakes a subscriber sooner on a topic published at a steady rate. It is off by default and the release packages do not enable it; build the library with `cargo build --release --locked -p rmw_cerulion --features period-park`. On Linux, `rmw_wait` learns each subscribed topic's arrival period. Once a topic is regular (eight gaps in a row between 200 µs and 100 ms, with a smoothed deviation of at most an eighth of the smoothed period and at most 25 µs), each wait sleeps in the kernel `ppoll` block until shortly before the next expected message, then parks on that topic's doorbell for at most 200 µs, so the publish wakes it from the park rather than from the kernel block. A topic that is not regular, `CERULION_MONITOR_WAIT=0`, an x86 CPU without `UMWAIT` and a wait set of more than 16 subscription topics keep the stock wait. - Generated messages with only fixed fields gain `Shm::read_unaligned(&[u8]) -> Option`, which copies one value out of bytes at any address, such as one element of `PoseArray.poses_bytes()`, and returns `None` for a source shorter than the message. - Nodes that share a process can run in executor units, which are opt in: without a profile the nodes of a process run as one unit, one level loop, as before, and units form only from the graph's profile (`graphs/.costs.yaml`) or a node's `isolate: true`. A graph that already has `graphs/.costs.yaml` (the profile the cost-fused partitioner reads) therefore now runs its processes in the executor units that profile forms in a free run on the real clock, and such a run, when it derives its process groups from the profile (a graph without `process_groups:`, or `--auto-partition`), can derive other groups than before, since the partitioner keeps each linear chain within the per-group budget in one group (see the entry on linear chains below). Without that file each process runs as one unit again unless a node of it declares `isolate: true` (`graph partition --costs ` reads a profile moved elsewhere), but the default run of a graph without `process_groups:` then derives one process per node, so a graph that keeps cost-fused groups declares them (`cerulion graph partition --yes` writes the groups the cost rules derive). With the file kept, `isolate: false` changes no process group; declared on every node that another node of its process triggers, it keeps that process in one unit when no node of it declares `isolate: true` and its trigger and `block` edges connect all of its nodes, and it never joins nodes that no such edge connects. A node that declares `isolate: true` runs in a unit of its own, so its ticks no longer hold the other nodes of its process. Each unit runs on its own thread with its own step counter, clock and trace ring, and units are joined by the same bounded drop-oldest queues that join processes, so a recording of such a process is a bag with one rank per unit and replays like a process-per-node bag. A unit waits for a frame from another unit as a process waits for one from another process: its park takes the wake on its first declared trigger or sync input that another unit or process writes and sees a frame on any other input when its current wait ends (within 20 µs on an x86 host with a monitor-wait instruction, within one event-stream period, about 130 µs, on an Arm host whose WFE park has no timeout, and one 100 µs recheck plus the kernel timer's overshoot elsewhere), so a join with two or more such inputs can wait that long when its set completes on one of them but the first; inside one process a join has two or more when, for example, its unit holds none of its producers: it declares `isolate: true`; with a profile, no `isolate: false` or `block` edge keeps it with its producers; without one, it runs past an isolated node's level in a later unit that holds none of them, or its producers all declare `isolate: true`. With a profile, `isolate: false` on the join keeps it in the unit of the nodes of its process that trigger it, where the joined unit keeps its band of levels (below); without one a join runs in its process's unit unless it declares `isolate: true` or runs past an isolated node's level in a later unit, and `isolate: false` changes nothing. On an oversubscribed host each hop between units can also wait one scheduler quantum for the reading unit's thread to run, which a process that runs as one unit does not pay; that wait is the p99 of a run in units on a loaded host. With a profile every node starts a unit, and a linear chain (one producer handing each frame to one consumer that fires on it; the fused-chain census and the partitioner start from the same link rules) merges into one unit, where a hop runs on the level loop with no wake, only when the profile shows the unit's summed tick stays under a quarter of the shortest period the merged unit is fed at (each member's own period, the profiled rate of each trigger edge into a member, and the profiled fire rate of a member no graph node triggers or that fires on a topic no graph node publishes) and of the tightest `tick_within_ms` of its members, and only where the merged unit keeps a contiguous band of the graph's levels in which, on levels derived from the trigger edges, each node above the band's first level is fed from inside the unit at the level below (a link that would break it stays split, an `isolate: false` join is held to the same band, and `graph plan` says why); a process whose split the partition validator still refuses, as when a `block` edge keeps nodes on both sides of a level in one unit, runs as one unit, which `graph plan` prints and a run logs at warn, naming the process and each node of it that declares `isolate: true`. A `block` edge's producer and consumers stay in one unit, `isolate: true` included, and a merge into that unit counts the ticks of all of them. Units are fixed when the graph loads. Units form, from a profile or `isolate: true`, in a `process_groups:` group with more than one node, a cost-fused group, and under `--single-process` on the real clock; process-per-node graphs, the lockstep execution mode and the virtual and external time sources run as before. Under `--single-process` a graph whose nodes split into several units runs them all in one worker process beside `graph run`, its recording embeds one process group holding every node and records one rank per unit as a multi-process run does (so the single-process refusal of a graph that reads a topic no node in it publishes does not apply to it), and the run still says that the auto-partition default is skipped (or that the declared `process_groups:` are not executed); a graph that is one unit runs in the `graph run` process as before. A process that hosts several units sizes its file descriptor table before its unit threads start (to the soft `RLIMIT_NOFILE`, at most 65536 slots), so no unit's first publish waits for the kernel to grow a table its threads share; `cerulion_core::fd_limit` gains `presize_descriptor_table`, `presize_target`, `PresizeOutcome` and `DESCRIPTOR_TABLE_PRESIZE_CAP`. When a node stops on a fatal error, the run's verdict names the process group of the process that hosted it, once; a `--single-process` run prints only the node's own line, as before, and exits 3 (`CliError::WorkerNodeFatalAnnounced`). - A node's `isolate:` key in the graph YAML: `isolate: true` gives the node an executor unit of its own, where a run forms executor units, with or without a profile (a unit runs a contiguous band of the graph's levels, each node above the band's first level fed from inside the unit at the level below, so without a profile a node past the isolated node's level runs in a later unit when no node of the process's unit feeds it at the level below and that unit starts at a lower level, and `graph plan` says so); with a profile, `isolate: false` keeps it in the unit of the nodes that trigger it, whatever the profile's split says, where the joined unit keeps its band of levels: a node joins only the producers whose units keep it, and one that joins none of them runs in a unit of its own, which `graph plan` says. Without a profile `isolate: false` changes nothing. A node entry that declares `fuse:` is refused at load, naming the node and pointing to `isolate:`; a bag whose embedded graph declares it still replays, reading `fuse: false` as `isolate: true` and dropping `fuse: true`, with one warning naming the bag. - `cerulion graph plan ` prints the processes a free run of the graph starts, the executor units inside each, where they come from (one unit per process without a profile, apart from each `isolate: true` node, or the graph's profile), and why each unit starts. - When `graph run` derives process groups from a graph's profile for a run whose processes execute in executor units (the free run on the real clock), the cost-aware partitioner keeps every linear chain whose summed cost is within the per-group compute budget in one process group, unless the merged group could not run as one worker (a chain over the budget is cut where the cost model cuts it, and a chain is cut at a node the profile isolated, which keeps a process group of its own unless a `block` edge puts it in one group with that edge's producers and consumers; a chain is then cut at every node of that group, and only the cost rules can add another node to it); the executor units then split the chain inside the process where the profile says a merge is unsafe. `graph partition`, the lockstep execution mode and the virtual and external time sources partition as before. `cerulion_core::graph` gains `auto_partition_with_options` and `AutoPartitionOptions`, and `cerulion_cli_engine::partition_emit` gains `derive_emit_groups_with` and `run_auto_partition_preflight_with`. - `cerulion doctor` checks this host for problems that slow or stop Cerulion and prints the fix for each: the open-file limit against every workspace graph, `/dev/shm` size, dead iceoryx2 nodes, a `config/iceoryx2.toml` in the current directory that moves the shared-memory root, the filesystem recordings land on, the local sign-in state, and the CPU frequency governor (reported, never judged). Each check reports `pass`, `info`, `warn`, `fail` or `skip` with why it matters; `--json` prints a versioned report, `--check ID` runs one check, `--local` skips the checks that use the network and `--timeout-ms` bounds the run. It exits 1 when any check fails, needs no root, writes no file, changes no sysctl or network setting and runs on a machine that has never signed in. - `cerulion doctor` also checks the kernel clock (synchronised or not, read with `ntp_adjtime`, which changes nothing), whether each IP interface's MTU can carry a QUIC datagram (1228 bytes), the NVIDIA driver, devices and CUDA toolkit and whether the loader cache names `libcuda.so.1` on a host with a GPU it can use (from files, with no CUDA library loaded), the sourced ROS 2 distribution, and whether `librmw_cerulion.so` is where `cerulion ros2 run` looks. - `cerulion doctor` also reads the device certificate (expired, not yet valid, or issued for another device key), asks a running `cerulion-netd` for its status without starting one, and reports whether `cerulion-remoted` is installed and, on Linux, running. `NetdClient::status` returns the daemon's whole `status` answer. - `cerulion doctor` has two network checks, which `--local` and `CERULION_NETWORK=off` skip: `net.mdns` browses `_cerulion._tcp` for one second and warns when the browse cannot start or its responder stops mid-window, and `net.udp` sends one QUIC version-negotiation datagram to each `quic/` or `udp/...?rel=1` connect locator of the workspace's graphs and each `--udp-target HOST:PORT`, and warns for an endpoint that does not answer. The probe needs no handshake or certificate; `cerulion_cli_engine::doctor::udp_probe` exposes it. Both checks print robot names, endpoints and resolver errors with each control character replaced by U+FFFD, so a LAN peer or a graph file cannot put terminal escapes in the report. - `cerulion doctor` checks `net.ipv4.tcp_slow_start_after_idle` on Linux and warns when it is nonzero, with the fix the `graph run` warning for `tcp/` egress prints. - `#[input(trigger, consume = latest)]` fires a data-triggered node at most once per scheduler step and serves the newest queued frame; the older frames that read drained are not served. `consume = fifo`, one fire per queued frame in arrival order, stays the default. A frame no fire has read yet, because `throttle_ms` or a `block` gate deferred the fire, is kept until a newer frame arrives. Holding it takes a third borrowed sample on the input's source topic, so a graph whose `latest` input reads an external topic another process already created with the default two fails at build, naming the count. On an input read through a second subscriber that counts arrivals (`block`, `sample(N)`, or a hand-written `NodeEntry` without unified drain capability), the step fires the node only while the input's own subscriber still holds a frame, so a frame an earlier read already took fires nothing more; `NodeEntry` gains `probe_trigger_input` and `probes_trigger_input` (`TriggerProbe`, non-exhaustive) for that question. The host probes every stable node library, including macro nodes, Python nodes and the `--raw-ffi` template, through host-owned head operations; there is no export to add. A hand-written entry answers it by implementing `probe_trigger_input` and returning `true` from `probes_trigger_input`, which defaults to `false` whether or not the entry implements the per-set Sync head ops. A node that cannot answer it is named once at graph build. `consume` on a non-trigger input, and `consume = latest` on any input of a `sync_window_ms` or `unbounded_sync` node, are compile errors, and the `cerulion` commands that read a node's source refuse the same forms. A library carries the declaration as the `"consume":"latest"` input key. A library built before the stable boundary is refused at load with the instruction to rebuild using `cerulion node build`. Replay reproduces a `latest` input's reads and fires, and the fire re-derivation of a free-run recording holds a `latest` node to at most one fire per step, and to exactly one on a step whose drain popped a frame unless the node declares `throttle_ms` or its input is read through a second subscriber. - Topic discovery lists account-owned robots and robots with a saved pairing anywhere, with direct or relayed reachability and visible offline status. Topic reads and remote visualization demand authenticated wire/2 streams automatically, keep identical local and remote names separate, and release streams when their observers exit. `topic echo`, `hz`, and `info` accept `--robot NAME` and refuse ambiguous names with exit 2. - Network-enabled runs start the authenticated remote server on their first egress registration without requiring `CERULION_NETD_LISTEN`. Query-only desks and local-only runs start no server; the last serving registration's release or disconnect reaps it after active work, owed e-stop delivery and its latch clear. Saved robot pairings and expired saved logins preserve offline serving. Owned remote servers receive SIGTERM and a bounded graceful cleanup window before forced reap. - A machine serving authenticated remote topics can also consume topics through the same device endpoint. Outbound mirror release preserves incoming serving. - `cerulion topic type `, `cerulion topic find `, `cerulion topic bw [--window N]` and `cerulion topic list -t` (also `--show-types`), the counterparts of `ros2 topic type`, `find`, `bw` and `list -t`. `topic type` prints a topic's `package/Type`, local or remote, read from one message. `topic find` takes `package/Type`, `package/msg/Type` or a bare workspace `Type` and lists the local topics of that type and the remote ones whose robot catalog names it (`--local` reads local topics only). `topic list -t` prints each row's type after the topic name, LOCAL rows from one message within one shared one second wait and REMOTE rows from the robots' catalogs, with `[unknown]` where the type is not known; plain `topic list` output does not change. `topic bw` prints once a second the payload bytes per second over the newest `N` messages (default 100, from 2 to 100000), in decimal units, measured from the messages' wire stamps. - An explicit open LAN graph's `network:` block can choose QUIC for its zenoh cross-host link. Paired graph links use authenticated iroh without locator or TLS-file setup. The carrier is the locator's first segment: `quic/:` is QUIC over TLS 1.3 with one stream per priority, `quic/:?mixed_rel=1` adds a datagram link on the same connection and port, and `udp/:?rel=1;mixed_rel=1` is QUIC with no encryption and no peer authentication, for a WireGuard overlay that supplies both. TCP stays the default. A new `tls:` block names the PEM files (`certificate` and `private_key` for a `quic/` listener, `root_ca` for a `quic/` connect, which also checks that the certificate names the host or IP it dials); a self-signed certificate can be its own `root_ca` when it is not marked `CA:TRUE`, and a `quic/` or `tls/` listener whose certificate is marked `CA:TRUE` refuses to start, naming the file and the `openssl` flag that mints an end entity. `cerulion-netd` reads the same files from `CERULION_NETD_TLS_ROOT_CA`, `CERULION_NETD_TLS_CERTIFICATE` and `CERULION_NETD_TLS_PRIVATE_KEY` and checks them at start-up by the graph rules (absolute, readable PEM paths, a listener certificate not marked `CA:TRUE`, a certificate and key for every `quic/` or `tls/` listen, a root CA for every `quic/` or `tls/` connect, certificate and key together, no file that no `quic/` or `tls/` locator reads, a carrier this build compiles); `cerulion-netd` refuses to start, naming the variable, on any of them or on a datagram-only locator in `CERULION_NETD_LISTEN` or `CERULION_NETD_CONNECT`. - For explicit open zenoh LAN access, `CERULION_UNENCRYPTED_QUIC=on` (opt-in, read by `cerulion-netd`) listens on zenoh's unencrypted QUIC carrier, `udp/:?rel=1`, beside every `tcp/` listen locator on the same port, advertises it in the mDNS record as `udp_rel=`, and dials it first: at start-up netd checks each discovered peer that advertises it, and each `CERULION_NETD_CONNECT` locator written that way, over UDP, and dials it over QUIC when it answers or over `tcp/` on the same port when it does not, with one warning that starts `QUIC FALLBACK:` and names the locators and the reason. The check waits at most `CERULION_NETD_QUIC_PROBE_TIMEOUT_MS` (default 1000, at most 6000). Explicit `tcp/` locators are used as written. This QUIC has no encryption and no peer authentication, the same as `tcp/`. What it changes is congestion control: a Linux TCP connection that idles longer than one retransmission timeout restarts from its initial window, while the QUIC stack has no idle reset, so a large message sent about once a second does not pay the extra round trips. With the setting unset, nothing changes. - A graph's `network:` block takes `default_reliability: reliable | best_effort` (default `reliable`), the put reliability of every `egress` entry that sets no `reliability` of its own. An entry's own `reliability` wins in both directions, and an entry may set `reliability: reliable`, so one topic can stay reliable under a `best_effort` default. Graph-load validation refuses a `best_effort` default on a graph with no `mixed_rel=1` locator, as it refuses a best-effort topic, and an unknown value is a parse error naming it. The receive path is unchanged. - An `egress:` entry can be a map, `{topic: /r/scan, reliability: best_effort}`, beside the bare topic name it was. A best-effort topic is put with zenoh's best-effort marker and rides the QUIC datagram link of a `mixed_rel=1` connection, so a lost frame is not retransmitted and later frames are not held behind it; every other topic is put at the block's `default_reliability`. Graph-load validation refuses a best-effort topic on a graph with no `mixed_rel=1` locator, a `quic/` or `tls/` locator without the certificate files it needs, a `tls:` file no `quic/` or `tls/` locator reads, a `tls:` block that sets no file, a locator whose carrier this build does not compile (`ws/`), and a datagram-only locator (plain `udp/:`, `udp/...?rel=0`, `quic/...?rel=0`), which sends every message once with no retransmission, so a reliable topic or one of zenoh's own declarations would be lost with the packet; the refusal names the reliable spellings `udp/:?rel=1;mixed_rel=1`, `quic/:?mixed_rel=1` and `tcp/`. Graph load warns when a best-effort topic can reach a peer over a locator with no datagram link. - One message file types a port in both languages. A workspace's `schemas//msg/*.msg` files and `schemas/*.yaml` schemas generate into the Rust message crate beside the built-ins (`native_ros2_messages::::`, a package-less YAML schema at the crate root) and into the Python `cerulion.msgs` namespace (`from cerulion.msgs. import `), by the one resolution rule the runtime uses, so the type, its layout and its wire hash agree. `workspace create` and `workspace init` set `CERULION_WORKSPACE_MSGS` in `.cargo/config.toml`; an existing workspace adds `CERULION_WORKSPACE_MSGS = { value = ".", relative = true }` under `[env]`. `node create` and `node modify` now scaffold a Rust port of a `.msg` store type, which they used to refuse; in a workspace without the setting it is refused with the line to add. - Python message classes: every message is a class in `cerulion.msgs` (`from cerulion.msgs.sensor_msgs import LaserScan`), and every view of a schema is an instance of its class, nested fields included. The wheel ships type stubs for the built-in packages; `cerulion node build` writes a workspace's stubs to `.cerulion/python/cerulion-stubs/`, as does `python -m cerulion.msgs`. `SchemaSet.message_type(name)` returns the class of any schema set. - `cerulion graph pause ` and `cerulion graph resume ` hold a live run at its next step boundary and stop its clock, so timers neither skip ticks nor burst on resume and a recording shows no gap across the pause. A run's `run.json` records `"paused"` while a run is held. A run that is never paused is unchanged. - `cerulion bag play --resim all --record-out ` writes the frames the re-executed graph published to a new bag: one channel per graph-produced topic, labelled with the schema the re-executed graph publishes, with its name and provisioning copied from the input bag's channel where it has one. It works with and without `--verify`. The path must not exist, so an existing file is refused with exit 2 and never overwritten, and a run that does not finish removes the partial file. The `--report` JSON gains a `record_out` field naming the written path; reports from runs without the flag are unchanged, and `report_version` is unchanged. - `cerulion-wsd` creates and builds. `graph.create`, `node.create` and `schema.create` do what `cerulion graph create`, `node create` and `schema create` do and answer with the `version` of the file they wrote, which a graph or node edit can send as `expect_version`. `node.build` runs `cerulion node build` and streams cargo's compiler messages as structured `diagnostic` events (file, line, column, level, message, code), then a `done` event; a client that closes its connection cancels the build. The protocol version is unchanged: an older daemon answers the new verbs with `unknown_verb`, and every existing verb is as it was. `cerulion_cli_engine` gains `node_cmd::node_build_streaming`, and `node create`'s trigger-policy defaulting moved from the `cerulion` binary into `node_cmd::resolve_create_policy` so the daemon applies the same rules. - `cerulion-remoted`, the robot-side remote-access daemon, ships in every release archive, in the Debian package (`/usr/bin/cerulion-remoted`) and in the Homebrew formula. `install.sh` places it beside the CLI and links it with the other programs (see the install script entry under Changed); a v1.0.0 archive, which does not carry it, still installs, and removes a `cerulion-remoted` a later release left in the install directory along with its link. `--uninstall` removes it. - `cerulion-wsd` can wire and unwire a graph and remove a node from it. `graph.wire` and `graph.unwire` add or delete one `inputs:` entry, and `graph.unstage` deletes a node entry. Each takes an optional `expect_version`, edits the file in place so comments and layout survive, and refuses a wire between different schemas (`schema_mismatch`) or removing a node other nodes read from (`would_break`, with the wires listed) unless `force` is set. The protocol version is unchanged. - `install.sh --uninstall` (`curl ... | sh -s -- --uninstall`) removes what the script installed: the programs and libraries, the links that point at them and, when the env file names that install, the marked line in each shell startup file and the env files. A directory without the installer's marker is left alone. The sign-in, keys and settings in `~/.cerulion` and the Rust toolchain stay. - A Python client, new in this release: `import cerulion` publishes and subscribes to topics on the local machine over the same shared memory as Rust nodes, with no copy on receive. Call `cerulion.connect()`, then `session.publisher(topic, schema=T)` and `session.subscriber(topic, schema=T)`. `subscriber.receive(timeout_ms)` returns a `Frame` whose `view()` reads fields in place, `with publisher.loan(...) as msg:` writes straight into the outgoing slot, and `cerulion.open_bag(path)` reads a finished `bag record` bag. Build it from source with `cd crates/cerulion_py && maturin develop --release` (Python 3.11 or later); the release archives do not carry a wheel. - Nodes can be written in Python. `cerulion node create --lang python` writes `nodes//node.py`, a class decorated with `@cerulion.node(...)` whose ports are `cerulion.input(T)` and `cerulion.output(T)`, plus a cdylib that embeds CPython. `graph run`, recording and replay treat it like a Rust node. A Python node must declare `period_ms`, one `trigger=True` input or `sync_window_ms`; `--raw-ffi` and `node modify` refuse it. `node build` uses `CERULION_PYTHON`, else `/.venv/bin/python`, else `python3`. `cerulion node new` is now an alias of `node create`. - Python APIs take message classes. `cerulion.input(T)` and `cerulion.output(T)`, `session.publisher(topic, schema=T)`, `session.subscriber(topic, schema=T)`, `frame.view(T)` and `record.view(T)` take a class from `cerulion.msgs`; a quoted schema name is accepted with `schemas=` (and alone in a node port) for a schema with no class. `Frame.view` and `Record.view` take the schema first; a call that passes the schema set first is refused with a `TypeError` that names the replacement spellings, `view(LaserScan)` and `view('pkg/Name', schemas=schemas)`. A class used against a set that resolves its name to another hash raises `SchemaMismatch`. The `node create --lang python` scaffold writes `import cerulion` and typed imports. - Node parameters: mark a plain field of a `#[cerulion_node]` struct with `#[param(default = .., min = .., max = .., description = "..")]` to make it a typed setting (`bool`, `i8` to `i64`, `u8` to `u64`, `f32`, `f64` or `String`). A graph sets it per node with a `params:` map on the node entry, for example `params: {gain: 0.5}`. Values are checked for type and bounds when the graph loads and are written into the field before `init`. `graph validate` prints a `params ''` line per node, and `node info` prints a `Params:` table. A recording keeps the values, and `bag play --resim` applies them. - Launch arguments: a graph declares a top-level `args:` map. Each entry is a default (`side: left`) or `{default: .., description: ..}`, and it is used as `${name}` in `prefix`, an output's `topic`, an input's `source` and `params:` values (`$$` is a literal `$`). `cerulion graph run side:=right gain:=0.5` overrides values for one run. A name the graph does not declare is refused with the nearest declared one, and a word without `:=` is a usage error. A graph with no `args:` loads exactly as before, and a recording stores the resolved graph. - `#[input(accumulate)]` on a node input hands each fire every frame that arrived since the node's last fire, not only the newest. Frames come oldest first by publish time; read them with `self..iter()`, `len()` and `is_empty()`. `cap = N` (default 10, range 1 to 64) bounds what one fire holds; past it the oldest frames are dropped and counted in `dropped()`. An accumulate input never fires the node. It cannot be combined with `trigger`, `depth`, `backpressure = block` or `backpressure = sample(N)`. - Generated message types keep a `.msg` file's constants and field defaults. `int8 STATUS_FIX=0` becomes `NavSatStatus::STATUS_FIX`, and `float64 w 1` or `int32[] ids [1, 2]` set the value that `Default` builds. Neither changes the wire layout or the schema hash, and a loaned output slot still starts zeroed. A constant or default that does not fit its type, or a constant whose name is not upper case, is a parse error naming the line. `cerulion_core::codegen` also reads `.srv` files (`parse_rossrv`, `split_rossrv`) into `_Request` and `_Response` messages. - `cerulion_core::dynamic` converts any message to YAML and back using only its schema: `message_to_yaml`, `message_to_yaml_with` and `yaml_to_message`. Reading YAML enforces ROS 2 `string<=N` and `T[<=N]` bounds and names the field path in errors. A block copied from `topic echo` output reads back to the same message. `yaml_to_message_with` reads YAML with a `YamlDecodeOptions`: `missing_fields` takes `MissingFields::Required` (the default, which refuses a field the input leaves out) or `MissingFields::Zero` (which writes the zero value of that field, at any depth), and `max_body_bytes` refuses a message body past that limit with `DynamicError::YamlBodyTooLarge` before the reader builds more. The limit leaves out the alignment padding between variable fields, so a finished body can be up to seven bytes per variable field longer. - `cerulion logout` signs this machine out: it removes the session and refresh tokens from `~/.cerulion/auth.json` (the account id stays) and then revokes the session at the account service. Every command that needs an account then starts a sign-in at a terminal, and is refused with exit 7 elsewhere (a script, a CI job), until the next `cerulion login`. It prints one line, `signed_out: account=` or `not_signed_in`, and exits 1 if the file could not be rewritten or the service did not confirm the revoke. - `cerulion workspace create --starter obstacle_avoidance` creates a complete workspace from sources bundled with this CLI version: a laser scanner node and a safety controller node with their tests, and the `obstacle_avoidance` graph. `starter.toml` records the CLI version and compiler. Creation is atomic and refuses any existing path; on a filesystem without a no-replace rename (some network, FUSE, SMB or FAT volumes) it is refused with the reason. - `--local` keeps a command on this machine. On `graph run` and `node run` it is the same as `--network off`. On `topic list` (where `--no-network` is an alias), `topic echo`, `topic hz` and `topic info` it skips remote discovery, the robot schema query and starting `cerulion-netd`, reading only publishers on this machine. On `topic echo`, `hz` and `info` it also refuses a topic that `cerulion-netd` or `cerulion connect` re-injected from a robot. `CERULION_NETWORK=off` still selects the same scope. - `graph run`, `node run` and `ros2 attach` log one line when the run sends topics off the machine over `tcp/` from a Linux host whose `net.ipv4.tcp_slow_start_after_idle` is nonzero, the Linux default: a warning naming the locators when a per-run gateway's locators include `tcp/`, and an info line when the egress goes through the shared `cerulion-netd` session, which every networked run registers with whether or not a remote peer subscribes. On such a host the congestion window of an idle TCP connection decays toward its initial size, so each large message sent at a low rate pays a few extra round trips, a cost that grows with the path's round-trip time; measured over a 31 ms wide-area path, a 301 KB message once per second took 164.8 ms p50 on `tcp/` and 79.3 ms on `quic/`. The line names both fixes: the sysctl set to 0 on the sending host, or `quic/` on both ends. A run with no egress, a gateway with no `tcp/` locator, and any other host log nothing. - Usage telemetry. The `cerulion` CLI sends usage telemetry, on by default, when the build carries a telemetry key; `cerulion telemetry status` says whether this build has one. A source build carries none, `POSTHOG_API_KEY` supplies one to any build, and `POSTHOG_HOST` changes the destination (https only). The first command that could send prints a notice on stderr and sends nothing; later commands send. To turn it off, use `cerulion telemetry off` (saved in `${CERULION_HOME:-~/.cerulion}/telemetry.json`), `DO_NOT_TRACK=1` (or `true`) or `CERULION_TELEMETRY=0`; `DO_NOT_TRACK` wins over `CERULION_TELEMETRY`, which wins over the file. `cerulion telemetry status` names the deciding setting, `cerulion telemetry on` turns it back on, and the verb needs no sign-in. See `docs/telemetry.md`. - What the telemetry sends: one `cli_command_run` per command (`verb`, `subverb`, `exit_code`, `duration_bucket`, and `install_method` of `install.sh`, `deb` or `brew`, read from a marker the installer leaves: `.cerulion-provenance.json` beside the programs, or `share/cerulion/install.json` for the package and formula). Also `graph_run_started`/`graph_run_completed`, `node_build_completed`, `bag_record_completed`/`bag_record_failed`, `bag_replay_completed`, `resim_completed`, `ros2_bridge_started`, `connect_session_completed` and `cli_login_completed`, which carry only flags, counts, exit codes and size or duration buckets. Every event also carries `surface`, `env` (`prod` or `dev`) and `app_version`. Never sent: arguments, paths, names, URLs, emails or message contents; a value that looks like one, or is over 128 characters, is dropped. Events go to PostHog in one batch at exit, waiting at most 300 ms; on a slow network they are dropped, never stored. `telemetry`, `completions`, `bagd` and internal subprocesses send nothing. - CLI telemetry events carry your Cerulion account id once the machine has signed in to a hosted account, and otherwise a random `anon:` kept in `telemetry.json`. A machine's first `cerulion login` sends that random id with the sign-in request so earlier events join the account, and the CLI sends PostHog one alias event that links the two ids. A different account signing in replaces it, and deleting `telemetry.json` resets the id and the notice. - `cerulion graph levels` ends with a chains block: the trigger edges that could run as one fused chain inside one process, and for every other consumer edge the reason it stays queued (`fan-out`, `separate-processes` and others). Each `graph run` writes its own census under `chains` in `run.json`. By default the runtime fuses no chain, so runs are unchanged. - `cerulion bag play --resim all` resumes a free-run bag that begins mid-run, such as a Flashback capture, when the recording holds one worker process. It restores from that bag's checkpoint and periodic firing deadlines. A mid-run free-run bag with several worker processes is still refused with exit 2; the message names the worker count and says to re-execute the bag from its start or capture a graph that runs in one process group. - `cerulion_core` gains an opt-in `local-transport` Cargo feature for an app whose publishers, subscribers and gateway all run in one process, such as an Android app that cannot use cross-process shared memory. Publish and receive stay zero-copy inside the process, and a gateway still serves topics over TCP. With the feature on, `process_groups:`, cross-process initialization and native cdylib nodes are refused. See `docs/android.md`. - Cerulion builds and runs on Android, API 30 or newer, arm64-v8a and x86_64, cross-built with cargo-ndk. That covers shared memory publish and subscribe between processes, and `cerulion graph run`, `topic`, `bag` and `cerulion-netd` from `adb shell`, with node libraries cross-built on a host. `crates/cerulion_android` embeds the runtime in an app. An Android gateway announces itself over mDNS and refuses LAN topic requests by default: `CERULION_LAN_ACCESS=open` (or the app's `lan_access` key) serves them, and every other platform defaults to `paired` as well. See `docs/android.md`. - `rmw_cerulion` builds from source and runs on ROS 2 Foxy, Galactic, Humble and Lyrical as well as Jazzy. CI builds it against each distro's own headers, runs its test suite and exchanges messages with a real rclpy node in both directions; a manually started emulated arm64 Foxy job builds it and runs the rclpy exchange. The Linux release archives and the Debian package carry the Jazzy library, and each release also publishes the Lyrical library, for x86_64 and arm64 Linux, as separate `cerulion-rmw-lyrical--.tar.gz` tarballs. On Foxy and Galactic, the C++ (rclcpp) path carries a message with a `bool[]` member too (see Fixed). - An `rmw_cerulion` library built for Kilted, Lyrical or Rolling refuses to load, at `rmw_init` and the init-options calls, in a process that sets no `ROS_DISTRO`, because those distros lay out their structs differently from Jazzy and earlier. The error names the distro it was built for and the setup file to source (`source /opt/ros//setup.bash`, or both files for the Lyrical and Rolling pair). A library built for Jazzy or earlier loads as before. - On ROS 2 Lyrical, `rmw_cerulion` publishes a message whose `rosidl::Buffer` field lives on a non-CPU backend (for example `cuda`, as in GPU camera pipelines) by copying it to host memory. Each topic logs a warning on its first copy and at every power of ten. A subscription whose `acceptable_buffer_backends` names a backend the rmw lacks is created with one warning and receives CPU data; only a malformed list fails. - `cerulion_core::TransportManager::topic_publisher_nodes` lists a topic's publishers with the name of the iceoryx2 node each runs under. A publisher's id is the `origin` of every frame it commits, so a reader can name the node a frame came from. - `cerulion_cli_engine::bag_cmd::PlaySummary` gains `scheduled_advance_ns`, how long a played bag should have taken measured from its first frame: the longest played channel's scheduled advance at the given `--rate`, with none of the wall time spent before the first frame. `scheduled_span_ns` is unchanged and equals the run origin plus this value. - `cargo add cerulion` is now the whole dependency list for writing a node. The new `cerulion` crate re-exports the runtime, the node macros and the ROS 2 message types at a single version, as `cerulion::prelude`, `cerulion::msgs`, `cerulion::core` and `cerulion::macros`. - The status of an Android app's embedded runtime now lists linked nodes whose tick panicked. A panic is contained: that node stops and does not run again, the rest of the graph keeps running and `state` stays `running`, but status used to show no sign of the dead node. The status JSON gains `node_failures`, a list in graph order of `{ "node_id", "message" }` objects (the node's graph id and its first panic message), and `[]` when no node panicked. A node is listed once, and a node that returns an error from its tick is not listed. The list is read live while the graph runs and stays readable after `stop`; the next `start` whose config parses and passes its path checks clears it, also when that start then fails. In Rust, `cerulion_android::Status` gains `node_failures` (`NodeFailures`, a list of `NodeFailure`), and `cerulion_core` gains `GraphRuntime::node_tick_panic_records()` and `NodeTickPanicRecords`. See `docs/android.md`, `Graph nodes in an app`. - On an Android device, the embedded runtime's `tracing` lines and those of every node linked into the app library now go to logcat under the tag `Cerulion`, so a node registration error, a failed mDNS beacon or a teardown warning is visible with `adb logcat -s Cerulion`. A line reads `: =...`, and the levels map to logcat priorities `E`, `W`, `I`, `D` and `V`. A new start key, `log_level` (`"error"`, `"warn"`, `"info"` as the default, `"debug"` or `"trace"`), sets the lowest level written; any other value or a misspelled key is rejected with error code 3. Each start sets the level again, so a start without the key returns to `info`, and a start that fails after it set the level puts the previous level back. A release build of the app library compiles out `debug` and `trace` lines, whatever `log_level` says. `embed_nodes!` installs the logcat subscriber when Java loads the library, and `CerulionRuntime.init` installs it when the load did not. To keep your own global `tracing` subscriber, set it in your own `JNI_OnLoad` before calling `cerulion_android::nodes::register`; the runtime then writes nothing to logcat and `log_level` has no effect. A line logged through the `log` crate does not reach logcat. See `docs/android.md`, `Logs in logcat`. - An Android app can read a node's output without a sink node of its own. List the topics in the start config under `subscribe`, an array of `{ "topic", "schema", "depth" }` entries, then call `CerulionRuntime.poll(topic, out)`. It takes the oldest message off that topic's queue without waiting and appends it to a `StringBuilder` as the same JSON object text `publish` takes, for example `{"x":1.5,"y":0.0,"z":2.0}`. It returns `CerulionRuntime.OK` after appending (only `OK` appends) or `EMPTY` (15) when the queue holds no message; `BUSY` means a start, a stop or another publish or poll is in flight, so retry; `DECODE` (14) means the message did not decode, and it was still taken, so the next poll reads the one after it; `RECEIVE` (16) means the transport refused to create or read a subscription. `depth` defaults to 10 and must be 1 to 16; when a queue is full the oldest message is dropped. A schema with a nested message or an array other than bytes, a duplicate `subscribe` topic, and a topic the app or the graph produces under another schema are refused with error code 3, and a start logs a warning for a `subscribe` topic that is neither an app `publish` topic nor a graph output. `poll` also reads a run whose graph `finished`, until `stop`, so the last outputs are not lost. The status JSON gains `subscribed`, with `polled`, `dropped` and `undecodable` counts per topic. A non-finite float reads as `null`. See `docs/android.md`. - An Android app can keep some topics on the device while it opens a desk connection. Under `"lan_access": "open"` the gateway sends every topic the app serves; a start config can now list `egress`, an array of canonical topics, and a LAN peer receives only those. A demand for any other topic is answered `refused` and no frame of it leaves the device. `[]` sends no topic, and without the key an `open` gateway sends every topic as before. Under `"paired"` nothing is sent either way. Each listed topic must be a graph output or an app `publish` topic; a non-canonical, reserved, duplicate or unknown topic, or a value that is not an array of strings (`null` included), is refused with error code 3, so a bad list never means send everything. The catalog still names every topic the app serves with its schema and liveness, so a desk can see that a withheld topic exists but cannot receive it. A start with `egress` and an empty `listen` and `connect` builds no gateway, so the list has no effect and the start logs a warning. See `docs/android.md`, `Choose which topics leave the device`. - An Android app can dial a desk instead of waiting to be dialed. The new `connect` start key takes an array of `tcp/:` locators, the mirror of `listen`, for a network that drops multicast or connections into the device. A desk that is not listening yet does not fail the start: the app dials it again in the background. A locator that is not a well-formed `tcp/` locator (`quic/` and `tls/` included), a duplicate, or a value that is not an array of strings fails the start with error code 3. A `connect`-only start builds the gateway, so `lan_access`, `egress` and `ingress` apply to the desk the app dials just as they do to a desk that dials the app, and `mdns` raises no beacon for a `connect` locator. Like `listen`, `connect` is fixed for the process lifetime by the first start: a later start with different locators returns `BAD_STATE`, so restart the app process to change them. For a desk on USB, `docs/android.md` also documents a loopback `listen` with `adb forward` (the app stays off the Wi-Fi network and raises no beacon) and `adb reverse` with `connect`, and it states that Android passes multicast to the app only while it holds a `WifiManager.MulticastLock` (permission `android.permission.CHANGE_WIFI_MULTICAST_STATE`). The sample app reads a `connect` launch intent extra in debuggable builds only. See `docs/android.md`. - An Android app can let a LAN peer publish into the graph. A new start key `ingress` is an array of canonical topics (default `[]`); under `"lan_access": "open"` the gateway re-injects frames a desk or another device publishes on those topics into the graph inputs that read them with an absolute `source:`, and drops a frame whose schema hash differs from the hash those inputs declare (the first drop of a series logs a warning, and drops are counted in `schema_mismatch_drops`). The desk sends the topic from a graph that lists it under `network: egress:`, and the app demands it from the desk as a graph run does. Each topic must be read by a graph input that declares its schema and must be neither a graph output nor a publish topic. A non-canonical, reserved prefix or duplicate topic, a value that is not an array of strings (`null` included), a topic no graph input reads, or a topic with another writer fails the start with error code 3 and names the topic. A schema no input declares, or inputs that disagree on the schema, fails it with error code 5. Under `"paired"`, and in a start with no `listen` or `connect`, the gateway opens no ingress and the start logs a warning. A stop releases each ingress bridge, so the next start can register the topic again. Ingress carries no sender identity: under `open`, any host that reaches the gateway can publish into every listed topic, so keep the list to the topics a desk must write, and keep a USB desk on the loopback listener. A recording does not hold the frames of an `ingress` topic. `cerulion_core::graph::resolve_ingress_schema_hash` is now public, and a gateway in `cerulion_core` adds its ingress topics to the transport manager's shared demand set, so an app that stops and starts again demands the new run's topics and not the first run's. See `docs/android.md`. - Android app frames are stamped from the runtime clock, and a caller can supply the stamp. Each frame `CerulionRuntime.publish` sends now takes its wire stamp from the same clock the graph and its nodes use (nanoseconds of `CLOCK_MONOTONIC`, the clock `System.nanoTime()` reads on Android; `SystemClock.elapsedRealtimeNanos()` is another clock and also counts deep sleep), and a recording keeps that stamp as the log time of each message. New `CerulionRuntime.publishStamped(String topic, String json, long stampNs)` stamps a frame with the time an event happened, for example a tap read with `System.nanoTime()` when it lands. A stamp in the past is taken as is. A negative stamp returns `INVALID_ARGUMENT` (3) at once. Otherwise the call checks the runtime state and the topic as `publish` does, with the same codes, and then a stamp more than one second ahead of the runtime clock returns `INVALID_ARGUMENT` (3) before the message is read. A refused call sends nothing and uses no sequence number. In Rust, `EmbeddedRuntime::publish_stamped` and the constant `MAX_PUBLISH_STAMP_LEAD_NS` are new. See `docs/android.md`. - `CerulionRuntime.publish` and `publishStamped` now take nested messages and arrays of every schema type, for example a `geometry_msgs/PoseStamped` with its `std_msgs/Header` or a `geometry_msgs/Twist`. A publish reads the JSON with the same reader `cerulion` uses for a message typed as text, so the app and the command line share one set of encode rules, and a field the JSON leaves out is written as its zero value at any depth. The top-level value must still be a JSON object, unknown fields are refused, and the text must be strict JSON: comments, `NaN`, unquoted keys, a number past the `float64` range and duplicate keys are refused, and a bare `-0` reads as `0` (write `-0.0` for a negative zero float). A message that passes `max_payload_bytes` is refused while it is built, so a short text that leaves out many fields cannot build a large message. A bad value returns `ENCODE` (9) with a message that names the field path, such as `pose.position.x: expected float64, got string`, and sends nothing; text that is not JSON reads `invalid publish JSON: ...`. Publish allocates for each message, so it stays the app's convenience path. `poll` still reads flat schemas only. See `docs/android.md` and `docs/user-api.md`. - `cerulion_remoted` can now serve the paired remote plane from a host process, not only as the `cerulion-remoted` daemon. The host builds a `RemotePlane` with a state root, a network daemon control socket and a relay setting, passes its own keys through the `KeyProvider` trait (`KeyFiles` is the daemon's two key files), calls `bind` to load the trust state and bind the iroh endpoint, then `serve` with a shutdown signal; `BoundPlane` reports `endpoint_id` and `bound_sockets`. The daemon serves through the same entry and keeps its behavior, files and verbs. A plane hosted this way answers `restart` and `engage-estop` with `unsupported_host`, names itself `cerulion-remote-plane` in the handshake, and does not read `--network` or `CERULION_NETWORK`. See `docs/remote_plane.md`. - `cerulion-remoted` and a plane hosted in an app now refuse an empty trust-store MAC key while a trust store or device index exists, because an empty key verifies nothing and cannot persist a claim or a pairing. `cerulion-remoted` used to load with an empty key; it now refuses to start. When the key comes from a file, the error names the key file (`trust_store.mac_key` under `remoted/` in the state root); restore this device's key into it, or stream it into the app's files directory again. A host with its own `KeyProvider` gets the same refusal, and its error says it has no key file to name. See `docs/internals/remote-access.md`. - An Android app can host the paired remote plane in its own process, so a paired desk reads the app's catalog, schemas and topics from another network while `lan_access` stays `paired`. The plane lives in the new crate `cerulion_android_remote` because it links iroh; the app's runtime crate lists its host in `embed_nodes!` as `remote: cerulion_android_remote::Host,` (the node list may then be empty), and an app that does not do this links no iroh. Turn it on with a `remote` start key: `{ "enabled": true, "relay": "public" | "disabled" | [urls], "state_dir": "remote" }`. `enabled` is required, `relay` defaults to `"public"` (development only, run your own relays for production), and `state_dir` is a relative path inside the app files directory. The plane reads `device_key`, `trust_store.mac_key` and `trust_store` from `remoted/` under `state_dir` and never creates them: a start without one of them, or with one that does not verify, fails with `REMOTE_NOT_PROVISIONED` (17), runs nothing and serves nothing, so provision them into the app's private files directory first. `device_index.json` beside them is optional; without it no desk is paired. Any other plane failure is `REMOTE` (18): no host linked, a relay URL that does not parse, a second runtime in the process while one plane serves, or a plane that stops on its own. `status` gains `remote`, `{ "endpoint_id", "bound_sockets" }` while it serves and `null` otherwise, and `CerulionRuntime` gains the constants `REMOTE_NOT_PROVISIONED` and `REMOTE`. A paired desk can read every topic of the app's transport (`egress` limits LAN peers only) and cannot publish into the app, and the plane refuses `restart` and `engage-estop`. If a stop does not close the plane within 5 seconds, `status` reports `failed` with code 18 and every later start with `remote.enabled` fails with 18 until the app process restarts. See `docs/android.md`, `Host the paired remote plane`. - Each GitHub release attaches the `cerulion_android` Java facade as `cerulion-android-java-.tar.gz`: the crate's `java/` tree and its `LICENSE` under one versioned directory, with its checksum in the release's `SHA256SUMS`. An app adds that `java/` directory to its Gradle sources without reading a Cargo checkout. `tools/scripts/package_android_java.py` rebuilds the same archive contents from the tagged commit. See `docs/android.md`, `Graph nodes in an app`. - `cerulion topic pub`, `cerulion service call` and `cerulion topic snapshot` publish a message given as JSON or YAML text, call a service once, and save the newest frame of a camera topic as a JPEG. `topic pub ` fills each field the message leaves out with its `.msg` default or zero, publishes `--times` frames at `--rate` and prints one `published:` line; `service call [REQUEST]` speaks the protocol ROS 2 nodes on `rmw_cerulion` serve and prints the response as one JSON document; `topic snapshot ` reads a `sensor_msgs/Image` in `yuv422_yuy2`, `rgb8`, `bgr8`, `rgba8`, `bgra8` or `mono8`, or a `sensor_msgs/CompressedImage` holding a JPEG. With `--robot NAME` each runs on a paired robot instead, with the same output and exit codes: the desk runs `cerulion-connectd act`, which dials the robot's ops plane with this machine's paired device key and calls one of four new `cerulion-remoted` ops verbs. `topic-publish` and `service-call` need the teleop capability and the operator role and are refused while the robot's e-stop is engaged; a running publish stops at its next frame when it engages, and each frame and each request is sent only while the e-stop reads clear. `topic-snapshot` and `topic-echo-once` need the observe capability. The verbs resolve types from the built-in ROS 2 messages and the `.msg`/`.srv` store under `CERULION_REMOTED_SCHEMAS_DIR`. Only the `cerulion-remoted` daemon serves them: a process that hosts the remote plane as a library refuses each with `unsupported_host`. While `CERULION_NETWORK` engages the kill-switch, `--robot` is refused with exit 2 before anything is sent. The message codec, the schema store, the service client, the publish loop and the snapshot are the new `cerulion_msgio` crate, which the CLI and `cerulion-remoted` share. `cerulion_core` gains `FullQueueSend`, what a send does at a subscriber whose queue is full, and three constructors that take it, `TransportManager::create_ingress_publisher_with`, `create_ingress_injector_with` and `create_service_client_with`, whose `FullQueueSend::Discard` skips a full queue instead of waiting on it; `IngressInjector::subscriber_count`; `ServiceClient::server_count`, `ServiceClient::send_request_counted`, which also returns how many servers the request reached, and `ServiceClient::start_sequence_at`; and a public `cerulion_core::dynamic::find_anchor_or_alias`, which finds a YAML anchor or alias in message text. A `.msg` or `.srv` type in a store or workspace that names a nested type of its own package without the package (`Item` in a `demo_msgs` file) now hashes it package-qualified, as `demo_msgs/Item`, as ROS 2 and `rmw_cerulion` hash it, so bags recorded by, and peers running, an earlier cerulion report a hash mismatch for such a type. Built-in types are unaffected. - An ops `engage-estop` on `cerulion-remoted` also sends an `estop` tool call to the robot's `cerulion-rcpd`, so rcpd closes its own e-stop latch and refuses each mutating tool call it holds when the `estop` reaches it and has not yet published, including calls sent over `cerulion rcp` before the engage, and the graph receives rcpd's e-stop frame. It goes over the rcp plane's link (`--rcp-addr`, `--rcp-token-file`) on an MCP session of its own, with the reason `the robot's ops e-stop was engaged (engage-estop)` (the new public constant `cerulion_remoted::rcp::OPS_ESTOP_REASON`), and rcpd receipts every attempt under the identity of the first engager since rcpd last answered one. `engage-estop` answers without waiting for it, starts it before it writes its own log line, and the ops e-stop stays engaged whatever happens to it. Each attempt waits for each response head for `--rcp-head-timeout-ms` or 1 s, whichever is longer. The `estop` reaches rcpd once rcpd answers that its latch closed: while rcpd is not reachable, the token file fails its check or rcpd answers with an error, `cerulion-remoted` sends it again, waiting 100 ms after the first failure, twice as long after each further one and at most 2 s, and logs the first failure and the 10th, 100th and so on at warn and the others at debug. One such delivery runs at a time: an `engage-estop` while one runs starts none, since the one running keeps sending, and one that comes after the attempt rcpd answers began makes it send the `estop` once more. A delivery that ends before rcpd answers, at a stop by Ctrl-C or SIGTERM, a panic or a dropped runtime, logs at error, and at such a stop an attempt rcpd issued an MCP session first deletes it; a `cerulion-remoted` that is killed, crashes, or is ended by its hard-exit deadline or a second stop signal may end without that line. One that ends, on a panic or a dropped runtime, while it deletes the MCP session of an attempt rcpd answered that its latch closed logs nothing, unless an `engage-estop` came after that attempt began: then it logs at error that the `estop` it owed that `engage-estop` was not sent, and the next `engage-estop` sends it. `cerulion_remoted` now depends on `cerulion_wireclient`, for the sanitizer it applies to rcpd's text in its failure lines. To recover, as after an rcp `estop`, restart `cerulion-remoted`, then clear rcpd's latch with `estop_clear` under `limits.estop_clear: agent`, or delete `.estop` and restart rcpd. - The ops authorizer of `cerulion-remoted` classifies two e-stop verbs ahead of their handlers. `clear-estop` is admitted for the operator and owner roles and refused to a cloud device whether the robot's allow-from-cloud switch is on or off; while the switch is on the refusal reads `verb 'clear-estop' refused: the e-stop is cleared only from a device that is not a cloud principal`. `estop-status` is admitted with the observe capability. A refusal is receipted `Denied`, and until a handler is registered an admitted call answers `unknown_verb`. - `cerulion_remoted::shutdown::ShutdownStage` is the stage `serve_planes` runs when its accept loop stops, after it drops its shutdown future: each `ShutdownParticipant` registered on `OpsServing::shutdown_stage` is driven to settlement in order while the ops receipt log is alive, and after a stop signal the endpoint too. One that fails, panics or is cancelled is returned as `RemotedError::Shutdown`. ### Fixed - A graph that imports topics from another robot keeps using the authenticated trust it saved when the account service cannot refresh revocations or the sign-in has expired: it logs a counted warning and checks each topic's source as before. - A desk's requests to robots name only the robots it selected or already reads from, not every robot on the account, so an account with many robots no longer overflows the request frame. - On Android, account requests verify the server against the system certificate roots without a Java context, and an account client that fails to set up leaves local topic reads working. - A session refresh that succeeds while the account store is briefly busy still saves its new tokens, or revokes them when you signed out meanwhile, within a bounded wait of its own. - A robot that starts with no reads of its own from other robots skips reader migration, so a clean start logs no migration failure. Reads restored after an interrupted first connection stay active, and a read that cannot be restored is named in a warning and recovers on its own. - A remote schema read sees a producer that registered after the reader connected, and creates no temporary service on the robot for a topic that has carried no data. A topic whose privacy changes while its metadata is pending is still refused. - Local-only graph and node runs exclude their topics, schemas and run metadata from every remote serving plane, including an already running open gateway. An enabled `network:` block's egress list is enforced for that producing run by other daemons too. - `cerulion ros2 run` no longer prints a false "another allocator won malloc" line for the Python launcher and rclpy nodes when the heap hook owns `malloc`. The hook stays active with non-PIE Python interpreters, including Python 3.8 on Ubuntu 20.04 and Python 3.12 in ROS 2 Jazzy; an earlier foreign allocator still reports a loss and unbounded borrowing copies. - `cerulion bag play --resim` runs on a private shared-memory namespace of its own, so nothing attached to local shared memory or the network sees its frames. It used to run on the shared namespace a live `cerulion graph run` uses, so on the same machine a live graph's inputs, actuators included, `cerulion bag record`, `cerulion topic echo`, a `cerulion-netd` egressing a topic and a `cerulion-remoted` streaming one to a paired desk received the frames the resim re-executed and the recorded external inputs it re-injected, under the recording's topic names. The private namespace covers Cerulion topic frames only: a re-executed node that drives hardware or another network directly (for example a node that opens a robot's own command channel in `init`) still does so during a resim, so run a resim of such a node only where its devices are safe to drive or disconnected. A resim runs on one of 256 namespace slots, under the iceoryx2 prefix `cer_resim__` with the slot in eight hex digits: it takes the lowest slot whose lock file (`cer_resim_.lock`, in `/dev/shm` on Linux and `/tmp` on macOS) it can lock exclusively and whose namespace holds no node once the dead ones are removed, and holds the lock until it exits. Before it starts, within the 2 s startup sweep budget, it removes what earlier resims left in that slot's namespace: their iceoryx2 nodes and the services a killed resim still held, then every shared-memory segment named with the slot's prefix, the namespace's iceoryx2 management segment included. A finished resim leaves its node and that segment for the next resim on the slot. A slot whose lock file cannot be opened or locked, or whose namespace does not come back clean (for example a node another user's resim left there, which this user cannot inspect), is passed over with a warning naming the slot and the reason, and keeps its files. So the files resims leave belong to no more namespaces than the most resims that ran at once plus the slots passed over; `cerulion clean` does not remove them. With every slot taken or passed over it fails with exit 5, publishing nothing, as it does when its process transport is already running on another namespace; the error names the first lock file it could not open or lock and the last slot whose namespace was refused, with the reason. Its frames, verdicts and reports are unchanged: nothing they hold names the namespace or the slot. Plain `cerulion bag play` still publishes onto the shared namespace, as documented. - A `cerulion graph run --record` shorter than one checkpoint interval (15 s by default) no longer ends with the warning `bagd checkpoint coverage INCOMPLETE ... some node ended the run with NO anchor`. The recorder opened each worker's node-state ring at its current write position when it found the ring, so the step-0 checkpoint each worker writes just before that was never in the bag. A recorder that is running when the graph starts now reads each ring from its start, as it already did for a ring named on its command line, so the bag keeps every node's step-0 checkpoint. A `cerulion bag record --run` that attaches to a graph already running still starts at the current position and still warns when a node has no checkpoint in its bag. - `cerulion bag play --resim` of a multi-process recording no longer warns `absolute source is inside this graph's own prefix namespace but matches no declared output` about a correct edge between two processes, such as the obstacle avoidance starter's `safety_controller` input fed by `laser_scanner`. The replay re-executes each recorded process against its own part of the graph and now tells it which topics the other processes produce, as `graph run` already tells each worker. A source no process produces still warns. - A node library no longer prints `cerulion cdylib tracing: node-side logs -> stderr (filter: ...)` on every run when `RUST_LOG` is set to a filter that parses, such as `RUST_LOG=warn`, which printed it once per node library per process (four times on the obstacle avoidance starter's `graph run`). The line now prints only when `RUST_LOG` fails to parse and the node library falls back to `info`, the one case where its filter differs from the one you wrote. - A `block` producer whose consumer runs in another process is no longer held for good by a frame the consumer already read. The producer counted each frame on the edge's shared credit word after the frame was sent, and a consumer that read the frame and recorded its drain before that count found the word at zero, so the late count left the word one frame above an empty queue. At `depth = 1` the producer then deferred every tick, and only its stall warning, which named the consumer, said anything was wrong. The producer now counts a frame before the send makes it visible, on every publish path (a node's output, `publish_raw`, `send_raw_loan` and the overflow re-send), and takes the count back when the send fails. A consumer's drain that removes more frames than the word counts, which means some of them were never counted (native history to a late joiner, or a writer outside the graph on a `multi_publisher_topics` topic), now logs a warning naming the topic, `block credit drain removed frames its word never counted`, at the start of a run of such drains. The rest of the run is counted at debug level, except that the drain that takes the running total to each power of ten logs a second warning, `block credit drains still remove frames their word never counted`. A run ends only after a stretch of consecutive drains the word counted in full, and each end doubles the stretch the next run needs, up to 65536 drains, so an outside writer whose frames interleave with the producer's at most a few thousand drains apart logs only a handful of warnings, a writer whose frames are 65536 or more drains apart warns on each of them, and the first such drain after 65536 counted drains in a row warns again. The end of a run with counted repeats logs one line saying drains match the count again. This needs node ABI 32 (see Changed). - `cerulion-remoted` stops gracefully on SIGTERM, which a service manager and `kill` send, as it does on Ctrl-C: it logs the signal, stops accepting connections, closes its endpoint and exits 0. Before, a SIGTERM ended the process at once, with no log line and none of that cleanup. The stop is bounded by `CERULION_REMOTED_HARD_EXIT_MS` (default 30000 ms), past which it exits with status 4, and a second Ctrl-C or SIGTERM during the stop also exits with status 4; either waits at most 100 ms for its queued log lines first. A stop that starts because the accept loop stopped on its own is bounded by the same deadline and exits 0 when it finishes, and the first Ctrl-C or SIGTERM after it exits with status 4. A shutdown participant that fails, panics or is cancelled makes the daemon exit 3; `cerulion-remoted` registers none of its own. When `cerulion-netd`'s robot supervisor stops `cerulion-remoted` (a netd stop, the idle stop after the last serving registration, or a supervisor error), it sends SIGTERM and sends SIGKILL only if `cerulion-remoted` has not exited within `CERULION_REMOTED_HARD_EXIT_MS` plus 500 ms. - `cerulion-remoted` no longer holds an e-stop on a blocked log write. With stderr full (a full pipe, a stalled journald), each thread that logged waited in its write, so an `estop` over `cerulion rcp` could wait before it reached `cerulion-rcpd`, an ops `engage-estop` could wait to answer and to send its retries, and a graceful stop could wait until the hard-exit deadline. The daemon now writes its log lines from a thread of its own, through a queue of at most 4096 lines and 1 MiB: a line that does not fit, or whose write fails, is dropped and counted, and no `tracing` line holds the thread that logs it; the iceoryx2 console logger and a panic message still write to stderr directly. Once stderr takes lines again, a warning names how many were dropped and, when more than one was, an info line says the log caught up. The count since the daemon started is the new `log_lines_dropped` field of the `cerulion/wire/2` `status` reply, absent from a host that embeds the remote plane; it leaves out the writer's own report lines and the lines an exit discards. Each exit waits at most 100 ms for the lines still queued, and counts those it discards in one error line. In Rust, `cerulion_wireclient::protocol::StatusReply` gains the public field `log_lines_dropped`, so code that builds one with a struct literal names it, and `cerulion_remoted` gains the public module `log_writer` and the same field on its `StatusReply`. - The ops verb `restart` on `cerulion-remoted` is refused while the robot's e-stop is engaged or an engage is waiting for the control lease, as `topic-publish` and `service-call` are: it answers the verb error `unavailable: the robot's e-stop is engaged, so restart is refused` and stops and starts nothing. A device with the operator role could restart a graph, and so run its nodes again, while the e-stop was engaged. `restart` reads the e-stop before it reads its arguments, so the refusal reads the same on every host, and again after it stops the graph and before it starts it: an engage while the graph stops means the start command does not run, with `unavailable: the robot's e-stop was engaged during the restart, so the graph was not started again after its stop`. `cerud` gains `RestartStep`, the `RestartGate` trait and `RestartVerb::with_gate`, which ask a gate before each step; `RestartVerb::new` and `RestartVerb::with_runner` build no gate. `cerulion_remoted` gains `EstopLease::holds`, the e-stop read that the act verbs' refusal, `restart` and the rcp plane's Act check share, and the error text `ops::RESTART_STOPPED_NOT_STARTED`. `EstopLease::holds` reads the engage count again under the control lease's lock, so the act verbs' refusal and the rcp plane's Act check no longer miss an engage that counts itself in while they wait for the lock. A process that hosts the remote plane as a library still answers `restart` with `unsupported_host`. See `docs/rcp.md` and `docs/remote_plane.md`. - `cerulion doctor`'s `cpu.governor` reported `cpuinfo_max_freq`, the hardware maximum, as the CPU's maximum clock, which hides the cap a power mode sets, such as a Jetson nvpmodel mode. It now reports each CPU cluster's governor, its clock now and the limits in force (`scaling_min_freq` and `scaling_max_freq`) beside the hardware range, says what holds a clock floor up (the power mode, `scaling_min_freq`, the `performance` governor, or a source it cannot tell on a Jetson whose power mode it cannot read), and names the latency cluster, the cluster whose floor holds the highest clock. On a Jetson it also reports the nvpmodel mode from `/var/lib/nvpmodel/status` and warns when that mode is one `/etc/nvpmodel.conf` does not define, as after an L4T upgrade that rewrites the file, since the next boot does not apply it. It reads files only and changes no clock. In `--json`, `max_freq_khz` stays the hardware maximum; the new readings are `scaling_max_freq_khz`, the per-cluster `clusters`, `cluster_governors`, `cluster_min_khz`, `cluster_max_khz`, `cluster_cur_khz`, `cluster_hw_min_khz`, `cluster_hw_max_khz` and `cluster_floors` (one value per cluster, joined with `;`, with `-` for a clock not read and `unknown` for a governor not read; a floor is `none`, `nvpmodel`, `scaling_min_freq`, `performance`, `raised` or `offline`), `latency_cluster` (the CPUs of the cluster or clusters tied at the highest floor, absent when no cluster has a floor, or when more than one cluster is online and every online cluster is tied there), and `nvpmodel_mode`, `nvpmodel_mode_name` and `nvpmodel_mode_defined`. - An Android app now sees a remote plane that did not stop. `status.remote` keeps its `endpoint_id` and `bound_sockets` and adds `stop_error`, the reason the stop failed. Before, `status.remote` read `null` after a restart, a stop or a teardown after a panic whose plane did not close, so remote access was down without a sign. A restart still starts its graph. Every later start in that process, also of a new runtime and with or without `remote.enabled`, starts its graph and names the stuck plane in `status.remote`. A start with `remote.enabled` runs with remote off: it binds no plane and adds `off_reason`, which says why remote is off. Before, such a start failed with code 18. Remote off applies once a stop has failed: a start while the stop of another runtime still runs fails with code 18 and can try again. Every other bind failure keeps its code. Remote comes back after the app process restarts. See `docs/android.md`, `Host the paired remote plane`. - Under `CERULION_NETWORK=off`, a machine that never signed in no longer meets the login gate before a verb that reaches a robot: `topic pub`, `topic snapshot` and `service call` with `--robot`, and `viz --robot`, print their kill-switch refusal with its exit code (2, 2, 2 and 1), where the gate started a device-code sign-in against the account service at a terminal and exited 7 anywhere else. `cerulion connect`, on exactly `off` in `--network` or `CERULION_NETWORK`, prints its warning and exits 0 without resolving the robot or starting `cerulion-connectd`. The CLI sends no usage event, and shows no telemetry notice, while the switch is engaged, `--network off` is given (on `cerulion connect` and `cerulion rcp`, any `--network` value that is not blank), or `graph run` or `node run` runs with `--local`. `viz --robot` with no TOPIC is answered with its usage error before the switch and the gate. - Under `rmw_cerulion`, an rclcpp intra-process subscription received each message twice when the topic also had an rmw subscription in the same process. Every take now fills `rmw_message_info_t::publisher_gid` with the gid of the publisher that sent the message, the gid `rmw_get_gid_for_publisher` returns for it, so rclcpp drops the rmw copy of a message it already delivered in process. A take that `CERULION_RMW_REPLAY` serves from a delivery log still reports the all-zero gid. The gid is the id of the publisher's iceoryx2 port, which every message the port sends carries: a message still queued from a publisher that has since been destroyed reports that publisher's gid, and a message a native node or a network gateway publishes reports its own port's id, which no rmw publisher holds. - A Cerulion service server no longer keeps a reply publisher, with its shared memory, for every client it ever answered. It forgets a client whose reply topic has no subscriber left: when a request arrives from a client it holds nothing for, and when a response reaches no subscriber. A client in a process that crashed counts as present until iceoryx2 removes the dead process's ports. A client whose reply topic cannot be probed is kept, with a warning. `ServiceServer::tracked_client_count` reports how many clients the server tracks request sequences for, and `TransportManager::topic_subscriber_count_checked` returns a topic's subscriber count, or `None` when the probe fails. - `cerulion graph run --record --single-process` refuses a graph whose nodes read a topic no node in it publishes, naming each topic and its readers, before any recorder starts. Such a recording stamped its own frames from a clock that starts at zero while the outside publisher stamped boot-monotonic time, so `bag play --resim all` did not inject the outside frames at the steps that read them and `--verify` failed. Record such a graph without `--single-process`. - An idle `rmw_cerulion` subscriber on aarch64 Linux no longer holds a CPU core. `rmw_wait` parked every block of a call in `WFE`, which the scheduler counts as running, so on a Jetson Orin NX each idle subscription used about one core. It now parks only the first 200 µs block of each call and then sleeps in the kernel `ppoll` wait, as `CERULION_MONITOR_WAIT=1` already did on x86. - With `rmw_cerulion`, the first rmw endpoint to open a ROS topic no longer decides the history and buffer limits of that topic for the other rmw endpoints. A subscription or a shallower publisher that opened a topic first made a later TRANSIENT_LOCAL publisher with a deeper history fail to open, with `DoesNotSupportRequestedMinHistorySize` or `DoesNotSupportRequestedMinBufferSize`; an rclcpp action server could abort when its client started first. Every rmw publisher and subscription now creates a topic with the same history limit, taken from the message type: 16, or 12 for types whose slice ceiling is above 16 MiB (`sensor_msgs/Image`, `PointCloud2` and unlisted variable types), with a subscriber buffer ceiling that holds it. A TRANSIENT_LOCAL publisher's depth is clamped to that limit, and a KEEP_ALL one asks for and reports the limit. Two processes that set different `CERULION_RMW_SLICE_CEILING` overrides for one variable type across 16 MiB derive different limits, and the one with the limit of 12 can still refuse the other's TRANSIENT_LOCAL publisher of depth 13 to 16, or of KEEP_ALL history. A native (non-rmw) Cerulion process that creates a ROS topic first still creates it without the limit, so a later rmw TRANSIENT_LOCAL publisher can still be refused there. Each publisher's shared-memory segment gains that many slots, plus 6 per subscriber slot at a limit of 16 (none at 12), as reserved address space, which is demand-paged: at the 4 MiB tier a VOLATILE publisher reserves 3.1 GiB where it reserved 2.3 GiB, more than a 32-bit process's user address space; at the 16 MiB tier 12.3 to 13.3 GiB where it reserved 9.1 to 10.1 GiB; at a 32 MiB ceiling 18.5 to 20.5 GiB where it reserved 18.1 to 20.1 GiB; and at the 128 MiB tier 20 to 22 GiB where it reserved 18.5 to 20.5 GiB (the upper figures for types that support loaned takes). A TRANSIENT_LOCAL publisher whose depth was above 12 at the 128 MiB tier reserves less than before. `cerulion_core`'s `TopicServiceConfig` gains `create_history_floor`; `TransportManager` gains `create_subscriber_with_history_request`; and `transport::wire_header_attribute` gains `HISTORY_FLOOR_ATTRIBUTE_KEY`, `with_history_floor` and `history_is_floor`. - A Flashback capture of a live run no longer ends inside a step. A capture reads its trace and then its frames, so its trace could stop after a node's output was published and before the read that produced it was recorded; `bag play --resim --verify` then found no recorded read for the consult that produced that output and exited 6. The capture's trace now ends at the last step each rank's next boundary proves complete. A step that shares the final step's gating-clock target is removed with it, because their frames carry one stamp. Frames of the removed steps stay in the bag at their own step's target, after the covered range, and the capture manifest's `handoff.trace_end_cut` says how many steps were removed and why; a capture that leaves some rank with no complete step while another rank keeps one is not resimmable, and its reason names the rank; the `handoff.trace` sentence for a capture left with no trace now names the end cut too. A capture whose trace held only one step past its anchor is now not resimmable. `cerulion_bagd` gains `end_at_last_complete_step` and `CompleteSteps`, the rule the capture's trace end is cut by; in `cerulion_core::flashback::resim`, `ResimFacts` gains `ranks_without_a_kept_step` and `ResimGap` gains `RankWithoutCompleteStep`. - A variable-schema generated reader no longer panics on bytes at an odd address. `HeaderShm::from_bytes(image.header_bytes())` panicked with `misaligned source pointer (need align 4)` whenever the writer had placed the nested header after strings or arrays whose lengths left it off a 4-byte boundary (a 1 MiB `mono8` `sensor_msgs/Image`, for one), and the frame reaches other nodes unchanged over the network and through `bag play`. `Shm::from_bytes` of a message with variable fields now never panics: a source aligned to the schema's new `Shm::READ_ALIGN` (the larger of its fixed section's alignment and its widest primitive-array element, 4 for `std_msgs/Header`) that holds the fixed section and offset table is read in place as before, and any other source, misaligned or truncated, is read from an aligned copy, with missing bytes read as zero. `from_bytes` of a message with only fixed fields still panics on a misaligned or short source. `CerulionSubscriber::spin_view_until_seq` now refuses a frame too short for its schema or not 8-aligned, as the other receive paths do. - `cerulion bag play --resim` on a free-run bag no longer stands down the read-log-steered injection on a consumer whose recorded step took more frames than its input's declared depth (frames that arrived while it fired, pulled by the refill between fires). It used to report `queue_overflow` and fall back to the recorded-clock window, which could evict frames the recording delivered, hand the consumer nothing for several fires, and leave its reads off by the evicted frames. The replay now builds that input's queue as deep as the recorded schedule fills it, logs one line per raised input naming both depths, and reproduces the recorded reads. `queue_overflow` remains for a live producer's own connection over its depth and for a schedule deeper than replay will provision (16 frames on a `multi_publisher_topics` topic, the shared ceiling; 64 on any other, the deepest an input may declare). `cerulion_core` gains `GraphRuntime::build_with_schema_hashes_and_wiring` and `CrossProcessWiring::with_input_depth_floors`; in `cerulion_cli_engine::replay_inject`, `ConsumerEdge` gains `provisionable_depth` and `InjectionSchedule` gains `depth_raises` (`DepthRaise`). - A reliable egress topic is no longer dropped at the sender when the network link is congested. zenoh's default put discards a frame when its transmit queue stays full and still reports success, so the gateway counted such a frame as forwarded. Reliable topics now wait for the queue instead, for up to zenoh's `wait_before_close` (5 s by default), after which zenoh closes the link to that peer. Each egress topic has its own bounded send queue and sender thread, so a congested link holds up only the topics it carries, not the gateway's other links (closing LAN access waits for a put already under way). When a reliable topic's send queue is full the new frame is refused, counted, and a warning names the topic; a best-effort topic drops its oldest queued frame instead. An egress entry's new `send_queue: N` sets the bound, which otherwise is the depth of the gateway's tap on the topic. Every gateway logs every 10 s a warning for a topic that refused or failed frames (an info line for best-effort drops), and each topic's totals when it stops; the `cerulion-netd` gateway also reports the counters in its `status` reply. - On ROS 2 Lyrical, `rmw_cerulion` exports `rmw_get_clients_info_by_service` and `rmw_get_servers_info_by_service`, which report `RMW_RET_UNSUPPORTED`; `rmw_implementation` used to print a failed-to-resolve warning for each at startup. Builds for Jazzy and older distros, whose headers do not declare the two calls, still do not export them. - A replay of a recording in which a `Data` node's burst fired the per-step cap of 64 with a frame still queued now fires as the recording did. The live burst's refill after its last fire pops that frame and holds it unfired for the next step's first fire; the trace-driven replay now drives that refill too, so the next step's first fire serves the same frame, where it used to serve the frame after it and shift every later read of that input by one. The schedule re-derivation counts the carried frame, so such a recording no longer reports a false "FIFO pop count" fire-schedule divergence (exit 6 under `--verify`, a report line under a neutral `--resim`). The same holds for a throttled `Data` node whose refill popped a frame its throttle then left unfired. - The fire re-derivation of a free-run recording now catches a `consume = latest` node, read through a second subscriber, that stops firing on frames its queue still holds. Such a node owes a fire at a step whose trigger drain has counted, since the node's last fire, more frames than that fire's read took plus two per writer still delivering one, and the finding names the input, the step and the newest frame counted. The writers are the larger of the graph's publisher cap and the writers the read log names on the input: a topic opened on a service that already existed with more publisher slots than the graph asks for accepts publishers from outside the graph, so the cap alone does not bound them. Before the node's first fire in the pass, one queue of the input more (its declared depth per writer) is excused, and the `--report` JSON names that once per input as a judged note, a `rederivation_notes` entry of kind `latest_before_first_fire`, not a `stand_down`: a node's init can read its inputs before the recording starts its read log, and a resumed pass starts after reads its bag does not keep. A count past that queue is judged as one after a fire is, on a resumed pass too: from `trace_format` 8 on, the counts a bag that begins mid-run records before the trigger drain's first producer annotation are frames of the one writer whose run it began inside, counted as one writer more. A resumed pass that holds no fire of the node and no read its body made stands down by name once a count passes that queue (`latest_unfired_since_anchor`, which also prints a warning on stderr and changes no exit code): a node that returned `NodeError::Fatal` before the pass's anchor records exactly that, and so does a running node the scheduler never fired in the pass, since the bag records no stop and the anchor does not stamp each node's stopped state; a from-start pass re-executes the stop, and a node that fires or reads in its body anywhere in a resumed pass is still judged. A `--verify` replay of a one-rank bag this build recorded mid-run is refused before its first step when a single-writer read in it continues a writer run that began before the bag (`read_identity_absent`, exit 2), so on such a bag a neutral `--resim all` is the replay that reaches this rule. The rule stands down by name only where a count needs an excuse the bag cannot check: the input's topic has no graph producer, so nothing caps the frames still in delivery (`latest_writers_uncapped`); the read log does not name the writer of every frame counted since the node's last fire, so a publisher beyond the cap cannot be ruled out (`latest_writers_unnamed`, until the node's next fire; a bag below `trace_format` 8 names no writer on a topic with one graph producer, so there a count past the cap stands down, from the start of a recording or resumed; a count of more than one frame is named whole from `trace_format` 9, when its batch frames fit the read stage); or the node produces a topic a `block` input in its own rank reads, whose pre-fire check can hold the owed fire with no record (`latest_block_held`, which also stands down the fire a pop owes on one subscriber). On an older bag that does not record whether a `drop_oldest` input was read through one subscriber or two, a step that popped a frame and fired nothing stands down (`latest_drain_unrecorded`) instead of being judged as one subscriber. - Two instances of one node library in one process no longer wait on each other: the generated code held one library-wide lock across every tick, so instances on different threads ticked one at a time. Each instance now has its own lock. A rebuilt node cdylib has the per-instance lock; every node cdylib must be rebuilt for this release (see the node ABI entry under Changed). - The warning and the `cerulion logout` error for a `~/.cerulion/auth.json` that cannot be parsed names the file and the line and column of the error, and no longer repeats the parser's message, which could quote a token from the file. - iceoryx2 node ids no longer depend on uninitialized shared memory: the shared counter that goes into every node id now starts at zero when its segment is created, where it used to start from whatever bytes the new segment held. - A graph with a `network:` block can send a topic that a process outside the graph publishes on the same machine, such as a ROS 2 program running on `rmw_cerulion`. List it under `egress:` as `{topic: /chatter, external: true}`: the gateway announces it, and a remote that demands it receives its frames. Before, graph-load validation refused any egress topic no node in the graph produced, and an unlisted outside topic was announced but refused at the bridge, so a remote subscriber found it and received nothing. Topics the block does not list still never leave the machine. `external: true` on a topic a node in the graph produces is refused at graph load, and the refusal of an unmarked entry with no producer now names the `external: true` spelling. - `CERULION_NETD_NETWORK=off` now keeps `topic list`, `topic echo`, `topic hz`, `topic info` and `schema info` local, as `CERULION_NETWORK=off` does: they open no zenoh discovery session, run no discovery ladder, and neither query nor start `cerulion-netd`. Before, `topic list` scouted the LAN under it, and a remote schema lookup that netd answered "not network-configured" fell back to a scouting session of its own. Only the exact value `off` engages it, as in the daemon, and a refusal names the variable that engaged it. `cerulion viz --robot` now refuses when `CERULION_NETWORK` is `off` or holds a value it cannot read, or when `CERULION_NETD_NETWORK=off` or `CERULION_VIZD_NETWORK=off` is set, before it spawns or contacts the daemon. - The discovery peer cache honours `CERULION_HOME`: `cerulion topic list` and `cerulion-netd` read and write `$CERULION_HOME/peers.json` when it is set, as documented, where they used to use `~/.cerulion/peers.json` regardless. `cerulion_discovery::peer_cache` gains `cache_path_from`. - Under `rmw_cerulion`, a third ROS 2 node on one machine could not start: every node publishes `/rosout`, the topic's shared memory service held two publishers, and `rcl_node_init` failed on the third node's `/rosout` publisher (in practice the `ros2` daemon's). A topic that an rmw publisher or subscription creates now holds 32 publishers, up from 2, and up to 32 subscriptions, up from 8: 1 GiB divided by the type's slice ceiling, at most 32, so a 128 MiB tier type (`sensor_msgs/Image`, `PointCloud2`, unlisted variable-size types) keeps 8 and one publisher still reserves about 18 GiB of virtual address space. On an arm64 kernel with 39-bit addresses, lower a large type's ceiling with `CERULION_RMW_SLICE_CEILING`, for example `sensor_msgs/Image:8388608`. Such a topic admits one process per publisher and subscriber slot (64 for most types, 40 for a 128 MiB tier type) where iceoryx2's default is 20, and its event ports follow its data limits even when `iceoryx2.toml` raises them. A topic another process created first keeps the slots it was created with, and an rmw endpoint still attaches to it. - Under `rmw_cerulion`, `ros2 node list` failed with "Failed to get node names: error not set". rcl hands `rmw_get_node_names` arrays with no allocator set, and the rmw returned `RMW_RET_BAD_ALLOC` instead of filling them with the default allocator. `rmw_get_node_names_with_enclaves` had the same defect and is fixed too. - `cerulion node create` refuses two outputs of one name, and (outside `--raw-ffi`) an output named like an input, with a validation error. Both used to scaffold a node whose source could not build. - A graph could die with no panic text when the `cerulion` host and a node cdylib had been built against different layouts of a transport type. A type whose field types change is re-packed by the compiler, which can leave its size, its alignment and its field names identical and still move its fields, so a node built earlier reads a field at an offset the host no longer writes. The fix is one of the changes behind this release's new node cdylib ABI, so every prebuilt node cdylib must be rebuilt (see the node ABI entry under Changed). - The lockfiles move tokio to 1.53.3, which fixes RUSTSEC-2026-0386 (`AsyncFd` constructors that violate I/O safety), and ctutils to 0.4.4, which fixes RUSTSEC-2026-0385 (non-constant-time mask generation and `u128` comparisons). The `aspire_arm` example, new in this release, uses tokio 1.54.1, which fixes RUSTSEC-2026-0384. - A Flashback capture of a free-run multi-process `graph run` started without `--record` can be re-executed with `cerulion bag play --resim`. Before, only `--record` put the workers on the clock that replay needs, so replay refused a plain run's trace at its first message. - Each Cerulion process that builds a transport raises its soft open-file limit at start: to the hard limit on Linux (at most 1048576), and at most to 1024 elsewhere. On Linux, under the usual 1024 soft limit, a graph of about 40 nodes no longer fails to start with `UnableToCreatePortTag`. `rmw_cerulion` and Python's `cerulion.connect()` raise it at most to 1024. `graph run` and `graph profile` refuse a graph estimated to need more (40 plus 14 per output port and 22 per input port), naming the fix; `CERULION_OPEN_FILE_CHECK=0` starts it anyway with a warning. - Nested fields decode against the right definition in a workspace that defines a type twice: once as a packaged schema and once as a package-less YAML schema whose name is written `pkg/Type`. This applies to `topic echo`, `schema info`, the viz daemon and header stamp capture, and each definition stays reachable by its own schema hash. Before, a nested field could bind to the other definition or fail to resolve. A reference that does not bind now returns a typed error from the new `try_layout_of` (`LayoutError::UnresolvedNested`), as the frame walker's `WalkError::NestedResolutionFailed` already did. - `cerulion clean` and `cerulion clean --report-only` run on a machine that has never signed in (they read no account and reach no network), so a CI runner or a fresh install can clear what a killed process left behind. `cerulion clean --report-only` deletes nothing: it lists the dead-node entries a plain `cerulion clean` would remove (ten, then "and N more") and ends with "Report only: nothing was removed." and the command that acts on the list. Before, the dead-node sweep ran before the flag was read. - The lockfiles move rustls from 0.23.45 to 0.23.46, which fixes RUSTSEC-2026-0346 to RUSTSEC-2026-0349 (TLS secrets in Debug output, a 1 GiB certificate decompression before authentication, and two handshake defects). rustls-webpki moves from 0.103.15 to 0.103.16, which fixes RUSTSEC-2026-0382 (distrusted intermediates accepted). webpki-roots and webpki-root-certs move from 1.0.9 to 1.0.10, which fixes RUSTSEC-2026-0381 and RUSTSEC-2026-0383. - The lockfiles move rmcp from 3.5.1 to 3.9.0, which fixes RUSTSEC-2026-0457 (the OAuth client's request-forgery filter checked host names, not the addresses they resolve to), RUSTSEC-2026-0461 (an unbounded tool schema cache in the Streamable HTTP server that `cerulion_rcpd` serves on) and RUSTSEC-2026-0462 (unbounded response bodies in the Streamable HTTP clients), and rusqlite from 0.37.0 to 0.41.1 with libsqlite3-sys from 0.35.0 to 0.39.1, whose bundled SQLite 3.54.1 fixes RUSTSEC-2026-0459 (CVE-2026-119375, uninitialized page cache memory read through a write-ahead log whose page size differs from its database's). `cerulion_rcpd` now requires rmcp 3.9 and `cerulion_accountd` rusqlite 0.41. - A `cerulion_bagd` test of the failed-close salvage no longer fails intermittently on macOS. It assumed that a four-frame burst reaches the writer in one hand-off; it now makes that one hand-off, and a new test pins the split case: the failing hand-off is salvaged whole, and frames handed over after the write error are not written. The recorder itself does not change. - The node macros resolve their own crate root. They read your package's `Cargo.toml` at expansion time and emit paths through whichever of `cerulion` or `cerulion_core` your package names, instead of always emitting `cerulion_core`. A package that names both gets `cerulion` paths only when `cerulion` is a plain `[dependencies]` entry without `optional = true` and `cerulion_core` is not, the one layout where only the umbrella is linked into every target. Every other package that names `cerulion_core`, which includes everything `cerulion workspace create` scaffolds, gets the code it got before, and a type error on a node's field is still reported at that field; a renamed `cerulion_core` dependency now gets its own name in the paths. A package that names neither is told which dependency to add, rather than being shown a resolution error against a path it never wrote. - An Android app can feed a linked graph node that holds its latest value from an app `publish` topic. Before, a graph that read such a topic through an absolute `source:` into a plain `#[input]` on a `period_ms` node failed to start, because the runtime created the app topic with room for fewer borrowed samples than that node needs; a trigger input already worked. The runtime now creates every app `publish` topic with the borrow floor a graph output gets, so both kinds of input start. The node produces nothing until the app's first publish and then reads the newest value on each tick. `cerulion_core::transport::SUBSCRIBER_MAX_BORROWED_HELD` (3) is now public. See `docs/android.md`, `Graph nodes in an app`. - After a stop and a new start in one app process, the embedded runtime's catalog showed the first run's frame activity and nothing for topics the new run added. The catalog now reports the live run only: the next start's catalog lists that run's topics, schemas and observed frames, never an earlier run's, and a topic the new run adds shows its frames. A host that rebuilds a gateway under one query surface, the embedded runtime and the network daemon among them, now serves the rebuilt gateway's liveness. - An Android app's embedded runtime now keeps only the newest 100 000 node fires in its in-memory execution record, the same default as `cerulion graph run --trace-limit`. Before, the runtime set no limit, so a graph that ran for days grew the app's native memory with every fire until `stop()`. Nothing changes in your config: there is no new key, and the memory use of a long-running app graph now levels off. - An app topic can now feed a linked node input deeper than 16 frames. The runtime used to create each `publish` topic with the stock queue of 16, so a node that read it on an input with `depth` above 16 was refused at start. Each `publish` topic is now created as deep as the deepest graph input that reads it, so any input `depth` up to 64 holds that many frames. A node that declares a deeper input fails the start before the app creates any topic and before the `init` of any node in the graph runs: `status` reports `state` `failed` with `last_error.code` 5 and a message that names the input, its depth and the limit of 64. Graphs whose inputs on app topics are 16 deep or less create the same topics as before. See `docs/android.md`. - An Android app start now refuses a graph whose linked node declares an output (an `#[output]` field) that the graph YAML does not list under that node's `outputs:`. Before, `start` returned `OK` and `status` said `running` with no `last_error`, while a `#[cerulion_node]` node failed every tick with `missing publisher for output`, because the graph creates a publisher only for a listed output. Now `start` still returns `OK` because it only queues the start, and `status` reports `state` `failed` with `last_error.code` 5 and a message that names the node and the first unlisted output in declaration order, before any topic is created. To fix it, add `- name: ` with its `schema:` under the node's `outputs:`. An output the YAML lists and the node does not declare is still accepted. See `docs/android.md`. - `cerulion graph run` no longer writes the value of a `CERULION_*`, `RUST_LOG` or `IOX2_*` variable whose name marks it as a secret into `env.json` under the default `--record-env allowlist`. Such a value was stored in plain text, so a token exported as `CERULION_RCP_TOKEN` reached every `--record` bag and the run directory's `env.json`, which `cerulion bag record --run` and Flashback captures copy. The name is split at every character that is not an ASCII letter or digit, and a part that, in any case and with trailing digits removed, is `TOKEN`, `KEY`, `SECRET`, `PASSWORD` or `CREDENTIAL`, or one of their plurals, marks a secret (`CERULION_API_KEY`, `CERULION_KEY2`, `CERULION_DB-PASSWORD`). Its value is now stored as `{"redacted": true, "fnv64": ""}`, the same hash as every value outside the allowlist, so a re-execution still detects a change. A marker inside a longer part does not count (`CERULION_KEYBOARD_LAYOUT`, `CERULION_TOKENIZER`, `CERULION_APIKEY`), and certificate paths such as `CERULION_NETD_DEVICE_CERT` stay plain. `--record-env all` still records every value verbatim and `--record-env none` still records names only. A bag recorded earlier keeps the value it stored. - On ROS 2 Foxy and Galactic, an rclcpp (C++) node no longer aborts at startup under `rmw_cerulion` with `frame sizing failed topic=/parameter_events` and `sequence missing size_function`. Every rclcpp node publishes `rcl_interfaces/ParameterEvent` when it starts, and that message carries a `bool[]` member, which the C++ typesupport of those two distros gives no accessor, so every C++ node died on its first publish while rclpy nodes ran. `rmw_cerulion` now reads and fills such a member through its compiled C++ shim, writing the same bytes as on Humble and later, so C++ messages with a `bool[]` member are published and received on Foxy and Galactic. The Foxy and Galactic CI lanes also run the stock C++ and Python demo talker and listener over `rmw_cerulion` now. ### Changed - The ops act verbs refuse a topic the robot imports from another robot, and a reserved topic still gets a usage error. A read refused because account membership did not validate leaves the other live readers running, and a cleanup or identity check that fails is reported as a lost transport. - The shared device endpoint keeps the signed proof that a robot belongs to the account on its control messages, and each read it restores gets one overall deadline. - A read through the shared device endpoint survives a refused operation or a failed metadata lookup, keeps the serving daemon from its idle stop while it runs, and keeps an imported topic under its source robot's access policy. - A graph's declared `ingress:` topics are created before the run starts, single-writer and sized for every consumer. Authenticated forwarding follows a reliable entry's declared queue and counts the frames it refuses. An embedded Android start refuses `ingress` it has no path to deliver. - A declared authenticated import needs a single-writer topic on the producing robot; an observer can still read a multi-publisher topic that has one live writer. - Networking guides and the Go2 graph pair describe automatic account and saved pairing discovery, authenticated declared imports, shared serving and consuming, and explicit open-LAN compatibility without requiring addresses for paired access. - `cerulion bag play --resim --verify` prints a provenance line above its verdict only when the line narrows what the verdict covers. The lines for the normal case, `coordination: free_run (...)` or `coordination: lockstep`, `reads: fed by recorded identity (...)`, a clean `NOTE: read-log enforcement: ...` and `read log: verified clean (...)`, are no longer printed, and the `--report` JSON carries the same facts as before (`coordination`, `read_identity`, `read_log_enforcement`, `read_log`). An inferred coordination contract, best-effort reads, an enforcement anomaly and a quarantined, not exercised, inert, disabled or diverged read log still print. A bare `--resim` drops the stamped coordination line the same way. Under `--verify` a data violation and a schedule divergence are no longer also logged as a `WARN replay: ...` line beside the verdict block that states them, and under either mode a node failure is no longer logged that way beside the block that names it; those log lines are now `info`. A bare `--resim`, whose summary only counts the differing topics, still logs each data violation and schedule divergence as a `WARN`. A replay that stops because one recorded process cannot be re-executed prints only that error, so the data violations, schedule divergence and node failures of the processes that finished are still logged as a `WARN` under either mode. - With `RUST_LOG` unset, `cerulion graph run` and `cerulion bag play` default to the quiet `warn` filter, as the run-and-exit verbs already did, instead of `info`. A graph run prints `graph '' running: ...; press Ctrl+C to stop` once it is live (`graph '' starting in one process; ...` for a one-process live run, which can still refuse to start), any warning, and `recording written to `; a verification prints its verdict. A `--record` run stopped with Ctrl+C before its recorder is ready writes no bag, and it now says so as a warning, since no `recording written to` line follows. Its worker processes and its recorder (`cerulion bagd`, also when run by hand) take the same default; the recorder still warns when a monitor verdict asks for a capture (a topic that stops publishing mid-run, for example), when a verdict that reached a capture clears and when the run it is bound to vanishes, names the path of each capture a worker death, a disabled node, a monitor verdict or a vanished run raises, and warns when its hourly cap first refuses one of those, counting the repeats at `info`. A node library defaults to `info` for the node's own code and `warn` for the framework inside it. `graph profile`, `node run`, `bag record` and the other daemons keep `info`. `RUST_LOG=info` prints the lifecycle lines again, in the worker processes, the recorder and the node libraries too; `-v` raises only the `cerulion` process it is given, not the workers or the recorder a graph run starts. - `cerulion graph run`, `cerulion graph profile` and `cerulion bag play --resim` refuse at start a graph in which a `#[cerulion_node]` node declares an output that its entry in the graph YAML does not list under `outputs:`. The graph creates a publisher only for a listed output, and such a node failed every tick with `missing publisher for output`. `graph run` and `graph profile` fail the build with an error that names the node and the output and says to add the output with its `schema:` under the node's `outputs:`. `bag play --resim` exits with code 2 and says that the graph the bag embeds does not list the output. A Python node and a raw FFI node take a publisher only for an output they write, so their graphs are not refused. A macro node now reports this need: `NodeInfo` gains `with_publisher_for_every_output` and `publisher_for_every_output`, and the library info JSON gains the `publisher_for_every_output` key. A library built before the stable boundary is refused at load with the instruction to rebuild using `cerulion node build`. The embedded Android runtime keeps its own check, which refuses every node kind with the same message, and `cerulion_core::graph` gains `check_declared_outputs_listed`, the check both use. - `rmw_cerulion` entity gids are host-unique. A publisher's gid is the 16 bytes of its iceoryx2 port id, little-endian. A subscription's or a client's gid holds the pid-namespace id in bytes 0 to 3 (0 where there is none), the process id in bytes 4 to 7 and the process's entity counter in bytes 8 to 15, all little-endian. Publisher and subscription gids used to be an entity counter plus the schema hash, and a client's a hash of its node name, its service name and an entity counter, so two processes could hold equal gids. A publisher's gid now changes from run to run, and a client's gid, and with it its reply topic, changes whenever the process id or pid namespace does. - An `rmw_cerulion` subscription asks for retained messages by its own durability, as DDS does: a VOLATILE subscription receives no messages a publisher sent before it connected, and a TRANSIENT_LOCAL one receives up to its own depth, or up to the topic's history limit when its history is KEEP_ALL. A BEST_AVAILABLE subscription (rclcpp's `BestAvailableQoS`, Iron and later) receives what a TRANSIENT_LOCAL one would when the topic has at least one publisher as it opens and every one of them is a retaining publisher, and no retained message otherwise, including when the topic has no publisher yet; publishers in other processes count. This matches `rmw_dds_common` on Jazzy and later; Iron resolves the zero-publisher case to TRANSIENT_LOCAL. A retaining publisher is a TRANSIENT_LOCAL or BEST_AVAILABLE rmw publisher, or a native publisher that declares history; a BEST_AVAILABLE publisher now retains like a TRANSIENT_LOCAL one and reports its depth. Such a publisher carries the iceoryx2 port name `cerulion.retains`, so a publisher from a build without it counts as one that retains nothing. A VOLATILE subscription used to receive a TRANSIENT_LOCAL publisher's retained messages; it no longer does. A TRANSIENT_LOCAL subscription deeper than the publisher can receive more of the publisher's retained messages than the publisher's depth, up to the topic's history limit, and a TRANSIENT_LOCAL subscription can receive messages a VOLATILE publisher retained (DDS would not match that pair). A TRANSIENT_LOCAL publisher of a type above the 16 MiB slice tier, including `rcl_interfaces/Log` on `/rosout` (an unlisted type, so it takes the 128 MiB catch-all), now retains at most 12 messages where it retained 16. A publisher's endpoint info reports its depth clamped to the topic's history limit, the limit itself when its history is KEEP_ALL, and 0 when it is VOLATILE. A service an rmw endpoint creates states its history floor (the `cerulion.history_floor` attribute), and a native subscriber that asks for no particular history (a graph input, a Python `Subscriber`, `cerulion topic echo` and `hz`) takes no retained messages from such a service, so it does not replay a VOLATILE rmw publisher's last messages when it connects. On topics a native creator made, a native late joiner still receives the history the creator declared, including messages a VOLATILE rmw publisher on that topic sent. `cerulion bag record` and the viz daemon still take a service's history either way, so a recording started after a VOLATILE rmw publisher can include up to the topic's history limit (16, or 12 above the 16 MiB tier) of its earlier messages. A native graph input on a latched ROS topic, such as `/tf_static` from a TRANSIENT_LOCAL rmw publisher, no longer receives the retained messages; it received them before only when that publisher had opened the topic first. `cerulion_core::transport` gains `RETAINING_PUBLISHER_NAME` and `TransportManager::topic_publisher_retain_marks`, and `TransportError` gains `TopicPublishers`. - The Linux release programs (the CLI and its daemons), the heap hook and the Debian package now run on glibc 2.31, so they install and run on Ubuntu 20.04 and Debian 11; they are built on Ubuntu 20.04 and the package depends on `libc6 (>= 2.31)`. `cerulion ros2 run` and `cerulion ros2 launch` still need a host where a supported ROS 2 distro and its rmw library run: the packaged rmw is the Jazzy build, which needs Ubuntu 24.04, and the Lyrical rmw ships as the separate `cerulion-rmw-lyrical` tarball. - A typed reader of a message with variable fields (`T::build_reader`, which every typed receive runs) no longer clones a shared `Arc` topic when it is built or releases it when it drops, and `build_reader` is `#[inline]`. Checking an `Image` frame and reading three fixed fields and the first data byte measures 11 to 12 ns before and 2.2 ns after on an Intel i9-13900HK, and 6.0 ns before and 2.5 ns after on an Apple M3 Max. Misuse errors from a reader still name the topic ``, now `cerulion_core::message::READ_ONLY_TOPIC`; `cerulion_core::message::read_only_topic()` is removed. - The fused-chain census (the chains block of `cerulion graph levels` and the `chains` census in a run's `run.json`) refuses one more edge: an edge whose consumer has an output that a node reads as a latest value at a level after the chain head's level and at or before the consumer's own. Such an edge keeps the queued path, with the reason `early-latest-value-reader`, and its consumer may head a chain of its own. A graph with no such reader reports as before. - Usage telemetry is quieter and says more about itself. The first-run notice is one line, printed only when stderr is a terminal, and links https://cerulion.com/telemetry, which `cerulion telemetry status` also prints; a command without a terminal prints no notice and sends as usual. A CI run (`CI`, `GITHUB_ACTIONS` and the other variables listed in `docs/telemetry.md`) prints no notice, sends with `ci: true` and no person profile under a random id minted for that process and never stored, so no later login can join it to an account; every event now carries `ci`. `CERULION_TELEMETRY` also accepts `false`, `off` and `no`, in either case, to turn telemetry off. `docs/telemetry.md` now lists the fields PostHog adds, the `$create_alias` event, that events are sent as they are queued, the PostHog host, the IP address and the location derived from it, and how long events are kept. `cerulion_telemetry::Common` gains a `ci` field. - `CerulionRuntime` (the `cerulion_android` Java facade) no longer loads `libcerulion_android.so` by itself. Call `CerulionRuntime.loadLibrary("")` once before any other method, with the name of the app's runtime library. Every other method throws `IllegalStateException` until then, and a second `loadLibrary` with a different name throws `IllegalStateException`. - `cerulion node create` writes node crates with `crate-type = ["cdylib", "rlib"]` and a `pub` node struct, so another crate, such as an app's own native library, can link a node as a plain dependency with `default-features = false` (which compiles the node's C exports out) and name it by its `Entry`. The cdylib that `cerulion node build` and `cerulion graph run` load is unchanged. The `obstacle_avoidance` starter and example and the `basic_timer` example use the same layout. An existing node crate links this way after two edits: add `"rlib"` to its `crate-type` and make its `#[cerulion_node]` struct `pub` (see `docs/user-api.md`). - `cerulion_android` builds as a Rust library only (`crate-type = ["rlib"]`); it no longer produces `libcerulion_android.so`. An app links it into its own runtime crate, a `cdylib` that also links the app's graph nodes, and ships that one library: copy `target//release/lib.so` into `jniLibs//` rather than using `cargo ndk -o`, which also copies each node crate's own library. `tools/scripts/android_jnilibs_gate.sh` checks a jniLibs tree for exactly one library per ABI, built for that ABI, 16 KB aligned `LOAD` segments, `JNI_OnLoad` and no node exports. The sample app now ships its graph (`timer`, `relay`, `printer`) as an APK asset, links those nodes into `libcerulion_sample_runtime.so` from `crates/cerulion_android/android/runtime`, and the emulator test checks their topics, recordings, a restart in the same process and a start after a kill. An app that loaded `libcerulion_android.so` makes a runtime crate (see `docs/android.md`, `App embedding`) and passes its name to `CerulionRuntime.loadLibrary`. - `cerulion_android::encode::encode_json` takes a `FrameWalker` and the qualified schema name where it took a `WireLayout`, and reads the JSON with the shared message YAML reader of `cerulion_core::dynamic`. `encode_json_into` is removed: call `encode_json`, which returns the frame. - An Android app can run graph nodes in its embedded runtime. The app's runtime crate links the node crates as plain libraries and lists them once with `cerulion_android::embed_nodes! { "timer" => timer::TimerNodeEntry, ... }`, which defines the library's `JNI_OnLoad` and registers each graph YAML `type:`. A start looks every node up among the linked types and makes fresh nodes, so a stop and a new start in one process run new instances. A type that is not linked, a type listed twice, or `node_lib_dir` with a native-node graph on the in-process transport fails the start with error code 5 and a message that says why. The status JSON gains `linked_nodes`. `cerulion_android` is now published with the workspace, and gains a `local-transport` feature for host builds on the app's transport. The app's runtime crate copies the `iceoryx2*` entries of Cerulion's `[patch.crates-io]` table, also when it takes `cerulion_android` from crates.io, and an app that hosts the remote plane takes `cerulion_android_remote`, which is not on crates.io, and `cerulion_android` from git at one commit. See `docs/android.md`, `Graph nodes in an app`. - `NetworkBlock::egress` (the `network:` block of a `GraphConfig`) holds `EgressTopic` entries where it held `String`s. A 1.0 graph file's list of topic names parses unchanged, and an entry with no `reliability` and no `external: true` serializes back to its bare name. In Rust, `EgressTopic` converts from `&str` and `String` (`vec!["/r/cmd".into()]`), reads back as `&str` through `as_str()` and `AsRef`, formats as its topic name, and compares with `str`, `&str` and `String` in either order, so `block.egress == vec!["/r/cmd"]` holds; a string equals an entry only when the entry sets neither a `reliability` of its own nor `external: true`. The field's type is still new to 1.0 code, which needs these edits: `vec!["/t".into()]` where it wrote `vec!["/t".to_string()]`, `.into()` where it pushed a `String`, `iter().any(|t| *t == s)` where it called `contains(&s)` with a `String` `s`, and `NetworkBlock::egress_topics()` where it needs the names as `&str`s. - LAN access is paired by default on every platform: unpaired peers cannot read exported topics or publish into a run's ingress, and `CERULION_LAN_ACCESS=open` selects unauthenticated LAN access with a warning at startup. Signed-in desks find and read account robots over the authenticated remote plane without listen or connect settings; existing saved pairings use that same plane. The first live export starts authenticated serving automatically, and iroh uses a direct path where available or a relay otherwise. For explicit open zenoh LAN access, mDNS advertises fixed TCP listeners and netd folds reachable mDNS and cached peers into its boot-time dial list. Multicast scouting is off by default; `CERULION_MULTICAST_SCOUTING=on` on both machines enables scouts where mDNS does not cross. A graph's explicit listen locators are found through mDNS or an explicit connect locator. These zenoh discovery choices do not grant access to paired runs. A machine's own netd and gateway processes (its identity on one of its own addresses) are left out of its own `topic list` and boot fold; `cerulion_discovery::ladder` gains `drop_this_hosts_gateways` and `drop_this_hosts_gateways_with`. `cerulion_mdns` gains `browse_rung` and `instance_from_fullname`, moved from `cerulion_cli_engine::mdns_discovery` (which re-exports `browse_rung`), and `cerulion_netd::discovery_fold` gains `fold_discovered_peers` and `fold_discovered_peers_at`, replacing `fold_cached_peers`; `PeerFold`'s `folded_cached` and `dropped_cached` are renamed `folded_discovered` and `dropped_discovered`. - The wire header grows from 32 to 40 bytes (wire header version 2): `WireHeader` gains `step_tag` at byte 32, a `u64` holding the producer rank in bits 48 to 63 and the step plus one in bits 0 to 47, so `0` means untagged (`cerulion_core::wire::StepTag`). Every frame this release publishes is untagged. `WireHeader::SIZE` is 40, so the smallest `max_slice_len` is 40 (it was 32): a graph, a `CERULION_RMW_SLICE_CEILING` entry or a bridge mapping below 40 is refused as before. Releases with the 32-byte header cannot exchange frames with this one. Where this release can see the other side's version it refuses loudly: the node cdylib ABI changes (see the node ABI entry below), so every prebuilt node cdylib must be rebuilt (`cerulion node build `); every iceoryx2 data service this release creates carries a `cerulion.wire_header_version` attribute, and an opener refuses a service stating another version (one stating none, made by a raw iceoryx2 program or an older release, is accepted with a warning that its frames are assumed to be this layout); zenoh frames move to the `cerulion_w2` key namespace and a demand GET states its version (a producer at another version answers `refused:wire-header` and enables nothing); the iroh plane's ALPN is `cerulion/wire/2`; the `cerulion-netd` banner states `wire_header`, and a client refuses a daemon at another wire header version; a robot's catalog states `wire_header_version`. These checks run in the newer process only: an older process opening something this release created reads no version and is not refused, so run one Cerulion release per machine and the same release on machines that talk to each other. Bags record a version 2 schema descriptor (20 bytes, with the wire header version); a bag recorded with the 32-byte header still reads, and its frames are upgraded to the 40-byte layout as they are read: a message stream upgrades one message at a time, and a frame walk (`bag play`, `--resim`, the Python frame iterator) builds one upgraded copy of the bag's frames per open bag, reserved at its exact size and held until the bag is closed, and refuses a bag whose copy would pass 2 GiB, naming `cerulion bag migrate`. A frame with bytes after its declared size is upgraded with them kept after it; one shorter than the header or declaring a size past its end is served unchanged and counted. `bag info` reads the recorded bytes, names the upgraded topics and the memory a walk would hold, and reports a bag of any size. `cerulion bag migrate` writes a current copy of such a bag, a graph-less `bag record` bag included, records the upgraded topics in the migration record (whose two graph digests are now absent for a bag with no graph), and refuses a bag holding a frame it cannot upgrade. `cerulion_bag` API: `SchemaDescriptor` gains `wire_header_version`, and its `descriptor_version` field is now private, read with `SchemaDescriptor::descriptor_version()`; `BagError` gains `UnsupportedWireHeader` and `LegacyUpgrade`; `BagReader` gains `legacy_wire_header_topics`, `legacy_passthrough_count`, `has_readable_footer` and `user_frames_as_recorded`, and the crate exports `LEGACY_UPGRADE_CAP_BYTES`. `cerulion_core::wire` exports `WIRE_HEADER_VERSION`, `V1_HEADER_SIZE`, `upgrade_v1_frame_into`, `upgrade_v1_frame` and `FrameUpgradeError`. The permissive `cerulion-wire` crate mirrors the change: `WireHeader::SIZE` is 40, the struct gains a public `step_tag: u64` field (code that builds a `WireHeader` with a struct literal must add it) and the crate exports `WIRE_HEADER_VERSION`. The Python client exposes `Frame.step_tag`, `Record.step_tag` and `cerulion.WIRE_HEADER_VERSION`. - zenoh moves from 1.8.0 to 1.10.1, the first release with mixed-reliability QUIC, and `cerulion_core` compiles zenoh's `transport_quic`, `transport_quic_datagram`, `transport_udp` and `unstable` features beside `transport_tcp`. zenoh-transport 1.10.1 depends on lz4_flex 0.10.0, which RUSTSEC-2026-0041 covers and which has no patched 0.10 release; the affected functions compile only under zenoh's `transport_compression` feature, which nothing enables, and `tools/release/deny.toml` carries an exception for that one advisory until zenoh moves to a patched lz4_flex. The same file accepts RUSTSEC-2025-0134 (rustls-pemfile, unmaintained, no vulnerability), which zenoh-link-commons 1.10.1 uses to read certificate files. quinn-proto moves from 0.11.17 to 0.11.19, the release that fixes RUSTSEC-2026-0340 and RUSTSEC-2026-0343, now that QUIC carries graph traffic. - A Rust port of a package-less workspace YAML schema is scaffolded as `use native_ros2_messages::;` (the type generated at the message crate's root) instead of `use ;`. - A publish rings its topic's shared memory doorbell for every topic a graph produces while the doorbell is on, where it used to ring only for a topic a sibling process in the same deployment was planned to read. A consumer in a graph nobody planned alongside the publisher, an `rmw_cerulion` wait set and any other blocked reader are woken by the publish rather than at the end of their own recheck period. The page a consumer opens is unchanged: a declared trigger or sync input topic that admits a writer outside its executor unit, another unit or another process. A topic that admits outside publishers is armed with shared ownership, so a graph's exit leaves the page for the other publisher. A publish on a topic nobody is blocked on costs one atomic and one cached backend read, with the kernel wake held behind the page's parked claim, and the live loop's wait policy line reports both the number of topics armed and the number the plan named as read by a sibling group. - An input that declares no trigger no longer creates an event listener. Such an input is read on its own node's fire by the step's snapshot and is woken by nothing, so the port that would sit in every publisher's notify path for it is not created at all; a topic's live listener count and its expected in-process total both drop by one per such input. `CerulionSubscriber::wait_for_message`, and `AnySubscriber::wait_for_message` which forwards to it and is the method a node body can reach through the prelude, now return an error naming the topic ("this subscriber was built with no event listener, so there is nothing here to wait on") instead of waiting out its timeout and returning `Ok(0)`. That entry serves subscribers a tool builds for itself, the `cerulion topic` observer among them; a node reads a declared input through its own tick or has the step drain it. - A recording writes a read-log record at every gated consult a replay of it also makes, the ones that found the queue empty included, so a replay can tell a read the candidate never made from one the recording never held. The one empty consult left unrecorded is a burst's between-fires refill: a live burst discovers its own length by asking until the answer is empty, while a replay fires the recorded count and never asks, so recording it would leave a position no replay could fill, and a per-set Sync node has no refill hook at all, so a replay of its planned fires runs no align pass behind them. These records are part of `trace_format` 7; a Cerulion that reads up to 6 refuses a bag at format 7 or later up front with "recorded by a NEWER Cerulion; upgrade to replay it" (exit 2) instead of replaying it under the wrong contract. This build replays every earlier format exactly as before, and on a bag at format 7 or later a consult the recording holds no read for is a schedule divergence (exit 6) rather than the counter it used to be. - Node libraries use stable node ABI 32 and load across Rust compiler versions at or above the supported minimum. The compiler-match rule and its warning are gone. Existing node libraries must be rebuilt once: run `cerulion node build `. Libraries remain compatible with CLI updates within the same stable boundary major; a different major is refused with a rebuild message. - The processes of a multi-process run start their first step at one shared instant. The supervisor's start signal to its workers changes from a plain `go` file to `cerulion-go-v1 epoch_ns=`, an instant 20 ms after the supervisor writes it, and every worker waits for that instant before its first step, so the processes that are ready by then start together. A free-run `--record` process that arrives later than the graph's tightest declared timing (at least 1 ms) logs how late it was and starts its own timeline, with no burst of catch-up steps. The supervisor and its workers must come from the same release: a worker from this release refuses the plain `go` file an older supervisor writes and does not start, and a worker from an older release does not wait for the shared instant. - A recording names the frame every read served. Every edge now carries producer annotations, where only `multi_publisher_topics` and producer-less external topics did. Those keep one before every read. Every other edge carries one per writer run: the recorder writes one before a read whose writer differs from the last one it named on that read stage and read site, and every later read up to the next annotation was served by that writer, so a single-writer edge grows by one record per read site for the whole recording. The read log therefore records the writer and the wire sequence of every served frame. These annotations are part of `trace_format` 8; a Cerulion that reads up to 7 refuses a bag at format 8 or later up front with "recorded by a NEWER Cerulion; upgrade to replay it" (exit 2). - `cerulion bag play --resim all --verify` on a free-run bag at `trace_format` 8 or later feeds every read its recorded frames. Each read stage of the re-executed graph subscribes to a private service of its own, and before each read pops, the replay publishes onto it exactly the frames that recorded read consumed, found in the bag by writer and sequence. A frame the live consumer lost to `drop_oldest`, a topic read by several consumers and a topic written by several publishers therefore replay read for read, where the replay used to re-create each consumer's queue and fall back to recorded timestamps when it could not. A read whose frames cannot be found is refused by name before the first step (exit 2, naming the node, the input, the writer and the sequence): a frame missing from the bag, a read with no recorded writer (on a multi-writer edge, a read without an annotation of its own), two reads of one read stage claiming one frame, several recorded frames with one writer and one sequence (a gateway republishing several remote writers under one port), a read of a topic with no writer label when the bag's label stream could not be read in full (label records from a newer Cerulion, say), a read that popped several frames and does not name each one (a bag below format 9), a `sample(N)` read that dropped frames, a per-set `Sync` trigger input, and a graph with `ros2` nodes, whose takes the read log does not record. A take on an rmw path inside a replayed node is an edge-read divergence (exit 6). The verdict gains a second provenance line, `reads: fed by recorded identity (...)` or `reads: best effort, no read identity ()`, and the `--report` JSON a `read_identity` field (`{"mode": "fed", "reads", "frames"}` or `{"mode": "best_effort", "reason"}`); `report_version` is unchanged. Bags recorded before format 8, lockstep bags and a resim without `--verify` replay as before, labelled best effort; a resim without `--verify` keeps each consumer's queue so a changed node's own frames reach its consumers. - A recording names every frame a read consumed, not only the one it served. Before a read that popped more than one frame, the recorder writes one read-log record per other frame the read consumed (outcome kind 8, `batch_frame`), in pop order, each with that frame's wire sequence and, on an annotated edge, its writer, when they and the read fit in the read stage (a deeper batch keeps only its read record). A batch's frames need not be consecutive: on a `drop_oldest` queue a writer can refill and overflow the queue while the node's callback runs between two receives of one batch, so a depth-two queue can hand one batch frames 1, 19 and 20. `bag play --resim all --verify` feeds such a read exactly the frames it recorded, on a topic with several writers too. Bags recorded by this build stamp `trace_format` 9; a Cerulion that reads up to 8 refuses such a bag up front with "recorded by a NEWER Cerulion; upgrade to replay it" (exit 2). A replay of a bag below format 9 writes no `batch_frame` record, as its recorder wrote none, so its read log still compares position for position. A fed replay refuses by name a read that popped more than one frame and does not name each one, as on a bag recorded below format 9 (`read_identity_batch_unattributed`, exit 2), rather than feed it frames counted back from the served one, and a read whose recording names more frames than it popped (`read_identity_batch_miscounted`, exit 2). On a multi-writer edge a batch frame without a writer annotation of its own is refused as `read_identity_absent`, naming that frame's sequence. - `cerulion_core` gains the `replay_feed` module (`ReadFeed`, `ReplayWiring`, `EdgeIdentity`, `replay_feed_topic`), `GraphRuntime::build_for_replay`, `GraphRuntime::install_replay_read_feed` and `read_outcome::writer_run_site`; `ReplayReadViolationKind` gains `FeedFailed` and `UnrecordedTake`, `ProducerAnnotation` gains `WriterRuns`, `replay_feed::annotates_every_read` names the per-read rule of a multi-writer edge, and `Scheduler::set_replay_trailing_refills` and `GraphRuntime::set_replay_trailing_refills` mark a replayed step's capped bursts. `cerulion_cli_engine` gains `replay_feed`, `replay_engine::ReplayPurpose` (a field of `ReplayInputs` and `ReplayOptions`), `ReadIdentityReport` and `render_read_identity_line`; `stamp_trace_format` takes a sixth argument, `records_identity`; `replay_inject::StepAdmission` gains `identity`, `RecordedRead::producer` takes the raw token, and the multi-publisher injection planner attributes a read to the last annotation of its site before it. - `cerulion_core`: `ReadOutcomeKind` gains `BatchFrame` (`trace_ring::READ_OUTCOME_BATCH_FRAME`); the `replay_feed` module also holds `new_replay_id` (an identifier built from an iceoryx2 `UniqueSystemId`, or `ReplayIdUnavailable` when the clock cannot be read) and `REPLAY_FEED_TOPIC_MAX_LEN`, `ReplayWiring` carries a `replay_id`, and `replay_feed_topic` takes that identifier and names the node by a 16 hex digit digest of its id, so a feed name is at most 86 characters; `ReadStageRole::label` is a `const fn`. `cerulion_cli_engine`: `replay_feed` also holds `FeedNeed`, `FrameIndexBuilder`, `FeedIndexOverBudget`, `FEED_INDEX_ENTRY_BYTES` and `DEFAULT_FEED_INDEX_BUDGET`, and `plan_feeds` takes a step bound; `ReplayInputs`, `ReplayOptions`, `resim_cmd::PlayFlags` and `resim_cmd::ResimOptions` gain `feed_index_budget`; `replay_inject::ReadIdentity` carries `batch`, and `RecordedReadBody` gains `BatchFrame`. - The minimum supported Rust version is 1.95 (it was 1.93), and the release workflow builds with Rust 1.95.0. `cerulion_core` calls `try_update` on its atomics, the name Rust 1.95 stabilised and Rust 1.99 uses in place of the deprecated `fetch_update`; a workspace that denies warnings builds again under the current stable. - The release installer sets up current stable Rust. `install.sh`, `cerulion-install-rust` and an archive's `install_rust.sh` accept a Rust 1.95 or newer that is already there (the one in Cargo's home when it holds `rustc` and `cargo`, else the one on the PATH) and change nothing. Otherwise they add current stable through rustup, making it the default only where there is no default, or install rustup with stable where there is no Rust. An older default is kept, with the command that selects stable. Release archives no longer carry `rustc-version.txt`. - New workspaces no longer pin a compiler. `cerulion workspace create` and `cerulion workspace init` write no `rust-toolchain.toml`, so Cargo and rustup select the compiler as usual; an existing toolchain file is left as it is. - `cerulion node build`, `cerulion workspace create` and `cerulion workspace init` offer to install Rust when no Rust 1.95 or newer is found. On a terminal they ask `Rust 1.95 or newer is needed to build nodes. Install it now? [Y/n]`; a yes runs `cerulion-install-rust` when it is installed, else rustup or the official rustup installer with stable and the minimal profile, and the command goes on. Off a terminal, or after a no, they print the command that installs Rust, and `node build` fails with the same error and exit code as before. A toolchain file that selects an older Rust is named instead of offered an install. - The shared memory transport moves to iceoryx2 0.10.0. Every event service is sized to the event ids the transport actually mints rather than the library default, so a listener no longer walks 256 shared memory counters on every wait. - The install script links `cerulion`, `cerulion-netd`, `cerulion-connectd` and `cerulion-remoted` into `~/.local/bin` (and into `/usr/local/bin` when that directory is on the PATH, writable without `sudo`, every account can reach the install directory, neither `~/.local/bin` nor another `cerulion` is on the PATH, and no other account can change `/usr/local/bin`, the install directory or a linked program; otherwise it makes only the `~/.local/bin` links, with a warning when another account could change one of those paths), so a shell that already searches either directory runs `cerulion` as soon as the install finishes. Its last line now says whether `cerulion` is ready in the terminal that ran it, and names the one command that fixes it, `. ~/.cerulion/env` (`source ~/.cerulion/env.fish` in fish), only when it is not. The README one-liner ends with that command, so it leaves `cerulion` on the PATH of the terminal it was pasted in. A name in either directory that is not already the installer's own link is left alone, and `--no-modify-path` skips the links as well as the startup files. - `cerulion topic echo` prints each frame as one YAML document: a `# seq=.. ts=..ns schema=0x.. size=..` comment, a `# ` comment, the fields with no indent, then `---`. Gap notices and the hex of an undecodable frame are `#` comments. An array longer than `--truncate-length` (default 128) ends in `!truncated `. `std_msgs/String` and `sensor_msgs/Image` print in full like every other type, not as one-line summaries. This changes the command's output, which SemVer covers: a script that parsed the old lines should read the output as a stream of YAML documents and skip `#` lines. - A multi-process `graph run` free-runs by default. This covers a graph with `process_groups:` and an unpartitioned graph that `graph run` partitions on Unix. Each worker process steps on its own wall-following clock, with no shared per-step barrier. Set `CERULION_EXECUTION_MODE=lockstep` to get the 1.0 barrier behaviour back. `run.json`'s `gating` reads `recorded_wall` (or `wall` under `--no-rings`) instead of `quantum`. `--record` bags stamp `coordination: free_run`, which `bag play --resim` follows. `--single-process` runs of a graph that is one executor unit are unchanged. This changes the default behaviour of `graph run`, which SemVer covers. - A node that returns `NodeError::Fatal` is stopped. The scheduler logs one error line naming the node and never fires it again, and the rest of the graph keeps running. When the run ends, `graph run` prints `Error: node '' stopped on a fatal error: ` for each stopped node and exits 3, where it used to exit 0. A failure that fails the run still exits 1. This changes how a node's error is handled and the command's exit status, which SemVer covers. - `cerulion graph run` on a graph without `process_groups:`, and `graph run --auto-partition`, run the derived multi-process layout in memory without asking, in a terminal or a script, and leave the graph file unchanged. Before, a terminal run showed the partition diff and asked whether to write it. Add `--yes` to save the layout into the graph YAML (with a `.bak` backup); `cerulion graph partition` still offers the interactive save. This changes the command's behaviour, which SemVer covers. - The machine key moves from `~/.cerulion/desk.key` to `~/.cerulion/identity/device.key` (0600, in a 0700 directory). On first use an existing `desk.key` is adopted byte for byte, so paired robots keep trusting it, and `desk.key` stays, as a hard link to the same key or an identical copy; two different keys under the two names are refused, naming both files. The config directory itself does not move, but `cerulion connect` now honours `CERULION_HOME` for the key, `robots.toml`, `config.toml`, `epochs/` and `ros2/` (it used to read `~/.cerulion` regardless), so move those files if you set `CERULION_HOME`. To start a new key, remove both key files. - State records, the restore points a mid-run resume reads, carry the writing worker's rank and a format version, and their header grows from 32 to 40 bytes. A mid-run bag recorded by Cerulion 1.0 can no longer resume from its state records: `cerulion bag play --resim` refuses it, naming both format versions, and the fix is to record it again. Replaying such a bag from its start is unchanged. - Re-executing a free-run recording with `cerulion bag play --resim` delivers each frame one node sends to another in the same worker process at the step the recording read it, and holds back a frame that arrives early. A recorded read the re-execution does not reproduce exits 6 and names the edge, the step and both sequences. A read log that cannot be enforced on such an edge is refused with exit 2. The `--report` JSON gains `read_log_enforcement`, always present, and `read_log_verdict`, present only when the read log finds a schedule divergence (exit 6). Lockstep recordings are unchanged. - On macOS 14.4 and later, a worker process of a multi-process run that is waiting for data wakes on the publish instead of on its recheck timer: the publisher bumps a wake word in the topic's shared memory doorbell page, and the kernel wakes the blocked consumer. `CERULION_DOORBELL_OS_SYNC=0` turns this off on macOS only; `CERULION_DOORBELL=0` turns the doorbell off on every platform. - One parser reads schema YAML everywhere, and it refuses three shapes that used to load silently, naming the schema: an entry that is not a mapping, a `fields:` written as a list (`fields: []`), and two fields with the same name. `schema info` on such a file exits with the error; `graph run`, `schema list`, `topic` and `node create` warn, skip that file and load the rest. An empty `fields:` is still valid. - `cerulion ros2 attach --dry-run` runs from any directory, so listing a robot's DDS topics no longer needs a workspace. Outside a workspace it uses one empty temporary directory under `TMPDIR` and removes it on exit; if that directory cannot be created it refuses and says to point `TMPDIR` at a writable location or run from inside a workspace. Writing or running the bridge graph still requires a workspace. - In `cerulion_core`, `DoorbellRegistry` loses `primary_addr` and `primary_topic`: look a topic up by name with `addr(topic)` or the new `bell(topic)` and `slot_of(topic)`. `CrossProcessWiring::with_sibling_topics` and `ValidationOptions::sibling_topics` take the new `SiblingProducedTopics` instead of a `BTreeSet`, and a new `SiblingConsumedTopics` sits beside it. Both are built with `.collect()` from `String`s and serialize as the bare set. - In `cerulion_core`, `DemandGetState::from_topics` is removed. Make the set with `DemandGetState::default()` and call `add_topic` once for each canonical topic. - The README's Debian and Ubuntu recipe uses the archive at `https://apt.cerulion.com`. It installs the archive key only after checking its fingerprint (`953C69FD279D9256FA4B71C5DA5FDE5D0DC6D91B`), so a failed download no longer leaves an empty keyring that breaks `apt-get update`. A machine set up with the 1.0 recipe, whose `/etc/apt/sources.list.d/cerulion.list` names the older address, can switch by running the new recipe. - `cerulion pair` no longer runs the code-pairing ceremony: nothing on a robot starts a pairing code in this release, so the ceremony could not complete. The verb is not listed in `cerulion --help` or offered by `cerulion `, and running it with any arguments exits 2 with `Error: code pairing is not available in this release`, before the network kill switch and the login gate, where it used to exit 0 to 4 or 130 by the ceremony's outcome. It sends no `pair_completed` usage event. Robots on your account are reached by signing in with `cerulion login`, which this does not affect. - `cerulion_core`: `CreditShared::record_drained` returns how many of the frames it was asked to remove it could not take off the word because the word reached zero, and `CreditShared::record_unpublished` takes back the count of a send that returned an error. ### Source only, not packaged These components are in the source tree and not in the 2.0.0 release downloads: `cerulion-rcpd`, which `cerulion rcp` serves from a paired robot, and `cerulion-vizd` with its viewer. - `cerulion-vizd`'s `runs` rows carry `"paused": true` while `cerulion graph pause` holds a run. Its usage telemetry events always carry the random id, never an account id. It sends `vizd_started` (`os`, `arch`) and a `vizd_heartbeat` (`uptime_minutes`) every 15 minutes under the CLI's consent settings, and only when `POSTHOG_API_KEY` is set in its environment; a running daemon checks consent again before each heartbeat, and it sends nothing until the CLI has shown the telemetry notice on the machine, except under CI. - `cerulion-vizd` answers a new `sample` request: the newest 1 to 20 messages of an attached topic, each as `seq`, `ts_ns`, `size`, the decoded `fields` where the schema is known (or `null`) and a one line `summary`. The daemon keeps frames only for a topic that is being sampled, drops the ring five seconds after the last request, keeps at most eight rings, and keeps no body larger than 16 KiB, so sampling adds no subscription and a bounded amount of memory. The control protocol version in the banner is unchanged; a daemon without the verb answers it with the structured unknown-method error. See `docs/user-api.md`. - `cerulion-vizd` can load a robot's URDF model onto an attached `unitree_go/LowState` topic through two new control socket requests: `load_model` (`urdf_path`, `topic`, `model_id`, and 1 to 12 `motor_joints` in motor-array order) and `model_status`. The model is checked before any mesh file is read (fixed, revolute and continuous joints, one GLB, OBJ, STL or DAE mesh per link, at most 16 MiB of XML), its meshes are read within a 256 MiB budget, and it is then drawn at `models/` with its joints driven by the measured motor angles. See `docs/user-api.md`. - `cerulion-vizd` draws voxel-delta map streams. A `sensor_msgs/PointCloud2` whose fields are exactly `vx_mm`, `vy_mm`, `vz_mm` (`int16`), `hits` and `op` (`uint8`), with `point_step` 8, is read as map edits rather than points. The viewer keeps the map under the topic as static tiles of height-coloured cubes, walls, outlines and the robot's trail. `attach`, `status` and `list` report such a topic as `VoxelMap`, where they reported `Points3D`. - `cerulion-rcpd` is an MCP server that lets an agent read a running graph (`robot://graph`, `robot://state/{name}`) and call only the tools an `rcp.yaml` manifest declares, plus a built-in `estop`. Arguments are checked against each tool's `input_schema` before anything is published. Every call goes into a hash-chained receipt log (`--verify-receipts ` checks it), and every call that passes the checks is published on the manifest's `journal.calls_topic` (default `/rcp/calls`), so a recording replays with `bag play --resim all --verify`. `--http` needs `CERULION_RCP_TOKEN`. It is not in the release archives; build it with `cargo build --release -p cerulion_rcpd`. See `docs/rcp.md`. - `cerulion-rcpd` answers a graph's requests for a second look at a wrist-camera frame with Jev, TypeSafe's System One model, through OpenRouter by default. With an `eyes.jev` section in `rcp.yaml` (route, pinned model, fixed question sets, frame topic, key file, region), a node publishes an ask naming a question set and a frame on `/rcp/eye/ask`; the daemon sends that frame unchanged in one request and publishes one answer per ask on `/rcp/eye/answer`, `ok` or the reason Jev is absent (`disabled`, `no_credential`, `unavailable`, `timeout`, `rate_limited`, `quota`, `throttled`, `refused`, `wrong_model`, `malformed`, `not_visible`, `not_recorded`). Before any request it refuses anything but one JPEG of at most 640 x 480 and 200 KB and 4,000 estimated input tokens, and holds requests to 2 in flight and 5 a second after a burst of 10; a reply after the 1.5 s deadline is never delivered. It answers at most 20 asks at once and 10 a second after that; an ask over that bound gets no answer. Each answer has an `eye.jev` receipt, carries `"provenance": "third_party"` and records what was sent except the image and the key; `--verify-bag ` joins a recording's answers to the receipt log. A gate reads an answer against the exact ask frame it published, so an answer given for another ask, such as a recorded answer that `bag play --resim` re-injects for an ask that changed, reads as `not_recorded`, and `EyeAnswer::for_image` does the same for an answer that names another frame's image. The eye tells a played recording by the transport node its frames come from (`cerulion_bag_play`, or a node name beginning `cerulion_replay_`): an ask from `bag play` gets no request, no answer and no receipt, and a played wrist frame is never held, whatever their timestamps say. `bag play --resim` runs on a private shared-memory namespace the eye never sees, so its asks and wrist frames never reach the eye. An ask's deadline runs from its wire timestamp when that stamp is at most 250 ms behind the host clock, and from when the daemon reads it otherwise, so a run resumed after a pause keeps its whole deadline. The key is read from a file only its owner can read; `cerulion-rcpd jev on | off | status` switches Jev and reports today's looks and the asks dropped unanswered, and the first time Jev is on, the daemon logs one line saying frames leave the robot, before the first frame does. The daemon opens the graph's ask and frame topics once the graph has created them and never creates them, so it can start before the graph. An eye that cannot start leaves the tools served. See `docs/rcp.md`. - `cerulion rcp ` serves a paired robot's `cerulion-rcpd` as a local stdio MCP server: an MCP client runs it as a stdio server and reads the robot's resources and calls its tools. It runs `cerulion-connectd rcp`, which dials the robot's new `cerulion/rcp/1` plane with this machine's device key. `cerulion-remoted` admits only a key on the robot's access list and checks every message against the live access list: the resources, `subscriptions/listen` and `tools/list` need the observe capability, `tools/call` needs the teleop capability and the operator role, and any desk on the access list may call `estop`. It forwards each admitted message to the robot's local rcpd over loopback HTTP with a bearer token and names the desk in the `x-cerulion-caller` header; rcpd receipts and journals the call under that identity. At startup `cerulion-remoted` creates `/remoted/rcp.token` (mode 0600) when it is absent, a systemd environment file rcpd can read; `--rcp-addr`, `--rcp-token-file` and the `--rcp-*` bound and timer flags change the link. The ops act verbs, the ops verb `restart` and the rcp plane share one e-stop latch, and LAN ingress does not read it. An `estop` over rcp engages the ops e-stop before it is forwarded, so an unreachable rcpd still leaves it engaged, and so does an `estop` sent within `--rcp-drain-ms` after rcpd restarts and loses the session, which is answered with an error. While the ops e-stop is engaged, `topic-publish`, `service-call` and `restart` are refused with a verb error, and every rcp tool call except `estop` and `estop_clear` is refused with error `-32001` `refused: the robot's e-stop is engaged`. The ops e-stop clears only when `cerulion-remoted` restarts: while it is engaged, rcp `estop_clear` is refused with `refused: the robot's ops e-stop is engaged; it clears when cerulion-remoted restarts`, and once it is clear `estop_clear` reaches rcpd as any tool call does. Every message's access is checked when it arrives. An Observe or Act message's access, and the e-stop latch for a tool call other than `estop`, are checked again on the open connection to rcpd just before the plane sends it; an `estop` is not checked again. A `notifications/cancelled` reaches rcpd after rcpd has taken the tool call it names, or once `--rcp-head-timeout-ms` passes. Only the `cerulion-remoted` daemon serves the rcp plane; a process that hosts the remote plane as a library serves none. While `CERULION_NETWORK` or `--network` engages the desk's kill-switch, `cerulion rcp` is refused with exit 2 before any sign-in and before it resolves the robot, and `cerulion-connectd rcp` refuses before it binds an endpoint. `cerulion_link` gains `read_frame_or_end`, which returns `Ok(None)` only for a finish at a frame boundary. - `cerulion-rcpd`'s `estop` tool queues the graph's e-stop frame before it logs a latch file or `intent` receipt it could not write. It used to write that error line first, through its synchronous stderr writer and while holding the lock that orders engages and clears, so a blocked stderr held the frame until the line was written. `estop_clear` now logs a receipt it could not write after it releases that lock, so its error line no longer holds an `estop` that waits for the lock. The error line for a receipt that could not be written, from any tool call or eye answer, is now also written after the receipt log's lock is released; an `estop` takes that lock before it queues its frame. - A `cerulion-vizd` started while `CERULION_NETWORK` or `CERULION_VIZD_NETWORK` engages the network kill switch sends no telemetry; a daemon already running keeps the setting it started with, and `cerulion viz` says so when it reuses one under the switch. The docs, the switch's `--help`, the LOCAL-ONLY notices of a run and the fail-closed warns of a run or a query say what the switch covers: robots, relays, hosted Cerulion services and telemetry, not signing in, so the login gate's sign-in, `login`, `logout` and `account` still work under it. - `cerulion-vizd` refuses a remote `attach` that pins a different `schema` than the topic's live remote tap was attached with, and names both schemas in the error. It used to answer `ok` with the new schema name while the mirror kept carrying the original type, and once a frame had decoded the reply paired that name with the frames' archetype while `status` and `list` kept the original schema. Detach the topic first to attach it with a different schema. - A URDF with a malformed number no longer loads with a limb drawn at the origin. Every `origin xyz`, `origin rpy`, `axis xyz` and mesh `scale` it supplies must be three finite numbers, where a bad value used to be read as zero; otherwise the model fails to load with an error naming the element, attribute, line and text. An absent attribute keeps its default. A configured motor joint that is not revolute or continuous is left still, with a warning naming it. - A camera topic's decoded picture is placed under the topic's frame in the viewer, where it was drawn at the world origin. The viz daemon's render queue holds 128 batches (it held 8) and takes in its backlog before each render, so two 500 Hz topics no longer drop whole batches and blank the camera pane until the next keyframe. The `status` worker block reports `absorbed_batches`. - A world-frame map cloud shows only its latest frame in the viewer, where the last eight frames were drawn over each other and every wall looked a voxel thick. A topic counts as a map when its name contains `world_cloud`, `cloud_world`, `map/cloud` or `cloud_map` (any case); other point clouds keep accumulating sweeps. A map topic stays in the world frame under a loaded URDF and is not mounted on the lidar link. - The viewer's 2D and 3D views always use the stage colour `#0b0d11` (it was `#10161f`), including views in a layout set with `set_blueprint`, which used to get the viewer's dark gradient. Point clouds coloured by intensity start at cerulean `#00c0ff` instead of pure blue; the green and red stops are unchanged. - `cerulion-vizd` answers `list` and `status` from the last gathered mirror attribution instead of reading the mirror registry first whenever that attribution had expired, so a slow registry no longer holds their reply past the control client's deadline. A mirror attached by the local path shows the `robot` the last `discover` or local `attach` read; those two still refresh it. - After a `detach`, `cerulion-vizd`'s `attach`, `list`, `status` and `discover` replies no longer name the retired mirror's robot for a topic a desk producer took over. A mirror-provenance read that started before a `detach` or a remote `attach` and finished after it was stored over the newer state; it is now refused. ## [1.0.0] - 2026-09-21 The first release of Cerulion. Its crates, binaries and Debian packages come from this tree. ### Changed - The crates live under `crates/`, the tooling under `tools/`, and the user API reference under `docs/user-api.md`. - The always-on window recorder is pinned and niced, and the dead-node walk left the live loop, so the multi-process round trip stays flat with the recorder on. - A credit-blocked producer parks on the credit word instead of polling. - A Flashback capture reads its frames after it snapshots its trace, and its coverage manifest marks every exit that left the close's final drain incomplete. - The network posture pair and the service drain-all take halves were removed (ABI 21); services take one message at a time by design. - Comments and documentation no longer carry internal tracker identifiers; the repository root holds the license, the readme, the changelog and the build manifests, with community files under `.github/` and legal files under `docs/legal/`. - The default log filter is quieter: the per-topic producer reconciliation is one compact line of counters, the recorder's clean finalize keeps its one completion line, and startup, worker drain, exit hygiene and clean-finalize bookkeeping moved to `debug`, so `recording written to ` is the last line of a recorded run and a verification's `replay PASS` is no longer preceded by paragraphs of accounting. The long-running verbs still print their `info` lifecycle lines (worker spawn, trace ring and ready-file names, topic provisioning, daemon boot). The daemon's first-use spawn is reported at `info` (a boot still waiting after two seconds is reported at `warn`, so the quiet verbs are never silent for the whole readiness wait), the zenoh no-listener line is filtered by default, and a node cdylib announces its log filter only when `RUST_LOG` is set. The multi-process supervisor's planning build no longer prints a reconciliation line for a graph that never ran. Release builds compile `debug` out (`tracing`'s `release_max_level_info`), so the demoted lines are absent from a release build of `cerulion` (which hosts the recorder, `cerulion bagd`) and of `cerulion-netd` at any `RUST_LOG`; binaries built without cargo's `--release` keep them. The `debug-logging` cargo feature cannot lift that ceiling, and the documentation no longer says it can. ### Added - Every `cerulion` command runs under an account. `cerulion login` signs a machine in once, with a short code to approve from a browser on any machine; later commands read the result locally and keep working offline. `login`, `completions`, `--help` and `--version` need no account. - The release installer provisions the compiler that built the release. Every platform archive now carries the compiler metadata of its own build beside the binaries, and `install.sh` installs that exact rustc and its Cargo through rustup, verifies the full commit hash, and only then activates the binaries, so the compiler that builds your nodes is the one that built the CLI loading them. A failed setup leaves the previously installed binaries in place, though a partly installed Rust toolchain can remain under rustup's own management. Existing rustup defaults, profiles and shell startup files are left alone, `CARGO_HOME` and `RUSTUP_HOME` are honored, and an installation that carries Rust without rustup is refused rather than replaced. Archives from before the metadata still install their binaries, with a warning that they cannot set Rust up. - The launch readme with the benchmark evidence packages, the benchmark charts on three platforms, the ROS 2 compatibility page and the second architecture panel. - New workspaces select the compiler that built the CLI. `cerulion workspace create` and `cerulion workspace init` write a `rust-toolchain.toml` naming that release with the minimal profile, so `cerulion node build` inside the workspace uses it without an environment variable. The file is written only when a rustup toolchain whose release and full commit hash match the CLI is already installed; the check is offline, installs nothing, and leaves rustup's default alone. A missing, custom, nightly or beta compiler produces a warning instead, and an existing `rust-toolchain` or `rust-toolchain.toml`, symlinks included, is preserved. Workspaces created before this keep using an explicit `RUSTUP_TOOLCHAIN=`. ### Fixed - A graph could abort with no panic text and no backtrace when the `cerulion` host and a node cdylib had been compiled by different rustc releases. A node crosses that boundary carrying Rust types whose layout the compiler chooses, and two releases can agree on every struct size and offset and still encode one of those types differently at run time, so the existing ABI-version check passed and the host then read a value the node never wrote and freed memory that was never initialized. A node cdylib now reports the compiler that built it, and the loader refuses a node whose compiler differs from the host's, naming both compilers and the two ways out: rebuild the node with the host's compiler, or reinstall the CLI with yours. `cerulion node build` also warns when the `rustc` on `PATH` reports a different release, while leaving Cargo's own compiler selection alone. This takes the node cdylib ABI from 21 to 22, so every prebuilt node cdylib must be rebuilt (`cerulion node build `) before it will load. - The examples cargo-check job skips the Go2 workspace and manifest-less directories; the fuzz job enters the crate at its new path.