@lunora/client 1.0.0-alpha.28 → 1.0.0-alpha.29

package/dist/packem_shared/OfflineQueue-BgarnAub.mjs

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

package/dist/packem_shared/SKIP-vItZChkw.mjs

@@ -1,50 +0,0 @@
-const SKIP = "skip";
-const toSubscriptionError = (error) => {
-  if (error instanceof Error) {
-    return { message: error.message };
-  }
-  return { message: String(error) };
-};
-const createQuerySubscription = (client, function_, args, sinks, options = {}) => {
-  if (args === SKIP) {
-    sinks.onReset?.();
-    return () => {
-    };
-  }
-  let cancelled = false;
-  const handleError = (error) => {
-    if (cancelled) {
-      return;
-    }
-    sinks.onError?.(error);
-  };
-  const onError = sinks.onError ? handleError : void 0;
-  let unsubscribe;
-  try {
-    unsubscribe = client.subscribe(
-      function_,
-      args,
-      (value) => {
-        if (cancelled) {
-          return;
-        }
-        sinks.onData(value);
-      },
-      { onError, shardKey: options.shardKey }
-    );
-  } catch (error) {
-    if (!sinks.onError) {
-      throw error;
-    }
-    handleError(toSubscriptionError(error));
-    return () => {
-      cancelled = true;
-    };
-  }
-  return () => {
-    cancelled = true;
-    unsubscribe();
-  };
-};
-
-export { SKIP, createQuerySubscription, toSubscriptionError };

package/dist/packem_shared/SubscriptionRegistry-CxS_Inha.mjs

