jspurefix 5.8.5 → 5.9.1

package/src/transport/ascii/ascii-session.ts

@@ -6,8 +6,9 @@ import {
   FixMsgAsciiStoreResend, FixMsgMemoryStore, FixMsgStoreRecord,
   IFixMsgStore, IFixMsgStoreRecord,
   IFixSessionStore, IFixSessionStoreFactory,
-  MemorySessionStoreFactory, FileSessionStoreFactory, SessionId
+  MemorySessionStore, MemorySessionStoreFactory, FileSessionStoreFactory, SessionId
 } from '../../store'
+import { asMutable } from '../session/clone-session-description'
 import { SessionState } from '../tcp'
 import { TickAction } from '../tick-action'
 import { IMsgApplication } from '../msg-application'
@@ -20,12 +21,24 @@ import { MsgTransport } from '../factory'
 import { ILooseObject } from '../../collections/collection'
 
 export abstract class AsciiSession extends FixSession {
+  /**
+   * TargetCompID value which tells an acceptor to take its target from whichever
+   * counterparty logs on, rather than from static configuration.
+   */
+  public static readonly WildcardCompId = '*'
   public heartbeat: boolean = true
   protected store: IFixMsgStore | null = null
   protected resender: FixMsgAsciiStoreResend
-  protected readonly coordinator: SessionSequenceCoordinator
-  protected readonly sessionStore: IFixSessionStore
-  protected readonly sessionId: SessionId
+  protected coordinator: SessionSequenceCoordinator
+  protected sessionStore: IFixSessionStore
+  protected sessionId: SessionId
+  private registered: boolean = false
+  /** acceptor configured with TargetCompID '*' - identity comes from the peer Logon */
+  protected readonly wildcardTarget: boolean
+  private identityBound: boolean
+  private bindInProgress: boolean = false
+  private readonly pendingRx: Array<{ msgType: string, view: MsgView }> = []
+  private readonly clock: DefaultFixClock = new DefaultFixClock()
 
   protected constructor (public readonly config: IJsFixConfig) {
     super(config)
@@ -34,22 +47,38 @@ export abstract class AsciiSession extends FixSession {
     this.store = new FixMsgMemoryStore(this.config.description.SenderCompId, this.config)
     this.resender = new FixMsgAsciiStoreResend(this.store, this.config)
 
-    // Create session store from factory.
-    // Priority: programmatic config > JSON store config > default in-memory
-    const storeFactory = config.sessionStoreFactory ?? AsciiSession.createStoreFactory(config.description.store)
+    // A wildcard TargetCompID lets one acceptor serve counterparties it was not
+    // statically configured for - the peer's SenderCompID becomes our target, and
+    // therefore our SessionId and store, once the Logon arrives.  An initiator has
+    // to know who it is calling, so '*' is meaningless there.
+    this.wildcardTarget = config.description.TargetCompID === AsciiSession.WildcardCompId
+    if (this.wildcardTarget && this.initiator) {
+      throw new Error(`TargetCompID '${AsciiSession.WildcardCompId}' is only valid for acceptors, not initiators`)
+    }
+    this.identityBound = !this.wildcardTarget
+
     this.sessionId = new SessionId(
       config.description.BeginString,
       config.description.SenderCompId,
       config.description.TargetCompID
     )
-    this.sessionStore = storeFactory.create(this.sessionId)
-
-    const clock = new DefaultFixClock()
-    this.coordinator = new SessionSequenceCoordinator(this.sessionStore, clock)
+    // Until the peer identifies itself there is nothing worth persisting, so a
+    // wildcard session starts on a throwaway in-memory store.  The real store -
+    // keyed on the peer's comp id - is created by bindIdentity.
+    this.sessionStore = this.wildcardTarget
+      ? new MemorySessionStore(this.sessionId)
+      : this.storeFactory().create(this.sessionId)
+
+    this.coordinator = new SessionSequenceCoordinator(this.sessionStore, this.clock)
     const lastReceivedSeqNum = config.description.LastReceivedSeqNum ?? 0
     this.coordinator.initializeFromConfig(undefined, lastReceivedSeqNum + 1)
   }
 
+  private storeFactory (): IFixSessionStoreFactory {
+    // Priority: programmatic config > JSON store config > default in-memory
+    return this.config.sessionStoreFactory ?? AsciiSession.createStoreFactory(this.config.description.store)
+  }
+
   /**
    * Initialize the session store (reads persisted sequences from file if using FileSessionStore),
    * sync the coordinator and transmitter from the store, then start the session.
@@ -65,6 +94,15 @@ export abstract class AsciiSession extends FixSession {
     // the client's Logon can arrive and be parsed into the void.
     transport.duplex.readable?.pause()
 
+    if (this.wildcardTarget && !this.identityBound) {
+      // Nothing to recover yet - the SessionId is not known until the peer logs on,
+      // so store initialisation, sequence sync and registry claim all happen in
+      // bindIdentity.  Resume and wait for the Logon.
+      this.sessionLogger.info('wildcard acceptor: awaiting peer Logon to establish session identity')
+      transport.duplex.readable?.resume()
+      return await super.run(transport)
+    }
+
     // Initialize store — reads persisted .seqnums file if using FileSessionStore.
     // For MemorySessionStore this is a no-op.
     await this.sessionStore.initialize()
@@ -81,6 +119,11 @@ export abstract class AsciiSession extends FixSession {
 
     this.sessionLogger.info(`store initialized: nextSender=${this.coordinator.nextSenderSeqNum}, expectedTarget=${this.coordinator.expectedTargetSeqNum}`)
 
+    // Claim this SessionId.  A counterparty which reconnected before its previous
+    // socket was detected as dead would otherwise leave two live sessions writing
+    // to one store - see issue #153.
+    this.claimSessionId()
+
     // Resume the stream — super.run() will call subscribe() to hook up the message handler,
     // then the buffered data (including the client's Logon) will be delivered.
     transport.duplex.readable?.resume()
@@ -330,6 +373,30 @@ export abstract class AsciiSession extends FixSession {
     this.sessionLogger.info('coordinator reset transient state for reconnect')
   }
 
+  /**
+   * Take ownership of this SessionId in the registry, stopping whatever session
+   * held it before.  Idempotent - a session reused across reconnects (the
+   * RecoveringTcpInitiator pattern) simply re-registers itself.
+   */
+  private claimSessionId (): void {
+    const registry = this.config.sessionRegistry
+    if (!registry) return
+    const stoppedOld = registry.register(this.sessionId, this)
+    if (stoppedOld) {
+      this.sessionLogger.info(`session registry stopped previous session for ${this.sessionId.toString()}`)
+    }
+    this.registered = true
+  }
+
+  protected override onSessionStopping (): void {
+    super.onSessionStopping()
+    const registry = this.config.sessionRegistry
+    if (!registry || !this.registered) return
+    this.registered = false
+    this.sessionLogger.info(`session stopping - unregistering from registry: ${this.sessionId.toString()}`)
+    registry.unregister(this.sessionId, this)
+  }
+
   protected override async onPreLogon (): Promise<void> {
     if (!this.config.description.ResetSeqNumFlag) return
 
@@ -477,6 +544,114 @@ export abstract class AsciiSession extends FixSession {
   }
 
   protected onMsg (msgType: string, view: MsgView): void {
+    if (this.wildcardTarget && !this.identityBound) {
+      this.onMsgBeforeIdentity(msgType, view)
+      return
+    }
+    this.dispatchMsg(msgType, view)
+  }
+
+  /**
+   * Message handling for a wildcard acceptor which has not yet learned who it is
+   * talking to.  The first message must be a Logon; it carries the peer's
+   * SenderCompID, which becomes our TargetCompID and hence our SessionId and store.
+   *
+   * Binding is asynchronous (the store may have to be read from disk) while message
+   * delivery is not: the parser emits every message it finds in a TCP segment in one
+   * synchronous burst, and a view is only valid for the duration of its own event -
+   * AsciiParser recycles the tag index and buffer immediately afterwards.  So each
+   * message that arrives mid-bind is cloned and queued, then replayed in order.
+   */
+  private onMsgBeforeIdentity (msgType: string, view: MsgView): void {
+    if (this.bindInProgress) {
+      this.sessionLogger.info(`queueing '${msgType}' received while binding session identity`)
+      this.pendingRx.push({ msgType, view: view.clone() })
+      return
+    }
+
+    if (msgType !== MsgType.Logon) {
+      this.terminate(new Error(`wildcard acceptor expects Logon as the first message, received '${msgType}'`))
+      return
+    }
+
+    const peerCompId = view.getString(MsgTag.SenderCompID)
+    if (!peerCompId) {
+      this.terminate(new Error('Logon has no SenderCompID - cannot establish session identity'))
+      return
+    }
+
+    this.bindInProgress = true
+    const logon = view.clone()
+    this.transport?.duplex.readable?.pause()
+
+    this.bindIdentity(peerCompId).then(() => {
+      this.bindInProgress = false
+      this.identityBound = true
+      this.dispatchMsg(MsgType.Logon, logon)
+      this.drainPendingRx()
+      this.transport?.duplex.readable?.resume()
+    }).catch((e: Error) => {
+      this.bindInProgress = false
+      this.pendingRx.length = 0
+      this.terminate(new Error(`failed to bind session identity for peer '${peerCompId}': ${e.message}`))
+    })
+  }
+
+  private drainPendingRx (): void {
+    while (this.pendingRx.length > 0) {
+      const queued = this.pendingRx.shift()
+      if (!queued) break
+      if (this.sessionState.state === SessionState.Stopped) {
+        this.sessionLogger.info(`dropping queued '${queued.msgType}' - session stopped during bind`)
+        continue
+      }
+      this.dispatchMsg(queued.msgType, queued.view)
+    }
+  }
+
+  /**
+   * Adopt the peer's comp id as our TargetCompID, then build the identity derived
+   * state: SessionId, message store, sequence coordinator, registry claim.  This is
+   * the wildcard equivalent of the work run() does up front for a statically
+   * configured session.
+   */
+  private async bindIdentity (peerCompId: string): Promise<void> {
+    const logger = this.sessionLogger
+    logger.info(`wildcard acceptor: binding session identity to peer SenderCompID '${peerCompId}'`)
+
+    // the description is this session's own clone (see makeSessionScope), and the
+    // session message factory holds the same object, so outbound headers pick the
+    // new target up immediately
+    asMutable(this.config.description).TargetCompID = peerCompId
+
+    // every session on a wildcard listener shared one logger name until now, which
+    // makes a multi-client server log impossible to follow
+    this.sessionLogger = this.config.logFactory.logger(`${this.me}:${peerCompId}:FixSession`)
+
+    this.sessionId = new SessionId(
+      this.config.description.BeginString,
+      this.config.description.SenderCompId,
+      peerCompId
+    )
+    this.sessionStore = this.storeFactory().create(this.sessionId)
+    await this.sessionStore.initialize()
+
+    this.coordinator = new SessionSequenceCoordinator(this.sessionStore, this.clock)
+    this.coordinator.initializeFromStore()
+
+    const transmitter = this.transport?.transmitter as AsciiMsgTransmitter | undefined
+    if (transmitter) {
+      transmitter.msgSeqNum = this.coordinator.nextSenderSeqNum
+    }
+    this.sessionState.lastPeerMsgSeqNum = this.coordinator.lastProcessedPeerSeqNum
+
+    logger.info(`session identity bound: ${this.sessionId.toString()} ` +
+      `nextSender=${this.coordinator.nextSenderSeqNum}, expectedTarget=${this.coordinator.expectedTargetSeqNum}`)
+
+    this.claimSessionId()
+  }
+
+  private dispatchMsg (msgType: string, view: MsgView): void {
     if (!this.checkSeqNo(msgType, view)) {
       this.sessionLogger.info(`message '${msgType}' failed checkSeqNo.`)
       return

package/src/transport/duplex/fix-duplex.ts

@@ -5,5 +5,14 @@ export type MakeDuplex = () => FixDuplex
 export abstract class FixDuplex {
   public readable: Readable
   public writable: Writable
+  /** graceful shutdown - for a socket this is a FIN, which the peer may never answer */
   public abstract end (): void
+  /**
+   * Release the underlying resource unconditionally.  A half open socket - one whose
+   * peer has vanished without FIN or RST - will not complete a graceful end, so the
+   * acceptor needs a way to stop holding it (issue #153).  Defaults to end().
+   */
+  public destroy (): void {
+    this.end()
+  }
 }

package/src/transport/duplex/tcp-duplex.ts

@@ -14,4 +14,14 @@ export class TcpDuplex extends FixDuplex {
   end (): void {
     this.socket.end()
   }
+
+  /**
+   * A socket whose peer has gone without FIN or RST will never complete the
+   * graceful end() above - the FIN is sent and no answer ever comes, so the handle
+   * stays open indefinitely.  destroy() drops it regardless.
+   */
+  destroy (): void {
+    if (this.socket.destroyed) return
+    this.socket.destroy()
+  }
 }

package/src/transport/factory/msg-transport.ts

@@ -34,10 +34,30 @@ export class MsgTransport {
     }
   }
 
+  /**
+   * Milliseconds to wait after a graceful end before dropping the connection.  A
+   * half open socket never answers the FIN, so without this the handle - and the
+   * memory behind its session - is held for the life of the process (issue #153).
+   */
+  public static lingerMs: number = 5000
+
   public end (): void {
+    if (this.ended) return
+    this.ended = true
     this.duplex.end()
+    if (MsgTransport.lingerMs <= 0) {
+      this.duplex.destroy()
+      return
+    }
+    const linger = setTimeout(() => {
+      this.duplex.destroy()
+    }, MsgTransport.lingerMs)
+    // never keep the process alive purely to time out a dead socket
+    linger.unref?.()
   }
 
+  private ended: boolean = false
+
   public async wait (): Promise<any> {
     return await new Promise<any>((resolve, reject) => {
       this.receiver.on('end', () => {

package/src/transport/session/a-session-msg-factory.ts

@@ -20,6 +20,24 @@ export abstract class ASessionMsgFactory implements ISessionMsgFactory {
   protected constructor (public readonly description: ISessionDescription, public mutator: ObjectMutator | null = null) {
   }
 
+  /**
+   * Rebuild this factory against another session description, preserving the
+   * concrete type.  An acceptor needs one factory per accepted connection so that
+   * outbound headers carry that session's comp ids; without preserving the type, an
+   * application's own factory would be silently replaced by the stock one.
+   *
+   * Reconstructing through `this.constructor` covers any subclass whose constructor
+   * takes (description, mutator) - the shape every factory in this library uses.
+   * Override this if yours takes anything else.
+   */
+  public cloneFor (description: ISessionDescription): ISessionMsgFactory {
+    const Ctor = this.constructor as new (
+      description: ISessionDescription,
+      mutator: ObjectMutator | null
+    ) => ISessionMsgFactory
+    return new Ctor(description, this.mutator)
+  }
+
   public reject (msgType: string, seqNo: number, msg: string, reason: number): ILooseObject {
     const o: IReject = {
       RefMsgType: msgType,

package/src/transport/session/clone-session-description.ts

@@ -0,0 +1,41 @@
+import { IDynamicSessionParams, ISessionDescription } from './session-description'
+
+/**
+ * A session description with the readonly modifiers stripped.  The description is
+ * immutable by design - it is loaded once from JSON and shared by everything in the
+ * session - but an acceptor running in wildcard mode has to write the peer's
+ * SenderCompID into its own copy once the Logon arrives.  Cast through this type so
+ * the (deliberately rare) mutation is explicit at every call site.
+ */
+export type MutableSessionDescription = {
+  -readonly [K in keyof ISessionDescription]: ISessionDescription[K]
+}
+
+/**
+ * Shallow clone a session description, optionally overriding identity fields.
+ *
+ * Each connection accepted by a FIX acceptor needs its own description: the
+ * SessionId (and therefore the message store), the outbound header comp ids and the
+ * session registry key are all derived from it.  Sharing one description across
+ * concurrent sessions makes every client collide on the same store.
+ *
+ * `application` and `store` are shared by reference - they are read only
+ * configuration (host, port, dictionary, store directory) common to every session
+ * on the listener.
+ */
+export function cloneSessionDescription (
+  description: ISessionDescription,
+  overrides?: Partial<IDynamicSessionParams>): ISessionDescription {
+  return {
+    ...description,
+    ...(overrides ?? {})
+  }
+}
+
+/**
+ * Make a description writable.  Use only where the FIX protocol itself forces a
+ * late binding - i.e. wildcard TargetCompID resolved from the peer's Logon.
+ */
+export function asMutable (description: ISessionDescription): MutableSessionDescription {
+  return description as MutableSessionDescription
+}

package/src/transport/session/fix-session.ts

@@ -9,17 +9,44 @@ import * as events from 'events'
 import { SessionState } from './session-state'
 import { SegmentType } from '../../buffer/segment/segment-type'
 
+/**
+ * The set of listeners this session attached to one specific transport.
+ *
+ * The handlers must be kept as stable references - `EventEmitter.removeListener`
+ * matches on identity, so subscribing with a fresh closure and unsubscribing with
+ * a method reference silently leaves the listener attached (issue #153).  Holding
+ * the transport alongside the handlers also lets `unsubscribe` detach from the
+ * transport it actually subscribed to, even when `this.transport` has already
+ * moved on to a newer connection.
+ */
+interface ITransportSubscription {
+  readonly transport: MsgTransport
+  readonly rxOnMsg: (msgType: string, view: MsgView) => void
+  readonly rxOnError: (e: Error) => void
+  readonly rxOnDone: () => void
+  readonly rxOnEnd: () => void
+  readonly rxOnDecoded: (msgType: string, data: ElasticBuffer, ptr: number) => void
+  readonly txOnError: (e: Error) => void
+  readonly txOnEncoded: (msgType: string, data: string, hdr: ILooseObject) => void
+}
+
 export abstract class FixSession extends events.EventEmitter {
   public logReceivedMsgs: boolean = false
   protected timer: NodeJS.Timeout | null = null
   protected transport: MsgTransport | null = null
+  private subscription: ITransportSubscription | null = null
   public manageSession: boolean = true
   public checkMsgIntegrity: boolean = false
   protected readonly me: string
   protected readonly initiator: boolean
   protected readonly acceptor: boolean
   protected readonly sessionState: FixSessionState
-  protected readonly sessionLogger: IJsFixLogger
+  /**
+   * Not readonly: a wildcard acceptor does not know which counterparty it is
+   * serving until the Logon arrives, and every session on that listener would
+   * otherwise log under the same name.  Rebound once the identity is known.
+   */
+  protected sessionLogger: IJsFixLogger
   protected requestLogoutType: string
   protected respondLogoutType: string
   protected requestLogonType: string
@@ -120,7 +147,9 @@ export abstract class FixSession extends events.EventEmitter {
       }
       const onError = (e: Error): void => {
         cleanup()
-        logger.error(e)
+        // read the logger now, not the one captured when the run started - a
+        // wildcard acceptor rebinds it once it knows which peer it is serving
+        this.sessionLogger.error(e)
         reject(e)
       }
       const onDone = (): void => {
@@ -217,35 +246,90 @@ export abstract class FixSession extends events.EventEmitter {
     this.onEncoded(msgType, data)
   }
 
+  /**
+   * true when the event which has just fired came from the transport this session
+   * is currently running.  A half open socket can keep emitting long after the peer
+   * has reconnected on a fresh connection - those events must not be allowed to drive
+   * the live session (issue #153).
+   */
+  private isCurrentTransport (transport: MsgTransport, event: string): boolean {
+    if (this.subscription?.transport === transport && this.transport === transport) {
+      return true
+    }
+    const current = this.transport?.id ?? 'none'
+    this.sessionLogger.warning(`ignoring '${event}' from stale transport ${transport.id} - current transport is ${current}`)
+    return false
+  }
+
   protected unsubscribe (): void {
     const logger = this.sessionLogger
-    logger.info(`unsubscribe sessionState = [${this.sessionState.toString()}]`)
-    const transport = this.transport
-    const rx = transport?.receiver
-    const tx = transport?.transmitter
-
-    rx?.removeListener('msg', this.rxOnMsg)
-    rx?.removeListener('error', this.rxOnError)
-    rx?.removeListener('done', this.rxOnDone)
-    rx?.removeListener('end', this.rxOnEnd)
-    rx?.removeListener('decoded', this.rxOnDecoded)
-    tx?.removeListener('error', this.txOnError)
-    tx?.removeListener('encoded', this.txOnEncoded)
+    const subscription = this.subscription
+    if (!subscription) {
+      logger.debug('unsubscribe called with no active subscription')
+      return
+    }
+    const transport = subscription.transport
+    logger.info(`unsubscribe transport ${transport.id} sessionState = [${this.sessionState.toString()}]`)
+    const rx = transport.receiver
+    const tx = transport.transmitter
+
+    rx?.removeListener('msg', subscription.rxOnMsg)
+    rx?.removeListener('error', subscription.rxOnError)
+    rx?.removeListener('done', subscription.rxOnDone)
+    rx?.removeListener('end', subscription.rxOnEnd)
+    rx?.removeListener('decoded', subscription.rxOnDecoded)
+    tx?.removeListener('error', subscription.txOnError)
+    tx?.removeListener('encoded', subscription.txOnEncoded)
+    this.subscription = null
+    logger.debug(`unsubscribe complete - rx listeners now ${rx?.listenerCount('msg') ?? 0} msg, ${rx?.listenerCount('end') ?? 0} end`)
   }
 
   protected subscribe (): void {
     const transport = this.transport
-
-    const rx = transport?.receiver
-    const tx = transport?.transmitter
+    if (!transport) {
+      this.sessionLogger.warning('subscribe called with no transport')
+      return
+    }
+    // detach from any previous transport before attaching to this one
+    if (this.subscription) {
+      this.unsubscribe()
+    }
     const inst = this
-    rx?.on('msg', (msgType: string, view: MsgView) => { inst.rxOnMsg(msgType, view) })
-    rx?.on('error', (e: Error) => { inst.rxOnError(e) })
-    rx?.on('done', () => { inst.rxOnDone() })
-    rx?.on('end', () => { inst.rxOnEnd() })
-    rx?.on('decoded', (msgType: string, data: ElasticBuffer, ptr: number) => { inst.rxOnDecoded(msgType, data, ptr) })
-    tx?.on('error', (e: Error) => { inst.txOnError(e) })
-    tx?.on('encoded', (msgType: string, data: string, hdr: ILooseObject) => { inst.txOnEncoded(msgType, data, hdr) })
+    const subscription: ITransportSubscription = {
+      transport,
+      rxOnMsg: (msgType: string, view: MsgView) => {
+        if (inst.isCurrentTransport(transport, 'msg')) inst.rxOnMsg(msgType, view)
+      },
+      rxOnError: (e: Error) => {
+        if (inst.isCurrentTransport(transport, 'error')) inst.rxOnError(e)
+      },
+      rxOnDone: () => {
+        if (inst.isCurrentTransport(transport, 'done')) inst.rxOnDone()
+      },
+      rxOnEnd: () => {
+        if (inst.isCurrentTransport(transport, 'end')) inst.rxOnEnd()
+      },
+      rxOnDecoded: (msgType: string, data: ElasticBuffer, ptr: number) => {
+        if (inst.isCurrentTransport(transport, 'decoded')) inst.rxOnDecoded(msgType, data, ptr)
+      },
+      txOnError: (e: Error) => {
+        if (inst.isCurrentTransport(transport, 'tx error')) inst.txOnError(e)
+      },
+      txOnEncoded: (msgType: string, data: string, hdr: ILooseObject) => {
+        if (inst.isCurrentTransport(transport, 'encoded')) inst.txOnEncoded(msgType, data, hdr)
+      }
+    }
+    const rx = transport.receiver
+    const tx = transport.transmitter
+    rx?.on('msg', subscription.rxOnMsg)
+    rx?.on('error', subscription.rxOnError)
+    rx?.on('done', subscription.rxOnDone)
+    rx?.on('end', subscription.rxOnEnd)
+    rx?.on('decoded', subscription.rxOnDecoded)
+    tx?.on('error', subscription.txOnError)
+    tx?.on('encoded', subscription.txOnEncoded)
+    this.subscription = subscription
+    this.sessionLogger.info(`subscribed to transport ${transport.id}`)
   }
 
   protected validStateApplicationMsg (): boolean {
@@ -285,12 +369,16 @@ export abstract class FixSession extends events.EventEmitter {
     if (this.sessionState.state === SessionState.Stopped) return
     this.sessionLogger.error(error)
     this.stopTimer()
+    this.unsubscribe()
     if (this.transport) {
+      this.sessionLogger.info(`terminate: kill transport ${this.transport.id}`)
       this.transport.end()
     }
     this.transport = null
     this.setState(SessionState.Stopped)
+    this.onSessionStopping()
     this.emit('error', error)
+    this.onStopped(error)
   }
 
   protected peerLogout (view: MsgView): void {
@@ -415,6 +503,16 @@ export abstract class FixSession extends events.EventEmitter {
     // Override in subclass to reset coordinator/transient state
   }
 
+  /**
+   * Called once as the session moves to Stopped, before the application is informed
+   * via onStopped.  Override to release session scoped resources - the ascii session
+   * uses this to remove itself from the session registry.  Mirrors cspurefix
+   * FixSession.OnSessionStopping.
+   */
+  protected onSessionStopping (): void {
+    // Default no-op
+  }
+
   /**
    * Called for initiators after the store is loaded but before the Logon is sent.
    * Override to reset sequences/store when ResetSeqNumFlag=Y so the Logon goes out
@@ -424,13 +522,26 @@ export abstract class FixSession extends events.EventEmitter {
     // Default no-op
   }
 
+  /**
+   * Stop this session on behalf of an external caller - typically the session registry
+   * when a new connection for the same SessionId replaces this one, but equally an
+   * application which has decided the peer is gone.  Mirrors cspurefix
+   * FixSession.RequestStop.
+   * @param reason recorded in the session log and carried on the emitted error
+   */
+  public requestStop (reason: string): void {
+    this.sessionLogger.info(`requestStop: ${reason}`)
+    this.stop(new Error(reason))
+  }
+
   protected stop (error: Error | null = null): void {
     if (this.sessionState.state === SessionState.Stopped) {
       return
     }
     this.stopTimer()
     this.unsubscribe()
-    this.sessionLogger.info('stop: kill transport')
+    this.sessionLogger.info(`stop: kill transport ${this.transport?.id ?? 'none'}`)
+    this.onSessionStopping()
     this.transport?.end()
     if (error) {
       this.sessionLogger.info(`stop: emit error ${error.message}`)

package/src/transport/session/index.ts

@@ -10,3 +10,5 @@ export * from './session-sequence-coordinator'
 export * from './session-sequence-store'
 export * from './resend-request-manager'
 export * from './fix-clock'
+export * from './session-registry'
+export * from './clone-session-description'

package/src/transport/session/session-msg-factory.ts

@@ -13,4 +13,17 @@ export interface ISessionMsgFactory {
   heartbeat: (testReqId: string) => ILooseObject
   header: (msgType: string, seqNum: number, time: Date, overrideData?: Partial<IStandardHeader>) => ILooseObject
   trailer: (checksum: number) => ILooseObject
+  /**
+   * Produce a factory of this same kind bound to another session description.
+   *
+   * An acceptor builds one of these per accepted connection, because the outbound
+   * header carries that session's comp ids - and under a wildcard TargetCompID the
+   * target is not known until the peer logs on.  Implementing this is what lets an
+   * application's own factory survive into those per-session scopes; without it the
+   * acceptor can only fall back to the stock factory for the protocol.
+   *
+   * ASessionMsgFactory supplies a default that reconstructs via the concrete
+   * constructor, so a subclass taking (description, mutator) needs to do nothing.
+   */
+  cloneFor?: (description: ISessionDescription) => ISessionMsgFactory
 }