@lunora/client 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/index.mjs

@@ -1,15 +1,15 @@
 export { createAsyncStoragePersistence } from './packem_shared/createAsyncStoragePersistence-1Z5BZ8RC.mjs';
 export { default as createInMemoryBookmarkStorage } from './packem_shared/createInMemoryBookmarkStorage-BoN7a7TH.mjs';
-export { createClientQuery } from './packem_shared/createClientQuery-CQ51bWAE.mjs';
-export { TabCoordinator } from './packem_shared/TabCoordinator-BwRR8H06.mjs';
+export { createClientQuery } from './packem_shared/createClientQuery-dJZg1ohm.mjs';
+export { TabCoordinator } from './packem_shared/TabCoordinator-D_5oNTTt.mjs';
 export { applyDelta, isMutationDelta } from './packem_shared/applyDelta-CRKZ1PBt.mjs';
 export { CONFLICT_ERROR_CODE, getErrorCode, getRetryAfterMs, isConflictError, isForbiddenError, isRateLimitedError, isUnauthorizedError } from './packem_shared/CONFLICT_ERROR_CODE-B8gQ8tyU.mjs';
-export { httpStream } from './packem_shared/httpStream-BJU-aflc.mjs';
+export { httpStream } from './packem_shared/httpStream-DIdL8NEw.mjs';
 export { c as createLocalStore } from './packem_shared/local-store-DIq-UWfD.mjs';
-export { LunoraClient } from './packem_shared/LunoraClient-BBCQjjbl.mjs';
+export { LunoraClient } from './packem_shared/LunoraClient-D3h4P7hg.mjs';
 export { createMutationRunner } from './packem_shared/createMutationRunner-BqsavzvG.mjs';
 export { createMutatorRunner } from './packem_shared/createMutatorRunner-BETvCd0p.mjs';
-export { O as OfflineQueue } from './packem_shared/offline-queue-CF4_Co5k.mjs';
+export { O as OfflineQueue } from './packem_shared/offline-queue-N-1JvYb4.mjs';
 export { createInMemoryPersistence, createIndexedDbPersistence } from './packem_shared/createInMemoryPersistence-DZ2VHWgm.mjs';
 export { preloadQuery, preloadedQueryResult } from './packem_shared/preloadQuery-lobFkD2Z.mjs';
 export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey } from './packem_shared/createInMemoryQueryCache-DiaGZkA2.mjs';

package/dist/packem_shared/{LunoraClient-BBCQjjbl.mjs → LunoraClient-D3h4P7hg.mjs}

@@ -1,12 +1,12 @@
 import { LunoraError } from '@lunora/errors';
 import { s as stableWireKey, d as decodeWire, e as encodeWire } from './wire-key-Djie6aaR.mjs';
 import createInMemoryBookmarkStorage from './createInMemoryBookmarkStorage-BoN7a7TH.mjs';
-import { ClientQueryStore } from './createClientQuery-CQ51bWAE.mjs';
-import { TabCoordinator } from './TabCoordinator-BwRR8H06.mjs';
+import { ClientQueryStore } from './createClientQuery-dJZg1ohm.mjs';
+import { TabCoordinator } from './TabCoordinator-D_5oNTTt.mjs';
 import { isMutationDelta, applyDelta } from './applyDelta-CRKZ1PBt.mjs';
-import { httpStream } from './httpStream-BJU-aflc.mjs';
+import { httpStream } from './httpStream-DIdL8NEw.mjs';
 import { f as foldOptimistic, a as applyOptimisticLayer, d as dropConfirmedLayers, n as notifySubscription, c as createLocalStore } from './local-store-DIq-UWfD.mjs';
-import { O as OfflineQueue, n as nextId, i as isStaleVersion, r as reportPersistenceError } from './offline-queue-CF4_Co5k.mjs';
+import { O as OfflineQueue, n as nextId, i as isStaleVersion, r as reportPersistenceError } from './offline-queue-N-1JvYb4.mjs';
 import { resolvePersistenceAdapter } from './createInMemoryPersistence-DZ2VHWgm.mjs';
 import { resolveQueryCacheAdapter, queryCacheKey } from './createInMemoryQueryCache-DiaGZkA2.mjs';
 import { createReconnect } from './createReconnect-Di_-oHH7.mjs';
