@lunora/client 1.0.0-alpha.20 → 1.0.0-alpha.22

package/dist/packem_shared/{LunoraClient-hrmLXEHd.mjs → LunoraClient-Clb118SU.mjs}

@@ -1,16 +1,46 @@
 import { LunoraError } from '@lunora/errors';
-import { S as SubscriptionRegistry, s as stableStringify } from './subscription-DoyO04-2.mjs';
+import { s as stableStringify } from './stable-key-wv6eP48B.mjs';
 import createInMemoryBookmarkStorage from './createInMemoryBookmarkStorage-BoN7a7TH.mjs';
-import { isMutationDelta, applyDelta } from './applyDelta-4jFGTPA3.mjs';
-import { a as applyOptimisticLayer, d as dropConfirmedLayers, n as notifySubscription, f as foldOptimistic, c as createLocalStore } from './local-store-BNgN3Dw3.mjs';
-import { O as OfflineQueue, n as nextId, i as isStaleVersion, r as reportPersistenceError } from './offline-queue-B9vfdSqp.mjs';
-import { resolvePersistenceAdapter } from './createInMemoryPersistence-Ds7z8n8d.mjs';
-import { resolveQueryCacheAdapter, queryCacheKey } from './createInMemoryQueryCache-iWtKPrid.mjs';
+import { ClientQueryStore } from './createClientQuery-CQ51bWAE.mjs';
+import { TabCoordinator } from './TabCoordinator-BwRR8H06.mjs';
+import { isMutationDelta, applyDelta } from './applyDelta-CRKZ1PBt.mjs';
+import { f as foldOptimistic, a as applyOptimisticLayer, d as dropConfirmedLayers, n as notifySubscription, c as createLocalStore } from './local-store-DtcIW4c0.mjs';
+import { O as OfflineQueue, n as nextId, i as isStaleVersion, r as reportPersistenceError } from './offline-queue-CF4_Co5k.mjs';
+import { resolvePersistenceAdapter } from './createInMemoryPersistence-DZ2VHWgm.mjs';
+import { resolveQueryCacheAdapter, queryCacheKey } from './createInMemoryQueryCache-DiaGZkA2.mjs';
 import { createReconnect } from './createReconnect-Di_-oHH7.mjs';
 import { createStream } from './DEFAULT_MAX_BUFFER-7hFnzNk9.mjs';
+import { SubscriptionRegistry } from './SubscriptionRegistry-D4jfIzZu.mjs';
 
 const MAX_BATCH_ENTRIES = 500;
 
+const evictOldestEntry = (map, capacity) => {
+  if (map.size < capacity) {
+    return;
+  }
+  const oldest = map.keys().next().value;
+  if (oldest !== void 0) {
+    map.delete(oldest);
+  }
+};
+
+const toBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+const fromBase64 = (base64) => {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.codePointAt(index) ?? 0;
+  }
+  return bytes;
+};
+
 const TAG = "$lunora.wire$";
 const MAX_DEPTH = 64;
 const MAX_BIGINT_DIGITS = 1024;
@@ -37,22 +67,6 @@ const ERROR_CTORS = {
   TypeError,
   URIError
 };
