fhirsmith 0.18.0 → 0.18.2

package/tx/cs/cs-snomed.js

@@ -31,6 +31,18 @@ const Logger = require("../../library/logger");
 // shared - it simply recomputes.
 const SNOMED_FILTER_ANALYSIS = Symbol('snomedFilterAnalysis');
 
+/**
+ * Alternate identifier schemes (sct2_Identifier) that FHIRsmith knows how to present:
+ * the code system the identifiers are codes in, and the $lookup property they are
+ * returned as. An identifier in an unknown scheme is kept but not reported.
+ */
+const IDENTIFIER_SCHEMES = {
+  '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 */
+const MAPPED_FILTER_PREFIX = 'mapped:';
+
 // Description language index -> language code. The index is assigned at import
 // time by SnomedImporter.mapLanguageCode(); this table is its inverse and must
 // be kept in step with it.
@@ -192,6 +204,80 @@ class SnomedServices {
     // means "could not decide", and leaves the value unchecked.
     this.expressionServices.eclConstraintMatcher = (constraint, value) => this.mrcmRangeSatisfied(constraint, value);
     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);
+    }
+  }
+
+  /**
+   * Index the alternate identifiers (sct2_Identifier rows, active only, as
+   * [scheme, module, code, conceptId]) both ways: concept -> identifiers, and
+   * scheme|code -> concepts. Also which modules carry identifiers, since each such
+   * module defines an implicit map (?fhir_cm=<module>).
+   */
+  #loadIdentifiers(rows) {
+    this.identifiersByConcept = new Map();
+    this.conceptsByIdentifier = new Map();
+    this.identifierModules = new Map(); // module -> Set of schemes
+    for (const [scheme, module, code, conceptId] of rows) {
+      const entry = { scheme, module, code };
+      if (!this.identifiersByConcept.has(conceptId)) {
+        this.identifiersByConcept.set(conceptId, []);
+      }
+      this.identifiersByConcept.get(conceptId).push(entry);
+      const key = scheme + '|' + code;
+      if (!this.conceptsByIdentifier.has(key)) {
+        this.conceptsByIdentifier.set(key, []);
+      }
+      this.conceptsByIdentifier.get(key).push(conceptId);
+      if (!this.identifierModules.has(module)) {
+        this.identifierModules.set(module, new Set());
+      }
+      this.identifierModules.get(module).add(scheme);
+    }
+  }
+
+  /** The alternate identifiers of a concept (by id), optionally only those of one scheme */
+  getIdentifiers(conceptId, scheme = null) {
+    const list = this.identifiersByConcept.get(String(conceptId)) || [];
+    return scheme ? list.filter(i => i.scheme === scheme) : list;
+  }
+
+  /** The concept ids that have the given code in the given scheme */
+  getConceptsForIdentifier(scheme, code) {
+    return this.conceptsByIdentifier.get(scheme + '|' + code) || [];
   }
 
   /**
@@ -859,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.
    */
 
@@ -1015,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');
@@ -1027,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
@@ -1107,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
@@ -1264,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) {
@@ -1281,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) {
@@ -1303,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
@@ -1802,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);
@@ -1842,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
@@ -1859,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;
   };
@@ -1930,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;
   };
 
