@cosyte/transform 0.0.9 → 0.1.1

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 var fhir = require('@cosyte/fhir');
-var hl7 = require('@cosyte/hl7');
 var crypto = require('crypto');
+var hl7 = require('@cosyte/hl7');
 
 // src/diagnostics/codes.ts
 var ISSUE_CODES = {
@@ -54,7 +54,63 @@ var ISSUE_CODES = {
   /** A FHIR-required element's value could not be faithfully derived from the source, so it was
    * emitted with a `data-absent-reason` extension (value `unknown`) rather than fabricated, e.g.
    * `MessageHeader.source.endpoint` from an MSH-3 application namespace that is not a URL. */
-  TRANSFORM_REQUIRED_ELEMENT_UNKNOWN: "TRANSFORM_REQUIRED_ELEMENT_UNKNOWN"
+  TRANSFORM_REQUIRED_ELEMENT_UNKNOWN: "TRANSFORM_REQUIRED_ELEMENT_UNKNOWN",
+  /** A reverse (FHIR to v2) conversion was called without the explicit message trigger it requires.
+   * No FHIR resource carries a v2 trigger, so it is never inferred from resource content and never
+   * defaulted: no message is built and no builder is called. */
+  TRANSFORM_MISSING_TRIGGER: "TRANSFORM_MISSING_TRIGGER",
+  /** A reverse (FHIR to v2) conversion was handed a resource outside the narrow set of shapes it
+   * supports. No v2 message is emitted and no segment layout is guessed. */
+  TRANSFORM_UNSUPPORTED_RESOURCE: "TRANSFORM_UNSUPPORTED_RESOURCE",
+  /** A resource handed to a reverse (FHIR to v2) conversion is not structurally a FHIR resource of
+   * its expected type (not an object, no `resourceType`, or an element carrying the wrong node
+   * kind). Nothing is emitted and nothing is thrown. */
+  TRANSFORM_RESOURCE_MALFORMED: "TRANSFORM_RESOURCE_MALFORMED",
+  /** A populated FHIR element has no v2 field in the narrow reverse map that covers this shape
+   * (the IG map defines no source for it, or its inverse is not implemented here). The element is
+   * surfaced and left out, never approximated into a neighbouring v2 field. */
+  TRANSFORM_NO_V2_TARGET: "TRANSFORM_NO_V2_TARGET",
+  /** A FHIR value cannot be carried into its v2 target without altering it (a lexical form v2 has
+   * no representation for, or content that exceeds the target's component structure). The v2 field
+   * is left absent rather than truncated, rounded, or coerced. */
+  TRANSFORM_VALUE_NOT_REPRESENTABLE: "TRANSFORM_VALUE_NOT_REPRESENTABLE",
+  /** A FHIR code has no usable inverse in the IG ConceptMap that governs its field: either several
+   * v2 source codes map onto it (so the inverse is ambiguous) or the map has no row for it at all.
+   * The v2 field is left absent, never resolved to one arbitrary member of the ambiguous set. */
+  TRANSFORM_CODE_NOT_INVERTIBLE: "TRANSFORM_CODE_NOT_INVERTIBLE",
+  /** A `Coding.system` is not a system this library can name with a v2 coding-system mnemonic, so
+   * the coding cannot be written into a v2 coded field. It is flagged rather than emitted with no
+   * table context or with a code from an unrelated table. */
+  TRANSFORM_CODE_SYSTEM_NOT_V2: "TRANSFORM_CODE_SYSTEM_NOT_V2",
+  /** A v2 field the segment's own attribute table marks **required** (usage `R`) is absent from an
+   * emitted segment, because the FHIR resource carried no source this reverse map could ground it
+   * from, or the source it carried had no faithful v2 form. The field is left absent per v2
+   * optionality rules and **declared here**: a placeholder is never written to satisfy v2 structure,
+   * and the receiver is never left to discover the gap. Distinct from
+   * {@link ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN}, which is the forward direction's
+   * FHIR-required element. */
+  TRANSFORM_V2_REQUIRED_FIELD_ABSENT: "TRANSFORM_V2_REQUIRED_FIELD_ABSENT",
+  /** A reverse (FHIR to v2) conversion produced **no message at all**: nothing in the resource
+   * grounded a single field of the target segment, and an empty segment is never emitted. Raised so
+   * that an empty-handed conversion is never indistinguishable from a successful one, and separate
+   * from the refusals that name their own cause (an absent trigger, an unsupported resource type, a
+   * structurally malformed resource). */
+  TRANSFORM_NO_V2_MESSAGE_EMITTED: "TRANSFORM_NO_V2_MESSAGE_EMITTED",
+  /** A segment the message carried did **not** reach any resource in the returned bundle, and the IG
+   * *does* publish a segment map for its name: a **library gap**, fixable here. Raised once per
+   * occurrence, located `NAME[k]` with `k` counted 1-based among the occurrences of that name
+   * (`DG1[1]`, `DG1[2]`), so a consumer can tell how much of the message the bundle represents
+   * without diffing the two by hand. The occurrence may have been read and refused rather than never
+   * read: being counted, or already named by another issue, is not the same as reaching a resource. */
+  TRANSFORM_SEGMENT_NOT_EMITTED: "TRANSFORM_SEGMENT_NOT_EMITTED",
+  /** A segment the message carried did **not** reach any resource in the returned bundle, and its
+   * name is **not** one the IG publishes a segment map for: a **standard gap**, not fixable here.
+   * Custom Z-segments and `RXE` land on this code, and so does a name this library could not
+   * classify at all, because a damaged segment identifier is never re-derived from the line: an
+   * `AL1` whose identifier arrived as `AL11` reads as unclassifiable, not as an IG omission. Such an
+   * occurrence is located `[#n]` by its 1-based position among the segments of the message, with no
+   * name part at all. */
+  TRANSFORM_SEGMENT_NO_IG_MAP: "TRANSFORM_SEGMENT_NO_IG_MAP"
 };
 var FATAL_CODES = {
   /** The input carried nothing to transform. */
@@ -129,6 +185,61 @@ var ISSUE_REGISTRY = Object.freeze({
     severity: "information",
     fhirIssueType: "informational",
     message: "required FHIR element could not be derived from the source; emitted with a data-absent-reason extension, never fabricated."
+  },
+  [ISSUE_CODES.TRANSFORM_MISSING_TRIGGER]: {
+    severity: "error",
+    fhirIssueType: "required",
+    message: "reverse conversion requires an explicit v2 trigger from the caller; no resource carries one, so none was inferred and no message was built."
+  },
+  [ISSUE_CODES.TRANSFORM_UNSUPPORTED_RESOURCE]: {
+    severity: "error",
+    fhirIssueType: "not-supported",
+    message: "resource type is outside the reverse converter's supported shapes; no v2 message emitted and no segment layout guessed."
+  },
+  [ISSUE_CODES.TRANSFORM_RESOURCE_MALFORMED]: {
+    severity: "error",
+    fhirIssueType: "structure",
+    message: "input is not a structurally well-shaped FHIR resource for this conversion; nothing emitted, nothing thrown."
+  },
+  [ISSUE_CODES.TRANSFORM_NO_V2_TARGET]: {
+    severity: "information",
+    fhirIssueType: "informational",
+    message: "populated FHIR element has no v2 field in this reverse map; surfaced and left out, never approximated into a neighbouring field."
+  },
+  [ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE]: {
+    severity: "warning",
+    fhirIssueType: "value",
+    message: "FHIR value cannot be carried into its v2 target without altering it; the v2 field is left absent, never truncated, rounded, or coerced."
+  },
+  [ISSUE_CODES.TRANSFORM_CODE_NOT_INVERTIBLE]: {
+    severity: "warning",
+    fhirIssueType: "code-invalid",
+    message: "FHIR code has no usable inverse in the governing IG ConceptMap (ambiguous or absent); v2 field left absent, never resolved arbitrarily."
+  },
+  [ISSUE_CODES.TRANSFORM_CODE_SYSTEM_NOT_V2]: {
+    severity: "warning",
+    fhirIssueType: "code-invalid",
+    message: "coding system has no v2 coding-system mnemonic here; coding flagged rather than written with no table context or from an unrelated table."
+  },
+  [ISSUE_CODES.TRANSFORM_V2_REQUIRED_FIELD_ABSENT]: {
+    severity: "error",
+    fhirIssueType: "required",
+    message: "a v2-required field is absent from the emitted segment because the resource carried no source this map could ground it from; left absent per v2 optionality rules and declared here, never filled with a placeholder."
+  },
+  [ISSUE_CODES.TRANSFORM_NO_V2_MESSAGE_EMITTED]: {
+    severity: "error",
+    fhirIssueType: "processing",
+    message: "no v2 message was emitted: nothing in the resource grounded a single field of the target segment, and an empty segment is never emitted."
+  },
+  [ISSUE_CODES.TRANSFORM_SEGMENT_NOT_EMITTED]: {
+    severity: "information",
+    fhirIssueType: "informational",
+    message: "segment occurrence reached no resource in the returned bundle, and the IG publishes a segment map for its name; the bundle does not represent what this segment carried."
+  },
+  [ISSUE_CODES.TRANSFORM_SEGMENT_NO_IG_MAP]: {
+    severity: "information",
+    fhirIssueType: "informational",
+    message: "segment occurrence reached no resource in the returned bundle, and the IG publishes no segment map for its name, or the name could not be classified at all; the bundle does not represent what this segment carried."
   }
 });
 function issue(code, v2Location, fhirPath) {
@@ -512,6 +623,14 @@ var V3_ROUTE_OF_ADMINISTRATION_SYSTEM = "http://terminology.hl7.org/CodeSystem/v
 var V2_0550_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0550";
 var V2_0277_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0277";
 var V2_0161_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0161";
+var V2_0127_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0127";
+var V2_0128_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0128";
+var ALLERGY_INTOLERANCE_CATEGORY_SYSTEM = "http://hl7.org/fhir/allergy-intolerance-category";
+var ALLERGY_INTOLERANCE_TYPE_SYSTEM = "http://hl7.org/fhir/allergy-intolerance-type";
+var ALLERGY_INTOLERANCE_CRITICALITY_SYSTEM = "http://hl7.org/fhir/allergy-intolerance-criticality";
+var V2_0335_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0335";
+var V2_0528_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0528";
+var V3_TIMING_EVENT_SYSTEM = "http://terminology.hl7.org/CodeSystem/v3-TimingEvent";
 function valueMap(name, sourceSystem, sourceMnemonics, targets) {
   return Object.freeze({
     name,
@@ -1059,6 +1178,121 @@ var SUBSTITUTION_VALUE_MAP = valueMap(
   ["HL70161", "0161"],
   identityTargets(V2_0161_SYSTEM, ["N", "G", "T"])
 );
+var IG_ALLERGY_VALUE_MAPS_VERSION = "1.0.0";
+var IG_ALLERGY_VALUE_MAPS_PUBLISHED = "2025-10-07";
+var IG_ALLERGY_VALUE_MAPS_RETRIEVED = "2026-08-28";
+var IG_ALLERGY_VALUE_MAPS_SOURCE = "https://hl7.org/fhir/uv/v2mappings/ConceptMap-segment-al1-to-allergyintolerance.html";
+var ALLERGY_CATEGORY_VALUE_MAP = valueMap(
+  "table-hl70127-to-allergy-intolerance-category",
+  V2_0127_SYSTEM,
+  ["HL70127", "0127"],
+  {
+    DA: { system: ALLERGY_INTOLERANCE_CATEGORY_SYSTEM, code: "medication", display: "Medication" },
+    FA: { system: ALLERGY_INTOLERANCE_CATEGORY_SYSTEM, code: "food", display: "Food" },
+    EA: {
+      system: ALLERGY_INTOLERANCE_CATEGORY_SYSTEM,
+      code: "environment",
+      display: "Environment"
+    },
+    AA: { system: ALLERGY_INTOLERANCE_CATEGORY_SYSTEM, code: "biologic", display: "Biologic" },
+    PA: {
+      system: ALLERGY_INTOLERANCE_CATEGORY_SYSTEM,
+      code: "environment",
+      display: "Environment"
+    },
+    LA: {
+      system: ALLERGY_INTOLERANCE_CATEGORY_SYSTEM,
+      code: "environment",
+      display: "Environment"
+    }
+  }
+);
+var ALLERGY_TYPE_VALUE_MAP = valueMap(
+  "table-hl70127-to-allergy-intolerance-type",
+  V2_0127_SYSTEM,
+  ["HL70127", "0127"],
+  {
+    DA: { system: ALLERGY_INTOLERANCE_TYPE_SYSTEM, code: "allergy", display: "Allergy" },
+    FA: { system: ALLERGY_INTOLERANCE_TYPE_SYSTEM, code: "allergy", display: "Allergy" },
+    MA: { system: ALLERGY_INTOLERANCE_TYPE_SYSTEM, code: "allergy", display: "Allergy" },
+    EA: { system: ALLERGY_INTOLERANCE_TYPE_SYSTEM, code: "allergy", display: "Allergy" },
+    AA: { system: ALLERGY_INTOLERANCE_TYPE_SYSTEM, code: "allergy", display: "Allergy" },
+    PA: { system: ALLERGY_INTOLERANCE_TYPE_SYSTEM, code: "allergy", display: "Allergy" },
+    LA: { system: ALLERGY_INTOLERANCE_TYPE_SYSTEM, code: "allergy", display: "Allergy" }
+  }
+);
+var ALLERGY_CRITICALITY_VALUE_MAP = valueMap(
+  "table-hl70128-to-allergy-intolerance-criticality",
+  V2_0128_SYSTEM,
+  ["HL70128", "0128"],
+  {
+    SV: { system: ALLERGY_INTOLERANCE_CRITICALITY_SYSTEM, code: "high", display: "High Risk" },
+    MI: { system: ALLERGY_INTOLERANCE_CRITICALITY_SYSTEM, code: "low", display: "Low Risk" }
+  }
+);
+var ALLERGY_ORIGINAL_CATEGORY_VALUE_MAP = valueMap(
+  "table-hl70127-to-v2-0127",
+  V2_0127_SYSTEM,
+  ["HL70127", "0127"],
+  identityTargets(V2_0127_SYSTEM, ["DA", "FA", "MA", "MC", "EA", "AA", "PA", "LA"])
+);
+var ALLERGY_ORIGINAL_CRITICALITY_VALUE_MAP = valueMap(
+  "table-hl70128-original-to-v2-0128",
+  V2_0128_SYSTEM,
+  ["HL70128", "0128"],
+  identityTargets(V2_0128_SYSTEM, ["SV", "MO", "MI", "U"])
+);
+var TIMING_EVENT_VALUE_MAP = valueMap(
+  "table-hl70528-to-v3-timingevent",
+  V2_0528_SYSTEM,
+  ["HL70528", "0528"],
+  identityTargets(V3_TIMING_EVENT_SYSTEM, [
+    "HS",
+    "AC",
+    "PC",
+    "ACM",
+    "ACD",
+    "ACV",
+    "PCM",
+    "PCD",
+    "PCV"
+  ])
+);
+var REPEAT_PATTERN_LITERALS = Object.freeze(
+  /* @__PURE__ */ new Set([
+    "QAM",
+    "QSHIFT",
+    "QHS",
+    "QPM",
+    "C",
+    "PRN",
+    "Once",
+    "A",
+    "P",
+    "I",
+    "M",
+    "D",
+    "V",
+    "BID",
+    "TID",
+    "QID",
+    "QOD"
+  ])
+);
+var REPEAT_PATTERN_SHAPES = Object.freeze([
+  /^Q[0-9]+[SMHDWL]$/,
+  /^Q[0-9]+J[1-7]$/,
+  /^(?:[5-9]|[1-9][0-9]+)ID$/,
+  /^U .+$/,
+  /^[API]C[MDV]$/
+]);
+function isRepeatPatternRow(code) {
+  return REPEAT_PATTERN_LITERALS.has(code) || REPEAT_PATTERN_SHAPES.some((s) => s.test(code));
+}
+function isRepeatPatternCode(code) {
+  if (isRepeatPatternRow(code)) return true;
+  return code.startsWith("PRN") && code.length > 3 && isRepeatPatternRow(code.slice(3));
+}
 function codingFrom(system, code, display, version) {
   const props = [{ name: "system", value: fhir.primitive(system) }];
   if (version !== void 0 && version !== "")
@@ -1161,15 +1395,199 @@ function orderIdentifier(value, typeCode) {
     { name: "value", value: fhir.primitive(value) }
   ]);
 }
+function component(field, index) {
+  return field.repetitions[0]?.components[index]?.subcomponents[0] ?? "";
+}
+function toFhirEntityIdentifier(field) {
+  const entityId = component(field, 0);
+  const authorityValued = component(field, 1) !== "" || component(field, 2) !== "" || component(field, 3) !== "";
+  return {
+    identifier: entityId === "" ? void 0 : fhir.complex([{ name: "value", value: fhir.primitive(entityId) }]),
+    authorityValued
+  };
+}
+function withCodeableText(concept, textValue) {
+  return fhir.complex([
+    ...concept.properties.filter((p) => p.name !== "text"),
+    { name: "text", value: fhir.primitive(textValue) }
+  ]);
+}
 function dataAbsent(reasonCode) {
-  const ext = fhir.complex([
+  return fhir.primitive(void 0, { extension: [dataAbsentReason(reasonCode)] });
+}
+function dataAbsentReason(reasonCode) {
+  return fhir.complex([
     { name: "url", value: fhir.primitive(DATA_ABSENT_REASON_URL) },
     { name: "valueCode", value: fhir.primitive(reasonCode) }
   ]);
-  return fhir.primitive(void 0, { extension: [ext] });
+}
+function dataAbsentComplex(reasonCode) {
+  return fhir.complex([{ name: "extension", value: fhir.list([dataAbsentReason(reasonCode)]) }]);
 }
 
-// src/messages/appointment.ts
+// src/messages/allergy-intolerance.ts
+var ALLERGY_CLINICAL_STATUS_SYSTEM = "http://terminology.hl7.org/CodeSystem/allergyintolerance-clinical";
+var ALLERGY_CLINICAL_STATUS_CODE = "active";
+var ALTERNATE_CODES_EXTENSION_URL = "http://hl7.org/fhir/StructureDefinition/alternate-codes";
+var AL1_ONSET_WITHDRAWN_AT = Object.freeze([2, 7]);
+var READABLE_VERSION = /^\d+(?:\.\d+)*$/;
+function carriesLegacyOnsetDate(version) {
+  if (version === void 0 || !READABLE_VERSION.test(version)) return false;
+  const parts = version.split(".").map(Number);
+  for (let i = 0; i < AL1_ONSET_WITHDRAWN_AT.length; i++) {
+    const part = parts[i] ?? 0;
+    const bound = AL1_ONSET_WITHDRAWN_AT[i] ?? 0;
+    if (part !== bound) return part < bound;
+  }
+  return false;
+}
+function collectAllergies(msg) {
+  return msg.allSegments().filter((seg) => seg.type === "AL1");
+}
+function alternateCodesExtension(seg, field, map, ctx, issues) {
+  const original = toFhirCodeableConceptVia(seg.field(field).asCwe(), map, ctx);
+  issues.push(...original.issues);
+  if (original.value === void 0) return void 0;
+  return fhir.complex([
+    { name: "url", value: fhir.primitive(ALTERNATE_CODES_EXTENSION_URL) },
+    { name: "valueCodeableConcept", value: original.value }
+  ]);
+}
+function translatedCodeElement(seg, field, targetMap, originalMap, carryAlternateCodes, v2Location, fhirPath, ctx, issues) {
+  const extension = carryAlternateCodes ? alternateCodesExtension(seg, field, originalMap, ctx, issues) : void 0;
+  const target = translateBound(seg.field(field).asCwe(), targetMap);
+  if (target === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, v2Location, fhirPath));
+  }
+  if (target === void 0 && extension === void 0) return void 0;
+  return extension === void 0 ? fhir.primitive(target?.code) : fhir.primitive(target?.code, { extension: [extension] });
+}
+function buildReaction(al1) {
+  const manifestations = al1.field(5).repetitions.map((rep) => rep.components[0]?.subcomponents[0] ?? "").filter((text2) => text2 !== "").map((text2) => fhir.complex([{ name: "text", value: fhir.primitive(text2) }]));
+  if (manifestations.length === 0) return void 0;
+  return fhir.list([fhir.complex([{ name: "manifestation", value: fhir.list(manifestations) }])]);
+}
+function buildOnset(al1, version, ctx, issues) {
+  if (al1.field(6).value === "") return void 0;
+  if (!carriesLegacyOnsetDate(version)) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "AL1.6", "AllergyIntolerance.onsetDateTime")
+    );
+    return void 0;
+  }
+  const onset = toFhirDateTime(al1.field(6).asTs(), ctx.options);
+  issues.push(...onset.issues);
+  return onset.value === void 0 ? void 0 : fhir.primitive(onset.value);
+}
+function buildAllergyIntolerance(al1, patientFullUrl, version, ctx, options = {}) {
+  const issues = [];
+  const carryAlternateCodes = options.carryAlternateCodes ?? true;
+  const allergen = toFhirCodeableConcept(al1.field(3).asCwe(), ctx);
+  if (allergen.value === void 0) {
+    return {
+      value: void 0,
+      issues: [
+        ...allergen.issues,
+        issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "AL1.3", "AllergyIntolerance.code")
+      ]
+    };
+  }
+  issues.push(...allergen.issues);
+  const allergenTypeValued = al1.field(2).value !== "";
+  const type = allergenTypeValued ? translatedCodeElement(
+    al1,
+    2,
+    ALLERGY_TYPE_VALUE_MAP,
+    ALLERGY_ORIGINAL_CATEGORY_VALUE_MAP,
+    false,
+    "AL1.2",
+    "AllergyIntolerance.type",
+    ctx,
+    issues
+  ) : void 0;
+  const category = allergenTypeValued ? translatedCodeElement(
+    al1,
+    2,
+    ALLERGY_CATEGORY_VALUE_MAP,
+    ALLERGY_ORIGINAL_CATEGORY_VALUE_MAP,
+    carryAlternateCodes,
+    "AL1.2",
+    "AllergyIntolerance.category",
+    ctx,
+    issues
+  ) : void 0;
+  const criticality = al1.field(4).value !== "" ? translatedCodeElement(
+    al1,
+    4,
+    ALLERGY_CRITICALITY_VALUE_MAP,
+    ALLERGY_ORIGINAL_CRITICALITY_VALUE_MAP,
+    carryAlternateCodes,
+    "AL1.4",
+    "AllergyIntolerance.criticality",
+    ctx,
+    issues
+  ) : void 0;
+  const onset = buildOnset(al1, version, ctx, issues);
+  const reaction = buildReaction(al1);
+  const props = [
+    { name: "resourceType", value: fhir.primitive("AllergyIntolerance") },
+    // The IG's fixed assignment: not derived from the message, and the reason is on the row itself.
+    {
+      name: "clinicalStatus",
+      value: fhir.complex([
+        {
+          name: "coding",
+          value: fhir.list([
+            fhir.complex([
+              { name: "system", value: fhir.primitive(ALLERGY_CLINICAL_STATUS_SYSTEM) },
+              { name: "code", value: fhir.primitive(ALLERGY_CLINICAL_STATUS_CODE) }
+            ])
+          ])
+        }
+      ])
+    }
+  ];
+  if (type !== void 0) props.push({ name: "type", value: type });
+  if (category !== void 0) props.push({ name: "category", value: fhir.list([category]) });
+  if (criticality !== void 0) props.push({ name: "criticality", value: criticality });
+  props.push({ name: "code", value: allergen.value });
+  props.push({ name: "patient", value: reference(patientFullUrl) });
+  if (onset !== void 0) props.push({ name: "onsetDateTime", value: onset });
+  if (reaction !== void 0) props.push({ name: "reaction", value: reaction });
+  return { value: fhir.complex(props), issues };
+}
+function emitAllergyIntolerance(al1, patientFullUrl, version, ctx, gate, v2Location) {
+  const built = buildAllergyIntolerance(al1, patientFullUrl, version, ctx);
+  if (built.value === void 0) return built;
+  if (gate(built.value)) return built;
+  const issues = [...built.issues];
+  const withoutExtension = buildAllergyIntolerance(al1, patientFullUrl, version, ctx, {
+    carryAlternateCodes: false
+  });
+  if (withoutExtension.value !== void 0 && gate(withoutExtension.value)) {
+    if (al1.field(2).value !== "") {
+      issues.push(
+        issue(
+          ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+          "AL1.2",
+          "AllergyIntolerance.category.extension"
+        )
+      );
+    }
+    if (al1.field(4).value !== "") {
+      issues.push(
+        issue(
+          ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+          "AL1.4",
+          "AllergyIntolerance.criticality.extension"
+        )
+      );
+    }
+    return { value: withoutExtension.value, issues };
+  }
+  issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_INVALID, v2Location, "AllergyIntolerance"));
+  return { value: void 0, issues };
+}
 var APPOINTMENT_STATUS_MAP = Object.freeze({
   Pending: "pending",
   Waitlist: "waitlist",
@@ -1267,6 +1685,190 @@ function collectAppointment(msg) {
   }
   return { sch, ais };
 }
+var CONDITION_VERIFICATION_STATUS_SYSTEM = "http://terminology.hl7.org/CodeSystem/condition-ver-status";
+var CONDITION_ENTERED_IN_ERROR = "entered-in-error";
+var DG1_RETRACTION_ACTION_CODE = "D";
+function collectDiagnoses(msg) {
+  return msg.allSegments().filter((seg) => seg.type === "DG1");
+}
+function deferredDiagnosisIssues(dg1) {
+  const issues = [];
+  if (dg1.field(16).value !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "DG1.16", "Condition.asserter"));
+  }
+  if (dg1.field(22).value !== "") {
+    issues.push(
+      issue(
+        ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+        "DG1.22",
+        "Condition.extension[condition-dueTo].valueReference"
+      )
+    );
+  }
+  return issues;
+}
+function buildVerificationStatus(dg1, issues) {
+  const action = dg1.field(21).value;
+  if (action === "") return void 0;
+  if (action !== DG1_RETRACTION_ACTION_CODE) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "DG1.21", "Condition.verificationStatus")
+    );
+    return void 0;
+  }
+  return fhir.complex([
+    {
+      name: "coding",
+      value: fhir.list([
+        fhir.complex([
+          { name: "system", value: fhir.primitive(CONDITION_VERIFICATION_STATUS_SYSTEM) },
+          { name: "code", value: fhir.primitive(CONDITION_ENTERED_IN_ERROR) }
+        ])
+      ])
+    }
+  ]);
+}
+function buildCode(dg1, ctx, issues) {
+  const description = dg1.field(4).value;
+  const coded = toFhirCodeableConcept(dg1.field(3).asCwe(), ctx);
+  issues.push(...coded.issues);
+  if (coded.value === void 0) {
+    return description === "" ? void 0 : fhir.complex([{ name: "text", value: fhir.primitive(description) }]);
+  }
+  return description === "" ? coded.value : withCodeableText(coded.value, description);
+}
+function buildDateTime(dg1, field, ctx, issues) {
+  if (dg1.field(field).value === "") return void 0;
+  const converted = toFhirDateTime(dg1.field(field).asTs(), ctx.options);
+  issues.push(...converted.issues);
+  return converted.value === void 0 ? void 0 : fhir.primitive(converted.value);
+}
+function buildCondition(dg1, patientFullUrl, ctx, v2Location) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: fhir.primitive("Condition") }
+  ];
+  const entity = toFhirEntityIdentifier(dg1.field(20));
+  if (entity.identifier !== void 0) {
+    props.push({ name: "identifier", value: fhir.list([entity.identifier]) });
+  }
+  if (entity.authorityValued) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "DG1.20", "Condition.identifier.system")
+    );
+  }
+  const verification = buildVerificationStatus(dg1, issues);
+  if (verification !== void 0) props.push({ name: "verificationStatus", value: verification });
+  const code = buildCode(dg1, ctx, issues);
+  if (code === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, v2Location, "Condition.code"));
+  } else {
+    props.push({ name: "code", value: code });
+  }
+  props.push({ name: "subject", value: reference(patientFullUrl) });
+  const onset = buildDateTime(dg1, 5, ctx, issues);
+  if (onset !== void 0) props.push({ name: "onsetDateTime", value: onset });
+  const recorded = buildDateTime(dg1, 19, ctx, issues);
+  if (recorded !== void 0) props.push({ name: "recordedDate", value: recorded });
+  return { value: fhir.complex(props), issues };
+}
+var COVERAGE_SUBSCRIBER_ID_EXTENSION_URL = "http://hl7.org/fhir/5.0/StructureDefinition/extension-subscriberId";
+var COVERAGE_STATUS_UNKNOWN = "unknown";
+var IN1_SUBSCRIBER_NUMBER_TYPE = "SN";
+function collectCoverages(msg) {
+  return msg.allSegments().filter((seg) => seg.type === "IN1");
+}
+function insuranceCompanyName(in1) {
+  return in1.field(4).repetitions[0]?.components[0]?.subcomponents[0] ?? "";
+}
+function deferredCoverageIssues(in1) {
+  const deferred = [
+    [5, "Coverage.payer"],
+    [10, "Coverage.policyHolder"],
+    [11, "Coverage.policyHolder"],
+    [16, "Coverage.subscriber"],
+    [17, "Coverage.relationship"]
+  ];
+  const issues = [];
+  for (const [field, path] of deferred) {
+    if (in1.field(field).value !== "") {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, `IN1.${String(field)}`, path));
+    }
+  }
+  return issues;
+}
+function buildIdentifier(in1, issues) {
+  const cwe = in1.field(2).asCwe();
+  const planId = cwe.identifier;
+  if (planId === void 0 || planId === "") return void 0;
+  if (cwe.nameOfCodingSystem !== void 0 && cwe.nameOfCodingSystem !== "") {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "IN1.2", "Coverage.identifier.system")
+    );
+  }
+  return fhir.complex([{ name: "value", value: fhir.primitive(planId) }]);
+}
+function subscriberIdExtension(in1, field, ctx, issues) {
+  const identifier = toFhirIdentifier(in1.field(field).asCx(), ctx);
+  issues.push(...identifier.issues);
+  if (identifier.value === void 0) return void 0;
+  return fhir.complex([
+    { name: "url", value: fhir.primitive(COVERAGE_SUBSCRIBER_ID_EXTENSION_URL) },
+    { name: "valueIdentifier", value: identifier.value }
+  ]);
+}
+function buildPeriod(in1, ctx, issues) {
+  const props = [];
+  for (const [field, name] of [
+    [12, "start"],
+    [13, "end"]
+  ]) {
+    if (in1.field(field).value === "") continue;
+    const converted = toFhirDateTime(in1.field(field).asTs(), ctx.options);
+    issues.push(...converted.issues);
+    if (converted.value !== void 0) props.push({ name, value: fhir.primitive(converted.value) });
+  }
+  return props.length === 0 ? void 0 : fhir.complex(props);
+}
+function buildCoverage(in1, patientFullUrl, ctx, v2Location) {
+  const issues = [];
+  const payerName = insuranceCompanyName(in1);
+  if (payerName === "") {
+    return {
+      value: void 0,
+      issues: [issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, v2Location, "Coverage.payor")]
+    };
+  }
+  const props = [
+    { name: "resourceType", value: fhir.primitive("Coverage") }
+  ];
+  const extensions = [];
+  if (in1.field(10).asCx().identifierTypeCode === IN1_SUBSCRIBER_NUMBER_TYPE) {
+    const groupId = subscriberIdExtension(in1, 10, ctx, issues);
+    if (groupId !== void 0) extensions.push(groupId);
+  }
+  if (in1.field(49).value !== "") {
+    const insuredId = subscriberIdExtension(in1, 49, ctx, issues);
+    if (insuredId !== void 0) extensions.push(insuredId);
+  }
+  if (extensions.length > 0) props.push({ name: "extension", value: fhir.list(extensions) });
+  const identifier = buildIdentifier(in1, issues);
+  if (identifier !== void 0) props.push({ name: "identifier", value: fhir.list([identifier]) });
+  issues.push(issue(ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN, v2Location, "Coverage.status"));
+  props.push({ name: "status", value: dataAbsent(COVERAGE_STATUS_UNKNOWN) });
+  const type = toFhirCodeableConcept(in1.field(15).asCwe(), ctx);
+  issues.push(...type.issues);
+  if (type.value !== void 0) props.push({ name: "type", value: type.value });
+  props.push({ name: "beneficiary", value: reference(patientFullUrl) });
+  const period = buildPeriod(in1, ctx, issues);
+  if (period !== void 0) props.push({ name: "period", value: period });
+  props.push({
+    name: "payor",
+    value: fhir.list([fhir.complex([{ name: "display", value: fhir.primitive(payerName) }])])
+  });
+  issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "IN1.4", "Coverage.payor"));
+  return { value: fhir.complex(props), issues };
+}
 var V2_0074_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0074";
 var DIAGNOSTIC_REPORT_STATUS_MAP = Object.freeze({
   O: "registered",
@@ -1278,7 +1880,7 @@ var DIAGNOSTIC_REPORT_STATUS_MAP = Object.freeze({
   F: "final",
   X: "cancelled"
 });
-function buildDiagnosticReport(obr, resultFullUrls, subjectFullUrl, encounterFullUrl, ctx) {
+function buildDiagnosticReport(obr, resultFullUrls, subjectFullUrl, encounterFullUrl, ctx, specimenFullUrls = []) {
   const issues = [];
   const props = [
     { name: "resourceType", value: fhir.primitive("DiagnosticReport") }
@@ -1352,6 +1954,9 @@ function buildDiagnosticReport(obr, resultFullUrls, subjectFullUrl, encounterFul
       );
     }
   }
+  if (specimenFullUrls.length > 0) {
+    props.push({ name: "specimen", value: fhir.list(specimenFullUrls.map((u) => reference(u))) });
+  }
   if (resultFullUrls.length > 0) {
     props.push({ name: "result", value: fhir.list(resultFullUrls.map((u) => reference(u))) });
   }
@@ -1556,6 +2161,127 @@ function buildEncounter(visit, subjectFullUrl, ctx) {
   if (props.length === 1) return { value: void 0, issues };
   return { value: fhir.complex(props), issues };
 }
+function withEncounterDiagnosis(encounter, conditionFullUrls) {
+  if (conditionFullUrls.length === 0) return encounter;
+  const entries = conditionFullUrls.map(
+    (url) => fhir.complex([{ name: "condition", value: reference(url) }])
+  );
+  return fhir.complex([
+    ...encounter.properties.filter((p) => p.name !== "diagnosis"),
+    { name: "diagnosis", value: fhir.list(entries) }
+  ]);
+}
+function emitEncounterDiagnosis(encounter, conditionFullUrls, gate) {
+  const linked = withEncounterDiagnosis(encounter, conditionFullUrls);
+  if (linked === encounter || gate(linked)) return { value: linked, issues: [] };
+  return {
+    value: encounter,
+    issues: [issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "DG1", "Encounter.diagnosis")]
+  };
+}
+var PROCEDURE_STATUS_UNKNOWN = "unknown";
+var WHOLE_MINUTES = /^\d+$/;
+var ZONED_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+function collectProcedures(msg) {
+  return msg.allSegments().filter((seg) => seg.type === "PR1");
+}
+function addMinutes(start, minutes) {
+  const parts = ZONED_DATE_TIME.exec(start);
+  if (parts === null) return void 0;
+  const [, year, month, day, hour, minute, second, fraction, zone] = parts;
+  const wall = /* @__PURE__ */ new Date(0);
+  wall.setUTCFullYear(Number(year), Number(month) - 1, Number(day));
+  wall.setUTCHours(Number(hour), Number(minute), Number(second), 0);
+  const shifted = new Date(wall.getTime() + minutes * 6e4);
+  if (Number.isNaN(shifted.getTime())) return void 0;
+  const pad2 = (value, width) => String(value).padStart(width, "0");
+  const rendered = `${pad2(shifted.getUTCFullYear(), 4)}-${pad2(shifted.getUTCMonth() + 1, 2)}-${pad2(shifted.getUTCDate(), 2)}T${pad2(shifted.getUTCHours(), 2)}:${pad2(shifted.getUTCMinutes(), 2)}:${pad2(shifted.getUTCSeconds(), 2)}`;
+  return `${rendered}${fraction ?? ""}${zone ?? ""}`;
+}
+function deferredProcedureIssues(pr1) {
+  const deferred = [
+    [8, "Procedure.performer.actor"],
+    [11, "Procedure.performer.actor"],
+    [12, "Procedure.performer.actor"],
+    [16, "Procedure.code.value"],
+    [23, "Procedure.location"],
+    [25, "Procedure.partOf"]
+  ];
+  const issues = [];
+  for (const [field, path] of deferred) {
+    if (pr1.field(field).value !== "") {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, `PR1.${String(field)}`, path));
+    }
+  }
+  return issues;
+}
+function buildCode2(pr1, ctx, issues) {
+  const cne = pr1.field(3).asCwe();
+  const description = pr1.field(4).value;
+  const originalTextValued = cne.originalText !== void 0 && cne.originalText !== "";
+  const coded = toFhirCodeableConcept(cne, ctx);
+  issues.push(...coded.issues);
+  if (description !== "" && originalTextValued) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PR1.4", "Procedure.code.text"));
+    return coded.value;
+  }
+  if (coded.value === void 0) {
+    return description === "" ? void 0 : fhir.complex([{ name: "text", value: fhir.primitive(description) }]);
+  }
+  return description === "" ? coded.value : withCodeableText(coded.value, description);
+}
+function buildPerformed(pr1, ctx, issues) {
+  if (pr1.field(5).value === "") return void 0;
+  const converted = toFhirDateTime(pr1.field(5).asTs(), ctx.options);
+  issues.push(...converted.issues);
+  if (converted.value === void 0) return void 0;
+  const minutesRaw = pr1.field(7).value;
+  if (minutesRaw === "") {
+    return { name: "performedDateTime", value: fhir.primitive(converted.value) };
+  }
+  const end = WHOLE_MINUTES.test(minutesRaw) ? addMinutes(converted.value, Number(minutesRaw)) : void 0;
+  if (end === void 0) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PR1.7", "Procedure.performedPeriod.end")
+    );
+    return { name: "performedDateTime", value: fhir.primitive(converted.value) };
+  }
+  return {
+    name: "performedPeriod",
+    value: fhir.complex([
+      { name: "start", value: fhir.primitive(converted.value) },
+      { name: "end", value: fhir.primitive(end) }
+    ])
+  };
+}
+function buildProcedure(pr1, patientFullUrl, ctx) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: fhir.primitive("Procedure") }
+  ];
+  const entity = toFhirEntityIdentifier(pr1.field(19));
+  if (entity.identifier !== void 0) {
+    props.push({ name: "identifier", value: fhir.list([entity.identifier]) });
+  }
+  if (entity.authorityValued) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PR1.19", "Procedure.identifier.system")
+    );
+  }
+  props.push({ name: "status", value: fhir.primitive(PROCEDURE_STATUS_UNKNOWN) });
+  const category = toFhirCodeableConcept(pr1.field(6).asCwe(), ctx);
+  issues.push(...category.issues);
+  if (category.value !== void 0) props.push({ name: "category", value: category.value });
+  const code = buildCode2(pr1, ctx, issues);
+  if (code !== void 0) props.push({ name: "code", value: code });
+  props.push({ name: "subject", value: reference(patientFullUrl) });
+  const performed = buildPerformed(pr1, ctx, issues);
+  if (performed !== void 0) props.push(performed);
+  const reason = toFhirCodeableConcept(pr1.field(15).asCwe(), ctx);
+  issues.push(...reason.issues);
+  if (reason.value !== void 0) props.push({ name: "reasonCode", value: fhir.list([reason.value]) });
+  return { value: fhir.complex(props), issues };
+}
 var EMIT_SCHEMAS = Object.freeze([
   {
     type: "Encounter",
@@ -1620,6 +2346,88 @@ var EMIT_SCHEMAS = Object.freeze([
       occurrenceDateTime: { min: 1, max: 1, types: ["dateTime"] }
     }
   },
+  {
+    // Condition: subject (1..1 Reference) is required. A DG1 with no bundle Patient to anchor never
+    // reaches this gate (the assembly withholds it first); the entry is the defence behind that.
+    type: "Condition",
+    elements: {
+      subject: { min: 1, max: 1, types: ["Reference"] }
+    }
+  },
+  {
+    // Procedure: status (1..1 code) and subject (1..1 Reference) are both required. The status
+    // binding is R4's required EventStatus set, so the value the PR1 map's own row directs is
+    // checked rather than trusted, and a Procedure carrying anything else is withheld.
+    type: "Procedure",
+    elements: {
+      status: {
+        min: 1,
+        max: 1,
+        types: ["code"],
+        binding: {
+          strength: "required",
+          codes: [
+            "preparation",
+            "in-progress",
+            "not-done",
+            "on-hold",
+            "stopped",
+            "completed",
+            "entered-in-error",
+            "unknown"
+          ]
+        }
+      },
+      subject: { min: 1, max: 1, types: ["Reference"] }
+    }
+  },
+  {
+    // Coverage: status (1..1 code), beneficiary (1..1 Reference) and payor (1..* Reference) are all
+    // required. The status is modelled WITHOUT its required binding on purpose: no published row
+    // grounds a coverage status, so the element ships value-absent with a data-absent-reason
+    // extension, which satisfies the cardinality while asserting no member of the value set.
+    type: "Coverage",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      beneficiary: { min: 1, max: 1, types: ["Reference"] },
+      payor: { min: 1, max: fhir.UNBOUNDED, types: ["Reference"] }
+    }
+  },
+  {
+    // AllergyIntolerance: patient (1..1 Reference) is required, so an AL1 with no bundle Patient to
+    // anchor is withheld rather than emitted with a dangling reference. The three coded elements carry
+    // their R4 required bindings: an unmapped code leaves its element absent (never a neighbour), and a
+    // value-absent element carrying only the IG's alternate-codes extension is not a code to check.
+    type: "AllergyIntolerance",
+    elements: {
+      clinicalStatus: { min: 0, max: 1, types: ["CodeableConcept"] },
+      type: {
+        min: 0,
+        max: 1,
+        types: ["code"],
+        binding: { strength: "required", codes: ["allergy", "intolerance"] }
+      },
+      category: {
+        min: 0,
+        max: fhir.UNBOUNDED,
+        types: ["code"],
+        binding: {
+          strength: "required",
+          codes: ["food", "medication", "environment", "biologic"]
+        }
+      },
+      criticality: {
+        min: 0,
+        max: 1,
+        types: ["code"],
+        binding: { strength: "required", codes: ["low", "high", "unable-to-assess"] }
+      },
+      code: { min: 0, max: 1, types: ["CodeableConcept"] },
+      patient: { min: 1, max: 1, types: ["Reference"] },
+      onsetDateTime: { min: 0, max: 1, types: ["dateTime"] },
+      reaction: { min: 0, max: fhir.UNBOUNDED, types: ["BackboneElement"] }
+    }
+  },
   {
     // Appointment: status (1..1 code) and participant (1..* BackboneElement) are both required, so an
     // Appointment whose SCH-25 status could not be grounded via HL70278, or that has no resolvable Patient
@@ -1772,16 +2580,340 @@ function buildImmunization(rxa, rxr, orc, patientFullUrl, encounterFullUrl, ctx)
   }
   return { value: fhir.complex(props), issues };
 }
-var STATUS_UNKNOWN = "unknown";
-var ORDER_INTENT = "order";
-var UNSIGNED_INT = /^(0|[1-9][0-9]*)$/;
-function codeableFrom(seg, index, ctx, issues) {
-  if (seg.field(index).value === "") return void 0;
-  const cc = toFhirCodeableConcept(seg.field(index).asCwe(), ctx);
-  issues.push(...cc.issues);
-  return cc.value;
+var UNITS_OF_TIME = Object.freeze(
+  /* @__PURE__ */ new Set(["s", "min", "h", "d", "wk", "mo", "a"])
+);
+var UCUM_MNEMONICS = Object.freeze(/* @__PURE__ */ new Set(["UCUM", "ISO+"]));
+var HL70335_MNEMONICS = Object.freeze(/* @__PURE__ */ new Set(["HL70335", "0335"]));
+var CONDITION_TEXT_PATH = "MedicationRequest.dosageInstruction.additionalInstruction.text";
+var INSTRUCTION_TEXT_PATH = "MedicationRequest.text";
+function timingPath(target) {
+  return target === "MedicationRequest" ? "MedicationRequest.dosageInstruction.timing" : "ServiceRequest.occurrenceTiming";
 }
-function translatedFrom2(seg, index, map, ctx, issues) {
+var EXPLICIT_NULL = '""';
+function carriesValue(sub) {
+  return sub !== "" && sub !== EXPLICIT_NULL;
+}
+function repetitionValued(rep) {
+  return rep.components.some((c) => c.subcomponents.some(carriesValue));
+}
+function isValued(seg, index) {
+  return seg.field(index).repetitions.some(repetitionValued);
+}
+function subcomponents(rep, component3) {
+  return rep.components[component3 - 1]?.subcomponents ?? [];
+}
+function componentValued(rep, component3) {
+  return subcomponents(rep, component3).some(carriesValue);
+}
+function subcomponent(rep, component3, sub) {
+  return subcomponents(rep, component3)[sub - 1] ?? "";
+}
+function restoreStructuralEmpties(text2, repetitions, enc) {
+  const padded = (part, count) => {
+    const subs = part.split(enc.subcomponent);
+    if (subs.length >= count) return part;
+    return [...subs, ...Array.from({ length: count - subs.length }, () => "")].join(
+      enc.subcomponent
+    );
+  };
+  return text2.split(enc.repetition).map((repetition, r) => {
+    const components = repetitions[r]?.components ?? [];
+    const parts = repetition.split(enc.component);
+    const restored = parts.map(
+      (part, c) => padded(part, components[c]?.subcomponents.length ?? 0)
+    );
+    for (const dropped of components.slice(parts.length))
+      restored.push(padded("", dropped.subcomponents.length));
+    return restored.join(enc.component);
+  }).join(enc.repetition);
+}
+function freeText(seg, field) {
+  const f = seg.field(field);
+  if (f.repetitions.length === 0) return { kind: "absent" };
+  const rendered = hl7.renderText(
+    restoreStructuralEmpties(f.text, f.repetitions, seg.enc),
+    seg.enc
+  ).text;
+  return rendered === "" ? { kind: "unplaceable" } : { kind: "text", text: rendered };
+}
+function txValued(seg, field) {
+  return freeText(seg, field).kind !== "absent";
+}
+var SCHEDULE_NARROWING = Object.freeze([
+  [4, ".event"],
+  [5, ".repeat.offset"],
+  // R4 places every `bounds[x]` on `Timing.repeat`, not on `Timing`, so the element the IG's
+  // TQ1-6 rows would have reached is `...timing.repeat.boundsDuration`: a consumer routing on
+  // `fhirPath` must not be handed a path that resolves to nothing.
+  [6, ".repeat.boundsDuration"],
+  [12, ""],
+  [13, ".repeat.duration"],
+  [14, ".repeat.countMax"]
+]);
+var EXPRESSIBLE_RPT_COMPONENTS = Object.freeze(/* @__PURE__ */ new Set([1, 5, 6, 8]));
+function endPrecedesStart(start, end) {
+  const zoned = (v) => {
+    if (!v.includes("T")) return void 0;
+    const ms = Date.parse(v);
+    return Number.isNaN(ms) ? void 0 : ms;
+  };
+  const startMs = zoned(start);
+  const endMs = zoned(end);
+  if (startMs !== void 0 && endMs !== void 0) return endMs < startMs;
+  const datePart2 = (v) => v.split("T")[0] ?? v;
+  const widen = (v, high) => {
+    const d = datePart2(v);
+    if (d.length === 4) return high ? `${d}-12-31` : `${d}-01-01`;
+    if (d.length === 7) return high ? `${d}-31` : `${d}-01`;
+    return d;
+  };
+  return widen(end, true) < widen(start, false);
+}
+function timingCode(code) {
+  return fhir.complex([
+    {
+      name: "coding",
+      value: fhir.list([
+        fhir.complex([
+          { name: "system", value: fhir.primitive(V2_0335_SYSTEM) },
+          { name: "code", value: fhir.primitive(code) }
+        ])
+      ])
+    }
+  ]);
+}
+function readRepeatPattern(tq1, base, draft, issues) {
+  const valued = tq1.field(3).repetitions.filter(repetitionValued);
+  const rpt = valued[0];
+  if (rpt === void 0) return;
+  if (valued.length > 1) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.3", base));
+    draft.refused = true;
+    return;
+  }
+  const carried = rpt.components.length;
+  for (let component3 = 1; component3 <= carried; component3 += 1) {
+    if (EXPRESSIBLE_RPT_COMPONENTS.has(component3)) continue;
+    if (!componentValued(rpt, component3)) continue;
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, `TQ1.3.${String(component3)}`, base));
+    draft.refused = true;
+  }
+  if (componentValued(rpt, 1)) {
+    const code = subcomponent(rpt, 1, 1);
+    const mnemonic = subcomponent(rpt, 1, 3);
+    const fromTable = mnemonic === "" || HL70335_MNEMONICS.has(mnemonic);
+    if (fromTable && isRepeatPatternCode(code)) {
+      draft.code = timingCode(code);
+    } else {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "TQ1.3.1", `${base}.code`));
+      draft.refused = true;
+    }
+  }
+  if (componentValued(rpt, 5)) {
+    const raw = subcomponent(rpt, 5, 1);
+    let period;
+    try {
+      period = fhir.primitive(fhir.decimal(raw));
+    } catch {
+      period = void 0;
+    }
+    if (period === void 0 || raw.startsWith("-")) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_QUANTITY_VALUE_INVALID, "TQ1.3.5", `${base}.repeat.period`)
+      );
+      draft.refused = true;
+    } else {
+      draft.period = period;
+    }
+  }
+  if (componentValued(rpt, 6)) {
+    const unit = subcomponent(rpt, 6, 1);
+    const mnemonic = subcomponent(rpt, 6, 3);
+    const fromUcum = mnemonic === "" || UCUM_MNEMONICS.has(mnemonic);
+    if (fromUcum && UNITS_OF_TIME.has(unit)) {
+      draft.periodUnit = unit;
+    } else {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "TQ1.3.6", `${base}.repeat.periodUnit`)
+      );
+      draft.refused = true;
+    }
+  }
+  const periodValued = componentValued(rpt, 5);
+  const unitValued = componentValued(rpt, 6);
+  if (periodValued && !unitValued && draft.period !== void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.3.5", `${base}.repeat.period`));
+    draft.refused = true;
+  }
+  if (unitValued && !periodValued && draft.periodUnit !== void 0) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.3.6", `${base}.repeat.periodUnit`)
+    );
+    draft.refused = true;
+  }
+  if (componentValued(rpt, 8)) {
+    const event = subcomponent(rpt, 8, 1);
+    const mnemonic = subcomponent(rpt, 8, 3);
+    const target = translateBound(
+      { identifier: event, nameOfCodingSystem: mnemonic },
+      TIMING_EVENT_VALUE_MAP
+    );
+    if (target === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "TQ1.3.8", `${base}.repeat.when`));
+      draft.refused = true;
+    } else {
+      draft.when = target.code;
+    }
+  }
+}
+function readBounds(tq1, base, ctx, draft, issues) {
+  const endpoint = (field, name) => {
+    if (!isValued(tq1, field)) return void 0;
+    const converted = toFhirDateTime(tq1.field(field).asTs(), ctx.options);
+    issues.push(...converted.issues);
+    if (converted.value === void 0) {
+      issues.push(
+        issue(
+          ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+          `TQ1.${String(field)}`,
+          `${base}.repeat.boundsPeriod.${name}`
+        )
+      );
+      draft.refused = true;
+    }
+    return converted.value;
+  };
+  draft.boundsStart = endpoint(7, "start");
+  draft.boundsEnd = endpoint(8, "end");
+  if (draft.boundsStart !== void 0 && draft.boundsEnd !== void 0 && endPrecedesStart(draft.boundsStart, draft.boundsEnd)) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.8", `${base}.repeat.boundsPeriod.end`)
+    );
+    draft.refused = true;
+  }
+}
+function assembleTiming(draft) {
+  if (draft.refused) return void 0;
+  const bounds = [];
+  if (draft.boundsStart !== void 0)
+    bounds.push({ name: "start", value: fhir.primitive(draft.boundsStart) });
+  if (draft.boundsEnd !== void 0)
+    bounds.push({ name: "end", value: fhir.primitive(draft.boundsEnd) });
+  const repeat = [];
+  if (bounds.length > 0) repeat.push({ name: "boundsPeriod", value: fhir.complex(bounds) });
+  if (draft.period !== void 0) repeat.push({ name: "period", value: draft.period });
+  if (draft.periodUnit !== void 0)
+    repeat.push({ name: "periodUnit", value: fhir.primitive(draft.periodUnit) });
+  if (draft.when !== void 0) repeat.push({ name: "when", value: fhir.list([fhir.primitive(draft.when)]) });
+  const timing = [];
+  if (repeat.length > 0) timing.push({ name: "repeat", value: fhir.complex(repeat) });
+  if (draft.code !== void 0) timing.push({ name: "code", value: draft.code });
+  return timing.length === 0 ? void 0 : fhir.complex(timing);
+}
+function nothing(issues) {
+  return {
+    timing: void 0,
+    conditionText: void 0,
+    instructionText: void 0,
+    issues,
+    contributes: false
+  };
+}
+function readTq1(tq1s, target, ctx) {
+  const issues = [];
+  const base = timingPath(target);
+  if (tq1s.length === 0) return nothing(issues);
+  if (tq1s.length > 1) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1", base));
+    return nothing(issues);
+  }
+  const tq1 = tq1s[0];
+  if (tq1 === void 0) return nothing(issues);
+  if (isValued(tq1, 2)) {
+    issues.push(
+      issue(
+        ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+        "TQ1.2",
+        target === "MedicationRequest" ? "MedicationRequest.dosageInstruction.doseAndRate.doseQuantity" : "ServiceRequest.quantityQuantity"
+      )
+    );
+  }
+  if (isValued(tq1, 9)) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.9", `${target}.priority`));
+  }
+  const draft = {
+    refused: false,
+    code: void 0,
+    period: void 0,
+    periodUnit: void 0,
+    when: void 0,
+    boundsStart: void 0,
+    boundsEnd: void 0
+  };
+  for (const [field, suffix] of SCHEDULE_NARROWING) {
+    if (!isValued(tq1, field)) continue;
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, `TQ1.${String(field)}`, `${base}${suffix}`)
+    );
+    draft.refused = true;
+  }
+  readRepeatPattern(tq1, base, draft, issues);
+  readBounds(tq1, base, ctx, draft, issues);
+  const timing = assembleTiming(draft);
+  let conditionText;
+  let instructionText;
+  if (target === "MedicationRequest") {
+    const condition = freeText(tq1, 10);
+    if (condition.kind === "text") conditionText = condition.text;
+    else if (condition.kind === "unplaceable")
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.10", CONDITION_TEXT_PATH));
+    const instruction = freeText(tq1, 11);
+    if (instruction.kind === "unplaceable") {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.11", INSTRUCTION_TEXT_PATH));
+    } else if (instruction.kind === "text") {
+      if (instruction.text.trim() === "")
+        issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.11", INSTRUCTION_TEXT_PATH));
+      else instructionText = instruction.text;
+    }
+  } else {
+    if (txValued(tq1, 10))
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.10", "ServiceRequest"));
+    if (txValued(tq1, 11))
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TQ1.11", "ServiceRequest.note"));
+  }
+  return {
+    timing,
+    conditionText,
+    instructionText,
+    issues,
+    contributes: timing !== void 0 || conditionText !== void 0 || instructionText !== void 0
+  };
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function narrative(value) {
+  return fhir.complex([
+    { name: "status", value: fhir.primitive("additional") },
+    {
+      name: "div",
+      value: fhir.primitive(`<div xmlns="http://www.w3.org/1999/xhtml">${escapeXml(value)}</div>`)
+    }
+  ]);
+}
+
+// src/messages/medication-request.ts
+var STATUS_UNKNOWN = "unknown";
+var ORDER_INTENT = "order";
+var UNSIGNED_INT = /^(0|[1-9][0-9]*)$/;
+function codeableFrom(seg, index, ctx, issues) {
+  if (seg.field(index).value === "") return void 0;
+  const cc = toFhirCodeableConcept(seg.field(index).asCwe(), ctx);
+  issues.push(...cc.issues);
+  return cc.value;
+}
+function translatedFrom2(seg, index, map, ctx, issues) {
   if (seg.field(index).value === "") return void 0;
   const cc = toFhirCodeableConceptVia(seg.field(index).asCwe(), map, ctx);
   issues.push(...cc.issues);
@@ -1801,8 +2933,17 @@ function doseEndpoint(rxo, amountIndex, units, ctx, issues) {
   issues.push(...q.issues);
   return q.value;
 }
-function buildDosageInstruction(rxo, rxr, ctx, issues) {
+function buildDosageInstruction(rxo, rxr, tq1, ctx, issues) {
   const props = [];
+  if (tq1?.conditionText !== void 0) {
+    props.push({
+      name: "additionalInstruction",
+      value: fhir.list([fhir.complex([{ name: "text", value: fhir.primitive(tq1.conditionText) }])])
+    });
+  }
+  if (tq1?.timing !== void 0) {
+    props.push({ name: "timing", value: tq1.timing });
+  }
   if (rxr !== void 0) {
     const route = translatedFrom2(rxr, 1, ROUTE_VALUE_MAP, ctx, issues);
     if (route !== void 0) props.push({ name: "route", value: route });
@@ -1858,8 +2999,9 @@ function buildDispenseRequest(rxo, ctx, issues) {
   }
   return props.length === 0 ? void 0 : fhir.complex(props);
 }
-function buildMedicationRequest(rxo, rxr, orc, subjectFullUrl, encounterFullUrl, ctx) {
+function buildMedicationRequest(rxo, rxr, orc, tq1, subjectFullUrl, encounterFullUrl, ctx) {
   const issues = [];
+  if (tq1 !== void 0) issues.push(...tq1.issues);
   if (rxo === void 0 || rxo.field(1).value === "") return { value: void 0, issues };
   const medication = toFhirCodeableConcept(rxo.field(1).asCwe(), ctx);
   issues.push(...medication.issues);
@@ -1867,6 +3009,9 @@ function buildMedicationRequest(rxo, rxr, orc, subjectFullUrl, encounterFullUrl,
   const props = [
     { name: "resourceType", value: fhir.primitive("MedicationRequest") }
   ];
+  if (tq1?.instructionText !== void 0) {
+    props.push({ name: "text", value: narrative(tq1.instructionText) });
+  }
   props.push({ name: "status", value: fhir.primitive(STATUS_UNKNOWN) });
   issues.push(
     issue(ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN, "RXO", "MedicationRequest.status")
@@ -1883,7 +3028,7 @@ function buildMedicationRequest(rxo, rxr, orc, subjectFullUrl, encounterFullUrl,
     if (authored.value !== void 0)
       props.push({ name: "authoredOn", value: fhir.primitive(authored.value) });
   }
-  const dosage = buildDosageInstruction(rxo, rxr, ctx, issues);
+  const dosage = buildDosageInstruction(rxo, rxr, tq1, ctx, issues);
   if (dosage !== void 0) props.push({ name: "dosageInstruction", value: fhir.list([dosage]) });
   const dispense = buildDispenseRequest(rxo, ctx, issues);
   if (dispense !== void 0) props.push({ name: "dispenseRequest", value: dispense });
@@ -1938,6 +3083,40 @@ function buildMessageHeader(meta, focusFullUrls) {
   }
   return { value: fhir.complex(props), issues };
 }
+var DEFERRED_NOTE_ROWS = Object.freeze([
+  [4, "Annotation.extension"],
+  [5, "Annotation.authorReference"]
+]);
+function annotationTime(nte, ctx, issues) {
+  if (nte.field(6).value === "") return void 0;
+  const entered = toFhirDateTime(nte.field(6).asTs(), ctx.options);
+  issues.push(...entered.issues);
+  return entered.value === void 0 ? void 0 : fhir.primitive(entered.value);
+}
+function buildAnnotations(notes, ctx, issues) {
+  const annotations = [];
+  for (const nte of notes) {
+    for (const [field, path] of DEFERRED_NOTE_ROWS) {
+      if (nte.field(field).value !== "") {
+        issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, `NTE.${String(field)}`, path));
+      }
+    }
+    const comment = nte.field(3);
+    if (comment.repetitions.length === 0) continue;
+    const time = annotationTime(nte, ctx, issues);
+    for (const repetition of comment.text.split(nte.enc.repetition)) {
+      const rendered = hl7.renderText(repetition, nte.enc).text;
+      if (rendered === "") continue;
+      const props = [];
+      if (time !== void 0) props.push({ name: "time", value: time });
+      props.push({ name: "text", value: fhir.primitive(rendered) });
+      annotations.push(fhir.complex(props));
+    }
+  }
+  return annotations.length === 0 ? void 0 : fhir.list(annotations);
+}
+
+// src/messages/observation.ts
 var V3_OBSERVATION_INTERPRETATION_SYSTEM = "http://terminology.hl7.org/CodeSystem/v3-ObservationInterpretation";
 var HL70078_INTERPRETATION_CODES = /* @__PURE__ */ new Set([
   "<",
@@ -1989,6 +3168,10 @@ var OBSERVATION_STATUS_MAP = Object.freeze({
   W: "entered-in-error",
   X: "cancelled"
 });
+var OBSERVATION_VALUE_ATTACHMENT_EXTENSION_URL = "https://hl7.org/fhir/5.0/StructureDefinition/extension-Observation.valueAttachment";
+var ED_BASE64_ENCODING = "Base64";
+var SAMPLED_DATA_ABSENT_POINT = "E";
+var SAMPLED_DATA_UNGROUNDED = "unknown";
 var SN_COMPARATORS = /* @__PURE__ */ new Set([">", "<", ">=", "<="]);
 var CODED_VALUE_TYPES = /* @__PURE__ */ new Set(["CWE", "CE", "CF", "CNE", "IS"]);
 var DATETIME_VALUE_TYPES = /* @__PURE__ */ new Set(["DT", "DTM", "TS"]);
@@ -1997,6 +3180,117 @@ function rawComponent2(field, index) {
   const c = field.repetitions[0]?.components[index]?.subcomponents[0];
   return c === void 0 || c === "" ? void 0 : c;
 }
+function fieldEmpty(field) {
+  return field.repetitions.every(
+    (r) => r.components.every((c) => c.subcomponents.every((s) => s === ""))
+  );
+}
+function buildPeriodValue(field, ctx, issues) {
+  const props = [];
+  for (const [index, name] of [
+    [0, "start"],
+    [1, "end"]
+  ]) {
+    const raw = rawComponent2(field, index);
+    if (raw === void 0) continue;
+    const converted = toFhirDateTime(hl7.parseDtm(raw), ctx.options);
+    issues.push(...converted.issues);
+    if (converted.value !== void 0) props.push({ name, value: fhir.primitive(converted.value) });
+  }
+  return props.length === 0 ? void 0 : fhir.complex(props);
+}
+function rangeBound(raw, fhirPath, issues) {
+  if (raw === void 0) return void 0;
+  try {
+    return fhir.complex([{ name: "value", value: fhir.primitive(fhir.decimal(raw)) }]);
+  } catch {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_QUANTITY_VALUE_INVALID, "OBX.5", fhirPath));
+    return void 0;
+  }
+}
+function buildRangeValue(field, issues) {
+  const low = rangeBound(rawComponent2(field, 0), "Range.low.value", issues);
+  const high = rangeBound(rawComponent2(field, 1), "Range.high.value", issues);
+  const props = [];
+  if (low !== void 0) props.push({ name: "low", value: low });
+  if (high !== void 0) props.push({ name: "high", value: high });
+  return props.length === 0 ? void 0 : fhir.complex(props);
+}
+function timeValue(raw) {
+  const parts = /^(\d{2})(\d{2})(\d{2})(\.\d{1,4})?$/.exec(raw);
+  if (parts === null) return void 0;
+  const candidate = `${parts[1] ?? ""}:${parts[2] ?? ""}:${parts[3] ?? ""}${parts[4] ?? ""}`;
+  return fhir.validatePrimitiveValue(candidate, "time") === "ok" ? candidate : void 0;
+}
+function buildSampledData(field, issues) {
+  const rows = field.repetitions.map((r) => r.components.map((c) => c.subcomponents[0] ?? ""));
+  if (rows.length === 0) return void 0;
+  const width = Math.max(...rows.map((r) => r.length));
+  const dimensions = rows.length === 1 ? 1 : width;
+  const points = [];
+  for (const row of rows) {
+    for (let i = 0; i < width; i++) {
+      const cell = row[i] ?? "";
+      if (cell === "") {
+        points.push(SAMPLED_DATA_ABSENT_POINT);
+        continue;
+      }
+      try {
+        fhir.decimal(cell);
+        points.push(cell);
+      } catch {
+        issues.push(
+          issue(ISSUE_CODES.TRANSFORM_QUANTITY_VALUE_INVALID, "OBX.5", "SampledData.data")
+        );
+        return void 0;
+      }
+    }
+  }
+  for (const path of ["SampledData.origin", "SampledData.period"]) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN, "OBX.5", path));
+  }
+  return fhir.complex([
+    { name: "origin", value: dataAbsentComplex(SAMPLED_DATA_UNGROUNDED) },
+    { name: "period", value: dataAbsent(SAMPLED_DATA_UNGROUNDED) },
+    { name: "dimensions", value: fhir.primitive(fhir.decimal(String(dimensions))) },
+    { name: "data", value: fhir.primitive(points.join(" ")) }
+  ]);
+}
+function buildAttachmentExtension(field, issues) {
+  const payload = rawComponent2(field, 4);
+  if (payload === void 0) return void 0;
+  const attachment = [];
+  const subtype = rawComponent2(field, 2);
+  const typeOfData = rawComponent2(field, 1);
+  if (subtype === void 0 && typeOfData !== void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "OBX.5", "Attachment.contentType"));
+    attachment.push({
+      name: "extension",
+      value: fhir.list([
+        fhir.complex([
+          { name: "url", value: fhir.primitive(ALTERNATE_CODES_EXTENSION_URL) },
+          {
+            name: "valueCodeableConcept",
+            value: fhir.complex([
+              {
+                name: "coding",
+                value: fhir.list([fhir.complex([{ name: "code", value: fhir.primitive(typeOfData) }])])
+              }
+            ])
+          }
+        ])
+      ])
+    });
+  }
+  if (subtype !== void 0) attachment.push({ name: "contentType", value: fhir.primitive(subtype) });
+  attachment.push({ name: "data", value: fhir.primitive(payload) });
+  return fhir.list([
+    fhir.complex([
+      { name: "url", value: fhir.primitive(OBSERVATION_VALUE_ATTACHMENT_EXTENSION_URL) },
+      { name: "valueAttachment", value: fhir.complex(attachment) }
+    ])
+  ]);
+}
 function snText(field) {
   return [0, 1, 2, 3].map((i) => rawComponent2(field, i) ?? "").join("");
 }
