streamlib-packages

Domain-specific streamlib packages, distributed independently of the engine monorepo.

Package	@org/name	What it does
packages/network	@tatolab/network	Generic UDP source/sink processors — byte-level transport. NetworkPacket wire type; framing/protocol concerns belong in consumer packages.
packages/mavlink	@tatolab/mavlink	MAVLink2 encoder + decoder processors (wraps rust-mavlink, common dialect). Pairs with @tatolab/network for MAVLink-over-UDP.
packages/vadr-vision	@tatolab/vadr-vision	VADR-TS-002 §4.6 vision-stream depayloader — parses the 24-byte AGP chunk header, reassembles JPEG frames, emits EncodedJpegFrame to @tatolab/jpeg.

All three are engine-free packages: they Cargo-dep streamlib-plugin-sdk (the authoring SDK), never the streamlib engine facade, so a package cdylib never statically links a second copy of the engine. Each is its own standalone Cargo workspace ([workspace] self-root) and is not a member of any enclosing workspace.

Licensing

Everything here is licensed under the Business Source License 1.1 (BUSL-1.1) — the same license as streamlib. See LICENSE. Every Rust source carries the SPDX header; do not relicense.

Cross-package dependencies

• @tatolab/mavlink → @tatolab/network (for NetworkPacket) — both live here.
• @tatolab/vadr-vision → @tatolab/network (here) and @tatolab/jpeg (EncodedJpegFrame, which lives in the streamlib repo).

Cross-repo schema dependencies (@tatolab/jpeg, @tatolab/core) resolve by version at consume time — from a .slpkg registry (STREAMLIB_REGISTRY_URL) or from a streamlib linked checkout that contains them. There is no sibling-directory schema resolution; a package finds a dependency's schemas either in the linked engine checkout's packages/ tree or in the registry.

Consuming these packages

A streamlib host loads a package's built cdylib at runtime and its processors register into the runtime graph. Two paths:

• From a checkout (dev loop): streamlib link <path-to-package> symlinks the package into your app's streamlib_modules/@org/name.
• From a registry (distribution): build a source-only .slpkg (streamlib pkg build) and resolve it by @org/name + version range from a static .slpkg store (STREAMLIB_REGISTRY_URL).

Building / checking locally

Because the streamlib SDK is not on crates.io yet, building a package from source requires pointing its SDK deps at a local streamlib checkout with streamlib link --engine:

cd packages/network
streamlib link --engine /path/to/streamlib   # whole-tree [patch.crates-io] + link marker
cargo check                                   # SDK via patch; own schemas resolved locally

@tatolab/network is self-contained (owns all its schemas) and cargo checks cleanly against a bare streamlib checkout. @tatolab/mavlink and @tatolab/vadr-vision additionally import schemas from other packages (@tatolab/network, @tatolab/jpeg); their build.rs codegen must be able to resolve those — either via a .slpkg registry (STREAMLIB_REGISTRY_URL pointing at a store that carries them) or from a checkout that contains them. Against a bare streamlib checkout that no longer carries @tatolab/network, their schema codegen for NetworkPacket will not resolve without one of those sources.

CI runs a self-contained package-authoring lint gate (scripts/check-packages.sh); the source build is verified locally per the above. See .github/workflows/ci.yml for why CI is lint-only.

Provenance

These packages were extracted from the tatolab/streamlib monorepo on 2026-07-14 as a source snapshot. Git history prior to 2026-07-14 lives in tatolab/streamlib — this repo starts fresh and does not carry the pre-split commit history.

Running the package tests

Each package's self-contained tests (packages/network/tests/network_packet_serde_bytes_wire_format.rs, packages/vadr-vision/tests/reassembly_integration.rs) build against a linked streamlib checkout. Packages whose schemas reference other packages (mavlink, vadr-vision → @tatolab/network; vadr-vision → @tatolab/jpeg) additionally need a registry for schema resolution, because sibling-directory resolution is not a thing — schemas resolve by version from the link checkout's packages/ tree or a registry, and @tatolab/network no longer lives in the streamlib checkout.

The local dev-registry flow (no hosting required):

# 1. Emit a registry tree from a streamlib checkout (core, jpeg, …):
cd <streamlib-checkout>
cargo run -p xtask -- static-registry emit --out /tmp/dev-registry

# 2. Publish this repo's packages into the same tree:
export STREAMLIB_REGISTRY_URL="file:///tmp/dev-registry"
cd <this-repo>/packages/network && streamlib pkg publish

# 3. Link + test any package:
cd ../mavlink
streamlib link --engine <streamlib-checkout>
STREAMLIB_REGISTRY_URL="file:///tmp/dev-registry" cargo test

legacy-tests/ holds inherited test files that predate the engine-free conversion and need a rewrite against the module-loading flow before they can run again — see legacy-tests/README.md.