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

package/dist/packem_shared/TabCoordinator-BwRR8H06.mjs

@@ -0,0 +1,222 @@
+let nextTabId = 0;
+const DEFAULT_CHANNEL = "lunora-bridge";
+const DEFAULT_HEARTBEAT_MS = 1e3;
+const DEFAULT_LEADER_TIMEOUT_MS = 3e3;
+class TabCoordinator {
+  bc;
+  tabId;
+  heartbeatInterval;
+  leaderTimeout;
+  /** The tab id of the current known leader, or `undefined` if no leader. */
+  knownLeader = void 0;
+  /** `true` when this tab believes it is the leader. */
+  leader = false;
+  /** `true` once `start()` has been called. */
+  running = false;
+  /** Timestamp of the most recent leader heartbeat. */
+  lastHeartbeat = 0;
+  heartbeatTimer = void 0;
+  leaderCheckTimer = void 0;
+  /** Callbacks set via constructor options. */
+  onBecomeLeader;
+  onStopBeingLeader;
+  onSubscriptionData;
+  onSubscriptionError;
+  constructor(options = {}) {
+    nextTabId += 1;
+    this.tabId = `tab_${String(nextTabId)}_${crypto.randomUUID()}`;
+    this.heartbeatInterval = options.heartbeatInterval ?? DEFAULT_HEARTBEAT_MS;
+    this.leaderTimeout = options.leaderTimeout ?? DEFAULT_LEADER_TIMEOUT_MS;
+    this.onBecomeLeader = options.onBecomeLeader;
+    this.onStopBeingLeader = options.onStopBeingLeader;
+    this.onSubscriptionData = options.onSubscriptionData;
+    this.onSubscriptionError = options.onSubscriptionError;
+    if (typeof BroadcastChannel === "undefined") {
+      this.bc = void 0;
+      return;
+    }
+    this.bc = new BroadcastChannel(options.channelName ?? DEFAULT_CHANNEL);
+    this.bc.addEventListener("message", (event) => {
+      this.handleMessage(event.data);
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Start the coordinator: attempt to claim leadership and begin the
+   * heartbeat/leader-check cycle. Safe to call multiple times.
+   */
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    if (this.bc === void 0) {
+      this.becomeLeader();
+      return;
+    }
+    this.broadcast({ type: "claim-leadership", tabId: this.tabId, ts: Date.now() });
+    setTimeout(() => {
+      if (!this.running) {
+        return;
+      }
+      if (this.knownLeader === void 0) {
+        this.becomeLeader();
+      }
+    }, this.leaderTimeout);
+    this.leaderCheckTimer = setInterval(() => {
+      this.checkLeaderHealth();
+    }, this.leaderTimeout);
+    this.heartbeatTimer = setInterval(() => {
+      this.sendHeartbeat();
+    }, this.heartbeatInterval);
+  }
+  /**
+   * Stop the coordinator: yield leadership (if held), close the channel, and
+   * clear all timers. Safe to call multiple times.
+   */
+  stop() {
+    this.running = false;
+    if (this.leader) {
+      this.broadcast({ type: "yield-leadership", tabId: this.tabId });
+      this.leader = false;
+      this.knownLeader = void 0;
+      this.onStopBeingLeader?.();
+    }
+    if (this.heartbeatTimer !== void 0) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+    if (this.leaderCheckTimer !== void 0) {
+      clearInterval(this.leaderCheckTimer);
+      this.leaderCheckTimer = void 0;
+    }
+    this.bc?.close();
+  }
+  /** `true` when this tab is the current WebSocket leader. */
+  isLeader() {
+    return this.leader;
+  }
+  /** The tab id of the current leader, or `undefined` if unknown / no leader. */
+  get leaderTabId() {
+    return this.knownLeader;
+  }
+  /** The id of this tab. */
+  get id() {
+    return this.tabId;
+  }
+  /** `true` when the coordinator has been started and is not yet stopped. */
+  get isRunning() {
+    return this.running;
+  }
+  // -----------------------------------------------------------------------
+  // Broadcasting
+  // -----------------------------------------------------------------------
+  /**
+   * Broadcast subscription data to all follower tabs. Only the leader should
+   * call this.
+   */
+  broadcastSubscriptionData(key, data) {
+    if (!this.leader) {
+      return;
+    }
+    this.broadcast({ type: "subscription-data", tabId: this.tabId, key, data });
+  }
+  /**
+   * Broadcast a subscription error to all follower tabs. Only the leader
+   * should call this.
+   */
+  broadcastSubscriptionError(key, error) {
+    if (!this.leader) {
+      return;
+    }
+    this.broadcast({ type: "subscription-error", tabId: this.tabId, key, error });
+  }
+  // -----------------------------------------------------------------------
+  // Internal
+  // -----------------------------------------------------------------------
+  broadcast(message) {
+    this.bc?.postMessage(message);
+  }
+  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;
+        }
+        break;
+      }
+      case "heartbeat": {
+        this.lastHeartbeat = message.ts;
+        this.knownLeader = message.tabId;
+        break;
+      }
+      case "subscription-data": {
+        if (this.leader || message.tabId === this.tabId) {
+          break;
+        }
+        this.onSubscriptionData?.(message.key, message.data);
+        break;
+      }
+      case "subscription-error": {
+        if (this.leader || message.tabId === this.tabId) {
+          break;
+        }
+        this.onSubscriptionError?.(message.key, message.error);
+        break;
+      }
+      case "yield-leadership": {
+        if (this.knownLeader === message.tabId) {
+          this.knownLeader = void 0;
+        }
+        break;
+      }
+    }
+  }
+  becomeLeader() {
+    if (this.leader) {
+      return;
+    }
+    this.leader = true;
+    this.knownLeader = this.tabId;
+    this.lastHeartbeat = Date.now();
+    this.onBecomeLeader?.();
+    this.broadcast({ type: "heartbeat", tabId: this.tabId, ts: Date.now() });
+  }
+  sendHeartbeat() {
+    if (!this.leader) {
+      return;
+    }
+    this.broadcast({ type: "heartbeat", tabId: this.tabId, ts: Date.now() });
+  }
+  checkLeaderHealth() {
+    if (!this.running) {
+      return;
+    }
+    if (this.leader) {
+      return;
+    }
+    if (this.knownLeader !== void 0) {
+      const elapsed = Date.now() - this.lastHeartbeat;
+      if (elapsed > this.leaderTimeout) {
+        this.knownLeader = void 0;
+        this.broadcast({ type: "claim-leadership", tabId: this.tabId, ts: Date.now() });
+        setTimeout(() => {
+          if (this.running && this.knownLeader === void 0) {
+            this.becomeLeader();
+          }
+        }, this.leaderTimeout);
+      }
+    }
+  }
+}
+
+export { TabCoordinator };

