@soapbox.pub/nostr-lora 0.1.0

package/dist/serial-connection.js

@@ -0,0 +1,955 @@
+var D = Object.defineProperty;
+var U = (o, s, t) => s in o ? D(o, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[s] = t;
+var a = (o, s, t) => U(o, typeof s != "symbol" ? s + "" : s, t);
+import { verifyEvent as K } from "nostr-tools";
+import { WebSerialConnection as L, Constants as P } from "@liamcottle/meshcore.js";
+const g = {
+  DATA: 1,
+  REQUEST: 2,
+  GM: 3
+}, E = {
+  FIRST_CHUNK_PAYLOAD: 124,
+  SUBSEQUENT_CHUNK_PAYLOAD: 151,
+  // 168 - 17
+  EVENT_ID_PREFIX_LEN: 14,
+  // first 14 bytes of event_id (2^112 collision resistance)
+  MAX_CHUNKS: 8,
+  MAX_COMPRESSED_SIZE: 1152
+  // 1024 content + ~128 for 64-byte sig (hex)
+};
+class y {
+  static makeTable() {
+    if (!this.table) {
+      this.table = new Uint32Array(256);
+      for (let s = 0; s < 256; s++) {
+        let t = s;
+        for (let e = 0; e < 8; e++)
+          t = t & 1 ? 3988292384 ^ t >>> 1 : t >>> 1;
+        this.table[s] = t;
+      }
+    }
+  }
+  static calculate(s) {
+    this.makeTable();
+    let t = 4294967295;
+    for (let e = 0; e < s.length; e++)
+      t = t >>> 8 ^ this.table[(t ^ s[e]) & 255];
+    return (t ^ 4294967295) >>> 0;
+  }
+}
+a(y, "table", null);
+class q {
+  static async compress(s) {
+    const e = new Blob([s]).stream().pipeThrough(
+      new CompressionStream("deflate-raw")
+    ), n = await new Response(e).blob();
+    return new Uint8Array(await n.arrayBuffer());
+  }
+  static async decompress(s) {
+    const e = new Blob([s]).stream().pipeThrough(
+      new DecompressionStream("deflate-raw")
+    ), n = await new Response(e).blob();
+    return new Uint8Array(await n.arrayBuffer());
+  }
+}
+class b {
+  static createFromCompressed(s, t, e, n) {
+    const i = y.calculate(e);
+    let r = e.length - E.FIRST_CHUNK_PAYLOAD, u = 1;
+    for (; r > 0; )
+      u++, r -= E.SUBSEQUENT_CHUNK_PAYLOAD;
+    if (u > E.MAX_CHUNKS)
+      throw new Error(`Event requires ${u} chunks, max is ${E.MAX_CHUNKS}`);
+    const c = [];
+    let h = 0;
+    for (let l = 0; l < u; l++) {
+      const T = l === u - 1, _ = l === 0 ? E.FIRST_CHUNK_PAYLOAD : E.SUBSEQUENT_CHUNK_PAYLOAD, I = Math.min(_, e.length - h), w = e.slice(h, h + I);
+      l === 0 ? c.push(this.encodeFirst(
+        s,
+        t,
+        u,
+        i,
+        n,
+        w,
+        T
+      )) : c.push(this.encodeSubsequent(
+        s.slice(0, E.EVENT_ID_PREFIX_LEN),
+        l,
+        w,
+        T
+      )), h += I;
+    }
+    return c;
+  }
+  static encodeFirst(s, t, e, n, i, r, u) {
+    const c = new Uint8Array(44 + r.length);
+    let h = 0;
+    return c[h++] = g.DATA << 4 | (u ? 1 : 0), c[h++] = 0, c[h++] = 0, c.set(s.slice(0, 32), h), h += 32, c[h++] = e >> 8 & 255, c[h++] = e & 255, c[h++] = t >> 8 & 255, c[h++] = t & 255, c[h++] = n >> 24 & 255, c[h++] = n >> 16 & 255, c[h++] = n >> 8 & 255, c[h++] = n & 255, c[h++] = i, c.set(r, h), c;
+  }
+  static encodeSubsequent(s, t, e, n) {
+    const i = new Uint8Array(17 + e.length);
+    let r = 0;
+    return i[r++] = g.DATA << 4 | (n ? 1 : 0), i.set(s.slice(0, 14), r), r += 14, i[r++] = t >> 8 & 255, i[r++] = t & 255, i.set(e, r), i;
+  }
+  /**
+   * 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(s) {
+    const e = (s[0] & 1) !== 0;
+    if ((s[1] << 8 | s[2]) === 0) {
+      const i = s.slice(3, 35), r = s[35] << 8 | s[36], u = s[37] << 8 | s[38], c = (s[39] << 24 | s[40] << 16 | s[41] << 8 | s[42]) >>> 0, h = s[43], l = s.slice(44);
+      return { type: "first", eventId: i, eventKind: u, totalChunks: r, checksum: c, ttl: h, payload: l, isLast: e };
+    } else {
+      const i = s.slice(1, 15), r = s[15] << 8 | s[16], u = s.slice(17);
+      return { type: "subsequent", eventIdPrefix: i, chunkIndex: r, payload: u, isLast: e };
+    }
+  }
+}
+class R {
+  static create(s, t) {
+    const e = new Uint8Array(16);
+    let n = 0;
+    e[n++] = g.REQUEST << 4, e.set(s.slice(0, E.EVENT_ID_PREFIX_LEN), n), n += E.EVENT_ID_PREFIX_LEN;
+    let i = 0;
+    for (const r of t)
+      r < 8 && (i |= 1 << r);
+    return e[n++] = i & 255, e;
+  }
+  static decode(s) {
+    const t = s.slice(1, 1 + E.EVENT_ID_PREFIX_LEN), e = s[1 + E.EVENT_ID_PREFIX_LEN], n = [];
+    for (let i = 0; i < 8; i++)
+      e & 1 << i && n.push(i);
+    return { eventIdPrefix: t, missingChunks: n };
+  }
+}
+class v {
+  static create(s, t, e, n = Math.floor(Date.now() / 1e3)) {
+    const i = new Uint8Array(21);
+    let r = 0;
+    return i[r++] = g.GM << 4, i.set(s.slice(0, 8), r), r += 8, i[r++] = n >> 24 & 255, i[r++] = n >> 16 & 255, i[r++] = n >> 8 & 255, i[r++] = n & 255, i[r++] = t >> 24 & 255, i[r++] = t >> 16 & 255, i[r++] = t >> 8 & 255, i[r++] = t & 255, i[r++] = e >> 24 & 255, i[r++] = e >> 16 & 255, i[r++] = e >> 8 & 255, i[r++] = e & 255, i;
+  }
+  static decode(s) {
+    const t = s.slice(1, 9), e = (s[9] << 24 | s[10] << 16 | s[11] << 8 | s[12]) >>> 0, n = (s[13] << 24 | s[14] << 16 | s[15] << 8 | s[16]) >>> 0, i = (s[17] << 24 | s[18] << 16 | s[19] << 8 | s[20]) >>> 0;
+    return { nodeId: t, timestamp: e, eventCount: n, recentSince: i };
+  }
+}
+function F(o) {
+  return !o || o.length === 0 ? -1 : o[0] >> 4 & 15;
+}
+const G = new TextEncoder(), X = new TextDecoder();
+async function J(o) {
+  if (!o.id || typeof o.id != "string")
+    throw new Error("Event must have string id");
+  if (!o.pubkey || typeof o.pubkey != "string")
+    throw new Error("Event must have string pubkey");
+  if (!o.created_at || typeof o.created_at != "number")
+    throw new Error("Event must have numeric created_at");
+  if (o.kind === void 0 || typeof o.kind != "number")
+    throw new Error("Event must have numeric kind");
+  if (!Array.isArray(o.tags))
+    throw new Error("Event tags must be array");
+  if (typeof o.content != "string")
+    throw new Error("Event content must be string");
+  if (!o.sig || typeof o.sig != "string")
+    throw new Error("Event must have string sig");
+  const s = JSON.stringify([
+    0,
+    o.pubkey,
+    o.created_at,
+    o.kind,
+    o.tags,
+    o.content,
+    o.sig
+  ]), t = await q.compress(G.encode(s));
+  if (t.length > E.MAX_COMPRESSED_SIZE)
+    throw new Error(
+      `Compressed event too large: ${t.length} bytes (max ${E.MAX_COMPRESSED_SIZE})`
+    );
+  const e = y.calculate(t);
+  return { compressed: t, checksum: e };
+}
+async function $(o, s, t) {
+  const e = o.reduce((l, T) => l + T.length, 0), n = new Uint8Array(e);
+  let i = 0;
+  for (const l of o)
+    n.set(l, i), i += l.length;
+  const r = y.calculate(n);
+  if (r !== s)
+    throw new Error(
+      `Checksum mismatch: expected 0x${s.toString(16)}, got 0x${r.toString(16)}`
+    );
+  const u = await q.decompress(n), c = JSON.parse(X.decode(u)), h = {
+    id: t,
+    pubkey: c[1],
+    created_at: c[2],
+    kind: c[3],
+    tags: c[4],
+    content: c[5],
+    sig: c[6]
+  };
+  if (!K(h))
+    throw new Error(`Invalid signature for event ${t.substring(0, 16)}…`);
+  return h;
+}
+function p(o) {
+  const s = new Uint8Array(o.length / 2);
+  for (let t = 0; t < s.length; t++)
+    s[t] = parseInt(o.substr(t * 2, 2), 16);
+  return s;
+}
+function m(o) {
+  return Array.from(o).map((s) => s.toString(16).padStart(2, "0")).join("");
+}
+function N(o, s) {
+  for (let t = 0; t < s.length; t++)
+    if (o[t] !== s[t]) return !1;
+  return !0;
+}
+function S(o) {
+  return new Promise((s) => setTimeout(s, o));
+}
+class A {
+  constructor() {
+    a(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  on(s, t) {
+    return this.listeners.has(s) || this.listeners.set(s, /* @__PURE__ */ new Set()), this.listeners.get(s).add(t), () => {
+      var e;
+      return (e = this.listeners.get(s)) == null ? void 0 : e.delete(t);
+    };
+  }
+  emit(s, ...t) {
+    for (const e of this.listeners.get(s) ?? [])
+      try {
+        e(...t);
+      } catch (n) {
+        console.error(`[EventEmitter] '${s}' listener threw:`, n);
+      }
+  }
+}
+class B {
+  constructor(s) {
+    a(this, "eventId");
+    a(this, "eventKind");
+    a(this, "totalChunks");
+    a(this, "checksum");
+    a(this, "chunks");
+    a(this, "receivedChunks");
+    this.eventId = s.eventId, this.eventKind = s.eventKind, this.totalChunks = s.totalChunks, this.checksum = s.checksum, this.chunks = new Array(this.totalChunks), this.chunks[0] = s.payload, this.receivedChunks = 1;
+  }
+  get isComplete() {
+    return this.receivedChunks === this.totalChunks;
+  }
+  /** Returns true if this was a new chunk, false if duplicate. */
+  addChunk(s, t) {
+    return this.chunks[s] !== void 0 ? !1 : (this.chunks[s] = t, this.receivedChunks++, !0);
+  }
+  missingIndices() {
+    const s = [];
+    for (let t = 0; t < this.totalChunks; t++)
+      this.chunks[t] === void 0 && s.push(t);
+    return s;
+  }
+}
+class V {
+  constructor() {
+    /** In-progress sessions keyed by the full event ID as a hex string. */
+    a(this, "sessions", /* @__PURE__ */ new Map());
+    /** Subsequent chunks that arrived before their first chunk. */
+    a(this, "pendingSubsequent", []);
+  }
+  // ─── First-chunk path ───────────────────────────────────────────────────
+  handleFirst(s, t) {
+    const e = m(s.eventId);
+    if (s.ttl === 0) return { action: "none" };
+    if (s.totalChunks > E.MAX_CHUNKS) return { action: "none" };
+    if (t.has(e)) return { action: "none" };
+    if (this.sessions.has(e)) return { action: "none" };
+    const n = new B(s);
+    return this.sessions.set(e, n), this._replayPending(e, n), n.isComplete ? (this.sessions.delete(e), { action: "complete", session: n }) : { action: "started", session: n };
+  }
+  // ─── Subsequent-chunk path ──────────────────────────────────────────────
+  handleSubsequent(s, t) {
+    const e = this._findSessionForPrefix(s.eventIdPrefix);
+    if (!e)
+      return this.pendingSubsequent.push({
+        eventIdPrefix: s.eventIdPrefix,
+        chunkIndex: s.chunkIndex,
+        payload: s.payload,
+        isLast: s.isLast,
+        arrivedAt: Date.now()
+      }), this._prunePending(t), { action: "pending", prefix: s.eventIdPrefix };
+    const n = this.sessions.get(e);
+    return n.addChunk(s.chunkIndex, s.payload) ? n.isComplete ? (this.sessions.delete(e), { action: "complete", session: n }) : { action: "progress", session: n, eventIdHex: e } : { action: "none" };
+  }
+  // ─── Timer-driven queries ────────────────────────────────────────────────
+  /** Returns missing chunk indices for a session, or null if it no longer exists. */
+  missingChunks(s) {
+    const t = this.sessions.get(s);
+    return t ? t.missingIndices() : null;
+  }
+  /** Abandon an in-progress session after max retries exceeded. */
+  abandonSession(s) {
+    this.sessions.delete(s);
+  }
+  /**
+   * Returns missing chunk indices for a pending-subsequent group
+   * (chunk 0 still missing), or null if no buffered chunks exist for this prefix.
+   */
+  missingChunksForPending(s) {
+    const t = this.pendingSubsequent.filter(
+      (c) => m(c.eventIdPrefix) === s
+    );
+    if (t.length === 0) return null;
+    const e = new Set(t.map((c) => c.chunkIndex)), n = t.find((c) => c.isLast), i = Math.max(...e), r = n ? n.chunkIndex + 1 : i + 1, u = [];
+    for (let c = 0; c < r; c++)
+      e.has(c) || u.push(c);
+    return u.length > 0 ? u : null;
+  }
+  /** Abandon all pending entries for a given prefix after max retries exceeded. */
+  abandonPending(s) {
+    this.pendingSubsequent = this.pendingSubsequent.filter(
+      (t) => m(t.eventIdPrefix) !== s
+    );
+  }
+  /** True if a session is currently in progress for this event ID. */
+  hasSession(s) {
+    return this.sessions.has(s);
+  }
+  /**
+   * Returns the raw eventId bytes for an in-progress session, or null.
+   * Used by the transport to build REQUEST prefix bytes.
+   */
+  getSessionEventId(s) {
+    var t;
+    return ((t = this.sessions.get(s)) == null ? void 0 : t.eventId) ?? null;
+  }
+  // ─── Internals ───────────────────────────────────────────────────────────
+  _findSessionForPrefix(s) {
+    for (const [t] of this.sessions.entries())
+      if (N(p(t), s)) return t;
+    return null;
+  }
+  _replayPending(s, t) {
+    const e = [];
+    for (const n of this.pendingSubsequent)
+      N(p(s), n.eventIdPrefix) ? t.addChunk(n.chunkIndex, n.payload) : e.push(n);
+    this.pendingSubsequent = e;
+  }
+  _prunePending(s) {
+    const t = Date.now() - s;
+    this.pendingSubsequent = this.pendingSubsequent.filter(
+      (e) => e.arrivedAt > t
+    );
+  }
+}
+const d = {
+  // ── SendQueue ─────────────────────────────────────────────────────────────
+  /** Base delay between packets within a single queue item (ms). */
+  INTER_PACKET_DELAY: 2e3,
+  /** Maximum additional random jitter added on top of INTER_PACKET_DELAY (ms). */
+  INTER_PACKET_JITTER: 500,
+  // ── GmProtocol ────────────────────────────────────────────────────────────
+  /** Per-peer minimum response interval before the first backoff multiplier kicks in (ms). */
+  GM_BACKOFF_BASE: 300 * 1e3,
+  /** Maximum number of our own events to re-share in response to one GM. */
+  GM_MAX_SHARE_EVENTS: 3,
+  /** Lower bound of the random pre-share / pre-reply delay (ms). */
+  GM_JITTER_MIN: 500,
+  /** Upper bound of the random pre-share / pre-reply delay (ms). */
+  GM_JITTER_MAX: 1500,
+  // ── LoRaTransport ─────────────────────────────────────────────────────────
+  /** How long to wait for the next chunk before declaring a gap and sending REQUEST (ms). */
+  REQUEST_INACTIVITY: 3e4,
+  /** Number of REQUEST retries before abandoning a partial event. */
+  REQUEST_MAX_RETRIES: 3,
+  /** How long to keep sent chunk packets around for potential retransmission (ms). */
+  SENT_CHUNKS_TTL: 300 * 1e3,
+  /** How long before we stop deduplicating a previously-seen event ID (ms). */
+  DEDUP_TIMEOUT: 900 * 1e3,
+  /** How long to wait for subsequent chunks of a partial event (ms). */
+  EVENT_TIMEOUT: 3e4,
+  /** TTL assigned to locally-created events (decremented on each re-broadcast hop). */
+  INITIAL_TTL: 6
+};
+class O extends A {
+  constructor(t, e = {}, n) {
+    super();
+    a(this, "sendFn");
+    a(this, "items", []);
+    a(this, "running", !1);
+    a(this, "seq", 0);
+    a(this, "log");
+    a(this, "INTER_PACKET_DELAY");
+    a(this, "INTER_PACKET_JITTER");
+    if (typeof t != "function")
+      throw new Error("SendQueue requires a sendFn(packet) argument");
+    this.sendFn = t, this.log = n ?? null, this.INTER_PACKET_DELAY = e.INTER_PACKET_DELAY ?? d.INTER_PACKET_DELAY, this.INTER_PACKET_JITTER = e.INTER_PACKET_JITTER ?? d.INTER_PACKET_JITTER;
+  }
+  // ─── Public API ──────────────────────────────────────────────────────────
+  enqueue(t, e, n, i = {}) {
+    const r = ++this.seq;
+    return this.items.push({ id: r, label: e, type: n, packets: t, meta: i, status: "pending" }), this.notifyUpdate(), this.drain(), r;
+  }
+  get snapshot() {
+    return this.items.map((t) => ({
+      id: t.id,
+      label: t.label,
+      type: t.type,
+      packetCount: t.packets.length,
+      status: t.status
+    }));
+  }
+  // ─── Internal ────────────────────────────────────────────────────────────
+  notifyUpdate() {
+    this.emit("queue:update", this.snapshot);
+  }
+  drain() {
+    this.running || (this.running = !0, this.run().catch((t) => {
+      var e;
+      (e = this.log) == null || e.error("[nostr-lora] send queue drain error:", t), this.running = !1;
+    }));
+  }
+  async run() {
+    var t;
+    for (; this.items.length > 0; ) {
+      const e = this.items[0];
+      e.status = "sending", this.notifyUpdate();
+      try {
+        for (let n = 0; n < e.packets.length; n++) {
+          const i = e.packets[n];
+          await this.sendFn(i), this.emit("packet:send", i, e), n < e.packets.length - 1 && await S(
+            this.INTER_PACKET_DELAY + Math.random() * this.INTER_PACKET_JITTER
+          );
+        }
+        e.meta._onSent && await e.meta._onSent();
+      } catch (n) {
+        (t = this.log) == null || t.error("[nostr-lora] send queue item error:", n), this.emit(
+          "error",
+          n instanceof Error ? n : new Error(String(n))
+        );
+      }
+      this.items.shift(), this.notifyUpdate(), this.items.length > 0 && await S(
+        this.INTER_PACKET_DELAY + Math.random() * this.INTER_PACKET_JITTER
+      );
+    }
+    this.running = !1;
+  }
+}
+class x extends A {
+  constructor(t, e = {}, n) {
+    super();
+    a(this, "getNodeId");
+    a(this, "getSentEvents");
+    a(this, "sendEvent");
+    a(this, "sendGm");
+    a(this, "backoff", /* @__PURE__ */ new Map());
+    a(this, "lastResponse", /* @__PURE__ */ new Map());
+    a(this, "log");
+    a(this, "BACKOFF_BASE");
+    a(this, "MAX_SHARE_EVENTS");
+    a(this, "JITTER_MIN");
+    a(this, "JITTER_MAX");
+    this.getNodeId = t.getNodeId, this.getSentEvents = t.getSentEvents, this.sendEvent = t.sendEvent, this.sendGm = t.sendGm, this.log = n ?? null, this.BACKOFF_BASE = e.GM_BACKOFF_BASE ?? d.GM_BACKOFF_BASE, this.MAX_SHARE_EVENTS = e.GM_MAX_SHARE_EVENTS ?? d.GM_MAX_SHARE_EVENTS, this.JITTER_MIN = e.GM_JITTER_MIN ?? d.GM_JITTER_MIN, this.JITTER_MAX = e.GM_JITTER_MAX ?? d.GM_JITTER_MAX;
+  }
+  async handlePacket(t) {
+    var I, w, k, M;
+    const e = v.decode(t);
+    this.emit("gm:receive", e, t.length);
+    const n = this.getNodeId();
+    if (!n) return;
+    const i = m(e.nodeId), r = m(n);
+    if (i === r) return;
+    const u = this.backoff.get(i) ?? 1, c = u * this.BACKOFF_BASE, h = this.lastResponse.get(i) ?? 0, l = Date.now();
+    if (l - h < c) {
+      this.backoff.set(i, Math.min(u * 2, 16)), (I = this.log) == null || I.debug(
+        `[nostr-lora] GM from ${i.substring(0, 16)} backed off (${u}x)`
+      );
+      return;
+    }
+    this.backoff.set(i, 1), this.lastResponse.set(i, l);
+    const T = this.getSentEvents(), _ = [];
+    for (const f of T.values())
+      if (f.created_at > e.recentSince && f.kind === 1 && (_.push(f), _.length >= this.MAX_SHARE_EVENTS))
+        break;
+    for (const f of _) {
+      await S(this.jitter());
+      try {
+        await this.sendEvent(f), (w = this.log) == null || w.debug(
+          `[nostr-lora] GM auto-share: sent event ${f.id.substring(0, 16)}`
+        );
+      } catch (C) {
+        (k = this.log) == null || k.warn("[nostr-lora] GM auto-share failed:", C);
+      }
+    }
+    if (Math.random() < 0.5) {
+      await S(this.jitter());
+      const f = T.size, C = this.oldestTimestamp(T);
+      await this.sendGm(n, f, C), (M = this.log) == null || M.debug(
+        `[nostr-lora] GM auto-reply sent to ${i.substring(0, 16)}`
+      );
+    }
+  }
+  jitter() {
+    return this.JITTER_MIN + Math.random() * (this.JITTER_MAX - this.JITTER_MIN);
+  }
+  oldestTimestamp(t) {
+    let e = Math.floor(Date.now() / 1e3);
+    for (const n of t.values())
+      n.created_at < e && (e = n.created_at);
+    return e;
+  }
+}
+class j extends A {
+  constructor(t, e = {}) {
+    super();
+    a(this, "connection");
+    a(this, "nodeId");
+    a(this, "log");
+    a(this, "eventTimeout");
+    a(this, "dedupTimeout");
+    a(this, "initialTtl");
+    a(this, "requestInactivity");
+    a(this, "requestMaxRetries");
+    a(this, "sentChunksTtl");
+    a(this, "assembler");
+    a(this, "queue");
+    a(this, "gm");
+    a(this, "recentEventIds", /* @__PURE__ */ new Map());
+    a(this, "inactivityTimers", /* @__PURE__ */ new Map());
+    a(this, "pendingTimers", /* @__PURE__ */ new Map());
+    a(this, "sentEvents", /* @__PURE__ */ new Map());
+    a(this, "sentChunks", /* @__PURE__ */ new Map());
+    this.connection = t, this.nodeId = e.nodeId ?? null, this.log = e.logger ?? null, this.eventTimeout = e.eventTimeout ?? d.EVENT_TIMEOUT, this.dedupTimeout = e.dedupTimeout ?? d.DEDUP_TIMEOUT, this.initialTtl = e.initialTtl ?? d.INITIAL_TTL, this.requestInactivity = e.requestInactivity ?? d.REQUEST_INACTIVITY, this.requestMaxRetries = e.requestMaxRetries ?? d.REQUEST_MAX_RETRIES, this.sentChunksTtl = e.sentChunksTtl ?? d.SENT_CHUNKS_TTL, this.assembler = new V(), this.queue = new O(
+      async (n) => {
+        await this.connection.sendRawData(n);
+      },
+      {
+        INTER_PACKET_DELAY: e.interPacketDelay ?? d.INTER_PACKET_DELAY,
+        INTER_PACKET_JITTER: e.interPacketJitter ?? d.INTER_PACKET_JITTER
+      },
+      this.log
+    ), this.queue.on("packet:send", (n, i) => {
+      i.type === "data" && this.emit("packet:send", b.decode(n), n.length);
+    }), this.queue.on(
+      "queue:update",
+      (n) => this.emit("queue:update", n)
+    ), this.queue.on("error", (n) => this.emit("error", n)), this.gm = new x(
+      {
+        getNodeId: () => this.nodeId,
+        getSentEvents: () => this.sentEvents,
+        sendEvent: (n) => this.sendEvent(n),
+        sendGm: (n, i, r) => this.sendGm(n, i, r)
+      },
+      {
+        GM_BACKOFF_BASE: e.gmBackoffBase ?? d.GM_BACKOFF_BASE,
+        GM_MAX_SHARE_EVENTS: e.gmMaxShareEvents ?? d.GM_MAX_SHARE_EVENTS,
+        GM_JITTER_MIN: e.gmJitterMin ?? d.GM_JITTER_MIN,
+        GM_JITTER_MAX: e.gmJitterMax ?? d.GM_JITTER_MAX
+      },
+      this.log
+    ), this.gm.on(
+      "gm:receive",
+      (n, i) => this.emit("gm:receive", n, i)
+    );
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  /**
+   * Open the connection and wire up data/lifecycle events.
+   * This triggers the browser port picker for `SerialConnectionManager`.
+   */
+  async begin() {
+    this.connection.on("data", (t) => {
+      this.handleRawDataPacket(t);
+    }), this.connection.on("connect", (t) => {
+      this.emit("connect", t);
+    }), this.connection.on("disconnect", () => {
+      this.emit("disconnect");
+    }), this.connection.on("error", (t) => {
+      this.emit("error", t);
+    }), await this.connection.open();
+  }
+  /** Close the connection. */
+  async end() {
+    await this.connection.close();
+  }
+  // ── Public API ────────────────────────────────────────────────────────────
+  async sendEvent(t) {
+    try {
+      const { compressed: e } = await J(t), n = p(t.id), i = b.createFromCompressed(
+        n,
+        t.kind,
+        e,
+        this.initialTtl
+      ), r = `EVENT kind:${t.kind} id:${t.id.substring(0, 8)}… (${i.length} pkt)`;
+      this.sentChunks.set(t.id, {
+        packets: i.slice(),
+        sentAt: Date.now()
+      }), this.pruneSentChunks(), this.queue.enqueue(i, r, "data", {
+        _onSent: async () => {
+          this.sentEvents.set(t.id, t), this.emit("event:send", t);
+        }
+      });
+    } catch (e) {
+      throw this.emit(
+        "error",
+        e instanceof Error ? e : new Error(String(e))
+      ), e;
+    }
+  }
+  async sendGm(t, e = 0, n = 0) {
+    const i = Math.floor(Date.now() / 1e3), r = v.create(
+      t,
+      e,
+      n,
+      i
+    ), u = `GM node:${m(t).substring(0, 16)}… events:${e}`;
+    this.queue.enqueue([r], u, "gm", {
+      _onSent: async () => {
+        this.emit(
+          "packet:send",
+          v.decode(r),
+          r.length
+        );
+      }
+    });
+  }
+  /**
+   * 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.
+   */
+  async handleRawDataPacket(t) {
+    var e;
+    try {
+      const n = new Uint8Array(
+        (t.data instanceof ArrayBuffer, t.data)
+      );
+      switch (this.emit("packet:receive", {
+        snr: t.snr || 0,
+        rssi: t.rssi || 0,
+        size: n.length
+      }), F(n)) {
+        case g.DATA:
+          await this.handleDataPacket(n);
+          break;
+        case g.REQUEST:
+          await this.handleRequestPacket(n);
+          break;
+        case g.GM:
+          await this.handleGmPacket(n);
+          break;
+        default:
+          (e = this.log) == null || e.warn(
+            "[nostr-lora] unknown packet type, flags=0x" + n[0].toString(16)
+          );
+      }
+    } catch (n) {
+      this.emit(
+        "error",
+        n instanceof Error ? n : new Error(String(n))
+      );
+    }
+  }
+  /** Update the inter-packet timing on the underlying send queue. */
+  setTimingOptions({ delay: t, jitter: e } = {}) {
+    t !== void 0 && (this.queue.INTER_PACKET_DELAY = t), e !== void 0 && (this.queue.INTER_PACKET_JITTER = e);
+  }
+  /** Number of events sent by this node (available for GM announcements). */
+  get sentEventCount() {
+    return this.sentEvents.size;
+  }
+  // ── Receive: DATA ─────────────────────────────────────────────────────────
+  async handleDataPacket(t) {
+    const e = b.decode(t);
+    if (this.emit("chunk:receive", e, t.length), e.type === "first") {
+      const n = m(e.eventId), i = this.assembler.handleFirst(
+        e,
+        this.recentEventIds
+      );
+      i.action === "complete" ? (this.clearInactivityTimer(n), this.clearPendingTimer(
+        m(
+          e.eventId.slice(0, E.EVENT_ID_PREFIX_LEN)
+        )
+      ), await this.completeSession(i.session)) : i.action === "started" && (this.resetInactivityTimer(n), this.clearPendingTimer(
+        m(
+          e.eventId.slice(0, E.EVENT_ID_PREFIX_LEN)
+        )
+      ));
+    } else {
+      const n = this.assembler.handleSubsequent(
+        e,
+        this.eventTimeout
+      );
+      n.action === "complete" ? (this.clearInactivityTimer(m(n.session.eventId)), await this.completeSession(n.session)) : n.action === "progress" ? this.resetInactivityTimer(n.eventIdHex) : n.action === "pending" && this.resetPendingTimer(n.prefix);
+    }
+  }
+  async completeSession(t) {
+    const e = m(t.eventId);
+    try {
+      const n = await $(
+        t.chunks.filter((i) => i !== void 0),
+        t.checksum,
+        e
+      );
+      this.recentEventIds.set(e, Date.now()), this.cleanupDeduplication(), this.emit("event:receive", n);
+    } catch (n) {
+      this.emit(
+        "error",
+        n instanceof Error ? n : new Error(String(n))
+      );
+    }
+  }
+  // ── Receive: REQUEST ──────────────────────────────────────────────────────
+  async handleRequestPacket(t) {
+    const e = R.decode(t), n = m(e.eventIdPrefix);
+    this.emit("request:receive", n, e.missingChunks);
+    let i = null, r = null;
+    for (const [h, l] of this.sentChunks.entries())
+      if (h.startsWith(n)) {
+        i = h, r = l;
+        break;
+      }
+    if (!r || !i) return;
+    const u = e.missingChunks.filter((h) => h < r.packets.length).map((h) => r.packets[h]);
+    if (u.length === 0) return;
+    const c = `RETX id:${i.substring(0, 8)}… chunks:[${e.missingChunks.join(",")}]`;
+    this.queue.enqueue(u, c, "data");
+  }
+  // ── Receive: GM ───────────────────────────────────────────────────────────
+  async handleGmPacket(t) {
+    await this.gm.handlePacket(t);
+  }
+  // ── Inactivity timers: session has chunk 0 ────────────────────────────────
+  resetInactivityTimer(t) {
+    const e = this.inactivityTimers.get(t), n = (e == null ? void 0 : e.requestCount) ?? 0;
+    e != null && e.timer && clearTimeout(e.timer);
+    const i = setTimeout(
+      () => this.onChunkInactivity(t),
+      this.requestInactivity
+    );
+    this.inactivityTimers.set(t, { timer: i, requestCount: n });
+  }
+  clearInactivityTimer(t) {
+    const e = this.inactivityTimers.get(t);
+    e != null && e.timer && clearTimeout(e.timer), this.inactivityTimers.delete(t);
+  }
+  async onChunkInactivity(t) {
+    var c;
+    const e = this.inactivityTimers.get(t);
+    if (!e) return;
+    const n = this.assembler.missingChunks(t);
+    if (!(n != null && n.length)) {
+      this.inactivityTimers.delete(t);
+      return;
+    }
+    if (e.requestCount++, e.requestCount > this.requestMaxRetries) {
+      (c = this.log) == null || c.warn(
+        `[nostr-lora] giving up on ${t.substring(0, 16)} after ${this.requestMaxRetries} REQUESTs`
+      ), this.clearInactivityTimer(t), this.assembler.abandonSession(t);
+      return;
+    }
+    const r = (this.assembler.getSessionEventId(t) ?? p(t)).slice(0, E.EVENT_ID_PREFIX_LEN), u = `REQ id:${t.substring(0, 8)}… missing:[${n.join(",")}] (#${e.requestCount})`;
+    this.queue.enqueue(
+      [R.create(r, n)],
+      u,
+      "request"
+    ), this.emit(
+      "request:send",
+      t,
+      n,
+      e.requestCount
+    ), e.timer = setTimeout(
+      () => this.onChunkInactivity(t),
+      this.requestInactivity
+    );
+  }
+  // ── Inactivity timers: chunk 0 still missing ──────────────────────────────
+  resetPendingTimer(t) {
+    const e = m(t), n = this.pendingTimers.get(e), i = (n == null ? void 0 : n.requestCount) ?? 0;
+    n != null && n.timer && clearTimeout(n.timer);
+    const r = setTimeout(
+      () => this.onPendingInactivity(e, t),
+      this.requestInactivity
+    );
+    this.pendingTimers.set(e, { timer: r, requestCount: i });
+  }
+  clearPendingTimer(t) {
+    const e = this.pendingTimers.get(t);
+    e != null && e.timer && clearTimeout(e.timer), this.pendingTimers.delete(t);
+  }
+  async onPendingInactivity(t, e) {
+    var u;
+    const n = this.pendingTimers.get(t);
+    if (!n) return;
+    const i = this.assembler.missingChunksForPending(t);
+    if (!i) {
+      this.pendingTimers.delete(t);
+      return;
+    }
+    if (n.requestCount++, n.requestCount > this.requestMaxRetries) {
+      (u = this.log) == null || u.warn(
+        `[nostr-lora] giving up on pending prefix ${t} after ${this.requestMaxRetries} REQUESTs`
+      ), this.assembler.abandonPending(t), this.pendingTimers.delete(t);
+      return;
+    }
+    const r = `REQ prefix:${t.substring(0, 8)}… missing:[${i.join(",")}] (#${n.requestCount})`;
+    this.queue.enqueue(
+      [R.create(e, i)],
+      r,
+      "request"
+    ), this.emit(
+      "request:send",
+      t,
+      i,
+      n.requestCount
+    ), n.timer = setTimeout(
+      () => this.onPendingInactivity(t, e),
+      this.requestInactivity
+    );
+  }
+  // ── Maintenance ───────────────────────────────────────────────────────────
+  pruneSentChunks() {
+    const t = Date.now() - this.sentChunksTtl;
+    for (const [e, n] of this.sentChunks.entries())
+      n.sentAt < t && this.sentChunks.delete(e);
+  }
+  cleanupDeduplication() {
+    const t = Date.now();
+    for (const [e, n] of this.recentEventIds.entries())
+      t - n > this.dedupTimeout && this.recentEventIds.delete(e);
+  }
+}
+class z extends A {
+  constructor(t) {
+    super();
+    a(this, "connection", null);
+    a(this, "label", null);
+    a(this, "log");
+    this.log = t ?? null;
+  }
+  // ── ConnectionManager interface ───────────────────────────────────────────
+  async open() {
+    if (!this.isWebSerialSupported())
+      throw new Error(
+        "Web Serial is not supported in this browser. Use Chrome or Edge."
+      );
+    try {
+      if (this.connection = await L.open(), !this.connection)
+        throw new Error("No serial port selected");
+      this.label = this.buildPortLabel(this.connection.serialPort), this.setupHandlers();
+    } catch (t) {
+      this.connection = null;
+      const e = t instanceof Error ? t : new Error(String(t));
+      throw this.emit("error", e), e;
+    }
+  }
+  async close() {
+    var t;
+    if (this.connection) {
+      try {
+        await this.connection.close();
+      } catch (e) {
+        (t = this.log) == null || t.warn("[nostr-lora] Error closing serial port:", e);
+      }
+      this.connection = null, this.label = null, this.emit("disconnect");
+    }
+  }
+  async sendRawData(t) {
+    if (!this.connection)
+      throw new Error("Not connected to device");
+    try {
+      const e = new Uint8Array(0);
+      await this.connection.sendCommandSendRawData(e, t);
+    } catch (e) {
+      const n = e instanceof Error ? e : new Error(String(e));
+      throw this.emit("error", n), n;
+    }
+  }
+  // ── Extra capabilities ────────────────────────────────────────────────────
+  /** Configure the LoRa radio parameters. Must be called after `open()`. */
+  async setRadioConfig(t) {
+    if (!this.connection) throw new Error("Not connected to device");
+    await this.connection.setRadioParams(
+      t.frequency,
+      t.bandwidth,
+      t.spreadingFactor,
+      t.codingRate
+    ), t.power !== void 0 && await this.connection.setTxPower(t.power);
+  }
+  isConnected() {
+    return this.connection !== null;
+  }
+  isWebSerialSupported() {
+    return typeof navigator < "u" && typeof navigator.serial < "u";
+  }
+  /** The USB VID:PID or "Serial device" label for the connected port. */
+  get portLabel() {
+    return this.label;
+  }
+  // ── Private ───────────────────────────────────────────────────────────────
+  buildPortLabel(t) {
+    try {
+      const e = t.getInfo();
+      if (e.usbVendorId !== void 0 && e.usbProductId !== void 0) {
+        const n = e.usbVendorId.toString(16).padStart(4, "0").toUpperCase(), i = e.usbProductId.toString(16).padStart(4, "0").toUpperCase();
+        return `USB ${n}:${i}`;
+      }
+    } catch {
+    }
+    return "Serial device";
+  }
+  setupHandlers() {
+    this.connection && (this.connection.once(
+      P.ResponseCodes.DeviceInfo,
+      (t) => {
+        const e = {
+          name: t.manufacturerModel ?? "Unknown",
+          firmwareVersion: t.firmwareVer != null ? String(t.firmwareVer) : "Unknown"
+        };
+        this.emit("deviceInfo", e);
+      }
+    ), this.connection.on("connected", async () => {
+      var t, e;
+      try {
+        await this.connection.sendCommandAppStart();
+      } catch (n) {
+        (t = this.log) == null || t.warn("[nostr-lora] AppStart failed:", n);
+      }
+      try {
+        const n = Math.floor(Date.now() / 1e3);
+        await this.connection.sendCommandSetDeviceTime(n);
+      } catch (n) {
+        (e = this.log) == null || e.warn("[nostr-lora] Time sync failed:", n);
+      }
+      this.emit("connect", this.label);
+    }), this.connection.on("disconnected", () => {
+      var t;
+      (t = this.log) == null || t.log("[nostr-lora] Serial device disconnected"), this.connection = null, this.label = null, this.emit("disconnect");
+    }), this.connection.on(
+      P.PushCodes.RawData,
+      (t) => {
+        this.emit("data", {
+          data: t.payload,
+          snr: t.lastSnr,
+          rssi: t.lastRssi
+        });
+      }
+    ));
+  }
+}
+export {
+  V as A,
+  d as D,
+  x as G,
+  j as L,
+  O as S,
+  z as a
+};
+//# sourceMappingURL=serial-connection.js.map