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

package/dist/packem_shared/createInMemoryQueryCache-DiaGZkA2.mjs

@@ -1,112 +0,0 @@
-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;
-const createInMemoryQueryCache = (options = {}) => {
-  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  const entries = /* @__PURE__ */ new Map();
-  const clone = (entry) => {
-    return { ...entry, value: structuredClone(entry.value) };
-  };
-  const evict = () => {
-    if (entries.size <= maxEntries) {
-      return;
-    }
-    const ordered = [...entries.values()].toSorted((a, b) => a.ts - b.ts);
-    for (const entry of ordered) {
-      if (entries.size <= maxEntries) {
-        break;
-      }
-      entries.delete(entry.key);
-    }
-  };
-  return {
-    clear: () => {
-      entries.clear();
-      return Promise.resolve();
-    },
-    load: () => Promise.resolve([...entries.values()].map((entry) => clone(entry))),
-    put: (key, entry) => {
-      entries.set(key, clone({ ...entry, key }));
-      evict();
-      return Promise.resolve();
-    },
-    remove: (key) => {
-      entries.delete(key);
-      return Promise.resolve();
-    }
-  };
-};
-const DEFAULT_DATABASE = "lunora-query-cache";
-const DEFAULT_STORE = "query-cache";
-const TS_INDEX = "by_ts";
-const DATABASE_VERSION = 1;
-const createIndexedDbQueryCache = (options = {}) => {
-  const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
-  if (!factory) {
-    throw new LunoraError("INTERNAL", "createIndexedDbQueryCache: no IndexedDB available — pass `indexedDB` or use createInMemoryQueryCache()");
-  }
-  const databaseName = options.databaseName ?? DEFAULT_DATABASE;
-  const storeName = options.storeName ?? DEFAULT_STORE;
-  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  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 });
-    }
-  });
-  const withStore = createWithStore(openDatabase, storeName);
-  const evict = async (store) => {
-    const count = await promisifyRequest(store.count());
-    let overflow = count - maxEntries;
-    if (overflow <= 0) {
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const cursorRequest = store.index(TS_INDEX).openCursor();
-      cursorRequest.addEventListener("success", () => {
-        const cursor = cursorRequest.result;
-        if (!cursor || overflow <= 0) {
-          resolve();
-          return;
-        }
-        cursor.delete();
-        overflow -= 1;
-        cursor.continue();
-      });
-      cursorRequest.addEventListener("error", () => {
-        reject(cursorRequest.error ?? new Error("IndexedDB eviction failed"));
-      });
-    });
-  };
-  return {
-    clear: async () => {
-      await withStore("readwrite", (store) => promisifyRequest(store.clear()));
-    },
-    load: async () => withStore("readonly", (store) => promisifyRequest(store.getAll())),
-    put: async (key, entry) => {
-      await withStore("readwrite", async (store) => {
-        await promisifyRequest(store.put({ ...entry, key }));
-        await evict(store);
-      });
-    },
-    remove: async (key) => {
-      await withStore("readwrite", (store) => promisifyRequest(store.delete(key)));
-    }
-  };
-};
-const resolveQueryCacheAdapter = (option) => {
-  if (option === false) {
-    return void 0;
-  }
-  if (option) {
-    return option;
-  }
-  if (typeof indexedDB === "undefined") {
-    return void 0;
-  }
-  return createIndexedDbQueryCache();
-};
-
-export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey, resolveQueryCacheAdapter };

package/dist/packem_shared/createLocalStore-BtqUmOQA.mjs

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

package/dist/packem_shared/createMutationRunner-BqsavzvG.mjs

@@ -1,21 +0,0 @@
-const createMutationRunner = (client, function_, sinks) => {
-  let inFlight = 0;
-  return async (args, options) => {
-    inFlight += 1;
-    sinks.setPending(true);
-    try {
-      const result = await client.mutation(function_, args, options);
-      sinks.setResult(result);
-      return result;
-    } catch (error) {
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      sinks.setError(normalized);
-      throw normalized;
-    } finally {
-      inFlight -= 1;
-      sinks.setPending(inFlight > 0);
-    }
-  };
-};
-
-export { createMutationRunner };

package/dist/packem_shared/createMutatorRunner-BETvCd0p.mjs

@@ -1,31 +0,0 @@
-const createMutatorRunner = (handle, sinks) => {
-  let inFlight = 0;
-  let latestInvocation = 0;
-  const mutate = async (args) => {
-    latestInvocation += 1;
-    const invocation = latestInvocation;
-    inFlight += 1;
-    sinks.setPending(true);
-    try {
-      await handle(args).isPersisted.promise;
-      if (invocation === latestInvocation) {
-        sinks.setError(void 0);
-      }
-    } catch (error) {
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      if (invocation === latestInvocation) {
-        sinks.setError(normalized);
-      }
-      throw normalized;
-    } finally {
-      inFlight -= 1;
-      sinks.setPending(inFlight > 0);
-    }
-  };
-  const reset = () => {
-    sinks.setError(void 0);
-  };
-  return { mutate, reset };
-};
-
-export { createMutatorRunner };

package/dist/packem_shared/createReconnect-Di_-oHH7.mjs

