@cosyte/fhir 0.0.10 → 0.1.0

package/dist/index.cjs

@@ -220,6 +220,12 @@ function markNonObjectMeta(node, source) {
 function markDroppedText(node) {
   return { ...node, droppedText: true };
 }
+function isForeignRoot(node) {
+  return node.kind === "complex" && node.foreignRoot === true;
+}
+function markForeignRoot(node) {
+  return { ...node, foreignRoot: true };
+}
 function primitive(value, meta = {}) {
   const node = { kind: "primitive", value };
   if (meta.id !== void 0) node.id = meta.id;
@@ -1237,1139 +1243,1798 @@ function typesOf(resource) {
   return getAllProperties(resource, "resourceType").flatMap((node) => [...primitiveStrings(node)]);
 }
 
-// src/safety/modifier-elements.ts
-var PATIENT = "Patient";
-var PRACTITIONER = "Practitioner";
-var IDENTIFIER = "identifier";
-var UNGATED_ELEMENTS = ["implicitRules", "comparator"];
-var MODIFIER_ELEMENT_ROOT_TYPES = /* @__PURE__ */ new Set([
-  ...SAFETY_RESOURCE_TYPES,
-  PATIENT,
-  PRACTITIONER,
-  "Bundle"
-]);
-function carries(node, name) {
-  return getAllProperties(node, name).length > 0 || getAllProperties(node, `_${name}`).length > 0;
-}
-function eachEntry(value, path, visit2) {
-  if (isList(value)) {
-    value.items.forEach((item, index) => {
-      if (isComplex(item)) visit2(item, `${path}[${String(index)}]`);
-    });
-    return;
-  }
-  if (isComplex(value)) visit2(value, path);
-}
-function collectModifierElements(node, path, out) {
-  for (const element of UNGATED_ELEMENTS) {
-    if (carries(node, element)) out.push({ element, location: childPath(path, element) });
-  }
-  const types = typesOf(node);
-  if (types.includes(PATIENT) && carries(node, "active")) {
-    out.push({ element: "active", location: childPath(path, "active") });
-  }
-  if (types.includes(PRACTITIONER)) {
-    const at = childPath(path, IDENTIFIER);
-    for (const written of getAllProperties(node, IDENTIFIER)) {
-      eachEntry(written, at, (entry, entryPath) => {
-        if (carries(entry, "use")) {
-          out.push({ element: "use", location: childPath(entryPath, "use") });
-        }
-      });
-    }
-  }
-}
-function dedupeModifierElements(reports) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const report of reports) {
-    const key = `${report.element}\0${report.location}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(report);
-  }
-  return out;
-}
-function rebaseModifierElements(reports, prefix, types) {
-  const declared = types[0];
-  if (declared === void 0) return [...reports];
-  const root = MODIFIER_ELEMENT_ROOT_TYPES.has(declared) ? rootPath(declared) : WITHHELD;
-  if (root === prefix) return [...reports];
-  return reports.map((report) => ({
-    element: report.element,
-    location: report.location.startsWith(prefix) ? `${root}${report.location.slice(prefix.length)}` : report.location
-  }));
-}
-
-// src/safety/absence.ts
-var DATA_ABSENT_REASON_URL = "http://hl7.org/fhir/StructureDefinition/data-absent-reason";
-var ABSENCE_CODES = [
-  "unknown",
-  "asked-unknown",
-  "temp-unknown",
-  "not-asked",
-  "asked-declined",
-  "masked",
-  "not-applicable",
-  "unsupported",
-  "as-text",
-  "error",
-  "not-a-number",
-  "negative-infinity",
-  "positive-infinity",
-  "not-performed",
-  "not-permitted"
-];
-function isAbsenceCode(value) {
-  return ABSENCE_CODES.includes(value);
-}
-var STRUCTURAL_MEMBERS = /* @__PURE__ */ new Set([
-  "id",
-  "url",
-  "extension",
-  "modifierExtension",
-  "resourceType"
-]);
-function extensionsOf(node) {
-  if (isPrimitive(node)) return node.extension ?? [];
-  if (!isComplex(node)) return [];
-  return getAllProperties(node, "extension").flatMap(
-    (written) => isList(written) ? written.items : [written]
-  );
-}
-function isAbsenceMarker(extension) {
-  if (!isComplex(extension)) return false;
-  return getAllProperties(extension, "url").some(
-    (written) => primitiveString(written) === DATA_ABSENT_REASON_URL
-  );
-}
-function reasonOf(marker) {
-  const written = getAllProperties(marker, "valueCode");
-  if (written.length !== 1) return void 0;
-  const spelled = primitiveString(written[0]);
-  if (spelled === void 0 || !isAbsenceCode(spelled)) return void 0;
-  return spelled;
-}
-function carriesValue(node) {
-  if (isPrimitive(node)) return node.value !== void 0;
-  if (!isComplex(node)) return false;
-  return [...node.properties, ...node.duplicates ?? []].some(
-    (property) => !STRUCTURAL_MEMBERS.has(property.name)
-  );
-}
-function pushOnce(out, location) {
-  if (!out.includes(location)) out.push(location);
-}
-function visit(node, path, out) {
-  const markers = extensionsOf(node).filter(isAbsenceMarker);
-  if (markers.length === 0) return;
-  if (carriesValue(node)) pushOnce(out.conflicting, path);
-  for (const marker of markers) {
-    const code = reasonOf(marker);
-    if (code === void 0) {
-      pushOnce(out.unreadable, path);
-      continue;
-    }
-    if (!out.markers.some((seen) => seen.code === code && seen.location === path)) {
-      out.markers.push({ code, location: path });
-    }
-  }
-}
-function walk(node, path, out) {
-  visit(node, path, out);
-  if (isList(node)) {
-    node.items.forEach((item, index) => {
-      walk(item, `${path}[${String(index)}]`, out);
-    });
-    return;
-  }
-  if (isPrimitive(node)) {
-    (node.extension ?? []).forEach((extension, index) => {
-      walk(extension, `${path}.extension[${String(index)}]`, out);
-    });
-    return;
-  }
-  for (const property of node.properties) walk(property.value, childPath(path, property.name), out);
-  for (const property of node.duplicates ?? []) {
-    walk(property.value, childPath(path, property.name), out);
-  }
-}
-function collectAbsence(resource, path) {
-  const out = { markers: [], unreadable: [], conflicting: [] };
-  walk(resource, path, out);
-  return out;
-}
-
-// src/safety/status.ts
-function readDoNotPerform(resource) {
-  const values = getAllProperties(resource, "doNotPerform");
-  if (values.some((node) => primitiveBooleans(node).includes(true))) return true;
-  return primitiveBooleans(values[0])[0];
-}
-function clinicalSystemFor(rt) {
-  if (rt === "AllergyIntolerance") return ALLERGY_CLINICAL_SYSTEM;
-  if (rt === "Condition") return CONDITION_CLINICAL_SYSTEM;
-  return void 0;
-}
-function verificationSystemFor(rt) {
-  if (rt === "AllergyIntolerance") return ALLERGY_VERIFICATION_SYSTEM;
-  if (rt === "Condition") return CONDITION_VERIFICATION_SYSTEM;
-  return void 0;
-}
-var NEGATION_ORDER = [
-  "entered-in-error",
-  "refuted",
-  "no-known-allergy",
-  "do-not-perform",
-  "not-taken",
-  "not-done"
-];
-function unhandledModifierExtensions(resource, path) {
-  return walkSafety(resource, path).modifiers;
-}
-function modifierElements(resource) {
-  const types = typesOf(resource);
-  const prefix = safetyPrefix(types);
-  return rebaseModifierElements(walkSafety(resource, prefix).modifierElements, prefix, types);
-}
-function safetyPrefix(types) {
-  const rt = types[0];
-  return rt === void 0 ? "$this" : rootPath(rt);
-}
-function shadowedProperties(resource, path) {
-  return walkSafety(resource, path).shadowed;
-}
-function arrayWrappedScalars(resource, path) {
-  return walkSafety(resource, path).arrayWrapped;
-}
-function unspellableXmlWrappers(resource, path) {
-  return walkSafety(resource, path).unspellableInXml;
-}
-function nestedArrays(resource, path) {
-  return collectMarked(resource, path, isNestedArray);
-}
-function droppedText(resource, path) {
-  return collectMarked(resource, path, isDroppedText);
-}
-function unreadableBooleans(resource, path) {
-  return walkSafety(resource, path).unreadableBoolean;
-}
-function nearMissNegationCodes(resource, path) {
-  return walkSafety(resource, path).nearMissCode;
-}
-function unreadableNegationCodes(resource, path) {
-  return walkSafety(resource, path).unreadableCode;
-}
-function absenceMarkers(resource, path) {
-  return [...collectAbsence(resource, path).markers];
-}
-function unreadableAbsenceMarkers(resource, path) {
-  return [...collectAbsence(resource, path).unreadable];
-}
-function conflictingAbsenceMarkers(resource, path) {
-  return [...collectAbsence(resource, path).conflicting];
-}
-function collectMarked(resource, path, marked) {
-  const out = [];
-  collectNested(resource, path, out, marked);
-  return [...new Set(out)];
-}
-function collectNested(node, path, out, marked) {
-  if (marked(node)) out.push(path);
-  if (isList(node)) {
-    node.items.forEach(
-      (item, index) => collectNested(item, `${path}[${String(index)}]`, out, marked)
-    );
-    return;
-  }
-  if (isPrimitive(node)) {
-    (node.extension ?? []).forEach(
-      (ext, index) => collectNested(ext, `${path}.extension[${String(index)}]`, out, marked)
-    );
-    return;
-  }
-  for (const property of node.properties)
-    collectNested(property.value, childPath(path, property.name), out, marked);
-  for (const property of node.duplicates ?? []) {
-    collectNested(property.value, childPath(path, property.name), out, marked);
-  }
-}
-function walkSafety(resource, path) {
-  const out = {
-    modifiers: [],
-    modifierElements: [],
-    shadowed: [],
-    arrayWrapped: [],
-    unspellableInXml: [],
-    negations: /* @__PURE__ */ new Set(),
-    unreadableBoolean: [],
-    nearMissCode: [],
-    unreadableCode: []
+// src/validate/issues.ts
+var ISSUE_SEVERITIES = {
+  FATAL: "fatal",
+  ERROR: "error",
+  WARNING: "warning",
+  INFORMATION: "information"
+};
+var ISSUE_TYPES = {
+  /** Structural issue, an element that is not allowed here, or a cardinality-max violation. */
+  STRUCTURE: "structure",
+  /** A required element (min cardinality ≥ 1) is missing. */
+  REQUIRED: "required",
+  /** An element value is invalid against its datatype value-domain (a primitive-regex failure). */
+  VALUE: "value",
+  /** A code is not a member of a required-strength value set binding. */
+  CODE_INVALID: "code-invalid",
+  /** A content-validation rule (a resource `constraint` / invariant) failed. */
+  INVARIANT: "invariant",
+  /** The content uses a modifier the processor does not support and cannot safely ignore. */
+  NOT_SUPPORTED: "not-supported",
+  /** Informational only, carries no defect (e.g. "this resource type has no schema yet"). */
+  INFORMATIONAL: "informational",
+  /** A business rule / profile-level assertion failed (e.g. a declared profile version is unknown). */
+  BUSINESS_RULE: "business-rule",
+  /** A referenced resource could not be found within the resolution closure (a Bundle reference). */
+  NOT_FOUND: "not-found"
+};
+var VALIDATION_CODES = {
+  /** Layer 1, an element the resource's structure does not define at this location. */
+  UNKNOWN_ELEMENT: "UNKNOWN_ELEMENT",
+  /** Layer 1, the resource carries no `resourceType`, so it cannot be structurally validated. */
+  RESOURCE_TYPE_UNKNOWN: "RESOURCE_TYPE_UNKNOWN",
+  /** Layer 1, no schema is available for this resource type; structural layers were skipped. */
+  RESOURCE_NOT_MODELED: "RESOURCE_NOT_MODELED",
+  /** Layer 1, an element's node shape (primitive / complex) is not what its datatype expects. */
+  TYPE_MISMATCH: "TYPE_MISMATCH",
+  /** Layer 1, more than one variant of a `choice[x]` element is present. */
+  CHOICE_AMBIGUOUS: "CHOICE_AMBIGUOUS",
+  /** Layer 2, a required element (min ≥ 1) is absent. */
+  CARDINALITY_MIN: "CARDINALITY_MIN",
+  /** Layer 2, an element appears more times than its maximum cardinality allows. */
+  CARDINALITY_MAX: "CARDINALITY_MAX",
+  /** Layer 3, a primitive value does not match its datatype's lexical form. */
+  PRIMITIVE_INVALID: "PRIMITIVE_INVALID",
+  /** Layer 3, a `code` value is outside a required-strength enumerated binding. */
+  CODE_INVALID: "CODE_INVALID",
+  /**
+   * Safety, an element carries a `modifierExtension` this library does not understand.
+   * FHIR's `?!` rule forbids ignoring an unknown modifier, so this **fails closed** (an `error`): the
+   * element cannot be safely processed. See {@link ./safety.js}.
+   */
+  UNHANDLED_MODIFIER_EXTENSION: "UNHANDLED_MODIFIER_EXTENSION",
+  /**
+   * Safety, the document wrote a property name more than once, so an element holds several values
+   * and nothing says which the sender meant. FHIR JSON requires unique property names (json.html §2.6.2:
+   * "Property names SHALL be unique") and expresses repetition with an array, so this is a violated
+   * `SHALL` and an `error`. The reader keeps every value (see {@link ../model/node.js} `duplicates`),
+   * so this reports an ambiguity, never a loss.
+   */
+  DUPLICATE_PROPERTY: "DUPLICATE_PROPERTY",
+  /**
+   * Safety, a single-valued (`0..1`) safety element, or `resourceType`, arrived wrapped in a JSON
+   * array. FHIR JSON writes a single-valued element as a name/value pair and uses an array only for a
+   * repeating element (json.html §2.6.2.2), so this is a non-conformant encoding and an `error`. It is the
+   * shape a **generic XML-to-JSON converter** produces for every element, which is how a C-CDA or v2
+   * feed commonly reaches a FHIR surface, and left unreported it reaches the same harm as a repeated
+   * property name: a single-value read finds no code in the array, so a retraction or a negation the
+   * sender wrote goes unreported and the record reads live. Nothing is lost, the wrapper is preserved
+   * and the safety layer reads through it; this reports that the encoding was ambiguous.
+   */
+  ARRAY_WRAPPED_SCALAR: "ARRAY_WRAPPED_SCALAR",
+  /**
+   * Safety, an `Observation.value[x]` choice element arrived wrapped in a JSON array. The same
+   * non-conformant encoding {@link VALIDATION_CODES.ARRAY_WRAPPED_SCALAR} reports (json.html
+   * §2.6.2.2 reserves the array for a repeating element), at the one position whose cardinality is
+   * decided by a choice rather than by a per-resource element table, so it needs a code of its own
+   * rather than a wider window on that one. An `error`.
+   *
+   * **Why the value readout needs its own channel.** `readObservationValue` fails safe on this
+   * shape, it reports the variant that is present and no `quantity`, so no wrong number is handed
+   * out, but "the variant is present and the magnitude is absent" reads identically to an
+   * `Observation` whose `valueQuantity` carried no `value`. A dose the sender wrote is then
+   * indistinguishable from one it did not, and this is the record that the position held content
+   * nothing here would read.
+   *
+   * **The window is `Observation.value[x]` and `Observation.component.value[x]`, at every
+   * Observation resource root the model holds**, which is the window the value readout itself reads
+   * (`../quantity/value.js`). Both are `0..1` in R4 (observation.html), so this needs no
+   * per-resource cardinality table and cannot fire on a conformant document. It is deliberately not
+   * every R4 `0..1` element: that is the per-resource model this library does not have.
+   *
+   * Value-free, the location of the choice variant, never the magnitude, unit or code inside the
+   * wrapper.
+   */
+  ARRAY_WRAPPED_CHOICE: "ARRAY_WRAPPED_CHOICE",
+  /**
+   * Safety, the document wrote a JSON array **inside another array**. FHIR JSON uses an array for a
+   * repeating element and for nothing else (json.html §2.6.2.2), so a list of lists has no meaning at
+   * any position and this is a non-conformant encoding wherever it appears, which is why it needs no
+   * cardinality rule and cannot fire on a conformant document. Reported at every position the model
+   * has a node for; a `_`-sibling the reader discards whole is the stated exception, and draws a
+   * reader warning instead: `UNKNOWN_PROPERTY` for an unrecognised member of a `_`-sibling object,
+   * `MISPLACED_PRIMITIVE_EXTENSION` for a sibling on an object or on a non-primitive array, not one
+   * code for all three. An `error`, and one of the two on this list
+   * where the reader could **not model** what the sender wrote (the other is
+   * {@link VALIDATION_CODES.DROPPED_ELEMENT_TEXT}): the codec does not model an inner array, so this
+   * reports a loss of *structure* rather than an ambiguity, though the array's JSON text is kept and
+   * readable (see {@link ../model/node.js} `nestedArrayContent`). Left unreported it is among the worst of the
+   * set, because the model then looks exactly like an element that was legitimately absent, and a
+   * refuted allergy, a resolved condition, or an entire resource inside a Bundle entry reads back as
+   * a clean document. Value-free, the position the inner array occupied, never its contents.
+   */
+  NESTED_ARRAY: "NESTED_ARRAY",
+  /**
+   * Safety, an XML document wrote **character data directly on a FHIR element**. FHIR XML carries a
+   * primitive's value in the `value` attribute (xml.html §2.6.1), so text written as element content
+   * has no slot on the model and the reader drops it: `<status>entered-in-error</status>` yields a
+   * `status` with no value. An `error`, and the only code on this list where the content is neither
+   * modeled **nor kept**: unlike {@link VALIDATION_CODES.NESTED_ARRAY}, which preserves the array's
+   * JSON text, the character data is discarded outright, because reading it back would be a
+   * tolerance for a non-conformant encoding rather than a report of one. Left unreported it reaches the same harm as
+   * {@link VALIDATION_CODES.NESTED_ARRAY} by the other wire format, because the model is again
+   * indistinguishable from an element that was legitimately absent: a retraction, a `refuted`
+   * verification status, or a dose *number* beside a surviving unit and UCUM code all read back as a
+   * clean document. Value-free, the position the text occupied, never its contents.
+   */
+  DROPPED_ELEMENT_TEXT: "DROPPED_ELEMENT_TEXT",
+  /**
+   * Safety, an element carries a DataAbsentReason extension **and a value of its own**, so the
+   * document asserts both that the element holds that value and that it holds none. An `error`
+   * (`structure`): the two cannot both be true, nothing here ranks them, and a consumer that
+   * happened to read one of the two would report the record as though the other had not been
+   * written. Both survive on the model and on the safety readout; this reports that they disagree.
+   * Value-free, the location of the element, never the value and never the reason.
+   *
+   * Cannot fire on a conformant document: an element the sender has data for is written with the
+   * data and no marker. It is **not** the `Observation.dataAbsentReason` ELEMENT beside a `value[x]`,
+   * which is the `obs-6` invariant and reports as {@link VALIDATION_CODES.INVARIANT_VIOLATED}; the
+   * element is not the extension, and the two never report about one another's shape.
+   */
+  ABSENCE_MARKER_CONFLICT: "ABSENCE_MARKER_CONFLICT",
+  /**
+   * Safety, an element carries a DataAbsentReason extension whose reason this library could not
+   * read: no `valueCode`, one holding no readable string, an empty one, one written twice, or a code
+   * outside the closed fifteen-concept value set the extension's `value[x]` binds to at **required**
+   * strength. An `error` (`code-invalid`), on the same footing as any other required-binding miss:
+   * the set is closed and published, so membership is decided from the set itself with no
+   * terminology service involved and no value-set expansion.
+   *
+   * **Nothing is coerced.** The code is not trimmed, case-folded or substituted, and the element is
+   * not read as `unknown` and not read as populated: doing either would author a reason the sender
+   * did not spell, or erase a declaration the sender did make. The element stays value-absent and
+   * this is the record that a declaration was made and could not be honoured. Value-free, the
+   * location of the element, never the code that failed to match.
+   */
+  ABSENCE_MARKER_UNREADABLE: "ABSENCE_MARKER_UNREADABLE",
+  /**
+   * Safety, the resource is marked `entered-in-error` and is therefore **retracted, not
+   * data**. Surfaced as `information` (it is not itself a defect) so a consumer cannot miss it.
+   */
+  RETRACTED_RESOURCE: "RETRACTED_RESOURCE",
+  /**
+   * Invariant, a resource constraint failed. Three sources raise it, each with or without the
+   * others: the safety layer's named invariants (`ait-1`/`ait-2`, `con-3`/`con-4`/`con-5`,
+   * `obs-6`/`obs-7`); the base-constraint layer, which evaluates the other error-severity
+   * constraints R4 declares on the eight modeled types and their `DomainResource` / `Element` /
+   * `Extension` base (`pat-1`, `obs-3`, `con-1`, `con-2`, `imm-1`, `dom-2` to `dom-5`, `ele-1`,
+   * `ext-1`) with no profile supplied; and a supplied profile's own `constraint`s. The specific
+   * constraint key travels in {@link ValidationIssue.constraint}, and the severity mirrors the
+   * constraint's own (`error`, except a `warning` constraint such as the best-practice `con-3`).
+   */
+  INVARIANT_VIOLATED: "INVARIANT_VIOLATED",
+  /**
+   * Invariant, a `constraint`'s FHIRPath `expression`, from a supplied profile or from the R4 base
+   * constraints the base-constraint layer evaluates, is **outside the bounded
+   * engine's subset** and could not be evaluated. Always `information` (`informational`):
+   * the constraint is reported **unchecked, never assumed to pass** (fail-safe), the
+   * library does not claim conformance to an invariant it could not test. The constraint `key` travels
+   * in {@link ValidationIssue.constraint}. Value-free (the location + key, never an instance value).
+   * A profile's verbatim copy of an R4 base constraint that the base-constraint layer decided at the
+   * same occurrence is not reported this way, because that constraint was evaluated: R4's `dom-3`
+   * on a resource with nothing contained draws nothing, with or without a profile.
+   */
+  INVARIANT_UNCHECKED: "INVARIANT_UNCHECKED",
+  /**
+   * Quantity/UCUM, a `Quantity` claims the UCUM `system` but its `code` is absent or not a
+   * shape-valid UCUM expression, so the unit cannot be trusted for machine use. A `warning`
+   * (`value`): the value is **preserved verbatim and never converted**, the library does not bundle
+   * UCUM content, so it cannot assert the code *is* a real unit, only that it is present and well-shaped.
+   */
+  UCUM_UNIT_UNRECOGNIZED: "UCUM_UNIT_UNRECOGNIZED",
+  /**
+   * Quantity/UCUM, a vital-signs Observation's measured value carries a unit the FHIR
+   * vital-signs profile forbids for that LOINC code (wrong UCUM `code`, or a non-UCUM `system`). An
+   * `error` (`code-invalid`): the vital-signs profile *requires* the unit, so a nonconformant one is a
+   * profile violation, compared on the UCUM `code` (case- and bracket-sensitive), never the `unit` string.
+   */
+  VITAL_SIGN_UNIT_NONCONFORMANT: "VITAL_SIGN_UNIT_NONCONFORMANT",
+  /**
+   * Quantity/UCUM, an Observation whose profile expects a numeric `Quantity` value carries
+   * a different `value[x]` variant instead (e.g. `valueString`). A `warning` (`value`): the value is
+   * preserved and surfaced by its real type, a caller must not read it as a number.
+   */
+  VALUE_TYPE_UNEXPECTED: "VALUE_TYPE_UNEXPECTED",
+  /**
+   * Terminology, a bound coding's `system` URI is not in the frozen known-systems registry
+   * (and not one the binding's value set draws from). Always `information` (`code-invalid`): an
+   * unknown system may be a legitimate local/proprietary one, so it is never a defect, it only means
+   * the library cannot validate codes drawn from it. Content-free, so it can never flip validity.
+   */
+  CODE_SYSTEM_UNKNOWN: "CODE_SYSTEM_UNKNOWN",
+  /**
+   * Terminology, a bound coding uses a **known** code `system` that is not one the
+   * binding's value set draws from (e.g. an ICD-10-CM code where the binding expects RxNorm + SNOMED).
+   * This is the content-free "wrong system for this binding" check, decided from the `system` alone,
+   * with no value-set content. Severity follows the binding strength (`required` → `error`;
+   * `extensible`/`preferred` → `warning`, since a different system may be a legitimate extension;
+   * `example` → none). Compared on the `system` URI, never a code value.
+   */
+  CODE_SYSTEM_UNEXPECTED: "CODE_SYSTEM_UNEXPECTED",
+  /**
+   * Terminology, a configured terminology service reported that a bound coding's
+   * `(system, code)` is **not a member** of the binding's value set. Severity follows the binding
+   * strength (`required`/`extensible` → `error`; `preferred` → `warning`; `example` → `information`,
+   * never an error). Emitted **only** when a service definitively answers `not-in`; with no service,
+   * or an `unknown` answer, the library degrades to the content-free system checks and never
+   * false-errors (fail-safe). Value-free, the coding location, never the code itself.
+   *
+   * The **only** finding that carries a {@link ValidationIssue.codeSystemVersion} record, because it
+   * is the only one a terminology service produces: the release the service declared its answer was
+   * made against, or the explicit mark that it declared none. Severity, emission and the fail-safe
+   * degrade are all independent of it.
+   */
+  CODE_NOT_IN_VALUESET: "CODE_NOT_IN_VALUESET",
+  /**
+   * Profile, an instance element is present under a **closed** slicing whose discriminators
+   * matched none of the profile's defined slices. A `structure` `error`: `closed` slicing forbids
+   * content outside the named slices. (Under `open` slicing an unmatched element is allowed and draws
+   * nothing; under `openAtEnd` it is allowed only in the trailing position, this library flags a
+   * closed-slicing miss and leaves the ordering nuance unenforced.)
+   */
+  PROFILE_SLICE_UNMATCHED: "PROFILE_SLICE_UNMATCHED",
+  /**
+   * Profile, a slicing whose discriminator this library cannot evaluate (a `profile`
+   * discriminator, which needs recursive profile resolution, or the R5-only `position`). Emitted as
+   * `information` so slice membership is reported **unchecked, never silently passed** (the
+   * fail-safe): the library does not guess a slice assignment it cannot justify.
+   */
+  PROFILE_SLICE_UNCHECKED: "PROFILE_SLICE_UNCHECKED",
+  /**
+   * Profile, an element the profile marks **must-support** is absent from the instance.
+   * **Always `information`, never an error** (the fail-safe, and the single most important
+   * must-support rule): must-support is a *system obligation* on the sender to be able to populate the
+   * element and on the receiver to tolerate its absence, it is **not** an instance-presence
+   * requirement. A strict client that errors on an absent must-support element is the classic bug this
+   * code exists to avoid.
+   */
+  MUST_SUPPORT_ABSENT: "MUST_SUPPORT_ABSENT",
+  /**
+   * Profile, the instance's `meta.profile` declares a profile at a version the supplied
+   * profile set does not carry (`canonical|version` with a different version, or an unresolvable
+   * canonical). A `warning` (`business-rule`): an unknown profile
+   * version is flagged rather than silently best-effort-validating against a different one.
+   */
+  PROFILE_VERSION_MISMATCH: "PROFILE_VERSION_MISMATCH",
+  /**
+   * Profile, an element carries a value that is not **exactly** the profile's `fixed[x]`.
+   * A `value` `error`: `fixed[x]` is an equality constraint (the element SHALL match the fixed value
+   * exactly, including every nested property). Compared structurally and precision-exactly (decimals
+   * via {@link ../model/decimal.js}), never by echoing the value.
+   */
+  PROFILE_FIXED_MISMATCH: "PROFILE_FIXED_MISMATCH",
+  /**
+   * Profile, an element does not match the profile's `pattern[x]`. A `value` `error`:
+   * `pattern[x]` is a **subset** constraint (the element SHALL contain *at least* the pattern's
+   * properties and values, but may carry more), the weaker sibling of `fixed[x]`. Value-free.
+   */
+  PROFILE_PATTERN_MISMATCH: "PROFILE_PATTERN_MISMATCH",
+  /**
+   * Bundle, a `Reference` inside a Bundle entry (or a `#fragment` inside a resource's
+   * `contained`) that could not be resolved within the resolution closure: a fragment whose target
+   * contained resource is absent, or a relative `Type/id` reference naming no entry in the Bundle. A
+   * `warning` (`not-found`) and **never fatal**, the target may legitimately live outside the
+   * supplied closure (a partial Bundle, an external server), so the reference is **preserved**, only
+   * flagged. An absolute/logical reference that is simply external to the Bundle draws **no** finding.
+   * Value-free, the FHIRPath location of the reference, never the reference string itself.
+   */
+  REFERENCE_UNRESOLVED: "REFERENCE_UNRESOLVED",
+  /**
+   * Bundle, the `#fragment` references among a resource's `contained` resources form a
+   * **cycle** (a → b → a, or a self-reference). An `error` (`structure`): a containment cycle is
+   * malformed and, to a naive transitive resolver, a denial-of-service (an unbounded loop / stack
+   * blow-up). The bounded, iterative cycle guard detects it and reports it here rather than looping,
+   * DoS-safe by construction. Value-free, the location of the `contained` element, never a value.
+   */
+  CONTAINED_CYCLE: "CONTAINED_CYCLE",
+  /**
+   * Bundle, a Bundle entry's `fullUrl` is a RESTful URL (relative `Type/id` or an absolute
+   * URL ending in `Type/id`) whose id disagrees with the entry `resource.id`. An `error`
+   * (`business-rule`): FHIR requires a RESTful `fullUrl` to be consistent with the resource it wraps,
+   * and a disagreement can cause a reference to resolve to the wrong resource. A `urn:uuid:` (logical)
+   * `fullUrl` places no constraint on `resource.id`, so it never triggers this. Value-free, the
+   * location of the `fullUrl`, never either id.
+   */
+  FULLURL_ID_MISMATCH: "FULLURL_ID_MISMATCH"
+};
+var CODE_SYSTEM_VERSION_RECORD_SYSTEM = "https://cosyte.com/fhir/CodeSystem/code-system-version-record";
+var CODE_SYSTEM_VERSION_RECORD_CODES = {
+  /** The service declared a release; the string it declared travels beside this marker. */
+  DECLARED: "declared",
+  /**
+   * The service was consulted, answered definitively, and declared **no** release. It is an
+   * applicable, unanswered question, **not** "current" and not "not applicable": the marker is
+   * emitted precisely so the silence cannot be read as currency.
+   */
+  UNDECLARED: "undeclared"
+};
+var ISSUE_TYPE_OF = {
+  UNKNOWN_ELEMENT: ISSUE_TYPES.STRUCTURE,
+  RESOURCE_TYPE_UNKNOWN: ISSUE_TYPES.STRUCTURE,
+  RESOURCE_NOT_MODELED: ISSUE_TYPES.INFORMATIONAL,
+  TYPE_MISMATCH: ISSUE_TYPES.STRUCTURE,
+  CHOICE_AMBIGUOUS: ISSUE_TYPES.STRUCTURE,
+  CARDINALITY_MIN: ISSUE_TYPES.REQUIRED,
+  CARDINALITY_MAX: ISSUE_TYPES.STRUCTURE,
+  PRIMITIVE_INVALID: ISSUE_TYPES.VALUE,
+  CODE_INVALID: ISSUE_TYPES.CODE_INVALID,
+  UNHANDLED_MODIFIER_EXTENSION: ISSUE_TYPES.NOT_SUPPORTED,
+  DUPLICATE_PROPERTY: ISSUE_TYPES.STRUCTURE,
+  ARRAY_WRAPPED_SCALAR: ISSUE_TYPES.STRUCTURE,
+  ARRAY_WRAPPED_CHOICE: ISSUE_TYPES.STRUCTURE,
+  NESTED_ARRAY: ISSUE_TYPES.STRUCTURE,
+  DROPPED_ELEMENT_TEXT: ISSUE_TYPES.STRUCTURE,
+  ABSENCE_MARKER_CONFLICT: ISSUE_TYPES.STRUCTURE,
+  ABSENCE_MARKER_UNREADABLE: ISSUE_TYPES.CODE_INVALID,
+  RETRACTED_RESOURCE: ISSUE_TYPES.INFORMATIONAL,
+  INVARIANT_VIOLATED: ISSUE_TYPES.INVARIANT,
+  INVARIANT_UNCHECKED: ISSUE_TYPES.INFORMATIONAL,
+  UCUM_UNIT_UNRECOGNIZED: ISSUE_TYPES.VALUE,
+  VITAL_SIGN_UNIT_NONCONFORMANT: ISSUE_TYPES.CODE_INVALID,
+  VALUE_TYPE_UNEXPECTED: ISSUE_TYPES.VALUE,
+  CODE_SYSTEM_UNKNOWN: ISSUE_TYPES.CODE_INVALID,
+  CODE_SYSTEM_UNEXPECTED: ISSUE_TYPES.CODE_INVALID,
+  CODE_NOT_IN_VALUESET: ISSUE_TYPES.CODE_INVALID,
+  PROFILE_SLICE_UNMATCHED: ISSUE_TYPES.STRUCTURE,
+  PROFILE_SLICE_UNCHECKED: ISSUE_TYPES.INFORMATIONAL,
+  MUST_SUPPORT_ABSENT: ISSUE_TYPES.INFORMATIONAL,
+  PROFILE_VERSION_MISMATCH: ISSUE_TYPES.BUSINESS_RULE,
+  PROFILE_FIXED_MISMATCH: ISSUE_TYPES.VALUE,
+  PROFILE_PATTERN_MISMATCH: ISSUE_TYPES.VALUE,
+  REFERENCE_UNRESOLVED: ISSUE_TYPES.NOT_FOUND,
+  CONTAINED_CYCLE: ISSUE_TYPES.STRUCTURE,
+  FULLURL_ID_MISMATCH: ISSUE_TYPES.BUSINESS_RULE
+};
+var DIAGNOSTIC_OF = {
+  UNKNOWN_ELEMENT: "Element is not defined at this location in the resource structure.",
+  RESOURCE_TYPE_UNKNOWN: "Resource is missing a resourceType and cannot be structurally validated.",
+  RESOURCE_NOT_MODELED: "No structural schema is available for this resource type; structural validation was skipped.",
+  TYPE_MISMATCH: "Element value is not of the shape its datatype requires.",
+  CHOICE_AMBIGUOUS: "More than one variant of a choice element is present.",
+  CARDINALITY_MIN: "Required element is missing.",
+  CARDINALITY_MAX: "Element appears more times than its maximum cardinality allows.",
+  PRIMITIVE_INVALID: "Primitive value does not match the required lexical form for its datatype.",
+  CODE_INVALID: "Code is not in the required value set for this element.",
+  UNHANDLED_MODIFIER_EXTENSION: "Element carries a modifierExtension this processor does not understand; it cannot be safely processed and is rejected (fail-closed).",
+  DUPLICATE_PROPERTY: "Property name appears more than once on this object; FHIR requires unique property names and uses an array for a repeating element, so the element's value is ambiguous.",
+  ARRAY_WRAPPED_SCALAR: "Single-valued element is wrapped in an array; FHIR JSON writes a 0..1 element as a name/value pair and uses an array only for a repeating element, so the element's encoding is ambiguous.",
+  ARRAY_WRAPPED_CHOICE: "Observation value[x] choice is wrapped in an array; FHIR JSON writes a 0..1 choice as a name/value pair and uses an array only for a repeating element, so the value's encoding is ambiguous and no magnitude, unit or code was read from inside the wrapper.",
+  NESTED_ARRAY: "A JSON array appears inside another array; FHIR JSON uses an array only for a repeating element, so this shape has no meaning and its contents were not read. Content the sender wrote is missing from the model at this position.",
+  DROPPED_ELEMENT_TEXT: "Character data was written directly on this element; FHIR XML carries a primitive's value in the value attribute, so an element has no slot for text and it was not read. Content the sender wrote is missing from the model at this position.",
+  ABSENCE_MARKER_CONFLICT: "Element carries a data-absent-reason extension and a value of its own; the document asserts both that the element holds that value and that it holds none, and neither is preferred here. Both are preserved.",
+  ABSENCE_MARKER_UNREADABLE: "Element carries a data-absent-reason extension whose reason could not be read: it is absent, empty, written more than once, or outside the value set the extension requires. The reason is not guessed and the element is not read as populated.",
+  RETRACTED_RESOURCE: "Resource is marked entered-in-error; it is retracted and must not be treated as active data.",
+  INVARIANT_VIOLATED: "A resource invariant (content-validation constraint) was violated.",
+  INVARIANT_UNCHECKED: "A resource invariant could not be evaluated by the bounded FHIRPath engine; it is reported unchecked rather than assumed to pass.",
+  UCUM_UNIT_UNRECOGNIZED: "Quantity declares the UCUM system but its unit code is absent or not a well-formed UCUM expression; the unit is preserved verbatim and never converted.",
+  VITAL_SIGN_UNIT_NONCONFORMANT: "Vital-signs measurement carries a unit the vital-signs profile does not allow for this code.",
+  VALUE_TYPE_UNEXPECTED: "Observation value is present but not the expected type for this profile.",
+  CODE_SYSTEM_UNKNOWN: "Coding uses a code system that is not in the known-systems registry; its codes cannot be validated (an unrecognized system is not itself an error).",
+  CODE_SYSTEM_UNEXPECTED: "Coding uses a code system that the bound value set does not draw from.",
+  CODE_NOT_IN_VALUESET: "Coding is not a member of the value set required by this element's binding.",
+  PROFILE_SLICE_UNMATCHED: "Element is present under closed slicing but matches none of the profile's defined slices.",
+  PROFILE_SLICE_UNCHECKED: "Slice membership could not be evaluated (an unsupported discriminator); it is reported unchecked rather than assumed to pass.",
+  MUST_SUPPORT_ABSENT: "Profile marks this element must-support; it is absent. Must-support is a system obligation, not an instance-presence requirement, this is informational, never an error.",
+  PROFILE_VERSION_MISMATCH: "Instance declares a profile at a version the supplied profile set does not carry; it was not validated against that exact version.",
+  PROFILE_FIXED_MISMATCH: "Element value does not exactly match the value the profile fixes for it.",
+  PROFILE_PATTERN_MISMATCH: "Element does not match the pattern the profile requires for it.",
+  REFERENCE_UNRESOLVED: "Reference could not be resolved within the supplied closure; it is preserved and flagged, never dropped (the target may live outside this Bundle).",
+  CONTAINED_CYCLE: "Contained resources reference each other in a cycle; the containment graph is malformed and was reported by the bounded cycle guard rather than followed into an unbounded loop.",
+  FULLURL_ID_MISMATCH: "Bundle entry fullUrl is a RESTful URL whose id disagrees with the wrapped resource's id."
+};
+function diagnosticFor(code) {
+  return DIAGNOSTIC_OF[code];
+}
+function validationIssue(code, severity, expression, constraint, codeSystemVersion) {
+  const issue = { code, severity, type: ISSUE_TYPE_OF[code], expression };
+  const withConstraint = constraint === void 0 ? issue : { ...issue, constraint };
+  return codeSystemVersion === void 0 ? withConstraint : { ...withConstraint, codeSystemVersion };
+}
+
+// src/quantity/ucum.ts
+var UCUM_SYSTEM = "http://unitsofmeasure.org";
+var LOINC_SYSTEM = "http://loinc.org";
+var OBSERVATION_CATEGORY_SYSTEM = "http://terminology.hl7.org/CodeSystem/observation-category";
+var VITAL_SIGNS_CATEGORY = "vital-signs";
+var VITAL_SIGNS_PROFILE = "http://hl7.org/fhir/StructureDefinition/vitalsigns";
+var VITAL_SIGN_UNITS = /* @__PURE__ */ new Map([
+  ["29463-7", ["g", "kg", "[lb_av]"]],
+  // Body weight
+  ["8302-2", ["cm", "[in_i]"]],
+  // Body height
+  ["8306-3", ["cm", "[in_i]"]],
+  // Body height (lying) / body length
+  ["8287-5", ["cm", "[in_i]"]],
+  // Head circumference (Occipital-frontal, by tape)
+  ["9843-4", ["cm", "[in_i]"]],
+  // Head circumference
+  ["8310-5", ["Cel", "[degF]"]],
+  // Body temperature
+  ["8867-4", ["/min"]],
+  // Heart rate
+  ["9279-1", ["/min"]],
+  // Respiratory rate
+  ["8480-6", ["mm[Hg]"]],
+  // Systolic blood pressure
+  ["8462-4", ["mm[Hg]"]],
+  // Diastolic blood pressure
+  ["2708-6", ["%"]],
+  // Oxygen saturation in Arterial blood
+  ["59408-5", ["%"]],
+  // Oxygen saturation (SpO2) by pulse oximetry
+  ["39156-5", ["kg/m2"]]
+  // Body mass index
+]);
+function requiredVitalSignUnits(loincCode) {
+  return VITAL_SIGN_UNITS.get(loincCode);
+}
+function decimalValue(node) {
+  if (node === void 0 || !isPrimitive(node)) return void 0;
+  const { value } = node;
+  if (typeof value === "object") return value;
+  return typeof value === "string" ? decimalFromLexical(value) : void 0;
+}
+function readQuantity(node) {
+  if (node === void 0 || node.kind !== "complex") return void 0;
+  const q = node;
+  return {
+    value: decimalValue(getProperty(q, "value")),
+    comparator: primitiveString(getProperty(q, "comparator")),
+    unit: primitiveString(getProperty(q, "unit")),
+    system: primitiveString(getProperty(q, "system")),
+    code: primitiveString(getProperty(q, "code"))
   };
-  walkComplex(resource, path, out, true);
-  return { ...out, modifierElements: dedupeModifierElements(out.modifierElements) };
 }
