diff --git a/.github/workflows/cdr-native.yml b/.github/workflows/cdr-native.yml
new file mode 100644
index 00000000000..55c20c9980f
--- /dev/null
+++ b/.github/workflows/cdr-native.yml
@@ -0,0 +1,69 @@
+name: CDR native interoperability
+
+on:
+  pull_request:
+  workflow_dispatch:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  native:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    env:
+      DIMOS_ALLOW_MISSING_COCKPIT: "1"
+      CARGO_TARGET_DIR: ${{ github.workspace }}/target
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          lfs: false
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@v10.2.0
+        with:
+          python-version: '3.12'
+          enable-cache: true
+      - uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.6.10
+      - name: Install build and media dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake pkg-config clang libclang-dev portaudio19-dev libturbojpeg ffmpeg
+      - name: Install Python project and test dependencies
+        run: uv sync --frozen --group tests
+      - name: Test SDK and build native consumers
+        run: |
+          cargo test --locked --manifest-path native/rust/dimos-module/Cargo.toml
+          cargo test --locked --manifest-path native/rust/dimos-module-macros/Cargo.toml
+          cargo test --locked --manifest-path dimos/mapping/ray_tracing/rust/Cargo.toml --lib
+          cargo test --locked --manifest-path dimos/navigation/global_planner/mls_planner/rust/Cargo.toml --lib
+          cargo test --locked --manifest-path dimos/navigation/local_planner/rust/Cargo.toml --features module,test-bodies
+          cargo test --locked --manifest-path dimos/navigation/trajectory_follower/fancy/rust/Cargo.toml --features module
+          cargo test --locked --manifest-path dimos/hardware/sensors/camera/v4l2/rust/Cargo.toml --lib
+          cargo check --locked --manifest-path dimos/perception/depth2depth_cloud/rust/Cargo.toml --lib
+          cargo check --locked --manifest-path dimos/hardware/sensors/camera/realsense/rust/Cargo.toml --all-targets --features docs-only
+          cargo build --locked --manifest-path dimos/mapping/ray_tracing/rust/Cargo.toml --bin voxel_ray_tracing
+          cargo build --locked --manifest-path dimos/navigation/global_planner/mls_planner/rust/Cargo.toml --bin mls_planner
+          cargo build --locked --manifest-path dimos/navigation/local_planner/rust/Cargo.toml --features module --bin local_planner
+          cargo build --locked --manifest-path dimos/navigation/trajectory_follower/fancy/rust/Cargo.toml --features module --bin trajectory_follower
+      - name: Prepare DimSim dependencies
+        working-directory: misc/DimSim/cli
+        run: deno install --node-modules-dir=auto --entrypoint bridge/cdr_test.ts
+      - name: Exchange generated messages with real native and TypeScript consumers
+        run: |
+          export DIMOS_NATIVE_RAY_TRACING_BINARY="$CARGO_TARGET_DIR/debug/voxel_ray_tracing"
+          export DIMOS_NATIVE_MLS_BINARY="$CARGO_TARGET_DIR/debug/mls_planner"
+          export DIMOS_NATIVE_LOCAL_PLANNER_BINARY="$CARGO_TARGET_DIR/debug/local_planner"
+          export DIMOS_NATIVE_FOLLOWER_BINARY="$CARGO_TARGET_DIR/debug/trajectory_follower"
+          export DIMOS_DIMSIM_DENO="$(command -v deno)"
+          uv run --no-sync pytest --noconftest --import-mode=importlib -o addopts='' -q \
+            dimos/mapping/ray_tracing/test_generated_native.py \
+            dimos/navigation/global_planner/mls_planner/test_generated_native.py \
+            dimos/navigation/local_planner/test_generated_native.py \
+            dimos/robot/unitree/test_dimsim_connection.py \
+            dimos/navigation/trajectory_follower/fancy/test_generated_native.py \
+            dimos/hardware/sensors/camera/realsense/test_camera.py \
+            dimos/perception/depth2depth_cloud/test_depth2depth_cloud_config.py
diff --git a/bin/generate-native-tf-messages b/bin/generate-native-tf-messages
new file mode 100755
index 00000000000..85706252620
--- /dev/null
+++ b/bin/generate-native-tf-messages
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# Copyright 2026 Dimensional Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Regenerate the SDK's standard TF message crate with dimos-cdrgen 0.1.2."""
+
+from importlib.metadata import version
+from pathlib import Path
+import shutil
+from tempfile import TemporaryDirectory
+
+from dimos_cdrgen.generate import generate
+
+root = Path(__file__).resolve().parents[1]
+crate = root / "native/rust/dimos-tf-messages"
+if version("dimos-cdrgen") != "0.1.2":
+    raise RuntimeError("Install dimos-cdrgen==0.1.2 before regenerating TF messages")
+with TemporaryDirectory() as temporary:
+    output = Path(temporary) / "generated"
+    generate(
+        [crate / "interfaces"],
+        output,
+        ["tf2_msgs/msg/TFMessage"],
+        module="dimos_tf",
+        version="0.1.0",
+        languages=("rust",),
+    )
+    shutil.copytree(output / "rust", crate, dirs_exist_ok=True)
+    generated_lib = crate / "src/lib.rs"
+    license_header = (crate / "build.rs").read_text().split("use ros2msg", 1)[0]
+    generated_lib.write_text(license_header + generated_lib.read_text())
diff --git a/native/message-source.nix b/native/message-source.nix
new file mode 100644
index 00000000000..d54683ac53e
--- /dev/null
+++ b/native/message-source.nix
@@ -0,0 +1,52 @@
+# Copyright 2026 Dimensional Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Generate the built-in definitions through the same configuration and core as pip.
+# Nix fetches fixed-hash inputs; the generation builder itself is offline.
+{ pkgs }:
+let
+  generatorWheel = pkgs.fetchurl {
+    url = "https://files.pythonhosted.org/packages/29/9f/a4fe6f8ea4dcafd3001c868ebbc751bb0af83aecb1fe6523765c12cdedba/dimos_cdrgen-0.1.2-py3-none-any.whl";
+    sha256 = "9857c8cc40de58b03f94cb81e7d27ae3caac98101c96cdaa2965413a332e685f";
+  };
+  generator = pkgs.runCommand "dimos-cdrgen-0.1.2-source" { nativeBuildInputs = [ pkgs.unzip ]; } ''
+    mkdir -p $out
+    unzip -q ${generatorWheel} -d $out
+  '';
+  python = pkgs.python3.withPackages (p: [
+    p.setuptools p.wheel p.pydantic p.empy p.lark p.rosbags p.numpy p.requests
+  ]);
+  product = pkgs.lib.fileset.toSource {
+    root = ../.;
+    fileset = pkgs.lib.fileset.unions [
+      ../pyproject.toml
+      ../dimos/message_codegen/build.py
+      ../packages/dimos-generated/schema-sources.json
+      ../packages/dimos-generated/custom
+    ];
+  };
+  schemaLock = builtins.fromJSON (builtins.readFile ../packages/dimos-generated/schema-sources.json);
+  schemaArchives = map (source: {
+    name = builtins.hashString "sha256" source.url + ".tar.gz";
+    archive = pkgs.fetchurl { inherit (source) url sha256; };
+  }) schemaLock.sources;
+  source = pkgs.runCommand "dimos-generated-message-source" { nativeBuildInputs = [ python ]; } ''
+    cp -r ${product} product
+    chmod -R u+w product
+    mkdir -p cache/archives
+    ${pkgs.lib.concatMapStringsSep "\n" (item: "cp ${item.archive} cache/archives/${item.name}") schemaArchives}
+    export PYTHONPATH="$PWD/product:${generator}:$PYTHONPATH"
+    python3 - <<'PYTHON'
+from pathlib import Path
+from dimos.message_codegen.build import prepare_builtin_sources
+from dimos_cdrgen.source_package import prepare
+prepare_builtin_sources(Path("cache"), offline=True)
+prepare(Path("product"))
+PYTHON
+    cp -r product/build/message-source $out
+    test -f $out/cpp/CMakeLists.txt
+    test -f $out/rust/Cargo.toml
+  '';
+in {
+  inherit generator python source;
+}
diff --git a/native/rust/dimos-module-macros/src/lib.rs b/native/rust/dimos-module-macros/src/lib.rs
index af89a0680b4..ff19a4af1ad 100644
--- a/native/rust/dimos-module-macros/src/lib.rs
+++ b/native/rust/dimos-module-macros/src/lib.rs
@@ -454,20 +454,33 @@ fn port_decls(classified: &[ClassifiedField], want_input: bool) -> Vec<PortDecl>
             FieldKind::Tf => want_input,
             _ => false,
         })
