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

package/dist/packem_shared/offline-queue-N-1JvYb4.mjs

@@ -1,211 +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.
-   *
-   * `hydrate()` runs post-construction (the caller awaits an async durable-store
-   * load), so a mutation issued while offline during that boot window is
-   * enqueued into `items` *before* this method's `await` resolves. Restored
-   * records are therefore `unshift`-ed ahead of whatever is already queued
-   * rather than `push`-ed to the end: the durable store's persist order is
-   * authoritative (a prior-session write is always older than anything from
-   * this session), so replaying a same-session boot-time write before an
-   * older restored write on the same document would let last-writer-wins
-   * silently clobber the newer data with the stale one.
-   */
-  async hydrate() {
-    if (!this.persistence) {
-      return [];
-    }
-    let persisted;
-    try {
-      persisted = await this.persistence.load();
-    } catch (error) {
-      reportPersistenceError(this.onPersistenceError, "load", error);
-      throw error;
-    }
-    const shardKeys = /* @__PURE__ */ new Set();
-    const restored = [];
-    for (const mutation of persisted) {
-      if (this.items.some((item) => item.id === mutation.id) || restored.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;
-      }
-      restored.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.items.unshift(...restored);
-    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();
-  }
-  /**
-   * Remove mutations whose precondition evaluates to `false` (stale/dirty
-   * writes that should not replay) and reject each with an
-   * `OFFLINE_PRECONDITION_FAILED` error. The valid (admitted) mutations stay
-   * queued in FIFO order. Returns the drained stale entries.
-   *
-   * Called during reconnect before the flush cycle to weed out writes whose
-   * assumptions no longer hold (e.g. a document was deleted by another client).
-   */
-  drainConflict() {
-    const conflicted = [];
-    const kept = [];
-    for (const item of this.items) {
-      if (item.precondition !== void 0 && !item.precondition()) {
-        const error = new Error("offline mutation skipped: precondition failed before replay");
-        error.code = "OFFLINE_PRECONDITION_FAILED";
-        item.reject(error);
-        conflicted.push(item);
-      } else {
-        kept.push(item);
-      }
-    }
-    if (conflicted.length > 0) {
-      this.items.length = 0;
-      this.items.push(...kept);
-      this.notifySize();
-    }
-    return conflicted;
-  }
-  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/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/wire-key-Djie6aaR.mjs

@@ -1,266 +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 (typeof value === "bigint") {
-    throw new TypeError("stableStringify: cannot use a bigint in a stable JSON cache key — pass it as a string, or use stableWireKey");
-  }
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const proto = Object.getPrototypeOf(value);
-  if (proto !== null && proto !== Object.prototype) {
-    const name = value.constructor?.name ?? "value";
-    throw new TypeError(
-      `stableStringify: cannot use a ${name} in a stable JSON cache key — only plain objects, arrays, and JSON primitives are supported (wire-typed values key via stableWireKey)`
-    );
-  }
-  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(",")}}`;
-};
-
-const toBase64 = (bytes) => {
-  let binary = "";
-  const chunk = 32768;
-  for (let index = 0; index < bytes.length; index += chunk) {
-    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
-  }
-  return btoa(binary);
-};
-const fromBase64 = (base64) => {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.codePointAt(index) ?? 0;
-  }
-  return bytes;
-};
-
-const TAG = "$lunora.wire$";
-const MAX_DEPTH = 64;
-const MAX_BIGINT_DIGITS = 1024;
-const UNSAFE_KEY = "__proto__";
-const TYPED_ARRAY_CTORS = {
-  BigInt64Array,
-  BigUint64Array,
-  Float32Array,
-  Float64Array,
-  Int8Array,
-  Int16Array,
-  Int32Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Uint16Array,
-  Uint32Array
-};
-const ERROR_CTORS = {
-  Error,
-  EvalError,
-  RangeError,
-  ReferenceError,
-  SyntaxError,
-  TypeError,
-  URIError
-};
-const encodeWire = (value, depth = 0) => {
-  if (depth > MAX_DEPTH) {
-    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
-  }
-  if (value === void 0) {
-    return [TAG, "undefined"];
-  }
-  if (value === null) {
-    return null;
-  }
-  const kind = typeof value;
-  if (kind === "bigint") {
-    return [TAG, "bigint", value.toString()];
-  }
-  if (kind === "number") {
-    const numeric = value;
-    if (Number.isNaN(numeric)) {
-      return [TAG, "nan"];
-    }
-    if (numeric === Infinity) {
-      return [TAG, "inf"];
-    }
-    if (numeric === -Infinity) {
-      return [TAG, "-inf"];
-    }
-    return numeric;
-  }
-  if (kind !== "object") {
-    return value;
-  }
-  if (value instanceof Date) {
-    return [TAG, "date", encodeWire(value.getTime(), depth + 1)];
-  }
-  if (value instanceof Error) {
-    const error = value;
-    const properties = {};
-    for (const key of Object.keys(error)) {
-      if (error[key] !== void 0) {
-        properties[key] = encodeWire(error[key], depth + 1);
-      }
-    }
-    const encodedError = [TAG, "error", error.name, error.message, properties];
-    if (error.cause !== void 0) {
-      encodedError.push(encodeWire(error.cause, depth + 1));
-    }
-    return encodedError;
-  }
-  if (value instanceof URL) {
-    return [TAG, "url", value.href];
-  }
-  if (value instanceof Map) {
-    return [TAG, "map", [...value.entries()].map(([k, v]) => [encodeWire(k, depth + 1), encodeWire(v, depth + 1)])];
-  }
-  if (value instanceof Set) {
-    return [TAG, "set", [...value].map((item) => encodeWire(item, depth + 1))];
-  }
-  if (value instanceof ArrayBuffer) {
-    return [TAG, "bytes", toBase64(new Uint8Array(value)), "ArrayBuffer"];
-  }
-  if (ArrayBuffer.isView(value)) {
-    const view = value;
-    const ctorName = view.constructor.name;
-    const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
-    return ctorName === "Uint8Array" ? [TAG, "bytes", toBase64(bytes)] : [TAG, "bytes", toBase64(bytes), ctorName];
-  }
-  if (Array.isArray(value)) {
-    const encoded = value.map((item) => encodeWire(item, depth + 1));
-    return encoded.length > 0 && encoded[0] === TAG ? [TAG, "arr", encoded] : encoded;
-  }
-  const proto = Object.getPrototypeOf(value);
-  if (proto !== null && proto !== Object.prototype) {
-    const name = value.constructor?.name ?? "value";
-    throw new TypeError(
-      `wire-codec: cannot encode a ${name} over the Lunora wire — only plain objects, arrays, and the supported built-ins (Date, Error, URL, Map, Set, ArrayBuffer/typed arrays, bigint) round-trip`
-    );
-  }
-  const source = value;
-  const result = {};
-  for (const key of Object.keys(source)) {
-    const field = source[key];
-    if (field !== void 0) {
-      result[key] = encodeWire(field, depth + 1);
-    }
-  }
-  return result;
-};
-const decodeWire = (value, depth = 0) => {
-  if (depth > MAX_DEPTH) {
-    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
-  }
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    if (value[0] === TAG) {
-      const tag = value[1];
-      switch (tag) {
-        case "-inf": {
-          return -Infinity;
-        }
-        case "arr": {
-          return value[2].map((item) => decodeWire(item, depth + 1));
-        }
-        case "bigint": {
-          const raw = value[2];
-          if (typeof raw !== "string" || raw.length > MAX_BIGINT_DIGITS || !/^-?\d+$/.test(raw)) {
-            throw new RangeError(`wire-codec: invalid or over-long bigint (max ${MAX_BIGINT_DIGITS} digits)`);
-          }
-          return BigInt(raw);
-        }
-        case "date": {
-          return new Date(decodeWire(value[2], depth + 1));
-        }
-        case "map": {
-          return new Map(value[2].map(([k, v]) => [decodeWire(k, depth + 1), decodeWire(v, depth + 1)]));
-        }
-        case "set": {
-          return new Set(value[2].map((item) => decodeWire(item, depth + 1)));
-        }
-        case "url": {
-          return new URL(value[2]);
-        }
-        case "error": {
-          const name = value[2];
-          const message = value[3];
-          const Ctor = (Object.hasOwn(ERROR_CTORS, name) ? ERROR_CTORS[name] : void 0) ?? Error;
-          const error = new Ctor(message);
-          if (error.name !== name) {
-            Object.defineProperty(error, "name", { configurable: true, value: name, writable: true });
-          }
-          const props = decodeWire(value[4], depth + 1);
-          for (const key of Object.keys(props)) {
-            if (key === UNSAFE_KEY) {
-              Object.defineProperty(error, key, { configurable: true, enumerable: true, value: props[key], writable: true });
-            } else {
-              error[key] = props[key];
-            }
-          }
-          if (value.length > 5) {
-            Object.defineProperty(error, "cause", { configurable: true, value: decodeWire(value[5], depth + 1), writable: true });
-          }
-          return error;
-        }
-        case "bytes": {
-          const bytes = fromBase64(value[2]);
-          const ctorName = value[3] ?? "Uint8Array";
-          if (ctorName === "ArrayBuffer") {
-            return bytes.buffer.byteLength === bytes.byteLength ? bytes.buffer : bytes.slice().buffer;
-          }
-          const Ctor = Object.hasOwn(TYPED_ARRAY_CTORS, ctorName) ? TYPED_ARRAY_CTORS[ctorName] : void 0;
-          return Ctor ? new Ctor(bytes.slice().buffer) : bytes;
-        }
-        case "inf": {
-          return Infinity;
-        }
-        case "nan": {
-          return Number.NaN;
-        }
-        case "undefined": {
-          return void 0;
-        }
-        default: {
-          return value.map((item) => decodeWire(item, depth + 1));
-        }
-      }
-    }
-    return value.map((item) => decodeWire(item, depth + 1));
-  }
-  const source = value;
-  const result = {};
-  for (const key of Object.keys(source)) {
-    const decoded = decodeWire(source[key], depth + 1);
-    if (key === UNSAFE_KEY) {
-      Object.defineProperty(result, key, { configurable: true, enumerable: true, value: decoded, writable: true });
-    } else {
-      result[key] = decoded;
-    }
-  }
-  return result;
-};
-
-const stableWireKey = (value) => stableStringify(encodeWire(value));
-
-export { decodeWire as d, encodeWire as e, stableWireKey as s };