package/dist/packem_shared/{applyDelta-4jFGTPA3.mjs → applyDelta-CRKZ1PBt.mjs}

@@ -7,14 +7,34 @@ const rowId = (row) => {
   const id = row[ID_FIELD];
   return typeof id === "string" ? id : void 0;
 };
+const isDescending = (list) => {
+  let previous;
+  for (const existingRow of list) {
+    const existing = existingRow[CREATION_FIELD];
+    if (typeof existing !== "number") {
+      continue;
+    }
+    if (previous !== void 0) {
+      if (existing < previous) {
+        return true;
+      }
+      if (existing > previous) {
+        return false;
+      }
+    }
+    previous = existing;
+  }
+  return false;
+};
 const insertionIndex = (list, row) => {
   const creation = row[CREATION_FIELD];
   if (typeof creation !== "number") {
     return list.length;
   }
+  const descending = isDescending(list);
   for (const [index, existingRow] of list.entries()) {
     const existing = existingRow[CREATION_FIELD];
-    if (typeof existing === "number" && existing > creation) {
+    if (typeof existing === "number" && (descending ? existing < creation : existing > creation)) {
       return index;
     }
   }

package/dist/packem_shared/createClientQuery-CQ51bWAE.mjs

@@ -0,0 +1,71 @@
+class ClientQueryStore {
+  /** Current values, keyed by the ref's stable key. Absent = never set. */
+  values = /* @__PURE__ */ new Map();
+  /** Subscribers keyed by ref key — notified on every set. */
+  subscribers = /* @__PURE__ */ new Map();
+  /**
+   * Return the current value for `ref`, or `ref.defaultValue` if none has
+   * been set explicitly. Returns `ref.defaultValue` when the slot has been
+   * set to `undefined` (which is distinct from "never set").
+   */
+  get(ref) {
+    if (this.values.has(ref.key)) {
+      return this.values.get(ref.key);
+    }
+    return ref.defaultValue;
+  }
+  /**
+   * Set a new value for `ref` and notify every subscriber. Pass `undefined`
+   * to reset the slot to `ref.defaultValue`.
+   */
+  set(ref, value) {
+    this.values.set(ref.key, value);
+    this.notify(ref.key);
+  }
+  /**
+   * Delete the stored value for `ref`, resetting to `ref.defaultValue` and
+   * notifying subscribers.
+   */
+  reset(ref) {
+    this.values.delete(ref.key);
+    this.notify(ref.key);
+  }
+  /**
+   * Subscribe to changes for `ref`. The callback is NOT invoked on
+   * registration — callers should read the current value via
+   * {@link get} first. Returns an unsubscribe function.
+   */
+  subscribe(ref, callback) {
+    let subs = this.subscribers.get(ref.key);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.subscribers.set(ref.key, subs);
+    }
+    subs.add(callback);
+    return () => {
+      subs.delete(callback);
+      if (subs.size === 0) {
+        this.subscribers.delete(ref.key);
+      }
+    };
+  }
+  /** Notify every subscriber of a value change for the given key. */
+  notify(key) {
+    const subs = this.subscribers.get(key);
+    if (!subs) {
+      return;
+    }
+    const value = this.values.get(key);
+    for (const callback of subs) {
+      try {
+        callback(value);
+      } catch {
+      }
+    }
+  }
+}
+const createClientQuery = (key, defaultValue) => {
+  return { defaultValue, key };
+};
+
+export { ClientQueryStore, createClientQuery };

package/dist/packem_shared/{createInMemoryPersistence-Ds7z8n8d.mjs → createInMemoryPersistence-DZ2VHWgm.mjs}

@@ -1,4 +1,5 @@
 import { LunoraError } from '@lunora/errors';
+import { p as promisifyRequest, c as createWithStore, a as createDatabaseOpener } from './idb-utility-DrSVX43Q.mjs';
 
 const createInMemoryPersistence = () => {
   const entries = /* @__PURE__ */ new Map();
@@ -30,14 +31,6 @@ const createInMemoryPersistence = () => {
 const DEFAULT_DATABASE = "lunora-outbox";
 const DEFAULT_STORE = "offline-mutations";
 const ID_INDEX = "by_id";
-const promisifyRequest = (request) => new Promise((resolve, reject) => {
-  request.addEventListener("success", () => {
-    resolve(request.result);
-  });
-  request.addEventListener("error", () => {
-    reject(request.error ?? new Error("IndexedDB request failed"));
-  });
-});
 const createIndexedDbPersistence = (options = {}) => {
   const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
   if (!factory) {
@@ -45,46 +38,13 @@ const createIndexedDbPersistence = (options = {}) => {
   }
   const databaseName = options.databaseName ?? DEFAULT_DATABASE;
   const storeName = options.storeName ?? DEFAULT_STORE;
-  let databasePromise;
-  const openDatabase = () => {
-    if (databasePromise) {
-      return databasePromise;
+  const openDatabase = createDatabaseOpener(factory, databaseName, 1, (database) => {
+    if (!database.objectStoreNames.contains(storeName)) {
+      const store = database.createObjectStore(storeName, { autoIncrement: true });
+      store.createIndex(ID_INDEX, "id", { unique: true });
     }
-    databasePromise = new Promise((resolve, reject) => {
-      const request = factory.open(databaseName, 1);
-      request.addEventListener("upgradeneeded", () => {
-        const database = request.result;
-        if (!database.objectStoreNames.contains(storeName)) {
-          const store = database.createObjectStore(storeName, { autoIncrement: true });
-          store.createIndex(ID_INDEX, "id", { unique: true });
-        }
-      });
-      request.addEventListener("success", () => {
-        resolve(request.result);
-      });
-      request.addEventListener("error", () => {
-        reject(request.error ?? new Error("IndexedDB open failed"));
-      });
-    });
-    return databasePromise;
-  };
-  const withStore = async (mode, run) => {
-    const database = await openDatabase();
-    const transaction = database.transaction(storeName, mode);
-    const result = await run(transaction.objectStore(storeName));
-    await new Promise((resolve, reject) => {
-      transaction.addEventListener("complete", () => {
-        resolve();
-      });
-      transaction.addEventListener("error", () => {
-        reject(transaction.error ?? new Error("IndexedDB transaction failed"));
-      });
-      transaction.addEventListener("abort", () => {
-        reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
-      });
-    });
-    return result;
-  };
+  });
+  const withStore = createWithStore(openDatabase, storeName);
   return {
     append: async (mutation) => {
       await withStore("readwrite", (store) => promisifyRequest(store.add(mutation)));

package/dist/packem_shared/{createInMemoryQueryCache-iWtKPrid.mjs → createInMemoryQueryCache-DiaGZkA2.mjs}

@@ -1,4 +1,5 @@
 import { LunoraError } from '@lunora/errors';
+import { p as promisifyRequest, c as createWithStore, a as createDatabaseOpener } from './idb-utility-DrSVX43Q.mjs';
 
 const queryCacheKey = (functionPath, argsKey, shardKey) => `${functionPath}::${argsKey}::${shardKey ?? ""}`;
 const DEFAULT_MAX_ENTRIES = 500;
@@ -41,14 +42,6 @@ const DEFAULT_DATABASE = "lunora-query-cache";
 const DEFAULT_STORE = "query-cache";
 const TS_INDEX = "by_ts";
 const DATABASE_VERSION = 1;
-const promisifyRequest = (request) => new Promise((resolve, reject) => {
-  request.addEventListener("success", () => {
-    resolve(request.result);
-  });
-  request.addEventListener("error", () => {
-    reject(request.error ?? new Error("IndexedDB request failed"));
-  });
-});
 const createIndexedDbQueryCache = (options = {}) => {
   const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
   if (!factory) {
@@ -57,46 +50,13 @@ const createIndexedDbQueryCache = (options = {}) => {
   const databaseName = options.databaseName ?? DEFAULT_DATABASE;
   const storeName = options.storeName ?? DEFAULT_STORE;
   const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  let databasePromise;
-  const openDatabase = () => {
-    if (databasePromise) {
-      return databasePromise;
+  const openDatabase = createDatabaseOpener(factory, databaseName, DATABASE_VERSION, (database) => {
+    if (!database.objectStoreNames.contains(storeName)) {
+      const store = database.createObjectStore(storeName, { keyPath: "key" });
+      store.createIndex(TS_INDEX, "ts", { unique: false });
     }
-    databasePromise = new Promise((resolve, reject) => {
-      const request = factory.open(databaseName, DATABASE_VERSION);
-      request.addEventListener("upgradeneeded", () => {
-        const database = request.result;
-        if (!database.objectStoreNames.contains(storeName)) {
-          const store = database.createObjectStore(storeName, { keyPath: "key" });
-          store.createIndex(TS_INDEX, "ts", { unique: false });
-        }
-      });
-      request.addEventListener("success", () => {
-        resolve(request.result);
-      });
-      request.addEventListener("error", () => {
-        reject(request.error ?? new Error("IndexedDB open failed"));
-      });
-    });
-    return databasePromise;
-  };
-  const withStore = async (mode, run) => {
-    const database = await openDatabase();
-    const transaction = database.transaction(storeName, mode);
-    const result = await run(transaction.objectStore(storeName));
-    await new Promise((resolve, reject) => {
-      transaction.addEventListener("complete", () => {
-        resolve();
-      });
-      transaction.addEventListener("error", () => {
-        reject(transaction.error ?? new Error("IndexedDB transaction failed"));
-      });
-      transaction.addEventListener("abort", () => {
-        reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
-      });
-    });
-    return result;
-  };
+  });
+  const withStore = createWithStore(openDatabase, storeName);
   const evict = async (store) => {
     const count = await promisifyRequest(store.count());
     let overflow = count - maxEntries;

package/dist/packem_shared/createLocalStore-BDbbkoXw.mjs

@@ -0,0 +1,2 @@
+export { c as createLocalStore } from './local-store-DtcIW4c0.mjs';
+import './SubscriptionRegistry-D4jfIzZu.mjs';

package/dist/packem_shared/createReply-lI4tVS2w.mjs

@@ -0,0 +1,36 @@
+const sendToSw = (sw, message, expectResponse = false) => new Promise((resolve, reject) => {
+  if (!sw) {
+    reject(new Error("No active service worker"));
+    return;
+  }
+  const id = message.correlationId ?? crypto.randomUUID();
+  const outgoingMessage = { ...message, correlationId: id };
+  if (expectResponse) {
+    let timer;
+    const handler = (event) => {
+      if (event.data.correlationId === id) {
+        clearTimeout(timer);
+        navigator.serviceWorker.removeEventListener("message", handler);
+        resolve(event.data.payload);
+      }
+    };
+    timer = setTimeout(() => {
+      navigator.serviceWorker.removeEventListener("message", handler);
+      reject(new Error(`SW message ${id} timed out`));
+    }, 3e4);
+    navigator.serviceWorker.addEventListener("message", handler);
+    sw.postMessage(outgoingMessage);
+  } else {
+    sw.postMessage(outgoingMessage);
+    resolve(void 0);
+  }
+});
+const createReply = (original, payload) => {
+  return {
+    type: `${original.type}:reply`,
+    payload,
+    correlationId: original.correlationId
+  };
+};
+
+export { createReply, sendToSw };

package/dist/packem_shared/{createServerClient-CKKZrXLc.mjs → createServerClient-Dxemst5C.mjs}

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

package/dist/packem_shared/createSnapshotPrecondition-CBwnVz6r.mjs

@@ -0,0 +1,18 @@
+import { s as stableStringify } from './stable-key-wv6eP48B.mjs';
+
+const createSnapshotPrecondition = (client, functionRef, args, shardKey) => {
+  const snapshot = client.peekActiveQueryValue(functionRef.__lunoraRef, args, shardKey);
+  const snapshotKey = snapshot === void 0 ? void 0 : stableStringify(snapshot);
+  return () => {
+    const current = client.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;
+  };
+};
+
+export { createSnapshotPrecondition as default };

package/dist/packem_shared/idb-utility-DrSVX43Q.mjs

@@ -0,0 +1,48 @@
+const promisifyRequest = (request) => new Promise((resolve, reject) => {
+  request.addEventListener("success", () => {
+    resolve(request.result);
+  });
+  request.addEventListener("error", () => {
+    reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+});
+const createDatabaseOpener = (factory, databaseName, version, upgrade) => {
+  let databasePromise;
+  return () => {
+    if (databasePromise) {
+      return databasePromise;
+    }
+    databasePromise = new Promise((resolve, reject) => {
+      const request = factory.open(databaseName, version);
+      request.addEventListener("upgradeneeded", () => {
+        upgrade(request.result);
+      });
+      request.addEventListener("success", () => {
+        resolve(request.result);
+      });
+      request.addEventListener("error", () => {
+        reject(request.error ?? new Error("IndexedDB open failed"));
+      });
+    });
+    return databasePromise;
+  };
+};
+const createWithStore = (open, storeName) => async (mode, run) => {
+  const database = await open();
+  const transaction = database.transaction(storeName, mode);
+  const result = await run(transaction.objectStore(storeName));
+  await new Promise((resolve, reject) => {
+    transaction.addEventListener("complete", () => {
+      resolve();
+    });
+    transaction.addEventListener("error", () => {
+      reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+    });
+    transaction.addEventListener("abort", () => {
+      reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+    });
+  });
+  return result;
+};
+
+export { createDatabaseOpener as a, createWithStore as c, promisifyRequest as p };

package/dist/packem_shared/{local-store-BNgN3Dw3.mjs → local-store-DtcIW4c0.mjs}

@@ -1,3 +1,5 @@
+import { SubscriptionRegistry } from './SubscriptionRegistry-D4jfIzZu.mjs';
+
 const foldOptimistic = (base, layers) => {
   let value = base;
   for (const layer of layers) {
@@ -68,33 +70,26 @@ const dropConfirmedLayers = (state, cursor) => {
   return state.optimisticLayers.length !== before;
 };
 
-const createLocalStore = (subscriptions, shardKey, stableStringify) => {
+const createLocalStore = (subscriptions, shardKey) => {
   const confirms = [];
   const rollbacks = [];
-  const findState = (functionRef, argsKey) => {
-    for (const state of subscriptions.all()) {
-      if (state.fn.__lunoraRef === functionRef && state.shardKey === shardKey && state.argsKey === argsKey) {
-        return state;
-      }
-    }
-    return void 0;
-  };
+  const findState = (functionRef, args) => subscriptions.get(SubscriptionRegistry.key(functionRef, args, shardKey));
   const store = {
     getAllQueries: (function_) => {
       const matches = [];
       for (const state of subscriptions.all()) {
-        if (state.fn.__lunoraRef === function_.__lunoraRef && state.shardKey === shardKey) {
+        if (state.fn.__lunoraRef === function_.__lunoraRef && (state.shardKey ?? "") === (shardKey ?? "")) {
           matches.push({ args: state.args, value: state.lastValue });
         }
       }
       return matches;
     },
     getQuery: (function_, args) => {
-      const state = findState(function_.__lunoraRef, stableStringify(args ?? {}));
+      const state = findState(function_.__lunoraRef, args ?? {});
       return state?.lastValue;
     },
     setQuery: (function_, args, value) => {
-      const state = findState(function_.__lunoraRef, stableStringify(args ?? {}));
+      const state = findState(function_.__lunoraRef, args ?? {});
       if (!state) {
         return;
       }