fhirsmith 0.13.4 → 0.14.1

package/tx/operation-context.js

@@ -4,6 +4,7 @@ const crypto = require("crypto");
 const {Languages} = require("../library/languages");
 const {Issue} = require("./library/operation-outcome");
 const Logger = require("../library/logger");
+const { readCgroupMemoryLimit } = require('../library/cgroup-memory');
 
 /**
  * Check if running under a debugger
@@ -110,6 +111,63 @@ class ResourceCache {
     // so a client polling $cache-control?mode=check can work out how often it needs
     // to poll instead of guessing. Null = not advertised.
     this.idleTimeoutMs = null;
+    // This server instance's code (modules.tx.instanceCode), prefixed onto every
+    // cache-id it issues as "<code>.<uuid>". A proxy in front of several instances
+    // routes on the prefix to get a cached request back to the one instance that
+    // holds the cache (see nginx.md). Null = unprefixed ids (a single server).
+    this.instanceCode = null;
+  }
+
+  /**
+   * Set the instance code that is prefixed onto the cache-ids this cache issues.
+   * 1-16 letters and digits: the code is followed by a '.', a proxy has to be able
+   * to match it with a simple pattern, and the whole id must stay a valid FHIR id. Empty/null/undefined means no prefix.
+   *
+   * @param {string|null|undefined} code
+   * @throws {Error} if the code is not letters and digits
+   */
+  setInstanceCode(code) {
+    this.instanceCode = ResourceCache.checkInstanceCode(code);
+  }
+
+  /**
+   * Validate an instance code from config.
+   * @param {string|null|undefined} code
+   * @returns {string|null} the code, or null for none (empty/null/undefined)
+   * @throws {Error} if the code is not letters and digits
+   */
+  static checkInstanceCode(code) {
+    if (code === undefined || code === null || code === '') {
+      return null;
+    }
+    // At most 16 characters: the cache-id goes back to the client as a FHIR id
+    // (valueId), which is capped at 64 - and "<code>." plus a 36-character UUID
+    // has to fit.
+    if (typeof code !== 'string' || !/^[A-Za-z0-9]{1,16}$/.test(code)) {
+      throw new Error(`tx instanceCode '${code}' is not valid: it must be 1-16 letters and digits`);
+    }
+    return code;
+  }
+
+  /**
+   * Mint a new cache-id: a UUID, prefixed with "<instanceCode>." when this server
+   * has an instance code. Minting only - the caller creates the entry with set().
+   * @returns {string}
+   */
+  newCacheId() {
+    const uuid = crypto.randomUUID();
+    return this.instanceCode ? `${this.instanceCode}.${uuid}` : uuid;
+  }
+
+  /**
+   * The instance code in a cache-id, or null if it has none. Ids this server mints
+   * are either a bare UUID (no '.') or "<code>.<uuid>".
+   * @param {string} cacheId
+   * @returns {string|null}
+   */
+  static issuerOf(cacheId) {
+    const dot = typeof cacheId === 'string' ? cacheId.indexOf('.') : -1;
+    return dot > 0 ? cacheId.substring(0, dot) : null;
   }
 
   /**
@@ -164,7 +222,9 @@ class ResourceCache {
 
   /**
    * The message to report for a cache-id that isn't here: which of the three
-   * fates it met, with the numbers that make it checkable. Both throw sites
+   * fates it met, with the numbers that make it checkable - or, when there's no
+   * record of it and its prefix names another instance, that it was routed here
+   * by mistake. Both throw sites
    * (worker.setupAdditionalResources and batchValidate.frontLoadBatch) use this
    * so they can never drift apart.
    *
@@ -175,6 +235,15 @@ class ResourceCache {
   describeMissing(cacheId) {
     const t = this.tombstone(cacheId);
     if (!t) {
+      // No record of it here. If its prefix names a different instance, say so:
+      // that's a routing problem (proxy misconfigured, or the owning instance is
+      // down and the request fell through to a backup), not a lifecycle one.
+      const issuer = ResourceCache.issuerOf(cacheId);
+      if (issuer && issuer !== this.instanceCode) {
+        return this.instanceCode
+          ? { messageId: 'CACHE_ID_OTHER_INSTANCE', params: [cacheId, issuer, this.instanceCode] }
+          : { messageId: 'CACHE_ID_OTHER_INSTANCE_UNNAMED', params: [cacheId, issuer] };
+      }
       return { messageId: 'CACHE_ID_UNKNOWN', params: [cacheId] };
     }
     const ago = formatDuration(Date.now() - t.at);
@@ -752,18 +821,12 @@ class ExpansionCache {
  * Returns the byte limit, or 0 if unavailable (disables the check).
  */
 function readMemoryLimit() {
-  try {
-    const raw = require('fs').readFileSync('/sys/fs/cgroup/memory.max', 'utf8').trim();
-    if (raw === 'max') return 0; // no cgroup limit
-    return parseInt(raw);
-  } catch {
-    return 0; // not on Linux / no cgroup
-  }
+  return readCgroupMemoryLimit().limit;
 }
 
 const MEMORY_LIMIT = readMemoryLimit();
 const MEMORY_FRACTION = 0.98;