-        .map(|f| PortDecl {
-            name: f.name.to_string(),
-            // `Tf` carries no generic payload. The port is TFMessage by
-            // construction.
-            // An explicit `msg` wins: a view type's wire payload and the dimos
-            // message it stands for are allowed to differ.
-            ty: match f.kind {
-                FieldKind::Tf => TF_PAYLOAD_TYPE.to_string(),
-                _ => f
-                    .msg
-                    .clone()
-                    .or_else(|| port_payload_type(f.ty))
-                    .unwrap_or_default(),
-            },
+        .flat_map(|f| {
+            let port = PortDecl {
+                name: f.name.to_string(),
+                // `Tf` carries no generic payload. The port is TFMessage by
+                // construction.
+                // An explicit `msg` wins: a view type's wire payload and the dimos
+                // message it stands for are allowed to differ.
+                ty: match f.kind {
+                    FieldKind::Tf => TF_PAYLOAD_TYPE.to_string(),
+                    _ => f
+                        .msg
+                        .clone()
+                        .or_else(|| port_payload_type(f.ty))
+                        .unwrap_or_default(),
+                },
+            };
+            if matches!(f.kind, FieldKind::Tf) {
+                vec![
+                    port,
+                    PortDecl {
+                        name: "tf_static".into(),
+                        ty: TF_PAYLOAD_TYPE.into(),
+                    },
+                ]
+            } else {
+                vec![port]
+            }
         })
         .collect()
 }
@@ -537,7 +550,7 @@ fn check_port_table(entry: &toml::Value, kind: &str, declared: &[PortDecl]) -> R
         let msg = msg
             .as_str()
             .ok_or_else(|| format!("`{kind}.{}` must be a string", port.name))?;
-        let want = msg.rsplit('.').next().unwrap_or(msg);
+        let want = msg.rsplit(['.', '/']).next().unwrap_or(msg);
         if want != port.ty {
             return Err(format!(
                 "port `{}` is declared `{msg}` in `{kind}` but the struct field carries `{}`",
@@ -649,6 +662,12 @@ fn classify_field(field: &Field, name: &Ident) -> syn::Result<FieldAttr> {
             if found.is_some() {
                 return Err(syn::Error::new_spanned(attr, ONE_ATTR_ONLY));
             }
+            if !matches!(&attr.meta, syn::Meta::Path(_)) {
+                return Err(syn::Error::new_spanned(
+                    attr,
+                    "#[tf] uses standard ROS TF messages and takes no codec arguments",
+                ));
+            }
             found = Some(FieldKind::Tf);
         }
     }
@@ -736,6 +755,36 @@ mod tests {
     };
     use syn::parse_quote;
 
+    #[test]
+    fn tf_accepts_legacy_or_explicit_codec_pair_and_keeps_registry_type() {
+        for field in [parse_quote!(#[tf] tf: Tf)] {
+            let attr = super::classify_field(&field, &parse_quote!(tf)).expect("valid TF field");
+            let ty: syn::Type = parse_quote!(Tf);
+            let name = parse_quote!(tf);
+            let fields = [ClassifiedField {
+                name: &name,
+                ty: &ty,
+                kind: attr.kind,
+                msg: attr.msg,
+            }];
+            let ports = super::port_decls(&fields, true);
+            assert_eq!(ports.len(), 2);
+            assert_eq!(ports[0].ty, "TFMessage");
+            assert_eq!(ports[1].name, "tf_static");
+        }
+    }
+
+    #[test]
+    fn tf_rejects_partial_or_unknown_codec_settings() {
+        for field in [
+            parse_quote!(#[tf(decode = wire::decode)] tf: Tf),
+            parse_quote!(#[tf(encode = wire::encode)] tf: Tf),
+            parse_quote!(#[tf(codec = wire::codec)] tf: Tf),
+        ] {
+            assert!(super::classify_field(&field, &parse_quote!(tf)).is_err());
+        }
+    }
+
     #[test]
     fn io_ports_are_rejected_by_the_registry_check() {
         let name: syn::LitStr = parse_quote!("demo");
@@ -790,6 +839,29 @@ mod tests {
         .expect("matching ports should pass");
     }
 
+    #[test]
+    fn accepts_canonical_cdr_names_and_still_rejects_type_mismatch() {
+        let manifest = MANIFEST.replace("sensor_msgs.PointCloud2", "sensor_msgs/msg/PointCloud2");
+        check_manifest_ports(
+            &manifest,
+            "demo",
+            &[port("lidar", "PointCloud2")],
+            &[port("global_map", "PointCloud2")],
+        )
+        .expect("canonical ROS message names match their imported Rust type");
+        let err = check_manifest_ports(
+            &manifest,
+            "demo",
+            &[port("lidar", "Image")],
+            &[port("global_map", "PointCloud2")],
+        )
+        .expect_err("canonical names must still enforce the payload type");
+        assert!(
+            err.contains("sensor_msgs/msg/PointCloud2") && err.contains("Image"),
+            "{err}"
+        );
+    }
+
     #[test]
     fn rejects_missing_metadata_section() {
         let err = check_manifest_ports(MANIFEST, "other", &[], &[])
diff --git a/native/rust/dimos-module/Cargo.lock b/native/rust/dimos-module/Cargo.lock
index cbd83d0f707..7143d4af75a 100644
--- a/native/rust/dimos-module/Cargo.lock
+++ b/native/rust/dimos-module/Cargo.lock
@@ -249,6 +249,15 @@ dependencies = [
  "shlex",
 ]
 
+[[package]]
+name = "cdr"
+version = "0.2.4"
+source = "git+https://github.com/TomCC7/cdr-rs?rev=38a4368255d408faf374726653b39d4a4e9735cb#38a4368255d408faf374726653b39d4a4e9735cb"
+dependencies = [
+ "byteorder",
+ "serde",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -582,7 +591,7 @@ dependencies = [
 [[package]]
 name = "dimos-lcm"
 version = "0.1.0"
-source = "git+https://github.com/dimensionalOS/dimos-lcm.git?branch=rust-codegen#04d78e8622500244123ba9cefa4c51b4cb454549"
+source = "git+https://github.com/dimensionalOS/dimos-lcm.git?rev=04d78e8622500244123ba9cefa4c51b4cb454549#04d78e8622500244123ba9cefa4c51b4cb454549"
 dependencies = [
  "byteorder",
  "socket2 0.5.10",
@@ -591,10 +600,12 @@ dependencies = [
 
 [[package]]
 name = "dimos-module"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
+ "cdr",
  "dimos-lcm",
  "dimos-module-macros",
+ "dimos-tf-messages",
  "lcm-msgs",
  "nalgebra",
  "rayon",
@@ -604,6 +615,7 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "tracing-test",
+ "transforms",
  "url",
  "validator",
  "zenoh",
@@ -619,6 +631,17 @@ dependencies = [
  "toml 1.1.6+spec-1.1.0",
 ]
 
+[[package]]
+name = "dimos-tf-messages"
+version = "0.1.0"
+dependencies = [
+ "cdr",
+ "heapless",
+ "ros2msg",
+ "serde",
+ "serde-big-array",
+]
+
 [[package]]
 name = "dirs"
 version = "6.0.0"
@@ -950,6 +973,15 @@ version = "0.33.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e762b9b188634fc508d4ec54b62ea3d352c43fd431d18d05d46f559f217f4725"
 
+[[package]]
+name = "hash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -991,6 +1023,28 @@ name = "hashbrown"
 version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "serde",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hermit-abi"
@@ -1385,7 +1439,7 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 [[package]]
 name = "lcm-msgs"
 version = "0.1.0"
-source = "git+https://github.com/dimensionalOS/dimos-lcm.git?branch=rust-codegen#04d78e8622500244123ba9cefa4c51b4cb454549"
+source = "git+https://github.com/dimensionalOS/dimos-lcm.git?rev=04d78e8622500244123ba9cefa4c51b4cb454549#04d78e8622500244123ba9cefa4c51b4cb454549"
 dependencies = [
  "byteorder",
 ]
@@ -1926,6 +1980,16 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "3.5.0"
@@ -2280,6 +2344,23 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "ros2msg"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fe291be5cb6d4b8e6bf9c9de80c40bd1cb09ecac50deafa2fdcae0027e04988"
+dependencies = [
+ "heck",
+ "pest",
+ "pest_derive",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "syn 2.0.119",
+ "thiserror",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.3"
@@ -2520,6 +2601,15 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-big-array"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11fc7cc2c76d73e0f27ee52abbd64eec84d46f370c88371120433196934e4b7f"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.229"
@@ -3216,6 +3306,18 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "transforms"
+version = "2.2.0"
+source = "git+https://github.com/TomCC7/transforms?rev=5ae9563de0c02638c04e393aadfad28444a4398e#5ae9563de0c02638c04e393aadfad28444a4398e"
+dependencies = [
+ "approx",
+ "hashbrown 0.17.1",
+ "libm",
+ "serde",
+ "thiserror",
+]
+
 [[package]]
 name = "twox-hash"
 version = "1.6.3"
diff --git a/native/rust/dimos-module/Cargo.toml b/native/rust/dimos-module/Cargo.toml
index b79f793a92c..57cb27bd429 100644
--- a/native/rust/dimos-module/Cargo.toml
+++ b/native/rust/dimos-module/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "dimos-module"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 description = "Rust native module SDK for dimos NativeModule framework"
 license = "Apache-2.0"
@@ -8,9 +8,12 @@ license = "Apache-2.0"
 [workspace]
 
 [dependencies]
-dimos-lcm = { git = "https://github.com/dimensionalOS/dimos-lcm.git", branch = "rust-codegen" }
+dimos-tf-messages = { path = "../dimos-tf-messages" }
+transforms = { version = "=2.2.0", git = "https://github.com/TomCC7/transforms", rev = "5ae9563de0c02638c04e393aadfad28444a4398e" }
+cdr = { version = "=0.2.4", git = "https://github.com/TomCC7/cdr-rs", rev = "38a4368255d408faf374726653b39d4a4e9735cb" }
+dimos-lcm = { git = "https://github.com/dimensionalOS/dimos-lcm.git", rev = "04d78e8622500244123ba9cefa4c51b4cb454549" }
 dimos-module-macros = { version = "=0.1.0", path = "../dimos-module-macros" }
-lcm-msgs = { git = "https://github.com/dimensionalOS/dimos-lcm.git", branch = "rust-codegen" }
+lcm-msgs = { git = "https://github.com/dimensionalOS/dimos-lcm.git", rev = "04d78e8622500244123ba9cefa4c51b4cb454549" }
 nalgebra = "0.35.0"
 rayon = "1"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "sync", "time", "signal", "io-std", "io-util"] }
diff --git a/native/rust/dimos-module/README.md b/native/rust/dimos-module/README.md
new file mode 100644
index 00000000000..77054406d08
--- /dev/null
+++ b/native/rust/dimos-module/README.md
@@ -0,0 +1,28 @@
+# Native module SDK
+
+`#[tf]` binds standard `tf2_msgs/TFMessage` streams named `tf` and `tf_static`.
+Both ports must appear in the native module registry and Python wrapper.
+The SDK uses generated `TransformStamped` and `Time` values directly. TF
+fields accept no codec parameters; CDR is the default wire format.
+
+`lookup_transform(target, source, time)` maps source coordinates into the
+target frame. ROS zero time selects the latest common time. `lookup().at()`
+also takes a ROS `Time`; `within()` waits for missing data. Lookups interpolate
+and reject extrapolation. The `transforms` library owns the frame tree,
+history, composition and interpolation. Its current registry pins each child's
+parent and static/dynamic kind; changing either requires rebuilding the buffer.
+
+`publish()` sends dynamic transforms and `publish_static()` sends static
+transforms. Static edges never expire from a receiving buffer and do not
+constrain the common time of a dynamic chain. Invalid batches do not change
+the graph or enqueue a packet. A failed publication queue leaves the graph
+unchanged.
+
+The SDK's LCM and Zenoh transports do not provide ROS DDS transient-local
+history. A static publisher must remain available and reannounce its complete
+mount set for late subscribers. Existing Python static-mount publishers still
+reannounce on dynamic `tf` for compatibility with the Python query layer; they
+have not been migrated to `tf_static` in this SDK change.
+
+Older modules pinned to SDK 0.1.0 retain their explicit legacy wire path. SDK
+0.2.0 does not fall back to legacy TF decoding.
diff --git a/native/rust/dimos-module/src/cdr.rs b/native/rust/dimos-module/src/cdr.rs
new file mode 100644
index 00000000000..833ac0976bd
--- /dev/null
+++ b/native/rust/dimos-module/src/cdr.rs
@@ -0,0 +1,123 @@
+// Copyright 2026 Dimensional Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! SDK error and message-boundary adapter for the upstream complete CDR codec.
+use ::cdr::{CdrBe, CdrLe, Infinite};
+use serde::{de::DeserializeOwned, Serialize};
+use std::io::{self, Cursor};
+
+pub fn encode<T: Serialize>(message: &T) -> io::Result<Vec<u8>> {
+    encode_endian(message, true)
+}
+
+pub fn encode_endian<T: Serialize>(message: &T, little_endian: bool) -> io::Result<Vec<u8>> {
+    if little_endian {
+        ::cdr::serialize::<_, _, CdrLe>(message, Infinite)
+    } else {
+        ::cdr::serialize::<_, _, CdrBe>(message, Infinite)
+    }
+    .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))
+}
+
+pub fn decode<T: DeserializeOwned>(bytes: &[u8]) -> io::Result<T> {
+    // The SDK accepts standalone plain XCDR1, not parameter lists or other DDS representations.
+    if !matches!(bytes.get(..4), Some([0, 0 | 1, 0, 0])) {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "Expected plain CDR/XCDR1 encapsulation",
+        ));
+    }
+    let mut reader = Cursor::new(bytes);
+    let value = ::cdr::deserialize_from(&mut reader, ::cdr::Bounded(bytes.len() as u64))
+        .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
+    if reader.position() != bytes.len() as u64 {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            "Trailing bytes after CDR message",
+        ));
+    }
+    Ok(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Int32 {
+        data: i32,
+    }
+
+    #[test]
+    fn literal_bytes_match_ros_cdr_in_both_byte_orders() {
+        let value = Int32 { data: 42 };
+        assert_eq!(encode(&value).unwrap(), vec![0, 1, 0, 0, 42, 0, 0, 0]);
+        assert_eq!(
+            encode_endian(&value, false).unwrap(),
+            vec![0, 0, 0, 0, 0, 0, 0, 42]
+        );
+        assert_eq!(decode::<Int32>(&[0, 1, 0, 0, 42, 0, 0, 0]).unwrap(), value);
+        assert_eq!(decode::<Int32>(&[0, 0, 0, 0, 0, 0, 0, 42]).unwrap(), value);
+    }
+
+    #[test]
+    fn serialization_failure_is_an_error() {
+        struct Unencodable;
+        impl Serialize for Unencodable {
+            fn serialize<S: serde::Serializer>(&self, _: S) -> Result<S::Ok, S::Error> {
+                Err(serde::ser::Error::custom("invalid message"))
+            }
+        }
+        assert_eq!(
+            encode(&Unencodable).unwrap_err().kind(),
+            io::ErrorKind::InvalidInput
+        );
+    }
+
+    #[test]
+    fn oversized_or_unterminated_strings_fail_at_the_library_boundary() {
+        for bytes in [
+            vec![0, 1, 0, 0, 255, 255, 255, 255],
+            vec![0, 1, 0, 0, 0, 0, 0, 0],
+            vec![0, 1, 0, 0, 2, 0, 0, 0, b'a', b'b'],
+        ] {
+            assert_eq!(
+                decode::<String>(&bytes).unwrap_err().kind(),
+                io::ErrorKind::InvalidData
+            );
+        }
+        assert_eq!(
+            decode::<String>(&encode(&"相机/café").unwrap()).unwrap(),
+            "相机/café"
+        );
+    }
+
+    #[test]
+    fn reject_wrong_encapsulation_truncation_and_trailing_bytes() {
+        for bytes in [
+            vec![],
+            vec![1, 1, 0, 0, 42, 0, 0, 0],
+            vec![0, 1, 1, 0, 42, 0, 0, 0],
+            vec![0, 1, 0, 0, 42],
+            vec![0, 3, 0, 0, 42, 0, 0, 0],
+            vec![0, 1, 0, 0, 42, 0, 0, 0, 0],
+        ] {
+            assert_eq!(
+                decode::<Int32>(&bytes).unwrap_err().kind(),
+                io::ErrorKind::InvalidData
+            );
+        }
+    }
+}
diff --git a/native/rust/dimos-module/src/host.rs b/native/rust/dimos-module/src/host.rs
index cc7982b7e55..fa01c48f320 100644
--- a/native/rust/dimos-module/src/host.rs
+++ b/native/rust/dimos-module/src/host.rs
@@ -891,7 +891,7 @@ mod tests {
         fn build(builder: &mut Builder, config: ProbeConfig) -> Self {
             Self {
                 key: config.key,
-                ping: builder.output("ping", |b: &Vec<u8>| b.clone()),
+                ping: builder.output("ping", |b: &Vec<u8>| Ok(b.clone())),
             }
         }
 
diff --git a/native/rust/dimos-module/src/lib.rs b/native/rust/dimos-module/src/lib.rs
index 5816445c3f4..c2345519993 100644
--- a/native/rust/dimos-module/src/lib.rs
+++ b/native/rust/dimos-module/src/lib.rs
@@ -17,6 +17,7 @@
 #[cfg(test)]
 extern crate self as dimos_module;
 
+pub mod cdr;
 pub mod host;
 pub mod lcm;
 pub mod log;
@@ -32,7 +33,7 @@ pub use dimos_module_macros::{native_config, Module};
 pub use host::{host_main, HostSpec, ModuleEntry};
 pub use lcm::LcmTransport;
 pub use module::{run, Builder, Input, Io, Module, ModuleConfig, NativeConfig, NoConfig, Output};
-pub use tf::{Lookup, Tf, Transform};
+pub use tf::{Lookup, Tf, TransformStamped};
 pub use transport::{SharedTransport, Transport};
 pub use workers::worker_pool;
 pub use zenoh::ZenohTransport;
diff --git a/native/rust/dimos-module/src/module.rs b/native/rust/dimos-module/src/module.rs
index 23fe965ba36..75b5aa44a94 100644
--- a/native/rust/dimos-module/src/module.rs
+++ b/native/rust/dimos-module/src/module.rs
@@ -123,13 +123,13 @@ impl<T> Input<T> {
 #[derive(Clone)]
 pub struct Output<T> {
     pub topic: String,
-    encode: fn(&T) -> Vec<u8>,
+    encode: fn(&T) -> io::Result<Vec<u8>>,
     sender: mpsc::Sender<Vec<u8>>,
 }
 
 impl<T> Output<T> {
     pub async fn publish(&self, msg: &T) -> io::Result<()> {
-        publish_encoded(&self.sender, (self.encode)(msg)).await
+        publish_encoded(&self.sender, (self.encode)(msg)?).await
     }
 }
 
@@ -140,7 +140,7 @@ impl<T> Output<T> {
 pub struct Io<T> {
     pub topic: String,
     receiver: mpsc::Receiver<T>,
-    encode: fn(&T) -> Vec<u8>,
+    encode: fn(&T) -> io::Result<Vec<u8>>,
     sender: mpsc::Sender<Vec<u8>>,
 }
 
@@ -150,7 +150,7 @@ impl<T> Io<T> {
     }
 
     pub async fn publish(&self, msg: &T) -> io::Result<()> {
-        publish_encoded(&self.sender, (self.encode)(msg)).await
+        publish_encoded(&self.sender, (self.encode)(msg)?).await
     }
 }
 
@@ -386,7 +386,7 @@ impl Builder {
         Input { topic, receiver }
     }
 
-    pub fn output<T>(&mut self, port: &str, encode: fn(&T) -> Vec<u8>) -> Output<T> {
+    pub fn output<T>(&mut self, port: &str, encode: fn(&T) -> io::Result<Vec<u8>>) -> Output<T> {
         let topic = self.topic_for(port);
         let sender = self.add_publisher(&topic);
         Output {
@@ -401,7 +401,7 @@ impl Builder {
         &mut self,
         port: &str,
         decode: fn(&[u8]) -> io::Result<T>,
-        encode: fn(&T) -> Vec<u8>,
+        encode: fn(&T) -> io::Result<Vec<u8>>,
     ) -> Io<T> {
         let topic = self.topic_for(port);
         let receiver = self.add_route(&topic, decode);
@@ -414,19 +414,22 @@ impl Builder {
         }
     }
 
-    /// A handle that answers transform queries and publishes on the `tf` topic.
-    ///
-    /// The graph fills in the background as `tf` messages arrive. Repeated calls
-    /// share one graph.
+    /// Standard ROS TF streams. Dynamic and static messages share one frame tree.
     pub fn tf(&mut self) -> crate::tf::Tf {
         if let Some(tf) = &self.tf {
             return tf.clone();
         }
         let topic = self.topic_for("tf");
+        let static_topic = self.topic_for("tf_static");
         let sender = self.add_publisher(&topic);
-        let (tf, route) =
-            crate::tf::tf_subscription(topic.clone(), crate::tf::DEFAULT_TF_WINDOW_SECS, sender);
+        let static_sender = self.add_publisher(&static_topic);
+        let (tf, route, static_route) =
+            crate::tf::tf_subscription(sender, static_sender, crate::tf::DEFAULT_TF_WINDOW);
         self.routes.entry(topic).or_default().push(route);
+        self.routes
+            .entry(static_topic)
+            .or_default()
+            .push(static_route);
         self.tf = Some(tf.clone());
         tf
     }
@@ -942,7 +945,7 @@ mod tests {
     #[test]
     fn output_uses_mapped_topic() {
         let mut builder = builder_with_topics(&[("cmd_vel", "/robot/cmd_vel")]);
-        let output = builder.output("cmd_vel", |b: &Vec<u8>| b.clone());
+        let output = builder.output("cmd_vel", |b: &Vec<u8>| Ok(b.clone()));
         assert_eq!(output.topic, "/robot/cmd_vel");
     }
 
@@ -950,7 +953,7 @@ mod tests {
     fn topics_matching_ports_exactly_pass() {
         let mut builder = builder_with_topics(&[("cmd", "/robot/cmd"), ("odom", "/robot/odom")]);
         builder.input("cmd", |b| Ok(b.to_vec()));
-        builder.output("odom", |b: &Vec<u8>| b.clone());
+        builder.output("odom", |b: &Vec<u8>| Ok(b.clone()));
         builder.enforce_topics_match_ports().expect("exact match");
     }
 
@@ -958,7 +961,7 @@ mod tests {
     fn a_port_the_coordinator_never_sent_is_rejected() {
         let mut builder = builder_with_topics(&[("cmd", "/robot/cmd")]);
         builder.input("cmd", |b| Ok(b.to_vec()));
-        builder.output("odom", |b: &Vec<u8>| b.clone());
+        builder.output("odom", |b: &Vec<u8>| Ok(b.clone()));
         let err = builder
             .enforce_topics_match_ports()
             .expect_err("odom has no topic");
@@ -977,7 +980,10 @@ mod tests {
 
     #[test]
     fn a_tf_field_claims_the_tf_topic() {
-        let mut builder = builder_with_topics(&[("tf", "/tf#tf2_msgs.TFMessage")]);
+        let mut builder = builder_with_topics(&[
+            ("tf", "/tf#tf2_msgs.TFMessage"),
+            ("tf_static", "/tf_static#tf2_msgs.TFMessage"),
+        ]);
         builder.tf();
         builder.enforce_topics_match_ports().expect("tf claimed");
     }
@@ -993,14 +999,14 @@ mod tests {
     #[test]
     fn io_uses_mapped_topic() {
         let mut builder = builder_with_topics(&[("cmd", "/robot/cmd")]);
-        let io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| b.clone());
+        let io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| Ok(b.clone()));
         assert_eq!(io.topic, "/robot/cmd");
     }
 
     #[test]
     fn io_registers_one_route_and_one_publisher_on_the_same_topic() {
         let mut builder = builder_with_topics(&[("cmd", "/robot/cmd")]);
-        let _io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| b.clone());
+        let _io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| Ok(b.clone()));
         assert_eq!(builder.routes.get("/robot/cmd").map(Vec::len), Some(1));
         assert_eq!(builder.outputs.len(), 1);
         assert_eq!(builder.outputs[0].0, "/robot/cmd");
@@ -1009,7 +1015,7 @@ mod tests {
     #[tokio::test]
     async fn io_receives_on_its_route_and_publishes_to_its_queue() {
         let mut builder = builder_with_topics(&[("cmd", "/robot/cmd")]);
-        let mut io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| b.clone());
+        let mut io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| Ok(b.clone()));
 
         builder.routes["/robot/cmd"][0].try_dispatch(b"inbound");
         assert_eq!(io.recv().await.expect("inbound message"), b"inbound");
@@ -1022,7 +1028,7 @@ mod tests {
     #[tokio::test]
     async fn io_publish_errors_when_the_publish_worker_is_gone() {
         let mut builder = builder_with_topics(&[]);
-        let io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| b.clone());
+        let io = builder.io("cmd", |b| Ok(b.to_vec()), |b: &Vec<u8>| Ok(b.clone()));
         builder.outputs.clear();
         let err = io
             .publish(&b"x".to_vec())
@@ -1044,10 +1050,44 @@ mod tests {
         let mut builder = builder_with_topics(&[("tf", "/tf")]);
         builder.tf();
         builder.tf();
-        assert_eq!(builder.outputs.len(), 1);
+        assert_eq!(builder.outputs.len(), 2);
         assert_eq!(builder.routes.get("/tf").map(Vec::len), Some(1));
     }
 
+    #[tokio::test]
+    async fn port_encode_error_does_not_enqueue_or_close_the_port() {
+        fn encode(value: &Vec<u8>) -> io::Result<Vec<u8>> {
+            if value == b"bad" {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "encoding failed",
+                ));
+            }
+            Ok(value.clone())
+        }
+        let mut builder = builder_with_topics(&[("output", "/out"), ("io", "/io")]);
+        let output = builder.output("output", encode);
+        let io = builder.io("io", |bytes| Ok(bytes.to_vec()), encode);
+        assert_eq!(
+            output.publish(&b"bad".to_vec()).await.unwrap_err().kind(),
+            io::ErrorKind::InvalidInput
+        );
+        assert_eq!(
+            io.publish(&b"bad".to_vec()).await.unwrap_err().kind(),
+            io::ErrorKind::InvalidInput
+        );
+        for (_, receiver) in &mut builder.outputs {
+            assert!(matches!(
+                receiver.try_recv(),
+                Err(tokio::sync::mpsc::error::TryRecvError::Empty)
+            ));
+        }
+        output.publish(&b"out".to_vec()).await.unwrap();
+        io.publish(&b"io".to_vec()).await.unwrap();
+        assert_eq!(builder.outputs[0].1.recv().await.unwrap(), b"out");
+        assert_eq!(builder.outputs[1].1.recv().await.unwrap(), b"io");
+    }
+
     // recv/publish concurrency
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -1065,7 +1105,7 @@ mod tests {
 
         let mut builder = Builder::new(topics(&[("data", "/data"), ("out", "/out")]));
         let _input = builder.input("data", |b| Ok(b.to_vec()));
-        let output = builder.output("out", |b: &Vec<u8>| b.clone());
+        let output = builder.output("out", |b: &Vec<u8>| Ok(b.clone()));
 
         subscribe_routes(&transport, builder.routes).await.unwrap();
         let transport = Arc::new(transport);
@@ -1115,7 +1155,7 @@ mod tests {
             }
             Ok(b.to_vec())
         });
-        let output = builder.output("out", |b: &Vec<u8>| b.clone());
+        let output = builder.output("out", |b: &Vec<u8>| Ok(b.clone()));
 
         subscribe_routes(&transport, builder.routes).await.unwrap();
         let transport = Arc::new(transport);
@@ -1166,8 +1206,8 @@ mod tests {
         });
 
         let mut builder = Builder::new(topics(&[("block_out", "/block"), ("fast_out", "/fast")]));
-        let block_out = builder.output("block_out", |b: &Vec<u8>| b.clone());
-        let fast_out = builder.output("fast_out", |b: &Vec<u8>| b.clone());
+        let block_out = builder.output("block_out", |b: &Vec<u8>| Ok(b.clone()));
+        let fast_out = builder.output("fast_out", |b: &Vec<u8>| Ok(b.clone()));
         let _pub_tasks = spawn_publish_tasks(Arc::clone(&transport), builder.outputs);
 
         // Wedge the block channel, then publish on the fast channel.
@@ -1278,8 +1318,8 @@ mod tests {
             Ok(Msg(bytes.to_vec()))
         }
 
-        fn encode(msg: &Msg) -> Vec<u8> {
-            msg.0.clone()
+        fn encode(msg: &Msg) -> io::Result<Vec<u8>> {
+            Ok(msg.0.clone())
         }
 
         #[derive(crate::Module)]
diff --git a/native/rust/dimos-module/src/pointcloud.rs b/native/rust/dimos-module/src/pointcloud.rs
index 31b8ef0aee6..1e6b7ddba7a 100644
--- a/native/rust/dimos-module/src/pointcloud.rs
+++ b/native/rust/dimos-module/src/pointcloud.rs
@@ -58,45 +58,78 @@ pub fn extract_xyz(msg: &PointCloud2) -> Result<Vec<[f32; 3]>, ExtractError> {
     if step == 0 {
         return Err(ExtractError("point_step is 0"));
     }
-    let n = count(msg.width, "negative width")?
-        .checked_mul(count(msg.height, "negative height")?)
-        .ok_or(ExtractError("width*height overflows"))?;
-    let needed = n
+    let width = count(msg.width, "negative width")?;
+    let height = count(msg.height, "negative height")?;
+    let row_step = width
         .checked_mul(step)
-        .ok_or(ExtractError("width*height*point_step overflows"))?;
-    if msg.data.len() < needed {
-        return Err(ExtractError(
-            "data buffer shorter than width*height*point_step",
-        ));
-    }
-    for off in [xo, yo, zo] {
-        if off.checked_add(4).is_none_or(|end| end > step) {
+        .ok_or(ExtractError("row size overflows"))?;
+    extract_xyz_rows(
+        &msg.data,
+        [width, height],
+        [step, row_step],
+        [xo, yo, zo],
+        false,
+    )
+}
+
+/// Read finite float32 xyz values from validated field offsets, respecting row padding.
+/// Message adapters retain their own schema types and pass only the wire layout here.
+pub fn extract_xyz_rows(
+    data: &[u8],
+    dimensions: [usize; 2],
+    steps: [usize; 2],
+    offsets: [usize; 3],
+    big_endian: bool,
+) -> Result<Vec<[f32; 3]>, ExtractError> {
+    let [width, height] = dimensions;
+    let [step, row_step] = steps;
+    if step == 0 {
+        return Err(ExtractError("point_step is 0"));
+    }
+    let packed = width
+        .checked_mul(step)
+        .ok_or(ExtractError("row size overflows"))?;
+    if row_step < packed {
+        return Err(ExtractError("row_step is shorter than a row"));
+    }
+    let needed = height
+        .checked_mul(row_step)
+        .ok_or(ExtractError("row buffer size overflows"))?;
+    if data.len() < needed {
+        return Err(ExtractError("data buffer shorter than rows"));
+    }
+    for offset in offsets {
+        if offset.checked_add(4).is_none_or(|end| end > step) {
             return Err(ExtractError(
                 "xyz field offsets do not fit within point_step",
             ));
         }
     }
-
-    let mut out = Vec::with_capacity(n);
-    for base in (0..needed).step_by(step) {
-        let x = read_f32_le(&msg.data, base + xo);
-        let y = read_f32_le(&msg.data, base + yo);
-        let z = read_f32_le(&msg.data, base + zo);
-        if x.is_finite() && y.is_finite() && z.is_finite() {
-            out.push([x, y, z]);
+    let mut out = Vec::new();
+    if width == 0 || height == 0 {
+        return Ok(out);
+    }
+    for row in 0..height {
+        for column in 0..width {
+            let base = row * row_step + column * step;
+            let point = offsets.map(|offset| {
+                let bytes: [u8; 4] = data[base + offset..base + offset + 4]
+                    .try_into()
+                    .expect("bounds checked above");
+                if big_endian {
+                    f32::from_be_bytes(bytes)
+                } else {
+                    f32::from_le_bytes(bytes)
+                }
+            });
+            if point.iter().all(|value| value.is_finite()) {
+                out.push(point);
+            }
         }
     }
     Ok(out)
 }
 
-#[inline]
-fn read_f32_le(buf: &[u8], off: usize) -> f32 {
-    let bytes: [u8; 4] = buf[off..off + 4]
-        .try_into()
-        .expect("bounds checked by caller");
-    f32::from_le_bytes(bytes)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -129,6 +162,40 @@ mod tests {
         }
     }
 
+    #[test]
+    fn padded_rows_and_both_byte_orders_preserve_finite_points() {
+        for big_endian in [false, true] {
+            let mut bytes = Vec::new();
+            for xyz in [[1.0f32, 2.0, 3.0], [4.0, 5.0, 6.0]] {
+                for value in xyz {
+                    bytes.extend(if big_endian {
+                        value.to_be_bytes()
+                    } else {
+                        value.to_le_bytes()
+                    });
+                }
+                bytes.extend([255u8; 4]);
+            }
+            assert_eq!(
+                extract_xyz_rows(&bytes, [1, 2], [12, 16], [0, 4, 8], big_endian).unwrap(),
+                vec![[1., 2., 3.], [4., 5., 6.]]
+            );
+        }
+    }
+
+    #[test]
+    fn malformed_row_layouts_are_rejected_before_allocation_or_indexing() {
+        for (dimensions, steps, offsets) in [
+            ([1, 1], [12, 11], [0, 4, 8]),
+            ([1, 2], [12, 16], [0, 4, 8]),
+            ([1, 1], [12, 12], [0, 4, usize::MAX]),
+            ([usize::MAX, 1], [12, 12], [0, 4, 8]),
+            ([1, usize::MAX], [12, 16], [0, 4, 8]),
+        ] {
+            assert!(extract_xyz_rows(&[0; 16], dimensions, steps, offsets, false).is_err());
+        }
+    }
+
     #[test]
     fn drops_non_finite_points_and_moves_nothing() {
         let cloud = cloud_of(&[[1.0, 2.0, 0.3], [f32::NAN, 0.0, 0.0], [0.0, 0.0, 0.0]]);
diff --git a/native/rust/dimos-module/src/tf.rs b/native/rust/dimos-module/src/tf.rs
index a6c1611f9e3..c5a81cd1d37 100644
--- a/native/rust/dimos-module/src/tf.rs
+++ b/native/rust/dimos-module/src/tf.rs
@@ -12,1194 +12,613 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Transform client for native modules.
-//!
-//! Each `/tf` edge is buffered per `(parent, child)`, and [`Tf::lookup`] composes
-//! the shortest path through the frame graph. Lookups are nearest-in-time within
-//! a tolerance, not interpolated. [`Tf::publish`] sends transforms onto the same
-//! topic and feeds the local graph.
-
-use std::collections::{HashMap, HashSet, VecDeque};
-use std::io;
-use std::sync::atomic::AtomicU64;
-use std::sync::{Arc, Mutex, RwLock};
-use std::time::Duration;
-
-use nalgebra::{Isometry3, Quaternion, Translation3, UnitQuaternion, Vector3};
-use tokio::sync::{mpsc, Notify};
-use tracing::warn;
+//! ROS TF messages backed by the `transforms` frame tree.
 
 use crate::module::Route;
-use crate::time::now_secs;
-
-/// How many seconds of history each edge keeps.
-pub(crate) const DEFAULT_TF_WINDOW_SECS: f64 = 10.0;
-
-const WARN_INTERVAL: Duration = Duration::from_secs(1);
-
-/// A rigid transform from `parent` to `child` at a point in time.
-///
-/// It maps a point expressed in `child` coordinates into `parent` coordinates.
-#[derive(Clone, Debug)]
-pub struct Transform {
-    pub parent: String,
-    pub child: String,
-    pub ts: f64,
-    iso: Isometry3<f64>,
+use nalgebra::{Isometry3, Quaternion, Translation3, UnitQuaternion};
+use std::{
+    io,
+    sync::{Arc, RwLock},
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use tokio::sync::{mpsc, Notify};
+use transforms::{
+    geometry::{
+        Quaternion as FrameQuaternion, Transform as FrameTransform, Vector3 as FrameVector,
+    },
+    time::Stamp,
+    Registry,
+};
+
+pub use dimos_tf_messages::{
+    builtin_interfaces::msg::time::Time, geometry_msgs::msg::transform_stamped::TransformStamped,
+    tf2_msgs::msg::tf_message::TFMessage,
+};
+use dimos_tf_messages::{
+    geometry_msgs::msg::{
+        quaternion::Quaternion as WireQuaternion, transform::Transform, vector3::Vector3,
+    },
+    std_msgs::msg::header::Header,
+};
+
+pub(crate) const DEFAULT_TF_WINDOW: Duration = Duration::from_secs(10);
+
+fn invalid(error: impl std::fmt::Display) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, error.to_string())
 }
 
-impl Transform {
-    pub fn new(
-        parent: impl Into<String>,
-        child: impl Into<String>,
-        ts: f64,
-        iso: Isometry3<f64>,
-    ) -> Self {
-        Self {
-            parent: parent.into(),
-            child: child.into(),
-            ts,
-            iso,
-        }
-    }
-
-    pub fn translation(&self) -> Vector3<f64> {
-        self.iso.translation.vector
-    }
-
-    pub fn rotation(&self) -> UnitQuaternion<f64> {
-        self.iso.rotation
-    }
-
-    fn inverse(&self) -> Transform {
-        Transform {
-            parent: self.child.clone(),
-            child: self.parent.clone(),
-            ts: self.ts,
-            iso: self.iso.inverse(),
-        }
-    }
-
-    fn compose(&self, other: &Transform) -> Transform {
-        Transform {
-            parent: self.parent.clone(),
-            child: other.child.clone(),
-            ts: self.ts,
-            iso: self.iso * other.iso,
-        }
+pub fn nanoseconds(time: &Time) -> io::Result<i64> {
+    if time.nanosec >= 1_000_000_000 {
+        return Err(invalid("unnormalized ROS time"));
     }
+    Ok(i64::from(time.sec) * 1_000_000_000 + i64::from(time.nanosec))
 }
 
-struct Sample {
-    ts: f64,
-    iso: Isometry3<f64>,
+pub fn time_from_nanoseconds(ns: i64) -> io::Result<Time> {
+    Ok(Time {
+        sec: ns.div_euclid(1_000_000_000).try_into().map_err(invalid)?,
+        nanosec: ns.rem_euclid(1_000_000_000) as u32,
+    })
 }
 
-// One edge's time-sorted history, capped to a fixed-duration window.
-struct TBuffer {
-    window_secs: f64,
-    samples: VecDeque<Sample>,
+fn system_time(time: &Time) -> io::Result<SystemTime> {
+    let ns = nanoseconds(time)?;
+    let duration = Duration::from_nanos(ns.unsigned_abs());
+    (if ns >= 0 {
+        UNIX_EPOCH.checked_add(duration)
+    } else {
+        UNIX_EPOCH.checked_sub(duration)
+    })
+    .ok_or_else(|| invalid("time out of range"))
 }
 
-impl TBuffer {
-    fn new(window_secs: f64) -> Self {
-        Self {
-            window_secs,
-            samples: VecDeque::new(),
-        }
-    }
-
-    fn add(&mut self, ts: f64, iso: Isometry3<f64>) {
-        // A stamp a whole window behind the newest is a clock reset, not jitter.
-        if self
-            .samples
-            .back()
-            .is_some_and(|s| ts < s.ts - self.window_secs)
-        {
-            self.samples.clear();
-        }
-        let pos = self.samples.partition_point(|s| s.ts <= ts);
-        self.samples.insert(pos, Sample { ts, iso });
-        // Anchored to the newest sample so a late message cannot widen the window.
-        let newest = self.samples.back().map_or(ts, |s| s.ts);
-        self.prune(newest - self.window_secs);
-    }
-
-    fn prune(&mut self, min_ts: f64) {
-        let drop_to = self.samples.partition_point(|s| s.ts < min_ts);
-        for _ in 0..drop_to {
-            self.samples.pop_front();
-        }
-    }
-
-    fn last(&self) -> Option<&Sample> {
-        self.samples.back()
-    }
-
-    // Nearest sample in time. On a tie, prefer the later sample. Returns None
-    // when the closest sample is further than tolerance from ts.
-    fn find_closest(&self, ts: f64, tolerance: Option<f64>) -> Option<&Sample> {
-        let pos = self.samples.partition_point(|s| s.ts < ts);
-        let prev = pos.checked_sub(1).and_then(|i| self.samples.get(i));
-        let next = self.samples.get(pos);
-        let best = match (prev, next) {
-            (Some(p), Some(n)) => {
-                if (n.ts - ts).abs() <= (ts - p.ts).abs() {
-                    n
-                } else {
-                    p
-                }
-            }
-            (Some(p), None) => p,
-            (None, Some(n)) => n,
-            (None, None) => return None,
-        };
-        match tolerance {
-            Some(tol) if (best.ts - ts).abs() > tol => None,
-            _ => Some(best),
-        }
-    }
+fn ros_time(time: SystemTime) -> io::Result<Time> {
+    let ns = match time.duration_since(UNIX_EPOCH) {
+        Ok(d) => i64::try_from(d.as_nanos()).map_err(invalid)?,
+        Err(e) => -i64::try_from(e.duration().as_nanos()).map_err(invalid)?,
+    };
+    time_from_nanoseconds(ns)
+}
 
-    fn sample(
-        &self,
-        parent: &str,
-        child: &str,
-        time: Option<f64>,
-        tolerance: Option<f64>,
-    ) -> Option<Transform> {
-        let s = match time {
-            None => self.last()?,
-            Some(t) => self.find_closest(t, Some(tolerance.unwrap_or(self.window_secs)))?,
-        };
-        Some(Transform {
-            parent: parent.to_string(),
-            child: child.to_string(),
-            ts: s.ts,
-            iso: s.iso,
-        })
+/// Adapt numeric geometry to a standard message; publication validates its values.
+pub fn from_isometry(
+    parent: impl Into<String>,
+    child: impl Into<String>,
+    stamp: Time,
+    iso: Isometry3<f64>,
+) -> TransformStamped {
+    let p = iso.translation.vector;
+    let q = iso.rotation;
+    TransformStamped {
+        header: Header {
+            stamp,
+            frame_id: parent.into(),
+        },
+        child_frame_id: child.into(),
+        transform: Transform {
+            translation: Vector3 {
+                x: p.x,
+                y: p.y,
+                z: p.z,
+            },
+            rotation: WireQuaternion {
+                x: q.i,
+                y: q.j,
+                z: q.k,
+                w: q.w,
+            },
+        },
     }
 }
 
-/// The transform graph: one [`TBuffer`] per `(parent, child)` edge.
-struct MultiTBuffer {
-    window_secs: f64,
-    buffers: HashMap<(String, String), TBuffer>,
+pub fn isometry(edge: &TransformStamped) -> io::Result<Isometry3<f64>> {
+    let p = &edge.transform.translation;
+    let q = &edge.transform.rotation;
+    if ![p.x, p.y, p.z, q.x, q.y, q.z, q.w]
+        .iter()
+        .all(|v| v.is_finite())
+    {
+        return Err(invalid("nonfinite TF geometry"));
+    }
+    let norm = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+    if (norm - 1.).abs() > 1e-6 {
+        return Err(invalid("TF quaternion must be normalized"));
+    }
+    Ok(Isometry3::from_parts(
+        Translation3::new(p.x, p.y, p.z),
+        UnitQuaternion::new_normalize(Quaternion::new(q.w, q.x, q.y, q.z)),
+    ))
 }
 
-impl MultiTBuffer {
-    fn new(window_secs: f64) -> Self {
-        Self {
-            window_secs,
-            buffers: HashMap::new(),
-        }
-    }
-
-    fn receive(&mut self, parent: &str, child: &str, ts: f64, iso: Isometry3<f64>) {
-        let window_secs = self.window_secs;
-        self.buffers
-            .entry((parent.to_string(), child.to_string()))
-            .or_insert_with(|| TBuffer::new(window_secs))
-            .add(ts, iso);
-    }
-
-    fn connections(&self, frame: &str) -> Vec<String> {
-        let mut out = Vec::new();
-        for (parent, child) in self.buffers.keys() {
-            if parent == frame {
-                out.push(child.clone());
-            }
-            if child == frame {
-                out.push(parent.clone());
-            }
-        }
-        out
-    }
-
-    fn edge(
-        &self,
-        parent: &str,
-        child: &str,
-        time: Option<f64>,
-        tolerance: Option<f64>,
-    ) -> Option<Transform> {
-        if parent == child {
-            return Some(Transform {
-                parent: parent.to_string(),
-                child: child.to_string(),
-                ts: time.unwrap_or_else(now_secs),
-                iso: Isometry3::identity(),
-            });
-        }
-        if let Some(buf) = self.buffers.get(&(parent.to_string(), child.to_string())) {
-            return buf.sample(parent, child, time, tolerance);
-        }
-        if let Some(buf) = self.buffers.get(&(child.to_string(), parent.to_string())) {
-            return buf
-                .sample(child, parent, time, tolerance)
-                .map(|t| t.inverse());
-        }
-        None
-    }
-
-    fn get(
-        &self,
-        parent: &str,
-        child: &str,
-        time: Option<f64>,
-        tolerance: Option<f64>,
-    ) -> Option<Transform> {
-        if let Some(direct) = self.edge(parent, child, time, tolerance) {
-            return Some(direct);
+fn to_frame(edge: &TransformStamped, is_static: bool) -> io::Result<FrameTransform<SystemTime>> {
+    for frame in [&edge.header.frame_id, &edge.child_frame_id] {
+        if frame.is_empty() || frame.starts_with('/') {
+            return Err(invalid(
+                "TF frame must be nonempty and have no leading slash",
+            ));
         }
-        let path = self.bfs(parent, child, time, tolerance)?;
-        // A composition is only as fresh as its stalest edge.
-        let oldest = path.iter().map(|t| t.ts).fold(f64::INFINITY, f64::min);
-        let mut steps = path.into_iter();
-        let first = steps.next()?;
-        let mut composed = steps.fold(first, |acc, step| acc.compose(&step));
-        composed.ts = oldest;
-        Some(composed)
     }
+    let time = system_time(&edge.header.stamp)?;
+    isometry(edge)?;
+    let p = &edge.transform.translation;
+    let q = &edge.transform.rotation;
+    FrameTransform::new(
+        &edge.header.frame_id,
+        &edge.child_frame_id,
+        FrameVector::new(p.x, p.y, p.z),
+        FrameQuaternion::from_wxyz(q.w, q.x, q.y, q.z),
+        if is_static {
+            Stamp::Static
+        } else {
+            Stamp::At(time)
+        },
+    )
+    .map_err(invalid)
+}
 
-    fn bfs(
-        &self,
-        parent: &str,
-        child: &str,
-        time: Option<f64>,
-        tolerance: Option<f64>,
-    ) -> Option<Vec<Transform>> {
-        let mut queue: VecDeque<(String, Vec<Transform>)> = VecDeque::new();
-        queue.push_back((parent.to_string(), Vec::new()));
-        let mut visited: HashSet<String> = HashSet::new();
-        visited.insert(parent.to_string());
-
-        while let Some((frame, path)) = queue.pop_front() {
-            if frame == child {
-                return Some(path);
-            }
-            for next in self.connections(&frame) {
-                if !visited.contains(&next) {
-                    if let Some(edge) = self.edge(&frame, &next, time, tolerance) {
-                        visited.insert(next.clone());
-                        let mut extended = path.clone();
-                        extended.push(edge);
-                        queue.push_back((next, extended));
-                    }
-                }
-            }
-        }
-        None
-    }
+fn from_frame(edge: FrameTransform<SystemTime>) -> io::Result<TransformStamped> {
+    edge.validate().map_err(invalid)?;
+    let p = edge.translation();
+    let q = edge.rotation();
+    Ok(TransformStamped {
+        header: Header {
+            stamp: ros_time(edge.timestamp().at().unwrap_or(UNIX_EPOCH))?,
+            frame_id: edge.parent().into(),
+        },
+        child_frame_id: edge.child().into(),
+        transform: Transform {
+            translation: Vector3 {
+                x: p.x,
+                y: p.y,
+                z: p.z,
+            },
+            rotation: WireQuaternion {
+                x: q.x,
+                y: q.y,
+                z: q.z,
+                w: q.w,
+            },
+        },
+    })
 }
 
-// The graph plus the signal that it changed. Every write notifies, so a writer
-// cannot leave a waiter asleep on a transform that has already landed.
 struct Graph {
-    buffer: RwLock<MultiTBuffer>,
+    buffer: RwLock<Registry<SystemTime>>,
     changed: Notify,
-    // Keyed per pair: warn_throttled! throttles per call site, and one site
-    // serves every lookup, so a missing pair would mute all the others.
-    warned: Mutex<HashMap<(String, String), AtomicU64>>,
 }
 
 impl Graph {
-    fn new(window_secs: f64) -> Self {
-        Self {
-            buffer: RwLock::new(MultiTBuffer::new(window_secs)),
-            changed: Notify::new(),
-            warned: Mutex::new(HashMap::new()),
-        }
-    }
-
-    fn should_warn(&self, parent: &str, child: &str) -> bool {
-        let mut warned = self.warned.lock().expect("tf warn map lock poisoned");
-        let last = warned
-            .entry((parent.to_string(), child.to_string()))
-            .or_default();
-        crate::log::check_and_record(last, WARN_INTERVAL.as_nanos() as u64)
-    }
-
-    fn update(&self, edits: impl FnOnce(&mut MultiTBuffer)) {
-        edits(&mut self.buffer.write().expect("tf buffer lock poisoned"));
+    fn insert(&self, message: &TFMessage, is_static: bool) -> io::Result<()> {
+        let edges = message
+            .transforms
+            .iter()
+            .map(|edge| to_frame(edge, is_static))
+            .collect::<io::Result<Vec<_>>>()?;
+        self.buffer
+            .write()
+            .map_err(invalid)?
+            .add_transforms(edges)
+            .map_err(invalid)?;
         self.changed.notify_waiters();
+        Ok(())
     }
 
-    fn get(
+    fn lookup(
         &self,
-        parent: &str,
-        child: &str,
-        time: Option<f64>,
-        tolerance: Option<f64>,
-    ) -> Option<Transform> {
-        self.buffer
-            .read()
-            .expect("tf buffer lock poisoned")
-            .get(parent, child, time, tolerance)
+        target: &str,
+        source: &str,
+        time: Option<&Time>,
+    ) -> io::Result<TransformStamped> {
+        if [target, source]
+            .iter()
+            .any(|frame| frame.is_empty() || frame.starts_with('/'))
+        {
+            return Err(invalid(
+                "TF frame must be nonempty and have no leading slash",
+            ));
+        }
+        let buffer = self.buffer.read().map_err(invalid)?;
+        let time = match time {
+            Some(t) => system_time(t)?,
+            None => buffer
+                .latest_common_time(target, source)
+                .map_err(invalid)?
+                .at()
+                .unwrap_or(UNIX_EPOCH),
+        };
+        from_frame(
+            buffer
+                .get_transform(target, source, time)
+                .map_err(invalid)?,
+        )
     }
 }
 
-/// A cheap-to-clone handle for querying and publishing transforms.
-///
-/// Obtain one from `Builder::tf` (or a `#[tf]` field on a `#[derive(Module)]`
-/// struct). The graph is filled in the background as `/tf` messages arrive.
 #[derive(Clone)]
 pub struct Tf {
     graph: Arc<Graph>,
     sender: mpsc::Sender<Vec<u8>>,
+    static_sender: mpsc::Sender<Vec<u8>>,
 }
 
 impl Tf {
-    /// Start a lookup of the transform from `parent` to `child`.
-    ///
-    /// Refine it with [`Lookup::at`] and [`Lookup::tolerance`], then finish with
-    /// [`Lookup::get`]. Use [`Tf::get_latest`] when no refinement is needed.
-    ///
-    /// ```ignore
-    /// let at_scan = tf.lookup("map", "base_link").at(scan_ts).tolerance(0.1).get();
-    /// ```
-    pub fn lookup<'a>(&'a self, parent: &'a str, child: &'a str) -> Lookup<'a> {
+    /// ROS lookup order: target, source, time. Zero time requests the latest common time.
+    pub fn lookup_transform(
+        &self,
+        target: &str,
+        source: &str,
+        time: Time,
+    ) -> io::Result<TransformStamped> {
+        nanoseconds(&time)?;
+        self.graph.lookup(
+            target,
+            source,
+            if time.sec == 0 && time.nanosec == 0 {
+                None
+            } else {
+                Some(&time)
+            },
+        )
+    }
+
+    pub fn lookup<'a>(&'a self, target: &'a str, source: &'a str) -> Lookup<'a> {
         Lookup {
             tf: self,
-            parent,
-            child,
+            target,
+            source,
             time: None,
-            tolerance: None,
         }
     }
+    pub fn get_latest(&self, target: &str, source: &str) -> Option<TransformStamped> {
+        self.graph.lookup(target, source, None).ok()
+    }
 
-    /// The latest transform from `parent` to `child`.
-    ///
-    /// Shorthand for `lookup(parent, child).get()`.
-    pub fn get_latest(&self, parent: &str, child: &str) -> Option<Transform> {
-        self.lookup(parent, child).get()
+    pub async fn publish(&self, transforms: &[TransformStamped]) -> io::Result<()> {
+        self.publish_message(
+            &TFMessage {
+                transforms: transforms.to_vec(),
+            },
+            false,
+        )
+        .await
+    }
+    pub async fn publish_static(&self, transforms: &[TransformStamped]) -> io::Result<()> {
+        self.publish_message(
+            &TFMessage {
+                transforms: transforms.to_vec(),
+            },
+            true,
+        )
+        .await
     }
 
-    /// Publish transforms on the `tf` topic.
-    ///
-    /// The transforms also feed the local graph, so a lookup right after sees
-    /// them without waiting for the transport round trip.
-    pub async fn publish(&self, transforms: &[Transform]) -> io::Result<()> {
-        self.graph.update(|buffer| {
-            for t in transforms {
-                buffer.receive(&t.parent, &t.child, t.ts, t.iso);
-            }
-        });
-        let msg = lcm_msgs::tf2_msgs::TFMessage {
-            transforms: transforms.iter().map(to_stamped).collect(),
+    async fn publish_message(&self, message: &TFMessage, is_static: bool) -> io::Result<()> {
+        let payload = crate::cdr::encode(message)?;
+        let sender = if is_static {
+            &self.static_sender
+        } else {
+            &self.sender
         };
-        crate::module::publish_encoded(&self.sender, msg.encode()).await
+        // Reserve transport capacity before changing the graph. A closed queue
+        // must neither publish nor make a transform visible locally.
+        let permit = sender
+            .reserve()
+            .await
+            .map_err(|error| io::Error::new(io::ErrorKind::BrokenPipe, error))?;
+        self.graph.insert(message, is_static)?;
+        permit.send(payload);
+        Ok(())
     }
 }
 
-/// A transform lookup being built. Created by [`Tf::lookup`].
 pub struct Lookup<'a> {
     tf: &'a Tf,
-    parent: &'a str,
-    child: &'a str,
-    time: Option<f64>,
-    tolerance: Option<f64>,
+    target: &'a str,
+    source: &'a str,
+    time: Option<Time>,
 }
-
 impl Lookup<'_> {
-    /// Take the sample nearest `time` rather than the latest one.
-    pub fn at(mut self, time: f64) -> Self {
+    pub fn at(mut self, time: Time) -> Self {
         self.time = Some(time);
         self
     }
-
-    /// Bound how far, in seconds, the chosen sample may sit from [`Lookup::at`].
-    pub fn tolerance(mut self, tolerance: f64) -> Self {
-        self.tolerance = Some(tolerance);
-        self
-    }
-
-    fn resolve(&self) -> Option<Transform> {
-        self.tf
-            .graph
-            .get(self.parent, self.child, self.time, self.tolerance)
+    pub fn get(self) -> Option<TransformStamped> {
+        self.resolve().ok()
     }
-
-    // A lookup that resolves to nothing is otherwise invisible: the caller sees
-    // None and the buffer says nothing about which frames or stamp missed.
-    fn warn_unresolved(&self) {
-        if !self.tf.graph.should_warn(self.parent, self.child) {
-            return;
+    fn resolve(&self) -> io::Result<TransformStamped> {
+        match &self.time {
+            Some(t) => self
+                .tf
+                .lookup_transform(self.target, self.source, t.clone()),
+            None => self.tf.graph.lookup(self.target, self.source, None),
         }
-        warn!(
-            parent = %self.parent,
-            child = %self.child,
-            at = self.time.unwrap_or_else(now_secs),
-            tolerance = self.tolerance.unwrap_or(f64::NAN),
-            "No transform found between frames",
-        );
     }
-
-    /// Resolve the lookup against the transforms buffered so far.
-    ///
-    /// `None` when no path connects the frames, or when the nearest sample is
-    /// outside the tolerance.
-    pub fn get(self) -> Option<Transform> {
-        let found = self.resolve();
-        if found.is_none() {
-            self.warn_unresolved();
-        }
-        found
-    }
-
-    /// Resolve the lookup, waiting up to `timeout` for a late transform.
-    ///
-    /// Returns as soon as the lookup succeeds, or `None` at the deadline.
-    /// Awaiting this inside a `handle_*` method parks the module's whole
-    /// dispatch loop, so prefer [`Lookup::get`] there and move a long wait onto
-    /// a task of its own.
-    pub async fn within(self, timeout: Duration) -> Option<Transform> {
+    pub async fn within(self, timeout: Duration) -> Option<TransformStamped> {
         let deadline = tokio::time::Instant::now() + timeout;
         loop {
-            // Registered before the resolve below, so a transform landing between
-            // the two still wakes this waiter instead of it sleeping out the
-            // whole timeout.
             let changed = self.tf.graph.changed.notified();
             tokio::pin!(changed);
             changed.as_mut().enable();
-
-            if let Some(transform) = self.resolve() {
-                return Some(transform);
-            }
-            // Only the deadline warns. An intermediate miss is the normal state
-            // of a wait, not a failure.
-            let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
-            if remaining.is_zero() {
-                self.warn_unresolved();
-                return None;
+            if let Ok(edge) = self.resolve() {
+                return Some(edge);
             }
-            if tokio::time::timeout(remaining, changed).await.is_err() {
-                self.warn_unresolved();
+            if tokio::time::timeout_at(deadline, changed).await.is_err() {
                 return None;
             }
         }
     }
 }
 
-fn to_stamped(t: &Transform) -> lcm_msgs::geometry_msgs::TransformStamped {
-    let mut sec = t.ts.floor();
-    let mut nsec = ((t.ts - sec) * 1e9).round();
-    if nsec >= 1e9 {
-        sec += 1.0;
-        nsec -= 1e9;
-    }
-    let p = t.iso.translation.vector;
-    let q = t.iso.rotation;
-    lcm_msgs::geometry_msgs::TransformStamped {
-        header: lcm_msgs::std_msgs::Header {
-            seq: 0,
-            stamp: lcm_msgs::std_msgs::Time {
-                sec: sec as i32,
-                nsec: nsec as i32,
-            },
-            frame_id: t.parent.clone(),
-        },
-        child_frame_id: t.child.clone(),
-        transform: lcm_msgs::geometry_msgs::Transform {
-            translation: lcm_msgs::geometry_msgs::Vector3 {
-                x: p.x,
-                y: p.y,
-                z: p.z,
-            },
-            rotation: lcm_msgs::geometry_msgs::Quaternion {
-                x: q.i,
-                y: q.j,
-                z: q.k,
-                w: q.w,
-            },
-        },
-    }
-}
-
-// Decodes /tf messages into the shared graph. Registered as a Route so the
-// module's existing recv loop dispatches tf traffic to it.
 struct TfRoute {
-    topic: String,
     graph: Arc<Graph>,
+    is_static: bool,
 }
-
 impl Route for TfRoute {
     fn try_dispatch(&self, data: &[u8]) {
-        let msg = match lcm_msgs::tf2_msgs::TFMessage::decode(data) {
-            Ok(msg) => msg,
-            Err(e) => {
-                crate::error_throttled!(
-                    Duration::from_secs(1),
-                    topic = %self.topic,
-                    error = %e,
-                    "tf decode error"
-                );
-                return;
-            }
-        };
-        self.graph.update(|buffer| {
-            for st in &msg.transforms {
-                let t = &st.transform.translation;
-                let q = &st.transform.rotation;
-                // Normalizing a zero-norm quaternion yields a NaN rotation.
-                let Some(rotation) =
-                    UnitQuaternion::try_new(Quaternion::new(q.w, q.x, q.y, q.z), 1e-9)
-                else {
-                    crate::error_throttled!(
-                        Duration::from_secs(1),
-                        topic = %self.topic,
-                        parent = %st.header.frame_id,
-                        child = %st.child_frame_id,
-                        "tf rotation is not a valid quaternion"
-                    );
-                    continue;
-                };
-                let iso = Isometry3::from_parts(Translation3::new(t.x, t.y, t.z), rotation);
-                let ts = st.header.stamp.sec as f64 + st.header.stamp.nsec as f64 * 1e-9;
-                buffer.receive(&st.header.frame_id, &st.child_frame_id, ts, iso);
-            }
-        });
+        let result = crate::cdr::decode::<TFMessage>(data)
+            .and_then(|msg| self.graph.insert(&msg, self.is_static));
+        if let Err(error) = result {
+            tracing::warn!(%error, is_static=self.is_static, "TF message rejected");
+        }
     }
 }
 
-// Builds the shared graph plus the handle and the route that feeds it. The
-// sender carries published messages to the tf topic's publish worker.
 pub(crate) fn tf_subscription(
-    topic: String,
-    window_secs: f64,
     sender: mpsc::Sender<Vec<u8>>,
-) -> (Tf, Box<dyn Route>) {
-    let graph = Arc::new(Graph::new(window_secs));
-    let tf = Tf {
-        graph: Arc::clone(&graph),
-        sender,
-    };
-    let route = Box::new(TfRoute { topic, graph });
-    (tf, route)
+    static_sender: mpsc::Sender<Vec<u8>>,
+    window: Duration,
+) -> (Tf, Box<dyn Route>, Box<dyn Route>) {
+    let graph = Arc::new(Graph {
+        buffer: RwLock::new(Registry::with_max_age(window)),
+        changed: Notify::new(),
+    });
+    (
+        Tf {
+            graph: graph.clone(),
+            sender,
+            static_sender,
+        },
+        Box::new(TfRoute {
+            graph: graph.clone(),
+            is_static: false,
+        }),
+        Box::new(TfRoute {
+            graph,
+            is_static: true,
+        }),
+    )
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::f64::consts::PI;
-
-    fn tf_with(window_secs: f64) -> (Tf, MultiHandle) {
-        let (tf, _rx, handle) = tf_with_publish(window_secs);
-        (tf, handle)
-    }
-
-    fn tf_with_publish(window_secs: f64) -> (Tf, mpsc::Receiver<Vec<u8>>, MultiHandle) {
-        let graph = Arc::new(Graph::new(window_secs));
-        let (tx, rx) = mpsc::channel(8);
-        (
-            Tf {
-                graph: Arc::clone(&graph),
-                sender: tx,
-            },
-            rx,
-            MultiHandle { graph },
+    fn edge(parent: &str, child: &str, ns: i64, x: f64) -> TransformStamped {
+        from_isometry(
+            parent,
+            child,
+            time_from_nanoseconds(ns).unwrap(),
+            Isometry3::translation(x, 0., 0.),
         )
     }
-
-    // Test-only writer that bypasses LCM and pushes edges straight into the graph.
-    struct MultiHandle {
-        graph: Arc<Graph>,
-    }
-
-    impl MultiHandle {
-        fn add(&self, parent: &str, child: &str, ts: f64, xyz: (f64, f64, f64), yaw: f64) {
-            let iso = Isometry3::from_parts(
-                Translation3::new(xyz.0, xyz.1, xyz.2),
-                UnitQuaternion::from_euler_angles(0.0, 0.0, yaw),
-            );
-            self.graph
-                .update(|buffer| buffer.receive(parent, child, ts, iso));
-        }
-    }
-
-    #[test]
-    fn direct_edge() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("base_link", "arm", 1.0, (1.0, -1.0, 0.0), 0.0);
-        let t = tf.get_latest("base_link", "arm").unwrap();
-        assert!((t.translation().x - 1.0).abs() < 1e-9);
-        assert!((t.translation().y + 1.0).abs() < 1e-9);
-        assert_eq!(t.parent, "base_link");
-        assert_eq!(t.child, "arm");
+    fn fixture() -> (
+        Tf,
+        Box<dyn Route>,
+        Box<dyn Route>,
+        mpsc::Receiver<Vec<u8>>,
+        mpsc::Receiver<Vec<u8>>,
+    ) {
+        let (tx, rx) = mpsc::channel(16);
+        let (static_tx, static_rx) = mpsc::channel(16);
+        let (tf, dynamic, static_route) = tf_subscription(tx, static_tx, Duration::from_secs(10));
+        (tf, dynamic, static_route, rx, static_rx)
     }
-
     #[test]
-    fn reverse_edge_returns_inverse() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("base_link", "arm", 1.0, (1.0, 2.0, 3.0), 0.0);
-        let inv = tf.get_latest("arm", "base_link").unwrap();
-        assert!((inv.translation().x + 1.0).abs() < 1e-9);
-        assert!((inv.translation().y + 2.0).abs() < 1e-9);
-        assert!((inv.translation().z + 3.0).abs() < 1e-9);
-        assert_eq!(inv.parent, "arm");
-        assert_eq!(inv.child, "base_link");
-    }
-
-    #[test]
-    fn composes_ros_example_chain() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("base_link", "arm", 1.0, (1.0, -1.0, 0.0), PI / 6.0);
-        h.add("arm", "end_effector", 1.0, (1.0, 1.0, 0.0), 0.0);
-        let t = tf.get_latest("base_link", "end_effector").unwrap();
-        assert!(
-            (t.translation().x - 1.366).abs() < 1e-3,
-            "{}",
-            t.translation().x
-        );
-        assert!(
-            (t.translation().y - 0.366).abs() < 1e-3,
-            "{}",
-            t.translation().y
-        );
-        assert_eq!(t.parent, "base_link");
-        assert_eq!(t.child, "end_effector");
-    }
-
-    #[test]
-    fn composes_multi_hop_chain() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("world", "robot", 1.0, (1.0, 2.0, 3.0), 0.0);
-        h.add("robot", "sensor", 1.0, (0.5, 0.0, 0.2), PI / 2.0);
-        let t = tf.get_latest("world", "sensor").unwrap();
-        assert!((t.translation().x - 1.5).abs() < 1e-3);
-        assert!((t.translation().y - 2.0).abs() < 1e-3);
-        assert!((t.translation().z - 3.2).abs() < 1e-3);
-    }
-
-    #[test]
-    fn composed_stamp_is_the_stalest_edge() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("world", "robot", 700.0, (1.0, 0.0, 0.0), 0.0);
-        h.add("robot", "sensor", 1000.0, (0.5, 0.0, 0.0), 0.0);
-        assert_eq!(tf.get_latest("world", "sensor").unwrap().ts, 700.0);
-        // Both directions, so the answer does not depend on which end is queried.
-        assert_eq!(tf.get_latest("sensor", "world").unwrap().ts, 700.0);
-    }
-
-    #[test]
-    fn missing_path_returns_none() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("world", "robot", 1.0, (1.0, 0.0, 0.0), 0.0);
-        assert!(tf.get_latest("world", "unconnected").is_none());
-    }
-
-    #[test]
-    fn identity_for_same_frame() {
-        let (tf, _h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        // No query time: identity is stamped now, not the epoch.
-        let t = tf.get_latest("base_link", "base_link").unwrap();
-        assert!((t.translation().norm()).abs() < 1e-12);
-        assert!(
-            t.ts > 0.0,
-            "identity ts should be a fresh stamp, got {}",
-            t.ts
+    fn invalid_query_frames_cannot_resolve_to_identity() {
+        let (tf, _, _, _, _) = fixture();
+        for frame in ["", "/map"] {
+            assert!(tf
+                .lookup_transform(frame, frame, Time { sec: 0, nanosec: 0 })
+                .is_err());
+        }
+        assert_eq!(
+            tf.get_latest("map", "map").unwrap().transform.rotation.w,
+            1.
         );
-        // Explicit query time is echoed back.
-        let at = tf.lookup("base_link", "base_link").at(42.0).get().unwrap();
-        assert!((at.ts - 42.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn time_query_picks_nearest_sample() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("a", "b", 10.0, (1.0, 0.0, 0.0), 0.0);
-        h.add("a", "b", 20.0, (2.0, 0.0, 0.0), 0.0);
-        let near_10 = tf.lookup("a", "b").at(11.0).get().unwrap();
-        assert!((near_10.translation().x - 1.0).abs() < 1e-9);
-        let near_20 = tf.lookup("a", "b").at(18.0).get().unwrap();
-        assert!((near_20.translation().x - 2.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn time_query_outside_tolerance_returns_none() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("a", "b", 10.0, (1.0, 0.0, 0.0), 0.0);
-        assert!(tf.lookup("a", "b").at(50.0).tolerance(1.0).get().is_none());
-        assert!(tf.lookup("a", "b").at(10.5).tolerance(1.0).get().is_some());
     }
-
-    #[test]
-    fn time_query_beyond_the_window_returns_none_without_a_tolerance() {
-        let (tf, h) = tf_with(10.0);
-        h.add("a", "b", 100.0, (1.0, 0.0, 0.0), 0.0);
-        assert!(tf.lookup("a", "b").at(50.0).get().is_none());
-    }
-
-    #[test]
-    fn time_query_inside_the_window_resolves_without_a_tolerance() {
-        let (tf, h) = tf_with(10.0);
-        h.add("a", "b", 100.0, (1.0, 0.0, 0.0), 0.0);
-        let t = tf
-            .lookup("a", "b")
-            .at(95.0)
-            .get()
-            .expect("within the window");
-        assert!((t.translation().x - 1.0).abs() < 1e-9);
-    }
-
-    // An explicit tolerance is the caller opting into staleness, so it widens
-    // past the window rather than being clamped by it.
-    #[test]
-    fn an_explicit_tolerance_reaches_past_the_window() {
-        let (tf, h) = tf_with(10.0);
-        h.add("a", "b", 100.0, (1.0, 0.0, 0.0), 0.0);
-        assert!(tf.lookup("a", "b").at(50.0).tolerance(60.0).get().is_some());
-    }
-
-    // The window bounds queries against a stamp, not the latest sample. With no
-    // requested time, the newest edge is returned however old it is.
-    #[test]
-    fn latest_is_not_bounded_by_the_window() {
-        let (tf, h) = tf_with(10.0);
-        h.add("a", "b", 100.0, (1.0, 0.0, 0.0), 0.0);
-        assert!(tf.get_latest("a", "b").is_some());
-    }
-
     #[tokio::test]
-    async fn within_returns_without_waiting_when_already_buffered() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("a", "b", 5.0, (1.0, 0.0, 0.0), 0.0);
-        let t = tf
-            .lookup("a", "b")
-            .at(5.0)
-            .tolerance(0.1)
-            .within(Duration::from_secs(30))
-            .await
-            .expect("already available");
-        assert!((t.translation().x - 1.0).abs() < 1e-9);
-    }
-
-    // Returns as soon as the transform lands, not at the deadline.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn within_resolves_when_the_transform_arrives_late() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        tokio::spawn(async move {
-            tokio::time::sleep(Duration::from_millis(30)).await;
-            h.add("a", "b", 5.0, (1.0, 0.0, 0.0), 0.0);
-        });
-        let started = tokio::time::Instant::now();
-        let t = tf
-            .lookup("a", "b")
-            .at(5.0)
-            .tolerance(0.1)
-            .within(Duration::from_secs(30))
-            .await
-            .expect("arrived inside the budget");
-        assert!(
-            started.elapsed() < Duration::from_secs(5),
-            "waited {:?}, should have returned on arrival",
-            started.elapsed()
+    async fn latest_resolves_the_whole_chain_at_its_common_time() {
+        let (tf, _, _, _rx, _static_rx) = fixture();
+        tf.publish(&[
+            edge("map", "odom", 1_000_000_000, 1.),
+            edge("map", "odom", 2_000_000_000, 2.),
+            edge("odom", "base", 1_000_000_000, 10.),
+        ])
+        .await
+        .unwrap();
+        let result = tf.get_latest("map", "base").unwrap();
+        assert_eq!(result.transform.translation.x, 11.);
+        assert_eq!(nanoseconds(&result.header.stamp).unwrap(), 1_000_000_000);
+        assert_eq!(
+            tf.get_latest("base", "map")
+                .unwrap()
+                .transform
+                .translation
+                .x,
+            -11.
         );
-        assert!((t.translation().x - 1.0).abs() < 1e-9);
     }
-
     #[tokio::test]
-    async fn within_times_out_when_nothing_arrives() {
-        let (tf, _h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        let started = tokio::time::Instant::now();
-        let t = tf
-            .lookup("a", "b")
-            .at(5.0)
-            .tolerance(0.1)
-            .within(Duration::from_millis(50))
-            .await;
-        assert!(t.is_none());
-        assert!(
-            started.elapsed() >= Duration::from_millis(50),
-            "returned early"
+    async fn interpolates_translation_and_rotation_without_extrapolation() {
+        let (tf, _, _, _rx, _static_rx) = fixture();
+        let end = from_isometry(
+            "map",
+            "base",
+            time_from_nanoseconds(3_000_000_000).unwrap(),
+            Isometry3::from_parts(
+                Translation3::new(2., 0., 0.),
+                UnitQuaternion::from_euler_angles(0., 0., std::f64::consts::FRAC_PI_2),
+            ),
         );
-    }
-
-    // The waiter is on a -> c, but what lands is b -> c. Waking only on the
-    // queried edge would sleep through the composition becoming possible.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn within_wakes_when_a_later_edge_completes_the_chain() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("a", "b", 5.0, (1.0, 0.0, 0.0), 0.0);
-        tokio::spawn(async move {
-            tokio::time::sleep(Duration::from_millis(30)).await;
-            h.add("b", "c", 5.0, (2.0, 0.0, 0.0), 0.0);
-        });
-        let t = tf
-            .lookup("a", "c")
-            .at(5.0)
-            .tolerance(0.1)
-            .within(Duration::from_secs(30))
+        tf.publish(&[edge("map", "base", 1_000_000_000, 0.), end])
             .await
-            .expect("chain completed inside the budget");
+            .unwrap();
+        let result = tf
+            .lookup_transform("map", "base", time_from_nanoseconds(2_000_000_000).unwrap())
+            .unwrap();
+        assert_eq!(result.transform.translation.x, 1.);
         assert!(
-            (t.translation().x - 3.0).abs() < 1e-9,
-            "{}",
-            t.translation().x
+            (isometry(&result).unwrap().rotation.angle() - std::f64::consts::FRAC_PI_4).abs()
+                < 1e-10
         );
-    }
-
-    // A waiting handler is woken by the transport's dispatch task, which its own
-    // stall cannot block. Guards against the wait deadlocking against tf intake.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn within_is_woken_by_a_transform_dispatched_through_the_route() {
-        let (tx, _rx) = mpsc::channel(8);
-        let (tf, route) = tf_subscription("/tf".to_string(), DEFAULT_TF_WINDOW_SECS, tx);
-        tokio::spawn(async move {
-            tokio::time::sleep(Duration::from_millis(30)).await;
-            route.try_dispatch(&stamped_message("a", "b", 5.0, 1.0));
-        });
-        let t = tf
-            .lookup("a", "b")
-            .at(5.0)
-            .tolerance(0.1)
-            .within(Duration::from_secs(30))
-            .await
-            .expect("route dispatch woke the waiter");
-        assert!((t.translation().x - 1.0).abs() < 1e-9);
-    }
-
-    fn stamped_message(parent: &str, child: &str, ts: f64, x: f64) -> Vec<u8> {
-        rotated_message(parent, child, ts, x, (0.0, 0.0, 0.0, 1.0))
-    }
-
-    fn rotated_message(
-        parent: &str,
-        child: &str,
-        ts: f64,
-        x: f64,
-        quat: (f64, f64, f64, f64),
-    ) -> Vec<u8> {
-        use lcm_msgs::geometry_msgs::{
-            Quaternion as LQuat, Transform as LTransform, TransformStamped, Vector3 as LVec3,
-        };
-        use lcm_msgs::std_msgs::{Header, Time};
-        let (x_q, y_q, z_q, w_q) = quat;
-        lcm_msgs::tf2_msgs::TFMessage {
-            transforms: vec![TransformStamped {
-                header: Header {
-                    seq: 0,
-                    stamp: Time {
-                        sec: ts as i32,
-                        nsec: 0,
-                    },
-                    frame_id: parent.to_string(),
-                },
-                child_frame_id: child.to_string(),
-                transform: LTransform {
-                    translation: LVec3 { x, y: 0.0, z: 0.0 },
-                    rotation: LQuat {
-                        x: x_q,
-                        y: y_q,
-                        z: z_q,
-                        w: w_q,
-                    },
-                },
-            }],
-        }
-        .encode()
-    }
-
-    #[test]
-    fn a_zero_rotation_on_the_wire_is_dropped_rather_than_stored_as_nan() {
-        let (tx, _rx) = mpsc::channel(4);
-        let (tf, route) = tf_subscription("/tf".to_string(), DEFAULT_TF_WINDOW_SECS, tx);
-        route.try_dispatch(&rotated_message("a", "b", 5.0, 1.0, (0.0, 0.0, 0.0, 0.0)));
-        assert!(tf.get_latest("a", "b").is_none());
-
-        route.try_dispatch(&stamped_message("a", "b", 6.0, 1.0));
-        let t = tf.get_latest("a", "b").expect("valid rotation is accepted");
-        assert!(t.rotation().coords.iter().all(|c| c.is_finite()));
-    }
-
-    #[test]
-    #[tracing_test::traced_test]
-    fn a_lookup_that_finds_nothing_warns_with_the_frames() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("world", "robot", 1.0, (1.0, 0.0, 0.0), 0.0);
-        assert!(tf.get_latest("world", "gripper").is_none());
-        assert!(logs_contain("No transform found between frames"));
-        assert!(logs_contain("gripper"));
-    }
-
-    #[test]
-    #[tracing_test::traced_test]
-    fn repeated_misses_warn_once_per_frame_pair() {
-        let (tf, _h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        for _ in 0..5 {
-            assert!(tf.get_latest("world", "gripper").is_none());
-        }
-        logs_assert(|lines: &[&str]| {
-            match lines.iter().filter(|l| l.contains("gripper")).count() {
-                1 => Ok(()),
-                n => Err(format!("expected 1 warning for the repeated pair, got {n}")),
-            }
-        });
-
-        // A pair that is throttled must not mute an unrelated one.
-        assert!(tf.get_latest("world", "camera").is_none());
-        assert!(logs_contain("camera"));
-    }
-
-    #[test]
-    #[tracing_test::traced_test]
-    fn a_resolved_lookup_stays_quiet() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("world", "robot", 1.0, (1.0, 0.0, 0.0), 0.0);
-        assert!(tf.get_latest("world", "robot").is_some());
-        assert!(!logs_contain("No transform found between frames"));
-    }
-
-    // A wait in progress is not a failure, so only the deadline warns.
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    #[tracing_test::traced_test]
-    async fn within_warns_only_once_it_gives_up() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        tokio::spawn(async move {
-            tokio::time::sleep(Duration::from_millis(20)).await;
-            h.add("a", "b", 5.0, (1.0, 0.0, 0.0), 0.0);
-        });
         assert!(tf
-            .lookup("a", "b")
-            .at(5.0)
-            .tolerance(0.1)
-            .within(Duration::from_secs(30))
-            .await
-            .is_some());
-        assert!(!logs_contain("No transform found between frames"));
-
+            .lookup_transform("map", "base", time_from_nanoseconds(4_000_000_000).unwrap())
+            .is_err());
         assert!(tf
-            .lookup("a", "missing")
-            .at(5.0)
-            .tolerance(0.1)
-            .within(Duration::from_millis(20))
-            .await
-            .is_none());
-        assert!(logs_contain("No transform found between frames"));
+            .lookup_transform("map", "base", time_from_nanoseconds(500_000_000).unwrap())
+            .is_err());
     }
-
-    #[test]
-    fn prunes_samples_outside_window() {
-        let mut buf = TBuffer::new(5.0);
-        buf.add(1.0, Isometry3::identity());
-        buf.add(2.0, Isometry3::identity());
-        buf.add(10.0, Isometry3::identity());
-        assert_eq!(buf.samples.len(), 1);
-        assert!((buf.last().unwrap().ts - 10.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn a_late_sample_does_not_spare_ones_the_window_has_aged_out() {
-        let mut buf = TBuffer::new(5.0);
-        buf.add(10.0, Isometry3::identity());
-        buf.add(11.0, Isometry3::identity());
-        // Late, but still inside the window.
-        buf.add(7.0, Isometry3::identity());
-        assert_eq!(buf.samples.len(), 3);
-
-        buf.add(20.0, Isometry3::identity());
-        assert_eq!(buf.samples.len(), 1);
-        assert!((buf.last().unwrap().ts - 20.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn a_clock_reset_drops_the_pre_jump_samples() {
-        let mut buf = TBuffer::new(5.0);
-        for i in 0..20 {
-            buf.add(1000.0 + i as f64, Isometry3::identity());
-        }
-        for i in 0..20 {
-            buf.add(100.0 + i as f64, Isometry3::identity());
-        }
-        assert!(
-            buf.samples.len() <= 6,
-            "buffer grew to {}",
-            buf.samples.len()
-        );
-        assert!((buf.last().unwrap().ts - 119.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn tf_route_decodes_into_graph() {
-        use lcm_msgs::geometry_msgs::{
-            Quaternion as LQuat, Transform as LTransform, Vector3 as LVec3,
-        };
-        use lcm_msgs::std_msgs::{Header, Time};
-        use lcm_msgs::tf2_msgs::TFMessage;
-
-        let (tx, _rx) = mpsc::channel(8);
-        let (tf, route) = tf_subscription("/tf".to_string(), DEFAULT_TF_WINDOW_SECS, tx);
-        let msg = TFMessage {
-            transforms: vec![lcm_msgs::geometry_msgs::TransformStamped {
-                header: Header {
-                    seq: 0,
-                    stamp: Time {
-                        sec: 5,
-                        nsec: 500_000_000,
-                    },
-                    frame_id: "base_link".to_string(),
-                },
-                child_frame_id: "mid360_link".to_string(),
-                transform: LTransform {
-                    translation: LVec3 {
-                        x: 0.1,
-                        y: 0.2,
-                        z: 0.3,
-                    },
-                    rotation: LQuat {
-                        x: 0.0,
-                        y: 0.0,
-                        z: 0.0,
-                        w: 1.0,
-                    },
-                },
-            }],
-        };
-        route.try_dispatch(&msg.encode());
-
-        let t = tf.get_latest("base_link", "mid360_link").unwrap();
-        assert!((t.translation().x - 0.1).abs() < 1e-9);
-        assert!((t.translation().y - 0.2).abs() < 1e-9);
-        assert!((t.translation().z - 0.3).abs() < 1e-9);
-        assert!((t.ts - 5.5).abs() < 1e-9);
-    }
-
     #[tokio::test]
-    async fn publish_feeds_local_graph() {
-        let (tf, _rx, _h) = tf_with_publish(DEFAULT_TF_WINDOW_SECS);
-        let iso = Isometry3::from_parts(
-            Translation3::new(1.0, 2.0, 3.0),
-            UnitQuaternion::from_euler_angles(0.0, 0.0, PI / 2.0),
-        );
-        tf.publish(&[Transform::new("map", "base_link", 7.0, iso)])
+    async fn static_edges_survive_eviction_and_do_not_limit_dynamic_time() {
+        let (tf, _, _, _rx, mut static_rx) = fixture();
+        tf.publish_static(&[edge("base", "camera", 0, 3.)])
             .await
             .unwrap();
-
-        let t = tf.get_latest("map", "base_link").unwrap();
-        assert!((t.translation().x - 1.0).abs() < 1e-9);
-        assert!((t.translation().y - 2.0).abs() < 1e-9);
-        assert!((t.translation().z - 3.0).abs() < 1e-9);
-        assert!((t.ts - 7.0).abs() < 1e-9);
+        let message: TFMessage = crate::cdr::decode(&static_rx.recv().await.unwrap()).unwrap();
+        assert_eq!(message.transforms[0].child_frame_id, "camera");
+        tf.publish(&[
+            edge("map", "base", 1, 1.),
+            edge("map", "base", 30_000_000_000, 2.),
+        ])
+        .await
+        .unwrap();
+        let result = tf.get_latest("map", "camera").unwrap();
+        assert_eq!(result.transform.translation.x, 5.);
+        assert_eq!(nanoseconds(&result.header.stamp).unwrap(), 30_000_000_000);
+        let at_negative = tf
+            .lookup_transform(
+                "base",
+                "camera",
+                Time {
+                    sec: -1,
+                    nanosec: 999_999_999,
+                },
+            )
+            .unwrap();
+        assert_eq!(at_negative.transform.translation.x, 3.);
+        assert_eq!(nanoseconds(&at_negative.header.stamp).unwrap(), -1);
     }
-
     #[tokio::test]
-    async fn publish_round_trips_through_route() {
-        let (tf_out, mut rx, _h) = tf_with_publish(DEFAULT_TF_WINDOW_SECS);
-        let iso = Isometry3::from_parts(
-            Translation3::new(0.5, -0.5, 0.25),
-            UnitQuaternion::from_euler_angles(0.0, 0.0, PI / 6.0),
-        );
-        tf_out
-            .publish(&[Transform::new("a", "b", 3.25, iso)])
+    async fn real_ros_messages_preserve_epoch_nanoseconds_and_negative_times_in_both_endians() {
+        for ns in [-1, 0, 1_700_000_000_123_456_789, 1_700_000_000_123_456_790] {
+            for little in [true, false] {
+                let (tf, route, _, _rx, _static_rx) = fixture();
+                let original = TFMessage {
+                    transforms: vec![edge("map", "base", ns, 4.)],
+                };
+                route.try_dispatch(&crate::cdr::encode_endian(&original, little).unwrap());
+                let found = tf.get_latest("map", "base").unwrap();
+                assert_eq!(nanoseconds(&found.header.stamp).unwrap(), ns);
+                assert_eq!(found, original.transforms[0]);
+            }
+        }
+        let (tf, _, _, _rx, _static_rx) = fixture();
+        let ns = 1_700_000_000_123_456_789;
+        tf.publish(&[edge("map", "base", ns, 1.), edge("map", "base", ns + 1, 2.)])
             .await
             .unwrap();
-        let bytes = rx.recv().await.unwrap();
-
-        let (tx, _rx2) = mpsc::channel(8);
-        let (tf_in, route) = tf_subscription("/tf".to_string(), DEFAULT_TF_WINDOW_SECS, tx);
-        route.try_dispatch(&bytes);
-
-        let t = tf_in.get_latest("a", "b").unwrap();
-        assert!((t.translation().x - 0.5).abs() < 1e-9);
-        assert!((t.translation().y + 0.5).abs() < 1e-9);
-        assert!((t.translation().z - 0.25).abs() < 1e-9);
-        assert!((t.ts - 3.25).abs() < 1e-9);
-        let (_, _, yaw) = t.rotation().euler_angles();
-        assert!((yaw - PI / 6.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn stamp_rounding_does_not_overflow_nsec() {
-        let st = to_stamped(&Transform::new(
-            "a",
-            "b",
-            1.9999999999,
-            Isometry3::identity(),
-        ));
-        assert_eq!(st.header.stamp.sec, 2);
-        assert_eq!(st.header.stamp.nsec, 0);
-    }
-
-    #[test]
-    fn add_out_of_order_keeps_samples_sorted() {
-        let mut buf = TBuffer::new(DEFAULT_TF_WINDOW_SECS);
-        buf.add(3.0, Isometry3::identity());
-        buf.add(1.0, Isometry3::identity());
-        buf.add(2.0, Isometry3::identity());
-        assert!((buf.last().unwrap().ts - 3.0).abs() < 1e-9);
-        let s = buf.find_closest(1.9, None).unwrap();
-        assert!((s.ts - 2.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn tie_prefers_the_later_sample() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("a", "b", 10.0, (1.0, 0.0, 0.0), 0.0);
-        h.add("a", "b", 12.0, (2.0, 0.0, 0.0), 0.0);
-        let t = tf.lookup("a", "b").at(11.0).get().unwrap();
-        assert!((t.translation().x - 2.0).abs() < 1e-9);
-    }
-
-    // Two routes to d: three hops through b, c and two through x. BFS must
-    // compose the two-hop route.
-    #[test]
-    fn bfs_takes_the_fewest_hops_on_a_branching_graph() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("a", "b", 1.0, (1.0, 0.0, 0.0), 0.0);
-        h.add("b", "c", 1.0, (1.0, 0.0, 0.0), 0.0);
-        h.add("c", "d", 1.0, (1.0, 0.0, 0.0), 0.0);
-        h.add("a", "x", 1.0, (10.0, 0.0, 0.0), 0.0);
-        h.add("x", "d", 1.0, (1.0, 0.0, 0.0), 0.0);
-        let t = tf.get_latest("a", "d").unwrap();
-        assert!(
-            (t.translation().x - 11.0).abs() < 1e-9,
-            "{}",
-            t.translation().x
+        assert_eq!(
+            tf.lookup_transform("map", "base", time_from_nanoseconds(ns).unwrap())
+                .unwrap()
+                .transform
+                .translation
+                .x,
+            1.
         );
-    }
-
-    // Inverse of a rotated edge is t' = -R^T t, the classic sign/order trap.
-    #[test]
-    fn reverse_edge_inverts_rotation_and_translation() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("base_link", "arm", 1.0, (1.0, 2.0, 3.0), PI / 2.0);
-        let inv = tf.get_latest("arm", "base_link").unwrap();
-        assert!(
-            (inv.translation().x + 2.0).abs() < 1e-9,
-            "{:?}",
-            inv.translation()
+        assert_eq!(
+            tf.get_latest("map", "base")
+                .unwrap()
+                .transform
+                .translation
+                .x,
+            2.
         );
-        assert!((inv.translation().y - 1.0).abs() < 1e-9);
-        assert!((inv.translation().z + 3.0).abs() < 1e-9);
-        let (_, _, yaw) = inv.rotation().euler_angles();
-        assert!((yaw + PI / 2.0).abs() < 1e-9);
-    }
-
-    #[test]
-    fn composed_chain_accumulates_rotation() {
-        let (tf, h) = tf_with(DEFAULT_TF_WINDOW_SECS);
-        h.add("a", "b", 1.0, (0.0, 0.0, 0.0), PI / 6.0);
-        h.add("b", "c", 1.0, (0.0, 0.0, 0.0), PI / 6.0);
-        let t = tf.get_latest("a", "c").unwrap();
-        let (_, _, yaw) = t.rotation().euler_angles();
-        assert!((yaw - PI / 3.0).abs() < 1e-9);
     }
-
-    #[test]
-    fn dispatch_of_undecodable_bytes_leaves_the_graph_empty() {
-        let (tx, _rx) = mpsc::channel(8);
-        let (tf, route) = tf_subscription("/tf".to_string(), DEFAULT_TF_WINDOW_SECS, tx);
-        route.try_dispatch(b"garbage");
-        assert!(tf.get_latest("a", "b").is_none());
+    #[tokio::test]
+    async fn invalid_batches_do_not_change_the_graph_or_publish() {
+        let (tf, route, _, mut rx, _static_rx) = fixture();
+        tf.publish(&[edge("map", "base", 1, 1.)]).await.unwrap();
+        rx.recv().await.unwrap();
+        let cycle = vec![edge("base", "camera", 1, 3.), edge("camera", "map", 1, 4.)];
+        assert!(tf.publish(&cycle).await.is_err());
+        assert!(tf.get_latest("base", "camera").is_none());
+        assert!(rx.try_recv().is_err());
+        let mut malformed = edge("base", "camera", 1, 3.);
+        malformed.transform.rotation.w = 0.;
+        let invalid = TFMessage {
+            transforms: vec![edge("base", "sensor", 1, 1.), malformed],
+        };
+        route.try_dispatch(&crate::cdr::encode(&invalid).unwrap());
+        assert!(tf.get_latest("base", "sensor").is_none());
+        let valid = crate::cdr::encode(&TFMessage {
+            transforms: vec![edge("base", "sensor", 1, 1.)],
+        })
+        .unwrap();
+        for bytes in [
+            &valid[..valid.len() - 1],
+            &[0, 9, 0, 0],
+            &[0, 1, 0, 0, 255][..],
+        ] {
+            route.try_dispatch(bytes);
+        }
+        let mut trailing = valid;
+        trailing.push(0);
+        route.try_dispatch(&trailing);
+        assert!(tf.get_latest("base", "sensor").is_none());
+        assert_eq!(
+            tf.get_latest("map", "base")
+                .unwrap()
+                .transform
+                .translation
+                .x,
+            1.
+        );
     }
-
     #[tokio::test]
-    async fn publish_errors_when_the_background_task_is_gone() {
-        let (tf, rx, _h) = tf_with_publish(DEFAULT_TF_WINDOW_SECS);
+    async fn closed_publication_queue_leaves_graph_unchanged() {
+        let (tf, _, _, rx, _static_rx) = fixture();
         drop(rx);
-        let err = tf
-            .publish(&[Transform::new("a", "b", 1.0, Isometry3::identity())])
-            .await
-            .unwrap_err();
-        assert_eq!(err.kind(), io::ErrorKind::BrokenPipe);
+        assert_eq!(
+            tf.publish(&[edge("map", "base", 1, 1.)])
+                .await
+                .unwrap_err()
+                .kind(),
+            io::ErrorKind::BrokenPipe
+        );
+        assert!(tf.get_latest("map", "base").is_none());
+    }
+    #[tokio::test]
+    async fn waiting_lookup_wakes_on_static_and_dynamic_messages() {
+        let (tf, route, static_route, _rx, _static_rx) = fixture();
+        let waiter = tf.clone();
+        let task = tokio::spawn(async move {
+            waiter
+                .lookup("map", "camera")
+                .within(Duration::from_secs(1))
+                .await
+                .unwrap()
+        });
+        static_route.try_dispatch(
+            &crate::cdr::encode(&TFMessage {
+                transforms: vec![edge("base", "camera", 0, 3.)],
+            })
+            .unwrap(),
+        );
+        route.try_dispatch(
+            &crate::cdr::encode(&TFMessage {
+                transforms: vec![edge("map", "base", 1, 1.)],
+            })
+            .unwrap(),
+        );
+        assert_eq!(task.await.unwrap().transform.translation.x, 4.);
     }
 }
diff --git a/native/rust/dimos-module/src/time.rs b/native/rust/dimos-module/src/time.rs
index 45d0f9235a5..f99ec67dbf4 100644
--- a/native/rust/dimos-module/src/time.rs
+++ b/native/rust/dimos-module/src/time.rs
@@ -16,7 +16,7 @@
 
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use lcm_msgs::std_msgs::Time;
+use crate::tf::Time;
 
 /// The wall clock as a message stamp.
 pub fn now() -> Time {
@@ -25,14 +25,6 @@ pub fn now() -> Time {
         .unwrap_or_default();
     Time {
         sec: dur.as_secs().min(i32::MAX as u64) as i32,
-        nsec: dur.subsec_nanos() as i32,
+        nanosec: dur.subsec_nanos(),
     }
 }
-
-/// The wall clock in seconds.
-pub(crate) fn now_secs() -> f64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_secs_f64())
-        .unwrap_or(0.0)
-}
diff --git a/native/rust/dimos-tf-messages/Cargo.toml b/native/rust/dimos-tf-messages/Cargo.toml
new file mode 100644
index 00000000000..4a5480adc1a
--- /dev/null
+++ b/native/rust/dimos-tf-messages/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "dimos-tf-messages"
+version = "0.1.0"
+edition = "2024"
+license = "Apache-2.0"
+[workspace]
+[dependencies]
+serde = {version = "1", features = ["derive"]}
+serde-big-array = "=0.5.1"
+cdr = { version = "=0.2.4", git = "https://github.com/TomCC7/cdr-rs", rev = "38a4368255d408faf374726653b39d4a4e9735cb" }
+heapless = {version = "=0.8.0", features = ["serde"]}
+[build-dependencies]
+ros2msg = "=0.5.3"
diff --git a/native/rust/dimos-tf-messages/README.md b/native/rust/dimos-tf-messages/README.md
new file mode 100644
index 00000000000..6ba61b2b192
--- /dev/null
+++ b/native/rust/dimos-tf-messages/README.md
@@ -0,0 +1,13 @@
+This crate contains the standard ROS 2 TF message closure, packaged by
+`dimos-cdrgen==0.1.2`. Cargo generates Rust types with `ros2msg`; the SDK uses
+`cdr` for serialization. No TF codec is implemented here.
+
+The definitions are the same standard schemas shipped in DimOS's message
+source package. The SDK carries this small closure so it can build without
+first installing or generating the full DimOS message package.
+
+Regenerate from the checked-in definitions with:
+
+```sh
+uv run --no-sync python bin/generate-native-tf-messages
+```
diff --git a/native/rust/dimos-tf-messages/build.rs b/native/rust/dimos-tf-messages/build.rs
new file mode 100644
index 00000000000..5a7c32aa188
--- /dev/null
+++ b/native/rust/dimos-tf-messages/build.rs
@@ -0,0 +1,57 @@
+// Copyright 2026 Dimensional Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ros2msg::generator::{FieldInfo, Generator, ItemInfo, ParseCallbacks};
+use std::{env, fs, path::PathBuf};
+
+struct Serde;
+impl ParseCallbacks for Serde {
+    fn sequence_type(&self, element: &str, bound: Option<u32>, _: &str) -> Option<String> {
+        bound.map(|n| format!("heapless::Vec<{element}, {n}>"))
+    }
+    fn add_derives(&self, _: &ItemInfo) -> Vec<String> {
+        vec!["serde::Serialize".into(), "serde::Deserialize".into(), "PartialEq".into()]
+    }
+    fn add_field_attributes(&self, field: &FieldInfo) -> Vec<String> {
+        if field.array_size().is_some_and(|n| n > 32) && field.capacity().is_none() {
+            vec!["#[serde(with = \"serde_big_array::BigArray\")]".into()]
+        } else { vec![] }
+    }
+}
+const HAS_OWNED_MESSAGES: bool = true;
+fn main() {
+    let output = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    if !HAS_OWNED_MESSAGES {
+        fs::write(output.join("mod.rs"), "").expect("write empty message module");
+        return;
+    }
+    println!("cargo:rerun-if-changed=interfaces");
+    let mut paths = Vec::new();
+    for package in fs::read_dir("interfaces").expect("missing message sources") {
+        let directory = package.unwrap().path().join("msg");
+        if directory.is_dir() {
+            for entry in fs::read_dir(directory).unwrap() {
+                let path = entry.unwrap().path();
+                if path.extension().is_some_and(|ext| ext == "msg") { paths.push(path); }
+            }
+        }
+    }
+    paths.sort();
+    // Upstream currently emits invalid floating-point default literals. Keep
+    // native constructors explicit until the upstream Default acceptance passes.
+    Generator::new().derive_debug(true).derive_clone(true).derive_default(false)
+        .parse_callbacks(Box::new(Serde)).includes(paths)
+        .output_dir(output)
+        .generate().expect("ros2msg generation failed");
+}
diff --git a/native/rust/dimos-tf-messages/interfaces/builtin_interfaces/msg/Time.msg b/native/rust/dimos-tf-messages/interfaces/builtin_interfaces/msg/Time.msg
new file mode 100644
index 00000000000..03cc83f8622
--- /dev/null
+++ b/native/rust/dimos-tf-messages/interfaces/builtin_interfaces/msg/Time.msg
@@ -0,0 +1,11 @@
+# This message communicates ROS Time defined here:
+# https://design.ros2.org/articles/clock_and_time.html
+
+# The seconds component, valid over all int32 values.
+int32 sec
+
+# The nanoseconds component, valid in the range [0, 1e9), to be added to the seconds component. 
+# e.g.
+# The time -1.7 seconds is represented as {sec: -2, nanosec: 3e8}
+# The time 1.7 seconds is represented as {sec: 1, nanosec: 7e8}
+uint32 nanosec
diff --git a/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Quaternion.msg b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Quaternion.msg
new file mode 100644
index 00000000000..96d392779a2
--- /dev/null
+++ b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Quaternion.msg
@@ -0,0 +1,6 @@
+# This represents an orientation in free space in quaternion form.
+
+float64 x 0
+float64 y 0
+float64 z 0
+float64 w 1
diff --git a/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Transform.msg b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Transform.msg
new file mode 100644
index 00000000000..f605c85ea8e
--- /dev/null
+++ b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Transform.msg
@@ -0,0 +1,4 @@
+# This represents the transform between two coordinate frames in free space.
+
+Vector3 translation
+Quaternion rotation
diff --git a/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/TransformStamped.msg b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/TransformStamped.msg
new file mode 100644
index 00000000000..24e97b80b39
--- /dev/null
+++ b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/TransformStamped.msg
@@ -0,0 +1,19 @@
+# This expresses a transform from coordinate frame header.frame_id
+# to the coordinate frame child_frame_id at the time of header.stamp
+#
+# This message is mostly used by the
+# <a href="https://docs.ros.org/en/rolling/p/tf2/">tf2</a> package.
+# See its documentation for more information.
+#
+# The child_frame_id is necessary in addition to the frame_id
+# in the Header to communicate the full reference for the transform
+# in a self contained message.
+
+# The frame id in the header is used as the reference frame of this transform.
+std_msgs/Header header
+
+# The frame id of the child frame to which this transform points.
+string child_frame_id
+
+# Translation and rotation in 3-dimensions of child_frame_id from header.frame_id.
+Transform transform
diff --git a/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Vector3.msg b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Vector3.msg
new file mode 100644
index 00000000000..b54588e117c
--- /dev/null
+++ b/native/rust/dimos-tf-messages/interfaces/geometry_msgs/msg/Vector3.msg
@@ -0,0 +1,9 @@
+# This represents a vector in free space.
+
+# This is semantically different than a point.
+# A vector is always anchored at the origin.
+# When a transform is applied to a vector, only the rotational component is applied.
+
+float64 x
+float64 y
+float64 z
diff --git a/native/rust/dimos-tf-messages/interfaces/std_msgs/msg/Header.msg b/native/rust/dimos-tf-messages/interfaces/std_msgs/msg/Header.msg
new file mode 100644
index 00000000000..6966bb98863
--- /dev/null
+++ b/native/rust/dimos-tf-messages/interfaces/std_msgs/msg/Header.msg
@@ -0,0 +1,9 @@
+# Standard metadata for higher-level stamped data types.
+# This is generally used to communicate timestamped data
+# in a particular coordinate frame.
+
+# Two-integer timestamp that is expressed as seconds and nanoseconds.
+builtin_interfaces/Time stamp
+
+# Transform frame with which this data is associated.
+string frame_id
diff --git a/native/rust/dimos-tf-messages/interfaces/tf2_msgs/msg/TFMessage.msg b/native/rust/dimos-tf-messages/interfaces/tf2_msgs/msg/TFMessage.msg
new file mode 100644
index 00000000000..fda1e4d0985
--- /dev/null
+++ b/native/rust/dimos-tf-messages/interfaces/tf2_msgs/msg/TFMessage.msg
@@ -0,0 +1 @@
+geometry_msgs/TransformStamped[] transforms
diff --git a/native/rust/dimos-tf-messages/schemas.json b/native/rust/dimos-tf-messages/schemas.json
new file mode 100644
index 00000000000..ae7248f356b
--- /dev/null
+++ b/native/rust/dimos-tf-messages/schemas.json
@@ -0,0 +1,9 @@
+{
+  "builtin_interfaces/msg/Time": "# This message communicates ROS Time defined here:\n# https://design.ros2.org/articles/clock_and_time.html\n\n# The seconds component, valid over all int32 values.\nint32 sec\n\n# The nanoseconds component, valid in the range [0, 1e9), to be added to the seconds component. \n# e.g.\n# The time -1.7 seconds is represented as {sec: -2, nanosec: 3e8}\n# The time 1.7 seconds is represented as {sec: 1, nanosec: 7e8}\nuint32 nanosec\n",
+  "geometry_msgs/msg/Quaternion": "# This represents an orientation in free space in quaternion form.\n\nfloat64 x 0\nfloat64 y 0\nfloat64 z 0\nfloat64 w 1\n",
+  "geometry_msgs/msg/Transform": "# This represents the transform between two coordinate frames in free space.\n\nVector3 translation\nQuaternion rotation\n================================================================================\nMSG: geometry_msgs/Quaternion\n# This represents an orientation in free space in quaternion form.\n\nfloat64 x 0\nfloat64 y 0\nfloat64 z 0\nfloat64 w 1\n================================================================================\nMSG: geometry_msgs/Vector3\n# This represents a vector in free space.\n\n# This is semantically different than a point.\n# A vector is always anchored at the origin.\n# When a transform is applied to a vector, only the rotational component is applied.\n\nfloat64 x\nfloat64 y\nfloat64 z\n",
+  "geometry_msgs/msg/TransformStamped": "# This expresses a transform from coordinate frame header.frame_id\n# to the coordinate frame child_frame_id at the time of header.stamp\n#\n# This message is mostly used by the\n# <a href=\"https://docs.ros.org/en/rolling/p/tf2/\">tf2</a> package.\n# See its documentation for more information.\n#\n# The child_frame_id is necessary in addition to the frame_id\n# in the Header to communicate the full reference for the transform\n# in a self contained message.\n\n# The frame id in the header is used as the reference frame of this transform.\nstd_msgs/Header header\n\n# The frame id of the child frame to which this transform points.\nstring child_frame_id\n\n# Translation and rotation in 3-dimensions of child_frame_id from header.frame_id.\nTransform transform\n================================================================================\nMSG: builtin_interfaces/Time\n# This message communicates ROS Time defined here:\n# https://design.ros2.org/articles/clock_and_time.html\n\n# The seconds component, valid over all int32 values.\nint32 sec\n\n# The nanoseconds component, valid in the range [0, 1e9), to be added to the seconds component. \n# e.g.\n# The time -1.7 seconds is represented as {sec: -2, nanosec: 3e8}\n# The time 1.7 seconds is represented as {sec: 1, nanosec: 7e8}\nuint32 nanosec\n================================================================================\nMSG: geometry_msgs/Quaternion\n# This represents an orientation in free space in quaternion form.\n\nfloat64 x 0\nfloat64 y 0\nfloat64 z 0\nfloat64 w 1\n================================================================================\nMSG: geometry_msgs/Transform\n# This represents the transform between two coordinate frames in free space.\n\nVector3 translation\nQuaternion rotation\n================================================================================\nMSG: geometry_msgs/Vector3\n# This represents a vector in free space.\n\n# This is semantically different than a point.\n# A vector is always anchored at the origin.\n# When a transform is applied to a vector, only the rotational component is applied.\n\nfloat64 x\nfloat64 y\nfloat64 z\n================================================================================\nMSG: std_msgs/Header\n# Standard metadata for higher-level stamped data types.\n# This is generally used to communicate timestamped data\n# in a particular coordinate frame.\n\n# Two-integer timestamp that is expressed as seconds and nanoseconds.\nbuiltin_interfaces/Time stamp\n\n# Transform frame with which this data is associated.\nstring frame_id\n",
+  "geometry_msgs/msg/Vector3": "# This represents a vector in free space.\n\n# This is semantically different than a point.\n# A vector is always anchored at the origin.\n# When a transform is applied to a vector, only the rotational component is applied.\n\nfloat64 x\nfloat64 y\nfloat64 z\n",
+  "std_msgs/msg/Header": "# Standard metadata for higher-level stamped data types.\n# This is generally used to communicate timestamped data\n# in a particular coordinate frame.\n\n# Two-integer timestamp that is expressed as seconds and nanoseconds.\nbuiltin_interfaces/Time stamp\n\n# Transform frame with which this data is associated.\nstring frame_id\n================================================================================\nMSG: builtin_interfaces/Time\n# This message communicates ROS Time defined here:\n# https://design.ros2.org/articles/clock_and_time.html\n\n# The seconds component, valid over all int32 values.\nint32 sec\n\n# The nanoseconds component, valid in the range [0, 1e9), to be added to the seconds component. \n# e.g.\n# The time -1.7 seconds is represented as {sec: -2, nanosec: 3e8}\n# The time 1.7 seconds is represented as {sec: 1, nanosec: 7e8}\nuint32 nanosec\n",
+  "tf2_msgs/msg/TFMessage": "geometry_msgs/TransformStamped[] transforms\n================================================================================\nMSG: builtin_interfaces/Time\n# This message communicates ROS Time defined here:\n# https://design.ros2.org/articles/clock_and_time.html\n\n# The seconds component, valid over all int32 values.\nint32 sec\n\n# The nanoseconds component, valid in the range [0, 1e9), to be added to the seconds component. \n# e.g.\n# The time -1.7 seconds is represented as {sec: -2, nanosec: 3e8}\n# The time 1.7 seconds is represented as {sec: 1, nanosec: 7e8}\nuint32 nanosec\n================================================================================\nMSG: geometry_msgs/Quaternion\n# This represents an orientation in free space in quaternion form.\n\nfloat64 x 0\nfloat64 y 0\nfloat64 z 0\nfloat64 w 1\n================================================================================\nMSG: geometry_msgs/Transform\n# This represents the transform between two coordinate frames in free space.\n\nVector3 translation\nQuaternion rotation\n================================================================================\nMSG: geometry_msgs/TransformStamped\n# This expresses a transform from coordinate frame header.frame_id\n# to the coordinate frame child_frame_id at the time of header.stamp\n#\n# This message is mostly used by the\n# <a href=\"https://docs.ros.org/en/rolling/p/tf2/\">tf2</a> package.\n# See its documentation for more information.\n#\n# The child_frame_id is necessary in addition to the frame_id\n# in the Header to communicate the full reference for the transform\n# in a self contained message.\n\n# The frame id in the header is used as the reference frame of this transform.\nstd_msgs/Header header\n\n# The frame id of the child frame to which this transform points.\nstring child_frame_id\n\n# Translation and rotation in 3-dimensions of child_frame_id from header.frame_id.\nTransform transform\n================================================================================\nMSG: geometry_msgs/Vector3\n# This represents a vector in free space.\n\n# This is semantically different than a point.\n# A vector is always anchored at the origin.\n# When a transform is applied to a vector, only the rotational component is applied.\n\nfloat64 x\nfloat64 y\nfloat64 z\n================================================================================\nMSG: std_msgs/Header\n# Standard metadata for higher-level stamped data types.\n# This is generally used to communicate timestamped data\n# in a particular coordinate frame.\n\n# Two-integer timestamp that is expressed as seconds and nanoseconds.\nbuiltin_interfaces/Time stamp\n\n# Transform frame with which this data is associated.\nstring frame_id\n"
+}
diff --git a/native/rust/dimos-tf-messages/src/lib.rs b/native/rust/dimos-tf-messages/src/lib.rs
new file mode 100644
index 00000000000..7766986c628
--- /dev/null
+++ b/native/rust/dimos-tf-messages/src/lib.rs
@@ -0,0 +1,16 @@
+// Copyright 2026 Dimensional Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub const ROS2MSG_SCHEMAS: &str = include_str!("../schemas.json");
+include!(concat!(env!("OUT_DIR"), "/mod.rs"));