@@ -2707,34 +2982,46 @@ class SnomedProvider extends BaseCSServices {
     const ctxt = await this.#ensureContext(context);
     if (ctxt) {
       if (!(ctxt instanceof SnomedExpressionContext) || ctxt.expression?.concepts.length == 1) {
-        const time = this.sct.concepts.getConcept(ctxt.getReference()).effectiveTime;
-        // Pascal TDateTime epoch (1899-12-30) computed in UTC so the formatted
-        // date is timezone-independent. new Date(1899,11,30) is LOCAL midnight,
-        // which in zones ahead of UTC rolls the ISO date back by one day.
-        const pascalEpochUTC = Date.UTC(1899, 11, 30);
-        const date = new Date(pascalEpochUTC + time * 86400000);
-        const dateStr = date.toISOString().slice(0, 10);
-        this._addDateTimeProperty(params, 'property', 'effectiveTime', dateStr);
-
+        // Only what was asked for, if anything was (see _hasProp): effectiveTime, module,
+        // parent, child and the defining relationships are returned by default but are not
+        // important enough to return when the client named the properties it wants.
+        // The mappings (alternate identifiers such as the LOINC code) are returned by
+        // default too, and when asked for by name.
+        if (this._hasProp(props, 'effectiveTime', true)) {
+          const time = this.sct.concepts.getConcept(ctxt.getReference()).effectiveTime;
+          // Pascal TDateTime epoch (1899-12-30) computed in UTC so the formatted
+          // date is timezone-independent. new Date(1899,11,30) is LOCAL midnight,
+          // which in zones ahead of UTC rolls the ISO date back by one day.
+          const pascalEpochUTC = Date.UTC(1899, 11, 30);
+          const date = new Date(pascalEpochUTC + time * 86400000);
+          const dateStr = date.toISOString().slice(0, 10);
+          this._addDateTimeProperty(params, 'property', 'effectiveTime', dateStr);
+        }
 
-        const parents = this.sct.getConceptParents(ctxt.getReference());
-        for (let parentRef of parents) {
-          const code = this.sct.getConceptId(parentRef);
-          const description = this.sct.getDisplayName(parentRef);
-          this._addCodeProperty(params, 'property', 'parent', code, null, description);
+        if (this._hasProp(props, 'parent', true)) {
+          const parents = this.sct.getConceptParents(ctxt.getReference());
+          for (let parentRef of parents) {
+            const code = this.sct.getConceptId(parentRef);
+            const description = this.sct.getDisplayName(parentRef);
+            this._addCodeProperty(params, 'property', 'parent', code, null, description);
+          }
         }
 
-        const children = this.sct.getConceptChildren(ctxt.getReference());
-        for (let childRef of children) {
-          const code = this.sct.getConceptId(childRef);
-          const description = this.sct.getDisplayName(childRef);
-          this._addCodeProperty(params, 'property', 'child', code, null, description);
+        if (this._hasProp(props, 'child', true)) {
+          const children = this.sct.getConceptChildren(ctxt.getReference());
+          for (let childRef of children) {
+            const code = this.sct.getConceptId(childRef);
+            const description = this.sct.getDisplayName(childRef);
+            this._addCodeProperty(params, 'property', 'child', code, null, description);
+          }
         }
 
-        const moduleId = this.sct.concepts.getModuleId(ctxt.getReference());
-        if (moduleId) {
-          const code = this.sct.getConceptId(moduleId);
-          this._addCodeProperty(params, 'property', 'module', code, null, this.sct.getDisplayName(moduleId));
+        if (this._hasProp(props, 'module', true)) {
+          const moduleId = this.sct.concepts.getModuleId(ctxt.getReference());
+          if (moduleId) {
+            const code = this.sct.getConceptId(moduleId);
+            this._addCodeProperty(params, 'property', 'module', code, null, this.sct.getDisplayName(moduleId));
+          }
         }
 
         const relationships = this.sct.getConceptRelationships(ctxt.getReference());
@@ -2742,7 +3029,7 @@ class SnomedProvider extends BaseCSServices {
         for (let relationshipRef of relationships) {
           const relationship = this.sct.relationships.getRelationship(relationshipRef);
           const relType = this.sct.getConceptId(relationship.relType);
-          if (relType != '116680003') {
+          if (relType != '116680003' && this._hasProp(props, relType, true)) {
             const relTypeD = this.sct.getDisplayName(relationship.relType);
             const code = this.sct.getConceptId(relationship.target);
             const description = this.sct.getDisplayName(relationship.target);
@@ -2753,6 +3040,8 @@ class SnomedProvider extends BaseCSServices {
             }
           }
         }
+
+        this.#addMappingProperties(ctxt, props, params);
       }
       if (ctxt instanceof SnomedExpressionContext) {
         // ignore concepts for now, but list refinements and refinement groups
@@ -2768,6 +3057,27 @@ class SnomedProvider extends BaseCSServices {
     }
   }
 
+  /**
+   * The concept's alternate identifiers in the schemes we know (IDENTIFIER_SCHEMES), as
+   * Coding-valued properties named for the scheme - e.g. loinc = http://loinc.org#2160-0.
+   * Returned by default, and when asked for by name.
+   */
+  #addMappingProperties(ctxt, props, params) {
+    const conceptId = this.sct.getConceptId(ctxt.getReference());
+    for (const ident of this.sct.getIdentifiers(conceptId)) {
+      const scheme = IDENTIFIER_SCHEMES[ident.scheme];
+      if (scheme && this._hasProp(props, scheme.property, true)) {
+        params.push({
+          name: 'property',
+          part: [
+            { name: 'code', valueCode: scheme.property },
+            { name: 'value', valueCoding: { system: scheme.system, code: ident.code } }
+          ]
+        });
+      }
+    }
+  }
+
   /**
    * Report one refinement of a post-coordinated expression as a lookup property.
    *
@@ -2823,6 +3133,11 @@ class SnomedProvider extends BaseCSServices {
       return true;
     }
 
+    if (prop.startsWith(MAPPED_FILTER_PREFIX)) {
+      return op === 'exists' && ['true', 'false'].includes(value) &&
+        this.sct.stringToIdOrZero(prop.substring(MAPPED_FILTER_PREFIX.length)) !== 0n;
+    }
+
     const cid = this.sct.stringToIdOrZero(prop);
     if (cid != 0) {
       const id = this.sct.stringToIdOrZero(value);
@@ -2979,6 +3294,27 @@ class SnomedProvider extends BaseCSServices {
       return null;
     }
 
+    // mapped:<identifier scheme> exists true|false - concepts that do (or don't) have an
+    // alternate identifier in that scheme (e.g. mapped:30051010000102: has a LOINC code).
+    // A prefix, so as not to be confused with the attribute filters (<attribute> = <value>)
+    if (prop.startsWith(MAPPED_FILTER_PREFIX)) {
+      const scheme = prop.substring(MAPPED_FILTER_PREFIX.length);
+      if (this.sct.stringToIdOrZero(scheme) === 0n) {
+        throw new Error(`Invalid identifier scheme: ${scheme}`);
+      }
+      if (op !== 'exists') {
+        throw new Error(`Unsupported filter operation: ${prop} ${op} ${value}`);
+      }
+      if (value !== 'true' && value !== 'false') {
+        throw new Error(`Invalid filter value: ${value}`);
+      }
+      const filter = new SnomedFilterContext();
+      filter.mappedScheme = scheme;
+      filter.mappedExists = value === 'true';
+      filterContext.filters.push(filter);
+      return null;
+    }
+
     const cid = this.sct.stringToIdOrZero(prop);
     if (cid != 0) {
 
@@ -3082,7 +3418,9 @@ class SnomedProvider extends BaseCSServices {
     }
     let found = false;
 
-    if (set.inactive !== undefined) {
+    if (set.mappedScheme !== undefined) {
+      found = this.#isMapped(reference, set.mappedScheme) === set.mappedExists;
+    } else if (set.inactive !== undefined) {
       let concept = this.sct.concepts.getConcept(reference);
       let active = (concept.flags & 0x0F) === 0;
       found = active !== set.inactive
@@ -3128,6 +3466,9 @@ class SnomedProvider extends BaseCSServices {
     }
 
     const reference = concept.getReference();
+    if (set.mappedScheme !== undefined) {
+      return this.#isMapped(reference, set.mappedScheme) === set.mappedExists;
+    }
     if (set.inactive !== undefined) {
       return this.sct.isActive(reference) !== set.inactive;
     }
@@ -3187,10 +3528,39 @@ class SnomedProvider extends BaseCSServices {
     return set._matchSet.has(reference);
   }
 
+  /** Whether the concept (by reference) has an alternate identifier in the scheme */
+  #isMapped(reference, scheme) {
+    return this.sct.getIdentifiers(this.sct.getConceptId(reference), scheme).length > 0;
+  }
+
   #ensurePopulated(set) {
     if (set.populationDone) {
       return;
     }
+    if (set.mappedScheme !== undefined) {
+      if (set.mappedExists) {
+        // straight from the identifier index, in concept order
+        const refs = new Set();
+        for (const [conceptId, idents] of this.sct.identifiersByConcept) {
+          if (idents.some(i => i.scheme === set.mappedScheme)) {
+            const r = this.sct.concepts.findConcept(BigInt(conceptId));
+            if (r.found) {
+              refs.add(r.index);
+            }
+          }
+        }
+        set.descendants = [...refs].sort((a, b) => a - b);
+      } else {
+        for (let i = 0; i < this.sct.concepts.count(); i++) {
+          const concept = this.sct.concepts.getConceptByCount(i);
+          if (!this.#isMapped(concept.index, set.mappedScheme)) {
+            set.descendants.push(concept.index);
+          }
+        }
+      }
+      set.populationDone = true;
+      return;
+    }
     if (set.inactive !== undefined && set.descendants.length === 0) {
       for (let i = 0; i < this.sct.concepts.count(); i++) {
         let concept = this.sct.concepts.getConceptByCount(i);
@@ -3342,6 +3712,9 @@ class SnomedProvider extends BaseCSServices {
   }
 
   async getTranslations(map, coding, target, reverse) {
+    if (map && map.jsonObj.identifierMap) {
+      return this.translateByIdentifier(map, coding, target);
+    }
     if (!map || reverse) {
       return [];
     }
@@ -3405,6 +3778,54 @@ class SnomedProvider extends BaseCSServices {
     return result;
   }
 
+  /**
+   * Translate using a module's alternate identifiers (the implicit map ?fhir_cm=<module>,
+   * e.g. the LOINC Extension's LOINC codes). The identifiers say the concept and the code
+   * are the same thing, so the map works the same in both directions: a SNOMED CT concept
+   * translates to its codes, and a code in the identifier's system to its concepts. Either
+   * way the relationship is equivalent.
+   */
+  async translateByIdentifier(map, coding, target) {
+    const { schemes } = map.jsonObj.identifierMap;
+    const targetSystem = target ? target.split('|')[0] : null;
+    const result = [];
+    if (coding.system === this.system()) {
+      const ctxt = await this.locate(coding.code);
+      if (!ctxt.context) {
+        return [];
+      }
+      const conceptId = this.sct.getConceptId(ctxt.context.getReference());
+      for (const ident of this.sct.getIdentifiers(conceptId)) {
+        const scheme = IDENTIFIER_SCHEMES[ident.scheme];
+        if (scheme && schemes.includes(ident.scheme) && (!targetSystem || targetSystem === scheme.system)) {
+          result.push({
+            map: map.vurl,
+            system: scheme.system,
+            code: ident.code,
+            relationship: 'equivalent'
+          });
+        }
+      }
+    } else if (!targetSystem || targetSystem === this.system()) {
+      for (const schemeId of schemes) {
+        const scheme = IDENTIFIER_SCHEMES[schemeId];
+        if (scheme && scheme.system === coding.system) {
+          for (const conceptId of this.sct.getConceptsForIdentifier(schemeId, coding.code)) {
+            result.push({
+              map: map.vurl,
+              system: this.system(),
+              version: this.version(),
+              code: conceptId,
+              display: await this.display(conceptId),
+              relationship: 'equivalent'
+            });
+          }
+        }
+      }
+    }
+    return result;
+  }
+
   /**
    * Translate a concept of this edition to the edition it depends on (typically a national
    * extension to the International Edition). There is no map: the answer comes from the
@@ -3789,6 +4210,9 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
    * edition URI plus ?fhir_cm=edition/<target edition module>
    */
   async findImplicitConceptMaps(conceptMaps, source, sourceVersion, dest) {
+    if (dest) {
+      this.#findIdentifierMaps(conceptMaps, source, sourceVersion, dest);
+    }
     if (source !== this.system() || !sourceVersion || !dest || !this.isMyEdition(sourceVersion)) {
       return;
     }
@@ -3823,6 +4247,61 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
     });
   }
 
+  /**
+   * Maps implied by alternate identifiers, found from the systems rather than nominated:
+   * from this edition (source system|version naming it) to an identifier system (LOINC,
+   * say), or from an identifier system to this edition (the target given as
+   * system|edition URI, with or without the version)
+   */
+  #findIdentifierMaps(conceptMaps, source, sourceVersion, dest) {
+    const bar = dest.indexOf('|');
+    const destSystem = bar === -1 ? dest : dest.substring(0, bar);
+    const destVersion = bar === -1 ? null : dest.substring(bar + 1);
+    let identSystem;
+    if (source === this.system() && sourceVersion && this.isMyEdition(sourceVersion)) {
+      identSystem = destSystem;
+    } else if (destSystem === this.system() && destVersion && this.isMyEdition(destVersion)) {
+      identSystem = source;
+    } else {
+      return;
+    }
+    for (const [moduleId, schemes] of this.snomedServices.identifierModules) {
+      if ([...schemes].some(s => IDENTIFIER_SCHEMES[s] && IDENTIFIER_SCHEMES[s].system === identSystem)) {
+        const cm = this.identifierMap(moduleId);
+        if (cm && !conceptMaps.some(m => m.url === cm.url)) {
+          conceptMaps.push(cm);
+        }
+      }
+    }
+  }
+
+  /**
+   * The implicit map defined by a module's alternate identifiers, if the module has any
+   * in a scheme we know. Its url follows the edition maps: <source edition>/version/<date>?fhir_cm=<module>
+   */
+  identifierMap(moduleId) {
+    const schemes = [...(this.snomedServices.identifierModules.get(moduleId) || [])].filter(s => IDENTIFIER_SCHEMES[s]);
+    if (schemes.length === 0) {
+      return null;
+    }
+    const systems = schemes.map(s => IDENTIFIER_SCHEMES[s].system);
+    const moduleName = this.snomedServices.conceptExists(moduleId)
+      ? this.snomedServices.getDisplayName(this.snomedServices.concepts.findConcept(BigInt(moduleId)).index) : moduleId;
+    return new ConceptMap({
+      resourceType: 'ConceptMap',
+      internalSource: this,
+      identifierMap: { module: moduleId, schemes: schemes },
+      url: `${this.version()}?fhir_cm=${moduleId}`,
+      name: `SNOMED CT ${moduleName} Concept Map`,
+      description: `The concept map implied by the alternate identifiers (${systems.join(', ')}) of the module ${moduleId} |${moduleName}| in ${this.version()}`,
+      status: 'active',
+      group: [
+        ...systems.map(s => ({ source: this.system(), target: s })),
+        ...systems.map(s => ({ source: s, target: this.system() }))
+      ]
+    });
+  }
+
   /** Whether a source version names this edition: exactly, or the edition without a version */
   isMyEdition(version) {
     const mine = this.version();
@@ -3846,6 +4325,16 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
       const dep = this.snomedServices.editionDependency(`http://snomed.info/sct/${url.substring(q + '?fhir_cm=edition/'.length)}`);
       return dep ? this.editionTranslationMap(dep) : null;
     }
+    // <edition[/version/date]>?fhir_cm=<module>: the map implied by a module's alternate
+    // identifiers (e.g. 11010000107, the LOINC Extension's LOINC codes)
+    const qm = url.indexOf('?fhir_cm=');
+    if (qm !== -1 && url.substring(0, qm) !== this.system()) {
+      if (!this.isMyEdition(url.substring(0, qm))) {
+        return null;
+      }
+      await this.#ensureLoaded();
+      return this.identifierMap(url.substring(qm + '?fhir_cm='.length));
+    }
     if (!url.startsWith(this.system()+"?fhir_cm=")) {
       return null;
     }