jspurefix 5.2.0 → 5.5.0

package/BACKPORT_PLAN.md

@@ -44,22 +44,9 @@ Instrument tags (15, 22, 48, 55) are scattered among order tags (21, 38, 40, 44,
 2. **Fragment Detection**: If a tag belonging to an already-exited depth-1 component is encountered, that component is added to `FragmentedComponents`.
 3. **Optimised Access**: Only fragmented components get expensive `SegmentView` construction via `TagIndex`. Non-fragmented components use simple position ranges (no overhead).
 
-### TS Files to Modify
+### Status: **DONE**
 
-| File | Change |
-|------|--------|
-| `src/buffer/ascii/ascii-segment-parser.ts` | Add fragment detection (ExitedDepth1Components, FragmentedComponents tracking) |
-| `src/buffer/segment/segment-description.ts` | May need SegmentView reference for fragmented components |
-| New: `src/buffer/segment/segment-view.ts` | Port SegmentView for non-contiguous tag access |
-| New: `src/buffer/ascii/tag-index.ts` | Port TagIndex for tag span indexing |
-
-### Test Data
-
-Port from `~/dev/cs/cspurefix/PureFix.Test.ModularTypes/Data/examples/FIX.4.4/fixsim-examples.txt` — 46 real FIX messages including fragmented Instrument components. Write a failing test first to prove the problem, then fix.
-
-### C# Test Reference
-
-`~/dev/cs/cspurefix/PureFix.Test.ModularTypes/FixSimTest.cs` — parses all 46 messages, verifies type counts, deserialises ExecutionReport to strongly-typed object.
+Completed in PR #110 (commits `17bcf9b`, `9223192`). Tag index, fragment detection, and segment view ported. Also includes `d660460` (relax body length constraint) and `4197ce0` (relax raw data length constraint for replayed messages).
 
 ---
 
@@ -80,12 +67,9 @@ m_parser.Reset();
 
 Also resets transient coordinator state (logon retry count, timeout recovery attempts) while preserving sequence numbers.
 
-### TS Files to Modify
+### Status: **DONE**
 
-| File | Change |
-|------|--------|
-| `src/transport/session/fix-session.ts` | Add parser reset in reconnection path |
-| `src/buffer/ascii/ascii-parser.ts` | Ensure `reset()` method clears all partial state |
+Completed in PR #111 (commit `deaccc3`). Parser state reset on disconnect to prevent buffer corruption.
 
 ---
 
@@ -220,22 +204,20 @@ Depends on 4A + 4B.
 
 #### PR 5A: Storm protection wiring (low risk)
 
-| File | Action |
-|------|--------|
-| `src/transport/ascii/ascii-session.ts` | Use `ResendAction` from coordinator to decide between sending ResendRequest, waiting, or gap-filling |
-| New: `src/test/session/resend-storm-protection.test.ts` | ~5 tests |
+### Status: **DONE**
 
-Mostly already done if 3A-3C are complete — this PR wires the `ResendActionType` responses into session control flow.
+Storm protection was largely wired during PR 3C/3D. Remaining gaps completed:
+- Accept gap-triggering message instead of dropping it (match C# behaviour)
+- Add pending gap range check for delayed messages with `seqDelta <= 0`
+- Add `coordinator.tick()` to session tick loop for resend request timeout cleanup
 
 #### PR 5B: ResendGapFillOnly mode (zero risk, independent)
 
 | File | Action |
 |------|--------|
-| `src/config/js-fix-config.ts` | Add optional `resendGapFillOnly?: boolean` |
-| `src/store/fix-msg-ascii-store-resend.ts` | Early return path when enabled — always GapFill instead of replaying |
-| New: `src/test/store/resend-gap-fill-only.test.ts` | ~3 tests |
+### Status: **DONE**
 
-Can be done at **any time** — independent of all other PRs.
+Added `resendGapFillOnly` option to `StoreConfig`. When enabled, `FixMsgAsciiStoreResend` always returns a single GapFill instead of replaying stored messages — prevents accidental duplicate order execution for client/initiator sessions. 5 tests added.
 
 ---
 
@@ -257,24 +239,138 @@ PR 5B (ResendGapFillOnly) ──── independent, can be done anytime
 
 | PR | Risk | Reason |
 |----|------|--------|
+| 1 | Medium | Non-contiguous tag parsing — **DONE** (PR #110) |
+| 2 | Low | Parser reset on disconnect — **DONE** (PR #111) |
 | 3A, 3B | None | New files only — **DONE** |
 | 3C | HIGH | Refactors `checkSeqNo` — pure refactor, same behaviour, but core message path — **DONE** |
 | 3D | Medium | Adds new capabilities (logon retry, PossDupFlag, ResetSeqNum, timeout recovery) — **DONE** |
-| 4A, 4B | None | New files only |
-| 4C | Low | New file, tested with mocks |
-| 4D | Medium | Changes send path, store errors must not block sends |
-| 5A | Low | Wiring only, coordinator makes decisions |
-| 5B | None | Additive config option |
+| 4A, 4B | None | New files only — **DONE** |
+| 4C | Low | New file, tested with mocks — **DONE** (PR #120) |
+| 4D | Medium | Changes send path, store errors must not block sends — **DONE** |
+| 5A | Low | Wiring only, coordinator makes decisions — **DONE** |
+| 5B | None | Additive config option — **DONE** |
 
 ---
 
-## Phase 6: Message Generator / XML Parser (Future)
+## Phase 6: QuickFix XML Parser Rework
+
+**Priority: Medium | Risk: HIGH | Scope: Large (multi-session)**
+
+### Background
+
+The C# QuickFix XML parser (`QuickFixXmlFileParser.cs`) is architecturally superior:
+- **DOM-based**: parses XML once into `XDocument`, then walks the tree
+- **Graph-based resolution**: nodes + edges + work queue, deterministic single logical pass
+- **Post-processor**: `IndexVisitor` + `ContainedFieldCollector` with memoisation ensures every `ContainedFieldSet` knows all tags below it
+- **Pre-parse validation**: `DictionaryValidator` catches missing fields, duplicates, undefined references with Levenshtein typo suggestions
+
+The TS parser uses SAX streaming with iterative N-pass (up to 5x) forward reference resolution. This works but is fragile, hard to reason about, and diverges from C#.
+
+**Scope**: Only the QuickFix parser chain needs rework. FIXML (XSD, already has include graph) and Repository (sequential file parsing) are fine as-is.
+
+### Strategy: SAX → In-Memory Tree → Graph Resolution
+
+Rather than replacing SAX with a new XML library, wrap SAX to build a lightweight in-memory element tree on a single pass. This tree then provides DOM-like random access for the graph resolver, without introducing new dependencies.
+
+```typescript
+interface XElement {
+  name: string
+  attributes: Record<string, string>
+  children: XElement[]
+  line?: number
+}
+```
+
+### Delivery: 6 PRs
+
+#### PR 6A: XElement tree builder (new files only, zero risk)
+
+### Status: **DONE** (PR #124)
+
+`XElement` interface + `XDocument`/`XNode` query wrappers + `SaxTreeBuilder` (single SAX pass → in-memory tree). 51 tests across all FIX dictionaries.
+
+#### PR 6B: DictionaryValidator (new files only, zero risk)
+
+### Status: **DONE**
+
+Three-pass validator ported from C#: collect definitions, validate references (with Levenshtein "did you mean" suggestions), check unused definitions. 40 tests including validation against all real FIX dictionaries.
+
+#### PR 6C: Graph-based parser + IndexVisitor (medium risk)
+
+### Status: **DONE**
+
+Verbatim port of C# `QuickFixXmlFileParser`: `GraphNode`/`Edge`/`NodeElementType` + work queue + field/component/group/message resolution. New parser sits alongside legacy parser for safe comparison testing.
+
+Includes `IndexVisitor` post-processor (originally PR 6D, merged into 6C because the parser doesn't work without it). Walks every message in post-order, clears aggregated tag indices on each set, and re-adds direct fields via `ContainedSetBuilder` so parents correctly know all descendant tags.
+
+**Comparison test results:** Graph parser produces a **superset** of legacy parser output for FIX50SP2 — correctly resolves deeply nested forward references (e.g., DividendFXTriggerDateBusinessCenter chain) that the legacy 5-pass iterative parser truncates. This is a correctness improvement.
+
+41 new tests including comparison against legacy parser for FIX 4.2, 4.3, 4.4, and 5.0SP2.
+
+#### PR 6E: Switch default parser (HIGH risk)
+
+### Status: **DONE**
+
+Added `QuickFixGraphFileParser` adapter that extends `FixParser` and matches the legacy parser's `(MakeDuplex, GetJsFixLogger)` constructor signature. `DefinitionFactory.getParser()` now instantiates the graph parser for QuickFix XML — all dictionary loading goes through the graph parser by default.
+
+The legacy `QuickFixXmlFileParser` remains exported for backward compatibility (anyone importing it directly still gets the old behaviour), but no production code in the project uses it.
+
+**Test fallout fixed:**
+- `src/test/env/data/fix5-mod.xml` had a redundant 215-line "admin fields" section that duplicated 62 fields already present in the canonical fields section. Plus the `HopGrp` and `MsgTypeGrp` components were defined twice. The legacy parser silently swallowed both classes of duplicate; the graph parser's validator correctly flags them as errors. Removed the redundant admin section (kept the unique `OTP` custom tag) and the duplicate component definitions.
+- `src/test/ascii/qf-50sp2-dict.test.ts` had two assertions where `Instrument` and `TrdCapRptSideGrp` were expected as `required=false` for TradeCaptureReport. The dictionary clearly says `required='Y'` for both. The legacy parser was producing `required=false` (a real bug); the graph parser correctly returns `true`. Updated the assertions.
+- Updated `getTrimDefinitions` in the same file to use `QuickFixGraphFileParser` instead of the legacy parser for consistency.
+
+All 533 tests pass with the graph parser as the default.
+
+Note: `parse-progress.ts`, `parse-state.ts`, and the legacy parser itself are NOT yet deleted — that's deferred to a follow-up cleanup PR after a release cycle to give downstream consumers time to migrate.
+
+#### PR 6F: Fix Trim function (medium risk)
+
+### Status: **DONE — TS trim was already correct**
+
+After investigation: the TS trim function (`QuickFixXmlFileBuilder`) is correct. The "bug" we suspected was actually introduced during the C# port — see C# commit `2ee4620c`. The original C# `WriteComponents` used a `foreach` over a snapshot of `_seenComponents`, dropping any components discovered during iteration. The C# fix added `ProcessComponentFields` for eager recursive collection.
+
+The TS version uses `while (components.length > 0) { components.pop() }` — a proper iterative discovery loop where newly-pushed components are processed in subsequent iterations. This pattern doesn't have the bug.
+
+**Added** comprehensive round-trip tests in `src/test/dictionary/trim-round-trip.test.ts`:
+- Trim → reparse with strict graph parser validation
+- Compare flattened tag sets at the message level
+- Deep nested-set comparison (every component/group in every message)
+- Worst case: trim ALL 116 FIX50SP2 messages and deep-compare every one
+
+All 9 tests pass. No code changes needed to `quick-fix-xml-file-builder.ts`.
+
+### Dependency Graph
+
+```
+PR 6A (XElement tree) ──────────┐
+                                 ├──→ PR 6C (Graph parser) ──→ PR 6E (Switch default)
+PR 6B (DictionaryValidator) ───┘                │
+                                                 ↓
+                                      PR 6D (IndexVisitor) ──→ PR 6E
+                                      
+PR 6F (Fix Trim) ──── after 6C is stable
+```
+
+### Risk Summary
+
+| PR | Risk | Reason |
+|----|------|--------|
+| 6A | None | New files only, SAX wrapper — **DONE** (PR #124) |
+| 6B | None | New files only, validation — **DONE** |
+| 6C | Medium | Graph parser + IndexVisitor — sits alongside legacy parser — **DONE** |
+| 6D | (merged into 6C) | IndexVisitor was needed for 6C to work correctly |
+| 6E | HIGH | Switches default parser — exposed 2 legacy parser bugs (now fixed) — **DONE** |
+| 6F | None | TS trim already correct — round-trip tests added — **DONE** |
+
+### Test Strategy
 
-**Priority: Low | Risk: Medium | Scope: Large**
+The parser is the foundation of the entire system. Test strategy must be comprehensive:
 
-- C# uses nested types for groups (sub-types) in generated code
-- QuickFix XML parser has improved design with better error tracking
-- Nice to align for maintenance but not critical
+1. **Comparison tests**: parse every FIX XML dictionary (4.2, 4.3, 4.4, 5.0SP2) with both old and new parser, diff the resulting `FixDefinitions`
+2. **Round-trip tests**: parse → trim → reparse, verify definitions match
+3. **Micro-dictionary tests** (future hardening): use Trim to create single-message dictionaries, then mutate them (remove fields, duplicate tags, etc.) to test validator edge cases
+4. **Regression anchor**: snapshot the `FixDefinitions` output for each FIX version before any changes — tests assert against snapshots
 
 ---
 

package/dist/config/js-fix-config.d.ts

@@ -3,6 +3,7 @@ import { ISessionDescription } from '../transport/session/session-description';
 import { ISessionMsgFactory } from '../transport/session/session-msg-factory';
 import { JsFixLoggerFactory } from './js-fix-logger-factory';
 import { DependencyContainer } from 'tsyringe';
+import { IFixSessionStoreFactory } from '../store/fix-session-store-factory';
 export interface IJsFixConfig {
     factory: ISessionMsgFactory | null;
     definitions: FixDefinitions;
@@ -11,6 +12,7 @@ export interface IJsFixConfig {
     logDelimiter?: number;
     logFactory: JsFixLoggerFactory;
     sessionContainer: DependencyContainer;
+    sessionStoreFactory?: IFixSessionStoreFactory;
 }
 export declare class JsFixConfig implements IJsFixConfig {
     readonly factory: ISessionMsgFactory | null;

package/dist/config/js-fix-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"js-fix-config.js","sourceRoot":"","sources":["../../src/config/js-fix-config.ts"],"names":[],"mappings":";;;AAIA,2DAAqD;AACrD,6DAAwD;AAaxD,MAAa,WAAW;IAGtB,YACkB,OAAkC,EAClC,WAA2B,EAC3B,WAAgC,EAChC,YAAoB,wBAAU,CAAC,GAAG,EAClC,aAAiC,IAAI,mCAAe,EAAE;QAJtD,YAAO,GAAP,OAAO,CAA2B;QAClC,gBAAW,GAAX,WAAW,CAAgB;QAC3B,gBAAW,GAAX,WAAW,CAAqB;QAChC,cAAS,GAAT,SAAS,CAAyB;QAClC,eAAU,GAAV,UAAU,CAA4C;QAPjE,iBAAY,GAAW,wBAAU,CAAC,IAAI,CAAA;IAQ7C,CAAC;CACF;AAVD,kCAUC","sourcesContent":["import { FixDefinitions } from '../dictionary/definition'\nimport { ISessionDescription } from '../transport/session/session-description'\nimport { ISessionMsgFactory } from '../transport/session/session-msg-factory'\nimport { JsFixLoggerFactory } from './js-fix-logger-factory'\nimport { EmptyLogFactory } from './empty-log-factory'\nimport { AsciiChars } from '../buffer/ascii/ascii-chars'\nimport { DependencyContainer } from 'tsyringe'\n\nexport interface IJsFixConfig {\n  factory: ISessionMsgFactory | null\n  definitions: FixDefinitions\n  description: ISessionDescription\n  delimiter?: number\n  logDelimiter?: number\n  logFactory: JsFixLoggerFactory\n  sessionContainer: DependencyContainer\n}\n\nexport class JsFixConfig implements IJsFixConfig {\n  public logDelimiter: number = AsciiChars.Pipe\n  public sessionContainer: DependencyContainer\n  constructor (\n    public readonly factory: ISessionMsgFactory | null,\n    public readonly definitions: FixDefinitions,\n    public readonly description: ISessionDescription,\n    public readonly delimiter: number = AsciiChars.Soh,\n    public readonly logFactory: JsFixLoggerFactory = new EmptyLogFactory()) {\n  }\n}\n"]}
+{"version":3,"file":"js-fix-config.js","sourceRoot":"","sources":["../../src/config/js-fix-config.ts"],"names":[],"mappings":";;;AAIA,2DAAqD;AACrD,6DAAwD;AAexD,MAAa,WAAW;IAGtB,YACkB,OAAkC,EAClC,WAA2B,EAC3B,WAAgC,EAChC,YAAoB,wBAAU,CAAC,GAAG,EAClC,aAAiC,IAAI,mCAAe,EAAE;QAJtD,YAAO,GAAP,OAAO,CAA2B;QAClC,gBAAW,GAAX,WAAW,CAAgB;QAC3B,gBAAW,GAAX,WAAW,CAAqB;QAChC,cAAS,GAAT,SAAS,CAAyB;QAClC,eAAU,GAAV,UAAU,CAA4C;QAPjE,iBAAY,GAAW,wBAAU,CAAC,IAAI,CAAA;IAQ7C,CAAC;CACF;AAVD,kCAUC","sourcesContent":["import { FixDefinitions } from '../dictionary/definition'\nimport { ISessionDescription } from '../transport/session/session-description'\nimport { ISessionMsgFactory } from '../transport/session/session-msg-factory'\nimport { JsFixLoggerFactory } from './js-fix-logger-factory'\nimport { EmptyLogFactory } from './empty-log-factory'\nimport { AsciiChars } from '../buffer/ascii/ascii-chars'\nimport { DependencyContainer } from 'tsyringe'\nimport { IFixSessionStoreFactory } from '../store/fix-session-store-factory'\n\nexport interface IJsFixConfig {\n  factory: ISessionMsgFactory | null\n  definitions: FixDefinitions\n  description: ISessionDescription\n  delimiter?: number\n  logDelimiter?: number\n  logFactory: JsFixLoggerFactory\n  sessionContainer: DependencyContainer\n  sessionStoreFactory?: IFixSessionStoreFactory\n}\n\nexport class JsFixConfig implements IJsFixConfig {\n  public logDelimiter: number = AsciiChars.Pipe\n  public sessionContainer: DependencyContainer\n  constructor (\n    public readonly factory: ISessionMsgFactory | null,\n    public readonly definitions: FixDefinitions,\n    public readonly description: ISessionDescription,\n    public readonly delimiter: number = AsciiChars.Soh,\n    public readonly logFactory: JsFixLoggerFactory = new EmptyLogFactory()) {\n  }\n}\n"]}

package/dist/dictionary/parser/quickfix/dictionary-validator.d.ts

@@ -0,0 +1,39 @@
+import { XDocument } from './x-element';
+import { ValidationError } from './validation-error';
+export declare class DictionaryValidator {
+    private readonly _errors;
+    private readonly fieldsByName;
+    private readonly fieldsByTag;
+    private readonly componentsByName;
+    private readonly messagesByName;
+    private readonly messagesByMsgType;
+    private readonly fieldNamesCaseInsensitive;
+    private readonly componentNamesCaseInsensitive;
+    private readonly referencedFields;
+    private readonly referencedComponents;
+    private readonly allFieldNames;
+    private readonly allComponentNames;
+    get errors(): ReadonlyArray<ValidationError>;
+    get hasErrors(): boolean;
+    get hasWarnings(): boolean;
+    validate(doc: XDocument): void;
+    throwIfErrors(): void;
+    private collectFieldDefinitions;
+    private validateFieldDefinition;
+    private validateFieldEnums;
+    private collectComponentDefinitions;
+    private validateComponentDefinition;
+    private collectMessageDefinitions;
+    private validateMessageDefinition;
+    private validateHeader;
+    private validateTrailer;
+    private validateComponentReferences;
+    private validateMessageReferences;
+    private validateFieldReferences;
+    private validateComponentReference;
+    private checkUnusedDefinitions;
+    private addError;
+    private addWarning;
+    static findSimilar(input: string, candidates: string[]): string | null;
+    static levenshteinDistance(s1: string, s2: string): number;
+}

package/dist/dictionary/parser/quickfix/dictionary-validator.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DictionaryValidator = void 0;
+const validation_error_1 = require("./validation-error");
+class DictionaryValidator {
+    constructor() {
+        this._errors = [];
+        this.fieldsByName = new Map();
+        this.fieldsByTag = new Map();
+        this.componentsByName = new Map();
+        this.messagesByName = new Map();
+        this.messagesByMsgType = new Map();
+        this.fieldNamesCaseInsensitive = new Map();
+        this.componentNamesCaseInsensitive = new Map();
+        this.referencedFields = new Set();
+        this.referencedComponents = new Set();
+        this.allFieldNames = [];
+        this.allComponentNames = [];
+    }
+    get errors() {
+        return this._errors;
+    }
+    get hasErrors() {
+        return this._errors.some(e => e.severity === validation_error_1.ValidationSeverity.Error);
+    }
+    get hasWarnings() {
+        return this._errors.some(e => e.severity === validation_error_1.ValidationSeverity.Warning);
+    }
+    validate(doc) {
+        this.collectFieldDefinitions(doc);
+        this.collectComponentDefinitions(doc);
+        this.collectMessageDefinitions(doc);
+        this.validateHeader(doc);
+        this.validateTrailer(doc);
+        this.validateComponentReferences(doc);
+        this.validateMessageReferences(doc);
+        this.checkUnusedDefinitions();
+    }
+    throwIfErrors() {
+        if (this.hasErrors) {
+            throw new validation_error_1.DictionaryValidationException(this._errors);
+        }
+    }
+    collectFieldDefinitions(doc) {
+        const fieldsNode = doc.firstDescendant('fields');
+        if (!fieldsNode) {
+            this.addError('MISSING_FIELDS', 'No <fields> section found in dictionary');
+            return;
+        }
+        for (const field of fieldsNode.elements('field')) {
+            this.validateFieldDefinition(field);
+        }
+    }
+    validateFieldDefinition(field) {
+        const name = field.attribute('name');
+        const numberStr = field.attribute('number');
+        const type = field.attribute('type');
+        const lineNumber = field.line;
+        if (!name) {
+            this.addError('FIELD_NO_NAME', 'Field definition missing \'name\' attribute', undefined, undefined, lineNumber);
+            return;
+        }
+        const tag = numberStr != null ? parseInt(numberStr, 10) : NaN;
+        if (!numberStr || isNaN(tag)) {
+            this.addError('FIELD_NO_TAG', `Field '${name}' missing or invalid 'number' attribute`, name, 'field', lineNumber);
+            return;
+        }
+        if (!type) {
+            this.addWarning('FIELD_NO_TYPE', `Field '${name}' missing 'type' attribute, defaulting to STRING`, name, 'field', lineNumber);
+        }
+        this.allFieldNames.push(name);
+        const existingByName = this.fieldsByName.get(name);
+        if (existingByName) {
+            this.addError('DUPLICATE_FIELD_NAME', `Duplicate field name '${name}' (tag ${tag}). Previously defined with tag ${existingByName.tag}`, name, 'field', lineNumber, existingByName.tag === tag ? 'Remove the duplicate definition' : 'Use unique field names');
+            return;
+        }
+        const existingByTag = this.fieldsByTag.get(tag);
+        if (existingByTag) {
+            this.addError('DUPLICATE_FIELD_TAG', `Duplicate field tag ${tag} for '${name}'. Tag already used by field '${existingByTag.name}'`, name, 'field', lineNumber, 'Each tag number must be unique');
+            return;
+        }
+        const info = { name, tag, type: type !== null && type !== void 0 ? type : 'STRING', lineNumber };
+        this.fieldsByName.set(name, info);
+        this.fieldsByTag.set(tag, info);
+        this.fieldNamesCaseInsensitive.set(name.toLowerCase(), name);
+        this.validateFieldEnums(field, name, lineNumber);
+    }
+    validateFieldEnums(field, fieldName, lineNumber) {
+        var _a;
+        const values = field.elements('value');
+        if (values.length === 0)
+            return;
+        const seenEnumKeys = new Set();
+        const seenEnumDescriptions = new Set();
+        for (const value of values) {
+            const enumKey = value.attribute('enum');
+            const description = value.attribute('description');
+            const valueLine = (_a = value.line) !== null && _a !== void 0 ? _a : lineNumber;
+            if (!enumKey) {
+                this.addError('ENUM_NO_KEY', `Field '${fieldName}' has enum value without 'enum' attribute`, fieldName, 'field', valueLine);
+                continue;
+            }
+            if (!description) {
+                this.addWarning('ENUM_NO_DESC', `Field '${fieldName}' enum '${enumKey}' has no description`, fieldName, 'field', valueLine);
+            }
+            if (seenEnumKeys.has(enumKey)) {
+                this.addError('DUPLICATE_ENUM_KEY', `Field '${fieldName}' has duplicate enum key '${enumKey}'`, fieldName, 'field', valueLine);
+            }
+            seenEnumKeys.add(enumKey);
+            if (description != null) {
+                const descLower = description.toLowerCase();
+                if (seenEnumDescriptions.has(descLower)) {
+                    this.addWarning('DUPLICATE_ENUM_DESC', `Field '${fieldName}' has duplicate enum description '${description}' which may cause naming conflicts`, fieldName, 'field', valueLine);
+                }
+                seenEnumDescriptions.add(descLower);
+            }
+        }
+    }
+    collectComponentDefinitions(doc) {
+        const componentsNode = doc.firstDescendant('components');
+        if (!componentsNode) {
+            return;
+        }
+        for (const component of componentsNode.elements('component')) {
+            this.validateComponentDefinition(component);
+        }
+    }
+    validateComponentDefinition(component) {
+        var _a;
+        const name = component.attribute('name');
+        const lineNumber = component.line;
+        if (!name) {
+            this.addError('COMPONENT_NO_NAME', 'Component definition missing \'name\' attribute', undefined, undefined, lineNumber);
+            return;
+        }
+        this.allComponentNames.push(name);
+        const existing = this.componentsByName.get(name);
+        if (existing) {
+            this.addError('DUPLICATE_COMPONENT', `Duplicate component name '${name}'`, name, 'component', lineNumber, `Previously defined at line ${(_a = existing.lineNumber) !== null && _a !== void 0 ? _a : '?'}`);
+            return;
+        }
+        this.componentsByName.set(name, { name, lineNumber });
+        this.componentNamesCaseInsensitive.set(name.toLowerCase(), name);
+        this.validateFieldReferences(component, name, 'component');
+    }
+    collectMessageDefinitions(doc) {
+        const messagesNode = doc.firstDescendant('messages');
+        if (!messagesNode) {
+            this.addError('MISSING_MESSAGES', 'No <messages> section found in dictionary');
+            return;
+        }
+        for (const message of messagesNode.elements('message')) {
+            this.validateMessageDefinition(message);
+        }
+    }
+    validateMessageDefinition(message) {
+        var _a;
+        const name = message.attribute('name');
+        const msgType = message.attribute('msgtype');
+        const lineNumber = message.line;
+        if (!name) {
+            this.addError('MESSAGE_NO_NAME', 'Message definition missing \'name\' attribute', undefined, undefined, lineNumber);
+            return;
+        }
+        if (!msgType) {
+            this.addError('MESSAGE_NO_MSGTYPE', `Message '${name}' missing 'msgtype' attribute`, name, 'message', lineNumber);
+            return;
+        }
+        const existingByName = this.messagesByName.get(name);
+        if (existingByName) {
+            this.addError('DUPLICATE_MESSAGE_NAME', `Duplicate message name '${name}'`, name, 'message', lineNumber, `Previously defined at line ${(_a = existingByName.lineNumber) !== null && _a !== void 0 ? _a : '?'}`);
+            return;
+        }
+        const existingByType = this.messagesByMsgType.get(msgType);
+        if (existingByType) {
+            this.addError('DUPLICATE_MESSAGE_TYPE', `Duplicate message type '${msgType}' for message '${name}'. Type already used by '${existingByType.name}'`, name, 'message', lineNumber);
+            return;
+        }
+        const info = { name, msgType, lineNumber };
+        this.messagesByName.set(name, info);
+        this.messagesByMsgType.set(msgType, info);
+        this.validateFieldReferences(message, name, 'message');
+    }
+    validateHeader(doc) {
+        const header = doc.firstDescendant('header');
+        if (!header) {
+            this.addError('MISSING_HEADER', 'No <header> section found in dictionary');
+            return;
+        }
+        this.validateFieldReferences(header, 'StandardHeader', 'header');
+    }
+    validateTrailer(doc) {
+        const trailer = doc.firstDescendant('trailer');
+        if (!trailer) {
+            this.addError('MISSING_TRAILER', 'No <trailer> section found in dictionary');
+            return;
+        }
+        this.validateFieldReferences(trailer, 'StandardTrailer', 'trailer');
+    }
+    validateComponentReferences(doc) {
+        const componentsNode = doc.firstDescendant('components');
+        if (!componentsNode)
+            return;
+        for (const component of componentsNode.elements('component')) {
+            const name = component.attribute('name');
+            if (!name)
+                continue;
+            for (const compRef of component.descendants('component')) {
+                this.validateComponentReference(compRef, name, 'component');
+            }
+        }
+    }
+    validateMessageReferences(doc) {
+        const messagesNode = doc.firstDescendant('messages');
+        if (!messagesNode)
+            return;
+        for (const message of messagesNode.elements('message')) {
+            const name = message.attribute('name');
+            if (!name)
+                continue;
+            for (const compRef of message.descendants('component')) {
+                this.validateComponentReference(compRef, name, 'message');
+            }
+        }
+    }
+    validateFieldReferences(container, containerName, containerType) {
+        var _a;
+        for (const fieldRef of container.elements('field')) {
+            const fieldName = fieldRef.attribute('name');
+            const lineNumber = fieldRef.line;
+            if (!fieldName) {
+                this.addError('FIELD_REF_NO_NAME', `Field reference in ${containerType} '${containerName}' missing 'name' attribute`, containerName, containerType, lineNumber);
+                continue;
+            }
+            this.referencedFields.add(fieldName);
+            if (!this.fieldsByName.has(fieldName)) {
+                const correctCase = this.fieldNamesCaseInsensitive.get(fieldName.toLowerCase());
+                const suggestion = correctCase !== null && correctCase !== void 0 ? correctCase : DictionaryValidator.findSimilar(fieldName, this.allFieldNames);
+                this.addError('UNDEFINED_FIELD', `Field '${fieldName}' referenced in ${containerType} '${containerName}' is not defined`, fieldName, 'field reference', lineNumber, suggestion != null ? `Did you mean '${suggestion}'?` : 'Add the field to the <fields> section');
+            }
+        }
+        for (const group of container.elements('group')) {
+            const groupName = (_a = group.attribute('name')) !== null && _a !== void 0 ? _a : 'unknown';
+            this.referencedFields.add(groupName);
+            if (groupName !== 'unknown' && !this.fieldsByName.has(groupName)) {
+                const lineNumber = group.line;
+                const suggestion = DictionaryValidator.findSimilar(groupName, this.allFieldNames);
+                this.addError('UNDEFINED_GROUP_FIELD', `Group '${groupName}' in ${containerType} '${containerName}' has no corresponding field definition (for the repeating count)`, groupName, 'group', lineNumber, suggestion != null ? `Did you mean '${suggestion}'?` : 'Add a NUMINGROUP field for this group');
+            }
+            this.validateFieldReferences(group, `${containerName}.${groupName}`, 'group');
+        }
+    }
+    validateComponentReference(compRef, containerName, containerType) {
+        const compName = compRef.attribute('name');
+        const lineNumber = compRef.line;
+        if (!compName) {
+            this.addError('COMPONENT_REF_NO_NAME', `Component reference in ${containerType} '${containerName}' missing 'name' attribute`, containerName, containerType, lineNumber);
+            return;
+        }
+        this.referencedComponents.add(compName);
+        if (!this.componentsByName.has(compName) &&
+            compName !== 'StandardHeader' && compName !== 'StandardTrailer') {
+            const suggestion = DictionaryValidator.findSimilar(compName, this.allComponentNames);
+            this.addError('UNDEFINED_COMPONENT', `Component '${compName}' referenced in ${containerType} '${containerName}' is not defined`, compName, 'component reference', lineNumber, suggestion != null ? `Did you mean '${suggestion}'?` : 'Add the component to the <components> section');
+        }
+    }
+    checkUnusedDefinitions() {
+        for (const field of this.fieldsByName.values()) {
+            if (!this.referencedFields.has(field.name)) {
+                this.addWarning('UNUSED_FIELD', `Field '${field.name}' (tag ${field.tag}) is defined but never referenced`, field.name, 'field', field.lineNumber);
+            }
+        }
+        for (const comp of this.componentsByName.values()) {
+            if (!this.referencedComponents.has(comp.name)) {
+                this.addWarning('UNUSED_COMPONENT', `Component '${comp.name}' is defined but never referenced`, comp.name, 'component', comp.lineNumber);
+            }
+        }
+    }
+    addError(code, message, elementName, elementType, lineNumber, suggestion) {
+        this._errors.push({ severity: validation_error_1.ValidationSeverity.Error, code, message, elementName, elementType, lineNumber, suggestion });
+    }
+    addWarning(code, message, elementName, elementType, lineNumber, suggestion) {
+        this._errors.push({ severity: validation_error_1.ValidationSeverity.Warning, code, message, elementName, elementType, lineNumber, suggestion });
+    }
+    static findSimilar(input, candidates) {
+        let bestMatch = null;
+        let bestDistance = Infinity;
+        const maxDistance = Math.max(3, Math.floor(input.length / 2));
+        const inputLower = input.toLowerCase();
+        for (const candidate of candidates) {
+            const distance = DictionaryValidator.levenshteinDistance(inputLower, candidate.toLowerCase());
+            if (distance < bestDistance && distance <= maxDistance) {
+                bestDistance = distance;
+                bestMatch = candidate;
+            }
+        }
+        return bestMatch;
+    }
+    static levenshteinDistance(s1, s2) {
+        const n = s1.length;
+        const m = s2.length;
+        if (n === 0)
+            return m;
+        if (m === 0)
+            return n;
+        const d = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+        for (let i = 0; i <= n; i++)
+            d[i][0] = i;
+        for (let j = 0; j <= m; j++)
+            d[0][j] = j;
+        for (let i = 1; i <= n; i++) {
+            for (let j = 1; j <= m; j++) {
+                const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+                d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+            }
+        }
+        return d[n][m];
+    }
+}
+exports.DictionaryValidator = DictionaryValidator;
+//# sourceMappingURL=dictionary-validator.js.map