@@ -2052,10 +3346,39 @@ function buildSnValue(field, units, ctx, issues) {
   }
   return valueStringProp(snText(field));
 }
+var COMPOSITE_VALUE_TYPES = /* @__PURE__ */ new Set(["DR", "NR", "TM", "NA", "ED"]);
+function buildMappedValue(field, vt, ctx, issues) {
+  if (vt === "DR") {
+    const period = buildPeriodValue(field, ctx, issues);
+    return period === void 0 ? void 0 : { name: "valuePeriod", value: period };
+  }
+  if (vt === "NR") {
+    const range = buildRangeValue(field, issues);
+    return range === void 0 ? void 0 : { name: "valueRange", value: range };
+  }
+  if (vt === "TM") {
+    const time = timeValue(field.text);
+    return time === void 0 ? void 0 : { name: "valueTime", value: fhir.primitive(time) };
+  }
+  if (vt === "NA") {
+    const sampled = buildSampledData(field, issues);
+    return sampled === void 0 ? void 0 : { name: "valueSampledData", value: sampled };
+  }
+  if (rawComponent2(field, 3) !== ED_BASE64_ENCODING) return void 0;
+  const extension = buildAttachmentExtension(field, issues);
+  return extension === void 0 ? void 0 : { name: "extension", value: extension };
+}
 function buildValue(obx, valueType, ctx, issues) {
   const field = obx.field(5);
   const rawValue = field.value;
   const vt = valueType.toUpperCase();
+  if (COMPOSITE_VALUE_TYPES.has(vt)) {
+    if (fieldEmpty(field)) return void 0;
+    const mapped = buildMappedValue(field, vt, ctx, issues);
+    if (mapped !== void 0) return mapped;
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "OBX.5", "Observation.value[x]"));
+    return valueStringProp(field.text);
+  }
   if (vt === "NM") {
     const q = quantityFromRawMagnitude(field.asNm().raw, obx.field(6).asCwe(), ctx);
     issues.push(...q.issues);
@@ -2108,7 +3431,7 @@ function buildInterpretation(obx, issues) {
   }
   return codings.length === 0 ? void 0 : fhir.list(codings);
 }
