fhirsmith 0.18.1 → 1.0.0

package/utilities/tx-stress-test.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+//
+// tx-stress.js - FHIR Terminology Server Stress Test Client
+//
+// Usage:
+//   node tx-stress.js <server-url> [options]
+//
+// Examples:
+//   node tx-stress.js http://localhost:3000/tx
+//   node tx-stress.js http://localhost:3000/tx --threads 10 --duration 60
+//   node tx-stress.js http://localhost:3000/tx --threads 5 --duration 30 --mode search
+//   node tx-stress.js http://localhost:3000/tx --threads 20 --duration 120 --mode random --verbose
+//
+
+const SEARCH_TERMS = [
+  'body', 'status', 'gender', 'type', 'code', 'category', 'event',
+  'condition', 'procedure', 'medication', 'observation', 'allergy',
+  'diagnosis', 'encounter', 'clinical', 'admin', 'result', 'finding',
+  'disorder', 'substance', 'unit', 'country', 'language', 'ethnic',
+  'marital', 'contact', 'address', 'identifier', 'security', 'action',
+  'request', 'response', 'priority', 'severity', 'risk', 'method'
+];
+
+// ── CLI parsing ──────────────────────────────────────────────────────
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+FHIR Terminology Server Stress Test
+
+Usage: node tx-stress.js <server-url> [options]
+
+Options:
+  --threads <n>     Number of concurrent workers (default: 10)
+  --duration <s>    Test duration in seconds (default: 60)
+  --mode <mode>     ValueSet discovery mode (default: both)
+                      browse  - paginate through all ValueSets
+                      search  - search with random terms
+                      both    - alternate between modes
+  --pick <n>        How many ValueSets to pick per cycle (default: 20)
+  --from <n>        Pick from first N search results (default: 100)
+  --verbose         Show per-request latencies
+  --delay <ms>      Delay between requests per worker in ms (default: 0)
+  --help, -h        Show this help
+
+Examples:
+  node tx-stress.js http://localhost:3000/tx
+  node tx-stress.js http://localhost:3000/tx --threads 20 --duration 120 --verbose
+  node tx-stress.js http://localhost:3000/tx --threads 5 --mode search --duration 30
+`);
+    process.exit(0);
+  }
+
+  const config = {
+    serverUrl: args[0].replace(/\/+$/, ''),
+    threads: 10,
+    duration: 60,
+    mode: 'both',
+    pick: 20,
+    from: 100,
+    verbose: false,
+    delay: 0
+  };
+
+  for (let i = 1; i < args.length; i++) {
+    switch (args[i]) {
+      case '--threads':   config.threads  = parseInt(args[++i]); break;
+      case '--duration':  config.duration = parseInt(args[++i]); break;
+      case '--mode':      config.mode     = args[++i];           break;
+      case '--pick':      config.pick     = parseInt(args[++i]); break;
+      case '--from':      config.from     = parseInt(args[++i]); break;
+      case '--verbose':   config.verbose  = true;                break;
+      case '--delay':     config.delay    = parseInt(args[++i]); break;
+      default:
+        console.error(`Unknown option: ${args[i]}`);
+        process.exit(1);
+    }
+  }
+
+  if (!['browse', 'search', 'both'].includes(config.mode)) {
+    console.error(`Invalid mode: ${config.mode}. Use browse, search, or both.`);
+    process.exit(1);
+  }
+
+  return config;
+}
+
+// ── Stats collection ─────────────────────────────────────────────────
+
+class StatsCollector {
+  constructor() {
+    this.requests = [];       // { worker, phase, url, status, latencyMs, error, timestamp }
+    this.cycles = 0;
+    this.errors = 0;
+    this.startTime = null;
+    this.endTime = null;
+  }
+
+  record(entry) {
+    this.requests.push(entry);
+    if (entry.error) this.errors++;
+  }
+
+  completeCycle() {
+    this.cycles++;
+  }
+
+  summarize() {
+    const duration = (this.endTime - this.startTime) / 1000;
+    const phases = {};
+
+    for (const req of this.requests) {
+      if (!phases[req.phase]) {
+        phases[req.phase] = { count: 0, errors: 0, latencies: [] };
+      }
+      const p = phases[req.phase];
+      p.count++;
+      if (req.error) p.errors++;
+      if (req.latencyMs !== null) p.latencies.push(req.latencyMs);
+    }
+
+    console.log('\n' + '═'.repeat(72));
+    console.log('  STRESS TEST RESULTS');
+    console.log('═'.repeat(72));
+    console.log(`  Duration:          ${duration.toFixed(1)}s`);
+    console.log(`  Workers:           ${this.workerCount}`);
+    console.log(`  Complete cycles:   ${this.cycles}`);
+    console.log(`  Total requests:    ${this.requests.length}`);
+    console.log(`  Total errors:      ${this.errors}`);
+    console.log(`  Requests/sec:      ${(this.requests.length / duration).toFixed(1)}`);
+    console.log(`  Cycles/sec:        ${(this.cycles / duration).toFixed(2)}`);
+
+    console.log('\n  Per-phase breakdown:');
+    console.log('  ' + '-'.repeat(70));
+    console.log(`  ${'Phase'.padEnd(16)} ${'Count'.padStart(7)} ${'Errors'.padStart(7)} ${'Avg ms'.padStart(8)} ${'p50 ms'.padStart(8)} ${'p95 ms'.padStart(8)} ${'p99 ms'.padStart(8)} ${'Max ms'.padStart(8)}`);
+    console.log('  ' + '-'.repeat(70));
+
+    for (const [phase, data] of Object.entries(phases)) {
+      const sorted = data.latencies.slice().sort((a, b) => a - b);
+      const avg = sorted.length ? (sorted.reduce((a, b) => a + b, 0) / sorted.length) : 0;
+      const p50 = percentile(sorted, 50);
+      const p95 = percentile(sorted, 95);
+      const p99 = percentile(sorted, 99);
+      const max = sorted.length ? sorted[sorted.length - 1] : 0;
+
+      console.log(`  ${phase.padEnd(16)} ${String(data.count).padStart(7)} ${String(data.errors).padStart(7)} ${avg.toFixed(0).padStart(8)} ${p50.toFixed(0).padStart(8)} ${p95.toFixed(0).padStart(8)} ${p99.toFixed(0).padStart(8)} ${max.toFixed(0).padStart(8)}`);
+    }
+
+    // Overall latency
+    const allLatencies = this.requests.filter(r => r.latencyMs !== null).map(r => r.latencyMs).sort((a, b) => a - b);
+    if (allLatencies.length > 0) {
+      const avg = allLatencies.reduce((a, b) => a + b, 0) / allLatencies.length;
+      console.log('  ' + '-'.repeat(70));
+      console.log(`  ${'OVERALL'.padEnd(16)} ${String(this.requests.length).padStart(7)} ${String(this.errors).padStart(7)} ${avg.toFixed(0).padStart(8)} ${percentile(allLatencies, 50).toFixed(0).padStart(8)} ${percentile(allLatencies, 95).toFixed(0).padStart(8)} ${percentile(allLatencies, 99).toFixed(0).padStart(8)} ${allLatencies[allLatencies.length - 1].toFixed(0).padStart(8)}`);
+    }
+
+    console.log('═'.repeat(72));
+
+    // Error summary
+    const errorTypes = {};
+    for (const req of this.requests) {
+      if (req.error) {
+        const key = `${req.phase}: ${req.error}`;
+        errorTypes[key] = (errorTypes[key] || 0) + 1;
+      }
+    }
+    if (Object.keys(errorTypes).length > 0) {
+      console.log('\n  Error summary:');
+      for (const [msg, count] of Object.entries(errorTypes).sort((a, b) => b[1] - a[1])) {
+        console.log(`    ${count}x  ${msg}`);
+      }
+    }
+  }
+}
+
+function percentile(sorted, pct) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil((pct / 100) * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+
+// ── HTTP helpers ─────────────────────────────────────────────────────
+
+async function fhirGet(url, stats, worker, phase, verbose) {
+  const start = performance.now();
+  let status = null;
+  let error = null;
+  let body = null;
+
+  try {
+    const resp = await fetch(url, {
+      headers: { 'Accept': 'application/fhir+json' },
+      signal: AbortSignal.timeout(30000)
+    });
+    status = resp.status;
+
+    if (!resp.ok) {
+      error = `HTTP ${resp.status}`;
+      return null;
+    }
+
+    body = await resp.json();
+    return body;
+
+  } catch (err) {
+    error = err.name === 'TimeoutError' ? 'Timeout (30s)' : err.message;
+    return null;
+
+  } finally {
+    const latencyMs = performance.now() - start;
+    const entry = {
+      worker,
+      phase,
+      url: shortenUrl(url),
+      status,
+      latencyMs,
+      error,
+      timestamp: new Date()
+    };
+    stats.record(entry);
+
+    if (verbose) {
+      const icon = error ? '✗' : '✓';
+      const statusStr = status ? `${status}` : '---';
+      console.log(`  [W${String(worker).padStart(2)}] ${icon} ${phase.padEnd(14)} ${latencyMs.toFixed(0).padStart(6)}ms  ${statusStr}  ${shortenUrl(url)}`);
+    }
+  }
+}
+
+function shortenUrl(url) {
+  // Trim to last meaningful path segments for readable logging
+  try {
+    const u = new URL(url);
+    const path = u.pathname + u.search;
+    return path.length > 90 ? path.substring(0, 87) + '...' : path;
+  } catch {
+    return url.length > 90 ? url.substring(0, 87) + '...' : url;
+  }
+}
+
+// ── FHIR operations ──────────────────────────────────────────────────
+
+async function searchValueSets(config, stats, worker, mode) {
+  const baseUrl = config.serverUrl;
+  const allEntries = [];
+  const pageSize = 50;
+
+  if (mode === 'search') {
+    // Search with a random term
+    const term = SEARCH_TERMS[Math.floor(Math.random() * SEARCH_TERMS.length)];
+    const url = `${baseUrl}/ValueSet?name:contains=${encodeURIComponent(term)}&_count=${pageSize}`;
+    const bundle = await fhirGet(url, stats, worker, 'vs-search', config.verbose);
+    if (bundle && bundle.entry) {
+      allEntries.push(...bundle.entry);
+    }
+    // Get a second page if we need more results and there is one
+    if (allEntries.length < config.from && bundle && bundle.link) {
+      const nextLink = bundle.link.find(l => l.relation === 'next');
+      if (nextLink) {
+        const bundle2 = await fhirGet(nextLink.url, stats, worker, 'vs-search', config.verbose);
+        if (bundle2 && bundle2.entry) {
+          allEntries.push(...bundle2.entry);
+        }
+      }
+    }
+  } else {
+    // Browse mode - paginate through ValueSets
+    const offset = Math.floor(Math.random() * 200) * pageSize;
+    const url = `${baseUrl}/ValueSet?_count=${pageSize}&_offset=${offset}`;
+    const bundle = await fhirGet(url, stats, worker, 'vs-browse', config.verbose);
+    if (bundle && bundle.entry) {
+      allEntries.push(...bundle.entry);
+    }
+    // Get a second page
+    if (allEntries.length < config.from && bundle && bundle.link) {
+      const nextLink = bundle.link.find(l => l.relation === 'next');
+      if (nextLink) {
+        const bundle2 = await fhirGet(nextLink.url, stats, worker, 'vs-browse', config.verbose);
+        if (bundle2 && bundle2.entry) {
+          allEntries.push(...bundle2.entry);
+        }
+      }
+    }
+  }
+
+  return allEntries;
+}
+
+function pickRandom(arr, n) {
+  const copy = arr.slice(0, Math.min(arr.length, 200)); // cap working set
+  const result = [];
+  for (let i = 0; i < n && copy.length > 0; i++) {
+    const idx = Math.floor(Math.random() * copy.length);
+    result.push(copy.splice(idx, 1)[0]);
+  }
+  return result;
+}
+
+async function expandValueSet(config, stats, worker, vsUrl) {
+  const url = `${config.serverUrl}/ValueSet/$expand?url=${encodeURIComponent(vsUrl)}&count=20`;
+  const result = await fhirGet(url, stats, worker, 'vs-expand', config.verbose);
+  return result;
+}
+
+async function validateCode(config, stats, worker, system, code, vsUrl) {
+  const params = new URLSearchParams();
+  params.set('system', system);
+  params.set('code', code);
+  if (vsUrl) params.set('url', vsUrl);
+
+  const url = `${config.serverUrl}/ValueSet/$validate-code?${params.toString()}`;
+  const result = await fhirGet(url, stats, worker, 'validate-code', config.verbose);
+  return result;
+}
+
+// ── Worker cycle ─────────────────────────────────────────────────────
+
+async function runWorkerCycle(config, stats, worker, deadline) {
+  // 1. Decide mode for this cycle
+  let mode;
+  if (config.mode === 'both') {
+    mode = Math.random() < 0.5 ? 'browse' : 'search';
+  } else {
+    mode = config.mode;
+  }
+
+  // 2. Search for ValueSets
+  const entries = await searchValueSets(config, stats, worker, mode);
+  if (Date.now() >= deadline) return;
+
+  if (!entries || entries.length === 0) {
+    return; // nothing to work with this cycle
+  }
+
+  // 3. Pick a random subset
+  const picked = pickRandom(entries, config.pick);
+
+  // 4. Expand each and validate a code from each expansion
+  for (const entry of picked) {
+    if (Date.now() >= deadline) return;
+
+    const vs = entry.resource;
+    if (!vs || !vs.url) continue;
+
+    // Expand
+    const expansion = await expandValueSet(config, stats, worker, vs.url);
+    if (Date.now() >= deadline) return;
+
+    if (config.delay > 0) await sleep(config.delay);
+
+    // Find a code in the expansion to validate
+    const contains = expansion?.expansion?.contains;
+    if (contains && contains.length > 0) {
+      const pick = contains[Math.floor(Math.random() * contains.length)];
+      if (pick.system && pick.code) {
+        await validateCode(config, stats, worker, pick.system, pick.code, vs.url);
+      }
+    }
+
+    if (config.delay > 0) await sleep(config.delay);
+  }
+
+  stats.completeCycle();
+}
+
+async function runWorker(config, stats, worker, deadline) {
+  while (Date.now() < deadline) {
+    try {
+      await runWorkerCycle(config, stats, worker, deadline);
+    } catch (err) {
+      // Shouldn't happen since fhirGet catches errors, but just in case
+      stats.record({
+        worker,
+        phase: 'cycle-error',
+        url: '',
+        status: null,
+        latencyMs: null,
+        error: err.message,
+        timestamp: new Date()
+      });
+    }
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// ── Connectivity check ───────────────────────────────────────────────
+
+async function checkServer(config) {
+  console.log(`\nChecking server at ${config.serverUrl} ...`);
+
+  try {
+    const resp = await fetch(`${config.serverUrl}/metadata`, {
+      headers: { 'Accept': 'application/fhir+json' },
+      signal: AbortSignal.timeout(10000)
+    });
+
+    if (!resp.ok) {
+      console.error(`Server returned HTTP ${resp.status}. Aborting.`);
+      process.exit(1);
+    }
+
+    const cs = await resp.json();
+    const sw = cs.software ? `${cs.software.name || '?'} ${cs.software.version || ''}` : 'unknown';
+    const fhirVer = cs.fhirVersion || '?';
+    console.log(`  Server: ${sw} (FHIR ${fhirVer})`);
+    console.log(`  Status: OK\n`);
+    return cs;
+
+  } catch (err) {
+    console.error(`Cannot reach server: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// ── Live progress ────────────────────────────────────────────────────
+
+function startProgressReporter(stats, config, deadline) {
+  const interval = setInterval(() => {
+    const elapsed = (Date.now() - stats.startTime) / 1000;
+    const remaining = Math.max(0, (deadline - Date.now()) / 1000);
+    const rps = stats.requests.length / elapsed;
+    process.stdout.write(
+      `\r  ⏱ ${elapsed.toFixed(0)}s elapsed | ${remaining.toFixed(0)}s remaining | ` +
+      `${stats.requests.length} reqs (${rps.toFixed(1)}/s) | ` +
+      `${stats.cycles} cycles | ${stats.errors} errors   `
+    );
+  }, 1000);
+
+  return () => {
+    clearInterval(interval);
+    process.stdout.write('\r' + ' '.repeat(100) + '\r');
+  };
+}
+
+// ── Main ─────────────────────────────────────────────────────────────
+
+async function main() {
+  const config = parseArgs();
+
+  console.log('╔' + '═'.repeat(70) + '╗');
+  console.log('║  FHIR Terminology Server Stress Test' + ' '.repeat(33) + '║');
+  console.log('╚' + '═'.repeat(70) + '╝');
+  console.log(`  Server:    ${config.serverUrl}`);
+  console.log(`  Workers:   ${config.threads}`);
+  console.log(`  Duration:  ${config.duration}s`);
+  console.log(`  Mode:      ${config.mode}`);
+  console.log(`  Pick:      ${config.pick} of first ${config.from}`);
+  if (config.delay > 0) console.log(`  Delay:     ${config.delay}ms between requests`);
+
+  await checkServer(config);
+
+  const stats = new StatsCollector();
+  stats.workerCount = config.threads;
+  stats.startTime = Date.now();
+  const deadline = stats.startTime + (config.duration * 1000);
+
+  console.log(`Starting ${config.threads} workers for ${config.duration}s...\n`);
+
+  const stopProgress = config.verbose ? () => {} : startProgressReporter(stats, config, deadline);
+
+  // Launch all workers concurrently
+  const workers = [];
+  for (let i = 1; i <= config.threads; i++) {
+    workers.push(runWorker(config, stats, i, deadline));
+  }
+
+  await Promise.all(workers);
+
+  stats.endTime = Date.now();
+  stopProgress();
+  stats.summarize();
+}
+
+main().catch(err => {
+  console.error(`Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/vcl/readme.md

@@ -0,0 +1,37 @@
+# VCL - ValueSet Compose Language
+
+The `vcl` module turns an expression in VCL, the ValueSet Compose Language (a compact text
+syntax for a value set's compose: includes, excludes, filters, ...), into a FHIR ValueSet.
+It only parses: it doesn't expand the value set or check its codes. Use the `tx` module for
+that.
+
+This module exists for the FHIR tooling; it isn't
+designed for anyone else to run, though nothing stops you.
+
+## Configuration
+
+In `config.json`, under `modules`:
+
+```json
+"vcl": {
+  "enabled": true
+}
+```
+
+There are no other settings.
+
+## Endpoint
+
+`GET /VCL?vcl={expression}`
+
+- The expression is the `vcl` query parameter (URL-encoded), up to 10000 characters. It may
+  also be given as a URI, `http://fhir.org/VCL/{expression}`.
+- The response is the ValueSet, as JSON, with `compose` from the expression and `url`
+  `cid:{hash}` - a hash of the content, so the same expression always has the same url.
+- An expression that isn't valid VCL is a 400, with `error`, `message` and, where it is known,
+  the `position` in the expression where parsing failed.
+
+For example, `GET /VCL?vcl=(http://loinc.org)COMPONENT=LP15842-2` gives a ValueSet that includes
+the LOINC codes whose COMPONENT is LP15842-2.
+
+The parser (`vcl-parser.js`) is based on the Java VCL parser in the FHIR core library.

package/vcl/vcl-parser.js

@@ -309,10 +309,15 @@ class VCLLexer {
   }
 }
 
+// How deep brackets may nest. The parser recurses once per bracket, so without a bound a hostile
+// expression is a RangeError (stack overflow) rather than a parse error. Real VCL nests a few levels.
+const MAX_VCL_DEPTH = 100;
+
 class VCLParserClass {
   constructor(tokens, fhirFactory = null) {
     this.tokens = tokens;
     this.pos = 0;
+    this.depth = 0;
     this.fhirFactory = fhirFactory;
     this.valueSet = this.createValueSet();
   }
@@ -477,6 +482,9 @@ class VCLParserClass {
 
     if (this.current().type === TokenType.OPEN) {
       this.consume(TokenType.OPEN);
+      if (++this.depth > MAX_VCL_DEPTH) {
+        throw new VCLParseException(`The expression nests more than ${MAX_VCL_DEPTH} levels deep`, this.current().position);
+      }
 
       // Check for nested system URI
       if (this.current().type === TokenType.OPEN && this.peek().type === TokenType.URI) {
@@ -494,6 +502,7 @@ class VCLParserClass {
 
       // This should fail for unmatched parentheses
       this.consume(TokenType.CLOSE);
+      this.depth--;
     } else {
       this.parseSimpleExpr(systemUri, isExclusion);
     }
@@ -834,6 +843,10 @@ class VCLParserClass {
       const tokenType = this.current().type;
 
       switch (tokenType) {
+        case TokenType.EOF:
+          // current() answers EOF forever once the tokens run out, so without this an
+          // unterminated "{" looped here until the terms array overflowed
+          throw new VCLParseException("Expected '}' to close the filter list", this.current().position);
         case TokenType.LCRLY:
           depth++;
           break;
@@ -1035,6 +1048,7 @@ if (typeof module !== 'undefined' && module.exports) {
     splitSystemUri,
     isVCLCompatible,
     VCLParseException,
+    MAX_VCL_DEPTH,
     TokenType,
     FilterOperator,
     // Export classes for debugging
@@ -1053,6 +1067,7 @@ if (typeof module !== 'undefined' && module.exports) {
     splitSystemUri,
     isVCLCompatible,
     VCLParseException,
+    MAX_VCL_DEPTH,
     TokenType,
     FilterOperator,
     // Export classes for debugging

package/xig/readme.md

@@ -0,0 +1,52 @@
+# XIG - the Cross-IG resource browser
+
+The `xig` module serves the FHIR Cross-IG index: every conformance resource (profiles, value
+sets, code systems, extensions, ...) in every published implementation guide package, with a
+page for each and a searchable list.
+
+The content is a SQLite database built elsewhere, by the IG statistics process, and published
+at `https://fhir.org/guides/stats/xig.db`. This module downloads it and serves it read-only. It
+doesn't build or change it.
+
+This module exists to run fhir.org's own service; it isn't designed for anyone else to run,
+though nothing stops you.
+
+## Configuration
+
+In `config.json`, under `modules`:
+
+```json
+"xig": {
+  "enabled": true,
+  "autoUpdate": true,
+  "updateToken": "a-long-random-string"
+}
+```
+
+| Setting | Default | Description |
+|---|---|---|
+| `enabled` | false | Run the module, at `/xig` |
+| `autoUpdate` | true | Download the database again every night at 02:00 (server time). `false` keeps whatever is there |
+| `updateToken` | none | A shared secret for `POST /xig/update`, which downloads the database now. Send it in the `x-update-token` header (or from the form on `/xig/stats`). Without it, that endpoint is turned off. The nightly update doesn't need it |
+
+The database is kept at `xig/xig.db` in the data directory. If it isn't there at startup, it is
+downloaded a few seconds after the server starts; until then the pages say there's no
+database. A download replaces the database only once it is complete.
+
+The database's HTML fragments are shown as they are, so the download URL is fixed to fhir.org
+(over https) and isn't a setting.
+
+## Endpoints
+
+| Path | What |
+|---|---|
+| `GET /xig` | The resource list, filtered by FHIR version (`ver`), authority (`auth`), realm (`realm`), resource type (`rt`), type (`type`), package (`pkg`), text (`text`) and `onlyUsed`; paged by `offset` |
+| `GET /xig/resource/{package}/{type}/{id}` | One resource |
+| `GET /xig/{package}/{type}/{id}` | The same, by a shorter path |
+| `GET /xig/stats` | Statistics: the database, its updates, and requests |
+| `GET /xig/status` | The database's status, as JSON |
+| `GET /xig/cache` | Cache statistics, as JSON |
+| `POST /xig/update` | Download the database now (needs `updateToken`) |
+
+The list and resource pages can be asked for as JSON or CSV as well as HTML (`_fmt=json` or `_fmt=csv`, or an `Accept`
+header).

package/xig/xig-template.html

@@ -53,8 +53,6 @@
 		<div id="stripe"> </div>
 		<div class="container">  <!-- container -->
 		<div style="background-color: #ad1f2f; padding: 6px; color: white;">  <!-- container -->
-  <a href="http://www.hl7.org/fhir" style="color: gold" title="Fast Healthcare Interoperability Resources - Home Page"><img border="0" src="/icon-fhir-16.png" style="vertical-align: text-bottom"/> <b>FHIR</b></a> &copy; HL7.org &nbsp;|&nbsp;
-  <a href="https://github.com/HealthIntersections/FHIRsmith/blob/main/README.md" style="color: gold"><img border="0" src="/FHIRsmith16.png" style="vertical-align: text-bottom"/> FHIRsmith</a> [%ver%] &nbsp;|&nbsp;
   <a href="/" style="color: gold"> Server Home</a> &nbsp;|&nbsp;
   <a href="/xig" style="color: gold">XIG Home</a>  &nbsp;|&nbsp;
   <a href="/xig/stats" style="color: gold">XIG Stats</a>  &nbsp;|&nbsp;
@@ -70,7 +68,7 @@
             	<div class="inner-wrapper">
  <div class="col-9">
 
-  <h2><img border="0" src="../FHIRsmith32.png" style="vertical-align: text-bottom"/> FHIR IG analytics</h2>
+  <h2><a href="https://github.com/HealthIntersections/FHIRsmith/blob/main/README.md" title="FHIRsmith [%ver%]"><img border="0" src="/FHIRsmith32.png" alt="FHIRsmith Logo" style="vertical-align: text-bottom"/></a> FHIR IG analytics</h2>
 
 [%content%]
 
@@ -88,8 +86,7 @@
 		<div class="container">  <!-- container -->
 			<div class="inner-wrapper">
 				<p>
-                    <a href="http://www.hl7.org/fhir" style="color: gold" title="Fast Healthcare Interoperability Resources - Home Page"><img border="0" src="/icon-fhir-16.png" style="vertical-align: text-bottom"/> <b>FHIR</b></a> &copy; HL7.org 2011+.  &nbsp;|&nbsp;
-                    <a href="https://github.com/HealthIntersections/FHIRsmith/blob/main/README.md" style="color: gold"><img border="0" src="/FHIRsmith16.png" style="vertical-align: text-bottom"/> FHIRsmith</a>  [%ver%]  &copy; HealthIntersections.com.au 2023+ &nbsp;|&nbsp;
+                    <a href="https://github.com/HealthIntersections/FHIRsmith/blob/main/README.md" style="color: gold"><img border="0" src="/FHIRsmith16.png" alt="FHIRsmith Logo" style="vertical-align: text-bottom"/> FHIRsmith</a>  [%ver%]  &copy; HealthIntersections.com.au 2023+ &nbsp;|&nbsp;
         XIG built as of [%download-date%] &nbsp;|&nbsp; [%total-resources%] resources in [%total-packages%] packages &nbsp;|
                     &nbsp; ([%ms%] ms)
                     [%sponsorMessage%]
@@ -113,10 +110,10 @@
 ================================================== -->
   <!-- Placed at the end of the document so the pages load faster -->
 <!-- <script src="/assets/js/jquery.js"/> -->
-<script src="/assets/js/bootstrap.min.js"/>
-<script src="/assets/js/respond.min.js"/>
+<script src="/assets/js/bootstrap.min.js"></script>
+<script src="/assets/js/respond.min.js"></script>
 
-<script src="/assets/js/fhir.js"/>
+<script src="/assets/js/fhir.js"></script>
 
   <!-- Analytics Below
 ================================================== -->