fhirsmith 0.5.2 → 0.5.3

package/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to the Health Intersections Node Server will be documented i
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v0.5.2] - 2026-02-24
+
+### Added
+- Page listing logical problems in terminology definitions
+
+### Changed
+- Fixed many bugs identified by usage
+
+### Tx Conformance Statement
+
+FHIRsmith 0.5.1 passed all 1382 HL7 terminology service tests (modes tx.fhir.org,omop,general,snomed, tests v1.9.0, runner v6.8.1)
+
 ## [v0.5.1] - 2026-02-20
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fhirsmith",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "A Node.js server that provides a collection of tools to serve the FHIR ecosystem",
   "main": "server.js",
   "engines": {
@@ -116,4 +116,4 @@
     "url": "https://github.com/HealthIntersections/fhirsmith/issues"
   },
   "homepage": "https://github.com/HealthIntersections/fhirsmith#readme"
-}
+}

package/server.js

@@ -568,6 +568,19 @@ async function startServer() {
     if (modules.packages && config.modules.packages.enabled) {
       modules.packages.startInitialCrawler();
     }
+    // Run usage tracker in background after startup
+    if (modules.tx && modules.tx.library) {
+      setImmediate(async () => {
+        try {
+          serverLog.info('Starting ConceptUsageTracker scan...');
+          let count = await modules.tx.usageTracker.scanValueSets(modules.tx.library);
+          serverLog.info(`ConceptUsageTracker scan complete: ${count} valuesets list codes`);
+        } catch (err) {
+          console.log(err);
+          serverLog.error('ConceptUsageTracker scan failed:', err);
+        }
+      });
+    }
   } catch (error) {
     console.error('FATAL - Failed to start server:', error);
     serverLog.error('FATAL - Failed to start server:', error);

package/stats.js

@@ -33,10 +33,12 @@ class ServerStats {
         ? this.intervalMs / 60000
         : (now - this.startTime) / 60000;
       const requestsPerMin = minutesSinceStart > 0 ? requestsDelta / minutesSinceStart : 0;
-      const elapsedMs = (now - this.lastTime);
-      const usage = process.cpuUsage(this.lastUsage);
-      const cpuMs = (usage.user + usage.system) / 1000; // microseconds → milliseconds
-      const percent = elapsedMs > 0 ? 100 * cpuMs / elapsedMs : 0;
+
+      const currentCpu = this.readSystemCpu();
+      const idleDelta = currentCpu.idle - this.lastUsage.idle;
+      const totalDelta = currentCpu.total - this.lastUsage.total;
+      const percent = totalDelta > 0 ? 100 * (1 - idleDelta / totalDelta) : 0;
+      
       const loopDelay = this.eventLoopMonitor.mean / 1e6;
       let cacheCount = 0;
       for (let m of this.cachingModules) {
@@ -48,9 +50,9 @@ class ServerStats {
       this.eventLoopMonitor.reset();
       this.requestCountSnapshot = this.requestCount;
       this.requestTime = 0;
-      this.lastUsage = process.cpuUsage();
       this.lastTime = now;
-
+      this.lastUsage = currentCpu;
+      
       // Prune old data (keep 24 hours)
       const cutoff = now - (24 * 60 * 60 * 1000); // 24 hours ago
       this.history = this.history.filter(m => m.time > cutoff);
@@ -61,7 +63,7 @@ class ServerStats {
     this.started = true;
     this.startMem = process.memoryUsage().heapUsed;
     this.startTime = Date.now();
-    this.lastUsage = process.cpuUsage();
+    this.lastUsage = this.readSystemCpu();
     this.lastTime = this.startTime;
     this.eventLoopMonitor = monitorEventLoopDelay({ resolution: 20 });
     this.eventLoopMonitor.enable();
@@ -114,5 +116,17 @@ class ServerStats {
   finishStats() {
     clearInterval(this.timer);
   }
+
+  readSystemCpu() {
+    const os = require('os');
+    const cpus = os.cpus();
+    let idle = 0, total = 0;
+    for (const cpu of cpus) {
+      idle += cpu.times.idle;
+      total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+    }
+    return { idle, total };
+  }
+
 }
 module.exports = ServerStats;

package/tx/README.md

@@ -26,6 +26,8 @@ Add the `tx` section to your `config.json`:
       "enabled": true,
       "librarySource": "/path/to/library.yml",
       "cacheTimeout": 30,
+      "internalLimit" : 10000,
+      "externalLimit" : 1000,
       "expansionCacheSize": 1000,
       "expansionCacheMemoryThreshold": 0,
       "endpoints": [
@@ -57,14 +59,16 @@ Add the `tx` section to your `config.json`:
 
 ### Configuration Options
 
-| Option | Type | Required | Description |
-|--------|------|----------|-------------|
-| `enabled` | boolean | Yes | Whether the module is enabled |
-| `cacheTimeout` | integer | No | How many minutes to keep client side caches (for cache-id parameter). Default: 30 |
-| `expansionCacheSize` | integer | No | Maximum number of expanded ValueSets to cache. Default: 1000 |
-| `expansionCacheMemoryThreshold` | integer | No | Heap memory usage in MB that triggers evicting oldest half of expansion cache. 0 = disabled. Default: 0 |
-| `librarySource` | string | Yes | Path to the YAML file that defines the terminology sources to load |
-| `endpoints` | array | Yes | List of endpoint configurations (at least one required) |
+| Option                          | Type    | Required | Description                                                                                             |
+|---------------------------------|---------|----------|---------------------------------------------------------------------------------------------------------|
+| `enabled`                       | boolean | Yes      | Whether the module is enabled                                                                           |
+| `cacheTimeout`                  | integer | No       | How many minutes to keep client side caches (for cache-id parameter). Default: 30                       |
+| `expansionCacheSize`            | integer | No       | Maximum number of expanded ValueSets to cache. Default: 1000                                            |
+| `expansionCacheMemoryThreshold` | integer | No       | Heap memory usage in MB that triggers evicting oldest half of expansion cache. 0 = disabled. Default: 0 |
+| `librarySource`                 | string  | Yes      | Path to the YAML file that defines the terminology sources to load                                      |
+| `internalLimit`                 | integer | No       | Largest number of codes in internal expansions                                                          |
+| `externalLimit`                 | integer | No       | Largest number of codes the server will return in an expansion                                          |
+| `endpoints`                     | array   | Yes      | List of endpoint configurations (at least one required)                                                 |
 
 ### Endpoint Configuration
 

package/tx/cs/cs-api.js

@@ -30,7 +30,7 @@ class CodeSystemProvider {
    */
   supplements;
 
-  constructor(opContext, supplements) {
+  constructor(opContext, supplements = null) {
     this.opContext = opContext;
     this.supplements = supplements;
     this._ensureOpContext(opContext);
@@ -488,6 +488,39 @@ class CodeSystemProvider {
 
   // procedure getCDSInfo(card : TCDSHookCard; langList : THTTPLanguageList; baseURL, code, display : String); virtual;
 
+  /**
+   * There are two models for handling concepts and filters. The first is where the logic is entirely
+   * handled by worker classes; this is needed for value sets that select codes across systems, and
+   * with references to other value sets. This workflow consists of calling GetPrepContext, followed
+   * by some combination of filter+searchFilter, and then executeFilters
+   *
+   * followed by filterMore/filterConcept. All code system providers have to support this workflow
+   *
+   * But an important subset of value sets simply select codes from one codeSystem, from large
+   * code systems. Such processing can be done much more efficiently by the code system provider.
+   * providers that do this should return handlesSelecting() = true, and then for suitable valuesets,
+   * the method processSelection() will be called
+   */
+  handlesSelecting() {
+    return false;
+  }
+
+  /**
+   * Process a set of includes and excludes for the code system
+   *
+   * @param {TxParameters} params: information from the request that the user made, to help optimise loading
+   * @param {Object[]} includes - a list of includes from the code system. Each include may contain just the system(+version), concepts and/or filters (but won't contain value sets)
+   * @param {Object[]} excludes - a list of excludes from the code system. Each include may contain just the system(+version), concepts and/or filters (but won't contain value sets)
+   * @param {boolean} excludeInactive: whether the server will use inactive codes or not
+   * @param {int} offset if handlesOffset() and !iterate, and if the value set is a simple one that only uses this provider, then this is the applicable offset. -1 if not applicable
+   * @param {int} count if handlesOffset() and !iterate, and if the value set is a simple one that only uses this provider, then this is the applicable count. -1 if not applicable
+   * @returns {FilterConceptSet[]} filter sets. In general, it wouldn't make sense to return more than one, but providers can do if they want to. See futher comments on executeFilters
+   */
+  processSelection(params, includes, excludes, excludeInactive, offset, count) {
+    // well, you only need to override if handlesSelecting=true, but that's the only time this will be called
+    throw new Error("Must override");
+  }
+
   /**
    * returns true if a filter is supported
    *
@@ -499,14 +532,16 @@ class CodeSystemProvider {
   async doesFilter(prop, op, value) { return false; }
 
   /**
-   * gets a single context in which filters will be evaluated. The application doesn't make use of this context;
-   * it's only use is to be passed back to the CodeSystem provider so it can make use of it - if it wants
+   * gets a single context in which filters will be evaluated. The server doesn't doesn't make use of this context;
+   * it's only use is to be passed back to the CodeSystem provider so it can make use of it to organise the filter process
    *
    * @param {boolean} iterate true if the conceptSets that result from this will be iterated, and false if they'll be used to locate a single code
-   * @returns {FilterExecutionContext} filter (or null, it no use for this)
-   * */
+   * @returns {FilterExecutionContext} filter
+   *
+   **/
   async getPrepContext(iterate) { return new FilterExecutionContext(iterate); }
 
+
   /**
    * executes a text search filter (whatever that means) and returns a FilterConceptSet
    *
@@ -516,7 +551,7 @@ class CodeSystemProvider {
    * @param {String} filter user entered text search
    * @param {boolean} sort ?
    **/
-  async searchFilter(filterContext, filter, sort) { throw new Error("Must override"); } // ? must override?
+  async searchFilter(filterContext, filter, sort) { throw new Error("Text Search is not supported"); } // ? must override?
 
   /**
    * Used for searching ucum (see specialEnumeration)
@@ -532,7 +567,7 @@ class CodeSystemProvider {
   } // ? must override?
 
   /**
-   * Get a FilterConceptSet for a value set filter
+   * inform the CS provider about a filter
    *
    * throws an exception if the search filter can't be handled
    *
@@ -549,6 +584,9 @@ class CodeSystemProvider {
    * one FilterConceptSet, then the code system provider has done the join across the
    * filters, otherwise the engine will do so as required
    *
+   * The first in the set of returned FilterConceptSet is used for iterating; other
+   * FilterConceptSets are used for filterCheck();
+   *
    * @param {FilterExecutionContext} filterContext filtering context
    * @returns {FilterConceptSet[]} filter sets
    **/
@@ -679,7 +717,22 @@ class CodeSystemProvider {
     return null;
   }
 
-
+  /**
+   * a record of observed usages of codes from this code system
+   * - a map of code and object which has count, an integer count
+   * of frequency of use (this server iteration, for now)
+   *
+   * Only populated when expanding, and read-only to the CS Provider
+   *
+   * @type {Map<String, Object>}
+   */
+  usages() {
+    if (this.usagesObj == undefined) {
+      this.usagesObj = this.opContext.usageTracker ? this.opContext.usageTracker.usages(this.system()) : null;
+    }
+    return this.usagesObj;
+  }
+  usagesObj = undefined;
 }
 
 class CodeSystemFactoryProvider {
@@ -759,6 +812,32 @@ class CodeSystemFactoryProvider {
     return null;
   }
 
+  /**
+   * If the data available to the provider includes the definition of some supplements,
+   * then the provider has to declare them to the server by overriding this method. The
+   * method returns a list of CodeSystem resources, with jsonObj provided. The jsonObj
+   * in this case must include the correct metadata, with content = supplement, but need
+   * not include any actual content (which might be anticipated to be large). If the
+   * server sees a CodeSystem supplement with no content that comes from a provider
+   * then the server will use fillOutSupplement to ask for the details to be populated
+   * if a client has done something that means the server needs it (mostly, it doesn't)
+   *
+   * @returns {CodeSystem[]}
+   */
+  async registerSupplements() {
+    return [];
+  }
+
+  /**
+   * see comemnts for registerSupplements()
+   *
+   * @param {CodeSystem} supplement - the supplement to flesh out
+   * @returns void
+   */
+  async fillOutSupplement(supplement) {
+    // nothing
+  }
+
   /**
    * build and return a known concept map from the URL, if there is one.
    *

package/tx/cs/cs-areacode.js

@@ -169,15 +169,6 @@ class AreaCodeServices extends CodeSystemProvider {
     return (prop === 'type' || prop === 'class') && op === '=';
   }
 
-  async searchFilter(filterContext, filter, sort) {
-    
-    assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');
-    assert(filter && typeof filter === 'string', 'filter must be a non-null string');
-    assert(typeof sort === 'boolean', 'sort must be a boolean');
-
-    throw new Error('Search filter not implemented for AreaCode');
-  }
-
   async filter(filterContext, prop, op, value) {
     
     assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');

package/tx/cs/cs-country.js

@@ -22,7 +22,6 @@ class CountryCodeServices extends CodeSystemProvider {
     super(opContext, supplements);
     this.codes = codes || [];
     this.codeMap = codeMap || new Map();
-    this.supplements = [];
   }
 
   // Metadata methods
@@ -179,15 +178,6 @@ class CountryCodeServices extends CodeSystemProvider {
   }
 
 
-  async searchFilter(filterContext, filter, sort) {
-    
-    assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');
-    assert(filter && typeof filter === 'string', 'filter must be a non-null string');
-    assert(typeof sort === 'boolean', 'sort must be a boolean');
-
-    throw new Error('Search filter not implemented for CountryCode');
-  }
-
   async filter(filterContext, prop, op, value) {
     
     assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');

package/tx/cs/cs-cpt.js

@@ -569,12 +569,7 @@ class CPTServices extends BaseCSServices {
     return filterContext.filters.some(f => !f.closed);
   }
 
-  // Search filter - not implemented
-  // eslint-disable-next-line no-unused-vars
-  async searchFilter(filterContext, filter, sort) {
-    
-    throw new Error('Text search not implemented yet');
-  }
+
 
   // Subsumption testing - not implemented
   async subsumesTest(codeA, codeB) {

package/tx/cs/cs-cs.js

@@ -109,7 +109,6 @@ class FhirCodeSystemProvider extends BaseCSServices {
    */
   constructor(opContext, codeSystem, supplements) {
     super(opContext, supplements);
-
     if (codeSystem.content == 'supplements') {
       throw new Issue('error', 'invalid', null, 'CODESYSTEM_CS_NO_SUPPLEMENT', opContext.i18n.translate('CODESYSTEM_CS_NO_SUPPLEMENT', opContext.langs, codeSystem.vurl));
     }
@@ -1134,7 +1133,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     
 
     const results = new FhirCodeSystemProviderFilterContext();
-    const searchTerm = filter.toLowerCase();
+    const searchTerm = filter.filter.toLowerCase();
 
     // Search through all concepts
     const allConcepts = this.codeSystem.getAllConcepts();

package/tx/cs/cs-currency.js

@@ -176,15 +176,6 @@ class Iso4217Services extends CodeSystemProvider {
     return prop === 'decimals' && op === 'equals';
   }
 
-  async searchFilter(filterContext, filter, sort) {
-    
-    assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');
-    assert(filter && typeof filter === 'string', 'filter must be a non-null string');
-    assert(typeof sort === 'boolean', 'sort must be a boolean');
-
-    throw new Error('Search filter not implemented for ISO 4217');
-  }
-
   async filter(filterContext, prop, op, value) {
     
     assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');

package/tx/cs/cs-hgvs.js

@@ -200,11 +200,6 @@ class HGVSServices extends CodeSystemProvider {
     throw new Error('Filters are not supported for HGVS');
   }
 
-  async searchFilter(filterContext, filter, sort) {
-    
-    throw new Error('Filters are not supported for HGVS');
-  }
-
   async filter(filterContext, prop, op, value) {
     
     throw new Error('Filters are not supported for HGVS');

package/tx/cs/cs-lang.js

@@ -259,16 +259,6 @@ class IETFLanguageCodeProvider extends CodeSystemProvider {
     return false;
   }
 
-  async searchFilter(filterContext, filter, sort) {
-
-    assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');
-    assert(filter && typeof filter === 'string', 'filter must be a non-null string');
-    assert(typeof sort === 'boolean', 'sort must be a boolean');
-
-    throw new Error('Text search not supported');
-  }
-
-
   async filter(filterContext, prop, op, value) {
 
     assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');

package/tx/cs/cs-loinc.js

@@ -1020,13 +1020,6 @@ class LoincServices extends BaseCSServices {
     return set.hasKey(concept.key);
   }
 
-  // Search filter - placeholder for text search
-  // eslint-disable-next-line no-unused-vars
-  async searchFilter(filterContext, filter, sort) {
-
-    throw new Error('Text search not implemented yet');
-  }
-
   // Subsumption testing
   async subsumesTest(codeA, codeB) {
     await this.#ensureContext(codeA);

package/tx/cs/cs-omop.js

@@ -650,12 +650,6 @@ class OMOPServices extends BaseCSServices {
     return false; // OMOP filters are closed
   }
 
-  // Search filter - not implemented
-  // eslint-disable-next-line no-unused-vars
-  async searchFilter(filterContext, filter, sort) {
-    
-    throw new Error('Search filter not implemented yet');
-  }
 
   // Subsumption testing - not implemented
   async subsumesTest(codeA, codeB) {

package/tx/cs/cs-rxnorm.js

@@ -748,6 +748,9 @@ class RxNormTypeServicesFactory extends CodeSystemFactoryProvider {
             if (d.includes('_')) {
               d = d.substring(d.lastIndexOf('_') + 1);
             }
+            if (d.includes('-')) {
+              d = d.substring(0, d.lastIndexOf('-'));
+            }
             if (/^\d+$/.test(d)) {
               version = d;
             }

package/tx/cs/cs-snomed.js

@@ -1166,7 +1166,12 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
 
     if (id.startsWith('?fhir_vs=refset/')) {
       const refsetId = id.substring(16);
-      if (!this.referenceSetExists(refsetId)) {
+      let ref = this.snomedServices.concepts.findConcept(refsetId);
+      if (!ref.found) {
+        return null;
+      }
+      let rref = this.snomedServices.refSetIndex.getRefSetByConcept(ref.index);
+      if (rref == 0) {
         return null;
       }
       return {
@@ -1176,7 +1181,7 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
         version: this.versionDate,
         name: 'SNOMEDCTRefSet' + refsetId,
         title: 'SNOMED CT Reference Set ' + refsetId,
-        description: this.getDisplayName(refsetId, ''),
+        description: this.snomedServices.getDisplayName(ref.index),
         date: now,
         compose: {
           include: [{
@@ -1193,7 +1198,8 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
 
     if (id.startsWith('?fhir_vs=isa/')) {
       const conceptId = id.substring(13);
-      if (!this.conceptExists(conceptId)) {
+      let ref = this.snomedServices.concepts.findConcept(conceptId);
+      if (!ref.found) {
         return null;
       }
       return {
@@ -1203,7 +1209,7 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
         version: this.versionDate,
         name: 'SNOMEDCTConcept' + conceptId,
         title: 'SNOMED CT Concept ' + conceptId + ' and descendants',
-        description: 'All Snomed CT concepts for ' + this.getDisplayName(conceptId, ''),
+        description: 'All Snomed CT concepts for ' + this.snomedServices.getDisplayName(ref.index),
         date: now,
         compose: {
           include: [{

package/tx/cs/cs-ucum.js

@@ -245,15 +245,6 @@ class UcumCodeSystemProvider extends BaseCSServices {
     return (prop === 'canonical' && op === '=');
   }
 
-  async searchFilter(filterContext, filter, sort) {
-    
-    assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');
-    assert(filter && typeof filter === 'string', 'filter must be a non-null string');
-    assert(typeof sort === 'boolean', 'sort must be a boolean');
-
-    throw new Error('Search filter not implemented for UCUM');
-  }
-
   async specialFilter(filterContext, filter, sort) {
     
     assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');

package/tx/html/tx-template.html

@@ -89,6 +89,7 @@
             <a href="[%endpoint-path%]/metadata" style="color: gold">Capability Statement</a>  &nbsp;|&nbsp;
             <a href="[%endpoint-path%]/metadata?mode=terminology" style="color: gold">Terminology Capabilities</a>  &nbsp;|&nbsp;
             <a href="[%endpoint-path%]/op.html" style="color: gold">Operations</a>  &nbsp;|&nbsp;
+            <a href="[%endpoint-path%]/problems.html" style="color: gold">Problems</a>  &nbsp;|&nbsp;
   &nbsp;
 		</div>
 		</div>

package/tx/library/designations.js

@@ -608,7 +608,11 @@ class Designations {
         }
       }
     }
-
+    for (const cd of this.designations) {
+      if (!cd.language && this.isDisplay(cd)) {
+        return cd;
+      }
+    }
     return null;
   }
 

package/tx/library/renderer.js

@@ -2,6 +2,7 @@ const {CodeSystemProvider} = require("../cs/cs-api");
 const {Extensions} = require("./extensions");
 const {div} = require("../../library/html");
 const {getValuePrimitive} = require("../../library/utilities");
+const {getValueName} = require("../../library/utilities");
 
 /**
  * @typedef {Object} TerminologyLinkResolver
@@ -904,7 +905,11 @@ class Renderer {
     this.renderProperty(tbl, 'Expansion Total', vs.expansion.total);
     this.renderProperty(tbl, 'Expansion Offset', vs.expansion.offset);
     for (let p of vs.expansion.parameter || []) {
-      await this.renderPropertyLink(tbl, "Parameter: " + p.name, getValuePrimitive(p));
+      if( getValueName(p) === 'valueUri' || getValueName(p) === 'valueCanonical') {
+        await this.renderPropertyLink(tbl, "Parameter: " + p.name, getValuePrimitive(p));
+      } else {
+        this.renderProperty(tbl, "Parameter: " + p.name, getValuePrimitive(p));
+      }
     }
 
     if (!vs.expansion.contains || vs.expansion.contains.length === 0) {

package/tx/library.js

@@ -758,6 +758,7 @@ class Library {
       cmp.close();
     }
   }
+
 }
 
 module.exports = { Library };

package/tx/operation-context.js

@@ -447,6 +447,7 @@ class OperationContext {
     newContext.timeTracker = this.timeTracker.link();
     newContext.logEntries = [...this.logEntries];
     newContext.debugging = this.debugging;
+    newContext.usageTracker = this.usageTracker;
     return newContext;
   }
 

package/tx/params.js

@@ -36,6 +36,7 @@ class TxParameters {
   validating = false;
   abstractOk = true; // note true!
   inferSystem = false;
+  sort = 'design';
 
   constructor(languages, i18n, validating) {
     validateParameter(languages, 'languages', LanguageDefinitions);
@@ -242,6 +243,10 @@ class TxParameters {
           if (getValuePrimitive(p) == true) this.inferSystem = true;
           break;
         }
+        case 'sort': {
+          this.sort = getValuePrimitive(p);
+          break;
+        }
         case "exclude-system": {
           throw new Issue('error', 'not-supported', null, null, "The parameter 'exclude-system' is not supported by this system", null, 400);
         }
@@ -524,7 +529,7 @@ class TxParameters {
       this.FUid + '|' + b(this.FMembershipOnly) + '|' + this.FProperties.join(',') + '|' +
       b(this.FActiveOnly) + b(this.FDisplayWarning) + b(this.FExcludeNested) + b(this.FGenerateNarrative) + b(this.FExcludeNotForUI) + b(this.FExcludePostCoordinated) +
       b(this.FIncludeDesignations) + b(this.FIncludeDefinition) + b(this.hasActiveOnly) + b(this.hasExcludeNested) + b(this.hasGenerateNarrative) +
-      b(this.hasExcludeNotForUI) + b(this.hasExcludePostCoordinated) + b(this.hasIncludeDesignations) +
+      b(this.hasExcludeNotForUI) + b(this.hasExcludePostCoordinated) + b(this.hasIncludeDesignations) + this.sort+'|'+
       b(this.hasIncludeDefinition) + b(this.hasDefaultToLatestVersion) + b(this.hasDisplayWarning) + b(this.hasExcludeNotForUI) + b(this.hasMembershipOnly) + b(this.FDefaultToLatestVersion);
 
     if (this.hasHTTPLanguages) {
@@ -585,6 +590,7 @@ class TxParameters {
     this.hasDefaultToLatestVersion = other.hasDefaultToLatestVersion;
     this.hasMembershipOnly = other.hasMembershipOnly;
     this.hasDisplayWarning = other.hasDisplayWarning;
+    this.sort = other.sort;
 
     if (other.FProperties) {
       this.FProperties = [...other.FProperties];