-function buildObservation(obx, subjectFullUrl, encounterFullUrl, ctx) {
+function buildObservation(obx, subjectFullUrl, encounterFullUrl, ctx, notes = []) {
   const issues = [];
   const props = [
     { name: "resourceType", value: fhir.primitive("Observation") }
@@ -2142,6 +3465,8 @@ function buildObservation(obx, subjectFullUrl, encounterFullUrl, ctx) {
   if (value !== void 0) props.push(value);
   const interpretation = buildInterpretation(obx, issues);
   if (interpretation !== void 0) props.push({ name: "interpretation", value: interpretation });
+  const note = buildAnnotations(notes, ctx, issues);
+  if (note !== void 0) props.push({ name: "note", value: note });
   const refRange = obx.field(7).value;
   if (refRange !== "") {
     props.push({
@@ -2158,7 +3483,13 @@ function collectOrderGroups(msg) {
   let current;
   let rxeCount = 0;
   const open = () => {
-    const g = { orc: void 0, obr: void 0, rxo: void 0, rxrs: [] };
+    const g = {
+      orc: void 0,
+      obr: void 0,
+      rxo: void 0,
+      rxrs: [],
+      tq1s: []
+    };
     groups.push(g);
     current = g;
     return g;
@@ -2179,13 +3510,22 @@ function collectOrderGroups(msg) {
       case "RXR":
         if (current !== void 0) current.rxrs.push(seg);
         break;
+      case "TQ1":
+        if (current !== void 0) current.tq1s.push(seg);
+        break;
       case "RXE":
         rxeCount += 1;
         break;
     }
   }
   return {
-    groups: groups.map((g) => ({ orc: g.orc, obr: g.obr, rxo: g.rxo, rxrs: g.rxrs })),
+    groups: groups.map((g) => ({
+      orc: g.orc,
+      obr: g.obr,
+      rxo: g.rxo,
+      rxrs: g.rxrs,
+      tq1s: g.tq1s
+    })),
     rxeCount
   };
 }
@@ -2194,14 +3534,29 @@ function collectOrderGroups(msg) {
 function collectReportGroups(msg) {
   const groups = [];
   let current;
+  let openObservation;
   let orphanObxCount = 0;
   for (const seg of msg.allSegments()) {
+    if (seg.type === "NTE") {
+      if (openObservation !== void 0) openObservation.notes.push(seg);
+      continue;
+    }
+    if (seg.type === "OBX") {
+      if (current === void 0) {
+        orphanObxCount += 1;
+        openObservation = void 0;
+        continue;
+      }
+      openObservation = { obx: seg, notes: [] };
+      current.observations.push(openObservation);
+      continue;
+    }
+    openObservation = void 0;
     if (seg.type === "OBR") {
-      current = { obr: seg, observations: [] };
+      current = { obr: seg, observations: [], specimens: [] };
       groups.push(current);
-    } else if (seg.type === "OBX") {
-      if (current === void 0) orphanObxCount += 1;
-      else current.observations.push(seg);
+    } else if (seg.type === "SPM" && current !== void 0) {
+      current.specimens.push(seg);
     }
   }
   return { groups, orphanObxCount };
@@ -2303,6 +3658,131 @@ function buildRelatedPerson(nk1, patientFullUrl, ctx, setIndex) {
   if (!hasContent) return { value: void 0, issues };
   return { value: fhir.complex(props), issues };
 }
+
+// src/messages/ig-segment-maps.ts
+var IG_SEGMENT_MAPS_VERSION = "1.0.0";
+var IG_SEGMENT_MAPS_PUBLISHED = "2025-10-07";
+var IG_SEGMENT_MAPS_RETRIEVED = "2026-08-22";
+var IG_SEGMENT_MAPS_SOURCE = "https://hl7.org/fhir/uv/v2mappings/segment_maps.html";
+var IG_MAPPED_SEGMENT_NAMES = Object.freeze(
+  /* @__PURE__ */ new Set([
+    "AIG",
+    "AIL",
+    "AIP",
+    "AIS",
+    "AL1",
+    "DG1",
+    "EVN",
+    "IAM",
+    "IN1",
+    "IN3",
+    "MRG",
+    "MSA",
+    "MSH",
+    "NK1",
+    "NTE",
+    "OBR",
+    "OBX",
+    "ORC",
+    "PD1",
+    "PID",
+    "PR1",
+    "PRT",
+    "PV1",
+    "PV2",
+    "ROL",
+    "RXA",
+    "RXO",
+    "RXR",
+    "SCH",
+    "SFT",
+    "SPM",
+    "TQ1",
+    "TXA"
+  ])
+);
+function isIgMappedSegmentName(name) {
+  return IG_MAPPED_SEGMENT_NAMES.has(name);
+}
+
+// src/messages/segment-completeness.ts
+var SEGMENT_IDENTIFIER_SHAPE = /^[A-Z][A-Za-z0-9]{2}$/;
+function isWellFormedSegmentName(name) {
+  return SEGMENT_IDENTIFIER_SHAPE.test(name);
+}
+function enumerateSegmentOccurrences(msg) {
+  const occurrences = [];
+  const seenPerName = /* @__PURE__ */ new Map();
+  for (const [i, segment] of msg.allSegments().entries()) {
+    if (segment.type === "" && segment.fields.length === 0) continue;
+    if (isWellFormedSegmentName(segment.type)) {
+      const nameIndex = (seenPerName.get(segment.type) ?? 0) + 1;
+      seenPerName.set(segment.type, nameIndex);
+      occurrences.push({ segment, ordinal: i + 1, name: segment.type, nameIndex });
+    } else {
+      occurrences.push({ segment, ordinal: i + 1, name: void 0, nameIndex: void 0 });
+    }
+  }
+  return occurrences;
+}
+function segmentOccurrenceLocation(occurrence) {
+  return occurrence.name !== void 0 && occurrence.nameIndex !== void 0 ? `${occurrence.name}[${String(occurrence.nameIndex)}]` : `[#${String(occurrence.ordinal)}]`;
+}
+var SegmentReachLedger = class {
+  occurrences;
+  reached = /* @__PURE__ */ new Set();
+  /**
+   * @param msg - The parsed message whose occurrences are being tracked.
+   */
+  constructor(msg) {
+    this.occurrences = enumerateSegmentOccurrences(msg);
+  }
+  /**
+   * Record that each given segment contributed to a resource now present in the bundle. `undefined`
+   * entries are ignored, so a call site can pass an optional part of a group without branching.
+   */
+  mark(...segments) {
+    for (const segment of segments) {
+      if (segment !== void 0) this.reached.add(segment);
+    }
+  }
+  /**
+   * Record that the FIRST occurrence of `type` contributed. The parser's derived views (`patient`,
+   * `visit`, `meta`) are built from the first segment of their type, so this is how a resource built
+   * from a view marks the occurrence it came from.
+   */
+  markFirstOfType(type) {
+    const found = this.occurrences.find((o) => o.name === type);
+    if (found !== void 0) this.reached.add(found.segment);
+  }
+  /**
+   * Record that the `index`-th (0-based) occurrence of `type` contributed: the counterpart of
+   * {@link SegmentReachLedger.markFirstOfType} for the repeating views (`nextOfKin()`), whose
+   * entries are in document order.
+   */
+  markNthOfType(type, index) {
+    const matching = this.occurrences.filter((o) => o.name === type);
+    const found = matching[index];
+    if (found !== void 0) this.reached.add(found.segment);
+  }
+  /** The occurrences that contributed to no resource present in the bundle, in message order. */
+  reportable() {
+    return this.occurrences.filter((o) => !this.reached.has(o.segment));
+  }
+  /**
+   * One value-free issue per reportable occurrence, in message order: the library-gap code when the
+   * IG publishes a segment map for the name, the standard-gap code otherwise, and the standard-gap
+   * code for every name that could not be classified at all.
+   */
+  issues() {
+    return this.reportable().map(
+      (occurrence) => issue(
+        occurrence.name !== void 0 && isIgMappedSegmentName(occurrence.name) ? ISSUE_CODES.TRANSFORM_SEGMENT_NOT_EMITTED : ISSUE_CODES.TRANSFORM_SEGMENT_NO_IG_MAP,
+        segmentOccurrenceLocation(occurrence)
+      )
+    );
+  }
+};
 var REQUEST_STATUS_MAP = Object.freeze({
   AF: "active",
   CA: "active",
@@ -2333,8 +3813,9 @@ var ORDER_INTENT2 = "order";
 function fieldValue(seg, index) {
   return seg === void 0 ? "" : seg.field(index).value;
 }
-function buildServiceRequest(orc, obr, subjectFullUrl, encounterFullUrl, ctx) {
+function buildServiceRequest(orc, obr, tq1, subjectFullUrl, encounterFullUrl, ctx) {
   const issues = [];
+  if (tq1 !== void 0) issues.push(...tq1.issues);
   if (orc === void 0 && obr === void 0) return { value: void 0, issues };
   const props = [
     { name: "resourceType", value: fhir.primitive("ServiceRequest") }
@@ -2388,8 +3869,16 @@ function buildServiceRequest(orc, obr, subjectFullUrl, encounterFullUrl, ctx) {
   if (obr !== void 0 && obr.field(6).value !== "") {
     const occurrence = toFhirDateTime(obr.field(6).asTs(), ctx.options);
     issues.push(...occurrence.issues);
-    if (occurrence.value !== void 0)
+    if (occurrence.value !== void 0 && tq1?.timing === void 0) {
       props.push({ name: "occurrenceDateTime", value: fhir.primitive(occurrence.value) });
+    } else if (occurrence.value !== void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "OBR.6", "ServiceRequest.occurrenceDateTime")
+      );
+    }
+  }
+  if (tq1?.timing !== void 0) {
+    props.push({ name: "occurrenceTiming", value: tq1.timing });
   }
   if (obr !== void 0 && obr.field(31).value !== "") {
     const reason = toFhirCodeableConcept(obr.field(31).asCwe(), ctx);
@@ -2398,6 +3887,122 @@ function buildServiceRequest(orc, obr, subjectFullUrl, encounterFullUrl, ctx) {
   }
   return { value: fhir.complex(props), issues };
 }
+var SPM_SHIPMENT_IDENTIFIER_TYPE = "SHIP";
+var DEFERRED_SPECIMEN_ROWS = Object.freeze([
+  [3, "Specimen.parent"],
+  [12, "Specimen.collection.quantity"],
+  [20, "Specimen.status"]
+]);
+function subcomponent2(spm, field, component3, sub) {
+  return spm.field(field).repetitions[0]?.components[component3 - 1]?.subcomponents[sub - 1] ?? "";
+}
+function codeable(spm, field, ctx, issues) {
+  const converted = toFhirCodeableConcept(spm.field(field).asCwe(), ctx);
+  issues.push(...converted.issues);
+  return converted.value;
+}
+function identifierFrom(spm, field, ctx, issues) {
+  const converted = toFhirIdentifier(spm.field(field).asCx(), ctx);
+  issues.push(...converted.issues);
+  return converted.value;
+}
+function buildIdentifiers(spm, ctx, issues) {
+  const identifiers = [];
+  for (const component3 of [1, 2]) {
+    const entityId = subcomponent2(spm, 2, component3, 1);
+    if (entityId !== "") {
+      identifiers.push(fhir.complex([{ name: "value", value: fhir.primitive(entityId) }]));
+    }
+  }
+  const other = identifierFrom(spm, 31, ctx, issues);
+  if (other !== void 0) identifiers.push(other);
+  const shipment = orderIdentifier(spm.field(32).value, SPM_SHIPMENT_IDENTIFIER_TYPE);
+  if (shipment !== void 0) identifiers.push(shipment);
+  return identifiers;
+}
+function buildCollection(spm, ctx, issues) {
+  const props = [];
+  const method = codeable(spm, 7, ctx, issues);
+  if (method !== void 0) props.push({ name: "method", value: method });
+  const bodySite = codeable(spm, 8, ctx, issues);
+  if (bodySite !== void 0) props.push({ name: "bodySite", value: bodySite });
+  const start = subcomponent2(spm, 17, 1, 1);
+  const end = subcomponent2(spm, 17, 2, 1);
+  const bounds = [];
+  for (const [raw, name] of [
+    [start, "start"],
+    [end, "end"]
+  ]) {
+    if (raw === "") continue;
+    const converted = toFhirDateTime(hl7.parseDtm(raw), ctx.options);
+    issues.push(...converted.issues);
+    if (converted.value !== void 0) bounds.push({ name, value: fhir.primitive(converted.value) });
+  }
+  if (end !== "" && bounds.length > 0) {
+    props.push({ name: "collectedPeriod", value: fhir.complex(bounds) });
+  } else if (bounds[0] !== void 0) {
+    props.push({ name: "collectedDateTime", value: bounds[0].value });
+  }
+  return props.length === 0 ? void 0 : fhir.complex(props);
+}
+function buildContainer(spm, ctx, issues) {
+  const props = [];
+  const type = codeable(spm, 27, ctx, issues);
+  if (type !== void 0) props.push({ name: "type", value: type });
+  const additive = codeable(spm, 6, ctx, issues);
+  if (additive !== void 0) props.push({ name: "additiveCodeableConcept", value: additive });
+  return props.length === 0 ? void 0 : fhir.list([fhir.complex(props)]);
+}
+function buildDescriptionNotes(spm) {
+  const annotations = [];
+  for (const repetition of spm.field(14).repetitions) {
+    const text2 = repetition.components[0]?.subcomponents[0] ?? "";
+    if (text2 === "") continue;
+    annotations.push(fhir.complex([{ name: "text", value: fhir.primitive(text2) }]));
+  }
+  return annotations.length === 0 ? void 0 : fhir.list(annotations);
+}
+function buildSpecimen(spm, subjectFullUrl, ctx) {
+  const issues = [];
+  for (const [field, path] of DEFERRED_SPECIMEN_ROWS) {
+    if (spm.field(field).value !== "") {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, `SPM.${String(field)}`, path));
+    }
+  }
+  const props = [];
+  const identifiers = buildIdentifiers(spm, ctx, issues);
+  if (identifiers.length > 0) props.push({ name: "identifier", value: fhir.list(identifiers) });
+  const accession = identifierFrom(spm, 30, ctx, issues);
+  if (accession !== void 0) props.push({ name: "accessionIdentifier", value: accession });
+  const type = codeable(spm, 4, ctx, issues);
+  if (type !== void 0) props.push({ name: "type", value: type });
+  if (subjectFullUrl !== void 0) {
+    props.push({
+      name: "subject",
+      value: fhir.complex([{ name: "reference", value: fhir.primitive(subjectFullUrl) }])
+    });
+  }
+  if (spm.field(18).value !== "") {
+    const received = toFhirDateTime(spm.field(18).asTs(), ctx.options);
+    issues.push(...received.issues);
+    if (received.value !== void 0) {
+      props.push({ name: "receivedTime", value: fhir.primitive(received.value) });
+    }
+  }
+  const collection = buildCollection(spm, ctx, issues);
+  if (collection !== void 0) props.push({ name: "collection", value: collection });
+  const container = buildContainer(spm, ctx, issues);
+  if (container !== void 0) props.push({ name: "container", value: container });
+  const condition = codeable(spm, 24, ctx, issues);
+  if (condition !== void 0) props.push({ name: "condition", value: fhir.list([condition]) });
+  const note = buildDescriptionNotes(spm);
+  if (note !== void 0) props.push({ name: "note", value: note });
+  if (props.every((p) => p.name === "subject")) return { value: void 0, issues };
+  return {
+    value: fhir.complex([{ name: "resourceType", value: fhir.primitive("Specimen") }, ...props]),
+    issues
+  };
+}
 
 // src/messages/to-fhir.ts
 var IG_MAPPED_ADT_TRIGGERS = /* @__PURE__ */ new Set([
@@ -2414,9 +4019,12 @@ var IG_MAPPED_ORDER_TRIGGERS = /* @__PURE__ */ new Set(["ORM^O01", "OML^O21"]);
 var IG_MAPPED_IMMUNIZATION_TRIGGERS = /* @__PURE__ */ new Set(["V04"]);
 var IG_MAPPED_APPOINTMENT_TRIGGERS = /* @__PURE__ */ new Set(["S12"]);
 var IG_MAPPED_DOCUMENT_TRIGGERS = /* @__PURE__ */ new Set(["T02"]);
-function passesEmitGate(resource, v2Location, fhirPath, issues) {
+function clearsEmitGate(resource) {
   const result = fhir.resourceType(resource) === "Patient" ? fhir.validateResource(resource, { mode: "strict" }) : fhir.validateResource(resource, { mode: "lenient", schemas: EMIT_SCHEMAS });
-  if (result.valid) return true;
+  return result.valid;
+}
+function passesEmitGate(resource, v2Location, fhirPath, issues) {
+  if (clearsEmitGate(resource)) return true;
   issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_INVALID, v2Location, fhirPath));
   return false;
 }
@@ -2455,6 +4063,7 @@ function toFhir(msg, opts = {}) {
   const namingSystem = opts.namingSystem ?? createNamingSystem();
   const ctx = { namingSystem, options: opts };
   const ids = new IdAllocator(opts);
+  const reach = new SegmentReachLedger(msg);
   const code = msg.meta.messageCode;
   const trigger = msg.meta.triggerEvent;
   const messageMapGrounded = trigger !== void 0 && (code === "ADT" && IG_MAPPED_ADT_TRIGGERS.has(trigger) || code === "ORU" && IG_MAPPED_ORU_TRIGGERS.has(trigger) || code === "VXU" && IG_MAPPED_IMMUNIZATION_TRIGGERS.has(trigger) || code === "SIU" && IG_MAPPED_APPOINTMENT_TRIGGERS.has(trigger) || code === "MDM" && IG_MAPPED_DOCUMENT_TRIGGERS.has(trigger) || IG_MAPPED_ORDER_TRIGGERS.has(`${code ?? ""}^${trigger}`));
@@ -2470,16 +4079,20 @@ function toFhir(msg, opts = {}) {
     if (built.value !== void 0 && passesEmitGate(built.value, "PID", "Patient", issues)) {
       patientFullUrl = ids.next();
       focalEntries.push({ fullUrl: patientFullUrl, resource: built.value });
+      reach.markFirstOfType("PID");
     }
   }
   let encounterFullUrl;
+  let encounterEntryIndex = -1;
   const visitView = msg.visit;
   if (visitView !== void 0) {
     const built = buildEncounter(visitView, patientFullUrl, ctx);
     issues.push(...built.issues);
     if (built.value !== void 0 && passesEmitGate(built.value, "PV1", "Encounter", issues)) {
       encounterFullUrl = ids.next();
+      encounterEntryIndex = focalEntries.length;
       focalEntries.push({ fullUrl: encounterFullUrl, resource: built.value });
+      reach.markFirstOfType("PV1");
     }
   }
   const nextOfKin = msg.nextOfKin();
@@ -2491,11 +4104,116 @@ function toFhir(msg, opts = {}) {
       issues.push(...built.issues);
       if (built.value !== void 0 && passesEmitGate(built.value, `NK1[${String(i)}]`, "RelatedPerson", issues)) {
         focalEntries.push({ fullUrl: ids.next(), resource: built.value });
+        reach.markNthOfType("NK1", i);
       }
     }
   } else if (nextOfKin.length > 0) {
     issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "NK1", "RelatedPerson.patient"));
   }
+  const allergyFullUrls = [];
+  const allergies = collectAllergies(msg);
+  for (let i = 0; i < allergies.length; i++) {
+    const al1 = allergies[i];
+    if (al1 === void 0) continue;
+    const location = `AL1[${String(i)}]`;
+    if (patientFullUrl === void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, location, "AllergyIntolerance.patient")
+      );
+      continue;
+    }
+    const emitted = emitAllergyIntolerance(
+      al1,
+      patientFullUrl,
+      msg.meta.version,
+      ctx,
+      clearsEmitGate,
+      location
+    );
+    issues.push(...emitted.issues);
+    if (emitted.value === void 0) continue;
+    const url = ids.next();
+    allergyFullUrls.push(url);
+    focalEntries.push({ fullUrl: url, resource: emitted.value });
+    reach.mark(al1);
+  }
+  const conditionFullUrls = [];
+  const diagnoses = collectDiagnoses(msg);
+  for (let i = 0; i < diagnoses.length; i++) {
+    const dg1 = diagnoses[i];
+    if (dg1 === void 0) continue;
+    const location = `DG1[${String(i)}]`;
+    issues.push(...deferredDiagnosisIssues(dg1));
+    if (patientFullUrl === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, location, "Condition.subject"));
+      continue;
+    }
+    const built = buildCondition(dg1, patientFullUrl, ctx, location);
+    issues.push(...built.issues);
+    if (built.value === void 0) continue;
+    if (!passesEmitGate(built.value, location, "Condition", issues)) continue;
+    const url = ids.next();
+    conditionFullUrls.push(url);
+    focalEntries.push({ fullUrl: url, resource: built.value });
+    reach.mark(dg1);
+  }
+  if (diagnoses.length > 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "DG1", "EpisodeOfCare"));
+  }
+  if (conditionFullUrls.length > 0 && encounterEntryIndex >= 0) {
+    const emitted = focalEntries[encounterEntryIndex];
+    if (emitted !== void 0) {
+      const linked = emitEncounterDiagnosis(emitted.resource, conditionFullUrls, clearsEmitGate);
+      issues.push(...linked.issues);
+      if (linked.value !== void 0) {
+        focalEntries[encounterEntryIndex] = { fullUrl: emitted.fullUrl, resource: linked.value };
+      }
+    }
+  }
+  const procedureFullUrls = [];
+  const procedures = collectProcedures(msg);
+  for (let i = 0; i < procedures.length; i++) {
+    const pr1 = procedures[i];
+    if (pr1 === void 0) continue;
+    const location = `PR1[${String(i)}]`;
+    issues.push(...deferredProcedureIssues(pr1));
+    if (patientFullUrl === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, location, "Procedure.subject"));
+      continue;
+    }
+    const built = buildProcedure(pr1, patientFullUrl, ctx);
+    issues.push(...built.issues);
+    if (built.value === void 0) continue;
+    if (!passesEmitGate(built.value, location, "Procedure", issues)) continue;
+    const url = ids.next();
+    procedureFullUrls.push(url);
+    focalEntries.push({ fullUrl: url, resource: built.value });
+    reach.mark(pr1);
+  }
+  const coverages = collectCoverages(msg);
+  const visitSegment = msg.allSegments().find((seg) => seg.type === "PV1");
+  if (coverages.length > 0 && visitSegment !== void 0 && visitSegment.field(20).value !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PV1.20", "Coverage"));
+  }
+  const coverageFullUrls = [];
+  for (let i = 0; i < coverages.length; i++) {
+    const in1 = coverages[i];
+    if (in1 === void 0) continue;
+    const location = `IN1[${String(i)}]`;
+    issues.push(...deferredCoverageIssues(in1));
+    if (patientFullUrl === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, location, "Coverage.beneficiary"));
+      continue;
+    }
+    const built = buildCoverage(in1, patientFullUrl, ctx, location);
+    issues.push(...built.issues);
+    if (built.value === void 0) continue;
+    if (!passesEmitGate(built.value, location, "Coverage", issues)) continue;
+    const url = ids.next();
+    coverageFullUrls.push(url);
+    focalEntries.push({ fullUrl: url, resource: built.value });
+    reach.mark(in1);
+  }
   const diagnosticReportFullUrls = [];
   if (code === "ORU") {
     const { groups, orphanObxCount } = collectReportGroups(msg);
@@ -2506,28 +4224,54 @@ function toFhir(msg, opts = {}) {
       const resultFullUrls = [];
       const observationEntries = [];
       for (let i = 0; i < group.observations.length; i++) {
-        const obx = group.observations[i];
-        if (obx === void 0) continue;
-        const built = buildObservation(obx, patientFullUrl, encounterFullUrl, ctx);
+        const observation = group.observations[i];
+        if (observation === void 0) continue;
+        const built = buildObservation(
+          observation.obx,
+          patientFullUrl,
+          encounterFullUrl,
+          ctx,
+          observation.notes
+        );
         issues.push(...built.issues);
         if (built.value !== void 0 && passesEmitGate(built.value, `OBX[${String(i)}]`, "Observation", issues)) {
           const url = ids.next();
           resultFullUrls.push(url);
           observationEntries.push({ fullUrl: url, resource: built.value });
+          reach.mark(observation.obx, ...observation.notes);
         }
       }
+      const specimenFullUrls = [];
+      const specimenEntries = [];
+      const emittedSpecimens = [];
+      for (let i = 0; i < group.specimens.length; i++) {
+        const spm = group.specimens[i];
+        if (spm === void 0) continue;
+        const built = buildSpecimen(spm, patientFullUrl, ctx);
+        issues.push(...built.issues);
+        if (built.value === void 0) continue;
+        if (!passesEmitGate(built.value, `SPM[${String(i)}]`, "Specimen", issues)) continue;
+        const url = ids.next();
+        specimenFullUrls.push(url);
+        specimenEntries.push({ fullUrl: url, resource: built.value });
+        emittedSpecimens.push(spm);
+      }
       const report = buildDiagnosticReport(
         group.obr,
         resultFullUrls,
         patientFullUrl,
         encounterFullUrl,
-        ctx
+        ctx,
+        specimenFullUrls
       );
       issues.push(...report.issues);
       if (report.value !== void 0 && passesEmitGate(report.value, "OBR", "DiagnosticReport", issues)) {
         const reportUrl = ids.next();
         diagnosticReportFullUrls.push(reportUrl);
         focalEntries.push({ fullUrl: reportUrl, resource: report.value });
+        reach.mark(group.obr);
+        focalEntries.push(...specimenEntries);
+        reach.mark(...emittedSpecimens);
       }
       focalEntries.push(...observationEntries);
     }
@@ -2540,9 +4284,11 @@ function toFhir(msg, opts = {}) {
     }
     for (const group of groups) {
       if (group.obr !== void 0 || group.orc !== void 0 && group.rxo === void 0) {
+        const tq1 = readTq1(group.tq1s, "ServiceRequest", ctx);
         const built = buildServiceRequest(
           group.orc,
           group.obr,
+          tq1,
           patientFullUrl,
           encounterFullUrl,
           ctx
@@ -2553,13 +4299,16 @@ function toFhir(msg, opts = {}) {
           const url = ids.next();
           orderResourceFullUrls.push(url);
           focalEntries.push({ fullUrl: url, resource: built.value });
+          reach.mark(group.orc, group.obr, tq1.contributes ? group.tq1s[0] : void 0);
         }
       }
       if (group.rxo !== void 0) {
+        const tq1 = readTq1(group.tq1s, "MedicationRequest", ctx);
         const built = buildMedicationRequest(
           group.rxo,
           group.rxrs[0],
           group.orc,
+          tq1,
           patientFullUrl,
           encounterFullUrl,
           ctx
@@ -2569,6 +4318,12 @@ function toFhir(msg, opts = {}) {
           const url = ids.next();
           orderResourceFullUrls.push(url);
           focalEntries.push({ fullUrl: url, resource: built.value });
+          reach.mark(
+            group.rxo,
+            group.rxrs[0],
+            group.orc,
+            tq1.contributes ? group.tq1s[0] : void 0
+          );
         }
       }
     }
@@ -2589,6 +4344,7 @@ function toFhir(msg, opts = {}) {
         const url = ids.next();
         immunizationFullUrls.push(url);
         focalEntries.push({ fullUrl: url, resource: built.value });
+        reach.mark(group.rxa, group.rxr, group.orc);
       }
     }
     for (const seg of msg.allSegments()) {
@@ -2597,6 +4353,7 @@ function toFhir(msg, opts = {}) {
       issues.push(...built.issues);
       if (built.value !== void 0 && passesEmitGate(built.value, "OBX", "Observation", issues)) {
         focalEntries.push({ fullUrl: ids.next(), resource: built.value });
+        reach.mark(seg);
       }
     }
   }
@@ -2610,6 +4367,7 @@ function toFhir(msg, opts = {}) {
         const url = ids.next();
         appointmentFullUrls.push(url);
         focalEntries.push({ fullUrl: url, resource: built.value });
+        reach.mark(sch, ais);
       }
     }
   }
