jspurefix 5.8.5 → 5.9.2

package/src/sample/tcp/qf-md/app.ts

@@ -15,9 +15,9 @@ class AppLauncher extends SessionLauncher {
   protected override makeFactory (config: IJsFixConfig): EngineFactory {
     const isInitiator = this.isInitiator(config.description)
     return {
-      makeSession: () => isInitiator
-        ? new MDClient(config)
-        : new MDServer(config)
+      makeSession: (sessionConfig: IJsFixConfig) => isInitiator
+        ? new MDClient(sessionConfig)
+        : new MDServer(sessionConfig)
     } as EngineFactory
   }
 }

package/src/sample/tcp/skeleton/app.ts

@@ -13,7 +13,7 @@ class AppLauncher extends SessionLauncher {
 
   protected override makeFactory (config: IJsFixConfig): EngineFactory {
     return {
-      makeSession: () => new SkeletonSession(config, 45, false)
+      makeSession: (sessionConfig: IJsFixConfig) => new SkeletonSession(sessionConfig, 45, false)
     } as EngineFactory
   }
 }

package/src/sample/tcp/trade-capture/app-launcher.ts

@@ -14,9 +14,9 @@ export class AppLauncher extends SessionLauncher {
   protected override makeFactory (config: IJsFixConfig): EngineFactory {
     const isInitiator = this.isInitiator(config.description)
     return {
-      makeSession: () => isInitiator
-        ? new TradeCaptureClient(config)
-        : new TradeCaptureServer(config)
+      makeSession: (sessionConfig: IJsFixConfig) => isInitiator
+        ? new TradeCaptureClient(sessionConfig)
+        : new TradeCaptureServer(sessionConfig)
     } as EngineFactory
   }
 }

package/src/store/file-session-store.ts

@@ -22,7 +22,7 @@ export class FileSessionStore implements IFixSessionStore {
   private creationTimeValue: Date = new Date()
 
   // In-memory index: seqnum -> { offset, length }
-  private readonly headerIndex: Map<number, { offset: number, length: number }> = new Map()
+  private readonly headerIndex = new Map<number, { offset: number, length: number }>()
 
   /**
    * Creates a FileSessionStore with the default file-based stream provider.
@@ -285,7 +285,7 @@ export class FileSessionStore implements IFixSessionStore {
    */
   static parseSessionTime (str: string): Date | null {
     // Format: YYYYMMDD-HH:MM:SS.ffffff
-    const match = str.match(/^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2}):(\d{2})\.(\d{3,6})$/)
+    const match = /^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2}):(\d{2})\.(\d{3,6})$/.exec(str)
     if (!match) return null
     const [, y, M, d, h, m, s, frac] = match
     const ms = parseInt(frac.substring(0, 3), 10)

package/src/store/file-session-stream-provider.ts

@@ -32,28 +32,34 @@ export class FileSessionStreamProvider implements ISessionStreamProvider {
   }
 
   openBody (): void {
-    if (this.bodyFd !== null) return
-    this.bodyFd = fs.openSync(this.bodyPath, 'a+')
-    const stat = fs.fstatSync(this.bodyFd)
-    this.bodySize = stat.size
+    this.openBodyFd()
   }
 
