fhirsmith 0.18.1 → 0.18.2

package/tx/cs/cs-cs.js

@@ -19,6 +19,9 @@ const regexUtilities = require("../../library/regex-utilities");
 // filter results do not depend on forIteration, so one form is stored per version.
 const FILTER_ANALYSIS = Symbol('filterAnalysis');
 
+// The standard concept properties (http://hl7.org/fhir/concept-properties)
+const CONCEPT_PROPERTIES = 'http://hl7.org/fhir/concept-properties#';
+
 // The texts of each concept as a text filter compares them, by concept. Folding is
 // the costly part of a search over a large code system, so it is done once per
 // concept, and dropped with the code system.
@@ -315,6 +318,46 @@ class FhirCodeSystemProvider extends BaseCSServices {
     return this.codeSystem.jsonObj.property || null;
   }
 
+  /**
+   * The codes this code system uses for one of the standard concept properties
+   * (http://hl7.org/fhir/concept-properties#<name>). A property declared with the
+   * standard uri counts whatever local code it was given. A code that the code
+   * system declares with a different uri is a different property, and does not
+   * count. A code the code system doesn't declare (or declares with no uri) is
+   * recognised by the code alone - the standard code, and any legacy aliases
+   *
+   * @param {string} name - the standard property code (e.g. notSelectable)
+   * @param {string[]} aliases - legacy codes also recognised when not declared otherwise
+   * @returns {Set<string>} the local codes for the property
+   */
+  standardPropertyCodes(name, aliases = []) {
+    const uri = CONCEPT_PROPERTIES + name;
+    const defs = this.propertyDefinitions() || [];
+    const codes = new Set();
+    for (const d of defs) {
+      if (d.uri === uri) {
+        codes.add(d.code);
+      }
+    }
+    for (const c of [name, ...aliases]) {
+      if (!defs.some(d => d.code === c && d.uri && d.uri !== uri)) {
+        codes.add(c);
+      }
+    }
+    return codes;
+  }
+
+  /**
+   * Whether the code system declares the code of a standard concept property for a
+   * property of its own (with a different uri), so that the code is not the standard one
+   * @param {string} name - the standard property code
+   * @returns {boolean}
+   */
+  redefinesStandardProperty(name) {
+    const uri = CONCEPT_PROPERTIES + name;
+    return (this.propertyDefinitions() || []).some(d => d.code === name && d.uri && d.uri !== uri);
+  }
+
   /**
    * @param {Languages} languages - Language specification
    * @returns {boolean} Whether any displays are available for the languages
@@ -524,14 +567,10 @@ class FhirCodeSystemProvider extends BaseCSServices {
       return false;
     }
 
-    // Check for abstract property
+    // Check for the notSelectable property, by whatever code this code system gives it
     if (ctxt.concept.property && Array.isArray(ctxt.concept.property)) {
-      const abstractProp = ctxt.concept.property.find(p =>
-        p.code === 'abstract' ||
-        p.code === 'not-selectable' ||
-        p.code === 'notSelectable' ||
-        p.uri === 'http://hl7.org/fhir/concept-properties#notSelectable'
-      );
+      const codes = this.standardPropertyCodes('notSelectable', ['abstract', 'not-selectable']);
+      const abstractProp = ctxt.concept.property.find(p => codes.has(p.code));
       if (abstractProp && abstractProp.valueBoolean) {
         return true;
       }
@@ -1399,9 +1438,10 @@ class FhirCodeSystemProvider extends BaseCSServices {
         }
       }
 
-      // Handle known special properties
+      // Handle known special properties - unless the code system uses the code for a
+      // property of its own, in which case the property filter above applies
       const knownProperties = ['notSelectable', 'status', 'inactive', 'deprecated'];
-      if (knownProperties.includes(prop)) {
+      if (knownProperties.includes(prop) && !this.redefinesStandardProperty(prop)) {
         results = await this._handleKnownPropertyFilter(filterContext, prop, op, value);
       }
 
@@ -1705,13 +1745,14 @@ class FhirCodeSystemProvider extends BaseCSServices {
   async _handleKnownPropertyFilter(filterContext, prop, op, value) {
     const results = new FhirCodeSystemProviderFilterContext();
     const allConcepts = this.codeSystem.getAllConcepts();
+    const nsCodes = this.standardPropertyCodes('notSelectable', ['abstract', 'not-selectable']);
 
     for (const concept of allConcepts) {
       this.opContext.deadCheck('cs:knownPropertyFilter');
       let matches = false;
 
       if (prop === 'notSelectable') {
-        const abstractProp = (concept.property || []).find(p => p.code === 'abstract' || p.code === 'notSelectable' || p.uri === 'http://hl7.org/fhir/concept-properties#notSelectable');
+        const abstractProp = (concept.property || []).find(p => nsCodes.has(p.code));
         let vv = abstractProp ? String(getValuePrimitive(abstractProp)) : null;
         if (op === '=') {
           matches = (vv === value);

package/tx/cs/cs-loinc.js

@@ -492,7 +492,14 @@ class LoincServices extends BaseCSServices {
         } else {
           for (const row of rows) {
             if (this._hasProp(props, row.Relationship, true)) {
-              this._addCodeProperty(params, 'property', row.Relationship, row.Code);
+              if (row.Relationship === 'CLASS') {
+                // CLASS is a string property - the class name (e.g. PULM). The Part code for the
+                // class is also returned, as partCode (an informal extension to the property)
+                this._addStringProperty(params, 'property', row.Relationship, row.Value || row.Code)
+                  .part.push({name: 'partCode', valueCode: row.Code});
+              } else {
+                this._addCodeProperty(params, 'property', row.Relationship, row.Code);
+              }
             }
           }
           resolve();

package/tx/cs/cs-snomed.js

@@ -37,7 +37,7 @@ const SNOMED_FILTER_ANALYSIS = Symbol('snomedFilterAnalysis');
  * returned as. An identifier in an unknown scheme is kept but not reported.
  */
 const IDENTIFIER_SCHEMES = {
-  '30051010000102': { system: 'http://loinc.org', property: 'loinc' }   // |LOINC code identifier| (LOINC Extension)
+  '30051010000102': { system: 'http://loinc.org', property: 'loinc', alias: 'LOINC' }   // |LOINC code identifier| (LOINC Extension)
 };
 
 /** The $expand / ECL-free filter on alternate identifiers: mapped:<scheme> exists true|false */