@@ -2623,12 +4381,17 @@ function toFhir(msg, opts = {}) {
         const url = ids.next();
         documentFullUrls.push(url);
         focalEntries.push({ fullUrl: url, resource: built.value });
+        reach.mark(txa, ...obxs);
       }
     }
   }
   const focus = [
     patientFullUrl,
     encounterFullUrl,
+    ...allergyFullUrls,
+    ...conditionFullUrls,
+    ...procedureFullUrls,
+    ...coverageFullUrls,
     ...diagnosticReportFullUrls,
     ...orderResourceFullUrls,
     ...immunizationFullUrls,
@@ -2640,63 +4403,829 @@ function toFhir(msg, opts = {}) {
   const entries = [];
   if (header.value !== void 0 && passesEmitGate(header.value, "MSH", "MessageHeader", issues)) {
     entries.push({ fullUrl: ids.next(), resource: header.value });
+    reach.markFirstOfType("MSH");
   }
   entries.push(...focalEntries);
   const bundle = buildBundle(msg, entries, ctx, issues);
+  issues.push(...reach.issues());
   return { bundle, issues };
 }
+function itemsOf(node) {
+  if (node === void 0) return [];
+  return fhir.isList(node) ? node.items : [node];
+}
+function at(node, name) {
+  return fhir.getProperty(node, name);
+}
+function readString(node, location, fhirPath, issues) {
+  if (node === void 0) return void 0;
+  if (!fhir.isPrimitive(node) || typeof node.value !== "string") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_MALFORMED, location, fhirPath));
+    return void 0;
+  }
+  return node.value === "" ? void 0 : node.value;
+}
+function readStrings(node, location, fhirPath, issues) {
+  const out = [];
+  for (const item of itemsOf(node)) {
+    const value = readString(item, location, fhirPath, issues);
+    if (value !== void 0) out.push(value);
+  }
+  return out;
+}
+function readComplexes(node, location, fhirPath, issues) {
+  const out = [];
+  for (const item of itemsOf(node)) {
+    if (fhir.isComplex(item)) out.push(item);
+    else issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_MALFORMED, location, fhirPath));
+  }
+  return out;
+}
+function readNumberText(node, location, fhirPath, issues) {
+  if (node === void 0) return void 0;
+  const value = fhir.isPrimitive(node) ? node.value : void 0;
+  if (value === void 0 || typeof value === "boolean") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_MALFORMED, location, fhirPath));
+    return void 0;
+  }
+  return typeof value === "string" ? value : value.raw;
+}
+
+// src/reverse/v2.ts
+function component2(value) {
+  return { subcomponents: value === void 0 || value === "" ? [] : [value] };
+}
+function v2Field(repetitions) {
+  const present = repetitions.filter(
+    (components) => components.some((value) => value !== void 0 && value !== "")
+  );
+  if (present.length === 0) return void 0;
+  return {
+    isNull: false,
+    repetitions: present.map((components) => {
+      let last = components.length;
+      while (last > 0 && (components[last - 1] === void 0 || components[last - 1] === ""))
+        last--;
+      return { components: components.slice(0, last).map(component2) };
+    })
+  };
+}
+function segmentFields(byPosition) {
+  const positions = [...byPosition.keys()];
+  const highest = positions.length === 0 ? 0 : Math.max(...positions);
+  const out = [];
+  for (let position = 1; position <= highest; position++) {
+    out.push(byPosition.get(position) ?? "");
+  }
+  return out;
+}
+var FHIR_DATETIME = /^(\d{4})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(\.\d{1,4})?(Z|[+-]\d{2}:\d{2}))?)?)?$/;
+function v2Timestamp(value) {
+  const parts = FHIR_DATETIME.exec(value);
+  if (parts === null) return void 0;
+  const [, year, month, day, hour, minute, second, fraction, zone] = parts;
+  let out = year ?? "";
+  if (month !== void 0) out += month;
+  if (day !== void 0) out += day;
+  if (hour === void 0) return out;
+  out += `${hour}${minute ?? ""}${second ?? ""}${fraction ?? ""}`;
+  return out + (zone === "Z" ? "+0000" : (zone ?? "").replace(":", ""));
+}
+function v2Date(value) {
+  return value.includes("T") ? void 0 : v2Timestamp(value);
+}
+var V2_NUMBER = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+function v2Number(raw) {
+  return V2_NUMBER.test(raw) ? raw : void 0;
+}
+function invertCodeMap(forward) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const [v2Code, fhirCode] of Object.entries(forward)) {
+    const seen = sources.get(fhirCode);
+    if (seen === void 0) sources.set(fhirCode, [v2Code]);
+    else seen.push(v2Code);
+  }
+  const inverse = {};
+  for (const [fhirCode, v2Codes] of sources) {
+    const only = v2Codes[0];
+    if (v2Codes.length === 1 && only !== void 0) inverse[fhirCode] = only;
+  }
+  return Object.freeze(inverse);
+}
+
+// src/reverse/coding.ts
+function reverseContext(options = {}) {
+  const mnemonics = invertCodeMap({ ...DEFAULT_V2_CODE_SYSTEMS, ...options.codeSystems });
+  const authorities = options.assigningAuthorities ?? {};
+  return {
+    mnemonicFor: (system) => Object.hasOwn(mnemonics, system) ? mnemonics[system] : void 0,
+    namespaceFor: (system) => Object.hasOwn(authorities, system) ? authorities[system] : void 0,
+    envelope: options.envelope ?? {}
+  };
+}
+function readCoding(coding2, ctx, location, fhirPath, issues) {
+  const code = readString(at(coding2, "code"), location, `${fhirPath}.code`, issues);
+  const display = readString(at(coding2, "display"), location, `${fhirPath}.display`, issues);
+  const system = readString(at(coding2, "system"), location, `${fhirPath}.system`, issues);
+  if (code === void 0) return void 0;
+  const mnemonic = system === void 0 ? void 0 : ctx.mnemonicFor(system);
+  if (mnemonic === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_SYSTEM_NOT_V2, location, `${fhirPath}.system`));
+    return void 0;
+  }
+  return { code, display, mnemonic };
+}
+function codeableToCwe(concept, ctx, location, fhirPath, issues) {
+  const codings = [];
+  for (const coding2 of readComplexes(
+    at(concept, "coding"),
+    location,
+    `${fhirPath}.coding`,
+    issues
+  )) {
+    const read = readCoding(coding2, ctx, location, `${fhirPath}.coding`, issues);
+    if (read !== void 0) codings.push(read);
+  }
+  const text2 = readString(at(concept, "text"), location, `${fhirPath}.text`, issues);
+  if (codings.length === 0 && text2 === void 0) return void 0;
+  if (codings.length > 2) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, location, `${fhirPath}.coding`)
+    );
+  }
+  const primary = codings[0];
+  const alternate = codings[1];
+  return [
+    primary?.code,
+    primary?.display,
+    primary?.mnemonic,
+    alternate?.code,
+    alternate?.display,
+    alternate?.mnemonic,
+    void 0,
+    void 0,
+    text2
+  ];
+}
+function codeInSystem(concept, system, location, fhirPath, issues) {
+  let found;
+  let foreign = false;
+  for (const coding2 of readComplexes(
+    at(concept, "coding"),
+    location,
+    `${fhirPath}.coding`,
+    issues
+  )) {
+    const codingSystem = readString(at(coding2, "system"), location, `${fhirPath}.system`, issues);
+    const code = readString(at(coding2, "code"), location, `${fhirPath}.code`, issues);
+    if (code === void 0) continue;
+    if (codingSystem === system) found ??= code;
+    else foreign = true;
+  }
+  if (found === void 0 && foreign) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_SYSTEM_NOT_V2, location, `${fhirPath}.system`));
+  }
+  return found;
+}
+var NAMED_RESOURCES = /* @__PURE__ */ new Set([
+  "Appointment",
+  "Bundle",
+  "DiagnosticReport",
+  "DocumentReference",
+  "Encounter",
+  "Immunization",
+  "MedicationRequest",
+  "MessageHeader",
+  "Observation",
+  "OperationOutcome",
+  "Patient",
+  "RelatedPerson",
+  "ServiceRequest"
+]);
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+var BARE_TRIGGER = /^[^\s|^~\\&\r\n]+$/;
+function hasTrigger(trigger, issues) {
+  if (!isNonEmptyString(trigger)) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_MISSING_TRIGGER, "MSH.9.2", "trigger"));
+    return false;
+  }
+  if (!BARE_TRIGGER.test(trigger)) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "MSH.9.2", "trigger"));
+    return false;
+  }
+  return true;
+}
+function readResource(input, expected, location, issues) {
+  if (!fhir.isComplex(input)) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_MALFORMED, location, "Resource"));
+    return void 0;
+  }
+  const type = fhir.resourceType(input);
+  if (type === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_MALFORMED, location, "Resource.resourceType"));
+    return void 0;
+  }
+  if (type !== expected) {
+    const named = NAMED_RESOURCES.has(type) ? type : "Resource";
+    issues.push(issue(ISSUE_CODES.TRANSFORM_UNSUPPORTED_RESOURCE, location, named));
+    return void 0;
+  }
+  return input;
+}
+function flagUnmapped(resource, mapped, targets, resourceName, segment, issues) {
+  for (const property of resource.properties) {
+    if (mapped.has(property.name)) continue;
+    const known = Object.hasOwn(targets, property.name);
+    issues.push(
+      issue(
+        ISSUE_CODES.TRANSFORM_NO_V2_TARGET,
+        known ? targets[property.name] ?? segment : segment,
+        known ? `${resourceName}.${property.name}` : resourceName
+      )
+    );
+  }
+}
+function emitMessage(shape, trigger, byPosition, ctx, issues) {
+  if (byPosition.size === 0) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_NO_V2_MESSAGE_EMITTED, shape.segment, shape.resourceName)
+    );
+    return void 0;
+  }
+  for (const field of shape.required) {
+    if (byPosition.has(field.position)) continue;
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_V2_REQUIRED_FIELD_ABSENT, field.location, field.fhirPath)
+    );
+  }
+  return hl7.buildMessage({ ...ctx.envelope, type: `${shape.messageCode}^${trigger}` }).addSegment(
+    shape.segment,
+    segmentFields(byPosition)
+  );
+}
+
+// src/reverse/patient.ts
+var GENDER_TO_V2 = invertCodeMap(ADMINISTRATIVE_GENDER_MAP);
+var NAME_USE_TO_V2 = invertCodeMap(NAME_USE_MAP);
+var ADDRESS_USE_TO_V2 = invertCodeMap(ADDRESS_USE_MAP);
+var PATIENT_MAPPED = /* @__PURE__ */ new Set([
+  "resourceType",
+  "identifier",
+  "name",
+  "birthDate",
+  "gender",
+  "address"
+]);
+var PID_REQUIRED = [
+  // PID-3 Patient Identifier List, v2.5.1 item 00106.
+  { position: 3, location: "PID.3", fhirPath: "Patient.identifier" },
+  // PID-5 Patient Name, v2.5.1 item 00108.
+  { position: 5, location: "PID.5", fhirPath: "Patient.name" }
+];
+var PATIENT_SHAPE = {
+  messageCode: "ADT",
+  segment: "PID",
+  resourceName: "Patient",
+  required: PID_REQUIRED
+};
+var PATIENT_UNMAPPED = Object.freeze({
+  telecom: "PID.13",
+  communication: "PID.15",
+  maritalStatus: "PID.16",
+  multipleBirthBoolean: "PID.24",
+  multipleBirthInteger: "PID.25",
+  deceasedDateTime: "PID.29",
+  deceasedBoolean: "PID.30",
+  contact: "NK1"
+});
+function invertible(inverse, code, location, fhirPath, issues) {
+  if (Object.hasOwn(inverse, code)) return inverse[code];
+  issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_NOT_INVERTIBLE, location, fhirPath));
+  return void 0;
+}
+function identifierComponents(identifier, ctx, issues) {
+  const value = readString(at(identifier, "value"), "CX.1", "Patient.identifier.value", issues);
+  if (value === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_NO_V2_TARGET, "CX.1", "Patient.identifier"));
+    return void 0;
+  }
+  const system = readString(at(identifier, "system"), "CX.4", "Patient.identifier.system", issues);
+  let namespace;
+  if (system !== void 0) {
+    namespace = ctx.namespaceFor(system);
+    if (namespace === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_NO_V2_TARGET, "CX.4", "Patient.identifier.system"));
+    }
+  }
+  const typeConcept = readComplexes(
+    at(identifier, "type"),
+    "CX.5",
+    "Patient.identifier.type",
+    issues
+  )[0];
+  const typeCode = typeConcept === void 0 ? void 0 : codeInSystem(typeConcept, V2_0203_SYSTEM, "CX.5", "Patient.identifier.type", issues);
+  return [value, void 0, void 0, namespace, typeCode];
+}
+function nameComponents(name, issues) {
+  const family = readString(at(name, "family"), "XPN.1", "Patient.name.family", issues);
+  const given = readStrings(at(name, "given"), "XPN.2", "Patient.name.given", issues);
+  const prefix = readStrings(at(name, "prefix"), "XPN.5", "Patient.name.prefix", issues);
+  const suffix = readStrings(at(name, "suffix"), "XPN.4", "Patient.name.suffix", issues);
+  const use = readString(at(name, "use"), "XPN.7", "Patient.name.use", issues);
+  if (given.length > 2) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "XPN.3", "Patient.name.given")
+    );
+  }
+  if (prefix.length > 1) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "XPN.5", "Patient.name.prefix")
+    );
+  }
+  if (suffix.length > 1) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "XPN.4", "Patient.name.suffix")
+    );
+  }
+  const nameType = use === void 0 ? void 0 : invertible(NAME_USE_TO_V2, use, "XPN.7", "Patient.name.use", issues);
+  return [family, given[0], given[1], suffix[0], prefix[0], void 0, nameType];
+}
+function addressComponents(address, issues) {
+  const line = readStrings(at(address, "line"), "XAD.1", "Patient.address.line", issues);
+  const city = readString(at(address, "city"), "XAD.3", "Patient.address.city", issues);
+  const state = readString(at(address, "state"), "XAD.4", "Patient.address.state", issues);
+  const postal = readString(
+    at(address, "postalCode"),
+    "XAD.5",
+    "Patient.address.postalCode",
+    issues
+  );
+  const country = readString(at(address, "country"), "XAD.6", "Patient.address.country", issues);
+  const district = readString(at(address, "district"), "XAD.9", "Patient.address.district", issues);
+  const use = readString(at(address, "use"), "XAD.7", "Patient.address.use", issues);
+  const type = readString(at(address, "type"), "XAD.7", "Patient.address.type", issues);
+  if (line.length > 2) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "XAD.2", "Patient.address.line")
+    );
+  }
+  const addressType = use === void 0 ? void 0 : invertible(ADDRESS_USE_TO_V2, use, "XAD.7", "Patient.address.use", issues);
+  if (type !== void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_NOT_INVERTIBLE, "XAD.7", "Patient.address.type"));
+  }
+  return [line[0], line[1], city, state, postal, country, addressType, void 0, district];
+}
+function pidFields(patient, ctx, issues) {
+  const fields = /* @__PURE__ */ new Map();
+  const identifiers = [];
+  for (const identifier of readComplexes(
+    at(patient, "identifier"),
+    "PID.3",
+    "Patient.identifier",
+    issues
+  )) {
+    const components = identifierComponents(identifier, ctx, issues);
+    if (components !== void 0) identifiers.push(components);
+  }
+  const pid3 = v2Field(identifiers);
+  if (pid3 !== void 0) fields.set(3, pid3);
+  const names = readComplexes(at(patient, "name"), "PID.5", "Patient.name", issues).map(
+    (name) => nameComponents(name, issues)
+  );
+  const pid5 = v2Field(names);
+  if (pid5 !== void 0) fields.set(5, pid5);
+  const birthDate = readString(at(patient, "birthDate"), "PID.7", "Patient.birthDate", issues);
+  if (birthDate !== void 0) {
+    const dtm = v2Date(birthDate);
+    if (dtm === void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "PID.7", "Patient.birthDate")
+      );
+    } else {
+      const pid7 = v2Field([[dtm]]);
+      if (pid7 !== void 0) fields.set(7, pid7);
+    }
+  }
+  const gender = readString(at(patient, "gender"), "PID.8", "Patient.gender", issues);
+  const sex = gender === void 0 ? void 0 : invertible(GENDER_TO_V2, gender, "PID.8", "Patient.gender", issues);
+  const pid8 = sex === void 0 ? void 0 : v2Field([[sex]]);
+  if (pid8 !== void 0) fields.set(8, pid8);
+  const addresses = readComplexes(at(patient, "address"), "PID.11", "Patient.address", issues).map(
+    (address) => addressComponents(address, issues)
+  );
+  const pid11 = v2Field(addresses);
+  if (pid11 !== void 0) fields.set(11, pid11);
+  return fields;
+}
+function toV2Patient(resource, trigger, options = {}) {
+  const issues = [];
+  const triggerOk = hasTrigger(trigger, issues);
+  const patient = readResource(resource, "Patient", "PID", issues);
+  if (!triggerOk || patient === void 0) return { value: void 0, issues };
+  flagUnmapped(patient, PATIENT_MAPPED, PATIENT_UNMAPPED, "Patient", "PID", issues);
+  const ctx = reverseContext(options);
+  const fields = pidFields(patient, ctx, issues);
+  const value = emitMessage(PATIENT_SHAPE, trigger, fields, ctx, issues);
+  return { value, issues };
+}
+
+// src/reverse/observation.ts
+var OBSERVATION_STATUS_TO_V2 = invertCodeMap(OBSERVATION_STATUS_MAP);
+var SN_COMPARATORS2 = /* @__PURE__ */ new Set(["<", "<=", ">=", ">"]);
+var OBSERVATION_MAPPED = /* @__PURE__ */ new Set([
+  "resourceType",
+  "code",
+  "status",
+  "effectiveDateTime",
+  "interpretation",
+  "referenceRange",
+  "valueQuantity",
+  "valueCodeableConcept",
+  "valueString",
+  "valueDateTime"
+]);
+var OBX_REQUIRED = [
+  // OBX-3 Observation Identifier. UNREACHABLE TODAY BY CONSTRUCTION, and kept
+  // anyway: `obxFields` returns no field at all when it cannot build OBX-3, so an
+  // emitted OBX always carries one and this row can only fire if that early return
+  // is ever relaxed. It guards the next edit rather than changing this one.
+  { position: 3, location: "OBX.3", fhirPath: "Observation.code" },
+  // OBX-11 Observation Result Status.
+  { position: 11, location: "OBX.11", fhirPath: "Observation.status" }
+];
+var OBSERVATION_SHAPE = {
+  messageCode: "ORU",
+  segment: "OBX",
+  resourceName: "Observation",
+  required: OBX_REQUIRED
+};
+var OBSERVATION_UNMAPPED = Object.freeze({
+  valueBoolean: "OBX.5",
+  valueInteger: "OBX.5",
+  valueRange: "OBX.5",
+  valueRatio: "OBX.5",
+  valueTime: "OBX.5",
+  valuePeriod: "OBX.5",
+  valueSampledData: "OBX.5",
+  valueAttachment: "OBX.5",
+  dataAbsentReason: "OBX.5",
+  effectivePeriod: "OBX.14",
+  effectiveInstant: "OBX.14",
+  issued: "OBX.19",
+  performer: "OBX.16",
+  method: "OBX.17",
+  specimen: "OBX.18",
+  device: "OBX.18",
+  bodySite: "OBX.20",
+  identifier: "OBX.21",
+  note: "NTE",
+  subject: "PID",
+  encounter: "PV1",
+  basedOn: "OBR",
+  category: "OBR",
+  component: "OBX",
+  hasMember: "OBX",
+  derivedFrom: "OBX"
+});
+function unitComponents(quantity, ctx, issues) {
+  const unit = readString(at(quantity, "unit"), "OBX.6", "Observation.valueQuantity.unit", issues);
+  const code = readString(at(quantity, "code"), "OBX.6", "Observation.valueQuantity.code", issues);
+  const system = readString(
+    at(quantity, "system"),
+    "OBX.6",
+    "Observation.valueQuantity.system",
+    issues
+  );
+  const mnemonic = system === void 0 ? void 0 : ctx.mnemonicFor(system);
+  if (code !== void 0 && mnemonic !== void 0) return [code, unit, mnemonic];
+  if (code !== void 0) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_CODE_SYSTEM_NOT_V2, "OBX.6", "Observation.valueQuantity.system")
+    );
+  }
+  return unit === void 0 ? void 0 : [void 0, unit];
+}
+function quantityValue(quantity, ctx, issues) {
+  const raw = readNumberText(
+    at(quantity, "value"),
+    "OBX.5",
+    "Observation.valueQuantity.value",
+    issues
+  );
+  const magnitude = raw === void 0 ? void 0 : v2Number(raw);
+  if (magnitude === void 0) {
+    if (raw !== void 0) {
+      issues.push(
+        issue(
+          ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE,
+          "OBX.5",
+          "Observation.valueQuantity.value"
+        )
+      );
+    }
+    return void 0;
+  }
+  const units = unitComponents(quantity, ctx, issues);
+  const comparator = readString(
+    at(quantity, "comparator"),
+    "OBX.5",
+    "Observation.valueQuantity.comparator",
+    issues
+  );
+  if (comparator === void 0) return { valueType: "NM", value: [magnitude], units };
+  if (!SN_COMPARATORS2.has(comparator)) {
+    issues.push(
+      issue(
+        ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE,
+        "OBX.5",
+        "Observation.valueQuantity.comparator"
+      )
+    );
+    return void 0;
+  }
+  return { valueType: "SN", value: [comparator, magnitude], units };
+}
+function observationValue(observation, ctx, issues) {
+  const quantity = readComplexes(
+    at(observation, "valueQuantity"),
+    "OBX.5",
+    "Observation.valueQuantity",
+    issues
+  )[0];
+  if (quantity !== void 0) return quantityValue(quantity, ctx, issues);
+  const concept = readComplexes(
+    at(observation, "valueCodeableConcept"),
+    "OBX.5",
+    "Observation.valueCodeableConcept",
+    issues
+  )[0];
+  if (concept !== void 0) {
+    const cwe = codeableToCwe(concept, ctx, "OBX.5", "Observation.valueCodeableConcept", issues);
+    return cwe === void 0 ? void 0 : { valueType: "CWE", value: cwe, units: void 0 };
+  }
+  const text2 = readString(
+    at(observation, "valueString"),
+    "OBX.5",
+    "Observation.valueString",
+    issues
+  );
+  if (text2 !== void 0) return { valueType: "ST", value: [text2], units: void 0 };
+  const instant = readString(
+    at(observation, "valueDateTime"),
+    "OBX.5",
+    "Observation.valueDateTime",
+    issues
+  );
+  if (instant !== void 0) {
+    const dtm = v2Timestamp(instant);
+    if (dtm === void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "OBX.5", "Observation.valueDateTime")
+      );
+      return void 0;
+    }
+    return { valueType: "DTM", value: [dtm], units: void 0 };
+  }
+  return void 0;
+}
+function interpretationField(observation, issues) {
+  const flags = [];
+  for (const concept of readComplexes(
+    at(observation, "interpretation"),
+    "OBX.8",
+    "Observation.interpretation",
+    issues
+  )) {
+    const code = codeInSystem(
+      concept,
+      V3_OBSERVATION_INTERPRETATION_SYSTEM,
+      "OBX.8",
+      "Observation.interpretation",
+      issues
+    );
+    if (code === void 0) continue;
+    if (HL70078_INTERPRETATION_CODES.has(code)) flags.push([code]);
+    else {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_CODE_NOT_INVERTIBLE, "OBX.8", "Observation.interpretation")
+      );
+    }
+  }
+  return v2Field(flags);
+}
+function referenceRangeField(observation, issues) {
+  const ranges = readComplexes(
+    at(observation, "referenceRange"),
+    "OBX.7",
+    "Observation.referenceRange",
+    issues
+  );
+  if (ranges.length > 1) {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE, "OBX.7", "Observation.referenceRange")
+    );
+  }
+  const first = ranges[0];
+  if (first === void 0) return void 0;
+  const text2 = readString(at(first, "text"), "OBX.7", "Observation.referenceRange.text", issues);
+  if (text2 === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_NO_V2_TARGET, "OBX.7", "Observation.referenceRange"));
+    return void 0;
+  }
+  return v2Field([[text2]]);
+}
+function obxFields(observation, ctx, issues) {
+  const fields = /* @__PURE__ */ new Map();
+  const concept = readComplexes(at(observation, "code"), "OBX.3", "Observation.code", issues)[0];
+  if (concept === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_MALFORMED, "OBX.3", "Observation.code"));
+    return fields;
+  }
+  const cwe = codeableToCwe(concept, ctx, "OBX.3", "Observation.code", issues);
+  const obx3 = cwe === void 0 ? void 0 : v2Field([cwe]);
+  if (obx3 === void 0) return fields;
+  fields.set(3, obx3);
+  const value = observationValue(observation, ctx, issues);
+  if (value !== void 0) {
+    const obx2 = v2Field([[value.valueType]]);
+    const obx5 = v2Field([value.value]);
+    if (obx2 !== void 0 && obx5 !== void 0) {
+      fields.set(2, obx2);
+      fields.set(5, obx5);
+    }
+    const obx6 = value.units === void 0 ? void 0 : v2Field([value.units]);
+    if (obx6 !== void 0) fields.set(6, obx6);
+  }
+  const referenceRange = referenceRangeField(observation, issues);
+  if (referenceRange !== void 0) fields.set(7, referenceRange);
+  const interpretation = interpretationField(observation, issues);
+  if (interpretation !== void 0) fields.set(8, interpretation);
+  const status = readString(at(observation, "status"), "OBX.11", "Observation.status", issues);
+  if (status !== void 0) {
+    const code = Object.hasOwn(OBSERVATION_STATUS_TO_V2, status) ? OBSERVATION_STATUS_TO_V2[status] : void 0;
+    if (code === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_NOT_INVERTIBLE, "OBX.11", "Observation.status"));
+    } else {
+      const obx11 = v2Field([[code]]);
+      if (obx11 !== void 0) fields.set(11, obx11);
+    }
+  }
+  const effective = readString(
+    at(observation, "effectiveDateTime"),
+    "OBX.14",
+    "Observation.effectiveDateTime",
+    issues
+  );
+  if (effective !== void 0) {
+    const dtm = v2Timestamp(effective);
+    if (dtm === void 0) {
+      issues.push(
+        issue(
+          ISSUE_CODES.TRANSFORM_VALUE_NOT_REPRESENTABLE,
+          "OBX.14",
+          "Observation.effectiveDateTime"
+        )
+      );
+    } else {
+      const obx14 = v2Field([[dtm]]);
+      if (obx14 !== void 0) fields.set(14, obx14);
+    }
+  }
+  return fields;
+}
+function toV2Observation(resource, trigger, options = {}) {
+  const issues = [];
+  const triggerOk = hasTrigger(trigger, issues);
+  const observation = readResource(resource, "Observation", "OBX", issues);
+  if (!triggerOk || observation === void 0) return { value: void 0, issues };
+  flagUnmapped(observation, OBSERVATION_MAPPED, OBSERVATION_UNMAPPED, "Observation", "OBX", issues);
+  const ctx = reverseContext(options);
+  const fields = obxFields(observation, ctx, issues);
+  const value = emitMessage(OBSERVATION_SHAPE, trigger, fields, ctx, issues);
+  return { value, issues };
+}
 
 // src/index.ts
