jspurefix 5.11.3 → 5.11.4

package/src/generator/value-conventions.ts

@@ -0,0 +1,295 @@
+import { SimpleFieldDefinition } from '../dictionary/definition'
+import { TagType } from '../buffer/tag/tag-type'
+import { MarketContext } from './market-context'
+
+/**
+ * How a tag gets a value that looks like the thing it names.
+ *
+ * Three layers, tried in order, and the ordering is the design:
+ *
+ *  1. a table of tags whose meaning the generator actually knows, read off the
+ *     `MarketContext` so they agree with each other;
+ *  2. conventions over the field *name* - anything ending `Px`, `Qty`, `Currency`,
+ *     `Date` and so on - which is what lets an unfamiliar message type, or a broker
+ *     dialect nobody here has seen, still come out readable;
+ *  3. the type, as a last resort, but with ranges a trader would not blink at rather
+ *     than a signed float with seven decimal places.
+ *
+ * Layer 2 is doing most of the work.  FIX field naming is remarkably disciplined -
+ * `LegLastPx`, `UnderlyingSettlPrice`, `AllocSettlCurrency` - so a suffix is very nearly
+ * a type declaration, and treating it as one covers thousands of fields for the cost of
+ * a dozen rules.
+ *
+ * Which *instrument* a value is read from is not decided here.  The walker moves
+ * `MarketContext.leg` and `.underlying` as it descends, so `LegPrice` inside the second
+ * leg resolves against that leg without this layer knowing where it is.
+ */
+
+export interface IFieldContext {
+  /** set names from the message down to the field, e.g. ['TrdCapRptSideGrp', 'Parties'] */
+  readonly path: readonly string[]
+  /** index within the nearest enclosing group instance, 0 when not in a group */
+  readonly instance: number
+}
+
+const mics: readonly string[] = ['XLON', 'XNAS', 'XNYS', 'XETR', 'IFEU', 'XCME', 'XOFF']
+const currencies: readonly string[] = ['USD', 'EUR', 'GBP', 'JPY', 'CHF']
+const sessions: readonly string[] = ['DAY', 'REG', 'ELECTRONIC', 'AFTERHOURS']
+const ratings: readonly string[] = ['AAA', 'AA+', 'A', 'BBB+', 'BB-']
+const countries: readonly string[] = ['US', 'GB', 'DE', 'NL', 'JP']
+/** a field named for a classification but with no enumeration behind it in this
+ *  dictionary - still a small ordinal, not a five digit number */
+const ordinalName = /(Type|Status|Reason|Indicator|Action|Capacity|Method|Mode|Level)$/
+
+type Handler = (m: MarketContext, ctx: IFieldContext, sf: SimpleFieldDefinition) => any
+
+/**
+ * Tags the generator understands well enough to keep consistent with the rest of the
+ * message.  Everything absent from here still gets a plausible value from the name
+ * conventions below - it just is not tied to the trade.
+ */
+const byTag: Map<number, Handler> = new Map<number, Handler>([
+  [1, m => m.account],
+  [6, m => m.avgPx],
+  [11, (m, ctx) => (ctx.instance > 0 ? `${m.clOrdId}-${ctx.instance}` : m.clOrdId)],
+  [14, m => m.cumQty],
+  [15, m => m.instrument.currency],
+  [17, m => `${m.execId}-${m.nextSeq()}`],
+  [22, m => m.current().securityIdSource],
+  [30, m => m.instrument.securityExchange],
+  [31, m => m.lastPx],
+  [32, m => m.lastQty],
+  [37, (m, ctx) => (ctx.instance > 0 ? `${m.orderId}-${ctx.instance}` : m.orderId)],
+  [38, m => m.orderQty],
+  [41, m => m.origClOrdId],
+  [44, m => m.price],
+  [48, m => m.current().securityId],
+  [54, (m, ctx) => (ctx.instance % 2 === 0 ? m.side : (m.side === '1' ? '2' : '1'))],
+  [55, m => m.current().symbol],
+  [58, m => m.text()],
+  [60, m => m.transactTime],
+  [64, m => m.settlDate],
+  [75, m => m.tradeDate],
+  [76, m => m.firms[0].id],
+  [100, m => m.instrument.securityExchange],
+  [107, m => m.instrument.name],
+  [110, m => m.instrument.lotSize],
+  [151, m => m.leavesQty],
+  [167, m => m.current().securityType],
+  [200, m => m.current().maturityMonthYear ?? m.instrument.maturityMonthYear],
+  [201, m => m.instrument.putOrCall],
+  [202, m => m.instrument.strikePrice],
+  [207, m => m.instrument.securityExchange],
+  [231, m => m.instrument.contractMultiplier],
+  [336, m => m.rng.pick(sessions)],
+  [375, m => m.firms[2].id],
+  [381, m => m.grossAmount()],
+  [447, (m, ctx) => m.party(ctx.instance).idSource],
+  [448, (m, ctx) => m.party(ctx.instance).id],
+  [452, (m, ctx) => m.party(ctx.instance).role],
+  [460, m => m.instrument.product],
+  [461, m => m.instrument.cfiCode],
+  [541, m => m.instrument.maturityDate],
+  [571, m => m.tradeId],
+  [255, m => m.rng.pick(ratings)],
+  [470, m => m.rng.pick(countries)],
+  [472, m => m.rng.pick(countries)],
+  [65, () => undefined],
+  [572, m => `${m.tradeId}-REF`],
+
+  // legs - resolved through current(), which the walker has already pointed at the leg
+  [600, m => m.current().symbol],
+  [602, m => m.current().securityId],
+  [603, m => m.current().securityIdSource],
+  [609, m => m.current().securityType],
+  [610, m => m.current().maturityMonthYear],
+  [623, m => m.leg?.ratio ?? 1],
+  [624, m => m.leg?.side ?? m.side],
+  [566, m => m.priceNear()],
+  [637, m => m.priceNear()],
+  [687, m => m.lastQty * (m.leg?.ratio ?? 1)],
+
+  // underlyings
+  [311, m => m.underlying?.symbol ?? m.instrument.symbol],
+  [309, m => m.underlying?.securityId ?? m.instrument.securityId],
+  [305, m => m.underlying?.securityIdSource ?? m.instrument.securityIdSource],
+
+  // allocation
+  [79, m => m.account],
+  [80, m => m.lastQty],
+
+  // market data
+  [270, m => m.priceNear()],
+  [271, m => m.quantity()],
+  [272, m => m.tradeDate],
+  [273, m => m.transactTime],
+  [346, m => m.rng.int(1, 25)]
+])
+
+interface INameRule {
+  readonly test: RegExp
+  readonly apply: Handler
+}
+
+/**
+ * Suffix first, then a few prefixes.  Order matters - `PriceType` must not be caught by
+ * the `Price` rule, so the more specific patterns are listed above the general ones.
+ */
+const nameRules: readonly INameRule[] = [
+  { test: /(Type|Source|Status|Reason|Indicator|Capacity|Restrictions)$/, apply: () => undefined },
+
+  { test: /(Px|Price)$/, apply: m => m.priceNear() },
+  { test: /(Qty|Quantity|Shares|Size|Volume)$/, apply: m => m.quantity() },
+  { test: /(Currency|Ccy)$/, apply: m => m.rng.pick(currencies) },
+  { test: /Symbol$/, apply: m => m.current().symbol },
+  { test: /(Exchange|Mkt|Market)$/, apply: m => m.rng.pick(mics) },
+  { test: /SecurityID$/, apply: m => m.current().securityId },
+  { test: /(MonthYear)$/, apply: m => m.current().maturityMonthYear ?? m.instrument.maturityMonthYear },
+  { test: /(Amt|Amount|Notional|Consideration)$/, apply: m => m.grossAmount() },
+  { test: /(Rate|Yield|Coupon)$/, apply: m => Number((m.rng.int(1, 800) / 10000).toFixed(5)) },
+  { test: /(Percent|Pct|Ratio)$/, apply: m => Number((m.rng.int(0, 10000) / 100).toFixed(2)) },
+  { test: /Account$/, apply: m => m.account },
+  { test: /(Desk|Division)$/, apply: m => m.desk },
+  { test: /(Text|Desc|Description|Comment|Instructions)$/, apply: m => m.text() },
+  { test: /(Timestamp|Time)$/, apply: m => m.transactTime },
+  { test: /Date$/, apply: m => m.tradeDate },
+  { test: /(Broker|Firm)$/, apply: (m, ctx) => m.party(ctx.instance).id },
+  { test: /(Trader|User|Operator)$/, apply: m => m.traders[0].id }
+]
+
+function initials (name: string): string {
+  const caps = name.replace(/[^A-Z]/g, '')
+  if (caps.length >= 2) return caps.substring(0, 4)
+  return name.substring(0, 3).toUpperCase()
+}
+
+export class ValueConventions {
+  constructor (public readonly market: MarketContext) {
+  }
+
+  /**
+   * whether this tag is one the generator understands rather than merely guesses at.
+   * The field walker reads it as a proxy for "would a real message of this type carry
+   * this field", which is a crude signal but a better one than the tag number alone.
+   */
+  public static knows (tag: number): boolean {
+    return byTag.has(tag)
+  }
+
+  /**
+   * a value for this field, or undefined if the caller should leave the tag out
+   */
+  public value (sf: SimpleFieldDefinition, ctx: IFieldContext): any {
+    const exact = byTag.get(sf.tag)
+    if (exact) {
+      const v = exact(this.market, ctx, sf)
+      if (v != null) return this.conform(sf, v)
+      // a handler declining - e.g. StrikePrice on a future - is a reason to omit, not
+      // a reason to fall through and invent one
+      return undefined
+    }
+    if (sf.isEnum()) {
+      return this.enumValue(sf)
+    }
+    for (const rule of nameRules) {
+      if (!rule.test.test(sf.name)) continue
+      const v = rule.apply(this.market, ctx, sf)
+      if (v == null) break
+      return this.conform(sf, v)
+    }
+    return this.byType(sf, ctx)
+  }
+
+  /**
+   * Dictionaries list enumerated values roughly in order of how ordinary they are, so a
+   * front biased pick lands on Side 1 or 2 far more often than on the twenty exotics
+   * below them.  Not true universally, but true often enough to be worth more than a
+   * uniform draw, and it stays deterministic.
+   */
+  private enumValue (sf: SimpleFieldDefinition): any {
+    const keys = Array.from(sf.enums.keys())
+    if (keys.length === 0) return undefined
+    const choice = keys[this.market.rng.frontBiased(keys.length)]
+    switch (sf.tagType) {
+      case TagType.Int: return parseInt(choice, 10)
+      case TagType.Float: return parseFloat(choice)
+      case TagType.Boolean: return choice === 'Y'
+      default: return choice
+    }
+  }
+
+  /**
+   * a value supplied by tag or by name may not be of the type the dictionary declares -
+   * `SecurityIDSource` is a String in one dictionary and an Int in another - so coerce
+   * rather than emit something the encoder will mangle
+   */
+  private conform (sf: SimpleFieldDefinition, v: any): any {
+    switch (sf.tagType) {
+      case TagType.RawData: {
+        // a name rule may well have produced a perfectly good string for EncodedText,
+        // but the encoder writes the preceding Length only when handed a Buffer, and a
+        // raw field arriving without its length is unparseable
+        if (Buffer.isBuffer(v)) return v
+        return Buffer.from(String(v))
+      }
+      case TagType.Int:
+      case TagType.Length: {
+        if (typeof v === 'number') return Math.round(v)
+        const n = parseInt(String(v), 10)
+        return isNaN(n) ? undefined : n
+      }
+      case TagType.Float: {
+        if (typeof v === 'number') return v
+        const f = parseFloat(String(v))
+        return isNaN(f) ? undefined : f
+      }
+      case TagType.Boolean: {
+        if (typeof v === 'boolean') return v
+        return String(v) === 'Y' || String(v) === 'true'
+      }
+      case TagType.String: {
+        if (v instanceof Date) return MarketContext.yyyymmdd(v)
+        return String(v)
+      }
+      default:
+        return v
+    }
+  }
+
+  private byType (sf: SimpleFieldDefinition, ctx: IFieldContext): any {
+    const m = this.market
+    const rng = m.rng
+    switch (sf.tagType) {
+      case TagType.String:
+        if (ordinalName.test(sf.name)) return String(rng.int(0, 4))
+        // identifier shaped, and carrying the field it came from, so a message can be
+        // read back to the dictionary by eye
+        return `${initials(sf.name)}-${rng.int(1000, 99999)}`
+      case TagType.Int:
+        return ordinalName.test(sf.name) ? rng.int(0, 4) : rng.int(1, 500)
+      case TagType.Float:
+        return Number((rng.int(1, 100000) / 100).toFixed(2))
+      case TagType.Length:
+        // written by the encoder from the RawData it precedes
+        return undefined
+      case TagType.Boolean:
+        return rng.bool(0.5)
+      case TagType.UtcTimestamp:
+        return m.transactTime
+      case TagType.UtcTimeOnly: {
+        const t = m.transactTime
+        return new Date(Date.UTC(0, 0, 0, t.getUTCHours(), t.getUTCMinutes(), t.getUTCSeconds(), 0))
+      }
+      case TagType.UtcDateOnly:
+        return m.tradeDate
+      case TagType.LocalDate: {
+        const d = m.tradeDate
+        return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), 0, 0, 0, 0)
+      }
+      case TagType.RawData:
+        return Buffer.from(`${initials(sf.name)}:${m.tradeId}:${ctx.instance}`)
+      default:
+        return undefined
+    }
+  }
+}

