@spacemolt/lib 9.0.0 → 10.0.0

package/dist/data/catalog.d.ts

@@ -1,9 +1,13 @@
+import type { FacilityDefinition, Item, Module, Recipe, ShipClass, SkillDefinition } from '../generated/openapi/types.gen.js';
 /**
  * Local copy of the bulk game catalog (`GET /api/catalog.json`).
  *
  * Reference data — ships, items, recipes, skills, facilities — that changes
- * only on a server release. The entry shapes aren't in the v2 OpenAPI spec, so
- * they're typed loosely with `id`-keyed lookups.
+ * only on a server release. Entry shapes come from the spec's published
+ * `CatalogDump` component types (`ShipClass`, `Item`/`Module`, `Recipe`,
+ * `SkillDefinition`, `FacilityDefinition`), so they track the server via the
+ * spec sync. Entries are structurally validated as JSON objects and then
+ * trusted to match the spec — the same trust model as state-cache deltas.
  *
  * The payload is large (multiple MB), so the server ships it `public,
  * max-age=3600` with a content-hash `ETag`. We keep that ETag on the cache and
@@ -12,17 +16,20 @@
  * catalog after a server release instead of holding the copy it fetched at
  * startup forever (see `SpacemoltClient.catalog`).
  */
-export interface CatalogEntry {
-    id?: string;
-    [key: string]: unknown;
-}
+/** A ship entry — the spec's `ShipClass` (the dump omits live prices). */
+export type CatalogShip = ShipClass;
+/** An item entry — regular items and modules share the merged `items` list. */
+export type CatalogItem = Item | Module;
+export type CatalogRecipe = Recipe;
+export type CatalogSkill = SkillDefinition;
+export type CatalogFacility = FacilityDefinition;
 export interface Catalog {
     version?: string;
-    ships: CatalogEntry[];
-    items: CatalogEntry[];
-    recipes: CatalogEntry[];
-    skills: CatalogEntry[];
-    facilities: CatalogEntry[];
+    ships: CatalogShip[];
+    items: CatalogItem[];
+    recipes: CatalogRecipe[];
+    skills: CatalogSkill[];
+    facilities: CatalogFacility[];
 }
 /** Result of a conditional catalog fetch. */
 export interface CatalogFetchResult {
@@ -46,7 +53,11 @@ export declare class CatalogCache {
     readonly catalog: Catalog;
     /** The server `ETag` this catalog was fetched with, for conditional reloads. */
     readonly etag?: string | undefined;
-    private readonly indexes;
+    private readonly shipsById;
+    private readonly itemsById;
+    private readonly recipesById;
+    private readonly skillsById;
+    private readonly facilitiesById;
     constructor(catalog: Catalog, 
     /** The server `ETag` this catalog was fetched with, for conditional reloads. */
     etag?: string | undefined);
@@ -59,14 +70,14 @@ export declare class CatalogCache {
      */
     revalidate(httpBaseUrl: string): Promise<CatalogCache>;
     get version(): string | undefined;
-    ship(id: string): CatalogEntry | undefined;
-    item(id: string): CatalogEntry | undefined;
-    recipe(id: string): CatalogEntry | undefined;
-    skill(id: string): CatalogEntry | undefined;
-    facility(id: string): CatalogEntry | undefined;
-    get ships(): readonly CatalogEntry[];
-    get items(): readonly CatalogEntry[];
-    get recipes(): readonly CatalogEntry[];
-    get skills(): readonly CatalogEntry[];
-    get facilities(): readonly CatalogEntry[];
+    ship(id: string): CatalogShip | undefined;
+    item(id: string): CatalogItem | undefined;
+    recipe(id: string): CatalogRecipe | undefined;
+    skill(id: string): CatalogSkill | undefined;
+    facility(id: string): CatalogFacility | undefined;
+    get ships(): readonly CatalogShip[];
+    get items(): readonly CatalogItem[];
+    get recipes(): readonly CatalogRecipe[];
+    get skills(): readonly CatalogSkill[];
+    get facilities(): readonly CatalogFacility[];
 }

package/dist/data/stations.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Station directory (`GET /api/stations`).
+ *
+ * A public summary of every station in the galaxy — identity, owning
+ * empire/faction, system, offered services, condition, and defensive posture —
+ * plus the empire display list the server sends alongside it. Live data (the
+ * server caches it for ~10s), so fetch on demand rather than caching like the
+ * catalog or map.
+ *
+ * These shapes mirror the server's station list response; they aren't
+ * published in the OpenAPI spec yet (see docs/gameserver-todo.md), so they're
+ * hand-typed here and kept tolerant of server-side additions via the index
+ * signature.
+ */
+export interface StationSummary {
+    id: string;
+    name: string;
+    description: string;
+    empire?: string;
+    empire_name?: string;
+    faction_id?: string;
+    faction_name?: string;
+    faction_tag?: string;
+    faction_color?: string;
+    system_id: string;
+    system_name: string;
+    services: string[];
+    condition: string;
+    condition_text: string;
+    satisfaction_pct: number;
+    facility_count: number;
+    /** Damage per tick the station's armed guns can actually deliver — zero when its batteries are out of shells. */
+    weapon_dps: number;
+    wrecked: boolean;
+    [key: string]: unknown;
+}
+/** An empire display entry from the station list (`{ id, name }`). */
+export interface StationEmpire {
+    id: string;
+    name: string;
+}
+export interface StationList {
+    stations: StationSummary[];
+    empires: StationEmpire[];
+}
+/** Fetch the public station directory. */
+export declare function fetchStations(httpBaseUrl: string): Promise<StationList>;

package/dist/index.d.ts

@@ -20,8 +20,9 @@ export { MarketCache, type MarketBook, type MarketItem } from './state/market.js
 export { ObservationCache, type ObservationView, type ObservedPlayer, type CloakedContact, } from './state/observation.js';
 export { TypedEmitter, EventStream } from './events/emitter.js';
 export { type Commands, type CommandDispatch, buildCommands } from './generated/commands.gen.js';
-export { CatalogCache, fetchCatalog, fetchCatalogConditional, type Catalog, type CatalogEntry, type CatalogFetchResult, } from './data/catalog.js';
+export { CatalogCache, fetchCatalog, fetchCatalogConditional, type Catalog, type CatalogFacility, type CatalogFetchResult, type CatalogItem, type CatalogRecipe, type CatalogShip, type CatalogSkill, } from './data/catalog.js';
 export { MapCache, fetchMap, httpBaseFromWs, type GalaxyMap, type MapSystem } from './data/map.js';
+export { fetchStations, type StationEmpire, type StationList, type StationSummary } from './data/stations.js';
 export { Socket, type SocketOptions, type WebSocketLike, type WebSocketFactory, type MessageEventLike, type CloseEventLike, } from './transport/socket.js';
 export { ACTIONS, GENERATED_SPEC_VERSION } from './generated/actions.gen.js';
 export type { ToolName, ActionName, ActionDef, ActionParam } from './generated/actions.gen.js';

package/dist/index.js

@@ -4389,7 +4389,7 @@ class MemoryCredentialStore {
 
 // src/data/catalog.ts
 function catalogEntries(value) {
-  return Array.isArray(value) ? value.filter((entry) => isRecord(entry)) : [];
+  return Array.isArray(value) ? value.filter(isRecord) : [];
 }
 function normalizeCatalog(value) {
   const data = requireRecord(value, "catalog response");
@@ -4429,17 +4429,19 @@ async function fetchCatalog(httpBaseUrl) {
 class CatalogCache {
   catalog;
   etag;
-  indexes;
+  shipsById;
+  itemsById;
+  recipesById;
+  skillsById;
+  facilitiesById;
   constructor(catalog, etag) {
     this.catalog = catalog;
     this.etag = etag;
-    this.indexes = {
-      ships: index(catalog.ships),
-      items: index(catalog.items),
-      recipes: index(catalog.recipes),
-      skills: index(catalog.skills),
-      facilities: index(catalog.facilities)
-    };
+    this.shipsById = index(catalog.ships);
+    this.itemsById = index(catalog.items);
+    this.recipesById = index(catalog.recipes);
+    this.skillsById = index(catalog.skills);
+    this.facilitiesById = index(catalog.facilities);
   }
   static async load(httpBaseUrl) {
     const { catalog, etag } = await fetchCatalogConditional(httpBaseUrl);
@@ -4459,19 +4461,19 @@ class CatalogCache {
     return this.catalog.version;
   }
   ship(id) {
-    return this.indexes.ships.get(id);
+    return this.shipsById.get(id);
   }
   item(id) {
-    return this.indexes.items.get(id);
+    return this.itemsById.get(id);
   }
   recipe(id) {
-    return this.indexes.recipes.get(id);
+    return this.recipesById.get(id);
   }
   skill(id) {
-    return this.indexes.skills.get(id);
+    return this.skillsById.get(id);
   }
   facility(id) {
-    return this.indexes.facilities.get(id);
+    return this.facilitiesById.get(id);
   }
   get ships() {
     return this.catalog.ships;
@@ -4492,7 +4494,7 @@ class CatalogCache {
 function index(entries) {
   const map = new Map;
   for (const entry of entries) {
-    const id = typeof entry.id === "string" ? entry.id : undefined;
+    const id = isRecord(entry) && typeof entry.id === "string" ? entry.id : undefined;
     if (id)
       map.set(id, entry);
   }
@@ -4840,6 +4842,17 @@ 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/generated/notifications.gen.ts
 var TYPED_NOTIFICATION_TYPES = [
   "achievement_unlocked",
@@ -4888,6 +4901,7 @@ export {
   isActionResultFrame,
   isActionErrorFrame,
   httpBaseFromWs,
+  fetchStations,
   fetchMap,
   fetchCatalogConditional,
   fetchCatalog,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spacemolt/lib",
-  "version": "9.0.0",
+  "version": "10.0.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",