@@ -1,22 +0,0 @@
-const createReconnect = (options = {}, random = Math.random) => {
-  const initialDelayMs = options.initialDelayMs ?? 250;
-  const maxDelayMs = options.maxDelayMs ?? 3e4;
-  const jitter = options.jitter ?? true;
-  let attempt = 0;
-  return {
-    next() {
-      const exponential = Math.min(maxDelayMs, initialDelayMs * 2 ** attempt);
-      attempt += 1;
-      if (!jitter) {
-        return exponential;
-      }
-      const min = exponential / 2;
-      return Math.floor(min + random() * (exponential - min));
-    },
-    reset() {
-      attempt = 0;
-    }
-  };
-};
-
-export { createReconnect };

package/dist/packem_shared/createReply-lI4tVS2w.mjs

@@ -1,36 +0,0 @@
-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-Bp2r9tcB.mjs

@@ -1,11 +0,0 @@
-import { LunoraClient } from './LunoraClient-DKATLGHY.mjs';
-
-const createServerClient = (options) => {
-  const client = new LunoraClient({ fetch: options.fetch, url: options.url });
-  if (options.token !== void 0) {
-    client.setAuthToken(options.token);
-  }
-  return client;
-};
-
-export { createServerClient };

package/dist/packem_shared/createSnapshotPrecondition-CxQ1T4ZP.mjs

@@ -1,18 +0,0 @@
-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/deserializePreloaded-C0eJTY_W.mjs

@@ -1,4 +0,0 @@
-const serializePreloaded = (preloaded) => JSON.stringify(preloaded).replaceAll("<", String.raw`\u003c`);
-const deserializePreloaded = (serialized) => JSON.parse(serialized);
-
-export { deserializePreloaded, serializePreloaded };

package/dist/packem_shared/getServerSession-8jXewqxd.mjs

@@ -1,13 +0,0 @@
-const extractHeaders = (source) => {
-  if (source instanceof Headers) {
-    return source;
-  }
-  return source.headers;
-};
-const getServerSession = async (request, auth) => {
-  const headers = extractHeaders(request);
-  const result = await auth.api.getSession({ headers });
-  return result ?? null;
-};
-
-export { getServerSession };

package/dist/packem_shared/httpStream-DIdL8NEw.mjs

@@ -1,168 +0,0 @@
-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();
-  let onExternalAbort;
-  if (options.signal) {
-    if (options.signal.aborted) {
-      ac.abort();
-    } else {
-      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: () => {
-      ac.abort();
-    }
-  });
-  (async () => {
-    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();
-    }
-  })().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/idb-utility-DrSVX43Q.mjs

@@ -1,48 +0,0 @@
-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-DIq-UWfD.mjs

@@ -1,106 +0,0 @@
-import { SubscriptionRegistry } from './SubscriptionRegistry-CxS_Inha.mjs';
-
-const foldOptimistic = (base, layers) => {
-  let value = base;
-  for (const layer of layers) {
-    try {
-      value = layer.transform(value);
-    } catch {
-    }
-  }
-  return value;
-};
-const notifySubscription = (state, value) => {
-  if (value === state.lastValue) {
-    return;
-  }
-  state.lastValue = value;
-  for (const callback of state.callbacks) {
-    try {
-      callback(value);
-    } catch {
-    }
-  }
-};
-const applyOptimisticLayer = (state, optimistic) => {
-  let next;
-  try {
-    next = optimistic(state.lastValue);
-  } catch {
-    return void 0;
-  }
-  const layer = { id: /* @__PURE__ */ Symbol("optimistic"), transform: optimistic };
-  state.optimisticLayers.push(layer);
-  notifySubscription(state, next);
-  const remove = () => {
-    const index = state.optimisticLayers.findIndex((entry) => entry.id === layer.id);
-    if (index === -1) {
-      return false;
-    }
-    state.optimisticLayers.splice(index, 1);
-    return true;
-  };
-  const refold = () => {
-    notifySubscription(state, foldOptimistic(state.serverBase, state.optimisticLayers));
-  };
-  return {
-    confirm: (commitCursor) => {
-      if (commitCursor === void 0) {
-        remove();
-        return;
-      }
-      layer.commitCursor = commitCursor;
-      if (state.serverCursor !== void 0 && state.serverCursor >= commitCursor && remove()) {
-        refold();
-      }
-    },
-    rollback: () => {
-      if (remove()) {
-        refold();
-      }
-    }
-  };
-};
-const dropConfirmedLayers = (state, cursor) => {
-  if (cursor === void 0 || state.optimisticLayers.length === 0) {
-    return false;
-  }
-  const before = state.optimisticLayers.length;
-  state.optimisticLayers = state.optimisticLayers.filter((layer) => layer.commitCursor === void 0 || layer.commitCursor > cursor);
-  return state.optimisticLayers.length !== before;
-};
-
-const createLocalStore = (subscriptions, shardKey) => {
-  const confirms = [];
-  const rollbacks = [];
-  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 ?? "")) {
-          matches.push({ args: state.args, value: state.lastValue });
-        }
-      }
-      return matches;
-    },
-    getQuery: (function_, args) => {
-      const state = findState(function_.__lunoraRef, args ?? {});
-      return state?.lastValue;
-    },
-    setQuery: (function_, args, value) => {
-      const state = findState(function_.__lunoraRef, args ?? {});
-      if (!state) {
-        return;
-      }
-      const handle = applyOptimisticLayer(state, () => value);
-      if (handle) {
-        confirms.push(handle.confirm);
-        rollbacks.push(handle.rollback);
-      }
-    }
-  };
-  return { confirms, rollbacks, store };
-};
-
-export { applyOptimisticLayer as a, createLocalStore as c, dropConfirmedLayers as d, foldOptimistic as f, notifySubscription as n };