-var VERSION = "0.0.9";
+var VERSION = "0.1.1";
 
 exports.ADDRESS_TYPE_MAP = ADDRESS_TYPE_MAP;
 exports.ADDRESS_USE_MAP = ADDRESS_USE_MAP;
+exports.ADDRESS_USE_TO_V2 = ADDRESS_USE_TO_V2;
 exports.ADMINISTRATIVE_GENDER_MAP = ADMINISTRATIVE_GENDER_MAP;
+exports.AL1_ONSET_WITHDRAWN_AT = AL1_ONSET_WITHDRAWN_AT;
+exports.ALLERGY_CATEGORY_VALUE_MAP = ALLERGY_CATEGORY_VALUE_MAP;
+exports.ALLERGY_CLINICAL_STATUS_CODE = ALLERGY_CLINICAL_STATUS_CODE;
+exports.ALLERGY_CLINICAL_STATUS_SYSTEM = ALLERGY_CLINICAL_STATUS_SYSTEM;
+exports.ALLERGY_CRITICALITY_VALUE_MAP = ALLERGY_CRITICALITY_VALUE_MAP;
+exports.ALLERGY_INTOLERANCE_CATEGORY_SYSTEM = ALLERGY_INTOLERANCE_CATEGORY_SYSTEM;
+exports.ALLERGY_INTOLERANCE_CRITICALITY_SYSTEM = ALLERGY_INTOLERANCE_CRITICALITY_SYSTEM;
+exports.ALLERGY_INTOLERANCE_TYPE_SYSTEM = ALLERGY_INTOLERANCE_TYPE_SYSTEM;
+exports.ALLERGY_ORIGINAL_CATEGORY_VALUE_MAP = ALLERGY_ORIGINAL_CATEGORY_VALUE_MAP;
+exports.ALLERGY_ORIGINAL_CRITICALITY_VALUE_MAP = ALLERGY_ORIGINAL_CRITICALITY_VALUE_MAP;
+exports.ALLERGY_TYPE_VALUE_MAP = ALLERGY_TYPE_VALUE_MAP;
+exports.ALTERNATE_CODES_EXTENSION_URL = ALTERNATE_CODES_EXTENSION_URL;
 exports.APPOINTMENT_STATUS_MAP = APPOINTMENT_STATUS_MAP;
 exports.APPOINTMENT_TYPE_VALUE_MAP = APPOINTMENT_TYPE_VALUE_MAP;
