screeps-connectivity 0.15.1 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.16.0
+
+### Minor Changes
+
+- f218429: Embedded clients are now configured from the first frame with no `/api/version` round-trip: both the xxscreeps mod and the classic server mod prefetch the version payload and inline it into the page (`window.__SCREEPS_BOOTSTRAP__`), and the client seeds it into both the pre-login UI and the connection. `ScreepsClient` gains an `initialVersion` option and `ServerStore` a `seedVersion()` method to support this.
+
+## 0.15.2
+
+### Patch Changes
+
+- b39a0c1: Fix duplicated console output when multiple parts of the app subscribe to the same `UserStore` channel. `subscribe()` now installs a single shared, ref-counted socket subscription and listener per channel instead of one listener per caller, so each incoming frame is processed and re-emitted exactly once. The server subscription and listener are torn down only after the last subscriber disposes.
+
 ## 0.15.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screeps-connectivity",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "license": "ISC",
   "type": "module",
   "repository": {

package/src/ScreepsClient.ts

@@ -14,6 +14,7 @@ import type { AuthStrategy } from './http/auth/AuthStrategy.js'
 import type { StorageAdapter } from './storage/StorageAdapter.js'
 import type { Subscription } from './subscription/index.js'
 import type { ApiRoomDecorationsResponse } from './types/api.js'
+import type { ServerVersion } from './types/game.js'
 
 type WsConstructor = typeof globalThis.WebSocket
 
@@ -49,6 +50,12 @@ export interface ScreepsClientOptions {
    * active regardless, so enabling this is a pure opt-in bandwidth trade.
    */
   gzip?: boolean
+  /**
+   * A pre-known `/api/version` response, seeded into the server store so `connect()`
+   * skips the initial version fetch. Used by embedded clients whose host mod inlines
+   * the payload into the page. Falls back to a normal fetch if omitted.
+   */
+  initialVersion?: ServerVersion
 }
 
 export class ScreepsClient {
@@ -100,6 +107,8 @@ export class ScreepsClient {
       navigation: new NavigationStore(50, this.logger.child('navigation')),
     }
 
+    if (opts.initialVersion) this.stores.server.seedVersion(opts.initialVersion)
+
     this.tokenRefreshIntervalMs = opts.tokenRefresh === false
       ? null
       : (opts.tokenRefresh?.intervalMs ?? 30_000)

package/src/stores/ServerStore.ts

@@ -43,9 +43,27 @@ export class ServerStore extends TypedStore<ServerStoreEvents> {
     this.socketSubs.length = 0
   }
 
+  /**
+   * Seed the server version without a network request. Used when the version is
+   * already known at construction time — e.g. an embedded client whose host mod
+   * inlines the `/api/version` payload into the page, sparing the initial fetch.
+   * Does not emit `server:version` (listeners aren't attached yet at that point);
+   * the value surfaces via the cache-hit path on the first `version()` call.
+   */
+  seedVersion(version: ServerVersion): void {
+    this._version = version
+    this.cache.set('server/version', version, 5 * 60_000)
+  }
+
   async version(): Promise<ServerVersion> {
     const cached = this.cache.get<ServerVersion>('server/version')
-    if (cached) return cached
+    if (cached) {
+      // Emit on cache hits too so a seeded version (see `seedVersion`) reaches
+      // listeners that only attach after construction. Idempotent for consumers.
+      this._version = cached
+      this.emit('server:version', cached)
+      return cached
+    }
     const res = await this.http.request<ServerVersion>('GET', '/api/version')
     this._version = res
     this.cache.set('server/version', res, 5 * 60_000)

package/src/stores/UserStore.ts

@@ -22,6 +22,15 @@ export class UserStore extends TypedStore<UserStoreEvents> {
   private _worldStatus: WorldStatus | null = null
   get worldStatusValue(): WorldStatus | null { return this._worldStatus }
   private _mePromise: Promise<UserInfo> | null = null
+  // Ref-counted store-level fan-out, keyed by channel. SocketClient.subscribe() already ref-counts the
+  // server subscription, but SocketClient.on() installs one listener per call — so a shared listener
+  // must be installed once and reused, otherwise N callers process (and re-emit) every frame N times.
+  private readonly channelSubs = new Map<string, {
+    refCount: number
+    disposed: boolean
+    socketSub: Subscription | null
+    listenerSub: Subscription | null
+  }>()
 
   constructor(http: HttpClient, socket: SocketClient, cache: Cache, logger?: Logger, maxConsoleSize = 100) {
     super(logger)
@@ -84,56 +93,70 @@ export class UserStore extends TypedStore<UserStoreEvents> {
 
   subscribe(channel: 'console' | 'cpu' | 'code' | 'set-active-branch'): Subscription {
     this.logger.log('subscribe', channel)
-    let socketSub: Subscription | null = null
-    let listenerSub: Subscription | null = null
-    let disposed = false
 
-    const setup = async () => {
-      try {
-        const uid = this._userId ?? (await this.me())._id
-        if (disposed) return
-        const fullChannel = `user:${uid}/${channel}`
-        socketSub = this.socket.subscribe(fullChannel)
-        listenerSub = this.socket.on(fullChannel, (data) => {
-          if (channel === 'cpu') {
-            this._cpu = data as CpuStats
-            this.emit('user:cpu', this._cpu)
-          } else if (channel === 'console') {
-            const raw = data as { messages?: ConsoleMessage, error?: string }
-            const msg: ConsoleMessage = {
-              log: raw.messages?.log ?? [],
-              results: raw.messages?.results ?? [],
-              error: raw.messages?.error ?? [],
-            }
-            if (raw.error) {
-              msg.error.push(raw.error)
-            }
-            this.console.push(msg)
-            if (this.console.length > this.maxConsoleSize) {
-              this.console.splice(0, this.console.length - this.maxConsoleSize)
+    // First caller for this channel installs the shared socket subscription + listener; later callers
+    // only bump the ref count so the frame is processed and re-emitted exactly once.
+    let entry = this.channelSubs.get(channel)
+    if (entry) {
+      entry.refCount++
+    } else {
+      entry = { refCount: 1, disposed: false, socketSub: null, listenerSub: null }
+      this.channelSubs.set(channel, entry)
+      const created = entry
+      const setup = async () => {
+        try {
+          const uid = this._userId ?? (await this.me())._id
+          if (created.disposed) return
+          const fullChannel = `user:${uid}/${channel}`
+          created.socketSub = this.socket.subscribe(fullChannel)
+          created.listenerSub = this.socket.on(fullChannel, (data) => {
+            if (channel === 'cpu') {
+              this._cpu = data as CpuStats
+              this.emit('user:cpu', this._cpu)
+            } else if (channel === 'console') {
+              const raw = data as { messages?: ConsoleMessage, error?: string }
+              const msg: ConsoleMessage = {
+                log: raw.messages?.log ?? [],
+                results: raw.messages?.results ?? [],
+                error: raw.messages?.error ?? [],
+              }
+              if (raw.error) {
+                msg.error.push(raw.error)
+              }
+              this.console.push(msg)
+              if (this.console.length > this.maxConsoleSize) {
+                this.console.splice(0, this.console.length - this.maxConsoleSize)
+              }
+              this.emit('user:console', { messages: msg })
+            } else if (channel === 'code') {
+              this.emit('user:code', data as { branch: string; modules: Record<string, string> })
+            } else if (channel === 'set-active-branch') {
+              this.emit('user:setActiveBranch', data as { activeName: 'activeWorld' | 'activeSim'; branch: string })
             }
-            this.emit('user:console', { messages: msg })
-          } else if (channel === 'code') {
-            this.emit('user:code', data as { branch: string; modules: Record<string, string> })
-          } else if (channel === 'set-active-branch') {
-            this.emit('user:setActiveBranch', data as { activeName: 'activeWorld' | 'activeSim'; branch: string })
+          })
+        } catch (err) {
+          if (!created.disposed) {
+            this.dispatchEvent(new ErrorEvent('error', { error: err instanceof Error ? err : new Error(String(err)) }))
           }
-        })
-      } catch (err) {
-        if (!disposed) {
-          this.dispatchEvent(new ErrorEvent('error', { error: err instanceof Error ? err : new Error(String(err)) }))
         }
       }
+      void setup()
     }
 
-    void setup()
-
+    let disposed = false
     return {
       dispose: () => {
-        this.logger.log('unsubscribe', channel)
+        if (disposed) return
         disposed = true
-        socketSub?.dispose()
-        listenerSub?.dispose()
+        this.logger.log('unsubscribe', channel)
+        const current = this.channelSubs.get(channel)
+        if (!current) return
+        if (--current.refCount <= 0) {
+          current.disposed = true
+          current.socketSub?.dispose()
+          current.listenerSub?.dispose()
+          this.channelSubs.delete(channel)
+        }
       },
     }
   }

package/tests/stores/ServerStore.test.ts

@@ -31,6 +31,18 @@ describe('ServerStore', () => {
     expect(http.request).toHaveBeenCalledOnce()
   })
 
+  it('serves a seeded version without fetching and emits server:version', async () => {
+    const { store, http } = makeStore()
+    const spy = vi.fn()
+    store.on('server:version', spy)
+    store.seedVersion({ ...mockVersion })
+    const v = await store.version()
+    expect(v.protocol).toBe(13)
+    expect(http.request).not.toHaveBeenCalled()
+    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ protocol: 13 }))
+    expect(store.versionInfo?.protocol).toBe(13)
+  })
+
   it('emits server:connected when socket fires connected event', () => {
     const { socket } = makeStore()
     let connectedCb: (data: unknown) => void = () => {}

package/tests/stores/UserStore.test.ts

@@ -133,4 +133,49 @@ describe('UserStore', () => {
     sub.dispose()
     expect(mockDispose).toHaveBeenCalled()
   })
+
+  it('multiple console subscribers share one socket listener and do not double output', async () => {
+    const { store, socket } = makeStore()
+    await store.me()
+    const handlers: Array<(data: unknown) => void> = []
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      handlers.push(cb)
+      return { dispose: vi.fn() }
+    })
+    const eventSpy = vi.fn()
+    store.on('user:console', eventSpy)
+
+    // Two independent parts of the app subscribe to the same channel (e.g. the console panel and the
+    // custom-UI store). Regression: this used to install two socket listeners, doubling every frame.
+    store.subscribe('console')
+    store.subscribe('console')
+    await new Promise(r => setTimeout(r, 0))
+
+    // Exactly one socket listener and one server subscription regardless of caller count.
+    expect(handlers).toHaveLength(1)
+    expect(socket.subscribe).toHaveBeenCalledTimes(1)
+
+    // One incoming frame produces exactly one console entry and one event.
+    handlers[0]!({ messages: { log: ['line1'], results: [] } })
+    expect(store.console).toHaveLength(1)
+    expect(eventSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('console socket subscription is ref-counted and dropped only after the last subscriber', async () => {
+    const { store, socket } = makeStore()
+    await store.me()
+    const mockDispose = vi.fn()
+    ;(socket.subscribe as ReturnType<typeof vi.fn>).mockReturnValue({ dispose: mockDispose })
+
+    const a = store.subscribe('console')
+    const b = store.subscribe('console')
+    await new Promise(r => setTimeout(r, 0))
+    expect(socket.subscribe).toHaveBeenCalledTimes(1)
+
+    a.dispose()
+    expect(mockDispose).not.toHaveBeenCalled() // second subscriber still active
+
+    b.dispose()
+    expect(mockDispose).toHaveBeenCalledTimes(1)
+  })
 })