fhirsmith 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -5,7 +5,32 @@ All notable changes to the Health Intersections Node Server will be documented i
 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).
 
-## [v0.5.2] - 2026-02-24
+## [v0.5.5] - 2026-02-26
+
+### Changed
+- Fix loading problem for multiple versions of the same code system
+- Fix url matching in search to be precise
+
+### Tx Conformance Statement
+
+FHIRsmith 0.5.5 passed all 1382 HL7 terminology service tests (modes tx.fhir.org,omop,general,snomed, tests v1.9.0, runner v6.8.1)
+
+## [v0.5.4] - 2026-02-25
+
+This version requires that you delete all package content from the terminology-cache directly
+by hand before running this version.
+
+### Changed
+- Improved Problem page
+- Ignore system version in VSAC value sets
+- Improve value set search
+- better handling of code systems without a content property
+
+### Tx Conformance Statement
+
+FHIRsmith 0.5.4 passed all 1382 HL7 terminology service tests (modes tx.fhir.org,omop,general,snomed, tests v1.9.0, runner v6.8.1)
+
+## [v0.5.3] - 2026-02-24
 
 ### Added
 - Page listing logical problems in terminology definitions

package/README.md

@@ -238,7 +238,7 @@ GitHub Actions will automatically:
    git push origin main:XXXXXX
 ```
 
-do it via a PR
+or do it via a PR
 
 4. Tag and push the release:
 ```bash

package/library/package-manager.js

@@ -907,7 +907,7 @@ class PackageContentLoader {
     }
 
     id() {
-        return this.package.name;
+        return this.package?.name;
     }
 
     version() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fhirsmith",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "A Node.js server that provides a collection of tools to serve the FHIR ecosystem",
   "main": "server.js",
   "engines": {
@@ -116,4 +116,4 @@
     "url": "https://github.com/HealthIntersections/fhirsmith/issues"
   },
   "homepage": "https://github.com/HealthIntersections/fhirsmith#readme"
-}
+}

package/tx/html/search-form.liquid

@@ -3,7 +3,7 @@
 <form method="get" id="searchForm" action="{{ baseUrl }}/CodeSystem">
 <table class="grid" cellpadding="0" cellspacing="0">
 <tr>
-<td colspan="2">URL: <input type="text" name="url" size="40"/></td>
+<td>URL: <input type="text" name="url" size="40"/></td>
 <td>Version: <input type="text" name="version"/></td>
 </tr>
 <tr>
@@ -11,10 +11,13 @@
 <td>Status: <select name="status" class="form-select"><option value="">(any status)</option>
 <option value="draft">draft</option><option value="active">active</option>
 <option value="retired">retired</option><option value="unknown">unknown</option></select></td>
+</tr>
+<tr>
 <td>Language: <input type="text" name="lang" size="10"/> (ietf code)</td>
+<td>Source: <select name="source" class="form-select">{{ sourceOptions }}</select></td>
 </tr>
 <tr>
-<td colspan="2" title="CodeSystem - for supplements, value sets, and concept maps">System: <input type="text" name="system" size="40"/></td>
+<td title="CodeSystem - for supplements, value sets, and concept maps">System: <input type="text" name="system" size="40"/></td>
 <td>CS Content: <select name="content-mode" class="form-select"><option value="">(any content)</option>
 <option value="not-present">not-present</option><option value="example">example</option>
 <option value="fragment">fragment</option><option value="complete">complete</option>

package/tx/library/canonical-resource.js