package/src/index.ts

@@ -4,3 +4,15 @@ export * from './buffer'
 export * from './transport'
 export * from './config'
 export * from './types'
+export * from './collections'
+export * from './store'
+export * from './util/definition-factory'
+export * from './util/dictionary-path'
+
+// These live in the generated dictionaries but appear in the public signature of
+// the session message factory, so an application overriding logon() or header()
+// has to be able to name them.  Without this it can only reach them behind a
+// dist/ path, which is what drove the module augmentation in issue #85.  The
+// FIXML one is aliased because both dictionaries call theirs IStandardHeader.
+export type { IStandardHeader, IHop } from './types/FIX4.4/repo'
+export type { IStandardHeader as IFixmlStandardHeader } from './types/FIXML50SP2'

package/src/jsfix-cmd.ts

@@ -5,6 +5,7 @@ import { AsciiParser, AsciiView, AsciiChars } from './buffer/ascii'
 import { ILooseObject } from './collections/collection'
 import { SimpleFieldDefinition, FixDefinitions } from './dictionary/definition'
 import { MessageGenerator, JsonHelper, getWords, DefinitionFactory } from './util'
+import { CaseBuilder, CorpusStore, IGeneratedCase, IGeneratorOptions, IOutcome, Scenarios, classify, describeCase, describeOutcome } from './generator'
 import { ISessionDescription, FileDuplex, StringDuplex } from './transport'
 
 import { MsgTag } from './types'
