fhirsmith 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.7.1] - 2026-03-14
+
+### Added
+- Add web interface for ConceptMap
+
+### Changed
+- Change status out parameter on $validate-code from string -> code
+
+### Fixed
+- Fix handling of markdown in release process
+- OCL cache fixes 
+- 
+### Tx Conformance Statement
+
+FHIRsmith passed all 1452 HL7 terminology service tests (modes tx.fhir.org+omop+general+snomed, tests v1.9.1-SNAPSHOT, runner v6.8.2)
+
 ## [v0.7.0] - 2026-03-13
 
 ### Added

package/README.md

@@ -1,7 +1,5 @@
 # ![🔥](static/FHIRsmith64.png) FHIRsmith - FHIR Server toolkit
 
-
-
 This server provides a set of server-side services that are useful for the FHIR Community. The set of are two kinds of services:
 
 ## Modules useful to anyone in the community
@@ -31,17 +29,28 @@ in-build support for SSL, rate limiting etc.
 
 There are 4 executable programs:
 * the server (`node server`)
-* the test cases (`npm test`)
 * the terminology importer (`node --max-old-space-size=8192 tx/importers/tx-import XXX`) - see [Doco](tx/importers/readme.md)
+* the test cases (`npm test`)
 * the test cases generater (`node tx/tests/testcases-generator.js`)
 
+Unless you're developing, you only need the first two
+
+### Quick Start
+
+* Install FHIRSmith (using docker, or an NPM release, or just get the code by git)
+* Figure out the data directory 
+* Provide a configuration to tell the server what to run (see documentation below, or use a [prebuilt configuration]/configurations/readme.md)
+* Run the server 
+
+For further details of these steps, read on
+
 ### Data Directory
 
 The server separates code from runtime data. All databases, caches, logs, and downloaded
 files are stored in a single data directory. The location is determined by:
 
 1. The `FHIRSMITH_DATA_DIR` environment variable (if set)
-2. Otherwise, defaults to `./data` relative to the working directory
+2. Otherwise, defaults to `./data` relative to the working directory (development set up)
 
 The data directory contains (depending on which modules are in use):
 * `config.json` — server and module configuration

package/configurations/readme.md

@@ -3,3 +3,4 @@ This folder contains some basic starter configurations:
 * Terminology server: see tx-config.json for a vanilla server that doesn't contain any licensed content
 * NPM web server: see projector.json for a basic configuration to make a package available online
 
+To use these, copy the relevant file to your local data directory, and rename to config.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fhirsmith",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "A Node.js server that provides a collection of tools to serve the FHIR ecosystem",
   "main": "server.js",
   "engines": {

package/tx/html/conceptmap-operations.liquid

@@ -0,0 +1,19 @@
+
+<div class="operation-form" style="margin-bottom: 15px;">
+  <strong>Translate</strong>
+  <form method="get" action="$translate" style="margin-left: 10px; margin-top: 5px;">
+    <input type="hidden" name="url" value="{{ url }}"/>
+    <table class="grid" cellpadding="0" cellspacing="0">
+      <tr>
+        <td>System:</td><td><select name="sourceSystem">{{ sources }}</select></td>
+      </tr>
+      <tr>
+        <td>Code:</td><td><select name="sourceCode">{{ codes }}</select></td>
+      </tr>
+      <tr>
+        <td>Target:</td><td><select name="targetSystem">{{ targets }}</select></td>
+      </tr>
+    </table>
+    <button type="submit" class="btn btn-sm btn-primary">Translate</button>
+  </form>
+</div>

package/tx/library/renderer.js

@@ -317,8 +317,8 @@ class Renderer {
     }
   }
 
-  translate(msgId) {
-    return this.opContext.i18n.formatPhrase(msgId, this.opContext.langs, []);
+  translate(msgId, params = []) {
+    return this.opContext.i18n.formatPhrase(msgId, this.opContext.langs, params);
   }
 
   translatePlural(num, msgId) {
@@ -1640,6 +1640,575 @@ class Renderer {
       }
     }
   }
