fhirsmith 0.16.1 → 0.18.0

package/tx/tx.js

@@ -59,6 +59,8 @@ const ConceptUsageTracker = require("./usage-tracker");
 const ProblemFinder = require("./problems");
 const { buildOperationOutcome, outcomeFromError } = require('./library/operation-outcome');
 const txOpenApi = require('./openapi');
+const { SyndicationStore } = require('./syndication/syndication-store');
+const syndicationFeed = require('./syndication/syndication-feed');
 // const {writeFileSync} = require("fs");
 
 class TXModule {
@@ -140,9 +142,14 @@ class TXModule {
    * Initialize the TX module
    * @param {Object} config - Module configuration
    * @param {express.Application} app - Express application for registering endpoints
+   * @param {Object} [server] - server level settings: {hostName} (config.hostName)
    */
-  async initialize(config, app) {
+  async initialize(config, app, server = {}) {
     this.config = config;
+    // the server's public host name, when it is configured as one (it is also used as a
+    // display name, so anything that isn't a host name is ignored)
+    this.publicHost = typeof server.hostName === 'string' && /^[A-Za-z0-9.-]+(:[0-9]{1,5})?$/.test(server.hostName)
+      ? server.hostName : null;
     // Initialize logger with config settings
     this.log = Logger.getInstance().child({
       module: 'tx',
@@ -166,6 +173,7 @@ class TXModule {
     // Off unless the operator opts in. This gates the nav item as well as the route, so a
     // server that does not publish its library source shows no link to it.
     txHtml.setPublishLibrarySource(config.publishLibrarySource === true);
+    txHtml.setSyndicationFeed(!!(config.syndication && config.syndication.enabled));
 
     // Validate config
     if (!config.librarySource) {
@@ -211,7 +219,7 @@ class TXModule {
           }
         };
         void prune(); // errors are logged inside
-        this.timers.push(setInterval(prune, 24 * 60 * 60 * 1000));
+        this.timers.push(setInterval(() => void prune(), 24 * 60 * 60 * 1000));
       }
     }
 
@@ -236,6 +244,17 @@ class TXModule {
     // Load the library from YAML
     this.log.info(`Loading library from: ${config.librarySource}`);
     this.library = new Library(config.librarySource, config.vsacCfg, this.log, this.stats);
+
+    // The syndication feed: content is recorded in the store as the library loads it, from
+    // the time the administrator turns it on (see tx/syndication). One store serves every
+    // endpoint, since the library is shared. If it is turned on and the store can't be
+    // opened, that stops startup.
+    this.syndicationStore = null;
+    if (config.syndication && config.syndication.enabled) {
+      this.syndicationStore = new SyndicationStore(path.join(this.library.cacheFolder, 'syndication'), this.log).open();
+      this.library.syndication = this.syndicationStore;
+      this.log.info(`Syndication feed enabled: store in ${this.syndicationStore.folder}`);
+    }
     this.log.info(`Load...`);
     await this.library.load();
     this.log.info('Library loaded successfully');
@@ -305,13 +324,14 @@ class TXModule {
     if (this.stats) {
       this.stats.addTask("Client Cache", "5 min");
     }
-    this.timers.push(setInterval(async () => {
+    const updateCodeSystemList = async () => {
       try {
         await endpointInfo.provider.updateCodeSystemList();
       } catch (error) {
         this.log.error(`Error updating CodeSystem list for ${endpointPath}: ${error.message}`);
       }
-    }, 60 * 1000));
+    };
+    this.timers.push(setInterval(() => void updateCodeSystemList(), 60 * 1000)); // errors are logged inside
     this.log.info(`CodeSystem list update scheduled for ${endpointPath}`);
     this.timers.push(setInterval(() => {
       endpointInfo.resourceCache.prune(cacheTimeoutMs);
@@ -1132,6 +1152,10 @@ class TXModule {
       });
     }
 
+    if (this.syndicationStore) {
+      this.setupSyndicationRoutes(router, endpointPath);
+    }
+
     // Metadata / CapabilityStatement
     router.get('/metadata', async (req, res) => {
       const start = Date.now();
@@ -1331,6 +1355,31 @@ class TXModule {
     };
   }
 
+  /**
+   * The paragraph for the server's daily report: how many of each operation
+   * were performed, over all the endpoints.
+   */
+  dailyReport({since, now}) {
+    const {plural} = require('../library/daily-report');
+    if (!this.stats) {
+      return null;
+    }
+    const counts = this.stats.countsSince(since, now);
+    if (counts.total === 0) {
+      return 'No requests were served.';
+    }
+    // the FHIR operations first, busiest first, then the rest (pages, metadata, reads)
+    const names = Object.keys(counts.operations).sort((a, b) => {
+      const opA = a.startsWith('$') ? 0 : 1;
+      const opB = b.startsWith('$') ? 0 : 1;
+      return opA - opB || counts.operations[b] - counts.operations[a] || a.localeCompare(b);
+    });
+    const list = names.map(n => `${n} ${counts.operations[n].toLocaleString('en-US')}`).join(', ');
+    const endpoints = Object.keys(counts.endpoints).filter(e => e).length;
+    const where = endpoints > 1 ? ` over ${plural(endpoints, 'endpoint')}` : '';
+    return `${counts.total.toLocaleString('en-US')} requests were served${where}: ${list}.`;
+  }
+
   /**
    * Shutdown the module
    */
@@ -1340,6 +1389,10 @@ class TXModule {
       clearInterval(timer);
     }
     this.timers = [];
+    if (this.syndicationStore) {
+      // let an induction in progress finish, so the store isn't left with a half-copied file
+      await this.syndicationStore.whenIdle();
+    }
     // Clean up any resources if needed
     await this.library.close();
     if (this.closureStore) {
@@ -1349,6 +1402,93 @@ class TXModule {
     this.log.info('TX module shut down');
   }
 
+  /**
+   * The syndication feed for an endpoint (Terminology Syndication Feed IG, RFC 5005
+   * archived feeds) - see tx/syndication/syndication-feed.js. Atom unless HTML is asked for.
+   */
+  /**
+   * The public url of an endpoint, for the links in its feed: from the configured host name
+   * (config.hostName), so the links don't depend on what a client puts in the Host header.
+   * Only without one does it fall back to the request (as for a local test server).
+   */
+  syndicationBase(req, endpointPath) {
+    if (this.publicHost) {
+      return `https://${this.publicHost}${endpointPath}`;
+    }
+    return `${req.protocol}://${req.get('host')}${endpointPath}`;
+  }
+
+  setupSyndicationRoutes(router, endpointPath) {
+    const sendFeed = async (req, res, page) => {
+      const start = Date.now();
+      try {
+        const params = {
+          store: this.syndicationStore,
+          endpointPath,
+          fhirVersion: req.txEndpoint.fhirVersion,
+          base: this.syndicationBase(req, endpointPath),
+          page,
+          title: this.config.title,
+          serverVersion: packageJson.version
+        };
+        if (txHtml.acceptsHtml(req)) {
+          const content = syndicationFeed.renderHtml(params);
+          if (content == null) {
+            res.status(404).json(this.operationOutcome('error', 'not-found', 'There is no such syndication archive'));
+            return;
+          }
+          let txhtml = new TxHtmlRenderer(new Renderer(req.txOpContext, req.txProvider), this.liquid, this.languages, this.i18n, endpointPath);
+          const title = page == null ? 'Syndication Feed' : `Syndication Feed (archive ${page})`;
+          const html = await txhtml.renderPage(title, content, req.txEndpoint, req.txStartTime);
+          res.setHeader('Content-Type', 'text/html');
+          res.send(html);
+          return;
+        }
+        const xml = syndicationFeed.renderAtom(params);
+        if (xml == null) {
+          res.status(404).json(this.operationOutcome('error', 'not-found', 'There is no such syndication archive'));
+          return;
+        }
+        // an archive never changes; the current document changes whenever content is added.
+        // An archive is only cacheable forever when its links come from the configured host
+        // name - links made from the request's Host header must not be cached for others
+        res.setHeader('Cache-Control', page == null || !this.publicHost ? 'no-cache' : 'public, max-age=31536000, immutable');
+        res.setHeader('Content-Type', 'application/atom+xml; charset=utf-8');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.send(xml);
+      } catch (error) {
+        this.log.error(`Error rendering syndication feed: ${error.message}`);
+        res.status(500).json(this.operationOutcome('error', 'exception', 'Unable to render the syndication feed'));
+      } finally {
+        this.countRequest(endpointPath, 'syndication', Date.now() - start);
+      }
+    };
+
+    router.get('/syndication', (req, res) => sendFeed(req, res, null));
+
+    router.get('/syndication/archive/:page', (req, res) => {
+      const page = /^[1-9][0-9]{0,8}$/.test(req.params.page) ? Number(req.params.page) : -1;
+      return sendFeed(req, res, page);
+    });
+
+    // not rate limited here: as for the rest of the tx module, nginx does that (see nginx.md)
+    router.get('/syndication/files/:name', (req, res) => {
+      const file = this.syndicationStore.filePath(req.params.name);
+      if (!file) {
+        res.status(404).json(this.operationOutcome('error', 'not-found', 'There is no such syndication file'));
+        return;
+      }
+      // copies in the store never change
+      res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+      res.setHeader('Content-Type', 'application/fhir+json');
+      // the file is whatever the source folder held: never let a browser sniff it as a page
+      res.setHeader('X-Content-Type-Options', 'nosniff');
+      // served from the store's folder by the store's own name for it (sendFile refuses
+      // anything that would leave root)
+      res.sendFile(path.basename(file), { root: this.syndicationStore.filesFolder });
+    });
+  }
+
   trimParameters(params) {
     if (!params || !params.parameter) {
       return params;
@@ -1514,8 +1654,11 @@ class TXModule {
     if (hdr) {
       return parseInt(hdr);
     }
+    // the tx-ecosystem test runner (Tools/Java) always gets the test limit, so every server
+    // gives it the same answer. Otherwise the configured externalLimit - it used to be read
+    // only when internalLimit was configured too, so setting it alone did nothing
     let isTest = req.header("User-Agent") == 'Tools/Java';
-    if (this.config.internalLimit && !isTest) return this.config.externalLimit; else return EXTERNAL_TEST_DEFAULT_LIMIT;
+    if (this.config.externalLimit && !isTest) return this.config.externalLimit; else return EXTERNAL_TEST_DEFAULT_LIMIT;
   }
 
 }

package/tx/vs/vs-database.js

@@ -4,6 +4,9 @@ const sqlite3 = require('sqlite3').verbose();
 const { VersionUtilities } = require('../../library/version-utilities');
 const ValueSet = require("../library/valueset");
 
+// Settings key written once a package cache has been fully populated (see isComplete)
+const CACHE_COMPLETE_KEY = 'cache-complete';
+
 // Columns that can be returned directly without parsing JSON
 const INDEXED_COLUMNS = ['id', 'url', 'version', 'date', 'description', 'name', 'publisher', 'status', 'title'];
 
@@ -485,6 +488,29 @@ class ValueSetDatabase {
     });
   }
 
+  /**
+   * True if this cache was fully populated: markComplete() was reached. A cache
+   * whose population was cut short (the process killed part way through) has no
+   * marker - and so does a file too damaged to open or read - so it reports false.
+   * @returns {Promise<boolean>}
+   */
+  async isComplete() {
+    try {
+      return (await this.getSetting(CACHE_COMPLETE_KEY)) != null;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Record that this cache has been fully populated. Called once, after the last
+   * value set has been written
+   * @returns {Promise<void>}
+   */
+  async markComplete() {
+    await this.setSetting(CACHE_COMPLETE_KEY, new Date().toISOString());
+  }
+
   /**
    * Insert or update a single ValueSet in the database
    * @param {Object} valueSet - The ValueSet resource

package/tx/vs/vs-package.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const { assertNoActiveContent } = require('../../library/narrative-check');
 const fs = require('fs').promises;
 const { AbstractValueSetProvider } = require('./vs-api');
 const { PackageContentLoader } = require('../../library/package-manager');
@@ -21,7 +22,9 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     super();
     validateParameter(packageLoader, "packageLoader", PackageContentLoader);
     this.packageLoader = packageLoader;
-    this.dbPath = path.join(packageLoader.packageFolder, '.valuesets.db');
+    // -2: caches from before value sets were checked for active content in their narrative
+    // are rebuilt (see initialize)
+    this.dbPath = path.join(packageLoader.packageFolder, '.valuesets-2.db');
     this.database = new ValueSetDatabase(this.dbPath);
     this.valueSetMap = new Map();
     this.initialized = false;
@@ -45,12 +48,21 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
       return;
     }
     await this.packageLoader.initialize();
-
-    const dbExists = await this.database.exists();
+    await fs.rm(path.join(this.packageLoader.packageFolder, '.valuesets.db'), { force: true }); // the old cache
+
+    // A cache is only used once its population finished. One that was cut short
+    // (the process killed part way through) would otherwise be trusted forever,
+    // silently missing whatever hadn't been written yet
+    let dbExists = await this.database.exists();
+    if (dbExists && !(await this.database.isComplete())) {
+      require('../../library/logger').getInstance().child({ module: 'tx' })
+        .warn(`Package ${this.packageLoader.pid ? this.packageLoader.pid() : ''}: value set cache ${this.dbPath} is incomplete - rebuilding it`);
+      await this.#discardDatabase();
+      dbExists = false;
+    }
 
     if (!dbExists) {
-      await this.database.create();
-      await this._populateDatabase();
+      await this.#buildDatabase();
     }
 
     this.valueSetMap = await this.database.loadAllValueSets(this.sourcePackage());
@@ -60,11 +72,8 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     // package-manager.js): if any cached value set still carries a "system|version"
     // include or a pipe in its url, rebuild this cache from the package.
     if (dbExists && this.#hasPipeVersionedCanonicals()) {
-      await this.database.close();
-      await fs.rm(this.dbPath, { force: true });
-      this.database = new ValueSetDatabase(this.dbPath);
-      await this.database.create();
-      await this._populateDatabase();
+      await this.#discardDatabase();
+      await this.#buildDatabase();
       this.valueSetMap = await this.database.loadAllValueSets(this.sourcePackage());
     }
 
@@ -84,6 +93,27 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     this.initialized = true;
   }
 
+  /**
+   * Create the cache and fill it from the package. The complete marker is written
+   * last, so a build that doesn't finish is detected (and redone) next time
+   * @private
+   */
+  async #buildDatabase() {
+    await this.database.create();
+    await this._populateDatabase();
+    await this.database.markComplete();
+  }
+
+  /**
+   * Close and delete the cache file, leaving a fresh (not yet created) database
+   * @private
+   */
+  async #discardDatabase() {
+    await this.database.close();
+    await fs.rm(this.dbPath, { force: true });
+    this.database = new ValueSetDatabase(this.dbPath);
+  }
+
   /**
    * True if any loaded value set still has a pipe-versioned canonical (url or
    * compose include/exclude system) - the signature of a cache written before
@@ -134,6 +164,8 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
           // don't store a value set the server can't use (e.g. one that contains a
           // CodeSystem): it would be listed by search, and fail when read
           checkContained(valueSet);
+          // its narrative is shown as-is in a page, so it must not carry script
+          assertNoActiveContent(valueSet);
         } catch (e) {
           require('../../library/logger').getInstance().child({ module: 'tx' })
             .warn(`Package ${this.packageLoader.pid ? this.packageLoader.pid() : ''}: skipping ValueSet ${valueSet.url}: ${e.message}`);

package/tx/vs/vs-vsac.js

@@ -26,7 +26,7 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
    * @param {string} config.apiKey - API key for VSAC authentication
    * @param {string} config.cacheFolder - Local folder for cached database
    * @param {number} [config.refreshIntervalHours=24] - Hours between refresh scans
-   * @param {string} [config.baseUrl='http://cts.nlm.nih.gov/fhir'] - Base URL for VSAC FHIR server
+   * @param {string} [config.baseUrl='https://cts.nlm.nih.gov/fhir'] - Base URL for VSAC FHIR server
    * @param {number} [config.timeoutMs=120000] - HTTP request timeout in milliseconds
    * @param {string} [config.resyncPassword] - If set, enables the operator "resync a ValueSet"
    *   form on the /info page, gated by this password. If unset, the form is not offered.
@@ -43,7 +43,12 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
     // Optional operator password for the on-demand resync form (see info()).
     this.resyncPassword = config.resyncPassword || null;
     this.cacheFolder = folders.ensureFilePath("terminology-cache/vsac");
-    this.baseUrl = config.baseUrl || 'http://cts.nlm.nih.gov/fhir';
+    // https: every request carries the API key. (VSAC redirects http to https, but only after
+    // the key has been sent in the clear)
+    this.baseUrl = (config.baseUrl || 'https://cts.nlm.nih.gov/fhir').replace(/\/+$/, '');
+    if (this.baseUrl.startsWith('http://')) {
+      console.warn(`VSAC: baseUrl ${this.baseUrl} is http, so the API key is sent unencrypted - use https`);
+    }
     this.refreshIntervalHours = config.refreshIntervalHours || 24;
 
     this.dbPath = path.join(this.cacheFolder, 'vsac-valuesets.db');
@@ -397,10 +402,24 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
       return null;
     }
 
-    // Extract relative path from full URL
-    let s = nextLink.url;
-    s = s.replace(this.baseUrl, '');
-    return s;
+    // Followed only on the VSAC server itself, as a path under baseUrl: the request carries the
+    // API key, so a next link must not be able to send it anywhere else. The scheme is ignored -
+    // VSAC's links can say http - and the request goes out on baseUrl's
+    let next;
+    let base;
+    try {
+      base = new URL(this.baseUrl);
+      next = new URL(nextLink.url, this.baseUrl + '/');
+    } catch (e) {
+      console.warn(`VSAC: ignoring next link ${String(nextLink.url).substring(0, 200)}: ${e.message}`);
+      return null;
+    }
+    const basePath = base.pathname.replace(/\/+$/, '');
+    if (next.host !== base.host || !(next.pathname === basePath || next.pathname.startsWith(basePath + '/'))) {
+      console.warn(`VSAC: ignoring next link ${String(nextLink.url).substring(0, 200)}: it is not on ${this.baseUrl}`);
+      return null;
+    }
+    return next.pathname.substring(basePath.length) + next.search;
   }
 
   /**

package/tx/workers/expand.js

@@ -458,6 +458,19 @@ class ValueSetExpander {
           }
         }
 
+        // properties the code system always reports (ICD-11's classificationCode), unless
+        // the request asked for them anyway and the loops here add them
+        if (csProps != null && cs != null && !this.params.properties.includes('*')) {
+          for (const pn of cs.mandatoryExpansionProperties()) {
+            if (!this.params.properties.includes(pn)) {
+              for (const cp of csProps.filter(p => p.code === pn)) {
+                const vn = getValueName(cp);
+                this.defineProperty(expansion, n, this.getPropUrl(cs, pn, cp), pn, vn, cp[vn], true);
+              }
+            }
+          }
+        }
+
         for (const pn of this.params.properties) {
           if (pn === '*') {
             continue; // done above
@@ -836,7 +849,7 @@ class ValueSetExpander {
               notClosed.value = true;
             }
             const prep = await cs.getPrepContext(true);
-            const ctxt = await cs.searchFilter(prep, filter, false);
+            const ctxt = await cs.searchFilter(prep, filter, true);
             let set = await cs.executeFilters(prep);
             if (this.count === 0 && valueSets.length === 0) {
               // count=0 (count only): report the filtered size directly without
@@ -890,8 +903,9 @@ class ValueSetExpander {
             const cctxt = await cs.locate(cc.code, this.allAltCodes);
             if (cctxt && cctxt.context && (!this.params.activeOnly || !await cs.isInactive(cctxt.context)) && await this.passesFilters(cs, cctxt.context, prep, filters, 0)) {
               let added;
+              const ecode = await cs.expansionCode(cctxt.context, cc.code);
               if (this.noDetails) {
-                added = await this.includeCode(cs, null, cs.system(), cs.version(), cc.code, await cs.isAbstract(cctxt.context), await cs.isInactive(cctxt.context), null, null, cds,
+                added = await this.includeCode(cs, null, cs.system(), cs.version(), ecode, await cs.isAbstract(cctxt.context), await cs.isInactive(cctxt.context), null, null, cds,
                     null, null, expansion, valueSets, null, null, null, null, excludeInactive, vsSrc.url);
               } else {
                 await this.listDisplaysFromProvider(cds, cs, cctxt.context);
@@ -901,7 +915,7 @@ class ValueSetExpander {
                   if (!ov) {
                     ov = await cs.itemWeight(cctxt.context);
                   }
-                  added = await this.includeCode(cs, null, cs.system(), cs.version(), cc.code, await cs.isAbstract(cctxt.context), await cs.isInactive(cctxt.context), await cs.isDeprecated(cctxt.context), await cs.getStatus(cctxt.context), cds,
+                  added = await this.includeCode(cs, null, cs.system(), cs.version(), ecode, await cs.isAbstract(cctxt.context), await cs.isInactive(cctxt.context), await cs.isDeprecated(cctxt.context), await cs.getStatus(cctxt.context), cds,
                       await cs.definition(cctxt.context), ov, expansion, valueSets, await cs.extensions(cctxt.context), cc.extension, await cs.properties(cctxt.context), null, excludeInactive, vsSrc.url);
                 }
                 if (added) {
@@ -939,16 +953,29 @@ class ValueSetExpander {
           }
 
           const fset = await cs.executeFilters(prep);
-          if (await cs.filtersNotClosed(prep)) {
+          const filtersOpen = await cs.filtersNotClosed(prep);
+          if (filtersOpen) {
             notClosed.value = true;
-          } else if (fset.length === 1 && !excludeInactive && !this.params.activeOnly) {
-            // this.addToTotal(await cs.filterSize(prep, fset[0]));
+          }
+
+          // count=0 asks only for the total. When this include is the whole value set and its one
+          // filter set is the whole answer - nothing else to add, overlap, exclude or skip - the
+          // total is the set's size, and walking it would only end in VALUESET_TOO_COSTLY once
+          // the set is bigger than the limit. Anything less certain is counted by walking, as
+          // before: an earlier version added filterSize *and* walked, and double counted (#91, #93).
+          const countOnly = this.count === 0 && !filtersOpen && fset.length === 1 && filter.isNull
+            && !excludeInactive && !this.params.activeOnly && !this.hasExclusions
+            && !(cset.concept && cset.concept.length) && !(cset.valueSet && cset.valueSet.length)
+            && (compose.include || []).length === 1 && (compose.exclude || []).length === 0;
+          if (countOnly) {
+            this.worker.opContext.log('count only: the filter size is the total');
+            this.addToTotal(await cs.filterSize(prep, fset[0]));
           }
 
           this.worker.opContext.log('iterate filters');
           this.addToTotal(0);
           const cds = new Designations(this.worker.i18n.languageDefinitions);
-          while (await cs.filterMore(prep, fset[0])) {
+          while (!countOnly && await cs.filterMore(prep, fset[0])) {
             await this.worker.checkAndYield('processCodes#5');
             const c = await cs.filterConcept(prep, fset[0]);
             const ok = (!this.params.activeOnly || !await cs.isInactive(c)) && (await this.passesFilters(cs, c, prep, fset, 1));

package/tx/workers/lookup.js

@@ -15,6 +15,7 @@ const {Parameters} = require("../library/parameters");
 const { Issue, OperationOutcome, buildOperationOutcome, outcomeFromError } = require('../library/operation-outcome');
 const {debugLog} = require("../operation-context");
 const {checkAddedParameters} = require("../library/parameter-check");
+const { Languages } = require("../../library/languages");
 
 class LookupWorker extends TerminologyWorker {
   /**
@@ -204,7 +205,7 @@ class LookupWorker extends TerminologyWorker {
       const supplements = this.loadSupplements(codeSystem.url, codeSystem.version, txp.supplements);
 
       // Create a FhirCodeSystemProvider for this CodeSystem
-      const csProvider = new FhirCodeSystemProvider(this.opContext, codeSystem, supplements);
+      const csProvider = FhirCodeSystemProvider.create(this.opContext, codeSystem, supplements);
 
       // Perform the lookup
       const result = await this.doLookup(csProvider, code, txp);
@@ -247,6 +248,11 @@ class LookupWorker extends TerminologyWorker {
       );
     };
 
+    // Explicitly asked for: named in the property list, or '*'. An empty list is not asking for
+    // anything in particular (the server chooses), which is not the same thing for abstract and
+    // notSelectable - see below.
+    const asked = (name) => (params.properties || []).some(p => p === '*' || p.toLowerCase() === name.toLowerCase());
+
     // Locate the code in the code system
     const locateResult = await csProvider.locate(code);
 
@@ -271,7 +277,7 @@ class LookupWorker extends TerminologyWorker {
     // name (required)
     responseParams.push({
       name: 'name',
-      valueString: csProvider.name(params.workingLanguages())
+      valueString: csProvider.lookupName(params.workingLanguages())
     });
     responseParams.push({
       name: 'code',
@@ -303,6 +309,32 @@ class LookupWorker extends TerminologyWorker {
       valueString: disp || display || code
     });
 
+    // A displayLanguage the code system has no display in, for this concept, still gets an
+    // answer - in the default language - but the client is told so: a display in a language it
+    // did not ask for, offered without comment, reads as an answer in the language it did.
+    // Only for an explicit displayLanguage: Accept-Language is a browser's standing preference,
+    // not a request about this code.
+    if (params.hasDisplayLanguages) {
+      // the languages actually asked for: displayLanguage is parsed with a wildcard appended,
+      // and the wildcard matches whatever display there is
+      const langs = new Languages(this.languages);
+      for (const l of params.workingLanguages()) {
+        if (l.code !== '*') langs.add(l);
+      }
+      const covered = langs.length === 0 || (designations.designations.length > 0
+        ? designations.hasAnyDisplays(langs)
+        : csProvider.hasAnyDisplays(langs));
+      if (!covered) {
+        const used = (pd && pd.language) ? String(pd.language) : (csProvider.defLang() || 'en');
+        const csDesc = version ? csProvider.system() + '|' + version : csProvider.system();
+        responseParams.push({
+          name: 'warning',
+          valueString: this.i18n.translate('LOOKUP_DISPLAY_LANGUAGE_FALLBACK', params.HTTPLanguages,
+            [langs.asString(false), code, csDesc, used])
+        });
+      }
+    }
+
     // definition (optional) - top-level parameter
     if (hasProp('definition', true)) {
       const definition = await csProvider.definition(ctxt);
@@ -314,9 +346,12 @@ class LookupWorker extends TerminologyWorker {
       }
     }
 
-    // abstract property (optional)
-    if (hasProp('abstract', true)) {
-      const isAbstract = await csProvider.isAbstract(ctxt);
+    // abstract and notSelectable (agreed for the tx-ecosystem tests, October 2026): a concept that
+    // is not selectable always says so, both ways, whatever properties were asked for - that is
+    // the fact a client most needs about it. A selectable one says neither unless asked.
+    // notSelectable is reconciled after the provider has added its properties, below.
+    const isAbstract = await csProvider.isAbstract(ctxt);
+    if (isAbstract || asked('abstract')) {
       responseParams.push({
         name: 'abstract',
         valueBoolean: isAbstract
@@ -389,7 +424,7 @@ class LookupWorker extends TerminologyWorker {
     // primitive belongs is a provider bug, and shipping it would produce a
     // response that isn't valid FHIR (and, in XML, isn't even parseable).
     const providerParamsFrom = responseParams.length;
-    await csProvider.extendLookup(ctxt, params.properties || [], responseParams);
+    await csProvider.extendLookup(ctxt, params.properties || [], responseParams, params);
     let providerName;
     try {
       providerName = csProvider.system();
@@ -398,6 +433,26 @@ class LookupWorker extends TerminologyWorker {
     }
     checkAddedParameters(responseParams, providerParamsFrom, providerName);
 
+    // notSelectable, the property: present (true) for every concept that is not selectable;
+    // for a selectable one only when asked for (false), and taken out if a provider added it
+    // anyway
+    const isNotSelectable = (p) => p.name === 'property' &&
+      (p.part || []).some(x => x.name === 'code' && x.valueCode === 'notSelectable');
+    const nsAt = responseParams.findIndex(isNotSelectable);
+    if (isAbstract) {
+      if (nsAt < 0) {
+        responseParams.push({ name: 'property', part: [
+          { name: 'code', valueCode: 'notSelectable' }, { name: 'value', valueBoolean: true }] });
+      }
+    } else if (asked('notSelectable')) {
+      if (nsAt < 0) {
+        responseParams.push({ name: 'property', part: [
+          { name: 'code', valueCode: 'notSelectable' }, { name: 'value', valueBoolean: false }] });
+      }
+    } else if (nsAt >= 0) {
+      responseParams.splice(nsAt, 1);
+    }
+
     if (reportedSupplements) {
       for (const supplement of reportedSupplements) {
         responseParams.push({

package/tx/workers/metadata.js

@@ -472,7 +472,12 @@ class MetadataHandler {
         { name: 'useSupplement' },
         { name: 'valueSet' },
         { name: 'valueSetVersion' }
-      ]
+      ],
+      textFilter: 'On code systems loaded from files and packages, a text filter ignores case, and accents on Latin, Greek and Cyrillic letters. ' +
+        'It matches concepts whose code, display, definition or a designation contains the text. ' +
+        'A filter of several words also matches a display or designation in which each word starts a word, ' +
+        'in any order; for this, punctuation and spaces only separate words. The closest matches come first. ' +
+        'Other code systems, such as SNOMED CT, LOINC and RxNorm, match text in their own way.'
     };
   }
 

package/tx/workers/subsumes.js

@@ -177,7 +177,7 @@ class SubsumesWorker extends TerminologyWorker {
     const supplements = this.loadSupplements(codeSystem.url, codeSystem.version, txp.supplements);
 
     // Create a FhirCodeSystemProvider for this CodeSystem
-    const csProvider = new FhirCodeSystemProvider(this.opContext, codeSystem, supplements);
+    const csProvider = FhirCodeSystemProvider.create(this.opContext, codeSystem, supplements);
 
     // Get the codings
     let codingA, codingB;