@@ -118,6 +119,46 @@ const options = buildOptions({
     default: 0.8
   },
 
+  scenarios: {
+    type: 'boolean',
+    default: false
+  },
+
+  realistic: {
+    type: 'boolean',
+    default: false
+  },
+
+  'russian-doll': {
+    type: 'number',
+    default: 0
+  },
+
+  fragments: {
+    type: 'number',
+    default: 2
+  },
+
+  seed: {
+    type: 'number',
+    default: 0
+  },
+
+  'as-of': {
+    type: 'string',
+    default: ''
+  },
+
+  'corpus-add': {
+    type: 'string',
+    default: ''
+  },
+
+  note: {
+    type: 'string',
+    default: ''
+  },
+
   repeats: {
     type: 'number',
     alias: 'r',
@@ -342,6 +383,15 @@ export class JsfixCmd {
   }
 
   protected async generate (): Promise<void> {
+    if (argv.scenarios) {
+      console.log('scenarios - a named shape of traffic, generated to look like the real thing')
+      console.log(Scenarios.describe())
+      return
+    }
+    if (argv.scenario || argv.realistic || argv['russian-doll'] > 0) {
+      await this.generateCase()
+      return
+    }
     const lipPath: string = path.join(this.root, 'data/examples/lipsum.txt')
     const words: string[] = await getWords(lipPath)
     const generator = new MessageGenerator(words, this.definitions)
@@ -361,6 +411,134 @@ export class JsfixCmd {
     }
   }
 
+  /**
+   * The realistic generator: a message that reads like traffic, optionally taken apart
+   * into a legal but scattered ordering, and then round tripped through the parser to
+   * say whether this engine survives the shape.
+   */
+  private async generateCase (): Promise<void> {
+    if (!this.session) {
+      console.log('provide a session json file e.g. --session=data/session/test-initiator.json')
+      return
+    }
+    const delimiter = String.fromCharCode(this.delimiter)
+    const builder = new CaseBuilder(this.definitions, (msgType, obj) => this.encodeObject(msgType, obj))
+    const generated = builder.build({
+      scenario: argv.scenario,
+      msgType: argv.type,
+      seed: argv.seed || 0x5eed,
+      depth: argv['russian-doll'] || 0,
+      fragments: argv.fragments || 2,
+      delimiter,
+      generator: JsfixCmd.generatorOverrides()
+    })
+    console.log(describeCase(generated, delimiter))
+    console.log('')
+    console.log(JSON.stringify(generated.object, null, 4))
+    console.log('')
+    console.log(`canonical ${generated.canonical}`)
+    if (generated.plan.depth > 0) {
+      console.log(`scattered ${generated.scattered}`)
+    }
+    const outcome = await this.reportRoundTrip(generated)
+    if (argv.unit) {
+      await JsfixCmd.writeFile('./fix.txt', generated.scattered)
+      await JsfixCmd.writeFile('./canonical.txt', generated.canonical)
+      await JsfixCmd.writeFile('./object.json', JSON.stringify(generated.object, null, 4))
+      await JsfixCmd.writeFile('./plan.json', JSON.stringify(generated.plan, null, 4))
+      await JsfixCmd.writeFile('./case.txt', describeCase(generated, delimiter))
+    }
+    if (argv['corpus-add']) {
+      this.addToCorpus(generated, outcome, delimiter)
+    }
+  }
+
+  /**
+   * Only the options actually given on the command line.  A key present with an undefined
+   * value still wins a spread, so building this object unconditionally would silently
+   * erase whatever density the chosen scenario had asked for.
+   */
+  private static generatorOverrides (): IGeneratorOptions {
+    const overrides: ILooseObject = {}
+    // a seed fixes every choice the generator makes, but dates are read off the wall
+    // clock unless anchored, so a reproducible corpus needs --as-of as well
+    if (argv['as-of']) {
+      overrides.asOf = new Date(argv['as-of'])
+    }
+    if (argv.realistic && argv.density != null) {
+      overrides.density = parseFloat(argv.density)
+    }
+    return overrides
+  }
+
+  /**
+   * Freeze this case into the corpus.  What is written is the bytes and the expectation,
+   * not the seed - a seed only reproduces a message while the generator is unchanged, and
+   * a corpus has to outlive the tool that proposed it.
+   */
+  private addToCorpus (generated: IGeneratedCase, outcome: IOutcome | null, delimiter: string): void {
+    if (generated.plan.depth === 0) {
+      console.log('cannot add to the corpus - nothing was scattered, so there is nothing to assert')
+      return
+    }
+    if (!outcome) {
+      console.log('cannot add to the corpus - the canonical encoding did not parse')
+      return
+    }
+    const name = `${argv['corpus-add']}`
+    const note = argv.note ? `${argv.note}` : describeOutcome(outcome)
+    // the corpus records the session relative to data/, and a path may arrive with
+    // either separator on windows
+    const session = `${argv.session}`.replace(/^.*data[\\/]/, '')
+    const store = new CorpusStore(path.join(this.root, 'data/corpus'))
+    const entry = CorpusStore.fromCase(
+      name,
+      note,
+      `${argv.dict ?? this.sessionDescription?.application?.dictionary ?? 'unknown'}`,
+      session,
+      delimiter,
+      generated,
+      outcome.outcome,
+      outcome,
+      argv['as-of'] ? new Date(argv['as-of']) : undefined)
+    const written = store.save(entry, generated.canonical, generated.scattered)
+    console.log(`corpus case ${name} written to ${written}`)
+    console.log(`expected outcome recorded as ${outcome.outcome} - read it before committing`)
+  }
+
+  /**
+   * Parse both encodings and compare.  The canonical one is contiguous by construction
+   * so it is the oracle; the scattered one says the same thing in a different order, so
+   * any difference at all is the engine losing information.
+   */
+  private async reportRoundTrip (generated: IGeneratedCase): Promise<IOutcome | null> {
+    const canonical = await this.parseOnce(generated.canonical)
+    if (!canonical.view) {
+      console.log(`canonical does not parse: ${canonical.error ?? 'no message'}`)
+      return null
+    }
+    if (generated.plan.depth === 0) {
+      console.log('canonical parses')
+      return null
+    }
+    const scattered = await this.parseOnce(generated.scattered)
+    const outcome = classify(
+      canonical.view.toObject(),
+      scattered.view ? scattered.view.toObject() : null)
+    console.log(describeOutcome(outcome))
+    return outcome
+  }
+
+  private async parseOnce (fix: string): Promise<{ view: MsgView | null, error: string | null }> {
+    const transport: MsgTransport = new MsgTransport(1, this.session.config, new StringDuplex(fix))
+    try {
+      const view = await this.firstMessage(transport)
+      return { view, error: null }
+    } catch (e: any) {
+      return { view: null, error: e?.message ?? `${e}` }
+    }
+  }
+
   private async single (generator: MessageGenerator, density: number): Promise<void> {
     if (!argv.type) {
       console.log('specify type to generate e.g. --type = AE')
@@ -778,6 +956,32 @@ function showHelp (): void {
   console.log('npm run fixml -- --field=50')
   console.log()
 
+  console.log('list the named scenarios - lifelike messages built from a book of real instruments')
+  console.log('node dist/jsfix-cmd --generate --scenarios --session=data/session/test-initiator.json')
+  console.log('npm run scenarios')
+  console.log()
+
+  console.log('generate one lifelike message - prices on tick, quantities in lots, dates that agree')
+  console.log('node dist/jsfix-cmd --generate --scenario=spread-trade-capture --delimiter="|" --session=data/session/test-initiator.json')
+  console.log('npm run scenario -- --scenario=equity-fill')
+  console.log()
+
+  console.log('take the message apart - russian doll n scatters a component inside a component, n levels deep,')
+  console.log('then parses both orderings and says whether this engine survives the shape')
+  console.log('node dist/jsfix-cmd --generate --scenario=spread-trade-capture --russian-doll=2 --delimiter="|" --session=data/session/test-initiator.json')
+  console.log('npm run doll -- --scenario=spread-trade-capture --russian-doll=2')
+  console.log('add --seed=42 --as-of=2026-01-15T10:30:00Z to reproduce a case exactly, --unit to write the files')
+  console.log()
+
+  console.log('keep an interesting case - freezes the two encodings and the outcome into data/corpus,')
+  console.log('where src/test/ascii/corpus.test.ts picks it up.  read what it wrote, then commit it')
+  console.log('npm run doll -- --scenario=spread-trade-capture --russian-doll=2 --seed=1 --as-of=2026-01-15T10:30:00Z --corpus-add=my-case --note="what this shows"')
+  console.log()
+
+  console.log('any message type, lifelike rather than dense - see docs/scattered-components.md for what doll depth means')
+  console.log('node dist/jsfix-cmd --generate --realistic --type=8 --density=0.5 --delimiter="|" --session=data/session/test-initiator.json')
+  console.log()
+
   console.log('generate unit test set of files - i.e. randomly generate an object, encode to fix. density 1 is all fields')
   console.log('node dist/jsfix-cmd --generate --type=AE --density=0.8 --unit --delimiter="|" --session=data/session/test-initiator.json')
   console.log('npm run repo44-unit -- --type=AE')

package/src/store/fix-msg-ascii-store-resend.ts

@@ -2,7 +2,8 @@ import { IFixMsgStore } from './fix-msg-store'
 import { FixMsgStoreRecord, IFixMsgStoreRecord } from './fix-msg-store-record'
 import { IJsFixConfig } from '../config'
 import { MsgType } from '../types'
-import { ElasticBuffer, MsgView } from '../buffer'
+import { ElasticBuffer } from '../buffer/elastic-buffer'
+import { MsgView } from '../buffer/msg-view'
 import { AsciiParser } from '../buffer/ascii'
 import { ISequenceReset, IStandardHeader } from '../types/FIX4.4/repo'
 

package/src/store/fix-msg-store-record.ts

@@ -1,5 +1,8 @@
 import { ILooseObject } from '../collections/collection'
-import { MsgView } from '../buffer'
+// straight at the module, not the ../buffer barrel: the barrel now names the
+// ascii parser, which reaches config and back into this file - see the madge
+// check in npm run circular
+import { MsgView } from '../buffer/msg-view'
 import { MsgTag } from '../types'
 
 export interface IFixMsgStoreRecord {

package/src/store/index.ts

@@ -11,3 +11,4 @@ export * from './memory-session-stream-provider'
 export * from './file-session-stream-provider'
 export * from './file-session-store'
 export * from './store-config'
+export * from './fix-msg-store-state'

package/src/transport/index.ts

@@ -13,3 +13,13 @@ export * from './ascii/ascii-session'
 export * from './ascii/ascii-session-msg-factory'
 export * from './fixml/fixml-session-msg-factory'
 export * from './session'
+export * from './factory'
+// the transport description types an application writes in its session JSON -
+// the concrete tcp/http entities stay out of the root barrel so that requiring
+// jspurefix does not drag express in behind them
+export * from './tcp/tcp-transport-description'
+export * from './tcp/tls-options'
+export * from './http/http-transport-description'
+export * from './http/http-adapter'
+export * from './http/html-options'
+export * from './http/html-route'

package/src/transport/session/index.ts

@@ -12,3 +12,4 @@ export * from './resend-request-manager'
 export * from './fix-clock'
 export * from './session-registry'
 export * from './clone-session-description'
+export * from './fix-session-state-args'