@cosyte/transform 0.0.2

package/dist/index.mjs

@@ -0,0 +1,2652 @@
+import { complex, primitive, list, decimal, UCUM_SYSTEM, validateUcumShape, resourceType, validateResource, UNBOUNDED } from '@cosyte/fhir';
+import { parseDtm } from '@cosyte/hl7';
+import { randomUUID } from 'crypto';
+
+// src/diagnostics/codes.ts
+var ISSUE_CODES = {
+  /** A v2 DTM/TS carried a time-of-day but no timezone offset. FHIR forbids time-without-zone, so
+   * the value was reduced to date precision (or an explicit sender offset applied via options) —
+   * **never** a guessed UTC. */
+  TRANSFORM_TIMESTAMP_NO_TIMEZONE: "TRANSFORM_TIMESTAMP_NO_TIMEZONE",
+  /** A v2 DTM/TS could not be parsed into a valid FHIR date/time; no value was emitted. */
+  TRANSFORM_TIMESTAMP_INVALID: "TRANSFORM_TIMESTAMP_INVALID",
+  /** The assigning authority (HD) could not be resolved to a FHIR `Identifier.system` URI via the
+   * NamingSystem registry. The identifier is emitted with its value and **no** system — a system URI
+   * is **never** synthesized from HD.1 alone. */
+  TRANSFORM_IDENTIFIER_SYSTEM_UNRESOLVED: "TRANSFORM_IDENTIFIER_SYSTEM_UNRESOLVED",
+  /** A coded value could not be mapped to a FHIR concept — either it carried no coding-system context
+   * (CWE.3 absent), or it is a table code the IG ConceptMap has **no target** for (e.g. an OBX-11/
+   * OBR-25 result status the HL70085/HL70123 map does not carry, or an OBX-8 abnormal flag absent from
+   * HL70078). The original code is preserved / the FHIR value left absent; **never** coerced to a
+   * neighbor and **never** guessed to `final`/`normal`. */
+  TRANSFORM_CODE_UNMAPPED: "TRANSFORM_CODE_UNMAPPED",
+  /** A coding-system mnemonic (CWE.3 / CWE.6) was not recognized, so no canonical system URI could
+   * be emitted. The code is preserved; a URI is **never** invented. */
+  TRANSFORM_CODE_SYSTEM_UNRESOLVED: "TRANSFORM_CODE_SYSTEM_UNRESOLVED",
+  /** A unit was not a valid UCUM code (or was not declared UCUM). It is preserved verbatim in
+   * `Quantity.unit`; `Quantity.code`/`.system` are left absent — a UCUM code is **never** fabricated
+   * and a magnitude is **never** converted. */
+  TRANSFORM_UNIT_NOT_UCUM: "TRANSFORM_UNIT_NOT_UCUM",
+  /** A v2 numeric value (NM) could not be represented as a FHIR `decimal` without altering it — e.g.
+   * a leading `+`, a leading zero, or a trailing dot, which FHIR's `decimal` lexical form forbids. No
+   * `Quantity` value is emitted rather than a canonicalized (and therefore altered) magnitude. */
+  TRANSFORM_QUANTITY_VALUE_INVALID: "TRANSFORM_QUANTITY_VALUE_INVALID",
+  /** A populated source element was not carried to its FHIR target and was dropped — either because
+   * the IG map defines no target, or because that target's conversion is **not implemented**
+   * (e.g. XTN→ContactPoint telecom, PV1 participants). Surfaced here rather than silently discarded,
+   * never a fabricated value. */
+  TRANSFORM_ELEMENT_DROPPED: "TRANSFORM_ELEMENT_DROPPED",
+  /** An XPN.7 name-type code has no equivalent in the IG's HL70200 → name-use ConceptMap;
+   * `HumanName.use` is left absent rather than guessed. */
+  TRANSFORM_NAME_USE_UNMAPPED: "TRANSFORM_NAME_USE_UNMAPPED",
+  /** An XAD.7 address-type code has no equivalent in the IG's HL70190 → address-use/type
+   * ConceptMaps; `Address.use`/`.type` are left absent rather than guessed. */
+  TRANSFORM_ADDRESS_USE_UNMAPPED: "TRANSFORM_ADDRESS_USE_UNMAPPED",
+  /** The message's trigger event has no IG *message* map, so its resource graph was assembled from
+   * the reusable IG *segment* maps rather than a message map. The graph is best-effort and flagged
+   * as such — never a fabricated message map. */
+  TRANSFORM_SEGMENT_ASSEMBLED: "TRANSFORM_SEGMENT_ASSEMBLED",
+  /** A produced FHIR resource failed `@cosyte/fhir` R4 structural validation and was **withheld**
+   * from the bundle rather than emitted as a silently-invalid resource — the conservative-emit gate. */
+  TRANSFORM_RESOURCE_INVALID: "TRANSFORM_RESOURCE_INVALID",
+  /** 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"
+};
+var FATAL_CODES = {
+  /** The input carried nothing to transform. */
+  EMPTY_INPUT: "EMPTY_INPUT",
+  /** The input was not a shape this transform accepts. */
+  TRANSFORM_UNSUPPORTED_INPUT: "TRANSFORM_UNSUPPORTED_INPUT"
+};
+
+// src/diagnostics/issue.ts
+var ISSUE_REGISTRY = Object.freeze({
+  [ISSUE_CODES.TRANSFORM_TIMESTAMP_NO_TIMEZONE]: {
+    severity: "warning",
+    fhirIssueType: "value",
+    message: "v2 timestamp carried a time-of-day but no timezone offset; reduced to date precision (FHIR forbids time without a zone)."
+  },
+  [ISSUE_CODES.TRANSFORM_TIMESTAMP_INVALID]: {
+    severity: "warning",
+    fhirIssueType: "value",
+    message: "v2 timestamp could not be parsed into a valid FHIR date/time; no value emitted."
+  },
+  [ISSUE_CODES.TRANSFORM_IDENTIFIER_SYSTEM_UNRESOLVED]: {
+    severity: "warning",
+    fhirIssueType: "not-found",
+    message: "assigning authority could not be resolved to an Identifier.system; identifier emitted with value and no system (never synthesized from a bare namespace)."
+  },
+  [ISSUE_CODES.TRANSFORM_CODE_UNMAPPED]: {
+    severity: "warning",
+    fhirIssueType: "code-invalid",
+    message: "coded value could not be mapped to a FHIR concept (no coding system, or no target in the IG ConceptMap); original code preserved / FHIR value left absent, never coerced or guessed."
+  },
+  [ISSUE_CODES.TRANSFORM_CODE_SYSTEM_UNRESOLVED]: {
+    severity: "warning",
+    fhirIssueType: "code-invalid",
+    message: "coding-system mnemonic not recognized; code preserved, no system URI invented."
+  },
+  [ISSUE_CODES.TRANSFORM_UNIT_NOT_UCUM]: {
+    severity: "warning",
+    fhirIssueType: "value",
+    message: "unit is not a valid UCUM code; preserved verbatim in Quantity.unit, code/system absent, magnitude never converted."
+  },
+  [ISSUE_CODES.TRANSFORM_QUANTITY_VALUE_INVALID]: {
+    severity: "warning",
+    fhirIssueType: "value",
+    message: "numeric value is not a valid FHIR decimal literal (e.g. leading sign/zero or trailing dot); no Quantity value emitted rather than altering the magnitude."
+  },
+  [ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED]: {
+    severity: "information",
+    fhirIssueType: "informational",
+    message: "populated source element was not carried to its FHIR target (no target in this map, or its conversion is not implemented); dropped."
+  },
+  [ISSUE_CODES.TRANSFORM_NAME_USE_UNMAPPED]: {
+    severity: "information",
+    fhirIssueType: "value",
+    message: "name-type code has no equivalent in the HL70200 to name-use map; use left absent."
+  },
+  [ISSUE_CODES.TRANSFORM_ADDRESS_USE_UNMAPPED]: {
+    severity: "information",
+    fhirIssueType: "value",
+    message: "address-type code has no equivalent in the HL70190 to address-use/type maps; use/type left absent."
+  },
+  [ISSUE_CODES.TRANSFORM_SEGMENT_ASSEMBLED]: {
+    severity: "information",
+    fhirIssueType: "informational",
+    message: "message trigger has no IG message map; resource graph assembled from IG segment maps, best-effort."
+  },
+  [ISSUE_CODES.TRANSFORM_RESOURCE_INVALID]: {
+    severity: "error",
+    fhirIssueType: "structure",
+    message: "produced resource failed FHIR R4 structural validation; withheld from the bundle rather than emitted invalid."
+  },
+  [ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN]: {
+    severity: "information",
+    fhirIssueType: "informational",
+    message: "required FHIR element could not be derived from the source; emitted with a data-absent-reason extension, never fabricated."
+  }
+});
+function issue(code, v2Location, fhirPath) {
+  const meta = ISSUE_REGISTRY[code];
+  const base = {
+    code,
+    severity: meta.severity,
+    v2Location,
+    message: meta.message
+  };
+  return fhirPath === void 0 ? base : { ...base, fhirPath };
+}
+function fhirIssueTypeFor(code) {
+  return ISSUE_REGISTRY[code].fhirIssueType;
+}
+var TRANSFORM_ISSUE_SYSTEM = "https://cosyte.com/fhir/CodeSystem/transform-issue-codes";
+function prop(name, value) {
+  return { name, value };
+}
+function renderIssue(i) {
+  const details = complex([
+    prop(
+      "coding",
+      list([
+        complex([
+          prop("system", primitive(TRANSFORM_ISSUE_SYSTEM)),
+          prop("code", primitive(i.code))
+        ])
+      ])
+    ),
+    prop("text", primitive(i.message))
+  ]);
+  const props = [
+    prop("severity", primitive(i.severity)),
+    prop("code", primitive(fhirIssueTypeFor(i.code))),
+    prop("details", details),
+    // `diagnostics` carries the v2 source location — positional metadata, never a value.
+    prop("diagnostics", primitive(i.v2Location))
+  ];
+  if (i.fhirPath !== void 0) {
+    props.push(prop("expression", list([primitive(i.fhirPath)])));
+  }
+  return complex(props);
+}
+function toOperationOutcome(issues) {
+  const rendered = issues.length > 0 ? issues.map(renderIssue) : [
+    complex([
+      prop("severity", primitive("information")),
+      prop("code", primitive("informational")),
+      prop("details", complex([prop("text", primitive("No transform issues."))]))
+    ])
+  ];
+  return complex([
+    prop("resourceType", primitive("OperationOutcome")),
+    prop("issue", list(rendered))
+  ]);
+}
+
+// src/terminology/naming-system.ts
+var V2_0203_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0203";
+var DEFAULT_V2_CODE_SYSTEMS = Object.freeze({
+  LN: "http://loinc.org",
+  SCT: "http://snomed.info/sct",
+  RXNORM: "http://www.nlm.nih.gov/research/umls/rxnorm",
+  CVX: "http://hl7.org/fhir/sid/cvx",
+  UCUM: "http://unitsofmeasure.org"
+});
+function isOid(value) {
+  return /^[0-2](\.(0|[1-9]\d*))+$/.test(value);
+}
+function isUuid(value) {
+  return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(
+    value
+  );
+}
+function createNamingSystem(seed = {}) {
+  const codeSystems = { ...DEFAULT_V2_CODE_SYSTEMS, ...seed.codeSystems };
+  const authorities = { ...seed.authorities };
+  return Object.freeze({
+    resolveCodeSystem(mnemonic) {
+      if (mnemonic === "") return void 0;
+      return Object.hasOwn(codeSystems, mnemonic) ? codeSystems[mnemonic] : void 0;
+    },
+    resolveAssigningAuthority(hd) {
+      if (hd.universalId !== void 0 && Object.hasOwn(authorities, hd.universalId)) {
+        return authorities[hd.universalId];
+      }
+      if (hd.namespaceId !== void 0 && Object.hasOwn(authorities, hd.namespaceId)) {
+        return authorities[hd.namespaceId];
+      }
+      if (hd.universalId !== void 0 && hd.universalId !== "") {
+        if (hd.universalIdType === "ISO" && isOid(hd.universalId)) {
+          return `urn:oid:${hd.universalId}`;
+        }
+        if (hd.universalIdType === "UUID" && isUuid(hd.universalId)) {
+          return `urn:uuid:${hd.universalId.toLowerCase()}`;
+        }
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/datatypes/datetime.ts
+function pad(value, width) {
+  return String(value).padStart(width, "0");
+}
+function formatOffset(offsetMinutes) {
+  const sign = offsetMinutes < 0 ? "-" : "+";
+  const abs = Math.abs(offsetMinutes);
+  return `${sign}${pad(Math.floor(abs / 60), 2)}:${pad(abs % 60, 2)}`;
+}
+function datePart(ts) {
+  let out = pad(ts.year ?? 0, 4);
+  if (ts.month !== void 0) out += `-${pad(ts.month, 2)}`;
+  if (ts.day !== void 0) out += `-${pad(ts.day, 2)}`;
+  return out;
+}
+function toFhirDateTime(ts, options = {}) {
+  if (!ts.valid || ts.precision === void 0 || ts.year === void 0) {
+    return {
+      value: void 0,
+      issues: [issue(ISSUE_CODES.TRANSFORM_TIMESTAMP_INVALID, "TS.1", "dateTime")]
+    };
+  }
+  const date = datePart(ts);
+  if (ts.hour === void 0) {
+    return { value: date, issues: [] };
+  }
+  const hasFullTime = ts.precision === "second" || ts.precision === "fraction";
+  const offset = ts.hasTimezone ? ts.offsetMinutes : options.assumeTimezoneOffsetMinutes;
+  if (hasFullTime && offset !== void 0) {
+    const frac = ts.precision === "fraction" && ts.fractionalSeconds !== void 0 ? `.${ts.fractionalSeconds}` : "";
+    const value = `${date}T${pad(ts.hour, 2)}:${pad(ts.minute ?? 0, 2)}:${pad(ts.second ?? 0, 2)}${frac}${formatOffset(offset)}`;
+    const issues = ts.hasTimezone ? [] : [issue(ISSUE_CODES.TRANSFORM_TIMESTAMP_NO_TIMEZONE, "TS.1", "dateTime")];
+    return { value, issues };
+  }
+  const code = !ts.hasTimezone && offset === void 0 ? ISSUE_CODES.TRANSFORM_TIMESTAMP_NO_TIMEZONE : ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED;
+  return { value: date, issues: [issue(code, "TS.1", "dateTime")] };
+}
+function text(value) {
+  return value === void 0 || value === "" ? void 0 : primitive(value);
+}
+function arr(items) {
+  const present = items.filter((i) => i !== void 0);
+  return present.length === 0 ? void 0 : list(present);
+}
+function object(fields) {
+  const props = fields.filter((f) => f[1] !== void 0).map(([name, value]) => ({ name, value }));
+  return props.length === 0 ? void 0 : complex(props);
+}
+
+// src/datatypes/identifier.ts
+function buildType(typeCode) {
+  if (typeCode === void 0 || typeCode === "") return void 0;
+  const coding2 = object([
+    ["system", text(V2_0203_SYSTEM)],
+    ["code", text(typeCode)]
+  ]);
+  return object([["coding", arr([coding2])]]);
+}
+function toFhirIdentifier(cx, ctx = {}) {
+  const issues = [];
+  if (cx.idNumber === void 0 || cx.idNumber === "") {
+    return { value: void 0, issues };
+  }
+  let system;
+  const hd = cx.assigningAuthority;
+  const hasAuthority = hd !== void 0 && (hd.namespaceId !== void 0 || hd.universalId !== void 0 || hd.universalIdType !== void 0);
+  if (hd !== void 0 && hasAuthority) {
+    system = ctx.namingSystem?.resolveAssigningAuthority(hd);
+    if (system === void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_IDENTIFIER_SYSTEM_UNRESOLVED, "CX.4", "Identifier.system")
+      );
+    }
+  }
+  const identifier = object([
+    ["type", buildType(cx.identifierTypeCode)],
+    ["system", text(system)],
+    ["value", text(cx.idNumber)]
+  ]);
+  if (cx.effectiveDate !== void 0 && cx.effectiveDate !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "CX.7", "Identifier.period"));
+  }
+  if (cx.expirationDate !== void 0 && cx.expirationDate !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "CX.8", "Identifier.period"));
+  }
+  if (cx.assigningJurisdiction !== void 0 && cx.assigningJurisdiction !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "CX.9"));
+  }
+  if (cx.assigningAgencyOrDepartment !== void 0 && cx.assigningAgencyOrDepartment !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "CX.10"));
+  }
+  return { value: identifier, issues };
+}
+
+// src/datatypes/codeable-concept.ts
+function buildCoding(parts, ctx, codeLocation, systemLocation, issues) {
+  if ((parts.code === void 0 || parts.code === "") && (parts.display === void 0 || parts.display === "")) {
+    return void 0;
+  }
+  let system;
+  if (parts.mnemonic !== void 0 && parts.mnemonic !== "") {
+    system = ctx.namingSystem?.resolveCodeSystem(parts.mnemonic);
+    if (system === void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_CODE_SYSTEM_UNRESOLVED, systemLocation, "Coding.system")
+      );
+    }
+  } else if (parts.code !== void 0 && parts.code !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, codeLocation, "Coding.code"));
+  }
+  return object([
+    ["system", text(system)],
+    ["version", text(parts.version)],
+    ["code", text(parts.code)],
+    ["display", text(parts.display)]
+  ]);
+}
+function toFhirCodeableConcept(cwe, ctx = {}) {
+  const issues = [];
+  const primary = buildCoding(
+    {
+      code: cwe.identifier,
+      display: cwe.text,
+      mnemonic: cwe.nameOfCodingSystem,
+      version: cwe.codingSystemVersionId
+    },
+    ctx,
+    "CWE.1",
+    "CWE.3",
+    issues
+  );
+  const alternate = buildCoding(
+    {
+      code: cwe.alternateIdentifier,
+      display: cwe.alternateText,
+      mnemonic: cwe.nameOfAlternateCodingSystem,
+      version: cwe.alternateCodingSystemVersionId
+    },
+    ctx,
+    "CWE.4",
+    "CWE.6",
+    issues
+  );
+  const value = object([
+    ["coding", arr([primary, alternate])],
+    ["text", text(cwe.originalText)]
+  ]);
+  return { value, issues };
+}
+
+// src/datatypes/human-name.ts
+var NAME_USE_MAP = Object.freeze({
+  BAD: "old",
+  D: "usual",
+  L: "official",
+  M: "maiden",
+  MSK: "anonymous",
+  N: "nickname",
+  NAV: "temp",
+  R: "official",
+  TEMP: "temp"
+});
+function toFhirHumanName(xpn) {
+  const issues = [];
+  let use;
+  if (xpn.nameTypeCode !== void 0 && xpn.nameTypeCode !== "") {
+    use = Object.hasOwn(NAME_USE_MAP, xpn.nameTypeCode) ? NAME_USE_MAP[xpn.nameTypeCode] : void 0;
+    if (use === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_NAME_USE_UNMAPPED, "XPN.7", "HumanName.use"));
+    }
+  }
+  if (xpn.effectiveDate !== void 0 && xpn.effectiveDate !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "XPN.12", "HumanName.period"));
+  }
+  if (xpn.expirationDate !== void 0 && xpn.expirationDate !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "XPN.13", "HumanName.period"));
+  }
+  const value = object([
+    ["use", text(use)],
+    ["family", text(xpn.familyName)],
+    ["given", arr([text(xpn.givenName), text(xpn.secondName)])],
+    ["prefix", arr([text(xpn.prefix)])],
+    // XPN.4 (suffix), XPN.6 (degree), XPN.14 (professional suffix) all land in HumanName.suffix.
+    ["suffix", arr([text(xpn.suffix), text(xpn.degree), text(xpn.professionalSuffix)])]
+  ]);
+  return { value, issues };
+}
+
+// src/datatypes/address.ts
+var ADDRESS_USE_MAP = Object.freeze({
+  BA: "old",
+  BI: "billing",
+  C: "temp",
+  B: "work",
+  H: "home",
+  O: "work"
+});
+var ADDRESS_TYPE_MAP = Object.freeze({
+  M: "postal",
+  SH: "postal"
+});
+function toFhirAddress(xad) {
+  const issues = [];
+  let use;
+  let type;
+  if (xad.addressType !== void 0 && xad.addressType !== "") {
+    use = Object.hasOwn(ADDRESS_USE_MAP, xad.addressType) ? ADDRESS_USE_MAP[xad.addressType] : void 0;
+    type = Object.hasOwn(ADDRESS_TYPE_MAP, xad.addressType) ? ADDRESS_TYPE_MAP[xad.addressType] : void 0;
+    if (use === void 0 && type === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ADDRESS_USE_UNMAPPED, "XAD.7", "Address.use"));
+    }
+  }
+  if (xad.otherGeographicDesignation !== void 0 && xad.otherGeographicDesignation !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "XAD.8"));
+  }
+  const value = object([
+    ["use", text(use)],
+    ["type", text(type)],
+    ["line", arr([text(xad.street), text(xad.otherDesignation)])],
+    ["city", text(xad.city)],
+    ["district", text(xad.countyParishCode)],
+    ["state", text(xad.stateOrProvince)],
+    ["postalCode", text(xad.zipOrPostalCode)],
+    ["country", text(xad.country)]
+  ]);
+  return { value, issues };
+}
+function toFhirQuantity(value, units, ctx = {}) {
+  if (value.value === void 0 || value.raw === "") {
+    return { value: void 0, issues: [] };
+  }
+  return quantityFromRawMagnitude(value.raw, units, ctx);
+}
+function quantityFromRawMagnitude(raw, units, ctx = {}, comparator, valueLocation = "OBX.5", unitLocation = "OBX.6") {
+  const issues = [];
+  if (raw === "") {
+    return { value: void 0, issues };
+  }
+  let valueNode;
+  try {
+    valueNode = primitive(decimal(raw));
+  } catch {
+    return {
+      value: void 0,
+      issues: [
+        issue(ISSUE_CODES.TRANSFORM_QUANTITY_VALUE_INVALID, valueLocation, "Quantity.value")
+      ]
+    };
+  }
+  const unitCode = units.identifier;
+  const unitDisplay = units.text;
+  const hasUnit = unitCode !== void 0 && unitCode !== "" || unitDisplay !== void 0 && unitDisplay !== "";
+  let ucumCode;
+  let system;
+  let unitStr = unitDisplay ?? unitCode;
+  if (hasUnit) {
+    const mnemonic = units.nameOfCodingSystem;
+    const declaredUcum = mnemonic === "UCUM" || mnemonic !== void 0 && ctx.namingSystem?.resolveCodeSystem(mnemonic) === UCUM_SYSTEM;
+    if (declaredUcum && unitCode !== void 0 && unitCode !== "" && validateUcumShape(unitCode) === "ok") {
+      ucumCode = unitCode;
+      system = UCUM_SYSTEM;
+      unitStr = unitDisplay ?? unitCode;
+    } else {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_UNIT_NOT_UCUM, unitLocation, "Quantity.code"));
+    }
+  }
+  const quantity = object([
+    ["comparator", text(comparator)],
+    ["value", valueNode],
+    ["unit", text(unitStr)],
+    ["system", text(system)],
+    ["code", text(ucumCode)]
+  ]);
+  return { value: quantity, issues };
+}
+var V2_0162_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0162";
+var V3_ROUTE_OF_ADMINISTRATION_SYSTEM = "http://terminology.hl7.org/CodeSystem/v3-RouteOfAdministration";
+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";
+function valueMap(name, sourceSystem, sourceMnemonics, targets) {
+  return Object.freeze({
+    name,
+    sourceSystem,
+    sourceMnemonics: new Set(sourceMnemonics),
+    translate: (code) => Object.hasOwn(targets, code) ? targets[code] : void 0
+  });
+}
+function identityTargets(system, codes) {
+  const t = {};
+  for (const code of codes) t[code] = { system, code };
+  return t;
+}
+var ROUTE_VALUE_MAP = valueMap(
+  "table-hl70162-to-v2-0162",
+  V2_0162_SYSTEM,
+  ["HL70162", "0162"],
+  {
+    ...identityTargets(V2_0162_SYSTEM, [
+      "AP",
+      "B",
+      "DT",
+      "EP",
+      "ET",
+      "GTT",
+      "GU",
+      "IMR",
+      "IA",
+      "IB",
+      "IC",
+      "ICV",
+      "IH",
+      "IHA",
+      "IN",
+      "IO",
+      "IP",
+      "IS",
+      "IT",
+      "IU",
+      "MTH",
+      "MM",
+      "NS",
+      "NG",
+      "NP",
+      "NT",
+      "OP",
+      "OT",
+      "OTH",
+      "PF",
+      "PR",
+      "RM",
+      "SD",
+      "SL",
+      "TP",
+      "TRA",
+      "TL",
+      "UR",
+      "VG",
+      "VM",
+      "WND"
+    ]),
+    ID: {
+      system: V3_ROUTE_OF_ADMINISTRATION_SYSTEM,
+      code: "IDINJ",
+      display: "Injection, intradermal"
+    },
+    IM: {
+      system: V3_ROUTE_OF_ADMINISTRATION_SYSTEM,
+      code: "IM",
+      display: "Injection, intramuscular"
+    },
+    IV: {
+      system: V3_ROUTE_OF_ADMINISTRATION_SYSTEM,
+      code: "IVINJ",
+      display: "Injection, intravenous"
+    },
+    PO: { system: V3_ROUTE_OF_ADMINISTRATION_SYSTEM, code: "PO", display: "Swallow, oral" },
+    SC: {
+      system: V3_ROUTE_OF_ADMINISTRATION_SYSTEM,
+      code: "SQ",
+      display: "Injection, subcutaneous"
+    },
+    TD: { system: V3_ROUTE_OF_ADMINISTRATION_SYSTEM, code: "TRNSDERM", display: "Transdermal" }
+  }
+);
+var SITE_VALUE_MAP = valueMap(
+  "table-hl70550-to-v2-0550",
+  V2_0550_SYSTEM,
+  ["HL70550", "0550"],
+  identityTargets(V2_0550_SYSTEM, [
+    "JUGE",
+    "ADB",
+    "ACET",
+    "ACHIL",
+    "ADE",
+    "ADR",
+    "AMN",
+    "AMS",
+    "ANAL",
+    "ANKL",
+    "ANTEC",
+    "ANTECF",
+    "ANTR",
+    "ANUS",
+    "AORTA",
+    "AR",
+    "AV",
+    "APDX",
+    "AREO",
+    "ARM",
+    "ARTE",
+    "ASCIT",
+    "ASCT",
+    "ATR",
+    "AURI",
+    "AXI",
+    "BACK",
+    "BARTD",
+    "BARTG",
+    "BRTGF",
+    "BPH",
+    "BID",
+    "BIFL",
+    "BLAD",
+    "BLOOD",
+    "BLDA",
+    "BLDC",
+    "BLDV",
+    "CBLD",
+    "BLD",
+    "BDY",
+    "BON",
+    "BMAR",
+    "BOWEL",
+    "BOWLA",
+    "BOWSM",
+    "BRA",
+    "BRAIN",
+    "BCYS",
+    "BRST",
+    "BRSTFL",
+    "BRO",
+    "BROCH",
+    "BRONC",
+    "BRV",
+    "BUCCA",
+    "BURSA",
+    "BURSF",
+    "BUTT",
+    "CALF",
+    "CANAL",
+    "CANLI",
+    "CNL",
+    "CANTH",
+    "CDM",
+    "CARO",
+    "CARP",
+    "CAVIT",
+    "CHE",
+    "CECUM",
+    "CSF",
+    "CVX",
+    "CERVUT",
+    "CHEEK",
+    "CHES",
+    "CHEST\xC2",
+    "CHIN",
+    "CIRCU",
+    "CLAVI",
+    "CLITO",
+    "CLIT",
+    "COCCG",
+    "COCCY",
+    "COLON",
+    "COLOS",
+    "COS",
+    "CDUCT",
+    "CONJ",
+    "CORAL",
+    "COR",
+    "CORD",
+    "CORN",
+    "CRANE",
+    "CRANF",
+    "CRANO",
+    "CRANP",
+    "CRANS",
+    "CRANT",
+    "CUBIT",
+    "CUFF",
+    "CULD",
+    "CULDO",
+    "DELT",
+    "DENTA",
+    "DEN",
+    "DIAF",
+    "DPH",
+    "DIGIT",
+    "DISC",
+    "DORS",
+    "DUFL",
+    "DUODE",
+    "DUR",
+    "EAR",
+    "EARBI",
+    "EARBM",
+    "EARBS",
+    "EARLO",
+    "ELBOW",
+    "ELBOWJ",
+    "ENDC",
+    "EC",
+    "EOLPH",
+    "ENDM",
+    "ET",
+    "EUR",
+    "EOS",
+    "EPICA",
+    "EPICM",
+    "EPD",
+    "EPIDU",
+    "EPIGL",
+    "ESOPG",
+    "ESO",
+    "ETHMO",
+    "\xC2",
+    "EYE",
+    "BROW",
+    "EYELI",
+    "FACE",
+    "FBINC",
+    "FBLAC",
+    "FBMAX",
+    "FBNAS",
+    "FBPAL",
+    "FBVOM",
+    "FBZYG",
+    "FALLT",
+    "FEMOR",
+    "FMH",
+    "FEMUR",
+    "FET",
+    "FIBU",
+    "FING",
+    "FINGN",
+    "FOL",
+    "FOOT",
+    "FOREA",
+    "FOREH",
+    "FORES",
+    "FOURC",
+    "GB",
+    "GEN",
+    "GVU",
+    "GENC",
+    "GL",
+    "GENL",
+    "GLAND",
+    "GLANS",
+    "GLUTE",
+    "GLUT",
+    "GLUTM",
+    "GROIN",
+    "GUM",
+    "HAR",
+    "HAL",
+    "HAND",
+    "HEAD",
+    "HART",
+    "HV",
+    "HVB",
+    "HVT",
+    "HEEL",
+    "HEM",
+    "HIP",
+    "HIPJ",
+    "HUMER",
+    "HYMEN",
+    "ILC",
+    "ILE",
+    "ILEOS",
+    "ILEUM",
+    "ILIAC",
+    "ILCR",
+    "ILCON",
+    "INGUI",
+    "JUGI",
+    "INT",
+    "ICX",
+    "INASA",
+    "INTRU",
+    "INTRO",
+    "ISCHI",
+    "JAW",
+    "KIDN\xC2",
+    "KNEE",
+    "KNEEF",
+    "KNEEJ",
+    "LABIA",
+    "LABMA",
+    "LABMI",
+    "LACRI",
+    "LAM",
+    "INSTL",
+    "LARYN",
+    "LEG",
+    "LENS",
+    "WBC",
+    "LING",
+    "LINGU",
+    "LIP",
+    "STOOLL",
+    "LIVER",
+    "LOBE",
+    "LOCH",
+    "ISH",
+    "LUMBA",
+    "LMN",
+    "LUNG",
+    "LN",
+    "LNG",
+    "LYM",
+    "MAC",
+    "MALLE",
+    "MANDI",
+    "MAR",
+    "MAST",
+    "MAXIL",
+    "MAXS",
+    "MEATU",
+    "MEC",
+    "MEDST",
+    "MEDU",
+    "MOU",
+    "MPB",
+    "METAC",
+    "METAT",
+    "MILK",
+    "MITRL",
+    "MOLAR",
+    "MP",
+    "MONSU",
+    "MONSV",
+    "MOUTH",
+    "MRSA2",
+    "MYO",
+    "NAIL",
+    "NAILB",
+    "NAILF",
+    "NAILT",
+    "NARES",
+    "NASL",
+    "NSS",
+    "NLACR",
+    "NP",
+    "NTRAC",
+    "NAVEL",
+    "NECK",
+    "NERVE",
+    "NIPPL",
+    "NOS",
+    "NOSE",
+    "NOSTR",
+    "OCCIP",
+    "OLECR",
+    "OMEN",
+    "ORBIT",
+    "ORO",
+    "OSCOX",
+    "OVARY",
+    "PALAT",
+    "PLATH",
+    "PLATS",
+    "PALM",
+    "PANCR",
+    "PAFL",
+    "PAS",
+    "PARAT",
+    "PARIE",
+    "PARON",
+    "PAROT",
+    "PATEL",
+    "PELV",
+    "PENSH",
+    "PENIS",
+    "PANAL",
+    "PERI",
+    "PCARD",
+    "PCLIT",
+    "PERIH",
+    "PNEAL",
+    "PERIN",
+    "PNEPH",
+    "PNM",
+    "PORBI",
+    "PERRA",
+    "PERIS",
+    "PER",
+    "PERT",
+    "PERIT",
+    "PTONS",
+    "PERIU",
+    "PERIV",
+    "PHALA",
+    "PILO",
+    "PINNA",
+    "PLC",
+    "PLACF",
+    "PLACM",
+    "PLANT",
+    "PLEUR",
+    "PLEU",
+    "PLR",
+    "POPLI",
+    "PREAU",
+    "PRERE",
+    "PRST",
+    "PROS",
+    "PUBIC",
+    "PUL",
+    "RADI",
+    "RADIUS",
+    "RECTL",
+    "RECTU",
+    "RBC",
+    "RENL",
+    "RNP",
+    "RPERI",
+    "RIB",
+    "SACRA",
+    "SACRO",
+    "SACIL",
+    "SACRU",
+    "SALGL",
+    "SCALP",
+    "SCAPU",
+    "SCLER",
+    "SCROT",
+    "SEMN",
+    "SEM",
+    "SEPTU",
+    "SEROM",
+    "SHIN",
+    "SHOLJ",
+    "SHOL",
+    "SIGMO",
+    "SINUS",
+    "SKM",
+    "SKENE",
+    "SKULL",
+    "INSTS",
+    "SOLE",
+    "SPRM",
+    "SPHEN",
+    "SPCOR",
+    "SPLN",
+    "STER",
+    "STOM",
+    "USTOM",
+    "STOMA",
+    "STUMP",
+    "SCLV",
+    "SDP",
+    "SUB",
+    "SUBD",
+    "SGF",
+    "SUBM",
+    "SUBX",
+    "SUBME",
+    "SUBPH",
+    "SPX",
+    "SCLAV",
+    "SUPRA",
+    "SUPB",
+    "SWT",
+    "SWTG",
+    "SYNOL",
+    "SYN",
+    "SYNOV",
+    "TARS",
+    "TDUCT",
+    "TEAR",
+    "TEMPL",
+    "TEMPO",
+    "TML",
+    "TESTI",
+    "THIGH",
+    "THORA",
+    "THRB",
+    "THUMB",
+    "TNL",
+    "THM",
+    "THYRD",
+    "TIBIA",
+    "TOE",
+    "TOEN",
+    "TONG",
+    "TONS",
+    "TOOTH",
+    "TSK",
+    "TRCHE",
+    "TBRON",
+    "TCN",
+    "ULNA",
+    "UMB",
+    "UMBL",
+    "URET",
+    "URTH",
+    "UTERI",
+    "SAC",
+    "UTER",
+    "VAGIN",
+    "VCUFF",
+    "VGV",
+    "VAL",
+    "VAS",
+    "VASTL",
+    "VAULT",
+    "VEIN",
+    "VENTG",
+    "VCSF",
+    "VERMI",
+    "VERTC",
+    "VERTL",
+    "VERTT",
+    "VESI",
+    "VESCL",
+    "VESFLD",
+    "VESTI",
+    "VITR",
+    "VOC",
+    "VULVA",
+    "WRIST"
+  ])
+);
+var APPOINTMENT_TYPE_VALUE_MAP = valueMap(
+  "table-hl70277-to-v2-0277",
+  V2_0277_SYSTEM,
+  ["HL70277", "0277"],
+  identityTargets(V2_0277_SYSTEM, ["Normal", "Tentative", "Complete"])
+);
+var SUBSTITUTION_VALUE_MAP = valueMap(
+  "table-hl70161-to-v2-0161",
+  V2_0161_SYSTEM,
+  ["HL70161", "0161"],
+  identityTargets(V2_0161_SYSTEM, ["N", "G", "T"])
+);
+function codingFrom(system, code, display, version) {
+  const props = [{ name: "system", value: primitive(system) }];
+  if (version !== void 0 && version !== "")
+    props.push({ name: "version", value: primitive(version) });
+  props.push({ name: "code", value: primitive(code) });
+  if (display !== void 0 && display !== "")
+    props.push({ name: "display", value: primitive(display) });
+  return complex(props);
+}
+function translateBound(cwe, map) {
+  const mnemonic = cwe.nameOfCodingSystem;
+  const fromBoundTable = mnemonic === void 0 || mnemonic === "" || map.sourceMnemonics.has(mnemonic);
+  if (!fromBoundTable) return void 0;
+  const code = cwe.identifier;
+  return code === void 0 || code === "" ? void 0 : map.translate(code);
+}
+function codeableConceptFromTarget(target, text2) {
+  const props = [
+    { name: "coding", value: list([codingFrom(target.system, target.code, target.display)]) }
+  ];
+  if (text2 !== void 0 && text2 !== "") props.push({ name: "text", value: primitive(text2) });
+  return complex(props);
+}
+function toFhirCodeableConceptVia(cwe, map, ctx = {}) {
+  const target = translateBound(cwe, map);
+  if (target === void 0) {
+    return toFhirCodeableConcept(cwe, ctx);
+  }
+  const issues = [];
+  const codings = [];
+  codings.push(
+    codingFrom(map.sourceSystem, cwe.identifier, cwe.text, cwe.codingSystemVersionId)
+  );
+  const isIdentity = target.system === map.sourceSystem && target.code === cwe.identifier;
+  if (!isIdentity) codings.push(codingFrom(target.system, target.code, target.display));
+  const alternate = buildCoding(
+    {
+      code: cwe.alternateIdentifier,
+      display: cwe.alternateText,
+      mnemonic: cwe.nameOfAlternateCodingSystem,
+      version: cwe.alternateCodingSystemVersionId
+    },
+    ctx,
+    "CWE.4",
+    "CWE.6",
+    issues
+  );
+  if (alternate !== void 0) codings.push(alternate);
+  const props = [{ name: "coding", value: list(codings) }];
+  if (cwe.originalText !== void 0 && cwe.originalText !== "") {
+    props.push({ name: "text", value: primitive(cwe.originalText) });
+  }
+  return { value: complex(props), issues };
+}
+var DATA_ABSENT_REASON_URL = "http://hl7.org/fhir/StructureDefinition/data-absent-reason";
+var IdAllocator = class {
+  gen;
+  /**
+   * @param options - The transform options; `options.generateId` overrides the default UUID source.
+   */
+  constructor(options) {
+    this.gen = options?.generateId ?? (() => randomUUID());
+  }
+  /** Mint one fresh `urn:uuid:<id>` fullUrl. */
+  next() {
+    return `urn:uuid:${this.gen()}`;
+  }
+};
+function reference(fullUrl) {
+  return complex([{ name: "reference", value: primitive(fullUrl) }]);
+}
+function coding(system, code, display) {
+  if (code === void 0 || code === "") return void 0;
+  const props = [
+    { name: "system", value: primitive(system) },
+    { name: "code", value: primitive(code) }
+  ];
+  if (display !== void 0 && display !== "") {
+    props.push({ name: "display", value: primitive(display) });
+  }
+  return complex(props);
+}
+function orderIdentifier(value, typeCode) {
+  if (value === "") return void 0;
+  return complex([
+    {
+      name: "type",
+      value: complex([
+        {
+          name: "coding",
+          value: list([
+            complex([
+              { name: "system", value: primitive(V2_0203_SYSTEM) },
+              { name: "code", value: primitive(typeCode) }
+            ])
+          ])
+        }
+      ])
+    },
+    { name: "value", value: primitive(value) }
+  ]);
+}
+function dataAbsent(reasonCode) {
+  const ext = complex([
+    { name: "url", value: primitive(DATA_ABSENT_REASON_URL) },
+    { name: "valueCode", value: primitive(reasonCode) }
+  ]);
+  return primitive(void 0, { extension: [ext] });
+}
+
+// src/messages/appointment.ts
+var APPOINTMENT_STATUS_MAP = Object.freeze({
+  Pending: "pending",
+  Waitlist: "waitlist",
+  Booked: "booked",
+  Started: "checked-in",
+  Complete: "fulfilled",
+  Cancelled: "cancelled",
+  Deleted: "entered-in-error",
+  Noshow: "noshow"
+});
+var PARTICIPANT_STATUS_UNKNOWN = "unknown";
+var MINUTE_UNITS = /* @__PURE__ */ new Set(["min", "MIN", "minutes", "m"]);
+var POSITIVE_INT = /^[1-9][0-9]*$/;
+function tqInstant(raw, ctx, location, fhirPath, issues) {
+  if (raw === void 0 || raw === "") return void 0;
+  const ts = parseDtm(raw);
+  const dt = toFhirDateTime(ts, ctx.options);
+  issues.push(...dt.issues);
+  if (dt.value === void 0) return void 0;
+  if (dt.value.includes("T") && (dt.value.includes("+") || dt.value.endsWith("Z") || /-\d{2}:\d{2}$/.test(dt.value))) {
+    return dt.value;
+  }
+  issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, location, fhirPath));
+  return void 0;
+}
+function rawComponent(seg, field, index) {
+  const c = seg.field(field).repetitions[0]?.components[index]?.subcomponents[0];
+  return c === void 0 || c === "" ? void 0 : c;
+}
+function patientParticipant(patientFullUrl, issues) {
+  if (patientFullUrl === void 0) return void 0;
+  issues.push(
+    issue(ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN, "SIU", "Appointment.participant.status")
+  );
+  return complex([
+    { name: "actor", value: reference(patientFullUrl) },
+    { name: "status", value: dataAbsent(PARTICIPANT_STATUS_UNKNOWN) }
+  ]);
+}
+function buildAppointment(sch, ais, patientFullUrl, ctx) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: primitive("Appointment") }
+  ];
+  const fillerStatus = sch.field(25).value;
+  if (fillerStatus !== "") {
+    const status = Object.hasOwn(APPOINTMENT_STATUS_MAP, fillerStatus) ? APPOINTMENT_STATUS_MAP[fillerStatus] : void 0;
+    if (status === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "SCH.25", "Appointment.status"));
+    } else {
+      props.push({ name: "status", value: primitive(status) });
+    }
+  }
+  const identifiers = [sch.field(1).value, sch.field(2).value].filter((v) => v !== "").map((v) => complex([{ name: "value", value: primitive(v) }]));
+  if (identifiers.length > 0) props.push({ name: "identifier", value: list(identifiers) });
+  if (sch.field(8).value !== "") {
+    const appointmentType = toFhirCodeableConceptVia(
+      sch.field(8).asCwe(),
+      APPOINTMENT_TYPE_VALUE_MAP,
+      ctx
+    );
+    issues.push(...appointmentType.issues);
+    if (appointmentType.value !== void 0)
+      props.push({ name: "appointmentType", value: appointmentType.value });
+  }
+  if (ais !== void 0 && ais.field(3).value !== "") {
+    const serviceType = toFhirCodeableConcept(ais.field(3).asCwe(), ctx);
+    issues.push(...serviceType.issues);
+    if (serviceType.value !== void 0)
+      props.push({ name: "serviceType", value: list([serviceType.value]) });
+  }
+  if (sch.field(7).value !== "") {
+    const reason = toFhirCodeableConcept(sch.field(7).asCwe(), ctx);
+    issues.push(...reason.issues);
+    if (reason.value !== void 0) props.push({ name: "reasonCode", value: list([reason.value]) });
+  }
+  const duration = sch.field(9).value;
+  if (duration !== "" && POSITIVE_INT.test(duration) && MINUTE_UNITS.has(rawComponent(sch, 10, 0) ?? "")) {
+    props.push({ name: "minutesDuration", value: primitive(decimal(duration)) });
+  }
+  const start = tqInstant(rawComponent(sch, 11, 3), ctx, "SCH.11", "Appointment.start", issues);
+  if (start !== void 0) props.push({ name: "start", value: primitive(start) });
+  const end = tqInstant(rawComponent(sch, 11, 4), ctx, "SCH.11", "Appointment.end", issues);
+  if (end !== void 0) props.push({ name: "end", value: primitive(end) });
+  const participant = patientParticipant(patientFullUrl, issues);
+  if (participant !== void 0) props.push({ name: "participant", value: list([participant]) });
+  return { value: complex(props), issues };
+}
+function collectAppointment(msg) {
+  let sch;
+  let ais;
+  for (const seg of msg.allSegments()) {
+    if (seg.type === "SCH" && sch === void 0) sch = seg;
+    else if (seg.type === "AIS" && ais === void 0) ais = seg;
+  }
+  return { sch, ais };
+}
+var V2_0074_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0074";
+var DIAGNOSTIC_REPORT_STATUS_MAP = Object.freeze({
+  O: "registered",
+  I: "registered",
+  S: "registered",
+  P: "preliminary",
+  R: "partial",
+  C: "corrected",
+  F: "final",
+  X: "cancelled"
+});
+function buildDiagnosticReport(obr, resultFullUrls, subjectFullUrl, encounterFullUrl, ctx) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: primitive("DiagnosticReport") }
+  ];
+  const identifiers = [
+    orderIdentifier(obr.field(2).value, "PLAC"),
+    orderIdentifier(obr.field(3).value, "FILL")
+  ].filter((i) => i !== void 0);
+  if (identifiers.length > 0) props.push({ name: "identifier", value: list(identifiers) });
+  const statusCode = obr.field(25).value;
+  if (statusCode !== "") {
+    const status = Object.hasOwn(DIAGNOSTIC_REPORT_STATUS_MAP, statusCode) ? DIAGNOSTIC_REPORT_STATUS_MAP[statusCode] : void 0;
+    if (status === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "OBR.25", "DiagnosticReport.status"));
+    } else {
+      props.push({ name: "status", value: primitive(status) });
+    }
+  }
+  const section = obr.field(24).value;
+  if (section !== "") {
+    props.push({
+      name: "category",
+      value: list([
+        complex([
+          {
+            name: "coding",
+            value: list([
+              complex([
+                { name: "system", value: primitive(V2_0074_SYSTEM) },
+                { name: "code", value: primitive(section) }
+              ])
+            ])
+          }
+        ])
+      ])
+    });
+  }
+  const code = toFhirCodeableConcept(obr.field(4).asCwe(), ctx);
+  issues.push(...code.issues);
+  if (code.value === void 0) return { value: void 0, issues };
+  props.push({ name: "code", value: code.value });
+  if (subjectFullUrl !== void 0)
+    props.push({ name: "subject", value: reference(subjectFullUrl) });
+  if (encounterFullUrl !== void 0) {
+    props.push({ name: "encounter", value: reference(encounterFullUrl) });
+  }
+  const hasEnd = obr.field(8).value !== "";
+  if (obr.field(7).value !== "") {
+    const start = toFhirDateTime(obr.field(7).asTs(), ctx.options);
+    issues.push(...start.issues);
+    if (start.value !== void 0 && !hasEnd) {
+      props.push({ name: "effectiveDateTime", value: primitive(start.value) });
+    } else if (start.value !== void 0) {
+      const end = toFhirDateTime(obr.field(8).asTs(), ctx.options);
+      issues.push(...end.issues);
+      const periodProps = [
+        { name: "start", value: primitive(start.value) }
+      ];
+      if (end.value !== void 0) periodProps.push({ name: "end", value: primitive(end.value) });
+      props.push({ name: "effectivePeriod", value: complex(periodProps) });
+    }
+  }
+  if (obr.field(22).value !== "") {
+    const issued = toFhirDateTime(obr.field(22).asTs(), ctx.options);
+    issues.push(...issued.issues);
+    if (issued.value !== void 0 && issued.value.includes("T")) {
+      props.push({ name: "issued", value: primitive(issued.value) });
+    } else if (issued.value !== void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "OBR.22", "DiagnosticReport.issued")
+      );
+    }
+  }
+  if (resultFullUrls.length > 0) {
+    props.push({ name: "result", value: list(resultFullUrls.map((u) => reference(u))) });
+  }
+  return { value: complex(props), issues };
+}
+var STATUS_AVAILABLE_TARGET = "current";
+var BODY_CONTENT_TYPE = Object.freeze({
+  TX: "application/text",
+  FT: "text/hl7v2"
+});
+function buildContent(obx, index, issues) {
+  const valueType = obx.field(2).value.toUpperCase();
+  const raw = obx.field(5).value;
+  if (raw === "") return void 0;
+  if (Object.hasOwn(BODY_CONTENT_TYPE, valueType)) {
+    const data = Buffer.from(raw, "utf8").toString("base64");
+    return complex([
+      {
+        name: "attachment",
+        value: complex([
+          { name: "contentType", value: primitive(BODY_CONTENT_TYPE[valueType]) },
+          { name: "data", value: primitive(data) }
+        ])
+      }
+    ]);
+  }
+  if (valueType === "RP") {
+    return complex([
+      {
+        name: "attachment",
+        value: complex([{ name: "url", value: primitive(raw) }])
+      }
+    ]);
+  }
+  issues.push(
+    issue(
+      ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+      `OBX[${String(index)}].5`,
+      "DocumentReference.content"
+    )
+  );
+  return void 0;
+}
+function buildDocumentReference(txa, obxs, subjectFullUrl, ctx) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: primitive("DocumentReference") }
+  ];
+  const availability = txa.field(19).value;
+  if (availability === "AV") {
+    props.push({ name: "status", value: primitive(STATUS_AVAILABLE_TARGET) });
+  } else if (availability !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "TXA.19", "DocumentReference.status"));
+  }
+  if (txa.field(17).value !== "") {
+    issues.push(
+      issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "TXA.17", "DocumentReference.docStatus")
+    );
+  }
+  if (txa.field(2).value !== "") {
+    const type = toFhirCodeableConcept(txa.field(2).asCwe(), ctx);
+    issues.push(...type.issues);
+    if (type.value !== void 0) props.push({ name: "type", value: type.value });
+  }
+  if (txa.field(12).value !== "") {
+    props.push({
+      name: "masterIdentifier",
+      value: complex([{ name: "value", value: primitive(txa.field(12).value) }])
+    });
+  }
+  if (txa.field(16).value !== "") {
+    props.push({
+      name: "identifier",
+      value: list([complex([{ name: "value", value: primitive(txa.field(16).value) }])])
+    });
+  }
+  if (subjectFullUrl !== void 0)
+    props.push({ name: "subject", value: reference(subjectFullUrl) });
+  if (txa.field(6).value !== "") {
+    const date = toFhirDateTime(txa.field(6).asTs(), ctx.options);
+    issues.push(...date.issues);
+    if (date.value !== void 0 && date.value.includes("T")) {
+      props.push({ name: "date", value: primitive(date.value) });
+    } else if (date.value !== void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "TXA.6", "DocumentReference.date"));
+    }
+  }
+  if (txa.field(3).value !== "") {
+    issues.push(
+      issue(
+        ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+        "TXA.3",
+        "DocumentReference.content.attachment.contentType"
+      )
+    );
+  }
+  if (txa.field(25).value !== "")
+    props.push({ name: "description", value: primitive(txa.field(25).value) });
+  const contents = [];
+  for (let i = 0; i < obxs.length; i++) {
+    const obx = obxs[i];
+    if (obx === void 0) continue;
+    const content = buildContent(obx, i, issues);
+    if (content !== void 0) contents.push(content);
+  }
+  if (contents.length > 0) props.push({ name: "content", value: list(contents) });
+  return { value: complex(props), issues };
+}
+function collectDocument(msg) {
+  let txa;
+  const obxs = [];
+  for (const seg of msg.allSegments()) {
+    if (seg.type === "TXA" && txa === void 0) txa = seg;
+    else if (seg.type === "OBX") obxs.push(seg);
+  }
+  return { txa, obxs };
+}
+var V3_ACTCODE_SYSTEM = "http://terminology.hl7.org/CodeSystem/v3-ActCode";
+var V2_0004_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0004";
+var ENCOUNTER_CLASS_V3_MAP = Object.freeze({
+  E: { code: "EMER", display: "emergency" },
+  I: { code: "IMP", display: "inpatient encounter" },
+  O: { code: "AMB", display: "ambulatory" },
+  P: { code: "PRENC", display: "pre-admission" }
+});
+var V2_SELF_CLASSES = /* @__PURE__ */ new Set(["R", "B", "C", "N", "U"]);
+var ENCOUNTER_STATUS_MAP = Object.freeze({
+  E: "in-progress",
+  I: "in-progress",
+  O: "in-progress",
+  R: "in-progress",
+  B: "in-progress",
+  C: "in-progress",
+  N: "in-progress",
+  P: "planned",
+  U: "unknown"
+});
+function buildClass(patientClass, issues) {
+  if (patientClass === void 0 || patientClass === "") return void 0;
+  const v3 = ENCOUNTER_CLASS_V3_MAP[patientClass];
+  if (v3 !== void 0) return coding(V3_ACTCODE_SYSTEM, v3.code, v3.display);
+  if (V2_SELF_CLASSES.has(patientClass)) return coding(V2_0004_SYSTEM, patientClass);
+  issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "PV1.2", "Encounter.class"));
+  return void 0;
+}
+function buildEncounter(visit, subjectFullUrl, ctx) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: primitive("Encounter") }
+  ];
+  if (visit.visitNumber !== void 0 && visit.visitNumber !== "") {
+    const vnCoding = complex([
+      { name: "system", value: primitive(V2_0203_SYSTEM) },
+      { name: "code", value: primitive("VN") }
+    ]);
+    const identifier = complex([
+      { name: "type", value: complex([{ name: "coding", value: list([vnCoding]) }]) },
+      { name: "value", value: primitive(visit.visitNumber) }
+    ]);
+    props.push({ name: "identifier", value: list([identifier]) });
+  }
+  const discharged = visit.dischargeDateTime !== void 0;
+  let status;
+  if (discharged) {
+    status = "finished";
+  } else if (visit.patientClass !== void 0 && visit.patientClass !== "") {
+    status = Object.hasOwn(ENCOUNTER_STATUS_MAP, visit.patientClass) ? ENCOUNTER_STATUS_MAP[visit.patientClass] : void 0;
+    if (status === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "PV1.2", "Encounter.status"));
+    }
+  }
+  if (status !== void 0) props.push({ name: "status", value: primitive(status) });
+  const encounterClass = buildClass(visit.patientClass, issues);
+  if (encounterClass !== void 0) props.push({ name: "class", value: encounterClass });
+  if (subjectFullUrl !== void 0) {
+    props.push({ name: "subject", value: reference(subjectFullUrl) });
+  } else {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PID", "Encounter.subject"));
+  }
+  const periodProps = [];
+  if (visit.admitDateTime !== void 0) {
+    const start = toFhirDateTime(visit.admitDateTime, ctx.options);
+    issues.push(...start.issues);
+    if (start.value !== void 0)
+      periodProps.push({ name: "start", value: primitive(start.value) });
+  }
+  if (visit.dischargeDateTime !== void 0) {
+    const end = toFhirDateTime(visit.dischargeDateTime, ctx.options);
+    issues.push(...end.issues);
+    if (end.value !== void 0) periodProps.push({ name: "end", value: primitive(end.value) });
+  }
+  if (periodProps.length > 0) props.push({ name: "period", value: complex(periodProps) });
+  if (visit.location !== void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PV1.3", "Encounter.location"));
+  }
+  if (visit.attendingDoctor !== void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PV1.7", "Encounter.participant"));
+  }
+  if (visit.referringDoctor !== void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PV1.8", "Encounter.participant"));
+  }
+  if (props.length === 1) return { value: void 0, issues };
+  return { value: complex(props), issues };
+}
+var EMIT_SCHEMAS = Object.freeze([
+  {
+    type: "Encounter",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      class: { min: 1, max: 1, types: ["Coding"] }
+    }
+  },
+  {
+    type: "MessageHeader",
+    elements: {
+      eventCoding: { min: 1, max: 1, types: ["Coding"] }
+    }
+  },
+  {
+    type: "RelatedPerson",
+    elements: {
+      patient: { min: 1, max: 1, types: ["Reference"] }
+    }
+  },
+  {
+    type: "DiagnosticReport",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      code: { min: 1, max: 1, types: ["CodeableConcept"] }
+    }
+  },
+  {
+    type: "Observation",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      code: { min: 1, max: 1, types: ["CodeableConcept"] }
+    }
+  },
+  {
+    type: "ServiceRequest",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      intent: { min: 1, max: 1, types: ["code"] },
+      subject: { min: 1, max: 1, types: ["Reference"] }
+    }
+  },
+  {
+    type: "MedicationRequest",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      intent: { min: 1, max: 1, types: ["code"] },
+      subject: { min: 1, max: 1, types: ["Reference"] },
+      medicationCodeableConcept: { min: 1, max: 1, types: ["CodeableConcept"] }
+    }
+  },
+  {
+    // Immunization: status (1..1 code), vaccineCode (1..1 CodeableConcept), patient (1..1 Reference), and
+    // occurrence[x] (1..1) are all required — the assembler only ever emits the occurrenceDateTime form, so
+    // it is required here. An RXA with no groundable status/vaccine/occurrence, or no bundle Patient, is
+    // withheld rather than emitted incomplete.
+    type: "Immunization",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      vaccineCode: { min: 1, max: 1, types: ["CodeableConcept"] },
+      patient: { min: 1, max: 1, types: ["Reference"] },
+      occurrenceDateTime: { min: 1, max: 1, types: ["dateTime"] }
+    }
+  },
+  {
+    // Appointment: status (1..1 code) and participant (1..* BackboneElement) are both required — an
+    // Appointment whose SCH-25 status could not be grounded via HL70278, or that has no resolvable Patient
+    // participant, is withheld rather than emitted with a guessed status or no participant.
+    type: "Appointment",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      participant: { min: 1, max: UNBOUNDED, types: ["BackboneElement"] }
+    }
+  },
+  {
+    // DocumentReference: status (1..1 code) and content (1..* BackboneElement) are both required — a
+    // reference whose TXA-19 is not "AV" (no groundable status), or that carries no document body from its
+    // OBX segments, is withheld rather than emitted with a guessed status or referencing nothing.
+    type: "DocumentReference",
+    elements: {
+      status: { min: 1, max: 1, types: ["code"] },
+      content: { min: 1, max: UNBOUNDED, types: ["BackboneElement"] }
+    }
+  }
+]);
+var IMMUNIZATION_STATUS_MAP = Object.freeze({
+  CP: "completed",
+  PA: "completed",
+  RE: "not-done",
+  NA: "not-done"
+});
+function collectImmunizationGroups(msg) {
+  const groups = [];
+  let current;
+  const open = () => {
+    const g = { orc: void 0, rxa: void 0, rxr: void 0 };
+    groups.push(g);
+    current = g;
+    return g;
+  };
+  for (const seg of msg.allSegments()) {
+    switch (seg.type) {
+      case "ORC":
+        open().orc = seg;
+        break;
+      case "RXA":
+        if (current === void 0 || current.rxa !== void 0) open();
+        current.rxa = seg;
+        break;
+      case "RXR":
+        if (current !== void 0 && current.rxa !== void 0 && current.rxr === void 0) {
+          current.rxr = seg;
+        }
+        break;
+    }
+  }
+  return groups.filter((g) => g.rxa !== void 0).map((g) => ({ orc: g.orc, rxa: g.rxa, rxr: g.rxr }));
+}
+function buildStatus(rxa, issues) {
+  const actionCode = rxa.field(21).value;
+  if (actionCode === "D") return "entered-in-error";
+  const completion = rxa.field(20).value;
+  if (completion === "") return "completed";
+  const mapped = Object.hasOwn(IMMUNIZATION_STATUS_MAP, completion) ? IMMUNIZATION_STATUS_MAP[completion] : void 0;
+  if (mapped === void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "RXA.20", "Immunization.status"));
+  }
+  return mapped;
+}
+function translatedFrom(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);
+  return cc.value;
+}
+function buildImmunization(rxa, rxr, orc, patientFullUrl, encounterFullUrl, ctx) {
+  const issues = [];
+  if (rxa.field(5).value === "") return { value: void 0, issues };
+  const vaccineCode = toFhirCodeableConcept(rxa.field(5).asCwe(), ctx);
+  issues.push(...vaccineCode.issues);
+  if (vaccineCode.value === void 0) return { value: void 0, issues };
+  const props = [
+    { name: "resourceType", value: primitive("Immunization") }
+  ];
+  if (orc !== void 0) {
+    const identifiers = [
+      orderIdentifier(orc.field(2).value, "PLAC"),
+      orderIdentifier(orc.field(3).value, "FILL")
+    ].filter((i) => i !== void 0);
+    if (identifiers.length > 0) props.push({ name: "identifier", value: list(identifiers) });
+  }
+  const status = buildStatus(rxa, issues);
+  if (status !== void 0) props.push({ name: "status", value: primitive(status) });
+  props.push({ name: "vaccineCode", value: vaccineCode.value });
+  if (patientFullUrl !== void 0)
+    props.push({ name: "patient", value: reference(patientFullUrl) });
+  if (encounterFullUrl !== void 0)
+    props.push({ name: "encounter", value: reference(encounterFullUrl) });
+  if (rxa.field(3).value !== "") {
+    const occurrence = toFhirDateTime(rxa.field(3).asTs(), ctx.options);
+    issues.push(...occurrence.issues);
+    if (occurrence.value !== void 0)
+      props.push({ name: "occurrenceDateTime", value: primitive(occurrence.value) });
+  }
+  const recordedTs = rxa.field(22).value !== "" ? rxa.field(22).asTs() : orc !== void 0 && orc.field(9).value !== "" ? orc.field(9).asTs() : void 0;
+  if (recordedTs !== void 0) {
+    const recorded = toFhirDateTime(recordedTs, ctx.options);
+    issues.push(...recorded.issues);
+    if (recorded.value !== void 0)
+      props.push({ name: "recorded", value: primitive(recorded.value) });
+  }
+  const doseRaw = rxa.field(6).asNm().raw;
+  if (doseRaw !== "") {
+    const dose = quantityFromRawMagnitude(
+      doseRaw,
+      rxa.field(7).asCwe(),
+      ctx,
+      void 0,
+      "RXA.6",
+      "RXA.7"
+    );
+    issues.push(...dose.issues);
+    if (dose.value !== void 0) props.push({ name: "doseQuantity", value: dose.value });
+  }
+  if (rxa.field(15).value !== "")
+    props.push({ name: "lotNumber", value: primitive(rxa.field(15).value) });
+  if (rxa.field(16).value !== "") {
+    const exp = toFhirDateTime(rxa.field(16).asTs(), ctx.options);
+    issues.push(...exp.issues);
+    if (exp.value !== void 0 && !exp.value.includes("T")) {
+      props.push({ name: "expirationDate", value: primitive(exp.value) });
+    } else if (exp.value !== void 0) {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "RXA.16", "Immunization.expirationDate")
+      );
+    }
+  }
+  if (rxa.field(18).value !== "") {
+    const reason = toFhirCodeableConcept(rxa.field(18).asCwe(), ctx);
+    issues.push(...reason.issues);
+    if (reason.value !== void 0) props.push({ name: "statusReason", value: reason.value });
+  }
+  if (rxa.field(19).value !== "") {
+    const indication = toFhirCodeableConcept(rxa.field(19).asCwe(), ctx);
+    issues.push(...indication.issues);
+    if (indication.value !== void 0)
+      props.push({ name: "reasonCode", value: list([indication.value]) });
+  }
+  if (rxr !== void 0) {
+    const route = translatedFrom(rxr, 1, ROUTE_VALUE_MAP, ctx, issues);
+    if (route !== void 0) props.push({ name: "route", value: route });
+    const site = translatedFrom(rxr, 2, SITE_VALUE_MAP, ctx, issues);
+    if (site !== void 0) props.push({ name: "site", value: site });
+  }
+  return { value: 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;
+}
+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);
+  return cc.value;
+}
+function doseEndpoint(rxo, amountIndex, units, ctx, issues) {
+  const raw = rxo.field(amountIndex).asNm().raw;
+  if (raw === "") return void 0;
+  const q = quantityFromRawMagnitude(
+    raw,
+    units,
+    ctx,
+    void 0,
+    `RXO.${String(amountIndex)}`,
+    "RXO.4"
+  );
+  issues.push(...q.issues);
+  return q.value;
+}
+function buildDosageInstruction(rxo, rxr, ctx, issues) {
+  const props = [];
+  if (rxr !== void 0) {
+    const route = translatedFrom2(rxr, 1, ROUTE_VALUE_MAP, ctx, issues);
+    if (route !== void 0) props.push({ name: "route", value: route });
+    const site = translatedFrom2(rxr, 2, SITE_VALUE_MAP, ctx, issues);
+    if (site !== void 0) props.push({ name: "site", value: site });
+    const method = codeableFrom(rxr, 4, ctx, issues);
+    if (method !== void 0) props.push({ name: "method", value: method });
+  }
+  if (rxo !== void 0) {
+    const units = rxo.field(4).asCwe();
+    const low = doseEndpoint(rxo, 2, units, ctx, issues);
+    const high = doseEndpoint(rxo, 3, units, ctx, issues);
+    const rangeProps = [];
+    if (low !== void 0) rangeProps.push({ name: "low", value: low });
+    if (high !== void 0) rangeProps.push({ name: "high", value: high });
+    if (rangeProps.length > 0) {
+      props.push({
+        name: "doseAndRate",
+        value: list([complex([{ name: "doseRange", value: complex(rangeProps) }])])
+      });
+    }
+  }
+  return props.length === 0 ? void 0 : complex(props);
+}
+function buildDispenseRequest(rxo, ctx, issues) {
+  const props = [];
+  const amount = rxo.field(11).asNm().raw;
+  if (amount !== "") {
+    const q = quantityFromRawMagnitude(
+      amount,
+      rxo.field(12).asCwe(),
+      ctx,
+      void 0,
+      "RXO.11",
+      "RXO.12"
+    );
+    issues.push(...q.issues);
+    if (q.value !== void 0) props.push({ name: "quantity", value: q.value });
+  }
+  const refills = rxo.field(13).value;
+  if (refills !== "") {
+    if (UNSIGNED_INT.test(refills)) {
+      props.push({ name: "numberOfRepeatsAllowed", value: primitive(decimal(refills)) });
+    } else {
+      issues.push(
+        issue(
+          ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED,
+          "RXO.13",
+          "dispenseRequest.numberOfRepeatsAllowed"
+        )
+      );
+    }
+  }
+  return props.length === 0 ? void 0 : complex(props);
+}
+function buildMedicationRequest(rxo, rxr, orc, subjectFullUrl, encounterFullUrl, ctx) {
+  const 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);
+  if (medication.value === void 0) return { value: void 0, issues };
+  const props = [
+    { name: "resourceType", value: primitive("MedicationRequest") }
+  ];
+  props.push({ name: "status", value: primitive(STATUS_UNKNOWN) });
+  issues.push(
+    issue(ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN, "RXO", "MedicationRequest.status")
+  );
+  props.push({ name: "intent", value: primitive(ORDER_INTENT) });
+  props.push({ name: "medicationCodeableConcept", value: medication.value });
+  if (subjectFullUrl !== void 0)
+    props.push({ name: "subject", value: reference(subjectFullUrl) });
+  if (encounterFullUrl !== void 0)
+    props.push({ name: "encounter", value: reference(encounterFullUrl) });
+  if (orc !== void 0 && orc.field(1).value === "NW" && orc.field(9).value !== "") {
+    const authored = toFhirDateTime(orc.field(9).asTs(), ctx.options);
+    issues.push(...authored.issues);
+    if (authored.value !== void 0)
+      props.push({ name: "authoredOn", value: primitive(authored.value) });
+  }
+  const dosage = buildDosageInstruction(rxo, rxr, ctx, issues);
+  if (dosage !== void 0) props.push({ name: "dosageInstruction", value: list([dosage]) });
+  const dispense = buildDispenseRequest(rxo, ctx, issues);
+  if (dispense !== void 0) props.push({ name: "dispenseRequest", value: dispense });
+  const cwe9 = rxo.field(9).asCwe();
+  if (cwe9.identifier !== void 0 && cwe9.identifier !== "") {
+    const target = translateBound(cwe9, SUBSTITUTION_VALUE_MAP);
+    if (target === void 0) {
+      issues.push(
+        issue(
+          ISSUE_CODES.TRANSFORM_CODE_UNMAPPED,
+          "RXO.9",
+          "MedicationRequest.substitution.allowedCodeableConcept"
+        )
+      );
+    } else {
+      props.push({
+        name: "substitution",
+        value: complex([
+          {
+            name: "allowedCodeableConcept",
+            value: codeableConceptFromTarget(target, cwe9.originalText)
+          }
+        ])
+      });
+    }
+  }
+  return { value: complex(props), issues };
+}
+var V2_0003_SYSTEM = "http://terminology.hl7.org/CodeSystem/v2-0003";
+function buildMessageHeader(meta, focusFullUrls) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: primitive("MessageHeader") }
+  ];
+  const eventCoding = coding(V2_0003_SYSTEM, meta.triggerEvent);
+  if (eventCoding !== void 0) {
+    props.push({ name: "eventCoding", value: eventCoding });
+  } else {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "MSH.9", "MessageHeader.eventCoding"));
+  }
+  const sourceProps = [];
+  if (meta.sendingApp !== void 0 && meta.sendingApp !== "") {
+    sourceProps.push({ name: "name", value: primitive(meta.sendingApp) });
+  }
+  sourceProps.push({ name: "endpoint", value: dataAbsent("unknown") });
+  issues.push(
+    issue(ISSUE_CODES.TRANSFORM_REQUIRED_ELEMENT_UNKNOWN, "MSH.3", "MessageHeader.source.endpoint")
+  );
+  props.push({ name: "source", value: complex(sourceProps) });
+  if (focusFullUrls.length > 0) {
+    props.push({ name: "focus", value: list(focusFullUrls.map((url) => reference(url))) });
+  }
+  return { value: complex(props), issues };
+}
+var V3_OBSERVATION_INTERPRETATION_SYSTEM = "http://terminology.hl7.org/CodeSystem/v3-ObservationInterpretation";
+var HL70078_INTERPRETATION_CODES = /* @__PURE__ */ new Set([
+  "<",
+  ">",
+  "A",
+  "AA",
+  "B",
+  "CAR",
+  "D",
+  "DET",
+  "E",
+  "EX",
+  "EXP",
+  "H",
+  "HH",
+  "HU",
+  "I",
+  "IE",
+  "IND",
+  "L",
+  "LL",
+  "LU",
+  "MS",
+  "N",
+  "NCL",
+  "ND",
+  "NEG",
+  "NR",
+  "NS",
+  "POS",
+  "R",
+  "RR",
+  "S",
+  "SDD",
+  "SYN-R",
+  "SYN-S",
+  "U",
+  "UNE",
+  "VS",
+  "W",
+  "WR"
+]);
+var OBSERVATION_STATUS_MAP = Object.freeze({
+  A: "amended",
+  C: "corrected",
+  D: "entered-in-error",
+  F: "final",
+  P: "preliminary",
+  W: "entered-in-error",
+  X: "cancelled"
+});
+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"]);
+var STRING_VALUE_TYPES = /* @__PURE__ */ new Set(["ST", "TX", "FT"]);
+function rawComponent2(field, index) {
+  const c = field.repetitions[0]?.components[index]?.subcomponents[0];
+  return c === void 0 || c === "" ? void 0 : c;
+}
+function snText(field) {
+  return [0, 1, 2, 3].map((i) => rawComponent2(field, i) ?? "").join("");
+}
+function valueStringProp(raw) {
+  return { name: "valueString", value: primitive(raw) };
+}
+function endpointPair(field, units, ctx, issues) {
+  const n1 = rawComponent2(field, 1);
+  const n2 = rawComponent2(field, 3);
+  if (n1 === void 0 || n2 === void 0) return void 0;
+  const first = quantityFromRawMagnitude(n1, units, ctx);
+  const second = quantityFromRawMagnitude(n2, units, ctx);
+  issues.push(...first.issues, ...second.issues);
+  if (first.value === void 0 || second.value === void 0) return void 0;
+  return { first: first.value, second: second.value };
+}
+function buildSnValue(field, units, ctx, issues) {
+  const sn = field.asSn();
+  const separator = sn?.separatorOrSuffix;
+  if (separator === "-") {
+    const pair = endpointPair(field, units, ctx, issues);
+    if (pair !== void 0) {
+      return {
+        name: "valueRange",
+        value: complex([
+          { name: "low", value: pair.first },
+          { name: "high", value: pair.second }
+        ])
+      };
+    }
+    return valueStringProp(snText(field));
+  }
+  if (separator === ":" || separator === "/") {
+    const pair = endpointPair(field, units, ctx, issues);
+    if (pair !== void 0) {
+      return {
+        name: "valueRatio",
+        value: complex([
+          { name: "numerator", value: pair.first },
+          { name: "denominator", value: pair.second }
+        ])
+      };
+    }
+    return valueStringProp(snText(field));
+  }
+  const comparator = sn?.comparator;
+  const num1 = rawComponent2(field, 1);
+  if (comparator !== "<>" && num1 !== void 0) {
+    const fhirComparator = comparator !== void 0 && SN_COMPARATORS.has(comparator) ? comparator : void 0;
+    const q = quantityFromRawMagnitude(num1, units, ctx, fhirComparator);
+    issues.push(...q.issues);
+    if (q.value !== void 0) return { name: "valueQuantity", value: q.value };
+  }
+  return valueStringProp(snText(field));
+}
+function buildValue(obx, valueType, ctx, issues) {
+  const field = obx.field(5);
+  const rawValue = field.value;
+  const vt = valueType.toUpperCase();
+  if (vt === "NM") {
+    const q = quantityFromRawMagnitude(field.asNm().raw, obx.field(6).asCwe(), ctx);
+    issues.push(...q.issues);
+    if (q.value !== void 0) return { name: "valueQuantity", value: q.value };
+    return rawValue === "" ? void 0 : valueStringProp(rawValue);
+  }
+  if (vt === "SN") {
+    if (rawValue === "" && snText(field) === "") return void 0;
+    return buildSnValue(field, obx.field(6).asCwe(), ctx, issues);
+  }
+  if (CODED_VALUE_TYPES.has(vt)) {
+    const cc = toFhirCodeableConcept(field.asCwe(), ctx);
+    issues.push(...cc.issues);
+    return cc.value === void 0 ? void 0 : { name: "valueCodeableConcept", value: cc.value };
+  }
+  if (DATETIME_VALUE_TYPES.has(vt)) {
+    if (rawValue === "") return void 0;
+    const dt = toFhirDateTime(field.asTs(), ctx.options);
+    issues.push(...dt.issues);
+    return dt.value === void 0 ? void 0 : { name: "valueDateTime", value: primitive(dt.value) };
+  }
+  if (rawValue === "") return void 0;
+  if (STRING_VALUE_TYPES.has(vt)) return valueStringProp(rawValue);
+  issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "OBX.5", "Observation.value[x]"));
+  return valueStringProp(rawValue);
+}
+function buildInterpretation(obx, issues) {
+  const flags = obx.field(8).repetitions.map((r) => r.components[0]?.subcomponents[0] ?? "").filter((f) => f !== "");
+  const codings = [];
+  for (const flag of flags) {
+    if (HL70078_INTERPRETATION_CODES.has(flag)) {
+      codings.push(
+        complex([
+          {
+            name: "coding",
+            value: list([
+              complex([
+                { name: "system", value: primitive(V3_OBSERVATION_INTERPRETATION_SYSTEM) },
+                { name: "code", value: primitive(flag) }
+              ])
+            ])
+          }
+        ])
+      );
+    } else {
+      issues.push(
+        issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "OBX.8", "Observation.interpretation")
+      );
+    }
+  }
+  return codings.length === 0 ? void 0 : list(codings);
+}
+function buildObservation(obx, subjectFullUrl, encounterFullUrl, ctx) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: primitive("Observation") }
+  ];
+  const statusCode = obx.field(11).value;
+  if (statusCode !== "") {
+    const status = Object.hasOwn(OBSERVATION_STATUS_MAP, statusCode) ? OBSERVATION_STATUS_MAP[statusCode] : void 0;
+    if (status === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "OBX.11", "Observation.status"));
+    } else {
+      props.push({ name: "status", value: primitive(status) });
+    }
+  }
+  const code = toFhirCodeableConcept(obx.field(3).asCwe(), ctx);
+  issues.push(...code.issues);
+  if (code.value === void 0) return { value: void 0, issues };
+  props.push({ name: "code", value: code.value });
+  if (subjectFullUrl !== void 0)
+    props.push({ name: "subject", value: reference(subjectFullUrl) });
+  if (encounterFullUrl !== void 0) {
+    props.push({ name: "encounter", value: reference(encounterFullUrl) });
+  }
+  if (obx.field(14).value !== "") {
+    const effective = toFhirDateTime(obx.field(14).asTs(), ctx.options);
+    issues.push(...effective.issues);
+    if (effective.value !== void 0) {
+      props.push({ name: "effectiveDateTime", value: primitive(effective.value) });
+    }
+  }
+  const value = buildValue(obx, obx.field(2).value, ctx, issues);
+  if (value !== void 0) props.push(value);
+  const interpretation = buildInterpretation(obx, issues);
+  if (interpretation !== void 0) props.push({ name: "interpretation", value: interpretation });
+  const refRange = obx.field(7).value;
+  if (refRange !== "") {
+    props.push({
+      name: "referenceRange",
+      value: list([complex([{ name: "text", value: primitive(refRange) }])])
+    });
+  }
+  return { value: complex(props), issues };
+}
+
+// src/messages/orders.ts
+function collectOrderGroups(msg) {
+  const groups = [];
+  let current;
+  let rxeCount = 0;
+  const open = () => {
+    const g = { orc: void 0, obr: void 0, rxo: void 0, rxrs: [] };
+    groups.push(g);
+    current = g;
+    return g;
+  };
+  for (const seg of msg.allSegments()) {
+    switch (seg.type) {
+      case "ORC":
+        open().orc = seg;
+        break;
+      case "OBR":
+        if (current === void 0 || current.obr !== void 0 || current.rxo !== void 0) open();
+        current.obr = seg;
+        break;
+      case "RXO":
+        if (current === void 0 || current.obr !== void 0 || current.rxo !== void 0) open();
+        current.rxo = seg;
+        break;
+      case "RXR":
+        if (current !== void 0) current.rxrs.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 })),
+    rxeCount
+  };
+}
+
+// src/messages/oru.ts
+function collectReportGroups(msg) {
+  const groups = [];
+  let current;
+  let orphanObxCount = 0;
+  for (const seg of msg.allSegments()) {
+    if (seg.type === "OBR") {
+      current = { obr: seg, observations: [] };
+      groups.push(current);
+    } else if (seg.type === "OBX") {
+      if (current === void 0) orphanObxCount += 1;
+      else current.observations.push(seg);
+    }
+  }
+  return { groups, orphanObxCount };
+}
+var ADMINISTRATIVE_GENDER_MAP = Object.freeze({
+  F: "female",
+  M: "male",
+  O: "other",
+  U: "unknown",
+  A: "other",
+  N: "other"
+});
+function listOrUndefined(items) {
+  return items.length === 0 ? void 0 : list(items);
+}
+function buildPatient(patient, ctx) {
+  const issues = [];
+  const props = [
+    { name: "resourceType", value: primitive("Patient") }
+  ];
+  const identifiers = [];
+  for (const cx of patient.identifiers) {
+    const { value, issues: idIssues } = toFhirIdentifier(cx, ctx);
+    issues.push(...idIssues);
+    if (value !== void 0) identifiers.push(value);
+  }
+  const identifierList = listOrUndefined(identifiers);
+  if (identifierList !== void 0) props.push({ name: "identifier", value: identifierList });
+  const name = toFhirHumanName(patient.name);
+  issues.push(...name.issues);
+  if (name.value !== void 0) props.push({ name: "name", value: list([name.value]) });
+  if (patient.sex !== void 0 && patient.sex !== "") {
+    const gender = Object.hasOwn(ADMINISTRATIVE_GENDER_MAP, patient.sex) ? ADMINISTRATIVE_GENDER_MAP[patient.sex] : void 0;
+    if (gender === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "PID.8", "Patient.gender"));
+    } else {
+      props.push({ name: "gender", value: primitive(gender) });
+    }
+  }
+  if (patient.dateOfBirth !== void 0) {
+    const dob = toFhirDateTime(patient.dateOfBirth, ctx.options);
+    issues.push(...dob.issues);
+    if (dob.value !== void 0) {
+      const tIndex = dob.value.indexOf("T");
+      if (tIndex === -1) {
+        props.push({ name: "birthDate", value: primitive(dob.value) });
+      } else {
+        props.push({ name: "birthDate", value: primitive(dob.value.slice(0, tIndex)) });
+        issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PID.7", "Patient.birthDate"));
+      }
+    }
+  }
+  if (patient.address !== void 0) {
+    const address = toFhirAddress(patient.address);
+    issues.push(...address.issues);
+    if (address.value !== void 0) props.push({ name: "address", value: list([address.value]) });
+  }
+  if (patient.phoneNumbers.length > 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "PID.13", "Patient.telecom"));
+  }
+  if (props.length === 1) return { value: void 0, issues };
+  return { value: complex(props), issues };
+}
+function buildRelatedPerson(nk1, patientFullUrl, ctx, setIndex) {
+  const issues = [];
+  const loc = `NK1[${String(setIndex)}]`;
+  const props = [
+    { name: "resourceType", value: primitive("RelatedPerson") },
+    { name: "patient", value: reference(patientFullUrl) }
+  ];
+  let hasContent = false;
+  if (nk1.relationship !== void 0) {
+    const rel = toFhirCodeableConcept(nk1.relationship, ctx);
+    issues.push(...rel.issues);
+    if (rel.value !== void 0) {
+      props.push({ name: "relationship", value: list([rel.value]) });
+      hasContent = true;
+    }
+  }
+  if (nk1.name !== void 0) {
+    const name = toFhirHumanName(nk1.name);
+    issues.push(...name.issues);
+    if (name.value !== void 0) {
+      props.push({ name: "name", value: list([name.value]) });
+      hasContent = true;
+    }
+  }
+  if (nk1.address !== void 0) {
+    const address = toFhirAddress(nk1.address);
+    issues.push(...address.issues);
+    if (address.value !== void 0) {
+      props.push({ name: "address", value: list([address.value]) });
+      hasContent = true;
+    }
+  }
+  if (nk1.phone !== void 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, `${loc}.5`, "RelatedPerson.telecom"));
+  }
+  if (!hasContent) return { value: void 0, issues };
+  return { value: complex(props), issues };
+}
+var REQUEST_STATUS_MAP = Object.freeze({
+  AF: "active",
+  CA: "active",
+  CR: "revoked",
+  DC: "revoked",
+  DF: "revoked",
+  DR: "revoked",
+  FU: "completed",
+  HD: "active",
+  HR: "on-hold",
+  NW: "active",
+  OC: "revoked",
+  OD: "revoked",
+  OH: "on-hold",
+  OK: "active",
+  PR: "active",
+  PY: "active",
+  RL: "active",
+  RO: "active",
+  RQ: "active"
+});
+var SERVICE_REQUEST_PRIORITY_MAP = Object.freeze({
+  S: "stat",
+  A: "asap",
+  R: "routine"
+});
+var ORDER_INTENT2 = "order";
+function fieldValue(seg, index) {
+  return seg === void 0 ? "" : seg.field(index).value;
+}
+function buildServiceRequest(orc, obr, subjectFullUrl, encounterFullUrl, ctx) {
+  const issues = [];
+  if (orc === void 0 && obr === void 0) return { value: void 0, issues };
+  const props = [
+    { name: "resourceType", value: primitive("ServiceRequest") }
+  ];
+  const orc1 = fieldValue(orc, 1);
+  const orc5 = fieldValue(orc, 5);
+  if (orc5 !== "") {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "ORC.5", "ServiceRequest.status"));
+  } else if (orc1 !== "") {
+    const status = Object.hasOwn(REQUEST_STATUS_MAP, orc1) ? REQUEST_STATUS_MAP[orc1] : void 0;
+    if (status === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "ORC.1", "ServiceRequest.status"));
+    } else {
+      props.push({ name: "status", value: primitive(status) });
+    }
+  }
+  props.push({ name: "intent", value: primitive(ORDER_INTENT2) });
+  const placer = fieldValue(obr, 2) !== "" ? fieldValue(obr, 2) : fieldValue(orc, 2);
+  const filler = fieldValue(obr, 3) !== "" ? fieldValue(obr, 3) : fieldValue(orc, 3);
+  const identifiers = [orderIdentifier(placer, "PLAC"), orderIdentifier(filler, "FILL")].filter(
+    (i) => i !== void 0
+  );
+  if (identifiers.length > 0) props.push({ name: "identifier", value: list(identifiers) });
+  if (obr !== void 0 && obr.field(4).value !== "") {
+    const code = toFhirCodeableConcept(obr.field(4).asCwe(), ctx);
+    issues.push(...code.issues);
+    if (code.value !== void 0) props.push({ name: "code", value: code.value });
+  }
+  const obr5cwe = obr?.field(5).asCwe();
+  const obr5 = obr5cwe?.identifier ?? "";
+  if (obr5 !== "") {
+    const mnemonic = obr5cwe?.nameOfCodingSystem;
+    const fromTable = mnemonic === void 0 || mnemonic === "" || mnemonic === "HL70485" || mnemonic === "0485";
+    const priority = fromTable && Object.hasOwn(SERVICE_REQUEST_PRIORITY_MAP, obr5) ? SERVICE_REQUEST_PRIORITY_MAP[obr5] : void 0;
+    if (priority === void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_CODE_UNMAPPED, "OBR.5", "ServiceRequest.priority"));
+    } else {
+      props.push({ name: "priority", value: primitive(priority) });
+    }
+  }
+  if (subjectFullUrl !== void 0)
+    props.push({ name: "subject", value: reference(subjectFullUrl) });
+  if (encounterFullUrl !== void 0)
+    props.push({ name: "encounter", value: reference(encounterFullUrl) });
+  if (orc1 === "NW" && fieldValue(orc, 9) !== "" && orc !== void 0) {
+    const authored = toFhirDateTime(orc.field(9).asTs(), ctx.options);
+    issues.push(...authored.issues);
+    if (authored.value !== void 0)
+      props.push({ name: "authoredOn", value: primitive(authored.value) });
+  }
+  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)
+      props.push({ name: "occurrenceDateTime", value: primitive(occurrence.value) });
+  }
+  if (obr !== void 0 && obr.field(31).value !== "") {
+    const reason = toFhirCodeableConcept(obr.field(31).asCwe(), ctx);
+    issues.push(...reason.issues);
+    if (reason.value !== void 0) props.push({ name: "reasonCode", value: list([reason.value]) });
+  }
+  return { value: complex(props), issues };
+}
+
+// src/messages/to-fhir.ts
+var IG_MAPPED_ADT_TRIGGERS = /* @__PURE__ */ new Set([
+  "A01",
+  "A02",
+  "A05",
+  "A06",
+  "A09",
+  "A11",
+  "A17"
+]);
+var IG_MAPPED_ORU_TRIGGERS = /* @__PURE__ */ new Set(["R01"]);
+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) {
+  const result = resourceType(resource) === "Patient" ? validateResource(resource, { mode: "strict" }) : validateResource(resource, { mode: "lenient", schemas: EMIT_SCHEMAS });
+  if (result.valid) return true;
+  issues.push(issue(ISSUE_CODES.TRANSFORM_RESOURCE_INVALID, v2Location, fhirPath));
+  return false;
+}
+function buildBundle(msg, entries, ctx, issues) {
+  const props = [
+    { name: "resourceType", value: primitive("Bundle") }
+  ];
+  const controlId = msg.meta.controlId;
+  if (controlId !== void 0 && controlId !== "") {
+    props.push({
+      name: "identifier",
+      value: complex([{ name: "value", value: primitive(controlId) }])
+    });
+  }
+  props.push({ name: "type", value: primitive("message") });
+  if (msg.meta.timestamp !== void 0) {
+    const ts = toFhirDateTime(msg.meta.timestamp, ctx.options);
+    issues.push(...ts.issues);
+    if (ts.value !== void 0 && ts.value.includes("T")) {
+      props.push({ name: "timestamp", value: primitive(ts.value) });
+    } else if (ts.value !== void 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "MSH.7", "Bundle.timestamp"));
+    }
+  }
+  const entryNodes = entries.map(
+    (e) => complex([
+      { name: "fullUrl", value: primitive(e.fullUrl) },
+      { name: "resource", value: e.resource }
+    ])
+  );
+  if (entryNodes.length > 0) props.push({ name: "entry", value: list(entryNodes) });
+  return complex(props);
+}
+function toFhir(msg, opts = {}) {
+  const issues = [];
+  const namingSystem = opts.namingSystem ?? createNamingSystem();
+  const ctx = { namingSystem, options: opts };
+  const ids = new IdAllocator(opts);
+  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}`));
+  if (!messageMapGrounded) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_SEGMENT_ASSEMBLED, "MSH.9"));
+  }
+  const focalEntries = [];
+  let patientFullUrl;
+  const patientView = msg.patient;
+  if (patientView !== void 0) {
+    const built = buildPatient(patientView, ctx);
+    issues.push(...built.issues);
+    if (built.value !== void 0 && passesEmitGate(built.value, "PID", "Patient", issues)) {
+      patientFullUrl = ids.next();
+      focalEntries.push({ fullUrl: patientFullUrl, resource: built.value });
+    }
+  }
+  let encounterFullUrl;
+  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();
+      focalEntries.push({ fullUrl: encounterFullUrl, resource: built.value });
+    }
+  }
+  const nextOfKin = msg.nextOfKin();
+  if (patientFullUrl !== void 0) {
+    for (let i = 0; i < nextOfKin.length; i++) {
+      const nk1 = nextOfKin[i];
+      if (nk1 === void 0) continue;
+      const built = buildRelatedPerson(nk1, patientFullUrl, ctx, i);
+      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 });
+      }
+    }
+  } else if (nextOfKin.length > 0) {
+    issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "NK1", "RelatedPerson.patient"));
+  }
+  const diagnosticReportFullUrls = [];
+  if (code === "ORU") {
+    const { groups, orphanObxCount } = collectReportGroups(msg);
+    if (orphanObxCount > 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "OBX", "DiagnosticReport.result"));
+    }
+    for (const group of groups) {
+      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);
+        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 });
+        }
+      }
+      const report = buildDiagnosticReport(
+        group.obr,
+        resultFullUrls,
+        patientFullUrl,
+        encounterFullUrl,
+        ctx
+      );
+      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 });
+      }
+      focalEntries.push(...observationEntries);
+    }
+  }
+  const orderResourceFullUrls = [];
+  if (code !== "ORU" && code !== "VXU" && code !== "SIU" && code !== "MDM") {
+    const { groups, rxeCount } = collectOrderGroups(msg);
+    if (rxeCount > 0) {
+      issues.push(issue(ISSUE_CODES.TRANSFORM_ELEMENT_DROPPED, "RXE", "MedicationRequest"));
+    }
+    for (const group of groups) {
+      if (group.obr !== void 0 || group.orc !== void 0 && group.rxo === void 0) {
+        const built = buildServiceRequest(
+          group.orc,
+          group.obr,
+          patientFullUrl,
+          encounterFullUrl,
+          ctx
+        );
+        issues.push(...built.issues);
+        const loc = group.orc !== void 0 ? "ORC" : "OBR";
+        if (built.value !== void 0 && passesEmitGate(built.value, loc, "ServiceRequest", issues)) {
+          const url = ids.next();
+          orderResourceFullUrls.push(url);
+          focalEntries.push({ fullUrl: url, resource: built.value });
+        }
+      }
+      if (group.rxo !== void 0) {
+        const built = buildMedicationRequest(
+          group.rxo,
+          group.rxrs[0],
+          group.orc,
+          patientFullUrl,
+          encounterFullUrl,
+          ctx
+        );
+        issues.push(...built.issues);
+        if (built.value !== void 0 && passesEmitGate(built.value, "RXO", "MedicationRequest", issues)) {
+          const url = ids.next();
+          orderResourceFullUrls.push(url);
+          focalEntries.push({ fullUrl: url, resource: built.value });
+        }
+      }
+    }
+  }
+  const immunizationFullUrls = [];
+  if (code === "VXU") {
+    for (const group of collectImmunizationGroups(msg)) {
+      const built = buildImmunization(
+        group.rxa,
+        group.rxr,
+        group.orc,
+        patientFullUrl,
+        encounterFullUrl,
+        ctx
+      );
+      issues.push(...built.issues);
+      if (built.value !== void 0 && passesEmitGate(built.value, "RXA", "Immunization", issues)) {
+        const url = ids.next();
+        immunizationFullUrls.push(url);
+        focalEntries.push({ fullUrl: url, resource: built.value });
+      }
+    }
+    for (const seg of msg.allSegments()) {
+      if (seg.type !== "OBX") continue;
+      const built = buildObservation(seg, patientFullUrl, encounterFullUrl, ctx);
+      issues.push(...built.issues);
+      if (built.value !== void 0 && passesEmitGate(built.value, "OBX", "Observation", issues)) {
+        focalEntries.push({ fullUrl: ids.next(), resource: built.value });
+      }
+    }
+  }
+  const appointmentFullUrls = [];
+  if (code === "SIU") {
+    const { sch, ais } = collectAppointment(msg);
+    if (sch !== void 0) {
+      const built = buildAppointment(sch, ais, patientFullUrl, ctx);
+      issues.push(...built.issues);
+      if (built.value !== void 0 && passesEmitGate(built.value, "SCH", "Appointment", issues)) {
+        const url = ids.next();
+        appointmentFullUrls.push(url);
+        focalEntries.push({ fullUrl: url, resource: built.value });
+      }
+    }
+  }
+  const documentFullUrls = [];
+  if (code === "MDM") {
+    const { txa, obxs } = collectDocument(msg);
+    if (txa !== void 0) {
+      const built = buildDocumentReference(txa, obxs, patientFullUrl, ctx);
+      issues.push(...built.issues);
+      if (built.value !== void 0 && passesEmitGate(built.value, "TXA", "DocumentReference", issues)) {
+        const url = ids.next();
+        documentFullUrls.push(url);
+        focalEntries.push({ fullUrl: url, resource: built.value });
+      }
+    }
+  }
+  const focus = [
+    patientFullUrl,
+    encounterFullUrl,
+    ...diagnosticReportFullUrls,
+    ...orderResourceFullUrls,
+    ...immunizationFullUrls,
+    ...appointmentFullUrls,
+    ...documentFullUrls
+  ].filter((u) => u !== void 0);
+  const header = buildMessageHeader(msg.meta, focus);
+  issues.push(...header.issues);
+  const entries = [];
+  if (header.value !== void 0 && passesEmitGate(header.value, "MSH", "MessageHeader", issues)) {
+    entries.push({ fullUrl: ids.next(), resource: header.value });
+  }
+  entries.push(...focalEntries);
+  const bundle = buildBundle(msg, entries, ctx, issues);
+  return { bundle, issues };
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+
+export { ADDRESS_TYPE_MAP, ADDRESS_USE_MAP, ADMINISTRATIVE_GENDER_MAP, APPOINTMENT_STATUS_MAP, APPOINTMENT_TYPE_VALUE_MAP, DEFAULT_V2_CODE_SYSTEMS, DIAGNOSTIC_REPORT_STATUS_MAP, ENCOUNTER_CLASS_V3_MAP, ENCOUNTER_STATUS_MAP, FATAL_CODES, HL70078_INTERPRETATION_CODES, IG_MAPPED_ADT_TRIGGERS, IG_MAPPED_APPOINTMENT_TRIGGERS, IG_MAPPED_DOCUMENT_TRIGGERS, IG_MAPPED_IMMUNIZATION_TRIGGERS, IG_MAPPED_ORDER_TRIGGERS, IG_MAPPED_ORU_TRIGGERS, IMMUNIZATION_STATUS_MAP, ISSUE_CODES, ISSUE_REGISTRY, NAME_USE_MAP, OBSERVATION_STATUS_MAP, REQUEST_STATUS_MAP, ROUTE_VALUE_MAP, SERVICE_REQUEST_PRIORITY_MAP, SITE_VALUE_MAP, SUBSTITUTION_VALUE_MAP, TRANSFORM_ISSUE_SYSTEM, V2_0161_SYSTEM, V2_0162_SYSTEM, V2_0203_SYSTEM, V2_0277_SYSTEM, V2_0550_SYSTEM, V3_ROUTE_OF_ADMINISTRATION_SYSTEM, VERSION, codeableConceptFromTarget, createNamingSystem, fhirIssueTypeFor, issue, toFhir, toFhirAddress, toFhirCodeableConcept, toFhirCodeableConceptVia, toFhirDateTime, toFhirHumanName, toFhirIdentifier, toFhirQuantity, toOperationOutcome, translateBound };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map