zyro-gateway 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-05-17
+
+### Added
+
+- Modular server under `src/` (config, routes, Socket.IO, terminal logging).
+- CLI: `zyro-gateway`, `zyro-gateway config`, `zyro-gateway help`.
+- Programmatic API: `require('zyro-gateway/server')` → `createGateway()`, `start()`.
+- HTTP fallback: `POST /api/register`, `POST /api/income`, `POST /api/notification`.
+- REST: dashboard, devices, transactions, notifications.
+- Browser client (`Zyro.connect`) bundled to `dist/zyro.js`.
+- Documentation: README setup, API reference, website integration.
+
+### Changed
+
+- npm package name `zyro-gateway` (the `zyro` name is already taken on npm).
+
+[1.0.0]: https://github.com/orod-codes/zyro-getway/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 orod-codes
+
+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,226 @@
+# Zyro Gateway
+
+[![npm version](https://img.shields.io/npm/v/zyro-gateway)](https://www.npmjs.com/package/zyro-gateway)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Real-time sync between a **phone monitor app** (Flutter) and your **desktop terminal / website**. Income transactions and notifications flow over Socket.IO, with HTTP fallback when sockets are unavailable.
+
+## Features
+
+- Terminal server with live **connected devices** and **income logs** (name, amount, sender, ref)
+- Browser client (`Zyro.connect`) for dashboards and stores
+- Pairing rooms — isolate traffic per store with a short pairing code
+- REST API for polling clients and HTTP-only phones
+- Config via `zyro.config.js` in your project (not committed)
+
+## Requirements
+
+- Node.js **18+**
+- Phone app and website on the same LAN as the gateway (or USB `adb reverse` for local dev)
+
+## Quick start
+
+```bash
+npm install zyro-gateway
+npx zyro-gateway config    # creates ./zyro.config.js
+# Edit ip, port, pairingCode in zyro.config.js
+npx zyro-gateway           # start server
+```
+
+From a git clone:
+
+```bash
+cd zyrogetway
+npm install
+npm run config
+npm start
+```
+
+The terminal prints **config path**, **pairing code**, **IP**, and **port**. Use those in your phone app under **Setup → Zyro Gateway**.
+
+### USB debugging (Android)
+
+```bash
+adb reverse tcp:3001 tcp:3001
+```
+
+On the phone, set gateway IP to `127.0.0.1` and port `3001` (match `zyro.config.js`).
+
+## Configuration
+
+| Field | Description |
+|--------|-------------|
+| `ip` | PC LAN address. Leave `''` to auto-detect. |
+| `port` | Listen port (default `3000` if unset; example uses `3001`). |
+| `pairingCode` | 4–12 letters/numbers; must match the phone app. |
+| `deviceName` | Optional label for web clients. |
+| `autoConnect` | Browser client: connect on load. |
+| `pollIntervalMs` | HTTP polling interval when sockets fail. |
+
+**Load order**
+
+1. `ZYRO_CONFIG` environment variable (absolute path)
+2. `./zyro.config.js` in the current working directory
+3. `zyro.config.js` inside the installed package
+
+**Environment**
+
+| Variable | Purpose |
+|----------|---------|
+| `PORT` | Override listen port |
+| `ZYRO_CONFIG` | Path to config file |
+
+## Phone app
+
+Point **Setup → Zyro Gateway** at the same **IP**, **port**, and **pairing code** shown in the terminal.
+
+When Socket.IO is blocked, the app can register and post income over HTTP (`/api/register`, `/api/income`). The terminal still lists the device and logs income.
+
+## Website integration
+
+Serve the bundled client from the gateway (after `npm run build` / install):
+
+```html
+<script src="http://YOUR-IP:3001/socket.io/socket.io.js"></script>
+<script src="http://YOUR-IP:3001/zyro/zyro.js"></script>
+<script>
+  const sync = Zyro.connect({
+    ip: '192.168.1.10',
+    port: 3001,
+    pairingCode: 'MYSTORE',
+    role: 'desktop',
+    deviceName: 'My Store',
+  });
+
+  sync.on('transaction', (tx) => {
+    console.log('Income', tx.amount, tx.name);
+  });
+
+  sync.on('notification', (note) => {
+    console.log('Notification', note.title);
+  });
+
+  sync.on('dashboard', (data) => {
+    console.log('Today total', data.stats.todayTotal);
+  });
+</script>
+```
+
+### ESM / bundlers
+
+```javascript
+import { connect } from 'zyro-gateway';
+const sync = connect({ ip: '192.168.1.10', port: 3001, pairingCode: 'MYSTORE', role: 'desktop' });
+```
+
+## Programmatic server
+
+Embed the gateway in your own Node process:
+
+```javascript
+const { createGateway } = require('zyro-gateway/server');
+
+async function main() {
+  const gateway = createGateway({ packageRoot: __dirname });
+  const { url, pairingCode } = await gateway.start();
+  console.log('Listening at', url, 'pairing', pairingCode);
+}
+
+main();
+```
+
+`createGateway()` returns `{ app, server, io, start(), stop() }` without listening until you call `start()`.
+
+## HTTP API
+
+All pairing-scoped routes accept `?pairing=CODE` or header `X-Pairing: CODE`. If `pairingCode` is set in `zyro.config.js`, it becomes the default.
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/` | Service index + endpoint list |
+| GET | `/api/info` | Server info, URLs, features |
+| GET | `/api/config` | IP, port, pairing from config |
+| GET | `/api/dashboard` | Today stats + recent activity |
+| GET | `/api/devices` | Connected devices for pairing room |
+| GET | `/api/transactions` | Transactions (`?after=ISO` for incremental) |
+| GET | `/api/notifications` | Notifications (`?after=ISO`) |
+| POST | `/api/register` | Register phone via HTTP |
+| POST | `/api/income` | Post income JSON body |
+| POST | `/api/notification` | Post notification JSON body |
+
+Static client: `GET /zyro/zyro.js`
+
+## Socket.IO events
+
+**Client → server**
+
+| Event | Payload |
+|--------|---------|
+| `register` | `{ deviceName, platform, ... }` |
+| `income_transaction` | Transaction object |
+| `notification_event` | Notification object |
+
+**Server → client**
+
+| Event | Description |
+|--------|-------------|
+| `sync_ready` | Handshake OK |
+| `sync_error` | Invalid pairing |
+| `history` | Recent transactions |
+| `notification_history` | Recent notifications |
+| `income_transaction` | New transaction |
+| `notification_event` | New notification |
+| `dashboard_update` | Stats snapshot |
+| `presence` | Device counts |
+| `device_joined` / `device_left` / `device_updated` | Device lifecycle |
+
+Connect query: `?pairing=MYSTORE&role=phone|desktop&deviceName=Label`
+
+## CLI
+
+```bash
+zyro-gateway              # Start server
+zyro-gateway config       # Create zyro.config.js in cwd
+zyro-gateway help           # Usage
+```
+
+## Project layout
+
+```
+bin/zyro-gateway.js       CLI entry
+src/
+  config/                 load-config, pairing helpers
+  server/                 routes, socket, broadcast, terminal
+  utils/                  network, formatting
+  index.js                start() + exports
+zyro/zyro.js              ESM browser client (source)
+dist/zyro.js              IIFE bundle (published)
+scripts/                  build, init-config
+server.js                 npm start shim
+```
+
+## npm scripts (development)
+
+| Script | Action |
+|--------|--------|
+| `npm run config` | Create `zyro.config.js` in cwd |
+| `npm run build` | Bundle browser client to `dist/zyro.js` |
+| `npm start` | Build + start gateway |
+| `npm run dev` | Start with `--watch` |
+
+## Publish to npm
+
+The package name on npm is **`zyro-gateway`** (`zyro` is already registered).
+
+```bash
+npm run build
+npm publish --access public
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Repository
+
+https://github.com/orod-codes/zyro-getway

package/bin/zyro-gateway.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+'use strict';
+
+const cmd = process.argv[2];
+
+if (cmd === 'config' || cmd === 'init') {
+  require('../scripts/init-config.js');
+} else if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
+  console.log(`
+Zyro Gateway — real-time phone ↔ desktop sync
+
+Usage:
+  zyro-gateway              Start the gateway server
+  zyro-gateway config       Create zyro.config.js in the current directory
+  zyro-gateway help         Show this message
+
+Environment:
+  PORT          Override listen port
+  ZYRO_CONFIG   Path to zyro.config.js
+
+Docs: https://github.com/orod-codes/zyro-getway#readme
+`);
+} else {
+  require('../src/index').start();
+}

package/dist/zyro.js

@@ -0,0 +1,395 @@
+var Zyro = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // zyro/browser-entry.js
+  var browser_entry_exports = {};
+  __export(browser_entry_exports, {
+    DEFAULTS: () => DEFAULTS,
+    EVENTS: () => EVENTS,
+    ZyroConnection: () => ZyroConnection,
+    connect: () => connect
+  });
+
+  // zyro/zyro.js
+  var DEFAULTS = {
+    ip: "",
+    port: 3e3,
+    serverUrl: "",
+    pairingCode: "",
+    role: "desktop",
+    deviceName: "Web Client",
+    autoConnect: true,
+    pollIntervalMs: 1500,
+    maxItems: 200
+  };
+  function resolveBaseUrl(config) {
+    if (config.serverUrl) return normalizeUrl(config.serverUrl);
+    const ip = String(config.ip || "").trim();
+    const port = Number(config.port) || 3e3;
+    if (!ip) {
+      if (typeof location !== "undefined") {
+        return normalizeUrl(`http://${location.hostname}:${port}`);
+      }
+      throw new Error("Zyro: set ip and port in zyro.config.js");
+    }
+    return normalizeUrl(`http://${ip}:${port}`);
+  }
+  var EVENTS = {
+    READY: "ready",
+    STATUS: "status",
+    ERROR: "error",
+    TRANSACTION: "transaction",
+    NOTIFICATION: "notification",
+    DASHBOARD: "dashboard",
+    PRESENCE: "presence",
+    DEVICES: "devices"
+  };
+  function normalizeUrl(url) {
+    let u = String(url || "").trim().replace(/\/+$/, "");
+    if (!u && typeof location !== "undefined") return location.origin;
+    if (u.startsWith("ws://")) u = `http://${u.slice(5)}`;
+    if (u.startsWith("wss://")) u = `https://${u.slice(6)}`;
+    return u;
+  }
+  function normalizePairing(raw) {
+    const p = String(raw || "").trim().toUpperCase().replace(/[^A-Z0-9]/g, "");
+    if (p.length < 4 || p.length > 12) return "";
+    return p;
+  }
+  function txKey(tx) {
+    if (tx.id) return String(tx.id);
+    return `${tx.transactionNumber || tx.referenceNumber || ""}|${tx.timestamp || tx.receivedAt}|${tx.amount}`;
+  }
+  function noteKey(n) {
+    if (n.id) return String(n.id);
+    return `${n.timestamp || n.receivedAt}|${n.preview}`;
+  }
+  var ZyroConnection = class {
+    constructor(options = {}) {
+      this.config = { ...DEFAULTS, ...options };
+      this._handlers = /* @__PURE__ */ new Map();
+      this._socket = null;
+      this._baseUrl = "";
+      this._pairingCode = "";
+      this._status = "idle";
+      this._pollTimers = [];
+      this.transactions = [];
+      this.notifications = [];
+      this.devices = /* @__PURE__ */ new Map();
+      this.dashboard = null;
+      this.presence = { phones: 0, desktops: 0 };
+      this._seenTx = /* @__PURE__ */ new Set();
+      this._seenNotes = /* @__PURE__ */ new Set();
+      this._lastTxTime = "";
+      this._lastNoteTime = "";
+      if (this.config.autoConnect) {
+        this.connect().catch((err) => this._emit(EVENTS.ERROR, err));
+      }
+    }
+    on(event, fn) {
+      if (!this._handlers.has(event)) this._handlers.set(event, /* @__PURE__ */ new Set());
+      this._handlers.get(event).add(fn);
+      return () => this.off(event, fn);
+    }
+    off(event, fn) {
+      this._handlers.get(event)?.delete(fn);
+    }
+    _emit(event, ...args) {
+      const set = this._handlers.get(event);
+      if (!set) return;
+      for (const fn of [...set]) fn(...args);
+    }
+    _setStatus(status, detail = {}) {
+      this._status = status;
+      this._emit(EVENTS.STATUS, { status, ...detail });
+    }
+    async connect() {
+      this._baseUrl = resolveBaseUrl(this.config);
+      this._setStatus("connecting");
+      const infoRes = await fetch(`${this._baseUrl}/api/info`, { cache: "no-store" });
+      if (!infoRes.ok) throw new Error(`Zyro: cannot reach server (${infoRes.status})`);
+      const configured = normalizePairing(this.config.pairingCode);
+      if (!configured) {
+        throw new Error(
+          "Zyro: pairingCode is required in zyro.config.js (4\u201312 letters/numbers)"
+        );
+      }
+      this._pairingCode = configured;
+      const info = await infoRes.json();
+      const cfgPort = Number(this.config.port) || 3e3;
+      if (info.port && info.port !== cfgPort) {
+        console.warn(
+          `Zyro: server port is ${info.port} but zyro.config.js port is ${cfgPort} \u2014 fix port and restart npm start`
+        );
+      }
+      if (info.ip && !this.config.ip) {
+        this.config.ip = info.ip;
+      }
+      this._connectSocket();
+      this._startPollers();
+      if (typeof document !== "undefined") {
+        document.addEventListener("visibilitychange", () => {
+          if (document.visibilityState === "visible") {
+            this._pollTransactions();
+            this._pollNotifications();
+            this._refreshDashboard();
+            if (this._socket && !this._socket.connected) this._socket.connect();
+          }
+        });
+      }
+      return { pairingCode: this._pairingCode, serverUrl: this._baseUrl };
+    }
+    async setPairingCode(code) {
+      const next = normalizePairing(code);
+      if (!next) throw new Error("Zyro: invalid pairing code (4\u201312 letters/numbers)");
+      this.config.pairingCode = next;
+      this.disconnect();
+      this._seenTx.clear();
+      this._seenNotes.clear();
+      this._lastTxTime = "";
+      this._lastNoteTime = "";
+      this.transactions.length = 0;
+      this.notifications.length = 0;
+      this.devices.clear();
+      return this.connect();
+    }
+    _pairingQuery(extra = {}) {
+      const params = new URLSearchParams({ pairing: this._pairingCode, ...extra });
+      return `?${params.toString()}`;
+    }
+    _fetchOpts() {
+      return {
+        cache: "no-store",
+        headers: { "X-Pairing": this._pairingCode }
+      };
+    }
+    disconnect() {
+      this._stopPollers();
+      if (this._socket) {
+        this._socket.removeAllListeners();
+        this._socket.disconnect();
+        this._socket = null;
+      }
+      this._setStatus("disconnected");
+    }
+    _connectSocket() {
+      const io = typeof globalThis !== "undefined" ? globalThis.io : null;
+      if (!io) {
+        this._setStatus("polling", { reason: "socket.io not loaded \u2014 using HTTP poll only" });
+        return;
+      }
+      if (this._socket) {
+        this._socket.removeAllListeners();
+        this._socket.disconnect();
+      }
+      this._socket = io(this._baseUrl, {
+        query: {
+          pairing: this._pairingCode,
+          role: this.config.role,
+          deviceName: this.config.deviceName
+        },
+        transports: ["websocket", "polling"],
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 1e3,
+        reconnectionDelayMax: 5e3,
+        timeout: 2e4
+      });
+      this._socket.on("connect", () => {
+        this._setStatus("connected");
+        this._pollTransactions();
+        this._pollNotifications();
+        this._refreshDashboard();
+      });
+      this._socket.on("disconnect", () => this._setStatus("reconnecting"));
+      this._socket.on("connect_error", () => this._setStatus("reconnecting"));
+      this._socket.io.on("reconnect", () => {
+        this._pollTransactions();
+        this._pollNotifications();
+        this._refreshDashboard();
+      });
+      this._socket.on("sync_ready", (data) => {
+        this._emit(EVENTS.READY, data);
+        this._pollTransactions();
+        this._pollNotifications();
+        this._refreshDashboard();
+      });
+      this._socket.on("presence", (data) => {
+        this.presence = data;
+        if (Array.isArray(data.devices)) this._mergeDevices(data.devices);
+        this._emit(EVENTS.PRESENCE, data);
+        this._emit(EVENTS.DEVICES, this.getDevices());
+      });
+      this._socket.on("device_joined", (d) => {
+        this._upsertDevice(d);
+        this._emit(EVENTS.DEVICES, this.getDevices());
+      });
+      this._socket.on("device_updated", (d) => {
+        this._upsertDevice(d);
+        this._emit(EVENTS.DEVICES, this.getDevices());
+      });
+      this._socket.on("device_left", ({ id }) => {
+        this.devices.delete(id);
+        this._emit(EVENTS.DEVICES, this.getDevices());
+      });
+      this._socket.on("history", (list) => this._mergeTxList(list));
+      this._socket.on("notification_history", (list) => this._mergeNoteList(list));
+      this._socket.on("income_transaction", (tx) => {
+        if (this._addTransaction(tx)) this._emit(EVENTS.TRANSACTION, tx);
+      });
+      this._socket.on("notification_event", (note) => {
+        if (this._addNotification(note)) this._emit(EVENTS.NOTIFICATION, note);
+      });
+      this._socket.on("dashboard_update", (payload) => {
+        this.dashboard = payload;
+        this._emit(EVENTS.DASHBOARD, payload);
+      });
+    }
+    _startPollers() {
+      this._stopPollers();
+      const ms = this.config.pollIntervalMs;
+      this._pollTransactions();
+      this._pollNotifications();
+      this._refreshDashboard();
+      this._pollTimers.push(setInterval(() => this._pollTransactions(), ms));
+      this._pollTimers.push(setInterval(() => this._pollNotifications(), ms));
+      this._pollTimers.push(setInterval(() => this._refreshDashboard(), ms * 2));
+    }
+    _stopPollers() {
+      for (const t of this._pollTimers) clearInterval(t);
+      this._pollTimers = [];
+    }
+    async _pollTransactions() {
+      try {
+        const extra = this._lastTxTime ? { after: this._lastTxTime } : {};
+        const data = await fetch(
+          `${this._baseUrl}/api/transactions${this._pairingQuery(extra)}`,
+          this._fetchOpts()
+        ).then((r) => r.json());
+        for (const tx of data.transactions || []) {
+          if (this._addTransaction(tx)) this._emit(EVENTS.TRANSACTION, tx);
+        }
+      } catch (_) {
+      }
+    }
+    async _pollNotifications() {
+      try {
+        const extra = this._lastNoteTime ? { after: this._lastNoteTime } : {};
+        const data = await fetch(
+          `${this._baseUrl}/api/notifications${this._pairingQuery(extra)}`,
+          this._fetchOpts()
+        ).then((r) => r.json());
+        for (const note of data.notifications || []) {
+          if (this._addNotification(note)) this._emit(EVENTS.NOTIFICATION, note);
+        }
+      } catch (_) {
+      }
+    }
+    async _refreshDashboard() {
+      try {
+        const data = await fetch(
+          `${this._baseUrl}/api/dashboard${this._pairingQuery()}`,
+          this._fetchOpts()
+        ).then((r) => r.json());
+        this.dashboard = data;
+        if (data.stats) {
+          this.presence = {
+            phones: data.stats.phones,
+            desktops: data.stats.desktops
+          };
+        }
+        this._emit(EVENTS.DASHBOARD, data);
+      } catch (_) {
+      }
+      try {
+        const data = await fetch(
+          `${this._baseUrl}/api/devices${this._pairingQuery()}`,
+          this._fetchOpts()
+        ).then((r) => r.json());
+        if (Array.isArray(data.devices)) {
+          this.devices.clear();
+          this._mergeDevices(data.devices);
+          this._emit(EVENTS.DEVICES, this.getDevices());
+        }
+      } catch (_) {
+      }
+    }
+    _addTransaction(tx) {
+      const key = txKey(tx);
+      if (this._seenTx.has(key)) return false;
+      this._seenTx.add(key);
+      const t = String(tx.receivedAt || tx.timestamp || "");
+      if (t && t > this._lastTxTime) this._lastTxTime = t;
+      this.transactions.unshift(tx);
+      while (this.transactions.length > this.config.maxItems) {
+        const removed = this.transactions.pop();
+        this._seenTx.delete(txKey(removed));
+      }
+      return true;
+    }
+    _mergeTxList(list) {
+      if (!Array.isArray(list)) return;
+      for (let i = list.length - 1; i >= 0; i -= 1) {
+        if (this._addTransaction(list[i])) this._emit(EVENTS.TRANSACTION, list[i]);
+      }
+    }
+    _addNotification(note) {
+      const key = noteKey(note);
+      if (this._seenNotes.has(key)) return false;
+      this._seenNotes.add(key);
+      const t = String(note.receivedAt || note.timestamp || "");
+      if (t && t > this._lastNoteTime) this._lastNoteTime = t;
+      this.notifications.unshift(note);
+      while (this.notifications.length > this.config.maxItems) {
+        const removed = this.notifications.pop();
+        this._seenNotes.delete(noteKey(removed));
+      }
+      return true;
+    }
+    _mergeNoteList(list) {
+      if (!Array.isArray(list)) return;
+      for (let i = list.length - 1; i >= 0; i -= 1) {
+        if (this._addNotification(list[i])) this._emit(EVENTS.NOTIFICATION, list[i]);
+      }
+    }
+    _upsertDevice(d) {
+      if (!d?.id) return;
+      this.devices.set(d.id, { ...this.devices.get(d.id), ...d, online: true });
+    }
+    _mergeDevices(list) {
+      for (const d of list) this._upsertDevice(d);
+    }
+    getDevices() {
+      return Array.from(this.devices.values());
+    }
+    get isConnected() {
+      return this._status === "connected";
+    }
+    get pairingCode() {
+      return this._pairingCode;
+    }
+    get serverUrl() {
+      return this._baseUrl;
+    }
+  };
+  function connect(options) {
+    return new ZyroConnection(options);
+  }
+  return __toCommonJS(browser_entry_exports);
+})();