@soapbox.pub/nostr-lora 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soapbox contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+# @soapbox.pub/nostr-lora
+
+Reference implementation of [NIP-LR](./NIP.md): Nostr over LoRa.
+
+Handles packet encoding/decoding, chunked transmission, reassembly,
+retransmission requests, and GM (announce) messages. Designed for use with
+MeshCore LoRa devices over Web Serial.
+
+## Structure
+
+```
+nostr-lora          # core — LoRaTransport, SerialConnectionManager, etc.
+nostr-lora/react    # React hook — useNostrLora
+```
+
+React is an optional peer dependency. The core entry point has no React
+dependency.
+
+## Installation
+
+```sh
+npm install @soapbox.pub/nostr-lora
+```
+
+## Usage
+
+### React
+
+```tsx
+import { useNostrLora } from "nostr-lora/react";
+
+function App() {
+    const { connect, disconnect, isConnected, sendEvent, error } = useNostrLora(
+        {
+            onEvent(event) {
+                console.log("received event", event);
+            },
+        },
+    );
+
+    return (
+        <div>
+            {isConnected
+                ? <button onClick={disconnect}>Disconnect</button>
+                : <button onClick={connect}>Connect</button>}
+            {error && <p>{error.message}</p>}
+        </div>
+    );
+}
+```
+
+`connect()` triggers the browser's serial port picker. Once connected, incoming
+Nostr events are delivered via `onEvent`. Call `sendEvent(event)` to broadcast a
+signed Nostr event over LoRa.
+
+Full return type:
+
+| Field              | Type                                                   | Description                               |
+| ------------------ | ------------------------------------------------------ | ----------------------------------------- |
+| `isConnected`      | `boolean`                                              | Whether the serial port is open           |
+| `connecting`       | `boolean`                                              | `true` while the port is being opened     |
+| `error`            | `Error \| null`                                        | Last error, if any                        |
+| `portLabel`        | `string \| null`                                       | USB VID:PID of the connected device       |
+| `deviceName`       | `string \| null`                                       | Device name from firmware                 |
+| `sendQueue`        | `QueueSnapshot[]`                                      | Current outbound packet queue             |
+| `lastPacket`       | `PacketReceiveInfo \| null`                            | SNR/RSSI/size of last received packet     |
+| `connect`          | `() => Promise<void>`                                  | Open port and begin transport             |
+| `disconnect`       | `() => Promise<void>`                                  | Close port                                |
+| `sendEvent`        | `(event: NostrEvent) => Promise<void>`                 | Send a signed event                       |
+| `sendGm`           | `(nodeId, eventCount?, recentSince?) => Promise<void>` | Broadcast a GM announcement               |
+| `setTimingOptions` | `({ delay?, jitter? }) => void`                        | Adjust inter-packet timing live           |
+| `transport`        | `LoRaTransport \| null`                                | Direct access to the underlying transport |
+
+### Vanilla (no framework)
+
+```ts
+import { LoRaTransport, SerialConnectionManager } from "nostr-lora";
+
+const connection = new SerialConnectionManager();
+const transport = new LoRaTransport(connection);
+
+transport.on("event:receive", (event) => {
+    console.log("received event", event);
+});
+
+transport.on("connect", (portLabel) => {
+    console.log("connected to", portLabel);
+});
+
+transport.on("error", (err) => {
+    console.error(err);
+});
+
+// Triggers the browser port picker
+await transport.begin();
+
+// Send a signed Nostr event
+await transport.sendEvent(signedEvent);
+
+// Later
+await transport.end();
+```
+
+### Custom connection
+
+Implement `ConnectionManager` to use a different transport (e.g. WebSocket,
+BLE):
+
+```ts
+import type { ConnectionManager, ConnectionManagerEvents } from "nostr-lora";
+import { LoRaTransport } from "nostr-lora";
+
+class MyConnection implements ConnectionManager {
+    on<E extends keyof ConnectionManagerEvents>(
+        event: E,
+        handler: (...args: ConnectionManagerEvents[E]) => void,
+    ) {/* ... */}
+
+    async open() {/* ... */}
+    async close() {/* ... */}
+    async sendRawData(data: Uint8Array) {/* ... */}
+}
+
+const transport = new LoRaTransport(new MyConnection());
+```
+
+## Options
+
+All options are optional. Defaults are exported as `Defaults`:
+
+```ts
+import { Defaults } from "nostr-lora";
+```
+
+| Option              | Default     | Description                                                 |
+| ------------------- | ----------- | ----------------------------------------------------------- |
+| `nodeId`            | `undefined` | Your node's identity bytes (used in GM packets)             |
+| `logger`            | `null`      | Object with `log/warn/error/debug` methods (e.g. `console`) |
+| `interPacketDelay`  | `2000` ms   | Base delay between packets in the send queue                |
+| `interPacketJitter` | `500` ms    | Max random jitter added on top of the delay                 |
+| `requestInactivity` | `30000` ms  | Idle time before sending a retransmission request           |
+| `requestMaxRetries` | `3`         | Max retransmission attempts before abandoning               |
+| `eventTimeout`      | `30000` ms  | Max wait for all chunks of a partial event                  |
+| `dedupTimeout`      | `900000` ms | How long to remember received event IDs                     |
+| `sentChunksTtl`     | `300000` ms | How long to keep sent chunks for potential retransmission   |
+| `initialTtl`        | `6`         | Hop TTL assigned to locally-created events                  |
+| `gmBackoffBase`     | `300000` ms | Minimum interval between GM responses to the same peer      |
+| `gmMaxShareEvents`  | `3`         | Max events to re-share in response to a GM                  |
+| `gmJitterMin`       | `500` ms    | Min random delay before responding to a GM                  |
+| `gmJitterMax`       | `1500` ms   | Max random delay before responding to a GM                  |
+
+## Events
+
+`LoRaTransport` extends `EventEmitter` and emits:
+
+| Event             | Args                                 | Description                                      |
+| ----------------- | ------------------------------------ | ------------------------------------------------ |
+| `connect`         | `portLabel: string`                  | Connection opened                                |
+| `disconnect`      | —                                    | Connection closed                                |
+| `error`           | `err: Error`                         | Error from connection or packet handling         |
+| `event:receive`   | `event: NostrEvent`                  | A complete Nostr event was received and verified |
+| `event:send`      | `event: NostrEvent`                  | A Nostr event finished sending                   |
+| `packet:receive`  | `info: PacketReceiveInfo`            | Raw packet received (SNR, RSSI, size)            |
+| `chunk:receive`   | `decoded, byteLength`                | Individual DATA chunk received                   |
+| `gm:receive`      | `decoded, byteLength`                | GM packet received                               |
+| `request:receive` | `prefixHex, missingChunks`           | Retransmission request received from peer        |
+| `request:send`    | `eventIdHex, missingChunks, attempt` | Retransmission request sent                      |
+| `queue:update`    | `snapshot: QueueSnapshot[]`          | Send queue changed                               |
+
+## License
+
+The source code of this library is provided to you under the terms of the
+[MIT License](./LICENSE).

