fhirsmith 0.8.5 → 0.9.0

package/library/logger.js

@@ -1,8 +1,25 @@
-const winston = require('winston');
-require('winston-daily-rotate-file');
 const fs = require('fs');
+const path = require('path');
 const folders = require('./folder-setup');
 
+// ---------------------------------------------------------------------------
+// Buffered, daily-rotating logger
+//   - Writes are batched and flushed every FLUSH_INTERVAL ms or FLUSH_SIZE lines
+//   - this is intended to be highly efficient
+// ---------------------------------------------------------------------------
+
+const DEFAULTS = {
+  level:          'info',       // error, warn, info, debug, verbose
+  console:        true,         // write to stdout/stderr
+  consoleErrors:  false,        // include error/warn on console (when running as service, these go to journal)
+  maxFiles:       14,           // number of daily log files to keep
+  maxSize:        0,            // max bytes per file (0 = unlimited)
+  flushInterval:  2000,         // ms between flushes
+  flushSize:      200,          // flush when buffer reaches this many lines
+};
+
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3, verbose: 4 };
+
 class Logger {
   static _instance = null;
 
@@ -13,260 +30,278 @@ class Logger {
     return Logger._instance;
   }
 
+  // options = config.logging section from config.json (all fields optional)
+  //
+  // Example config.json:
+  //   {
+  //     "logging": {
+  //       "level": "info",
+  //       "console": false,
+  //       "consoleErrors": false,
+  //       "maxFiles": 14,
+  //       "maxSize": "50m",
+  //       "flushInterval": 2000,
+  //       "flushSize": 200
+  //     }
+  //   }
+  //
   constructor(options = {}) {
-    this.options = {
-      level: options.level || 'info',
-      logDir: options.logDir || folders.logsDir(),
-      console: options.console !== undefined ? options.console : true,
-      consoleErrors: options.consoleErrors !== undefined ? options.consoleErrors : false,
-      telnetErrors: options.telnetErrors !== undefined ? options.telnetErrors : false,
-      file: {
-        filename: options.file?.filename || 'server-%DATE%.log',
-        datePattern: options.file?.datePattern || 'YYYY-MM-DD',
-        maxSize: options.file?.maxSize || '20m',
-        maxFiles: options.file?.maxFiles || 14
-      }
-    };
+    this.level = options.level || DEFAULTS.level;
+    this.logDir = options.logDir || folders.logsDir();
+    this.maxFiles = options.maxFiles ?? DEFAULTS.maxFiles;
+    this.maxSize = Logger._parseSize(options.maxSize) || DEFAULTS.maxSize;
+    this.showConsole = options.console ?? DEFAULTS.console;
+    this.consoleErrors = options.consoleErrors ?? DEFAULTS.consoleErrors;
+
+    const flushInterval = options.flushInterval ?? DEFAULTS.flushInterval;
+    this._flushSize = options.flushSize ?? DEFAULTS.flushSize;
 
     // Ensure log directory exists
-    if (!fs.existsSync(this.options.logDir)) {
-      fs.mkdirSync(this.options.logDir, { recursive: true });
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
     }
 
-    // Telnet clients storage
-    this.telnetClients = new Set();
+    // Buffer
+    this._buffer = [];
+    this._currentDate = null;
+    this._fd = null;
+    this._currentFileSize = 0;
 
-    this._createLogger();
+    // Periodic flush
+    this._flushTimer = setInterval(() => this._flush(), flushInterval);
+    if (this._flushTimer.unref) this._flushTimer.unref(); // don't keep process alive
 
-    // Log logger initialization
-    this.info('Logger initialized @ ' + this.options.logDir, {
-      level: this.options.level,
-      logDir: this.options.logDir
-    });
+    // Flush on exit
+    process.on('exit', () => this._flushSync());
+
+    this.info('Logger initialized @ ' + this.logDir, {});
   }
 
-  _createLogger() {
-    // Define formats for file output (with full metadata including stack traces)
-    const fileFormats = [
-      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }),
-      winston.format.errors({ stack: true }),
-      winston.format.splat(),
-      winston.format.json()
-    ];
-
-    // Create transports
-    const transports = [];
-
-    // Add file transport with rotation (includes ALL levels with full metadata)
-    const fileTransport = new winston.transports.DailyRotateFile({
-      dirname: this.options.logDir,
-      filename: this.options.file.filename,
-      datePattern: this.options.file.datePattern,
-      maxSize: this.options.file.maxSize,
-      maxFiles: this.options.file.maxFiles,
-      level: this.options.level,
-      format: winston.format.combine(...fileFormats)
-    });
-    transports.push(fileTransport);
-
-    // Add console transport if enabled
-    if (this.options.console) {
-      const consoleFormat = winston.format.combine(
-        winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }),
-        winston.format.errors({ stack: true }),
-        winston.format.colorize({ all: true }),
-        winston.format.printf(info => {
-          const stack = info.stack ? `\n${info.stack}` : '';
-          return `${info.timestamp} ${info.level.padEnd(7)} ${info.message}${stack}`;
-        })
-      );
-
-      const consoleTransport = new winston.transports.Console({
-        level: this.options.level,
-        format: consoleFormat
-      });
-
-      transports.push(consoleTransport);
+  // Parse human-readable size strings: "20m" -> bytes, "1g" -> bytes
+  static _parseSize(value) {
+    if (!value) return 0;
+    if (typeof value === 'number') return value;
+    const m = String(value).match(/^(\d+(?:\.\d+)?)\s*([kmg])?b?$/i);
+    if (!m) return 0;
+    const num = parseFloat(m[1]);
+    switch ((m[2] || '').toLowerCase()) {
+      case 'k': return num * 1024;
+      case 'm': return num * 1024 * 1024;
+      case 'g': return num * 1024 * 1024 * 1024;
+      default:  return num;
     }
+  }
 