-function unspellableInXml(name, value) {
-  if (!isList(value)) return false;
-  return name === "resourceType" || value.items.length < 2;
+function validateUcumShape(code) {
+  if (code.length === 0) return "invalid";
+  const skeleton = code.replace(/\{[^{}]*\}/g, "");
+  if (skeleton.includes("{") || skeleton.includes("}")) return "invalid";
+  if (/\s/.test(skeleton)) return "invalid";
+  const pairs = { "]": "[", ")": "(" };
+  const stack = [];
+  for (const ch of skeleton) {
+    if (ch === "[" || ch === "(") stack.push(ch);
+    else if (ch === "]" || ch === ")") {
+      if (stack.pop() !== pairs[ch]) return "invalid";
+    }
+  }
+  return stack.length === 0 ? "ok" : "invalid";
+}
+
+// src/quantity/value.ts
+var OBSERVATION_VALUE_TYPES = [
+  "Quantity",
+  "CodeableConcept",
+  "String",
+  "Boolean",
+  "Integer",
+  "Range",
+  "Ratio",
+  "SampledData",
+  "Time",
+  "DateTime",
+  "Period"
+];
+function presentValues(node) {
+  const byName = new Map(node.properties.map((p) => [p.name, p.value]));
+  const out = [];
+  for (const type of OBSERVATION_VALUE_TYPES) {
+    const value = byName.get(`value${type}`);
+    if (value !== void 0) out.push({ type, node: value });
+  }
+  return out;
+}
+function readObservationValue(node) {
+  const [first, ...rest] = presentValues(node);
+  if (first === void 0) return void 0;
+  const wrapped = isList(first.node);
+  return {
+    type: first.type,
+    property: `value${first.type}`,
+    node: first.node,
+    // Never from inside a wrapper, and the guard is written here rather than left to
+    // {@link readQuantity} returning `undefined` for a list. Picking the member would author a
+    // magnitude at a position the sender spelled ambiguously, which is the one thing Postel's Law
+    // does not license: tolerate the form, never invent the content.
+    quantity: first.type === "Quantity" && !wrapped ? readQuantity(first.node) : void 0,
+    ambiguous: rest.map((r) => r.type),
+    encodingIssue: wrapped ? VALIDATION_CODES.ARRAY_WRAPPED_CHOICE : void 0
+  };
+}
+var OBSERVATION_VALUE_PROPERTIES = new Set(
+  OBSERVATION_VALUE_TYPES.map((type) => `value${type}`)
+);
+function collectChoiceWrappers(element, path, keep, out) {
+  for (const property of [...element.properties, ...element.duplicates ?? []]) {
+    if (!OBSERVATION_VALUE_PROPERTIES.has(property.name)) continue;
+    if (!isList(property.value)) continue;
+    if (!keep(property.value.items)) continue;
+    const at = childPath(path, property.name);
+    if (!out.includes(at)) out.push(at);
+  }
+}
+function walkForObservationRoots(node, path, keep, out) {
+  if (isList(node)) {
+    node.items.forEach(
+      (item, index) => walkForObservationRoots(item, `${path}[${String(index)}]`, keep, out)
+    );
+    return;
+  }
+  if (isPrimitive(node)) return;
+  if (typesOf(node).includes("Observation")) {
+    collectChoiceWrappers(node, path, keep, out);
+    for (const member of getAllProperties(node, "component")) {
+      const items = isList(member) ? member.items : [member];
+      items.forEach((item, index) => {
+        if (!isComplex(item)) return;
+        const at = isList(member) ? `${path}.component[${String(index)}]` : `${path}.component`;
+        collectChoiceWrappers(item, at, keep, out);
+      });
+    }
+  }
+  for (const property of [...node.properties, ...node.duplicates ?? []]) {
+    walkForObservationRoots(property.value, childPath(path, property.name), keep, out);
+  }
+}
+var ANY_ARITY = () => true;
+function arrayWrappedValueChoices(resource, path) {
+  const out = [];
+  walkForObservationRoots(resource, path, ANY_ARITY, out);
+  return out;
+}
+function unspellableXmlValueChoices(resource, path) {
+  const out = [];
+  walkForObservationRoots(resource, path, (items) => items.length < 2, out);
+  return out;
+}
+function readReferenceRanges(observation) {
+  const node = getProperty(observation, "referenceRange");
+  if (node === void 0) return [];
+  const items = isList(node) ? node.items : [node];
+  const ranges = [];
+  for (const item of items) {
+    if (item.kind !== "complex") continue;
+    ranges.push({
+      low: readQuantity(getProperty(item, "low")),
+      high: readQuantity(getProperty(item, "high")),
+      type: codingsOf(getProperty(item, "type")),
+      text: primitiveString(getProperty(item, "text"))
+    });
+  }
+  return ranges;
+}
+function readInterpretations(observation) {
+  return codingsOf(getProperty(observation, "interpretation"));
+}
+
+// src/safety/modifier-elements.ts
+var PATIENT = "Patient";
+var PRACTITIONER = "Practitioner";
+var IMMUNIZATION = "Immunization";
+var MEDICATION_REQUEST = "MedicationRequest";
+var IDENTIFIER = "identifier";
+var DECEASED = "deceased";
+var INTENT = "intent";
+var INTENT_CODES = /* @__PURE__ */ new Set([
+  "proposal",
+  "plan",
+  "order",
+  "original-order",
+  "reflex-order",
+  "filler-order",
+  "instance-order",
+  "option"
+]);
+var USE = "use";
+var USE_ROOT_TYPES = /* @__PURE__ */ new Set([
+  "AllergyIntolerance",
+  "Condition",
+  "DiagnosticReport",
+  "Immunization",
+  "MedicationRequest",
+  "MedicationStatement",
+  "Observation",
+  PATIENT
+]);
+var IDENTIFIER_USE = /* @__PURE__ */ new Set([
+  "usual",
+  "official",
+  "temp",
+  "secondary",
+  "old"
+]);
+var NAME_USE = /* @__PURE__ */ new Set([
+  "usual",
+  "official",
+  "temp",
+  "nickname",
+  "anonymous",
+  "old",
+  "maiden"
+]);
+var ADDRESS_USE = /* @__PURE__ */ new Set([
+  "home",
+  "work",
+  "temp",
+  "old",
+  "billing"
+]);
+var CONTACT_POINT_USE = /* @__PURE__ */ new Set([
+  "home",
+  "work",
+  "temp",
+  "old",
+  "mobile"
+]);
+var IDENTIFIER_MEMBERS = /* @__PURE__ */ new Set(["identifier", "groupIdentifier"]);
+var PATIENT_MEMBERS = /* @__PURE__ */ new Map([
+  ["name", NAME_USE],
+  ["telecom", CONTACT_POINT_USE],
+  ["address", ADDRESS_USE]
+]);
+var CONTACT = "contact";
+var UNGATED_ELEMENTS = ["implicitRules", "comparator"];
+var MODIFIER_ELEMENT_ROOT_TYPES = /* @__PURE__ */ new Set([
+  ...SAFETY_RESOURCE_TYPES,
+  PATIENT,
+  PRACTITIONER,
+  "Bundle"
+]);
+function carries(node, name) {
+  return getAllProperties(node, name).length > 0 || getAllProperties(node, `_${name}`).length > 0;
+}
+function eachEntry(value, path, visit2) {
+  if (isList(value)) {
+    value.items.forEach((item, index) => {
+      if (isComplex(item)) visit2(item, `${path}[${String(index)}]`);
+    });
+    return;
+  }
+  if (isComplex(value)) visit2(value, path);
 }
-function checkArrayWrapping(node, path, report) {
+function collectModifierElements(node, path, out) {
+  for (const element of UNGATED_ELEMENTS) {
+    if (carries(node, element)) out.push({ element, location: childPath(path, element) });
+  }
   const types = typesOf(node);
-  const isSafetyType = types.some((type) => SAFETY_RESOURCE_TYPES.has(type));
-  for (const property of [...node.properties, ...node.duplicates ?? []]) {
-    const clinical = SAFETY_SCALAR_ELEMENTS.has(property.name);
-    if (property.name !== "resourceType" && !(clinical && isSafetyType)) continue;
-    const at = childPath(path, property.name);
-    if (isList(property.value)) report(at, unspellableInXml(property.name, property.value));
-    if (clinical && isSafetyType && SAFETY_CODEABLE_ELEMENTS.has(property.name)) {
-      checkCodingWrapping(property.value, at, report);
+  if (types.includes(PATIENT)) {
+    if (carries(node, "active")) {
+      out.push({ element: "active", location: childPath(path, "active") });
     }
+    for (const member of deceasedMembers(node)) {
+      out.push({ element: "deceased", location: childPath(path, member) });
+    }
+    if (carries(node, "link")) out.push({ element: "link", location: childPath(path, "link") });
   }
-}
-function checkCodingWrapping(value, path, report) {
-  const concepts = isList(value) ? value.items : [value];
-  concepts.forEach((concept, conceptIndex) => {
-    if (!isComplex(concept)) return;
-    const base = isList(value) ? `${path}[${String(conceptIndex)}]` : path;
-    for (const member of getAllProperties(concept, "coding")) {
-      const codings = isList(member) ? member.items : [member];
-      codings.forEach((coding, index) => {
-        if (!isComplex(coding)) return;
-        const at = isList(member) ? `${base}.coding[${String(index)}]` : `${base}.coding`;
-        for (const name of CODING_SCALAR_ELEMENTS) {
-          const members = getAllProperties(coding, name);
-          if (members.some((scalar) => isList(scalar))) {
-            report(
-              `${at}.${name}`,
-              members.some((scalar) => unspellableInXml(name, scalar))
-            );
-          }
+  if (types.includes(IMMUNIZATION) && carries(node, "isSubpotent")) {
+    out.push({ element: "isSubpotent", location: childPath(path, "isSubpotent") });
+  }
+  if (types.includes(PRACTITIONER)) {
+    const at = childPath(path, IDENTIFIER);
+    for (const written of getAllProperties(node, IDENTIFIER)) {
+      eachEntry(written, at, (entry, entryPath) => {
+        if (carries(entry, "use")) {
+          out.push({ element: "use", location: childPath(entryPath, "use") });
         }
       });
     }
-  });
+  }
 }
-var CODING_SCALAR_ELEMENTS = ["system", "code"];
-function checkNegations(node, path, report, out) {
-  const written = getAllProperties(node, "doNotPerform");
-  if (written.length > 0) {
-    const at = childPath(path, "doNotPerform");
-    if (written.some((value) => primitiveBooleans(value).includes(true))) {
-      out.negations.add("do-not-perform");
-    }
-    if (written.some(hasUnreadableBoolean)) out.unreadableBoolean.push(at);
+function dedupeModifierElements(reports) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const report of reports) {
+    const key = `${report.element}\0${report.location}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(report);
   }
-  if (isRetracted(node)) out.negations.add(ENTERED_IN_ERROR);
-  if (getAllProperties(node, "verificationStatus").some((v) => safetyHasCodeAnySystem(v, REFUTED))) {
-    out.negations.add(REFUTED);
+  return out;
+}
+function deceasedMembers(node) {
+  const members = /* @__PURE__ */ new Set();
+  for (const property of [...node.properties, ...node.duplicates ?? []]) {
+    const name = property.name.startsWith("_") ? property.name.slice(1) : property.name;
+    if (name.startsWith(DECEASED)) members.add(name);
+  }
+  return [...members];
+}
+function collectIntent(node, path, intents, unreadable) {
+  if (!typesOf(node).includes(MEDICATION_REQUEST)) return;
+  const written = getAllProperties(node, INTENT);
+  if (written.length === 0 && getAllProperties(node, `_${INTENT}`).length === 0) return;
+  const at = childPath(path, INTENT);
+  const only = written.length === 1 ? written[0] : void 0;
+  const value = only !== void 0 && isPrimitive(only) ? only.value : void 0;
+  if (typeof value === "string" && isIntentCode(value)) {
+    intents.push({ code: value, location: at });
+  } else {
+    unreadable.push(at);
   }
-  if (statusSpells(node, NOT_TAKEN)) out.negations.add(NOT_TAKEN);
-  if (statusSpells(node, NOT_DONE)) out.negations.add(NOT_DONE);
-  for (const read of NEGATION_CODE_READS) {
-    const written2 = getAllProperties(node, read.element);
-    if (written2.length === 0) continue;
-    if (read.codings === true) {
-      const at = childPath(path, read.element);
-      for (const value of written2) checkCodingWrapping(value, at, report);
-    }
-    const spelled = written2.flatMap((value) => [...read.values(value)]);
-    const near = read.codes.some(
-      (code) => !spelled.includes(code) && spelled.some((value) => isNearMissCode(value, code))
-    );
-    if (near) out.nearMissCode.push(childPath(path, read.element));
-    const unread = read.unread;
-    if (unread !== void 0 && written2.some((value) => unread(value))) {
-      out.unreadableCode.push(childPath(path, read.element));
+}
+function isIntentCode(value) {
+  return INTENT_CODES.has(value);
+}
+function collectDatatypeUses(node, path, out) {
+  const types = typesOf(node);
+  if (types.includes(PRACTITIONER)) return;
+  if (!types.some((type) => USE_ROOT_TYPES.has(type))) return;
+  readUsesUnder(node, path, types.includes(PATIENT) ? "patient-root" : "other", out);
+}
+function readUsesUnder(node, path, place, out) {
+  for (const property of [...node.properties, ...node.duplicates ?? []]) {
+    const at = childPath(path, property.name);
+    const codes = coveredCodes(property.name, place);
+    if (codes !== void 0) {
+      eachEntry(property.value, at, (entry, entryPath) => {
+        readUse(entry, entryPath, codes, out);
+      });
     }
+    const next = place === "patient-root" && property.name === CONTACT ? "patient-contact" : "other";
+    descendForUses(property.value, at, next, out);
   }
 }
-function checkResourceRoot(node, path, out) {
-  const reported = /* @__PURE__ */ new Set();
-  const unspellable = /* @__PURE__ */ new Set();
-  const report = (location, unwritable) => {
-    if (!reported.has(location)) {
-      reported.add(location);
-      out.arrayWrapped.push(location);
+function descendForUses(value, path, place, out) {
+  if (isList(value)) {
+    value.items.forEach((item, index) => {
+      descendForUses(item, `${path}[${String(index)}]`, place, out);
+    });
+    return;
+  }
+  if (isPrimitive(value)) {
+    (value.extension ?? []).forEach((extension, index) => {
+      descendForUses(extension, `${path}.extension[${String(index)}]`, "other", out);
+    });
+    return;
+  }
+  if (getAllProperties(value, "resourceType").length > 0) return;
+  readUsesUnder(value, path, place, out);
+}
+function coveredCodes(name, place) {
+  if (IDENTIFIER_MEMBERS.has(name)) return IDENTIFIER_USE;
+  if (place === "other") return void 0;
+  return PATIENT_MEMBERS.get(name);
+}
+function readUse(entry, at, codes, out) {
+  const written = getAllProperties(entry, USE);
+  if (written.length === 0 && getAllProperties(entry, `_${USE}`).length === 0) return;
+  const only = written.length === 1 ? written[0] : void 0;
+  const value = only !== void 0 && isPrimitive(only) ? only.value : void 0;
+  const code = typeof value === "string" && isUseCode(value, codes) ? value : void 0;
+  out.push({ location: childPath(at, USE), code });
+}
+function isUseCode(value, codes) {
+  return codes.has(value);
+}
+function resolveDatatypeUses(readings) {
+  const byLocation = /* @__PURE__ */ new Map();
+  for (const reading of readings) {
+    const codes = byLocation.get(reading.location) ?? /* @__PURE__ */ new Set();
+    codes.add(reading.code);
+    byLocation.set(reading.location, codes);
+  }
+  const uses = [];
+  const unreadable = [];
+  for (const [location, codes] of byLocation) {
+    const [only] = [...codes];
+    if (codes.size === 1 && only !== void 0) uses.push({ code: only, location });
+    else unreadable.push(location);
+  }
+  return { uses, unreadable };
+}
+function modifierLocationRebaser(prefix, types) {
+  const declared = types[0];
+  if (declared === void 0) return (location) => location;
+  const root = MODIFIER_ELEMENT_ROOT_TYPES.has(declared) ? rootPath(declared) : WITHHELD;
+  if (root === prefix) return (location) => location;
+  return (location) => location.startsWith(prefix) ? `${root}${location.slice(prefix.length)}` : location;
+}
+function rebaseModifierElements(reports, prefix, types) {
+  const rebase = modifierLocationRebaser(prefix, types);
+  return reports.map((report) => ({ element: report.element, location: rebase(report.location) }));
+}
+
+// src/safety/absence.ts
+var DATA_ABSENT_REASON_URL = "http://hl7.org/fhir/StructureDefinition/data-absent-reason";
+var ABSENCE_CODES = [
+  "unknown",
+  "asked-unknown",
+  "temp-unknown",
+  "not-asked",
+  "asked-declined",
+  "masked",
+  "not-applicable",
+  "unsupported",
+  "as-text",
+  "error",
+  "not-a-number",
+  "negative-infinity",
+  "positive-infinity",
+  "not-performed",
+  "not-permitted"
+];
+function isAbsenceCode(value) {
+  return ABSENCE_CODES.includes(value);
+}
+var STRUCTURAL_MEMBERS = /* @__PURE__ */ new Set([
+  "id",
+  "url",
+  "extension",
+  "modifierExtension",
+  "resourceType"
+]);
+function extensionsOf(node) {
+  if (isPrimitive(node)) return node.extension ?? [];
+  if (!isComplex(node)) return [];
+  return getAllProperties(node, "extension").flatMap(
+    (written) => isList(written) ? written.items : [written]
+  );
+}
+function isAbsenceMarker(extension) {
+  if (!isComplex(extension)) return false;
+  return getAllProperties(extension, "url").some(
+    (written) => primitiveString(written) === DATA_ABSENT_REASON_URL
+  );
+}
+function reasonOf(marker) {
+  const written = getAllProperties(marker, "valueCode");
+  if (written.length !== 1) return void 0;
+  const spelled = primitiveString(written[0]);
+  if (spelled === void 0 || !isAbsenceCode(spelled)) return void 0;
+  return spelled;
+}
+function carriesValue(node) {
+  if (isPrimitive(node)) return node.value !== void 0;
+  if (!isComplex(node)) return false;
+  return [...node.properties, ...node.duplicates ?? []].some(
+    (property) => !STRUCTURAL_MEMBERS.has(property.name)
+  );
+}
+function pushOnce(out, location) {
+  if (!out.includes(location)) out.push(location);
+}
+function visit(node, path, out) {
+  const markers = extensionsOf(node).filter(isAbsenceMarker);
+  if (markers.length === 0) return;
+  if (carriesValue(node)) pushOnce(out.conflicting, path);
+  for (const marker of markers) {
+    const code = reasonOf(marker);
+    if (code === void 0) {
+      pushOnce(out.unreadable, path);
+      continue;
     }
-    if (unwritable && !unspellable.has(location)) {
-      unspellable.add(location);
-      out.unspellableInXml.push(location);
+    if (!out.markers.some((seen) => seen.code === code && seen.location === path)) {
+      out.markers.push({ code, location: path });
     }
-  };
-  checkArrayWrapping(node, path, report);
-  checkNegations(node, path, report, out);
+  }
 }
-function walkComplex(node, path, out, isRoot = false) {
-  if (isRoot || getAllProperties(node, "resourceType").length > 0) {
-    checkResourceRoot(node, path, out);
+function walk(node, path, out) {
+  visit(node, path, out);
+  if (isList(node)) {
+    node.items.forEach((item, index) => {
+      walk(item, `${path}[${String(index)}]`, out);
+    });
+    return;
   }
-  collectModifierElements(node, path, out.modifierElements);
-  for (const property of node.properties) visitProperty(property, path, out);
-  const reported = /* @__PURE__ */ new Set();
+  if (isPrimitive(node)) {
+    (node.extension ?? []).forEach((extension, index) => {
+      walk(extension, `${path}.extension[${String(index)}]`, out);
+    });
+    return;
+  }
+  for (const property of node.properties) walk(property.value, childPath(path, property.name), out);
   for (const property of node.duplicates ?? []) {
-    if (!reported.has(property.name)) {
-      reported.add(property.name);
-      out.shadowed.push(childPath(path, property.name));
-    }
-    visitProperty(property, path, out);
+    walk(property.value, childPath(path, property.name), out);
   }
 }
-function visitProperty(property, path, out) {
-  if (property.name === "modifierExtension") {
-    checkModifierExtension(property.value, path, out.modifiers);
-  }
-  descend(property.value, childPath(path, property.name), out);
+function collectAbsence(resource, path) {
+  const out = { markers: [], unreadable: [], conflicting: [] };
+  walk(resource, path, out);
+  return out;
+}
+
+// src/safety/status.ts
+function readDoNotPerform(resource) {
+  const values = getAllProperties(resource, "doNotPerform");
+  if (values.some((node) => primitiveBooleans(node).includes(true))) return true;
+  return primitiveBooleans(values[0])[0];
+}
+function clinicalSystemFor(rt) {
+  if (rt === "AllergyIntolerance") return ALLERGY_CLINICAL_SYSTEM;
+  if (rt === "Condition") return CONDITION_CLINICAL_SYSTEM;
+  return void 0;
 }
-function checkModifierExtension(value, path, out) {
-  const items = isList(value) ? value.items : [value];
-  items.forEach((ext, index) => {
-    const url = isComplex(ext) ? primitiveString(getProperty(ext, "url")) : void 0;
-    if (url === void 0 || !KNOWN_MODIFIER_EXTENSION_URLS.has(url)) {
-      out.push(
-        isList(value) ? `${path}.modifierExtension[${String(index)}]` : `${path}.modifierExtension`
-      );
-    }
-  });
+function verificationSystemFor(rt) {
+  if (rt === "AllergyIntolerance") return ALLERGY_VERIFICATION_SYSTEM;
+  if (rt === "Condition") return CONDITION_VERIFICATION_SYSTEM;
+  return void 0;
 }
-function descend(node, path, out) {
-  if (isComplex(node)) walkComplex(node, path, out);
-  else if (isList(node))
-    node.items.forEach((item, index) => descend(item, `${path}[${String(index)}]`, out));
+var NEGATION_ORDER = [
+  "entered-in-error",
+  "refuted",
+  "no-known-allergy",
+  "do-not-perform",
+  "not-taken",
+  "not-done"
+];
+function unhandledModifierExtensions(resource, path) {
+  return walkSafety(resource, path).modifiers;
 }
-function readSafety(resource) {
+function modifierElements(resource) {
   const types = typesOf(resource);
-  const rt = types[0];
-  const isType = (type) => types.includes(type);
-  const status = primitiveStrings(getProperty(resource, "status"))[0];
-  const clinicalStatus = safetyCodeOf(
-    getProperty(resource, "clinicalStatus"),
-    clinicalSystemFor(rt)
-  );
-  const verificationStatus = safetyCodeOf(
-    getProperty(resource, "verificationStatus"),
-    verificationSystemFor(rt)
-  );
   const prefix = safetyPrefix(types);
-  const walk2 = walkSafety(resource, prefix);
-  const doNotPerform = readDoNotPerform(resource);
-  const retracted = isRetracted(resource);
-  const noKnownAllergy = isType("AllergyIntolerance") && getAllProperties(resource, "code").some(
-    (node) => safetyHasCoding(node, SNOMED_SCT, NO_KNOWN_ALLERGY)
-  );
-  const found = new Set(walk2.negations);
-  if (noKnownAllergy) found.add("no-known-allergy");
-  const negations = NEGATION_ORDER.filter((kind) => found.has(kind));
-  const { modifiers, shadowed, arrayWrapped, unreadableBoolean, nearMissCode, unreadableCode } = walk2;
-  const modifierElementReports = rebaseModifierElements(walk2.modifierElements, prefix, types);
-  const nested = nestedArrays(resource, prefix);
-  const dropped = droppedText(resource, prefix);
-  const absence = collectAbsence(resource, prefix);
-  return {
-    resourceType: rt === void 0 ? void 0 : rootPath(rt),
-    status,
-    clinicalStatus,
-    verificationStatus,
-    doNotPerform,
-    retracted,
-    noKnownAllergy,
-    negations,
-    unhandledModifierExtensions: modifiers,
-    modifierElements: modifierElementReports,
-    shadowedProperties: shadowed,
-    arrayWrappedScalars: arrayWrapped,
-    nestedArrays: nested,
-    droppedText: dropped,
-    unreadableBooleans: unreadableBoolean,
-    nearMissNegationCodes: nearMissCode,
-    unreadableNegationCodes: unreadableCode,
-    absenceMarkers: absence.markers,
-    unreadableAbsenceMarkers: absence.unreadable,
-    conflictingAbsenceMarkers: absence.conflicting,
-    safeToSummarize: modifiers.length === 0 && modifierElementReports.length === 0 && shadowed.length === 0 && arrayWrapped.length === 0 && nested.length === 0 && dropped.length === 0 && unreadableBoolean.length === 0 && nearMissCode.length === 0 && unreadableCode.length === 0 && absence.unreadable.length === 0 && absence.conflicting.length === 0
-  };
-}
-var FhirSafetyError = class extends Error {
-  /** FHIRPath locations that forced the refusal (value-free). */
-  locations;
-  /**
-   * @param locations - The FHIRPath locations that forced the refusal (value-free).
-   */
-  constructor(locations) {
-    super(
-      `Resource cannot be safely summarized: an unhandled modifierExtension, a modifier element, a repeated property name, an array-wrapped single-valued element, an array inside an array, dropped XML element text, a boolean value this library cannot read, a code that spells a negation bar its case or its surrounding whitespace, content where a code belongs, a declared absence whose reason this library cannot read, or a declared absence beside a value leaves an element this library must not flatten (${String(locations.length)} location(s)).`
-    );
-    this.name = "FhirSafetyError";
-    this.locations = locations;
-  }
-};
-function assertSafeToSummarize(resource) {
-  const readout = "unhandledModifierExtensions" in resource ? resource : readSafety(resource);
-  const locations = [
-    ...readout.unhandledModifierExtensions,
-    ...readout.modifierElements.map((report) => report.location),
-    ...readout.shadowedProperties,
-    ...readout.arrayWrappedScalars,
-    ...readout.nestedArrays,
-    ...readout.droppedText,
-    ...readout.unreadableBooleans,
-    ...readout.nearMissNegationCodes,
-    ...readout.unreadableNegationCodes,
-    // The two absence channels that withdraw the affirmation. `absenceMarkers` is deliberately
-    // absent from this list, exactly as it is absent from `safeToSummarize`'s conjunction: a
-    // declaration the caller can read is a disclosure, not a loss.
-    ...readout.unreadableAbsenceMarkers,
-    ...readout.conflictingAbsenceMarkers
-  ];
-  if (locations.length > 0) throw new FhirSafetyError(locations);
-}
-
-// src/codec/serialize-guard.ts
-var SERIALIZE_ERROR_CODES = {
-  /**
-   * The model carries character data the XML reader dropped, at one or more locations. There is no
-   * conformant encoding of it in either wire format, and emitting the element as unfilled would
-   * launder the `DROPPED_ELEMENT_TEXT` finding across a round trip.
-   */
-  DROPPED_ELEMENT_TEXT: "DROPPED_ELEMENT_TEXT",
-  /**
-   * The model carries a name that cannot occupy the `Name` slot of an XML start tag, so writing it
-   * would emit markup that does not re-read as the element the model holds. **XML only**: JSON
-   * escapes a member name, so this refusal never reaches it and that route stays open. **Narrowed
-   * 2026-08-07 from "encodes every one of these correctly", which was false and shipped**: a model
-   * refused here can carry one of `serializeResource`'s own declared exceptions and emit that.
-   *
-   * See {@link breaksTag} for the exact predicate and for what is deliberately NOT refused.
-   */
-  UNSERIALIZABLE_ELEMENT_NAME: "UNSERIALIZABLE_ELEMENT_NAME",
-  /**
-   * A `div` property carries a string the XML writer would emit as raw markup, and that string does
-   * not contribute exactly one element named `div` to the document. **XML only**: `serializeResource`
-   * carries the string as a string, so this refusal never reaches it and that route stays open.
-   *
-   * **That is a statement about the `div` string, not about the whole model.** `serializeResource`
-   * has its own declared non-spec-clean exceptions, so a model refused here can still route through
-   * it and emit one of those: `{"text":{"div":""},"name":[[{"family":"X"}]]}` is refused here and
-   * `serializeResource` emits the array inside an array unchanged.
-   *
-   * See `emitsOneDivElement` in `../xml/write.js` for the exact predicate and what it does not cover.
-   */
-  UNSERIALIZABLE_DIV_MARKUP: "UNSERIALIZABLE_DIV_MARKUP",
-  /**
-   * The model carries, at one or more locations, a shape the JSON reader marked because FHIR JSON
-   * gives that position no meaning: an array inside an array, a scalar or `null` where FHIR JSON has
-   * an object (a complex element's own position or a primitive's `_`-sibling), or a `null` in a
-   * primitive's value channel that padded nothing. **XML only**: this refusal does not reach
-   * `serializeResource`, which writes these back from the text the reader preserved at every position
-   * that writer walks. **It does not walk a member a repeated property name shadowed, and this
-   * refusal does reach one** -- `serializeResource` refuses that model on
-   * {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_SHADOWED_PROPERTY} rather than emitting it, so it is
-   * still not a route the shape survives. The XML writer keeps reporting THIS code on such a model,
-   * because this one is raised first. See {@link assertXmlSerializable}.
-   *
-   * XML has no array-of-arrays, no `_`-sibling and no `null`, so the XML writer has nowhere to put
-   * any of it and emits the element the reader was left holding: an empty one, or none. That output
-   * re-reads with an empty issue list, so the finding the reader raised is gone after one trip.
-   *
-   * See {@link assertXmlSerializable} for the exact set of markers and for what it does NOT cover.
-   */
-  UNSERIALIZABLE_JSON_ONLY_SHAPE: "UNSERIALIZABLE_JSON_ONLY_SHAPE",
-  /**
-   * The model carries, at a location this library already reports as an array-wrapped `0..1` safety
-   * element, a wrapper FHIR XML has no repetition to spell back: one holding fewer than two items,
-   * or any wrapper at all on `resourceType`. **XML only**: `serializeResource` writes the list back
-   * and the re-read reports the same location, so that route stays open.
-   *
-   * XML spells a repeat by repeating the element and has no other mark for one, so a wrapper of
-   * fewer than two items emits at most one element and re-reads as an ordinary single-valued
-   * element. The encoding complaint the reader raised is then gone, and with it an `error`-severity
-   * `ARRAY_WRAPPED_SCALAR` and a `safeToSummarize: false`.
-   *
-   * See {@link assertXmlArrayWrapper} for the exact predicate and for what it deliberately leaves.
-   */
-  UNSERIALIZABLE_ARRAY_WRAPPER: "UNSERIALIZABLE_ARRAY_WRAPPER",
-  /**
-   * The model carries, at one or more object elements, a member a repeated property name shadowed
-   * ({@link ../model/node.js} `duplicates`). **Both writers**, unlike the four refusals above it:
-   * each walks `properties` only, so each wrote one member per name and the second value left the
-   * document with no diagnostic on it.
-   *
-   * See {@link assertNoShadowedProperty} for the window, the two routes weighed, and what it leaves.
-   */
-  UNSERIALIZABLE_SHADOWED_PROPERTY: "UNSERIALIZABLE_SHADOWED_PROPERTY",
-  /**
-   * The model carries, at one or more elements, a first `resourceType` that is not a string. FHIR
-   * XML has no `resourceType` element at all -- the type IS the tag -- so the XML writer skipped the
-   * property, and at the root, with no string to name the tag, it wrote `Resource` instead: the
-   * member deleted and the element named a type nobody wrote. **XML only**: `serializeResource` emits a
-   * non-string `resourceType` through its ordinary path, so this refusal never reaches it and that
-   * route stays open.
-   *
-   * See {@link assertXmlResourceType} for the window and for what it deliberately leaves.
-   */
-  UNSERIALIZABLE_RESOURCE_TYPE: "UNSERIALIZABLE_RESOURCE_TYPE"
-};
-var FhirSerializeError = class extends Error {
-  /** Which refusal this is. */
-  code;
-  /** The bounded FHIRPath locations the refusal is about, in walk order. Never document content. */
-  locations;
-  /**
-   * @param message - A value-free description of the refusal.
-   * @param code - Which refusal this is.
-   * @param locations - The bounded FHIRPath locations it is about.
-   */
-  constructor(message, code, locations) {
-    super(message);
-    this.name = "FhirSerializeError";
-    this.code = code;
-    this.locations = locations;
-  }
-};
-function assertSerializable(node) {
-  const locations = droppedText(node, rootPath(typeOf(node) ?? "Resource"));
-  if (locations.length === 0) return;
-  throw new FhirSerializeError(
-    `cannot serialize: the reader dropped character data at ${String(locations.length)} location(s), which this model cannot encode`,
-    SERIALIZE_ERROR_CODES.DROPPED_ELEMENT_TEXT,
-    locations
-  );
-}
-function carriesJsonOnlyShape(node) {
-  if (node.kind === "list") return false;
-  if (node.nestedArray === true || node.nestedArraySource !== void 0) return true;
-  if (node.kind === "complex") return node.nonObjectSource !== void 0;
-  return node.undefinedNull === true || node.nonObjectMetaSource !== void 0 || node.nestedArrayMetaSource !== void 0;
+  return rebaseModifierElements(walkSafety(resource, prefix).modifierElements, prefix, types);
 }
-function assertXmlSerializable(node) {
-  const locations = collectMarked(node, rootPath(typeOf(node) ?? "Resource"), carriesJsonOnlyShape);
-  if (locations.length === 0) return;
-  throw new FhirSerializeError(
-    // Says only what this refusal does NOT reach, which is the wording the two refusals beside it
-    // were narrowed to. It deliberately does not promise that `serializeResource` writes the shape
-    // back: it does for every position that writer walks, and a marked node inside a member a
-    // repeated property name shadowed is dropped by it as well.
-    `cannot serialize to XML: ${String(locations.length)} location(s) carry a shape only FHIR JSON can spell, which XML has no channel for; this refusal does not reach serializeResource`,
-    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_JSON_ONLY_SHAPE,
-    locations
-  );
+function safetyPrefix(types) {
+  const rt = types[0];
+  return rt === void 0 ? "$this" : rootPath(rt);
 }
-function assertXmlArrayWrapper(node) {
-  const locations = unspellableXmlWrappers(node, rootPath(typeOf(node) ?? "Resource"));
-  if (locations.length === 0) return;
-  throw new FhirSerializeError(
-    // Says what this refusal does not reach, in the wording the three refusals beside it were
-    // narrowed to. `serializeResource` does write these wrappers back -- pinned by the JSON half of
-    // the same test -- with the shadowed-member limit stated in the docblock rather than here.
-    `cannot serialize to XML: ${String(locations.length)} location(s) carry an array wrapper around a 0..1 element that XML has no repeated element to spell back; this refusal does not reach serializeResource`,
-    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_ARRAY_WRAPPER,
-    locations
-  );
+function shadowedProperties(resource, path) {
+  return walkSafety(resource, path).shadowed;
 }
-function assertNoShadowedProperty(node) {
-  const locations = shadowedProperties(node, rootPath(typeOf(node) ?? "Resource"));
-  if (locations.length === 0) return;
-  throw new FhirSerializeError(
-    // Names both writers, because both drop it: there is no route here that keeps the member, and a
-    // message pointing at one would point an operator at a silent drop. That is the wording the four
-    // refusals above were narrowed to, at the one refusal where the answer is "neither".
-    `cannot serialize: ${String(locations.length)} location(s) carry a member a repeated property name shadowed, which neither serializeResource nor serializeResourceXml can write`,
-    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_SHADOWED_PROPERTY,
-    locations
-  );
+function arrayWrappedScalars(resource, path) {
+  return walkSafety(resource, path).arrayWrapped;
 }
-function lacksTaggableResourceType(node) {
-  if (node.kind !== "complex") return false;
-  const written = node.properties.find((property) => property.name === "resourceType");
-  if (written === void 0) return false;
-  return !(isPrimitive(written.value) && typeof written.value.value === "string");
+function unspellableXmlWrappers(resource, path) {
+  return walkSafety(resource, path).unspellableInXml;
 }
-function assertXmlResourceType(node) {
-  const elements = collectMarked(
-    node,
-    rootPath(typeOf(node) ?? "Resource"),
-    lacksTaggableResourceType
-  );
-  if (elements.length === 0) return;
-  const locations = elements.map((element) => childPath(element, "resourceType"));
-  throw new FhirSerializeError(
-    // Says what this refusal does not reach, in the wording the refusals beside it were narrowed to.
-    // `serializeResource` emits a non-string `resourceType` through its ordinary path -- pinned by
-    // the JSON half of the same test -- which is a statement about this shape, not about the rest of
-    // the model: that writer's own declared exceptions still apply to everything else it carries.
-    // It does NOT say "while naming the element Resource": that substitution happens at the root,
-    // and this refusal reports depths where the tag comes from the property name instead.
-    `cannot serialize to XML: ${String(locations.length)} location(s) carry a resourceType with no string to name a tag with, which this writer would delete; this refusal does not reach serializeResource`,
-    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_RESOURCE_TYPE,
-    locations
-  );
+function nestedArrays(resource, path) {
+  return collectMarked(resource, path, isNestedArray);
 }
-var TAG_BREAKING = /[ \t\n\r/>=<]/u;
-var TAG_OPENER_STEALING = /* @__PURE__ */ new Set(["!", "?"]);
-function breaksTag(name) {
-  return name === "" || TAG_BREAKING.test(name) || TAG_OPENER_STEALING.has(name.slice(0, 1));
+function droppedText(resource, path) {
+  return collectMarked(resource, path, isDroppedText);
 }
-function refuseUnserializableNames(locations) {
-  throw new FhirSerializeError(
-    `cannot serialize to XML: ${String(locations.length)} location(s) carry a name that cannot be written as an XML tag without changing which elements the document holds; serializeResource escapes a member name, so this refusal never reaches it`,
-    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_ELEMENT_NAME,
-    locations
-  );
+function unreadableBooleans(resource, path) {
+  return walkSafety(resource, path).unreadableBoolean;
 }
-function refuseUnserializableDivMarkup(locations) {
-  throw new FhirSerializeError(
-    `cannot serialize to XML: ${String(locations.length)} div location(s) carry markup that would not be written as the one div element the model names; serializeResource carries the string as a string`,
-    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_DIV_MARKUP,
-    locations
-  );
+function nearMissNegationCodes(resource, path) {
+  return walkSafety(resource, path).nearMissCode;
 }
-
-// src/codec/write.ts
-function emitScalar(value) {
-  if (value === void 0) return "null";
-  if (typeof value === "string") return JSON.stringify(value);
-  if (typeof value === "boolean") return value ? "true" : "false";
-  return value.raw;
+function unreadableNegationCodes(resource, path) {
+  return walkSafety(resource, path).unreadableCode;
 }
-function emitPrimitiveValue(node) {
-  return node.nestedArraySource ?? emitScalar(node.value);
+function absenceMarkers(resource, path) {
+  return [...collectAbsence(resource, path).markers];
 }
-function hasValue(node) {
-  return node.value !== void 0 || node.nestedArraySource !== void 0 || node.undefinedNull === true;
+function unreadableAbsenceMarkers(resource, path) {
+  return [...collectAbsence(resource, path).unreadable];
 }
-function hasMeta(node) {
-  return node.id !== void 0 || node.extension !== void 0 && node.extension.length > 0 || node.nestedArrayMetaSource !== void 0 || node.nonObjectMetaSource !== void 0;
+function conflictingAbsenceMarkers(resource, path) {
+  return [...collectAbsence(resource, path).conflicting];
 }
-function emitMeta(node) {
-  if (node.nestedArrayMetaSource !== void 0) return node.nestedArrayMetaSource;
-  if (node.nonObjectMetaSource !== void 0) return node.nonObjectMetaSource;
-  const parts = [];
-  if (node.id !== void 0) parts.push(`"id":${JSON.stringify(node.id)}`);
-  if (node.extension !== void 0 && node.extension.length > 0) {
-    parts.push(`"extension":[${node.extension.map(emitComplex).join(",")}]`);
-  }
-  return `{${parts.join(",")}}`;
+function collectMarked(resource, path, marked) {
+  const out = [];
+  collectNested(resource, path, out, marked);
+  return [...new Set(out)];
 }
-function emitPrimitiveProperty(name, node) {
-  const entries = [];
-  if (hasValue(node)) {
-    entries.push(`${JSON.stringify(name)}:${emitPrimitiveValue(node)}`);
+function collectNested(node, path, out, marked) {
+  if (marked(node)) out.push(path);
+  if (isList(node)) {
+    node.items.forEach(
+      (item, index) => collectNested(item, `${path}[${String(index)}]`, out, marked)
+    );
+    return;
   }
-  if (hasMeta(node)) {
-    entries.push(`${JSON.stringify(`_${name}`)}:${emitMeta(node)}`);
+  if (isPrimitive(node)) {
+    (node.extension ?? []).forEach(
+      (ext, index) => collectNested(ext, `${path}.extension[${String(index)}]`, out, marked)
+    );
+    return;
+  }
+  for (const property of node.properties)
+    collectNested(property.value, childPath(path, property.name), out, marked);
+  for (const property of node.duplicates ?? []) {
+    collectNested(property.value, childPath(path, property.name), out, marked);
   }
-  return entries;
 }
-function emitListProperty(name, node) {
-  if (node.items.length === 0) return [];
-  const allPrimitive = node.items.every(isPrimitive);
-  if (!allPrimitive) {
-    return [`${JSON.stringify(name)}:[${node.items.map(emitNode).join(",")}]`];
+function walkSafety(resource, path) {
+  const out = {
+    modifiers: [],
+    modifierElements: [],
+    intents: [],
+    unreadableIntent: [],
+    useReadings: [],
+    datatypeUses: [],
+    unreadableDatatypeUse: [],
+    shadowed: [],
+    arrayWrapped: [],
+    unspellableInXml: [],
+    negations: /* @__PURE__ */ new Set(),
+    unreadableBoolean: [],
+    nearMissCode: [],
+    unreadableCode: []
+  };
+  walkComplex(resource, path, out, true);
+  const uses = resolveDatatypeUses(out.useReadings);
+  const intentKeys = /* @__PURE__ */ new Set();
+  return {
+    ...out,
+    modifierElements: dedupeModifierElements(out.modifierElements),
+    intents: out.intents.filter((read) => {
+      const key = `${read.code} ${read.location}`;
+      if (intentKeys.has(key)) return false;
+      intentKeys.add(key);
+      return true;
+    }),
+    unreadableIntent: [...new Set(out.unreadableIntent)],
+    datatypeUses: uses.uses,
+    unreadableDatatypeUse: uses.unreadable
+  };
+}
+function unspellableInXml(name, value) {
+  if (!isList(value)) return false;
+  return name === "resourceType" || value.items.length < 2;
+}
+function checkArrayWrapping(node, path, report) {
+  const types = typesOf(node);
+  const isSafetyType = types.some((type) => SAFETY_RESOURCE_TYPES.has(type));
+  for (const property of [...node.properties, ...node.duplicates ?? []]) {
+    const clinical = SAFETY_SCALAR_ELEMENTS.has(property.name);
+    if (property.name !== "resourceType" && !(clinical && isSafetyType)) continue;
+    const at = childPath(path, property.name);
+    if (isList(property.value)) report(at, unspellableInXml(property.name, property.value));
+    if (clinical && isSafetyType && SAFETY_CODEABLE_ELEMENTS.has(property.name)) {
+      checkCodingWrapping(property.value, at, report);
+    }
   }
-  const primitives = node.items.filter(isPrimitive);
-  const anyValue = primitives.some(hasValue);
-  const anyMeta = primitives.some(hasMeta);
-  const entries = [];
-  if (anyValue) {
-    const values = primitives.map(emitPrimitiveValue).join(",");
-    entries.push(`${JSON.stringify(name)}:[${values}]`);
+}
+function checkCodingWrapping(value, path, report) {
+  const concepts = isList(value) ? value.items : [value];
+  concepts.forEach((concept, conceptIndex) => {
+    if (!isComplex(concept)) return;
+    const base = isList(value) ? `${path}[${String(conceptIndex)}]` : path;
+    for (const member of getAllProperties(concept, "coding")) {
+      const codings = isList(member) ? member.items : [member];
+      codings.forEach((coding, index) => {
+        if (!isComplex(coding)) return;
+        const at = isList(member) ? `${base}.coding[${String(index)}]` : `${base}.coding`;
+        for (const name of CODING_SCALAR_ELEMENTS) {
+          const members = getAllProperties(coding, name);
+          if (members.some((scalar) => isList(scalar))) {
+            report(
+              `${at}.${name}`,
+              members.some((scalar) => unspellableInXml(name, scalar))
+            );
+          }
+        }
+      });
+    }
+  });
+}
+var CODING_SCALAR_ELEMENTS = ["system", "code"];
+function checkNegations(node, path, report, out) {
+  const written = getAllProperties(node, "doNotPerform");
+  if (written.length > 0) {
+    const at = childPath(path, "doNotPerform");
+    if (written.some((value) => primitiveBooleans(value).includes(true))) {
+      out.negations.add("do-not-perform");
+    }
+    if (written.some(hasUnreadableBoolean)) out.unreadableBoolean.push(at);
+  }
+  if (isRetracted(node)) out.negations.add(ENTERED_IN_ERROR);
+  if (getAllProperties(node, "verificationStatus").some((v) => safetyHasCodeAnySystem(v, REFUTED))) {
+    out.negations.add(REFUTED);
+  }
+  if (statusSpells(node, NOT_TAKEN)) out.negations.add(NOT_TAKEN);
+  if (statusSpells(node, NOT_DONE)) out.negations.add(NOT_DONE);
+  for (const read of NEGATION_CODE_READS) {
+    const written2 = getAllProperties(node, read.element);
+    if (written2.length === 0) continue;
+    if (read.codings === true) {
+      const at = childPath(path, read.element);
+      for (const value of written2) checkCodingWrapping(value, at, report);
+    }
+    const spelled = written2.flatMap((value) => [...read.values(value)]);
+    const near = read.codes.some(
+      (code) => !spelled.includes(code) && spelled.some((value) => isNearMissCode(value, code))
+    );
+    if (near) out.nearMissCode.push(childPath(path, read.element));
+    const unread = read.unread;
+    if (unread !== void 0 && written2.some((value) => unread(value))) {
+      out.unreadableCode.push(childPath(path, read.element));
+    }
+  }
+}
+function checkResourceRoot(node, path, out) {
+  const reported = /* @__PURE__ */ new Set();
+  const unspellable = /* @__PURE__ */ new Set();
+  const report = (location, unwritable) => {
+    if (!reported.has(location)) {
+      reported.add(location);
+      out.arrayWrapped.push(location);
+    }
+    if (unwritable && !unspellable.has(location)) {
+      unspellable.add(location);
+      out.unspellableInXml.push(location);
+    }
+  };
+  checkArrayWrapping(node, path, report);
+  checkNegations(node, path, report, out);
+}
+function walkComplex(node, path, out, isRoot = false) {
+  if (isRoot || getAllProperties(node, "resourceType").length > 0) {
+    checkResourceRoot(node, path, out);
   }
-  if (anyMeta) {
-    const metas = primitives.map((item) => hasMeta(item) ? emitMeta(item) : "null").join(",");
-    entries.push(`${JSON.stringify(`_${name}`)}:[${metas}]`);
+  collectModifierElements(node, path, out.modifierElements);
+  collectIntent(node, path, out.intents, out.unreadableIntent);
+  collectDatatypeUses(node, path, out.useReadings);
+  for (const property of node.properties) visitProperty(property, path, out);
+  const reported = /* @__PURE__ */ new Set();
+  for (const property of node.duplicates ?? []) {
+    if (!reported.has(property.name)) {
+      reported.add(property.name);
+      out.shadowed.push(childPath(path, property.name));
+    }
+    visitProperty(property, path, out);
   }
-  return entries;
 }
-function emitNode(node) {
-  switch (node.kind) {
-    case "complex":
-      return emitComplex(node);
-    case "list":
-      return `[${node.items.map(emitNode).join(",")}]`;
-    case "primitive":
-      return emitPrimitiveValue(node);
+function visitProperty(property, path, out) {
+  if (property.name === "modifierExtension") {
+    checkModifierExtension(property.value, path, out.modifiers);
   }
+  descend(property.value, childPath(path, property.name), out);
 }
-function emitComplex(node) {
-  if (node.nestedArraySource !== void 0) return node.nestedArraySource;
-  if (node.nonObjectSource !== void 0) return node.nonObjectSource;
-  const parts = [];
-  const rt = node.properties.find((p) => p.name === "resourceType");
-  const hoisted = rt !== void 0 && isPrimitive(rt.value) && typeof rt.value.value === "string";
-  if (hoisted) parts.push(`"resourceType":${JSON.stringify(rt.value.value)}`);
-  for (const property of node.properties) {
-    if (property.name === "resourceType" && hoisted) {
-      if (isPrimitive(property.value) && hasMeta(property.value)) {
-        parts.push(`"_resourceType":${emitMeta(property.value)}`);
-      }
-      continue;
-    }
-    const value = property.value;
-    switch (value.kind) {
-      case "primitive":
-        parts.push(...emitPrimitiveProperty(property.name, value));
-        break;
-      case "list":
-        parts.push(...emitListProperty(property.name, value));
-        break;
-      case "complex":
-        parts.push(`${JSON.stringify(property.name)}:${emitComplex(value)}`);
-        break;
+function checkModifierExtension(value, path, out) {
+  const items = isList(value) ? value.items : [value];
+  items.forEach((ext, index) => {
+    const url = isComplex(ext) ? primitiveString(getProperty(ext, "url")) : void 0;
+    if (url === void 0 || !KNOWN_MODIFIER_EXTENSION_URLS.has(url)) {
+      out.push(
+        isList(value) ? `${path}.modifierExtension[${String(index)}]` : `${path}.modifierExtension`
+      );
     }
-  }
-  return `{${parts.join(",")}}`;
+  });
 }
-function serializeResource(node) {
-  assertSerializable(node);
-  assertNoShadowedProperty(node);
-  return emitComplex(node);
+function descend(node, path, out) {
+  if (isComplex(node)) walkComplex(node, path, out);
+  else if (isList(node))
+    node.items.forEach((item, index) => descend(item, `${path}[${String(index)}]`, out));
 }
-
-// src/validate/issues.ts
-var ISSUE_SEVERITIES = {
-  FATAL: "fatal",
-  ERROR: "error",
-  WARNING: "warning",
-  INFORMATION: "information"
-};
-var ISSUE_TYPES = {
-  /** Structural issue, an element that is not allowed here, or a cardinality-max violation. */
-  STRUCTURE: "structure",
-  /** A required element (min cardinality ≥ 1) is missing. */
-  REQUIRED: "required",
-  /** An element value is invalid against its datatype value-domain (a primitive-regex failure). */
-  VALUE: "value",
-  /** A code is not a member of a required-strength value set binding. */
-  CODE_INVALID: "code-invalid",
-  /** A content-validation rule (a resource `constraint` / invariant) failed. */
-  INVARIANT: "invariant",
-  /** The content uses a modifier the processor does not support and cannot safely ignore. */
-  NOT_SUPPORTED: "not-supported",
-  /** Informational only, carries no defect (e.g. "this resource type has no schema yet"). */
-  INFORMATIONAL: "informational",
-  /** A business rule / profile-level assertion failed (e.g. a declared profile version is unknown). */
-  BUSINESS_RULE: "business-rule",
-  /** A referenced resource could not be found within the resolution closure (a Bundle reference). */
-  NOT_FOUND: "not-found"
-};
-var VALIDATION_CODES = {
-  /** Layer 1, an element the resource's structure does not define at this location. */
-  UNKNOWN_ELEMENT: "UNKNOWN_ELEMENT",
-  /** Layer 1, the resource carries no `resourceType`, so it cannot be structurally validated. */
-  RESOURCE_TYPE_UNKNOWN: "RESOURCE_TYPE_UNKNOWN",
-  /** Layer 1, no schema is available for this resource type; structural layers were skipped. */
-  RESOURCE_NOT_MODELED: "RESOURCE_NOT_MODELED",
-  /** Layer 1, an element's node shape (primitive / complex) is not what its datatype expects. */
-  TYPE_MISMATCH: "TYPE_MISMATCH",
-  /** Layer 1, more than one variant of a `choice[x]` element is present. */
-  CHOICE_AMBIGUOUS: "CHOICE_AMBIGUOUS",
-  /** Layer 2, a required element (min ≥ 1) is absent. */
-  CARDINALITY_MIN: "CARDINALITY_MIN",
-  /** Layer 2, an element appears more times than its maximum cardinality allows. */
-  CARDINALITY_MAX: "CARDINALITY_MAX",
-  /** Layer 3, a primitive value does not match its datatype's lexical form. */
-  PRIMITIVE_INVALID: "PRIMITIVE_INVALID",
-  /** Layer 3, a `code` value is outside a required-strength enumerated binding. */
-  CODE_INVALID: "CODE_INVALID",
-  /**
-   * Safety, an element carries a `modifierExtension` this library does not understand.
-   * FHIR's `?!` rule forbids ignoring an unknown modifier, so this **fails closed** (an `error`): the
-   * element cannot be safely processed. See {@link ./safety.js}.
-   */
-  UNHANDLED_MODIFIER_EXTENSION: "UNHANDLED_MODIFIER_EXTENSION",
-  /**
-   * Safety, the document wrote a property name more than once, so an element holds several values
-   * and nothing says which the sender meant. FHIR JSON requires unique property names (json.html §2.6.2:
-   * "Property names SHALL be unique") and expresses repetition with an array, so this is a violated
-   * `SHALL` and an `error`. The reader keeps every value (see {@link ../model/node.js} `duplicates`),
-   * so this reports an ambiguity, never a loss.
-   */
-  DUPLICATE_PROPERTY: "DUPLICATE_PROPERTY",
-  /**
-   * Safety, a single-valued (`0..1`) safety element, or `resourceType`, arrived wrapped in a JSON
-   * array. FHIR JSON writes a single-valued element as a name/value pair and uses an array only for a
-   * repeating element (json.html §2.6.2.2), so this is a non-conformant encoding and an `error`. It is the
-   * shape a **generic XML-to-JSON converter** produces for every element, which is how a C-CDA or v2
-   * feed commonly reaches a FHIR surface, and left unreported it reaches the same harm as a repeated
-   * property name: a single-value read finds no code in the array, so a retraction or a negation the
-   * sender wrote goes unreported and the record reads live. Nothing is lost, the wrapper is preserved
-   * and the safety layer reads through it; this reports that the encoding was ambiguous.
-   */
-  ARRAY_WRAPPED_SCALAR: "ARRAY_WRAPPED_SCALAR",
-  /**
-   * Safety, the document wrote a JSON array **inside another array**. FHIR JSON uses an array for a
-   * repeating element and for nothing else (json.html §2.6.2.2), so a list of lists has no meaning at
-   * any position and this is a non-conformant encoding wherever it appears, which is why it needs no
-   * cardinality rule and cannot fire on a conformant document. Reported at every position the model
-   * has a node for; a `_`-sibling the reader discards whole is the stated exception, and draws a
-   * reader warning instead: `UNKNOWN_PROPERTY` for an unrecognised member of a `_`-sibling object,
-   * `MISPLACED_PRIMITIVE_EXTENSION` for a sibling on an object or on a non-primitive array, not one
-   * code for all three. An `error`, and one of the two on this list
-   * where the reader could **not model** what the sender wrote (the other is
-   * {@link VALIDATION_CODES.DROPPED_ELEMENT_TEXT}): the codec does not model an inner array, so this
-   * reports a loss of *structure* rather than an ambiguity, though the array's JSON text is kept and
-   * readable (see {@link ../model/node.js} `nestedArrayContent`). Left unreported it is among the worst of the
-   * set, because the model then looks exactly like an element that was legitimately absent, and a
-   * refuted allergy, a resolved condition, or an entire resource inside a Bundle entry reads back as
-   * a clean document. Value-free, the position the inner array occupied, never its contents.
-   */
-  NESTED_ARRAY: "NESTED_ARRAY",
-  /**
-   * Safety, an XML document wrote **character data directly on a FHIR element**. FHIR XML carries a
-   * primitive's value in the `value` attribute (xml.html §2.6.1), so text written as element content
-   * has no slot on the model and the reader drops it: `<status>entered-in-error</status>` yields a
-   * `status` with no value. An `error`, and the only code on this list where the content is neither
-   * modeled **nor kept**: unlike {@link VALIDATION_CODES.NESTED_ARRAY}, which preserves the array's
-   * JSON text, the character data is discarded outright, because reading it back would be a
-   * tolerance for a non-conformant encoding rather than a report of one. Left unreported it reaches the same harm as
-   * {@link VALIDATION_CODES.NESTED_ARRAY} by the other wire format, because the model is again
-   * indistinguishable from an element that was legitimately absent: a retraction, a `refuted`
-   * verification status, or a dose *number* beside a surviving unit and UCUM code all read back as a
-   * clean document. Value-free, the position the text occupied, never its contents.
-   */
-  DROPPED_ELEMENT_TEXT: "DROPPED_ELEMENT_TEXT",
-  /**
-   * Safety, an element carries a DataAbsentReason extension **and a value of its own**, so the
-   * document asserts both that the element holds that value and that it holds none. An `error`
-   * (`structure`): the two cannot both be true, nothing here ranks them, and a consumer that
-   * happened to read one of the two would report the record as though the other had not been
-   * written. Both survive on the model and on the safety readout; this reports that they disagree.
-   * Value-free, the location of the element, never the value and never the reason.
-   *
-   * Cannot fire on a conformant document: an element the sender has data for is written with the
-   * data and no marker. It is **not** the `Observation.dataAbsentReason` ELEMENT beside a `value[x]`,
-   * which is the `obs-6` invariant and reports as {@link VALIDATION_CODES.INVARIANT_VIOLATED}; the
-   * element is not the extension, and the two never report about one another's shape.
-   */
-  ABSENCE_MARKER_CONFLICT: "ABSENCE_MARKER_CONFLICT",
-  /**
-   * Safety, an element carries a DataAbsentReason extension whose reason this library could not
-   * read: no `valueCode`, one holding no readable string, an empty one, one written twice, or a code
-   * outside the closed fifteen-concept value set the extension's `value[x]` binds to at **required**
-   * strength. An `error` (`code-invalid`), on the same footing as any other required-binding miss:
-   * the set is closed and published, so membership is decided from the set itself with no
-   * terminology service involved and no value-set expansion.
-   *
-   * **Nothing is coerced.** The code is not trimmed, case-folded or substituted, and the element is
-   * not read as `unknown` and not read as populated: doing either would author a reason the sender
-   * did not spell, or erase a declaration the sender did make. The element stays value-absent and
-   * this is the record that a declaration was made and could not be honoured. Value-free, the
-   * location of the element, never the code that failed to match.
-   */
-  ABSENCE_MARKER_UNREADABLE: "ABSENCE_MARKER_UNREADABLE",
-  /**
-   * Safety, the resource is marked `entered-in-error` and is therefore **retracted, not
-   * data**. Surfaced as `information` (it is not itself a defect) so a consumer cannot miss it.
-   */
-  RETRACTED_RESOURCE: "RETRACTED_RESOURCE",
-  /**
-   * Safety, a named resource invariant failed (`ait-1`/`ait-2`, `con-3`/`con-4`/`con-5`,
-   * `obs-6`/`obs-7`). The specific constraint key travels in {@link ValidationIssue.constraint}, and
-   * the severity mirrors the constraint's own (`error`, except the best-practice `con-3` → `warning`).
-   */
-  INVARIANT_VIOLATED: "INVARIANT_VIOLATED",
-  /**
-   * Invariant, a profile `constraint`'s FHIRPath `expression` is **outside the bounded
-   * engine's subset** and could not be evaluated. Always `information` (`informational`):
-   * the constraint is reported **unchecked, never assumed to pass** (fail-safe), the
-   * library does not claim conformance to an invariant it could not test. The constraint `key` travels
-   * in {@link ValidationIssue.constraint}. Value-free (the location + key, never an instance value).
-   */
-  INVARIANT_UNCHECKED: "INVARIANT_UNCHECKED",
-  /**
-   * Quantity/UCUM, a `Quantity` claims the UCUM `system` but its `code` is absent or not a
-   * shape-valid UCUM expression, so the unit cannot be trusted for machine use. A `warning`
-   * (`value`): the value is **preserved verbatim and never converted**, the library does not bundle
-   * UCUM content, so it cannot assert the code *is* a real unit, only that it is present and well-shaped.
-   */
-  UCUM_UNIT_UNRECOGNIZED: "UCUM_UNIT_UNRECOGNIZED",
-  /**
-   * Quantity/UCUM, a vital-signs Observation's measured value carries a unit the FHIR
-   * vital-signs profile forbids for that LOINC code (wrong UCUM `code`, or a non-UCUM `system`). An
-   * `error` (`code-invalid`): the vital-signs profile *requires* the unit, so a nonconformant one is a
-   * profile violation, compared on the UCUM `code` (case- and bracket-sensitive), never the `unit` string.
-   */
-  VITAL_SIGN_UNIT_NONCONFORMANT: "VITAL_SIGN_UNIT_NONCONFORMANT",
-  /**
-   * Quantity/UCUM, an Observation whose profile expects a numeric `Quantity` value carries
-   * a different `value[x]` variant instead (e.g. `valueString`). A `warning` (`value`): the value is
-   * preserved and surfaced by its real type, a caller must not read it as a number.
-   */
-  VALUE_TYPE_UNEXPECTED: "VALUE_TYPE_UNEXPECTED",
+function readSafety(resource) {
+  const types = typesOf(resource);
+  const rt = types[0];
+  const isType = (type) => types.includes(type);
+  const status = primitiveStrings(getProperty(resource, "status"))[0];
+  const clinicalStatus = safetyCodeOf(
+    getProperty(resource, "clinicalStatus"),
+    clinicalSystemFor(rt)
+  );
+  const verificationStatus = safetyCodeOf(
+    getProperty(resource, "verificationStatus"),
+    verificationSystemFor(rt)
+  );
+  const prefix = safetyPrefix(types);
+  const walk2 = walkSafety(resource, prefix);
+  const doNotPerform = readDoNotPerform(resource);
+  const retracted = isRetracted(resource);
+  const noKnownAllergy = isType("AllergyIntolerance") && getAllProperties(resource, "code").some(
+    (node) => safetyHasCoding(node, SNOMED_SCT, NO_KNOWN_ALLERGY)
+  );
+  const found = new Set(walk2.negations);
+  if (noKnownAllergy) found.add("no-known-allergy");
+  const negations = NEGATION_ORDER.filter((kind) => found.has(kind));
+  const { modifiers, shadowed, arrayWrapped, unreadableBoolean, nearMissCode, unreadableCode } = walk2;
+  const modifierElementReports = rebaseModifierElements(walk2.modifierElements, prefix, types);
+  const rebase = modifierLocationRebaser(prefix, types);
+  const intents = walk2.intents.map((read) => ({
+    code: read.code,
+    location: rebase(read.location)
+  }));
+  const unreadableIntents = walk2.unreadableIntent.map(rebase);
+  const datatypeUses = walk2.datatypeUses.map((read) => ({
+    code: read.code,
+    location: rebase(read.location)
+  }));
+  const unreadableDatatypeUses = walk2.unreadableDatatypeUse.map(rebase);
+  const nested = nestedArrays(resource, prefix);
+  const dropped = droppedText(resource, prefix);
+  const absence = collectAbsence(resource, prefix);
+  return {
+    resourceType: rt === void 0 ? void 0 : rootPath(rt),
+    status,
+    clinicalStatus,
+    verificationStatus,
+    doNotPerform,
+    retracted,
+    noKnownAllergy,
+    negations,
+    unhandledModifierExtensions: modifiers,
+    modifierElements: modifierElementReports,
+    intents,
+    datatypeUses,
+    shadowedProperties: shadowed,
+    arrayWrappedScalars: arrayWrapped,
+    nestedArrays: nested,
+    droppedText: dropped,
+    unreadableBooleans: unreadableBoolean,
+    nearMissNegationCodes: nearMissCode,
+    unreadableNegationCodes: unreadableCode,
+    unreadableIntents,
+    unreadableDatatypeUses,
+    absenceMarkers: absence.markers,
+    unreadableAbsenceMarkers: absence.unreadable,
+    conflictingAbsenceMarkers: absence.conflicting,
+    safeToSummarize: modifiers.length === 0 && modifierElementReports.length === 0 && shadowed.length === 0 && arrayWrapped.length === 0 && nested.length === 0 && dropped.length === 0 && unreadableBoolean.length === 0 && nearMissCode.length === 0 && unreadableCode.length === 0 && unreadableIntents.length === 0 && unreadableDatatypeUses.length === 0 && absence.unreadable.length === 0 && absence.conflicting.length === 0
+  };
+}
+var FhirSafetyError = class extends Error {
+  /** FHIRPath locations that forced the refusal (value-free). */
+  locations;
   /**
-   * Terminology, a bound coding's `system` URI is not in the frozen known-systems registry
-   * (and not one the binding's value set draws from). Always `information` (`code-invalid`): an
-   * unknown system may be a legitimate local/proprietary one, so it is never a defect, it only means
-   * the library cannot validate codes drawn from it. Content-free, so it can never flip validity.
+   * @param locations - The FHIRPath locations that forced the refusal (value-free).
    */
-  CODE_SYSTEM_UNKNOWN: "CODE_SYSTEM_UNKNOWN",
+  constructor(locations) {
+    super(
+      `Resource cannot be safely summarized: an unhandled modifierExtension, a modifier element, a repeated property name, an array-wrapped single-valued element, an array inside an array, dropped XML element text, a boolean value this library cannot read, a code that spells a negation bar its case or its surrounding whitespace, content where a code belongs, a use on an identifier, name, address or contact point this library cannot read, a declared absence whose reason this library cannot read, or a declared absence beside a value leaves an element this library must not flatten (${String(locations.length)} location(s)).`
+    );
+    this.name = "FhirSafetyError";
+    this.locations = locations;
+  }
+};
+function assertSafeToSummarize(resource) {
+  const readout = "unhandledModifierExtensions" in resource ? resource : readSafety(resource);
+  const locations = [
+    ...readout.unhandledModifierExtensions,
+    ...readout.modifierElements.map((report) => report.location),
+    ...readout.shadowedProperties,
+    ...readout.arrayWrappedScalars,
+    ...readout.nestedArrays,
+    ...readout.droppedText,
+    ...readout.unreadableBooleans,
+    ...readout.nearMissNegationCodes,
+    ...readout.unreadableNegationCodes,
+    // `intents` is deliberately absent, exactly as it is absent from `safeToSummarize`'s
+    // conjunction: a readable intent is surfaced for the caller, and only an unreadable one refuses.
+    ...readout.unreadableIntents,
+    // `datatypeUses` is absent for the same reason `intents` is: a readable `use` is surfaced for
+    // the caller, and only one this library cannot read refuses.
+    ...readout.unreadableDatatypeUses,
+    // The two absence channels that withdraw the affirmation. `absenceMarkers` is deliberately
+    // absent from this list, exactly as it is absent from `safeToSummarize`'s conjunction: a
+    // declaration the caller can read is a disclosure, not a loss.
+    ...readout.unreadableAbsenceMarkers,
+    ...readout.conflictingAbsenceMarkers
+  ];
+  if (locations.length > 0) throw new FhirSafetyError(locations);
+}
+
+// src/codec/serialize-guard.ts
+var SERIALIZE_ERROR_CODES = {
   /**
-   * Terminology, a bound coding uses a **known** code `system` that is not one the
-   * binding's value set draws from (e.g. an ICD-10-CM code where the binding expects RxNorm + SNOMED).
-   * This is the content-free "wrong system for this binding" check, decided from the `system` alone,
-   * with no value-set content. Severity follows the binding strength (`required` → `error`;
-   * `extensible`/`preferred` → `warning`, since a different system may be a legitimate extension;
-   * `example` → none). Compared on the `system` URI, never a code value.
+   * The model carries character data the XML reader dropped, at one or more locations. There is no
+   * conformant encoding of it in either wire format, and emitting the element as unfilled would
+   * launder the `DROPPED_ELEMENT_TEXT` finding across a round trip.
    */
-  CODE_SYSTEM_UNEXPECTED: "CODE_SYSTEM_UNEXPECTED",
+  DROPPED_ELEMENT_TEXT: "DROPPED_ELEMENT_TEXT",
   /**
-   * Terminology, a configured terminology service reported that a bound coding's
-   * `(system, code)` is **not a member** of the binding's value set. Severity follows the binding
-   * strength (`required`/`extensible` → `error`; `preferred` → `warning`; `example` → `information`,
-   * never an error). Emitted **only** when a service definitively answers `not-in`; with no service,
-   * or an `unknown` answer, the library degrades to the content-free system checks and never
-   * false-errors (fail-safe). Value-free, the coding location, never the code itself.
+   * The model carries a name that cannot occupy the `Name` slot of an XML start tag, so writing it
+   * would emit markup that does not re-read as the element the model holds. **XML only**: JSON
+   * escapes a member name, so this refusal never reaches it and that route stays open. **Narrowed
+   * 2026-08-07 from "encodes every one of these correctly", which was false and shipped**: a model
+   * refused here can carry one of `serializeResource`'s own declared exceptions and emit that.
+   *
+   * See {@link breaksTag} for the exact predicate and for what is deliberately NOT refused.
    */
-  CODE_NOT_IN_VALUESET: "CODE_NOT_IN_VALUESET",
+  UNSERIALIZABLE_ELEMENT_NAME: "UNSERIALIZABLE_ELEMENT_NAME",
   /**
-   * Profile, an instance element is present under a **closed** slicing whose discriminators
-   * matched none of the profile's defined slices. A `structure` `error`: `closed` slicing forbids
-   * content outside the named slices. (Under `open` slicing an unmatched element is allowed and draws
-   * nothing; under `openAtEnd` it is allowed only in the trailing position, this library flags a
-   * closed-slicing miss and leaves the ordering nuance unenforced.)
+   * A `div` property carries a string the XML writer would emit as raw markup, and that string does
+   * not contribute exactly one element named `div` to the document. **XML only**: `serializeResource`
+   * carries the string as a string, so this refusal never reaches it and that route stays open.
+   *
+   * **That is a statement about the `div` string, not about the whole model.** `serializeResource`
+   * has its own declared non-spec-clean exceptions, so a model refused here can still route through
+   * it and emit one of those: `{"text":{"div":""},"name":[[{"family":"X"}]]}` is refused here and
+   * `serializeResource` emits the array inside an array unchanged.
+   *
+   * See `emitsOneDivElement` in `../xml/write.js` for the exact predicate and what it does not cover.
    */
-  PROFILE_SLICE_UNMATCHED: "PROFILE_SLICE_UNMATCHED",
+  UNSERIALIZABLE_DIV_MARKUP: "UNSERIALIZABLE_DIV_MARKUP",
   /**
-   * Profile, a slicing whose discriminator this library cannot evaluate (a `profile`
-   * discriminator, which needs recursive profile resolution, or the R5-only `position`). Emitted as
-   * `information` so slice membership is reported **unchecked, never silently passed** (the
-   * fail-safe): the library does not guess a slice assignment it cannot justify.
+   * The model carries, at one or more locations, a shape the JSON reader marked because FHIR JSON
+   * gives that position no meaning: an array inside an array, a scalar or `null` where FHIR JSON has
+   * an object (a complex element's own position or a primitive's `_`-sibling), or a `null` in a
+   * primitive's value channel that padded nothing. **XML only**: this refusal does not reach
+   * `serializeResource`, which writes these back from the text the reader preserved at every position
+   * that writer walks. **It does not walk a member a repeated property name shadowed, and this
+   * refusal does reach one** -- `serializeResource` refuses that model on
+   * {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_SHADOWED_PROPERTY} rather than emitting it, so it is
+   * still not a route the shape survives. The XML writer keeps reporting THIS code on such a model,
+   * because this one is raised first. See {@link assertXmlSerializable}.
+   *
+   * XML has no array-of-arrays, no `_`-sibling and no `null`, so the XML writer has nowhere to put
+   * any of it and emits the element the reader was left holding: an empty one, or none. That output
+   * re-reads with an empty issue list, so the finding the reader raised is gone after one trip.
+   *
+   * See {@link assertXmlSerializable} for the exact set of markers and for what it does NOT cover.
    */
-  PROFILE_SLICE_UNCHECKED: "PROFILE_SLICE_UNCHECKED",
+  UNSERIALIZABLE_JSON_ONLY_SHAPE: "UNSERIALIZABLE_JSON_ONLY_SHAPE",
   /**
-   * Profile, an element the profile marks **must-support** is absent from the instance.
-   * **Always `information`, never an error** (the fail-safe, and the single most important
-   * must-support rule): must-support is a *system obligation* on the sender to be able to populate the
-   * element and on the receiver to tolerate its absence, it is **not** an instance-presence
-   * requirement. A strict client that errors on an absent must-support element is the classic bug this
-   * code exists to avoid.
+   * The model carries, at a location this library already reports as an array-wrapped `0..1` safety
+   * element, a wrapper FHIR XML has no repetition to spell back: one holding fewer than two items,
+   * or any wrapper at all on `resourceType`. **XML only**: `serializeResource` writes the list back
+   * and the re-read reports the same location, so that route stays open.
+   *
+   * XML spells a repeat by repeating the element and has no other mark for one, so a wrapper of
+   * fewer than two items emits at most one element and re-reads as an ordinary single-valued
+   * element. The encoding complaint the reader raised is then gone, and with it an `error`-severity
+   * `ARRAY_WRAPPED_SCALAR` and a `safeToSummarize: false`.
+   *
+   * See {@link assertXmlArrayWrapper} for the exact predicate and for what it deliberately leaves.
    */
-  MUST_SUPPORT_ABSENT: "MUST_SUPPORT_ABSENT",
+  UNSERIALIZABLE_ARRAY_WRAPPER: "UNSERIALIZABLE_ARRAY_WRAPPER",
   /**
-   * Profile, the instance's `meta.profile` declares a profile at a version the supplied
-   * profile set does not carry (`canonical|version` with a different version, or an unresolvable
-   * canonical). A `warning` (`business-rule`): an unknown profile
-   * version is flagged rather than silently best-effort-validating against a different one.
+   * The model carries, at a location this library already reports as an array-wrapped
+   * `Observation.value[x]` choice, a wrapper FHIR XML has no repetition to spell back: one holding
+   * fewer than two items. **XML only**: `serializeResource` writes the list back and the re-read
+   * reports the same location, so that route stays open.
+   *
+   * The same harm as {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_ARRAY_WRAPPER}, at the position
+   * where the number is a DOSE: `{"resourceType":"Observation","status":"final","valueQuantity":
+   * [{"value":5,"system":"http://unitsofmeasure.org","code":"mg"}]}` reads with the encoding
+   * reported and no magnitude handed out, and used to come back from XML as an unambiguous 5 mg
+   * nothing had complained about.
+   *
+   * See {@link assertXmlValueChoiceWrapper} for the window and for what it deliberately leaves.
    */
-  PROFILE_VERSION_MISMATCH: "PROFILE_VERSION_MISMATCH",
+  UNSERIALIZABLE_CHOICE_WRAPPER: "UNSERIALIZABLE_CHOICE_WRAPPER",
   /**
-   * Profile, an element carries a value that is not **exactly** the profile's `fixed[x]`.
-   * A `value` `error`: `fixed[x]` is an equality constraint (the element SHALL match the fixed value
-   * exactly, including every nested property). Compared structurally and precision-exactly (decimals
-   * via {@link ../model/decimal.js}), never by echoing the value.
+   * The model carries, at one or more object elements, a member a repeated property name shadowed
+   * ({@link ../model/node.js} `duplicates`). **Both writers**, unlike the four refusals above it:
+   * each walks `properties` only, so each wrote one member per name and the second value left the
+   * document with no diagnostic on it.
+   *
+   * See {@link assertNoShadowedProperty} for the window, the two routes weighed, and what it leaves.
    */
-  PROFILE_FIXED_MISMATCH: "PROFILE_FIXED_MISMATCH",
+  UNSERIALIZABLE_SHADOWED_PROPERTY: "UNSERIALIZABLE_SHADOWED_PROPERTY",
   /**
-   * Profile, an element does not match the profile's `pattern[x]`. A `value` `error`:
-   * `pattern[x]` is a **subset** constraint (the element SHALL contain *at least* the pattern's
-   * properties and values, but may carry more), the weaker sibling of `fixed[x]`. Value-free.
+   * The model carries, at one or more elements, a first `resourceType` that is not a string. FHIR
+   * XML has no `resourceType` element at all -- the type IS the tag -- so the XML writer skipped the
+   * property, and at the root, with no string to name the tag, it wrote `Resource` instead: the
+   * member deleted and the element named a type nobody wrote. **XML only**: `serializeResource` emits a
+   * non-string `resourceType` through its ordinary path, so this refusal never reaches it and that
+   * route stays open.
+   *
+   * See {@link assertXmlResourceType} for the window and for what it deliberately leaves.
    */
-  PROFILE_PATTERN_MISMATCH: "PROFILE_PATTERN_MISMATCH",
+  UNSERIALIZABLE_RESOURCE_TYPE: "UNSERIALIZABLE_RESOURCE_TYPE",
   /**
-   * Bundle, a `Reference` inside a Bundle entry (or a `#fragment` inside a resource's
-   * `contained`) that could not be resolved within the resolution closure: a fragment whose target
-   * contained resource is absent, or a relative `Type/id` reference naming no entry in the Bundle. A
-   * `warning` (`not-found`) and **never fatal**, the target may legitimately live outside the
-   * supplied closure (a partial Bundle, an external server), so the reference is **preserved**, only
-   * flagged. An absolute/logical reference that is simply external to the Bundle draws **no** finding.
-   * Value-free, the FHIRPath location of the reference, never the reference string itself.
+   * The model carries, at one or more elements, a root the XML reader read out of a vocabulary that
+   * resolved to something other than FHIR's. **XML only**: `serializeResource` spells a member name
+   * and never a namespace, so it emits the model exactly as it did before this refusal existed and
+   * that route stays open -- which is a statement about that writer's output, **not** a claim that
+   * the JSON channel keeps the flag. It does not, and that half is declared open.
+   *
+   * FHIR XML puts the resource in the FHIR namespace, and the writer has no vendor binding to write
+   * instead, so it emitted a document in the FHIR namespace with no trace of the one the sender
+   * wrote. That output re-reads with an **empty** issue list, so the one warning that said the
+   * document came from another vocabulary is gone after a single trip and the vendor document is
+   * indistinguishable from FHIR.
+   *
+   * See {@link assertXmlForeignRoot} for the window, the two routes weighed, and what it costs.
    */
-  REFERENCE_UNRESOLVED: "REFERENCE_UNRESOLVED",
+  UNSERIALIZABLE_FOREIGN_ROOT: "UNSERIALIZABLE_FOREIGN_ROOT",
   /**
-   * Bundle, the `#fragment` references among a resource's `contained` resources form a
-   * **cycle** (a → b → a, or a self-reference). An `error` (`structure`): a containment cycle is
-   * malformed and, to a naive transitive resolver, a denial-of-service (an unbounded loop / stack
-   * blow-up). The bounded, iterative cycle guard detects it and reports it here rather than looping,
-   * DoS-safe by construction. Value-free, the location of the `contained` element, never a value.
+   * The model holds, at one or more tag positions, a name carrying a colon. XML reads the colon as
+   * a namespace prefix, and the model carries no namespace binding for the writer to declare one
+   * with, so the document would not be namespace-well-formed. **XML only**: `serializeResource`
+   * spells a member name as a JSON string, so this refusal never reaches it and that route stays
+   * open.
+   *
+   * Written anyway, the output named a prefix nothing declared, which a conformant XML parser
+   * rejects, and a prefix rebound between siblings (`<p:x xmlns:p="urn:a"/>` beside
+   * `<p:x xmlns:p="urn:b"/>`) lost its `MIXED_XML_SPELLING` report across one write and one re-read.
+   * **Not {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_ELEMENT_NAME}**, whose line is whether this
+   * library's own round trip survives a name: a colon-bearing name survives that round trip, so the
+   * two are different questions and keep different codes. A name that trips both keeps that one.
+   *
+   * See {@link carriesUndeclarablePrefix} for the exact predicate, its one exemption, and what it
+   * leaves.
    */
-  CONTAINED_CYCLE: "CONTAINED_CYCLE",
+  UNSERIALIZABLE_PREFIXED_NAME: "UNSERIALIZABLE_PREFIXED_NAME",
   /**
-   * Bundle, a Bundle entry's `fullUrl` is a RESTful URL (relative `Type/id` or an absolute
-   * URL ending in `Type/id`) whose id disagrees with the entry `resource.id`. An `error`
-   * (`business-rule`): FHIR requires a RESTful `fullUrl` to be consistent with the resource it wraps,
-   * and a disagreement can cause a reference to resolve to the wrong resource. A `urn:uuid:` (logical)
-   * `fullUrl` places no constraint on `resource.id`, so it never triggers this. Value-free, the
-   * location of the `fullUrl`, never either id.
-   */
-  FULLURL_ID_MISMATCH: "FULLURL_ID_MISMATCH"
-};
-var ISSUE_TYPE_OF = {
-  UNKNOWN_ELEMENT: ISSUE_TYPES.STRUCTURE,
-  RESOURCE_TYPE_UNKNOWN: ISSUE_TYPES.STRUCTURE,
-  RESOURCE_NOT_MODELED: ISSUE_TYPES.INFORMATIONAL,
-  TYPE_MISMATCH: ISSUE_TYPES.STRUCTURE,
-  CHOICE_AMBIGUOUS: ISSUE_TYPES.STRUCTURE,
-  CARDINALITY_MIN: ISSUE_TYPES.REQUIRED,
-  CARDINALITY_MAX: ISSUE_TYPES.STRUCTURE,
-  PRIMITIVE_INVALID: ISSUE_TYPES.VALUE,
-  CODE_INVALID: ISSUE_TYPES.CODE_INVALID,
-  UNHANDLED_MODIFIER_EXTENSION: ISSUE_TYPES.NOT_SUPPORTED,
-  DUPLICATE_PROPERTY: ISSUE_TYPES.STRUCTURE,
-  ARRAY_WRAPPED_SCALAR: ISSUE_TYPES.STRUCTURE,
-  NESTED_ARRAY: ISSUE_TYPES.STRUCTURE,
-  DROPPED_ELEMENT_TEXT: ISSUE_TYPES.STRUCTURE,
-  ABSENCE_MARKER_CONFLICT: ISSUE_TYPES.STRUCTURE,
-  ABSENCE_MARKER_UNREADABLE: ISSUE_TYPES.CODE_INVALID,
-  RETRACTED_RESOURCE: ISSUE_TYPES.INFORMATIONAL,
-  INVARIANT_VIOLATED: ISSUE_TYPES.INVARIANT,
-  INVARIANT_UNCHECKED: ISSUE_TYPES.INFORMATIONAL,
-  UCUM_UNIT_UNRECOGNIZED: ISSUE_TYPES.VALUE,
-  VITAL_SIGN_UNIT_NONCONFORMANT: ISSUE_TYPES.CODE_INVALID,
-  VALUE_TYPE_UNEXPECTED: ISSUE_TYPES.VALUE,
-  CODE_SYSTEM_UNKNOWN: ISSUE_TYPES.CODE_INVALID,
-  CODE_SYSTEM_UNEXPECTED: ISSUE_TYPES.CODE_INVALID,
-  CODE_NOT_IN_VALUESET: ISSUE_TYPES.CODE_INVALID,
-  PROFILE_SLICE_UNMATCHED: ISSUE_TYPES.STRUCTURE,
-  PROFILE_SLICE_UNCHECKED: ISSUE_TYPES.INFORMATIONAL,
-  MUST_SUPPORT_ABSENT: ISSUE_TYPES.INFORMATIONAL,
-  PROFILE_VERSION_MISMATCH: ISSUE_TYPES.BUSINESS_RULE,
-  PROFILE_FIXED_MISMATCH: ISSUE_TYPES.VALUE,
-  PROFILE_PATTERN_MISMATCH: ISSUE_TYPES.VALUE,
-  REFERENCE_UNRESOLVED: ISSUE_TYPES.NOT_FOUND,
-  CONTAINED_CYCLE: ISSUE_TYPES.STRUCTURE,
-  FULLURL_ID_MISMATCH: ISSUE_TYPES.BUSINESS_RULE
+   * The model holds, at one or more `div` locations, a string the XML writer would splice in as raw
+   * markup that spells the one `div` element the property names, and whose markup names a namespace
+   * prefix, on an element or on an attribute, that no declaration inside the string binds. **XML
+   * only**: `serializeResource` carries the string as a string, so this refusal never reaches it and
+   * that route stays open.
+   *
+   * Written anyway, `<v:div>x</v:div>` put a prefix nothing declared into the output, which a
+   * conformant XML parser rejects, and this library's own re-read of that output turned the narrative
+   * into a property named `v:div`: the narrative gone after one write and one read, with no
+   * diagnostic at either end. **Not {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_PREFIXED_NAME}**,
+   * whose published meaning is a name at a tag position, and **not
+   * {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_DIV_MARKUP}**, whose question is which elements the
+   * string contributes: a string that fails that question keeps that code whatever prefix it names.
+   *
+   * See `bindsEveryPrefix` in `../xml/write.js` for the exact predicate and what it leaves.
+   *
+   * @example
+   * ```ts
+   * import {
+   *   FhirSerializeError,
+   *   SERIALIZE_ERROR_CODES,
+   *   parseResource,
+   *   serializeResourceXml,
+   * } from "@cosyte/fhir";
+   * const { resource } = parseResource(
+   *   '{"resourceType":"Patient","text":{"status":"generated","div":"<v:div>x</v:div>"}}',
+   * );
+   * try {
+   *   serializeResourceXml(resource);
+   * } catch (err) {
+   *   if (err instanceof FhirSerializeError && err.code === SERIALIZE_ERROR_CODES.UNSERIALIZABLE_DIV_PREFIX) {
+   *     err.locations; // ["Patient.text.div"]
+   *   }
+   * }
+   * ```
+   */
+  UNSERIALIZABLE_DIV_PREFIX: "UNSERIALIZABLE_DIV_PREFIX",
+  /**
+   * The model holds, at one or more tag positions, a name that is not an XML 1.0 `Name` (production
+   * [5]): `a&b`, `1abc`, `-x`, a name carrying U+0000 or an unpaired surrogate. A conforming XML
+   * processor must reject such a document as a fatal error. **XML only**: `serializeResource` spells
+   * a member name as a JSON string, so this refusal never reaches it and that route stays open.
+   *
+   * Written anyway, `<a&b value="v"/>` was a document this library's own reader read back unchanged
+   * and a third-party parser rejected, which is why the tag-breaking refusal, whose line is this
+   * library's own round trip, never reached it. **Not
+   * {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_ELEMENT_NAME}** and **not
+   * {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_PREFIXED_NAME}**: a name that breaks the tag, or
+   * carries a colon, keeps the code it drew before this one existed, whether or not it is a `Name`.
+   * A name carrying a character outside `Char` is not a `Name`, so it draws this code rather than
+   * {@link SERIALIZE_ERROR_CODES.UNSERIALIZABLE_XML_CHARACTER}.
+   *
+   * See {@link isXmlName} for the exact predicate and what it leaves.
+   *
+   * @example
+   * ```ts
+   * import {
+   *   FhirSerializeError,
+   *   SERIALIZE_ERROR_CODES,
+   *   parseResource,
+   *   serializeResourceXml,
+   * } from "@cosyte/fhir";
+   * const { resource } = parseResource('{"resourceType":"Patient","1abc":"v"}');
+   * try {
+   *   serializeResourceXml(resource);
+   * } catch (err) {
+   *   if (err instanceof FhirSerializeError && err.code === SERIALIZE_ERROR_CODES.UNSERIALIZABLE_XML_NAME) {
+   *     err.locations; // ["Patient.<withheld>"]
+   *   }
+   * }
+   * ```
+   */
+  UNSERIALIZABLE_XML_NAME: "UNSERIALIZABLE_XML_NAME",
+  /**
+   * The model holds, at one or more locations, a value the XML writer would emit as an attribute
+   * value (a primitive's `value`, an `id` written as an attribute, an `Extension.url`), or a `div`
+   * string it would splice in, carrying a code point outside XML 1.0 `Char` (production [2]): U+0000
+   * to U+0008, U+000B, U+000C, U+000E to U+001F, an unpaired surrogate, U+FFFE or U+FFFF. In a `div`
+   * string that includes a numeric character reference denoting one (`&#0;`), which the Legal
+   * Character constraint makes as fatal as the raw character; each reference is judged on its own, so
+   * `&#xD83D;&#xDE00;` is two unpaired surrogates, not one character. **XML only**: `serializeResource`
+   * writes these values as JSON strings, so this refusal never reaches it and that route stays open.
+   *
+   * Written anyway, a U+0000 went into the output raw and a conforming processor rejected the
+   * document. **Refused, never repaired**: a reference to a non-`Char` is itself a fatal error, and
+   * replacing or dropping the character would change a value the sender wrote, so the model is left
+   * exactly as it was and no string is returned. Raised after every other refusal, the name code
+   * included.
+   *
+   * See {@link carriesNonXmlCharacter} for the exact predicate.
+   *
+   * @example
+   * ```ts
+   * import {
+   *   FhirSerializeError,
+   *   SERIALIZE_ERROR_CODES,
+   *   parseResource,
+   *   serializeResourceXml,
+   * } from "@cosyte/fhir";
+   * const { resource } = parseResource('{"resourceType":"Patient","gender":"a\\u0000"}');
+   * try {
+   *   serializeResourceXml(resource);
+   * } catch (err) {
+   *   if (err instanceof FhirSerializeError && err.code === SERIALIZE_ERROR_CODES.UNSERIALIZABLE_XML_CHARACTER) {
+   *     err.locations; // ["Patient.gender"]
+   *   }
+   * }
+   * ```
+   */
+  UNSERIALIZABLE_XML_CHARACTER: "UNSERIALIZABLE_XML_CHARACTER"
 };
-var DIAGNOSTIC_OF = {
-  UNKNOWN_ELEMENT: "Element is not defined at this location in the resource structure.",
-  RESOURCE_TYPE_UNKNOWN: "Resource is missing a resourceType and cannot be structurally validated.",
-  RESOURCE_NOT_MODELED: "No structural schema is available for this resource type; structural validation was skipped.",
-  TYPE_MISMATCH: "Element value is not of the shape its datatype requires.",
-  CHOICE_AMBIGUOUS: "More than one variant of a choice element is present.",
-  CARDINALITY_MIN: "Required element is missing.",
-  CARDINALITY_MAX: "Element appears more times than its maximum cardinality allows.",
-  PRIMITIVE_INVALID: "Primitive value does not match the required lexical form for its datatype.",
-  CODE_INVALID: "Code is not in the required value set for this element.",
-  UNHANDLED_MODIFIER_EXTENSION: "Element carries a modifierExtension this processor does not understand; it cannot be safely processed and is rejected (fail-closed).",
-  DUPLICATE_PROPERTY: "Property name appears more than once on this object; FHIR requires unique property names and uses an array for a repeating element, so the element's value is ambiguous.",
-  ARRAY_WRAPPED_SCALAR: "Single-valued element is wrapped in an array; FHIR JSON writes a 0..1 element as a name/value pair and uses an array only for a repeating element, so the element's encoding is ambiguous.",
-  NESTED_ARRAY: "A JSON array appears inside another array; FHIR JSON uses an array only for a repeating element, so this shape has no meaning and its contents were not read. Content the sender wrote is missing from the model at this position.",
-  DROPPED_ELEMENT_TEXT: "Character data was written directly on this element; FHIR XML carries a primitive's value in the value attribute, so an element has no slot for text and it was not read. Content the sender wrote is missing from the model at this position.",
-  ABSENCE_MARKER_CONFLICT: "Element carries a data-absent-reason extension and a value of its own; the document asserts both that the element holds that value and that it holds none, and neither is preferred here. Both are preserved.",
-  ABSENCE_MARKER_UNREADABLE: "Element carries a data-absent-reason extension whose reason could not be read: it is absent, empty, written more than once, or outside the value set the extension requires. The reason is not guessed and the element is not read as populated.",
-  RETRACTED_RESOURCE: "Resource is marked entered-in-error; it is retracted and must not be treated as active data.",
-  INVARIANT_VIOLATED: "A resource invariant (content-validation constraint) was violated.",
-  INVARIANT_UNCHECKED: "A resource invariant could not be evaluated by the bounded FHIRPath engine; it is reported unchecked rather than assumed to pass.",
-  UCUM_UNIT_UNRECOGNIZED: "Quantity declares the UCUM system but its unit code is absent or not a well-formed UCUM expression; the unit is preserved verbatim and never converted.",
-  VITAL_SIGN_UNIT_NONCONFORMANT: "Vital-signs measurement carries a unit the vital-signs profile does not allow for this code.",
-  VALUE_TYPE_UNEXPECTED: "Observation value is present but not the expected type for this profile.",
-  CODE_SYSTEM_UNKNOWN: "Coding uses a code system that is not in the known-systems registry; its codes cannot be validated (an unrecognized system is not itself an error).",
-  CODE_SYSTEM_UNEXPECTED: "Coding uses a code system that the bound value set does not draw from.",
-  CODE_NOT_IN_VALUESET: "Coding is not a member of the value set required by this element's binding.",
-  PROFILE_SLICE_UNMATCHED: "Element is present under closed slicing but matches none of the profile's defined slices.",
-  PROFILE_SLICE_UNCHECKED: "Slice membership could not be evaluated (an unsupported discriminator); it is reported unchecked rather than assumed to pass.",
-  MUST_SUPPORT_ABSENT: "Profile marks this element must-support; it is absent. Must-support is a system obligation, not an instance-presence requirement, this is informational, never an error.",
-  PROFILE_VERSION_MISMATCH: "Instance declares a profile at a version the supplied profile set does not carry; it was not validated against that exact version.",
-  PROFILE_FIXED_MISMATCH: "Element value does not exactly match the value the profile fixes for it.",
-  PROFILE_PATTERN_MISMATCH: "Element does not match the pattern the profile requires for it.",
-  REFERENCE_UNRESOLVED: "Reference could not be resolved within the supplied closure; it is preserved and flagged, never dropped (the target may live outside this Bundle).",
-  CONTAINED_CYCLE: "Contained resources reference each other in a cycle; the containment graph is malformed and was reported by the bounded cycle guard rather than followed into an unbounded loop.",
-  FULLURL_ID_MISMATCH: "Bundle entry fullUrl is a RESTful URL whose id disagrees with the wrapped resource's id."
+var FhirSerializeError = class extends Error {
+  /** Which refusal this is. */
+  code;
+  /** The bounded FHIRPath locations the refusal is about, in walk order. Never document content. */
+  locations;
+  /**
+   * @param message - A value-free description of the refusal.
+   * @param code - Which refusal this is.
+   * @param locations - The bounded FHIRPath locations it is about.
+   */
+  constructor(message, code, locations) {
+    super(message);
+    this.name = "FhirSerializeError";
+    this.code = code;
+    this.locations = locations;
+  }
 };
-function diagnosticFor(code) {
-  return DIAGNOSTIC_OF[code];
+function assertSerializable(node) {
+  const locations = droppedText(node, rootPath(typeOf(node) ?? "Resource"));
+  if (locations.length === 0) return;
+  throw new FhirSerializeError(
+    `cannot serialize: the reader dropped character data at ${String(locations.length)} location(s), which this model cannot encode`,
+    SERIALIZE_ERROR_CODES.DROPPED_ELEMENT_TEXT,
+    locations
+  );
+}
+function carriesJsonOnlyShape(node) {
+  if (node.kind === "list") return false;
+  if (node.nestedArray === true || node.nestedArraySource !== void 0) return true;
+  if (node.kind === "complex") return node.nonObjectSource !== void 0;
+  return node.undefinedNull === true || node.nonObjectMetaSource !== void 0 || node.nestedArrayMetaSource !== void 0;
+}
+function assertXmlSerializable(node) {
+  const locations = collectMarked(node, rootPath(typeOf(node) ?? "Resource"), carriesJsonOnlyShape);
+  if (locations.length === 0) return;
+  throw new FhirSerializeError(
+    // Says only what this refusal does NOT reach, which is the wording the two refusals beside it
+    // were narrowed to. It deliberately does not promise that `serializeResource` writes the shape
+    // back: it does for every position that writer walks, and a marked node inside a member a
+    // repeated property name shadowed is dropped by it as well.
+    `cannot serialize to XML: ${String(locations.length)} location(s) carry a shape only FHIR JSON can spell, which XML has no channel for; this refusal does not reach serializeResource`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_JSON_ONLY_SHAPE,
+    locations
+  );
+}
+function assertXmlArrayWrapper(node) {
+  const locations = unspellableXmlWrappers(node, rootPath(typeOf(node) ?? "Resource"));
+  if (locations.length === 0) return;
+  throw new FhirSerializeError(
+    // Says what this refusal does not reach, in the wording the three refusals beside it were
+    // narrowed to. `serializeResource` does write these wrappers back -- pinned by the JSON half of
+    // the same test -- with the shadowed-member limit stated in the docblock rather than here.
+    `cannot serialize to XML: ${String(locations.length)} location(s) carry an array wrapper around a 0..1 element that XML has no repeated element to spell back; this refusal does not reach serializeResource`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_ARRAY_WRAPPER,
+    locations
+  );
+}
+function assertXmlValueChoiceWrapper(node) {
+  const locations = unspellableXmlValueChoices(node, rootPath(typeOf(node) ?? "Resource"));
+  if (locations.length === 0) return;
+  throw new FhirSerializeError(
+    // Says what this refusal does not reach, in the wording the refusals beside it were narrowed to.
+    // `serializeResource` writes the wrapper back and the re-read reports the same location, pinned
+    // by the JSON half of the same test.
+    `cannot serialize to XML: ${String(locations.length)} location(s) carry an array wrapper around a 0..1 value[x] choice that XML has no repeated element to spell back; this refusal does not reach serializeResource`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_CHOICE_WRAPPER,
+    locations
+  );
+}
+function assertNoShadowedProperty(node) {
+  const locations = shadowedProperties(node, rootPath(typeOf(node) ?? "Resource"));
+  if (locations.length === 0) return;
+  throw new FhirSerializeError(
+    // Names both writers, because both drop it: there is no route here that keeps the member, and a
+    // message pointing at one would point an operator at a silent drop. That is the wording the four
+    // refusals above were narrowed to, at the one refusal where the answer is "neither".
+    `cannot serialize: ${String(locations.length)} location(s) carry a member a repeated property name shadowed, which neither serializeResource nor serializeResourceXml can write`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_SHADOWED_PROPERTY,
+    locations
+  );
+}
+function lacksTaggableResourceType(node) {
+  if (node.kind !== "complex") return false;
+  const written = node.properties.find((property) => property.name === "resourceType");
+  if (written === void 0) return false;
+  return !(isPrimitive(written.value) && typeof written.value.value === "string");
+}
+function assertXmlResourceType(node) {
+  const elements = collectMarked(
+    node,
+    rootPath(typeOf(node) ?? "Resource"),
+    lacksTaggableResourceType
+  );
+  if (elements.length === 0) return;
+  const locations = elements.map((element) => childPath(element, "resourceType"));
+  throw new FhirSerializeError(
+    // Says what this refusal does not reach, in the wording the refusals beside it were narrowed to.
+    // `serializeResource` emits a non-string `resourceType` through its ordinary path -- pinned by
+    // the JSON half of the same test -- which is a statement about this shape, not about the rest of
+    // the model: that writer's own declared exceptions still apply to everything else it carries.
+    // It does NOT say "while naming the element Resource": that substitution happens at the root,
+    // and this refusal reports depths where the tag comes from the property name instead.
+    `cannot serialize to XML: ${String(locations.length)} location(s) carry a resourceType with no string to name a tag with, which this writer would delete; this refusal does not reach serializeResource`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_RESOURCE_TYPE,
+    locations
+  );
+}
+function assertXmlForeignRoot(node) {
+  const locations = collectMarked(node, rootPath(typeOf(node) ?? "Resource"), isForeignRoot);
+  if (locations.length === 0) return;
+  throw new FhirSerializeError(
+    // Says what this refusal does not reach, in the wording the refusals beside it were narrowed to.
+    // It names no namespace, no tag and no value: the marker it fires on carries none of them, and
+    // the vendor URI is the one piece of document content this whole residual is about.
+    `cannot serialize to XML: ${String(locations.length)} location(s) hold a resource whose root named another vocabulary, which this writer would emit in the FHIR namespace; this refusal does not reach serializeResource`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_FOREIGN_ROOT,
+    locations
+  );
+}
+var TAG_BREAKING = /[ \t\n\r/>=<]/u;
+var TAG_OPENER_STEALING = /* @__PURE__ */ new Set(["!", "?"]);
+function breaksTag(name) {
+  return name === "" || TAG_BREAKING.test(name) || TAG_OPENER_STEALING.has(name.slice(0, 1));
+}
+function refuseUnserializableNames(locations) {
+  throw new FhirSerializeError(
+    `cannot serialize to XML: ${String(locations.length)} location(s) carry a name that cannot be written as an XML tag without changing which elements the document holds; serializeResource escapes a member name, so this refusal never reaches it`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_ELEMENT_NAME,
+    locations
+  );
+}
+function refuseUnserializableDivMarkup(locations) {
+  throw new FhirSerializeError(
+    `cannot serialize to XML: ${String(locations.length)} div location(s) carry markup that would not be written as the one div element the model names; serializeResource carries the string as a string`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_DIV_MARKUP,
+    locations
+  );
+}
+var XML_PREFIX = "xml:";
+function carriesUndeclarablePrefix(name) {
+  if (!name.includes(":")) return false;
+  const local = name.slice(XML_PREFIX.length);
+  return !(name.startsWith(XML_PREFIX) && local !== "" && !local.includes(":"));
+}
+function refuseUndeclarablePrefixes(locations) {
+  throw new FhirSerializeError(
+    `cannot serialize to XML, because ${String(locations.length)} location(s) carry a name with a colon, which XML reads as a namespace prefix and this model carries no binding to declare, so the output would not be namespace-well-formed; this refusal does not reach serializeResource`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_PREFIXED_NAME,
+    locations
+  );
+}
+function refuseUnboundDivPrefixes(locations) {
+  throw new FhirSerializeError(
+    `cannot serialize to XML, because ${String(locations.length)} div location(s) carry markup naming a namespace prefix that no declaration inside the string binds, so the output would not be namespace-well-formed; serializeResource carries the string as a string, so this refusal never reaches it`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_DIV_PREFIX,
+    locations
+  );
+}
+var XML_NAME = /^[:A-Z_a-z\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}][\u{300}-\u{36F}\-.0-9:A-Z_a-z\u{B7}\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}\u{200C}-\u{200D}\u{203F}-\u{2040}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}]*$/u;
+function isXmlName(name) {
+  return XML_NAME.test(name);
+}
+function refuseNonXmlNames(locations) {
+  throw new FhirSerializeError(
+    `cannot serialize to XML, because ${String(locations.length)} location(s) carry a name that is not an XML 1.0 Name, so a conforming XML processor must reject the output; serializeResource escapes a member name, so this refusal never reaches it`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_XML_NAME,
+    locations
+  );
+}
+var NON_XML_CHARACTER = /[^\t\n\r\u{20}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}]/u;
+function carriesNonXmlCharacter(text) {
+  return NON_XML_CHARACTER.test(text);
+}
+function refuseNonXmlCharacters(locations) {
+  throw new FhirSerializeError(
+    `cannot serialize to XML, because ${String(locations.length)} location(s) carry a character outside the XML 1.0 Char production, which a conforming XML processor must reject and which this writer neither escapes, replaces nor drops; this refusal does not reach serializeResource`,
+    SERIALIZE_ERROR_CODES.UNSERIALIZABLE_XML_CHARACTER,
+    locations
+  );
+}
+
+// src/codec/write.ts
+function emitScalar(value) {
+  if (value === void 0) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return value.raw;
+}
+function emitPrimitiveValue(node) {
+  return node.nestedArraySource ?? emitScalar(node.value);
+}
+function hasValue(node) {
+  return node.value !== void 0 || node.nestedArraySource !== void 0 || node.undefinedNull === true;
+}
+function hasMeta(node) {
+  return node.id !== void 0 || node.extension !== void 0 && node.extension.length > 0 || node.nestedArrayMetaSource !== void 0 || node.nonObjectMetaSource !== void 0;
+}
+function emitMeta(node) {
+  if (node.nestedArrayMetaSource !== void 0) return node.nestedArrayMetaSource;
+  if (node.nonObjectMetaSource !== void 0) return node.nonObjectMetaSource;
+  const parts = [];
+  if (node.id !== void 0) parts.push(`"id":${JSON.stringify(node.id)}`);
+  if (node.extension !== void 0 && node.extension.length > 0) {
+    parts.push(`"extension":[${node.extension.map(emitComplex).join(",")}]`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function emitPrimitiveProperty(name, node) {
+  const entries = [];
+  if (hasValue(node)) {
+    entries.push(`${JSON.stringify(name)}:${emitPrimitiveValue(node)}`);
+  }
+  if (hasMeta(node)) {
+    entries.push(`${JSON.stringify(`_${name}`)}:${emitMeta(node)}`);
+  }
+  return entries;
+}
+function emitListProperty(name, node) {
+  if (node.items.length === 0) return [];
+  const allPrimitive = node.items.every(isPrimitive);
+  if (!allPrimitive) {
+    return [`${JSON.stringify(name)}:[${node.items.map(emitNode).join(",")}]`];
+  }
+  const primitives = node.items.filter(isPrimitive);
+  const anyValue = primitives.some(hasValue);
+  const anyMeta = primitives.some(hasMeta);
+  const entries = [];
+  if (anyValue) {
+    const values = primitives.map(emitPrimitiveValue).join(",");
+    entries.push(`${JSON.stringify(name)}:[${values}]`);
+  }
+  if (anyMeta) {
+    const metas = primitives.map((item) => hasMeta(item) ? emitMeta(item) : "null").join(",");
+    entries.push(`${JSON.stringify(`_${name}`)}:[${metas}]`);
+  }
+  return entries;
+}
+function emitNode(node) {
+  switch (node.kind) {
+    case "complex":
+      return emitComplex(node);
+    case "list":
+      return `[${node.items.map(emitNode).join(",")}]`;
+    case "primitive":
+      return emitPrimitiveValue(node);
+  }
 }
-function validationIssue(code, severity, expression, constraint) {
-  const issue = { code, severity, type: ISSUE_TYPE_OF[code], expression };
-  return constraint === void 0 ? issue : { ...issue, constraint };
+function emitComplex(node) {
+  if (node.nestedArraySource !== void 0) return node.nestedArraySource;
+  if (node.nonObjectSource !== void 0) return node.nonObjectSource;
+  const parts = [];
+  const rt = node.properties.find((p) => p.name === "resourceType");
+  const hoisted = rt !== void 0 && isPrimitive(rt.value) && typeof rt.value.value === "string";
+  if (hoisted) parts.push(`"resourceType":${JSON.stringify(rt.value.value)}`);
+  for (const property of node.properties) {
+    if (property.name === "resourceType" && hoisted) {
+      if (isPrimitive(property.value) && hasMeta(property.value)) {
+        parts.push(`"_resourceType":${emitMeta(property.value)}`);
+      }
+      continue;
+    }
+    const value = property.value;
+    switch (value.kind) {
+      case "primitive":
+        parts.push(...emitPrimitiveProperty(property.name, value));
+        break;
+      case "list":
+        parts.push(...emitListProperty(property.name, value));
+        break;
+      case "complex":
+        parts.push(`${JSON.stringify(property.name)}:${emitComplex(value)}`);
+        break;
+    }
+  }
+  return `{${parts.join(",")}}`;
+}
+function serializeResource(node) {
+  assertSerializable(node);
+  assertNoShadowedProperty(node);
+  return emitComplex(node);
 }
 
 // src/validate/operation-outcome.ts
@@ -2380,14 +3045,26 @@ function issueNode(issue) {
     { name: "diagnostics", value: primitive(diagnosticFor(issue.code)) },
     { name: "expression", value: list([primitive(issue.expression)]) }
   ];
-  if (issue.constraint !== void 0) {
-    properties.splice(3, 0, {
-      name: "details",
-      value: complex([{ name: "text", value: primitive(issue.constraint) }])
-    });
-  }
+  const details = detailsNode(issue);
+  if (details !== void 0) properties.splice(3, 0, { name: "details", value: details });
   return complex(properties);
 }
+function detailsNode(issue) {
+  const members = [];
+  const record = issue.codeSystemVersion;
+  if (record !== void 0) members.push({ name: "coding", value: list([recordCoding(record)]) });
+  let text = issue.constraint;
+  if (record !== void 0) text = record.declared ? record.version : void 0;
+  if (text !== void 0) members.push({ name: "text", value: primitive(text) });
+  return members.length === 0 ? void 0 : complex(members);
+}
+function recordCoding(record) {
+  const marker = record.declared ? CODE_SYSTEM_VERSION_RECORD_CODES.DECLARED : CODE_SYSTEM_VERSION_RECORD_CODES.UNDECLARED;
+  return complex([
+    { name: "system", value: primitive(CODE_SYSTEM_VERSION_RECORD_SYSTEM) },
+    { name: "code", value: primitive(marker) }
+  ]);
+}
 function allClearNode() {
   return complex([
     { name: "severity", value: primitive(ISSUE_SEVERITIES.INFORMATION) },
@@ -2741,76 +3418,6 @@ function collectBundleIssues(resource) {
   return issues;
 }
 
-// src/quantity/ucum.ts
-var UCUM_SYSTEM = "http://unitsofmeasure.org";
-var LOINC_SYSTEM = "http://loinc.org";
-var OBSERVATION_CATEGORY_SYSTEM = "http://terminology.hl7.org/CodeSystem/observation-category";
-var VITAL_SIGNS_CATEGORY = "vital-signs";
-var VITAL_SIGNS_PROFILE = "http://hl7.org/fhir/StructureDefinition/vitalsigns";
-var VITAL_SIGN_UNITS = /* @__PURE__ */ new Map([
-  ["29463-7", ["g", "kg", "[lb_av]"]],
-  // Body weight
-  ["8302-2", ["cm", "[in_i]"]],
-  // Body height
-  ["8306-3", ["cm", "[in_i]"]],
-  // Body height (lying) / body length
-  ["8287-5", ["cm", "[in_i]"]],
-  // Head circumference (Occipital-frontal, by tape)
-  ["9843-4", ["cm", "[in_i]"]],
-  // Head circumference
-  ["8310-5", ["Cel", "[degF]"]],
-  // Body temperature
-  ["8867-4", ["/min"]],
-  // Heart rate
-  ["9279-1", ["/min"]],
-  // Respiratory rate
-  ["8480-6", ["mm[Hg]"]],
-  // Systolic blood pressure
-  ["8462-4", ["mm[Hg]"]],
-  // Diastolic blood pressure
-  ["2708-6", ["%"]],
-  // Oxygen saturation in Arterial blood
-  ["59408-5", ["%"]],
-  // Oxygen saturation (SpO2) by pulse oximetry
-  ["39156-5", ["kg/m2"]]
-  // Body mass index
-]);
-function requiredVitalSignUnits(loincCode) {
-  return VITAL_SIGN_UNITS.get(loincCode);
-}
-function decimalValue(node) {
-  if (node === void 0 || !isPrimitive(node)) return void 0;
-  const { value } = node;
-  if (typeof value === "object") return value;
-  return typeof value === "string" ? decimalFromLexical(value) : void 0;
-}
-function readQuantity(node) {
-  if (node === void 0 || node.kind !== "complex") return void 0;
-  const q = node;
-  return {
-    value: decimalValue(getProperty(q, "value")),
-    comparator: primitiveString(getProperty(q, "comparator")),
-    unit: primitiveString(getProperty(q, "unit")),
-    system: primitiveString(getProperty(q, "system")),
-    code: primitiveString(getProperty(q, "code"))
-  };
-}
-function validateUcumShape(code) {
-  if (code.length === 0) return "invalid";
-  const skeleton = code.replace(/\{[^{}]*\}/g, "");
-  if (skeleton.includes("{") || skeleton.includes("}")) return "invalid";
-  if (/\s/.test(skeleton)) return "invalid";
-  const pairs = { "]": "[", ")": "(" };
-  const stack = [];
-  for (const ch of skeleton) {
-    if (ch === "[" || ch === "(") stack.push(ch);
-    else if (ch === "]" || ch === ")") {
-      if (stack.pop() !== pairs[ch]) return "invalid";
-    }
-  }
-  return stack.length === 0 ? "ok" : "invalid";
-}
-
 // src/quantity/dose.ts
 function dosageProperty(rt) {
   if (rt === "MedicationRequest") return "dosageInstruction";
@@ -2851,60 +3458,6 @@ function readMedicationDoses(resource, rt) {
   return doses;
 }
 
-// src/quantity/value.ts
-var OBSERVATION_VALUE_TYPES = [
-  "Quantity",
-  "CodeableConcept",
-  "String",
-  "Boolean",
-  "Integer",
-  "Range",
-  "Ratio",
-  "SampledData",
-  "Time",
-  "DateTime",
-  "Period"
-];
-function presentValues(node) {
-  const byName = new Map(node.properties.map((p) => [p.name, p.value]));
-  const out = [];
-  for (const type of OBSERVATION_VALUE_TYPES) {
-    const value = byName.get(`value${type}`);
-    if (value !== void 0) out.push({ type, node: value });
-  }
-  return out;
-}
-function readObservationValue(node) {
-  const [first, ...rest] = presentValues(node);
-  if (first === void 0) return void 0;
-  return {
-    type: first.type,
-    property: `value${first.type}`,
-    node: first.node,
-    quantity: first.type === "Quantity" ? readQuantity(first.node) : void 0,
-    ambiguous: rest.map((r) => r.type)
-  };
-}
-function readReferenceRanges(observation) {
-  const node = getProperty(observation, "referenceRange");
-  if (node === void 0) return [];
-  const items = isList(node) ? node.items : [node];
-  const ranges = [];
-  for (const item of items) {
-    if (item.kind !== "complex") continue;
-    ranges.push({
-      low: readQuantity(getProperty(item, "low")),
-      high: readQuantity(getProperty(item, "high")),
-      type: codingsOf(getProperty(item, "type")),
-      text: primitiveString(getProperty(item, "text"))
-    });
-  }
-  return ranges;
-}
-function readInterpretations(observation) {
-  return codingsOf(getProperty(observation, "interpretation"));
-}
-
 // src/validate/quantity.ts
 function collectQuantityIssues(resource, rt) {
   const issues = [];
@@ -2914,13 +3467,14 @@ function collectQuantityIssues(resource, rt) {
     forEachComponent(resource, (component, path) => {
       checkValueChoice(component, path, vital, issues);
     });
-    return issues;
-  }
-  if (rt === "MedicationRequest" || rt === "MedicationStatement") {
+  } else if (rt === "MedicationRequest" || rt === "MedicationStatement") {
     for (const { node, path } of locateDoseQuantities(resource, rt)) {
       checkUcumShape(readQuantity(node), path, issues);
     }
   }
+  for (const location of arrayWrappedValueChoices(resource, rootPath(rt))) {
+    issues.push(validationIssue("ARRAY_WRAPPED_CHOICE", ISSUE_SEVERITIES.ERROR, location));
+  }
   return issues;
 }
 function isVitalSign(observation) {
@@ -3155,13 +3709,13 @@ function buildBindingRegistry(extra = []) {
 
 // src/validate/terminology.ts
 function collectTerminologyIssues(resource, rt, options = {}) {
-  const registry = buildBindingRegistry(options.bindings ?? []);
+  const registry2 = buildBindingRegistry(options.bindings ?? []);
   const service = options.terminology;
   const issues = [];
   const root = rootPath(rt);
   for (const property of resource.properties) {
     if (property.name === "resourceType") continue;
-    const binding = registry(`${rt}.${property.name}`);
+    const binding = registry2(`${rt}.${property.name}`);
     if (binding === void 0) continue;
     for (const coding of locatedCodings(property.value, childPath(root, property.name))) {
       checkCoding(coding, binding, service, issues);
@@ -3213,13 +3767,20 @@ function checkCoding(coding, binding, service, issues) {
     return;
   }
   if (service === void 0 || code === void 0) return;
-  const { membership: membership2 } = service.validateCode({ valueSet: binding.valueSet, system, code });
-  if (membership2 !== "not-in") return;
+  const answer = service.validateCode({ valueSet: binding.valueSet, system, code });
+  if (answer.membership !== "not-in") return;
   const severity = notInSeverity(binding.strength);
   if (severity !== void 0) {
-    issues.push(validationIssue("CODE_NOT_IN_VALUESET", severity, path));
+    issues.push(
+      validationIssue("CODE_NOT_IN_VALUESET", severity, path, void 0, declaredRelease(answer))
+    );
   }
 }
+function declaredRelease(answer) {
+  const declared = answer.systemVersion;
+  if (typeof declared !== "string" || declared.trim() === "") return { declared: false };
+  return { declared: true, version: declared };
+}
 function systemUnexpectedSeverity(strength) {
   switch (strength) {
     case "required":
@@ -3337,11 +3898,249 @@ var OBSERVATION_ELEMENTS = {
   referenceRange: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] },
   hasMember: { min: 0, max: UNBOUNDED, types: ["Reference"] },
   derivedFrom: { min: 0, max: UNBOUNDED, types: ["Reference"] },
-  component: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] }
+  component: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] }
+};
+var DIAGNOSTIC_REPORT_STATUS = [
+  "registered",
+  "partial",
+  "preliminary",
+  "final",
+  "amended",
+  "corrected",
+  "appended",
+  "cancelled",
+  "entered-in-error",
+  "unknown"
+];
+var DIAGNOSTIC_REPORT_ELEMENTS = {
+  identifier: { min: 0, max: UNBOUNDED, types: ["Identifier"] },
+  basedOn: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  status: {
+    min: 1,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...DIAGNOSTIC_REPORT_STATUS] }
+  },
+  category: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  code: { min: 1, max: 1, types: ["CodeableConcept"] },
+  subject: { min: 0, max: 1, types: ["Reference"] },
+  encounter: { min: 0, max: 1, types: ["Reference"] },
+  effective: { min: 0, max: 1, types: ["dateTime", "Period"] },
+  issued: { min: 0, max: 1, types: ["instant"] },
+  performer: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  resultsInterpreter: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  specimen: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  result: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  imagingStudy: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  media: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] },
+  conclusion: { min: 0, max: 1, types: ["string"] },
+  conclusionCode: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  presentedForm: { min: 0, max: UNBOUNDED, types: ["Attachment"] }
+};
+var CONDITION_ELEMENTS = {
+  identifier: { min: 0, max: UNBOUNDED, types: ["Identifier"] },
+  clinicalStatus: { min: 0, max: 1, types: ["CodeableConcept"] },
+  verificationStatus: { min: 0, max: 1, types: ["CodeableConcept"] },
+  category: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  severity: { min: 0, max: 1, types: ["CodeableConcept"] },
+  code: { min: 0, max: 1, types: ["CodeableConcept"] },
+  bodySite: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  subject: { min: 1, max: 1, types: ["Reference"] },
+  encounter: { min: 0, max: 1, types: ["Reference"] },
+  onset: { min: 0, max: 1, types: ["dateTime", "Age", "Period", "Range", "string"] },
+  abatement: { min: 0, max: 1, types: ["dateTime", "Age", "Period", "Range", "string"] },
+  recordedDate: { min: 0, max: 1, types: ["dateTime"] },
+  recorder: { min: 0, max: 1, types: ["Reference"] },
+  asserter: { min: 0, max: 1, types: ["Reference"] },
+  stage: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] },
+  evidence: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] },
+  note: { min: 0, max: UNBOUNDED, types: ["Annotation"] }
+};
+var MEDICATION_REQUEST_STATUS = [
+  "active",
+  "on-hold",
+  "cancelled",
+  "completed",
+  "entered-in-error",
+  "stopped",
+  "draft",
+  "unknown"
+];
+var MEDICATION_REQUEST_INTENT = [
+  "proposal",
+  "plan",
+  "order",
+  "original-order",
+  "reflex-order",
+  "filler-order",
+  "instance-order",
+  "option"
+];
+var REQUEST_PRIORITY = ["routine", "urgent", "asap", "stat"];
+var MEDICATION_REQUEST_ELEMENTS = {
+  identifier: { min: 0, max: UNBOUNDED, types: ["Identifier"] },
+  status: {
+    min: 1,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...MEDICATION_REQUEST_STATUS] }
+  },
+  statusReason: { min: 0, max: 1, types: ["CodeableConcept"] },
+  intent: {
+    min: 1,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...MEDICATION_REQUEST_INTENT] }
+  },
+  category: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  priority: {
+    min: 0,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...REQUEST_PRIORITY] }
+  },
+  doNotPerform: { min: 0, max: 1, types: ["boolean"] },
+  reported: { min: 0, max: 1, types: ["boolean", "Reference"] },
+  medication: { min: 1, max: 1, types: ["CodeableConcept", "Reference"] },
+  subject: { min: 1, max: 1, types: ["Reference"] },
+  encounter: { min: 0, max: 1, types: ["Reference"] },
+  supportingInformation: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  authoredOn: { min: 0, max: 1, types: ["dateTime"] },
+  requester: { min: 0, max: 1, types: ["Reference"] },
+  performer: { min: 0, max: 1, types: ["Reference"] },
+  performerType: { min: 0, max: 1, types: ["CodeableConcept"] },
+  recorder: { min: 0, max: 1, types: ["Reference"] },
+  reasonCode: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  reasonReference: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  instantiatesCanonical: { min: 0, max: UNBOUNDED, types: ["canonical"] },
+  instantiatesUri: { min: 0, max: UNBOUNDED, types: ["uri"] },
+  basedOn: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  groupIdentifier: { min: 0, max: 1, types: ["Identifier"] },
+  courseOfTherapyType: { min: 0, max: 1, types: ["CodeableConcept"] },
+  insurance: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  note: { min: 0, max: UNBOUNDED, types: ["Annotation"] },
+  dosageInstruction: { min: 0, max: UNBOUNDED, types: ["Dosage"] },
+  dispenseRequest: { min: 0, max: 1, types: ["BackboneElement"] },
+  substitution: { min: 0, max: 1, types: ["BackboneElement"] },
+  priorPrescription: { min: 0, max: 1, types: ["Reference"] },
+  detectedIssue: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  eventHistory: { min: 0, max: UNBOUNDED, types: ["Reference"] }
+};
+var ALLERGY_INTOLERANCE_TYPE = ["allergy", "intolerance"];
+var ALLERGY_INTOLERANCE_CATEGORY = ["food", "medication", "environment", "biologic"];
+var ALLERGY_INTOLERANCE_CRITICALITY = ["low", "high", "unable-to-assess"];
+var ALLERGY_INTOLERANCE_ELEMENTS = {
+  identifier: { min: 0, max: UNBOUNDED, types: ["Identifier"] },
+  clinicalStatus: { min: 0, max: 1, types: ["CodeableConcept"] },
+  verificationStatus: { min: 0, max: 1, types: ["CodeableConcept"] },
+  type: {
+    min: 0,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...ALLERGY_INTOLERANCE_TYPE] }
+  },
+  category: {
+    min: 0,
+    max: UNBOUNDED,
+    types: ["code"],
+    binding: { strength: "required", codes: [...ALLERGY_INTOLERANCE_CATEGORY] }
+  },
+  criticality: {
+    min: 0,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...ALLERGY_INTOLERANCE_CRITICALITY] }
+  },
+  code: { min: 0, max: 1, types: ["CodeableConcept"] },
+  patient: { min: 1, max: 1, types: ["Reference"] },
+  encounter: { min: 0, max: 1, types: ["Reference"] },
+  onset: { min: 0, max: 1, types: ["dateTime", "Age", "Period", "Range", "string"] },
+  recordedDate: { min: 0, max: 1, types: ["dateTime"] },
+  recorder: { min: 0, max: 1, types: ["Reference"] },
+  asserter: { min: 0, max: 1, types: ["Reference"] },
+  lastOccurrence: { min: 0, max: 1, types: ["dateTime"] },
+  note: { min: 0, max: UNBOUNDED, types: ["Annotation"] },
+  reaction: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] }
+};
+var IMMUNIZATION_STATUS = ["completed", "entered-in-error", "not-done"];
+var IMMUNIZATION_ELEMENTS = {
+  identifier: { min: 0, max: UNBOUNDED, types: ["Identifier"] },
+  status: {
+    min: 1,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...IMMUNIZATION_STATUS] }
+  },
+  statusReason: { min: 0, max: 1, types: ["CodeableConcept"] },
+  vaccineCode: { min: 1, max: 1, types: ["CodeableConcept"] },
+  patient: { min: 1, max: 1, types: ["Reference"] },
+  encounter: { min: 0, max: 1, types: ["Reference"] },
+  occurrence: { min: 1, max: 1, types: ["dateTime", "string"] },
+  recorded: { min: 0, max: 1, types: ["dateTime"] },
+  primarySource: { min: 0, max: 1, types: ["boolean"] },
+  reportOrigin: { min: 0, max: 1, types: ["CodeableConcept"] },
+  location: { min: 0, max: 1, types: ["Reference"] },
+  manufacturer: { min: 0, max: 1, types: ["Reference"] },
+  lotNumber: { min: 0, max: 1, types: ["string"] },
+  expirationDate: { min: 0, max: 1, types: ["date"] },
+  site: { min: 0, max: 1, types: ["CodeableConcept"] },
+  route: { min: 0, max: 1, types: ["CodeableConcept"] },
+  doseQuantity: { min: 0, max: 1, types: ["Quantity"] },
+  performer: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] },
+  note: { min: 0, max: UNBOUNDED, types: ["Annotation"] },
+  reasonCode: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  reasonReference: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  isSubpotent: { min: 0, max: 1, types: ["boolean"] },
+  subpotentReason: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  education: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] },
+  programEligibility: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  fundingSource: { min: 0, max: 1, types: ["CodeableConcept"] },
+  reaction: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] },
+  protocolApplied: { min: 0, max: UNBOUNDED, types: ["BackboneElement"] }
+};
+var MEDICATION_STATEMENT_STATUS = [
+  "active",
+  "completed",
+  "entered-in-error",
+  "intended",
+  "stopped",
+  "on-hold",
+  "unknown",
+  "not-taken"
+];
+var MEDICATION_STATEMENT_ELEMENTS = {
+  identifier: { min: 0, max: UNBOUNDED, types: ["Identifier"] },
+  basedOn: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  partOf: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  status: {
+    min: 1,
+    max: 1,
+    types: ["code"],
+    binding: { strength: "required", codes: [...MEDICATION_STATEMENT_STATUS] }
+  },
+  statusReason: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  category: { min: 0, max: 1, types: ["CodeableConcept"] },
+  medication: { min: 1, max: 1, types: ["CodeableConcept", "Reference"] },
+  subject: { min: 1, max: 1, types: ["Reference"] },
+  context: { min: 0, max: 1, types: ["Reference"] },
+  effective: { min: 0, max: 1, types: ["dateTime", "Period"] },
+  dateAsserted: { min: 0, max: 1, types: ["dateTime"] },
+  informationSource: { min: 0, max: 1, types: ["Reference"] },
+  derivedFrom: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  reasonCode: { min: 0, max: UNBOUNDED, types: ["CodeableConcept"] },
+  reasonReference: { min: 0, max: UNBOUNDED, types: ["Reference"] },
+  note: { min: 0, max: UNBOUNDED, types: ["Annotation"] },
+  dosage: { min: 0, max: UNBOUNDED, types: ["Dosage"] }
 };
 var BUILTIN_SCHEMAS = [
   { type: "Patient", elements: PATIENT_ELEMENTS },
-  { type: "Observation", elements: OBSERVATION_ELEMENTS }
+  { type: "Observation", elements: OBSERVATION_ELEMENTS },
+  { type: "DiagnosticReport", elements: DIAGNOSTIC_REPORT_ELEMENTS },
+  { type: "Condition", elements: CONDITION_ELEMENTS },
+  { type: "MedicationRequest", elements: MEDICATION_REQUEST_ELEMENTS },
+  { type: "AllergyIntolerance", elements: ALLERGY_INTOLERANCE_ELEMENTS },
+  { type: "Immunization", elements: IMMUNIZATION_ELEMENTS },
+  { type: "MedicationStatement", elements: MEDICATION_STATEMENT_ELEMENTS }
 ];
 function withBase(schema) {
   return { type: schema.type, elements: { ...BASE_ELEMENTS, ...schema.elements } };
@@ -3750,6 +4549,370 @@ var UnsupportedFhirPathError = class extends Error {
   }
 };
 