@@ -888,6 +888,20 @@ class LunoraClient {
   onMutationSettled(listener) {
     return this.mutationSettledListeners.add(listener);
   }
+  /**
+   * The `WebSocket` implementation this client was constructed with (an
+   * explicit `options.WebSocket`, or the ambient global on platforms that have
+   * one) — `undefined` if neither is available. This is the seam a feature
+   * that opens its OWN socket outside the client's multiplexed connection
+   * (e.g. a voice-agent hook) should default to, instead of reaching for
+   * `globalThis.WebSocket` directly: on React Native the client wraps this
+   * constructor to inject the auth-headers factory's credential onto the
+   * upgrade request (`createLunoraClient`'s `withAuthWebSocket`), which a raw
+   * `new globalThis.WebSocket(url)` would silently bypass.
+   */
+  getWebSocketImpl() {
+    return this.WebSocketImpl;
+  }
   // --- Client Query (local state) ----------------------------------------
   /**
    * Read the current value for a {@link ClientQueryRef}. Returns

package/dist/packem_shared/{OfflineQueue-B4HUF7rt.mjs → OfflineQueue-BgarnAub.mjs}

@@ -1 +1 @@
-export { O as OfflineQueue, n as nextId, r as reportPersistenceError } from './offline-queue-CF4_Co5k.mjs';
+export { O as OfflineQueue, n as nextId, r as reportPersistenceError } from './offline-queue-N-1JvYb4.mjs';

package/dist/packem_shared/{TabCoordinator-BwRR8H06.mjs → TabCoordinator-D_5oNTTt.mjs}

@@ -142,21 +142,11 @@ class TabCoordinator {
   handleMessage(message) {
     switch (message.type) {
       case "claim-leadership": {
-        if (message.tabId === this.tabId) {
-          break;
-        }
-        if (this.leader) {
-          this.broadcast({ type: "heartbeat", tabId: this.tabId, ts: Date.now() });
-          break;
-        }
-        if (this.knownLeader === void 0 && message.tabId < this.tabId) {
-          this.knownLeader = message.tabId;
-        }
+        this.handleClaimLeadership(message);
         break;
       }
       case "heartbeat": {
-        this.lastHeartbeat = message.ts;
-        this.knownLeader = message.tabId;
+        this.handleHeartbeat(message);
         break;
       }
       case "subscription-data": {
@@ -181,6 +171,52 @@ class TabCoordinator {
       }
     }
   }
+  handleClaimLeadership(message) {
+    if (message.tabId === this.tabId) {
+      return;
+    }
+    if (this.leader) {
+      this.broadcast({ type: "heartbeat", tabId: this.tabId, ts: Date.now() });
+      return;
+    }
+    if (this.knownLeader === void 0 && message.tabId < this.tabId) {
+      this.knownLeader = message.tabId;
+      this.lastHeartbeat = message.ts;
+    }
+  }
+  handleHeartbeat(message) {
+    if (message.tabId === this.tabId) {
+      return;
+    }
+    if (this.leader) {
+      this.resolveLeaderVsLeaderTieBreak(message);
+      return;
+    }
+    this.lastHeartbeat = message.ts;
+    this.knownLeader = message.tabId;
+  }
+  /**
+   * Resolve two leaders existing at once — e.g. this tab was backgrounded
+   * and its heartbeat/health timers were throttled while a foreground
+   * follower's were not, so the follower's `checkLeaderHealth` timed out
+   * the (still-alive) leader and self-promoted. `BroadcastChannel` message
+   * delivery isn't subject to the same timer-throttling clamp, so even a
+   * backgrounded leader eventually observes the pretender's heartbeat here
+   * — resolve the split-brain deterministically with the same
+   * lexicographically-smaller-tabId rule used at claim-adoption. If the
+   * other tab wins, step down; if we win, reassert immediately so the
+   * pretender demotes itself the moment it processes our heartbeat.
+   */
+  resolveLeaderVsLeaderTieBreak(message) {
+    if (message.tabId < this.tabId) {
+      this.leader = false;
+      this.knownLeader = message.tabId;
+      this.lastHeartbeat = message.ts;
+      this.onStopBeingLeader?.();
+    } else {
+      this.broadcast({ type: "heartbeat", tabId: this.tabId, ts: Date.now() });
+    }
+  }
   becomeLeader() {
     if (this.leader) {
       return;

package/dist/packem_shared/{createClientQuery-CQ51bWAE.mjs → createClientQuery-dJZg1ohm.mjs}

@@ -16,11 +16,16 @@ class ClientQueryStore {
   }
   /**
    * Set a new value for `ref` and notify every subscriber. Pass `undefined`
-   * to reset the slot to `ref.defaultValue`.
+   * to reset the slot to `ref.defaultValue` — delegates to {@link reset} so
+   * `get` reports the default rather than a stored `undefined`.
    */
   set(ref, value) {
+    if (value === void 0) {
+      this.reset(ref);
+      return;
+    }
     this.values.set(ref.key, value);
-    this.notify(ref.key);
+    this.notify(ref.key, value);
   }
   /**
    * Delete the stored value for `ref`, resetting to `ref.defaultValue` and
@@ -28,7 +33,7 @@ class ClientQueryStore {
    */
   reset(ref) {
     this.values.delete(ref.key);
-    this.notify(ref.key);
+    this.notify(ref.key, ref.defaultValue);
   }
   /**
    * Subscribe to changes for `ref`. The callback is NOT invoked on
@@ -49,13 +54,17 @@ class ClientQueryStore {
       }
     };
   }
-  /** Notify every subscriber of a value change for the given key. */
-  notify(key) {
+  /**
+   * Notify every subscriber of a value change for the given key with the
+   * resolved value — the caller passes the just-stored value on `set` or
+   * `ref.defaultValue` on `reset`, so a subscriber always sees the same value
+   * {@link get} would return (never a stale re-read after the store mutation).
+   */
+  notify(key, value) {
     const subs = this.subscribers.get(key);
     if (!subs) {
       return;
     }
-    const value = this.values.get(key);
     for (const callback of subs) {
       try {
         callback(value);

package/dist/packem_shared/{createServerClient-CTTAmvMx.mjs → createServerClient-DzeC2J3A.mjs}

@@ -1,4 +1,4 @@
-import { LunoraClient } from './LunoraClient-BBCQjjbl.mjs';
+import { LunoraClient } from './LunoraClient-D3h4P7hg.mjs';
 
 const createServerClient = (options) => {
   const client = new LunoraClient({ fetch: options.fetch, url: options.url });

package/dist/packem_shared/{httpStream-BJU-aflc.mjs → httpStream-DIdL8NEw.mjs}

@@ -104,19 +104,22 @@ const httpStream = (route, args, options = {}) => {
   }
   const url = buildHttpStreamUrl(route, args ?? {}, options.baseUrl ?? "");
   const ac = new AbortController();
+  let onExternalAbort;
   if (options.signal) {
     if (options.signal.aborted) {
       ac.abort();
     } else {
-      options.signal.addEventListener(
-        "abort",
-        () => {
-          ac.abort();
-        },
-        { once: true }
-      );
+      onExternalAbort = () => {
+        ac.abort();
+      };
+      options.signal.addEventListener("abort", onExternalAbort, { once: true });
     }
   }
+  const detachExternalAbort = () => {
+    if (onExternalAbort) {
+      options.signal?.removeEventListener("abort", onExternalAbort);
+    }
+  };
   const { handle, iterable } = createStream({
     maxBuffer: options.maxBuffer,
     onCancel: () => {
@@ -124,24 +127,30 @@ const httpStream = (route, args, options = {}) => {
     }
   });
   (async () => {
-    const response = await fetchImpl(url, {
-      headers: { accept: "text/event-stream", ...options.headers },
-      method: route.method,
-      signal: ac.signal
-    });
-    if (!response.ok) {
-      handle.fail(
-        new LunoraError("HTTP_STREAM_STATUS", `httpStream: request failed (status ${response.status.toString()})`, {
-          status: response.status
-        })
-      );
-      return;
-    }
-    if (!response.body) {
-      handle.fail(new LunoraError("HTTP_STREAM_NO_BODY", "httpStream: response has no body"));
-      return;
+    try {
+      const response = await fetchImpl(url, {
+        headers: { accept: "text/event-stream", ...options.headers },
+        method: route.method,
+        signal: ac.signal
+      });
+      if (!response.ok) {
+        await response.body?.cancel().catch(() => {
+        });
+        handle.fail(
+          new LunoraError("HTTP_STREAM_STATUS", `httpStream: request failed (status ${response.status.toString()})`, {
+            status: response.status
+          })
+        );
+        return;
+      }
+      if (!response.body) {
+        handle.fail(new LunoraError("HTTP_STREAM_NO_BODY", "httpStream: response has no body"));
+        return;
+      }
+      await pumpSseBody(response.body, handle);
+    } finally {
+      detachExternalAbort();
     }
-    await pumpSseBody(response.body, handle);
   })().catch((error) => {
     if (ac.signal.aborted) {
       handle.complete();