jspurefix 5.8.5 → 5.9.2

package/src/benchmark/parse-bench.ts

@@ -0,0 +1,144 @@
+import { AsciiParser } from '../buffer/ascii/ascii-parser'
+import { ElasticBuffer } from '../buffer/elastic-buffer'
+import { MsgView } from '../buffer/msg-view'
+import { IJsFixConfig } from '../config/js-fix-config'
+import { DITokens } from '../runtime/di-tokens'
+import { makeSessionScope } from '../runtime/session-scope'
+import { IBenchCase } from './bench-types'
+
+/**
+ * what a decoded message is taken through once the parser has produced a view
+ */
+export enum ParseDepth {
+  /** stop at the MsgView - tokenise, discover the structure, build the view */
+  View = 'view',
+  /** materialise the whole object graph, which is what most consumers do */
+  Object = 'object'
+}
+
+export interface IParseCaseOptions {
+  readonly config: IJsFixConfig
+  /** the raw text of a fix log, one or more complete messages */
+  readonly contents: string
+  readonly depth: ParseDepth
+}
+
+/**
+ * Drives fix bytes through the real parser and counts messages out of it.
+ *
+ * The bytes are fed as one buffer per invocation, the same way a socket read
+ * reaches parse, rather than by concatenating the file thousands of times into
+ * one enormous string. That concatenation is itself a large allocation, and
+ * doing it before the timer starts leaves a heap that no memory reading taken
+ * afterwards can be trusted through.
+ */
+export class ParseCase implements IBenchCase {
+  public readonly name: string
+  public readonly description: string
+  /** messages produced by one pass over the input */
+  public readonly operationsPerInvocation: number
+
+  private readonly source: Buffer
+  private readonly depth: ParseDepth
+  private readonly options: IParseCaseOptions
+  private parser: AsciiParser | null = null
+  private decoded: number = 0
+
+  constructor (name: string, options: IParseCaseOptions) {
+    this.name = name
+    this.options = options
+    this.depth = options.depth
+    this.source = Buffer.from(options.contents)
+    this.description = options.depth === ParseDepth.Object
+      ? 'tokenise, discover structure, build view, materialise object'
+      : 'tokenise, discover structure, build view'
+    this.operationsPerInvocation = this.countMessages()
+    if (this.operationsPerInvocation === 0) {
+      throw new Error(`${name}: input yielded no messages, check the dictionary and the delimiter`)
+    }
+  }
+
+  /**
+   * Round a requested round size up to a whole number of passes over the input.
+   * A pass cannot be stopped part way, so asking for a count that is not a
+   * multiple of it would silently measure more work than it reported.
+   */
+  public alignOperations (requested: number): number {
+    const per = this.operationsPerInvocation
+    return Math.max(per, Math.ceil(requested / per) * per)
+  }
+
+  public setup (): void {
+    this.parser = this.makeParser(true)
+  }
+
+  public teardown (): void {
+    this.parser?.removeAllListeners()
+    this.parser = null
+  }
+
+  public run (operations: number): number {
+    const parser = this.parser
+    if (!parser) {
+      throw new Error(`${this.name}: run called before setup`)
+    }
+    const source = this.source
+    const passes = operations / this.operationsPerInvocation
+    if (!Number.isInteger(passes)) {
+      throw new Error(`${this.name}: ${operations} operations is not a whole number of passes over the input`)
+    }
+    this.decoded = 0
+    for (let i = 0; i < passes; ++i) {
+      parser.parseBuffer(source)
+    }
+    return this.decoded
+  }
+
+  /**
+   * A parser on a session scope of its own.
+   *
+   * It has to be a scope rather than a hand built AsciiParser: AsciiParserState
+   * takes the ParseBuffer from the container, so a parser handed some other
+   * buffer writes bytes the state never reads and the parse walks off into
+   * nonsense. The scope re-registers the buffer and hands the same instance to
+   * both, which is the same thing an accepted connection gets.
+   */
+  private makeParser (subscribe: boolean): AsciiParser {
+    const scoped = makeSessionScope(this.options.config)
+    const container = scoped.sessionContainer
+    // constructed rather than resolved: DITokens.readStream has no registration
+    // outside a live transport, and there is no stream here - the harness hands
+    // the parser its bytes. Everything else comes from the scope, so the buffer
+    // below is the same instance AsciiParserState will be injected with.
+    const buffer = container.resolve<ElasticBuffer>(DITokens.ParseBuffer)
+    const maxMessageLen = container.resolve<number>(DITokens.maxMessageLen)
+    const parser = new AsciiParser(scoped, null, buffer, maxMessageLen)
+    const object = subscribe && this.depth === ParseDepth.Object
+    parser.on('msg', (_: string, view: MsgView) => {
+      ++this.decoded
+      if (object) {
+        // read the result back so the materialisation cannot be treated as
+        // dead and folded away
+        const materialised = view.toObject()
+        if (materialised === null) {
+          throw new Error('view produced no object')
+        }
+      }
+    })
+    return parser
+  }
+
+  /**
+   * How many messages one pass over the input yields. Counted on a throwaway
+   * parser during construction so the measured run never has to ask.
+   */
+  private countMessages (): number {
+    const parser = this.makeParser(false)
+    this.decoded = 0
+    parser.parseBuffer(this.source)
+    parser.removeAllListeners()
+    const count = this.decoded
+    this.decoded = 0
+    return count
+  }
+}