+// src/fhirpath/matches.ts
+var META = /* @__PURE__ */ new Set([
+  "\\",
+  "^",
+  "$",
+  ".",
+  "|",
+  "?",
+  "*",
+  "+",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}"
+]);
+var CLASS_ESCAPABLE = /* @__PURE__ */ new Set(["\\", "]", "[", "-", "^"]);
+var MAX_REPEAT = 1e3;
+function refuse() {
+  throw new UnsupportedFhirPathError("matches() pattern outside the portable subset");
+}
+var PatternCheck = class {
+  constructor(chars) {
+    this.chars = chars;
+  }
+  chars;
+  pos = 0;
+  run() {
+    this.alternation();
+    if (this.pos !== this.chars.length) refuse();
+  }
+  peek() {
+    return this.chars[this.pos];
+  }
+  alternation() {
+    let shape = this.sequence();
+    let alternates = false;
+    while (this.peek() === "|") {
+      this.pos += 1;
+      alternates = true;
+      const next = this.sequence();
+      shape = { quantified: shape.quantified || next.quantified, alternates: true };
+    }
+    return { quantified: shape.quantified, alternates: alternates || shape.alternates };
+  }
+  sequence() {
+    let quantified = false;
+    let alternates = false;
+    for (let c = this.peek(); c !== void 0 && c !== "|" && c !== ")"; c = this.peek()) {
+      if (c === "^" || c === "$") {
+        this.pos += 1;
+        if (this.isQuantifierStart()) refuse();
+        continue;
+      }
+      const atom = this.atom();
+      if (this.isQuantifierStart()) {
+        if (atom.quantified || atom.alternates) refuse();
+        this.quantifier();
+        quantified = true;
+      }
+      quantified ||= atom.quantified;
+      alternates ||= atom.alternates;
+    }
+    return { quantified, alternates };
+  }
+  isQuantifierStart() {
+    const c = this.peek();
+    return c === "*" || c === "+" || c === "?" || c === "{";
+  }
+  atom() {
+    const c = this.peek();
+    if (c === void 0) refuse();
+    if (c === "(") {
+      this.pos += 1;
+      if (this.peek() === "?") refuse();
+      const inner = this.alternation();
+      if (this.peek() !== ")") refuse();
+      this.pos += 1;
+      return inner;
+    }
+    if (c === "[") {
+      this.characterClass();
+      return { quantified: false, alternates: false };
+    }
+    if (c === "\\") {
+      const escaped = this.chars[this.pos + 1];
+      if (escaped === void 0 || !(META.has(escaped) || escaped === "/")) refuse();
+      this.pos += 2;
+      return { quantified: false, alternates: false };
+    }
+    if (c === ".") {
+      this.pos += 1;
+      return { quantified: false, alternates: false };
+    }
+    if (META.has(c)) refuse();
+    this.pos += 1;
+    return { quantified: false, alternates: false };
+  }
+  quantifier() {
+    const c = this.peek();
+    this.pos += 1;
+    if (c === "{") {
+      const low = this.count();
+      let high = low;
+      if (this.peek() === ",") {
+        this.pos += 1;
+        high = this.peek() === "}" ? MAX_REPEAT : this.count();
+      }
+      if (this.peek() !== "}" || high < low) refuse();
+      this.pos += 1;
+    }
+    if (this.isQuantifierStart()) refuse();
+  }
+  count() {
+    let digits = "";
+    for (let c = this.peek(); c !== void 0 && c >= "0" && c <= "9"; c = this.peek()) {
+      digits += c;
+      this.pos += 1;
+    }
+    const value = digits === "" ? Number.NaN : Number(digits);
+    if (!(value <= MAX_REPEAT)) refuse();
+    return value;
+  }
+  characterClass() {
+    this.pos += 1;
+    if (this.peek() === "^") this.pos += 1;
+    let members = 0;
+    while (this.peek() !== "]") {
+      this.classCharacter();
+      if (this.peek() === "-" && this.chars[this.pos + 1] !== "]") {
+        this.pos += 1;
+        this.classCharacter();
+      }
+      members += 1;
+    }
+    if (members === 0) refuse();
+    this.pos += 1;
+  }
+  classCharacter() {
+    const c = this.peek();
+    if (c === void 0 || c === "[" || c === "-") refuse();
+    if (c === "&" && this.chars[this.pos + 1] === "&") refuse();
+    if (c === "\\") {
+      const escaped = this.chars[this.pos + 1];
+      if (escaped === void 0 || !CLASS_ESCAPABLE.has(escaped)) refuse();
+      this.pos += 2;
+      return;
+    }
+    this.pos += 1;
+  }
+};
+function compileMatchesPattern(pattern) {
+  new PatternCheck([...pattern]).run();
+  try {
+    return new RegExp(pattern, "su");
+  } catch {
+    return refuse();
+  }
+}
+
+// src/fhirpath/types.ts
+var FHIR_PRIMITIVES = /* @__PURE__ */ new Set([
+  "boolean",
+  "integer",
+  "string",
+  "decimal",
+  "uri",
+  "url",
+  "canonical",
+  "base64Binary",
+  "instant",
+  "date",
+  "dateTime",
+  "time",
+  "code",
+  "oid",
+  "id",
+  "markdown",
+  "unsignedInt",
+  "positiveInt",
+  "uuid"
+]);
+var FHIR_COMPLEX = /* @__PURE__ */ new Set([
+  "Address",
+  "Age",
+  "Annotation",
+  "Attachment",
+  "CodeableConcept",
+  "Coding",
+  "ContactPoint",
+  "Count",
+  "Distance",
+  "Duration",
+  "Extension",
+  "HumanName",
+  "Identifier",
+  "Money",
+  "Narrative",
+  "Period",
+  "Quantity",
+  "Range",
+  "Ratio",
+  "Reference",
+  "SampledData",
+  "Signature",
+  "Timing"
+]);
+var SPECIALIZES = /* @__PURE__ */ new Map([
+  ["Age", "Quantity"],
+  ["Count", "Quantity"],
+  ["Distance", "Quantity"],
+  ["Duration", "Quantity"]
+]);
+var FHIR_ABSTRACT = /* @__PURE__ */ new Set(["Resource"]);
+var SYSTEM_TYPES = /* @__PURE__ */ new Set([
+  "Boolean",
+  "String",
+  "Integer",
+  "Decimal",
+  "Date",
+  "DateTime",
+  "Time",
+  "Quantity"
+]);
+var registry;
+function tables() {
+  registry ??= buildRegistry();
+  return registry;
+}
+function fhirKind(name) {
+  if (FHIR_PRIMITIVES.has(name)) return "primitive";
+  if (FHIR_COMPLEX.has(name)) return "complex";
+  if (FHIR_ABSTRACT.has(name)) return "abstract";
+  if (tables()(name) !== void 0) return "resource";
+  return void 0;
+}
+function resolveTypeSpecifier(specifier) {
+  const dot = specifier.indexOf(".");
+  if (dot >= 0) {
+    const model = specifier.slice(0, dot);
+    const name = specifier.slice(dot + 1);
+    if (model === "FHIR" && fhirKind(name) !== void 0) return { model, name };
+    if (model === "System" && SYSTEM_TYPES.has(name)) return { model, name };
+    return void 0;
+  }
+  if (fhirKind(specifier) !== void 0) return { model: "FHIR", name: specifier };
+  if (SYSTEM_TYPES.has(specifier)) return { model: "System", name: specifier };
+  return void 0;
+}
+function typeSpecifierOf(arg) {
+  const names = [];
+  let at = arg;
+  while (at !== null) {
+    if (at.kind !== "member") return void 0;
+    names.unshift(at.name);
+    at = at.target;
+  }
+  return names.join(".");
+}
+var POSITIONS = /* @__PURE__ */ new WeakMap();
+function positionsIn(resource) {
+  const cached = POSITIONS.get(resource);
+  if (cached !== void 0) return cached;
+  const out = /* @__PURE__ */ new Map();
+  const pending = [resource];
+  const seen = /* @__PURE__ */ new Set([resource]);
+  const record = (value, parent, property, inList) => {
+    if (isList(value)) {
+      for (const item of value.items) record(item, parent, property, true);
+      return;
+    }
+    const list2 = out.get(value);
+    if (list2 === void 0) out.set(value, [{ parent, property, inList }]);
+    else list2.push({ parent, property, inList });
+    if (!seen.has(value)) {
+      seen.add(value);
+      pending.push(value);
+    }
+  };
+  for (let node = pending.pop(); node !== void 0; node = pending.pop()) {
+    if (isComplex(node)) {
+      for (const p of node.properties) record(p.value, node, p.name, false);
+      for (const p of node.duplicates ?? []) record(p.value, node, p.name, false);
+    } else if (isPrimitive(node)) {
+      for (const ext of node.extension ?? []) record(ext, node, "extension", true);
+    }
+  }
+  POSITIONS.set(resource, out);
+  return out;
+}
+function suffixContradicts(property, node) {
+  for (let i = 1; i < property.length; i += 1) {
+    const first = property.charAt(i);
+    if (first < "A" || first > "Z") continue;
+    const suffix = property.slice(i);
+    const kind = fhirKind(suffix);
+    if (isPrimitive(node) && (kind === "complex" || kind === "resource")) return true;
+    if (isComplex(node) && FHIR_PRIMITIVES.has(first.toLowerCase() + suffix.slice(1))) return true;
+  }
+  return false;
+}
+function choiceVariantType(position, resource) {
+  if (position.inList || position.parent !== resource || !isComplex(resource)) return void 0;
+  const type = resourceType(resource);
+  const schema = type === void 0 ? void 0 : tables()(type);
+  if (schema === void 0) return void 0;
+  const resolved = resolveElement(schema.elements, position.property);
+  if (resolved === void 0 || !isChoice(resolved.element)) return void 0;
+  return resolved.datatype;
+}
+function establishedType(node, resource) {
+  const positions = positionsIn(resource).get(node) ?? [];
+  if (node === resource) {
+    if (positions.length > 0 || !isComplex(node)) return void 0;
+    const type = resourceType(node);
+    return type !== void 0 && fhirKind(type) === "resource" ? type : void 0;
+  }
+  let established;
+  for (const position of positions) {
+    const type = choiceVariantType(position, resource);
+    if (type === void 0 || established !== void 0 && established !== type) {
+      return void 0;
+    }
+    established = type;
+  }
+  return established;
+}
+function isOfType(actual, tested) {
+  if (actual === tested) return true;
+  const actualKind = fhirKind(actual);
+  const testedKind = fhirKind(tested);
+  if (actualKind === void 0 || testedKind === void 0 || testedKind === "abstract") {
+    throw new UnsupportedFhirPathError("type test between types this engine cannot relate");
+  }
+  if (actualKind === "primitive" || testedKind === "primitive") {
+    throw new UnsupportedFhirPathError("type test between two different FHIR primitive types");
+  }
+  return SPECIALIZES.get(actual) === tested;
+}
+function nodeIsOfType(node, type, resource) {
+  if (isList(node)) throw new UnsupportedFhirPathError("type test on a repeating element");
+  const positions = positionsIn(resource).get(node) ?? [];
+  if (positions.some((p) => suffixContradicts(p.property, node))) {
+    throw new UnsupportedFhirPathError(
+      "type test on an element whose property name contradicts its shape"
+    );
+  }
+  if (type.model === "System") {
+    if (isComplex(node)) return false;
+    throw new UnsupportedFhirPathError(`type test '${type.name}' on a model primitive`);
+  }
+  const kind = fhirKind(type.name);
+  if (isPrimitive(node) && kind !== "primitive") return false;
+  if (isComplex(node) && kind === "primitive") return false;
+  const actual = establishedType(node, resource);
+  if (actual === void 0) {
+    throw new UnsupportedFhirPathError(
+      "type test on an element whose type the instance does not establish"
+    );
+  }
+  return isOfType(actual, type.name);
+}
+
 // src/fhirpath/evaluate.ts
 function wrap(node) {
   if (isList(node)) return node.items.flatMap(wrap);
@@ -3843,7 +5006,12 @@ function childrenOf(item) {
     return item.node.properties.filter((p) => p.name !== "resourceType").flatMap((p) => wrap(p.value));
   }
   if (isPrimitive(item.node)) {
-    return (item.node.extension ?? []).map((ext) => ({ t: "node", node: ext }));
+    const id = item.node.id === void 0 ? [] : [{ t: "str", value: item.node.id }];
+    const extensions = (item.node.extension ?? []).map((ext) => ({
+      t: "node",
+      node: ext
+    }));
+    return [...id, ...extensions];
   }
   return [];
 }
