fhirsmith 0.11.2 → 0.12.0

package/stats-db.js

@@ -0,0 +1,127 @@
+const path = require('path');
+const fs = require('fs');
+const Database = require('better-sqlite3');
+const folders = require('./library/folder-setup');
+
+/**
+ * Persistent storage for the server's request statistics (issue #255).
+ *
+ * The in-memory counters in ServerStats reset every time the server restarts,
+ * which makes them useless for anything but "what has happened since the last
+ * deploy". This class writes them to a SQLite database that outlives restarts
+ * and upgrades.
+ *
+ * One row per (module, endpoint, operation) per collection interval, holding
+ * both numbers:
+ *
+ *  - the *delta*: what happened in that interval. This is what you graph -
+ *    plot count_delta against time and you have requests per interval without
+ *    any differencing at the query end.
+ *  - the *total*: the all-time cumulative count, carried across restarts by
+ *    reloading it at startup. This is what you quote as "how much has this
+ *    endpoint ever been asked to do", and it means a restart shows up as a
+ *    flat spot in the graph rather than a cliff back to zero.
+ *
+ * Rows are only written for keys that saw traffic in the interval, so idle
+ * endpoints cost nothing. Nothing is pruned: at 10 minute intervals a
+ * continuously busy (endpoint, operation) pair produces ~52,000 rows a year,
+ * which SQLite does not notice.
+ *
+ * better-sqlite3 (rather than sqlite3) on purpose: the writes are synchronous,
+ * so the final flush in ServerStats.finishStats() lands on disk before
+ * server.js calls process.exit(). A handful of inserts every ten minutes is
+ * well under a millisecond, so this does not put the event loop at risk.
+ */
+class StatsDatabase {
+
+  constructor(config, log) {
+    this.log = log || console;
+    this.config = config || {};
+    this.db = null;
+    this.path = StatsDatabase.resolvePath(this.config);
+  }
+
+  /**
+   * Where the database lives: config.database if given (relative paths resolve
+   * under the data folder's databases directory), otherwise stats.db there.
+   */
+  static resolvePath(config) {
+    const configured = config && config.database;
+    if (!configured) {
+      return path.join(folders.databasesDir(), 'stats.db');
+    }
+    return path.isAbsolute(configured) ? configured : path.join(folders.databasesDir(), configured);
+  }
+
+  /**
+   * Open the database, creating the file and the schema if they aren't there.
+   */
+  open() {
+    fs.mkdirSync(path.dirname(this.path), {recursive: true});
+    this.db = new Database(this.path);
+    this.db.pragma('journal_mode = WAL');
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS request_counts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        time INTEGER NOT NULL,
+        interval_ms INTEGER NOT NULL,
+        module TEXT NOT NULL,
+        endpoint TEXT NOT NULL,
+        operation TEXT NOT NULL,
+        count_delta INTEGER NOT NULL,
+        count_total INTEGER NOT NULL,
+        time_delta INTEGER NOT NULL,
+        time_total INTEGER NOT NULL
+      )
+    `);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_request_counts_time ON request_counts(time)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_request_counts_key ON request_counts(module, endpoint, operation, id)`);
+
+    this.insertStatement = this.db.prepare(`
+      INSERT INTO request_counts
+        (time, interval_ms, module, endpoint, operation, count_delta, count_total, time_delta, time_total)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    this.insertAll = this.db.transaction((time, intervalMs, rows) => {
+      for (const row of rows) {
+        this.insertStatement.run(time, intervalMs, row.module, row.endpoint, row.operation,
+          row.countDelta, row.countTotal, row.timeDelta, row.timeTotal);
+      }
+    });
+    return this;
+  }
+
+  /**
+   * The most recent cumulative total for each key, so counting resumes where
+   * the last run left off instead of starting again from zero.
+   */
+  loadTotals() {
+    if (!this.db) {
+      return [];
+    }
+    return this.db.prepare(`
+      SELECT module, endpoint, operation, count_total AS countTotal, time_total AS timeTotal
+      FROM request_counts
+      WHERE id IN (SELECT MAX(id) FROM request_counts GROUP BY module, endpoint, operation)
+    `).all();
+  }
+
+  /**
+   * Write one interval's worth of rows. All or nothing - if the transaction
+   * fails the caller keeps its deltas and tries again next interval.
+   */
+  write(time, intervalMs, rows) {
+    if (this.db && rows && rows.length > 0) {
+      this.insertAll(time, intervalMs, rows);
+    }
+  }
+
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}
+
+module.exports = StatsDatabase;

package/stats.js

@@ -1,6 +1,49 @@
 const { monitorEventLoopDelay } = require('perf_hooks');
 const {Utilities} = require("./library/utilities");
 const escape = require('escape-html');
+const StatsDatabase = require('./stats-db');
+
+// Requests that aren't counted by a module (the root page, the dashboard) are
+// attributed here, and requests that have no endpoint dimension (everything
+// outside the tx module) carry NO_ENDPOINT.
+const SERVER_MODULE = '(server)';
+const NO_ENDPOINT = '';
+
+/**
+ * A per-module view of the server statistics.
+ *
+ * Modules are handed one of these instead of the ServerStats itself, so that
+ * everything they count is attributed to them without each of the ~76 call
+ * sites having to name its own module. The API is deliberately the same shape
+ * as ServerStats, so a module can't tell the difference - except that
+ * countRequest takes an optional endpoint, which is how the tx module
+ * distinguishes /tx/r4 from /tx/r5.
+ */
+class ModuleStats {
+
+  constructor(parent, module) {
+    this.parent = parent;
+    this.module = module;
+  }
+
+  countRequest(name, tat, endpoint = NO_ENDPOINT) {
+    this.parent.countRequest(name, tat, this.module, endpoint);
+  }
+
+  addTask(name, frequency) { this.parent.addTask(name, frequency); }
+  task(name, state) { this.parent.task(name, state); }
+  taskDone(name, state) { this.parent.taskDone(name, state); }
+  taskError(name, state) { this.parent.taskError(name, state); }
+
+  // Pass-throughs for the handful of properties modules read off the stats
+  // object. These have to be getters, not copies, or a module would capture
+  // the value at construction time and never see it change.
+  get cachingModules() { return this.parent.cachingModules; }
+  get requestCount() { return this.parent.requestCount; }
+  get staticRequestCount() { return this.parent.staticRequestCount; }
+  get history() { return this.parent.history; }
+  get startTime() { return this.parent.startTime; }
+}
 
 class ServerStats {
   started = false;
@@ -16,13 +59,53 @@ class ServerStats {
   timer;
   cachingModules = [];
   taskMap = new Map();
+  // key (module/endpoint/operation) -> counter. See countRequest().
+  counters = new Map();
+  db = null;
 
-  constructor() {
+  constructor(config, log) {
+    this.config = config || {};
+    this.log = log || console;
+    if (this.config.intervalMinutes) {
+      this.intervalMs = this.config.intervalMinutes * 60 * 1000;
+    }
+    this.openDatabase();
     this.timer = setInterval(() => {
       this.recordMetrics();
     }, this.intervalMs);
   }
 
+  /**
+   * Open the persistent counter store and pick up where the last run of the
+   * server left off. Statistics must never be the reason the server won't
+   * start, so a failure here is logged and then ignored: the counters carry
+   * on in memory, they just don't survive the next restart.
+   */
+  openDatabase() {
+    if (this.config.enabled === false) {
+      return;
+    }
+    try {
+      this.db = new StatsDatabase(this.config, this.log).open();
+      for (const row of this.db.loadTotals()) {
+        const counter = this.counterFor(row.module, row.endpoint, row.operation);
+        counter.countTotal = row.countTotal;
+        counter.timeTotal = row.timeTotal;
+      }
+    } catch (e) {
+      this.log.error(`Unable to open the statistics database: ${e.message}. Statistics will not be persisted`);
+      this.db = null;
+    }
+  }
+
+  /**
+   * A view of the statistics that attributes everything counted through it to
+   * the named module (see ModuleStats).
+   */
+  forModule(module) {
+    return new ModuleStats(this, module);
+  }
+
   recordMetrics() {
     if (this.started) {
       const now = Date.now();
@@ -61,9 +144,12 @@ class ServerStats {
       this.requestTime = 0;
       this.lastTime = now;
 
-      // Prune old data (keep 24 hours)
+      // Prune old data (keep 24 hours). Only the in-memory history is pruned -
+      // the per-endpoint counters are persisted and kept indefinitely.
       const cutoff = now - (24 * 60 * 60 * 1000); // 24 hours ago
       this.history = this.history.filter(m => m.time > cutoff);
+
+      this.flushCounters(now, this.intervalMs);
     }
   }
 
@@ -77,11 +163,78 @@ class ServerStats {
     this.recordMetrics();
   }
 
-  countRequest(name, tat) {
-    // we ignore name for now, but we might split the tat tracking up by name
-    // at some stage
+  /**
+   * The counter for one (module, endpoint, operation), created on first use.
+   *
+   * countDelta/timeDelta accumulate within the current interval and are reset
+   * each time they're written out; countTotal/timeTotal are cumulative for the
+   * life of the database, not the life of the process.
+   */
+  counterFor(module, endpoint, operation) {
+    const key = `${module}\u001f${endpoint}\u001f${operation}`;
+    let counter = this.counters.get(key);
+    if (!counter) {
+      counter = {
+        module: module, endpoint: endpoint, operation: operation,
+        countDelta: 0, timeDelta: 0, countTotal: 0, timeTotal: 0
+      };
+      this.counters.set(key, counter);
+    }
+    return counter;
+  }
+
+  /**
+   * Count one request. Modules go through their own ModuleStats, which fills
+   * in module (and, for tx, the endpoint) for them.
+   *
+   * @param {string} name - the operation, e.g. '$expand' or 'login'
+   * @param {number} tat - turnaround time in ms
+   * @param {string} module - the module that served it
+   * @param {string} endpoint - the endpoint within the module, where the
+   *   module has more than one (the tx module does; nothing else does yet)
+   */
+  countRequest(name, tat, module = SERVER_MODULE, endpoint = NO_ENDPOINT) {
     this.requestCount++;
     this.requestTime = this.requestTime + tat;
+
+    const counter = this.counterFor(module || SERVER_MODULE, endpoint || NO_ENDPOINT, name || '(unnamed)');
+    counter.countDelta++;
+    counter.countTotal++;
+    counter.timeDelta = counter.timeDelta + tat;
+    counter.timeTotal = counter.timeTotal + tat;
+  }
+
+  /**
+   * Write out the counters that saw traffic this interval, and start the next
+   * one. The deltas are only cleared if the write succeeded, so a transient
+   * database problem delays the numbers rather than losing them (the interval
+   * they're eventually written against is longer, which is what interval_ms on
+   * the row is for).
+   */
+  flushCounters(now, intervalMs) {
+    if (!this.db) {
+      return 0;
+    }
+    const rows = [];
+    for (const counter of this.counters.values()) {
+      if (counter.countDelta > 0) {
+        rows.push({...counter});
+      }
+    }
+    if (rows.length === 0) {
+      return 0;
+    }
+    try {
+      this.db.write(now, intervalMs, rows);
+    } catch (e) {
+      this.log.error(`Unable to write statistics: ${e.message}`);
+      return 0;
+    }
+    for (const counter of this.counters.values()) {
+      counter.countDelta = 0;
+      counter.timeDelta = 0;
+    }
+    return rows.length;
   }
 
   addTask(name, frequency) {
@@ -144,6 +297,17 @@ class ServerStats {
 
   finishStats() {
     clearInterval(this.timer);
+    // Synchronous, so the last partial interval is on disk before server.js
+    // calls process.exit().
+    this.flushCounters(Date.now(), Date.now() - (this.lastTime || this.startTime));
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch (e) {
+        this.log.error(`Unable to close the statistics database: ${e.message}`);
+      }
+      this.db = null;
+    }
   }
 
   // Live cache aggregates across all registered caching modules (defensive: a
@@ -174,4 +338,6 @@ class ServerStats {
     }
   }
 }
-module.exports = ServerStats;
+module.exports = ServerStats;
+module.exports.ModuleStats = ModuleStats;
+module.exports.SERVER_MODULE = SERVER_MODULE;

package/translations/Messages.properties

@@ -1101,7 +1101,10 @@ Unable_to_resolve_system__value_set_has_multiple_matches = The System URI could
 Unable_to_resolve_system__value_set_has_no_includes_or_expansion = The System URI could not be determined for the code ''{0}'' in the ValueSet ''{1}'': value set has no includes or expansion
 UNABLE_TO_RESOLVE_SYSTEM_SYSTEM_IS_INDETERMINATE = The code system {1} referred to from value set {0} has a grammar, and the code might be valid in it
 Unable_to_resolve_value_Set_ = A definition for the value Set ''{0}'' could not be found
-CACHE_ID_UNKNOWN = The cache ''{0}'' is not known to this server. Caches are created with $cache-control?mode=start; this one was never created, or has expired or been released
+CACHE_ID_UNKNOWN = The cache ''{0}'' was never issued by this server, and this server has no record of it ever existing. Caches are created with $cache-control?mode=start, and a cache-id is only valid on the server instance and endpoint that issued it - either it was issued somewhere else, or this server has restarted since it was issued
+CACHE_ID_CLOSED = The cache ''{0}'' was closed {1} ago by the client, using $cache-control?mode=end (it had been open for {2}). It did not expire and it was not idle: something in the client released this cache while this request was still using it
+CACHE_ID_EXPIRED = The cache ''{0}'' expired: it went {1} without being used, and this server closes caches that have been idle for more than {2} (this one was dropped {3} ago). Every request that uses a cache resets its idle clock, so a client that keeps using a cache will not see this
+CACHE_ID_CLEARED = The cache ''{0}'' was dropped {1} ago, when this server cleared all of its caches
 Unable_to_validate_code_without_using_server = Unable to validate code without using server because: {0}
 Undefined_attribute__on__for_type__properties__ = Undefined attribute ''@{0}'' on {1} for type {2}
 Undefined_element_ = Undefined element ''{0}'' at {1}

package/tx/cs/cs-api.md

@@ -105,7 +105,7 @@ All are `async`.
 | `parent(code)` | `null` | The parent concept, for hierarchical code systems. |
 | `extensions(code)` | `null` | FHIR extensions on the concept, if any. |
 | `properties(code)` | `[]` | The defined properties for the concept. |
-| `incompleteValidationMessage(code)` | `null` | A message explaining why validation may be incomplete (used by SCT). |
+| `incompleteValidationMessage(code)` | `null` | A message explaining why validation may be incomplete. No provider overrides this: SNOMED expressions are checked against the concept model, and the only things it cannot check are ones SNOMED itself publishes no rule for. |
 | `sameConcept(a, b)` | `false` | Returns `true` if `a` and `b` refer to the same concept (e.g. different expression forms). |
 | `isDisplay(designation)` | `false` | Called for designations not already marked with a standard display use code; return `true` to treat the designation as a display. |
 | `subsumesTest(codeA, codeB)` | `'not-subsumed'` | Returns one of `equivalent`, `subsumes`, `subsumed-by`, or `not-subsumed`. |

package/tx/cs/cs-snomed.js

@@ -148,6 +148,58 @@ class SnomedServices {
       refSetIndex: this.refSetIndex
     }, this.isAIndex);
 
+    // The expression services check the MRCM attribute ranges, but those are ECL
+    // and the ECL engine lives here, so hand them an evaluator. Returning null
+    // means "could not decide", and leaves the value unchecked.
+    this.expressionServices.eclConstraintMatcher = (constraint, value) => this.mrcmRangeSatisfied(constraint, value);
+    this._mrcmRangeCache = new Map();
+  }
+
+  /**
+   * Does this refinement value satisfy an MRCM range constraint?
+   *
+   * @param {string} constraint - the rangeConstraint ECL, e.g. "<< 182353008 |Side|"
+   * @param {SnomedExpression} value - the refinement's value expression
+   * @returns {boolean|null} null when the constraint cannot be evaluated
+   */
+  mrcmRangeSatisfied(constraint, value) {
+    let entry = this._mrcmRangeCache.get(constraint);
+    if (entry === undefined) {
+      entry = null;
+      try {
+        const ast = new ECLParser(new ECLLexer(constraint).tokenize()).parse();
+        const ctxt = this._evalECLNode(ast, null);
+        entry = {
+          ast: ast,
+          wildcard: !!ctxt.eclWildcard,
+          members: new Set(this._eclToIndexArray(ctxt))
+        };
+      } catch (error) {
+        // Concrete value ranges (dec/int/str) and anything else the ECL engine
+        // does not support: remembered as unusable so it is parsed only once.
+        entry = null;
+      }
+      this._mrcmRangeCache.set(constraint, entry);
+    }
+    if (!entry) {
+      return null;
+    }
+    if (entry.wildcard) {
+      return true;
+    }
+
+    const concepts = (value.concepts || []).filter(c => c.reference != null && c.reference !== NO_REFERENCE);
+    const refined = value.hasRefinements() || value.hasRefinementGroups();
+    if (!refined) {
+      if (concepts.length === 0) {
+        return null; // a concrete value, or nothing we can resolve
+      }
+      // Every focus concept of a plain value must be in the constraint's set.
+      return concepts.every(c => entry.members.has(c.reference));
+    }
+    // A refined value: ask the ECL engine whether the expression satisfies the
+    // constraint (it knows that a refinement of X is still << X).
+    return this._eclExpressionSatisfies({ expression: value }, entry.ast, null);
   }
 
   close() {
@@ -664,7 +716,7 @@ class SnomedServices {
     // we actually need the full concept list, otherwise filterSize returns 0
     // and the iteration yields nothing. Materialise active concepts now.
     if (forIteration && result.eclWildcard && (!result.descendants || result.descendants.length === 0)) {
-      result.descendants = this._eclEnumerateActiveConcepts(opContext);
+      result.descendants = this._eclEnumerateAllConcepts(opContext);
       delete result.eclWildcard;
       // The materialised wildcard form differs from the lazy (eclWildcard) form,
       // so mark it: the filter cache must not share it across iteration modes.
@@ -677,31 +729,29 @@ class SnomedServices {
   };
 
   /**
-   * Return every active concept's index. Used to materialise wildcard results
-   * when the filter needs to be iterated over (e.g. $expand).
+   * Return every concept's index. Used to materialise wildcard results when the
+   * filter needs to be iterated over (e.g. $expand).
+   *
+   * `*` means every concept the server knows, so this deliberately walks the
+   * concept table rather than descending from 138875005 |SNOMED CT Concept|.
+   * Two kinds of concept are in the table but not reachable from that root:
+   * inactive concepts (their is-a relationships are inactive too), and the
+   * foundation-metadata concepts that a subset carries without their is-a
+   * relationships - module concepts above all. Both belong in `*`, and both are
+   * counted by countAllCodes, so descending from the root made $expand of a
+   * `constraint = *` filter disagree with $expand of the whole code system.
+   *
+   * Inactive concepts are not filtered out here: activeOnly is applied by the
+   * expansion itself (see ValueSetExpander.processCodes), which is what lets one
+   * enumeration serve both activeOnly=true and activeOnly=false.
    * @returns {number[]}
    */
-  _eclEnumerateActiveConcepts = function (opContext) {
-    // The wildcard `*` enumerates the SNOMED CT concept hierarchy: the root
-    // 138875005 |SNOMED CT Concept| and its descendants. This excludes the
-    // foundation-metadata concepts that appear in a subset's concept table
-    // (referenced by the RF2 files as module / type / acceptability ... ids)
-    // without their is-a relationships, so they are not reachable from the root
-    // and are not returned by `*` (matching Snowstorm). On a full edition every
-    // real concept is under the root, so nothing is lost.
-    const rootRes = this.concepts.findConcept(138875005n);
-    if (rootRes && rootRes.found) {
-      return this.filterIsA(138875005n, true).descendants;
-    }
-    // Fallback (no recognisable root): every active concept.
+  _eclEnumerateAllConcepts = function (opContext) {
     const all = [];
     const n = this.concepts.count();
     for (let i = 0; i < n; i++) {
-      if (opContext) opContext.deadCheck('ecl:enumerateActiveConcepts');
-      const concept = this.concepts.getConceptByCount(i);
-      if ((concept.flags & 0x0F) === 0) {
-        all.push(concept.index);
-      }
+      if (opContext) opContext.deadCheck('ecl:enumerateAllConcepts');
+      all.push(this.concepts.getConceptByCount(i).index);
     }
     return all;
   };
@@ -918,7 +968,7 @@ class SnomedServices {
   };
 
   /**
-   * Wildcard — all active concepts.  The eclWildcard flag tells filterCheck /
+   * Wildcard — every concept, active or not.  The eclWildcard flag tells filterCheck /
    * filterLocate to accept every active concept without enumeration.
    * @returns {SnomedFilterContext}
    */
@@ -1312,15 +1362,15 @@ class SnomedServices {
 
   /**
    * Like _eclToIndexArray, but if the context is a bare wildcard (no
-   * descendants populated) it materialises the full active-concept list
-   * via _eclEnumerateActiveConcepts. Used by dotted/refined evaluation,
+   * descendants populated) it materialises the full concept list
+   * via _eclEnumerateAllConcepts. Used by dotted/refined evaluation,
    * which need an explicit concept set to iterate over.
    * @param {SnomedFilterContext} ctx
    * @returns {number[]}
    */
   _eclResolveSet = function (ctx, opContext) {
     if (ctx.eclWildcard && (!ctx.descendants || ctx.descendants.length === 0)) {
-      return this._eclEnumerateActiveConcepts(opContext);
+      return this._eclEnumerateAllConcepts(opContext);
     }
     return this._eclToIndexArray(ctx);
   };
@@ -1369,9 +1419,9 @@ class SnomedServices {
     const rightSet = new Set(this._eclToIndexArray(right));
 
     if (left.eclWildcard) {
-      // Wildcard minus the right set: use the shared active-concept enumeration
-      // (the root hierarchy) so `*` behaves consistently everywhere.
-      result.descendants = this._eclEnumerateActiveConcepts(opContext)
+      // Wildcard minus the right set: use the shared enumeration so `*` behaves
+      // consistently everywhere.
+      result.descendants = this._eclEnumerateAllConcepts(opContext)
         .filter(idx => !rightSet.has(idx));
       return result;
     }
@@ -1734,19 +1784,6 @@ class SnomedProvider extends BaseCSServices {
     }
   }
 
-  async incompleteValidationMessage(context) {
-
-    const ctxt = await this.#ensureContext(context);
-
-    if (!ctxt) return null;
-
-    if (ctxt.isComplex()) {
-      return "The expression is grammatically correct and the concepts are valid, but the expression has not been checked against the SNOMED CT concept model (MRCM)";
-    } else {
-      return null;
-    }
-  }
-
   async locateIsA(code, parent, disallowParent = false) {
 
 
@@ -1881,25 +1918,37 @@ class SnomedProvider extends BaseCSServices {
       if (ctxt instanceof SnomedExpressionContext) {
         // ignore concepts for now, but list refinements and refinement groups
         for (const refinement of ctxt.expression.refinements) {
-          const codeA = refinement.name.code;
-          const codeB = refinement.value.describe();
-          const description = await this.display(codeB);
-          let p = this._addCodeProperty(params, 'property', codeA, codeB, null, description);
-          p.part.push({name: 'code-display', valueString: await this.display(codeA)});
+          await this._addRefinementProperty(params, refinement);
         }
         for (const refinementGroup of ctxt.expression.refinementGroups) {
           for (const refinement of refinementGroup.refinements) {
-            const codeA = refinement.name.code;
-            const codeB = refinement.value.describe();
-            const description = await this.display(codeB);
-            let p = this._addCodeProperty(params, 'property', codeA, codeB, null, description);
-            p.part.push({name: 'code-display', valueString: await this.display(codeA)});
+            await this._addRefinementProperty(params, refinement);
           }
         }
       }
     }
   }
 
+  /**
+   * Report one refinement of a post-coordinated expression as a lookup property.
+   *
+   * The value is handled as an expression, not as a string: SnomedExpression's
+   * describe() is a human-readable rendering that joins concepts and refinements
+   * with commas ("85562004,272741003=24028007"), so round-tripping it through
+   * display() parsed it back as SCG and failed on any refined value.
+   *
+   * @param {Object} params - the Parameters being built
+   * @param {SnomedRefinement} refinement
+   */
+  async _addRefinementProperty(params, refinement) {
+    const codeA = refinement.name.code;
+    const value = SnomedExpressionContext.fromExpression('', refinement.value);
+    const codeB = await this.code(value);
+    const description = await this.display(value);
+    const p = this._addCodeProperty(params, 'property', codeA, codeB, null, description);
+    p.part.push({name: 'code-display', valueString: await this.display(codeA)});
+  }
+
   // Filter support
   async doesFilter(prop, op, value) {
     if (prop === 'concept') {
@@ -2131,7 +2180,7 @@ class SnomedProvider extends BaseCSServices {
     // A wildcard (`*`) set is lazy - it carries the eclWildcard flag rather than a
     // materialised descendant list - so count the active concepts it denotes.
     if (set.eclWildcard && (!set.descendants || set.descendants.length === 0)) {
-      return this.sct._eclEnumerateActiveConcepts(this.opContext).length;
+      return this.sct._eclEnumerateAllConcepts(this.opContext).length;
     }
     if (set.matches && set.matches.length > 0) {
       return set.matches.length;
@@ -2183,7 +2232,7 @@ class SnomedProvider extends BaseCSServices {
     const reference = ctxt.getReference();
 
     if (set.eclWildcard) {
-      return this.sct.isActive(reference) ? ctxt : null;
+      return ctxt; // `*` is every concept; inactive ones included
     }
 
     // A post-coordinated expression validated against an ECL value set: test the
@@ -2266,7 +2315,7 @@ class SnomedProvider extends BaseCSServices {
       return this.#descendantsHas(set, reference);
     }
     if (set.eclWildcard) {
-      return this.sct.isActive(reference);
+      return true; // `*` is every concept; inactive ones included
     }
     return false;
   }

package/tx/library/conceptmap.js

@@ -173,6 +173,45 @@ class ConceptMap extends CanonicalResource {
     return result;
   }
 
+  /**
+   * The canonical references this map defers to. Only group.unmapped.otherMap creates
+   * such a dependency: a map that names another map cannot be resolved without it, so
+   * it has to be consulted first.
+   * @returns {string[]} canonical references, as written (may or may not be versioned)
+   */
+  listDependencies() {
+    const result = [];
+    for (const g of this.jsonObj.group || []) {
+      if (g.unmapped && g.unmapped.mode === 'other-map' && g.unmapped.otherMap) {
+        if (!result.includes(g.unmapped.otherMap)) {
+          result.push(g.unmapped.otherMap);
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * The groups that would have been consulted for this coding, whether or not any of
+   * their elements matched. group.unmapped only applies to a group that was in scope
+   * for the translation, so the caller needs the same source/target test that
+   * listTranslations applies - without the per-element filter.
+   * @returns {Object[]} the matching group objects
+   */
+  listGroupsInScope(coding, targetScope, targetSystem) {
+    const result = [];
+    const vurl = VersionUtilities.vurl(coding.system, coding.version);
+    const all = this.canonicalMatches(targetScope, this.targetScope);
+    for (const g of this.jsonObj.group || []) {
+      const sourceOk = this.canonicalMatches(vurl, g.source);
+      const targetOk = !targetSystem || this.canonicalMatches(targetSystem, g.target);
+      if (all || (sourceOk && targetOk)) {
+        result.push(g);
+      }
+    }
+    return result;
+  }
+
   listTranslationsReverse(coding, targetScope, sourceSystem) {
     let result = [];
     let vurl = VersionUtilities.vurl(coding.system, coding.version);