@@ -206,6 +206,39 @@ class SnomedServices {
     this._mrcmRangeCache = new Map();
 
     this.#loadIdentifiers(sharedData.identifiers || []);
+    this.#loadConcreteValues(sharedData.concreteValues);
+  }
+
+  /**
+   * Index the concrete value relationships (cache version 19: rows of
+   * [sourceId, typeId, group, value], value as written in RF2 - "#500", "#5.5",
+   * a quoted string, or true/false) by source concept index, for the ECL
+   * evaluator. `concreteValues` stays null when the cache predates them, which
+   * is how a concrete-value refinement knows to report itself as unsupported
+   * rather than answering with nothing.
+   */
+  #loadConcreteValues(rows) {
+    this.concreteValues = null;
+    if (!rows) return;
+    this.concreteValues = new Map();
+    for (const [sourceId, typeId, group, raw] of rows) {
+      const src = this.concepts.findConcept(sourceId);
+      const type = this.concepts.findConcept(typeId);
+      if (!src.found || !type.found) continue;
+      let value;
+      if (/^#-?\d+(\.\d+)?$/.test(raw)) {
+        value = { kind: 'number', value: Number(raw.substring(1)), decimal: raw.includes('.') };
+      } else if (/^".*"$/.test(raw)) {
+        value = { kind: 'string', value: raw.substring(1, raw.length - 1) };
+      } else if (/^(true|false)$/i.test(raw)) {
+        value = { kind: 'boolean', value: raw.toLowerCase() === 'true' };
+      } else {
+        value = { kind: 'string', value: raw };
+      }
+      const list = this.concreteValues.get(src.index) || [];
+      list.push({ relType: type.index, group: group || 0, concrete: value });
+      this.concreteValues.set(src.index, list);
+    }
   }
 
   /**
@@ -912,14 +945,16 @@ class SnomedServices {
    *   hierarchy operators on *, ^ and bracketed sets (applied per member)
    *   AND / OR / MINUS compound expressions
    *   !!> / !!< (top / bottom of set)
-   *   refinements (= against an expression, attribute AND/OR/",", groups,
-   *   attribute and group cardinality, attribute names that are expressions),
+   *   refinements (= and != against an expression, reversed (R) attributes,
+   *   attribute AND/OR/",", groups, attribute and group cardinality,
+   *   attribute names that are expressions),
    *   dotted expressions, {{ C ... }} concept filters, {{ D ... }} description
-   *   filters, comments
+   *   filters, {{ + HISTORY... }} history supplements, concrete (numeric /
+   *   string / boolean) values in refinements (cache version 19+), comments
+   *
+   *   alternate identifiers (LOINC#code, from the identifier scheme aliases)
    *
-   * Everything else (reverse attributes, != and concrete (numeric/string/
-   * boolean) values in refinements, alternate identifiers, reference set field
-   * selection on ^, {{ + ... }} history supplements) throws an informative
+   * Everything else (reference set field selection on ^) throws an informative
    * error which is reported as UNSUPPORTED_ECL.
    */
 
