transform-tree 0.0.5__tar.gz → 0.0.7__tar.gz

transform_tree-0.0.7/Cargo.toml

@@ -0,0 +1,123 @@
+[workspace]
+resolver = "2"
+members = [
+    "crates/tf_tree_math",
+    "crates/tf_tree_arena",
+    "crates/tf_tree_core",
+    "crates/tf_tree_ipc",
+    "crates/tf_tree",
+    "crates/tf_tree_bench",
+    "crates/tf_tree_cli",
+    "crates/tf_tree_bridge",
+    "crates/tf_tree_ingest",
+    "crates/tf_tree_c",
+    "xtask",
+]
+# `tf_tree_tf2_sys` (ROS 2) and `tf_tree_py` (libpython) are excluded so
+# `cargo build --workspace` works on every host.
+exclude = [
+    "crates/tf_tree_py","crates/tf_tree_tf2_sys"]
+
+[workspace.package]
+# 0.0.x: every release may break every other (`SUPPORT.md`).
+version = "0.0.7"
+edition = "2021"
+# 1.87 is forced by `ruzstd 0.9.0` (`tf_tree_ingest`). The `msrv` job reads this
+# field; policy in `SUPPORT.md`.
+rust-version = "1.87"
+# Publishable crates symlink `LICENSE-*` and `NOTICE`; publish from Linux.
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/NoeFontana/tf_tree"
+homepage = "https://github.com/NoeFontana/tf_tree"
+authors = ["Noé Fontana <noe.fontana.pro@gmail.com>"]
+keywords = ["robotics", "tf", "transform", "se3", "ros"]
+categories = ["science::robotics", "no-std"]
+
+[workspace.lints.clippy]
+unwrap_used = "deny"
+expect_used = "deny"
+panic = "deny"
+todo = "deny"
+unimplemented = "deny"
+dbg_macro = "deny"
+print_stdout = "warn"
+print_stderr = "warn"
+needless_pass_by_value = "warn"
+redundant_clone = "warn"
+# 0007 rule 3: every `unsafe` block has a `// SAFETY:` comment directly above it.
+# `tf_tree_py` and `tf_tree_tf2_sys` repeat it.
+undocumented_unsafe_blocks = "deny"
+
+[workspace.lints.rust]
+missing_docs = "warn"
+unreachable_pub = "warn"
+unused_must_use = "deny"
+# Registers `--cfg loom` so `-D warnings` accepts it.
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
+
+[workspace.dependencies]
+# Intra-workspace crates.
+tf_tree_math = { path = "crates/tf_tree_math", version = "0.0.7" }
+tf_tree_arena = { path = "crates/tf_tree_arena", version = "0.0.7" }
+# `shm` (`docs/PHASE2.md` §2): `linux_raw` backend, no C build; used only by `tf_tree_ipc`.
+libc = "0.2"
+rustix = { version = "1.1", default-features = false, features = ["mm", "fs", "std"] }
+# `default-features = false` is load-bearing: without it `--no-default-features`
+# downstream still enables `counters` (`docs/PHASE5.md` §5.5).
+tf_tree_core = { path = "crates/tf_tree_core", version = "0.0.7", default-features = false }
+tf_tree_ipc = { path = "crates/tf_tree_ipc", version = "0.0.7" }
+tf_tree = { path = "crates/tf_tree", version = "0.0.7", default-features = false }
+# publish = false crates; `default-features = false` as above.
+tf_tree_bench = { path = "crates/tf_tree_bench", default-features = false }
+tf_tree_bridge = { path = "crates/tf_tree_bridge" }
+# `docs/PHASE5.md` §3. The CLI decides whether the engine counts.
+tf_tree_ingest = { path = "crates/tf_tree_ingest", default-features = false }
+# no_std numeric + POD casting (the entire core dependency budget, plus blake3).
+libm = "0.2"
+bytemuck = { version = "1", features = ["derive"] }
+blake3 = { version = "1", default-features = false }
+# `tf_tree_math`'s optional `helicoid` feature (`docs/decisions/0063`): off by default, so D14's budget holds for everyone who does not opt in.
+helicoid = "=0.0.4"
+helicoid-linalg = "=0.0.4"
+# std-side facade / tooling only.
+thiserror = "2"
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+# dev / bench only.
+proptest = "1"
+loom = "0.7"
+criterion = { version = "0.5", features = ["html_reports"] }
+serde_json = "1"
+
+[profile.release]
+lto = "thin"
+codegen-units = 1
+debug = "line-tables-only"
+strip = "debuginfo"
+
+[profile.dev]
+opt-level = 0
+
+[profile.bench]
+lto = "thin"
+codegen-units = 1
+
+# Release codegen with debuginfo for profilers.
+[profile.profiling]
+inherits = "release"
+debug = "full"
+strip = "none"
+
+# An embedder's `cargo build --release` (`docs/PHASE5.md` §9.2, `docs/API.md` §2.3):
+# every default spelled out; `crates/tf_tree_bench/src/embed.rs` tests these values.
+[profile.embedder]
+inherits = "release"
+opt-level = 3
+lto = false
+codegen-units = 16
+debug = false
+strip = "none"
+debug-assertions = false
+overflow-checks = false
+incremental = false
+panic = "unwind"

