@cryptiklemur/lattice 5.10.1-beta.1 → 5.12.0

package/dist/server/mesh/connector.js

@@ -6,39 +6,39 @@ import { listProjects } from "../project/registry.js";
 import { getProjectBySlug } from "../project/registry.js";
 import { handleSessionSync, handleSessionRequest } from "./session-sync.js";
 import { log } from "../logger.js";
-var connections = new Map();
-var lastKnownProjects = new Map();
-var connectedCallbacks = [];
-var disconnectedCallbacks = [];
-var messageCallbacks = [];
-var MIN_BACKOFF_MS = 1000;
-var MAX_BACKOFF_MS = 30000;
-var CONNECTION_TIMEOUT_MS = 10000;
-var CIRCUIT_BREAKER_THRESHOLD = 5;
-var CIRCUIT_BREAKER_COOLDOWN = 60000;
-var circuitBreakers = new Map();
-var RECONNECT_INTERVAL_MS = 15000;
-var HEALTH_CHECK_INTERVAL_MS = 30000;
-var HEALTH_MISS_THRESHOLD = 3;
-var healthStates = new Map();
+const connections = new Map();
+const lastKnownProjects = new Map();
+const connectedCallbacks = [];
+const disconnectedCallbacks = [];
+const messageCallbacks = [];
+const MIN_BACKOFF_MS = 1000;
+const MAX_BACKOFF_MS = 30000;
+const CONNECTION_TIMEOUT_MS = 10000;
+const CIRCUIT_BREAKER_THRESHOLD = 5;
+const CIRCUIT_BREAKER_COOLDOWN = 60000;
+const circuitBreakers = new Map();
+const RECONNECT_INTERVAL_MS = 15000;
+const HEALTH_CHECK_INTERVAL_MS = 30000;
+const HEALTH_MISS_THRESHOLD = 3;
+const healthStates = new Map();
 export function getPeerHealth(nodeId) {
-    var state = healthStates.get(nodeId);
+    const state = healthStates.get(nodeId);
     if (!state)
         return undefined;
     return { latencyMs: state.latencyMs, healthy: state.healthy };
 }
 export function getAllPeerHealth() {
-    var result = new Map();
-    for (var [nodeId, state] of healthStates) {
+    const result = new Map();
+    for (const [nodeId, state] of healthStates) {
         result.set(nodeId, { latencyMs: state.latencyMs, healthy: state.healthy });
     }
     return result;
 }
 function startHealthCheck(conn) {
-    var state = healthStates.get(conn.nodeId);
+    const state = healthStates.get(conn.nodeId);
     if (state && state.pingTimer)
         return;
-    var healthState = {
+    const healthState = {
         lastPongAt: Date.now(),
         latencyMs: 0,
         missedPongs: 0,
@@ -46,7 +46,7 @@ function startHealthCheck(conn) {
         pingTimer: null,
     };
     healthStates.set(conn.nodeId, healthState);
-    var lastPingSentAt = 0;
+    let lastPingSentAt = 0;
     healthState.pingTimer = setInterval(function () {
         if (conn.dead || !isWebSocketOpen(conn.ws)) {
             stopHealthCheck(conn.nodeId);
@@ -70,7 +70,7 @@ function startHealthCheck(conn) {
     healthState.pingTimer.unref?.();
 }
 function stopHealthCheck(nodeId) {
-    var state = healthStates.get(nodeId);
+    const state = healthStates.get(nodeId);
     if (state && state.pingTimer) {
         clearInterval(state.pingTimer);
         state.pingTimer = null;
@@ -78,7 +78,7 @@ function stopHealthCheck(nodeId) {
     healthStates.delete(nodeId);
 }
 function handlePong(nodeId, timestamp) {
-    var state = healthStates.get(nodeId);
+    const state = healthStates.get(nodeId);
     if (!state)
         return;
     state.lastPongAt = Date.now();
@@ -94,14 +94,14 @@ export function startMeshConnections() {
     setInterval(reconcilePeers, RECONNECT_INTERVAL_MS);
 }
 function reconcilePeers() {
-    var peers = loadPeers();
-    for (var i = 0; i < peers.length; i++) {
-        var peer = peers[i];
+    const peers = loadPeers();
+    for (let i = 0; i < peers.length; i++) {
+        const peer = peers[i];
         if (!peer.addresses || peer.addresses.length === 0) {
             log.meshConnect("skip %s — no addresses", peer.name);
             continue;
         }
-        var existing = connections.get(peer.id);
+        const existing = connections.get(peer.id);
         if (existing && !existing.dead && isWebSocketOpen(existing.ws))
             continue;
         if (existing && !existing.dead && existing.retryTimer !== null) {
@@ -116,7 +116,7 @@ function reconcilePeers() {
     }
 }
 export function stopMeshConnections() {
-    for (var [nodeId, conn] of connections) {
+    for (const [nodeId, conn] of connections) {
         conn.dead = true;
         if (conn.retryTimer !== null) {
             clearTimeout(conn.retryTimer);
@@ -131,17 +131,17 @@ export function connectToPeer(nodeId, address) {
     if (connections.has(nodeId)) {
         return;
     }
-    var peers = loadPeers();
-    var peer = peers.find(function (p) { return p.id === nodeId; });
+    const peers = loadPeers();
+    const peer = peers.find(function (p) { return p.id === nodeId; });
     if (!peer) {
         return;
     }
-    var config = loadConfig();
-    var protocol = config.tls ? "wss" : "ws";
-    var url = address.includes(":")
+    const config = loadConfig();
+    const protocol = config.tls ? "wss" : "ws";
+    const url = address.includes(":")
         ? protocol + "://" + address + "/ws"
         : protocol + "://" + address + ":" + config.port + "/ws";
-    var conn = {
+    const conn = {
         nodeId: nodeId,
         ws: null,
         backoffMs: MIN_BACKOFF_MS,
@@ -153,7 +153,7 @@ export function connectToPeer(nodeId, address) {
     openConnection(conn, url);
 }
 function openConnection(conn, url) {
-    var circuit = circuitBreakers.get(conn.nodeId);
+    let circuit = circuitBreakers.get(conn.nodeId);
     if (circuit && circuit.failures >= CIRCUIT_BREAKER_THRESHOLD && !circuit.halfOpen) {
         if (Date.now() < circuit.openUntil) {
             log.meshConnect("circuit breaker open for %s, retry in %dms", conn.nodeId.slice(0, 8), circuit.openUntil - Date.now());
@@ -169,9 +169,9 @@ function openConnection(conn, url) {
         circuit.halfOpen = true;
     }
     log.meshConnect("opening WebSocket to %s", url);
-    var ws = new WebSocket(url);
+    const ws = new WebSocket(url);
     conn.ws = ws;
-    var connectionTimer = setTimeout(function () {
+    const connectionTimer = setTimeout(function () {
         if (!isWebSocketOpen(ws)) {
             log.meshConnect("connection timeout for %s at %s", conn.nodeId.slice(0, 8), url);
             ws.close();
@@ -185,10 +185,10 @@ function openConnection(conn, url) {
         }
         circuitBreakers.delete(conn.nodeId);
         conn.backoffMs = MIN_BACKOFF_MS;
-        var identity = loadOrCreateIdentity();
-        var config = loadConfig();
-        var projects = listProjects(identity.id);
-        var hello = {
+        const identity = loadOrCreateIdentity();
+        const config = loadConfig();
+        const projects = listProjects(identity.id);
+        const hello = {
             type: "mesh:hello",
             nodeId: identity.id,
             name: config.name,
@@ -199,7 +199,7 @@ function openConnection(conn, url) {
         };
         ws.send(JSON.stringify(hello));
         log.mesh("Connected to peer: %s", conn.nodeId);
-        for (var i = 0; i < connectedCallbacks.length; i++) {
+        for (let i = 0; i < connectedCallbacks.length; i++) {
             connectedCallbacks[i](conn.nodeId);
         }
     });
@@ -208,7 +208,7 @@ function openConnection(conn, url) {
             return;
         }
         try {
-            var msg = JSON.parse(event.data);
+            const msg = JSON.parse(event.data);
             if (msg.type === "mesh:hello") {
                 conn.projects = msg.projects;
                 if (msg.projects.length > 0) {
@@ -217,12 +217,12 @@ function openConnection(conn, url) {
                 startHealthCheck(conn);
             }
             else if (msg.type === "mesh:ping") {
-                var pingMsg = msg;
+                const pingMsg = msg;
                 conn.ws.send(JSON.stringify({ type: "mesh:pong", timestamp: pingMsg.timestamp }));
                 return;
             }
             else if (msg.type === "mesh:pong") {
-                var pongMsg = msg;
+                const pongMsg = msg;
                 handlePong(conn.nodeId, pongMsg.timestamp);
                 return;
             }
@@ -230,13 +230,13 @@ function openConnection(conn, url) {
                 handleSessionSync(conn.nodeId, msg);
             }
             else if (msg.type === "mesh:session_request") {
-                var reqMsg = msg;
-                var reqProject = getProjectBySlug(reqMsg.projectSlug);
+                const reqMsg = msg;
+                const reqProject = getProjectBySlug(reqMsg.projectSlug);
                 if (reqProject) {
                     handleSessionRequest(conn.nodeId, reqMsg, reqProject.path);
                 }
             }
-            for (var i = 0; i < messageCallbacks.length; i++) {
+            for (let i = 0; i < messageCallbacks.length; i++) {
                 messageCallbacks[i](conn.nodeId, msg);
             }
         }
@@ -249,7 +249,7 @@ function openConnection(conn, url) {
         if (conn.dead) {
             return;
         }
-        var circuit = circuitBreakers.get(conn.nodeId);
+        let circuit = circuitBreakers.get(conn.nodeId);
         if (!circuit) {
             circuit = { failures: 0, openUntil: 0, halfOpen: false };
             circuitBreakers.set(conn.nodeId, circuit);
@@ -264,10 +264,10 @@ function openConnection(conn, url) {
             circuit.openUntil = Date.now() + CIRCUIT_BREAKER_COOLDOWN;
             log.mesh("Circuit breaker open for peer: %s after %d consecutive failures", conn.nodeId, circuit.failures);
         }
-        for (var i = 0; i < disconnectedCallbacks.length; i++) {
+        for (let i = 0; i < disconnectedCallbacks.length; i++) {
             disconnectedCallbacks[i](conn.nodeId);
         }
-        var delay = conn.backoffMs;
+        const delay = conn.backoffMs;
         conn.backoffMs = Math.min(conn.backoffMs * 2, MAX_BACKOFF_MS);
         conn.retryTimer = setTimeout(function () {
             if (conn.dead) {
@@ -282,7 +282,7 @@ function openConnection(conn, url) {
     });
 }
 export function getPeerConnection(nodeId) {
-    var conn = connections.get(nodeId);
+    const conn = connections.get(nodeId);
     if (!conn) {
         return undefined;
     }
@@ -292,7 +292,7 @@ export function getPeerConnection(nodeId) {
     return conn.ws;
 }
 export function registerInboundPeer(nodeId, ws, peerProjects) {
-    var existing = connections.get(nodeId);
+    const existing = connections.get(nodeId);
     if (existing && !existing.dead && isWebSocketOpen(existing.ws)) {
         log.meshConnect("inbound peer %s already connected, skipping", nodeId.slice(0, 8));
         return;
@@ -305,8 +305,8 @@ export function registerInboundPeer(nodeId, ws, peerProjects) {
         }
     }
     circuitBreakers.delete(nodeId);
-    var incomingProjects = peerProjects ?? [];
-    var conn = {
+    const incomingProjects = peerProjects ?? [];
+    const conn = {
         nodeId: nodeId,
         ws: ws,
         backoffMs: 1000,
@@ -318,12 +318,12 @@ export function registerInboundPeer(nodeId, ws, peerProjects) {
         lastKnownProjects.set(nodeId, incomingProjects);
     }
     connections.set(nodeId, conn);
-    var peers = loadPeers();
-    var peer = peers.find(function (p) { return p.id === nodeId; });
+    const peers = loadPeers();
+    const peer = peers.find(function (p) { return p.id === nodeId; });
     if (peer) {
-        var identity = loadOrCreateIdentity();
-        var config = loadConfig();
-        var projects = config.projects || [];
+        const identity = loadOrCreateIdentity();
+        const config = loadConfig();
+        const projects = config.projects || [];
         conn.projects = [];
         ws.send(JSON.stringify({
             type: "mesh:hello",
@@ -337,7 +337,7 @@ export function registerInboundPeer(nodeId, ws, peerProjects) {
     }
 }
 export function disconnectPeer(nodeId) {
-    var existing = connections.get(nodeId);
+    const existing = connections.get(nodeId);
     if (existing) {
         existing.dead = true;
         if (existing.retryTimer !== null) {
@@ -351,7 +351,7 @@ export function disconnectPeer(nodeId) {
     circuitBreakers.delete(nodeId);
 }
 export function reconnectPeer(nodeId) {
-    var existing = connections.get(nodeId);
+    const existing = connections.get(nodeId);
     if (existing) {
         existing.dead = true;
         if (existing.retryTimer !== null) {
@@ -362,15 +362,15 @@ export function reconnectPeer(nodeId) {
         connections.delete(nodeId);
     }
     circuitBreakers.delete(nodeId);
-    var peers = loadPeers();
-    var peer = peers.find(function (p) { return p.id === nodeId; });
+    const peers = loadPeers();
+    const peer = peers.find(function (p) { return p.id === nodeId; });
     if (peer && peer.addresses && peer.addresses.length > 0) {
         connectToPeer(nodeId, peer.addresses[0]);
     }
 }
 export function getConnectedPeerIds() {
-    var ids = [];
-    for (var [nodeId, conn] of connections) {
+    const ids = [];
+    for (const [nodeId, conn] of connections) {
         if (isWebSocketOpen(conn.ws)) {
             ids.push(nodeId);
         }
@@ -390,27 +390,27 @@ function isWebSocketOpen(ws) {
     return ws.readyState === WebSocket.OPEN || ws.readyState === 0;
 }
 export function getConnectedPeerProjects(nodeId) {
-    var conn = connections.get(nodeId);
+    const conn = connections.get(nodeId);
     if (!conn || !isWebSocketOpen(conn.ws))
         return [];
     return conn.projects;
 }
 export function getAllRemoteProjects(localNodeId) {
-    var allPeers = peersModule.loadPeers();
-    var connectedIds = new Set(getConnectedPeerIds());
-    var results = [];
-    for (var p = 0; p < allPeers.length; p++) {
-        var peer = allPeers[p];
-        var isOnline = connectedIds.has(peer.id);
-        var projects = [];
-        var conn = connections.get(peer.id);
+    const allPeers = peersModule.loadPeers();
+    const connectedIds = new Set(getConnectedPeerIds());
+    const results = [];
+    for (let p = 0; p < allPeers.length; p++) {
+        const peer = allPeers[p];
+        const isOnline = connectedIds.has(peer.id);
+        let projects = [];
+        const conn = connections.get(peer.id);
         if (conn && conn.projects.length > 0) {
             projects = conn.projects;
         }
         else if (lastKnownProjects.has(peer.id)) {
             projects = lastKnownProjects.get(peer.id);
         }
-        for (var i = 0; i < projects.length; i++) {
+        for (let i = 0; i < projects.length; i++) {
             results.push({
                 slug: projects[i].slug,
                 path: "",
@@ -425,11 +425,11 @@ export function getAllRemoteProjects(localNodeId) {
     return results;
 }
 export function findNodeForProject(projectSlug) {
-    for (var [nodeId, conn] of connections) {
+    for (const [nodeId, conn] of connections) {
         if (!isWebSocketOpen(conn.ws)) {
             continue;
         }
-        for (var i = 0; i < conn.projects.length; i++) {
+        for (let i = 0; i < conn.projects.length; i++) {
             if (conn.projects[i].slug === projectSlug) {
                 return nodeId;
             }

package/dist/server/mesh/crypto.js

@@ -1,16 +1,16 @@
 import { createSign, createVerify, randomBytes, createCipheriv, createDecipheriv, createHash, diffieHellman, generateKeyPairSync, createPublicKey, createPrivateKey } from "node:crypto";
 export function sign(privateKeyBase64, data) {
-    var privateKeyDer = Buffer.from(privateKeyBase64, "base64");
-    var key = createPrivateKey({ key: privateKeyDer, format: "der", type: "pkcs8" });
-    var signer = createSign("ed25519");
+    const privateKeyDer = Buffer.from(privateKeyBase64, "base64");
+    const key = createPrivateKey({ key: privateKeyDer, format: "der", type: "pkcs8" });
+    const signer = createSign("ed25519");
     signer.update(data);
     return signer.sign(key).toString("base64");
 }
 export function verify(publicKeyBase64, data, signatureBase64) {
     try {
-        var publicKeyDer = Buffer.from(publicKeyBase64, "base64");
-        var key = createPublicKey({ key: publicKeyDer, format: "der", type: "spki" });
-        var verifier = createVerify("ed25519");
+        const publicKeyDer = Buffer.from(publicKeyBase64, "base64");
+        const key = createPublicKey({ key: publicKeyDer, format: "der", type: "spki" });
+        const verifier = createVerify("ed25519");
         verifier.update(data);
         return verifier.verify(key, Buffer.from(signatureBase64, "base64"));
     }
@@ -22,7 +22,7 @@ export function generateChallenge() {
     return randomBytes(32).toString("base64");
 }
 export function generateEphemeralKeys() {
-    var pair = generateKeyPairSync("x25519", {
+    const pair = generateKeyPairSync("x25519", {
         publicKeyEncoding: { type: "spki", format: "der" },
         privateKeyEncoding: { type: "pkcs8", format: "der" },
     });
@@ -32,20 +32,20 @@ export function generateEphemeralKeys() {
     };
 }
 export function deriveSharedSecret(myPrivateKeyDer, theirPublicKeyBase64, nodeIdA, nodeIdB) {
-    var myKey = createPrivateKey({ key: myPrivateKeyDer, format: "der", type: "pkcs8" });
-    var theirKey = createPublicKey({ key: Buffer.from(theirPublicKeyBase64, "base64"), format: "der", type: "spki" });
-    var shared = diffieHellman({ privateKey: myKey, publicKey: theirKey });
-    var sortedIds = [nodeIdA, nodeIdB].sort().join(":");
-    var hash = createHash("sha256");
+    const myKey = createPrivateKey({ key: myPrivateKeyDer, format: "der", type: "pkcs8" });
+    const theirKey = createPublicKey({ key: Buffer.from(theirPublicKeyBase64, "base64"), format: "der", type: "spki" });
+    const shared = diffieHellman({ privateKey: myKey, publicKey: theirKey });
+    const sortedIds = [nodeIdA, nodeIdB].sort().join(":");
+    const hash = createHash("sha256");
     hash.update(shared);
     hash.update(Buffer.from("lattice-mesh-v1:" + sortedIds));
     return hash.digest();
 }
 export function encrypt(key, nonce, plaintext) {
-    var iv = Buffer.alloc(12);
+    const iv = Buffer.alloc(12);
     iv.writeBigUInt64BE(BigInt(nonce), 4);
-    var cipher = createCipheriv("aes-256-gcm", key, iv);
-    var encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
     return {
         ciphertext: encrypted.toString("base64"),
         tag: cipher.getAuthTag().toString("base64"),
@@ -53,11 +53,11 @@ export function encrypt(key, nonce, plaintext) {
 }
 export function decrypt(key, nonce, ciphertext, tag) {
     try {
-        var iv = Buffer.alloc(12);
+        const iv = Buffer.alloc(12);
         iv.writeBigUInt64BE(BigInt(nonce), 4);
-        var decipher = createDecipheriv("aes-256-gcm", key, iv);
+        const decipher = createDecipheriv("aes-256-gcm", key, iv);
         decipher.setAuthTag(Buffer.from(tag, "base64"));
-        var decrypted = Buffer.concat([decipher.update(Buffer.from(ciphertext, "base64")), decipher.final()]);
+        const decrypted = Buffer.concat([decipher.update(Buffer.from(ciphertext, "base64")), decipher.final()]);
         return decrypted.toString("utf-8");
     }
     catch {
@@ -69,13 +69,13 @@ export function createSecureSession(sharedKey) {
 }
 export function encryptMessage(session, message) {
     session.sendNonce++;
-    var result = encrypt(session.sharedKey, session.sendNonce, JSON.stringify(message));
+    const result = encrypt(session.sharedKey, session.sendNonce, JSON.stringify(message));
     return { type: "mesh:encrypted", nonce: session.sendNonce, ...result };
 }
 export function decryptMessage(session, nonce, ciphertext, tag) {
     if (nonce <= session.recvNonce)
         return null;
-    var plaintext = decrypt(session.sharedKey, nonce, ciphertext, tag);
+    const plaintext = decrypt(session.sharedKey, nonce, ciphertext, tag);
     if (!plaintext)
         return null;
     session.recvNonce = nonce;

package/dist/server/mesh/discovery.js

@@ -1,11 +1,11 @@
 import BonjourImport from "bonjour-service";
-var Bonjour = (typeof BonjourImport === "function" ? BonjourImport : BonjourImport.default);
-var bonjour = null;
-var publishedService = null;
-var browser = null;
-var discoveredNodes = new Map();
-var discoveredCallbacks = [];
-var lostCallbacks = [];
+const Bonjour = (typeof BonjourImport === "function" ? BonjourImport : BonjourImport.default);
+let bonjour = null;
+let publishedService = null;
+let browser = null;
+const discoveredNodes = new Map();
+const discoveredCallbacks = [];
+const lostCallbacks = [];
 export function startDiscovery(nodeId, name, port) {
     if (bonjour !== null) {
         return;
@@ -24,20 +24,20 @@ export function startDiscovery(nodeId, name, port) {
     });
     console.log(`[discovery] Published _lattice._tcp as "${name}" on port ${port}`);
     browser = bonjour.find({ type: "lattice", protocol: "tcp" }, function (service) {
-        var txt = service.txt;
+        const txt = service.txt;
         if (!txt || !txt.nodeId) {
             return;
         }
         if (txt.nodeId === nodeId) {
             return;
         }
-        var address = service.addresses && service.addresses.length > 0
+        const address = service.addresses && service.addresses.length > 0
             ? service.addresses[0]
             : (service.referer ? service.referer.address : "");
         if (!address) {
             return;
         }
-        var node = {
+        const node = {
             nodeId: txt.nodeId,
             name: txt.name || service.name,
             address: address,
@@ -46,22 +46,22 @@ export function startDiscovery(nodeId, name, port) {
         };
         discoveredNodes.set(node.nodeId, node);
         console.log(`[discovery] Found node: ${node.name} (${node.nodeId}) at ${node.address}:${node.port}`);
-        for (var i = 0; i < discoveredCallbacks.length; i++) {
+        for (let i = 0; i < discoveredCallbacks.length; i++) {
             discoveredCallbacks[i](node);
         }
     });
     browser.on("down", function (service) {
-        var txt = service.txt;
+        const txt = service.txt;
         if (!txt || !txt.nodeId) {
             return;
         }
-        var lostId = txt.nodeId;
+        const lostId = txt.nodeId;
         if (!discoveredNodes.has(lostId)) {
             return;
         }
         discoveredNodes.delete(lostId);
         console.log(`[discovery] Lost node: ${lostId}`);
-        for (var i = 0; i < lostCallbacks.length; i++) {
+        for (let i = 0; i < lostCallbacks.length; i++) {
             lostCallbacks[i](lostId);
         }
     });

package/dist/server/mesh/pairing.js

@@ -1,13 +1,13 @@
 import { randomBytes } from "node:crypto";
-var BASE62_CHARS = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
-var CODE_LENGTH = 16;
-var PAIRING_TOKEN_TTL = 300000;
-var CLEANUP_INTERVAL = 60000;
-var pendingTokens = new Map();
+const BASE62_CHARS = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
+const CODE_LENGTH = 16;
+const PAIRING_TOKEN_TTL = 300000;
+const CLEANUP_INTERVAL = 60000;
+const pendingTokens = new Map();
 function base62Encode(buf) {
-    var n = BigInt("0x" + buf.toString("hex"));
-    var result = "";
-    var base = BigInt(BASE62_CHARS.length);
+    let n = BigInt("0x" + buf.toString("hex"));
+    let result = "";
+    const base = BigInt(BASE62_CHARS.length);
     while (n > 0n) {
         result = BASE62_CHARS[Number(n % base)] + result;
         n = n / base;
@@ -18,25 +18,25 @@ function base62Encode(buf) {
     return result;
 }
 function base62Decode(s) {
-    var n = 0n;
-    var base = BigInt(BASE62_CHARS.length);
-    for (var i = 0; i < s.length; i++) {
-        var idx = BASE62_CHARS.indexOf(s[i]);
+    let n = 0n;
+    const base = BigInt(BASE62_CHARS.length);
+    for (let i = 0; i < s.length; i++) {
+        const idx = BASE62_CHARS.indexOf(s[i]);
         if (idx < 0) {
             throw new Error("Invalid base62 character: " + s[i]);
         }
         n = n * base + BigInt(idx);
     }
-    var hex = n.toString(16);
+    let hex = n.toString(16);
     if (hex.length % 2 !== 0) {
         hex = "0" + hex;
     }
     return Buffer.from(hex, "hex");
 }
 function packPayload(address, port, token) {
-    var parts = address.split(".");
-    var buf = Buffer.alloc(4 + 2 + token.length);
-    for (var i = 0; i < 4; i++) {
+    const parts = address.split(".");
+    const buf = Buffer.alloc(4 + 2 + token.length);
+    for (let i = 0; i < 4; i++) {
         buf[i] = parseInt(parts[i] || "0", 10);
     }
     buf.writeUInt16BE(port, 4);
@@ -46,14 +46,14 @@ function packPayload(address, port, token) {
 function unpackPayload(buf) {
     if (buf.length < 8)
         return null;
-    var address = buf[0] + "." + buf[1] + "." + buf[2] + "." + buf[3];
-    var port = buf.readUInt16BE(4);
-    var token = buf.subarray(6).toString("hex");
+    const address = buf[0] + "." + buf[1] + "." + buf[2] + "." + buf[3];
+    const port = buf.readUInt16BE(4);
+    const token = buf.subarray(6).toString("hex");
     return { address, port, token };
 }
 function formatCode(raw) {
-    var chunks = [];
-    for (var i = 0; i < raw.length; i += 4) {
+    const chunks = [];
+    for (let i = 0; i < raw.length; i += 4) {
         chunks.push(raw.slice(i, i + 4));
     }
     return "LTCE-" + chunks.join("-");
@@ -62,18 +62,18 @@ function stripCode(code) {
     return code.replace(/^LTCE-/i, "").replace(/-/g, "");
 }
 export async function generateInviteCode(address, port) {
-    var tokenBuf = randomBytes(4);
-    var token = tokenBuf.toString("hex");
-    var payload = packPayload(address, port, tokenBuf);
-    var encoded = base62Encode(payload);
-    var code = formatCode(encoded);
+    const tokenBuf = randomBytes(4);
+    const token = tokenBuf.toString("hex");
+    const payload = packPayload(address, port, tokenBuf);
+    const encoded = base62Encode(payload);
+    const code = formatCode(encoded);
     pendingTokens.set(token, Date.now());
     return { code, token, qrDataUrl: "" };
 }
 export function parseInviteCode(code) {
     try {
-        var stripped = stripCode(code);
-        var decoded = base62Decode(stripped);
+        const stripped = stripCode(code);
+        const decoded = base62Decode(stripped);
         return unpackPayload(decoded);
     }
     catch {
@@ -81,7 +81,7 @@ export function parseInviteCode(code) {
     }
 }
 export function validatePairingToken(token) {
-    var createdAt = pendingTokens.get(token);
+    const createdAt = pendingTokens.get(token);
     if (createdAt === undefined) {
         return false;
     }
@@ -95,7 +95,7 @@ export function consumePairingToken(token) {
     pendingTokens.delete(token);
 }
 setInterval(function () {
-    var now = Date.now();
+    const now = Date.now();
     pendingTokens.forEach(function (createdAt, token) {
         if (now - createdAt > PAIRING_TOKEN_TTL) {
             pendingTokens.delete(token);