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

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-CxS_Inha.mjs

@@ -0,0 +1,31 @@
+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-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/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/createLocalStore-BtqUmOQA.mjs

@@ -0,0 +1,2 @@
+export { c as createLocalStore } from './local-store-DIq-UWfD.mjs';
+import './SubscriptionRegistry-CxS_Inha.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-DF-3mLmb.mjs → createServerClient-CTTAmvMx.mjs}

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

package/dist/packem_shared/createSnapshotPrecondition-CxQ1T4ZP.mjs

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

package/dist/packem_shared/httpStream-BJU-aflc.mjs

@@ -0,0 +1,159 @@
+import { LunoraError } from '@lunora/errors';
+import { createStream } from './DEFAULT_MAX_BUFFER-7hFnzNk9.mjs';
+
+const SSE_FIELD_SPACE_RE = /^ /u;
+const parameterToString = (value) => typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+const parseSseFrame = (raw) => {
+  let event = "";
+  const dataLines = [];
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("event:")) {
+      event = line.slice("event:".length).replace(SSE_FIELD_SPACE_RE, "");
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice("data:".length).replace(SSE_FIELD_SPACE_RE, ""));
+    }
+  }
+  return { data: dataLines.join("\n"), event };
+};
+const buildHttpStreamUrl = (route, args, baseUrl) => {
+  const parameters = args.params ?? {};
+  const path = route.path.split("/").map((segment) => {
+    if (!segment.startsWith(":")) {
+      return segment;
+    }
+    const name = segment.slice(1);
+    const value = parameters[name];
+    if (value === void 0) {
+      throw new LunoraError("HTTP_STREAM_MISSING_PARAM", `httpStream: missing path param ":${name}" for route ${route.path}`);
+    }
+    return encodeURIComponent(parameterToString(value));
+  }).join("/");
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(args.searchParams ?? {})) {
+    if (value !== void 0) {
+      search.set(key, parameterToString(value));
+    }
+  }
+  const query = search.toString();
+  const trimmedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return `${trimmedBase}${path}${query === "" ? "" : `?${query}`}`;
+};
+const handleSseFrame = (frame, handle) => {
+  if (frame.event === "complete") {
+    handle.complete();
+    return true;
+  }
+  if (frame.event === "error") {
+    let payload = {};
+    try {
+      payload = JSON.parse(frame.data);
+    } catch {
+    }
+    const message = typeof payload.message === "string" ? payload.message : "stream error";
+    const code = typeof payload.code === "string" ? payload.code : "HTTP_STREAM_ERROR";
+    handle.fail(new LunoraError(code, message));
+    return true;
+  }
+  if ((frame.event === "" || frame.event === "message") && frame.data !== "") {
+    try {
+      handle.push(JSON.parse(frame.data));
+    } catch {
+      handle.fail(new LunoraError("HTTP_STREAM_BAD_CHUNK", "httpStream: malformed SSE chunk (invalid JSON)"));
+      return true;
+    }
+  }
+  return false;
+};
+const pumpSseBody = async (body, handle) => {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const drainFrames = () => {
+    let separatorIndex = buffer.indexOf("\n\n");
+    while (separatorIndex !== -1) {
+      const frame = parseSseFrame(buffer.slice(0, separatorIndex));
+      buffer = buffer.slice(separatorIndex + 2);
+      if (handleSseFrame(frame, handle)) {
+        return true;
+      }
+      separatorIndex = buffer.indexOf("\n\n");
+    }
+    return false;
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true }).replaceAll("\r\n", "\n");
+    if (drainFrames()) {
+      await reader.cancel().catch(() => {
+      });
+      return;
+    }
+  }
+  buffer += decoder.decode().replaceAll("\r\n", "\n");
+  if (!drainFrames()) {
+    handle.fail(new LunoraError("HTTP_STREAM_INTERRUPTED", "httpStream: stream ended without a complete frame"));
+  }
+};
+const httpStream = (route, args, options = {}) => {
+  const fetchImpl = options.fetch ?? (typeof fetch === "function" ? fetch.bind(globalThis) : void 0);
+  if (!fetchImpl) {
+    throw new LunoraError("INTERNAL", "httpStream: no `fetch` implementation available");
+  }
+  const url = buildHttpStreamUrl(route, args ?? {}, options.baseUrl ?? "");
+  const ac = new AbortController();
+  if (options.signal) {
+    if (options.signal.aborted) {
+      ac.abort();
+    } else {
+      options.signal.addEventListener(
+        "abort",
+        () => {
+          ac.abort();
+        },
+        { once: true }
+      );
+    }
+  }
+  const { handle, iterable } = createStream({
+    maxBuffer: options.maxBuffer,
+    onCancel: () => {
+      ac.abort();
+    }
+  });
+  (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;
+    }
+    await pumpSseBody(response.body, handle);
+  })().catch((error) => {
+    if (ac.signal.aborted) {
+      handle.complete();
+      return;
+    }
+    if (error instanceof Error && "code" in error) {
+      handle.fail(error);
+      return;
+    }
+    handle.fail(new LunoraError("HTTP_STREAM_TRANSPORT", error instanceof Error ? error.message : String(error), { cause: error }));
+  });
+  return iterable;
+};
+
+export { httpStream };

package/dist/packem_shared/{local-store-BveBeFEo.mjs → local-store-DIq-UWfD.mjs}

@@ -1,4 +1,4 @@
-import { S as SubscriptionRegistry } from './subscription-BjynOXCU.mjs';
+import { SubscriptionRegistry } from './SubscriptionRegistry-CxS_Inha.mjs';
 
 const foldOptimistic = (base, layers) => {
   let value = base;