fhirsmith 0.10.0 → 0.11.0

package/registry/model.js

@@ -86,6 +86,8 @@ class ServerInformation {
     this.authCSList = []; // Authoritative code systems (with wildcards)
     this.authVSList = []; // Authoritative value sets (with wildcards)
     this.usageList = []; // Usage tags
+    this.languages = {}; // Language specific authoritative claims: BCP-47 tag -> list of CS masks
+    this.exclusions = []; // CodeSystem/ValueSet masks hidden from the ecosystem entirely
     this.versions = []; // Array of ServerVersionInformation
   }
 
@@ -100,6 +102,11 @@ class ServerInformation {
     this.authCSList = [...source.authCSList];
     this.authVSList = [...source.authVSList];
     this.usageList = [...source.usageList];
+    this.languages = {};
+    Object.keys(source.languages || {}).forEach(tag => {
+      this.languages[tag] = [...source.languages[tag]];
+    });
+    this.exclusions = [...(source.exclusions || [])];
     
     source.versions.forEach(sourceVersion => {
       const existing = this.getVersion(sourceVersion.version);
@@ -116,11 +123,80 @@ class ServerInformation {
   }
 
   isAuthCS(codeSystem) {
-    return this.authCSList.some(mask => this._passesMask(mask, codeSystem));
+    return !this.isExcludedTarget(codeSystem) &&
+      this.authCSList.some(mask => this._passesMask(mask, codeSystem));
   }
 
   isAuthVS(valueSet) {
-    return this.authVSList.some(mask => this._passesMask(mask, valueSet));
+    return !this.isExcludedTarget(valueSet) &&
+      this.authVSList.some(mask => this._passesMask(mask, valueSet));
+  }
+
+  /**
+   * True if the code system / value set is hidden from the ecosystem for this server
+   * (matches an entry in exclusions). Excluded content is hidden entirely: the server
+   * is never offered for it, neither as authoritative nor as a candidate, even if an
+   * authoritative mask (or language specific claim) would otherwise match it.
+   * Masks are tested against both the full canonical (url|version) and the base url.
+   */
+  isExcludedTarget(value) {
+    return (this.exclusions || []).some(mask => this._passesMaskEx(mask, value, true));
+  }
+
+  /**
+   * Match this server's authoritative claims for a code system, taking language specific
+   * claims (the languages property: BCP-47 tag -> mask list) into account.
+   *
+   * Language specific claims are only visible when the request specifies a language. A
+   * claimed tag is inherently a mask: it covers a request language that is equal to it or
+   * more specific ('de' covers 'de' and 'de-AT'; 'de-AT' does not cover plain 'de'). The
+   * best match is on the earliest (heaviest) request language, then the most specific
+   * claimed tag. Claims in the authoritative list apply irrespective of language, but rank
+   * after all language specific matches (score = MAX_SAFE_INTEGER).
+   *
+   * @param {string} codeSystem - canonical url or url|version
+   * @param {Array|null} requestLangs - parsed Accept-Language list ([{tag, q}] in descending
+   *   weight order, per ServerRegistryUtilities.parseAcceptLanguage), or null for no language
+   * @param {boolean} maskBase - also test masks against the base URL (before '|'), matching
+   *   the semantics of hasMatchingCodeSystem as used for the discovery rows
+   * @returns {Object} {isAuth: boolean, scoped: boolean, tag?: string, score: number}
+   *   score: lower is better - earlier request languages and more specific tags win
+   */
+  matchAuthCS(codeSystem, requestLangs = null, maskBase = false) {
+    // excluded content is hidden entirely - no claim of any kind can match it
+    if (this.isExcludedTarget(codeSystem)) {
+      return { isAuth: false, scoped: false, score: Number.MAX_SAFE_INTEGER };
+    }
+
+    const masksMatch = (masks) => masks.some(mask => this._passesMaskEx(mask, codeSystem, maskBase));
+
+    if (requestLangs && requestLangs.length > 0 && this.languages) {
+      let best = null;
+      for (let i = 0; i < requestLangs.length; i++) {
+        for (const tag of Object.keys(this.languages)) {
+          if (!ServerRegistryUtilities.languageTagCovers(tag, requestLangs[i].tag)) continue;
+          if (!masksMatch(this.languages[tag] || [])) continue;
+          // earlier request language (higher weight) dominates; then longer (more specific) tag
+          const score = i * 1000 + (256 - tag.length);
+          if (!best || score < best.score) {
+            best = { isAuth: true, scoped: true, tag, score };
+          }
+        }
+        if (best) return best; // don't consider later (lighter) request languages
+      }
+    }
+    if (masksMatch(this.authCSList)) {
+      return { isAuth: true, scoped: false, score: Number.MAX_SAFE_INTEGER };
+    }
+    return { isAuth: false, scoped: false, score: Number.MAX_SAFE_INTEGER };
+  }
+
+  _passesMaskEx(mask, value, includeBase) {
+    if (this._passesMask(mask, value)) return true;
+    if (includeBase && value.includes('|')) {
+      return this._passesMask(mask, value.substring(0, value.indexOf('|')));
+    }
+    return false;
   }
 
   _passesMask(mask, value) {
@@ -132,11 +208,34 @@ class ServerInformation {
 
   getDescription() {
     let result = '';
-    
+
     if (this.usageList.length > 0) {
       result = `Usage Tags: ${this.usageList.join(', ')}`;
     }
-    
+
+    const langTags = Object.keys(this.languages || {});
+    if (langTags.length > 0) {
+      if (result) result += '. ';
+      result += 'Authoritative for particular languages: <ul>';
+      langTags.forEach(tag => {
+        (this.languages[tag] || []).forEach(mask => {
+          const escaped = escape(mask).replace(/\*/g, '<b>*</b>');
+          result += `<li>${escape(tag)}: ${escaped}</li>`;
+        });
+      });
+      result += '</ul>';
+    }
+
+    if (this.exclusions && this.exclusions.length > 0) {
+      if (result) result += '. ';
+      result += 'Excluded (hidden from the ecosystem): <ul>';
+      this.exclusions.forEach(mask => {
+        const escaped = escape(mask).replace(/\*/g, '<b>*</b>');
+        result += `<li>${escaped}</li>`;
+      });
+      result += '</ul>';
+    }
+
     if (this.authCSList.length > 0) {
       if (result) result += '. ';
       result += 'Authoritative for the following CodeSystems: <ul>';
@@ -169,6 +268,8 @@ class ServerInformation {
       authoritative: this.authCSList.join(','),
       'authoritative-valuesets': this.authVSList.join(','),
       usageList: this.usageList,
+      languages: this.languages,
+      exclusions: this.exclusions.join(','),
       versions: this.versions.map(v => v.toJSON())
     };
   }
@@ -179,13 +280,20 @@ class ServerInformation {
     instance.name = json.name || '';
     instance.address = json.address || '';
     instance.accessInfo = json['access-info'] || '';
-    instance.authCSList = json.authoritative 
+    instance.authCSList = json.authoritative
       ? json.authoritative.split(',').filter(s => s)
       : [];
-    instance.authVSList = json['authoritative-valuesets'] 
+    instance.authVSList = json['authoritative-valuesets']
       ? json['authoritative-valuesets'].split(',').filter(s => s)
       : [];
     instance.usageList = json.usageList || [];
+    // languages is an object (tag -> mask list); tolerate legacy/absent data
+    instance.languages = (json.languages && typeof json.languages === 'object' && !Array.isArray(json.languages))
+      ? json.languages
+      : {};
+    instance.exclusions = json.exclusions
+      ? json.exclusions.split(',').filter(s => s)
+      : [];
     instance.versions = (json.versions || []).map(v => ServerVersionInformation.fromJSON(v));
     return instance;
   }
@@ -327,6 +435,7 @@ class ServerRow {
     this.systems = 0; // count of code systems
     this.sets = 0; // count of value sets
     this.authoritative = false;
+    this.languages = []; // language tag(s) of the language specific claim matched (empty = none)
   }
 
   toJSON() {
@@ -357,7 +466,10 @@ class ServerRow {
       json['authoritative-valuesets'] = this.authVSList;
     }
 
-    
+    if (this.languages.length > 0) {
+      json.languages = this.languages;
+    }
+
     return json;
   }
 
@@ -378,12 +490,13 @@ class ServerRow {
     instance.authCSList = json.authoritative || [];
     instance.authVSList = json['authoritative-valuesets'] || [];
     instance.security = json['security'] || '';
+    instance.languages = json.languages || [];
 
     return instance;
   }
 }
 
-// Utility functions (similar to TServerRegistryUtilities)
+// Utility functions for registry matching and row building
 class ServerRegistryUtilities {
   static passesMask(mask, value) {
     if (mask.endsWith('*')) {
@@ -392,6 +505,43 @@ class ServerRegistryUtilities {
     return value === mask;
   }
 
+  /**
+   * Parse an Accept-Language style value ('de', 'de-AT, de;q=0.9, en;q=0.1') into
+   * an ordered list of {tag, q}, highest weight first. Wildcards ('*') and zero-weight
+   * entries are dropped - they don't constrain routing. Returns null when nothing usable.
+   */
+  static parseAcceptLanguage(value) {
+    if (!value || typeof value !== 'string') return null;
+    const items = [];
+    for (const part of value.split(',')) {
+      const pieces = part.trim().split(';').map(p => p.trim());
+      const tag = pieces[0];
+      if (!tag || tag === '*') continue;
+      let q = 1.0;
+      for (let i = 1; i < pieces.length; i++) {
+        const m = /^q\s*=\s*([0-9.]+)$/i.exec(pieces[i]);
+        if (m) q = parseFloat(m[1]);
+      }
+      if (!(q > 0)) continue;
+      items.push({ tag, q });
+    }
+    if (items.length === 0) return null;
+    items.sort((a, b) => b.q - a.q); // stable: preserves order among equal weights
+    return items;
+  }
+
+  /**
+   * BCP-47 tags are hierarchical, so a tag is inherently a mask: a scoped tag covers a
+   * request language that is equal to it, or more specific (on '-' boundaries).
+   * languageTagCovers('de', 'de-AT') = true; ('de', 'dent') = false; ('de-AT', 'de') = false.
+   */
+  static languageTagCovers(scopedTag, requestTag) {
+    if (!scopedTag || !requestTag) return false;
+    const s = scopedTag.toLowerCase();
+    const r = requestTag.toLowerCase();
+    return r === s || r.startsWith(s + '-');
+  }
+
   static hasMatchingCodeSystem(cs, list, supportMask, content, noVersionIndependentMatching = false) {
     if (!cs || list.length === 0) return false;
 

package/registry/readme.md

@@ -178,6 +178,10 @@ Servers can be marked as authoritative for specific code systems or value sets.
 - Authoritative servers are always ranked first
 - Wildcards are supported (e.g., `http://loinc.org*`)
 - Non-authoritative servers are still returned but ranked lower
+- Language specific claims (`languages`: BCP-47 tag -> mask list) make a server authoritative for
+  requests in that language only; matched entries rank ahead of language independent claims
+- `exclusions` hides matching code systems/value sets from the ecosystem entirely (never
+  authoritative, never a candidate)
 
 ## Testing
 
@@ -205,18 +209,6 @@ Start development server with auto-reload:
 npm run dev
 ```
 
-## Migration from Pascal
-
-This module is a JavaScript port of a Pascal implementation. Key differences:
-
-| Pascal | JavaScript |
-|--------|------------|
-| TStringList | Array |
-| TFslList<T> | Array |
-| set of TServerSecurity | Set |
-| TFslDateTime | Date |
-| class methods | static methods |
-
 ## Security Models
 
 The crawler detects the following security models:
@@ -230,4 +222,4 @@ The crawler detects the following security models:
 
 ## License
 
-BSD-3-Clause (matching the original Pascal implementation)
+BSD-3-Clause

package/registry/registry.js

@@ -116,13 +116,13 @@ class RegistryModule {
 
     // Run initial crawl after a short delay
     setTimeout(() => {
-      this.performCrawl();
+      this.performCrawl().catch((err) => this.logger.error('Registry crawl failed: ' + err.message));
     }, 5000);
 
     // Set up periodic crawling
     this.stats.addTask("TxRegistry", `${intervalMinutes} min`);
     this.crawlInterval = setInterval(() => {
-      this.performCrawl();
+      this.performCrawl().catch((err) => this.logger.error('Registry crawl failed: ' + err.message));
     }, intervalMs);
 
     this.logger.info(`Started periodic crawl every ${intervalMinutes} minutes`);
@@ -299,7 +299,7 @@ class RegistryModule {
 
   /**
    * Get status text about crawling
-   * Based on Pascal status function
+   * Describes the crawl schedule state
    */
   getStatusText() {
     if (this.crawlInProgress) {
@@ -331,7 +331,7 @@ class RegistryModule {
 
   /**
    * Format a time period in milliseconds to a human-readable string
-   * Based on Pascal DescribePeriod function
+  
    */
   describePeriod(milliseconds) {
     const seconds = Math.floor(milliseconds / 1000);
@@ -552,35 +552,43 @@ class RegistryModule {
 
     if (!data || !data.registries) return [];
 
-    // Gather all authoritative code systems
-    data.registries.forEach(registry => {
-      registry.servers.forEach(server => {
-        server.authCSList.forEach(csMask => {
-          // Create or update entry for this code system mask
-          if (!authCSMap.has(csMask)) {
-            authCSMap.set(csMask, {
-              mask: csMask,
-              servers: new Map()
-            });
-          }
+    // Gather all authoritative code systems - both the language independent claims
+    // (authoritative) and the language specific claims (languages: tag -> mask list)
+    const addClaim = (server, csMask, languageTag) => {
+      if (!authCSMap.has(csMask)) {
+        authCSMap.set(csMask, {
+          mask: csMask,
+          servers: new Map()
+        });
+      }
 
-          // Add server info
-          const csEntry = authCSMap.get(csMask);
-          if (!csEntry.servers.has(server.name)) {
-            csEntry.servers.set(server.name, {
-              name: server.name,
-              url: server.address,
-              versions: new Set()
-            });
-          }
+      // Key by server code + language tag, so a server's language independent and
+      // language specific claims for the same mask show as separate rows
+      const csEntry = authCSMap.get(csMask);
+      const key = `${server.code}|${languageTag || ''}`;
+      if (!csEntry.servers.has(key)) {
+        csEntry.servers.set(key, {
+          name: server.name,
+          url: server.address,
+          languages: languageTag ? [languageTag] : [],
+          versions: new Set()
+        });
+      }
 
-          // Add version info for this server
-          const serverEntry = csEntry.servers.get(server.name);
-          server.versions.forEach(version => {
-            if (!version.error) {
-              serverEntry.versions.add(version.version);
-            }
-          });
+      // Add version info for this server
+      const serverEntry = csEntry.servers.get(key);
+      server.versions.forEach(version => {
+        if (!version.error) {
+          serverEntry.versions.add(version.version);
+        }
+      });
+    };
+
+    data.registries.forEach(registry => {
+      registry.servers.forEach(server => {
+        server.authCSList.forEach(csMask => addClaim(server, csMask, null));
+        Object.keys(server.languages || {}).forEach(tag => {
+          (server.languages[tag] || []).forEach(csMask => addClaim(server, csMask, tag));
         });
       });
     });
@@ -626,18 +634,19 @@ class RegistryModule {
             });
           }
 
-          // Add server info
+          // Add server info (value set claims have no language dimension at this time)
           const vsEntry = authVSMap.get(vsMask);
-          if (!vsEntry.servers.has(server.name)) {
-            vsEntry.servers.set(server.name, {
+          if (!vsEntry.servers.has(server.code)) {
+            vsEntry.servers.set(server.code, {
               name: server.name,
               url: server.address,
+              languages: [],
               versions: new Set()
             });
           }
 
           // Add version info for this server
-          const serverEntry = vsEntry.servers.get(server.name);
+          const serverEntry = vsEntry.servers.get(server.code);
           server.versions.forEach(version => {
             if (!version.error) {
               serverEntry.versions.add(version.version);
@@ -788,6 +797,19 @@ class RegistryModule {
     return text.replace(/\*/g, '<strong class="text-primary">*</strong>');
   }
 
+  /**
+   * Render the language tag(s) of a language specific claim (empty string when the
+   * claim is language independent)
+   * @param {Object} serverEntry - entry with a languages array
+   * @returns {string} HTML fragment
+   */
+  _renderLanguageScope(serverEntry) {
+    if (!serverEntry.languages || serverEntry.languages.length === 0) {
+      return '';
+    }
+    return ` <span class="badge badge-info" title="This claim applies to requests in these languages only">${escape(serverEntry.languages.join(', '))}</span>`;
+  }
+
   /**
    * Render HTML table for authoritative code systems
    * @returns {string} HTML string
@@ -821,7 +843,7 @@ class RegistryModule {
       const rowspan = cs.servers.length;
       html += '<tr>';
       html += `<td rowspan="${rowspan}">${this._highlightWildcard(escape(formattedMask))}</td>`;
-      html += `<td><a href="${escape(cs.servers[0].url)}" target="_blank">${escape(cs.servers[0].url)}</a></td>`;
+      html += `<td><a href="${escape(cs.servers[0].url)}" target="_blank">${escape(cs.servers[0].url)}</a>${this._renderLanguageScope(cs.servers[0])}</td>`;
 
       // Format versions as R3/R4/R5
       const formattedVersions = cs.servers[0].versions.map(v => this._formatFhirVersion(v));
@@ -831,7 +853,7 @@ class RegistryModule {
       // Additional rows for this code system (if any)
       for (let i = 1; i < cs.servers.length; i++) {
         html += '<tr>';
-        html += `<td><a href="${escape(cs.servers[i].url)}" target="_blank">${escape(cs.servers[i].url)}</a></td>`;
+        html += `<td><a href="${escape(cs.servers[i].url)}" target="_blank">${escape(cs.servers[i].url)}</a>${this._renderLanguageScope(cs.servers[i])}</td>`;
 
         // Format versions as R3/R4/R5
         const formattedVersions = cs.servers[i].versions.map(v => this._formatFhirVersion(v));
@@ -877,7 +899,7 @@ class RegistryModule {
       const rowspan = vs.servers.length;
       html += '<tr>';
       html += `<td rowspan="${rowspan}">${this._highlightWildcard(escape(vs.mask))}</td>`;
-      html += `<td><a href="${escape(vs.servers[0].url)}" target="_blank">${escape(vs.servers[0].url)}</a></td>`;
+      html += `<td><a href="${escape(vs.servers[0].url)}" target="_blank">${escape(vs.servers[0].url)}</a>${this._renderLanguageScope(vs.servers[0])}</td>`;
 
       // Format versions as R3/R4/R5
       const formattedVersions = vs.servers[0].versions.map(v => this._formatFhirVersion(v));
@@ -887,7 +909,7 @@ class RegistryModule {
       // Additional rows for this value set (if any)
       for (let i = 1; i < vs.servers.length; i++) {
         html += '<tr>';
-        html += `<td><a href="${escape(vs.servers[i].url)}" target="_blank">${escape(vs.servers[i].url)}</a></td>`;
+        html += `<td><a href="${escape(vs.servers[i].url)}" target="_blank">${escape(vs.servers[i].url)}</a>${this._renderLanguageScope(vs.servers[i])}</td>`;
 
         // Format versions as R3/R4/R5
         const formattedVersions = vs.servers[i].versions.map(v => this._formatFhirVersion(v));
@@ -976,7 +998,7 @@ class RegistryModule {
 
       try {
         const params = this._normalizeQueryParams(req.query);
-        const {fhirVersion, valueSet, usage, version} = params;
+        const {fhirVersion, valueSet, usage, version, language} = params;
         let {url} = params;
 
         // If a version was supplied separately, fold it into the code system
@@ -1050,16 +1072,16 @@ class RegistryModule {
 
         if (valueSet) {
           // Value set resolve
-          const resolveResult = this.api.resolveValueSet(fhirVersion, valueSet, authoritativeOnly, usage);
+          const resolveResult = this.api.resolveValueSet(fhirVersion, valueSet, authoritativeOnly, usage, language);
           result = resolveResult.result;
           matches = resolveResult.matches;
-          this.logger.info(`Resolved ValueSet ${valueSet} for FHIR ${fhirVersion} (usage=${usage}): ${matches}`);
+          this.logger.info(`Resolved ValueSet ${valueSet} for FHIR ${fhirVersion} (usage=${usage}, language=${language || 'none'}): ${matches}`);
         } else {
           // Code system resolve
-          const resolveResult = this.api.resolveCodeSystem(fhirVersion, url, authoritativeOnly, usage);
+          const resolveResult = this.api.resolveCodeSystem(fhirVersion, url, authoritativeOnly, usage, language);
           result = resolveResult.result;
           matches = resolveResult.matches;
-          this.logger.info(`Resolved CodeSystem ${url} for FHIR ${fhirVersion} (usage=${usage}): ${matches}`);
+          this.logger.info(`Resolved CodeSystem ${url} for FHIR ${fhirVersion} (usage=${usage}, language=${language || 'none'}): ${matches}`);
         }
 
         // If only authoritative servers are requested, filter results
@@ -1076,7 +1098,7 @@ class RegistryModule {
               htmlServer.loadTemplate('registry', templatePath);
             }
 
-            const content = this.buildResolveResultContent(result, fhirVersion, url || valueSet, usage);
+            const content = this.buildResolveResultContent(result, fhirVersion, url || valueSet, usage, language);
             const stats = this.api.getStatistics();
             stats.processingTime = Date.now() - startTime;
 
@@ -1104,7 +1126,7 @@ class RegistryModule {
     }
   }
 
-  buildResolveResultContent(result, fhirVersion, resourceUrl, usage) {
+  buildResolveResultContent(result, fhirVersion, resourceUrl, usage, language) {
     let html = '';
 
     // Query information section
@@ -1119,6 +1141,9 @@ class RegistryModule {
     if (usage) {
       html += `<p><strong>Usage:</strong> ${escape(usage)}</p>`;
     }
+    if (language) {
+      html += `<p><strong>Language:</strong> ${escape(language)}</p>`;
+    }
     html += '</div>';
     html += '</div>';
 
@@ -1136,6 +1161,7 @@ class RegistryModule {
       html += '<th>Server Name</th>';
       html += '<th>URL</th>';
       html += '<th>Security</th>';
+      html += '<th>Languages</th>';
       html += '<th>Access Info</th>';
       html += '</tr>';
       html += '</thead>';
@@ -1146,6 +1172,7 @@ class RegistryModule {
         html += `<td>${escape(server['server-name'])}</td>`;
         html += `<td><a href="${server.url}" target="_blank">${escape(server.url)}</a></td>`;
         html += `<td>${this.renderSecurityTags(server)}</td>`;
+        html += `<td>${server.languages ? escape(server.languages.join(', ')) : ''}</td>`;
         html += `<td>${server.access_info ? escape(server.access_info) : ''}</td>`;
         html += '</tr>';
       });
@@ -1173,6 +1200,7 @@ class RegistryModule {
       html += '<th>Server Name</th>';
       html += '<th>URL</th>';
       html += '<th>Security</th>';
+      html += '<th>Languages</th>';
       html += '<th>Access Info</th>';
       html += '<th>Content</th>';
       html += '</tr>';
@@ -1184,6 +1212,11 @@ class RegistryModule {
         html += `<td>${escape(server['server-name'])}</td>`;
         html += `<td><a href="${server.url}" target="_blank">${escape(server.url)}</a></td>`;
         html += `<td>${this.renderSecurityTags(server)}</td>`;
+        if (server['language-support'] === 'unknown') {
+          html += '<td><span class="text-muted" title="This server hosts the code system, but the ecosystem does not know whether it can supply the requested language">unknown</span></td>';
+        } else {
+          html += `<td>${server.languages ? escape(server.languages.join(', ')) : ''}</td>`;
+        }
         html += `<td>${server.access_info ? escape(server.access_info) : ''}</td>`;
         html += `<td>${server.content ? escape(server.content) : ''}</td>`;
         html += '</tr>';
@@ -1229,6 +1262,7 @@ class RegistryModule {
     const url = queryParams.url || '';
     const version = queryParams.version || '';
     const valueSet = queryParams.valueSet || '';
+    const language = queryParams.language || '';
     const authoritativeOnly = queryParams.authoritativeOnly === 'true';
 
     let html = '';
@@ -1271,6 +1305,13 @@ class RegistryModule {
     html += '</p>';
     html += '<p class="text-muted small">Example: http://hl7.org/fhir/ValueSet/observation-codes</p>';
 
+    // Language field (optional)
+    html += '<p>';
+    html += '<label for="language" class="form-label fw-bold">Language</label>';
+    html += `<input type="text" class="form-control" id="language" name="language"
+           value="${escape(language)}">`;
+    html += '</p>';
+    html += '<p class="text-muted small">Optional. The language of the request being routed, in Accept-Language syntax. Examples: de or de-AT, de;q=0.9, en;q=0.1</p>';
 
     // Authoritative Only checkbox
     html += '<p>';

package/registry/test-runner.js

@@ -187,7 +187,7 @@ function runTests() {
   if (rows2.length > 0) {
     console.log(`  Versions: ${rows2.map(r => `${r.version} (auth=${r.authoritative})`).join(', ')}`);
   }
-  console.log(`  Test ${rows2.length === 1 && rows2[0].version === '4.0.1' ? '✓ PASSED (strict)' : rows2.length === 2 ? '✓ PASSED (Pascal-style)' : '✗ FAILED'}\n`);
+  console.log(`  Test ${rows2.length === 1 && rows2[0].version === '4.0.1' ? '✓ PASSED (strict)' : rows2.length === 2 ? '✓ PASSED (lenient)' : '✗ FAILED'}\n`);
   
   // Test 3: should rank servers without errors higher
   console.log('Test 3: should not include servers with errors even if authoritative');

package/server.js

@@ -68,6 +68,10 @@ htmlServer.setSponsorMessage(config.sponsorMessage ? config.sponsorMessage : '')
 
 const app = express();
 
+// Behind nginx (or any reverse proxy): honor X-Forwarded-* so req.protocol and
+// req.hostname reflect what the client actually requested, not the loopback hop.
+app.set('trust proxy', config.server.trustProxy ?? true);
+
 const PORT = process.env.PORT || config.server.port || 3000;
 
 // Middleware
@@ -860,4 +864,7 @@ async function serveFhirsmithHome(req, res) {
 }
 
 // Start the server
-startServer();
+startServer().catch((err) => {
+  serverLog.error('Fatal error during startup:', err);
+  process.exit(1);
+});

package/token/token.js

@@ -528,7 +528,7 @@ class TokenModule {
           }
 
           if (userId) {
-            this.logSecurityEvent(userId, 'logout', req.ip, req.get('User-Agent'), {});
+            void this.logSecurityEvent(userId, 'logout', req.ip, req.get('User-Agent'), {}); // fire-and-forget audit; errors handled internally
           }
 
           res.redirect('/token/login');

package/translations/Messages.properties

@@ -158,6 +158,7 @@ CODESYSTEM_SHAREABLE_MISSING_HL7 = Code systems published by HL7 SHALL conform t
 CODESYSTEM_SUPP_NO_DISPLAY = This display (''{0}'') differs from that defined by the base code system (''{1}''). Both displays claim to be the ''primary designation'' for the same language (''{2}''), and the correct interpretation of this is undefined
 CODESYSTEM_THO_CHECK = Most code systems defined in HL7 IGs will need to move to THO later during the process. Consider giving this code system a THO URL now (See https://confluence.hl7.org/display/TSMG/Terminology+Play+Book, and/or talk to TSMG)
 CODESYSTEM_TOO_COSTLY_TIME = The operation ''{1}'' took too long to process (>{0}sec) (at {2})
+CODESYSTEM_NOT_ENUMERABLE = The code system ''{0}'' cannot be expanded because its codes cannot be iterated or enumerated in any meaningful sense
 Coding_has_no_system__cannot_validate = Coding has no system. A code with no system has no defined meaning, and it cannot be validated. A system should be provided
 CONCEPTMAP_GROUP_SOURCE_CODE_INVALID = The source code ''{0}'' is not valid in the code system {1}
 CONCEPTMAP_GROUP_SOURCE_CODE_INVALID_VS = The source code ''{0}'' is not valid in the value set {1}
@@ -1492,7 +1493,8 @@ RESOURCE_INTERNAL_USE_ONLY = This {0} comes from the package {1} which has been
 TYPE_SPECIFIC_CHECKS_DT_SID_INCORRECT = The URL {0} is not a correct URL to use (in spite of being in the standard, and/or accepted in the past)
 INACTIVE_DISPLAY_FOUND_one =  ''{1}'' is no longer considered a correct display for code ''{2}'' (status = {4}). The correct display is ''{3}''
 INACTIVE_DISPLAY_FOUND_other = ''{1}'' is no longer considered a correct display for code ''{2}'' (status = {4}). The correct display is one of {3}
-INACTIVE_CONCEPT_FOUND =  The concept ''{1}'' has a status of {0} and its use should be reviewed
+INACTIVE_CONCEPT_FOUND = The concept ''{1}'' has a status of {0} and its use should be reviewed
+INACTIVE_CONCEPT_FOUND_ADD = The concept ''{1}'' has a status of {0} and {2} and its use should be reviewed
 DEPRECATED_CONCEPT_FOUND = The concept ''{1}'' is deprecated and its use should be reviewed
 CONCEPT_DEPRECATED_IN_VALUESET = The presence of the concept ''{1}'' in the system ''{0}'' in the value set {3} is marked with a status of {2} and its use should be reviewed
 SYSTEM_VERSION_MULTIPLE_OVERRIDE = Multiple version overrides found for system {0}: ''{1}'', ''{2}'');