@lunora/client 1.0.0-alpha.11 → 1.0.0-alpha.110

package/dist/packem_shared/offline-queue-7Wc4onA0.mjs

@@ -1,164 +0,0 @@
-const isStaleVersion = (current, stamped) => current !== void 0 && stamped !== current;
-
-let idCounter = 0;
-const nextId = () => {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  idCounter += 1;
-  const entropy = typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function" ? [...crypto.getRandomValues(new Uint8Array(8))].map((byte) => byte.toString(16).padStart(2, "0")).join("") : (
-    // eslint-disable-next-line sonarjs/pseudo-random -- non-cryptographic uniqueness entropy, not a security token; only reached when neither crypto.randomUUID nor crypto.getRandomValues exists
-    Math.random().toString(16).slice(2, 12)
-  );
-  return `m_${Date.now().toString(36)}_${idCounter.toString(36)}_${entropy}`;
-};
-const reportPersistenceError = (handler, operation, error, mutationId) => {
-  if (handler) {
-    handler({ error, mutationId, operation });
-    return;
-  }
-  console.warn(`[lunora] offline-queue persistence ${operation} failed`, error);
-};
-class OfflineQueue {
-  /** Opt-in to queueing mutations before the targeted shard's first connect. */
-  queueBeforeFirstConnect;
-  maxItems;
-  onPersistenceError;
-  persistence;
-  onEvict;
-  onSizeChange;
-  /** App/schema version stamped on persisted writes; mismatched records are purged on hydrate. */
-  version;
-  items = [];
-  constructor(options = {}, deps = {}) {
-    this.maxItems = options.maxItems ?? 1e3;
-    this.queueBeforeFirstConnect = options.queueBeforeFirstConnect ?? false;
-    this.onPersistenceError = options.onPersistenceError;
-    this.persistence = deps.persistence;
-    this.onEvict = deps.onEvict;
-    this.onSizeChange = deps.onSizeChange;
-    this.version = deps.version;
-  }
-  get size() {
-    return this.items.length;
-  }
-  enqueue(entry) {
-    const item = entry;
-    item.id ??= nextId();
-    this.items.push(item);
-    this.persistence?.append({
-      args: item.args,
-      functionPath: item.functionPath,
-      id: item.id,
-      identity: item.identity,
-      shardKey: item.shardKey,
-      ...this.version === void 0 ? {} : { version: this.version }
-    }).catch((error) => {
-      reportPersistenceError(this.onPersistenceError, "append", error, item.id);
-    });
-    while (this.items.length > this.maxItems) {
-      const dropped = this.items.shift();
-      if (dropped) {
-        if (dropped.id) {
-          this.persistence?.remove(dropped.id).catch((error2) => {
-            reportPersistenceError(this.onPersistenceError, "remove", error2, dropped.id);
-          });
-        }
-        const error = new Error("offline queue overflow");
-        error.code = "OFFLINE_QUEUE_OVERFLOW";
-        dropped.reject(error);
-        this.onEvict?.(dropped, error);
-      }
-    }
-    this.notifySize();
-  }
-  /**
-   * Restore mutations persisted in a prior session and re-queue them in FIFO
-   * order. Restored entries already live in durable storage, so they are not
-   * re-appended; they carry no-op `resolve`/`reject` (the original awaiter is
-   * gone after a reload). No-op when no persistence adapter is configured.
-   * Returns the distinct shard keys of the restored writes so the caller can
-   * open their sockets to trigger a flush.
-   */
-  async hydrate() {
-    if (!this.persistence) {
-      return [];
-    }
-    const persisted = await this.persistence.load();
-    const shardKeys = /* @__PURE__ */ new Set();
-    for (const mutation of persisted) {
-      if (this.items.some((item) => item.id === mutation.id)) {
-        continue;
-      }
-      if (isStaleVersion(this.version, mutation.version)) {
-        this.persistence.remove(mutation.id).catch((error) => {
-          reportPersistenceError(this.onPersistenceError, "remove", error, mutation.id);
-        });
-        continue;
-      }
-      this.items.push({
-        args: mutation.args,
-        functionPath: mutation.functionPath,
-        id: mutation.id,
-        identity: mutation.identity,
-        reject: () => void 0,
-        resolve: () => void 0,
-        shardKey: mutation.shardKey
-      });
-      shardKeys.add(mutation.shardKey);
-    }
-    this.notifySize();
-    return [...shardKeys];
-  }
-  /**
-   * Remove and return queued mutations. With no `predicate`, drains the whole
-   * queue. With one, drains only matching entries (preserving FIFO order) and
-   * leaves the rest queued — used to flush a single shard's writes when its
-   * socket reconnects while other shards are still down.
-   */
-  drain(predicate) {
-    if (!predicate) {
-      const drained2 = [...this.items];
-      this.items.length = 0;
-      this.notifySize();
-      return drained2;
-    }
-    const drained = [];
-    const kept = [];
-    for (const item of this.items) {
-      (predicate(item) ? drained : kept).push(item);
-    }
-    this.items.length = 0;
-    this.items.push(...kept);
-    this.notifySize();
-    return drained;
-  }
-  /**
-   * Return previously-drained mutations to the front of the queue, preserving
-   * their FIFO order, without re-persisting them — they were never unpersisted,
-   * so durable storage still holds them. Used when a flush aborts on a transient
-   * transport failure: the unreplayed writes stay queued for the next reconnect.
-   */
-  requeue(items) {
-    if (items.length === 0) {
-      return;
-    }
-    this.items.unshift(...items);
-    this.notifySize();
-  }
-  clear() {
-    for (const item of this.items) {
-      const error = new Error("CLIENT_CLOSED");
-      error.code = "CLIENT_CLOSED";
-      item.reject(error);
-    }
-    this.items.length = 0;
-    this.notifySize();
-  }
-  /** Notify the size observer (the client's pending-sync count) after any change. */
-  notifySize() {
-    this.onSizeChange?.(this.items.length);
-  }
-}
-
-export { OfflineQueue as O, isStaleVersion as i, nextId as n, reportPersistenceError as r };