package/dist/assembler.d.ts

@@ -0,0 +1,74 @@
+import { FirstChunk, SubsequentChunk } from './protocol.js';
+/** Holds the per-event state while chunks are being collected. Not exported. */
+declare class AssemblySession {
+    readonly eventId: Uint8Array;
+    readonly eventKind: number;
+    readonly totalChunks: number;
+    readonly checksum: number;
+    readonly chunks: Array<Uint8Array | undefined>;
+    receivedChunks: number;
+    constructor(first: FirstChunk);
+    get isComplete(): boolean;
+    /** Returns true if this was a new chunk, false if duplicate. */
+    addChunk(index: number, payload: Uint8Array): boolean;
+    missingIndices(): number[];
+}
+export interface CompleteAction {
+    action: 'complete';
+    session: AssemblySession;
+}
+export interface StartedAction {
+    action: 'started';
+    session: AssemblySession;
+}
+export interface ProgressAction {
+    action: 'progress';
+    session: AssemblySession;
+    eventIdHex: string;
+}
+export interface PendingAction {
+    action: 'pending';
+    prefix: Uint8Array;
+}
+export interface NoneAction {
+    action: 'none';
+}
+export type FirstChunkResult = CompleteAction | StartedAction | NoneAction;
+export type SubsequentChunkResult = CompleteAction | ProgressAction | PendingAction | NoneAction;
+interface PendingEntry {
+    eventIdPrefix: Uint8Array;
+    chunkIndex: number;
+    payload: Uint8Array;
+    isLast: boolean;
+    arrivedAt: number;
+}
+export declare class Assembler {
+    /** In-progress sessions keyed by the full event ID as a hex string. */
+    sessions: Map<string, AssemblySession>;
+    /** Subsequent chunks that arrived before their first chunk. */
+    pendingSubsequent: PendingEntry[];
+    handleFirst(decoded: FirstChunk, seenIds: Map<string, number>): FirstChunkResult;
+    handleSubsequent(decoded: SubsequentChunk, eventTimeout: number): SubsequentChunkResult;
+    /** Returns missing chunk indices for a session, or null if it no longer exists. */
+    missingChunks(eventIdHex: string): number[] | null;
+    /** Abandon an in-progress session after max retries exceeded. */
+    abandonSession(eventIdHex: string): void;
+    /**
+     * Returns missing chunk indices for a pending-subsequent group
+     * (chunk 0 still missing), or null if no buffered chunks exist for this prefix.
+     */
+    missingChunksForPending(prefixHex: string): number[] | null;
+    /** Abandon all pending entries for a given prefix after max retries exceeded. */
+    abandonPending(prefixHex: string): void;
+    /** True if a session is currently in progress for this event ID. */
+    hasSession(eventIdHex: string): boolean;
+    /**
+     * Returns the raw eventId bytes for an in-progress session, or null.
+     * Used by the transport to build REQUEST prefix bytes.
+     */
+    getSessionEventId(eventIdHex: string): Uint8Array | null;
+    private _findSessionForPrefix;
+    private _replayPending;
+    private _prunePending;
+}
+export {};

