# Dispatch order 1. **Built-ins** — resolved via [`dispatch_builtin`] and wrapped in `BuiltinAdapter`. 2. **Native** (`.so` / `.dylib` / `.dll`) — resolved by scanning `bundle_dir` for a native artifact, then dlopen-loaded via [`NativeExtension`]. 3. **WASM** — resolved by scanning `bundle_dir` for a `.wasm` artifact, then loaded via [`WasmExtension`]. 4. **Host** (Python) — not supported in this Rust-only router; returns [`CodecError::Unsupported`] with a clear message. The router caches resolved codecs by `CanonicalId` so repeated calls for the same id are free after the first lookup. # Wire-format note `PlaneRecord` now carries both `codec_id: CodecId` (closed enum, legacy) and `codec_table_idx: u16` (Extension Table index, C2 wire-format addition). When `codec_table_idx` is parsed, `decode_tensor` in `container.rs` resolves the `CanonicalId` via the Extension Table and validates availability through this router before dispatching the actual decode to the in-tree `PlaneCodec` implementation (for built-ins) or, for third-party codecs in a future task, to a dynamically-loaded extension.

Same shape as [`PlaneCodecRouter`], minus the built-in step: `ptwm` ships zero built-in `delta_scheme` contributions today, so resolution goes straight to the installed-extension search (native preferred over WASM). Results are cached by `CanonicalId`, same as `PlaneCodecRouter`.

Mirrors [`DispatchedPlaneCodec`], but over the two-buffer delta ABI: `encode(base, target) -> delta`, `decode(base, delta) -> target`.

Provides two methods: `dispatch_decode_cuda` for decoding on CUDA devices, and `cuda_stream_handle` to acquire a stream for a given device ordinal.

The buffer ABI mirrors the flat ABI used by native and WASM extensions: input is a byte slice, output is caller-allocated. Returns the number of bytes written on success. `decode_with_state` is the state-aware variant used by the third-party branch of the container decode loop. Stateless codecs can ignore the state parameters; stateful codecs (per-group codebook, predictive scale coder, …) need them to round-trip planes whose state was captured in `PlaneRecord.{inline,shared}_state_bytes`.

Distinct from [`DispatchedPlaneCodec`], whose buffers are host memory. Implementors move no data across the host boundary: both input and output stay device-resident.

Same shape as [`DeltaSchemeRouter`], with two deliberate differences. First, there is no WASM branch: a `u64` device pointer cannot be expressed in WASM's 32-bit linear address space, so `hardware_backend` is native-only by construction. Second, [`resolve`](Self::resolve) runs [`check`] against the entry's declared capabilities before attempting a native load, using `self.policy`; see [`Self::new`] and [`Self::new_with_policy`] for how that policy is chosen.

The entry is used only to satisfy the `WasmExtension::load_from_path` / `NativeExtension::load` constructors; fields that are not required by those constructors are filled with safe defaults.

Same shape as [`HardwareBackendRouter`]: a `Mutex<HashMap<..>>` cache, the same `new` / `new_with_policy` constructor split, and the same `hardware_class`-presence precondition gated through [`check`] against `self.policy` before any native load is attempted. See [`HardwareBackendRouter::resolve`]'s doc comment for the full reasoning behind that precondition; it applies here unchanged. It differs from [`HardwareBackendRouter`] in two ways. First, it caches `Arc<dyn DispatchedPlaneCodecCuda>` and constructs [`NativePlaneCodecCudaAdapter`] rather than `NativeHardwareBackendCudaAdapter`. Second, a `plane_codec` contribution that resolves to a real installed manifest entry but has no loadable native artifact reports a fixed, non-formatted message ("plane_codec CUDA dispatch requires the native flavor") rather than one naming the canonical id and bundle directory: a WASM contribution cannot hold device pointers (WASM's linear address space is 32-bit), so this router is native-only by construction, exactly like [`HardwareBackendRouter`].

Construct once per decode session (or shared) and call [`Self::get`] for each plane. Results are internally cached so expensive dynamic loads happen at most once per id.