fhirsmith 0.18.0 → 0.18.1

package/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to Health Intersections FHIRsmith will be documented in this
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.18.1] - 2026-10-25
+
+
+### Added
+
+- ICF (`http://hl7.org/fhir/sid/icf`): qualified codes now cover environmental factors (`e`) - a barrier after `.`, or a facilitator after `+` in place of the `.` (no `+9`), on the new `q5` (barrier) and `q6` (facilitator) scales. As a whole: A category may be followed by `.` and one qualifier digit per position, the positions depending on the component: extent for body functions (`b`); extent, nature and localization for body structures (`s`); performance, capacity, and optionally capacity with assistance and performance without assistance for activities and participation (`d`); one for environmental factors (`e`), a barrier after `.` or a facilitator after `+` in place of the `.`. Each digit is checked against its scale in the code system (`q1`-`q6`, added to the ICF code systems in fhir.tx.support with a `kind` property). A qualified code gets a generated display (8, not specified, is left out of it; `d` qualifiers are labelled `performance`, `capacity`, ...), its qualifiers as properties in `$lookup` (`extent`, `nature`, `localization`, `performance`, `capacity`, `capacity-with-assistance`, `performance-without-assistance`, `barrier`, `facilitator`), and sits under its category for subsumption and `is-a` filters. Value sets can control qualifiers with an `exists` `true`/`false` filter on any of those properties (8 counts as absent) and `qualified` `=` `false`. ICF is now marked as not closed. The behaviour is in `tx/cs/cs-icf.js`, a subclass of the CodeSystem provider that `FhirCodeSystemProvider.create()` picks by url - the way to give any code system loaded from a package behaviour of its own
+- SNOMED CT alternate identifiers (`sct2_Identifier`, e.g. the LOINC Extension's LOINC codes): the importer reads them into the cache (cache format 18, written only when there are identifiers, so other caches stay 17). `$lookup` returns them as Coding properties named for the scheme (`loinc` = `http://loinc.org#...`), by default and when asked for. `$expand`: the filter `mapped:<scheme>` `exists` `true`/`false` (e.g. `mapped:30051010000102`) for concepts that do or don't have one. `$translate`: each module with identifiers defines an implicit map `<edition>/version/<date>?fhir_cm=<module>` (e.g. `?fhir_cm=11010000107`), `equivalent` in both directions, nominated by url or found from the systems (`targetSystem` `http://loinc.org` from a SNOMED CT coding, or `http://snomed.info/sct|<edition>` from a LOINC one)
+- SNOMED CT test edition: a subset of the LOINC Extension (LOINC ontology, module `11010000107`) - twelve LOINC-coded concepts with their LOINC identifiers (`sct2_Identifier`), plus the module and identifier scheme concepts - generated from the LOINC Extension release by `utilities/make-sct-loinc-subset.js`. The test cache is now `sct_test_20250909d.cache` (2280 concepts)
+- LOINC importer: mappings from LOINC codes, parts and answers to other code systems, in two new tables - `ExternalCodes` (system, version, code, display; one row per target) and `ExternalMappings` (LOINC code to target, with an equivalence). Read from `PartFile/PartRelatedCodeMapping.csv` (the file's own equivalence; the RadLex rows are left out for now), `LoincIeeeMedicalDeviceCodeMappingTable` (MDC, `urn:iso:std:iso:11073:10101`, the CF_CODE10 as the code and the REFID as display; IEEE's `broader`/`narrower` are from the LOINC side, so they become `narrower`/`wider`) and the `ExtCode*` columns of `AnswerList.csv` (`equivalent`; LOINC's `CMS/HCPCS` and `https://www.cdc.gov/phin` systems become `http://www.cms.gov/Medicare/Coding/HCPCSReleaseCodeSets` and `urn:oid:2.16.840.1.113883.6.238`). Both mapping files are optional. LOINC caches need rebuilding to get them; nothing uses them yet
+- LOINC: the mappings to other code systems are used. `$lookup` returns them as Coding properties named for the map (`sct`, `chebi`, `mdc`, `race`...), with the equivalence as a subproperty, by default and when asked for. `$translate`: each target system has an implicit map `http://loinc.org/cm/<name>` - `loinc`, `ncbi` (PubChem), `sct`, `hcpcs`, `gene-names`, `rxnorm`, `chebi`, `ncbi-clinvar`, `ncbi-gene`, `ncbi-taxo`, `mdc`, `race` - that works in both directions (LOINC to the system, and the system to LOINC), found from the target system or nominated by url. Found from the systems, a map is only offered for a code it has a mapping for, so translations that a SNOMED CT edition answers (the LOINC Extension) are unchanged. Targets in other systems (`CMS LCDS`, `Unicode`) are not used yet. Code system providers' `findImplicitConceptMaps` now also gets the code being translated
+- `$closure`: `dispose` - a request with `name` and `dispose` = `true` says the client has finished with the closure table, and the server deletes it (not in the specification; disposing of a table that doesn't exist is fine - it may already have been pruned). It can't be combined with concepts, a version, `reset` or configuration (`CLOSURE_DISPOSE_NOT_ALONE`, 400). Documented in the OpenAPI
+
+### Changed
+
+- Global language packs: the `codesystem-supplement-type` code is now `global-lang-pack` (`lang-pack` is still accepted)
+- `$lookup` on SNOMED CT: when the request names properties, only those are returned - effectiveTime, module, parent, child and the defining relationships are no longer added regardless
+- Daily report: the title is now "{server} daily report for {date} covering the last {24 hours | n days}", and the summary is one line per item - `Versions:` (FHIRsmith and Node), `Uptime:` (this run, and the percentage over all recorded runs), `Space:` (the log files and the disk) and `Audit:`
+- Tx test generator (`tx/tests/testcases-generator.js`): disabled suites and tests are left out, and `version` gates (including negated ones, `!4.0`) and `modes` lists are read as the Java runner reads them, so tests gated `!4.0` now run at R5. The rules are in `tx/tests/test-case-gates.js`
+
+### Fixed
+
+- Implicit ConceptMaps nominated by url are looked for in every version of a code system, not just the first loaded (a SNOMED CT edition's maps are named by its edition URI)
+- LOINC importer (and subsetter): CSV files are read by record, not by line, so a quoted field with a line break in it is one record. LOINC 2.83's `ComponentHierarchyBySystem.csv` has one (the text of `LP409416-7`), and the import failed with `UNIQUE constraint failed: Config.ConfigKey` - the second half of the record looked like a second root
+- `$expand`: a supplement that only supplied the chosen display or a designation - a global language pack, typically - was never reported as a `used-supplement`. Designations from a supplement carry it as `.supplement`, but the reporting looked for `.source`, which is never set
+- `CodeSystem/$validate-code` with `useSupplement`: the supplement was always reported as missing (`VALUESET_SUPPLEMENT_MISSING`, 422), even when it was passed in `tx-resource`, because the supplements were only checked off while preparing a value set, and validating against a code system doesn't prepare one
+- `$lookup` on a CodeSystem resource: a property asked for by its own code (`property=prop`) was not returned - only `property=property`, `*` or no `property` parameter returned the code system's properties. A property the server doesn't know is still ignored
+
+### Tx Conformance Statement
+
+FHIRsmith v0.18.1 passed all 4337 HL7 terminology service tests (modes tx.fhir.org+omop+general+snomed+mimetypes+icd-11+icf+closure, tests v1.10.0, runner v7.0.3)
+
 ## [0.18.0] - 2026-10-23
 
 A big release: a new IPS module (prototype), a secured and documented registry with uptime reporting, a syndication feed for the terminology server, a daily email report, ICF qualified codes, SNOMED CT edition to edition translation and much more ECL, and the ICD-11 representation agreed at the October 2026 test-case review meetings. Plus the outcome of security reviews of the registry, IPS and token modules. The README now says what state each module is in.
@@ -43,7 +74,6 @@ Note: We are heading towards a 1.0.0 release.
 - Home page and dashboard: the uptime box now also reports the server's overall uptime - `Uptime: 38m 16s (99.3% overall)` - the proportion of the time since the first recorded run that the server has been running. Each run is recorded in the statistics database (`server_runs` in `stats.db`) with a heartbeat every minute, so a crash loses at most a minute. Not shown when statistics are turned off
 - `library/fhir-search-values.js`: the date range, prefix and comma-splitting parts of FHIR search, moved out of the testing module for sharing
 - `library/package-manager.js`: a cached package folder with no `package/package.json` (a download that failed after the folder was made) is fetched again instead of being used
-- ICF (`http://hl7.org/fhir/sid/icf`): qualified codes. A category may be followed by `.` and one qualifier digit per position, the positions depending on the component: extent for body functions (`b`); extent, nature and localization for body structures (`s`); performance, capacity, and optionally capacity with assistance and performance without assistance for activities and participation (`d`). Qualifiers on environmental factors (`e`) are not supported yet. Each digit is checked against its scale in the code system (`q1`-`q4`, added to the ICF code systems in fhir.tx.support with a `kind` property). A qualified code gets a generated display (8, not specified, is left out of it; `d` qualifiers are labelled `performance`, `capacity`, ...), its qualifiers as properties in `$lookup` (`extent`, `nature`, `localization`, `performance`, `capacity`, `capacity-with-assistance`, `performance-without-assistance`), and sits under its category for subsumption and `is-a` filters. Value sets can control qualifiers with an `exists` `true`/`false` filter on any of those properties (8 counts as absent) and `qualified` `=` `false`. ICF is now marked as not closed. The behaviour is in `tx/cs/cs-icf.js`, a subclass of the CodeSystem provider that `FhirCodeSystemProvider.create()` picks by url - the way to give any code system loaded from a package behaviour of its own
 - `$translate`: SNOMED CT edition to edition translation with no map - from an edition to one it depends on (per the module dependency reference set), using the implicit map `<edition>/version/<date>?fhir_cm=edition/<target module>` (the url agreed with the SNOMED committee), found from `targetSystem` or nominated by url. A concept in the target edition's modules is its own translation; an inactive concept translates through its historical associations; a fully defined extension concept translates to its normal form (or the target concept with that normal form), when that uses only target edition content; anything else translates to its proximal target-edition ancestors as `source-is-narrower-than-target`, unless those are only top-level hierarchies, which is reported as the reason there is no translation. The source concept in a match carries its version, as given
 - `$translate`: when the target code a map directs to is not in its code system's normal form, the match has a `normalized-concept`. A source code that has a normal form is looked up both as given and in its normal form (a map entry written in the normal form matches any code with that normal form; the map's own entries are not normalised). A target in a code system the server doesn't know gets a `note` saying it was not validated, and a target code that is not valid gives an `error`
 - `$lookup`: a warning when the `displayLanguage` asked for has no display for the code, and the display is in the default language (`LOOKUP_DISPLAY_LANGUAGE_FALLBACK`)

package/library/daily-report.js

@@ -85,6 +85,15 @@ function formatSpan(ms) {
   return parts.join(' ');
 }
 
+/** "24 hours", "3 days" - for the report title; rounded, since it's a description of the period */
+function describeSpan(ms) {
+  const hours = Math.round(ms / 3600000);
+  if (hours < 48) {
+    return plural(Math.max(1, hours), 'hour');
+  }
+  return plural(Math.round(hours / 24), 'day');
+}
+
 function plural(n, word) {
   return `${n} ${word}${n === 1 ? '' : 's'}`;
 }
@@ -243,8 +252,7 @@ class DailyReport {
    */
   async build(since, now = Date.now()) {
     const parts = [];
-    parts.push(`# ${this.serverId} daily report`);
-    parts.push(`${localDateTime(now)}, covering the ${formatSpan(now - since)} since ${localDateTime(since)}.`);
+    parts.push(`# ${this.serverId} daily report for ${localDateTime(now)} covering the last ${describeSpan(now - since)}`);
     parts.push('## Stability');
     parts.push(this.stabilityParagraph(since, now));
     for (const [name, module] of Object.entries(this.modules)) {
@@ -347,25 +355,26 @@ class DailyReport {
    * the disk they're on.
    */
   systemParagraph(now) {
-    const sentences = [];
-    sentences.push(`${this.serverId} is running FHIRsmith v${this.version} on Node.js ${process.version} (${os.type()} ${os.release()}, ${os.arch()}).`);
+    // one line each; the two trailing spaces are markdown's line break
+    const lines = [];
+    lines.push(`Versions: FHIRsmith = v${this.version}. Node = ${process.version} (${os.type()} ${os.release()}, ${os.arch()})`);
     if (this.stats && typeof this.stats.startTime === 'number') {
-      let up = `This run has been up for ${formatSpan(now - this.stats.startTime)}, since ${localDateTime(this.stats.startTime)}`;
+      let up = `Uptime: This run = ${formatSpan(now - this.stats.startTime)}`;
       const overall = typeof this.stats.overallUptime === 'function' ? this.stats.overallUptime(now) : null;
       if (overall) {
         const pct = overall.percent >= 100 ? '100' : (Math.floor(overall.percent * 10) / 10).toFixed(1);
-        up += `; over all its recorded runs (since ${localDate(overall.since)}) the server has been up ${pct}% of the time`;
+        up += `. All runs, ${pct}%`;
       }
-      sentences.push(up + '.');
+      lines.push(up);
     }
-    sentences.push(this.logsSentence());
+    lines.push(`Space: ${this.logsText()}`);
     if (this.npmAudit && typeof this.npmAudit.reportText === 'function') {
       const audit = this.npmAudit.reportText();
       if (audit) {
-        sentences.push(audit);
+        lines.push(`Audit: ${audit}`);
       }
     }
-    return sentences.join(' ');
+    return lines.join('  \n');
   }
 
   /**
@@ -388,7 +397,7 @@ class DailyReport {
     return `${plural(failed.length, 'background task')} ${failed.length === 1 ? 'is' : 'are'} in a failed state:\n\n${lines.join('\n')}`;
   }
 
-  logsSentence() {
+  logsText() {
     const logDir = folders.logsDir();
     try {
       const files = fs.readdirSync(logDir).filter(f => f.endsWith('.log'));
@@ -402,13 +411,13 @@ class DailyReport {
         const free = fstats.bavail * fstats.bsize;
         const size = fstats.blocks * fstats.bsize;
         const freePct = size > 0 ? Math.round((free * 100) / size) : 0;
-        disk = `, on a disk with ${formatBytes(free)} free of ${formatBytes(size)} (${freePct}% free)`;
+        disk = ` on a disk with ${formatBytes(free)} free of ${formatBytes(size)} (${freePct}% free)`;
       } catch {
-        disk = ', on a disk whose free space could not be read';
+        disk = ' on a disk whose free space could not be read';
       }
-      return `The logs folder (${logDir}) holds ${plural(files.length, 'log file')} totalling ${formatBytes(total)}${disk}.`;
+      return `${plural(files.length, 'log file')} totalling ${formatBytes(total)}${disk}.`;
     } catch (e) {
-      return `The logs folder (${logDir}) could not be read: ${e.message}.`;
+      return `the logs folder (${logDir}) could not be read: ${e.message}.`;
     }
   }
 }
@@ -417,6 +426,7 @@ module.exports = DailyReport;
 module.exports.nextMidnight = nextMidnight;
 module.exports.localDate = localDate;
 module.exports.formatSpan = formatSpan;
+module.exports.describeSpan = describeSpan;
 // for modules writing their paragraph: "3 packages", "1 package"
 module.exports.plural = plural;
 module.exports.localDateTime = localDateTime;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fhirsmith",
-  "version": "0.18.0",
-  "txVersion": "1.9.6",
+  "version": "0.18.1",
+  "txVersion": "1.10.0",
   "description": "A Node.js server that provides a collection of tools to serve the FHIR ecosystem",
   "main": "server.js",
   "engines": {

package/translations/Messages.properties

@@ -1129,6 +1129,7 @@ CLOSURE_NAME_NOT_UUID = The closure table name ''{0}'' is not valid: this server
 CLOSURE_PARAM_UNKNOWN = The parameter ''{0}'' is not supported by $closure on this server
 CLOSURE_CONCEPT_AND_VERSION = A $closure request can add concepts or resynchronise from a version, but not both at once
 CLOSURE_RESET_AND_VERSION = A $closure request can reset the closure table or resynchronise from a version, but not both at once
+CLOSURE_DISPOSE_NOT_ALONE = A $closure request that disposes of the closure table can only name the table: it cannot also add concepts, resynchronise, reset or configure it
 CLOSURE_TABLE_EXISTS = The closure table ''{0}'' already exists. To discard its content and start again, include the parameter reset = true
 CLOSURE_TABLE_UNKNOWN = The closure table ''{0}'' does not exist on this server. Initialise it first, with a $closure request that names it and has no concepts
 CLOSURE_CONFIG_NOT_ALLOWED = The parameter ''{0}'' configures a closure table, so it can only be supplied when the table is initialised (or reset)

package/tx/closure/closure-store.js

@@ -286,6 +286,20 @@ class ClosureStore {
     return tx();
   }
 
+  /**
+   * Delete a table, and everything in it. The caller holds the table's lock.
+   * @param {string} name
+   * @returns {boolean} whether there was a table to delete
+   */
+  dropTable(name) {
+    const existing = this.stmt.getTable.get(name);
+    if (!existing) {
+      return false;
+    }
+    this.stmt.deleteTable.run(existing.id);
+    return true;
+  }
+
   /**
    * The parameters the table was initialised with, as Parameters.parameter entries.
    */

package/tx/cs/cs-api.js

@@ -1036,9 +1036,11 @@ class CodeSystemFactoryProvider {
    * @param source - the source system URI
    * @param sourceVersion - the version of the source coding (may be null)
    * @param dest - the target system URI, possibly with |version
+   * @param code - the code being translated, if known (under reverse, the target concept's
+   *   code), so a provider can leave out a map that has nothing to say about it
    */
   // eslint-disable-next-line no-unused-vars
-  async findImplicitConceptMaps(conceptMaps, source, sourceVersion, dest) {
+  async findImplicitConceptMaps(conceptMaps, source, sourceVersion, dest, code = null) {
     return null;
   }
 

package/tx/cs/cs-cs.js

@@ -1027,11 +1027,17 @@ class FhirCodeSystemProvider extends BaseCSServices {
       return;
     }
 
-    // Add properties if requested (or by default)
-    if (this._hasProp(props, 'property', true)) {
+    // Add the concept's properties: each one if it was asked for by its code (or '*', or nothing
+    // was asked for). 'property' asks for all of them - it used to be the only thing that did, so
+    // asking for a property by its own code returned nothing. A code the server doesn't know is
+    // simply not matched
+    {
       const properties = await this.properties(ctxt);
       if (properties) {
         for (const property of properties) {
+          if (!this._hasProp(props, property.code, true) && !this._hasProp(props, 'property', true)) {
+            continue;
+          }
           let parts = [];
           parts.push({ name: 'code', valueCode: property.code });
 

package/tx/cs/cs-icf.js

@@ -12,10 +12,12 @@
  *   s  body structures            extent, nature, localization
  *   d  activities/participation   performance, capacity, then optionally capacity with
  *                                 assistance and performance without assistance
- *   e  environmental factors      not supported yet (barriers '.', facilitators '+')
+ *   e  environmental factors      one: a barrier after '.', or a facilitator after '+' (in
+ *                                 place of the '.') - e310.2, e310+3
  * Each digit must be a value of its position's scale, which the code system carries as the
- * concepts q1-n (extent of impairment), q2-n (nature), q3-n (localization) and q4-n (extent of
- * problem), under the group concepts q1..q4. A position cannot be omitted; 8 (not specified) is
+ * concepts q1-n (extent of impairment), q2-n (nature), q3-n (localization), q4-n (extent of
+ * problem), q5-n (barrier) and q6-n (facilitator, which has no 9), under the group concepts
+ * q1..q6. A position cannot be omitted; 8 (not specified) is
  * what fills it, and 8 says nothing in the display. Each position is reported by $lookup as the
  * property named in QUALIFIERS.
  *
@@ -37,32 +39,40 @@ const { Issue } = require('../library/operation-outcome');
 const { FhirCodeSystemProvider, FhirCodeSystemProviderContext, FhirCodeSystemProviderFilterContext } = require('./cs-cs');
 
 /**
- * The qualifier positions of each component: the property that reports the qualifier, the
- * scale (group concept) its values come from, and the label that introduces its value in the
- * display (none for b and s, whose qualifiers say what they are).
+ * The qualifier positions of each component, by the separator that introduces them: the
+ * property that reports the qualifier, the scale (group concept) its values come from, and the
+ * label that introduces its value in the display (none where the value says what it is).
+ * Only environmental factors take '+', which makes the qualifier a facilitator.
  */
 const QUALIFIERS = {
-  b: [
-    { property: 'extent', scale: 'q1' }
-  ],
-  s: [
-    { property: 'extent', scale: 'q1' },
-    { property: 'nature', scale: 'q2' },
-    { property: 'localization', scale: 'q3' }
-  ],
-  d: [
-    { property: 'performance', scale: 'q4', label: 'performance' },
-    { property: 'capacity', scale: 'q4', label: 'capacity' },
-    { property: 'capacity-with-assistance', scale: 'q4', label: 'capacity with assistance' },
-    { property: 'performance-without-assistance', scale: 'q4', label: 'performance without assistance' }
-  ],
-  e: null // barriers and facilitators: not supported yet
+  b: {
+    '.': [{ property: 'extent', scale: 'q1' }]
+  },
+  s: {
+    '.': [
+      { property: 'extent', scale: 'q1' },
+      { property: 'nature', scale: 'q2' },
+      { property: 'localization', scale: 'q3' }
+    ]
+  },
+  d: {
+    '.': [
+      { property: 'performance', scale: 'q4', label: 'performance' },
+      { property: 'capacity', scale: 'q4', label: 'capacity' },
+      { property: 'capacity-with-assistance', scale: 'q4', label: 'capacity with assistance' },
+      { property: 'performance-without-assistance', scale: 'q4', label: 'performance without assistance' }
+    ]
+  },
+  e: {
+    '.': [{ property: 'barrier', scale: 'q5' }],
+    '+': [{ property: 'facilitator', scale: 'q6' }]
+  }
 };
 
 const COMPONENT_NAMES = { b: 'body functions', s: 'body structures', d: 'activities and participation', e: 'environmental factors' };
-const COMPONENT_CODES = { b: 'a body functions (b) code', s: 'a body structures (s) code', d: 'an activities and participation (d) code' };
+const COMPONENT_CODES = { b: 'a body functions (b) code', s: 'a body structures (s) code', d: 'an activities and participation (d) code', e: 'an environmental factors (e) code' };
 
-const QUALIFIER_PROPERTIES = new Set(Object.values(QUALIFIERS).filter(q => q).flatMap(q => q.map(p => p.property)));
+const QUALIFIER_PROPERTIES = new Set(Object.values(QUALIFIERS).flatMap(c => Object.values(c)).flatMap(q => q.map(p => p.property)));
 
 /**
  * A category with qualifiers. code and concept are the category's, so whatever is inherited
@@ -110,21 +120,22 @@ class IcfCodeSystemProvider extends FhirCodeSystemProvider {
   // -- locating -------------------------------------------------------------------------
 
   /**
-   * A code in the code system, or a selectable category followed by '.' and one to three
-   * qualifier digits. An unknown category is a plain miss (no message); a known category
-   * with bad qualifiers says what is wrong with them.
+   * A code in the code system, or a selectable category followed by '.' (or, for an
+   * environmental factor, '+') and its qualifier digits. An unknown category is a plain miss
+   * (no message); a known category with bad qualifiers says what is wrong with them.
    */
   async locate(code) {
     const base = await super.locate(code);
     if (base.context || typeof code !== 'string') {
       return base;
     }
-    const dot = code.indexOf('.');
-    if (dot <= 0) {
+    const sep = code.search(/[.+]/);
+    if (sep <= 0) {
       return base;
     }
-    const stemCode = code.substring(0, dot);
-    const digits = code.substring(dot + 1);
+    const separator = code[sep];
+    const stemCode = code.substring(0, sep);
+    const digits = code.substring(sep + 1);
     const stem = this.codeSystem.getConceptByCode(stemCode);
     if (!stem) {
       return { context: null, message: undefined };
@@ -133,15 +144,17 @@ class IcfCodeSystemProvider extends FhirCodeSystemProvider {
       return { context: null, message: `The ICF code '${code}' is not valid: qualifiers can only follow a selectable ICF category, and '${stemCode}' is not one` };
     }
     const component = stemCode[0];
-    const positions = QUALIFIERS[component];
+    const positions = (QUALIFIERS[component] || {})[separator];
     if (!positions) {
-      return { context: null, message: `The ICF code '${code}' is not valid: qualifiers on ${COMPONENT_NAMES[component] || 'these'} codes are not supported` };
+      return { context: null, message: separator === '+'
+        ? `The ICF code '${code}' is not valid: only an environmental factor (e) can be a facilitator, written with '+'`
+        : `The ICF code '${code}' is not valid: qualifiers on ${COMPONENT_NAMES[component] || 'these'} codes are not supported` };
     }
     const names = positions.map(q => q.property).join(', ');
     if (!new RegExp(`^[0-9]{1,${positions.length}}$`).test(digits)) {
       return { context: null, message: positions.length === 1
-        ? `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes one qualifier digit after the '.' (${names})`
-        : `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes 1 to ${positions.length} qualifier digits after the '.' (${names})` };
+        ? `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes one qualifier digit after the '${separator}' (${names})`
+        : `The ICF code '${code}' is not valid: ${COMPONENT_CODES[component]} takes 1 to ${positions.length} qualifier digits after the '${separator}' (${names})` };
     }
     const qualifiers = [];
     for (let i = 0; i < digits.length; i++) {