fhirsmith 0.9.2 → 0.9.3

package/tx/cs/cs-ucum.js

@@ -256,7 +256,7 @@ class UcumCodeSystemProvider extends BaseCSServices {
     // filterContext.filters.push(ucumFilter);
   }
 
-  async filter(filterContext, prop, op, value) {
+  async filter(filterContext, forIteration, prop, op, value) {
     assert(filterContext && filterContext instanceof FilterExecutionContext, 'filterContext must be a FilterExecutionContext');
     assert(prop != null && typeof prop === 'string', 'prop must be a non-null string');
     assert(op != null && typeof op === 'string', 'op must be a non-null string');

package/tx/sct/ecl.js

@@ -7,8 +7,6 @@
  * Supports ECL v2.1 specification from SNOMED International
  */
 
-const { SnomedFilterContext } = require('../cs/cs-snomed');
-
 // ECL Token Types
 const ECLTokenType = {
   // Literals
@@ -18,15 +16,15 @@ const ECLTokenType = {
   INTEGER: 'INTEGER',
   DECIMAL: 'DECIMAL',
 
-  // Operators
-  CHILD_OF: 'CHILD_OF',                    // <
-  CHILD_OR_SELF_OF: 'CHILD_OR_SELF_OF',   // <<
-  DESCENDANT_OF: 'DESCENDANT_OF',         // <!
-  DESCENDANT_OR_SELF_OF: 'DESCENDANT_OR_SELF_OF', // <<!
-  PARENT_OF: 'PARENT_OF',                 // >
-  PARENT_OR_SELF_OF: 'PARENT_OR_SELF_OF', // >>
-  ANCESTOR_OF: 'ANCESTOR_OF',             // >!
-  ANCESTOR_OR_SELF_OF: 'ANCESTOR_OR_SELF_OF', // >>!
+  // Operators (ECL 2.x spec)
+  CHILD_OF: 'CHILD_OF',                    // <!   direct children only
+  CHILD_OR_SELF_OF: 'CHILD_OR_SELF_OF',   // <<!  self + direct children
+  DESCENDANT_OF: 'DESCENDANT_OF',         // <    all transitive descendants, no self
+  DESCENDANT_OR_SELF_OF: 'DESCENDANT_OR_SELF_OF', // <<   self + all transitive descendants
+  PARENT_OF: 'PARENT_OF',                 // >!   direct parents only
+  PARENT_OR_SELF_OF: 'PARENT_OR_SELF_OF', // >>!  self + direct parents
+  ANCESTOR_OF: 'ANCESTOR_OF',             // >    all transitive ancestors, no self
+  ANCESTOR_OR_SELF_OF: 'ANCESTOR_OR_SELF_OF', // >>   self + all transitive ancestors
 
   // Set operators
   AND: 'AND',
@@ -268,29 +266,38 @@ class ECLLexer {
       }
 
       // Multi-character operators
+      // ECL 2.x hierarchy operators:
+      //   <    descendantOf         (transitive, no self)
+      //   <<   descendantOrSelfOf   (transitive, with self)
+      //   <!   childOf              (one step)
+      //   <<!  childOrSelfOf        (one step + self)
+      //   >    ancestorOf           (transitive, no self)
+      //   >>   ancestorOrSelfOf     (transitive, with self)
+      //   >!   parentOf             (one step)
+      //   >>!  parentOrSelfOf       (one step + self)
       if (this.current === '<') {
         if (this.peek() === '<') {
           if (this.peek(2) === '!') {
             this.advance();
             this.advance();
             this.advance();
-            return { type: ECLTokenType.DESCENDANT_OR_SELF_OF, value: '<<!', };
+            return { type: ECLTokenType.CHILD_OR_SELF_OF, value: '<<!' };
           } else {
             this.advance();
             this.advance();
-            return { type: ECLTokenType.CHILD_OR_SELF_OF, value: '<<' };
+            return { type: ECLTokenType.DESCENDANT_OR_SELF_OF, value: '<<' };
           }
         } else if (this.peek() === '!') {
           this.advance();
           this.advance();
-          return { type: ECLTokenType.DESCENDANT_OF, value: '<!' };
+          return { type: ECLTokenType.CHILD_OF, value: '<!' };
         } else if (this.peek() === '=') {
           this.advance();
           this.advance();
           return { type: ECLTokenType.LTE, value: '<=' };
         } else {
           this.advance();
-          return { type: ECLTokenType.CHILD_OF, value: '<' };
+          return { type: ECLTokenType.DESCENDANT_OF, value: '<' };
         }
       }
 
@@ -300,23 +307,23 @@ class ECLLexer {
             this.advance();
             this.advance();
             this.advance();
-            return { type: ECLTokenType.ANCESTOR_OR_SELF_OF, value: '>>!' };
+            return { type: ECLTokenType.PARENT_OR_SELF_OF, value: '>>!' };
           } else {
             this.advance();
             this.advance();
-            return { type: ECLTokenType.PARENT_OR_SELF_OF, value: '>>' };
+            return { type: ECLTokenType.ANCESTOR_OR_SELF_OF, value: '>>' };
           }
         } else if (this.peek() === '!') {
           this.advance();
           this.advance();
-          return { type: ECLTokenType.ANCESTOR_OF, value: '>!' };
+          return { type: ECLTokenType.PARENT_OF, value: '>!' };
         } else if (this.peek() === '=') {
           this.advance();
           this.advance();
           return { type: ECLTokenType.GTE, value: '>=' };
         } else {
           this.advance();
-          return { type: ECLTokenType.PARENT_OF, value: '>' };
+          return { type: ECLTokenType.ANCESTOR_OF, value: '>' };
         }
       }
 
@@ -350,9 +357,9 @@ class ECLLexer {
 
         // Check if immediately followed by .digit (decimal number)
         if (pos < this.input.length &&
-          this.input[pos] === '.' &&
-          pos + 1 < this.input.length &&
-          /\d/.test(this.input[pos + 1])) {
+            this.input[pos] === '.' &&
+            pos + 1 < this.input.length &&
+            /\d/.test(this.input[pos + 1])) {
           // This is a decimal number - parse it completely
           const num = this.readNumber();
           return { type: num.type, value: num.value };
@@ -471,8 +478,8 @@ class ECLParser {
       const right = this.parseRefinedExpressionConstraint();
 
       const nodeType = operator.type === ECLTokenType.AND ? ECLNodeType.CONJUNCTION :
-        operator.type === ECLTokenType.OR ? ECLNodeType.DISJUNCTION :
-          ECLNodeType.EXCLUSION;
+          operator.type === ECLTokenType.OR ? ECLNodeType.DISJUNCTION :
+              ECLNodeType.EXCLUSION;
 
       left = {
         type: ECLNodeType.COMPOUND_EXPRESSION_CONSTRAINT,
@@ -527,10 +534,10 @@ class ECLParser {
     // Handle constraint operators
     let operator = null;
     if (this.match(
-      ECLTokenType.CHILD_OF, ECLTokenType.CHILD_OR_SELF_OF,
-      ECLTokenType.DESCENDANT_OF, ECLTokenType.DESCENDANT_OR_SELF_OF,
-      ECLTokenType.PARENT_OF, ECLTokenType.PARENT_OR_SELF_OF,
-      ECLTokenType.ANCESTOR_OF, ECLTokenType.ANCESTOR_OR_SELF_OF
+        ECLTokenType.CHILD_OF, ECLTokenType.CHILD_OR_SELF_OF,
+        ECLTokenType.DESCENDANT_OF, ECLTokenType.DESCENDANT_OR_SELF_OF,
+        ECLTokenType.PARENT_OF, ECLTokenType.PARENT_OR_SELF_OF,
+        ECLTokenType.ANCESTOR_OF, ECLTokenType.ANCESTOR_OR_SELF_OF
     )) {
       operator = this.current;
       this.advance();
@@ -681,8 +688,11 @@ class ECLParser {
         operator: operator.type,
         value
       };
-    } else if (this.match(ECLTokenType.LT, ECLTokenType.LTE, ECLTokenType.CHILD_OF, ECLTokenType.PARENT_OF, ECLTokenType.GTE)) {
-      // Note: CHILD_OF (<) is treated as LT and PARENT_OF (>) is treated as GT in numeric comparison context
+    } else if (this.match(ECLTokenType.LT, ECLTokenType.LTE, ECLTokenType.DESCENDANT_OF, ECLTokenType.ANCESTOR_OF, ECLTokenType.GTE)) {
+      // In ECL, bare `<` and `>` are overloaded: they lex as hierarchy
+      // operators (DESCENDANT_OF / ANCESTOR_OF) but in an attribute comparison
+      // context they mean less-than / greater-than. Accept them here and map
+      // them to LT / GT so downstream consumers see a uniform shape.
       const operator = this.current;
       this.advance();
 
@@ -697,11 +707,11 @@ class ECLParser {
         this.error('Expected numeric value after #');
       }
 
-      // Map CHILD_OF to LT and PARENT_OF to GT for numeric comparisons
+      // Map DESCENDANT_OF to LT and ANCESTOR_OF to GT for numeric comparisons
       let operatorType = operator.type;
-      if (operator.type === ECLTokenType.CHILD_OF) {
+      if (operator.type === ECLTokenType.DESCENDANT_OF) {
         operatorType = ECLTokenType.LT;
-      } else if (operator.type === ECLTokenType.PARENT_OF) {
+      } else if (operator.type === ECLTokenType.ANCESTOR_OF) {
         operatorType = ECLTokenType.GT;
       }
 
@@ -1030,6 +1040,8 @@ class ECLValidator {
   }
 
   async evaluateWildcard() {
+    const { SnomedFilterContext } = require('../cs/cs-snomed');
+
     // Return all concepts - this would need optimization in practice
     const filter = new SnomedFilterContext();
     const allConcepts = [];
@@ -1046,49 +1058,86 @@ class ECLValidator {
   }
 
   async evaluateSubExpressionConstraint(node) {
+    const { SnomedFilterContext } = require('../cs/cs-snomed');
+
     const baseFilter = await this.evaluateAST(node.focus);
 
     if (!node.operator) {
       return baseFilter;
     }
 
-    // Apply constraint operator
-    const results = new SnomedFilterContext();
+    // Apply constraint operator — collect into a Set to deduplicate across
+    // multi-concept base filters.
+    const accumulated = new Set();
 
     for (const conceptIndex of baseFilter.descendants || []) {
       const conceptId = this.sct.concepts.getConceptId(conceptIndex);
 
       let operatorFilter;
       switch (node.operator) {
-        case ECLTokenType.CHILD_OF:
+          // ── Descendants ─────────────────────────────────────────────────────
+        case ECLTokenType.DESCENDANT_OF:           // <    transitive, no self
           operatorFilter = this.sct.filterIsA(conceptId, false);
           break;
-        case ECLTokenType.CHILD_OR_SELF_OF:
+        case ECLTokenType.DESCENDANT_OR_SELF_OF:   // <<   transitive + self
           operatorFilter = this.sct.filterIsA(conceptId, true);
           break;
-        case ECLTokenType.DESCENDANT_OF:
-          operatorFilter = this.sct.filterIsA(conceptId, false);
+        case ECLTokenType.CHILD_OF:                // <!   direct children only
+          operatorFilter = this.sct.filterChildOf(conceptId);
           break;
-        case ECLTokenType.DESCENDANT_OR_SELF_OF:
-          operatorFilter = this.sct.filterIsA(conceptId, true);
+        case ECLTokenType.CHILD_OR_SELF_OF: {      // <<!  self + direct children
+          operatorFilter = new SnomedFilterContext();
+          const selfResult = this.sct.concepts.findConcept(conceptId);
+          const children = selfResult.found ? this.sct.getConceptChildren(selfResult.index) : [];
+          operatorFilter.descendants = selfResult.found ? [selfResult.index, ...children] : children;
+          break;
+        }
+
+          // ── Ancestors ───────────────────────────────────────────────────────
+        case ECLTokenType.ANCESTOR_OF:             // >    transitive, no self
+          operatorFilter = this.sct.filterGeneralizes(conceptId);
+          break;
+        case ECLTokenType.ANCESTOR_OR_SELF_OF: {   // >>   transitive + self
+          operatorFilter = this.sct.filterGeneralizes(conceptId);
+          const selfResult = this.sct.concepts.findConcept(conceptId);
+          if (selfResult.found && !operatorFilter.descendants.includes(selfResult.index)) {
+            operatorFilter.descendants.push(selfResult.index);
+          }
+          break;
+        }
+        case ECLTokenType.PARENT_OF: {             // >!   direct parents only
+          operatorFilter = new SnomedFilterContext();
+          const selfResult = this.sct.concepts.findConcept(conceptId);
+          operatorFilter.descendants = selfResult.found
+              ? this.sct.getConceptParents(selfResult.index)
+              : [];
+          break;
+        }
+        case ECLTokenType.PARENT_OR_SELF_OF: {     // >>!  self + direct parents
+          operatorFilter = new SnomedFilterContext();
+          const selfResult = this.sct.concepts.findConcept(conceptId);
+          const parents = selfResult.found ? this.sct.getConceptParents(selfResult.index) : [];
+          operatorFilter.descendants = selfResult.found ? [selfResult.index, ...parents] : parents;
           break;
-        case ECLTokenType.PARENT_OF:
-        case ECLTokenType.PARENT_OR_SELF_OF:
-        case ECLTokenType.ANCESTOR_OF:
-        case ECLTokenType.ANCESTOR_OR_SELF_OF:
-          // These would require reverse hierarchy traversal
-          throw new Error(`Operator ${node.operator} not yet implemented`);
+        }
+
         default:
           throw new Error(`Unknown constraint operator: ${node.operator}`);
       }
 
-      results.descendants = [...(results.descendants || []), ...(operatorFilter.descendants || [])];
+      for (const idx of operatorFilter.descendants || []) {
+        accumulated.add(idx);
+      }
     }
 
+    const results = new SnomedFilterContext();
+    results.descendants = [...accumulated];
     return results;
   }
 
   async evaluateCompoundExpression(node) {
+    const { SnomedFilterContext } = require('../cs/cs-snomed');
+
     const leftFilter = await this.evaluateAST(node.left);
     const rightFilter = await this.evaluateAST(node.right);
 
@@ -1327,7 +1376,7 @@ class ECLValidator {
         this.validateSemanticAST(node.value, errors);
         break;
 
-      // Basic nodes don't need semantic validation
+        // Basic nodes don't need semantic validation
       case ECLNodeType.CONCEPT_REFERENCE:
       case ECLNodeType.WILDCARD:
         break;

package/tx/tx.js

@@ -20,7 +20,7 @@ const packageJson = require("../package.json");
 // Import workers
 const ReadWorker = require('./workers/read');
 const SearchWorker = require('./workers/search');
-const { ExpandWorker, INTERNAL_DEFAULT_LIMIT, EXTERNAL_DEFAULT_LIMIT} = require('./workers/expand');
+const { ExpandWorker, INTERNAL_DEFAULT_LIMIT, EXTERNAL_TEST_DEFAULT_LIMIT} = require('./workers/expand');
 const { ValidateWorker } = require('./workers/validate');
 const TranslateWorker = require('./workers/translate');
 const LookupWorker = require('./workers/lookup');
@@ -1212,8 +1212,12 @@ class TXModule {
   }
 
   externalLimit(req) {
+    let hdr = req.headers["x-too-costly-threshold"];
+    if (hdr) {
+      return parseInt(hdr);
+    }
     let isTest = req.header("User-Agent") == 'Tools/Java';
-    if (this.config.internalLimit && !isTest) return this.config.externalLimit; else return EXTERNAL_DEFAULT_LIMIT;
+    if (this.config.internalLimit && !isTest) return this.config.externalLimit; else return EXTERNAL_TEST_DEFAULT_LIMIT;
   }
 
 }

package/tx/vs/vs-vsac.js

@@ -136,7 +136,7 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
       console.log('Starting VSAC ValueSet refresh...');
 
       // This lists all the currently valid value sets by URL, but not the older versions
-      let url = '/ValueSet?_offset=0&_count=100&_elements=id,url,version,status';
+      let url = '/ValueSet?_offset=0&_count=1000&_elements=id,url,version,status';
 
       let total = undefined;
       let count = 0;
@@ -669,7 +669,23 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
       );
     });
 
-    const fmt = ts => ts
+    // ISO date (YYYY-MM-DD UTC) for grouping
+    const dayKey = ts => ts
+        ? new Date(ts * 1000).toISOString().substring(0, 10)
+        : '';
+    // Human-friendly day heading e.g. "Tuesday, 14 April 2026"
+    const dayLabel = ts => ts
+        ? new Date(ts * 1000).toLocaleDateString('en-GB', {
+          weekday: 'long', year: 'numeric', month: 'long', day: 'numeric',
+          timeZone: 'UTC'
+        })
+        : '—';
+    // HH:MM:SS UTC within a day
+    const timeOnly = ts => ts
+        ? new Date(ts * 1000).toISOString().substring(11, 19) + ' UTC'
+        : '—';
+    // Full timestamp (used in "Running..." detail where context is needed)
+    const fmtFull = ts => ts
         ? new Date(ts * 1000).toISOString().replace('T', ' ').substring(0, 19) + ' UTC'
         : '—';
 
@@ -678,7 +694,16 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
     html += '<thead><tr><th>Time</th><th>Event</th><th>Detail</th></tr></thead>';
     html += '<tbody>';
 
+    let currentDay = null;
     for (const row of rows) {
+      const rowDay = dayKey(row.ts);
+      if (rowDay !== currentDay) {
+        currentDay = rowDay;
+        html += `<tr style="background:#d8d8d8">`;
+        html += `<td colspan="3"><strong>${escape(dayLabel(row.ts))}</strong></td>`;
+        html += `</tr>`;
+      }
+
       if (row.kind === 'run') {
         const duration = row.finished_at ? `${row.finished_at - row.ts}s` : 'in progress';
         let detail, colour;
@@ -690,11 +715,11 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
           detail = `Failed: ${escape(row.error_message || '')} (${duration})`;
           colour = 'red';
         } else {
-          detail = `Running... (started ${fmt(row.ts)})`;
+          detail = `Running... (started ${fmtFull(row.ts)})`;
           colour = 'orange';
         }
         html += `<tr style="background:#f0f0f0">`;
-        html += `<td>${escape(fmt(row.ts))}</td>`;
+        html += `<td>${escape(timeOnly(row.ts))}</td>`;
         html += `<td><strong style="color:${colour}">Sync run</strong></td>`;
         html += `<td>${detail}</td>`;
         html += `</tr>`;
@@ -703,15 +728,15 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
         let label, colour;
         switch (row.event_type) {
           case 'new':
-            label = 'New value set';
+            label = 'New';
             colour = 'green';
             break;
           case 'updated':
-            label = 'Updated value set';
+            label = 'Updated';
             colour = 'blue';
             break;
           case 'deleted':
-            label = 'Deleted value set';
+            label = 'Deleted';
             colour = 'red';
             break;
           default:
@@ -719,9 +744,9 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
             colour = 'black';
         }
         html += `<tr>`;
-        html += `<td>${escape(fmt(row.ts))}</td>`;
+        html += `<td>${escape(timeOnly(row.ts))}</td>`;
         html += `<td><span style="color:${colour}">${label}</span></td>`;
-        html += `<td>${escape(row.url || '')}#${escape(row.version || '')}</td>`;
+        html += `<td>${escape(this.urlTail(row.url) || '')} v <a href="../ValueSet/${escape(this.urlTail(row.url) || '')}-${escape(row.version || '')}">${escape(row.version || '')}</a></td>`;
         html += `</tr>`;
       }
     }
@@ -733,6 +758,10 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
   id() {
     return "vsac";
   }
+
+  urlTail(url) {
+    return url ? url.substring(url.lastIndexOf('/') + 1) : '';
+  }
 }
 
 // Usage examples:

package/tx/workers/expand.js

@@ -22,6 +22,7 @@ const {debugLog} = require("../operation-context");
 
 // Expansion limits (from Pascal constants)
 const EXTERNAL_DEFAULT_LIMIT = 1000;
+const EXTERNAL_TEST_DEFAULT_LIMIT = 3000;
 const INTERNAL_DEFAULT_LIMIT = 10000;
 const EXPANSION_DEAD_TIME_SECS = 30;
 const CACHE_WHEN_DEBUGGING = false;
@@ -508,8 +509,8 @@ class ValueSetExpander {
     this.excluded.add(key);
   }
 
-  async checkCanExpandValueSet(uri, version) {
-    const vs = await this.worker.findValueSet(uri, version);
+  async checkCanExpandValueSet(uri, version, source) {
+    const vs = await this.worker.findValueSet(uri, version, source);
     if (vs == null) {
       if (!version && uri.includes('|')) {
         version = uri.substring(uri.indexOf('|') + 1);
@@ -525,9 +526,8 @@ class ValueSetExpander {
     }
   }
 
-  async expandValueSet(uri, version, filter, notClosed) {
+  async expandValueSet(uri, version, vs, filter, notClosed) {
 
-    let vs = await this.worker.findValueSet(uri, version);
     if (!vs) {
       if (version) {
         throw new Issue('error', 'not-found', null, 'VS_EXP_IMPORT_UNK_PINNED', this.worker.i18n.translate('VS_EXP_IMPORT_UNK_PINNED', this.params.httpLanguages, [uri, version]), "not-found", 422);
@@ -609,14 +609,14 @@ class ValueSetExpander {
     }
   }
 
-  async checkSource(cset, exp, filter, srcURL, ts, vsInfo) {
+  async checkSource(cset, exp, filter, srcURL, ts, vsInfo , source) {
     this.worker.deadCheck('checkSource');
     Extensions.checkNoModifiers(cset, 'ValueSetExpander.checkSource', 'set', srcURL);
     let imp = false;
     for (const u of cset.valueSet || []) {
       this.worker.deadCheck('checkSource');
       const s = this.worker.pinValueSet(u);
-      await this.checkCanExpandValueSet(s, '');
+      await this.checkCanExpandValueSet(s, '', source);
       imp = true;
     }
 
@@ -659,7 +659,7 @@ class ValueSetExpander {
 
         if (!cset.concept && !cset.filter) {
           if (cs.specialEnumeration()) {
-            await this.checkCanExpandValueSet(cs.specialEnumeration(), '');
+            await this.checkCanExpandValueSet(cs.specialEnumeration(), '', null);
           } else if (filter.isNull) {
             if (cs.isNotClosed()) {
               if (cs.specialEnumeration()) {
@@ -704,9 +704,12 @@ class ValueSetExpander {
         this.worker.deadCheck('processCodes#2');
         const s = this.worker.pinValueSet(u);
         this.worker.opContext.log('import value set ' + s);
-        const ivs = new ImportedValueSet(await this.expandValueSet(s, '', filter, notClosed));
-        this.checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
-        this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+        let vs = await this.worker.findValueSet(s, '', vsSrc);
+        const ivs = new ImportedValueSet(await this.expandValueSet(s, '', vs, filter, notClosed));
+        this. checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
+        if (!vs.isContained) {
+          this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+        }
         valueSets.push(ivs);
       }
       this.addToTotal(await this.importValueSet(valueSets[0].valueSet, expansion, valueSets, 1));
@@ -728,16 +731,20 @@ class ValueSetExpander {
           this.worker.deadCheck('processCodes#2');
           const s = this.worker.pinValueSet(u);
           this.worker.opContext.log('import value set ' + s);
-          const ivs = new ImportedValueSet(await this.expandValueSet(s, '', filter, notClosed));
+          let vs = await this.worker.findValueSet(s, '', vsSrc);
+          const ivs = new ImportedValueSet(await this.expandValueSet(s, '', vs, filter, notClosed));
           this.checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
-          this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+          if (!vs.isContained) {
+            this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+          }
           valueSets.push(ivs);
         }
 
         if (!cset.concept && !cset.filter) {
           if (cs.specialEnumeration() && filters.length === 0) {
             this.worker.opContext.log('import special value set ' + cs.specialEnumeration());
-            const base = await this.expandValueSet(cs.specialEnumeration(), '', filter, notClosed);
+            let vs = await this.worker.findValueSet(cs.specialEnumeration(), '', null);
+            const base = await this.expandValueSet(cs.specialEnumeration(), '', vs, filter, notClosed);
             Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
             Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
             await this.importValueSet(base, expansion, valueSets, 0);
@@ -860,7 +867,7 @@ class ValueSetExpander {
               throw new Issue('error', 'invalid', path + ".filter[" + i + "]", 'UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.worker.i18n.translate('UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.params.httpLanguages, [cs.system(), fc.property, fc.op]), 'vs-invalid', 400);
             }
             Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
-            await cs.filter(prep, fc.property, fc.op, fc.value);
+            await cs.filter(prep, i == 0, fc.property, fc.op, fc.value);
           }
 
           const fset = await cs.executeFilters(prep);
@@ -871,6 +878,7 @@ class ValueSetExpander {
           }
 
           this.worker.opContext.log('iterate filters');
+          this.addToTotal(0);
           const cds = new Designations(this.worker.i18n.languageDefinitions);
           while (await cs.filterMore(prep, fset[0])) {
             this.worker.deadCheck('processCodes#5');
@@ -937,9 +945,12 @@ class ValueSetExpander {
         for (const u of cset.valueSet) {
           const s = this.worker.pinValueSet(u);
           this.worker.deadCheck('processCodes#2');
-          const ivs = new ImportedValueSet(await this.expandValueSet(s, '', filter, notClosed));
+          let vs = await this.worker.findValueSet(s, '', vsSrc);
+          const ivs = new ImportedValueSet(await this.expandValueSet(s, '',  vs, filter, notClosed));
           this.checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
-          this.addParamUri(expansion, 'used-valueset', ivs.valueSet.vurl);
+          if (!vs.isContained) {
+            this.addParamUri(expansion, 'used-valueset', ivs.valueSet.vurl);
+          }
           valueSets.push(ivs);
         }
         this.excludeValueSet(valueSets[0].valueSet, expansion, valueSets, 1);
@@ -959,9 +970,12 @@ class ValueSetExpander {
         this.worker.deadCheck('processCodes#3');
         const s = this.worker.pinValueSet(u);
         this.worker.opContext.log('import value set ' + s);
-        const ivs = new ImportedValueSet(await this.expandValueSet(s, '', filter, notClosed));
+        let vs = await this.worker.findValueSet(s, '', vsSrc);
+        const ivs = new ImportedValueSet(await this.expandValueSet(s, '', vs, filter, notClosed));
         this.checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
-        this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+        if (!vs.isContained) {
+          this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+        }
         valueSets.push(ivs);
       }
 
@@ -1039,10 +1053,12 @@ class ValueSetExpander {
           Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
         }
 
+        let first = true;
         for (let fc of cset.filter) {
           this.worker.deadCheck('processCodes#4a');
           Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
-          await cs.filter(prep, fc.property, fc.op, fc.value);
+          await cs.filter(prep, first, fc.property, fc.op, fc.value);
+          first = false;
         }
 
         this.worker.opContext.log('iterate filters');
@@ -1150,12 +1166,12 @@ class ValueSetExpander {
     const ts = new Map();
     for (const c of source.jsonObj.compose.include || []) {
       this.worker.deadCheck('handleCompose#2');
-      await this.checkSource(c, expansion, filter, source.url, ts, vsInfo);
+      await this.checkSource(c, expansion, filter, source.url, ts, vsInfo, source);
     }
     for (const c of source.jsonObj.compose.exclude || []) {
       this.worker.deadCheck('handleCompose#3');
       this.hasExclusions = true;
-      await this.checkSource(c, expansion, filter, source.url, ts, null);
+      await this.checkSource(c, expansion, filter, source.url, ts, null, source);
     }
 
     this.worker.opContext.log('compose #2');
@@ -1215,6 +1231,7 @@ class ValueSetExpander {
       result.publisher = undefined;
       result.extension = undefined;
       result.text = undefined;
+      result.contained = undefined;
     }
 
     for (let s of this.params.supplements) this.requiredSupplements.add(s);
@@ -1909,7 +1926,7 @@ class ExpandWorker extends TerminologyWorker {
       const url = this.getParameterValue(urlParam);
       const version = versionParam ? this.getParameterValue(versionParam) : null;
 
-      valueSet = await this.findValueSet(url, version);
+      valueSet = await this.findValueSet(url, version, null);
       this.seeSourceVS(valueSet, url);
       if (!valueSet) {
         return res.status(422).json(this.operationOutcome('error', 'not-found',
@@ -2072,8 +2089,8 @@ class ExpandWorker extends TerminologyWorker {
 
     if (params.limit < -1) {
       params.limit = -1;
-    } else if (params.limit > EXTERNAL_DEFAULT_LIMIT) {
-      params.limit = EXTERNAL_DEFAULT_LIMIT; // can't ask for more than this externally, though you can internally
+    } else if (params.limit > this.externalLimit) {
+      params.limit = this.externalLimit; // can't ask for more than this externally, though you can internally
     }
 
     const filter = new SearchFilterText(params.filter);
@@ -2123,6 +2140,7 @@ module.exports = {
   EmptyFilterContext,
   EXTERNAL_DEFAULT_LIMIT,
   INTERNAL_DEFAULT_LIMIT,
+  EXTERNAL_TEST_DEFAULT_LIMIT,
   TotalStatus,
   EXPANSION_DEAD_TIME_SECS
 };

package/tx/workers/related.js

@@ -188,7 +188,7 @@ class RelatedWorker extends TerminologyWorker {
     const url = this.getParameterValue(urlParam);
     const version = versionParam ? this.getParameterValue(versionParam) : null;
 
-    let valueSet = await this.findValueSet(url, version);
+    let valueSet = await this.findValueSet(url, version, null);
     this.seeSourceVS(valueSet, url);
     if (!valueSet) {
       return res.status(404).json(this.operationOutcome('error', 'not-found',