@@ -1068,9 +1103,6 @@ class SnomedServices {
     // ({{ M ... }}) are handled in _evalMemberOf; concept filters ({{ C ... }})
     // and description filters ({{ D ... }}) are applied to the result below.
     if (node.filters && node.filters.length > 0) {
-      if (node.filters.some(fc => fc.kind === '+')) {
-        throw new Error('ECL history supplements ({{ + ... }}) are not supported');
-      }
       const inner = { ...node, filters: undefined };
       let ctx = this._evalSubExpression(inner, opContext);
       const conceptFilters = node.filters.filter(fc => fc.kind === 'C');
@@ -1080,12 +1112,26 @@ class SnomedServices {
       for (const fc of node.filters.filter(fc => fc.kind === 'D')) {
         ctx = this._applyDescriptionFilter(ctx, fc.filters, opContext);
       }
+      for (const fc of node.filters.filter(fc => fc.kind === '+')) {
+        ctx = this._applyHistorySupplement(ctx, fc, opContext);
+      }
       return ctx;
     }
 
-    // Alternate identifiers (ECL 2.1 "scheme#code")
+    // Alternate identifiers (ECL 2.1 "scheme#code"): the concept(s) that carry
+    // the code in that identifier scheme, then the operator applies to them as
+    // to any set. The scheme is an alias from the ECL specification (LOINC) or
+    // the identifier scheme concept's own id.
     if (focus.type === ECLNodeType.ALT_IDENTIFIER) {
-      throw new Error(`ECL alternate identifiers (${focus.scheme}#${focus.code}) are not supported - no alternate identifier reference sets are loaded`);
+      const set = this._eclAltIdentifier(focus);
+      if (!operator) {
+        const result = new SnomedFilterContext();
+        result.descendants = set;
+        return result;
+      }
+      const base = new SnomedFilterContext();
+      base.descendants = set;
+      return this._eclApplyOperatorToSet(base, operator, opContext);
     }
 
     // Top / bottom of set: the members of the focus set with no ancestor
@@ -1160,6 +1206,32 @@ class SnomedServices {
     return result;
   };
 
+  /**
+   * Resolve an ECL alternate identifier (scheme#code) to concept indexes. The
+   * scheme is a known alias (IDENTIFIER_SCHEMES[].alias, case-insensitive) or
+   * an identifier scheme concept id. An unknown scheme, or a code nobody has,
+   * is an invalid expression - the same standing as an unknown concept.
+   */
+  _eclAltIdentifier = function (node) {
+    let schemeId = null;
+    if (/^\d{6,18}$/.test(node.scheme)) {
+      schemeId = node.scheme;
+    } else {
+      for (const [id, def] of Object.entries(IDENTIFIER_SCHEMES)) {
+        if (def.alias && def.alias.toLowerCase() === node.scheme.toLowerCase()) schemeId = id;
+      }
+    }
+    const invalid = (msg) => { const e = new Error(msg); e.eclInvalid = true; return e; };
+    if (!schemeId) {
+      throw invalid(`The alternate identifier scheme "${node.scheme}" is not known`);
+    }
+    const concepts = this.getConceptsForIdentifier(schemeId, node.code);
+    if (concepts.length === 0) {
+      throw invalid(`No concept has the alternate identifier ${node.scheme}#${node.code}`);
+    }
+    return concepts.map(id => this.concepts.findConcept(id)).filter(r => r.found).map(r => r.index);
+  };
+
   /**
    * !!> / !!< : keep the concepts in `set` that have no ancestor (top) or no
    * descendant (bottom) that is also in `set`. Walks the stated parents of each
@@ -1317,6 +1389,9 @@ class SnomedServices {
     }
     const refsetConcepts = this._eclResolveSet(this._evalECLNode(memberOfNode.refSet, opContext), opContext);
     const memberFilters = this._eclPrepareMemberFilters(memberOfNode.memberFilters, opContext);
+    const rs = memberOfNode.refSet;
+    const explicit = rs.type === ECLNodeType.CONCEPT_REFERENCE ||
+      (rs.type === ECLNodeType.SUB_EXPRESSION_CONSTRAINT && !rs.operator && rs.focus.type === ECLNodeType.CONCEPT_REFERENCE);
 
     const members = new Set();
     for (const refsetIdx of refsetConcepts) {
@@ -1334,9 +1409,12 @@ class SnomedServices {
       }
       const memberList = this.refSetMembers.getMembers(membersRef) || [];
       // A reference set whose members are descriptions (a language reference
-      // set, say) has no concept members to return. Say so rather than
-      // answering with an empty set, which would read as "no members".
-      if (memberList.length > 0 && !memberList.some(m => m.kind === 0)) {
+      // set, say) has no concept members to return. When it was named
+      // explicitly, say so rather than answering with an empty set, which would
+      // read as "no members". When it merely falls inside a computed operand
+      // (^ *, ^ (< 900000000000455006)) it contributes nothing and the rest of
+      // the operand still counts.
+      if (explicit && memberList.length > 0 && !memberList.some(m => m.kind === 0)) {
         throw new Error(`The members of reference set ${this.concepts.getConceptId(refsetIdx)} are descriptions, not concepts, so ^ cannot be evaluated for it`);
       }
       for (const m of memberList) {
@@ -1356,6 +1434,82 @@ class SnomedServices {
     return result;
   };
 
+  /**
+   * Apply a history supplement ({{ + HISTORY... }}): add to the result the
+   * inactive concepts that the selected historical association reference sets
+   * associate with a concept in the result (the association rows whose
+   * targetComponentId is in the result).
+   *
+   * Profiles (ECL 2.x): MIN = SAME AS; MOD = SAME AS, WAS A, REPLACED BY,
+   * PARTIALLY EQUIVALENT TO; MAX (and a bare HISTORY) = every reference set
+   * under 900000000000522004 |Historical association|; HISTORY (expr) = the
+   * reference sets the expression yields. A reference set the edition does not
+   * carry simply contributes nothing.
+   */
+  _applyHistorySupplement = function (ctx, hs, opContext) {
+    const HISTORICAL_ASSOCIATION = '900000000000522004';
+    const PROFILES = {
+      MIN: ['900000000000527005'],
+      MOD: ['900000000000527005', '900000000000528000', '900000000000526001', '1186924009']
+    };
+    let refsetIdxs;
+    if (hs.profile === 'EXPLICIT') {
+      refsetIdxs = this._eclResolveSet(this._evalECLNode(hs.refsets, opContext), opContext);
+    } else if (hs.profile === 'MAX') {
+      const root = this.concepts.findConcept(HISTORICAL_ASSOCIATION);
+      refsetIdxs = root.found ? this._eclToIndexArray(this.filterIsA(HISTORICAL_ASSOCIATION, false)) : [];
+    } else {
+      refsetIdxs = PROFILES[hs.profile].map(id => this.concepts.findConcept(id)).filter(r => r.found).map(r => r.index);
+    }
+
+    const base = this._eclResolveSet(ctx, opContext);
+    const inResult = new Set(base);
+    const added = new Set();
+    for (const refsetIdx of refsetIdxs) {
+      if (opContext) opContext.deadCheck('ecl:history');
+      const byTarget = this._historyIndex(refsetIdx);
+      if (!byTarget) continue;
+      for (const [target, sources] of byTarget) {
+        if (inResult.has(target)) {
+          for (const src of sources) {
+            if (!inResult.has(src)) added.add(src);
+          }
+        }
+      }
+    }
+    const result = new SnomedFilterContext();
+    result.descendants = base.concat([...added]);
+    return result;
+  };
+
+  /**
+   * target concept index -> [referenced (inactive) concept indexes] for one
+   * association reference set, built once per edition. null when the concept
+   * is not a reference set with concept-valued members.
+   */
+  _historyIndex = function (refsetIdx) {
+    this._historyIndexes = this._historyIndexes || new Map();
+    if (this._historyIndexes.has(refsetIdx)) {
+      return this._historyIndexes.get(refsetIdx);
+    }
+    let index = null;
+    const refSet = this._findRefSetRecord(refsetIdx);
+    if (refSet && refSet.membersByRef && refSet.membersByRef !== 0xFFFFFFFF) {
+      for (const m of this.refSetMembers.getMembers(refSet.membersByRef) || []) {
+        if (m.kind !== 0 || !m.values) continue;
+        const values = this.refs.getReferences(m.values);
+        // targetComponentId is the first additional field, stored as (value, type) with type 1 = concept
+        if (!values || values.length < 2 || values[1] !== 1) continue;
+        index = index || new Map();
+        const list = index.get(values[0]) || [];
+        list.push(m.ref);
+        index.set(values[0], list);
+      }
+    }
+    this._historyIndexes.set(refsetIdx, index);
+    return index;
+  };
+
   /**
    * Apply {{ C ... }} concept filters to a result: each concept is tested on
    * its own active flag, module, effectiveTime and definition status. Several
@@ -1855,17 +2009,11 @@ class SnomedServices {
    * @returns {boolean}
    */
   _attributeMatches = function (rels, attr, groupFilter, opContext) {
-    if (attr.reverse) {
-      throw new Error('ECL reverse attributes (R) are not yet supported');
-    }
     if (!attr.comparison) {
       throw new Error('ECL attribute without a comparison is not supported');
     }
-    if (attr.comparison.type !== ECLNodeType.EXPRESSION_COMPARISON) {
-      throw new Error('ECL concrete values (numeric, string and boolean attribute values) are not supported - concrete value relationships are not loaded');
-    }
-    if (attr.comparison.operator !== ECLTokenType.EQUALS) {
-      throw new Error('ECL != in refinements is not yet supported');
+    if (attr.comparison.type !== ECLNodeType.EXPRESSION_COMPARISON && !this.concreteValues) {
+      throw new Error('ECL concrete values (numeric, string and boolean attribute values) cannot be evaluated - this edition was imported without its concrete value relationships');
     }
 
     const count = this._countAttributeMatches(rels, attr, groupFilter, opContext);
@@ -1895,15 +2043,30 @@ class SnomedServices {
     // fresh per request, so memoising on the node is safe within a request.
     let resolved = attr._eclResolved;
     if (!resolved) {
-      resolved = {
-        types: this._eclAttributeTypes(attr.name, opContext),
-        valueSet: new Set(this._eclResolveSet(this._evalECLNode(attr.comparison.value, opContext), opContext))
-      };
+      resolved = { types: this._eclAttributeTypes(attr.name, opContext) };
+      if (attr.comparison.type === ECLNodeType.EXPRESSION_COMPARISON) {
+        resolved.valueSet = new Set(this._eclResolveSet(this._evalECLNode(attr.comparison.value, opContext), opContext));
+      } else {
+        resolved.concrete = this._eclConcreteMatcher(attr.comparison);
+      }
       attr._eclResolved = resolved;
     }
     const types = resolved.types;
     const valueSet = resolved.valueSet;
 
+    if (resolved.concrete) {
+      // A concrete-value comparison: only the concrete rows count, each
+      // occurrence being a (group, value) pair
+      const matched = new Set();
+      for (const rel of rels) {
+        if (!rel.concrete) continue;
+        if (!types.any && !types.types.has(rel.relType)) continue;
+        if (groupFilter !== null && rel.group !== groupFilter) continue;
+        if (resolved.concrete(rel.concrete)) matched.add(rel.group + ':' + JSON.stringify(rel.concrete.value));
+      }
+      return matched.size;
+    }
+
     // ECL cardinality counts OCCURRENCES of a matching attribute, per role group
     // — not distinct values. ECL runs against the necessary normal form, where a
     // role group has no redundant attributes, so the same (type, value) in two
@@ -1912,13 +2075,26 @@ class SnomedServices {
     // form, not to de-duplicating across groups). We therefore count distinct
     // (group, target) pairs: within a group filter this is the matching values
     // in that group; ungrouped it is the total occurrences across all groups.
+    //
+    // "!=" counts the occurrences whose value is NOT in the set (so "A != X"
+    // matches a concept with at least one A whose value is something other than
+    // X, and "[0..0] A != X" one whose every A is X).
+    //
+    // A reversed attribute ("R A = X") is matched against the concept's INBOUND
+    // relationships: the concept is the value of an A attribute on some concept
+    // in X. _conceptRelRecords supplies those tagged `inbound`; the records built
+    // for a post-coordinated expression have none, so R matches nothing there.
+    const notEquals = attr.comparison.operator === ECLTokenType.NOT_EQUALS;
+    const reverse = !!attr.reverse;
     const matched = new Set();
     for (const rel of rels) {
       if (opContext) opContext.deadCheck('ecl:countAttributeMatches');
-      if (!rel.active) continue;
+      if (!rel.active || rel.concrete) continue;
+      if (!!rel.inbound !== reverse) continue;
       if (!types.any && !types.types.has(rel.relType)) continue;
       if (groupFilter !== null && rel.group !== groupFilter) continue;
-      if (valueSet.has(rel.target)) matched.add(rel.group + ':' + rel.target);
+      const value = reverse ? rel.source : rel.target;
+      if (valueSet.has(value) !== notEquals) matched.add(rel.group + ':' + value);
     }
     return matched.size;
   };
@@ -1983,12 +2159,58 @@ class SnomedServices {
   // target, group} — the shape the refinement matchers consume. Sharing this
   // shape lets the same matchers run against a post-coordinated expression's
   // relationships (see _expressionRelRecords).
+  /**
+   * A predicate over a stored concrete value for one comparison node:
+   *   numeric: = != < <= > >= against a number (integers and decimals compare as
+   *            numbers, so #5 = #5.0)
+   *   string:  = / != against typed search terms (match / wild semantics, as for
+   *            description terms), any of a set
+   *   boolean: = / != true/false
+   * A value of another kind never matches (and never "not-matches" either: a
+   * string attribute is not "!= #5").
+   */
+  _eclConcreteMatcher = function (comparison) {
+    switch (comparison.type) {
+      case ECLNodeType.NUMERIC_COMPARISON: {
+        const n = Number(comparison.value);
+        const op = { [ECLTokenType.EQUALS]: '=', [ECLTokenType.NOT_EQUALS]: '!=', [ECLTokenType.LT]: '<', [ECLTokenType.LTE]: '<=', [ECLTokenType.GT]: '>', [ECLTokenType.GTE]: '>=' }[comparison.operator] || comparison.operator;
+        return (v) => v.kind === 'number' && this._eclCompareValues(v.value, op, [n], (a, b) => a - b);
+      }
+      case ECLNodeType.STRING_COMPARISON: {
+        const matchers = comparison.values.map(t => this._eclTermMatcher(typeof t === 'string' ? { kind: 'match', value: t } : t));
+        const neg = comparison.operator === ECLTokenType.NOT_EQUALS;
+        return (v) => v.kind === 'string' && (matchers.some(m => m(v.value)) !== neg);
+      }
+      case ECLNodeType.BOOLEAN_COMPARISON: {
+        const neg = comparison.operator === ECLTokenType.NOT_EQUALS;
+        return (v) => v.kind === 'boolean' && ((v.value === comparison.value) !== neg);
+      }
+      default:
+        throw new Error(`Unsupported comparison ${comparison.type}`);
+    }
+  };
+
   _conceptRelRecords = function (conceptIdx) {
-    const relIdxs = this.getConceptRelationships(conceptIdx);
     const out = [];
-    for (const relIdx of relIdxs) {
+    for (const relIdx of this.getConceptRelationships(conceptIdx)) {
       out.push(this.relationships.getRelationship(relIdx));
     }
+    // concrete value rows, for numeric / string / boolean comparisons
+    if (this.concreteValues) {
+      for (const cv of this.concreteValues.get(conceptIdx) || []) {
+        out.push({ active: true, relType: cv.relType, group: cv.group, target: -1, concrete: cv.concrete });
+      }
+    }
+    // inbound relationships, for reversed (R) attributes
+    const concept = this.concepts.getConcept(conceptIdx);
+    if (concept.inbounds) {
+      for (const relIdx of this.refs.getReferences(concept.inbounds) || []) {
+        const rel = this.relationships.getRelationship(relIdx);
+        if (rel.active && rel.relType !== this.isAIndex) {
+          out.push({ ...rel, inbound: true });
+        }
+      }
+    }
     return out;
   };
 

package/tx/importers/import-sct.module.js

@@ -1139,6 +1139,9 @@ class SnomedImporter {
       // Step 10a: Read alternate identifiers (e.g. the LOINC codes of the LOINC Extension)
       await this.readIdentifiers();
 
+      // Step 10b: Read concrete value relationships (sct2_RelationshipConcreteValues)
+      await this.readConcreteValues();
+
       // Step 11: Link concepts
       this.linkConcepts();
 
@@ -1169,6 +1172,7 @@ class SnomedImporter {
       descriptions: [],
       relationships: [],
       identifiers: [],
+      concreteValues: [],
       refsetDirectories: []
     };
 
@@ -1224,6 +1228,8 @@ class SnomedImporter {
         files.relationships.push(filePath);
       } else if (files.identifiers && firstLine.startsWith('alternateIdentifier\teffectiveTime\tactive\tmoduleId\tidentifierSchemeId\treferencedComponentId')) {
         files.identifiers.push(filePath);
+      } else if (files.concreteValues && firstLine.startsWith('id\teffectiveTime\tactive\tmoduleId\tsourceId\tvalue\trelationshipGroup\ttypeId\tcharacteristicTypeId\tmodifierId')) {
+        files.concreteValues.push(filePath);
       }
     } catch (error) {
       console.log(`DEBUG: Error reading file ${filePath}: ${error.message}`);
@@ -1782,6 +1788,58 @@ class SnomedImporter {
     }
   }
 
+  /**
+   * Read the concrete value relationship files (sct2_RelationshipConcreteValues_*):
+   * the numeric and string attribute values of concepts (strength, count of base of
+   * active ingredient, ...). Kept as rows [sourceId, typeId, group, value] - the value
+   * as written in RF2 ("#500", "#5.5", "\"text\"", "true") - for the ECL evaluator;
+   * they are not relationships to concepts, so they do not join the relationship
+   * table. Only active, inferred rows; where a row appears more than once the latest
+   * effectiveTime wins.
+   */
+  async readConcreteValues() {
+    const rows = new Map(); // id -> {effectiveTime, active, row}
+    for (const file of this.files.concreteValues || []) {
+      const rl = readline.createInterface({
+        input: fs.createReadStream(file),
+        crlfDelay: Infinity
+      });
+      let lineCount = 0;
+      for await (const line of rl) {
+        lineCount++;
+        if (lineCount === 1 || !line) continue;
+        const parts = line.split('\t');
+        if (parts.length < 10) continue;
+        const [id, effectiveTime, active, , sourceId, value, group, typeId, characteristicTypeId] = parts.map(p => p.trim());
+        if (characteristicTypeId !== '900000000000011006') continue; // inferred only
+        const prior = rows.get(id);
+        if (!prior || prior.effectiveTime <= effectiveTime) {
+          rows.set(id, { effectiveTime, active: active === '1', row: [sourceId, typeId, parseInt(group, 10) || 0, value] });
+        }
+      }
+    }
+    this.concreteValues = [];
+    let missing = 0;
+    for (const r of rows.values()) {
+      if (!r.active) continue;
+      let known = false;
+      try {
+        known = this.conceptMap.has(BigInt(r.row[0])) && this.conceptMap.has(BigInt(r.row[1]));
+      } catch {
+        known = false;
+      }
+      if (known) {
+        this.concreteValues.push(r.row);
+      } else {
+        missing++;
+      }
+    }
+    this.concreteValues.sort((a, b) => (a.join('|') < b.join('|') ? -1 : 1));
+    if (this.concreteValues.length > 0 || missing > 0) {
+      console.log(`Concrete values: ${this.concreteValues.length}${missing ? ` (${missing} for concepts not in this edition, ignored)` : ''}`);
+    }
+  }
+
   async readRelationships() {
     // Estimate total lines
     let totalLines = 0;
@@ -2823,11 +2881,14 @@ class SnomedImporter {
     progressBar?.update(50);
 
     const identifiers = this.identifiers || [];
+    const concreteValues = this.concreteValues || [];
     await writer.writeCache({
-      // 18 = 17 plus the alternate identifiers. Only used when there are some, so that
-      // caches without them stay readable by servers that only know 17
-      version: identifiers.length > 0 ? '18' : '17',
+      // 17 = the base format; 18 = 17 plus the alternate identifiers; 19 = 18 plus
+      // the concrete value relationships. Each is only used when it has something
+      // to carry, so that caches without them stay readable by older servers.
+      version: concreteValues.length > 0 ? '19' : identifiers.length > 0 ? '18' : '17',
       identifiers: identifiers,
+      concreteValues: concreteValues,
       versionUri: this.isTesting ? this.config.uri.replace("/sct/", "/xsct/") : this.config.uri,
       versionDate: this.extractDateFromUri(this.config.uri),
 
@@ -2914,10 +2975,14 @@ class SnomedCacheWriter {
     }
     buffers.push(this.writeInteger(data.defaultLanguage));
 
-    if (data.version === '18') {
+    if (data.version === '18' || data.version === '19') {
       // alternate identifiers, as JSON: [[scheme, module, code, conceptId], ...]
       buffers.push(this.writeBytes(Buffer.from(JSON.stringify(data.identifiers || []), 'utf8')));
     }
+    if (data.version === '19') {
+      // concrete value relationships, as JSON: [[sourceId, typeId, group, value], ...]
+      buffers.push(this.writeBytes(Buffer.from(JSON.stringify(data.concreteValues || []), 'utf8')));
+    }
 
     // Write to file
     const finalBuffer = Buffer.concat(buffers);