+exports.CONDITION_ENTERED_IN_ERROR = CONDITION_ENTERED_IN_ERROR;
+exports.CONDITION_VERIFICATION_STATUS_SYSTEM = CONDITION_VERIFICATION_STATUS_SYSTEM;
+exports.COVERAGE_STATUS_UNKNOWN = COVERAGE_STATUS_UNKNOWN;
+exports.COVERAGE_SUBSCRIBER_ID_EXTENSION_URL = COVERAGE_SUBSCRIBER_ID_EXTENSION_URL;
 exports.DEFAULT_V2_CODE_SYSTEMS = DEFAULT_V2_CODE_SYSTEMS;
+exports.DG1_RETRACTION_ACTION_CODE = DG1_RETRACTION_ACTION_CODE;
 exports.DIAGNOSTIC_REPORT_STATUS_MAP = DIAGNOSTIC_REPORT_STATUS_MAP;
+exports.ED_BASE64_ENCODING = ED_BASE64_ENCODING;
 exports.ENCOUNTER_CLASS_V3_MAP = ENCOUNTER_CLASS_V3_MAP;
 exports.ENCOUNTER_STATUS_MAP = ENCOUNTER_STATUS_MAP;
 exports.FATAL_CODES = FATAL_CODES;
+exports.GENDER_TO_V2 = GENDER_TO_V2;
 exports.HL70078_INTERPRETATION_CODES = HL70078_INTERPRETATION_CODES;