@@ -3996,28 +5164,114 @@ function systemTypeOf(item) {
   return void 0;
 }
 var SYSTEM_TYPE_NAMES = /* @__PURE__ */ new Set(["Boolean", "String", "Integer", "Decimal"]);
-function itemIsType(item, typeName) {
-  const normalized = typeName.replace(/^System\./, "");
-  if (!SYSTEM_TYPE_NAMES.has(normalized)) {
-    throw new UnsupportedFhirPathError(
-      `type test '${typeName}' outside the System primitive types`
-    );
-  }
-  const actual = systemTypeOf(item);
-  if (actual === void 0) {
-    throw new UnsupportedFhirPathError(`type test '${typeName}' on a non-System value`);
-  }
-  if (normalized === "Decimal" && actual === "Integer") return true;
-  return actual === normalized;
+function itemIsType(item, typeName, ctx) {
+  const resolved = resolveTypeSpecifier(typeName);
+  const complexNode = item.t === "node" && isComplex(item.node);
+  if (resolved?.model === "System" && SYSTEM_TYPE_NAMES.has(resolved.name) && !complexNode) {
+    const actual = systemTypeOf(item);
+    if (actual === void 0) {
+      throw new UnsupportedFhirPathError(`type test '${typeName}' on a non-System value`);
+    }
+    if (resolved.name === "Decimal" && actual === "Integer") return true;
+    return actual === resolved.name;
+  }
+  return fhirTypeTest(item, typeName, resolved, ctx);
+}
+function fhirTypeTest(item, typeName, resolved, ctx) {
+  if (resolved === void 0) {
+    throw new UnsupportedFhirPathError(`type test '${typeName}' names no known type`);
+  }
+  if (item.t !== "node") {
+    throw new UnsupportedFhirPathError(`type test '${typeName}' on a computed value`);
+  }
+  return nodeIsOfType(item.node, resolved, ctx.resource);
+}
+function functionFormTypeTest(input, arg, construct, ctx) {
+  const typeName = typeNameOf(req(arg));
+  const resolved = resolveTypeSpecifier(typeName);
+  if (resolved === void 0) {
+    throw new UnsupportedFhirPathError(`type test '${typeName}' names no known type`);
+  }
+  if (input.length === 0) return "empty";
+  const item = singleItem(input, construct);
+  if (resolved.model === "System" && !(item.t === "node" && isComplex(item.node))) {
+    throw new UnsupportedFhirPathError(`function-form type test '${typeName}' on a primitive`);
+  }
+  return fhirTypeTest(item, typeName, resolved, ctx) ? item : void 0;
+}
+function ofTypeKeeps(item, arg, ctx) {
+  const typeName = typeNameOf(arg);
+  const qualified = arg.kind === "member" && arg.target !== null;
+  const complexNode = item.t === "node" && isComplex(item.node);
+  if (qualified && resolveTypeSpecifier(typeName)?.model === "System" && !complexNode) {
+    throw new UnsupportedFhirPathError(`qualified type test '${typeName}' on a primitive`);
+  }
+  return itemIsType(item, typeName, ctx);
+}
+function singleItem(input, construct) {
+  if (input.length !== 1) {
+    throw new UnsupportedFhirPathError(`${construct} over more than one item`);
+  }
+  return input[0];
+}
+function applyMatches(input, args, callFocus, ctx) {
+  if (input.length === 0) return [];
+  const patternColl = evaluate(req(args[0]), callFocus, ctx);
+  if (patternColl.length === 0) return [];
+  const value = stringOf2(singleItem(input, "matches()"));
+  if (value === void 0) throw new UnsupportedFhirPathError("matches() on a non-string value");
+  const pattern = patternColl.length === 1 ? stringOf2(patternColl[0]) : void 0;
+  if (pattern === void 0)
+    throw new UnsupportedFhirPathError("matches() needs one string pattern");
+  return [{ t: "bool", value: compileMatchesPattern(pattern).test(value) }];
 }
 function typeNameOf(arg) {
-  if (arg.kind === "member" && arg.target === null) return arg.name;
-  throw new UnsupportedFhirPathError("expected a type name argument");
+  const specifier = typeSpecifierOf(arg);
+  if (specifier === void 0) throw new UnsupportedFhirPathError("expected a type name argument");
+  return specifier;
 }
 function filterWhere(focus, criteria, ctx) {
   return focus.filter((item) => convertToBoolean(evaluate(criteria, [item], ctx)));
 }
+var SUBSET_FUNCTIONS = /* @__PURE__ */ new Set([
+  "exists",
+  "empty",
+  "not",
+  "where",
+  "select",
+  "all",
+  "count",
+  "first",
+  "last",
+  "distinct",
+  "hasValue",
+  "children",
+  "extension",
+  "intersect",
+  "ofType",
+  "is",
+  "as",
+  "matches"
+]);
+var SUBSET_OPERATORS = /* @__PURE__ */ new Set([
+  "and",
+  "or",
+  "xor",
+  "implies",
+  "=",
+  "!=",
+  "<",
+  ">",
+  "<=",
+  ">=",
+  "|",
+  "in",
+  "contains"
+]);
 function applyFunction(name, input, args, callFocus, ctx) {
+  if (!SUBSET_FUNCTIONS.has(name)) {
+    throw new UnsupportedFhirPathError(`unsupported function '${name}()'`);
+  }
   switch (name) {
     case "exists":
       return [
@@ -4061,7 +5315,17 @@ function applyFunction(name, input, args, callFocus, ctx) {
       return distinctItems(input).filter((item) => other.some((o) => itemsEqual(item, o)));
     }
     case "ofType":
-      return input.filter((item) => itemIsType(item, typeNameOf(req(args[0]))));
+      return input.filter((item) => ofTypeKeeps(item, req(args[0]), ctx));
+    case "is": {
+      const matched = functionFormTypeTest(input, args[0], "is()", ctx);
+      return matched === "empty" ? [] : [{ t: "bool", value: matched !== void 0 }];
+    }
+    case "as": {
+      const matched = functionFormTypeTest(input, args[0], "as()", ctx);
+      return matched === "empty" || matched === void 0 ? [] : [matched];
+    }
+    case "matches":
+      return applyMatches(input, args, callFocus, ctx);
     default:
       throw new UnsupportedFhirPathError(`unsupported function '${name}()'`);
   }
@@ -4084,6 +5348,7 @@ function req(arg) {
   return arg;
 }
 function evaluateBinary(op, node, focus, ctx) {
+  if (!SUBSET_OPERATORS.has(op)) throw new UnsupportedFhirPathError(`unsupported operator '${op}'`);
   if (op === "and" || op === "or" || op === "xor" || op === "implies") {
     const a = toTrit(evaluate(node.left, focus, ctx));
     const b = toTrit(evaluate(node.right, focus, ctx));
@@ -4191,9 +5456,9 @@ function evaluate(expr, focus, ctx) {
       if (expr.op === "is") {
         if (operand.length === 0) return [];
         if (operand.length !== 1) return [{ t: "bool", value: false }];
-        return [{ t: "bool", value: itemIsType(operand[0], expr.type) }];
+        return [{ t: "bool", value: itemIsType(operand[0], expr.type, ctx) }];
       }
-      return operand.filter((item) => itemIsType(item, expr.type));
+      return operand.filter((item) => itemIsType(item, expr.type, ctx));
     }
   }
 }
@@ -4658,11 +5923,14 @@ function fociFor(resource, rt, root, elementPath) {
   }));
 }
 function collectInvariantIssues(resource, profile, options = {}) {
+  return invariantFindings(resource, profile, options).map((finding) => finding.issue);
+}
+function invariantFindings(resource, profile, options = {}) {
   const rt = resourceType(resource);
   if (rt === void 0 || rt !== profile.type) return [];
   const root = rootPath(rt);
   const snapshot = snapshotElements(profile, options.resolve ?? (() => void 0));
-  const issues = [];
+  const findings = [];
   for (const el of snapshot) {
     if (el.constraint === void 0 || el.constraint.length === 0) continue;
     if (el.sliceName !== void 0) continue;
@@ -4678,21 +5946,217 @@ function collectInvariantIssues(resource, profile, options = {}) {
           resource
         );
         if (unchecked) {
-          issues.push(
-            validationIssue(
+          findings.push({
+            issue: validationIssue(
               "INVARIANT_UNCHECKED",
               ISSUE_SEVERITIES.INFORMATION,
               focus.path,
               constraint.key
-            )
-          );
+            ),
+            focus: focus.node,
+            expression: constraint.expression
+          });
         } else if (!satisfied) {
-          issues.push(validationIssue("INVARIANT_VIOLATED", severity, focus.path, constraint.key));
+          findings.push({
+            issue: validationIssue("INVARIANT_VIOLATED", severity, focus.path, constraint.key),
+            focus: focus.node,
+            expression: constraint.expression
+          });
         }
       }
     }
   }