@@ -1,31 +0,0 @@
-import { s as stableWireKey } from './wire-key-Djie6aaR.mjs';
-
-class SubscriptionRegistry {
-  static key(functionPath, args, shardKey) {
-    return `${functionPath}::${stableWireKey(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 };

package/dist/packem_shared/TabCoordinator-D_5oNTTt.mjs

@@ -1,258 +0,0 @@
-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": {
-        this.handleClaimLeadership(message);
-        break;
-      }
-      case "heartbeat": {
-        this.handleHeartbeat(message);
-        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;
-      }
-    }
-  }
-  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;
-    }
-    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-CRKZ1PBt.mjs

@@ -1,81 +0,0 @@
-const ID_FIELD = "_id";
-const CREATION_FIELD = "_creationTime";
-const rowId = (row) => {
-  if (typeof row !== "object" || row === null) {
-    return void 0;
-  }
-  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" && (descending ? existing < creation : existing > creation)) {
-      return index;
-    }
-  }
-  return list.length;
-};
-const isMutationDelta = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate["key"] === "string" && typeof candidate["table"] === "string" && (candidate["op"] === "insert" || candidate["op"] === "update" || candidate["op"] === "delete");
-};
-const applyDelta = (current, delta) => {
-  if (!Array.isArray(current)) {
-    return void 0;
-  }
-  const rows = [];
-  for (const element of current) {
-    const id = rowId(element);
-    if (id === void 0) {
-      return void 0;
-    }
-    rows.push(element);
-  }
-  const { key, op, row } = delta;
-  if (op === "delete") {
-    const next2 = rows.filter((existing) => existing[ID_FIELD] !== key);
-    return next2.length === rows.length ? [...rows] : next2;
-  }
-  if (row === void 0) {
-    return void 0;
-  }
-  const existingIndex = rows.findIndex((existing) => existing[ID_FIELD] === key);
-  if (existingIndex === -1) {
-    const next2 = [...rows];
-    next2.splice(insertionIndex(rows, row), 0, row);
-    return next2;
-  }
-  const next = [...rows];
-  next[existingIndex] = row;
-  return next;
-};
-
-export { applyDelta, isMutationDelta };

package/dist/packem_shared/createAsyncStoragePersistence-1Z5BZ8RC.mjs

@@ -1,45 +0,0 @@
-const DEFAULT_KEY = "lunora:offline-mutations";
-const createAsyncStoragePersistence = (options) => {
-  const { storage } = options;
-  const key = options.key ?? DEFAULT_KEY;
-  let chain = Promise.resolve();
-  const serialize = (run) => {
-    const next = chain.then(run, run);
-    chain = next.then(
-      () => void 0,
-      () => void 0
-    );
-    return next;
-  };
-  const readAll = async () => {
-    const raw = await storage.getItem(key);
-    if (raw === null) {
-      return [];
-    }
-    try {
-      const parsed = JSON.parse(raw);
-      return Array.isArray(parsed) ? parsed : [];
-    } catch {
-      return [];
-    }
-  };
-  const writeAll = (mutations) => storage.setItem(key, JSON.stringify(mutations));
-  return {
-    append: (mutation) => serialize(async () => {
-      const mutations = await readAll();
-      mutations.push(mutation);
-      await writeAll(mutations);
-    }),
-    clear: () => serialize(() => storage.removeItem(key)),
-    load: () => serialize(readAll),
-    remove: (id) => serialize(async () => {
-      const mutations = await readAll();
-      const remaining = mutations.filter((mutation) => mutation.id !== id);
-      if (remaining.length !== mutations.length) {
-        await writeAll(remaining);
-      }
-    })
-  };
-};
-
-export { createAsyncStoragePersistence };

package/dist/packem_shared/createClientQuery-dJZg1ohm.mjs

@@ -1,80 +0,0 @@
-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` — 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, value);
-  }
-  /**
-   * Delete the stored value for `ref`, resetting to `ref.defaultValue` and
-   * notifying subscribers.
-   */
-  reset(ref) {
-    this.values.delete(ref.key);
-    this.notify(ref.key, ref.defaultValue);
-  }
-  /**
-   * 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 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;
-    }
-    for (const callback of subs) {
-      try {
-        callback(value);
-      } catch {
-      }
-    }
-  }
-}
-const createClientQuery = (key, defaultValue) => {
-  return { defaultValue, key };
-};
-
-export { ClientQueryStore, createClientQuery };

package/dist/packem_shared/createInMemoryBookmarkStorage-BoN7a7TH.mjs

@@ -1,11 +0,0 @@
-const createInMemoryBookmarkStorage = () => {
-  let value = null;
-  return {
-    get: () => value,
-    set: (next) => {
-      value = next;
-    }
-  };
-};
-
-export { createInMemoryBookmarkStorage as default };

package/dist/packem_shared/createInMemoryPersistence-DZ2VHWgm.mjs

@@ -1,79 +0,0 @@
-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();
-  const clone = (mutation) => {
-    return {
-      args: { ...mutation.args },
-      functionPath: mutation.functionPath,
-      id: mutation.id,
-      identity: mutation.identity,
-      shardKey: mutation.shardKey
-    };
-  };
-  return {
-    append: (mutation) => {
-      entries.set(mutation.id, clone(mutation));
-      return Promise.resolve();
-    },
-    clear: () => {
-      entries.clear();
-      return Promise.resolve();
-    },
-    load: () => Promise.resolve([...entries.values()].map((mutation) => clone(mutation))),
-    remove: (id) => {
-      entries.delete(id);
-      return Promise.resolve();
-    }
-  };
-};
-const DEFAULT_DATABASE = "lunora-outbox";
-const DEFAULT_STORE = "offline-mutations";
-const ID_INDEX = "by_id";
-const createIndexedDbPersistence = (options = {}) => {
-  const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
-  if (!factory) {
-    throw new LunoraError("INTERNAL", "createIndexedDbPersistence: no IndexedDB available — pass `indexedDB` or use createInMemoryPersistence()");
-  }
-  const databaseName = options.databaseName ?? DEFAULT_DATABASE;
-  const storeName = options.storeName ?? DEFAULT_STORE;
-  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 });
-    }
-  });
-  const withStore = createWithStore(openDatabase, storeName);
-  return {
-    append: async (mutation) => {
-      await withStore("readwrite", (store) => promisifyRequest(store.add(mutation)));
-    },
-    clear: async () => {
-      await withStore("readwrite", (store) => promisifyRequest(store.clear()));
-    },
-    load: async () => withStore("readonly", (store) => promisifyRequest(store.getAll())),
-    remove: async (id) => {
-      await withStore("readwrite", async (store) => {
-        const key = await promisifyRequest(store.index(ID_INDEX).getKey(id));
-        if (key !== void 0) {
-          await promisifyRequest(store.delete(key));
-        }
-      });
-    }
-  };
-};
-const resolvePersistenceAdapter = (option, autoProbe = true) => {
-  if (option === false) {
-    return void 0;
-  }
-  if (option) {
-    return option;
-  }
-  if (!autoProbe || typeof indexedDB === "undefined") {
-    return void 0;
-  }
-  return createIndexedDbPersistence();
-};
-
-export { createInMemoryPersistence, createIndexedDbPersistence, resolvePersistenceAdapter };