+exports.IG_ALLERGY_VALUE_MAPS_PUBLISHED = IG_ALLERGY_VALUE_MAPS_PUBLISHED;
+exports.IG_ALLERGY_VALUE_MAPS_RETRIEVED = IG_ALLERGY_VALUE_MAPS_RETRIEVED;
+exports.IG_ALLERGY_VALUE_MAPS_SOURCE = IG_ALLERGY_VALUE_MAPS_SOURCE;
+exports.IG_ALLERGY_VALUE_MAPS_VERSION = IG_ALLERGY_VALUE_MAPS_VERSION;
 exports.IG_MAPPED_ADT_TRIGGERS = IG_MAPPED_ADT_TRIGGERS;
 exports.IG_MAPPED_APPOINTMENT_TRIGGERS = IG_MAPPED_APPOINTMENT_TRIGGERS;
 exports.IG_MAPPED_DOCUMENT_TRIGGERS = IG_MAPPED_DOCUMENT_TRIGGERS;
 exports.IG_MAPPED_IMMUNIZATION_TRIGGERS = IG_MAPPED_IMMUNIZATION_TRIGGERS;
 exports.IG_MAPPED_ORDER_TRIGGERS = IG_MAPPED_ORDER_TRIGGERS;
 exports.IG_MAPPED_ORU_TRIGGERS = IG_MAPPED_ORU_TRIGGERS;