-  return issues;
+  return findings;
+}
+
+// src/validate/base-invariants.ts
+var BASE_CONSTRAINT_TYPES = /* @__PURE__ */ new Set([
+  "AllergyIntolerance",
+  "Condition",
+  "DiagnosticReport",
+  "Immunization",
+  "MedicationRequest",
+  "MedicationStatement",
+  "Observation",
+  "Patient"
+]);
+var BASE_CONSTRAINTS = [
+  {
+    key: "dom-2",
+    anchor: { kind: "root" },
+    expression: "contained.contained.empty()"
+  },
+  {
+    key: "dom-3",
+    anchor: { kind: "root" },
+    expression: "contained.where((('#'+id in (%resource.descendants().reference | %resource.descendants().as(canonical) | %resource.descendants().as(uri) | %resource.descendants().as(url))) or descendants().where(reference = '#').exists() or descendants().where(as(canonical) = '#').exists() or descendants().where(as(canonical) = '#').exists()).not()).trace('unmatched', id).empty()"
+  },
+  {
+    key: "dom-4",
+    anchor: { kind: "root" },
+    expression: "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()"
+  },
+  {
+    key: "dom-5",
+    anchor: { kind: "root" },
+    expression: "contained.meta.security.empty()"
+  },
+  {
+    key: "pat-1",
+    anchor: { kind: "element", type: "Patient", element: "contact" },
+    expression: "name.exists() or telecom.exists() or address.exists() or organization.exists()"
+  },
+  {
+    key: "obs-3",
+    anchor: { kind: "element", type: "Observation", element: "referenceRange" },
+    expression: "low.exists() or high.exists() or text.exists()"
+  },
+  {
+    key: "con-1",
+    anchor: { kind: "element", type: "Condition", element: "stage" },
+    expression: "summary.exists() or assessment.exists()"
+  },
+  {
+    key: "con-2",
+    anchor: { kind: "element", type: "Condition", element: "evidence" },
+    expression: "code.exists() or detail.exists()"
+  },
+  {
+    key: "imm-1",
+    anchor: { kind: "element", type: "Immunization", element: "education" },
+    expression: "documentType.exists() or reference.exists()"
+  },
+  {
+    key: "ele-1",
+    anchor: { kind: "every-element" },
+    expression: "hasValue() or (children().count() > id.count())"
+  },
+  {
+    key: "ext-1",
+    anchor: { kind: "every-extension" },
+    expression: "extension.exists() != value.exists()"
+  }
+];
+function compile(expression) {
+  try {
+    return parseFhirPath(expression);
+  } catch {
+    return void 0;
+  }
+}
+var COMPILED = BASE_CONSTRAINTS.map((row) => ({
+  row,
+  ast: compile(row.expression)
+}));
+var EXPRESSION_OF = new Map(
+  BASE_CONSTRAINTS.map((row) => [row.key, row.expression])
+);
+var CONTAINED_SELECTION = compile("contained");
+function outcomeOf(ast, focus, resource) {
+  if (ast === void 0) return "unchecked";
+  try {
+    const at = [{ t: "node", node: focus }];
+    return convertToBoolean(evaluate(ast, at, { resource, context: at })) ? "satisfied" : "violated";
+  } catch {
+    return "unchecked";
+  }
+}
+function decideDom3(resource) {
+  if (CONTAINED_SELECTION === void 0) return "unchecked";
+  try {
+    const at = [{ t: "node", node: resource }];
+    const selected = evaluate(CONTAINED_SELECTION, at, { resource, context: at });
+    return selected.length === 0 ? "satisfied" : "unchecked";
+  } catch {
+    return "unchecked";
+  }
+}
+function holdsExtensions(name) {
+  return name === "extension" || name === "modifierExtension";
+}
+function occurrencesOf2(node, path) {
+  if (!isList(node)) return [{ node, path }];
+  return node.items.flatMap((item, i) => occurrencesOf2(item, `${path}[${String(i)}]`));
+}
+function walkElements(value, path, extension, typedElement, visit2) {
+  for (const occurrence of occurrencesOf2(value, path)) {
+    const { node } = occurrence;
+    visit2(node, occurrence.path, extension, typedElement);
+    if (isComplex(node)) {
+      walkChildren(node, occurrence.path, extension, visit2);
+    } else if (!isList(node)) {
+      (node.extension ?? []).forEach((ext, i) => {
+        walkElements(ext, `${occurrence.path}.extension[${String(i)}]`, true, true, visit2);
+      });
+    }
+  }
+}
+function walkChildren(node, path, isExtension, visit2) {
+  for (const property of node.properties) {
+    if (property.name === "resourceType") continue;
+    const plainString = property.name === "id" || isExtension && property.name === "url";
+    walkElements(
+      property.value,
+      childPath(path, property.name),
+      holdsExtensions(property.name),
+      !plainString,
+      visit2
+    );
+  }
+}
+function collectBaseInvariantFindings(resource, rt) {
+  const findings = [];
+  const decided = /* @__PURE__ */ new Map();
+  const result = {
+    findings,
+    decides: (focus, key, expression) => EXPRESSION_OF.get(key) === expression && decided.get(focus)?.has(key) === true
+  };
+  if (!BASE_CONSTRAINT_TYPES.has(rt)) return result;
+  const root = rootPath(rt);
+  const report = (outcome, key, focus, path) => {
+    if (outcome !== "unchecked") {
+      const keys = decided.get(focus) ?? /* @__PURE__ */ new Set();
+      keys.add(key);
+      decided.set(focus, keys);
+    }
+    if (outcome === "satisfied") return;
+    const issue = outcome === "violated" ? validationIssue("INVARIANT_VIOLATED", ISSUE_SEVERITIES.ERROR, path, key) : validationIssue("INVARIANT_UNCHECKED", ISSUE_SEVERITIES.INFORMATION, path, key);
+    findings.push({ issue, focus });
+  };
+  for (const { row, ast } of COMPILED) {
+    const { anchor } = row;
+    if (anchor.kind === "root") {
+      const outcome = row.key === "dom-3" ? decideDom3(resource) : outcomeOf(ast, resource, resource);
+      report(outcome, row.key, resource, root);
+    } else if (anchor.kind === "element" && anchor.type === rt) {
+      const value = getProperty(resource, anchor.element);
+      if (value === void 0) continue;
+      for (const { node, path } of occurrencesOf2(value, childPath(root, anchor.element))) {
+        report(outcomeOf(ast, node, resource), row.key, node, path);
+      }
+    }
+  }
+  const elementRow = COMPILED.find(({ row }) => row.anchor.kind === "every-element");
+  const extensionRow = COMPILED.find(({ row }) => row.anchor.kind === "every-extension");
+  const visit2 = (node, path, extension, typedElement) => {
+    if (elementRow !== void 0 && typedElement) {
+      report(outcomeOf(elementRow.ast, node, resource), elementRow.row.key, node, path);
+    }
+    if (extensionRow !== void 0 && extension) {
+      report(outcomeOf(extensionRow.ast, node, resource), extensionRow.row.key, node, path);
+    }
+  };
+  for (const property of resource.properties) {
+    if (property.name === "resourceType" || property.name === "contained") continue;
+    walkElements(
+      property.value,
+      childPath(root, property.name),
+      holdsExtensions(property.name),
+      property.name !== "id",
+      visit2
+    );
+  }
+  return result;
 }
 
 // src/validate/validate.ts
