Loss-Healing Encrypted Transport Where TCP, MQTT & Raw ESP-NOW Break.

from nltp import NLTPServer, NLTPClient, generate_nltp_key

key = generate_nltp_key()  # 256-bit pre-shared key (derives fresh 1-RTT X25519 session keys)

with NLTPServer(("0.0.0.0", 9000), save_dir="./inbox", psk=key) as server:
    with NLTPClient(("127.0.0.1", 9000), psk=key, max_tx_kbps=20_000) as client:
        # 1. Priority out-of-band reflex command (0 head-of-line blocking)
        seq = client.send_reflex("STOP_ACTUATOR")
        assert client.wait_reflex_ack(seq, timeout=3.0)

        # 2. LZ4-compressed + GF(2^8) Cauchy FEC stream with SHA-256 receipt
        receipt = client.send_bytes(b'{"pm25":14.2,"so2":3.1}\n' * 200, compress=True)
        assert receipt["verified_sha256"] is True

#include <NLTP.h>

NLTPESPNowNode node;
const uint8_t hubMac[6] = {0xAA, 0xBB, 0xCC, 0x00, 0x00, 0x02};
uint8_t telemetryBatch[8192];

void setup() {
  // Off-grid 2.4 GHz Ch 11 with X25519 + ChaCha20-Poly1305 + Cauchy FEC:
  node.begin(11, "shared-256bit-key", NLTP_ESPNOW_RATE_AUTO);
  node.setPeerMac(hubMac);
  node.sendBytesCompressed(telemetryBatch, sizeof(telemetryBatch), "sonde.jsonl");
}

void loop() {
  node.poll(); // Drives TX pacing, Cauchy FEC repairs, and confirmed Reflexes
}

import json, paho.mqtt.client as mqtt
from nltp import NLTPServer

mq = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
mq.connect("127.0.0.1", 1883)
mq.loop_start()

# Heal 0-35% wireless packet loss on the first mile, then fan out to existing MQTT topics:
with NLTPServer(("0.0.0.0", 9000), psk=FLEET_KEY) as ingest:
    while True:
        item = ingest.recv(timeout=5.0)
        if not item:
            continue
        if item.kind == "reflex":
            mq.publish("fleet/alerts/reflex", item.data, qos=1)  # 0 HOL blocking
        elif item.sha256_verified:
            for line in item.data.decode().splitlines():
                node = json.loads(line).get("node", "sensor")
                mq.publish(f"fleet/telemetry/{node}", line, qos=1)

# Generate a 256-bit key & inspect carrier NAT behaviour via RFC 5389 STUN
nltp gen-key
nltp stun

# Direct encrypted + LZ4-compressed transfer over lossy Wi-Fi or radio
nltp serve --host 0.0.0.0 --port 9000 --psk "<KEY>" --save-dir ./inbox
nltp send-file --host <SERVER_IP> --port 9000 --psk "<KEY>" --file telemetry.jsonl --compress

# Traverse symmetric 4G/5G CGNAT via any 1-port UDP VM (relay holds ZERO keys)
nltp relay --host 0.0.0.0 --port 9000
nltp serve --relay <RELAY_IP>:9000 --room buoy-01 --psk "<KEY>" --save-dir ./inbox
nltp send-file --relay <RELAY_IP>:9000 --room buoy-01 --psk "<KEY>" --file batch.bin -z

import { NLTPServer, NLTPClient, generateNltpKey } from 'nltp-js';

const key = generateNltpKey();
const server = await NLTPServer.listen({ host: '0.0.0.0', port: 9000, psk: key });
const client = await NLTPClient.connect({ host: '127.0.0.1', port: 9000, psk: key });

const seq = await client.sendReflex('PING_ACTUATOR');
await client.waitReflexAck(seq, 3000);

const receipt = await client.sendJson({ node: 'usv-01', waveHsM: 2.14 }, { compress: true });
console.log('SHA-256 verified:', receipt.verifiedSha256);

#define NLTP_TX_ONLY 1  /* 4.65 KB total endpoint RAM with X25519 + LZ4 + Reflex */
#include "nltp_core.h"

static nltp_endpoint_t g_ep;  /* sizeof(g_ep) == 4,760 bytes — zero malloc() */

void sensor_boot(void) {
  nltp_init_txonly(&g_ep, conn_id, radio_tx_cb, NULL);
  nltp_set_random(&g_ep, hw_trng_cb, NULL);
  nltp_set_psk_passphrase(&g_ep, "fleet-256bit-secret");
  nltp_send_buffer_lz4(&g_ep, peer_addr, log_buf, log_len, "aqms.jsonl", now_ms());
}

import io.necklink.nltp.NLTPClient;
import io.necklink.nltp.NLTPServer;

try (var server = NLTPServer.listen("0.0.0.0", 9000, key, Path.of("./inbox"));
     var client = NLTPClient.connect("127.0.0.1", 9000, key, 20_000)) {
    long seq = client.sendReflex("HEARTBEAT");
    client.waitReflexAck(seq, 2_000L);
    var receipt = client.sendBytesCompressed(jsonlBytes, "telemetry.jsonl", 10_000L);
    assert receipt.verifiedSha256();
}