@spacemolt/lib 15.0.1 → 15.2.0

package/dist/index.js

@@ -78,7 +78,7 @@ var STATE_SECTIONS = [
   "prize_recoveries"
 ];
 // src/generated/actions.gen.ts
-var GENERATED_SPEC_VERSION = "v0.609.4";
+var GENERATED_SPEC_VERSION = "v0.612.0";
 var ACTIONS = {
   "spacemolt_arena/accept": {
     tool: "spacemolt_arena",
@@ -3641,6 +3641,21 @@ function errorFromActionFrame(frame) {
   });
 }
 
+class HttpError extends Error {
+  status;
+  url;
+  attempts;
+  retryAfterMs;
+  constructor(message, opts) {
+    super(message);
+    this.name = "HttpError";
+    this.status = opts.status;
+    this.url = opts.url;
+    this.attempts = opts.attempts;
+    this.retryAfterMs = opts.retryAfterMs;
+  }
+}
+
 class ConnectionClosedError extends Error {
   code;
   reason;
@@ -3902,6 +3917,11 @@ class ObservationCache {
   }
 }
 
+// src/jitter.ts
+function jitteredDelayMs(baseMs) {
+  return baseMs + Math.random() * Math.max(baseMs * 0.25, 250);
+}
+
 // src/state/cache.ts
 function copySection(target, source, section) {
   const value = source[section];
@@ -4239,6 +4259,36 @@ function retryAfterMs(err) {
   const seconds = fromDetails ?? (match ? Number(match[1]) : undefined);
   return Math.max(250, (seconds ?? 1) * 1000);
 }
+var AUTH_SECRET_PAYLOAD_FIELDS = new Set(["password", "token", "registration_code", "device_code"]);
+function redactForOnSend(frame) {
+  if (frame.tool !== "spacemolt_auth" || !isRecord(frame.payload))
+    return frame;
+  let redacted;
+  for (const field of AUTH_SECRET_PAYLOAD_FIELDS) {
+    if (field in frame.payload) {
+      redacted ??= { ...frame.payload };
+      redacted[field] = "[redacted]";
+    }
+  }
+  return redacted ? { ...frame, payload: redacted } : frame;
+}
+function redactForOnReceive(frame) {
+  if (frame.type === "registered" && isRecord(frame.payload) && "password" in frame.payload) {
+    return { ...frame, payload: { ...frame.payload, password: "[redacted]" } };
+  }
+  if (frame.type === "result" && isRecord(frame.payload)) {
+    const { structuredContent } = frame.payload;
+    if (isRecord(structuredContent) && typeof structuredContent.device_code === "string" && structuredContent.device_code) {
+      const code = structuredContent.device_code;
+      const result = typeof frame.payload.result === "string" && frame.payload.result.includes(code) ? frame.payload.result.split(code).join("[redacted]") : frame.payload.result;
+      return {
+        ...frame,
+        payload: { ...frame.payload, result, structuredContent: { ...structuredContent, device_code: "[redacted]" } }
+      };
+    }
+  }
+  return frame;
+}
 function requireStructuredContent(result, command) {
   if (result.structuredContent === undefined) {
     throw new SpacemoltError("invalid_response", `${command} returned no structured content`);
@@ -4256,6 +4306,8 @@ class Account {
   seedState;
   url;
   webSocketFactory;
+  onSend;
+  onReceive;
   reconnectConfig;
   credentialsProvider;
   fetchImpl;
@@ -4268,6 +4320,7 @@ class Account {
   requestSeq = 0;
   _welcome = null;
   _authenticated = false;
+  reconnectsPending = 0;
   _loginPayload = null;
   _currentTick = 0;
   _commands = null;
@@ -4287,10 +4340,13 @@ class Account {
   reconnectedListeners = new Set;
   reconnectingListeners = new Set;
   disconnectedListeners = new Set;
+  rateLimitedListeners = new Set;
   constructor(opts = {}) {
     this.seedState = opts.seedState ?? true;
     this.url = opts.url ?? DEFAULT_URL;
     this.webSocketFactory = opts.webSocketFactory;
+    this.onSend = opts.onSend;
+    this.onReceive = opts.onReceive;
     this.credentialsProvider = opts.credentials;
     this.fetchImpl = opts.fetchImpl;
     this.maxRateLimitRetries = opts.maxRateLimitRetries ?? 5;
@@ -4384,37 +4440,47 @@ class Account {
     return this.open();
   }
   async open() {
+    const socket = this.socket;
     this._welcome = null;
-    await this.socket.connect();
+    await socket.connect();
     if (this._welcome)
       return this._welcome;
+    let waiter;
     const waitForWelcome = new Promise((resolve, reject) => {
-      this.welcomeWaiter = { resolve, reject };
+      waiter = { resolve, reject };
+      this.welcomeWaiter = waiter;
     });
     try {
       return await withTimeout(waitForWelcome, this.connectTimeoutMs, `No welcome frame received within ${this.connectTimeoutMs}ms`);
     } catch (err) {
-      this.welcomeWaiter = null;
-      this.socket.close();
+      if (waiter && this.welcomeWaiter === waiter)
+        this.welcomeWaiter = null;
+      if (this.socket === socket)
+        socket.close();
       throw err;
     }
   }
   async register(params) {
+    let authEntry;
     const registerPromise = new Promise((resolve, reject) => {
-      this.beginAuth((state, registered) => {
+      const accepted = this.beginAuth((state, registered) => {
         if (!registered) {
           reject(new SpacemoltError("missing_credentials", "register succeeded but no credentials frame was received"));
           return;
         }
         resolve({ password: registered.password, player_id: registered.player_id, state });
       }, reject);
-      this.sendFrame("spacemolt_auth", "register", { ...params }, this.nextRequestId());
+      if (accepted)
+        authEntry = this.pendingAuth ?? undefined;
+      if (accepted)
+        this.sendFrame("spacemolt_auth", "register", { ...params }, this.nextRequestId());
     });
     let result;
     try {
       result = await withTimeout(registerPromise, this.connectTimeoutMs, `No register response received within ${this.connectTimeoutMs}ms`);
     } catch (err) {
-      this.pendingAuth = null;
+      if (authEntry && this.pendingAuth === authEntry)
+        this.pendingAuth = null;
       throw err;
     }
     this._loginPayload = result.state;
@@ -4428,7 +4494,7 @@ class Account {
     return this.authExchange("login_token", { token });
   }
   authenticate(creds) {
-    return this.withRateLimitRetry(() => this.authenticateOnce(creds));
+    return this.withRateLimitRetry("authenticate", () => this.authenticateOnce(creds));
   }
   async authenticateOnce(creds) {
     switch (creds.kind) {
@@ -4486,7 +4552,7 @@ class Account {
     this._authenticated = false;
   }
   query(tool, action, payload, requestId) {
-    return this.withRateLimitRetry(async () => {
+    return this.withRateLimitRetry(`${tool}.${action}`, async () => {
       const id = this.claimRequestId(requestId);
       const promise = this.correlator.awaitQuery(id);
       try {
@@ -4500,7 +4566,7 @@ class Account {
   }
   mutate(tool, action, payload, onAck, requestId) {
     const mutationTimeoutMs = TRANSIT_ACTIONS.has(`${tool}/${action}`) ? this.mutationTimeoutMs : this.fastMutationTimeoutMs;
-    return this.enqueueMutation(() => this.withRateLimitRetry(() => {
+    return this.enqueueMutation(() => this.withRateLimitRetry(`${tool}.${action}`, () => {
       const id = this.claimRequestId(requestId);
       return this.awaitMutationWithTimeout(id, mutationTimeoutMs, () => this.sendFrame(tool, action, payload, id), onAck);
     }));
@@ -4779,6 +4845,12 @@ class Account {
       this.reconnectingListeners.delete(listener);
     };
   }
+  onRateLimited(listener) {
+    this.rateLimitedListeners.add(listener);
+    return () => {
+      this.rateLimitedListeners.delete(listener);
+    };
+  }
   onDisconnected(listener) {
     this.disconnectedListeners.add(listener);
     return () => {
@@ -4786,15 +4858,20 @@ class Account {
     };
   }
   async authExchange(action, payload) {
+    let authEntry;
     const authPromise = new Promise((resolve, reject) => {
-      this.beginAuth(resolve, reject);
-      this.sendFrame("spacemolt_auth", action, payload, this.nextRequestId());
+      const accepted = this.beginAuth(resolve, reject);
+      if (accepted)
+        authEntry = this.pendingAuth ?? undefined;
+      if (accepted)
+        this.sendFrame("spacemolt_auth", action, payload, this.nextRequestId());
     });
     let state;
     try {
       state = await withTimeout(authPromise, this.connectTimeoutMs, `No auth response received within ${this.connectTimeoutMs}ms`);
     } catch (err) {
-      this.pendingAuth = null;
+      if (authEntry && this.pendingAuth === authEntry)
+        this.pendingAuth = null;
       throw err;
     }
     this._loginPayload = state;
@@ -4811,16 +4888,32 @@ class Account {
   beginAuth(onLoggedIn, onError) {
     if (this.pendingAuth) {
       onError(new SpacemoltError("auth_in_progress", "another auth exchange is already in flight"));
-      return;
+      return false;
     }
     if (this._authenticated) {
       onError(new SpacemoltError("already_authenticated", "this connection is already authenticated"));
-      return;
+      return false;
     }
     this.pendingAuth = { onLoggedIn, onError };
+    return true;
   }
   sendFrame(tool, action, payload, requestId) {
-    this.socket.send({ tool, action, ...payload ? { payload } : {}, request_id: requestId });
+    const isAuthHandshake = tool === "spacemolt_auth" && action !== "logout";
+    if (this.reconnectsPending > 0 && !this._authenticated && !isAuthHandshake) {
+      throw new ConnectionClosedError("cannot send: account is reconnecting");
+    }
+    const frame = { tool, action, ...payload ? { payload } : {}, request_id: requestId };
+    this.callHook(this.onSend, "onSend", redactForOnSend(frame));
+    this.socket.send(frame);
+  }
+  callHook(hook, label, ...args) {
+    if (!hook)
+      return;
+    try {
+      hook(...args);
+    } catch (err) {
+      console.warn(`[spacemolt] ${label} hook threw: ${err}`);
+    }
   }
   nextRequestId() {
     let id = `r${++this.requestSeq}`;
@@ -4837,6 +4930,7 @@ class Account {
     return requestId;
   }
   routeFrame(frame) {
+    this.callHook(this.onReceive, "onReceive", redactForOnReceive(frame));
     if (isRecord(frame.payload))
       this.observeTick(frame.payload.tick);
     switch (frame.type) {
@@ -4924,10 +5018,9 @@ class Account {
   warnMalformedFrame(frame) {
     console.warn(`[spacemolt] dropped malformed ${frame.type} frame`);
   }
-  handleClose(err) {
+  failPendingWork(err) {
     this._authenticated = false;
     this.correlator.rejectAll(err);
-    this.emitter.closeStreams();
     if (this.welcomeWaiter) {
       const waiter = this.welcomeWaiter;
       this.welcomeWaiter = null;
@@ -4938,6 +5031,10 @@ class Account {
       this.pendingAuth = null;
       auth.onError(err);
     }
+  }
+  handleClose(err) {
+    this.failPendingWork(err);
+    this.emitter.closeStreams();
     if (this.reconnecting) {
       this.attemptClose = err;
       return;
@@ -5001,11 +5098,17 @@ class Account {
     };
     stopIfClosed();
     this.socket.close();
-    this.makeSocket();
-    await this.open();
-    stopIfClosed();
-    await this.authenticate(await this.credentialsProvider());
-    stopIfClosed();
+    this.reconnectsPending++;
+    this.failPendingWork(new ConnectionClosedError("account is reconnecting"));
+    try {
+      this.makeSocket();
+      await this.open();
+      stopIfClosed();
+      await this.authenticate(await this.credentialsProvider());
+      stopIfClosed();
+    } finally {
+      this.reconnectsPending--;
+    }
     await this.resubscribe();
   }
   async resubscribe() {
@@ -5020,13 +5123,15 @@ class Account {
       } catch {}
     }
   }
-  async withRateLimitRetry(fn) {
+  async withRateLimitRetry(command, fn) {
     for (let attempt = 0;; attempt++) {
       try {
         return await fn();
       } catch (err) {
         if (err instanceof SpacemoltError && err.code === "rate_limited" && attempt < this.maxRateLimitRetries) {
-          await delay(retryAfterMs(err));
+          const delayMs = jitteredDelayMs(retryAfterMs(err));
+          notifyListeners(this.rateLimitedListeners, "onRateLimited", { command, attempt: attempt + 1, delayMs });
+          await delay(delayMs);
           continue;
         }
         throw err;
@@ -5062,6 +5167,46 @@ class MemoryCredentialStore {
   }
 }
 
+// src/data/http.ts
+var MAX_RETRIES = 3;
+var BASE_BACKOFF_MS = 500;
+var MAX_RETRY_WAIT_MS = 60000;
+var delay2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function parseRetryAfterMs(header) {
+  if (!header)
+    return;
+  const seconds = Number(header);
+  if (!Number.isNaN(seconds))
+    return Math.max(0, seconds * 1000);
+  const dateMs = Date.parse(header);
+  return Number.isNaN(dateMs) ? undefined : Math.max(0, dateMs - Date.now());
+}
+async function httpGet(url, opts = {}) {
+  const { headers, timeoutMs = 30000, fetchImpl = fetch, okStatuses = [], maxRetryWaitMs = MAX_RETRY_WAIT_MS } = opts;
+  let totalBaseWaitMs = 0;
+  for (let attempt = 1;; attempt++) {
+    const res = await fetchImpl(url, { headers, signal: AbortSignal.timeout(timeoutMs) });
+    if (res.ok || okStatuses.includes(res.status))
+      return res;
+    const retryAfterMs = parseRetryAfterMs(res.headers.get("retry-after"));
+    const baseWaitMs = retryAfterMs ?? BASE_BACKOFF_MS * 2 ** (attempt - 1);
+    const retryable = (res.status === 429 || res.status === 503) && totalBaseWaitMs + baseWaitMs <= maxRetryWaitMs;
+    if (retryable && attempt <= MAX_RETRIES) {
+      totalBaseWaitMs += baseWaitMs;
+      await res.body?.cancel().catch(() => {});
+      await delay2(jitteredDelayMs(baseWaitMs));
+      continue;
+    }
+    await res.body?.cancel().catch(() => {});
+    throw new HttpError(`GET ${url} -> ${res.status} ${res.statusText}`, {
+      status: res.status,
+      url,
+      attempts: attempt,
+      retryAfterMs
+    });
+  }
+}
+
 // src/data/catalog.ts
 function catalogEntries(value) {
   return Array.isArray(value) ? value.filter(isRecord) : [];
@@ -5082,16 +5227,14 @@ function normalizeCatalog(value) {
     hidden_faction_achievement_count: typeof data.hidden_faction_achievement_count === "number" ? data.hidden_faction_achievement_count : 0
   };
 }
-async function fetchCatalogConditional(httpBaseUrl, etag) {
+async function fetchCatalogConditional(httpBaseUrl, etag, opts = {}) {
   const url = `${httpBaseUrl.replace(/\/$/, "")}/api/catalog.json`;
   const headers = { accept: "application/json" };
   if (etag)
     headers["if-none-match"] = etag;
-  const res = await fetch(url, { headers });
+  const res = await httpGet(url, { headers, fetchImpl: opts.fetchImpl, timeoutMs: opts.timeoutMs, okStatuses: [304] });
   if (res.status === 304)
     return { notModified: true, etag };
-  if (!res.ok)
-    throw new Error(`GET ${url} -> ${res.status} ${res.statusText}`);
   const data = await res.json();
   return {
     notModified: false,
@@ -5099,8 +5242,8 @@ async function fetchCatalogConditional(httpBaseUrl, etag) {
     etag: res.headers?.get?.("etag") ?? undefined
   };
 }
-async function fetchCatalog(httpBaseUrl) {
-  const { catalog } = await fetchCatalogConditional(httpBaseUrl);
+async function fetchCatalog(httpBaseUrl, opts = {}) {
+  const { catalog } = await fetchCatalogConditional(httpBaseUrl, undefined, opts);
   if (!catalog)
     throw new Error("unconditional catalog fetch returned no catalog");
   return catalog;
@@ -5125,14 +5268,14 @@ class CatalogCache {
     this.facilitiesById = index(catalog.facilities);
     this.achievementsById = index([...catalog.achievements, ...catalog.faction_achievements]);
   }
-  static async load(httpBaseUrl) {
-    const { catalog, etag } = await fetchCatalogConditional(httpBaseUrl);
+  static async load(httpBaseUrl, opts = {}) {
+    const { catalog, etag } = await fetchCatalogConditional(httpBaseUrl, undefined, opts);
     if (!catalog)
       throw new Error("unconditional catalog fetch returned no catalog");
     return new CatalogCache(catalog, etag);
   }
-  async revalidate(httpBaseUrl) {
-    const result = await fetchCatalogConditional(httpBaseUrl, this.etag);
+  async revalidate(httpBaseUrl, opts = {}) {
+    const result = await fetchCatalogConditional(httpBaseUrl, this.etag, opts);
     if (result.notModified)
       return this;
     if (!result.catalog)
@@ -5199,11 +5342,13 @@ function index(entries) {
 }
 
 // src/data/map.ts
-async function fetchMap(httpBaseUrl) {
+async function fetchMap(httpBaseUrl, opts = {}) {
   const url = `${httpBaseUrl.replace(/\/$/, "")}/api/map`;
-  const res = await fetch(url, { headers: { accept: "application/json" } });
-  if (!res.ok)
-    throw new Error(`GET ${url} -> ${res.status} ${res.statusText}`);
+  const res = await httpGet(url, {
+    headers: { accept: "application/json" },
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs
+  });
   const data = requireRecord(await res.json(), "map response");
   const systems = Array.isArray(data.systems) ? data.systems.filter((system) => isRecord(system)) : [];
   const empires = isRecord(data.empires) ? Object.fromEntries(Object.entries(data.empires).filter((entry) => typeof entry[1] === "string")) : {};
@@ -5222,8 +5367,8 @@ class MapCache {
         this.bySystemId.set(id, system);
     }
   }
-  static async load(httpBaseUrl) {
-    return new MapCache(await fetchMap(httpBaseUrl));
+  static async load(httpBaseUrl, opts = {}) {
+    return new MapCache(await fetchMap(httpBaseUrl, opts));
   }
   system(id) {
     return this.bySystemId.get(id);
@@ -5245,11 +5390,39 @@ function httpBaseFromWs(wsUrl) {
   }
 }
 
+// src/data/mobile-base.ts
+async function fetchMobileBase(httpBaseUrl, opts = {}) {
+  const url = `${httpBaseUrl.replace(/\/$/, "")}/wheres-mobile-base`;
+  const res = await httpGet(url, {
+    headers: { accept: "application/json" },
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs
+  });
+  const data = requireRecord(await res.json(), "mobile base response");
+  if (typeof data.system !== "string")
+    throw new Error("mobile base response is missing a system id");
+  return { system: data.system };
+}
+
+// src/data/stations.ts
+async function fetchStations(httpBaseUrl, opts = {}) {
+  const url = `${httpBaseUrl.replace(/\/$/, "")}/api/stations`;
+  const res = await httpGet(url, {
+    headers: { accept: "application/json" },
+    fetchImpl: opts.fetchImpl,
+    timeoutMs: opts.timeoutMs
+  });
+  const data = requireRecord(await res.json(), "stations response");
+  const stations = Array.isArray(data.stations) ? data.stations.filter(isRecord) : [];
+  const empires = Array.isArray(data.empires) ? data.empires.filter((empire) => isRecord(empire) && typeof empire.id === "string" && typeof empire.name === "string") : [];
+  return { stations, empires };
+}
+
 // src/client.ts
 var DEFAULT_HTTP_BASE = "https://game.spacemolt.com";
 var DEFAULT_CONNECT_RETRY = { maxRetries: 8, baseDelayMs: 2000, maxDelayMs: 60000 };
 var CONNECT_RATE_WINDOW_MS = 60000;
-var delay2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var delay3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 class SpacemoltClient {
   opts;
@@ -5293,21 +5466,30 @@ class SpacemoltClient {
   get httpBaseUrl() {
     return this.opts.httpBaseUrl ?? (this.opts.url ? httpBaseFromWs(this.opts.url) : DEFAULT_HTTP_BASE);
   }
+  get httpOptions() {
+    return { fetchImpl: this.opts.fetchImpl, timeoutMs: this.opts.httpTimeoutMs };
+  }
   async catalog(force = false) {
     const maxAgeMs = this.opts.catalogMaxAgeMs ?? 3600000;
     const cached = this.catalogCache;
     const fresh = cached && !force && Date.now() - this.catalogFetchedAt < maxAgeMs;
     if (fresh)
       return cached;
-    this.catalogCache = !this.catalogCache || force ? await CatalogCache.load(this.httpBaseUrl) : await this.catalogCache.revalidate(this.httpBaseUrl);
+    this.catalogCache = !this.catalogCache || force ? await CatalogCache.load(this.httpBaseUrl, this.httpOptions) : await this.catalogCache.revalidate(this.httpBaseUrl, this.httpOptions);
     this.catalogFetchedAt = Date.now();
     return this.catalogCache;
   }
   async map(force = false) {
     if (force || !this.mapCache)
-      this.mapCache = await MapCache.load(this.httpBaseUrl);
+      this.mapCache = await MapCache.load(this.httpBaseUrl, this.httpOptions);
     return this.mapCache;
   }
+  stations() {
+    return fetchStations(this.httpBaseUrl, this.httpOptions);
+  }
+  mobileBase() {
+    return fetchMobileBase(this.httpBaseUrl, this.httpOptions);
+  }
   get credentialStore() {
     return this.store;
   }
@@ -5355,7 +5537,7 @@ class SpacemoltClient {
         lastErr = err;
         if (i < retry.maxRetries) {
           const retryAfterMs = retryAfterMsFromClose(err);
-          await delay2(retryAfterMs ?? Math.min(retry.baseDelayMs * 2 ** i, retry.maxDelayMs));
+          await delay3(retryAfterMs ?? Math.min(retry.baseDelayMs * 2 ** i, retry.maxDelayMs));
         }
       }
     }
@@ -5458,10 +5640,10 @@ class SpacemoltClient {
     while (this.rateLimitedQueue.length > 0) {
       if (!isFirst) {
         if (batchSize > 0 && ranInCurrentBatch >= batchSize) {
-          await delay2(batchWaitMs);
+          await delay3(batchWaitMs);
           ranInCurrentBatch = 0;
         } else if (stagger > 0) {
-          await delay2(stagger);
+          await delay3(stagger);
         }
       }
       isFirst = false;
@@ -5520,6 +5702,8 @@ class SpacemoltClient {
       id,
       url: this.opts.url,
       webSocketFactory: this.opts.webSocketFactory,
+      onSend: this.opts.onSend && ((f) => this.opts.onSend?.(id, f)),
+      onReceive: this.opts.onReceive && ((f) => this.opts.onReceive?.(id, f)),
       seedState: this.opts.seedState,
       reconnect: false,
       fetchImpl: this.opts.fetchImpl,
@@ -5542,28 +5726,6 @@ class SpacemoltClient {
     }
   }
 }
-// src/data/stations.ts
-async function fetchStations(httpBaseUrl) {
-  const url = `${httpBaseUrl.replace(/\/$/, "")}/api/stations`;
-  const res = await fetch(url, { headers: { accept: "application/json" } });
-  if (!res.ok)
-    throw new Error(`GET ${url} -> ${res.status} ${res.statusText}`);
-  const data = requireRecord(await res.json(), "stations response");
-  const stations = Array.isArray(data.stations) ? data.stations.filter(isRecord) : [];
-  const empires = Array.isArray(data.empires) ? data.empires.filter((empire) => isRecord(empire) && typeof empire.id === "string" && typeof empire.name === "string") : [];
-  return { stations, empires };
-}
-// src/data/mobile-base.ts
-async function fetchMobileBase(httpBaseUrl) {
-  const url = `${httpBaseUrl.replace(/\/$/, "")}/wheres-mobile-base`;
-  const res = await fetch(url, { headers: { accept: "application/json" } });
-  if (!res.ok)
-    throw new Error(`GET ${url} -> ${res.status} ${res.statusText}`);
-  const data = requireRecord(await res.json(), "mobile base response");
-  if (typeof data.system !== "string")
-    throw new Error("mobile base response is missing a system id");
-  return { system: data.system };
-}
 // src/generated/notifications.gen.ts
 var TYPED_NOTIFICATION_TYPES = [
   "achievement_unlocked",
@@ -5599,6 +5761,7 @@ var TYPED_NOTIFICATION_TYPES = [
   "faction_peace_proposal",
   "faction_war_declared",
   "fleet",
+  "gift_received",
   "market_update",
   "mining_yield",
   "observation_update",
@@ -5677,6 +5840,7 @@ export {
   EventStream,
   FLEET_PUSH_ACTIONS,
   GENERATED_SPEC_VERSION,
+  HttpError,
   MapCache,
   MarketCache,
   MemoryCredentialStore,

package/dist/jitter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adds random jitter to a retry delay, so multiple callers retrying together
+ * (e.g. a fleet of accounts sharing a per-IP rate limit) don't all wake up
+ * and retry in the same instant. Extra is uniform in `[0, max(25% of base,
+ * 250ms))`. Shared by the WebSocket rate-limit retry (`account.ts`) and the
+ * HTTP retry (`data/http.ts`).
+ */
+export declare function jitteredDelayMs(baseMs: number): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spacemolt/lib",
-  "version": "15.0.1",
+  "version": "15.2.0",
   "description": "The definitive TypeScript library for SpaceMolt. WebSocket-v2-first, multi-account, with local state caches. Internals are regenerated from the server's OpenAPI spec.",
   "type": "module",
   "module": "./dist/index.js",