@@ -1,3 +1,4 @@
+const {VersionUtilities, VersionPrecision} = require("../../library/version-utilities");
 
 /**
  * Base class for metadata resources to provide common interface
@@ -83,6 +84,68 @@ class CanonicalResource {
     }
     return this.jsonObj.versionAlgorithmString;
   }
+
+  guessVersionAlgorithmFromVersion(version) {
+    if (VersionUtilities.isSemVerWithWildcards(version)) {
+      return 'semver';
+    }
+    if (this.appearsToBeDate(version)) {
+      return 'date';
+    }
+    if (this.isAnInteger(version)) {
+      return 'integer';
+    }
+    return 'alpha';
+  }
+
+  /**
+   * returns true if this is more recent than other.
+   *
+   * Uses version if possible, otherwise uses date
+   *
+   * @param other
+   * @returns {boolean}
+   */
+  isMoreRecent(other) {
+    if (this.version && other.version && this.version != other.version) {
+      const fmt = this.versionAlgorithm() || other.versionAlgorithm() || this.guessVersionAlgorithmFromVersion(this.version);
+      switch (fmt) {
+        case 'semver':
+          return VersionUtilities.isThisOrLater(other.version, this.version, VersionPrecision.PATCH);
+        case 'date':
+          return this.dateIsMoreRecent(this.version, other.version);
+        case 'integer':
+          return parseInt(this.version, 10) > parseInt(other.version, 10);
+        case 'alpha': return this.version.localeCompare(other.version) > 0;
+        default: return this.version.localeCompare(other.version);
+      }
+    }
+    if (this.date && other.date && this.date != other.date) {
+      return this.dateIsMoreRecent(this.date, other.date);
+    }
+    return false;
+  }
+
+  appearsToBeDate(version) {
+    if (!version || typeof version !== 'string') return false;
+    // Strip optional time portion (T...) before checking
+    const datePart = version.split('T')[0];
+    return /^\d{4}-?\d{2}(-?\d{2})?$/.test(datePart);
+
+  }
+
+  dateIsMoreRecent(date, date2) {
+    return this.normaliseDateString(date) > this.normaliseDateString(date2);
+  }
+
+  normaliseDateString(date) {
+    // Strip time portion, then remove dashes so all formats compare uniformly as YYYYMMDD or YYYYMM
+    return date.split('T')[0].replace(/-/g, '');
+  }
+
+  isAnInteger(version) {
+    return /^\d+$/.test(version);
+  }
 }
 
 module.exports = { CanonicalResource };

package/tx/library.js