package/dist/connection-manager.d.ts

@@ -0,0 +1,30 @@
+/** Events emitted by a ConnectionManager. */
+export type ConnectionManagerEvents = {
+    "data": [data: {
+        data: Uint8Array;
+        snr: number;
+        rssi: number;
+    }];
+    "connect": [portLabel: string];
+    "disconnect": [];
+    "deviceInfo": [info: {
+        name: string;
+        firmwareVersion: string;
+    }];
+    "error": [err: Error];
+};
+/**
+ * Abstraction over the physical radio link.
+ * Implement this interface to use `LoRaTransport` with a custom connection.
+ * `SerialConnectionManager` provides the Web Serial implementation.
+ */
+export interface ConnectionManager {
+    /** Send a raw binary packet to the radio. */
+    sendRawData(data: Uint8Array): Promise<void>;
+    /** Open the connection (e.g. show browser port picker, open port). */
+    open(): Promise<void>;
+    /** Close the connection. */
+    close(): Promise<void>;
+    /** Subscribe to connection lifecycle and data events. */
+    on<E extends keyof ConnectionManagerEvents>(event: E, handler: (...args: ConnectionManagerEvents[E]) => void): void;
+}

package/dist/constants.d.ts

@@ -0,0 +1,31 @@
+declare const Defaults: {
+    /** Base delay between packets within a single queue item (ms). */
+    readonly INTER_PACKET_DELAY: 2000;
+    /** Maximum additional random jitter added on top of INTER_PACKET_DELAY (ms). */
+    readonly INTER_PACKET_JITTER: 500;
+    /** Per-peer minimum response interval before the first backoff multiplier kicks in (ms). */
+    readonly GM_BACKOFF_BASE: number;
+    /** Maximum number of our own events to re-share in response to one GM. */
+    readonly GM_MAX_SHARE_EVENTS: 3;
+    /** Lower bound of the random pre-share / pre-reply delay (ms). */
+    readonly GM_JITTER_MIN: 500;
+    /** Upper bound of the random pre-share / pre-reply delay (ms). */
+    readonly GM_JITTER_MAX: 1500;
+    /** How long to wait for the next chunk before declaring a gap and sending REQUEST (ms). */
+    readonly REQUEST_INACTIVITY: 30000;
+    /** Number of REQUEST retries before abandoning a partial event. */
+    readonly REQUEST_MAX_RETRIES: 3;
+    /** How long to keep sent chunk packets around for potential retransmission (ms). */
+    readonly SENT_CHUNKS_TTL: number;
+    /** How long before we stop deduplicating a previously-seen event ID (ms). */
+    readonly DEDUP_TIMEOUT: number;
+    /** How long to wait for subsequent chunks of a partial event (ms). */
+    readonly EVENT_TIMEOUT: 30000;
+    /** TTL assigned to locally-created events (decremented on each re-broadcast hop). */
+    readonly INITIAL_TTL: 6;
+};
+export default Defaults;
+/** Widened (plain `number`) version of `Defaults` — use for constructor option types. */
+export type DefaultOptions = {
+    [K in keyof typeof Defaults]: number;
+};

