versacall-core-library-react 2.0.75 → 2.0.76-dev

package/dist/context/Channels/ChannelsProvider.js

@@ -11,15 +11,31 @@ var _withCore = _interopRequireDefault(require("../Core/withCore"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const namespace = 'ChannelsProvider';
-const emitter = require('emitter-io');
+
+// ─── Module-level singletons (one set per iframe / JS module scope) ──────────
+//
+// These are intentionally module-scoped so that multiple ChannelsProvider
+// instances within the same iframe bundle share a single set of state — the
+// same as the original design.
+//
+// Cross-iframe deduplication is handled by the SharedWorker: because all
+// iframes load the same bundle, `new URL(...)` resolves to the same hashed
+// URL and the browser routes every new SharedWorker(url) call to the same
+// running worker thread.
+
 const channelTimeoutHandlers = [];
 const channelInformation = [];
 const channelFunctions = [];
 const handlers = [];
 const connectionChangedHandlers = [];
 const subscribingHandlers = [];
-let client;
-let clientInitialized = false; // ✅ NEW: Track if client is initialized
+
+/** The MessagePort connected to the SharedWorker.  Null until first init. */
+let workerPort = null;
+/** Guard: set to true once the worker port has been opened for this iframe. */
+let clientInitialized = false;
+
+// ─── Shared utility functions (identical to original) ────────────────────────
 
 function compareChannelInfo(ci1, ci2) {
   if (ci1 !== null) {
@@ -50,9 +66,9 @@ const registerHandlers = (id, handler, connectionChanged, subscribing) => {
     });
   }
   if (connectionChanged) {
-    const existingConnectionChanged = connectionChangedHandlers.find(x => x.id === id);
-    if (existingConnectionChanged !== undefined) {
-      existingConnectionChanged.handler = connectionChanged;
+    const existingCC = connectionChangedHandlers.find(x => x.id === id);
+    if (existingCC !== undefined) {
+      existingCC.handler = connectionChanged;
     } else {
       connectionChangedHandlers.push({
         id: id,
@@ -61,9 +77,9 @@ const registerHandlers = (id, handler, connectionChanged, subscribing) => {
     }
   }
   if (subscribing) {
-    const existingSubscribing = subscribingHandlers.find(x => x.id === id);
-    if (existingSubscribing !== undefined) {
-      existingSubscribing.handler = subscribing;
+    const existingSub = subscribingHandlers.find(x => x.id === id);
+    if (existingSub !== undefined) {
+      existingSub.handler = subscribing;
     } else {
       subscribingHandlers.push({
         id: id,
@@ -77,13 +93,13 @@ const unregisterHandlers = id => {
   if (existing !== undefined) {
     handlers.splice(handlers.indexOf(existing), 1);
   }
-  const existingConnectionChanged = connectionChangedHandlers.find(x => x.id === id);
-  if (existingConnectionChanged !== undefined) {
-    connectionChangedHandlers.splice(connectionChangedHandlers.indexOf(existingConnectionChanged), 1);
+  const existingCC = connectionChangedHandlers.find(x => x.id === id);
+  if (existingCC !== undefined) {
+    connectionChangedHandlers.splice(connectionChangedHandlers.indexOf(existingCC), 1);
   }
-  const existingSubscribing = subscribingHandlers.find(x => x.id === id);
-  if (existingSubscribing !== undefined) {
-    subscribingHandlers.splice(subscribingHandlers.indexOf(existingSubscribing), 1);
+  const existingSub = subscribingHandlers.find(x => x.id === id);
+  if (existingSub !== undefined) {
+    subscribingHandlers.splice(subscribingHandlers.indexOf(existingSub), 1);
   }
 };
 const registerChannel = (id, channelFunction) => {
@@ -97,10 +113,7 @@ const registerChannel = (id, channelFunction) => {
     });
   }
 };
-const isChannelRegistered = id => {
-  const existing = channelFunctions.find(x => x.id === id);
-  return existing !== undefined;
-};
+const isChannelRegistered = id => channelFunctions.find(x => x.id === id) !== undefined;
 const clearTimeoutHandler = id => {
   const existing = channelTimeoutHandlers.find(x => x.id === id);
   if (existing !== undefined) {
@@ -123,47 +136,99 @@ const notifySubscribing = channel => {
     x.handler(channel);
   });
 };
+
+// ─── Worker initialisation ───────────────────────────────────────────────────
+
+/**
+ * Open a MessagePort to the SharedWorker and wire up the inbound message
+ * handler.  Safe to call multiple times — a module-level guard ensures the
+ * work only happens once per iframe.
+ *
+ * The SharedWorker URL is resolved by webpack 5 at build time via
+ * `new URL(relPath, import.meta.url)`, which produces a stable content-hashed
+ * URL.  Because every iframe loads the same bundle, they all resolve to the
+ * identical URL → the browser routes them all to the same running worker.
+ *
+ * @param {string}   host      Hostname / IP (no protocol, no port).
+ * @param {boolean}  secure    true → wss, false → ws.
+ * @param {Function} log       props.core.log bound to the core instance.
+ */
+function initWorkerPort(host, secure, log) {
+  if (clientInitialized) return;
+
+  // `new URL('./versacall-channels.worker.js', import.meta.url)` requires
+  // webpack 5 (react-scripts ≥ 5) or Vite.  If your build toolchain is older,
+  // replace this with a hardcoded absolute path, e.g.:
+  //   new SharedWorker('/versacall-channels.worker.js', { name: 'versacall-channels' })
+  // and serve the worker file from the app's public folder.
+  const worker = new SharedWorker('/ChannelsWorker.js', {
+    name: 'versacall-channels'
+  });
+  workerPort = worker.port;
+
+  // Inbound messages from the worker
+  workerPort.onmessage = ev => {
+    const {
+      type
+    } = ev.data;
+    if (type === 'MESSAGE') {
+      // ev.data.channel is the raw MQTT topic "{channelKey}/{channelName}/"
+      // — identical to what emitter-io exposed as msg.channel.
+      processMessage(ev.data.channel, ev.data.data);
+    } else if (type === 'CONNECTION_CHANGED') {
+      log('system', namespace, 'workerPort.onmessage', ev.data.connected ? 'Emitter Connect' : 'Emitter Disconnect');
+      notifyConnectionChanged(ev.data.connected);
+    }
+  };
+  workerPort.onmessageerror = err => {
+    log('error', namespace, 'workerPort.onmessageerror', err);
+  };
+
+  // start() is required for MessagePort when the event listener is assigned
+  // via the property (not addEventListener).
+  workerPort.start();
+
+  // Tell the worker our connection parameters.  If another iframe already
+  // sent INIT, the worker will skip reconnecting and reply with the current
+  // connection state instead.
+  workerPort.postMessage({
+    type: 'INIT',
+    host: host,
+    port: 9090,
+    secure: secure
+  });
+  clientInitialized = true;
+  log('system', namespace, 'initWorkerPort()', 'SharedWorker port opened (Singleton)');
+}
+
+// ─── Component ───────────────────────────────────────────────────────────────
+
 class ChannelsProvider extends _react.Component {
   constructor(props) {
     const methodName = 'constructor()';
     super(props);
-
-    // ✅ FIXED: Check if props are ready before initializing
     if (!clientInitialized) {
       if (!props.core || !props.core.baseUrl) {
-        // Props not ready yet, will retry on next instance
-        console.log('ChannelsProvider: Core props not ready, deferring client initialization');
+        // Core context not ready yet — another ChannelsProvider instance will
+        // complete the init once props are available.
+        console.log('ChannelsProvider: Core props not ready, deferring SharedWorker init');
         return;
       }
       const urlArray = props.core.baseUrl.split('://');
       const protocol = urlArray[0];
-      const modifiedUrl = urlArray[urlArray.length - 1];
+      const host = urlArray[urlArray.length - 1];
       const isSecure = protocol === 'https';
-      client = emitter.connect({
-        host: modifiedUrl,
-        port: 9090,
-        secure: isSecure
-      });
-      client.on('disconnect', () => {
-        props.core.log('system', namespace, methodName, 'Emitter Disconnect');
-        notifyConnectionChanged(false);
-      });
-      client.on('offline', () => {
-        props.core.log('system', namespace, methodName, 'Emitter Offline');
-        notifyConnectionChanged(false);
-      });
-      client.on('message', msg => {
-        processMessage(msg.channel, JSON.parse(msg.asString()));
-      });
-      client.on('error', error => {
-        props.core.log('error', namespace, methodName, error);
-      });
-      clientInitialized = true;
-      props.core.log('system', namespace, methodName, 'Emitter Connect (Singleton)');
-    } else if (props.core && props.core.baseUrl) {
-      props.core.log('system', namespace, methodName, 'Reusing existing Emitter connection');
+
+      // Bind log so it can be called without a `this` context inside the
+      // module-level initWorkerPort function.
+      initWorkerPort(host, isSecure, props.core.log.bind(props.core));
+    } else if (props.core && props.core.log) {
+      props.core.log('system', namespace, methodName, 'Reusing existing SharedWorker connection');
     }
   }
+
+  // ── Channel update / subscription lifecycle (unchanged) ──────────────────
+
   updateChannel(id, data) {
     const existing = channelTimeoutHandlers.find(x => x.id === id);
     if (existing !== undefined) {
@@ -211,25 +276,48 @@ class ChannelsProvider extends _react.Component {
       });
     }
   }
+
+  /**
+   * Tell the SharedWorker to subscribe to an emitter channel.
+   * The HTTP call that fetches {channelKey, channelName} still happens here in
+   * ChannelsProvider (via callChannelFunction / registerChannel) — only the
+   * actual WebSocket transport has moved to the worker.
+   */
   subscribe(channelInfo) {
     const methodName = 'subscribe()';
     this.props.core.log('system', namespace, methodName, "Subscribing to ".concat(channelInfo.channelName));
-    client.subscribe({
-      key: channelInfo.channelKey,
-      channel: channelInfo.channelName
-    });
+    if (workerPort) {
+      workerPort.postMessage({
+        type: 'SUBSCRIBE',
+        channelKey: channelInfo.channelKey,
+        channelName: channelInfo.channelName
+      });
+    }
     notifySubscribing(channelInfo.channelName);
   }
+
+  /** Tell the SharedWorker to unsubscribe from an emitter channel. */
   unsubscribe(channelInfo) {
     const methodName = 'unsubscribe()';
     this.props.core.log('system', namespace, methodName, "Unsubscribing from ".concat(channelInfo.channelName));
-    client.unsubscribe({
-      key: channelInfo.channelKey,
-      channel: channelInfo.channelName
-    });
+    if (workerPort) {
+      workerPort.postMessage({
+        type: 'UNSUBSCRIBE',
+        channelKey: channelInfo.channelKey,
+        channelName: channelInfo.channelName
+      });
+    }
   }
+
+  /**
+   * Re-issue subscribe calls for every channel currently tracked in
+   * channelInformation.  The SharedWorker already replays all active
+   * subscriptions after a reconnect (fixing the latent bug in the original
+   * code), so this method is kept for API compatibility but is no longer
+   * needed for reconnect recovery.
+   */
   resubscribeToChannels() {
-    channelInformation.forEach((item, i) => {
+    channelInformation.forEach(item => {
       this.subscribe(item.channelInfo);
     });
   }

package/dist/context/Channels/ChannelsWorker.js

@@ -0,0 +1,419 @@
+/* eslint-disable */
+'use strict';
+
+/**
+ * versacall-channels.worker.js
+ * SharedWorker — owns a single MQTT-over-WebSocket connection to the emitter
+ * server.  All iframes in the same origin connect here via MessagePort and
+ * share one WebSocket instead of opening one each.
+ *
+ * Wire protocol  (ChannelsProvider → Worker):
+ *   { type: 'INIT',        host, port, secure }
+ *   { type: 'SUBSCRIBE',   channelKey, channelName }
+ *   { type: 'UNSUBSCRIBE', channelKey, channelName }
+ *
+ * Wire protocol  (Worker → ChannelsProvider port):
+ *   { type: 'MESSAGE',            channel, data }
+ *   { type: 'CONNECTION_CHANGED', connected }
+ *
+ * Topic format matches emitter-io:  "{channelKey}/{channelName}/"
+ *
+ * No external dependencies — implements the minimal MQTT 3.1.1 subset needed:
+ *   TX: CONNECT, SUBSCRIBE, UNSUBSCRIBE, PINGREQ
+ *   RX: CONNACK, PUBLISH, SUBACK, UNSUBACK, PINGRESP
+ */
+
+// ─── Global state ────────────────────────────────────────────────────────────
+
+/** @type {Set<MessagePort>} */
+const ports = new Set();
+let ws = null; // current WebSocket
+let wsConfig = null; // { host, port, secure } — set once on first INIT
+let mqttConnected = false; // true after CONNACK(0) received
+let pingIntervalId = null;
+let reconnectTimerId = null;
+let receiveBuffer = new Uint8Array(0);
+let packetIdCounter = 0;
+
+/**
+ * topic string → { channelKey, channelName }
+ * Maintained across reconnects so we can resubscribe automatically.
+ */
+const activeSubscriptions = new Map();
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function nextPacketId() {
+  if (++packetIdCounter > 65535) packetIdCounter = 1;
+  return packetIdCounter;
+}
+
+/** Concatenate two Uint8Arrays */
+function concat(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+
+// ─── MQTT encoding ───────────────────────────────────────────────────────────
+
+/**
+ * Encode a UTF-8 string as MQTT length-prefixed bytes (2-byte big-endian len).
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+function mqttStr(str) {
+  const bytes = textEncoder.encode(str);
+  const out = new Uint8Array(2 + bytes.length);
+  out[0] = bytes.length >> 8 & 0xff;
+  out[1] = bytes.length & 0xff;
+  out.set(bytes, 2);
+  return out;
+}
+
+/**
+ * Encode n as an MQTT variable-length integer (1–4 bytes).
+ * @param {number} n
+ * @returns {Uint8Array}
+ */
+function mqttVarInt(n) {
+  const bytes = [];
+  do {
+    let b = n & 0x7f;
+    n >>>= 7;
+    if (n > 0) b |= 0x80;
+    bytes.push(b);
+  } while (n > 0);
+  return new Uint8Array(bytes);
+}
+
+/**
+ * Build a complete MQTT packet.
+ * @param {number}        firstByte   Fixed-header first byte (type + flags).
+ * @param {...Uint8Array} parts       Variable-header + payload parts in order.
+ * @returns {Uint8Array}
+ */
+function mqttPacket(firstByte) {
+  let remaining = 0;
+  for (var _len = arguments.length, parts = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    parts[_key - 1] = arguments[_key];
+  }
+  for (const p of parts) remaining += p.length;
+  const varLen = mqttVarInt(remaining);
+  const out = new Uint8Array(1 + varLen.length + remaining);
+  let off = 0;
+  out[off++] = firstByte;
+  out.set(varLen, off);
+  off += varLen.length;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+
+/** MQTT CONNECT packet (clean session, no credentials). */
+function buildConnect(clientId) {
+  // Protocol name "MQTT" as length-prefixed bytes
+  const protoName = new Uint8Array([0x00, 0x04, 0x4d, 0x51, 0x54, 0x54]);
+  const protoLevel = new Uint8Array([0x04]); // 3.1.1
+  const connFlags = new Uint8Array([0x02]); // clean session
+  const keepAlive = new Uint8Array([0x00, 0x1e]); // 30 seconds
+  return mqttPacket(0x10, protoName, protoLevel, connFlags, keepAlive, mqttStr(clientId));
+}
+
+/** MQTT SUBSCRIBE packet, QoS 0. */
+function buildSubscribe(packetId, topic) {
+  const id = new Uint8Array([packetId >> 8 & 0xff, packetId & 0xff]);
+  return mqttPacket(0x82, id, mqttStr(topic), new Uint8Array([0x00]));
+}
+
+/** MQTT UNSUBSCRIBE packet. */
+function buildUnsubscribe(packetId, topic) {
+  const id = new Uint8Array([packetId >> 8 & 0xff, packetId & 0xff]);
+  return mqttPacket(0xa2, id, mqttStr(topic));
+}
+const PINGREQ = new Uint8Array([0xc0, 0x00]);
+
+// ─── MQTT decoding ───────────────────────────────────────────────────────────
+
+/**
+ * Decode an MQTT variable-length integer starting at buffer[offset+1]
+ * (i.e. the byte after the fixed-header first byte).
+ * @returns {{ value: number, bytes: number } | null}  null if incomplete data
+ */
+function decodeVarInt(buf, offset) {
+  let value = 0,
+    mult = 1;
+  for (let i = 0; i < 4; i++) {
+    if (offset + i >= buf.length) return null; // need more data
+    const b = buf[offset + i];
+    value += (b & 0x7f) * mult;
+    mult *= 128;
+    if ((b & 0x80) === 0) return {
+      value,
+      bytes: i + 1
+    };
+  }
+  return null; // malformed
+}
+
+/**
+ * Drain receiveBuffer, dispatch any complete MQTT packets found.
+ * Leaves any trailing incomplete bytes in receiveBuffer.
+ */
+function drainBuffer() {
+  let offset = 0;
+  while (offset < receiveBuffer.length) {
+    const firstByte = receiveBuffer[offset];
+    const varInt = decodeVarInt(receiveBuffer, offset + 1);
+    if (!varInt) break; // need more data
+
+    const totalLen = 1 + varInt.bytes + varInt.value;
+    if (offset + totalLen > receiveBuffer.length) break; // packet incomplete
+
+    const packetType = firstByte >> 4 & 0x0f;
+    const headerFlags = firstByte & 0x0f;
+    const body = receiveBuffer.slice(offset + 1 + varInt.bytes, offset + totalLen);
+    dispatchMqttPacket(packetType, headerFlags, body);
+    offset += totalLen;
+  }
+  receiveBuffer = receiveBuffer.slice(offset);
+}
+
+/** Route a decoded MQTT packet to the appropriate handler. */
+function dispatchMqttPacket(type, flags, body) {
+  switch (type) {
+    case 2:
+      return onConnack(body);
+    // CONNACK
+    case 3:
+      return onPublish(flags, body);
+    // PUBLISH
+    // SUBACK(9), UNSUBACK(11), PINGRESP(13) — acknowledged, nothing to do
+  }
+}
+
+/**
+ * Handle CONNACK.  On success, mark connected and replay all active
+ * subscriptions — this is the fix for the latent resubscription-after-
+ * reconnect bug that existed in the original ChannelsProvider.
+ */
+function onConnack(body) {
+  // body[0] = session-present flag, body[1] = return code
+  if (body.length < 2 || body[1] !== 0) {
+    console.warn('[vc-worker] CONNACK error code:', body[1]);
+    return;
+  }
+  mqttConnected = true;
+  broadcast({
+    type: 'CONNECTION_CHANGED',
+    connected: true
+  });
+
+  // Resubscribe every channel the app has asked for.
+  // This handles both initial subscription after connect AND
+  // re-subscription after an unintended disconnect / reconnect.
+  activeSubscriptions.forEach((_, topic) => {
+    wsSend(buildSubscribe(nextPacketId(), topic));
+  });
+}
+
+/**
+ * Handle an incoming PUBLISH packet.
+ * The MQTT topic for emitter-io is:  "{channelKey}/{channelName}/"
+ * That same string is what emitter-io exposes as msg.channel, so we
+ * forward it unchanged — ChannelsConsumer handlers will match as before.
+ */
+function onPublish(flags, body) {
+  if (body.length < 2) return;
+  const topicLen = body[0] << 8 | body[1];
+  if (2 + topicLen > body.length) return;
+  const topic = textDecoder.decode(body.slice(2, 2 + topicLen));
+
+  // QoS > 0 means a 2-byte packet-id follows the topic
+  const qos = flags >> 1 & 0x03;
+  const payloadStart = 2 + topicLen + (qos > 0 ? 2 : 0);
+  const payloadStr = textDecoder.decode(body.slice(payloadStart));
+  let data;
+  try {
+    data = JSON.parse(payloadStr);
+  } catch (_) {
+    data = payloadStr;
+  }
+  broadcast({
+    type: 'MESSAGE',
+    channel: topic,
+    data
+  });
+}
+
+// ─── WebSocket management ────────────────────────────────────────────────────
+
+/** Send a Uint8Array over the WebSocket if it's open. */
+function wsSend(packet) {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(packet);
+  }
+}
+
+/**
+ * Open (or reopen) the WebSocket and perform an MQTT CONNECT.
+ * Any existing socket is closed first.
+ */
+function openWebSocket(config) {
+  // Tear down old socket cleanly
+  if (ws) {
+    ws.onopen = ws.onclose = ws.onerror = ws.onmessage = null;
+    try {
+      ws.close();
+    } catch (_) {/* ignore */}
+    ws = null;
+  }
+  clearInterval(pingIntervalId);
+  clearTimeout(reconnectTimerId);
+  const proto = config.secure ? 'wss' : 'ws';
+  const url = "".concat(proto, "://").concat(config.host, ":").concat(config.port);
+  ws = new WebSocket(url, 'mqtt');
+  ws.binaryType = 'arraybuffer';
+
+  // Each connection gets a fresh random client ID (emitter doesn't care about
+  // persistence between reconnects).
+  const clientId = 'vc_' + Math.random().toString(36).slice(2, 10);
+  ws.onopen = () => {
+    receiveBuffer = new Uint8Array(0); // reset frame reassembly buffer
+    wsSend(buildConnect(clientId));
+
+    // Keepalive: PINGREQ every 25 s (server keepalive is set to 30 s)
+    clearInterval(pingIntervalId);
+    pingIntervalId = setInterval(() => wsSend(PINGREQ), 25000);
+  };
+  ws.onmessage = ev => {
+    receiveBuffer = concat(receiveBuffer, new Uint8Array(ev.data));
+    drainBuffer();
+  };
+  ws.onclose = () => {
+    clearInterval(pingIntervalId);
+    if (mqttConnected) {
+      mqttConnected = false;
+      broadcast({
+        type: 'CONNECTION_CHANGED',
+        connected: false
+      });
+    }
+    // Reconnect after 3 s — forever, since the app may come back at any time.
+    reconnectTimerId = setTimeout(() => {
+      if (wsConfig) openWebSocket(wsConfig);
+    }, 3000);
+  };
+
+  // onerror always precedes onclose; logging only.
+  ws.onerror = err => {
+    console.warn('[vc-worker] WebSocket error:', err.message || err);
+  };
+}
+
+// ─── Port broadcast ──────────────────────────────────────────────────────────
+
+/**
+ * Send a message to every connected port.
+ * Dead ports (closed iframes) are removed on first failure.
+ */
+function broadcast(msg) {
+  for (const port of ports) {
+    try {
+      port.postMessage(msg);
+    } catch (_) {
+      ports.delete(port);
+    }
+  }
+}
+
+// ─── Incoming message handler ────────────────────────────────────────────────
+
+/**
+ * Handle a message arriving from one ChannelsProvider port.
+ * @param {MessagePort} port   The originating port (used for INIT replies).
+ * @param {{ type: string }} msg
+ */
+function handlePortMessage(port, msg) {
+  switch (msg.type) {
+    case 'INIT':
+      {
+        const config = {
+          host: msg.host,
+          port: msg.port,
+          secure: msg.secure
+        };
+        if (!wsConfig) {
+          // First INIT — record config and open the connection.
+          wsConfig = config;
+          openWebSocket(config);
+          port.postMessage({
+            type: 'LOG',
+            message: 'Worker: first INIT, opening WebSocket'
+          });
+        } else if (mqttConnected) {
+          // Subsequent INIT from a later iframe — we're already live.
+          // Immediately tell the new port so it can update connection-state UI.
+          port.postMessage({
+            type: 'CONNECTION_CHANGED',
+            connected: true
+          });
+          port.postMessage({
+            type: 'LOG',
+            message: 'Worker: subsequent INIT, reusing existing connection. Total ports: ' + ports.size
+          });
+        }
+        // If !mqttConnected and wsConfig is already set we're in the middle of
+        // connecting; the CONNACK broadcast will reach the new port once ready.
+        break;
+      }
+    case 'SUBSCRIBE':
+      {
+        // topic format matches emitter-io: "{channelKey}/{channelName}/"
+        const topic = "".concat(msg.channelKey, "/").concat(msg.channelName, "/");
+        activeSubscriptions.set(topic, {
+          channelKey: msg.channelKey,
+          channelName: msg.channelName
+        });
+        // Send SUBSCRIBE immediately if already connected; otherwise the topic
+        // will be replayed in onConnack() when the connection comes up.
+        if (mqttConnected) {
+          wsSend(buildSubscribe(nextPacketId(), topic));
+        }
+        break;
+      }
+    case 'UNSUBSCRIBE':
+      {
+        const topic = "".concat(msg.channelKey, "/").concat(msg.channelName, "/");
+        activeSubscriptions.delete(topic);
+        if (mqttConnected) {
+          wsSend(buildUnsubscribe(nextPacketId(), topic));
+        }
+        break;
+      }
+    default:
+      console.warn('[vc-worker] Unknown message type:', msg.type);
+  }
+}
+
+// ─── SharedWorker entry point ────────────────────────────────────────────────
+
+/**
+ * Called once for every new client context (iframe) that does
+ * `new SharedWorker(url)`.  Each gets its own MessagePort.
+ */
+self.onconnect = event => {
+  const port = event.ports[0];
+  ports.add(port);
+  port.onmessage = ev => handlePortMessage(port, ev.data);
+  port.onmessageerror = () => ports.delete(port);
+
+  // start() is required when the port was not started implicitly via
+  // addEventListener — calling it on an already-started port is harmless.
+  port.start();
+};

package/package.json

@@ -2,10 +2,10 @@
   "versacall": {
     "title": "Versacall Core Library React",
     "applicationType": "react-library",
-    "build": 75
+    "build": 76
   },
   "name": "versacall-core-library-react",
-  "version": "2.0.75",
+  "version": "2.0.76-dev",
   "description": "Versacall Core Library",
   "main": "dist/index.js",
   "module": "dist/index.js",