-const MEMORY_THRESHOLD = MEMORY_LIMIT > 0 ? MEMORY_LIMIT * MEMORY_FRACTION : 0; // 90% of cgroup limit
+const MEMORY_THRESHOLD = MEMORY_LIMIT > 0 ? MEMORY_LIMIT * MEMORY_FRACTION : 0; // MEMORY_FRACTION of cgroup limit
 const CHECK_FREQUENCY = 100;
 // How long an operation may compute without yielding the event loop (ms).
 // Node runs all JS on one thread: while a long operation executes, no other
@@ -891,8 +954,8 @@ class OperationContext {
     if (elapsed > this.timeLimit) {
       const timeInSeconds = Math.round(this.timeLimit / 1000);
       this.log(`Operation took too long @ ${place} (${this.constructor.name})`);
-      const error = new Issue("error", "too-costly", null,
-          `Operation exceeded time limit of ${timeInSeconds} seconds at ${place}`);
+      const error = new Issue("error", "too-costly", null, null,
+          `Operation exceeded time limit of ${timeInSeconds} seconds at ${place}`, "too-costly", 422);
       error.diagnostics = this.diagnostics();
       throw error;
     }
@@ -904,8 +967,8 @@ class OperationContext {
         const usedGB = (rss / 1024 / 1024 / 1024).toFixed(1);
         const limitGB = (MEMORY_LIMIT / 1024 / 1024 / 1024).toFixed(1);
         this.log(`Memory Limit: ${usedGB} GB of ${limitGB} GB limit @ ${place}`);
-        const error = new Issue("error", "too-costly", null,
-            `Operation aborted: server memory usage (${usedGB} GB) exceeds safe threshold (${MEMORY_FRACTION * 100}% of ${limitGB} GB limit) at ${place}`);
+        const error = new Issue("error", "too-costly", null, null,
+            `Operation aborted: server memory usage (${usedGB} GB) exceeds safe threshold (${MEMORY_FRACTION * 100}% of ${limitGB} GB limit) at ${place}`, "too-costly", 422);
         error.diagnostics = this.diagnostics();
         throw error;
       }
@@ -963,8 +1026,8 @@ class OperationContext {
       this._clock.lastYield = resumed;
       if (this._clock.clientGone) {
         this.log(`Operation abandoned @ ${place}: client disconnected`);
-        const error = new Issue("error", "too-costly", null,
-            `Operation abandoned at ${place}: the client disconnected before the response was ready`);
+        const error = new Issue("error", "too-costly", null, null,
+            `Operation abandoned at ${place}: the client disconnected before the response was ready`, "too-costly", 422);
         error.abandoned = true;
         error.diagnostics = this.diagnostics();
         throw error;
@@ -996,8 +1059,8 @@ class OperationContext {
     }
     if (this._clock.clientGone) {
       this.log(`Operation abandoned @ ${place}: client disconnected`);
-      const error = new Issue("error", "too-costly", null,
-          `Operation abandoned at ${place}: the client disconnected before the response was ready`);
+      const error = new Issue("error", "too-costly", null, null,
+          `Operation abandoned at ${place}: the client disconnected before the response was ready`, "too-costly", 422);
       error.abandoned = true;
       error.diagnostics = this.diagnostics();
       throw error;

package/tx/provider.js

@@ -449,6 +449,91 @@ class Provider {
     return null;
   }
 
+  /**
+   * A checker for codes in one code system, so that a page can ask about many codes
+   * without paying to build the code system each time.
+   *
+   * This is for deciding whether to offer a link. A property value that came back from
+   * $lookup as a code is, by the definition of CodeSystem.property.type, a concept in the
+   * same code system - but a provider can declare a property that way and then put
+   * something else in it (ICD-11's classKind is chapter|block|window|category, none of
+   * which is an ICD-11 concept), and a link to a code that is not there is worse than no
+   * link. So the codes are checked, once each, against the code system itself.
+   *
+   * @param {OperationContext} opContext
+   * @param {string} system
+   * @param {string|null} version
+   * @returns {Promise<function(string): Promise<string|null>>|null} a function returning
+   *   the code's display (possibly empty) if it exists and null if it does not, or null
+   *   when this server does not have that code system at all
+   */
+  async codeChecker(opContext, system, version) {
+    validateParameter(opContext, "opContext", OperationContext);
+    if (!system) {
+      return null;
+    }
+    if (system.includes("|")) {
+      version = version || system.substring(system.indexOf("|") + 1);
+      system = system.substring(0, system.indexOf("|"));
+    }
+    const vurl = system + (version ? "|" + version : "");
+    const vurlMM = VersionUtilities.isSemVer(version) ? system + "|" + VersionUtilities.getMajMin(version) : null;
+
+    let factory = this.codeSystemFactories.get(vurl);
+    if (factory == null && vurlMM) {
+      factory = this.codeSystemFactories.get(vurlMM);
+    }
+    if (factory != null) {
+      const csp = await factory.build(opContext, []);
+      if (csp) {
+        opContext.registerProvider(csp);
+        return async (code) => {
+          const located = await csp.locate(code);
+          return located && located.context ? (await csp.display(located.context)) || '' : null;
+        };
+      }
+    }
+
+    let cs = this.codeSystems.get(vurl);
+    if (cs == null && vurlMM) {
+      cs = this.codeSystems.get(vurlMM);
+    }
+    if (cs != null) {
+      return async (code) => {
+        const c = cs.codeMap.get(code);
+        return c ? (c.display || '') : null;
+      };
+    }
+    return null;
+  }
+
+  /**
+   * A link to $lookup for a code on this server.
+   *
+   * resolveCode() answers "where does this code live" - a code system page, or the
+   * publisher's own browser - which is the right answer in prose. In an expansion the
+   * question is different: the reader has a list of codes in front of them and wants to
+   * know what one of them actually is, which is what $lookup answers, here, in the
+   * version the expansion used.
+   *
+   * @param {string} system
+   * @param {string|null} version - may also be carried on system as system|version
+   * @param {string} code
+   * @returns {string|null} the URL, or null if there is not enough to build one
+   */
+  lookupLink(system, version, code) {
+    if (!system || !code) {
+      return null;
+    }
+    if (system.includes("|")) {
+      version = version || system.substring(system.indexOf("|") + 1);
+      system = system.substring(0, system.indexOf("|"));
+    }
+    return this.path + "/CodeSystem/$lookup?system=" + encodeURIComponent(system)
+      + (version ? "&version=" + encodeURIComponent(version) : "")
+      + "&code=" + encodeURIComponent(code);
+  }
+
   async hasCsVersion(system, version) {
     for (let cs of this.codeSystems.values()) {
       if (cs.url == system && cs.version == version) {

package/tx/sct/editions.js

@@ -0,0 +1,70 @@
+/**
+ * The SNOMED CT editions FHIRsmith knows by name - the one table, used for the provider's
+ * description and name (cs-snomed.js) and for the edition named in unknown-code messages
+ * (SCTVersion in workers/worker.js). Keyed by the edition's module id, as it appears in a
+ * version URI: http://snomed.info/sct/[module]/version/[date]
+ *
+ * name - human readable edition name
+ * code - short code used in the provider name ("SCT US")
+ *
+ * (The importer and the registry keep their own tables: those carry import settings and
+ * registry codes, not display names.)
+ */
+const EDITIONS = {
+  '900000000000207008': { name: 'International Edition', code: 'Intl' },
+  // The terminology-ecosystem test distribution, published under xsct - see the
+  // tx-ecosystem IG, which requires a server claiming the snomed mode to load it.
+  '31000003106': { name: 'Test Edition', code: 'Test' },
+  '449081005': { name: 'International Spanish Edition', code: 'es' },
+  '11000221109': { name: 'Argentinian Edition', code: 'AR-es' },
+  '32506021000036107': { name: 'Australian Edition (with drug extension)', code: 'AU+' },
+  '11000234105': { name: 'Austrian Edition', code: 'AT' },
+  '11000172109': { name: 'Belgian Edition', code: 'BE' },
+  '20621000087109': { name: 'Canadian English Edition', code: 'CA-en' },
+  '20611000087101': { name: 'Canadian Canadian French Edition', code: 'CA-fr' },
+  '554471000005108': { name: 'Danish Edition', code: 'DK' },
+  '11000279109': { name: 'Czech Edition', code: 'CZ' },
+  '11000181102': { name: 'Estonian Edition', code: 'ET' },
+  '11000229106': { name: 'Finnish Edition', code: 'FI' },
+  '11000274103': { name: 'German Edition', code: 'DE' },
+  '1121000189102': { name: 'Indian Edition', code: 'IN' },
+  '827022005': { name: 'IPS Terminology', code: 'IPS' },
+  '11000220105': { name: 'Irish Edition', code: 'IE' },
+  '11000146104': { name: 'Netherlands Edition', code: 'NL' },
+  '21000210109': { name: 'New Zealand Edition', code: 'NZ' },
+  '51000202101': { name: 'Norwegian Edition', code: 'NO' },
+  '11000267109': { name: 'Republic of Korea Edition (South Korea)', code: 'KR' },
+  '900000001000122104': { name: 'Spanish National Edition', code: 'ES-es' },
+  '45991000052106': { name: 'Swedish Edition', code: 'SE' },
+  '2011000195101': { name: 'Swiss Edition', code: 'CH' },
+  '83821000000107': { name: 'UK Edition', code: 'UK' },
+  '999000021000000109': { name: 'UK Clinical Edition', code: 'UK-Clinical' },
+  '5631000179106': { name: 'Uruguay Edition', code: 'UY' },
+  '731000124108': { name: 'US Edition', code: 'US' },
+  '21000325107': { name: 'Chilean Edition', code: 'CL' },
+  '5991000124107': { name: 'US Edition (with ICD-10-CM maps)', code: 'US+' }
+};
+
+/**
+ * @param {string} edition - edition module id
+ * @returns {string|null} the edition's name, or null if it isn't a known edition
+ */
+function editionName(edition) {
+  const e = EDITIONS[edition];
+  return e ? e.name : null;
+}
+
+/**
+ * @param {string} edition - edition module id
+ * @returns {string|null} the edition's short code, or null if it isn't a known edition
+ */
+function editionCode(edition) {
+  const e = EDITIONS[edition];
+  return e ? e.code : null;
+}
+
+module.exports = {
+  EDITIONS,
+  editionName,
+  editionCode
+};

package/tx/sct/expressions.js

@@ -26,6 +26,8 @@ const MRCM_ATTRIBUTE_RANGE_REFSET = 723562003n;
 // rules about authoring precoordinated concepts and do not constrain expressions.
 const MRCM_CONTENT_TYPE_ALL = 723596005n;
 const MRCM_CONTENT_TYPE_POSTCOORDINATED = 723594008n;
+// ruleStrengthId value for an optional rule (the other value, 723597001, is mandatory).
+const MRCM_RULE_STRENGTH_OPTIONAL = 723598006n;
 
 // Expression status enumeration
 const SnomedExpressionStatus = {
@@ -44,6 +46,17 @@ class SnomedExpressionBase {
   }
 }
 
+/**
+ * Whether an attribute value has to be written in brackets: the compositional grammar
+ * only allows a bare conceptReference as an attribute value, so anything with more than
+ * one focus concept, or with refinements of its own, is a bracketed subExpression.
+ */
+function needsBrackets(value) {
+  return !!value && ((value.concepts && value.concepts.length > 1) ||
+    (value.refinements && value.refinements.length > 0) ||
+    (value.refinementGroups && value.refinementGroups.length > 0));
+}
+
 /**
  * Represents a SNOMED concept with optional code, description, literal, or decimal value
  */
@@ -161,7 +174,9 @@ class SnomedRefinement extends SnomedExpressionBase {
    * Get a string description of this refinement
    */
   describe() {
-    return this.name.describe() + '=' + this.value.describe();
+    // A refined or conjoined value has to be bracketed - see attributeValue() in the parser
+    const v = this.value.describe();
+    return this.name.describe() + '=' + (needsBrackets(this.value) ? '(' + v + ')' : v);
   }
 
   /**
@@ -647,16 +662,33 @@ class SnomedExpressionParser {
 
   /**
    * Parse an attribute value
+   *
+   * The compositional grammar ABNF is
+   *   attributeValue  = expressionValue / QM stringValue QM / "#" numericValue / booleanValue
+   *   expressionValue = ws ( conceptReference / "(" ws subExpression ws ")" ) ws
+   * so a value that is anything more than a single concept - a refined concept, or a
+   * conjunction - must be in brackets. This parser used to take an unbracketed
+   * sub-expression too (367430006:{405813007=85562004:272741003=24028007}), but that is not
+   * just non-conformant, it is ambiguous: in A:{B=C:D=E,F=G} nothing says whether F=G
+   * refines C or A, and the old parser silently picked C. Other parsers reject it, so we
+   * do too, and the renderer brackets nested values so that what we emit re-parses anywhere.
    */
   attributeValue() {
     this.ws();
 
     if (this.gchar('(')) {
       const result = this.expression();
+      this.ws();
       this.fixed(')');
       return result;
     } else {
-      return this.expression();
+      const result = new SnomedExpression();
+      result.start = this.cursor;
+      result.concepts.push(this.concept());
+      this.rule(this.peek() !== ':' && this.peek() !== '+',
+        'A refined or conjoined attribute value must be enclosed in brackets, e.g. 405813007=(85562004:272741003=24028007) (in "' + this.source + '")');
+      result.stop = this.cursor;
+      return result;
     }
   }
 
@@ -1625,7 +1657,7 @@ class SnomedExpressionServices {
         this.checkRefinement(refinement);
         this.checkRefinementDomain(expression, refinement);
         this.checkRefinementRange(refinement);
-        this.checkRefinementGrouped(refinement);
+        this.checkRefinementGrouped(expression, refinement);
       }
     }
 
@@ -1644,12 +1676,8 @@ class SnomedExpressionServices {
 
   /**
    * Check one refinement against the MRCM attribute domain reference set: the
-   * focus concept the attribute is applied to must be in the attribute's domain.
-   *
-   * Every applicable rule must hold, mandatory or optional. Internationally
-   * there is exactly one optional rule - Laterality in the lateralizable body
-   * structure reference set - and it is the rule that stops laterality being
-   * applied to a structure that cannot be lateralized, so it is enforced.
+   * focus concept the attribute is applied to must be in one of the attribute's
+   * domains (see applicableDomainRules for how several rules combine).
    *
    * Attributes with no rule in this edition's MRCM are not checked, and neither
    * is cardinality (checkExpressionCardinality), grouping (checkRefinementGrouped)
@@ -1663,44 +1691,84 @@ class SnomedExpressionServices {
     if (attribute === undefined || attribute === null || attribute === NO_REFERENCE) {
       return;
     }
-    const rules = this.mrcmAttributeDomains().get(attribute);
-    if (!rules || rules.length === 0) {
-      // This edition's concept model says nothing about this attribute (3 active
-      // attributes internationally have no domain rule and appear in no
-      // postcoordination domain template), so there is nothing to check it against.
-      return;
+    const result = this.applicableDomainRules(expression, attribute);
+    if (result.failed) {
+      const attrDesc = this.describeConceptForMessage(attribute);
+      const focusDesc = result.focus.map(f => this.describeConceptForMessage(f)).join(' + ');
+      throw new Error(`The SNOMED CT concept model does not allow the attribute ${attrDesc} on ${focusDesc}`
+        + ` (the attribute is only valid ${result.failed})`);
     }
+  }
 
-    // The focus may be a conjunction of concepts; the expression is a subtype of
-    // each of them, so the attribute is in domain if any focus concept is.
+  /**
+   * Work out which of an attribute's MRCM domain rules apply to an expression's
+   * focus concept(s), and whether the attribute is allowed there at all.
+   *
+   * An attribute has one domain rule per domain it may be used in, so the
+   * mandatory rules are ALTERNATIVES: |Due to| has one rule for |Clinical finding|
+   * and one for |Event|, and is valid on a concept in either (issue #287 - these
+   * were once ANDed, which rejected |Due to| everywhere).
+   *
+   * Optional rules are RESTRICTIONS layered on top: internationally the only one
+   * is |Laterality| for the lateralizable body structure reference set, which
+   * narrows the mandatory |Anatomical structure| rule, and it is what stops
+   * laterality being applied to a structure that cannot be lateralized. So an
+   * optional rule must also hold wherever a mandatory rule has admitted the
+   * attribute. (An attribute with only optional rules treats them as
+   * alternatives, since there is nothing for them to narrow.)
+   *
+   * The focus may be a conjunction of concepts; the expression is a subtype of
+   * each of them, so a rule holds if it holds for any focus concept.
+   *
+   * @param {SnomedExpression} expression
+   * @param {number} attribute - concept index of the attribute
+   * @returns {{rules: Array, focus: number[], failed: string|null}} the rules that
+   *   apply (for cardinality and grouping - empty when the attribute is out of
+   *   domain), the focus concepts, and when the attribute is not allowed on this
+   *   focus, a description of the domain(s) it is restricted to
+   */
+  applicableDomainRules(expression, attribute) {
+    const rules = this.mrcmAttributeDomains().get(attribute);
     const focus = [];
     for (const concept of expression.concepts) {
       if (concept.reference !== undefined && concept.reference !== null && concept.reference !== NO_REFERENCE) {
         focus.push(concept.reference);
       }
     }
-    if (focus.length === 0) {
-      return;
+    if (!rules || rules.length === 0 || focus.length === 0) {
+      // This edition's concept model says nothing about this attribute (3 active
+      // attributes internationally have no domain rule and appear in no
+      // postcoordination domain template), so there is nothing to check it against.
+      return { rules: rules || [], focus, failed: null };
     }
 
-    // Report every rule that failed, not just the first: a laterality on a
-    // disorder breaks both the anatomical structure domain and the lateralizable
-    // refset rule, and naming only one of them misleads.
-    const failed = [];
-    for (const rule of rules) {
-      const ok = focus.some(f => rule.isRefset
-        ? this.conceptInRefSet(rule.domain, f)
-        : this.subsumes(rule.domain, f));
-      if (!ok) {
-        failed.push((rule.isRefset ? 'for concepts in ' : 'in the domain ') + this.describeConceptForMessage(rule.domain));
+    const holds = rule => focus.some(f => rule.isRefset
+      ? this.conceptInRefSet(rule.domain, f)
+      : this.subsumes(rule.domain, f));
+    const describe = rule => (rule.isRefset ? 'for concepts in ' : 'in the domain ')
+      + this.describeConceptForMessage(rule.domain);
+
+    const mandatory = rules.filter(rule => !rule.optional);
+    const alternatives = mandatory.length > 0 ? mandatory : rules;
+    const restrictions = mandatory.length > 0 ? rules.filter(rule => rule.optional) : [];
+
+    const matched = alternatives.filter(holds);
+    const failedRestrictions = restrictions.filter(rule => !holds(rule));
+    if (matched.length === 0) {
+      // Name every domain the attribute could have been used in, and any
+      // restriction that also fails: a laterality on a disorder is outside both
+      // the anatomical structure domain and the lateralizable refset, and naming
+      // only one of them misleads.
+      const parts = [alternatives.map(describe).join(', or ')];
+      for (const rule of failedRestrictions) {
+        parts.push(describe(rule));
       }
+      return { rules: [], focus, failed: parts.join(', and ') };
     }
-    if (failed.length > 0) {
-      const attrDesc = this.describeConceptForMessage(attribute);
-      const focusDesc = focus.map(f => this.describeConceptForMessage(f)).join(' + ');
-      throw new Error(`The SNOMED CT concept model does not allow the attribute ${attrDesc} on ${focusDesc}`
-        + ` (the attribute is only valid ${failed.join(', and ')})`);
+    if (failedRestrictions.length > 0) {
+      return { rules: [], focus, failed: failedRestrictions.map(describe).join(', and ') };
     }
+    return { rules: matched.concat(restrictions), focus, failed: null };
   }
 
   /**
@@ -1721,17 +1789,19 @@ class SnomedExpressionServices {
    * expression is not classifiable is honest, quietly guessing what they meant is not.
    *
    * As elsewhere in this check, an attribute with no rule in this edition's MRCM is
-   * left alone, and where several rules apply the strictest wins.
+   * left alone. Only the rules for the domain(s) the focus concept is in count
+   * (see applicableDomainRules), and where several of those apply the strictest wins.
    *
+   * @param {SnomedExpression} expression - the expression the refinement is on
    * @param {SnomedRefinement} refinement - a refinement outside any group
    */
-  checkRefinementGrouped(refinement) {
+  checkRefinementGrouped(expression, refinement) {
     const attribute = refinement.name ? refinement.name.reference : NO_REFERENCE;
     if (attribute === undefined || attribute === null || attribute === NO_REFERENCE) {
       return;
     }
-    const rules = this.mrcmAttributeDomains().get(attribute);
-    if (!rules || rules.length === 0) {
+    const rules = this.applicableDomainRules(expression, attribute).rules;
+    if (rules.length === 0) {
       return;
     }
     if (!rules.some(rule => rule.grouped)) {
@@ -1747,7 +1817,7 @@ class SnomedExpressionServices {
    * Built once per edition and cached; an edition with no MRCM yields an empty
    * map, which turns the domain check off rather than failing.
    *
-   * @returns {Map<number, Array<{domain: number, isRefset: boolean, grouped: boolean, max: number, maxInGroup: number}>>}
+   * @returns {Map<number, Array<{domain: number, isRefset: boolean, grouped: boolean, optional: boolean, max: number, maxInGroup: number}>>}
    */
   mrcmAttributeDomains() {
     if (this._mrcmAttributeDomains) {
@@ -1762,6 +1832,7 @@ class SnomedExpressionServices {
     }
     const contentAll = this.conceptIndexOf(MRCM_CONTENT_TYPE_ALL);
     const contentPost = this.conceptIndexOf(MRCM_CONTENT_TYPE_POSTCOORDINATED);
+    const strengthOptional = this.conceptIndexOf(MRCM_RULE_STRENGTH_OPTIONAL);
 
     // Every concept that defines a reference set, so a domain that is itself a
     // reference set (the lateralizable body structure refset) is tested by
@@ -1804,6 +1875,9 @@ class SnomedExpressionServices {
         // The grouped column is a plain 0/1 (type 4), not a reference into the string
         // table like the cardinalities beside it - reading it as one yields garbage.
         grouped: values[2] === 1,
+        // An optional rule narrows a mandatory one rather than adding a domain
+        // (see applicableDomainRules).
+        optional: values[8] === strengthOptional,
         // Only the maximums are enforced. A minimum ("1..1") says a concept in
         // this domain must have the attribute in its own definition; it does not
         // say a refinement of that concept has to restate it.
@@ -2033,8 +2107,10 @@ class SnomedExpressionServices {
    * a single relationship group - a maximum of 0 there is how the MRCM says an
    * attribute is ungrouped (all 37 ungrouped attributes carry "0..0").
    *
-   * Rules are ANDed, so where an attribute has several rules the tightest
-   * maximum applies. Nested value expressions are checked separately, when
+   * Only the rules for the domain(s) the focus concept is in count - |Procedure
+   * device| is 0..* in a group on a procedure but 0..1 on an observable, and a
+   * procedure must not get the observable's limit (see applicableDomainRules).
+   * Where several of those rules apply, the tightest maximum wins. Nested value expressions are checked separately, when
    * checkRefinement recurses into them.
    *
    * @param {SnomedExpression} expression
@@ -2072,10 +2148,14 @@ class SnomedExpressionServices {
       perGroup.push(counts);
     }
 
+    const applicable = new Map();
     const limit = (attribute, field) => {
-      const rules = domains.get(attribute);
-      if (!rules || rules.length === 0) {
-        return Infinity;
+      if (!applicable.has(attribute)) {
+        applicable.set(attribute, this.applicableDomainRules(expression, attribute).rules);
+      }
+      const rules = applicable.get(attribute);
+      if (rules.length === 0) {
+        return Infinity; // no rule, or out of domain (which checkRefinementDomain reports)
       }
       return rules.reduce((least, rule) => Math.min(least, rule[field]), Infinity);
     };
@@ -2529,7 +2609,11 @@ class SnomedExpressionServices {
   renderRefinement(parts, expr, option) {
     this.renderConcept(parts, expr.name, option);
     parts.push('=');
+    // a refined or conjoined value must be bracketed, or no conformant parser will read it back
+    const bracket = needsBrackets(expr.value);
+    if (bracket) parts.push('(');
     this.renderExpressionParts(parts, expr.value, option);
+    if (bracket) parts.push(')');
   }
 
   getDisplayName(conceptIdOrReference) {