package/dist/event-codec.d.ts

@@ -0,0 +1,15 @@
+export interface NostrEvent {
+    id: string;
+    pubkey: string;
+    created_at: number;
+    kind: number;
+    tags: string[][];
+    content: string;
+    sig: string;
+}
+export interface SerializedEvent {
+    compressed: Uint8Array;
+    checksum: number;
+}
+export declare function serializeEvent(event: NostrEvent): Promise<SerializedEvent>;
+export declare function deserializeEvent(chunkPayloads: Uint8Array[], expectedChecksum: number, eventIdHex: string): Promise<NostrEvent>;

package/dist/gm-protocol.d.ts

@@ -0,0 +1,30 @@
+import { DecodedGmPacket } from './protocol.js';
+import { EventEmitter, Logger } from './utils.js';
+import { DefaultOptions } from './constants.js';
+import { NostrEvent } from './event-codec.js';
+export interface GmProtocolDeps {
+    getNodeId: () => Uint8Array | null;
+    getSentEvents: () => Map<string, NostrEvent>;
+    sendEvent: (event: NostrEvent) => Promise<void>;
+    sendGm: (nodeId: Uint8Array, eventCount: number, recentSince: number) => Promise<void>;
+}
+export type GmProtocolEvents = {
+    "gm:receive": [decoded: DecodedGmPacket, byteLength: number];
+};
+export declare class GmProtocol extends EventEmitter<GmProtocolEvents> {
+    private getNodeId;
+    private getSentEvents;
+    private sendEvent;
+    private sendGm;
+    private backoff;
+    private lastResponse;
+    private log;
+    BACKOFF_BASE: number;
+    MAX_SHARE_EVENTS: number;
+    JITTER_MIN: number;
+    JITTER_MAX: number;
+    constructor(deps: GmProtocolDeps, options?: Partial<Pick<DefaultOptions, "GM_BACKOFF_BASE" | "GM_MAX_SHARE_EVENTS" | "GM_JITTER_MIN" | "GM_JITTER_MAX">>, logger?: Logger | null);
+    handlePacket(packet: Uint8Array): Promise<void>;
+    private jitter;
+    private oldestTimestamp;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { default as Defaults } from './constants.js';
+export { LoRaTransport } from './lora-transport.js';
+export type { LoRaTransportEvents, TransportOptions, PacketReceiveInfo, TimingOptions, } from './lora-transport.js';
+export type { Logger } from './utils.js';
+export { SerialConnectionManager } from './serial-connection.js';
+export type { DeviceInfo, RadioConfig } from './serial-connection.js';
+export type { ConnectionManager, ConnectionManagerEvents } from './connection-manager.js';
+export { Assembler } from './assembler.js';
+export { SendQueue } from './send-queue.js';
+export type { QueueSnapshot, QueueItem } from './send-queue.js';
+export { GmProtocol } from './gm-protocol.js';
+export type { GmProtocolDeps } from './gm-protocol.js';
+export type { NostrEvent } from './event-codec.js';
+export type { DecodedDataChunk, DecodedGmPacket } from './protocol.js';
+export { Defaults };
+export type { DefaultOptions } from './constants.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+import { A as s, D as o, G as r, L as n, S as t, a as l } from "./serial-connection.js";
+export {
+  s as Assembler,
+  o as Defaults,
+  r as GmProtocol,
+  n as LoRaTransport,
+  t as SendQueue,
+  l as SerialConnectionManager
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/lora-transport.d.ts

@@ -0,0 +1,109 @@
+import { DecodedDataChunk, DecodedGmPacket } from './protocol.js';
+import { NostrEvent } from './event-codec.js';
+import { QueueSnapshot } from './send-queue.js';
+import { EventEmitter, Logger } from './utils.js';
+import { ConnectionManager } from './connection-manager.js';
+export type { ConnectionManager };
+export type { ConnectionManagerEvents } from './connection-manager.js';
+export interface TransportOptions {
+    nodeId?: Uint8Array;
+    /** Diagnostic logger. Defaults to `null` (silent). */
+    logger?: Logger | null;
+    interPacketDelay?: number;
+    interPacketJitter?: number;
+    gmBackoffBase?: number;
+    gmMaxShareEvents?: number;
+    gmJitterMin?: number;
+    gmJitterMax?: number;
+    requestInactivity?: number;
+    requestMaxRetries?: number;
+    sentChunksTtl?: number;
+    dedupTimeout?: number;
+    eventTimeout?: number;
+    initialTtl?: number;
+}
+export interface PacketReceiveInfo {
+    snr: number;
+    rssi: number;
+    size: number;
+}
+export interface TimingOptions {
+    delay?: number;
+    jitter?: number;
+}
+export type LoRaTransportEvents = {
+    "event:receive": [event: NostrEvent];
+    "event:send": [event: NostrEvent];
+    "chunk:receive": [decoded: DecodedDataChunk, byteLength: number];
+    "gm:receive": [decoded: DecodedGmPacket, byteLength: number];
+    "packet:receive": [info: PacketReceiveInfo];
+    "packet:send": [
+        decoded: DecodedDataChunk | DecodedGmPacket,
+        byteLength: number
+    ];
+    "request:send": [
+        eventIdHex: string,
+        missingChunks: number[],
+        attempt: number
+    ];
+    "request:receive": [prefixHex: string, missingChunks: number[]];
+    "queue:update": [snapshot: QueueSnapshot[]];
+    "connect": [portLabel: string];
+    "disconnect": [];
+    "error": [err: Error];
+};
+export declare class LoRaTransport extends EventEmitter<LoRaTransportEvents> {
+    connection: ConnectionManager;
+    nodeId: Uint8Array | null;
+    private log;
+    private eventTimeout;
+    private dedupTimeout;
+    private initialTtl;
+    private requestInactivity;
+    private requestMaxRetries;
+    private sentChunksTtl;
+    private assembler;
+    private queue;
+    private gm;
+    private recentEventIds;
+    private inactivityTimers;
+    private pendingTimers;
+    private sentEvents;
+    private sentChunks;
+    constructor(connection: ConnectionManager, options?: TransportOptions);
+    /**
+     * Open the connection and wire up data/lifecycle events.
+     * This triggers the browser port picker for `SerialConnectionManager`.
+     */
+    begin(): Promise<void>;
+    /** Close the connection. */
+    end(): Promise<void>;
+    sendEvent(event: NostrEvent): Promise<void>;
+    sendGm(nodeId: Uint8Array, eventCount?: number, recentSince?: number): Promise<void>;
+    /**
+     * Feed a raw radio packet into the transport.
+     * Only needed when implementing a custom `ConnectionManager` that doesn't
+     * use the event interface — `begin()` wires this automatically otherwise.
+     */
+    handleRawDataPacket(data: {
+        data: ArrayBuffer | Uint8Array;
+        snr: number;
+        rssi: number;
+    }): Promise<void>;
+    /** Update the inter-packet timing on the underlying send queue. */
+    setTimingOptions({ delay, jitter }?: TimingOptions): void;
+    /** Number of events sent by this node (available for GM announcements). */
+    get sentEventCount(): number;
+    private handleDataPacket;
+    private completeSession;
+    private handleRequestPacket;
+    private handleGmPacket;
+    private resetInactivityTimer;
+    private clearInactivityTimer;
+    private onChunkInactivity;
+    private resetPendingTimer;
+    private clearPendingTimer;
+    private onPendingInactivity;
+    private pruneSentChunks;
+    private cleanupDeduplication;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,78 @@
+export declare const PacketType: {
+    readonly DATA: 1;
+    readonly REQUEST: 2;
+    readonly GM: 3;
+};
+export type PacketTypeValue = typeof PacketType[keyof typeof PacketType];
+export declare const Limits: {
+    readonly MAX_PACKET_SIZE: 168;
+    readonly FIRST_CHUNK_HEADER: 44;
+    readonly FIRST_CHUNK_PAYLOAD: 124;
+    readonly SUBSEQUENT_CHUNK_HEADER: 17;
+    readonly SUBSEQUENT_CHUNK_PAYLOAD: 151;
+    readonly EVENT_ID_PREFIX_LEN: 14;
+    readonly MAX_CHUNKS: 8;
+    readonly MAX_COMPRESSED_SIZE: 1152;
+};
+export declare class CRC32 {
+    private static table;
+    private static makeTable;
+    static calculate(data: Uint8Array): number;
+}
+export declare class Compression {
+    static compress(data: Uint8Array): Promise<Uint8Array>;
+    static decompress(data: Uint8Array): Promise<Uint8Array>;
+}
+export interface FirstChunk {
+    type: 'first';
+    eventId: Uint8Array;
+    eventKind: number;
+    totalChunks: number;
+    checksum: number;
+    ttl: number;
+    payload: Uint8Array;
+    isLast: boolean;
+}
+export interface SubsequentChunk {
+    type: 'subsequent';
+    eventIdPrefix: Uint8Array;
+    chunkIndex: number;
+    payload: Uint8Array;
+    isLast: boolean;
+}
+export type DecodedDataChunk = FirstChunk | SubsequentChunk;
+export declare class DataPacket {
+    static createFromCompressed(eventId: Uint8Array, eventKind: number, compressed: Uint8Array, ttl: number): Uint8Array[];
+    static encodeFirst(eventId: Uint8Array, eventKind: number, totalChunks: number, checksum: number, ttl: number, payload: Uint8Array, isLast: boolean): Uint8Array;
+    static encodeSubsequent(eventIdPrefix: Uint8Array, chunkIndex: number, payload: Uint8Array, isLast: boolean): Uint8Array;
+    /**
+     * Decode DATA packet.
+     * Distinguishes first vs subsequent by peeking at bytes 1-2:
+     * - First chunk:      bytes 1-2 are chunk_index == 0x0000, event_id at offset 3
+     * - Subsequent chunk: bytes 1-2 are part of event_id_prefix, chunk_index at offset 15
+     *
+     * For subsequent chunks, the first 2 bytes of event_id_prefix are statistically
+     * never 0x0000 for real event IDs, so 0x0000 reliably identifies first chunks.
+     */
+    static decode(packet: Uint8Array): DecodedDataChunk;
+}
+export interface DecodedRequestPacket {
+    eventIdPrefix: Uint8Array;
+    missingChunks: number[];
+}
+export declare class RequestPacket {
+    static create(eventIdPrefix: Uint8Array, missingChunks: number[]): Uint8Array;
+    static decode(packet: Uint8Array): DecodedRequestPacket;
+}
+export interface DecodedGmPacket {
+    nodeId: Uint8Array;
+    timestamp: number;
+    eventCount: number;
+    recentSince: number;
+}
+export declare class GmPacket {
+    static create(nodeId: Uint8Array, eventCount: number, recentSince: number, timestamp?: number): Uint8Array;
+    static decode(packet: Uint8Array): DecodedGmPacket;
+}
+/** Read the packet type from the flags byte without fully decoding the packet. */
+export declare function parsePacketType(packet: Uint8Array): number;

package/dist/react.d.ts

@@ -0,0 +1,2 @@
+export { useNostrLora } from './use-lora-transport.js';
+export type { UseNostrLoraOptions, UseNostrLoraReturn } from './use-lora-transport.js';

package/dist/react.js

@@ -0,0 +1,57 @@
+import { useState as o, useRef as d, useEffect as G, useCallback as s } from "react";
+import { a as I, L as Q } from "./serial-connection.js";
+function D(a = {}) {
+  const [g, p] = o(!1), [v, u] = o(!1), [E, l] = o(null), [y, m] = o(null), [L, C] = o(null), [N, R] = o([]), [b, k] = o(null), w = d(null), e = d(null), i = d(a);
+  G(() => {
+    i.current = a;
+  }, [a]);
+  const S = s(async () => {
+    u(!0), l(null);
+    try {
+      const n = new I(i.current.logger);
+      w.current = n, n.on("deviceInfo", (r) => C(r.name));
+      const { onEvent: t, ...f } = i.current, c = new Q(n, f);
+      e.current = c, c.on("connect", (r) => {
+        p(!0), m(r);
+      }), c.on("disconnect", () => {
+        p(!1), m(null);
+      }), c.on("error", (r) => l(r)), c.on("queue:update", (r) => R(r)), c.on("packet:receive", (r) => k(r)), t && c.on("event:receive", t), await c.begin();
+    } catch (n) {
+      const t = n instanceof Error ? n : new Error(String(n));
+      l(t), u(!1);
+    } finally {
+      u(!1);
+    }
+  }, []), h = s(async () => {
+    var n;
+    await ((n = e.current) == null ? void 0 : n.end()), e.current = null, w.current = null;
+  }, []), O = s(async (n) => {
+    if (!e.current) throw new Error("Not connected");
+    await e.current.sendEvent(n);
+  }, []), P = s(async (n, t, f) => {
+    if (!e.current) throw new Error("Not connected");
+    await e.current.sendGm(n, t, f);
+  }, []), T = s((n) => {
+    var t;
+    (t = e.current) == null || t.setTimingOptions(n);
+  }, []);
+  return {
+    isConnected: g,
+    connecting: v,
+    error: E,
+    portLabel: y,
+    deviceName: L,
+    sendQueue: N,
+    lastPacket: b,
+    connect: S,
+    disconnect: h,
+    sendEvent: O,
+    sendGm: P,
+    setTimingOptions: T,
+    transport: e.current
+  };
+}
+export {
+  D as useNostrLora
+};
+//# sourceMappingURL=react.js.map