+
+  // Methods to add to the Renderer class in renderer.js for ConceptMap rendering.
+// These follow the Java ConceptMapRenderer logic and use the same translated strings.
+
+// ---- Add these methods to the Renderer class ----
+
+  /**
+   * Render a ConceptMap resource to HTML.
+   * Follows the same pattern as renderValueSet/renderCodeSystem:
+   * metadata table (reusing renderMetadataTable), then group-by-group rendering.
+   */
+  async renderConceptMap(cm) {
+    if (cm.json) {
+      cm = cm.json;
+    }
+
+    let div_ = div();
+
+    // Metadata table
+    div_.h3().tx("Properties");
+    await this.renderMetadataTable(cm, div_.table("grid"));
+
+    div_.h3("Mapping Details");
+    // Source/Target scope line (mirrors Java: CONC_MAP_FROM / CONC_MAP_TO)
+    const p = div_.para();
+    p.tx(this.translate('CONC_MAP_FROM') + " ");
+    const sourceScope = cm.sourceScope || cm.sourceCanonical || cm.sourceUri;
+    if (sourceScope) {
+      await this.renderLink(p, sourceScope);
+    } else {
+      p.tx(this.translate('CONC_MAP_NOT_SPEC'));
+    }
+    p.tx(" " + this.translate('CONC_MAP_TO') + " ");
+    const targetScope = cm.targetScope || cm.targetCanonical || cm.targetUri;
+    if (targetScope) {
+      await this.renderLink(p, targetScope);
+    } else {
+      p.tx(this.translate('CONC_MAP_NOT_SPEC'));
+    }
+
+    div_.br();
+
+    // Render each group
+    let gc = 0;
+    for (const grp of cm.group || []) {
+      gc++;
+      if (gc > 1) {
+        div_.hr();
+      }
+      await this.renderConceptMapGroup(div_, cm, grp, gc);
+    }
+
+    return div_.toString();
+  }
+
+  /**
+   * Render a single ConceptMap group.
+   * Determines whether this is a "simple" group (1:1 mappings, no dependsOn/product)
+   * or a "complex" group, and delegates accordingly.
+   */
+  async renderConceptMapGroup(x, cm, grp, gc) {
+    // Analyze the group to determine rendering mode
+    let hasComment = false;
+    let hasProperties = false;
+    let ok = true; // true = simple rendering
+
+    const props = {};   // property code -> Set of systems
+    const sources = { code: new Set() };
+    const targets = { code: new Set() };
+
+    if (grp.source) sources.code.add(grp.source);
+    if (grp.target) targets.code.add(grp.target);
+
+    for (const elem of grp.element || []) {
+      const isSimple = elem.noMap ||
+        (elem.target && elem.target.length === 1 &&
+          (!elem.target[0].dependsOn || elem.target[0].dependsOn.length === 0) &&
+          (!elem.target[0].product || elem.target[0].product.length === 0));
+      ok = ok && isSimple;
+
+      if (Extensions.readString(elem, 'http://hl7.org/fhir/StructureDefinition/conceptmap-nomap-comment')) {
+        hasComment = true;
+      }
+
+      for (const tgt of elem.target || []) {
+        if (tgt.comment) {
+          hasComment = true;
+        }
+        for (const pp of tgt.property || []) {
+          if (!props[pp.code]) {
+            props[pp.code] = new Set();
+          }
+        }
+        for (const d of tgt.dependsOn || []) {
+          if (!sources[d.attribute]) {
+            sources[d.attribute] = new Set();
+          }
+        }
+        for (const d of tgt.product || []) {
+          if (!targets[d.attribute]) {
+            targets[d.attribute] = new Set();
+          }
+        }
+      }
+    }
+
+    if (Object.keys(props).length > 0) {
+      hasProperties = true;
+    }
+
+    // Group header
+    const pp = x.para();
+    pp.b().tx(this.translate('CONC_MAP_GRP', [gc])+ " ");
+    pp.tx(this.translate('CONC_MAP_FROM') + " ");
+    if (grp.source) {
+      await this.renderLink(pp, grp.source);
+    } else {
+      pp.code().tx(this.translate('CONC_MAP_CODE_SYS_UNSPEC'));
+    }
+    pp.tx(" to ");
+    if (grp.target) {
+      await this.renderLink(pp, grp.target);
+    } else {
+      pp.code().tx(this.translate('CONC_MAP_CODE_SYS_UNSPEC'));
+    }
+
+    if (ok) {
+      await this.renderSimpleConceptMapGroup(x, grp, hasComment);
+    } else {
+      await this.renderComplexConceptMapGroup(x, grp, hasComment, hasProperties, props, sources, targets);
+    }
+  }
+
+  /**
+   * Render a simple ConceptMap group: Source | Relationship | Target | Comment
+   * This is the "ok" path from the Java code where all elements have at most
+   * one target and no dependsOn/product.
+   */
+  async renderSimpleConceptMapGroup(x, grp, hasComment) {
+    const tbl = x.table("grid");
+    let tr = tbl.tr();
+    tr.td().b().tx(this.translate('CONC_MAP_SOURCE'));
+    tr.td().b().tx(this.translate('CONC_MAP_REL'));
+    tr.td().b().tx(this.translate('CONC_MAP_TRGT'));
+    if (hasComment) {
+      tr.td().b().tx(this.translate('GENERAL_COMMENT'));
+    }
+
+    for (const elem of grp.element || []) {
+      tr = tbl.tr();
+      const td = tr.td();
+      td.tx(elem.code);
+      const display = elem.display || await this.getDisplayForConcept(grp.source, elem.code);
+      if (display && !this.isSameCodeAndDisplay(elem.code, display)) {
+        td.tx(" (" + display + ")");
+      }
+
+      if (elem.noMap) {
+        const nomapComment = Extensions.readString(elem, 'http://hl7.org/fhir/StructureDefinition/conceptmap-nomap-comment');
+        if (!hasComment) {
+          tr.td().colspan("2").style("background-color: #efefef").tx("(not mapped)");
+        } else if (nomapComment) {
+          tr.td().colspan("2").style("background-color: #efefef").tx("(not mapped)");
+          tr.td().style("background-color: #efefef").tx(nomapComment);
+        } else {
+          tr.td().colspan("3").style("background-color: #efefef").tx("(not mapped)");
+        }
+      } else {
+        let first = true;
+        for (const tgt of elem.target || []) {
+          if (first) {
+            first = false;
+          } else {
+            tr = tbl.tr();
+            tr.td().style("opacity: 0.5").tx('"');
+          }
+
+          // Relationship cell
+          this.renderConceptMapRelationship(tr, tgt);
+
+          // Target code cell
+          const tgtTd = tr.td();
+          tgtTd.tx(tgt.code || '');
+          const tgtDisplay = tgt.display || await this.getDisplayForConcept(grp.target, tgt.code);
+          if (tgtDisplay && !this.isSameCodeAndDisplay(tgt.code, tgtDisplay)) {
+            tgtTd.tx(" (" + tgtDisplay + ")");
+          }
+
+          if (hasComment) {
+            tr.td().tx(tgt.comment || '');
+          }
+        }
+      }
+    }
+    this.addUnmapped(tbl, grp);
+  }
+
+  /**
+   * Render a complex ConceptMap group with dependsOn, product, and/or property columns.
+   * This is the "!ok" path from the Java code.
+   */
+  async renderComplexConceptMapGroup(x, grp, hasComment, hasProperties, props, sources, targets) {
+    // Check if any targets have relationships
+    let hasRelationships = false;
+    for (const elem of grp.element || []) {
+      for (const tgt of elem.target || []) {
+        if (tgt.relationship) {
+          hasRelationships = true;
+        }
+      }
+    }
+
+    const tbl = x.table("grid");
+
+    // First header row: Source Details | Relationship | Target Details | Comment | Properties
+    let tr = tbl.tr();
+    const sourceColCount = 1 + Object.keys(sources).length - 1; // code + dependsOn attributes
+    const targetColCount = 1 + Object.keys(targets).length - 1; // code + product attributes
+    tr.td().colspan(String(sourceColCount + 1)).b().tx(this.translate('CONC_MAP_SRC_DET'));
+    if (hasRelationships) {
+      tr.td().b().tx(this.translate('CONC_MAP_REL'));
+    }
+    tr.td().colspan(String(targetColCount + 1)).b().tx(this.translate('CONC_MAP_TRGT_DET'));
+    if (hasComment) {
+      tr.td().b().tx(this.translate('GENERAL_COMMENT'));
+    }
+    if (hasProperties) {
+      tr.td().colspan(String(Object.keys(props).length)).b().tx(this.translate('GENERAL_PROPS'));
+    }
+
+    // Second header row: actual column headers
+    tr = tbl.tr();
+
+    // Source code column
+    if (sources.code.size === 1) {
+      const url = [...sources.code][0];
+      await this.renderCSDetailsLink(tr, url, true);
+    } else {
+      tr.td().b().tx(this.translate('GENERAL_CODE'));
+    }
+    // Source dependsOn attribute columns
+    for (const s of Object.keys(sources)) {
+      if (s !== 'code') {
+        if (sources[s].size === 1) {
+          const url = [...sources[s]][0];
+          await this.renderCSDetailsLink(tr, url, false);
+        } else {
+          tr.td().b().tx(this.getDescForConcept(s));
+        }
+      }
+    }
+    // Relationship column
+    if (hasRelationships) {
+      tr.td();
+    }
+    // Target code column
+    if (targets.code.size === 1) {
+      const url = [...targets.code][0];
+      await this.renderCSDetailsLink(tr, url, true);
+    } else {
+      tr.td().b().tx(this.translate('GENERAL_CODE'));
+    }
+    // Target product attribute columns
+    for (const s of Object.keys(targets)) {
+      if (s !== 'code') {
+        if (targets[s].size === 1) {
+          const url = [...targets[s]][0];
+          await this.renderCSDetailsLink(tr, url, false);
+        } else {
+          tr.td().b().tx(this.getDescForConcept(s));
+        }
+      }
+    }
+    // Comment column header
+    if (hasComment) {
+      tr.td();
+    }
+    // Property column headers
+    if (hasProperties) {
+      for (const s of Object.keys(props)) {
+        if (props[s].size === 1) {
+          const url = [...props[s]][0];
+          await this.renderCSDetailsLink(tr, url, false);
+        } else {
+          tr.td().b().tx(this.getDescForConcept(s));
+        }
+      }
+    }
+
+    // Data rows
+    for (const elem of grp.element || []) {
+      if (elem.noMap) {
+        tr = tbl.tr();
+        const td = tr.td().style("border-right-width: 0px");
+        if (sources.code.size === 1) {
+          td.tx(elem.code);
+        } else {
+          td.tx(grp.source + " / " + elem.code);
+        }
+        const display = elem.display || await this.getDisplayForConcept(grp.source, elem.code);
+        tr.td().style("border-left-width: 0px").tx(display || '');
+
+        const nomapComment = Extensions.readString(elem, 'http://hl7.org/fhir/StructureDefinition/conceptmap-nomap-comment');
+        if (nomapComment) {
+          tr.td().colspan("3").style("background-color: #efefef").tx("(not mapped)");
+          tr.td().style("background-color: #efefef").tx(nomapComment);
+        } else {
+          tr.td().colspan("4").style("background-color: #efefef").tx("(not mapped)");
+        }
+      } else {
+        let first = true;
+        for (let ti = 0; ti < (elem.target || []).length; ti++) {
+          const tgt = elem.target[ti];
+          const last = ti === elem.target.length - 1;
+          tr = tbl.tr();
+
+          // Source code cell
+          const td = tr.td().style("border-right-width: 0px");
+          if (!first && !last) {
+            td.style("border-top-style: none; border-bottom-style: none");
+          } else if (!first) {
+            td.style("border-top-style: none");
+          } else if (!last) {
+            td.style("border-bottom-style: none");
+          }
+
+          if (first) {
+            if (sources.code.size === 1) {
+              td.tx(elem.code);
+            } else {
+              td.tx(grp.source + " / " + elem.code);
+            }
+            const display = elem.display || await this.getDisplayForConcept(grp.source, elem.code);
+            const dispTd = tr.td();
+            if (!last) {
+              dispTd.style("border-left-width: 0px; border-bottom-style: none");
+            } else {
+              dispTd.style("border-left-width: 0px");
+            }
+            dispTd.tx(display || '');
+          } else {
+            // Empty display cell for subsequent targets
+            const dispTd = tr.td();
+            if (!last) {
+              dispTd.style("border-left-width: 0px; border-top-style: none; border-bottom-style: none");
+            } else {
+              dispTd.style("border-top-style: none; border-left-width: 0px");
+            }
+          }
+
+          // Source dependsOn columns
+          for (const s of Object.keys(sources)) {
+            if (s !== 'code') {
+              const depTd = tr.td();
+              const val = this.getDependsOnValue(tgt.dependsOn, s, sources[s].size !== 1);
+              depTd.tx(val || '');
+              const depDisplay = this.getDependsOnDisplay(tgt.dependsOn, s);
+              if (depDisplay) {
+                depTd.tx(" (" + depDisplay + ")");
+              }
+            }
+          }
+
+          first = false;
+
+          // Relationship cell
+          if (hasRelationships) {
+            this.renderConceptMapRelationship(tr, tgt);
+          }
+
+          // Target code cell
+          const tgtTd = tr.td().style("border-right-width: 0px");
+          if (targets.code.size === 1) {
+            tgtTd.tx(tgt.code || '');
+          } else {
+            tgtTd.tx((grp.target || '') + " / " + (tgt.code || ''));
+          }
+          const tgtDisplay = tgt.display || await this.getDisplayForConcept(grp.target, tgt.code);
+          tr.td().style("border-left-width: 0px").tx(tgtDisplay || '');
+
+          // Target product columns
+          for (const s of Object.keys(targets)) {
+            if (s !== 'code') {
+              const prodTd = tr.td();
+              const val = this.getDependsOnValue(tgt.product, s, targets[s].size !== 1);
+              prodTd.tx(val || '');
+              const prodDisplay = this.getDependsOnDisplay(tgt.product, s);
+              if (prodDisplay) {
+                prodTd.tx(" (" + prodDisplay + ")");
+              }
+            }
+          }
+
+          // Comment cell
+          if (hasComment) {
+            tr.td().tx(tgt.comment || '');
+          }
+
+          // Property cells
+          if (hasProperties) {
+            for (const s of Object.keys(props)) {
+              const propTd = tr.td();
+              propTd.tx(this.getPropertyValueFromList(tgt.property, s));
+            }
+          }
+        }
+      }
+    }
+    this.addUnmapped(tbl, grp);
+  }
+
+  /**
+   * Render the relationship cell for a target element.
+   * Handles both R5 relationship codes and legacy R4 equivalence codes via extension.
+   */
+  renderConceptMapRelationship(tr, tgt) {
+    if (tgt.relationship) {
+      tr.td().tx(this.presentRelationshipCode(tgt.relationship));
+    } else if (tgt.equivalence) {
+      tr.td().tx(this.presentEquivalenceCode(tgt.equivalence));
+    } else {
+      tr.td().tx("(" + "equivalent" + ")");
+    }
+  }
+
+  /**
+   * Render a code system details link in a header cell.
+   * Mirrors Java renderCSDetailsLink.
+   */
+  async renderCSDetailsLink(tr, url, span2) {
+    const td = tr.td();
+    if (span2) {
+      td.colspan("2");
+    }
+    td.b().tx(this.translate('CONC_MAP_CODES'));
+    td.tx(" " + this.translate('CONC_MAP_FRM') + " ");
+    const linkinfo = this.linkResolver ? await this.linkResolver.resolveURL(this.opContext, url) : null;
+    if (linkinfo) {
+      td.ah(linkinfo.link).tx(linkinfo.description);
+    } else {
+      td.tx(url);
+    }
+  }
+
+  /**
+   * Translate a FHIR R5 ConceptMap relationship code to a human-readable string.
+   * Uses the same strings as the Java renderer.
+   */
+  presentRelationshipCode(code) {
+    switch (code) {
+      case 'related-to':                   return 'is related to';
+      case 'equivalent':                   return 'is equivalent to';
+      case 'source-is-narrower-than-target': return 'is narrower than';
+      case 'source-is-broader-than-target':  return 'is broader than';
+      case 'not-related-to':               return 'is not related to';
+      default:                             return code;
+    }
+  }
+
+  /**
+   * Translate a legacy (R2/R3/R4) ConceptMap equivalence code to a human-readable string.
+   * Uses the same strings as the Java renderer.
+   */
+  presentEquivalenceCode(code) {
+    switch (code) {
+      case 'relatedto':    return 'is related to';
+      case 'equivalent':   return 'is equivalent to';
+      case 'equal':        return 'is equal to';
+      case 'wider':        return 'maps to wider concept';
+      case 'subsumes':     return 'is subsumed by';
+      case 'narrower':     return 'maps to narrower concept';
+      case 'specializes':  return 'has specialization';
+      case 'inexact':      return 'maps loosely to';
+      case 'unmatched':    return 'has no match';
+      case 'disjoint':     return 'is not related to';
+      default:             return code;
+    }
+  }
+
+  /**
+   * Check if a code and its display text are essentially the same
+   * (ignoring spaces, hyphens, and case).
+   */
+  isSameCodeAndDisplay(code, display) {
+    if (!code || !display) return false;
+    const c = code.replace(/[ -]/g, '').toLowerCase();
+    const d = display.replace(/[ -]/g, '').toLowerCase();
+    return c === d;
+  }
+
+  /**
+   * Look up a display string for a concept. Delegates to the linkResolver if available.
+   */
+  async getDisplayForConcept(system, code) {
+    if (!system || !code) return null;
+    if (!this.linkResolver) return null;
+    const result = await this.linkResolver.resolveCode(this.opContext, system, null, code);
+    return result ? result.description : null;
+  }
+
+  /**
+   * Get a description for a concept attribute code (used in complex table headers).
+   * Mirrors Java getDescForConcept.
+   */
+  getDescForConcept(s) {
+    if (s.startsWith('http://hl7.org/fhir/v2/element/')) {
+      return 'v2 ' + s.substring('http://hl7.org/fhir/v2/element/'.length);
+    }
+    return s;
+  }
+
+  /**
+   * Extract a value from a dependsOn or product list by attribute name.
+   */
+  getDependsOnValue(list, attribute) {
+    if (!list) return null;
+    for (const item of list) {
+      if (item.attribute === attribute) {
+        // R5 uses value[x], try common types
+        if (item.valueCode) return item.valueCode;
+        if (item.valueString) return item.valueString;
+        if (item.valueCoding) return item.valueCoding.code || '';
+        if (item.value) return String(item.value);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Extract a display from a dependsOn or product list by attribute name.
+   */
+  // eslint-disable-next-line no-unused-vars
+  getDependsOnDisplay(list, attribute) {
+    // In current FHIR, dependsOn display is not directly available;
+    // would require a lookup. Return null for now (matches Java which also returns null).
+    return null;
+  }
+
+  /**
+   * Extract a property value from a target's property list by code.
+   */
+  getPropertyValueFromList(list, code) {
+    if (!list) return '';
+    const results = [];
+    for (const item of list) {
+      if (item.code === code) {
+        // R5 MappingPropertyComponent uses value[x]
+        if (item.valueCode !== undefined) results.push(item.valueCode);
+        else if (item.valueString !== undefined) results.push(item.valueString);
+        else if (item.valueCoding !== undefined) results.push(item.valueCoding.code || '');
+        else if (item.valueBoolean !== undefined) results.push(String(item.valueBoolean));
+        else if (item.valueInteger !== undefined) results.push(String(item.valueInteger));
+        else if (item.valueDecimal !== undefined) results.push(String(item.valueDecimal));
+        else if (item.valueDateTime !== undefined) results.push(item.valueDateTime);
+      }
+    }
+    return results.join(', ');
+  }
+
+  /**
+   * Render the unmapped section for a group, if present.
+   * Currently a stub matching the Java implementation.
+   */
+  addUnmapped(tbl, grp) {
+    if (grp.unmapped) {
+      // TODO: render unmapped mode/code/url when needed
+    }
+  }
+
 }
 
 module.exports = { Renderer };

package/tx/tx-html.js

@@ -18,6 +18,7 @@ const {CapabilityStatementXML} = require("./xml/capabilitystatement-xml");
 const {TerminologyCapabilitiesXML} = require("./xml/terminologycapabilities-xml");
 const {ParametersXML} = require("./xml/parameters-xml");
 const {OperationOutcomeXML} = require("./xml/operationoutcome-xml");
+const {debugLog} = require("./operation-context");
 
 const txHtmlLog = Logger.getInstance().child({ module: 'tx-html' });
 
@@ -312,7 +313,7 @@ class TxHtmlRenderer {
             return await this.renderValueSet(json, inBundle, _fmt, op, exp);
           }
           case 'ConceptMap':
-            return await this.renderConceptMap(json, inBundle);
+            return await this.renderConceptMap(json, inBundle, _fmt, op);
           case 'CapabilityStatement':
             return await this.renderCapabilityStatement(json, inBundle);
           case 'TerminologyCapabilities':
@@ -327,6 +328,7 @@ class TxHtmlRenderer {
             return await this.renderGeneric(json, inBundle);
         }
       } catch (error) {
+        debugLog(error);
         console.error(error);
         throw error;
       }
@@ -698,8 +700,51 @@ class TxHtmlRenderer {
    * Render ConceptMap resource
    */
   // eslint-disable-next-line no-unused-vars
-  async renderConceptMap(json, inBundle) {
-    return this.renderResourceWithNarrative(json);
+  async renderConceptMap(json, inBundle, _fmt, op) {
+    if (inBundle || op) {
+      return await this.renderResourceWithNarrative(json, await this.renderer.renderConceptMap(json));
+    } else {
+      let html = `<ul class="nav nav-tabs">`;
+      html += this.tab(!_fmt || _fmt == 'html', json.resourceType, json.resourceType, 'html', json.id);
+      html += this.tab(_fmt && _fmt == 'html/json', 'JSON', json.resourceType, 'html/json', json.id);
+      html += this.tab(_fmt && _fmt == 'html/narrative', 'Original Narrative', json.resourceType, 'html/narrative', json.id);
+      html += this.tab(_fmt && _fmt == 'html/ops', 'Translate', json.resourceType, 'html/ops', json.id);
+      html += `</ul>`;
+
+      if (!_fmt || _fmt == 'html') {
+        html += await this.renderResourceWithNarrative(json, await this.renderer.renderConceptMap(json));
+      } else if (_fmt == "html/json") {
+        html += await this.renderResourceJson(json);
+      } else if (_fmt == "html/narrative") {
+        html += await this.renderResourceWithNarrative(json, json.text?.div);
+      } else if (_fmt == "html/ops") {
+        const sourceSet = new Set();
+        const codeSet = new Set();
+        const targetSet = new Set();
+
+        for (const grp of json.group || []) {
+          if (grp.source) sourceSet.add(`<option value="${escape(grp.source)}">${escape(grp.source)}</option>`);
+          if (grp.target) targetSet.add(`<option value="${escape(grp.target)}">${escape(grp.target)}</option>`);
+          for (const elem of grp.element || []) {
+            if (elem.code) codeSet.add(`<option value="${escape(elem.code)}">${escape(elem.code)}</option>`);
+          }
+        }
+        const sources = [...sourceSet];
+        const codes = [...codeSet];
+        const targets = [...targetSet];
+
+        html += await this.liquid.renderFile('conceptmap-operations', {
+          opsId: this.generateResourceId(),
+          cmSystemId: this.generateResourceId(),
+          inferSystemId: this.generateResourceId(),
+          sources: sources,
+          codes: codes,
+          targets: targets,
+          url: escape(json.url || '')
+        });
+      }
+      return html;
+    }
   }
 
   /**

package/tx/workers/read.js

@@ -47,14 +47,7 @@ class ReadWorker extends TerminologyWorker {
           return await this.handleValueSet(req, res, id);
 
         case 'ConceptMap':
-          return res.status(501).json({
-            resourceType: 'OperationOutcome',
-            issue: [{
-              severity: 'error',
-              code: 'not-supported',
-              diagnostics: 'ConceptMap read not yet implemented'
-            }]
-          });
+          return await this.handleConceptMap(req, res, id);
 
         default:
           return res.status(404).json({
@@ -152,6 +145,28 @@ class ReadWorker extends TerminologyWorker {
       }
     }
 
+    return res.status(404).json({
+      resourceType: 'OperationOutcome',
+      issue: [{
+        severity: 'error',
+        code: 'not-found',
+        diagnostics: `ValueSet/${id} not found`
+      }]
+    });
+  }
+  /**
+   * Handle ConceptMap read
+   */
+  async handleConceptMap(req, res, id) {
+    // Iterate through valueSetProviders in order
+    for (const cmsp of this.provider.conceptMapProviders) {
+      this.deadCheck('handleConceptMap-loop');
+      const vs = await cmsp.fetchConceptMapById(id);
+      if (vs) {
+        return res.json(vs.jsonObj);
+      }
+    }
+
     return res.status(404).json({
       resourceType: 'OperationOutcome',
       issue: [{

package/tx/workers/search.js

@@ -96,7 +96,7 @@ class SearchWorker extends TerminologyWorker {
 
         case 'ConceptMap':
           // Not implemented yet - return empty set
-          matches = [];
+          matches = await this.searchConceptMaps(params, elements);
           break;
 
         default:
@@ -235,6 +235,41 @@ class SearchWorker extends TerminologyWorker {
     return allMatches;
   }
 
+  /**
+   * Search ConceptMaps by delegating to providers
+   */
+  async searchConceptMaps(params, elements) {
+    const allMatches = [];
+
+    // Convert params object to array format expected by ValueSet providers
+    // Exclude control params (_offset, _count, _elements, _sort)
+    const searchParams = [];
+    let source = null;
+    for (const [key, value] of Object.entries(params)) {
+      if (!key.startsWith('_') && value && SearchWorker.ALLOWED_PARAMS.includes(key)) {
+        searchParams.push({ name: key, value: value });
+      }
+      if (key == 'source') {
+        source = value;
+      }
+    }
+
+    for (const cmsp of this.provider.conceptMapProviders) {
+      if (!source || source == cmsp.sourcePackage()) {
+        this.deadCheck('searchConceptMaps-providers');
+        const results = await cmsp.searchConceptMaps(searchParams, elements);
+        if (results && Array.isArray(results)) {
+          for (const vs of results) {
+            this.deadCheck('searchConceptMaps-results');
+            allMatches.push(vs.jsonObj || vs);
+          }
+        }
+      }
+    }
+
+    return allMatches;
+  }
+
   /**
    * Check if a value matches the search term (partial, case-insensitive)
    */

package/tx/workers/validate.js

@@ -944,13 +944,13 @@ class ValueSetChecker {
       if (inactive.value) {
         result.AddParamBool('inactive', inactive.value);
         if (vstatus.value && vstatus.value !== 'inactive') {
-          result.addParamStr('status', vstatus.value);
+          result.addParamCode('status', vstatus.value);
         }
         let msg = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, coding.code]);
         messages.push(msg);
         op.addIssue(new Issue('warning', 'business-rule', path, 'INACTIVE_CONCEPT_FOUND', msg, 'code-comment'));
       } else if (vstatus.value.toLowerCase() === 'deprecated') {
-        result.addParamStr('status', vstatus.value);
+        result.addParamCode('status', vstatus.value);
         let msg = this.worker.i18n.translate('DEPRECATED_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, coding.code]);
         messages.push(msg);
         op.addIssue(new Issue('warning', 'business-rule', path, 'DEPRECATED_CONCEPT_FOUND', msg, 'code-comment'));
@@ -1348,13 +1348,18 @@ class ValueSetChecker {
     if (inactive.value) {
       result.addParamBool('inactive', inactive.value);
       if (vstatus.value && vstatus.value !== 'inactive') {
-        result.addParamStr('status', vstatus.value);
+        result.addParamCode('status', vstatus.value);
+      }
+      if (!['inactive', 'DISCOURAGED'].includes(vstatus.value)) {
+        let m = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, ['inactive', tcode]);
+        msg(m);
+        op.addIssue(new Issue('warning', 'business-rule', inactive.path, 'INACTIVE_CONCEPT_FOUND', m, 'code-comment'));
       }
       let m = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, tcode]);
       msg(m);
       op.addIssue(new Issue('warning', 'business-rule', inactive.path, 'INACTIVE_CONCEPT_FOUND', m, 'code-comment'));
     } else if (vstatus.value && vstatus.value.toLowerCase() === 'deprecated') {
-      result.addParamStr('status', 'deprecated');
+      result.addParamCode('status', 'deprecated');
       let m = this.worker.i18n.translate('DEPRECATED_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, tcode]);
       msg(m);
       op.addIssue(new Issue('warning', 'business-rule', issuePath, 'DEPRECATED_CONCEPT_FOUND', m, 'code-comment'));
@@ -1494,13 +1499,13 @@ class ValueSetChecker {
       if (inactive.value) {
         result.addParamBool('inactive', inactive.value);
         if (vstatus.value && vstatus.value !== 'inactive') {
-          result.addParamStr('status', vstatus.value);
+          result.addParamCode('status', vstatus.value);
         }
         let msg = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, code]);
         messages.push(msg);
         op.addIssue(new Issue('warning', 'business-rule', 'code', 'INACTIVE_CONCEPT_FOUND', msg, 'code-comment'));
       } else if (vstatus.value.toLowerCase() === 'deprecated') {
-        result.addParamStr('status', vstatus.value);
+        result.addParamCode('status', vstatus.value);
         let msg = this.worker.i18n.translate('DEPRECATED_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, code]);
         messages.push(msg);
         op.addIssue(new Issue('warning', 'business-rule', 'code', 'DEPRECATED_CONCEPT_FOUND', msg, 'code-comment'));