package/dist/packem_shared/preload.d-BfWzGJWV.d.mts

@@ -1,20 +0,0 @@
-import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-Dm1BYq19.mjs";
-/**
-* Run a query once on the server (during SSR) and capture its result in a
-* serializable {@link Preloaded} token. Embed the token in the rendered HTML and
-* pass it to `usePreloadedQuery` on the client: the first client render shows
-* the server value with no loading flash, then a live subscription takes over.
-*
-* The query is executed through the supplied {@link LunoraClient} over the same
-* HTTP RPC path the browser uses, so the SSR client only needs a `fetch`
-* implementation that can reach the worker — no in-process Durable Object access.
-*/
-declare const preloadQuery: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
-  shardKey?: string;
-}) => Promise<Preloaded<ReturnOf<F>>>;
-/**
-* Read the captured value out of a {@link Preloaded} token without subscribing.
-* Useful on the server (or in tests) when you only need the data, not a live feed.
-*/
-declare const preloadedQueryResult: <T>(preloaded: Preloaded<T>) => T;
-export { preloadedQueryResult as a, preloadQuery as p };

package/dist/packem_shared/preload.d-Sp_Ef-_u.d.ts

@@ -1,20 +0,0 @@
-import { F as FunctionReference, L as LunoraClient, A as ArgsOf, R as ReturnOf, P as Preloaded } from "./lunora-client.d-Dm1BYq19.js";
-/**
-* Run a query once on the server (during SSR) and capture its result in a
-* serializable {@link Preloaded} token. Embed the token in the rendered HTML and
-* pass it to `usePreloadedQuery` on the client: the first client render shows
-* the server value with no loading flash, then a live subscription takes over.
-*
-* The query is executed through the supplied {@link LunoraClient} over the same
-* HTTP RPC path the browser uses, so the SSR client only needs a `fetch`
-* implementation that can reach the worker — no in-process Durable Object access.
-*/
-declare const preloadQuery: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
-  shardKey?: string;
-}) => Promise<Preloaded<ReturnOf<F>>>;
-/**
-* Read the captured value out of a {@link Preloaded} token without subscribing.
-* Useful on the server (or in tests) when you only need the data, not a live feed.
-*/
-declare const preloadedQueryResult: <T>(preloaded: Preloaded<T>) => T;
-export { preloadedQueryResult as a, preloadQuery as p };

package/dist/packem_shared/preloadQuery-lobFkD2Z.mjs

@@ -1,13 +0,0 @@
-const preloadQuery = async (client, function_, args, options = {}) => {
-  const value = await client.query(function_, args, options);
-  return {
-    __lunoraPreloaded: true,
-    args: args ?? {},
-    functionPath: function_.__lunoraRef,
-    shardKey: options.shardKey,
-    value
-  };
-};
-const preloadedQueryResult = (preloaded) => preloaded.value;
-
-export { preloadQuery, preloadedQueryResult };

package/dist/packem_shared/subscription-C1Jy7HiF.mjs

@@ -1,55 +0,0 @@
-const compareKeys = (a, b) => {
-  if (a < b) {
-    return -1;
-  }
-  return a > b ? 1 : 0;
-};
-const stableStringify = (value) => {
-  if (value === void 0) {
-    return "null";
-  }
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const record = value;
-  const keys = Object.keys(record).toSorted(compareKeys);
-  const parts = [];
-  for (const key of keys) {
-    const raw = record[key];
-    if (raw === void 0) {
-      continue;
-    }
-    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
-  }
-  return `{${parts.join(",")}}`;
-};
-
-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) {
-    this.byKey.delete(SubscriptionRegistry.key(state.fn.__lunoraRef, state.args, state.shardKey));
-    this.byId.delete(state.id);
-  }
-  all() {
-    return [...this.byKey.values()];
-  }
-}
-
-export { SubscriptionRegistry as S, stableStringify as s };