fhirsmith 0.9.2 → 0.9.3

package/tx/cs/cs-snomed.js

@@ -13,6 +13,9 @@ const {DesignationUse} = require("../library/designations");
 const {BaseCSServices} = require("./cs-base");
 const {formatDateMMDDYYYY} = require("../../library/utilities");
 const {ConceptMap} = require("../library/conceptmap");
+const {ECLLexer, ECLParser, ECLNodeType, ECLTokenType} = require("../sct/ecl");
+const {Issue} = require("../library/operation-outcome");
+const {debugLog} = require("../operation-context");
 
 // Context kinds matching Pascal enum
 const SnomedProviderContextKind = {
@@ -57,15 +60,15 @@ class SnomedExpressionContext {
 
   getReference() {
     return this.expression && this.expression.concepts.length > 0
-      ? this.expression.concepts[0].reference
-      : NO_REFERENCE;
+        ? this.expression.concepts[0].reference
+        : NO_REFERENCE;
   }
 
   getCode() {
     if (this.source) return this.source;
     return this.expression && this.expression.concepts.length > 0
-      ? this.expression.concepts[0].code
-      : '';
+        ? this.expression.concepts[0].code
+        : '';
   }
 }
 
@@ -445,6 +448,561 @@ class SnomedServices {
 
   }
 
+  /**
+   * Supported ECL subset:
+   *   Plain concept ref      404684003
+   *   << (descendant-or-self-of)
+   *   <! (strict descendant-of)
+   *   <  (child-of)
+   *   >> (ancestor-or-self-of)
+   *   >! (strict ancestor-of)
+   *   >  (parent-of)
+   *   ^  (member-of refset)      — refset must be a plain concept ID
+   *   *  (wildcard)
+   *   AND / OR / MINUS compound expressions
+   *
+   * Everything else (refinements, dotted expressions, cardinality,
+   * reverse attributes, numeric/string comparisons) throws an informative error.
+   */
+
+  /**
+   * Parse an ECL expression string and return a SnomedFilterContext whose
+   * `descendants` array contains the resolved concept indexes.
+   *
+   * Throws an Error for syntax errors, unknown concepts, or unsupported features.
+   *
+   * @param {string} eclExpression
+   * @returns {SnomedFilterContext}
+   */
+  filterECL = function (eclExpression, forIteration, opContext) {
+    let ast;
+    try {
+      const tokens = new ECLLexer(eclExpression).tokenize();
+      ast = new ECLParser(tokens).parse();
+    } catch (err) {
+      debugLog(err);
+      throw new Issue('error', 'invalid', null, 'INVALID_ECL', opContext.i18n.translate('INVALID_ECL', opContext.langs, [eclExpression, err.message]), 'vs-invalid').handleAsOO(400);
+    }
+    let result;
+    try {
+      result = this._evalECLNode(ast);
+    } catch (err) {
+      debugLog(err);
+      throw new Issue('error', 'invalid', null, 'UNSUPPORTED_ECL', opContext.i18n.translate('UNSUPPORTED_ECL', opContext.langs, [eclExpression, err.message]), 'vs-invalid').handleAsOO(400);
+    }
+    // Wildcard + iteration: the `eclWildcard` flag is only consulted by the
+    // per-concept membership checks (filterCheck/filterLocate). For an $expand
+    // we actually need the full concept list, otherwise filterSize returns 0
+    // and the iteration yields nothing. Materialise active concepts now.
+    if (forIteration && result.eclWildcard && (!result.descendants || result.descendants.length === 0)) {
+      result.descendants = this._eclEnumerateActiveConcepts();
+      delete result.eclWildcard;
+    }
+    return result;
+  };
+
+  /**
+   * Return every active concept's index. Used to materialise wildcard results
+   * when the filter needs to be iterated over (e.g. $expand).
+   * @returns {number[]}
+   */
+  _eclEnumerateActiveConcepts = function () {
+    const all = [];
+    const n = this.concepts.count();
+    for (let i = 0; i < n; i++) {
+      const concept = this.concepts.getConceptByCount(i);
+      if ((concept.flags & 0x0F) === 0) { // active
+        all.push(concept.index);
+      }
+    }
+    return all;
+  };
+
+  /**
+   * Recursive ECL AST evaluator.
+   * @param {object} node
+   * @returns {SnomedFilterContext}
+   */
+  _evalECLNode = function (node) {
+    if (!node) {
+      throw new Error('ECL evaluation error: null AST node');
+    }
+
+    switch (node.type) {
+
+      case ECLNodeType.SUB_EXPRESSION_CONSTRAINT:
+        return this._evalSubExpression(node);
+
+      case ECLNodeType.COMPOUND_EXPRESSION_CONSTRAINT: {
+        const left = this._evalECLNode(node.left);
+        const right = this._evalECLNode(node.right);
+        switch (node.operator) {
+          case ECLNodeType.CONJUNCTION:
+            return this._eclIntersect(left, right);
+          case ECLNodeType.DISJUNCTION:
+            return this._eclUnion(left, right);
+          case ECLNodeType.EXCLUSION:
+            return this._eclMinus(left, right);
+          default:
+            throw new Error(`Unsupported ECL compound operator: ${node.operator}`);
+        }
+      }
+
+      case ECLNodeType.REFINED_EXPRESSION_CONSTRAINT:
+        return this._evalRefined(node);
+
+      case ECLNodeType.DOTTED_EXPRESSION_CONSTRAINT:
+        return this._evalDotted(node);
+
+      default:
+        // Could be a bare concept reference or wildcard passed in directly
+        // (e.g. when a parenthesised expression resolves to one of these).
+        if (node.type === ECLNodeType.CONCEPT_REFERENCE ||
+            node.type === ECLNodeType.WILDCARD ||
+            node.type === ECLNodeType.MEMBER_OF) {
+          // Wrap it as if it came from a no-operator SubExpressionConstraint
+          return this._evalSubExpression({type: ECLNodeType.SUB_EXPRESSION_CONSTRAINT, operator: null, focus: node});
+        }
+        throw new Error(`Unsupported ECL node type: ${node.type}`);
+    }
+  };
+
+  /**
+   * Evaluate a SUB_EXPRESSION_CONSTRAINT node, which combines an optional
+   * hierarchy operator with a focus (concept ref, wildcard, or member-of).
+   * @param {object} node
+   * @returns {SnomedFilterContext}
+   */
+  _evalSubExpression = function (node) {
+    const operator = node.operator; // an ECLTokenType string, or null
+    const focus = node.focus;
+
+    // Wildcard
+    if (focus.type === ECLNodeType.WILDCARD) {
+      if (operator) {
+        throw new Error('ECL hierarchy operators combined with wildcard (*) are not supported');
+      }
+      return this._eclWildcard();
+    }
+
+    // Member-of (^)
+    if (focus.type === ECLNodeType.MEMBER_OF) {
+      if (operator) {
+        throw new Error('ECL hierarchy operators combined with ^ (member-of) are not yet supported');
+      }
+      return this._evalMemberOf(focus);
+    }
+
+    // Plain concept reference
+    if (focus.type === ECLNodeType.CONCEPT_REFERENCE) {
+      return this._evalConceptWithOperator(focus.conceptId, operator);
+    }
+
+    // Parenthesised sub-expression: focus is itself a full constraint node
+    return this._evalECLNode(focus);
+  };
+
+  /**
+   * Resolve a concept ID + hierarchy operator.
+   * @param {string} conceptId
+   * @param {string|null} operator  ECLTokenType constant
+   * @returns {SnomedFilterContext}
+   */
+  _evalConceptWithOperator = function (conceptId, operator) {
+    switch (operator) {
+      case null:
+      case undefined:
+        return this.filterEquals(conceptId);
+
+        // ── Descendants ────────────────────────────────────────────────────────
+      case ECLTokenType.DESCENDANT_OR_SELF_OF: { // <<   self + all transitive descendants
+        return this.filterIsA(conceptId, true);
+      }
+
+      case ECLTokenType.DESCENDANT_OF: {         // <    all transitive descendants, no self
+        return this.filterIsA(conceptId, false);
+      }
+
+      case ECLTokenType.CHILD_OR_SELF_OF: {      // <<!  self + direct children only
+        const conceptResult = this.concepts.findConcept(conceptId);
+        if (!conceptResult.found) {
+          throw new Error(`The SNOMED CT Concept ${conceptId} is not known`);
+        }
+        const result = new SnomedFilterContext();
+        const children = this.getConceptChildren(conceptResult.index);
+        result.descendants = [conceptResult.index, ...children];
+        return result;
+      }
+
+      case ECLTokenType.CHILD_OF: {              // <!   direct children only
+        return this.filterChildOf(conceptId);
+      }
+
+        // ── Ancestors ──────────────────────────────────────────────────────────
+      case ECLTokenType.ANCESTOR_OR_SELF_OF: {   // >>   self + all transitive ancestors
+        const result = this.filterGeneralizes(conceptId);
+        const self = this.concepts.findConcept(conceptId);
+        if (self.found && !result.descendants.includes(self.index)) {
+          result.descendants.push(self.index);
+        }
+        return result;
+      }
+
+      case ECLTokenType.ANCESTOR_OF: {           // >    all transitive ancestors, no self
+        return this.filterGeneralizes(conceptId);
+      }
+
+      case ECLTokenType.PARENT_OR_SELF_OF: {     // >>!  self + direct parents only
+        const conceptResult = this.concepts.findConcept(conceptId);
+        if (!conceptResult.found) {
+          throw new Error(`The SNOMED CT Concept ${conceptId} is not known`);
+        }
+        const result = new SnomedFilterContext();
+        const parents = this.getConceptParents(conceptResult.index);
+        result.descendants = [conceptResult.index, ...parents];
+        return result;
+      }
+
+      case ECLTokenType.PARENT_OF: {             // >!   direct parents only
+        const conceptResult = this.concepts.findConcept(conceptId);
+        if (!conceptResult.found) {
+          throw new Error(`The SNOMED CT Concept ${conceptId} is not known`);
+        }
+        const result = new SnomedFilterContext();
+        result.descendants = this.getConceptParents(conceptResult.index);
+        return result;
+      }
+
+      default:
+        throw new Error(`Unsupported ECL hierarchy operator: ${operator}`);
+    }
+  };
+
+  /**
+   * Evaluate a MEMBER_OF node.  Only plain concept-reference refsets are
+   * supported; complex expressions inside ^ are not yet supported.
+   * @param {object} memberOfNode
+   * @returns {SnomedFilterContext}
+   */
+  _evalMemberOf = function (memberOfNode) {
+    const refSet = memberOfNode.refSet;
+    if (refSet.type !== ECLNodeType.CONCEPT_REFERENCE) {
+      throw new Error('ECL ^ (member-of) with a non-concept-reference refset is not yet supported');
+    }
+    // filterIn accepts a comma-separated string; a single ID works fine
+    return this.filterIn(refSet.conceptId);
+  };
+
+  /**
+   * Wildcard — all active concepts.  The eclWildcard flag tells filterCheck /
+   * filterLocate to accept every active concept without enumeration.
+   * @returns {SnomedFilterContext}
+   */
+  _eclWildcard = function () {
+    const result = new SnomedFilterContext();
+    result.eclWildcard = true;
+    return result;
+  };
+
+// ── Dotted expressions ───────────────────────────────────────────────────────
+
+  /**
+   * Evaluate a dotted expression: `<baseConstraint> . attrA . attrB`.
+   * For each chained attribute, replaces the current set with the set of
+   * active relationship targets whose `relType` matches the attribute.
+   * Only plain concept-reference attribute names are supported.
+   * @param {object} node
+   * @returns {SnomedFilterContext}
+   */
+  _evalDotted = function (node) {
+    let current = this._eclResolveSet(this._evalECLNode(node.base));
+
+    for (const attr of node.attributes || []) {
+      if (attr.type !== ECLNodeType.CONCEPT_REFERENCE) {
+        throw new Error('ECL dotted expressions only support plain concept-reference attribute names');
+      }
+      const attrResult = this.concepts.findConcept(attr.conceptId);
+      if (!attrResult.found) {
+        throw new Error(`The SNOMED CT Concept ${attr.conceptId} is not known`);
+      }
+      const attrTypeIdx = attrResult.index;
+
+      const next = new Set();
+      for (const conceptIdx of current) {
+        const relIdxs = this.getConceptRelationships(conceptIdx);
+        for (const relIdx of relIdxs) {
+          const rel = this.relationships.getRelationship(relIdx);
+          if (rel.active && rel.relType === attrTypeIdx) {
+            next.add(rel.target);
+          }
+        }
+      }
+      current = [...next];
+    }
+
+    const result = new SnomedFilterContext();
+    result.descendants = current;
+    return result;
+  };
+
+// ── Refinements ──────────────────────────────────────────────────────────────
+
+  /**
+   * Evaluate a refined expression: `<baseConstraint> : <refinement>`.
+   * Supported refinement shapes:
+   *   - ATTRIBUTE            attr = valueExpr
+   *   - ATTRIBUTE_SET        attr1 = v1, attr2 = v2 (conjunction)
+   *   - ATTRIBUTE_GROUP      { attr1 = v1, attr2 = v2 } (same relationship group)
+   * Reverse attributes, cardinality, `!=`, and non-concept attribute names
+   * throw informative errors.
+   * @param {object} node
+   * @returns {SnomedFilterContext}
+   */
+  _evalRefined = function (node) {
+    const baseSet = this._eclResolveSet(this._evalECLNode(node.base));
+    const matching = [];
+    for (const conceptIdx of baseSet) {
+      if (this._refinementMatches(conceptIdx, node.refinement)) {
+        matching.push(conceptIdx);
+      }
+    }
+    const result = new SnomedFilterContext();
+    result.descendants = matching;
+    return result;
+  };
+
+  /**
+   * Check whether a single concept satisfies a refinement node (ATTRIBUTE,
+   * ATTRIBUTE_SET, or ATTRIBUTE_GROUP).
+   * @param {number} conceptIdx
+   * @param {object} refinement
+   * @returns {boolean}
+   */
+  _refinementMatches = function (conceptIdx, refinement) {
+    switch (refinement.type) {
+      case ECLNodeType.ATTRIBUTE:
+        return this._attributeMatches(conceptIdx, refinement, null);
+      case ECLNodeType.ATTRIBUTE_SET:
+        for (const a of refinement.attributes) {
+          if (!this._refinementMatches(conceptIdx, a)) return false;
+        }
+        return true;
+      case ECLNodeType.ATTRIBUTE_GROUP:
+        return this._attributeGroupMatches(conceptIdx, refinement);
+      default:
+        throw new Error(`Unsupported refinement node type: ${refinement.type}`);
+    }
+  };
+
+  /**
+   * Check whether a concept has at least one active relationship whose
+   * `relType` matches the attribute name and whose `target` is in the value
+   * expression's result set. If `groupFilter` is not null, the relationship
+   * must also have that exact `group` number (used by group matching).
+   * @param {number} conceptIdx
+   * @param {object} attr
+   * @param {number|null} groupFilter
+   * @returns {boolean}
+   */
+  _attributeMatches = function (conceptIdx, attr, groupFilter) {
+    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 ${attr.comparison.type} in refinements is not yet supported`);
+    }
+    if (attr.comparison.operator !== ECLTokenType.EQUALS) {
+      throw new Error('ECL != in refinements is not yet supported');
+    }
+    if (attr.name.type !== ECLNodeType.CONCEPT_REFERENCE) {
+      throw new Error('ECL refinements only support plain concept-reference attribute names');
+    }
+
+    const count = this._countAttributeMatches(conceptIdx, attr, groupFilter);
+
+    if (attr.cardinality) {
+      return this._cardinalityAccepts(attr.cardinality, count);
+    }
+    return count >= 1;
+  };
+
+  /**
+   * Count the number of active relationships on the concept whose `relType`
+   * matches the attribute name and whose `target` is in the value expression's
+   * result set. Honours an optional group filter.
+   * @param {number} conceptIdx
+   * @param {object} attr
+   * @param {number|null} groupFilter
+   * @returns {number}
+   */
+  _countAttributeMatches = function (conceptIdx, attr, groupFilter) {
+    const attrResult = this.concepts.findConcept(attr.name.conceptId);
+    if (!attrResult.found) {
+      throw new Error(`The SNOMED CT Concept ${attr.name.conceptId} is not known`);
+    }
+    const attrTypeIdx = attrResult.index;
+
+    const valueSet = new Set(this._eclResolveSet(this._evalECLNode(attr.comparison.value)));
+
+    const relIdxs = this.getConceptRelationships(conceptIdx);
+    let count = 0;
+    for (const relIdx of relIdxs) {
+      const rel = this.relationships.getRelationship(relIdx);
+      if (!rel.active) continue;
+      if (rel.relType !== attrTypeIdx) continue;
+      if (groupFilter !== null && rel.group !== groupFilter) continue;
+      if (valueSet.has(rel.target)) count++;
+    }
+    return count;
+  };
+
+  /**
+   * Test a count against a parsed cardinality `{min, max}` where `max` is
+   * either an integer or the string `'*'` (unbounded).
+   * @param {{min: number, max: number|'*'}} cardinality
+   * @param {number} count
+   * @returns {boolean}
+   */
+  _cardinalityAccepts = function (cardinality, count) {
+    const { min, max } = cardinality;
+    if (min != null && count < min) return false;
+    if (max != null && max !== '*' && count > max) return false;
+    return true;
+  };
+
+  /**
+   * Check whether any single relationship group on the concept satisfies all
+   * attributes in an ATTRIBUTE_GROUP. Ungrouped relationships (group === 0)
+   * are not eligible — an attribute group must match within a real group.
+   *
+   * If the group itself carries cardinality (e.g. `[1..1] {…}`), the match
+   * requires the count of matching groups to fall within the specified range.
+   * @param {number} conceptIdx
+   * @param {object} group
+   * @returns {boolean}
+   */
+  _attributeGroupMatches = function (conceptIdx, group) {
+    const relIdxs = this.getConceptRelationships(conceptIdx);
+    const groupNumbers = new Set();
+    for (const relIdx of relIdxs) {
+      const rel = this.relationships.getRelationship(relIdx);
+      if (rel.active && rel.group > 0) {
+        groupNumbers.add(rel.group);
+      }
+    }
+
+    let matchingGroupCount = 0;
+    for (const g of groupNumbers) {
+      let allMatch = true;
+      for (const attr of group.attributes) {
+        if (!this._attributeMatches(conceptIdx, attr, g)) {
+          allMatch = false;
+          break;
+        }
+      }
+      if (allMatch) {
+        matchingGroupCount++;
+        // With no cardinality, short-circuit on the first matching group.
+        if (!group.cardinality) return true;
+      }
+    }
+
+    if (group.cardinality) {
+      return this._cardinalityAccepts(group.cardinality, matchingGroupCount);
+    }
+    return false;
+  };
+
+// ── Set operation helpers ────────────────────────────────────────────────────
+
+  /**
+   * Flatten a SnomedFilterContext to a plain array of concept indexes,
+   * handling the three different storage slots used by the existing filters.
+   * @param {SnomedFilterContext} ctx
+   * @returns {number[]}
+   */
+  _eclToIndexArray = function (ctx) {
+    if (ctx.descendants && ctx.descendants.length > 0) return ctx.descendants;
+    if (ctx.members && ctx.members.length > 0) return ctx.members.map(m => m.ref);
+    if (ctx.matches && ctx.matches.length > 0) return ctx.matches.map(m => m.index);
+    return [];
+  };
+
+  /**
+   * Like _eclToIndexArray, but if the context is a bare wildcard (no
+   * descendants populated) it materialises the full active-concept list
+   * via _eclEnumerateActiveConcepts. Used by dotted/refined evaluation,
+   * which need an explicit concept set to iterate over.
+   * @param {SnomedFilterContext} ctx
+   * @returns {number[]}
+   */
+  _eclResolveSet = function (ctx) {
+    if (ctx.eclWildcard && (!ctx.descendants || ctx.descendants.length === 0)) {
+      return this._eclEnumerateActiveConcepts();
+    }
+    return this._eclToIndexArray(ctx);
+  };
+
+  /**
+   * AND: concepts present in both sets.
+   */
+  _eclIntersect = function (left, right) {
+    if (left.eclWildcard) return right;
+    if (right.eclWildcard) return left;
+    const leftSet = new Set(this._eclToIndexArray(left));
+    const result = new SnomedFilterContext();
+    result.descendants = this._eclToIndexArray(right).filter(idx => leftSet.has(idx));
+    return result;
+  };
+
+  /**
+   * OR: concepts present in either set.
+   */
+  _eclUnion = function (left, right) {
+    if (left.eclWildcard || right.eclWildcard) return this._eclWildcard();
+    const combined = new Set([
+      ...this._eclToIndexArray(left),
+      ...this._eclToIndexArray(right)
+    ]);
+    const result = new SnomedFilterContext();
+    result.descendants = [...combined];
+    return result;
+  };
+
+  /**
+   * MINUS: concepts in left that are not in right.
+   */
+  _eclMinus = function (left, right) {
+    const result = new SnomedFilterContext();
+
+    if (right.eclWildcard) {
+      result.descendants = [];
+      return result;
+    }
+
+    const rightSet = new Set(this._eclToIndexArray(right));
+
+    if (left.eclWildcard) {
+      // Enumerate all active concepts minus the right set
+      const all = [];
+      for (let i = 0; i < this.concepts.count(); i++) {
+        const concept = this.concepts.getConceptByCount(i);
+        if (this.isActive(concept.index) && !rightSet.has(concept.index)) {
+          all.push(concept.index);
+        }
+      }
+      result.descendants = all;
+      return result;
+    }
+
+    result.descendants = this._eclToIndexArray(left).filter(idx => !rightSet.has(idx));
+    return result;
+  };
+
+
   searchFilter(searchText, includeInactive = false, exactMatch = false) {
     const result = new SnomedFilterContext();
 
@@ -575,7 +1133,7 @@ class SnomedProvider extends BaseCSServices {
 
   // Core concept methods
   async code(context) {
-    
+
     const ctxt = await this.#ensureContext(context);
 
     if (!ctxt) return null;
@@ -588,7 +1146,7 @@ class SnomedProvider extends BaseCSServices {
   }
 
   async display(context) {
-    
+
     const ctxt = await this.#ensureContext(context);
 
     if (!ctxt) return null;
@@ -615,7 +1173,7 @@ class SnomedProvider extends BaseCSServices {
   }
 
   async isInactive(context) {
-    
+
     const ctxt = await this.#ensureContext(context);
 
     if (!ctxt || ctxt.isComplex()) return false;
@@ -630,7 +1188,7 @@ class SnomedProvider extends BaseCSServices {
   }
 
   async getStatus(context) {
-    
+
     const ctxt = await this.#ensureContext(context);
 
     if (!ctxt || ctxt.isComplex()) return null;
@@ -639,7 +1197,7 @@ class SnomedProvider extends BaseCSServices {
   }
 
   async designations(context, displays) {
-    
+
     const ctxt = await this.#ensureContext(context);
 
     if (ctxt) {
@@ -752,7 +1310,7 @@ class SnomedProvider extends BaseCSServices {
   }
 
   async locateIsA(code, parent, disallowParent = false) {
-    
+
 
     const childId = this.sct.stringToIdOrZero(code);
     const parentId = this.sct.stringToIdOrZero(parent);
@@ -783,7 +1341,7 @@ class SnomedProvider extends BaseCSServices {
 
   // Iterator methods
   async iterator(context) {
-    
+
 
     if (!context) {
       // Iterate all active root concepts
@@ -891,7 +1449,7 @@ class SnomedProvider extends BaseCSServices {
     }
   }
 
-    // Filter support
+  // Filter support
   async doesFilter(prop, op, value) {
     if (prop === 'concept') {
       const id = this.sct.stringToIdOrZero(value);
@@ -918,6 +1476,9 @@ class SnomedProvider extends BaseCSServices {
       const id = this.sct.stringToIdOrZero(value);
       return id !== 0n && op === '=';
     }
+    if (prop === 'constraint') {
+      return op === '=';
+    }
 
     if (prop == 'expressions' && op == '=' && ['true', 'false'].includes(value)) {
       return true;
@@ -934,11 +1495,11 @@ class SnomedProvider extends BaseCSServices {
 
   // eslint-disable-next-line no-unused-vars
   async getPrepContext(iterate) {
-    
+
     return new SnomedPrep(); // Simple filter context
   }
 
-  async filter(filterContext, prop, op, value) {
+  async filter(filterContext, forIteration, prop, op, value) {
 
     if (prop === 'concept') {
       const id = this.sct.stringToIdOrZero(value);
@@ -991,6 +1552,11 @@ class SnomedProvider extends BaseCSServices {
       }
     }
 
+    if (prop === 'constraint' && op === '=') {
+      filterContext.filters.push(await this.sct.filterECL(value, forIteration, this.opContext));
+      return null;
+    }
+
     if (prop === 'moduleId') {
       const id = this.sct.stringToIdOrZero(value);
       if (id === 0n) {
@@ -1035,6 +1601,7 @@ class SnomedProvider extends BaseCSServices {
     throw new Error(`Unsupported filter property: ${prop}`);
   }
 
+
   async executeFilters(filterContext) {
     return filterContext.filters;
   }
@@ -1096,6 +1663,9 @@ class SnomedProvider extends BaseCSServices {
       return conceptResult.message;
     }
 
+    if (set.eclWildcard) {
+      return this.sct.isActive(reference) ? ctxt : null;
+    }
     const ctxt = conceptResult.context;
     const reference = ctxt.getReference();
     let found = false;
@@ -1168,7 +1738,9 @@ class SnomedProvider extends BaseCSServices {
     } else if (set.descendants && set.descendants.length > 0) {
       return set.descendants.includes(reference);
     }
-
+    if (set.eclWildcard) {
+      return this.sct.isActive(reference);
+    }
     return false;
   }
 
@@ -1218,7 +1790,7 @@ class SnomedProvider extends BaseCSServices {
 
   // Subsumption testing
   async subsumesTest(codeA, codeB) {
-    
+
 
     try {
       const exprA = new SnomedExpressionParser(this.sct.concepts).parse(codeA);
@@ -1287,7 +1859,7 @@ class SnomedProvider extends BaseCSServices {
 
   isDisplay(cd) {
     return cd.use.system === this.system() &&
-           (cd.use.code === '900000000000013009' || cd.use.code === '900000000000003001');
+        (cd.use.code === '900000000000013009' || cd.use.code === '900000000000003001');
   }
 
   async getTranslations(map, coding, target, reverse) {
@@ -1418,8 +1990,8 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
     }
 
     if (url.startsWith('http://snomed.info/sct?fhir_vs') ||
-      url.startsWith(`http://snomed.info/sct/${this.edition}?fhir_vs`) ||
-      url.startsWith(`http://snomed.info/sct/${this.edition}/version/${this.version}?fhir_vs`)) {
+        url.startsWith(`http://snomed.info/sct/${this.edition}?fhir_vs`) ||
+        url.startsWith(`http://snomed.info/sct/${this.edition}/version/${this.version}?fhir_vs`)) {
       id = url.substring(qIdx);
     } else {
       return null;
@@ -1564,9 +2136,12 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
     this.uses++;
   }
 
-
   name() {
-    return `SCT ${getEditionCode(this._sharedData.edition)}`;
+    if (this.version().includes("xsct")) {
+      return "SNOMED CT Test Set";
+    } else {
+      return `SCT ${getEditionCode(this._sharedData.edition)}`;
+    }
   }
 
   nameBase() {
@@ -1574,7 +2149,13 @@ class SnomedServicesFactory extends CodeSystemFactoryProvider {
   }
 
   id() {
-    const match = this.version().match(/^http:\/\/snomed\.info\/sct\/(\d+)(?:\/version\/(\d{8}))?$/);
+    let match = this.version().match(/^http:\/\/snomed\.info\/sct\/(\d+)(?:\/version\/(\d{8}))?$/);
+    if (!match) {
+      match = this.version().match(/^http:\/\/snomed\.info\/xsct\/(\d+)(?:\/version\/(\d{8}))?$/);
+      if (match) {
+        match = "x"+match;
+      }
+    }
     return match && match[1] && match[2] ? "SCT-"+match[1]+"-"+match[2] : null;
   }