{transform_tree-0.0.5/crates/tf_tree_core → transform_tree-0.0.7}/NOTICE

@@ -19,7 +19,8 @@ carries no third-party attributions of its own: `tf_tree` vendors no source and
 statically links no code it did not write. Its Rust dependencies are ordinary
 crates.io dependencies, each under its own licence, resolved at build time and
 enumerated in `Cargo.lock`; the set is constrained by `deny.toml` and checked by
-`cargo deny check`, which `just lint` runs.
+`cargo deny check` — the recipe `just audit`, run in CI as its own step of the
+job named `lint`.
 
 `tf_tree` is not affiliated with, endorsed by, or derived from the Open Source
 Robotics Foundation, ROS, or the `tf` / `tf2` packages. It is an independent

transform_tree-0.0.7/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: transform_tree
+Version: 0.0.7
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering
+Requires-Dist: numpy>=2.2.6
+License-File: LICENSE-APACHE
+License-File: LICENSE-MIT
+License-File: NOTICE
+Summary: A transform tree engine — faster and more scalable than ROS tf2
+Home-Page: https://github.com/NoeFontana/tf_tree
+Author-email: Noé Fontana <noe.fontana.pro@gmail.com>
+License-Expression: MIT OR Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# tf_tree
+
+[![crates.io](https://img.shields.io/crates/v/tf_tree.svg?logo=rust)](https://crates.io/crates/tf_tree)
+[![docs.rs](https://img.shields.io/docsrs/tf_tree?logo=docsdotrs)](https://docs.rs/tf_tree)
+[![PyPI](https://img.shields.io/pypi/v/transform_tree.svg?logo=pypi&logoColor=white)](https://pypi.org/project/transform_tree/)
+[![CI](https://github.com/NoeFontana/tf_tree/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/NoeFontana/tf_tree/actions/workflows/ci.yml)
+[![Licence](https://img.shields.io/badge/licence-MIT%20OR%20Apache--2.0-blue.svg)](#licence)
+
+A transform tree: it stores time-stamped poses between named frames and answers
+"where was frame A relative to frame B at time t?". Use it in a control loop,
+across processes on one host, or in a dataloader with no robot attached.
+
+It is faster than ROS `tf2` (below) but is not `tf2`: no ROS dependency and no
+drop-in `tf2_ros::Buffer`, only a one-way `/tf` ingest bridge
+([`0008`](./docs/decisions/0008-the-name-tf-tree.md)). Linux first: shared memory
+and frozen `.tft` files are Linux-only (`shm` feature); the in-process engine is
+portable.
+
+**`0.0.x` promises nothing between releases.** Pin exactly ([`CHANGELOG.md`](./CHANGELOG.md)).
+
+## Install
+
+- Rust: `cargo add tf_tree`
+- Python: `pip install transform_tree`, then `import tf_tree`
+- CLI (`tf_tree`, alias `tft`): a binary from the [latest release](https://github.com/NoeFontana/tf_tree/releases/latest), or `cargo install --path crates/tf_tree_cli --features shm`
+- C ABI, C++ header, ROS 2 bridge: `just c-abi-check`, `just cpp-check`, `just ros-build`
+
+## Quickstart
+
+Python, from scratch (`just quickstart` runs this). Stamps are integer nanoseconds; a pose is `[qw, qx, qy, qz, x, y, z]`.
+
+```python
+import tf_tree
+
+tree = tf_tree.build([("map", "base"), ("base", "cam")])
+tf_tree.push(tree, "base", "map", 1_000, [1, 0, 0, 0, 1.0, 2.0, 3.0])
+tf_tree.push(tree, "base", "map", 2_000, [1, 0, 0, 0, 3.0, 4.0, 5.0])
+
+plan = tree.plan("map", "base")   # compile the route once, reuse it
+print(plan.at(1_500)[:3, 3])      # -> [2. 3. 4.]
+```
+
+Rust:
+
+```rust
+use tf_tree::{Capacity, EdgeCfg, Iso3, Quat, Stamp, TreeBuilder, Vec3};
+
+let tree = TreeBuilder::new()
+    .static_edge("base_link", "lidar_top", &Iso3::IDENTITY)   // (parent, child)
+    .dynamic_edge("odom", "base_link", EdgeCfg::new(Capacity::history(100.0, 10.0)))
+    .build()
+    .expect("layout");
+let odom = tree.frame("odom").expect("declared");
+let base_link = tree.frame("base_link").expect("declared");
+let lidar_top = tree.frame("lidar_top").expect("declared");
+
+let w = tree.claim(base_link, odom).expect("unclaimed");   // (child, parent)
+let at_x = |x| Iso3::new(Quat::IDENTITY, Vec3::new(x, 0.0, 0.0));
+w.push(1_000_000_000, &at_x(0.0)).expect("monotonic");
+w.push(1_010_000_000, &at_x(1.0)).expect("monotonic");
+
+let plan = tree.plan(odom, lidar_top).expect("connected");
+let g = tree.guard();
+let t: Stamp = Stamp::from_nanos(1_005_000_000);
+let pose = plan.at(&g, t).expect("in range");
+assert!((pose.t.x - 0.5).abs() < 1e-12);
+```
+
+## From a recorded bag
+
+MCAP only (for `.db3`, run `ros2 bag convert` first):
+
+```sh
+tft doctor --from-bag drive.mcap                 # what is wrong with this /tf traffic
+tft freeze --from-bag drive.mcap -o drive.tft    # index it
+```
+```python
+tree = tf_tree.open_file("drive.tft")   # an mmap; open per worker, after fork/spawn
+poses = tree.plan("base_link", "lidar_top").at(stamps_ns, layout="quat_twist")  # (N, 13)
+```
+
+## Against `tf2`
+
+In-process, one thread, same interpolation, `tf2` called natively; 4-core EPYC-Milan,
+not core-pinned. Both agree to 7e-15 on 50,000 recorded queries.
+
+| | `tf_tree` | `tf2` | |
+|---|---|---|---|
+| Lookup, depth 3 | 94 ns | 253 ns | 2.7× |
+| Lookup, depth 15 | 1193 ns | 7337 ns | 6.2× |
+| Publish | 9.4 ns | 114 ns | 12.1× |
+
+Without LTO the lookup gap is 1.8×; through the C ABI, 1.5×. Method:
+[`tf2.md`](./docs/benchmarks/tf2.md); sources: [`EVIDENCE.md`](./docs/benchmarks/EVIDENCE.md).
+
+## Not for
+
+| Need | Why | See |
+|---|---|---|
+| Drop-in `tf2_ros::Buffer` | gated, not scheduled | [`PHASE7.md`](./docs/PHASE7.md) |
+| Covariance, multi-parent frames, loop closure | cut | [`0009`](./docs/decisions/0009-descoping-phase-6.md) |
+| Transforms across hosts | not started | [`PROJECT.md`](./docs/PROJECT.md) §4 |
+| Shared memory or `.tft` off Linux | not implemented | [`SUPPORT.md`](./SUPPORT.md) |
+| A viewer, point-cloud deskewing | deliberately absent | [`PHASE5.md`](./docs/PHASE5.md) §8 |
+
+## Status
+
+| Phase | | Status |
+|---|---|---|
+| 1 | Engine: arena, seqlock buffers, plans, SE(3) math | Implemented |
+| 2 | Shared memory across processes | Implemented, with gaps |
+| 3 | Python bindings | Implemented |
+| 4 | C ABI, C++ wrapper, ROS 2 ingest, derivatives | Implemented, with gaps |
+| 5 | Frozen `.tft`, bag ingestion, diagnostics, `tf_tree top` | Mostly implemented |
+| 6–8 | Continuous time, `tf2` shim, multi-host | Not started |
+
+The `§0.0` tables in [`PHASE2`](./docs/PHASE2.md#00-implementation-status),
+[`PHASE4`](./docs/PHASE4.md#00-implementation-status) and
+[`PHASE5`](./docs/PHASE5.md#00-implementation-status) win over this one.
+
+## Shared memory is not a sandbox
+
+Processes sharing an arena trust each other: a read-write participant can corrupt
+it ([`PHASE2.md`](./docs/PHASE2.md) §3.10; [`SECURITY.md`](./SECURITY.md)). A
+read-only participant (the default for readers) cannot, and a crashed or hung one
+cannot wedge the others.
+
+`fork()` is the sharp edge: a child's inherited handles report `ChildDetached`.
+Python's `multiprocessing` forks by default on Linux, so open the arena inside the
+worker or use `spawn`. A frozen `.tft` survives a fork.
+
+## Layout
+
+`crates/`: `tf_tree_math`, `tf_tree_arena`, `tf_tree_core`, `tf_tree` (facade),
+`tf_tree_ipc`, `tf_tree_c`, `tf_tree_bridge`, `tf_tree_ingest`, `tf_tree_py`,
+`tf_tree_bench`, `tf_tree_tf2_sys`, `tf_tree_cli`. `ros/` holds the ROS 2
+packages. `tf_tree_py`, `tf_tree_tf2_sys` and `ros/` sit outside the cargo
+workspace and have their own `just` recipes. Five crates publish: `tf_tree`,
+`tf_tree_core`, `tf_tree_math`, `tf_tree_arena`, `tf_tree_ipc`. MSRV **1.87**.
+
+Docs: [`docs/README.md`](./docs/README.md) ·
+[`CONTRIBUTING.md`](./CONTRIBUTING.md) · [`SUPPORT.md`](./SUPPORT.md) ·
+[`SECURITY.md`](./SECURITY.md) · [`CODE_OF_CONDUCT.md`](./CODE_OF_CONDUCT.md)
+
+## Licence
+
+Dual [MIT](./LICENSE-MIT) / [Apache-2.0](./LICENSE-APACHE), at your option. See
+[`NOTICE`](./NOTICE).
+

transform_tree-0.0.7/README.md

@@ -0,0 +1,148 @@
+# tf_tree
+
+[![crates.io](https://img.shields.io/crates/v/tf_tree.svg?logo=rust)](https://crates.io/crates/tf_tree)
+[![docs.rs](https://img.shields.io/docsrs/tf_tree?logo=docsdotrs)](https://docs.rs/tf_tree)
+[![PyPI](https://img.shields.io/pypi/v/transform_tree.svg?logo=pypi&logoColor=white)](https://pypi.org/project/transform_tree/)
+[![CI](https://github.com/NoeFontana/tf_tree/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/NoeFontana/tf_tree/actions/workflows/ci.yml)
+[![Licence](https://img.shields.io/badge/licence-MIT%20OR%20Apache--2.0-blue.svg)](#licence)
+
+A transform tree: it stores time-stamped poses between named frames and answers
+"where was frame A relative to frame B at time t?". Use it in a control loop,
+across processes on one host, or in a dataloader with no robot attached.
+
+It is faster than ROS `tf2` (below) but is not `tf2`: no ROS dependency and no
+drop-in `tf2_ros::Buffer`, only a one-way `/tf` ingest bridge
+([`0008`](./docs/decisions/0008-the-name-tf-tree.md)). Linux first: shared memory
+and frozen `.tft` files are Linux-only (`shm` feature); the in-process engine is
+portable.
+
+**`0.0.x` promises nothing between releases.** Pin exactly ([`CHANGELOG.md`](./CHANGELOG.md)).
+
+## Install
+
+- Rust: `cargo add tf_tree`
+- Python: `pip install transform_tree`, then `import tf_tree`
+- CLI (`tf_tree`, alias `tft`): a binary from the [latest release](https://github.com/NoeFontana/tf_tree/releases/latest), or `cargo install --path crates/tf_tree_cli --features shm`
+- C ABI, C++ header, ROS 2 bridge: `just c-abi-check`, `just cpp-check`, `just ros-build`
+
+## Quickstart
+
+Python, from scratch (`just quickstart` runs this). Stamps are integer nanoseconds; a pose is `[qw, qx, qy, qz, x, y, z]`.
+
+```python
+import tf_tree
+
+tree = tf_tree.build([("map", "base"), ("base", "cam")])
+tf_tree.push(tree, "base", "map", 1_000, [1, 0, 0, 0, 1.0, 2.0, 3.0])
+tf_tree.push(tree, "base", "map", 2_000, [1, 0, 0, 0, 3.0, 4.0, 5.0])
+
+plan = tree.plan("map", "base")   # compile the route once, reuse it
+print(plan.at(1_500)[:3, 3])      # -> [2. 3. 4.]
+```
+
+Rust:
+
+```rust
+use tf_tree::{Capacity, EdgeCfg, Iso3, Quat, Stamp, TreeBuilder, Vec3};
+
+let tree = TreeBuilder::new()
+    .static_edge("base_link", "lidar_top", &Iso3::IDENTITY)   // (parent, child)
+    .dynamic_edge("odom", "base_link", EdgeCfg::new(Capacity::history(100.0, 10.0)))
+    .build()
+    .expect("layout");
+let odom = tree.frame("odom").expect("declared");
+let base_link = tree.frame("base_link").expect("declared");
+let lidar_top = tree.frame("lidar_top").expect("declared");
+
+let w = tree.claim(base_link, odom).expect("unclaimed");   // (child, parent)
+let at_x = |x| Iso3::new(Quat::IDENTITY, Vec3::new(x, 0.0, 0.0));
+w.push(1_000_000_000, &at_x(0.0)).expect("monotonic");
+w.push(1_010_000_000, &at_x(1.0)).expect("monotonic");
+
+let plan = tree.plan(odom, lidar_top).expect("connected");
+let g = tree.guard();
+let t: Stamp = Stamp::from_nanos(1_005_000_000);
+let pose = plan.at(&g, t).expect("in range");
+assert!((pose.t.x - 0.5).abs() < 1e-12);
+```
+
+## From a recorded bag
+
+MCAP only (for `.db3`, run `ros2 bag convert` first):
+
+```sh
+tft doctor --from-bag drive.mcap                 # what is wrong with this /tf traffic
+tft freeze --from-bag drive.mcap -o drive.tft    # index it
+```
+```python
+tree = tf_tree.open_file("drive.tft")   # an mmap; open per worker, after fork/spawn
+poses = tree.plan("base_link", "lidar_top").at(stamps_ns, layout="quat_twist")  # (N, 13)
+```
+
+## Against `tf2`
+
+In-process, one thread, same interpolation, `tf2` called natively; 4-core EPYC-Milan,
+not core-pinned. Both agree to 7e-15 on 50,000 recorded queries.
+
+| | `tf_tree` | `tf2` | |
+|---|---|---|---|
+| Lookup, depth 3 | 94 ns | 253 ns | 2.7× |
+| Lookup, depth 15 | 1193 ns | 7337 ns | 6.2× |
+| Publish | 9.4 ns | 114 ns | 12.1× |
+
+Without LTO the lookup gap is 1.8×; through the C ABI, 1.5×. Method:
+[`tf2.md`](./docs/benchmarks/tf2.md); sources: [`EVIDENCE.md`](./docs/benchmarks/EVIDENCE.md).
+
+## Not for
+
+| Need | Why | See |
+|---|---|---|
+| Drop-in `tf2_ros::Buffer` | gated, not scheduled | [`PHASE7.md`](./docs/PHASE7.md) |
+| Covariance, multi-parent frames, loop closure | cut | [`0009`](./docs/decisions/0009-descoping-phase-6.md) |
+| Transforms across hosts | not started | [`PROJECT.md`](./docs/PROJECT.md) §4 |
+| Shared memory or `.tft` off Linux | not implemented | [`SUPPORT.md`](./SUPPORT.md) |
+| A viewer, point-cloud deskewing | deliberately absent | [`PHASE5.md`](./docs/PHASE5.md) §8 |
+
+## Status
+
+| Phase | | Status |
+|---|---|---|
+| 1 | Engine: arena, seqlock buffers, plans, SE(3) math | Implemented |
+| 2 | Shared memory across processes | Implemented, with gaps |
+| 3 | Python bindings | Implemented |
+| 4 | C ABI, C++ wrapper, ROS 2 ingest, derivatives | Implemented, with gaps |
+| 5 | Frozen `.tft`, bag ingestion, diagnostics, `tf_tree top` | Mostly implemented |
+| 6–8 | Continuous time, `tf2` shim, multi-host | Not started |
+
+The `§0.0` tables in [`PHASE2`](./docs/PHASE2.md#00-implementation-status),
+[`PHASE4`](./docs/PHASE4.md#00-implementation-status) and
+[`PHASE5`](./docs/PHASE5.md#00-implementation-status) win over this one.
+
+## Shared memory is not a sandbox
+
+Processes sharing an arena trust each other: a read-write participant can corrupt
+it ([`PHASE2.md`](./docs/PHASE2.md) §3.10; [`SECURITY.md`](./SECURITY.md)). A
+read-only participant (the default for readers) cannot, and a crashed or hung one
+cannot wedge the others.
+
+`fork()` is the sharp edge: a child's inherited handles report `ChildDetached`.
+Python's `multiprocessing` forks by default on Linux, so open the arena inside the
+worker or use `spawn`. A frozen `.tft` survives a fork.
+
+## Layout
+
+`crates/`: `tf_tree_math`, `tf_tree_arena`, `tf_tree_core`, `tf_tree` (facade),
+`tf_tree_ipc`, `tf_tree_c`, `tf_tree_bridge`, `tf_tree_ingest`, `tf_tree_py`,
+`tf_tree_bench`, `tf_tree_tf2_sys`, `tf_tree_cli`. `ros/` holds the ROS 2
+packages. `tf_tree_py`, `tf_tree_tf2_sys` and `ros/` sit outside the cargo
+workspace and have their own `just` recipes. Five crates publish: `tf_tree`,
+`tf_tree_core`, `tf_tree_math`, `tf_tree_arena`, `tf_tree_ipc`. MSRV **1.87**.
+
+Docs: [`docs/README.md`](./docs/README.md) ·
+[`CONTRIBUTING.md`](./CONTRIBUTING.md) · [`SUPPORT.md`](./SUPPORT.md) ·
+[`SECURITY.md`](./SECURITY.md) · [`CODE_OF_CONDUCT.md`](./CODE_OF_CONDUCT.md)
+
+## Licence
+
+Dual [MIT](./LICENSE-MIT) / [Apache-2.0](./LICENSE-APACHE), at your option. See
+[`NOTICE`](./NOTICE).

transform_tree-0.0.7/crates/tf_tree/Cargo.toml

@@ -0,0 +1,74 @@
+[package]
+name = "tf_tree"
+description = "std facade for the tf_tree transform engine: ergonomic builder, lookups, and Display errors."
+# Per-crate crates.io front page (see `tf_tree_math`'s manifest).
+readme = "README.md"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+authors.workspace = true
+keywords.workspace = true
+# Drops the inherited `no-std`: this is the `std` facade.
+categories = ["science::robotics"]
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[features]
+default = ["counters"]
+# Passthrough to `tf_tree_core` (`docs/PHASE5.md` §5.5).
+counters = ["tf_tree_core/counters"]
+pure-hash = ["tf_tree_core/pure-hash"]
+# `docs/PHASE2.md` §11.3's fault injection; arms `crate::CRASH_SITES` too.
+crash-points = ["tf_tree_core/crash-points"]
+# `TreeBuilder::build_shared` / `Tree::attach_shared`. Linux-only.
+shm = ["tf_tree_arena/shm", "dep:tf_tree_ipc"]
+# `docs/API.md` §6's Rust mirror of `tf_tree_unstable.h` (`docs/PHASE4.md` §3.1).
+# Enabling is the waiver: nothing behind it is covered by semver.
+#
+# Enabling consumers, checked by `just stable-tier-check` against this comment and
+# `docs/API.md` §6 row 4: `tf_tree_cli`, `tf_tree_c`, `tf_tree_bench`, `tf_tree_py`.
+unstable = []
+# `#[doc(hidden)]` test seams: `CLAIM_WINDOW_HOOK` (`docs/decisions/0005` §5) and
+# `reclamation_verdict_for_test` (`docs/decisions/0028` step 2). Run by `just shm-rendezvous`.
+test-hooks = []
+
+[dependencies]
+tf_tree_core.workspace = true
+tf_tree_math.workspace = true
+tf_tree_arena.workspace = true
+thiserror.workspace = true
+
+# The rendezvous (`docs/decisions/0005`); gated on `shm` and Linux.
+[target.'cfg(target_os = "linux")'.dependencies]
+tf_tree_ipc = { workspace = true, optional = true }
+
+[dev-dependencies]
+# No self dev-dependency: `cargo package` strips it. Tests gate `arena_view` call
+# sites with `#[cfg(feature = "unstable")]` (`tests/feature_gates.rs`).
+tf_tree_ipc = { workspace = true }
+proptest.workspace = true
+
+# `tests/rendezvous.rs`'s second process. Published, so the name is prefixed;
+# `cargo install --features shm` writes it to `~/.cargo/bin` (`README.md`). It
+# stays here because `env!("CARGO_BIN_EXE_…")` needs this package's executable.
+[[bin]]
+name = "tf_tree_rendezvous_child"
+path = "src/bin/rendezvous_child.rs"
+required-features = ["shm"]
+
+[[test]]
+name = "rendezvous"
+required-features = ["shm"]
+
+# `docs/PHASE5.md` §2; Linux-only, behind `shm`.
+[[test]]
+name = "frozen"
+required-features = ["shm"]

{transform_tree-0.0.5 → transform_tree-0.0.7}/crates/tf_tree/NOTICE

@@ -19,7 +19,8 @@ carries no third-party attributions of its own: `tf_tree` vendors no source and
 statically links no code it did not write. Its Rust dependencies are ordinary
 crates.io dependencies, each under its own licence, resolved at build time and
 enumerated in `Cargo.lock`; the set is constrained by `deny.toml` and checked by
-`cargo deny check`, which `just lint` runs.
+`cargo deny check` — the recipe `just audit`, run in CI as its own step of the
+job named `lint`.
 
 `tf_tree` is not affiliated with, endorsed by, or derived from the Open Source
 Robotics Foundation, ROS, or the `tf` / `tf2` packages. It is an independent

transform_tree-0.0.7/crates/tf_tree/README.md

@@ -0,0 +1,104 @@
+# tf_tree
+
+[![crates.io](https://img.shields.io/crates/v/tf_tree.svg?logo=rust)](https://crates.io/crates/tf_tree)
+[![docs.rs](https://img.shields.io/docsrs/tf_tree?logo=docsdotrs)](https://docs.rs/tf_tree)
+[![Licence](https://img.shields.io/badge/licence-MIT%20OR%20Apache--2.0-blue.svg)](#licence)
+
+A transform tree engine: store time-stamped rigid-body transforms between named
+coordinate frames and answer *"where was frame A relative to frame B at time
+t?"* — from a control loop, from many processes at once, or offline.
+
+**This is the crate to depend on**: the `std` facade over the `no_std` engine
+([`tf_tree_core`](https://crates.io/crates/tf_tree_core)). **It is not `tf2` and
+not affiliated with ROS**; there is no drop-in `tf2_ros::Buffer` shim.
+
+## Install
+
+```sh
+cargo add tf_tree
+```
+
+Shared arenas, the frozen `.tft` reader and `tf_tree::open()` are behind the
+default-off, **Linux-only** `shm` feature: `cargo add tf_tree --features shm`.
+Python: `pip install transform_tree`.
+
+## In full
+
+```rust
+use tf_tree::{Capacity, EdgeCfg, Iso3, Quat, Stamp, TreeBuilder, Vec3};
+
+// Topology is declared up front; nothing allocates after `build()`.
+let tree = TreeBuilder::new()
+    .static_edge("base_link", "lidar_top", &Iso3::IDENTITY)
+    .dynamic_edge("odom", "base_link", EdgeCfg::new(Capacity::history(100.0, 10.0)))
+    .build()
+    .expect("layout");
+
+let odom = tree.frame("odom").expect("declared");
+let base_link = tree.frame("base_link").expect("declared");
+let lidar_top = tree.frame("lidar_top").expect("declared");
+
+// One writer per edge, enforced by the claim table.
+let w = tree.claim(base_link, odom).expect("unclaimed");   // (child, parent)
+let at_x = |x| Iso3::new(Quat::IDENTITY, Vec3::new(x, 0.0, 0.0));
+w.push(1_000_000_000, &at_x(0.0)).expect("monotonic");     // integer nanoseconds
+w.push(1_010_000_000, &at_x(1.0)).expect("monotonic");
+
+// Compile the route once, evaluate it many times.
+let plan = tree.plan(odom, lidar_top).expect("connected");
+let g = tree.guard();
+
+// The annotation pins the default `SystemDomain`.
+let t: Stamp = Stamp::from_nanos(1_005_000_000);
+match plan.at(&g, t) {
+    Ok(pose) => println!("x = {}", pose.t.x),          // -> x = 0.5
+    Err(e) => println!("{}", tree.describe(e)),
+}
+
+let late: Stamp = Stamp::from_nanos(3_000_000_000);
+match plan.at(&g, late) {
+    Ok(_) => unreachable!(),
+    // -> lookup on odom->base_link (edge#2) would extrapolate:
+    //    requested 3000000000 ns, history [1000000000, 1010000000] ns
+    Err(e) => println!("{}", tree.describe(e)),
+}
+```
+
+**Stamps are integer nanoseconds and carry a domain in the type**; **`plan()` is
+the object you keep** (`lookup()` by name caches one); **errors are `Copy`
+identifiers naming the offending edge**, also `Display` and `std::error::Error`.
+
+## Features
+
+| Feature | Default | What it does |
+|---|---|---|
+| `counters` | **on** | Diagnostic counters; off does not fork the layout hash |
+| `shm` | off | `TreeBuilder::build_shared`, `Tree::attach_shared`, `tf_tree::open()`, the frozen `.tft` reader. **Linux only** |
+| `unstable` | off | Arena-shaped introspection (`tf_tree::unstable`, `Tree::arena_view`); **enabling it is the waiver** of semver |
+| `test-hooks` | off | An injection point inside `Tree::claim` for the repository's tests. Not for shipped builds |
+
+## Shared memory is not a sandbox
+
+Processes sharing an arena are **mutually trusting, same-user, cooperating
+processes**; a read-write participant can corrupt any part of the arena
+([`SECURITY.md`](https://github.com/NoeFontana/tf_tree/blob/main/SECURITY.md)).
+`fork()` is the sharp edge: a shared arena is mapped `MADV_DONTFORK`, so a child's
+handles report `ChildDetached`; open inside the worker. A frozen `.tft` is
+inherited intact.
+
+## Version and docs
+
+**`0.0.x` promises nothing**: pin exactly
+([`CHANGELOG.md`](https://github.com/NoeFontana/tf_tree/blob/main/CHANGELOG.md)).
+MSRV is **1.87**
+([`SUPPORT.md`](https://github.com/NoeFontana/tf_tree/blob/main/SUPPORT.md)).
+
+The CLI, C ABI and C++ wrapper, MCAP ingest, ROS 2 bridge and Python bindings are
+built from source; `cargo install tf_tree` installs no command. See the repository
+[`README.md`](https://github.com/NoeFontana/tf_tree/blob/main/README.md),
+[`docs/PROJECT.md`](https://github.com/NoeFontana/tf_tree/blob/main/docs/PROJECT.md)
+and [`docs/API.md`](https://github.com/NoeFontana/tf_tree/blob/main/docs/API.md).
+
+## Licence
+
+Dual [MIT](LICENSE-MIT) / [Apache-2.0](LICENSE-APACHE), at your option; see [`NOTICE`](NOTICE).