MXL

Preview · Host-local fabric · reach: bridged · meters at $0.005/min. Shared-memory / IPC on a single host (reach: bridged) — a WAVE node reads the host buffer and converts it to a WAN transport; no raw hosted spoke.

MXL is the EBU / Linux Foundation Dynamic Media Facility shared-memory exchange: media moves between processes on the same host through /dev/shm with zero network hops and zero copies. It is host-local, so its reach is bridged — a WAVE node reads the shared-memory buffer (zero-copy) and converts it to SRT or MoQ for WAN transport; on the far side a node writes MXL back into /dev/shm for the local application (there is no remote multicast — shared memory is host-bound). There is no raw hosted spoke by design. It is WAVE's reference full-package build: the adapter is proven, the meter is live, and because the local hop is pure shared memory its COGS is ~$0 (≈98% margin).

No raw hosted endpoint — bridged fabric. A WAVE node on the host/LAN converts it to a WAN transport (srt, moq); consume it through the adapter or a node bridge.

Reach: bridged (the WAN bridge)

WAVE owns no transport — it is the conversion layer — so even a host-local fabric becomes WAN-distributable. MXL is reached in two legs:

1. Ingest leg — a WAVE node on the source host reads the shared-memory buffer, stamps clock + integrity + metering, and converts the media to a WAN transport you choose: srt, moq.
2. Egress leg — a far-side node receives the WAN stream and converts it back to native MXL (written back to host shared memory for the local app).

The bridge target is operator-selectable per session (srt, moq today; MoQ for general low-latency relay, SRT for ultra-low-latency point-to-point). The conversion is a lossless envelope — not a transcode — so it stays cheap and high-margin.

The hosted bridge runtime is gated on CF Containers and (for some fabrics) a native adapter — see the phase above before treating the endpoint as live.

Install

Adapter: @wave-av/transports/mxl (wave-transports/mxl).

import { MxlAdapter } from "@wave-av/transports/mxl";

// Exchange frames with another process on this host via /dev/shm (zero-copy).
const mxl = new MxlAdapter({ flow: "cam1", key: process.env.WAVE_KEY });
for await (const frame of mxl.read()) handle(frame);

Every fabric authenticates with the same WAVE key (Authorization: Bearer $WAVE_KEY) and is gated by the same scope grant. A call carrying x-wave-protocol: mxl is attributed to this fabric end-to-end.

API reference

The WAVE gateway (api.wave.online) enforces auth, scope, entitlement, and metering for MXL — the same contract as every other fabric.

A subscription to the MXL product grants both mxl:read and mxl:write. Usage is reported as wall-clock minutes under the metering dimension duration_ms:mxl, which bills the live Stripe meter wave_usage_duration_ms_mxl once STRIPE_PRICE_STREAM_MIN_MXL is provisioned. Read your own accumulated usage at GET /v1/usage (scope usage:read).

All fabric reference fields above are generated from the fabric-support contract (catalog/fabrics.json) and the pricing SSOT, so the docs can never drift from what the gateway actually enforces.

Pricing

Every transport fabric meters at the uniform $0.005/min anchor. Metering is wall-clock and mutually exclusive — a minute is billed under duration_ms:mxl or the aggregate stream dimension, never both. Prices are inert until your subscription is attached; you are billed only for minutes the gateway observes.