package/src/buffer/ascii/ascii-parser.ts

@@ -39,7 +39,9 @@ export class AsciiParser extends MsgParser {
     this.id = AsciiParser.nextId++
     this.segmentParser = config.sessionContainer.resolve<AsciiSegmentParser>(AsciiSegmentParser)
     this.state = config.sessionContainer.resolve<AsciiParserState>(AsciiParserState)
-    this.state.locations = new Tags(this.receivingBuffer.size / 10, this.maxMessageLen)
+    // floored - Tags hands the starting length to new Array, which rejects a
+    // fraction, so any buffer size not divisible by 10 threw from here
+    this.state.locations = new Tags(Math.floor(this.receivingBuffer.size / 10), this.maxMessageLen)
     this.state.definitions = this.config.definitions
     this.state.beginMessage()
     if (readStream !== null) {
@@ -101,6 +103,19 @@ export class AsciiParser extends MsgParser {
     this.parse(buff, buff.length)
   }
 
+  /**
+   * feed bytes as though they had arrived from the transport. This is the path
+   * the socket takes - subscribe hands each chunk it receives straight to parse -
+   * so a caller driving the parser directly, a benchmark or a replay harness,
+   * measures the real thing rather than a copy of it.
+   *
+   * @param buff bytes to parse
+   * @param end how much of buff to consume, all of it by default
+   */
+  public parseBuffer (buff: Buffer, end: number = buff.length): void {
+    this.parse(buff, end)
+  }
+
   private parse (readBuffer: Buffer, end: number): void {
     const state = this.state
     const eq: number = AsciiChars.Eq

package/src/buffer/ascii/ascii-segment-parser.ts

@@ -29,10 +29,13 @@ export class AsciiSegmentParser {
   public parse (msgType: string, tags: Tags, last: number): Structure | null {
     // completed segments in that they are fully parsed
     const segments: SegmentDescription[] = []
-    const msgDefinition: MessageDefinition | undefined = this.definitions.message.get(msgType)
-    if (!msgDefinition) {
+    const resolved: MessageDefinition | undefined = this.definitions.message.get(msgType)
+    if (!resolved) {
       return null
     }
+    // narrowing of resolved is not visible inside the hoisted helpers below, so
+    // carry the definition on a const the compiler already sees as non-optional
+    const msgDefinition: MessageDefinition = resolved
     // in process of being discovered and may have any amount of depth
     // i.e. a component containing a repeated group of components
     // with sub-groups of components
@@ -41,8 +44,8 @@ export class AsciiSegmentParser {
     let peek: SegmentDescription
 
     // track depth-1 components that have been exited for fragmentation detection
-    const exitedDepth1Components: Set<string> = new Set()
-    const fragmentedComponents: Set<string> = new Set()
+    const exitedDepth1Components = new Set<string>()
+    const fragmentedComponents = new Set<string>()
 
     // having finished one segments keep unwinding until tag matches further up stack
     function unwind (tag: number): void {
@@ -189,8 +192,8 @@ export class AsciiSegmentParser {
       // only build SegmentViews for components detected as fragmented during discover
       // non-fragmented components use their position ranges directly (zero overhead)
       if (fragmentedComponents.size === 0) return
-      const ti = new TagIndex(msgDefinition!, tags, last + 1)
-      const seen: Set<string> = new Set()
+      const ti = new TagIndex(msgDefinition, tags, last + 1)
+      const seen = new Set<string>()
       for (let i = 1; i < segments.length - 1; i++) {
         const seg = segments[i]
         if (seg.depth !== 1) continue

package/src/buffer/ascii/tag-index.ts

@@ -10,9 +10,9 @@ export interface TagSpan {
 
 export class TagIndex {
   private readonly sortedTagPos: TagPos[]
-  private readonly tagSpans: Map<number, TagSpan> = new Map()
-  private readonly componentGroupWrappers: Set<string> = new Set()
-  private readonly cache: Map<string, SegmentView | null> = new Map()
+  private readonly tagSpans = new Map<number, TagSpan>()
+  private readonly componentGroupWrappers = new Set<string>()
+  private readonly cache = new Map<string, SegmentView | null>()
 
   constructor (
     public readonly set: IContainedSet,

package/src/buffer/msg-view.ts

@@ -263,29 +263,46 @@ export abstract class MsgView {
     return JSON.stringify(this.toObject(), null, 4)
   }
 
+  /**
+   * fetch a nested view, either by a single name - getView('Instrument') - or by a
+   * dotted path walked a step at a time - getView('Parties.PtysSubGrp')
+   */
   public getView (name: string): MsgView | null {
-    const parts: string[] = name.split('.')
-    const reducer = (a: MsgView | null, current: string): MsgView | null => {
-      if (!a) {
-        return a
+    // the dotted form is the exception. resolve a plain name without paying for
+    // the parts array and the closure a split and reduce would allocate - the
+    // component walk in toObject and validate comes through here per component.
+    if (!name.includes('.')) {
+      return this.resolveChild(name)
+    }
+    let view: MsgView | null = this
+    for (const part of name.split('.')) {
+      view = view.resolveChild(part)
+      if (!view) {
+        return null
       }
-      const structure = a.structure
-      const singleton: SegmentDescription | null = structure?.firstContainedWithin(current, a.segment) ?? null
-      if (singleton) {
-        return a.create(singleton)
-      }
-      // is this a full name where abbreviation exists
-      const component: ContainedField | null = a.segment.set?.localNameToField.get(current) ?? null
+    }
+    return view
+  }
 
-      if (component) {
-        const abbreviated: SegmentDescription | null = structure?.firstContainedWithin(component.name, a.segment) ?? null
-        if (abbreviated) {
-          return a.create(abbreviated)
-        }
+  /**
+   * resolve one step of a view path against this view
+   */
+  private resolveChild (name: string): MsgView | null {
+    const structure = this.structure
+    const singleton: SegmentDescription | null = structure?.firstContainedWithin(name, this.segment) ?? null
+    if (singleton) {
+      return this.create(singleton)
+    }
+    // is this a full name where abbreviation exists
+    const component: ContainedField | null = this.segment.set?.localNameToField.get(name) ?? null
+
+    if (component) {
+      const abbreviated: SegmentDescription | null = structure?.firstContainedWithin(component.name, this.segment) ?? null
+      if (abbreviated) {
+        return this.create(abbreviated)
       }
-      return null
     }
-    return parts.reduce<MsgView | null>(reducer, this)
+    return null
   }
 
   public abstract checksum (): number

package/src/config/js-fix-config.ts

@@ -6,6 +6,7 @@ import { EmptyLogFactory } from './empty-log-factory'
 import { AsciiChars } from '../buffer/ascii/ascii-chars'
 import { DependencyContainer } from 'tsyringe'
 import { IFixSessionStoreFactory } from '../store/fix-session-store-factory'
+import { ISessionRegistry } from '../transport/session/session-registry'
 
 export interface IJsFixConfig {
   factory: ISessionMsgFactory | null
@@ -16,11 +17,18 @@ export interface IJsFixConfig {
   logFactory: JsFixLoggerFactory
   sessionContainer: DependencyContainer
   sessionStoreFactory?: IFixSessionStoreFactory
+  /**
+   * Tracks the live session per SessionId.  Set by the acceptor listener so a
+   * reconnecting counterparty replaces - rather than duplicates - its session.
+   */
+  sessionRegistry?: ISessionRegistry
 }
 
 export class JsFixConfig implements IJsFixConfig {
   public logDelimiter: number = AsciiChars.Pipe
   public sessionContainer: DependencyContainer
+  public sessionStoreFactory?: IFixSessionStoreFactory
+  public sessionRegistry?: ISessionRegistry
   constructor (
     public readonly factory: ISessionMsgFactory | null,
     public readonly definitions: FixDefinitions,

package/src/dictionary/parser/quickfix/dictionary-validator.ts

@@ -49,7 +49,7 @@ export class DictionaryValidator {
   private readonly allFieldNames: string[] = []
   private readonly allComponentNames: string[] = []
 
-  get errors (): ReadonlyArray<ValidationError> {
+  get errors (): readonly ValidationError[] {
     return this._errors
   }
 

package/src/dictionary/parser/quickfix/quick-fix-graph-parser.ts

@@ -51,7 +51,7 @@ export class GraphNode {
     public readonly element: XNode
   ) {}
 
-  get edges (): ReadonlyArray<Edge> {
+  get edges (): readonly Edge[] {
     return this._edges
   }
 
@@ -118,8 +118,7 @@ export class QuickFixGraphParser {
     this.parseTrailer(doc)
     this.parseMessages(doc)
 
-    while (this.queue.length > 0) {
-      const node = this.queue.shift()!
+    for (let node = this.queue.shift(); node !== undefined; node = this.queue.shift()) {
       this.work(node)
     }
 

package/src/dictionary/parser/quickfix/validation-error.ts

@@ -14,7 +14,7 @@ export interface ValidationError {
 }
 
 export class DictionaryValidationException extends Error {
-  constructor (public readonly errors: ReadonlyArray<ValidationError>) {
+  constructor (public readonly errors: readonly ValidationError[]) {
     const errorCount = errors.filter(e => e.severity === ValidationSeverity.Error).length
     const warningCount = errors.filter(e => e.severity === ValidationSeverity.Warning).length
     const header = `FIX dictionary validation failed with ${errorCount} error(s) and ${warningCount} warning(s):`

package/src/jsfix-bench.ts

@@ -0,0 +1,204 @@
+import 'reflect-metadata'
+
+import * as path from 'path'
+import * as fs from 'fs'
+import minimist = require('minimist')
+import buildOptions from 'minimist-options'
+
+import { AsciiChars } from './buffer/ascii'
+import { IJsFixConfig } from './config'
+import { DefinitionFactory } from './util'
+import { SessionContainer } from './runtime'
+import { DITokens } from './runtime/di-tokens'
+import {
+  BenchRunner,
+  IBenchCase,
+  IBenchOptions,
+  IBenchSuiteResult,
+  ParseCase,
+  ParseDepth,
+  defaultBenchOptions,
+  formatComparison,
+  formatSuite
+} from './benchmark'
+
+const options = buildOptions({
+  dict: {
+    type: 'string',
+    alias: 'd',
+    default: 'qf44'
+  },
+
+  fix: {
+    type: 'string',
+    alias: 'f',
+    default: 'data/examples/FIX.4.4/quickfix/execution-report/fix.txt'
+  },
+
+  session: {
+    type: 'string',
+    alias: 's',
+    default: 'data/session/test-initiator.json'
+  },
+
+  delimiter: {
+    type: 'string',
+    alias: 'l',
+    default: '|'
+  },
+
+  depth: {
+    type: 'string',
+    default: 'view,object'
+  },
+
+  rounds: {
+    type: 'number',
+    default: defaultBenchOptions.rounds
+  },
+
+  msgs: {
+    type: 'number',
+    default: defaultBenchOptions.operationsPerRound
+  },
+
+  warmup: {
+    type: 'number',
+    default: defaultBenchOptions.warmupOperations
+  },
+
+  label: {
+    type: 'string',
+    default: 'jspurefix'
+  },
+
+  save: {
+    type: 'string'
+  },
+
+  baseline: {
+    type: 'string'
+  },
+
+  json: {
+    type: 'boolean',
+    default: false
+  },
+
+  help: {
+    type: 'boolean',
+    alias: 'h',
+    default: false
+  }
+})
+
+const argv: any = minimist(process.argv.slice(2), options)
+
+const root: string = path.join(__dirname, '../')
+
+function norm (p: string): string {
+  return path.isAbsolute(p) ? p : path.join(root, p)
+}
+
+function usage (): void {
+  console.log('measure the parse path and what it costs in time and in garbage')
+  console.log()
+  console.log('  --fix=<path>        fix log to parse, defaults to a 4.4 execution report')
+  console.log('  --dict=<name>       dictionary, e.g. qf44, repo44, qf50sp2')
+  console.log('  --delimiter=<char>  field delimiter in the log, defaults to |')
+  console.log('  --depth=view,object which stages to measure, comma separated')
+  console.log('  --rounds=<n>        measured rounds, one sample each')
+  console.log('  --msgs=<n>          messages per round')
+  console.log('  --warmup=<n>        messages discarded before measuring')
+  console.log('  --save=<path>       write the suite to json')
+  console.log('  --baseline=<path>   compare against a previously saved suite')
+  console.log('  --json              print the suite as json instead of a report')
+  console.log()
+  console.log('run under --expose-gc so rounds can be isolated and heap read cleanly:')
+  console.log('  node --expose-gc dist/jsfix-bench --fix=data/examples/FIX.4.4/quickfix/execution-report/fix.txt')
+  console.log('  npm run bench')
+}
+
+async function makeConfig (): Promise<IJsFixConfig> {
+  const sys = new SessionContainer()
+  sys.registerGlobal('error')
+  const sessionDescription = require(norm(argv.session))
+  const container = await sys.makeSystem(sessionDescription)
+  const config = container.resolve<IJsFixConfig>(DITokens.IJsFixConfig)
+  config.definitions = await new DefinitionFactory().getDefinitions(argv.dict)
+  // the parser reads the delimiter when it is constructed, so this has to be
+  // settled before any case is built
+  config.delimiter = AsciiChars.firstChar(argv.delimiter)
+  return config
+}
+
+function requestedDepths (): ParseDepth[] {
+  const known = new Map<string, ParseDepth>([
+    ['view', ParseDepth.View],
+    ['object', ParseDepth.Object]
+  ])
+  const asked = String(argv.depth).split(',').map(d => d.trim().toLowerCase()).filter(d => d.length > 0)
+  return asked.map(d => {
+    const depth = known.get(d)
+    if (!depth) {
+      throw new Error(`unknown depth ${d}, expected view or object`)
+    }
+    return depth
+  })
+}
+
+function readSuite (p: string): IBenchSuiteResult {
+  return JSON.parse(fs.readFileSync(norm(p), 'utf8'))
+}
+
+async function main (): Promise<void> {
+  if (argv.help) {
+    usage()
+    return
+  }
+  const fixPath = norm(argv.fix)
+  if (!fs.existsSync(fixPath)) {
+    throw new Error(`no such fix log ${fixPath}`)
+  }
+  const contents = fs.readFileSync(fixPath, 'utf8')
+  const config = await makeConfig()
+
+  const cases: ParseCase[] = requestedDepths().map(depth =>
+    new ParseCase(`parse:${depth}`, { config, contents, depth }))
+
+  // every case walks the same input, so one alignment covers the suite and all
+  // of them stay directly comparable
+  const perInvocation = cases[0].operationsPerInvocation
+  const operationsPerRound = cases[0].alignOperations(argv.msgs)
+  const benchOptions: IBenchOptions = {
+    warmupOperations: cases[0].alignOperations(argv.warmup),
+    rounds: argv.rounds,
+    operationsPerRound,
+    gcBetweenRounds: true
+  }
+
+  console.log(`${path.relative(root, fixPath)}  ${perInvocation} msg/pass  dict ${argv.dict}`)
+  const suite = await new BenchRunner(benchOptions).runAll(argv.label, cases as IBenchCase[])
+
+  if (argv.json) {
+    console.log(JSON.stringify(suite, null, 2))
+  } else {
+    console.log()
+    console.log(formatSuite(suite))
+  }
+  if (argv.baseline) {
+    console.log()
+    console.log(formatComparison(readSuite(argv.baseline), suite))
+  }
+  if (argv.save) {
+    const target = norm(argv.save)
+    fs.mkdirSync(path.dirname(target), { recursive: true })
+    fs.writeFileSync(target, JSON.stringify(suite, null, 2), 'utf8')
+    console.log(`saved ${path.relative(root, target)}`)
+  }
+}
+
+main().catch(e => {
+  console.error(e instanceof Error ? e.message : e)
+  process.exit(1)
+})

package/src/runtime/session-launcher.ts

@@ -126,8 +126,12 @@ export abstract class SessionLauncher {
       this.registerApplication(container)
     } else {
       if (factory.makeSession) {
+        // resolve the config from the container doing the resolving, not the one
+        // captured here.  An acceptor resolves each session from a per-connection
+        // child scope which re-registers IJsFixConfig, so this is how an application
+        // receives that session's own description, store and message factory.
         container.register<FixSession>(DITokens.FixSession, {
-          useFactory: () => factory.makeSession(config)
+          useFactory: (c) => factory.makeSession(c.resolve<IJsFixConfig>(DITokens.IJsFixConfig))
         })
       }
     }

package/src/runtime/session-scope.ts

@@ -0,0 +1,84 @@
+import { DependencyContainer } from 'tsyringe'
+import { IJsFixConfig, JsFixConfig } from '../config'
+import { DITokens } from './di-tokens'
+import { ElasticBuffer } from '../buffer/elastic-buffer'
+import { ISessionDescription } from '../transport/session/session-description'
+import { ISessionMsgFactory } from '../transport/session/session-msg-factory'
+import { cloneSessionDescription } from '../transport/session/clone-session-description'
+import { AsciiSessionMsgFactory } from '../transport/ascii/ascii-session-msg-factory'
+import { FixmlSessionMsgFactory } from '../transport/fixml/fixml-session-msg-factory'
+
+/**
+ * A FIX acceptor serves many connections from one listener configuration.  Until
+ * this existed every accepted connection shared the *same* parse buffer, transmit
+ * buffer, session description and message factory, because those are registered as
+ * instances on the single session container built at start up.  Two clients talking
+ * to one acceptor would therefore interleave bytes in a shared ElasticBuffer and
+ * compute the same SessionId - so the same message store file.
+ *
+ * A session scope is a tsyringe child container which re-registers exactly the
+ * per-connection state.  Everything else (dictionary, transient parser/transmitter
+ * classes, logger factory) is inherited from the parent, and resolving a parent
+ * registration from the child still injects the child's instances, so an
+ * AsciiParser resolved here receives this scope's ParseBuffer.
+ *
+ * Mirrors cspurefix TradeCaptureSessionFactory.CreatePerSessionConfigAndEncoder,
+ * which had to do the same thing for the same reason.
+ */
+export function makeSessionScope (
+  config: IJsFixConfig,
+  overrides?: Partial<ISessionDescription>): IJsFixConfig {
+  const parent: DependencyContainer = config.sessionContainer
+  const scope = parent.createChildContainer()
+
+  const description = cloneSessionDescription(config.description, overrides)
+  const factory = makeSessionMsgFactory(description, config.factory)
+
+  scope.registerInstance(DITokens.ISessionDescription, description)
+  scope.registerInstance(DITokens.ISessionMsgFactory, factory)
+  scope.registerInstance<ElasticBuffer>(DITokens.TransmitBuffer, cloneBuffer(parent, DITokens.TransmitBuffer))
+  scope.registerInstance<ElasticBuffer>(DITokens.ParseBuffer, cloneBuffer(parent, DITokens.ParseBuffer))
+
+  const scoped = new JsFixConfig(factory, config.definitions, description, config.delimiter, config.logFactory)
+  scoped.logDelimiter = config.logDelimiter ?? scoped.logDelimiter
+  scoped.sessionStoreFactory = config.sessionStoreFactory
+  scoped.sessionRegistry = config.sessionRegistry
+  scoped.sessionContainer = scope
+  scope.registerInstance(DITokens.IJsFixConfig, scoped)
+  scope.registerInstance(DITokens.Definitions, config.definitions)
+
+  return scoped
+}
+
+/**
+ * A fresh buffer of the same capacity as the one the parent container holds, so the
+ * sizing decisions made in SessionContainer.asAscii are honoured without repeating
+ * them here.
+ */
+function cloneBuffer (parent: DependencyContainer, token: DITokens): ElasticBuffer {
+  if (!parent.isRegistered(token, true)) {
+    return new ElasticBuffer()
+  }
+  const existing = parent.resolve<ElasticBuffer>(token)
+  return new ElasticBuffer(existing.size)
+}
+
+/**
+ * The scope needs a factory bound to *its* description, because the outbound header
+ * carries this session's comp ids.  Applications may supply their own factory (by
+ * overriding SessionContainer.makeSessionFactory), and that must survive into the
+ * per-session scope - building a stock one here would silently drop custom header
+ * handling on the acceptor path.  See issue #87.
+ */
+function makeSessionMsgFactory (
+  description: ISessionDescription,
+  current: ISessionMsgFactory | null): ISessionMsgFactory {
+  if (current?.cloneFor) {
+    return current.cloneFor(description)
+  }
+  const ascii = description.application?.protocol === 'ascii'
+  const mutator = (current as any)?.mutator ?? null
+  return ascii
+    ? new AsciiSessionMsgFactory(description, mutator)
+    : new FixmlSessionMsgFactory(description, mutator)
+}

package/src/sample/http/oms/app.ts

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