fhirsmith 0.4.2 → 0.5.0

package/tx/workers/validate.js

@@ -43,7 +43,6 @@ class ValueSetChecker {
   worker;
   valueSet;
   params;
-  requiredSupplements = [];
   others = new Map();
 
   constructor(worker, valueSet, params) {
@@ -74,20 +73,20 @@ class ValueSetChecker {
   checkCanonicalStatusFull(path, op, rtype, vurl, pid, status, standardsStatus, experimental, source) {
     if (op !== null) {
       if (standardsStatus === 'deprecated') {
-        op.addIssue(new Issue('information', 'business-rule', '', 'MSG_DEPRECATED', this.worker.i18n.translate('MSG_DEPRECATED', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
+        op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_DEPRECATED', this.worker.i18n.translate('MSG_DEPRECATED', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
       } else if (standardsStatus === 'withdrawn') {
-        op.addIssue(new Issue('information', 'business-rule', '', 'MSG_WITHDRAWN', this.worker.i18n.translate('MSG_WITHDRAWN', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
+        op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_WITHDRAWN', this.worker.i18n.translate('MSG_WITHDRAWN', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
       } else if (status === 'retired') {
-        op.addIssue(new Issue('information', 'business-rule', '', 'MSG_RETIRED', this.worker.i18n.translate('MSG_RETIRED', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
+        op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_RETIRED', this.worker.i18n.translate('MSG_RETIRED', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
       } else if (source !== null) {
         if (experimental && !source.experimental) {
-          op.addIssue(new Issue('information', 'business-rule', '', 'MSG_EXPERIMENTAL', this.worker.i18n.translate('MSG_EXPERIMENTAL', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
+          op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_EXPERIMENTAL', this.worker.i18n.translate('MSG_EXPERIMENTAL', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
         } else if ((status === 'draft' || standardsStatus === 'draft') &&
           !((source.status === 'draft') || (Extensions.readString(source, 'http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status') === 'draft'))) {
           if (pid) {
-            op.addIssue(new Issue('information', 'business-rule', '', 'MSG_DRAFT', this.worker.i18n.translate('MSG_DRAFT_SRC', this.params.HTTPLanguages, [vurl, pid, rtype]), 'status-check'), false);
+            op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_DRAFT', this.worker.i18n.translate('MSG_DRAFT_SRC', this.params.HTTPLanguages, [vurl, pid, rtype]), 'status-check'), false);
           } else {
-            op.addIssue(new Issue('information', 'business-rule', '', 'MSG_DRAFT', this.worker.i18n.translate('MSG_DRAFT', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
+            op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_DRAFT', this.worker.i18n.translate('MSG_DRAFT', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
           }
         }
       }
@@ -121,9 +120,10 @@ class ValueSetChecker {
           }
         }
       }
-    } catch (e) {
-      console.error(e);
-      throw new Error('Exception expanding value set in order to infer system: ' + e.message);
+    } catch (error) {
+      this.log.error(error);
+      this.debugLog(error);
+      throw new Error('Exception expanding value set in order to infer system: ' + error.message);
     }
     return result;
   }
@@ -151,6 +151,7 @@ class ValueSetChecker {
   async determineSystem(opContext, code, systems, op) {
     let result = '';
     let needDoExpansion = false;
+    let mayNeedExpansion = false;
 
     for (let vsi of this.valueSet.jsonObj.compose.exclude || []) {
       if (vsi.valueSet || !vsi.system || vsi.filter) {
@@ -158,9 +159,12 @@ class ValueSetChecker {
       }
     }
     for (let vsi of this.valueSet.jsonObj.compose.include || []) {
-      if (vsi.valueSet || !vsi.system || vsi.filter) {
+      if (vsi.valueSet || !vsi.system) {
         needDoExpansion = true;
       }
+      if (vsi.filter) {
+        mayNeedExpansion = true;
+      }
     }
 
     if (needDoExpansion) {
@@ -168,7 +172,7 @@ class ValueSetChecker {
     } else {
       for (let vsi of this.valueSet.jsonObj.compose.include) {
         this.worker.deadCheck('determineSystem');
-        let cs = await this.worker.findCodeSystem(vsi.system, '', null, ['complete', 'fragment'], op,true);
+        let cs = await this.worker.findCodeSystem(vsi.system, '', null, ['complete', 'fragment'], op,true, false, false, this.worker.requiredSupplements);
         if (cs === null) {
           return '';
         }
@@ -192,7 +196,11 @@ class ValueSetChecker {
             if (!result) {
               result = vsi.system;
             } else if (result !== vsi.system) {
-              return '';
+              if (mayNeedExpansion) {
+                result = await this.determineSystemFromExpansion(code, systems);
+              } else {
+                return '';
+              }
             }
           }
         }
@@ -212,7 +220,7 @@ class ValueSetChecker {
 
 
     let result;
-    let csa = await this.worker.findCodeSystem(system, '', this.params, "*",  op,true, false, true);
+    let csa = await this.worker.findCodeSystem(system, '', this.params, "*",  op,true, false, true, this.worker.requiredSupplements);
 
     result = this.worker.determineVersionBase(system, versionVS, this.params);
 
@@ -231,7 +239,7 @@ class ValueSetChecker {
         }
       }
 
-      let cs = await this.worker.findCodeSystem(system, result, this.params, ['complete', 'fragment'], op,true, false, false);
+      let cs = await this.worker.findCodeSystem(system, result, this.params, ['complete', 'fragment'], op,true, false, false, this.worker.requiredSupplements);
       if (cs !== null && cs.version() !== versionCoding && !cs.versionIsMoreDetailed(versionCoding, cs.version())) {
         let errLvl = 'error';
         let msg, mid;
@@ -252,7 +260,7 @@ class ValueSetChecker {
         if (errLvl === 'error') {
           messages.push(msg);
         }
-        let cs2 = await this.worker.findCodeSystem(system, versionCoding, this.params, ['complete', 'fragment'], op, true, false, true);
+        let cs2 = await this.worker.findCodeSystem(system, versionCoding, this.params, ['complete', 'fragment'], op, true, false, true, this.worker.requiredSupplements);
         if (cs2 !== null) {
           cs2 = null;
         } else {
@@ -289,7 +297,7 @@ class ValueSetChecker {
 
   async prepare() {
     if (this.valueSet === null) {
-      throw new Issue('error', 'not-found', null, null, 'Error Error: vs = nil');
+      throw new Issue('error', 'not-found', null, null, 'Error Error: vs = nil', null, 422);
     } else {
       this.seeValueSet();
       this.worker.opContext.addNote(this.valueSet, 'Analysing ' + this.valueSet.vurl + ' for validation purposes', this.indentCount);
@@ -300,11 +308,7 @@ class ValueSetChecker {
           this.worker.opContext.addNote(this.valueSet, 'Version Rules: ' + vrs, this.indentCount);
         }
       }
-      this.requiredSupplements = [];
-      for (let ext of Extensions.list(this.valueSet.jsonObj, 'http://hl7.org/fhir/StructureDefinition/valueset-supplement')) {
-        this.requiredSupplements.push(getValuePrimitive(ext));
-      }
-      if (this.requiredSupplements.length > 0) {
+      if (this.worker.requiredSupplements.size > 0) {
         await this.checkSupplementsExist(this.valueSet);
       }
 
@@ -315,6 +319,7 @@ class ValueSetChecker {
 
       if (this.valueSet.jsonObj.compose) {
         Extensions.checkNoModifiers(this.valueSet.jsonObj.compose, 'ValueSetChecker.prepare', 'ValueSet.compose');
+        this.worker.checkNoLockedDate(this.valueSet.url, this.valueSet.jsonObj.compose)
         let i = 0;
         for (let cc of this.valueSet.jsonObj.compose.include || []) {
           await this.prepareConceptSet('include['+i+']', cc);
@@ -327,8 +332,10 @@ class ValueSetChecker {
         }
       }
     }
-    if (this.requiredSupplements.length > 0) {
-     throw new Issue('error', 'not-found', null, 'VALUESET_SUPPLEMENT_MISSING', this.worker.i18n.translatePlural(this.requiredSupplements.length, 'VALUESET_SUPPLEMENT_MISSING', this.params.HTTPLanguages, [this.requiredSupplements.join(',')])).handleAsOO(400);
+
+    const unused = new Set([...this.worker.requiredSupplements].filter(s => !this.worker.usedSupplements.has(s)));
+    if (unused.size > 0) {
+     throw new Issue('error', 'not-found', null, 'VALUESET_SUPPLEMENT_MISSING', this.worker.i18n.translatePlural(unused.size, 'VALUESET_SUPPLEMENT_MISSING', this.params.HTTPLanguages, [[...unused].join(',')]), 'not-found').handleAsOO(422);
     }
   }
 
@@ -343,7 +350,7 @@ class ValueSetChecker {
         if (!this.others.has(s)) {
           let other = await this.worker.findValueSet(s, '');
           if (other === null) {
-            throw new Issue('error', 'not-found', null, 'Unable_to_resolve_value_Set_', this.worker.i18n.translate('Unable_to_resolve_value_Set_', this.params.HTTPLanguages, [s]), 'not-found');
+            throw new Issue('error', 'not-found', null, 'Unable_to_resolve_value_Set_', this.worker.i18n.translate('Unable_to_resolve_value_Set_', this.params.HTTPLanguages, [s]), 'not-found', 422);
           }
           let checker = new ValueSetChecker(this.worker, other, this.params);
           checker.indentCount = this.indentCount + 1;
@@ -353,12 +360,12 @@ class ValueSetChecker {
       }
     }
     let v = this.worker.determineVersionBase(cc.system, cc.version, this.params);
-    let cs = await this.worker.findCodeSystem(cc.system, v, this.params, ['complete', 'fragment'], null, true, false, false);
+    let cs = await this.worker.findCodeSystem(cc.system, v, this.params, ['complete', 'fragment'], null, true, false, false, this.worker.requiredSupplements);
     if (cs !== null) {
       this.worker.opContext.addNote(this.valueSet, 'CodeSystem found: "' + this.worker.renderer.displayCoded(cs) + '"', this.indentCount);
-      for (let i = this.requiredSupplements.length - 1; i >= 0; i--) {
-        if (cs.hasSupplement(this.requiredSupplements[i])) {
-          this.requiredSupplements.splice(i, 1);
+      for (const s of this.worker.requiredSupplements) {
+        if (cs.hasSupplement(s)) {
+          this.worker.usedSupplements.add(s);
         }
       }
       let i = 0;
@@ -415,9 +422,9 @@ class ValueSetChecker {
     }
   }
 
-  async checkSimple(issuePath, system, version, code, abstractOk, inferSystem, op) {
+  async checkSimple(issuePath, system, version, code, op) {
     this.worker.opContext.clearContexts();
-    if (inferSystem) {
+    if (this.params.inferSystem) {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + code + '" and infer system', this.indentCount);
     } else {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(system, version, code) + '"', this.indentCount);
@@ -433,13 +440,14 @@ class ValueSetChecker {
     let contentMode = {value: null};
     let impliedSystem = {value: ''};
     let defLang = {value: null};
-    return await this.check(issuePath, system, version, code, abstractOk, inferSystem, null, unknownSystems, ver, inactive, normalForm, vstatus, it, op, null, null, contentMode, impliedSystem, ts, msgs, defLang);
+    return await this.check(issuePath, system, version, code, null, unknownSystems, ver, inactive, normalForm, vstatus, it, op, null, null, contentMode, impliedSystem, ts, msgs, defLang);
   }
 
-  async check(path, system, version, code, abstractOk, inferSystem, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, params, contentMode, impliedSystem, unkCodes, messages, defLang) {
+  async check(path, system, version, code, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, params, contentMode, impliedSystem, unkCodes, messages, defLang) {
     defLang.value = new Language('en');
     this.worker.opContext.addNote(this.valueSet, 'Check "' + this.worker.renderer.displayCoded(system, version, code) + '"', this.indentCount);
-    if (!system && !inferSystem) {
+
+    if (!system && !this.params.inferSystem) {
       let msg = this.worker.i18n.translate('Coding_has_no_system__cannot_validate', this.params.HTTPLanguages, []);
       messages.push(msg);
       op.addIssue(new Issue('warning', 'invalid', path, 'Coding_has_no_system__cannot_validate', msg, 'invalid-data'));
@@ -455,7 +463,7 @@ class ValueSetChecker {
         op.addIssue(new Issue('warning', 'invalid', path, 'Coding_has_no_system__cannot_validate_NO_INFER', msg, 'invalid-data'));
         return false;
       }
-      let cs = await this.worker.findCodeSystem(system, version, this.params, ['complete', 'fragment'], op,true);
+      let cs = await this.worker.findCodeSystem(system, version, this.params, ['complete', 'fragment'], op,true, false, false, this.worker.requiredSupplements);
       this.seeSourceProvider(cs, system);
       if (cs === null) {
         this.worker.opContext.addNote(this.valueSet, 'Didn\'t find CodeSystem "' + this.worker.renderer.displayCoded(system, version) + '"', this.indentCount);
@@ -469,7 +477,7 @@ class ValueSetChecker {
           op.addIssue(new Issue('error', 'invalid', addToPath(path, 'system'), 'Terminology_TX_System_ValueSet2', msg, 'invalid-data'));
           unknownSystems.add(system);
         } else {
-          let css = await this.worker.findCodeSystem(system, version, this.params, ['supplement'], op,true);
+          let css = await this.worker.findCodeSystem(system, version, this.params, ['supplement'], op,true, false, false, this.worker.requiredSupplements);
           if (css !== null) {
             vss = null;
             let msg = this.worker.i18n.translate('CODESYSTEM_CS_NO_SUPPLEMENT', this.params.HTTPLanguages, [this.canonical(css.system(), css.version())]);
@@ -519,7 +527,7 @@ class ValueSetChecker {
             result = false;
             cause.value = 'code-invalid';
             this.worker.opContext.addNote(this.valueSet, 'Unknown code', this.indentCount);
-            let msg = this.worker.i18n.translate(Unknown_Code_in_VersionSCT(cs.system), this.params.HTTPLanguages, [code, cs.system(), cs.version(), SCTVersion(cs.system(), cs.version())]);
+            let msg = this.worker.i18n.translate(Unknown_Code_in_VersionSCT(cs.system, cs.version()), this.params.HTTPLanguages, [code, cs.system(), cs.version(), SCTVersion(cs.system(), cs.version())]);
             messages.push(msg);
             op.addIssue(new Issue('error', 'code-invalid', addToPath(path, 'code'), 'Unknown_Code_in_Version', msg, 'invalid-code'));
           }
@@ -528,7 +536,7 @@ class ValueSetChecker {
             vcc.addCoding(cs.system(), cs.version(), await cs.code(ctxt), cs.display(ctxt, this.params.workingLanguages()));
           }
           cause.value = 'null';
-          if (!(abstractOk || !(await cs.IsAbstract(ctxt)))) {
+          if (!(this.params.abstractOk || !(await cs.isAbstract(ctxt)))) {
             result = false;
             this.worker.opContext.addNote(this.valueSet, 'Abstract code when not allowed', this.indentCount);
             cause.value = 'business-rule';
@@ -565,7 +573,7 @@ class ValueSetChecker {
       }
     } else if (DEV_IGNORE_VALUESET) {
       // anyhow, we ignore the value set (at least for now)
-      let cs = await this.worker.findCodeSystem(system, version, this.params, ['complete', 'fragment'], op, true, true, false);
+      let cs = await this.worker.findCodeSystem(system, version, this.params, ['complete', 'fragment'], op, true, true, false, this.worker.requiredSupplements);
       if (cs === null) {
         result = null;
         cause.value = 'not-found';
@@ -596,11 +604,11 @@ class ValueSetChecker {
         defLang.value = cs.defLang();
         this.checkCanonicalStatus(path, op, cs, this.valueSet);
         ver.value = cs.version();
-        contentMode.value = cs.contentMode;
+        contentMode.value = cs.contentMode();
         let ctxt = cs.locate(code);
         if (ctxt.context === null) {
           unkCodes.push(system + '|' + version + '#' + code);
-          if (cs.contentMode !== 'complete') {
+          if (cs.contentMode() !== 'complete') {
             result = true;
             cause.value = 'code-invalid';
             this.worker.opContext.addNote(this.valueSet, 'Not found in Incomplete Code System', this.indentCount);
@@ -611,14 +619,14 @@ class ValueSetChecker {
             result = false;
             cause.value = 'code-invalid';
             this.worker.opContext.addNote(this.valueSet, 'Unknown code', this.indentCount);
-            let msg = this.worker.i18n.translate(Unknown_Code_in_VersionSCT(system), this.params.HTTPLanguages, [code, system, version, SCTVersion(system, version)]);
+            let msg = this.worker.i18n.translate(Unknown_Code_in_VersionSCT(system, version), this.params.HTTPLanguages, [code, system, version, SCTVersion(system, version)]);
             messages.push(msg);
             op.addIssue(new Issue('warning', 'code-invalid', addToPath(path, 'code'), 'Unknown_Code_in_Version', msg, 'invalid-code'));
           }
         } else {
           ctxt = ctxt.context;
           cause.value = 'null';
-          if (!(abstractOk || !cs.IsAbstract(ctxt))) {
+          if (!(this.params.abstractOk || !(await cs.isAbstract(ctxt)))) {
             result = false;
             this.worker.opContext.addNote(this.valueSet, 'Abstract code when not allowed', this.indentCount);
             cause.value = 'business-rule';
@@ -640,7 +648,7 @@ class ValueSetChecker {
         }
       }
     } else {
-      if (!system && inferSystem) {
+      if (!system && this.params.inferSystem) {
         let systems = new Set();
         system = await this.determineSystem(this.worker.opContext, code, systems, op);
         if (!system) {
@@ -661,8 +669,9 @@ class ValueSetChecker {
         }
       }
 
-      if (this.requiredSupplements.length > 0) {
-        throw new Issue('error', 'not-found', null, 'VALUESET_SUPPLEMENT_MISSING', this.worker.i18n.translatePlural(this.requiredSupplements.length, 'VALUESET_SUPPLEMENT_MISSING', this.params.HTTPLanguages, [this.requiredSupplements.join(',')])).handleAsOO(400);
+      const unused = new Set([...this.worker.requiredSupplements].filter(s => !this.worker.usedSupplements.has(s)));
+      if (unused.size > 0) {
+        throw new Issue('error', 'not-found', null, 'VALUESET_SUPPLEMENT_MISSING', this.worker.i18n.translatePlural(unused.size, 'VALUESET_SUPPLEMENT_MISSING', this.params.HTTPLanguages, [[...unused].join(',')]), 'not-found').handleAsOO(422);
       }
 
       if (Extensions.checkNoModifiers(this.valueSet.jsonObj.compose, 'ValueSetChecker.prepare', 'ValueSet.compose')) {
@@ -673,7 +682,7 @@ class ValueSetChecker {
             result = true;
           } else if (cc.system === system || system === '%%null%%') {
             let v = await this.determineVersion(path, cc.system, cc.version, version, op, unknownSystems, messages);
-            let cs = await this.worker.findCodeSystem(system, v, this.params, ["complete", "fragment"], op,true, true, false);
+            let cs = await this.worker.findCodeSystem(system, v, this.params, ["complete", "fragment"], op,true, true, false, this.worker.requiredSupplements);
             if (cs === null) {
               this.worker.opContext.addNote(this.valueSet, 'CodeSystem not found: ' + this.worker.renderer.displayCoded(cc.system, v), this.indentCount);
               if (!this.params.membershipOnly) {
@@ -711,11 +720,11 @@ class ValueSetChecker {
             this.worker.opContext.addNote(this.valueSet, 'CodeSystem found: ' + this.worker.renderer.displayCoded(cs) + ' for ' + this.worker.renderer.displayCoded(cc.system, v), this.indentCount);
             await this.checkCanonicalStatusCS(path, op, cs, this.valueSet);
             ver.value = cs.version();
-            this.worker.checkSupplements(cs, cc, this.requiredSupplements);
+            this.worker.checkSupplements(cs, cc, this.worker.requiredSupplements, this.worker.usedSupplements);
             contentMode.value = cs.contentMode();
 
             let msg = '';
-            if ((system === '%%null%%' || cs.system() === system) && await this.checkConceptSet(path, 'in', cs, cc, code, abstractOk, displays, this.valueSet, msg, inactive, normalForm, vstatus, op, vcc, messages)) {
+            if ((system === '%%null%%' || cs.system() === system) && await this.checkConceptSet(path, 'in', cs, cc, code, displays, this.valueSet, msg, inactive, normalForm, vstatus, op, vcc, messages)) {
               result = true;
             } else {
               result = false;
@@ -736,7 +745,7 @@ class ValueSetChecker {
             }
             this.checkCanonicalStatus(path, op, checker.valueSet, this.valueSet);
             if (result === true) {
-              result = await checker.check(path, system, version, code, abstractOk, inferSystem, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, params, contentMode, impliedSystem, unkCodes, messages, defLang);
+              result = await checker.check(path, system, version, code, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, params, contentMode, impliedSystem, unkCodes, messages, defLang);
             }
           }
           if (result === true) {
@@ -747,24 +756,24 @@ class ValueSetChecker {
           for (let cc of this.valueSet.jsonObj.compose.exclude || []) {
             this.worker.deadCheck('check#4');
             let excluded;
-            if (cc.system) {
+            if (!cc.system) {
               excluded = true;
             } else {
-              let cs = await this.worker.findCodeSystem(cc.system, cc.version, this.params, ['complete', 'fragment'], op,true, true, false);
+              let cs = await this.worker.findCodeSystem(cc.system, cc.version, this.params, ['complete', 'fragment'], op,true, true, false, this.worker.requiredSupplements);
               if (cs === null) {
                 throw new Issue('error', 'unknown', null, null, 'No Match for ' + cc.system + '|' + cc.version);
               }
               await this.checkCanonicalStatus(path, op, cs, this.valueSet);
-              this.worker.checkSupplements(cs, cc, this.requiredSupplements);
+              this.worker.checkSupplements(cs, cc, this.worker.requiredSupplements, this.worker.usedSupplements);
               ver.value = cs.version();
               contentMode.value = cs.contentMode();
               let msg = '';
-              excluded = (system === '%%null%%' || cs.system() === system) && await this.checkConceptSet(path, 'not in', cs, cc, code, abstractOk, displays, this.valueSet, msg, inactive, normalForm, vstatus, op, vcc);
+              excluded = (system === '%%null%%' || cs.system() === system) && await this.checkConceptSet(path, 'not in', cs, cc, code, displays, this.valueSet, msg, inactive, normalForm, vstatus, op, vcc);
               if (msg) {
                 messages.push(msg);
               }
             }
-            for (let u of cc.valueSets || []) {
+            for (let u of cc.valueSet || []) {
               this.worker.deadCheck('check#5');
               let s = this.worker.pinValueSet(u);
               let checker = this.others.get(s);
@@ -772,7 +781,7 @@ class ValueSetChecker {
                 throw new Issue('error', 'unknown', null, null, 'No Match for ' + cc.system + '|' + cc.version + ' in ' + Array.from(this.others.keys()).join(','));
               }
               this.checkCanonicalStatus(path, op, checker.valueSet, this.valueSet);
-              excluded = excluded && (await checker.check(path, system, version, code, abstractOk, inferSystem, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, params, contentMode, impliedSystem, unkCodes, messages, defLang) === true);
+              excluded = excluded && (await checker.check(path, system, version, code, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, params, contentMode, impliedSystem, unkCodes, messages, defLang) === true);
             }
             if (excluded) {
               return false;
@@ -799,7 +808,7 @@ class ValueSetChecker {
             op.addIssueNoId('error', 'not-found', addToPath(path, 'version'), msg, 'vs-invalid');
             return false;
           }
-          let cs = await this.worker.findCodeSystem(system, v, this.params, ['complete', 'fragment'], op, true, true, false);
+          let cs = await this.worker.findCodeSystem(system, v, this.params, ['complete', 'fragment'], op, true, true, false, this.worker.requiredSupplements);
           if (cs === null) {
             if (!this.params.membershipOnly) {
               let bAdd = true;
@@ -837,7 +846,7 @@ class ValueSetChecker {
           ver.value = cs.version();
           contentMode.value = cs.contentMode();
           let msg = '';
-          if ((system === '%%null%%' || cs.system() === system) && await this.checkExpansion(path, cs, ccc, code, abstractOk, displays, this.valueSet, msg, inactive, vstatus, op)) {
+          if ((system === '%%null%%' || cs.system() === system) && await this.checkExpansion(path, cs, ccc, code, displays, this.valueSet, msg, inactive, vstatus, op)) {
             result = true;
           } else {
             result = false;
@@ -854,7 +863,7 @@ class ValueSetChecker {
     return result;
   }
 
-  async checkCoding(issuePath, coding, abstractOk, inferSystem) {
+  async checkCoding(issuePath, coding) {
     let inactive = false;
     let path = issuePath;
     let unknownSystems = new Set();
@@ -863,7 +872,7 @@ class ValueSetChecker {
     let result = new Parameters();
 
     this.worker.opContext.clearContexts();
-    if (inferSystem) {
+    if (this.params.inferSystem) {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(coding) + '" and infer system', this.indentCount);
     } else {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(coding) + '"', this.indentCount);
@@ -881,7 +890,7 @@ class ValueSetChecker {
     let impliedSystem = {value: ''};
     let defLang = {value: null};
 
-    let ok = await this.check(path, coding.system, coding.version, coding.code, abstractOk, inferSystem, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, result, contentMode, impliedSystem, unkCodes, messages, defLang);
+    let ok = await this.check(path, coding.system, coding.version, coding.code, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, result, contentMode, impliedSystem, unkCodes, messages, defLang);
     if (ok === true) {
       result.AddParamBool('result', true);
       if ((cause.value === 'not-found' && contentMode.value !== 'complete') || contentMode.value === 'example') {
@@ -962,17 +971,17 @@ class ValueSetChecker {
   async checkSupplementsExist(vs) {
     for (let inc of vs.jsonObj.compose.include) {
       if (inc.system) {
-        let cs = await this.worker.findCodeSystem(inc.system, inc.version, this.params, ['complete', 'fragment'], null,true);
+        let cs = await this.worker.findCodeSystem(inc.system, inc.version, this.params, ['complete', 'fragment'], null,true, false, false, this.worker.requiredSupplements);
         if (cs !== null) {
-          await this.worker.checkSupplements(cs, null, this.requiredSupplements);
+          await this.worker.checkSupplements(cs, null, this.worker.requiredSupplements, this.worker.usedSupplements);
         }
       }
     }
   }
 
-  async checkCodeableConcept(issuePath, code, abstractOk, inferSystem, mode) {
+  async checkCodeableConcept(issuePath, code, mode) {
     this.worker.opContext.clearContexts();
-    if (inferSystem) {
+    if (this.params.inferSystem) {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(code) + '" and infer system', this.indentCount);
     } else {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(code) + '"', this.indentCount);
@@ -996,7 +1005,7 @@ class ValueSetChecker {
     let tsys = '';
     let tcode = '';
     let tver = '';
-    let vcc = {};
+    let vcc = {}; // todo: VCC is an appendage, and useless. remove it
     if (code.text) {
       vcc.text = code.text;
     }
@@ -1023,10 +1032,9 @@ class ValueSetChecker {
     mt = [];
     let i = 0;
     let impliedSystem = { value: '' };
-    for (let c of code.coding) {
-      const csd = await this.worker.findCodeSystem(c.system, null, this.params, ['complete', 'fragment'], false, true);
+    for (let c of code.coding || []) {
+      const csd = await this.worker.findCodeSystem(c.system, null, this.params, ['complete', 'fragment'], false, true, false, false, this.worker.requiredSupplements);
       this.worker.seeSourceProvider(csd, c.system);
-
       this.worker.deadCheck('check-b#1');
       let path;
       if (issuePath === 'CodeableConcept') {
@@ -1034,11 +1042,16 @@ class ValueSetChecker {
       } else {
         path = issuePath;
       }
+      if (!c.code) {
+        let msg = `Coding has no code for system ${c.system} and cannot be validated`;
+        op.addIssue(new Issue('error', 'invalid', path, null, msg, 'invalid-data'));
+        break;
+      }
       list.clear();
       let ver = { value: '' };
       let contentMode = { value: null };
       let defLang = { value: null };
-      let v = await this.check(path, c.system, c.version, c.code, abstractOk, inferSystem, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, result, contentMode, impliedSystem, ts, mt, defLang);
+      let v = await this.check(path, c.system, c.version, c.code, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, result, contentMode, impliedSystem, ts, mt, defLang);
       if (v === false) {
         cause.value = 'code-invalid';
       }
@@ -1053,6 +1066,9 @@ class ValueSetChecker {
         tcode = c.code;
         tver = c.version;
       }
+      if (!tver && ver.value) {
+        tver = ver.value;
+      }
       let cc;
       if (!ws) {
         ws = "";
@@ -1113,7 +1129,7 @@ class ValueSetChecker {
           mt.push(m);
           op.addIssue(new Issue('error', 'invalid', p, 'Terminology_TX_System_Relative', m, 'invalid-data'));
         }
-        let prov = await this.worker.findCodeSystem(ws, c.version, this.params, ['complete', 'fragment'],  op,true, true, false);
+        let prov = await this.worker.findCodeSystem(ws, c.version, this.params, ['complete', 'fragment'],  op,true, true, false, this.worker.requiredSupplements);
         if (prov === null) {
           let vss = await this.worker.findValueSet(ws, '');
           if (vss !== null) {
@@ -1123,7 +1139,7 @@ class ValueSetChecker {
             op.addIssue(new Issue('error', 'invalid', addToPath(path, 'system'), 'Terminology_TX_System_ValueSet2', m, 'invalid-data'));
             cause.value = 'invalid';
           } else {
-            let provS = await this.worker.findCodeSystem(ws, c.version, this.params, ['supplement'], op,true, true, false);
+            let provS = await this.worker.findCodeSystem(ws, c.version, this.params, ['supplement'], op,true, true, false, this.worker.requiredSupplements);
             if (provS !== null) {
               vss = null;
               let m = this.worker.i18n.translate('CODESYSTEM_CS_NO_SUPPLEMENT', this.params.HTTPLanguages, [provS.vurl()]);
@@ -1131,7 +1147,7 @@ class ValueSetChecker {
               op.addIssue(new Issue('error', 'invalid', addToPath(path, 'system'), 'CODESYSTEM_CS_NO_SUPPLEMENT', m, 'invalid-data'));
               cause.value = 'invalid';
             } else {
-              let prov2 = await this.worker.findCodeSystem(ws, '', this.params, ['complete', 'fragment'], op,true, true, false);
+              let prov2 = await this.worker.findCodeSystem(ws, '', this.params, ['complete', 'fragment'], op,true, true, false, this.worker.requiredSupplements);
               let bAdd = true;
               let m, mid, vn;
               if (prov2 === null && !c.version) {
@@ -1184,7 +1200,7 @@ class ValueSetChecker {
               ts.push(vs);
               let m;
               if (prov.contentMode() === 'complete') {
-                m = this.worker.i18n.translate(Unknown_Code_in_VersionSCT(ws), this.params.HTTPLanguages, [c.code, ws, prov.version(), SCTVersion(ws, prov.version())]);
+                m = this.worker.i18n.translate(Unknown_Code_in_VersionSCT(ws, prov.version()), this.params.HTTPLanguages, [c.code, ws, prov.version(), SCTVersion(ws, prov.version())]);
                 cause.value = 'code-invalid';
                 msg(m);
                 op.addIssue(new Issue('error', 'code-invalid', addToPath(path, 'code'), 'Unknown_Code_in_Version', m, 'invalid-code'), true);
@@ -1196,6 +1212,9 @@ class ValueSetChecker {
               }
             }
           } else {
+            if (!c.version && mode == 'codeableConcept' && prov.version()) {
+              c.version = prov.version();
+            }
             await this.worker.listDisplaysFromCodeSystem(list, prov, ctxt.context);
             let pd = list.preferredDisplay(this.params.workingLanguages());
             if (pd) {
@@ -1230,7 +1249,7 @@ class ValueSetChecker {
               msg(m);
               op.addIssue(new Issue(severity, 'invalid', addToPath(path, 'display'), baseMsg, m, 'invalid-display'));
             }
-            if (prov.version()) {
+            if (prov.version() && mode != 'codeableConcept') {
               result.addParamStr('version', prov.version());
             }
           }
@@ -1412,9 +1431,9 @@ class ValueSetChecker {
     }
   }
 
-  async checkSystemCode(issuePath, system, version, code, inferSystem) {
+  async checkSystemCode(issuePath, system, version, code) {
     this.worker.opContext.clearContexts();
-    if (inferSystem) {
+    if (this.params.inferSystem) {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + code + '" and infer system', this.indentCount);
     } else {
       this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(system, version, code) + '"', this.indentCount);
@@ -1435,7 +1454,7 @@ class ValueSetChecker {
     let impliedSystem = {value: ''};
     let defLang = {value: null};
 
-    let ok = await this.check(issuePath, system, version, code, true, inferSystem, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, result, contentMode, impliedSystem, unkCodes, messages, defLang);
+    let ok = await this.check(issuePath, system, version, code, true, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, result, contentMode, impliedSystem, unkCodes, messages, defLang);
     if (ok === true) {
       result.AddParamBool('result', true);
       let pd = list.preferredDisplay(this.params.workingLanguages());
@@ -1484,7 +1503,7 @@ class ValueSetChecker {
     return result;
   }
 
-  async checkConceptSet(path, role, cs, cset, code, abstractOk, displays, vs, message, inactive, normalForm, vstatus, op, vcc, messages) {
+  async checkConceptSet(path, role, cs, cset, code, displays, vs, message, inactive, normalForm, vstatus, op, vcc, messages) {
     this.worker.opContext.addNote(vs, 'check code ' + role + ' ' + this.worker.renderer.displayValueSetInclude(cset) + ' at ' + path, this.indentCount);
     inactive.value = false;
     let result = false;
@@ -1498,43 +1517,15 @@ class ValueSetChecker {
             op.addIssue(new Issue('warning', 'code-invalid', addToPath(path, 'code'), 'UNKNOWN_CODE_IN_FRAGMENT', this.worker.i18n.translate('UNKNOWN_CODE_IN_FRAGMENT', this.params.HTTPLanguages, [code, cs.system(), cs.version()]), 'invalid-code'));
             result = true;
           } else {
-            op.addIssue(new Issue('error', 'code-invalid', addToPath(path, 'code'), 'Unknown_Code_in_Version',
-              this.worker.i18n.translate(Unknown_Code_in_VersionSCT(cs.system()), this.params.HTTPLanguages, [code, cs.system(), cs.version(), SCTVersion(cs.system(), cs.version())]), 'invalid-code'));
+            op.addIssue(new Issue('error', 'code-invalid', addToPath(path, 'code'), cs.version() ? 'Unknown_Code_in_Version' : 'Unknown_Code_in',
+              this.worker.i18n.translate(Unknown_Code_in_VersionSCT(cs.system(), cs.version()), this.params.HTTPLanguages, [code, cs.system(), cs.version(), SCTVersion(cs.system(), cs.version())]), 'invalid-code'));
           }
         }
         if (loc.message && op) {
           op.addIssue(new Issue('information', 'code-invalid', addToPath(path, 'code'), null, loc.message, 'invalid-code'));
         }
-      } else if (!(abstractOk || !cs.IsAbstract(loc.context))) {
-        this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
-        if (!this.params.membershipOnly) {
-          op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
-        }
-      } else if (this.excludeInactives() && await cs.isInactive(loc.context)) {
-        this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
-        let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
-        op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
-        result = false;
-        messages.push(msg);
-        if (!this.params.membershipOnly) {
-          inactive.value = true;
-          inactive.path = path;
-          if (inactive.value) {
-            vstatus.value = await cs.getStatus(loc.context);
-          }
-        }
-      } else if (this.params.activeOnly && await cs.isInactive(loc.context)) {
-        this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
-        result = false;
-        inactive.value = true;
-        inactive.path = path;
-        vstatus.value = await cs.getStatus(loc.context);
-        let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
-        messages.push(msg);
-        op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
       } else {
         this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
-        result = true;
         if (await cs.code(loc.context) != code) {
           let msg;
           if (cs.version()) {
@@ -1550,22 +1541,53 @@ class ValueSetChecker {
           op.addIssue(new Issue('information', 'informational', addToPath(path, 'code'), null, msg, 'process-note'));
         }
         await this.worker.listDisplaysFromCodeSystem(displays, cs, loc.context);
-        inactive.value = await cs.isInactive(loc.context);
-        inactive.path = path;
-        vstatus.value = await cs.getStatus(loc.context);
 
-        if (vcc !== null) {
-          if (!vcc.coding) {
-            vcc.coding = [];
+        if (!(this.params.abstractOk || !(await cs.isAbstract(loc.context)))) {
+          this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
+          if (!this.params.membershipOnly) {
+            op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
+          }
+        } else if (this.excludeInactives() && await cs.isInactive(loc.context)) {
+          this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
+          let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
+          op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
+          result = false;
+          messages.push(msg);
+          if (!this.params.membershipOnly) {
+            inactive.value = true;
+            inactive.path = path;
+            if (inactive.value) {
+              vstatus.value = await cs.getStatus(loc.context);
+            }
+          }
+        } else if (this.params.activeOnly && await cs.isInactive(loc.context)) {
+          this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
+          result = false;
+          inactive.value = true;
+          inactive.path = path;
+          vstatus.value = await cs.getStatus(loc.context);
+          let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
+          messages.push(msg);
+          op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
+        } else {
+          result = true;
+          inactive.value = await cs.isInactive(loc.context);
+          inactive.path = path;
+          vstatus.value = await cs.getStatus(loc.context);
+
+          if (vcc !== null) {
+            if (!vcc.coding) {
+              vcc.coding = [];
+            }
+            vcc.coding.push({
+              system: cs.system(),
+              version: cs.version(),
+              code: await cs.code(loc.context),
+              display: displays.preferredDisplay(this.params.workingLanguages())
+            });
           }
-          vcc.coding.push({
-            system: cs.system(),
-            version: cs.version(),
-            code: await cs.code(loc.context),
-            display: displays.preferredDisplay(this.params.workingLanguages())
-          });
+          return result;
         }
-        return result;
       }
     }
 
@@ -1579,7 +1601,7 @@ class ValueSetChecker {
           this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
           await this.worker.listDisplaysFromCodeSystem(displays, cs, loc);
           this.worker.listDisplaysFromIncludeConcept(displays, cc, vs);
-          if (!(abstractOk || !cs.IsAbstract(loc))) {
+          if (!(this.params.abstractOk || !(await cs.isAbstract(loc)))) {
             if (!this.params.membershipOnly) {
               op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
             }
@@ -1627,149 +1649,62 @@ class ValueSetChecker {
         // }
       }
       let filters = await cs.executeFilters(prep);
-      if (filters) {
-        let ctxt = filters[0];
-        let loc = await cs.filterLocate(prep, ctxt, code);
-        if (loc != null && !(typeof loc === 'string')) {
-          await this.worker.listDisplaysFromCodeSystem(displays, cs, loc);
-          if (!(abstractOk || !cs.IsAbstract(loc))) {
-            this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
-            if (!this.params.membershipOnly) {
-              op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
-            }
-          } else if (this.excludeInactives() && await cs.isInactive(loc)) {
-            result = false;
-            this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
-            if (!this.params.membershipOnly) {
-              inactive.value = true;
-              inactive.path = path;
-              vstatus.value = await cs.getStatus(loc);
-            }
-          } else {
-            this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
-            if (vcc !== null) {
-              if (!vcc.coding) { vcc.coding = []}
-              vcc.coding.push( { system : cs.system(), version: cs.version(), code: await cs.code(loc), display: displays.preferredDisplay(this.params.workingLanguages())});
-            }
-            result = true;
-            return result;
+      if (!filters || filters.length == 0) {
+        throw new Error("executing filters failed for " + cs.name());
+      }
+      let loc = await cs.filterLocate(prep, filters[0], code);
+      if (loc != null && !(typeof loc === 'string') && filters.length > 1) {
+        for (let i = 1; i < filters.length; i++) {
+          if (!(await cs.filterCheck(prep, filters[i], loc))) {
+            loc = null;
+            break;
           }
-        } else if (loc != null) {
-          this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs)+ ": "+loc, this.indentCount);
-          messages.push(loc);
-        } else {
-          this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
         }
-      } else {
-        result = true;
-        let i = 0;
-        for (let fc of cfl) {
-          this.worker.deadCheck('checkConceptSet#3');
-          if (fc.propertyerty === 'concept' && ["is-a", "descendent-of"].includes(fc.op)) {
-            let loc = await cs.locateIsA(code, fc.value, fc.op === "descendent-of");
-            if (loc !== null) {
-              await this.worker.listDisplaysFromCodeSystem(displays, cs, loc);
-              if (!(abstractOk || !cs.IsAbstract(loc))) {
-                this.worker.opContext.addNote(this.valueSet, 'Filter "' + fc.property + '' + fc.op + '' + fc.value + '": Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
-                if (!this.params.membershipOnly) {
-                  op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
-                }
-              } else {
-                this.worker.opContext.addNote(this.valueSet, 'Filter "' + fc.property + fc.op + fc.value + '": Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
-                if (vcc !== null) {
-                  vcc.addCoding(cs.system(), cs.version(), await cs.code(loc), displays.preferredDisplay(this.params.workingLanguages()));
-                }
-                result = true;
-                return result;
-              }
-            } else {
-              result = false;
-              this.worker.opContext.addNote(this.valueSet, 'Filter "' + fc.property + fc.op + fc.value + '": Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
-            }
-          } else if (fc.property === 'concept' && fc.op === 'is-not-a') {
-            let loc = await cs.locateIsA(code, fc.value);
-            result = loc === null;
-            if (result) {
-              let msg;
-              loc = await cs.locate(code, null, msg);
-              if (loc !== null) {
-                await this.worker.listDisplaysFromCodeSystem(displays, cs, loc);
-                if (!(abstractOk || !cs.IsAbstract(loc))) {
-                  this.worker.opContext.addNote(this.valueSet, 'Filter ' + fc.property + fc.op + fc.value + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
-                  if (!this.params.membershipOnly) {
-                    op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
-                  }
-                } else if (this.excludeInactives() && await cs.isInactive(loc)) {
-                  this.worker.opContext.addNote(this.valueSet, 'Filter ' + fc.property + fc.op + fc.value + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
-                  result = false;
-                  if (!this.params.membershipOnly) {
-                    inactive.value = true;
-                    inactive.path = path;
-                    vstatus.value = await cs.getStatus(loc);
-                  }
-                } else {
-                  this.worker.opContext.addNote(this.valueSet, 'Filter ' + fc.property + fc.op + fc.value + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
-                  if (vcc !== null) {
-                    vcc.addCoding(cs.system(), cs.version(), await cs.code(loc), displays.preferredDisplay(this.params.workingLanguages()));
-                  }
-                  result = true;
-                  return result;
-                }
-              }
-            } else {
-              this.worker.opContext.addNote(this.valueSet, 'Filter ' + fc.property + fc.op + fc.value + ': Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
-            }
-          } else {
-            let ctxt = filters[i];
-            result = false;
-            let loc = await cs.filterLocate(prep, ctxt, code);
-            if (!(typeof loc === 'string')) {
-              await this.worker.listDisplaysFromCodeSystem(displays, cs, loc);
-              if (!(abstractOk || !cs.IsAbstract(loc))) {
-                this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
-                if (!this.params.membershipOnly) {
-                  op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
-                }
-              } else if (this.excludeInactives() && await cs.isInactive(loc)) {
-                this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
-                result = false;
-                if (!this.params.membershipOnly) {
-                  inactive.value = true;
-                  inactive.path = path;
-                  vstatus.value = await cs.getStatus(loc);
-                }
-              } else {
-                this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
-                if (vcc !== null) {
-                  vcc.addCoding(cs.system(), cs.version(), await cs.code(loc), displays.preferredDisplay(this.params.workingLanguages()));
-                }
-                result = true;
-                return result;
-              }
-            } else {
-              this.worker.opContext.addNote(this.valueSet, 'Filter ' + ctxt.summary + ': Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs)+": "+loc, this.indentCount);
-            }
+      }
+      if (loc != null && !(typeof loc === 'string')) {
+        await this.worker.listDisplaysFromCodeSystem(displays, cs, loc);
+        if (!(this.params.abstractOk || !(await cs.isAbstract(loc)))) {
+          this.worker.opContext.addNote(this.valueSet, 'Filter ' + this.filterSummary(cset) + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
+          if (!this.params.membershipOnly) {
+            op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
           }
-          if (!result) {
-            break;
+        } else if (this.excludeInactives() && await cs.isInactive(loc)) {
+          result = false;
+          this.worker.opContext.addNote(this.valueSet, 'Filter ' + this.filterSummary(cset) + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
+          if (!this.params.membershipOnly) {
+            inactive.value = true;
+            inactive.path = path;
+            vstatus.value = await cs.getStatus(loc);
           }
-          i++;
+        } else {
+          this.worker.opContext.addNote(this.valueSet, 'Filter ' + this.filterSummary(cset) + ': Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
+          if (vcc !== null) {
+            if (!vcc.coding) { vcc.coding = []}
+            vcc.coding.push( { system : cs.system(), version: cs.version(), code: await cs.code(loc), display: displays.preferredDisplay(this.params.workingLanguages())});
+          }
+          result = true;
+          return result;
         }
+      } else if (loc != null) {
+        this.worker.opContext.addNote(this.valueSet, 'Filter ' + this.filterSummary(cset) + ': Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs)+ ": "+loc, this.indentCount);
+        messages.push(loc);
+      } else {
+        this.worker.opContext.addNote(this.valueSet, 'Filter ' + this.filterSummary(cset) + ': Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs), this.indentCount);
       }
     }
     return result;
   }
 
-  async checkExpansion(path, cs, cset, code, abstractOk, displays, vs, message, inactive, vstatus, op) {
+  async checkExpansion(path, cs, cset, code, displays, vs, message, inactive, vstatus, op) {
     let result = false;
     let loc = await cs.locate(code, null, message);
     result = false;
     if (loc === null || loc.context == null) {
       if (!this.params.membershipOnly) {
         op.addIssue(new Issue('error', 'code-invalid', addToPath(path, 'code'), 'Unknown_Code_in_Version',
-          this.worker.i18n.translate(Unknown_Code_in_VersionSCT(cs.system()), this.params.HTTPLanguages, [code, cs.system(), cs.version(), SCTVersion(cs.system(), cs.version())]), 'invalid-code'));
+          this.worker.i18n.translate(Unknown_Code_in_VersionSCT(cs.system(), cs.version()), this.params.HTTPLanguages, [code, cs.system(), cs.version(), SCTVersion(cs.system(), cs.version())]), 'invalid-code'));
       }
-    } else if (!(abstractOk || !cs.IsAbstract(loc.context))) {
+    } else if (!(this.params.abstractOk || !(await cs.isAbstract(loc.context)))) {
       if (!this.params.membershipOnly) {
         op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
       }
@@ -1789,6 +1724,17 @@ class ValueSetChecker {
     return this.valueSet.jsonObj.compose && this.valueSet.jsonObj.compose.inactive != undefined && !this.valueSet.jsonObj.compose.inactive;
   }
 
+  filterSummary(cset) {
+    let list = [];
+    for (let filter of cset.filter) {
+      let s = cset.filter.length > 1 ? "(" : "";
+      s = filter.prop+" "+filter.op+" "+filter.value;
+      s = s + (cset.filter.length > 1 ? ")" : "");
+      list.push(s)
+    }
+    return list.join(",");
+  }
+
 }
 
 function addToPath(path, name) {
@@ -1800,11 +1746,13 @@ function addToPath(path, name) {
 }
 
 
-function Unknown_Code_in_VersionSCT(url) {
+function Unknown_Code_in_VersionSCT(url, version) {
   if (url === 'http://snomed.info/sct') {
     return 'Unknown_Code_in_Version_SCT';
-  } else {
+  } else if (version) {
     return 'Unknown_Code_in_Version';
+  } else {
+    return 'Unknown_Code_in';
   }
 }
 
@@ -1864,6 +1812,8 @@ function toText(st, sep) {
 
 class ValidateWorker extends TerminologyWorker {
 
+  requiredSupplements = new Set();
+  usedSupplements = new Set();
   /**
    * @param {OperationContext} opContext - Operation context
    * @param {Logger} log - Logger instance
@@ -1901,7 +1851,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
-      console.error(error);
+      this.debugLog(error);
       if (error instanceof Issue) {
         if (error.isHandleAsOO()) {
           let oo = new OperationOutcome();
@@ -1922,27 +1872,34 @@ class ValidateWorker extends TerminologyWorker {
     let coded;
     let mode;
 
-    try {
-      // Handle tx-resource and cache-id parameters
-      this.setupAdditionalResources(params);
+    // Handle tx-resource and cache-id parameters
+    this.setupAdditionalResources(params);
 
-      let txp = new TxParameters(this.languages, this.i18n, true);
-      txp.readParams(params);
+    let txp = new TxParameters(this.languages, this.i18n, true);
+    txp.readParams(params);
+    for (const item of txp.supplements) this.requiredSupplements.add(item);
+
+    try {
 
       // Extract coded value
       mode = {mode: null};
       coded = this.extractCodedValue(params, true, mode);
       if (!coded) {
-        throw new Issue('error', 'invalid', null, null, 'Unable to find code to validate (looked for coding | codeableConcept | code in parameters =codingX:Coding)', null, 400);
+        throw new Issue('error', 'invalid', null, null, 'Unable to find code to validate (looked for coding | codeableConcept | code in parameters)', null, 400).handleAsOO(400);
       }
 
       // Get the CodeSystem - from parameter or by url
       const codeSystem = await this.resolveCodeSystem(params, txp, coded?.coding?.[0] ?? null, mode);
       if (!codeSystem) {
-        throw new Issue('error', 'invalid', null, null, 'No CodeSystem specified - provide url parameter or codeSystem resource', null, 400);
+        if (!coded?.coding?.[0].system) {
+          let msg = this.i18n.translate('Coding_has_no_system__cannot_validate', txp.HTTPLanguages, []);
+          throw new Issue('warning', 'invalid', mode.issuePath, 'Coding_has_no_system__cannot_validate', msg, 'invalid-data');
+        } else {
+          throw new Issue('error', 'invalid', null, null, 'No CodeSystem specified - provide url parameter or codeSystem resource', null, 400);
+        }
       }
       if (codeSystem.contentMode() == 'supplement') {
-        throw new Issue('error', 'invalid', this.systemPath(mode), 'CODESYSTEM_CS_NO_SUPPLEMENT', this.opContext.i18n.translate('CODESYSTEM_CS_NO_SUPPLEMENT', txp.HTTPLanguages, [codeSystem.vurl()]), "invalid-data");
+        throw new Issue('error', 'invalid', this.systemPath(mode), 'CODESYSTEM_CS_NO_SUPPLEMENT', this.opContext.i18n.translate('CODESYSTEM_CS_NO_SUPPLEMENT', txp.HTTPLanguages, [codeSystem.vurl()]), "invalid-data", 400);
       }
 
       // Perform validation
@@ -1953,8 +1910,9 @@ class ValidateWorker extends TerminologyWorker {
       return result;
     } catch (error) {
       this.log.error(error);
+      this.debugLog(error);
       if (error instanceof Issue && !error.isHandleAsOO()) {
-        return this.handlePrepareError(error, coded, mode.mode);
+        return await this.handlePrepareError(error, coded, mode.mode, txp);
       } else {
         throw error;
       }
@@ -1986,11 +1944,12 @@ class ValidateWorker extends TerminologyWorker {
 
       let txp = new TxParameters(this.languages, this.i18n, true);
       txp.readParams(params);
+      for (const item of txp.supplements) this.requiredSupplements.add(item);
 
       // Get the CodeSystem by id
       const codeSystem = await this.provider.getCodeSystemById(this.opContext, id);
       if (!codeSystem) {
-        return res.status(404).json(this.operationOutcome('error', 'not-found',
+        return res.status(422).json(this.operationOutcome('error', 'not-found',
           `CodeSystem/${id} not found`));
       }
       const csp = new FhirCodeSystemProvider(this.opContext, new CodeSystem(codeSystem), []);
@@ -2010,6 +1969,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
+      this.debugLog(error);
       return res.status(error.statusCode || 500).json(this.operationOutcome(
         'error', error.issueCode || 'exception', error.message));
     }
@@ -2030,6 +1990,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
+      this.debugLog(error);
       if (error instanceof Issue) {
         let op = new OperationOutcome();
         op.addIssue(error);
@@ -2047,6 +2008,7 @@ class ValidateWorker extends TerminologyWorker {
 
     let txp = new TxParameters(this.languages, this.i18n, true);
     txp.readParams(params);
+    for (const item of txp.supplements) this.requiredSupplements.add(item);
 
     // Get the ValueSet - from parameter or by url
     const valueSet = await this.resolveValueSet(params, txp);
@@ -2058,7 +2020,7 @@ class ValidateWorker extends TerminologyWorker {
     let mode = { mode : null };
     const coded = this.extractCodedValue(params, false, mode);
     if (!coded) {
-      throw new Issue("error", "invalid", null, null, 'Unable to find code to validate (looked for coding | codeableConcept | code in parameters =codingX:Coding)', null, 400);
+      throw new Issue("error", "invalid", null, null, 'Unable to find code to validate (looked for coding | codeableConcept | code+system | code+inferSystem in parameters', null, 422);
     }
 
     // Perform validation
@@ -2083,12 +2045,13 @@ class ValidateWorker extends TerminologyWorker {
 
       let txp = new TxParameters(this.languages, this.i18n, true);
       txp.readParams(params);
+      for (const item of txp.supplements) this.requiredSupplements.add(item);
 
       // Get the ValueSet by id
       const valueSet = await this.provider.getValueSetById(this.opContext, id);
       this.seeSourceVS(valueSet, id);
       if (!valueSet) {
-        return res.status(404).json(this.operationOutcome('error', 'not-found',
+        return res.status(422).json(this.operationOutcome('error', 'not-found',
           `ValueSet/${id} not found`));
       }
 
@@ -2107,6 +2070,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
+      this.debugLog(error);
       return res.status(error.statusCode || 500).json(this.operationOutcome(
         'error', error.issueCode || 'exception', error.message));
     }
@@ -2118,13 +2082,13 @@ class ValidateWorker extends TerminologyWorker {
    * Resolve the CodeSystem to validate against
    * @param {Object} params - Parameters resource
    * @param {string|null} id - Instance id (if instance-level request)
-   * @returns {Object|null} CodeSystem resource (wrapper or JSON)
+   * @returns {CodeSystemProvider|null} CodeSystem resource (wrapper or JSON)
    */
   async resolveCodeSystem(params, txParams, coded, mode) {
     // Check for codeSystem resource parameter
     const csResource = this.getResourceParam(params, 'codeSystem');
     if (csResource) {
-      return csResource;
+      return new FhirCodeSystemProvider(this.opContext, new CodeSystem(csResource), []); // todo: supplements
     }
     let path = coded == null ? null : mode.issuePath+".system";
     let fromCoded = false;
@@ -2150,7 +2114,7 @@ class ValidateWorker extends TerminologyWorker {
     }
     version = this.determineVersionBase(url, version, txParams);
 
-    let supplements = this.loadSupplements(url, version);
+    let supplements = this.loadSupplements(url, version, this.requiredSupplements);
 
     // First check additional resources
     const fromAdditional = this.findInAdditionalResources(url, version, 'CodeSystem', false);
@@ -2169,12 +2133,12 @@ class ValidateWorker extends TerminologyWorker {
         } else if (version) {
           let vl = await this.listVersions(url);
           if (vl.length == 0) {
-            throw new Issue("error", "not-found", this.systemPath(mode), 'UNKNOWN_CODESYSTEM_VERSION_NONE', this.opContext.i18n.translate('UNKNOWN_CODESYSTEM_VERSION_NONE', this.opContext.HTTPLanguages, [url, version]), 'not-found').setUnknownSystem(url).addIssue(issue);
+            throw new Issue("error", "not-found", this.systemPath(mode), 'UNKNOWN_CODESYSTEM_VERSION_NONE', this.opContext.i18n.translate('UNKNOWN_CODESYSTEM_VERSION_NONE', this.opContext.HTTPLanguages, [url, version]), 'not-found', 422).setUnknownSystem(url).addIssue(issue);
           } else {
-            throw new Issue("error", "not-found", this.systemPath(mode), 'UNKNOWN_CODESYSTEM_VERSION', this.opContext.i18n.translate('UNKNOWN_CODESYSTEM_VERSION', this.opContext.HTTPLanguages, [url, version, this.presentVersionList(vl)]), 'not-found').setUnknownSystem(url + "|" + version).addIssue(issue);
+            throw new Issue("error", "not-found", this.systemPath(mode), 'UNKNOWN_CODESYSTEM_VERSION', this.opContext.i18n.translate('UNKNOWN_CODESYSTEM_VERSION', this.opContext.HTTPLanguages, [url, version, this.presentVersionList(vl)], 422), 'not-found').setUnknownSystem(url + "|" + version).addIssue(issue);
           }
         } else {
-          throw new Issue("error", "not-found", this.systemPath(mode), 'UNKNOWN_CODESYSTEM', this.opContext.i18n.translate('UNKNOWN_CODESYSTEM', this.opContext.HTTPLanguages, [url]), 'not-found').setUnknownSystem(url).addIssue(issue);
+          throw new Issue("error", "not-found", this.systemPath(mode), 'UNKNOWN_CODESYSTEM', this.opContext.i18n.translate('UNKNOWN_CODESYSTEM', this.opContext.HTTPLanguages, [url]), 'not-found', 422).setUnknownSystem(url).addIssue(issue);
         }
       }
     }
@@ -2208,7 +2172,7 @@ class ValidateWorker extends TerminologyWorker {
       let vs = await this.provider.findValueSet(this.opContext, url, version);
       this.seeSourceVS(vs, url);
       if (vs == null) {
-        throw new Issue('error', 'not-found', null, 'Unable_to_resolve_value_Set_', this.i18n.translate('Unable_to_resolve_value_Set_', params.HTTPLanguages, [url+(version ? "|"+version : "")]), 'not-found', 400);
+        throw new Issue('error', 'not-found', null, 'Unable_to_resolve_value_Set_', this.i18n.translate('Unable_to_resolve_value_Set_', params.HTTPLanguages, [url+(version ? "|"+version : "")]), 'not-found', 422);
       } else {
         return vs;
       }
@@ -2263,6 +2227,9 @@ class ValidateWorker extends TerminologyWorker {
       }
       const display = this.getStringParam(params, 'display');
 
+      if (!system && !this.getStringParam(params, 'inferSystem')) {
+        return null;
+      }
       const codingObj = {code};
       if (system) codingObj.system = system;
       if (version) codingObj.version = version;
@@ -2289,14 +2256,11 @@ class ValidateWorker extends TerminologyWorker {
 
     let vs = this.makeVsForCS(codeSystem);
 
-    // Get parameters
-    const abstractOk = this._getBoolParam(params, 'abstract', true);
-
     // Create and prepare checker
     const checker = new ValueSetChecker(this, vs, params);
 
     // Perform validation
-    const result = await checker.checkCodeableConcept(mode.issuePath, coded, abstractOk, false, mode.mode);
+    const result = await checker.checkCodeableConcept(mode.issuePath, coded, mode.mode);
 
     // Add diagnostics if requested
     if (params.diagnostics) {
@@ -2336,9 +2300,9 @@ class ValidateWorker extends TerminologyWorker {
     this.deadCheck('doValidationVS');
     this.params = params;
 
-    // Get parameters
-    const abstractOk = this._getBoolParam(params, 'abstract', true);
-    const inferSystem = this._getBoolParam(params, 'inferSystem', false) || (mode === 'code' && !coded.coding[0].system)
+    for (let ext of Extensions.list(valueSet.jsonObj, 'http://hl7.org/fhir/StructureDefinition/valueset-supplement')) {
+      this.requiredSupplements.add(getValuePrimitive(ext));
+    }
 
     // Create and prepare checker
     const checker = new ValueSetChecker(this, valueSet, params);
@@ -2346,15 +2310,16 @@ class ValidateWorker extends TerminologyWorker {
       await checker.prepare();
     } catch (error) {
       this.log.error(error);
+      this.debugLog(error);
       if (!(error instanceof Issue) || error.isHandleAsOO()) {
         throw error;
       } else {
-        return this.handlePrepareError(error, coded, mode);
+        return await this.handlePrepareError(error, coded, mode, params);
       }
     }
 
     // Perform validation
-    const result = await checker.checkCodeableConcept(issuePath, coded, abstractOk, inferSystem, mode);
+    const result = await checker.checkCodeableConcept(issuePath, coded, mode);
 
     // Add diagnostics if requested
     if (params.diagnostics) {
@@ -2462,14 +2427,16 @@ class ValidateWorker extends TerminologyWorker {
   }
 
 
-  handlePrepareError(error, coded, mode) {
+  async handlePrepareError(error, coded, mode, txp) {
     let op = new OperationOutcome();
     op.addIssue(error);
     let p = new Parameters();
     p.addParamResource('issues', op.jsonObj);
     p.addParamBool('result', false);
     p.addParamStr('message', error.message);
-    if (mode == 'codeableConcept') {
+    if (!mode || !coded) {
+      // nothing to add
+    } else if (mode == 'codeableConcept') {
       p.addParam('codeableConcept', 'valueCodeableConcept', coded);
     } else if (coded.coding) {
       if (coded.coding[0].system) {
@@ -2477,13 +2444,19 @@ class ValidateWorker extends TerminologyWorker {
       }
       if (coded.coding[0].version) {
         p.addParamStr('version', coded.coding[0].version)
+      } else if (coded.coding[0].system) {
+        try {
+          let cs = await this.findCodeSystem(coded.coding[0].system, null, txp);
+          if (cs && cs.version()) {
+            p.addParamStr('version', cs.version());
+          }
+        } catch (e) {
+          // nothing. not interested.
+        }
       }
       if (coded.coding[0].code) {
         p.addParamCode('code', coded.coding[0].code)
       }
-      if (coded.coding[0].display) {
-        p.addParamStr('display', coded.coding[0].display)
-      }
     }
     if (error.unknownSystem) {
       p.addParamCanonical("x-caused-by-unknown-system", error.unknownSystem);