+exports.IG_MAPPED_SEGMENT_NAMES = IG_MAPPED_SEGMENT_NAMES;
+exports.IG_SEGMENT_MAPS_PUBLISHED = IG_SEGMENT_MAPS_PUBLISHED;
+exports.IG_SEGMENT_MAPS_RETRIEVED = IG_SEGMENT_MAPS_RETRIEVED;
+exports.IG_SEGMENT_MAPS_SOURCE = IG_SEGMENT_MAPS_SOURCE;
+exports.IG_SEGMENT_MAPS_VERSION = IG_SEGMENT_MAPS_VERSION;
 exports.IMMUNIZATION_STATUS_MAP = IMMUNIZATION_STATUS_MAP;
+exports.IN1_SUBSCRIBER_NUMBER_TYPE = IN1_SUBSCRIBER_NUMBER_TYPE;
 exports.ISSUE_CODES = ISSUE_CODES;
 exports.ISSUE_REGISTRY = ISSUE_REGISTRY;
 exports.NAME_USE_MAP = NAME_USE_MAP;
+exports.NAME_USE_TO_V2 = NAME_USE_TO_V2;
 exports.OBSERVATION_STATUS_MAP = OBSERVATION_STATUS_MAP;
+exports.OBSERVATION_STATUS_TO_V2 = OBSERVATION_STATUS_TO_V2;
+exports.OBSERVATION_VALUE_ATTACHMENT_EXTENSION_URL = OBSERVATION_VALUE_ATTACHMENT_EXTENSION_URL;
+exports.PROCEDURE_STATUS_UNKNOWN = PROCEDURE_STATUS_UNKNOWN;
 exports.REQUEST_STATUS_MAP = REQUEST_STATUS_MAP;
 exports.ROUTE_VALUE_MAP = ROUTE_VALUE_MAP;
+exports.SAMPLED_DATA_ABSENT_POINT = SAMPLED_DATA_ABSENT_POINT;
+exports.SAMPLED_DATA_UNGROUNDED = SAMPLED_DATA_UNGROUNDED;
+exports.SEGMENT_IDENTIFIER_SHAPE = SEGMENT_IDENTIFIER_SHAPE;
 exports.SERVICE_REQUEST_PRIORITY_MAP = SERVICE_REQUEST_PRIORITY_MAP;
 exports.SITE_VALUE_MAP = SITE_VALUE_MAP;
+exports.SPM_SHIPMENT_IDENTIFIER_TYPE = SPM_SHIPMENT_IDENTIFIER_TYPE;
 exports.SUBSTITUTION_VALUE_MAP = SUBSTITUTION_VALUE_MAP;
+exports.SegmentReachLedger = SegmentReachLedger;
 exports.TRANSFORM_ISSUE_SYSTEM = TRANSFORM_ISSUE_SYSTEM;
+exports.V2_0127_SYSTEM = V2_0127_SYSTEM;
+exports.V2_0128_SYSTEM = V2_0128_SYSTEM;
 exports.V2_0161_SYSTEM = V2_0161_SYSTEM;
 exports.V2_0162_SYSTEM = V2_0162_SYSTEM;
 exports.V2_0203_SYSTEM = V2_0203_SYSTEM;
 exports.V2_0277_SYSTEM = V2_0277_SYSTEM;
 exports.V2_0550_SYSTEM = V2_0550_SYSTEM;
+exports.V3_OBSERVATION_INTERPRETATION_SYSTEM = V3_OBSERVATION_INTERPRETATION_SYSTEM;
 exports.V3_ROUTE_OF_ADMINISTRATION_SYSTEM = V3_ROUTE_OF_ADMINISTRATION_SYSTEM;
 exports.VERSION = VERSION;
+exports.addMinutes = addMinutes;
+exports.buildAnnotations = buildAnnotations;
+exports.buildCondition = buildCondition;
+exports.buildCoverage = buildCoverage;
+exports.buildProcedure = buildProcedure;
+exports.buildSpecimen = buildSpecimen;
+exports.carriesLegacyOnsetDate = carriesLegacyOnsetDate;
 exports.codeableConceptFromTarget = codeableConceptFromTarget;
+exports.collectAllergies = collectAllergies;
+exports.collectCoverages = collectCoverages;
+exports.collectDiagnoses = collectDiagnoses;
+exports.collectProcedures = collectProcedures;
 exports.createNamingSystem = createNamingSystem;
+exports.deferredCoverageIssues = deferredCoverageIssues;
+exports.deferredDiagnosisIssues = deferredDiagnosisIssues;
+exports.deferredProcedureIssues = deferredProcedureIssues;
+exports.emitEncounterDiagnosis = emitEncounterDiagnosis;
+exports.enumerateSegmentOccurrences = enumerateSegmentOccurrences;
 exports.fhirIssueTypeFor = fhirIssueTypeFor;
+exports.insuranceCompanyName = insuranceCompanyName;
+exports.invertCodeMap = invertCodeMap;
+exports.isIgMappedSegmentName = isIgMappedSegmentName;
+exports.isWellFormedSegmentName = isWellFormedSegmentName;
 exports.issue = issue;
+exports.segmentOccurrenceLocation = segmentOccurrenceLocation;
 exports.toFhir = toFhir;
 exports.toFhirAddress = toFhirAddress;
 exports.toFhirCodeableConcept = toFhirCodeableConcept;
 exports.toFhirCodeableConceptVia = toFhirCodeableConceptVia;
 exports.toFhirDateTime = toFhirDateTime;
+exports.toFhirEntityIdentifier = toFhirEntityIdentifier;
 exports.toFhirHumanName = toFhirHumanName;
 exports.toFhirIdentifier = toFhirIdentifier;
 exports.toFhirQuantity = toFhirQuantity;
 exports.toOperationOutcome = toOperationOutcome;
+exports.toV2Observation = toV2Observation;
+exports.toV2Patient = toV2Patient;
 exports.translateBound = translateBound;
+exports.withCodeableText = withCodeableText;
+exports.withEncounterDiagnosis = withEncounterDiagnosis;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map