@@ -449,8 +449,13 @@ class Library {
     for (const resource of resources) {
       const cs = new CodeSystem(await contentLoader.loadFile(resource, contentLoader.fhirVersion()));
       cs.sourcePackage = contentLoader.pid();
-      cp.codeSystems.set(cs.url, cs);
-      cp.codeSystems.set(cs.vurl, cs);
+      const existing = cp.codeSystems.get(cs.url);
+      if (!existing || cs.isMoreRecent(existing)) {
+        cp.codeSystems.set(cs.url, cs);
+      }
+      if (cs.version) {
+        cp.codeSystems.set(cs.vurl, cs);
+      }
       csc++;
     }
     this.codeSystemProviders.push(cp);

package/tx/problems.js

@@ -1,3 +1,4 @@
+const escape = require('escape-html');
 
 class ProblemFinder {
 
@@ -8,49 +9,70 @@ class ProblemFinder {
   async scanValueSets(provider) {
     let unknownVersions = {};  // system -> Set of versions not known to the server
     for (let vsp of provider.valueSetProviders) {
+      let sourceUnknownVersions = unknownVersions[vsp.sourcePackage()];
+      if (!sourceUnknownVersions) {
+        sourceUnknownVersions = {};
+        unknownVersions[vsp.sourcePackage()] = sourceUnknownVersions;
+      }
+
       let list = await vsp.listAllValueSets();
       for (let url of list) {
         let vs = await vsp.fetchValueSet(url);
         if (vs && vs.jsonObj.compose) {
-          await this.scanValueSet(vs.jsonObj.compose, unknownVersions, vs.jsonObj.status != 'retired');
+          await this.scanValueSet(vs.jsonObj.compose, sourceUnknownVersions);
         }
       }
     }
-    // Filter to only versions the server doesn't know about
-    for (const [system, vset] of Object.entries(unknownVersions)) {
-      for (let v of [...vset]) {
-        if (await provider.hasCsVersion(system, v)) {
-          vset.delete(v);
+    let result = '';
+    for (let sp of provider.listValueSetSourceCodes()) {
+      let sourceUnknownVersions = unknownVersions[sp];
+      if (sourceUnknownVersions) {
+        // Filter to only versions the server doesn't know about
+        for (const [system, vset] of Object.entries(sourceUnknownVersions)) {
+          for (let v of [...vset]) {
+            if (await provider.hasCsVersion(system, v)) {
+              vset.delete(v);
+            }
+          }
+          if (vset.size === 0) {
+            delete sourceUnknownVersions[system];
+          }
+        }
+        let list = await this.unknownVersionsHtml(sourceUnknownVersions, provider, sp);
+        if (list) {
+          result = result + `<h4>${sp}</h4>` + list;
         }
-      }
-      if (vset.size === 0) {
-        delete unknownVersions[system];
       }
     }
-    return this.unknownVersionsHtml(unknownVersions);
+    return result;
   }
 
-  unknownVersionsHtml(unknownVersions) {
+  async unknownVersionsHtml(unknownVersions, provider, source) {
     const entries = Object.entries(unknownVersions || {});
     if (entries.length === 0) {
       return '<p>No unknown system versions found.</p>';
     }
     entries.sort((a, b) => a[0].localeCompare(b[0]));
-    let html = '<table class="grid"><thead><tr><th>System</th><th>Unknown Versions</th></tr></thead><tbody>';
+    let html = '<table class="grid"><thead><tr><th>System</th><th>Unknown Versions</th><th>Known Versions</th></tr></thead><tbody>';
     for (const [system, vset] of entries) {
-      const versions = [...vset].sort((a, b) => a.localeCompare(b)).join('<br/>');
-      html += `<tr><td>${system}</td><td>${versions}</td></tr>`;
+      const systemEsc = escape(system);
+      const versions = [...vset].sort((a, b) => a.localeCompare(b));
+      const versionRefs = [];
+      for (const v of versions) {
+        versionRefs.push(`<a href="ValueSet?system=${systemEsc}|${escape(v)}&source=${source}&_elements=url%2Cversion%2Cname%2Ctitle%2Cstatus%2Ccontent%2Cdate">${v}</a>`);
+      }
+      const knownVersions = [...await provider.listCodeSystemVersions(system)].join('<br/>');
+      html += `<tr><td><a href="CodeSystem?url=${systemEsc}&_elements=url%2Cversion%2Cname%2Ctitle%2Cstatus%2Ccontent%2Cdate">${system}</a></td>`+
+        `<td>${versionRefs.join('<br/>')}</td><td>${knownVersions}</td></tr>`;
     }
     html += '</tbody></table>';
     return html;
   }
 
-  async scanValueSet(compose, versions, active) {
+  async scanValueSet(compose, versions) {
     for (let inc of compose.include || []) {
-      if (inc.system) {
-        if (active && inc.version) {
-          this.seeVersion(versions, inc.system, inc.version);
-        }
+      if (inc.system && inc.version) {
+        this.seeVersion(versions, inc.system, inc.version);
       }
     }
   }

package/tx/provider.js

@@ -136,8 +136,13 @@ class Provider {
     for (const resource of resources) {
       const cs = new CodeSystem(await contentLoader.loadFile(resource, contentLoader.fhirVersion()));
       cs.sourcePackage = contentLoader.pid();
-      this.codeSystems.set(cs.url, cs);
-      this.codeSystems.set(cs.vurl, cs);
+      const existing = this.codeSystems.get(cs.url);
+      if (!existing || cs.isMoreRecent(existing)) {
+        this.codeSystems.set(cs.url, cs);
+      }
+      if (cs.version) {
+        this.codeSystems.set(cs.vurl, cs);
+      }
     }
     const vs = new PackageValueSetProvider(contentLoader);
     await vs.initialize();
@@ -218,9 +223,16 @@ class Provider {
         await csp.findImplicitConceptMap(url, version);
       }
     }
-
   }
 
+  listValueSetSourceCodes() {
+    let result = [];
+    for (let vsp of this.valueSetProviders) {
+      result.push(vsp.sourcePackage());
+    }
+    result.sort((a, b) => {a.localeCompare(b)});
+    return result;
+  }
 
   async listCodeSystemVersions(url) {
     let result = new Set();

package/tx/tx-html.js

@@ -137,7 +137,7 @@ class TxHtmlRenderer {
 
 // eslint-disable-next-line no-unused-vars
   async buildSearchForm(req, mode, params) {
-    const html = await this.liquid.renderFile('search-form', { baseUrl: escape(req.baseUrl) });
+    const html = await this.liquid.renderFile('search-form', { baseUrl: escape(req.baseUrl), sourceOptions : this.buildSourceOptions(req.txProvider) });
     return html;
   }
 
@@ -800,14 +800,128 @@ class TxHtmlRenderer {
     return firstEntry?.resourceType || 'Resource';
   }
 
+  /**
+   * Build a human-readable description of what this search bundle represents,
+   * by parsing the self link URL parameters.
+   */
+  describeSearchBundle(json) {
+    const selfLink = json.link?.find(l => l.relation === 'self')?.url || '';
+    if (!selfLink) return '';
+
+    let urlObj;
+    try {
+      urlObj = new URL(selfLink);
+    } catch {
+      return '';
+    }
+
+    // Extract resource type from path
+    const typeMatch = selfLink.match(/\/(CodeSystem|ValueSet|ConceptMap)\b/);
+    const resourceType = typeMatch ? typeMatch[1] : 'Resource';
+
+    // Human-friendly labels for search params
+    const PARAM_LABELS = {
+      'url': 'URL',
+      'version': 'Version',
+      'name': 'Name',
+      'title': 'Title',
+      'status': 'Status',
+      'publisher': 'Publisher',
+      'description': 'Description',
+      'identifier': 'Identifier',
+      'jurisdiction': 'Jurisdiction',
+      'date': 'Date',
+      'text': 'Text',
+      'system': 'System',
+      'supplements': 'Supplements',
+      'content-mode': 'Content mode',
+      'source': 'Source'
+    };
+
+    const WORDS = {
+      'url': 'contains',
+      'version': 'contains',
+      'name': 'contains',
+      'title': 'contains',
+      'status': 'is',
+      'publisher': 'contains',
+      'description': 'contains',
+      'identifier': 'matches',
+      'jurisdiction': 'contains',
+      'date': 'matches',
+      'text': 'contains',
+      'system': 'matches',
+      'supplements': 'matches',
+      'content-mode': 'is',
+      'source': 'is'
+    };
+
+    const CONTROL_PARAMS = new Set(['_offset', '_count', '_sort', '_summary', '_elements', '_total']);
+
+    // Collect filter criteria
+    const criteria = [];
+    for (const [key, value] of urlObj.searchParams) {
+      if (key != 'mode') {
+        if (CONTROL_PARAMS.has(key) || !value) continue;
+        const label = PARAM_LABELS[key] || key;
+        const word = WORDS[key] || "contains";
+        criteria.push(`<strong>${escape(label)}</strong> ${word} &ldquo;${escape(value)}&rdquo;`);
+      }
+    }
+
+    // Collect display/pagination context
+    const total = json.total;
+    const offset = parseInt(urlObj.searchParams.get('_offset') || '0');
+    const count = parseInt(urlObj.searchParams.get('_count') || '20');
+    const sort = urlObj.searchParams.get('_sort');
+    const summary = urlObj.searchParams.get('_summary');
+    const elementsParam = urlObj.searchParams.get('_elements');
+
+    // Build the description sentence
+    let desc = `Searching <strong>${escape(resourceType)}s</strong>`;
+
+    if (criteria.length > 0) {
+      desc += ' where ' + criteria.join(', ');
+    } else {
+      desc += ' (all)';
+    }
+
+    // Pagination context
+    if (typeof total === 'number') {
+      const from = Math.min(offset + 1, total);
+      const to = Math.min(offset + count, total);
+      if (total === 0) {
+        desc += ' — <strong>no results found</strong>';
+      } else {
+        desc += ` — showing <strong>${from}–${to}</strong> of <strong>${total}</strong>`;
+      }
+    }
+
+    // Sort
+    if (sort) {
+      desc += `, sorted by <strong>${escape(sort)}</strong>`;
+    }
+
+    // Summary mode
+    if (summary && summary !== 'false') {
+      desc += ` [summary: ${escape(summary)}]`;
+    }
+
+    // Elements
+    if (elementsParam) {
+      desc += ` [fields: ${escape(elementsParam)}]`;
+    }
+
+    return `<p class="search-description">${desc}</p>`;
+  }
+
   /**
    * Render search results as a table (when _elements is specified)
    */
   async renderSearchTable(json, elements, req) {
     const entries = json.entry || [];
-    const total = json.total || 0;
 
-    let html = `<p>Found ${total} result(s)</p>`;
+    let html = this.describeSearchBundle(json);
 
     // Pagination links
     html += this.renderPaginationLinks(json);
@@ -859,22 +973,12 @@ class TxHtmlRenderer {
    */
   async renderSearchSummary(json, req) {
     const entries = json.entry || [];
-    const total = json.total || 0;
 
-    let html = `<p>Found ${total} result(s)</p>`;
+    let html = this.describeSearchBundle(json);
 
     // Pagination links
     html += this.renderPaginationLinks(json);
 
-    // Bundle summary
-    html += '<div class="card mb-3">';
-    html += '<div class="card-header">Bundle Summary</div>';
-    html += '<div class="card-body">';
-    html += `<p><strong>Type:</strong> ${escape(json.type)}</p>`;
-    html += `<p><strong>Total:</strong> ${total}</p>`;
-    html += '</div>';
-    html += '</div>';
-
     // Each entry
     for (const entry of entries) {
       html += '<hr/>';
@@ -1010,7 +1114,7 @@ class TxHtmlRenderer {
       html += '<div class="narrative">(No Narrative)</div>';
     }
     if (json.text && json.text.div) {
-    // Collapsible JSON source
+      // Collapsible JSON source
       html += '<div class="xhtml">';
       html += `<button type="button" class="btn btn-sm btn-outline-secondary" onclick="toggleOriginalNarrative('${resourceId}x')">`;
       html += 'Show Original Narrative</button>';
@@ -1047,8 +1151,17 @@ class TxHtmlRenderer {
       valueSetsJson: JSON.stringify(json.valueSets || [])
     });
   }
+
+  buildSourceOptions(provider) {
+    let result = '';
+    result += `<option value="internal">internal</option>`;
+    for (let sp of provider.listValueSetSourceCodes()) {
+      result += `<option value="${sp}">${sp}</option>`;
+    }
+    return result;
+  }
 }
 
 module.exports = {
- TxHtmlRenderer, loadTemplate
-};
+  TxHtmlRenderer, loadTemplate
+};

package/tx/vs/vs-api.js

@@ -8,6 +8,9 @@ class AbstractValueSetProvider {
    */
   spaceId;
 
+  code() {
+    throw new Error('code must be implemented by AbstractValueSetProvider subclass');
+  }
   /**
    * ensure that the ids on the value sets are unique, if they are
    * in the global namespace

package/tx/vs/vs-database.js

@@ -37,7 +37,7 @@ class ValueSetDatabase {
       this._db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
         if (err) {
           this._db = null;
-          reject(new Error(`Failed to open database: ${err.message}`));
+          reject(new Error(`Failed to open database ${this.dbPath}: ${err.message}`));
         } else {
           resolve(this._db);
         }
@@ -122,7 +122,7 @@ class ValueSetDatabase {
     return new Promise((resolve, reject) => {
       const db = new sqlite3.Database(this.dbPath, (err) => {
         if (err) {
-          reject(new Error(`Failed to create database: ${err.message}`));
+          reject(new Error(`Failed to create database ${this.dbPath}: ${err.message}`));
           return;
         }
 
@@ -177,6 +177,7 @@ class ValueSetDatabase {
               CREATE TABLE valueset_systems (
                                                 valueset_id TEXT,
                                                 system TEXT,
+                                                version TEXT,
                                                 FOREIGN KEY (valueset_id) REFERENCES valuesets(url)
               )
           `);
@@ -193,7 +194,7 @@ class ValueSetDatabase {
           db.run('CREATE INDEX idx_identifiers_value ON valueset_identifiers(value)');
           db.run('CREATE INDEX idx_jurisdictions_system ON valueset_jurisdictions(system)');
           db.run('CREATE INDEX idx_jurisdictions_code ON valueset_jurisdictions(code)');
-          db.run('CREATE INDEX idx_systems_system ON valueset_systems(system)');
+          db.run('CREATE INDEX idx_systems_system ON valueset_systems(system, version)');
 
           db.close((err) => {
             if (err) {
@@ -392,8 +393,8 @@ class ValueSetDatabase {
           pendingOperations++;
 
           db.run(`
-              INSERT INTO valueset_systems (valueset_id, system) VALUES (?, ?)
-          `, [valueSet.id, include.system], function(err) {
+              INSERT INTO valueset_systems (valueset_id, system, version) VALUES (?, ?, ?)
+          `, [valueSet.id, include.system, include.version], function(err) {
             if (err) {
               operationError(new Error(`Failed to insert system: ${err.message}`));
             } else {
@@ -735,8 +736,15 @@ class ValueSetDatabase {
 
         case 'system':
           joins.add('JOIN valueset_systems vs ON v.id = vs.valueset_id');
-          conditions.push('vs.system = ?');
-          params.push(value);
+          if (value.includes('|')) {
+            conditions.push('vs.system = ?');
+            params.push(value.substring(0, value.indexOf('|')));
+            conditions.push('vs.version = ?');
+            params.push(value.substring(value.indexOf('|')+1));
+          } else {
+            conditions.push('vs.system = ?');
+            params.push(value);
+          }
           break;
 
         default:

package/tx/vs/vs-package.js

@@ -23,6 +23,11 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     this.valueSetMap = new Map();
     this.initialized = false;
     this.count = 0;
+    this.sourcePackageCode = packageLoader.id();
+  }
+
+  sourcePackage() {
+    return this.sourcePackageCode;
   }
 
   /**
@@ -42,7 +47,7 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
       await this._populateDatabase();
     }
 
-    this.valueSetMap = await this.database.loadAllValueSets(this.packageLoader.pid());
+    this.valueSetMap = await this.database.loadAllValueSets(this.sourcePackage());
     this.initialized = true;
   }
 

package/tx/vs/vs-vsac.js

@@ -51,6 +51,10 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
     });
   }
 
+  sourcePackage() {
+    return "vsac";
+  }
+
   /**
    * Initialize the provider - setup database and start refresh cycle
    * @returns {Promise<void>}
@@ -313,8 +317,20 @@ class VSACValueSetProvider extends AbstractValueSetProvider {
    * @private
    */
   async _reloadMap() {
-    const newMap = await this.database.loadAllValueSets("vsac");
-
+    const newMap = await this.database.loadAllValueSets(this.sourcePackage());
+    for (const vs of newMap.values()) {
+      if (vs.jsonObj.compose) {
+        for (const inc of vs.jsonObj.compose.include || []) {
+          if (inc.version) {
+            delete inc.version;
+          }
+        }for (const inc of vs.jsonObj.compose.exclude || []) {
+          if (inc.version) {
+            delete inc.version;
+          }
+        }
+      }
+    }
     // Atomic replacement of the map
     this.valueSetMap = newMap;
   }

package/tx/workers/expand.js

@@ -12,7 +12,7 @@ const { TerminologyWorker } = require('./worker');
 const {TxParameters} = require("../params");
 const {Designations, SearchFilterText} = require("../library/designations");
 const {Extensions} = require("../library/extensions");
-const {getValuePrimitive, getValueName} = require("../../library/utilities");
+const {getValuePrimitive, getValueName, validateParameter} = require("../../library/utilities");
 const {div} = require("../../library/html");
 const {Issue, OperationOutcome} = require("../library/operation-outcome");
 const crypto = require('crypto');
@@ -624,13 +624,15 @@ class ValueSetExpander {
         if (vsInfo && vsInfo.isSimple) {
           vsInfo.handleByCS = cs.handlesSelecting();
         }
-        if (cs.contentMode() !== 'complete') {
+        if (!cs.contentMode()) {
+          throw new Issue('error', 'business-rule', null, null, 'The code system definition for ' + cset.system + ' has no content property, so this expansion cannot be performed', 'invalid');
+        } else if (cs.contentMode() !== 'complete') {
           if (cs.contentMode() === 'not-present') {
             throw new Issue('error', 'business-rule', null, null, 'The code system definition for ' + cset.system + ' has no content, so this expansion cannot be performed', 'invalid');
           } else if (cs.contentMode() === 'supplement') {
             throw new Issue('error', 'business-rule', null, null, 'The code system definition for ' + cset.system + ' defines a supplement, so this expansion cannot be performed', 'invalid');
           } else {
-            this.addParamUri(cs.contentMode(), cs.system + '|' + cs.version);
+            this.addParamUri(exp, cs.contentMode(), cs.system + '|' + cs.version);
             Extensions.addString(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed",
               "This extension is based on a fragment of the code system " + cset.system);
           }
@@ -1437,6 +1439,9 @@ class ValueSetExpander {
   }
 
   addParamUri(exp, name, value) {
+    validateParameter(name, 'name', String);
+    validateParameter(value, 'value', String);
+
     if (!this.hasParam(exp, name, value)) {
       if (!exp.parameter) {
         exp.parameter = [];

package/tx/workers/search.js

@@ -177,6 +177,12 @@ class SearchWorker extends TerminologyWorker {
               isMatch = false;
               break;
             }
+          } else if (param === 'url') { // exact match
+            const propValue = json.url;
+            if (propValue != searchValue) {
+              isMatch = false;
+              break;
+            }
           } else {
             // Standard partial text match
             const propValue = json[jsonProp];
@@ -205,19 +211,25 @@ class SearchWorker extends TerminologyWorker {
     // Convert params object to array format expected by ValueSet providers
     // Exclude control params (_offset, _count, _elements, _sort)
     const searchParams = [];
+    let source = null;
     for (const [key, value] of Object.entries(params)) {
       if (!key.startsWith('_') && value && SearchWorker.ALLOWED_PARAMS.includes(key)) {
         searchParams.push({ name: key, value: value });
       }
+      if (key == 'source') {
+        source = value;
+      }
     }
 
     for (const vsp of this.provider.valueSetProviders) {
-      this.deadCheck('searchValueSets-providers');
-      const results = await vsp.searchValueSets(searchParams, elements);
-      if (results && Array.isArray(results)) {
-        for (const vs of results) {
-          this.deadCheck('searchValueSets-results');
-          allMatches.push(vs.jsonObj || vs);
+      if (!source || source == vsp.sourcePackage()) {
+        this.deadCheck('searchValueSets-providers');
+        const results = await vsp.searchValueSets(searchParams, elements);
+        if (results && Array.isArray(results)) {
+          for (const vs of results) {
+            this.deadCheck('searchValueSets-results');
+            allMatches.push(vs.jsonObj || vs);
+          }
         }
       }
     }