-const toBase64 = (bytes) => {
-  let binary = "";
-  const chunk = 32768;
-  for (let index = 0; index < bytes.length; index += chunk) {
-    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
-  }
-  return btoa(binary);
-};
-const fromBase64 = (base64) => {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.codePointAt(index) ?? 0;
-  }
-  return bytes;
-};
 const encodeWire = (value, depth = 0) => {
   if (depth > MAX_DEPTH) {
     throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
@@ -453,11 +467,25 @@ const demuxBatchResults = (rawResults, count) => {
   return slots.map((slot) => slot ?? { error: new Error("batch call returned no result"), ok: false });
 };
 const TRANSIENT_BATCH_ERROR_CODES = /* @__PURE__ */ new Set(["SHARD_ERROR", "SHARD_UNAVAILABLE"]);
+const RESOLVED_PROMISE = Promise.resolve();
 class LunoraClient {
   /** Hard cap on concurrently-buffered pokes — a backstop that reclaims buffers abandoned by a mid-poke disconnect (no `pokeEnd`). Far above any real concurrent-in-flight count. */
   static MAX_POKE_BUFFERS = 256;
+  /**
+   * Create a typed {@link ClientQueryRef}. Convenience wrapper around
+   * {@link createClientQuery} so you don't need a separate import.
+   * @example
+   * ```ts
+   * const sidebarOpen = LunoraClient.createClientQuery("sidebarOpen", true);
+   * ```
+   */
+  static createClientQuery(key, defaultValue) {
+    return { defaultValue, key };
+  }
   url;
   wsUrl;
+  /** Local reactive store for {@link ClientQueryRef} values — no server round-trip. Private; reach it via `getClientQuery` / `setClientQuery` / `subscribeClientQuery`. */
+  clientQueryStore;
   wsToken;
   /** Better-auth base path (trailing slash stripped) for the `get-session` lookup. */
   authBasePath;
@@ -478,6 +506,20 @@ class LunoraClient {
   outbox;
   /** Stable per-client id stamped onto every `OutboxMutation` (custom-mutator watermark). */
   clientId;
+  /**
+   * `true` when the constructor's hydration microtask has finished loading the
+   * durable read cache (Pillar 2) into `hydratedQueryCache`. Signals that
+   * the cache is ready for synchronous `peekHydratedQuery` reads.
+   */
+  readyResolved = false;
+  /** Resolvers for `whenReady()` — called once hydration completes. */
+  readyResolve;
+  /**
+   * Promise that resolves once the durable read cache has been loaded. When
+   * `hydrateOnStart` is not set or no query cache is configured, resolves
+   * immediately (the constructor creates an already-resolved promise).
+   */
+  readyPromise;
   /**
    * Highest custom-mutator watermark the server has echoed for this client,
    * keyed by shard bucket (`shardKey ?? ""`) since the DO tracks one
@@ -511,6 +553,12 @@ class LunoraClient {
   pendingCacheWrites = /* @__PURE__ */ new Map();
   cacheFlushTimer;
   subscriptions = new SubscriptionRegistry();
+  /**
+   * Cross-tab coordinator; created only when `crossTabSync: true`. When the
+   * client is not the elected leader, all WebSocket operations are skipped.
+   * Not `readonly` — `close()` clears it (mirrors `outboxLeaderRelease`).
+   */
+  tabCoordinator;
   /** One {@link ShardConnection} per shard key (keyed by `shardKey ?? ""`). */
   connections = /* @__PURE__ */ new Map();
   /** Default `connect`-envelope context applied to a shard with no explicit override. */
@@ -606,6 +654,59 @@ class LunoraClient {
     this.persistenceVersion = options.persistenceVersion;
     this.queryCache = resolveQueryCacheAdapter(options.queryCache);
     this.onPersistenceError = options.offlineQueue?.onPersistenceError;
+    this.clientQueryStore = new ClientQueryStore();
+    if (options.crossTabSync) {
+      this.tabCoordinator = new TabCoordinator({
+        onBecomeLeader: () => {
+          for (const state of this.subscriptions.all()) {
+            this.ensureSocket(state.shardKey);
+            this.sendSubscribeIfOpen(state);
+          }
+        },
+        onStopBeingLeader: () => {
+          for (const [key, conn] of this.connections) {
+            conn.socket?.close();
+            this.connections.delete(key);
+          }
+        },
+        onSubscriptionData: (key, data) => {
+          const state = this.subscriptions.get(key);
+          if (state) {
+            state.serverBase = data;
+            const folded = state.optimisticLayers.length === 0 ? data : foldOptimistic(data, state.optimisticLayers);
+            state.lastValue = folded;
+            for (const callback of state.callbacks) {
+              try {
+                callback(folded);
+              } catch {
+              }
+            }
+          }
+        },
+        onSubscriptionError: (key, error) => {
+          const state = this.subscriptions.get(key);
+          if (state) {
+            for (const callback of state.errorCallbacks) {
+              try {
+                callback(error);
+              } catch {
+              }
+            }
+          }
+        }
+      });
+      this.tabCoordinator.start();
+    } else {
+      this.tabCoordinator = void 0;
+    }
+    if (options.hydrateOnStart && this.queryCache) {
+      this.readyPromise = new Promise((resolve) => {
+        this.readyResolve = resolve;
+      });
+    } else {
+      this.readyResolved = true;
+      this.readyPromise = RESOLVED_PROMISE;
+    }
     this.offlineQueue = new OfflineQueue(options.offlineQueue, {
       onEvict: (entry, error) => {
         this.emitItemSettled(entry, "rejected", error);
@@ -625,7 +726,17 @@ class LunoraClient {
     }
     if (this.queryCache) {
       queueMicrotask(() => {
-        this.hydrateQueryCache().catch(() => void 0);
+        const hydration = async () => {
+          try {
+            await this.hydrateQueryCache();
+          } catch {
+          } finally {
+            this.readyResolved = true;
+            this.readyResolve?.();
+          }
+        };
+        hydration().catch(() => {
+        });
       });
     }
   }
@@ -998,6 +1109,135 @@ class LunoraClient {
   onMutationSettled(listener) {
     return this.mutationSettledListeners.add(listener);
   }
+  // --- Client Query (local state) ----------------------------------------
+  /**
+   * Read the current value for a {@link ClientQueryRef}. Returns
+   * `ref.defaultValue` when no value has been explicitly set.
+   */
+  getClientQuery(ref) {
+    return this.clientQueryStore.get(ref);
+  }
+  /**
+   * Set a new value for `ref` and notify every subscriber. Pass `undefined`
+   * to reset the slot to `ref.defaultValue`.
+   */
+  setClientQuery(ref, value) {
+    this.clientQueryStore.set(ref, value);
+  }
+  /**
+   * Subscribe to changes for `ref`. The callback is NOT invoked on
+   * registration — call {@link getClientQuery} for the current value.
+   * Returns an unsubscribe function.
+   */
+  subscribeClientQuery(ref, callback) {
+    return this.clientQueryStore.subscribe(ref, callback);
+  }
+  /**
+   * Reset a {@link ClientQueryRef} to its default value, notifying every
+   * subscriber. Equivalent to `setClientQuery(ref, ref.defaultValue)` but
+   * removes the stored entry so a future {@link getClientQuery} returns
+   * the default rather than an explicitly-set value.
+   */
+  resetClientQuery(ref) {
+    this.clientQueryStore.reset(ref);
+  }
+  /**
+   * Capture a snapshot of the current live query value at call time and
+   * produce a `() => boolean` precondition that compares it against the
+   * value at replay time (on queue drain / reconnect).
+   *
+   * When the precondition is checked it re-reads the query's current value
+   * via `peekActiveQueryValue`. If the value differs from what was
+   * captured at call time the precondition returns `false` and the offline
+   * mutation is dropped as stale.
+   *
+   * This is a method wrapper around `createSnapshotPrecondition` that
+   * binds the client instance for you — no need to pass `client` explicitly.
+   * @example
+   * ```ts
+   * client.mutation(api.todos.update, { id, text }, {
+   *   precondition: client.snapshotPrecondition(api.todos.list, { userId }),
+   * });
+   * ```
+   */
+  snapshotPrecondition(functionRef, args, shardKey) {
+    const snapshot = this.peekActiveQueryValue(functionRef.__lunoraRef, args, shardKey);
+    const snapshotKey = snapshot === void 0 ? void 0 : stableStringify(snapshot);
+    return () => {
+      const current = this.peekActiveQueryValue(functionRef.__lunoraRef, args, shardKey);
+      if (snapshotKey === void 0 && current === void 0) {
+        return true;
+      }
+      if (snapshotKey === void 0 || current === void 0) {
+        return false;
+      }
+      return stableStringify(current) === snapshotKey;
+    };
+  }
+  // --- Hydration helpers --------------------------------------------------
+  /**
+   * Resolves once the durable read cache has been loaded into memory. When
+   * `hydrateOnStart` is not configured or no query cache adapter is active,
+   * returns an already-resolved promise so callers can always await it
+   * unconditionally.
+   *
+   * Framework adapters (React, Vue, etc.) use this to gate the first
+   * (enabled) render of a live query behind hydration, so the user sees
+   * cached data instead of an undefined flash before the socket round-trip.
+   */
+  whenReady() {
+    return this.readyPromise;
+  }
+  /**
+   * Synchronously reports whether {@link whenReady} has already resolved (the
+   * durable read cache is loaded, or none is configured). Framework adapters
+   * read this to seed the hydration-gate state on the first render without
+   * awaiting, then subscribe via {@link whenReady} for the pending case.
+   */
+  get isReady() {
+    return this.readyResolved;
+  }
+  /**
+   * Synchronously peek at a value the durable read cache loaded for the given
+   * function path + args + shard key. Returns `undefined` when:
+   *
+   * - No query cache adapter is configured.
+   * - Hydration hasn't completed yet (race — await {@link whenReady} first).
+   * - The cached value's identity fingerprint doesn't match the current auth.
+   *
+   * Unlike the internal {@link takeHydratedCache}, this is a READ-ONLY peek:
+   * the cached entry stays in `hydratedQueryCache` so the subscription created
+   * later by {@link subscribe} consumes it normally.
+   */
+  peekHydratedQuery(functionPath, args, shardKey) {
+    if (!this.readyResolved) {
+      return void 0;
+    }
+    const argsKey = stableStringify(args);
+    const key = queryCacheKey(functionPath, argsKey, shardKey);
+    const entry = this.hydratedQueryCache.get(key);
+    if (entry === void 0) {
+      return void 0;
+    }
+    return entry.identity === this.identityFingerprint() ? entry.value : void 0;
+  }
+  /**
+   * Peek at the **current live value** of an active subscription, if one
+   * exists. Returns the subscription's `lastValue` (which includes any
+   * optimistic overlay) or `undefined` if no subscription is active for the
+   * given `(functionPath, args, shardKey)`.
+   *
+   * Unlike {@link peekHydratedQuery} (which reads from the durable read cache
+   * and is independent of active subscriptions), this method reflects the
+   * current in-memory state of an already-opened subscription — useful for
+   * offline mutation preconditions that need to snapshot the value at call time
+   * and compare it at replay time.
+   */
+  peekActiveQueryValue(functionPath, args, shardKey) {
+    const key = SubscriptionRegistry.key(functionPath, args, shardKey);
+    const state = this.subscriptions.get(key);
+    return state?.lastValue;
+  }
   // --- RPC ---------------------------------------------------------------
   async query(function_, args, options = {}) {
     if (this.closed) {
@@ -1095,7 +1335,15 @@ class LunoraClient {
     const shouldQueueOffline = this.WebSocketImpl !== void 0 && connectedGate;
     const midReconnect = wsState === "connecting" && connectedGate;
     if (wsState !== "open" && !hasSocket && shouldQueueOffline || midReconnect) {
-      return this.enqueueOfflineMutation(function_, argsRecord, options.shardKey, mutationId, optimisticRollbacks, optimisticConfirms);
+      return this.enqueueOfflineMutation(
+        function_,
+        argsRecord,
+        options.shardKey,
+        mutationId,
+        optimisticRollbacks,
+        optimisticConfirms,
+        options.precondition
+      );
     }
     try {
       let commitCursor;
@@ -2103,6 +2351,8 @@ class LunoraClient {
     this.whisperHandlers.clear();
     this.shapeSubscriptions.clear();
     this.pokeBuffers.clear();
+    this.tabCoordinator?.stop();
+    this.tabCoordinator = void 0;
   }
   // --- Internals ----------------------------------------------------------
   /**
@@ -2116,7 +2366,7 @@ class LunoraClient {
    * optimistically (confirmation rides the synced view). Otherwise the
    * built-in `OfflineQueue` resolves/rejects the returned promise on replay.
    */
-  async enqueueOfflineMutation(function_, argsRecord, shardKey, mutationId, optimisticRollbacks, optimisticConfirms) {
+  async enqueueOfflineMutation(function_, argsRecord, shardKey, mutationId, optimisticRollbacks, optimisticConfirms, precondition) {
     const issuingIdentity = this.identityFingerprint();
     if (this.outbox) {
       this.outboxMutationCounter += 1;
@@ -2154,6 +2404,8 @@ class LunoraClient {
         // Persist the stamp alongside the record so a hydrated write can
         // only replay under the identity that queued it.
         identity: issuingIdentity,
+        // Optional precondition checked before replay — see drainConflict.
+        precondition,
         // Confirm the per-call optimistic layer(s) against the commit cursor
         // the flush replay echoes (see flushOfflineQueue).
         onCommit: (commitCursor) => {
@@ -2380,7 +2632,7 @@ class LunoraClient {
    * mutation or leave a partial patch live.
    */
   applyOptimisticUpdate(optimisticUpdate, args, shardKey, optimisticRollbacks, optimisticConfirms) {
-    const { confirms, rollbacks, store } = createLocalStore(this.subscriptions, shardKey, stableStringify);
+    const { confirms, rollbacks, store } = createLocalStore(this.subscriptions, shardKey);
     try {
       optimisticUpdate(store, args);
     } catch {
@@ -2608,6 +2860,9 @@ class LunoraClient {
     if (this.closed || this.WebSocketImpl === void 0) {
       return;
     }
+    if (this.tabCoordinator && !this.tabCoordinator.isLeader()) {
+      return;
+    }
     const conn = this.getOrCreateConnection(shardKey);
     if (conn.wsState === "open" || conn.wsState === "connecting") {
       return;
@@ -2709,6 +2964,13 @@ class LunoraClient {
     conn.wsState = "idle";
     this.emitConnectionStatus();
     this.markShardPendingAck(conn.shardKey);
+    const pendingStreamIds = new Set((conn.pendingStreams ?? []).map((message) => message.id));
+    for (const [id, stream] of this.streams) {
+      if (connectionKey(stream.shardKey) === connectionKey(conn.shardKey) && !pendingStreamIds.has(id)) {
+        stream.handle.fail(new LunoraError("STREAM_DISCONNECTED", "stream terminated: WebSocket disconnected"));
+        this.streams.delete(id);
+      }
+    }
     if (this.WebSocketImpl === void 0) {
       return;
     }
@@ -2881,12 +3143,7 @@ class LunoraClient {
     }
   }
   handlePokeStart(message) {
-    if (this.pokeBuffers.size >= LunoraClient.MAX_POKE_BUFFERS) {
-      const oldest = this.pokeBuffers.keys().next().value;
-      if (oldest !== void 0) {
-        this.pokeBuffers.delete(oldest);
-      }
-    }
+    evictOldestEntry(this.pokeBuffers, LunoraClient.MAX_POKE_BUFFERS);
     this.pokeBuffers.set(message.pokeId, { baseCheckpoint: message.baseCheckpoint, epoch: message.epoch, lastMutationId: /* @__PURE__ */ new Map(), parts: /* @__PURE__ */ new Map() });
   }
   handlePokePart(message) {
@@ -2967,6 +3224,10 @@ class LunoraClient {
     this.persistQueryValue(state);
     dropConfirmedLayers(state, state.serverCursor);
     notifySubscription(state, state.optimisticLayers.length === 0 ? payload : foldOptimistic(payload, state.optimisticLayers));
+    if (this.tabCoordinator?.isLeader()) {
+      const key = SubscriptionRegistry.key(state.fn.__lunoraRef, state.args, state.shardKey);
+      this.tabCoordinator.broadcastSubscriptionData(key, payload);
+    }
   }
   /**
    * Handle a `resume` frame (Pillar 1b): the server proved nothing the
@@ -3108,6 +3369,24 @@ class LunoraClient {
     if (token === null) {
       return null;
     }
+    return this.hashToken(token);
+  }
+  /**
+   * Stable token-hash fingerprint of a bearer token (the `&lt;len>:&lt;fnv>:&lt;djb2>`
+   * format a token-stamped queued write carries). Extracted so the replay gate
+   * can recompute the hash of the current credential and recognise a write
+   * stamped under it — even after the fingerprint was relabelled to a subject.
+   *
+   * Two independent 32-bit passes (FNV-1a + djb2) give a ~64-bit digest, so
+   * two distinct equal-length tokens are astronomically unlikely to share a
+   * fingerprint. A single 32-bit hash collides ~1-in-4e9 per equal-length
+   * pair — enough that, on a shared device, user B could hydrate A's cached
+   * reads. Different algorithms (not the same FNV with a different seed, which
+   * would be affine-related) keep the two passes genuinely independent.
+   * Still synchronous (no crypto) and stable across surrogate pairs.
+   */
+  // eslint-disable-next-line class-methods-use-this -- pure helper; a method for locality with identityFingerprint, reads no shared state
+  hashToken(token) {
     let fnv = 2166136261;
     let djb2 = 5381;
     for (let index = 0; index < token.length; index += 1) {
@@ -3118,6 +3397,25 @@ class LunoraClient {
     }
     return `${token.length.toString(36)}:${(fnv >>> 0).toString(36)}:${(djb2 >>> 0).toString(36)}`;
   }
+  /**
+   * True when `stamped` is a token-hash of the SAME credential still held now,
+   * even though the live identity has since been relabelled to a subject. Covers
+   * `setAuthToken(token, userId)` where the subject resolved a tick after the
+   * token was set: a write persisted (or requeued) under the token hash must
+   * still replay — the credential never changed, only its label — instead of
+   * being dropped as an identity mismatch. This is the durable counterpart to
+   * {@link restampQueuedIdentity}, which only relabels the in-memory live stamp
+   * (consumed on the first flush) and never touches `item.identity` or the
+   * persisted record, so a reload or a transient-failure requeue would otherwise
+   * fall back to the stale token-hash and wrongly reject the same user's write.
+   */
+  isSameCredentialUnderTokenHash(stamped) {
+    if (stamped === null || stamped.startsWith("subj:")) {
+      return false;
+    }
+    const token = this.authToken;
+    return token === null ? false : this.hashToken(token) === stamped;
+  }
   /**
    * Drain every in-memory offline write and reject it because the auth
    * identity changed. Durable entries are also dropped from persistence so a
@@ -3168,6 +3466,14 @@ class LunoraClient {
     this.queryCache?.clear().catch(() => void 0);
   }
   async flushOfflineQueue(shardKey) {
+    const conflicted = this.offlineQueue.drainConflict();
+    for (const item of conflicted) {
+      this.unpersist(item.id);
+      this.queuedIdentities.delete(item.id ?? "");
+      const error = new Error("offline mutation skipped: precondition failed before replay");
+      error.code = "OFFLINE_PRECONDITION_FAILED";
+      this.emitItemSettled(item, "rejected", error);
+    }
     const key = connectionKey(shardKey);
     const drained = this.offlineQueue.drain((item) => connectionKey(item.shardKey) === key);
     if (drained.length === 0) {
@@ -3246,7 +3552,7 @@ class LunoraClient {
   passesReplayIdentityGate(item, currentIdentity) {
     const liveStamp = item.id === void 0 ? void 0 : this.queuedIdentities.get(item.id);
     const stamped = liveStamp === void 0 ? item.identity : liveStamp;
-    if (stamped !== void 0 && stamped !== currentIdentity) {
+    if (stamped !== void 0 && stamped !== currentIdentity && !this.isSameCredentialUnderTokenHash(stamped)) {
       this.queuedIdentities.delete(item.id ?? "");
       this.unpersist(item.id);
       const error = new Error("offline mutation skipped: auth identity changed before replay");

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

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

package/dist/packem_shared/SubscriptionRegistry-D4jfIzZu.mjs

@@ -0,0 +1,31 @@
+import { s as stableStringify } from './stable-key-wv6eP48B.mjs';
+
+class SubscriptionRegistry {
+  static key(functionPath, args, shardKey) {
+    return `${functionPath}::${stableStringify(args)}::${shardKey ?? ""}`;
+  }
+  byKey = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.byKey.get(key);
+  }
+  getById(id) {
+    return this.byId.get(id);
+  }
+  add(state) {
+    this.byKey.set(SubscriptionRegistry.key(state.fn.__lunoraRef, state.args, state.shardKey), state);
+    this.byId.set(state.id, state);
+  }
+  remove(state) {
+    const key = SubscriptionRegistry.key(state.fn.__lunoraRef, state.args, state.shardKey);
+    if (this.byKey.get(key) === state) {
+      this.byKey.delete(key);
+    }
+    this.byId.delete(state.id);
+  }
+  all() {
+    return [...this.byKey.values()];
+  }
+}
+
+export { SubscriptionRegistry };