@muhkoo/connect 0.14.0-alpha.7 → 0.14.0-alpha.8

package/dist/workers/index.js

@@ -220,6 +220,32 @@ class Logger {
 // Export default instance for general use
 const log = new Logger('CONNECT', 'INFO', false);
 
+/**
+ * The SDK's process-global logger.
+ *
+ * Eight modules under `src/` read a bare `appLogger` off `globalThis` rather
+ * than importing one (`src/crypto/{KeyStore,DoubleRatchet,DoubleRatchetManager,
+ * Authenticator}.ts`, `src/core/Client.ts`,
+ * `src/core/namespaces/HostedAuth.ts`, `src/events/EventCore.ts`), so the
+ * binding has to exist before any of them runs, and the `declare global` below
+ * is what makes that typecheck.
+ *
+ * This module is the single place that bootstrap happens. It previously lived
+ * inline in three entry files — `src/browser/index.ts`, `src/workers/index.ts`,
+ * and `src/core/index.ts` (which `src/server/index.ts` picked up as an import
+ * side effect) — three copies that could drift.
+ *
+ * `??=` makes it idempotent, so importing it from several entries in one
+ * process is safe and the first writer wins.
+ *
+ * KNOWN HAZARD: package.json declares `"sideEffects": false`, which entitles a
+ * tree-shaker to drop a module imported purely for effect. The entries import
+ * this one for its `export`s as well, so it survives today — but the durable
+ * fix is to convert those eight bare reads into real imports of `appLogger`
+ * from here, which removes the reliance on a global entirely.
+ */
+(globalThis.appLogger ??= new Logger("connect", "ERROR"));
+
 /**
  * Byte conversion helpers usable in both Node and the browser.
  *
@@ -1600,26 +1626,56 @@ var EventCoreEvents;
  */
 class EventCore {
     static eventTarget = new EventTarget();
+    /**
+     * `event -> (caller's handler -> the wrapper actually registered on the
+     * EventTarget)`. Two levels because one event can have many listeners and
+     * {@link off} must remove exactly the wrapper it registered for that caller.
+     */
     static events = new Map();
     /**
      * @remarks Listen to an event.
      * @example EventCore.on('event', (e) =\> appLogger.debug(e));
      */
     static on(event, handler) {
-        if (!EventCore.events.has(event)) {
-            EventCore.events.set(event, handler);
-        }
-        EventCore.eventTarget.addEventListener(event, handler);
+        let handlers = EventCore.events.get(event);
+        if (!handlers) {
+            handlers = new Map();
+            EventCore.events.set(event, handlers);
+        }
+        // `addEventListener` ignores a duplicate (type, callback) pair; mirror
+        // that here so the bookkeeping can't drift from the EventTarget.
+        if (handlers.has(handler))
+            return;
+        // A throwing listener must not take down its siblings or escape to the
+        // host: Node's EventTarget surfaces an uncaught listener error as an
+        // `uncaughtException`, which terminates the process by default, and
+        // browsers fire `window.onerror`. Contain it and keep dispatching.
+        const wrapped = (e) => {
+            try {
+                handler(e);
+            }
+            catch (err) {
+                appLogger.error(`EventCore: listener for "${event}" threw`, err);
+            }
+        };
+        handlers.set(handler, wrapped);
+        EventCore.eventTarget.addEventListener(event, wrapped);
     }
     /**
      * @remarks Stop listening to an event.
      * @example EventCore.off('event', handler);
      */
     static off(event, handler) {
-        if (EventCore.events.has(event)) {
+        const handlers = EventCore.events.get(event);
+        const wrapped = handlers?.get(handler);
+        if (!handlers || !wrapped)
+            return;
+        EventCore.eventTarget.removeEventListener(event, wrapped);
+        handlers.delete(handler);
+        // Drop the event only once its LAST listener is gone, so the
+        // "no listeners" warning in `emit` stays truthful.
+        if (handlers.size === 0)
             EventCore.events.delete(event);
-        }
-        EventCore.eventTarget.removeEventListener(event, handler);
     }
     /**
      * @remarks Emit an event.
@@ -1628,7 +1684,6 @@ class EventCore {
     static emit(event, data) {
         if (!EventCore.events.has(event)) {
             appLogger.debug(`Warning: No listeners for event: ${event}`);
-            // appLogger.verbose(`Event data:`, data);
         }
         EventCore.eventTarget.dispatchEvent(new CustomEvent(event, { detail: data }));
     }
@@ -1887,7 +1942,7 @@ function isCipherFrame(frame) {
  *
  * Hands raw frame strings up (via the `MESSAGE` event) and accepts raw frame
  * strings down (via `send`). Anything frame-shape, encryption, or serialization
- * related belongs in the layer above (e.g. `Network` for client↔server
+ * related belongs in the layer above (e.g. `BroadcastChannel` for client↔server
  * encrypted pipes, `BroadcastChannel` for multi-peer E2E rooms).
  *
  * Responsibilities:
@@ -2199,7 +2254,7 @@ class WSTransport extends EventCore {
  *             anything else                 — passes through as `raw_frame`
  *                                              (the app decides what to do)
  *
- * **Event scoping.** Unlike `Network`, BroadcastChannel uses a per-instance
+ * **Event scoping.** BroadcastChannel uses a per-instance
  * `EventTarget`, so two channels (e.g. two rooms in the same app) don't
  * cross-contaminate each other's events.
  *
@@ -2491,6 +2546,14 @@ async function verifyGroth16(wasmInstance, memory, initialPFree, verificationKey
         const vk = unstringifyBigInts(verificationKey);
         const p = unstringifyBigInts(proof);
         const signals = unstringifyBigInts(publicSignals);
+        // ARITY. vk_x is computed as IC[0] + sum(IC[i+1] * signals[i]), so the
+        // number of public signals is not free — it must be exactly IC.length - 1.
+        // Without this check a caller can pass FEWER signals than the circuit
+        // declares: the loop below simply computes vk_x from fewer terms, which is a
+        // proof of a DIFFERENT statement, and it can verify as true. Passing more
+        // would read past the end of IC.
+        if (!Array.isArray(vk.IC) || signals.length !== vk.IC.length - 1)
+            return false;
         // Validate proof coordinates are within the base field
         if (!validateG1InField(p.pi_a))
             return false;
@@ -2663,8 +2726,5 @@ function alloc(u32, size) {
     return ptr;
 }
 
-const appLogger$1 = new Logger("connect", 'ERROR');
-globalThis.appLogger = appLogger$1;
-
 export { AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, BroadcastChannel, BroadcastChannelEvents, ChunkCipher, DoubleRatchet, EncryptedSession, EventCore, EventCoreEvents, KeyStore, Message, Message as MessageDefault, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, SerializeMessage, WSTransport, decorators, decryptAesGcm, deriveAesKeyFromPassphrase, deriveBitsHkdf, encryptAesGcm, getSubtle, initBn128Wasm, randomBytes, unwrapWithPassphrase, verifyGroth16, wrapWithPassphrase };
 //# sourceMappingURL=index.js.map