@@ -4750,8 +6214,8 @@ function validateResource(resource, options = {}) {
     return finalize(ctx);
   }
   const root = rootPath(rt);
-  const registry = buildRegistry(options.schemas ?? []);
-  const modeled = registry(rt);
+  const registry2 = buildRegistry(options.schemas ?? []);
+  const modeled = registry2(rt);
   const schema = modeled ?? baseSchema(rt);
   if (modeled === void 0) emit(ctx, "RESOURCE_NOT_MODELED", root);
   const counts = /* @__PURE__ */ new Map();
@@ -4764,19 +6228,19 @@ function validateResource(resource, options = {}) {
       if (modeled !== void 0) emit(ctx, "UNKNOWN_ELEMENT", path);
       continue;
     }
-    const { element, datatype, base } = match;
+    const { element, datatype, base: base2 } = match;
     const occ = occurrences(property.value, path);
-    counts.set(base, (counts.get(base) ?? 0) + occ.length);
+    counts.set(base2, (counts.get(base2) ?? 0) + occ.length);
     if (isChoice(element)) {
-      const seen = choiceVariants.get(base) ?? /* @__PURE__ */ new Set();
+      const seen = choiceVariants.get(base2) ?? /* @__PURE__ */ new Set();
       seen.add(property.name);
-      choiceVariants.set(base, seen);
+      choiceVariants.set(base2, seen);
     }
     if (occ.length > element.max) emit(ctx, "CARDINALITY_MAX", path);
     for (const { leaf, path: leafPath } of occ) checkLeaf(ctx, leaf, datatype, element, leafPath);
   }