-  async appendBody (data: Buffer): Promise<number> {
+  /**
+   * open the body file on first use and hand back the descriptor - returning it
+   * keeps callers free of a null check the compiler cannot see through.
+   */
+  private openBodyFd (): number {
     if (this.bodyFd === null) {
-      this.openBody()
+      this.bodyFd = fs.openSync(this.bodyPath, 'a+')
+      const stat = fs.fstatSync(this.bodyFd)
+      this.bodySize = stat.size
     }
+    return this.bodyFd
+  }
+
+  async appendBody (data: Buffer): Promise<number> {
+    const fd = this.openBodyFd()
     const offset = this.bodySize
-    fs.writeSync(this.bodyFd!, data, 0, data.length, offset)
+    fs.writeSync(fd, data, 0, data.length, offset)
     this.bodySize += data.length
     return offset
   }
 
   async readBody (offset: number, length: number): Promise<Buffer> {
-    if (this.bodyFd === null) {
-      this.openBody()
-    }
+    const fd = this.openBodyFd()
     const buf = Buffer.alloc(length)
-    fs.readSync(this.bodyFd!, buf, 0, length, offset)
+    fs.readSync(fd, buf, 0, length, offset)
     return buf
   }
 

package/src/store/fix-session-store-factory.ts

@@ -7,7 +7,7 @@ import { FileSessionStore } from './file-session-store'
  * Factory for creating session stores.
  */
 export interface IFixSessionStoreFactory {
-  create (sessionId: SessionId): IFixSessionStore
+  create: (sessionId: SessionId) => IFixSessionStore
 }
 
 /**

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

@@ -14,24 +14,24 @@ export interface IFixSessionStore {
   readonly sessionId: SessionId
 
   // Message Operations
-  put (record: IFixMsgStoreRecord): Promise<void>
-  get (seqNum: number): Promise<IFixMsgStoreRecord | null>
-  getRange (fromSeqNum: number, toSeqNum: number): Promise<IFixMsgStoreRecord[]>
+  put: (record: IFixMsgStoreRecord) => Promise<void>
+  get: (seqNum: number) => Promise<IFixMsgStoreRecord | null>
+  getRange: (fromSeqNum: number, toSeqNum: number) => Promise<IFixMsgStoreRecord[]>
 
   // Sequence Number Operations
   senderSeqNum: number
   targetSeqNum: number
-  setSenderSeqNum (value: number): Promise<void>
-  setTargetSeqNum (value: number): Promise<void>
-  nextSenderSeqNum (): Promise<number>
-  nextTargetSeqNum (): Promise<number>
+  setSenderSeqNum: (value: number) => Promise<void>
+  setTargetSeqNum: (value: number) => Promise<void>
+  nextSenderSeqNum: () => Promise<number>
+  nextTargetSeqNum: () => Promise<number>
 
   // Session Operations
   readonly creationTime: Date
-  reset (): Promise<void>
+  reset: () => Promise<void>
 
   // Lifecycle
-  initialize (): Promise<void>
-  flush (): Promise<void>
-  dispose (): Promise<void>
+  initialize: () => Promise<void>
+  flush: () => Promise<void>
+  dispose: () => Promise<void>
 }

package/src/store/memory-session-store.ts

@@ -7,7 +7,7 @@ import { IFixMsgStoreRecord } from './fix-msg-store-record'
  * Not persistent - all data lost on dispose.
  */
 export class MemorySessionStore implements IFixSessionStore {
-  private readonly messages: Map<number, IFixMsgStoreRecord> = new Map()
+  private readonly messages = new Map<number, IFixMsgStoreRecord>()
   private senderSeqNumValue: number = 1
   private targetSeqNumValue: number = 1
   private creationTimeValue: Date = new Date()

package/src/store/session-stream-provider.ts

@@ -7,68 +7,68 @@ export interface ISessionStreamProvider {
    * Opens or creates a read-write buffer for the message body file.
    * Must support random-access reads (by offset+length).
    */
-  openBody (): void
+  openBody: () => void
 
   /**
    * Appends data to the body. Returns the offset at which data was written.
    */
-  appendBody (data: Buffer): Promise<number>
+  appendBody: (data: Buffer) => Promise<number>
 
   /**
    * Reads data from the body at the given offset and length.
    */
-  readBody (offset: number, length: number): Promise<Buffer>
+  readBody: (offset: number, length: number) => Promise<Buffer>
 
   /**
    * Gets the current body size (for calculating offsets).
    */
-  getBodySize (): number
+  getBodySize: () => number
 
   /**
    * Appends a line to the header index file.
    */
-  appendHeaderLine (line: string): Promise<void>
+  appendHeaderLine: (line: string) => Promise<void>
 
   /**
    * Reads all lines from the header index file.
    * Returns empty array if no data exists.
    */
-  readHeaderLines (): Promise<string[]>
+  readHeaderLines: () => Promise<string[]>
 
   /**
    * Reads the sequence numbers string.
    * Returns null if no data exists.
    */
-  readSeqNums (): Promise<string | null>
+  readSeqNums: () => Promise<string | null>
 
   /**
    * Writes the sequence numbers string.
    */
-  writeSeqNums (content: string): Promise<void>
+  writeSeqNums: (content: string) => Promise<void>
 
   /**
    * Reads the session time string.
    * Returns null if no data exists.
    */
-  readSessionTime (): Promise<string | null>
+  readSessionTime: () => Promise<string | null>
 
   /**
    * Writes the session time string.
    */
-  writeSessionTime (content: string): Promise<void>
+  writeSessionTime: (content: string) => Promise<void>
 
   /**
    * Resets all streams/files for a new session.
    */
-  reset (): Promise<void>
+  reset: () => Promise<void>
 
   /**
    * Flushes any pending writes.
    */
-  flush (): Promise<void>
+  flush: () => Promise<void>
 
   /**
    * Disposes of all resources.
    */
-  dispose (): Promise<void>
+  dispose: () => Promise<void>
 }

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-clock.ts

@@ -1,5 +1,5 @@
 export interface IFixClock {
-  now (): Date
+  now: () => Date
 }
 
 export class DefaultFixClock implements IFixClock {