-    // Create the winston logger
-    this.logger = winston.createLogger({
-      level: this.options.level,
-      transports,
-      exitOnError: false
-    });
+  // Compatibility: server.js home page reads Logger.getInstance().options.file.maxFiles etc.
+  get options() {
+    return {
+      level: this.level,
+      file: {
+        maxFiles: this.maxFiles,
+        maxSize: this.maxSize > 0 ? `${Math.round(this.maxSize / 1024 / 1024)}m` : 'unlimited',
+      }
+    };
   }
 
-  // Telnet client management
-  addTelnetClient(socket) {
-    this.telnetClients.add(socket);
+  // --- formatting (inline, no libraries) ---
+
+  _timestamp() {
+    const d = new Date();
+    const Y = d.getFullYear();
+    const M = String(d.getMonth() + 1).padStart(2, '0');
+    const D = String(d.getDate()).padStart(2, '0');
+    const h = String(d.getHours()).padStart(2, '0');
+    const m = String(d.getMinutes()).padStart(2, '0');
+    const s = String(d.getSeconds()).padStart(2, '0');
+    const ms = String(d.getMilliseconds()).padStart(3, '0');
+    return `${Y}-${M}-${D} ${h}:${m}:${s}.${ms}`;
   }
 
-  removeTelnetClient(socket) {
-    this.telnetClients.delete(socket);
+  _dateTag() {
+    const d = new Date();
+    const Y = d.getFullYear();
+    const M = String(d.getMonth() + 1).padStart(2, '0');
+    const D = String(d.getDate()).padStart(2, '0');
+    return `${Y}-${M}-${D}`;
   }
 
-  _sendToTelnet(level, message, stack, options) {
-    // Check if we should send errors/warnings to telnet
-    if (!options.telnetErrors && (level === 'error' || level === 'warn')) {
-      return;
-    }
+  _formatLine(level, message, stack) {
+    const ts = this._timestamp();
+    const lv = level.padEnd(7);
+    let line = `${ts} ${lv} ${message}\n`;
+    if (stack) line += stack + '\n';
+    return line;
+  }
+
+  // --- file management ---
 
-    const timestamp = new Date().toISOString().replace('T', ' ').substring(0, 23);
-    let line = `${timestamp} ${level.padEnd(7)} ${message}\n`;
-    if (stack) {
-      line += stack + '\n';
+  _openFile(dateTag) {
+    // Check if we need to rotate due to size
+    if (this._fd !== null && this._currentDate === dateTag) {
+      if (this.maxSize <= 0 || this._currentFileSize < this.maxSize) return;
+      // Size limit exceeded — close and fall through to open a new file
+      try { fs.closeSync(this._fd); } catch (_) { /* intentional */ }
+      this._fd = null;
     }
+    // Close previous (date changed)
+    if (this._fd !== null) {
+      try { fs.closeSync(this._fd); } catch (_) { /* intentional */ }
+    }
+    const filename = `server-${dateTag}.log`;
+    const filePath = path.join(this.logDir, filename);
+    this._fd = fs.openSync(filePath, 'a');
+    try { this._currentFileSize = fs.fstatSync(this._fd).size; } catch (_) { this._currentFileSize = 0; }
+    this._currentDate = dateTag;
+
+    // Maintain a stable symlink so `tail -f server.log` always tracks the current file
+    const linkPath = path.join(this.logDir, 'server.log');
+    try { fs.unlinkSync(linkPath); } catch (_) { /* intentional */ }
+    try { fs.symlinkSync(filename, linkPath); } catch (_) { /* intentional */ }
+
+    this._purgeOldFiles();
+  }
 
-    for (const client of this.telnetClients) {
-      try {
-        client.write(line);
-      } catch (e) {
-        // Client disconnected, remove it
-        this.telnetClients.delete(client);
+  _purgeOldFiles() {
+    try {
+      const files = fs.readdirSync(this.logDir)
+          .filter(f => f.startsWith('server-') && f.endsWith('.log'))
+          .sort();
+      while (files.length > this.maxFiles) {
+        const old = files.shift();
+        fs.unlinkSync(path.join(this.logDir, old));
       }
-    }
+    } catch (_) { /* intentional */ }
   }
 
-  _shouldLogToConsole(level, options) {
-    if (level === 'error' || level === 'warn') {
-      return options.consoleErrors;
+  // --- buffer + flush ---
+
+  _enqueue(line) {
+    this._buffer.push(line);
+    if (this._buffer.length >= this._flushSize) {
+      this._flush();
     }
-    return true;
+  }
+
+  _flush() {
+    if (this._buffer.length === 0) return;
+    const dateTag = this._dateTag();
+    this._openFile(dateTag);
+    const chunk = this._buffer.join('');
+    this._buffer.length = 0;
+    // Async write — fire and forget; OS will buffer anyway
+    const buf = Buffer.from(chunk);
+    this._currentFileSize += buf.length;
+    fs.write(this._fd, buf, 0, buf.length, null, (err) => {
+      if (err) {
+        // If the fd went bad (e.g. date rolled), reopen and retry once
+        try {
+          this._currentDate = null;
+          this._openFile(this._dateTag());
+          fs.writeSync(this._fd, buf, 0, buf.length);
+        } catch (_) { /* intentional */ }
+      }
+    });
+  }
+
+  _flushSync() {
+    if (this._buffer.length === 0) return;
+    const dateTag = this._dateTag();
+    this._openFile(dateTag);
+    const chunk = this._buffer.join('');
+    this._buffer.length = 0;
+    try { fs.writeSync(this._fd, chunk); } catch (_) { /* intentional */ }
+  }
+
+  // --- core log ---
+
+  _shouldLog(level) {
+    return (LEVELS[level] ?? 99) <= (LEVELS[this.level] ?? 2);
   }
 
   _log(level, messageOrError, meta, options) {
+    if (!this._shouldLog(level)) return;
+
     let message;
     let stack;
 
-    // Check if we should skip console for errors/warnings
-    const skipConsole = !this._shouldLogToConsole(level, options);
-
-    // Handle Error objects
     if (messageOrError instanceof Error) {
       message = messageOrError.message;
       stack = messageOrError.stack;
-      if (skipConsole) {
-        // Log only to file transport
-        this.logger.transports
-          .filter(t => !(t instanceof winston.transports.Console))
-          .forEach(t => t.log({ level, message, stack, ...meta }));
-      } else {
-        this.logger[level](message, {stack, ...meta});
-      }
     } else {
       message = String(messageOrError);
       stack = meta?.stack;
-      if (skipConsole) {
-        this.logger.transports
-          .filter(t => !(t instanceof winston.transports.Console))
-          .forEach(t => t.log({ level, message, ...meta }));
-      } else {
-        this.logger[level](message, meta);
-      }
     }
 
-    this._sendToTelnet(level, message, stack, options);
-  }
-
-  error(message, meta = {}) {
-    this._log('error', message, meta, this.options);
-  }
-
-  warn(message, meta = {}) {
-    this._log('warn', message, meta, this.options);
-  }
-
-  info(message, meta = {}) {
-    this._log('info', message, meta, this.options);
+    const line = this._formatLine(level, message, stack);
+
+    // Buffer for file
+    this._enqueue(line);
+
+    // Console
+    if (this.showConsole) {
+      const isErrWarn = level === 'error' || level === 'warn';
+      const consoleErrors = options?.consoleErrors ?? this.consoleErrors;
+      if (!isErrWarn || consoleErrors) {
+        if (isErrWarn) {
+          process.stderr.write(line);
+        } else {
+          process.stdout.write(line);
+        }
+      }
+    }
   }
 
-  debug(message, meta = {}) {
-    this._log('debug', message, meta, this.options);
-  }
+  // --- public API (same as before) ---
 
-  verbose(message, meta = {}) {
-    this._log('verbose', message, meta, this.options);
-  }
+  error(message, meta = {}) { this._log('error', message, meta, this); }
+  warn(message, meta = {})  { this._log('warn', message, meta, this); }
+  info(message, meta = {})  { this._log('info', message, meta, this); }
+  debug(message, meta = {}) { this._log('debug', message, meta, this); }
+  verbose(message, meta = {}) { this._log('verbose', message, meta, this); }
 
-  log(level, message, meta = {}) {
-    this._log(level, message, meta, this.options);
-  }
+  log(level, message, meta = {}) { this._log(level, message, meta, this); }
 
   child(defaultMeta = {}) {
     const self = this;
 
-    // Build module-specific options
     const childOptions = {
-      consoleErrors: defaultMeta.consoleErrors ?? self.options.consoleErrors,
-      telnetErrors: defaultMeta.telnetErrors ?? self.options.telnetErrors
+      consoleErrors: defaultMeta.consoleErrors ?? self.consoleErrors,
     };
 
-    // Remove our custom options from defaultMeta so they don't pollute log output
-    const cleanMeta = { ...defaultMeta };
-    delete cleanMeta.consoleErrors;
-    delete cleanMeta.telnetErrors;
-
-    if (cleanMeta.module) {
-      const modulePrefix = `{${cleanMeta.module}}`;
-
-      return {
-        error: (messageOrError, meta = {}) => {
-          if (messageOrError instanceof Error) {
-            const prefixedError = new Error(`${modulePrefix}: ${messageOrError.message}`);
-            prefixedError.stack = messageOrError.stack;
-            self._log('error', prefixedError, meta, childOptions);
-          } else {
-            self._log('error', `${modulePrefix}: ${messageOrError}`, meta, childOptions);
-          }
-        },
-        warn: (messageOrError, meta = {}) => {
-          if (messageOrError instanceof Error) {
-            const prefixedError = new Error(`${modulePrefix}: ${messageOrError.message}`);
-            prefixedError.stack = messageOrError.stack;
-            self._log('warn', prefixedError, meta, childOptions);
-          } else {
-            self._log('warn', `${modulePrefix}: ${messageOrError}`, meta, childOptions);
-          }
-        },
-        info: (message, meta = {}) => self._log('info', `${modulePrefix}: ${message}`, meta, childOptions),
-        debug: (message, meta = {}) => self._log('debug', `${modulePrefix}: ${message}`, meta, childOptions),
-        verbose: (message, meta = {}) => self._log('verbose', `${modulePrefix}: ${message}`, meta, childOptions),
-        log: (level, message, meta = {}) => self._log(level, `${modulePrefix}: ${message}`, meta, childOptions)
-      };
-    }
+    const modulePrefix = defaultMeta.module ? `{${defaultMeta.module}}` : null;
 
-    // For other metadata without module prefix
-    const childLogger = {
-      error: (messageOrError, meta = {}) => self._log('error', messageOrError, { ...cleanMeta, ...meta }, childOptions),
-      warn: (messageOrError, meta = {}) => self._log('warn', messageOrError, { ...cleanMeta, ...meta }, childOptions),
-      info: (message, meta = {}) => self._log('info', message, { ...cleanMeta, ...meta }, childOptions),
-      debug: (message, meta = {}) => self._log('debug', message, { ...cleanMeta, ...meta }, childOptions),
-      verbose: (message, meta = {}) => self._log('verbose', message, { ...cleanMeta, ...meta }, childOptions),
-      log: (level, message, meta = {}) => self._log(level, message, { ...cleanMeta, ...meta }, childOptions)
+    const wrap = (level) => (messageOrError, meta = {}) => {
+      if (messageOrError instanceof Error) {
+        const prefixed = modulePrefix
+            ? Object.assign(new Error(`${modulePrefix}: ${messageOrError.message}`), { stack: messageOrError.stack })
+            : messageOrError;
+        self._log(level, prefixed, meta, childOptions);
+      } else {
+        const msg = modulePrefix ? `${modulePrefix}: ${messageOrError}` : String(messageOrError);
+        self._log(level, msg, meta, childOptions);
+      }
     };
 
-    return childLogger;
+    return {
+      error: wrap('error'),
+      warn:  wrap('warn'),
+      info:  wrap('info'),
+      debug: wrap('debug'),
+      verbose: wrap('verbose'),
+      log: (level, message, meta = {}) => wrap(level)(message, meta)
+    };
   }
 
   setLevel(level) {
-    this.options.level = level;
-    this.logger.transports.forEach(transport => {
-      transport.level = level;
-    });
+    this.level = level;
     this.info(`Log level changed to ${level}`);
   }
 
   setConsoleErrors(enabled) {
-    this.options.consoleErrors = enabled;
+    this.consoleErrors = enabled;
     this.info(`Console errors ${enabled ? 'enabled' : 'disabled'}`);
   }
 
-  setTelnetErrors(enabled) {
-    this.options.telnetErrors = enabled;
-    this.info(`Telnet errors ${enabled ? 'enabled' : 'disabled'}`);
-  }
-
   stream() {
     return {
       write: (message) => {
@@ -274,6 +309,11 @@ class Logger {
       }
     };
   }
+
+  // Force an immediate flush (e.g. before graceful shutdown)
+  flush() {
+    this._flushSync();
+  }
 }
 
 module.exports = Logger;

package/library/regex-utilities.js

@@ -0,0 +1,13 @@
+const { RE2 } = require('re2-wasm');
+
+class RegExUtilities {
+
+  compile(pattern, flags) {
+    // RE2 requires the unicode flag; add it if not already present
+    const re2Flags = flags && flags.includes('u') ? flags : (flags || '') + 'u';
+    return new RE2(pattern, re2Flags);
+  }
+
+}
+
+module.exports = new RegExUtilities();

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "fhirsmith",
-  "version": "0.8.5",
+  "version": "0.9.0",
+  "txVersion": "1.9.1",
   "description": "A Node.js server that provides a collection of tools to serve the FHIR ecosystem",
   "main": "server.js",
   "engines": {
@@ -50,7 +51,7 @@
     "fs-extra": "^11.3.3",
     "ini": "^6.0.0",
     "inquirer": "^8.2.5",
-    "liquidjs": "^10.24.0",
+    "liquidjs": "^10.25.5",
     "lusca": "^1.7.0",
     "natural": "^6.12.0",
     "node-cron": "^3.0.3",
@@ -60,6 +61,7 @@
     "passport-github2": "^0.1.12",
     "passport-google-oauth20": "^2.0.0",
     "properties-file": "^3.6.4",
+    "re2-wasm": "^1.0.2",
     "rimraf": "^5.0.10",
     "sqlite3": "^5.1.7",
     "tar": "^7.5.7",

package/packages/packages-template.html

@@ -92,7 +92,9 @@
 				<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;
-                    Package Registry last updated as of [%crawler-date%] &nbsp;|&nbsp; [%total-packages%] packages &nbsp;|&nbsp; ([%ms%] ms)
+                    Package Registry last updated as of [%crawler-date%] &nbsp;|&nbsp; [%total-packages%] packages &nbsp;|
+                    &nbsp; ([%ms%] ms)
+                    [%sponsorMessage%]
         </p>
 			</div>  <!-- /inner-wrapper -->
 		</div>  <!-- /container -->

package/publisher/publisher-template.html

@@ -123,6 +123,7 @@
                     <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;
                      ([%ms%] ms)
+                    [%sponsorMessage%]
         </p>
 			</div>  <!-- /inner-wrapper -->
 		</div>  <!-- /container -->

package/publisher/publisher.js

@@ -714,17 +714,38 @@ class PublisherModule {
 
     // Step 1: Clone supporting repositories into the task directory
     const registryDir = path.join(taskDir, 'ig-registry');
-    const historyDir = path.join(taskDir, 'fhir-ig-history-template');
-    const templatesDir = path.join(taskDir, 'fhir-web-templates');
 
     await this.runCommand('git', ['clone', 'git@github.com:FHIR/ig-registry.git', registryDir],
         {}, task.id, 'Cloning ig-registry');
 
-    await this.runCommand('git', ['clone', 'https://github.com/HL7/fhir-ig-history-template.git', historyDir],
-        {}, task.id, 'Cloning fhir-ig-history-template');
+    // Use website-configured history templates path if provided, otherwise clone the default repo
+    let historyDir;
+    if (website.history_templates) {
+      historyDir = website.history_templates;
+      await this.logTaskMessage(task.id, 'info', 'Using configured history templates: ' + historyDir);
+      if (!fs.existsSync(historyDir)) {
+        throw new Error('Configured history_templates path does not exist: ' + historyDir);
+      }
+    } else {
+      historyDir = path.join(taskDir, 'fhir-ig-history-template');
+      await this.runCommand('git', ['clone', 'https://github.com/HL7/fhir-ig-history-template.git', historyDir],
+          {}, task.id, 'Cloning fhir-ig-history-template');
+    }
 
-    await this.runCommand('git', ['clone', 'https://github.com/HL7/fhir-web-templates.git', templatesDir],
-        {}, task.id, 'Cloning fhir-web-templates');
+    // Use website-configured web templates path if provided, otherwise clone the default repo.
+    // This allows pointing to a subdirectory of the templates repo for different target websites.
+    let templatesDir;
+    if (website.web_templates) {
+      templatesDir = website.web_templates;
+      await this.logTaskMessage(task.id, 'info', 'Using configured web templates: ' + templatesDir);
+      if (!fs.existsSync(templatesDir)) {
+        throw new Error('Configured web_templates path does not exist: ' + templatesDir);
+      }
+    } else {
+      templatesDir = path.join(taskDir, 'fhir-web-templates');
+      await this.runCommand('git', ['clone', 'https://github.com/HL7/fhir-web-templates.git', templatesDir],
+          {}, task.id, 'Cloning fhir-web-templates');
+    }
 
     // Step 2: Reuse the publisher.jar from the draft build
     const publisherJar = path.join(taskDir, 'publisher.jar');
@@ -1853,7 +1874,7 @@ class PublisherModule {
         } else {
           content += '<div class="table-responsive">';
           content += '<table class="table table-striped">';
-          content += '<thead><tr><th>Name</th><th>Local Folder</th><th>Git Root</th><th>Update Script</th><th>Active</th><th>Created</th><th>Actions</th></tr></thead>';
+          content += '<thead><tr><th>Name</th><th>Local Folder</th><th>Git Root</th><th>History Templates</th><th>Web Templates</th><th>Update Script</th><th>Active</th><th>Created</th><th>Actions</th></tr></thead>';
           content += '<tbody>';
 
           websites.forEach(website => {

package/registry/registry-template.html

@@ -92,7 +92,9 @@
 				<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;
-       Terminology Registry last updated as of [%crawler-date%] &nbsp;|&nbsp; [%total-packages%] packages &nbsp;|&nbsp; ([%ms%] ms)
+       Terminology Registry last updated as of [%crawler-date%] &nbsp;|&nbsp; [%total-packages%] packages &nbsp;|
+                    &nbsp; ([%ms%] ms)
+                    [%sponsorMessage%]
         </p>
 			</div>  <!-- /inner-wrapper -->
 		</div>  <!-- /container -->