-  for (const [base, seen] of choiceVariants) {
-    if (seen.size > 1) emit(ctx, "CHOICE_AMBIGUOUS", `${root}.${base}[x]`);
+  for (const [base2, seen] of choiceVariants) {
+    if (seen.size > 1) emit(ctx, "CHOICE_AMBIGUOUS", `${root}.${base2}[x]`);
   }
   for (const [name, element] of Object.entries(schema.elements)) {
     if (element.min >= 1 && (counts.get(name) ?? 0) < element.min) {
@@ -4790,6 +6254,9 @@ function validateResource(resource, options = {}) {
     for (const issue of collectBundleIssues(resource)) ctx.issues.push(issue);
   }
   for (const issue of collectTerminologyIssues(resource, rt, options)) ctx.issues.push(issue);
+  const base = collectBaseInvariantFindings(resource, rt);
+  for (const finding of base.findings) ctx.issues.push(finding.issue);
+  const reportedByBase = alreadyReported(base.findings);
   if (options.profiles !== void 0 && options.profiles.length > 0) {
     const profileOptions = options.resolveBase === void 0 ? {} : { resolve: options.resolveBase };
     for (const profile of options.profiles) {
@@ -4797,8 +6264,12 @@ function validateResource(resource, options = {}) {
       for (const issue of collectProfileIssues(resource, profile, profileOptions)) {
         ctx.issues.push(issue);
       }
-      for (const issue of collectInvariantIssues(resource, profile, profileOptions)) {
-        ctx.issues.push(issue);
+      for (const finding of invariantFindings(resource, profile, profileOptions)) {
+        if (reportedByBase(finding.focus, finding.issue)) continue;
+        if (finding.issue.code === "INVARIANT_UNCHECKED" && base.decides(finding.focus, finding.issue.constraint ?? "", finding.expression)) {
+          continue;
+        }
+        ctx.issues.push(finding.issue);
       }
     }
     for (const issue of collectProfileVersionIssues(resource, options.profiles)) {
@@ -4807,6 +6278,15 @@ function validateResource(resource, options = {}) {
   }
   return finalize(ctx);
 }
+function alreadyReported(base) {
+  const byFocus = /* @__PURE__ */ new Map();
+  for (const { focus, issue } of base) {
+    const seen = byFocus.get(focus) ?? /* @__PURE__ */ new Set();
+    seen.add(`${issue.code} ${issue.constraint ?? ""}`);
+    byFocus.set(focus, seen);
+  }
+  return (focus, issue) => byFocus.get(focus)?.has(`${issue.code} ${issue.constraint ?? ""}`) === true;
+}
 function finalize(ctx) {
   const issues = [...ctx.issues];
   const valid = !issues.some(
@@ -5203,9 +6683,12 @@ function isWs(c) {
 }
 var RawXmlReader = class {
   #src;
+  /** Told the code point of each numeric character reference as it is decoded; never alters the parse. */
+  #onReference;
   #pos = 0;
-  constructor(src) {
+  constructor(src, onReference) {
     this.#src = src;
+    this.#onReference = onReference;
   }
   /** Parse the whole document: optional prolog, exactly one root element, optional trailing misc. */
   parse() {
@@ -5453,6 +6936,7 @@ var RawXmlReader = class {
         start
       );
     }
+    this.#onReference?.(code);
     return String.fromCodePoint(code);
   }
   fail(message) {
@@ -5462,6 +6946,13 @@ var RawXmlReader = class {
 function readRawXml(src) {
   return new RawXmlReader(src).parse();
 }
+function readRawXmlReferences(src) {
+  const references = [];
+  const root = new RawXmlReader(src, (codePoint) => {
+    references.push(codePoint);
+  }).parse();
+  return { root, references };
+}
 
 // src/xml/read.ts
 var FHIR_XML_NAMESPACE = "http://hl7.org/fhir";
@@ -5503,6 +6994,9 @@ function isForeign(resolved, parentNamespace) {
 function isNarrativeDiv(resolved) {
   return resolved.name === "div" && resolved.namespace === XHTML_NAMESPACE;
 }
+function rootVocabularyIsForeign(resolved) {
+  return !resolved.unboundPrefix && resolved.namespace !== FHIR_XML_NAMESPACE && resolved.namespace !== NO_NAMESPACE;
+}
 function modelNameOf(element, resolved, parentNamespace) {
   if (isNarrativeDiv(resolved)) return resolved.name;
   return isForeign(resolved, parentNamespace) ? element.name : resolved.name;
@@ -5632,6 +7126,12 @@ function readComplex2(self, path, issues, opts) {
 function hasStrayText(children) {
   return children.some((node) => node.type === "text" && node.value.trim() !== "");
 }
+function elementTextValue(children) {
+  const runs = children.flatMap(
+    (node) => node.type === "text" && node.value.trim() !== "" ? [node.value.trim()] : []
+  );
+  return runs.length === 1 ? runs[0] : void 0;
+}
 function unexpectedXmlContentAt(issues, path) {
   return issues.some((i) => i.code === ISSUE_CODES.UNEXPECTED_XML_CONTENT && i.expression === path);
 }
@@ -5691,7 +7191,7 @@ function buildSingle(self, path, issues, parentNamespace) {
       }
     }
     const dropped = flagStrayText(element.children, path, issues);
-    const node = primitive(valueAttribute(element), meta);
+    const node = primitive(valueAttribute(element) ?? elementTextValue(element.children), meta);
     return dropped ? markDroppedText(node) : node;
   }
   return readComplex2(self, path, issues, { isResource: false });
@@ -5703,26 +7203,69 @@ function parseResourceXml(input) {
   const resolved = resolveName(root.name, scope);
   const self = { element: root, scope, resolved, modelName: resolved.name };
   const path = rootPath(self.modelName);
-  const rootIsForeign = resolved.unboundPrefix || resolved.namespace !== FHIR_XML_NAMESPACE && resolved.namespace !== NO_NAMESPACE;
+  const rootIsForeign = resolved.unboundPrefix || rootVocabularyIsForeign(resolved);
   if (rootIsForeign) issues.push(unexpectedXmlContent(path));
-  const resource = readComplex2(self, path, issues, { isResource: true });
+  const read = readComplex2(self, path, issues, { isResource: true });
+  const resource = rootVocabularyIsForeign(resolved) ? markForeignRoot(read) : read;
   return { resource, issues };
 }
 
 // src/xml/write.ts
 function tag(name, path, sink) {
   if (breaksTag(name)) sink.refusedNames.push(path);
+  else if (carriesUndeclarablePrefix(name)) sink.refusedPrefixes.push(path);
+  else if (!isXmlName(name)) sink.refusedXmlNames.push(path);
   return name;
 }
+function attributeValue(text, path, sink) {
+  if (carriesNonXmlCharacter(text)) sink.refusedCharacters.push(path);
+  return escapeAttr(text);
+}
+function refersToNonXmlCharacter(references) {
+  return references.some((codePoint) => carriesNonXmlCharacter(String.fromCodePoint(codePoint)));
+}
 function emitsOneDivElement(value) {
-  let name;
+  let parse;
   try {
-    name = readRawXml(value).name;
+    parse = readRawXmlReferences(value);
   } catch {
-    return false;
+    return void 0;
   }
+  const { name } = parse.root;
   const colon = name.indexOf(":");
-  return (colon === -1 ? name : name.slice(colon + 1)) === "div";
+  return (colon === -1 ? name : name.slice(colon + 1)) === "div" ? parse : void 0;
+}
+var XML_PREFIX2 = "xml";
+var XMLNS_PREFIX = "xmlns";
+var DECLARATION = `${XMLNS_PREFIX}:`;
+var NOTHING_BOUND = /* @__PURE__ */ new Set();
+function prefixesInScope(element, inherited) {
+  const declarations = element.attributes.filter(({ name }) => name.startsWith(DECLARATION));
+  if (declarations.length === 0) return inherited;
+  const scope = new Set(inherited);
+  for (const { name, value } of declarations) {
+    const prefix = name.slice(DECLARATION.length);
+    if (value === "") scope.delete(prefix);
+    else scope.add(prefix);
+  }
+  return scope;
+}
+function nameIsBound(name, scope) {
+  const colon = name.indexOf(":");
+  if (colon === -1) return true;
+  const prefix = name.slice(0, colon);
+  const local = name.slice(colon + 1);
+  if (prefix === "" || prefix === XMLNS_PREFIX || local === "" || local.includes(":")) return false;
+  return prefix === XML_PREFIX2 || scope.has(prefix);
+}
+function bindsEveryPrefix(element, inherited = NOTHING_BOUND) {
+  const scope = prefixesInScope(element, inherited);
+  if (!nameIsBound(element.name, scope)) return false;
+  for (const { name } of element.attributes) {
+    if (name === XMLNS_PREFIX || name.startsWith(DECLARATION)) continue;
+    if (!nameIsBound(name, scope)) return false;
+  }
+  return element.children.every((child) => child.type === "text" || bindsEveryPrefix(child, scope));
 }
 function scalarText(value) {
   if (typeof value === "string") return value;
@@ -5740,14 +7283,18 @@ function resourceTypeOf(node) {
   return void 0;
 }
 function attributeText(node) {
-  if (isPrimitive(node) && node.value !== void 0) return escapeAttr(scalarText(node.value));
+  if (isPrimitive(node) && node.value !== void 0) return scalarText(node.value);
   return void 0;
 }
 function writePrimitiveElement(path, name, node, sink) {
   const tagName = tag(name, path, sink);
   let attrs = "";
-  if (node.id !== void 0) attrs += ` id="${escapeAttr(node.id)}"`;
-  if (node.value !== void 0) attrs += ` value="${escapeAttr(scalarText(node.value))}"`;
+  if (node.id !== void 0) {
+    attrs += ` id="${attributeValue(node.id, childPath(path, "id"), sink)}"`;
+  }
+  if (node.value !== void 0) {
+    attrs += ` value="${attributeValue(scalarText(node.value), path, sink)}"`;
+  }
   const extensions = node.extension ?? [];
   if (extensions.length === 0) return `<${tagName}${attrs}/>`;
   const extensionPath = childPath(path, "extension");
@@ -5758,9 +7305,20 @@ function writePrimitiveElement(path, name, node, sink) {
 }
 function writeItem(path, name, node, inExtension, sink) {
   if (name === "div" && node.kind === "primitive" && typeof node.value === "string") {
-    if (emitsOneDivElement(node.value)) return node.value;
-    sink.refusedDivs.push(path);
-    return "";
+    const parse = emitsOneDivElement(node.value);
+    if (parse === void 0) {
+      sink.refusedDivs.push(path);
+      return "";
+    }
+    if (!bindsEveryPrefix(parse.root)) {
+      sink.refusedDivPrefixes.push(path);
+      return "";
+    }
+    if (carriesNonXmlCharacter(node.value) || refersToNonXmlCharacter(parse.references)) {
+      sink.refusedCharacters.push(path);
+      return "";
+    }
+    return node.value;
   }
   if (node.kind === "primitive") return writePrimitiveElement(path, name, node, sink);
   if (node.kind === "list")
@@ -5781,27 +7339,29 @@ function writeProperty(parentPath, name, node, inExtension, sink) {
 function writeElement(path, tagName, node, isRoot, inExtension, sink) {
   const written = tag(tagName, path, sink);
   const isResource = resourceTypeOf(node) !== void 0;
+  const asId = (name) => name === "id" && !isResource;
+  const asUrl = (name) => name === "url" && inExtension;
   let attrs = isRoot ? ` xmlns="${FHIR_XML_NAMESPACE}"` : "";
-  let idAttr = "";
-  let urlAttr = "";
+  let idText;
+  let urlText;
+  for (const { name, value } of node.properties) {
+    const text = attributeText(value);
+    if (text === void 0) continue;
+    if (asId(name)) idText = text;
+    else if (asUrl(name)) urlText = text;
+  }
+  if (idText !== void 0) {
+    attrs += ` id="${attributeValue(idText, childPath(path, "id"), sink)}"`;
+  }
+  if (urlText !== void 0) {
+    attrs += ` url="${attributeValue(urlText, childPath(path, "url"), sink)}"`;
+  }
   const children = [];
-  for (const property of node.properties) {
-    const { name, value } = property;
-    if (name === "resourceType") continue;
-    if (name === "id" && !isResource) {
-      const text = attributeText(value);
-      if (text !== void 0) idAttr = ` id="${text}"`;
-      continue;
-    }
-    if (name === "url" && inExtension) {
-      const text = attributeText(value);
-      if (text !== void 0) urlAttr = ` url="${text}"`;
-      continue;
-    }
+  for (const { name, value } of node.properties) {
+    if (name === "resourceType" || asId(name) || asUrl(name)) continue;
     const childInExtension = name === "extension" || name === "modifierExtension";
     children.push(writeProperty(path, name, value, childInExtension, sink));
   }
-  attrs += idAttr + urlAttr;
   const inner = children.join("");
   return inner === "" ? `<${written}${attrs}/>` : `<${written}${attrs}>${inner}</${written}>`;
 }
@@ -5809,7 +7369,14 @@ function serializeResourceXml(node) {
   assertSerializable(node);
   const rt = resourceTypeOf(node);
   const tagName = rt ?? "Resource";
-  const sink = { refusedNames: [], refusedDivs: [] };
+  const sink = {
+    refusedNames: [],
+    refusedDivs: [],
+    refusedPrefixes: [],
+    refusedDivPrefixes: [],
+    refusedXmlNames: [],
+    refusedCharacters: []
+  };
   const xml = writeElement(rootPath(tagName), tagName, node, true, false, sink);
   if (sink.refusedNames.length > 0) refuseUnserializableNames([...new Set(sink.refusedNames)]);
   if (sink.refusedDivs.length > 0) refuseUnserializableDivMarkup([...new Set(sink.refusedDivs)]);
@@ -5817,6 +7384,18 @@ function serializeResourceXml(node) {
   assertXmlArrayWrapper(node);
   assertNoShadowedProperty(node);
   assertXmlResourceType(node);
+  assertXmlForeignRoot(node);
+  assertXmlValueChoiceWrapper(node);
+  if (sink.refusedPrefixes.length > 0) {
+    refuseUndeclarablePrefixes([...new Set(sink.refusedPrefixes)]);
+  }
+  if (sink.refusedDivPrefixes.length > 0) {
+    refuseUnboundDivPrefixes([...new Set(sink.refusedDivPrefixes)]);
+  }
+  if (sink.refusedXmlNames.length > 0) refuseNonXmlNames([...new Set(sink.refusedXmlNames)]);
+  if (sink.refusedCharacters.length > 0) {
+    refuseNonXmlCharacters([...new Set(sink.refusedCharacters)]);
+  }
   return xml;
 }
 
@@ -5971,7 +7550,7 @@ async function* streamNdjson(source, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.0.10";
+var VERSION = "0.1.0";
 
 exports.ABSENCE_CODES = ABSENCE_CODES;
 exports.ALLERGY_CLINICAL_SYSTEM = ALLERGY_CLINICAL_SYSTEM;
@@ -5979,6 +7558,8 @@ exports.ALLERGY_SUBSTANCE_VALUESET = ALLERGY_SUBSTANCE_VALUESET;
 exports.ALLERGY_VERIFICATION_SYSTEM = ALLERGY_VERIFICATION_SYSTEM;
 exports.BINDING_STRENGTHS = BINDING_STRENGTHS;
 exports.BUNDLE_TYPES = BUNDLE_TYPES;
+exports.CODE_SYSTEM_VERSION_RECORD_CODES = CODE_SYSTEM_VERSION_RECORD_CODES;
+exports.CODE_SYSTEM_VERSION_RECORD_SYSTEM = CODE_SYSTEM_VERSION_RECORD_SYSTEM;
 exports.CONDITION_CATEGORY_SYSTEM = CONDITION_CATEGORY_SYSTEM;
 exports.CONDITION_CLINICAL_SYSTEM = CONDITION_CLINICAL_SYSTEM;
 exports.CONDITION_VERIFICATION_SYSTEM = CONDITION_VERIFICATION_SYSTEM;
@@ -6077,6 +7658,7 @@ exports.isAtomicBundle = isAtomicBundle;
 exports.isChoice = isChoice;
 exports.isComplex = isComplex;
 exports.isDroppedText = isDroppedText;
+exports.isForeignRoot = isForeignRoot;
 exports.isKnownSystem = isKnownSystem;
 exports.isList = isList;
 exports.isNestedArray = isNestedArray;