@mieweb/ui 0.11.0-dev.29 → 0.11.0-dev.30

package/dist/chunk-7HFZL5V5.js

@@ -0,0 +1,2425 @@
+import { currentAssertion } from './chunk-5LNLB2XT.js';
+import { DateTime } from 'luxon';
+import { fieldDisplay, render } from '@mieweb/templit';
+import { markdownToHtml } from '@mieweb/templit/markdown';
+import { parseDocument, isMap, isSeq } from 'yaml';
+
+// src/components/EncounterVisit/date.ts
+function isEncounterDate(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const [year, month, day] = value.split("-").map(Number);
+  if (year < 1 || month < 1 || month > 12 || day < 1) return false;
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return day <= days[month - 1];
+}
+
+// src/components/EncounterVisit/definition.ts
+function getEncounterFieldId(sectionId, observationId) {
+  const prefix = `encounter:${encodeURIComponent(sectionId)}`;
+  return observationId === void 0 ? `${prefix}:narrative` : `${prefix}:observation:${encodeURIComponent(observationId)}`;
+}
+function getEncounterSectionFieldId(sectionId) {
+  return `encounter:${encodeURIComponent(sectionId)}:section`;
+}
+function getEncounterSectionFieldIds(section) {
+  if (section.kind === "narrative") return [getEncounterFieldId(section.id)];
+  if (section.kind !== "observations") {
+    return [
+      ...section.narrative ? [getEncounterFieldId(section.id)] : [],
+      getEncounterFieldId(section.id, "value")
+    ];
+  }
+  return [
+    ...section.narrative ? [getEncounterFieldId(section.id)] : [],
+    ...(section.observations ?? []).map(
+      (observation) => getEncounterFieldId(section.id, observation.id)
+    )
+  ];
+}
+var SECTION_KINDS = [
+  "narrative",
+  "observations",
+  "vitals",
+  "medications",
+  "allergies",
+  "conditions",
+  "plan",
+  "assessment"
+];
+function nonempty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function optionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function invalid(message) {
+  throw new Error(`Invalid encounter definition: ${message}`);
+}
+function validateFindings(findings, location) {
+  if (findings === void 0) return;
+  if (!Array.isArray(findings))
+    invalid(`findings must be an array in ${location}`);
+  const ids = /* @__PURE__ */ new Set();
+  for (const finding of findings) {
+    if (!finding || typeof finding !== "object" || !nonempty(finding.id) || !nonempty(finding.label) || !nonempty(finding.text))
+      invalid(`findings require id, label and text in ${location}`);
+    if (ids.has(finding.id))
+      invalid(`duplicate finding id ${finding.id} in ${location}`);
+    ids.add(finding.id);
+    if (finding.code !== void 0 && (!finding.code || typeof finding.code !== "object" || !nonempty(finding.code.system) || !nonempty(finding.code.code) || !optionalString(finding.code.display)))
+      invalid(`invalid finding code in ${location}`);
+  }
+}
+function validateEncounterDefinition(definition) {
+  if (!definition || typeof definition !== "object")
+    invalid("expected an object");
+  if (!nonempty(definition.id) || !nonempty(definition.title)) {
+    invalid("id and title must be nonempty strings");
+  }
+  if (definition.encounterDate !== void 0 && !isEncounterDate(definition.encounterDate))
+    invalid("encounterDate must be a valid YYYY-MM-DD date");
+  if (!Array.isArray(definition.sections) || definition.sections.length === 0) {
+    invalid("at least one section is required");
+  }
+  const sectionIds = /* @__PURE__ */ new Set();
+  for (const section of definition.sections) {
+    if (!section || typeof section !== "object")
+      invalid("expected a section object");
+    if (!nonempty(section.id) || !nonempty(section.title)) {
+      invalid("each section requires an id and title");
+    }
+    if (sectionIds.has(section.id))
+      invalid(`duplicate section id ${section.id}`);
+    sectionIds.add(section.id);
+    if (!SECTION_KINDS.includes(section.kind))
+      invalid(`unknown section kind ${section.kind}`);
+    if (!optionalString(section.description))
+      invalid(`invalid description in ${section.id}`);
+    if (section.required !== void 0 && typeof section.required !== "boolean") {
+      invalid(`required must be boolean in ${section.id}`);
+    }
+    if (section.narrative !== void 0 && typeof section.narrative !== "boolean") {
+      invalid(`narrative must be boolean in ${section.id}`);
+    }
+    if (section.observations !== void 0 && !Array.isArray(section.observations)) {
+      invalid(`observations must be an array in ${section.id}`);
+    }
+    if (section.kind !== "observations" && section.observations?.length) {
+      invalid(
+        `only observations sections accept individual observations (${section.id})`
+      );
+    }
+    if (section.kind === "observations" && !section.narrative && !section.observations?.length) {
+      invalid(`observations section ${section.id} has no fields`);
+    }
+    if (section.requireCoding !== void 0 && typeof section.requireCoding !== "boolean")
+      invalid(`requireCoding must be boolean in ${section.id}`);
+    validateFindings(section.findings, section.id);
+    if (section.findings?.length && section.kind !== "narrative" && !section.narrative)
+      invalid(`section findings require a narrative in ${section.id}`);
+    const observationIds = /* @__PURE__ */ new Set();
+    for (const observation of section.observations ?? []) {
+      if (!observation || typeof observation !== "object" || !nonempty(observation.id) || !nonempty(observation.label)) {
+        invalid(`observations in ${section.id} require an id and label`);
+      }
+      if (observationIds.has(observation.id))
+        invalid(`duplicate observation id ${observation.id} in ${section.id}`);
+      observationIds.add(observation.id);
+      if (observation.type !== void 0 && !["text", "number", "choice"].includes(observation.type)) {
+        invalid(`unknown observation type in ${section.id}.${observation.id}`);
+      }
+      if (!optionalString(observation.unit))
+        invalid(`invalid unit in ${section.id}.${observation.id}`);
+      if (observation.required !== void 0 && typeof observation.required !== "boolean") {
+        invalid(`required must be boolean in ${section.id}.${observation.id}`);
+      }
+      if (observation.code !== void 0 && (!observation.code || typeof observation.code !== "object" || !nonempty(observation.code.system) || !nonempty(observation.code.code) || !optionalString(observation.code.display))) {
+        invalid(`invalid code in ${section.id}.${observation.id}`);
+      }
+      if (observation.options !== void 0 && (!Array.isArray(observation.options) || observation.options.some((option) => !nonempty(option)) || new Set(observation.options).size !== observation.options.length)) {
+        invalid(
+          `options must be distinct nonempty strings in ${section.id}.${observation.id}`
+        );
+      }
+      validateFindings(observation.findings, `${section.id}.${observation.id}`);
+      if (observation.findings?.length && observation.type && observation.type !== "text")
+        invalid(
+          `findings require a text observation in ${section.id}.${observation.id}`
+        );
+      if (observation.type === "choice" && !observation.options?.length) {
+        invalid(
+          `choice observation ${section.id}.${observation.id} requires options`
+        );
+      }
+    }
+  }
+}
+function observationField(sectionId, observation) {
+  const base = {
+    id: getEncounterFieldId(sectionId, observation.id),
+    question: observation.label,
+    required: observation.required,
+    width: "full",
+    _sourceData: { ...observation, encounterFindings: observation.findings }
+  };
+  if (observation.type === "choice") {
+    return {
+      ...base,
+      fieldType: "dropdown",
+      options: observation.options?.map((value) => ({
+        id: encodeURIComponent(value),
+        value,
+        text: value
+      }))
+    };
+  }
+  if (observation.type === "number") {
+    return {
+      ...base,
+      fieldType: "text",
+      inputType: "number",
+      unit: observation.unit,
+      validators: [
+        { type: "number", message: "Enter a finite nonnegative number." }
+      ]
+    };
+  }
+  return {
+    ...base,
+    fieldType: "encounterNarrative",
+    unit: observation.unit
+  };
+}
+var CUSTOM_FIELD_TYPES = {
+  vitals: "encounterVitals",
+  medications: "encounterMedications",
+  allergies: "encounterAllergies",
+  conditions: "encounterConditions",
+  plan: "encounterPlan",
+  assessment: "encounterAssessment"
+};
+function createEncounterFormDefinition(definition) {
+  validateEncounterDefinition(definition);
+  return {
+    id: definition.id,
+    title: definition.title,
+    pages: [
+      {
+        id: `${definition.id}:visit`,
+        title: definition.title,
+        fields: definition.sections.map((section) => {
+          const fields = [];
+          if (section.description) {
+            fields.push({
+              id: `${getEncounterSectionFieldId(section.id)}:description`,
+              fieldType: "display",
+              content: section.description,
+              width: "full"
+            });
+          }
+          if (section.kind === "narrative" || section.narrative) {
+            fields.push({
+              id: getEncounterFieldId(section.id),
+              fieldType: "encounterNarrative",
+              question: section.kind === "narrative" ? section.title : `${section.title} narrative`,
+              required: section.kind === "narrative" ? section.required : void 0,
+              width: "full",
+              _sourceData: {
+                encounterHideLabel: true,
+                encounterFindings: section.findings
+              }
+            });
+          }
+          if (section.kind === "observations") {
+            fields.push(
+              ...(section.observations ?? []).map(
+                (observation) => observationField(section.id, observation)
+              )
+            );
+          } else if (section.kind !== "narrative") {
+            fields.push({
+              id: getEncounterFieldId(section.id, "value"),
+              fieldType: CUSTOM_FIELD_TYPES[section.kind],
+              question: section.title,
+              required: section.required,
+              _sourceData: {
+                encounterRequireCoding: section.requireCoding ?? true,
+                encounterDate: definition.encounterDate
+              },
+              width: "full"
+            });
+          }
+          return {
+            id: getEncounterSectionFieldId(section.id),
+            fieldType: "section",
+            title: section.title,
+            sectionCollapse: "expanded",
+            width: "full",
+            fields
+          };
+        })
+      }
+    ]
+  };
+}
+var DEFAULT_ENCOUNTER_VISIT_DEFINITION = {
+  id: "anonymous-encounter",
+  title: "Encounter visit",
+  sections: [
+    {
+      id: "hpi",
+      title: "History of present illness",
+      kind: "narrative",
+      findings: [
+        { id: "no-fever", label: "No fever", text: "Denies fever." },
+        { id: "no-trauma", label: "No trauma", text: "Denies recent trauma." },
+        {
+          id: "no-radiation",
+          label: "No radiation",
+          text: "Pain does not radiate."
+        }
+      ]
+    },
+    {
+      id: "history",
+      title: "Patient history",
+      kind: "observations",
+      narrative: true,
+      findings: [
+        {
+          id: "patient-source",
+          label: "Patient provided history",
+          text: "History provided by the patient."
+        },
+        {
+          id: "records-reviewed",
+          label: "Records reviewed",
+          text: "History supplemented by available records."
+        }
+      ],
+      observations: [
+        {
+          id: "medical",
+          label: "Medical history",
+          findings: [
+            {
+              id: "reviewed",
+              label: "History reviewed",
+              text: "Medical history reviewed."
+            },
+            {
+              id: "no-additional-history",
+              label: "No additional history",
+              text: "No additional medical history reported."
+            }
+          ]
+        },
+        {
+          id: "surgical",
+          label: "Surgical history",
+          findings: [
+            {
+              id: "no-surgeries",
+              label: "No prior surgery",
+              text: "No previous surgery reported."
+            },
+            {
+              id: "reviewed",
+              label: "History reviewed",
+              text: "Surgical history reviewed."
+            }
+          ]
+        },
+        {
+          id: "family",
+          label: "Family history",
+          findings: [
+            {
+              id: "unknown",
+              label: "History unknown",
+              text: "Family history unknown."
+            },
+            {
+              id: "noncontributory",
+              label: "No pertinent history",
+              text: "No pertinent family history reported."
+            }
+          ]
+        },
+        {
+          id: "social",
+          label: "Social history",
+          findings: [
+            {
+              id: "never-smoked",
+              label: "Never smoked",
+              text: "Never smoked."
+            },
+            {
+              id: "no-alcohol",
+              label: "No alcohol use",
+              text: "Denies alcohol use."
+            },
+            {
+              id: "no-recreational-drugs",
+              label: "No recreational drug use",
+              text: "Denies recreational drug use."
+            }
+          ]
+        }
+      ]
+    },
+    {
+      id: "ros",
+      title: "Review of systems",
+      kind: "observations",
+      narrative: true,
+      findings: [
+        {
+          id: "pertinent-hpi",
+          label: "Additional symptoms in HPI",
+          text: "Additional symptoms are documented in the history of present illness."
+        },
+        {
+          id: "limited-review",
+          label: "Limited review",
+          text: "Review of systems limited by patient condition."
+        }
+      ],
+      observations: [
+        {
+          id: "constitutional",
+          label: "Constitutional",
+          findings: [
+            {
+              id: "no-fever-chills",
+              label: "No fever or chills",
+              text: "Denies fever or chills."
+            }
+          ]
+        },
+        {
+          id: "cardiovascular",
+          label: "Cardiovascular",
+          findings: [
+            {
+              id: "no-chest-pain",
+              label: "No chest pain",
+              text: "Denies chest pain."
+            }
+          ]
+        },
+        {
+          id: "respiratory",
+          label: "Respiratory",
+          findings: [
+            {
+              id: "no-dyspnea",
+              label: "No dyspnea",
+              text: "Denies shortness of breath."
+            },
+            { id: "no-cough", label: "No cough", text: "Denies cough." }
+          ]
+        },
+        {
+          id: "musculoskeletal",
+          label: "Musculoskeletal",
+          findings: [
+            { id: "back-pain", label: "Back pain", text: "Reports back pain." },
+            {
+              id: "no-joint-swelling",
+              label: "No joint swelling",
+              text: "Denies joint swelling."
+            }
+          ]
+        },
+        {
+          id: "neurological",
+          label: "Neurological",
+          findings: [
+            {
+              id: "no-weakness",
+              label: "No weakness",
+              text: "Denies weakness."
+            },
+            {
+              id: "no-numbness-tingling",
+              label: "No numbness / tingling",
+              text: "Denies numbness or tingling."
+            },
+            {
+              id: "no-bowel-bladder-changes",
+              label: "No bowel / bladder changes",
+              text: "Denies bowel or bladder changes."
+            }
+          ]
+        }
+      ]
+    },
+    {
+      id: "vitals",
+      title: "Vitals",
+      kind: "vitals"
+    },
+    {
+      id: "exam",
+      title: "Physical examination",
+      kind: "observations",
+      narrative: true,
+      findings: [
+        {
+          id: "focused",
+          label: "Focused examination",
+          text: "Focused examination performed."
+        },
+        {
+          id: "limited-by-pain",
+          label: "Limited by pain",
+          text: "Examination limited by pain."
+        }
+      ],
+      observations: [
+        {
+          id: "general",
+          label: "General appearance",
+          findings: [
+            {
+              id: "no-distress",
+              label: "No acute distress",
+              text: "No acute distress."
+            },
+            { id: "alert", label: "Alert", text: "Alert and conversant." }
+          ]
+        },
+        {
+          id: "head-neck",
+          label: "Head and neck",
+          findings: [
+            {
+              id: "no-cervical-nodes",
+              label: "No cervical lymphadenopathy",
+              text: "No palpable cervical lymphadenopathy."
+            },
+            {
+              id: "no-oral-lesions",
+              label: "No oral lesions",
+              text: "No visible oral lesions."
+            }
+          ]
+        },
+        {
+          id: "cardiovascular",
+          label: "Cardiovascular",
+          findings: [
+            {
+              id: "regular",
+              label: "Regular rhythm",
+              text: "Regular rate and rhythm."
+            }
+          ]
+        },
+        {
+          id: "respiratory",
+          label: "Respiratory",
+          findings: [
+            {
+              id: "clear",
+              label: "Clear lungs",
+              text: "Lungs clear to auscultation bilaterally."
+            },
+            {
+              id: "nonlabored",
+              label: "Nonlabored",
+              text: "Breathing is nonlabored."
+            }
+          ]
+        },
+        {
+          id: "abdomen",
+          label: "Abdomen",
+          findings: [
+            {
+              id: "soft",
+              label: "Soft / nontender",
+              text: "Abdomen soft and nontender."
+            }
+          ]
+        },
+        {
+          id: "musculoskeletal",
+          label: "Musculoskeletal / back",
+          findings: [
+            {
+              id: "no-midline-tenderness",
+              label: "No midline tenderness",
+              text: "No midline spinal tenderness."
+            },
+            {
+              id: "paraspinal-tenderness",
+              label: "Paraspinal tenderness",
+              text: "Paraspinal tenderness is present."
+            },
+            {
+              id: "range-of-motion",
+              label: "Preserved range of motion",
+              text: "Spinal range of motion is preserved."
+            }
+          ]
+        },
+        {
+          id: "neurological",
+          label: "Neurological",
+          findings: [
+            {
+              id: "symmetric-strength",
+              label: "Symmetric leg strength",
+              text: "Strength symmetric in both lower extremities."
+            },
+            {
+              id: "light-touch",
+              label: "Intact light touch",
+              text: "Sensation intact to light touch in both lower extremities."
+            },
+            {
+              id: "steady-gait",
+              label: "Steady gait",
+              text: "Gait is steady."
+            }
+          ]
+        },
+        {
+          id: "skin",
+          label: "Skin",
+          findings: [
+            { id: "warm-dry", label: "Warm / dry", text: "Skin warm and dry." }
+          ]
+        }
+      ]
+    },
+    {
+      id: "conditions",
+      title: "Conditions",
+      kind: "conditions",
+      requireCoding: true
+    },
+    {
+      id: "medications",
+      title: "Presenting medications",
+      kind: "medications",
+      requireCoding: true
+    },
+    {
+      id: "allergies",
+      title: "Allergies and intolerances",
+      kind: "allergies",
+      requireCoding: true
+    },
+    {
+      id: "assessment",
+      title: "Assessment and orders",
+      kind: "assessment",
+      requireCoding: true
+    },
+    {
+      id: "plan",
+      title: "Plan",
+      kind: "plan",
+      narrative: true,
+      requireCoding: true,
+      findings: [
+        {
+          id: "questions",
+          label: "Questions answered",
+          text: "Questions were answered."
+        },
+        {
+          id: "understanding",
+          label: "Understanding confirmed",
+          text: "Patient verbalized understanding of the plan."
+        }
+      ]
+    },
+    {
+      id: "follow-up",
+      title: "Follow-up and appointments",
+      kind: "observations",
+      narrative: true,
+      findings: [
+        {
+          id: "arrangements-reviewed",
+          label: "Arrangements reviewed",
+          text: "Follow-up arrangements reviewed with the patient."
+        },
+        {
+          id: "patient-to-schedule",
+          label: "Patient will schedule",
+          text: "Patient will contact the office to schedule follow-up."
+        }
+      ],
+      observations: [
+        {
+          id: "interval",
+          label: "Return interval",
+          findings: [
+            { id: "one-week", label: "1 week", text: "1 week" },
+            { id: "one-month", label: "1 month", text: "1 month" },
+            { id: "three-months", label: "3 months", text: "3 months" }
+          ]
+        },
+        {
+          id: "appointment",
+          label: "Appointment details",
+          findings: [
+            {
+              id: "scheduled",
+              label: "Appointment scheduled",
+              text: "Appointment scheduled."
+            },
+            {
+              id: "patient-to-schedule",
+              label: "Patient to schedule",
+              text: "Patient to schedule appointment."
+            },
+            {
+              id: "scheduling-pending",
+              label: "Scheduling pending",
+              text: "Appointment scheduling pending."
+            }
+          ]
+        }
+      ]
+    }
+  ]
+};
+var EXAMPLE_ENCOUNTER_VISIT_RESPONSES = {
+  [getEncounterFieldId("hpi")]: {
+    answer: "45-year-old male with pre-diabetes, back pain and hypertension."
+  }
+};
+var ENCOUNTER_DOCUMENT_FIELD_ID = "__encounter_document__";
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasValue(value) {
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "number" || typeof value === "boolean") return true;
+  if (Array.isArray(value)) return value.some(hasValue);
+  if (record(value)) return Object.values(value).some(hasValue);
+  return false;
+}
+function hasSelectedValue(selected) {
+  if (Array.isArray(selected)) return selected.some(hasSelectedValue);
+  if (!record(selected)) return false;
+  if ("value" in selected) return hasValue(selected.value);
+  return Object.values(selected).some(hasSelectedValue);
+}
+function hasNativeValue(response, parseAnswer = false) {
+  return response?.answer !== void 0 && hasValue(parseAnswer ? canonicalValue(response) : response.answer) || hasSelectedValue(response?.selected);
+}
+function linkId(fieldId) {
+  return `visit_${Array.from(
+    new TextEncoder().encode(fieldId),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("")}`;
+}
+function unitDisplay(unit) {
+  return unit === "Cel" ? "\xB0C" : unit === "mm[Hg]" ? "mmHg" : unit === "{score}" ? "/10" : unit;
+}
+function observationDisplay(observation) {
+  const unit = unitDisplay(observation.unit);
+  return `${observation.value}${unit ? ` ${unit}` : ""}`;
+}
+function groupedDisplay(observations, showReadingId) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const observation of observations) {
+    const key = observation.groupId ?? "";
+    const group = groups.get(key) ?? [];
+    group.push(observation);
+    groups.set(key, group);
+  }
+  return Array.from(groups, ([groupId, values]) => {
+    const first = values[0];
+    const metadata = [
+      showReadingId ? groupId : void 0,
+      first.recordedAt,
+      first.position,
+      first.site
+    ].filter(Boolean);
+    const summary = values.map((value) => `${value.label}: ${observationDisplay(value)}`).join("\n");
+    return metadata.length ? `${summary} (${metadata.join("; ")})` : summary;
+  }).join("\n\n");
+}
+function getEncounterMdyFields(snapshot) {
+  return snapshot.definition.sections.flatMap(
+    (section) => getEncounterSectionFieldIds(section).map((fieldId) => {
+      const observations = snapshot.observations.filter(
+        (observation) => observation.fieldId === fieldId
+      );
+      const observationDefinition = section.observations?.find(
+        (observation) => getEncounterFieldId(section.id, observation.id) === fieldId
+      );
+      const narrative = fieldId === getEncounterFieldId(section.id);
+      const label = narrative ? section.kind === "narrative" ? section.title : `${section.title} narrative` : observationDefinition?.label ?? section.title;
+      const structured = !narrative && section.kind !== "observations";
+      let display;
+      if (structured) {
+        display = groupedDisplay(observations, section.kind === "vitals");
+      } else if (observations.length) {
+        display = observations.map(observationDisplay).join("; ");
+      } else {
+        display = fieldDisplay({ ...snapshot.responses[fieldId] });
+      }
+      return {
+        id: linkId(fieldId),
+        fieldId,
+        sectionId: section.id,
+        label,
+        display: display.trim() ? display : "\u2014",
+        empty: structured ? observations.length === 0 || !display.trim() : !hasNativeValue(snapshot.responses[fieldId])
+      };
+    })
+  );
+}
+function markdownText(value) {
+  return value.replace(/&/g, "&amp;").replace(/\r?\n/g, " \xB7 ").replace(/[\\[\]`*_~<>]/g, "\\$&");
+}
+function fieldLink(field) {
+  return `[${markdownDisplay(field.display)}](mdy:${field.id})`;
+}
+function markdownDisplay(value) {
+  return value.split(/\r?\n/).map(markdownText).join("<br>");
+}
+function initialBody(snapshot, fields) {
+  return [
+    `# ${markdownText(snapshot.definition.title)}`,
+    ...snapshot.definition.sections.map(
+      (section) => [
+        `## ${markdownText(section.title)}`,
+        fields.filter((field) => field.sectionId === section.id).map(
+          (field) => section.kind === "narrative" ? fieldLink(field) : `- **${markdownText(field.label)}:** ${fieldLink(field)}`
+        ).join("\n")
+      ].join("\n\n")
+    )
+  ].join("\n\n");
+}
+function fieldLinkSpans(body) {
+  const links = [];
+  const closingBrackets = /* @__PURE__ */ new Map();
+  const openingBrackets = [];
+  for (let cursor = 0; cursor < body.length; cursor += 1) {
+    if (body[cursor] === "\\") cursor += 1;
+    else if (body[cursor] === "[") openingBrackets.push(cursor);
+    else if (body[cursor] === "]") {
+      const opening = openingBrackets.pop();
+      if (opening !== void 0) closingBrackets.set(opening, cursor);
+    }
+  }
+  const ticksByLength = /* @__PURE__ */ new Map();
+  for (let cursor = 0; cursor < body.length; cursor += 1) {
+    if (body[cursor] !== "`") continue;
+    const start = cursor;
+    while (body[cursor + 1] === "`") cursor += 1;
+    const length = cursor - start + 1;
+    const runs = ticksByLength.get(length) ?? [];
+    runs.push(start);
+    ticksByLength.set(length, runs);
+  }
+  const tickCursors = /* @__PURE__ */ new Map();
+  let noMoreTagEnds = false;
+  let index = 0;
+  while (index < body.length) {
+    const lineStart = index === 0 || body[index - 1] === "\n";
+    if (lineStart) {
+      const rest = body.slice(index);
+      const fence = /^ {0,3}(`{3,}|~{3,})[^\n]*(?:\n|$)/.exec(rest);
+      if (fence) {
+        const marker = fence[1][0];
+        const close = new RegExp(
+          `^ {0,3}${marker}{${fence[1].length},}[ \\t]*\\r?$`,
+          "m"
+        ).exec(rest.slice(fence[0].length));
+        index += close ? fence[0].length + close.index + close[0].length : rest.length;
+        continue;
+      }
+      if (/^(?: {4}|\t)/.test(rest)) {
+        const end = body.indexOf("\n", index);
+        index = end < 0 ? body.length : end + 1;
+        continue;
+      }
+    }
+    if (body.startsWith("<!--", index)) {
+      const end = body.indexOf("-->", index + 4);
+      index = end < 0 ? body.length : end + 3;
+      continue;
+    }
+    const htmlPrefix = !noMoreTagEnds && body[index] === "<" ? /^<(pre|code|script|style)\b/i.exec(body.slice(index, index + 8)) : null;
+    if (htmlPrefix) {
+      const tagEnd = body.indexOf(">", index + htmlPrefix[0].length);
+      if (tagEnd < 0) noMoreTagEnds = true;
+      else {
+        const contentStart = tagEnd + 1;
+        const end = new RegExp(`</${htmlPrefix[1]}\\s*>`, "i").exec(
+          body.slice(contentStart)
+        );
+        index = end ? contentStart + end.index + end[0].length : body.length;
+        continue;
+      }
+    }
+    if (body[index] === "\\") {
+      index += 2;
+      continue;
+    }
+    if (body[index] === "`") {
+      let ticksEnd = index + 1;
+      while (body[ticksEnd] === "`") ticksEnd += 1;
+      const length = ticksEnd - index;
+      const runs = ticksByLength.get(length) ?? [];
+      let cursor = tickCursors.get(length) ?? 0;
+      while (cursor < runs.length && runs[cursor] < ticksEnd) cursor += 1;
+      tickCursors.set(length, cursor);
+      const closing2 = runs[cursor];
+      index = closing2 === void 0 ? ticksEnd : closing2 + length;
+      continue;
+    }
+    if (body[index] !== "[" || body[index - 1] === "!") {
+      index += 1;
+      continue;
+    }
+    const labelEnd = closingBrackets.get(index);
+    if (labelEnd === void 0) {
+      index += 1;
+      continue;
+    }
+    const closing = labelEnd + 1;
+    const destination = /^\([ \t]*(?:<(?:mdy:|#)([a-z0-9_-]+)>|(?:mdy:|#)([a-z0-9_-]+))(?:[ \t]+(?:"[^"\n]*"|'[^'\n]*'))?[ \t]*\)/.exec(
+      body.slice(closing)
+    );
+    if (destination) {
+      const end = closing + destination[0].length;
+      links.push({
+        id: destination[1] ?? destination[2],
+        start: index,
+        labelEnd,
+        end
+      });
+      index = end;
+    } else {
+      index += 1;
+    }
+  }
+  return links;
+}
+function refreshEncounterMdyLinks(body, fields) {
+  const byId = new Map(fields.map((field) => [field.id, field]));
+  let result = body;
+  for (const link of fieldLinkSpans(body).reverse()) {
+    const field = byId.get(link.id);
+    if (!field) continue;
+    result = result.slice(0, link.start + 1) + markdownDisplay(field.display) + result.slice(link.labelEnd);
+  }
+  return result;
+}
+function splitSource(source) {
+  const opening = /^\uFEFF?---[ \t]*\r?\n/.exec(source);
+  if (!opening) return void 0;
+  const remainder = source.slice(opening[0].length);
+  const closing = /(^|\r?\n)---[ \t]*(\r?\n|$)/.exec(remainder);
+  if (!closing) return void 0;
+  const yamlEnd = closing.index + closing[1].length;
+  const end = opening[0].length + closing.index + closing[0].length;
+  return {
+    frontMatterSource: source.slice(0, end),
+    yamlSource: remainder.slice(0, yamlEnd),
+    body: source.slice(end),
+    opening: opening[0],
+    closing: closing[0].slice(closing[1].length)
+  };
+}
+function fieldsFromFrontMatter(frontMatter) {
+  return Object.entries(frontMatter).flatMap(
+    ([id, value]) => /^[a-z0-9_-]+$/.test(id) && record(value) && typeof value.fieldId === "string" && typeof value.sectionId === "string" && typeof value.display === "string" ? [
+      {
+        id,
+        fieldId: value.fieldId,
+        sectionId: value.sectionId,
+        label: typeof value.label === "string" ? value.label : value.fieldId,
+        display: fieldDisplay(value)
+      }
+    ] : []
+  );
+}
+function validNativeForm(value) {
+  if (!record(value) || typeof value.id !== "string" || !Array.isArray(value.pages))
+    return false;
+  const ids = /* @__PURE__ */ new Set();
+  const fieldsValid = (fields) => Array.isArray(fields) && fields.every((field) => {
+    if (!record(field) || typeof field.id !== "string" || !field.id || typeof field.fieldType !== "string" || ids.has(field.id))
+      return false;
+    ids.add(field.id);
+    return field.fields === void 0 || fieldsValid(field.fields);
+  });
+  return value.pages.every(
+    (page) => record(page) && typeof page.id === "string" && fieldsValid(page.fields)
+  );
+}
+function validNativeResponses(value) {
+  return record(value) && Object.values(value).every(
+    (response) => record(response) && (response.answer === void 0 || typeof response.answer === "string") && (response.selected === void 0 || record(response.selected) || Array.isArray(response.selected))
+  );
+}
+function hasTemplateSyntax(body) {
+  for (const [opener, closer] of [
+    ["{{", "}}"],
+    ["{%", "%}"]
+  ]) {
+    const start = body.indexOf(opener);
+    if (start >= 0 && body.indexOf(closer, start + opener.length) >= 0)
+      return true;
+  }
+  return false;
+}
+function parseEncounterMdy(source) {
+  const split = splitSource(source);
+  const result = {
+    source,
+    frontMatterSource: split?.frontMatterSource ?? "",
+    body: split?.body ?? source,
+    frontMatter: null,
+    diagnostics: []
+  };
+  const error = (code, message) => result.diagnostics.push({ severity: "error", code, message });
+  if (!split) {
+    error(
+      "frontmatter",
+      "An encounter MDY document requires YAML front matter."
+    );
+    return result;
+  }
+  try {
+    const document = parseDocument(split.yamlSource, { uniqueKeys: true });
+    if (document.errors.length || document.warnings.length) {
+      throw new Error("Front matter must contain valid safe YAML.");
+    }
+    const data2 = document.toJS({ maxAliasCount: 100 });
+    if (!record(data2)) throw new Error("Front matter must be a YAML mapping.");
+    result.frontMatter = data2;
+  } catch (cause) {
+    error(
+      "frontmatter",
+      cause instanceof Error ? cause.message : "Invalid YAML front matter."
+    );
+    return result;
+  }
+  const data = result.frontMatter;
+  if (validNativeForm(data.form)) result.form = data.form;
+  else error("form", "Front matter requires a native eSheet form definition.");
+  if (validNativeResponses(data.response)) result.response = data.response;
+  else error("response", "Front matter requires a native eSheet response map.");
+  if (data.encounterDefinition !== void 0) {
+    try {
+      validateEncounterDefinition(
+        data.encounterDefinition
+      );
+      result.definition = data.encounterDefinition;
+    } catch {
+      error(
+        "definition",
+        "Front matter contains an invalid encounterDefinition."
+      );
+    }
+  }
+  const fields = fieldsFromFrontMatter(data);
+  const byId = new Map(fields.map((field) => [field.id, field]));
+  const linked = /* @__PURE__ */ new Set();
+  for (const link of fieldLinkSpans(result.body)) {
+    if (!byId.has(link.id)) {
+      if (link.id.startsWith("visit_") || result.body.slice(link.labelEnd, link.end).includes("mdy:"))
+        result.diagnostics.push({
+          severity: "error",
+          code: "dangling-link",
+          message: `Field link ${link.id} has no indexed data.`
+        });
+    } else linked.add(link.id);
+  }
+  for (const field of fields) {
+    if (!linked.has(field.id) && field.display !== "\u2014" && field.display.trim())
+      result.diagnostics.push({
+        severity: "warning",
+        code: "orphan",
+        message: `${field.label} is recorded without a narrative field link.`,
+        fieldId: field.fieldId
+      });
+  }
+  if (hasTemplateSyntax(result.body))
+    result.diagnostics.push({
+      severity: "warning",
+      code: "template-syntax",
+      message: "Template syntax belongs in .mdyt; document prose is displayed literally."
+    });
+  return result;
+}
+function getEncounterDocumentBody(responses) {
+  return responses[ENCOUNTER_DOCUMENT_FIELD_ID]?.answer;
+}
+function updateEncounterDocumentBody(responses, body, options = {}) {
+  return {
+    ...responses,
+    [ENCOUNTER_DOCUMENT_FIELD_ID]: {
+      ...responses[ENCOUNTER_DOCUMENT_FIELD_ID],
+      answer: body,
+      ...options
+    }
+  };
+}
+function encounterDocumentResponse(source) {
+  const parsed = parseEncounterMdy(source);
+  return {
+    answer: parsed.body,
+    attributes: { mdyFrontMatterSource: parsed.frontMatterSource }
+  };
+}
+function canonicalValue(response) {
+  if (response?.answer !== void 0) {
+    try {
+      return JSON.parse(response.answer);
+    } catch {
+      return response.answer;
+    }
+  }
+  return response?.selected ?? null;
+}
+var FORM_PROPERTIES = /* @__PURE__ */ new Set(["id", "title", "pages"]);
+var PAGE_PROPERTIES = /* @__PURE__ */ new Set(["id", "title", "fields"]);
+var FIELD_PROPERTIES = /* @__PURE__ */ new Set([
+  "id",
+  "fieldType",
+  "title",
+  "question",
+  "required",
+  "width",
+  "content",
+  "fields",
+  "sectionCollapse",
+  "options",
+  "inputType",
+  "unit",
+  "validators",
+  "_sourceData"
+]);
+var SOURCE_PROPERTIES = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "type",
+  "unit",
+  "code",
+  "options",
+  "required",
+  "encounterHideLabel",
+  "findings",
+  "encounterFindings",
+  "encounterRequireCoding",
+  "encounterDate"
+]);
+function mergeMetadata(previous, next, owned) {
+  const merged = { ...record(previous) ? previous : {}, ...next };
+  for (const property of owned) {
+    if (!(property in next)) delete merged[property];
+  }
+  return merged;
+}
+function mergeNativeFormMetadata(previous, next) {
+  if (!record(previous) || previous.id !== next.id) return next;
+  const mergeFields = (oldFields, newFields) => {
+    const oldById = new Map(
+      (Array.isArray(oldFields) ? oldFields : []).filter(record).map((field) => [field.id, field])
+    );
+    return newFields.filter(record).map((field) => {
+      const oldField = oldById.get(field.id);
+      const merged2 = mergeMetadata(oldField, field, FIELD_PROPERTIES);
+      if (Array.isArray(field.fields))
+        merged2.fields = mergeFields(oldField?.fields, field.fields);
+      if (record(field._sourceData))
+        merged2._sourceData = mergeMetadata(
+          oldField?._sourceData,
+          field._sourceData,
+          SOURCE_PROPERTIES
+        );
+      return merged2;
+    });
+  };
+  const oldPages = new Map(
+    (Array.isArray(previous.pages) ? previous.pages : []).filter(record).map((page) => [page.id, page])
+  );
+  const merged = mergeMetadata(
+    previous,
+    next,
+    FORM_PROPERTIES
+  );
+  merged.pages = next.pages.map((page) => {
+    const oldPage = oldPages.get(page.id);
+    return {
+      ...mergeMetadata(
+        oldPage,
+        page,
+        PAGE_PROPERTIES
+      ),
+      fields: mergeFields(oldPage?.fields, page.fields ?? [])
+    };
+  });
+  return merged;
+}
+function setPreserving(document, path, value) {
+  const node = document.getIn(path, true);
+  const previous = document.getIn(path);
+  if (JSON.stringify(previous) === JSON.stringify(value)) return false;
+  if (record(value) && isMap(node)) {
+    let changed = false;
+    const keys = new Set(
+      Object.keys(value).filter((key) => value[key] !== void 0)
+    );
+    for (const pair of [...node.items]) {
+      const key = String(pair.key);
+      if (!keys.has(key)) {
+        document.deleteIn([...path, key]);
+        changed = true;
+      }
+    }
+    for (const key of keys) {
+      changed = setPreserving(document, [...path, key], value[key]) || changed;
+    }
+    return changed;
+  }
+  if (Array.isArray(value) && isSeq(node)) {
+    if (value.every((item) => record(item) && typeof item.id === "string") && node.items.every(
+      (item) => isMap(item) && typeof item.get("id") === "string"
+    )) {
+      const byId = new Map(
+        node.items.map((item) => [
+          isMap(item) ? item.get("id") : void 0,
+          item
+        ])
+      );
+      node.items = value.map((item) => {
+        const id = item.id;
+        return byId.get(id) ?? document.createNode(item);
+      });
+      value.forEach(
+        (item, index) => setPreserving(document, [...path, index], item)
+      );
+      return true;
+    }
+    if (node.items.length === value.length) {
+      return value.reduce(
+        (changed, item, index) => setPreserving(document, [...path, index], item) || changed,
+        false
+      );
+    }
+  }
+  document.setIn(path, value);
+  return true;
+}
+function createEncounterMdy(snapshot, body, source) {
+  const reserved = snapshot.responses[ENCOUNTER_DOCUMENT_FIELD_ID];
+  const previousSource = source ?? reserved?.attributes?.mdyFrontMatterSource ?? "";
+  const split = splitSource(previousSource);
+  const fields = getEncounterMdyFields(snapshot);
+  const authoredBody = body ?? reserved?.answer ?? split?.body ?? initialBody(snapshot, fields);
+  let refreshedBody = refreshEncounterMdyLinks(authoredBody, fields);
+  const responses = Object.fromEntries(
+    Object.entries(snapshot.responses).filter(
+      ([id]) => id !== ENCOUNTER_DOCUMENT_FIELD_ID
+    )
+  );
+  const document = split ? parseDocument(split.yamlSource, { uniqueKeys: true }) : parseDocument("{}\n");
+  if (document.errors.length || document.warnings.length || !isMap(document.contents))
+    throw new Error("Cannot update invalid MDY front matter.");
+  if (!split) document.contents.flow = false;
+  let changed = false;
+  const existing = document.toJS({ maxAliasCount: 100 });
+  const activeIds = new Set(fields.map((field) => field.id));
+  const removedFields = [];
+  if (record(existing)) {
+    for (const [id, value] of Object.entries(existing)) {
+      if (!activeIds.has(id) && record(value) && typeof value.fieldId === "string" && id === linkId(value.fieldId)) {
+        document.delete(id);
+        changed = true;
+        removedFields.push({
+          id,
+          fieldId: value.fieldId,
+          sectionId: typeof value.sectionId === "string" ? value.sectionId : "",
+          label: "Field no longer configured",
+          display: "Field no longer configured"
+        });
+      }
+    }
+  }
+  refreshedBody = refreshEncounterMdyLinks(refreshedBody, removedFields);
+  const oldMdy = record(existing) && record(existing.mdy) ? existing.mdy : {};
+  const metadata = {
+    ...oldMdy,
+    kind: "document",
+    schema: "esheet",
+    template: oldMdy.template ?? {
+      name: snapshot.definition.title,
+      version: "1.0.0"
+    }
+  };
+  for (const [key, value] of Object.entries({
+    mdy: metadata,
+    form: mergeNativeFormMetadata(
+      record(existing) ? existing.form : void 0,
+      createEncounterFormDefinition(snapshot.definition)
+    ),
+    response: responses,
+    encounterDefinition: snapshot.definition
+  })) {
+    changed = setPreserving(document, [key], value) || changed;
+  }
+  for (const field of fields) {
+    const oldField = record(existing) ? existing[field.id] : void 0;
+    changed = setPreserving(document, [field.id], {
+      ...record(oldField) ? oldField : {},
+      fieldId: field.fieldId,
+      sectionId: field.sectionId,
+      label: field.label,
+      value: canonicalValue(responses[field.fieldId]),
+      display: field.display
+    }) || changed;
+  }
+  const newline = split?.opening.endsWith("\r\n") ? "\r\n" : "\n";
+  if (split && !changed) {
+    const boundary = refreshedBody && !split.frontMatterSource.endsWith("\n") ? newline : "";
+    return `${split.frontMatterSource}${boundary}${refreshedBody}`;
+  }
+  const yaml = document.toString({ lineWidth: 0 }).replace(/\n/g, newline);
+  let closing = split?.closing || `---${newline}`;
+  if (refreshedBody && !closing.endsWith("\n")) closing += newline;
+  return `${split?.opening ?? `---${newline}`}${yaml}${closing}${refreshedBody}`;
+}
+async function renderEncounterMdy(source) {
+  let parsed = parseEncounterMdy(source);
+  let fields = fieldsFromFrontMatter(parsed.frontMatter ?? {});
+  if (parsed.definition && parsed.response) {
+    const { createEncounterSnapshot: createEncounterSnapshot2 } = await import('./model-WFFZRQMY.js');
+    const snapshot = createEncounterSnapshot2(parsed.definition, {
+      ...parsed.response,
+      [ENCOUNTER_DOCUMENT_FIELD_ID]: encounterDocumentResponse(source)
+    });
+    parsed = parseEncounterMdy(snapshot.mdy);
+    const canonical = new Map(
+      getEncounterMdyFields(snapshot).map((field) => [field.fieldId, field])
+    );
+    fields = fieldsFromFrontMatter(parsed.frontMatter ?? {}).map((field) => ({
+      ...field,
+      display: canonical.get(field.fieldId)?.display ?? field.display,
+      empty: canonical.get(field.fieldId)?.empty ?? !hasNativeValue(parsed.response?.[field.fieldId], true)
+    }));
+  } else if (parsed.response) {
+    const units = /* @__PURE__ */ new Map();
+    const indexUnits = (nativeFields) => {
+      if (!Array.isArray(nativeFields)) return;
+      for (const field of nativeFields) {
+        if (!record(field)) continue;
+        if (typeof field.id === "string" && typeof field.unit === "string")
+          units.set(field.id, field.unit);
+        indexUnits(field.fields);
+      }
+    };
+    parsed.form?.pages.forEach((page) => indexUnits(page.fields));
+    const response = parsed.response;
+    fields = fields.map((field) => {
+      const cached = parsed.frontMatter?.[field.id];
+      const native = response[field.fieldId];
+      const empty = !hasNativeValue(native, true);
+      if (!native || !record(cached) || JSON.stringify(cached.value) === JSON.stringify(canonicalValue(native)))
+        return { ...field, empty };
+      const display = fieldDisplay({
+        ...native,
+        unit: units.get(field.fieldId)
+      });
+      parsed.diagnostics.push({
+        severity: "warning",
+        code: "response",
+        fieldId: field.fieldId,
+        message: `${field.label}'s cached projection differed from its canonical response and was refreshed.`
+      });
+      return { ...field, display: display.trim() ? display : "\u2014", empty };
+    });
+  }
+  const body = refreshEncounterMdyLinks(parsed.body, fields);
+  const envelope = parsed.frontMatterSource || "---\n{}\n---\n";
+  const { raw, html } = await render(
+    `${envelope}${body}`,
+    {},
+    {
+      engine: { name: "encounter-mdy-document", render: (content) => content },
+      markdown: markdownToHtml,
+      fieldLinks: false
+    }
+  );
+  return { raw, html, fields, diagnostics: parsed.diagnostics };
+}
+
+// src/components/EncounterVisit/model.ts
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nonempty2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function measurement(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function parseJson(answer) {
+  if (typeof answer !== "string" || !answer.trim()) return void 0;
+  try {
+    return JSON.parse(answer);
+  } catch {
+    return void 0;
+  }
+}
+var VITALS = [
+  { key: "pulse", label: "Pulse", unit: "/min", code: "8867-4" },
+  {
+    key: "respiratoryRate",
+    label: "Respiratory rate",
+    unit: "/min",
+    code: "9279-1"
+  },
+  { key: "temperature", label: "Temperature", unit: "Cel", code: "8310-5" },
+  {
+    key: "oxygenSaturation",
+    label: "Oxygen saturation",
+    unit: "%",
+    code: "2708-6"
+  },
+  { key: "height", label: "Height", unit: "cm", code: "8302-2" },
+  { key: "weight", label: "Weight", unit: "kg", code: "29463-7" },
+  { key: "pain", label: "Pain score", unit: "{score}", code: "72514-3" }
+];
+var VITAL_KEYS = [
+  "systolic",
+  "diastolic",
+  ...VITALS.map(({ key }) => key)
+];
+function loinc(code, display) {
+  return { system: "http://loinc.org", code, display };
+}
+function parseEncounterVitals(answer) {
+  const parsed = parseJson(answer);
+  if (!record2(parsed) || !Array.isArray(parsed.readings))
+    return { readings: [] };
+  const readings = parsed.readings.filter(
+    (reading) => record2(reading) && nonempty2(reading.id)
+  ).map((reading) => {
+    const safe = { id: reading.id };
+    for (const key of VITAL_KEYS) {
+      if (typeof reading[key] === "number" && Number.isFinite(reading[key]))
+        safe[key] = reading[key];
+    }
+    for (const key of ["recordedAt", "position", "site"]) {
+      if (typeof reading[key] === "string") safe[key] = reading[key];
+    }
+    return safe;
+  });
+  const inputDrafts = Array.isArray(parsed.inputDrafts) ? parsed.inputDrafts.filter(
+    (draft) => record2(draft) && nonempty2(draft.readingId) && nonempty2(draft.text) && VITAL_KEYS.includes(draft.key)
+  ) : void 0;
+  for (const draft of Array.isArray(parsed.inputDrafts) ? parsed.inputDrafts : []) {
+    if (!record2(draft) || typeof draft.readingId !== "string" || !VITAL_KEYS.includes(draft.key))
+      continue;
+    const reading = readings.find(({ id }) => id === draft.readingId);
+    if (reading) delete reading[draft.key];
+  }
+  return inputDrafts ? { readings, inputDrafts } : { readings };
+}
+function validateEncounterVitals(value, fieldId = "", sectionId = "") {
+  const issues = [];
+  const add = (message, path, readingId, code = "invalid-value") => {
+    issues.push({ sectionId, fieldId, code, message, path, readingId });
+  };
+  if (!record2(value) || !Array.isArray(value.readings)) {
+    add("Vitals must contain a readings array.", "readings");
+    return issues;
+  }
+  for (const key of Object.keys(value)) {
+    if (!["readings", "inputDrafts"].includes(key))
+      add(`Unknown vitals property ${key}.`, key);
+  }
+  const readings = value.readings;
+  const ids = /* @__PURE__ */ new Set();
+  readings.forEach((reading, index) => {
+    const path = `readings.${index}`;
+    if (!record2(reading) || !nonempty2(reading.id)) {
+      add("Each vital reading requires a nonempty id.", `${path}.id`);
+      return;
+    }
+    const id = reading.id;
+    if (ids.has(id)) add("Vital reading ids must be unique.", `${path}.id`, id);
+    ids.add(id);
+    const allowedKeys = /* @__PURE__ */ new Set([
+      "id",
+      "recordedAt",
+      "position",
+      "site",
+      ...VITAL_KEYS
+    ]);
+    for (const key of Object.keys(reading)) {
+      if (!allowedKeys.has(key))
+        add(`Unknown vital property ${key}.`, `${path}.${key}`, id);
+    }
+    if (!VITAL_KEYS.some((key) => reading[key] !== void 0)) {
+      add("Record at least one measurement in a vital reading.", path, id);
+    }
+    for (const key of VITAL_KEYS) {
+      if (reading[key] !== void 0 && !measurement(reading[key])) {
+        add(
+          `${key} must be a finite nonnegative number.`,
+          `${path}.${key}`,
+          id,
+          "invalid-number"
+        );
+      }
+    }
+    if (reading.systolic !== void 0 !== (reading.diastolic !== void 0)) {
+      add(
+        "Record both systolic and diastolic blood pressure, or leave both blank.",
+        path,
+        id,
+        "incomplete-blood-pressure"
+      );
+    }
+    if (measurement(reading.oxygenSaturation) && reading.oxygenSaturation > 100) {
+      add(
+        "Oxygen saturation must be between 0 and 100 percent.",
+        `${path}.oxygenSaturation`,
+        id,
+        "invalid-number"
+      );
+    }
+    if (measurement(reading.pain) && reading.pain > 10) {
+      add(
+        "Pain score must be between 0 and 10.",
+        `${path}.pain`,
+        id,
+        "invalid-number"
+      );
+    }
+    for (const key of ["recordedAt", "position", "site"]) {
+      if (reading[key] !== void 0 && typeof reading[key] !== "string") {
+        add(`${key} must be a string.`, `${path}.${key}`, id);
+      }
+    }
+    if (nonempty2(reading.recordedAt) && (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(reading.recordedAt) || !DateTime.fromISO(reading.recordedAt, { setZone: true }).isValid)) {
+      add(
+        "Recorded time must be a valid date and time.",
+        `${path}.recordedAt`,
+        id
+      );
+    }
+  });
+  if (value.inputDrafts !== void 0) {
+    if (!Array.isArray(value.inputDrafts)) {
+      add(
+        "Unfinished vital inputs must be an inputDrafts array.",
+        "inputDrafts"
+      );
+    } else {
+      const draftKeys = /* @__PURE__ */ new Set();
+      value.inputDrafts.forEach((draft, index) => {
+        const path = `inputDrafts.${index}`;
+        if (!record2(draft) || !nonempty2(draft.readingId) || !nonempty2(draft.text) || !VITAL_KEYS.includes(draft.key)) {
+          add(
+            "Each unfinished input requires a reading id, numeric measurement key and nonempty text.",
+            path,
+            record2(draft) && typeof draft.readingId === "string" ? draft.readingId : void 0
+          );
+          add(
+            "Finish or clear the malformed numeric input before saving.",
+            path,
+            record2(draft) && typeof draft.readingId === "string" ? draft.readingId : void 0,
+            "invalid-number"
+          );
+          return;
+        }
+        const readingId = draft.readingId;
+        if (!ids.has(readingId))
+          add(
+            "Unfinished input must reference an existing reading.",
+            `${path}.readingId`,
+            readingId
+          );
+        for (const key of Object.keys(draft)) {
+          if (!["readingId", "key", "text"].includes(key))
+            add(
+              `Unknown unfinished input property ${key}.`,
+              `${path}.${key}`,
+              readingId
+            );
+        }
+        const draftKey = JSON.stringify([readingId, draft.key]);
+        if (draftKeys.has(draftKey))
+          add(
+            "Each measurement can have only one unfinished input.",
+            path,
+            readingId
+          );
+        draftKeys.add(draftKey);
+        const readingIndex = readings.findIndex(
+          (reading) => record2(reading) && reading.id === readingId
+        );
+        add(
+          `Finish or clear the ${draft.key} input before saving.`,
+          `readings.${readingIndex}.${draft.key}`,
+          readingId,
+          "invalid-number"
+        );
+      });
+    }
+  }
+  return issues;
+}
+function optionalStrings(value, keys) {
+  return keys.every(
+    (key) => value[key] === void 0 || typeof value[key] === "string"
+  );
+}
+function validCode(value) {
+  return value === void 0 || record2(value) && nonempty2(value.system) && nonempty2(value.code) && optionalStrings(value, ["display"]);
+}
+function validFieldUncertainty(value) {
+  return record2(value) && typeof value.known === "boolean" && (value.reason === void 0 || ["asked-unknown", "not-asked", "masked", "unavailable"].includes(
+    value.reason
+  )) && (value.confidence === void 0 || ["low", "medium", "high"].includes(value.confidence)) && optionalStrings(value, ["note"]);
+}
+function validUncertainty(value) {
+  if (!record2(value)) return false;
+  if (value.overall !== void 0 && !["confirmed", "low", "medium", "high"].includes(value.overall)) {
+    return false;
+  }
+  if (value.fields === void 0) return true;
+  if (!record2(value.fields)) return false;
+  return Object.entries(value.fields).every(
+    ([field, fieldUncertainty]) => ["coding", "onset", "severity", "laterality", "bodySite"].includes(
+      field
+    ) && validFieldUncertainty(fieldUncertainty)
+  );
+}
+function validMedication(value) {
+  return record2(value) && nonempty2(value.id) && nonempty2(value.name) && [
+    "unreconciled",
+    "taking",
+    "taking-noncompliant",
+    "not-taking",
+    "unknown"
+  ].includes(value.status) && optionalStrings(value, [
+    "sig",
+    "discontinuedDate",
+    "note",
+    "task",
+    "strength",
+    "doseForm",
+    "quantity",
+    "quantityUnit",
+    "daysSupply",
+    "route",
+    "frequency",
+    "refills",
+    "startDate",
+    "endDate",
+    "indication",
+    "pharmacyNotes"
+  ]) && (value.expired === void 0 || typeof value.expired === "boolean") && (value.prn === void 0 || typeof value.prn === "boolean") && (value.substitution === void 0 || ["0", "1"].includes(value.substitution)) && validCode(value.code);
+}
+function validAllergy(value) {
+  return record2(value) && nonempty2(value.id) && nonempty2(value.allergen) && optionalStrings(value, ["reaction", "onsetDate", "note"]) && (value.type === void 0 || ["drug", "food", "environmental", "other"].includes(
+    value.type
+  )) && (value.kind === void 0 || ["allergy", "intolerance"].includes(value.kind)) && (value.severity === void 0 || ["mild", "moderate", "severe"].includes(value.severity)) && (value.inactive === void 0 || typeof value.inactive === "boolean") && validCode(value.code);
+}
+function duplicateIds(values, key) {
+  return new Set(values.map((value) => value[key])).size !== values.length;
+}
+function validAssessmentItem(value) {
+  return record2(value) && nonempty2(value.concernId) && nonempty2(value.assertionId) && optionalStrings(value, ["note"]);
+}
+function validateEncounterAssessment(value, fieldId = "", sectionId = "", externalConcerns = []) {
+  const issues = [];
+  const add = (message, path) => issues.push({
+    sectionId,
+    fieldId,
+    code: "invalid-value",
+    message,
+    path
+  });
+  if (!record2(value) || !Array.isArray(value.concerns) || !Array.isArray(value.items) || !Array.isArray(value.orders)) {
+    add("Assessment must contain concerns, items and orders arrays.");
+    return issues;
+  }
+  const concerns = new Map(
+    externalConcerns.map((concern) => [
+      concern.concernId,
+      new Set(concern.assertions.map((assertion) => assertion.id))
+    ])
+  );
+  const localConcernIds = /* @__PURE__ */ new Set();
+  value.concerns.forEach((concern, index) => {
+    const path = `concerns.${index}`;
+    if (!record2(concern) || !nonempty2(concern.concernId) || !Array.isArray(concern.assertions) || ![
+      "active",
+      "recurrence",
+      "relapse",
+      "inactive",
+      "remission",
+      "resolved"
+    ].includes(concern.clinicalStatus)) {
+      add(
+        "Each concern requires an id, clinical status and assertions array.",
+        path
+      );
+      return;
+    }
+    if (localConcernIds.has(concern.concernId))
+      add("Concern ids must be unique.", `${path}.concernId`);
+    localConcernIds.add(concern.concernId);
+    if (concern.relationships !== void 0 && (!Array.isArray(concern.relationships) || concern.relationships.some(
+      (relationship) => !record2(relationship) || !nonempty2(relationship.concernId) || ![
+        "caused-by",
+        "evolved-from",
+        "differential-sibling",
+        "complication-of"
+      ].includes(relationship.type) || !optionalStrings(relationship, ["display"])
+    ))) {
+      add(
+        "Concern relationships must be an array of records with a supported type and a concernId.",
+        `${path}.relationships`
+      );
+    }
+    if (concern.observations !== void 0 && (!Array.isArray(concern.observations) || concern.observations.some(
+      (observation) => !record2(observation) || !nonempty2(observation.id) || !nonempty2(observation.text) || !isEncounterDate(observation.date) || !optionalStrings(observation, ["author"])
+    ))) {
+      add(
+        "Concern observations must be an array of records with an id, text and a valid YYYY-MM-DD date.",
+        `${path}.observations`
+      );
+    }
+    const assertionIds = /* @__PURE__ */ new Set();
+    concerns.set(concern.concernId, assertionIds);
+    concern.assertions.forEach((assertion, assertionIndex) => {
+      const assertionPath = `${path}.assertions.${assertionIndex}`;
+      if (!record2(assertion) || !nonempty2(assertion.id) || !nonempty2(assertion.text) || !isEncounterDate(assertion.date) || ![
+        "unconfirmed",
+        "provisional",
+        "differential",
+        "confirmed",
+        "refuted",
+        "entered-in-error"
+      ].includes(assertion.verificationStatus) || !optionalStrings(assertion, ["note"])) {
+        add(
+          "Each assertion requires an id, text, a valid YYYY-MM-DD date and verification status.",
+          assertionPath
+        );
+        return;
+      }
+      if (assertionIds.has(assertion.id))
+        add(
+          "Assertion ids must be unique within a concern.",
+          `${assertionPath}.id`
+        );
+      assertionIds.add(assertion.id);
+      if (assertion.changeType !== void 0 && !["refinement", "revision", "progression", "reattribution"].includes(
+        assertion.changeType
+      )) {
+        add(
+          "Assertion changeType must be refinement, revision, progression or reattribution.",
+          `${assertionPath}.changeType`
+        );
+      }
+      if (assertion.coding !== void 0 && (!Array.isArray(assertion.coding) || assertion.coding.some((coding) => !validCode(coding)))) {
+        add(
+          "Assertion coding must contain system and code strings.",
+          `${assertionPath}.coding`
+        );
+      }
+      if (assertion.uncertainty !== void 0 && !validUncertainty(assertion.uncertainty)) {
+        add(
+          "Assertion uncertainty must use supported overall confidence and per-field known/reason/confidence records.",
+          `${assertionPath}.uncertainty`
+        );
+      }
+    });
+  });
+  const itemIds = /* @__PURE__ */ new Set();
+  value.items.forEach((item, index) => {
+    const path = `items.${index}`;
+    if (!validAssessmentItem(item)) {
+      add("Assessment items require concern and assertion ids.", path);
+      return;
+    }
+    if (itemIds.has(item.concernId))
+      add("Each concern may be assessed once.", `${path}.concernId`);
+    itemIds.add(item.concernId);
+    if (!concerns.get(item.concernId)?.has(item.assertionId)) {
+      add(
+        "An assessment item must reference an existing concern and assertion.",
+        path
+      );
+    }
+  });
+  const orderIds = /* @__PURE__ */ new Set();
+  value.orders.forEach((order, index) => {
+    const path = `orders.${index}`;
+    if (!record2(order) || !nonempty2(order.orderId) || !nonempty2(order.display) || !["medication", "lab", "imaging", "procedure", "referral"].includes(
+      order.type
+    ) || !optionalStrings(order, [
+      "concernId",
+      "detail",
+      "timing",
+      "indication",
+      "notes",
+      "bodySite",
+      "referTo"
+    ]) || order.priority !== void 0 && !["routine", "urgent", "stat"].includes(order.priority)) {
+      add(
+        "Each order requires an id, display text and supported order type.",
+        path
+      );
+      return;
+    }
+    if (orderIds.has(order.orderId))
+      add("Order ids must be unique.", `${path}.orderId`);
+    orderIds.add(order.orderId);
+    if (order.concernId !== void 0 && !concerns.has(order.concernId)) {
+      add(
+        "An order indication must reference an existing concern.",
+        `${path}.concernId`
+      );
+    }
+    if (order.code !== void 0 && (!record2(order.code) || !nonempty2(order.code.fullid) || !nonempty2(order.code.codetype) || !nonempty2(order.code.fullcode))) {
+      add(
+        "Order coding requires fullid, codetype and fullcode.",
+        `${path}.code`
+      );
+    }
+  });
+  return issues;
+}
+function parseEncounterAssessment(answer) {
+  const parsed = parseJson(answer);
+  return validateEncounterAssessment(parsed).length === 0 ? parsed : { concerns: [], items: [], orders: [] };
+}
+function validateClinicalList(parsed, key, validItem, title, fieldId, sectionId) {
+  const issues = [];
+  const add = (message, path) => issues.push({
+    sectionId,
+    fieldId,
+    code: "invalid-value",
+    message,
+    path
+  });
+  if (!record2(parsed) || !Array.isArray(parsed[key])) {
+    add(`${title} must contain a ${key} array.`, key);
+    return issues;
+  }
+  const values = parsed[key];
+  values.forEach((item, index) => {
+    if (!validItem(item))
+      add(
+        `Invalid ${key === "medications" ? "medication" : "allergy"} record.`,
+        `${key}.${index}`
+      );
+  });
+  if (values.every(record2) && duplicateIds(values, "id"))
+    add(`${title} ids must be unique.`, key);
+  if (key === "allergies") {
+    if (parsed.noKnownAllergies !== void 0 && typeof parsed.noKnownAllergies !== "boolean") {
+      add(
+        "No-known-allergies must be an explicit boolean.",
+        "noKnownAllergies"
+      );
+    }
+    if (parsed.noKnownAllergies === true && values.length > 0) {
+      add(
+        "Recorded allergies conflict with the no-known-allergies flag.",
+        "noKnownAllergies"
+      );
+    }
+  }
+  return issues;
+}
+function validateEncounterMedicationValue(value, fieldId = "", sectionId = "") {
+  return validateClinicalList(
+    value,
+    "medications",
+    validMedication,
+    "Medications",
+    fieldId,
+    sectionId
+  );
+}
+function validateEncounterAllergyValue(value, fieldId = "", sectionId = "") {
+  return validateClinicalList(
+    value,
+    "allergies",
+    validAllergy,
+    "Allergies",
+    fieldId,
+    sectionId
+  );
+}
+function validateEncounterConditions(value, fieldId = "", sectionId = "") {
+  return validateEncounterAssessment(
+    {
+      concerns: record2(value) ? value.concerns : void 0,
+      items: [],
+      orders: []
+    },
+    fieldId,
+    sectionId
+  );
+}
+function validateEncounterPlan(value, fieldId = "", sectionId = "") {
+  if (!record2(value) || !Array.isArray(value.orders))
+    return [
+      {
+        sectionId,
+        fieldId,
+        code: "invalid-value",
+        message: "Plan must contain an orders array.",
+        path: "orders"
+      }
+    ];
+  const ids = new Set(
+    value.orders.flatMap(
+      (order) => record2(order) && nonempty2(order.concernId) ? [order.concernId] : []
+    )
+  );
+  return validateEncounterAssessment(
+    {
+      concerns: Array.from(ids, (concernId) => ({
+        concernId,
+        clinicalStatus: "active",
+        assertions: []
+      })),
+      items: [],
+      orders: value.orders
+    },
+    fieldId,
+    sectionId
+  );
+}
+function parseEncounterConditions(answer) {
+  const parsed = parseJson(answer);
+  return validateEncounterConditions(parsed).length === 0 ? parsed : { concerns: [] };
+}
+function parseEncounterPlan(answer) {
+  const parsed = parseJson(answer);
+  return validateEncounterPlan(parsed).length === 0 ? parsed : { orders: [] };
+}
+function validateCoding(section, parsed, fieldId, externalConcerns = []) {
+  if (!(section.requireCoding ?? true)) return [];
+  const issues = [];
+  const add = (path) => issues.push({
+    sectionId: section.id,
+    fieldId,
+    code: "invalid-value",
+    path,
+    message: `${section.title} entries require a selected clinical code.`
+  });
+  const coded = (code) => record2(code) && validCode(code);
+  if (section.kind === "medications" || section.kind === "allergies") {
+    const key = section.kind;
+    if (Array.isArray(parsed[key]))
+      parsed[key].forEach((entry, index) => {
+        if (record2(entry) && !coded(entry.code)) add(`${key}.${index}.code`);
+      });
+  } else if (section.kind === "conditions" || section.kind === "assessment") {
+    if (Array.isArray(parsed.concerns))
+      parsed.concerns.forEach((entry, index) => {
+        if (!record2(entry) || !Array.isArray(entry.assertions)) return;
+        const assertion = currentAssertion(
+          entry
+        );
+        if (!assertion?.coding?.some(coded)) add(`concerns.${index}.coding`);
+      });
+  }
+  if (section.kind === "assessment" && Array.isArray(parsed.items)) {
+    const concerns = [
+      ...Array.isArray(parsed.concerns) ? parsed.concerns : [],
+      ...externalConcerns
+    ];
+    parsed.items.forEach((item, index) => {
+      if (!record2(item)) return;
+      const concern = concerns.find(
+        (entry) => record2(entry) && entry.concernId === item.concernId
+      );
+      const assertion = concern && Array.isArray(concern.assertions) ? concern.assertions.find(
+        (entry) => record2(entry) && entry.id === item.assertionId
+      ) : void 0;
+      if (!record2(assertion) || !Array.isArray(assertion.coding) || !assertion.coding.some(coded))
+        add(`items.${index}.coding`);
+    });
+  }
+  if (section.kind === "plan" || section.kind === "assessment") {
+    if (Array.isArray(parsed.orders))
+      parsed.orders.forEach((order, index) => {
+        if (record2(order) && (!record2(order.code) || !nonempty2(order.code.fullid) || !nonempty2(order.code.codetype) || !nonempty2(order.code.fullcode)))
+          add(`orders.${index}.code`);
+      });
+  }
+  return issues;
+}
+function validateCustom(section, answer, fieldId, externalConcerns = []) {
+  let parsed;
+  try {
+    parsed = JSON.parse(answer);
+  } catch {
+    return [
+      {
+        sectionId: section.id,
+        fieldId,
+        code: "invalid-json",
+        message: `${section.title} contains malformed JSON.`
+      }
+    ];
+  }
+  const shape = section.kind === "vitals" ? validateEncounterVitals(parsed, fieldId, section.id) : section.kind === "assessment" ? validateEncounterAssessment(
+    parsed,
+    fieldId,
+    section.id,
+    externalConcerns
+  ) : section.kind === "conditions" ? validateEncounterConditions(parsed, fieldId, section.id) : section.kind === "plan" ? validateEncounterPlan(parsed, fieldId, section.id) : section.kind === "medications" ? validateEncounterMedicationValue(parsed, fieldId, section.id) : validateEncounterAllergyValue(parsed, fieldId, section.id);
+  return shape.length || !record2(parsed) ? shape : validateCoding(section, parsed, fieldId, externalConcerns);
+}
+function selectedValue(response) {
+  return record2(response?.selected) && typeof response.selected.value === "string" ? response.selected.value : void 0;
+}
+function responseHasContent(response) {
+  return nonempty2(response?.answer) || nonempty2(selectedValue(response));
+}
+function customHasContent(section, answer) {
+  const parsed = parseJson(answer);
+  if (!record2(parsed)) return false;
+  if (section.kind === "vitals")
+    return parseEncounterVitals(answer).readings.some(
+      (reading) => VITAL_KEYS.some((key) => measurement(reading[key]))
+    );
+  if (section.kind === "medications")
+    return Array.isArray(parsed.medications) && parsed.medications.length > 0;
+  if (section.kind === "allergies")
+    return Array.isArray(parsed.allergies) && parsed.allergies.length > 0 || parsed.noKnownAllergies === true;
+  if (section.kind === "conditions")
+    return Array.isArray(parsed.concerns) && parsed.concerns.length > 0;
+  return Array.isArray(parsed.items) && parsed.items.length > 0 || Array.isArray(parsed.orders) && parsed.orders.length > 0;
+}
+function getEncounterConcerns(definition, responses) {
+  const concerns = /* @__PURE__ */ new Map();
+  const sections = [...definition.sections].sort(
+    (a, b) => Number(b.kind === "conditions") - Number(a.kind === "conditions")
+  );
+  for (const section of sections) {
+    if (section.kind !== "conditions" && section.kind !== "assessment")
+      continue;
+    const value = parseJson(
+      responses[getEncounterFieldId(section.id, "value")]?.answer
+    );
+    if (!record2(value) || validateEncounterConditions({ concerns: value.concerns }).length)
+      continue;
+    for (const concern of value.concerns)
+      if (!concerns.has(concern.concernId))
+        concerns.set(concern.concernId, concern);
+  }
+  return [...concerns.values()];
+}
+function validateEncounterResponses(definition, responses) {
+  validateEncounterDefinition(definition);
+  const externalConcerns = getEncounterConcerns(definition, responses);
+  const issues = [];
+  const add = (sectionId, fieldId, code, message) => issues.push({ sectionId, fieldId, code, message });
+  for (const section of definition.sections) {
+    const ids = getEncounterSectionFieldIds(section);
+    for (const fieldId of ids) {
+      const response = responses[fieldId];
+      if (response !== void 0 && (!record2(response) || response.answer !== void 0 && typeof response.answer !== "string")) {
+        add(
+          section.id,
+          fieldId,
+          "invalid-response",
+          "An eSheet response must be an object with a string answer."
+        );
+      }
+    }
+    if (section.kind === "narrative" || section.narrative) {
+      const fieldId = getEncounterFieldId(section.id);
+      const response = responses[fieldId];
+      if (response?.selected !== void 0)
+        add(
+          section.id,
+          fieldId,
+          "invalid-response",
+          "Narrative fields store text in answer."
+        );
+    }
+    if (section.kind === "observations") {
+      for (const observation of section.observations ?? []) {
+        const fieldId = getEncounterFieldId(section.id, observation.id);
+        const response = responses[fieldId];
+        const hasContent = responseHasContent(response);
+        if (observation.required && !hasContent)
+          add(
+            section.id,
+            fieldId,
+            "required",
+            `${observation.label} is required.`
+          );
+        if (observation.type === "choice") {
+          if (response?.selected !== void 0 && (!record2(response.selected) || typeof response.selected.id !== "string" || typeof response.selected.value !== "string" || !observation.options?.includes(response.selected.value) || response.selected.id !== encodeURIComponent(response.selected.value))) {
+            add(
+              section.id,
+              fieldId,
+              "invalid-choice",
+              `${observation.label} must use a configured option.`
+            );
+          }
+          if (nonempty2(response?.answer))
+            add(
+              section.id,
+              fieldId,
+              "invalid-response",
+              "Choice observations store the selected option in selected."
+            );
+        } else {
+          if (response?.selected !== void 0)
+            add(
+              section.id,
+              fieldId,
+              "invalid-response",
+              "Text and numeric observations store their value in answer."
+            );
+          if (observation.type === "number" && nonempty2(response?.answer) && !measurement(Number(response.answer.trim()))) {
+            add(
+              section.id,
+              fieldId,
+              "invalid-number",
+              `${observation.label} must be a finite nonnegative number.`
+            );
+          }
+        }
+      }
+    } else if (section.kind !== "narrative") {
+      const fieldId = getEncounterFieldId(section.id, "value");
+      const response = responses[fieldId];
+      if (response?.selected !== void 0)
+        add(
+          section.id,
+          fieldId,
+          "invalid-response",
+          "Structured sections store serialized JSON in answer."
+        );
+      if (nonempty2(response?.answer))
+        issues.push(
+          ...validateCustom(section, response.answer, fieldId, externalConcerns)
+        );
+    }
+    if (section.required) {
+      const hasContent = section.kind === "narrative" || section.kind === "observations" ? ids.some((id) => responseHasContent(responses[id])) : section.narrative && responseHasContent(responses[getEncounterFieldId(section.id)]) || customHasContent(
+        section,
+        responses[getEncounterFieldId(section.id, "value")]?.answer
+      );
+      if (!hasContent)
+        add(
+          section.id,
+          ids[0],
+          "required",
+          `${section.title} requires at least one recorded answer.`
+        );
+    }
+  }
+  const concernIds = new Set(
+    externalConcerns.map((concern) => concern.concernId)
+  );
+  for (const section of definition.sections) {
+    if (section.kind !== "plan") continue;
+    const fieldId = getEncounterFieldId(section.id, "value");
+    const parsed = parseJson(responses[fieldId]?.answer);
+    if (!record2(parsed) || !Array.isArray(parsed.orders)) continue;
+    parsed.orders.forEach((order, index) => {
+      if (record2(order) && nonempty2(order.concernId) && !concernIds.has(order.concernId))
+        issues.push({
+          sectionId: section.id,
+          fieldId,
+          code: "invalid-value",
+          path: `orders.${index}.concernId`,
+          message: "A plan order must link to a condition recorded in this visit."
+        });
+    });
+  }
+  return issues;
+}
+function exportVitals(section, answer) {
+  const fieldId = getEncounterFieldId(section.id, "value");
+  return parseEncounterVitals(answer).readings.flatMap((reading) => {
+    const base = {
+      sectionId: section.id,
+      fieldId,
+      groupId: reading.id,
+      recordedAt: reading.recordedAt,
+      position: reading.position,
+      site: reading.site
+    };
+    const observations = [];
+    if (measurement(reading.systolic) || measurement(reading.diastolic)) {
+      observations.push({
+        ...base,
+        label: "Blood pressure",
+        value: `${measurement(reading.systolic) ? reading.systolic : "?"}/${measurement(reading.diastolic) ? reading.diastolic : "?"}`,
+        unit: "mmHg",
+        code: loinc("85354-9", "Blood pressure panel"),
+        components: [
+          ...measurement(reading.systolic) ? [
+            {
+              label: "Systolic",
+              value: reading.systolic,
+              unit: "mmHg",
+              code: loinc("8480-6", "Systolic blood pressure")
+            }
+          ] : [],
+          ...measurement(reading.diastolic) ? [
+            {
+              label: "Diastolic",
+              value: reading.diastolic,
+              unit: "mmHg",
+              code: loinc("8462-4", "Diastolic blood pressure")
+            }
+          ] : []
+        ]
+      });
+    }
+    for (const vital of VITALS) {
+      const value = reading[vital.key];
+      if (measurement(value) && (vital.key !== "pain" || value <= 10) && (vital.key !== "oxygenSaturation" || value <= 100))
+        observations.push({
+          ...base,
+          label: vital.label,
+          value,
+          unit: vital.unit,
+          code: loinc(vital.code, vital.label)
+        });
+    }
+    return observations;
+  });
+}
+function exportCustom(section, answer, externalConcerns = []) {
+  if (section.kind === "vitals") return exportVitals(section, answer);
+  if (!nonempty2(answer) || validateCustom(
+    { ...section, requireCoding: false },
+    answer,
+    getEncounterFieldId(section.id, "value"),
+    externalConcerns
+  ).length > 0)
+    return [];
+  const parsed = parseJson(answer);
+  const base = {
+    sectionId: section.id,
+    fieldId: getEncounterFieldId(section.id, "value")
+  };
+  if (section.kind === "medications") {
+    return parsed.medications.map((medication) => ({
+      ...base,
+      label: "Medication",
+      value: [
+        medication.name,
+        medication.sig,
+        `Status: ${medication.status}`,
+        medication.note,
+        (section.requireCoding ?? true) && !medication.code ? "Coding required" : void 0
+      ].filter(Boolean).join("; "),
+      code: medication.code,
+      groupId: medication.id
+    }));
+  }
+  if (section.kind === "allergies") {
+    if (parsed.noKnownAllergies === true)
+      return [
+        {
+          ...base,
+          label: "Allergies",
+          value: "No known allergies (explicitly recorded)",
+          // HL7 IPA NKA example: AllergyIntolerance/716186003 (explicit absence).
+          code: {
+            system: "http://snomed.info/sct",
+            code: "716186003",
+            display: "No known allergy"
+          }
+        }
+      ];
+    return parsed.allergies.map((allergy) => ({
+      ...base,
+      label: allergy.kind === "intolerance" ? "Intolerance" : "Allergy",
+      value: [
+        allergy.allergen,
+        allergy.reaction,
+        allergy.severity,
+        allergy.inactive ? "inactive" : void 0,
+        allergy.note,
+        (section.requireCoding ?? true) && !allergy.code ? "Coding required" : void 0
+      ].filter(Boolean).join("; "),
+      code: allergy.code,
+      groupId: allergy.id
+    }));
+  }
+  if (section.kind === "conditions") {
+    return parsed.concerns.flatMap((concern) => {
+      const assertion = currentAssertion(concern);
+      if (!assertion) return [];
+      return [
+        {
+          ...base,
+          label: "Condition",
+          value: [
+            assertion.text,
+            `Status: ${concern.clinicalStatus}`,
+            `Verification: ${assertion.verificationStatus}`,
+            assertion.note,
+            (section.requireCoding ?? true) && !assertion.coding?.length ? "Coding required" : void 0
+          ].filter(Boolean).join("; "),
+          groupId: concern.concernId,
+          code: assertion.coding?.find((coding) => coding.primary) ?? assertion.coding?.[0]
+        }
+      ];
+    });
+  }
+  const assessment = section.kind === "plan" ? {
+    concerns: [],
+    items: [],
+    orders: parsed.orders
+  } : parsed;
+  const observations = [];
+  for (const item of assessment.items) {
+    const assertion = [...assessment.concerns, ...externalConcerns].find((concern) => concern.concernId === item.concernId)?.assertions.find((assertion2) => assertion2.id === item.assertionId);
+    if (assertion)
+      observations.push({
+        ...base,
+        label: "Assessment",
+        value: [
+          assertion.text,
+          `Verification: ${assertion.verificationStatus}`,
+          assertion.note,
+          item.note,
+          (section.requireCoding ?? true) && !assertion.coding?.length ? "Coding required" : void 0
+        ].filter(Boolean).join("; "),
+        groupId: item.concernId,
+        code: assertion.coding?.find((coding) => coding.primary) ?? assertion.coding?.[0]
+      });
+  }
+  for (const order of assessment.orders) {
+    observations.push({
+      ...base,
+      label: `${order.type} order`,
+      value: [
+        order.display,
+        order.detail,
+        order.priority,
+        order.timing,
+        order.indication,
+        order.bodySite,
+        order.referTo,
+        order.notes,
+        (section.requireCoding ?? true) && !order.code ? "Coding required" : void 0
+      ].filter(Boolean).join("; "),
+      groupId: order.concernId ?? order.orderId,
+      code: order.code ? {
+        system: order.code.codetype,
+        code: order.code.fullcode,
+        display: order.display
+      } : void 0
+    });
+  }
+  return observations;
+}
+function createEncounterSnapshot(definition, responses) {
+  const errors = validateEncounterResponses(definition, responses);
+  const externalConcerns = getEncounterConcerns(definition, responses);
+  const observations = [];
+  for (const section of definition.sections) {
+    if (section.kind === "narrative" || section.narrative) {
+      const fieldId = getEncounterFieldId(section.id);
+      const answer = responses[fieldId]?.answer;
+      if (nonempty2(answer))
+        observations.push({
+          sectionId: section.id,
+          fieldId,
+          label: section.kind === "narrative" ? section.title : `${section.title} narrative`,
+          value: answer
+        });
+    }
+    if (section.kind === "observations") {
+      for (const observation of section.observations ?? []) {
+        const fieldId = getEncounterFieldId(section.id, observation.id);
+        const response = responses[fieldId];
+        const raw = observation.type === "choice" ? selectedValue(response) : response?.answer;
+        if (!nonempty2(raw)) continue;
+        if (observation.type === "choice" && (!observation.options?.includes(raw) || errors.some(
+          (issue) => issue.fieldId === fieldId && issue.code === "invalid-choice"
+        )))
+          continue;
+        const value = observation.type === "number" ? Number(raw) : raw;
+        if (typeof value === "number" && !measurement(value)) continue;
+        observations.push({
+          sectionId: section.id,
+          fieldId,
+          label: observation.label,
+          value,
+          unit: observation.unit,
+          code: observation.code
+        });
+      }
+    } else if (section.kind !== "narrative") {
+      observations.push(
+        ...exportCustom(
+          section,
+          responses[getEncounterFieldId(section.id, "value")]?.answer,
+          externalConcerns
+        )
+      );
+    }
+  }
+  const note = [
+    definition.title,
+    ...definition.sections.flatMap((section) => {
+      const values = observations.filter(
+        (observation) => observation.sectionId === section.id
+      );
+      if (values.length === 0) return [];
+      return [
+        `${section.title}
+${values.map((observation) => {
+          const metadata = [
+            section.kind === "vitals" && observation.groupId && `Reading ${observation.groupId}`,
+            observation.recordedAt,
+            observation.position,
+            observation.site
+          ].filter(Boolean);
+          const unit = observation.unit === "Cel" ? "\xB0C" : observation.unit === "mm[Hg]" ? "mmHg" : observation.unit === "{score}" ? "/10" : observation.unit;
+          return `${observation.label}: ${observation.value}${unit ? ` ${unit}` : ""}${metadata.length ? ` (${metadata.join("; ")})` : ""}`;
+        }).join("\n")}`
+      ];
+    })
+  ].join("\n\n");
+  const snapshot = {
+    definition,
+    responses,
+    observations,
+    note,
+    errors
+  };
+  return globalThis.structuredClone({
+    ...snapshot,
+    mdy: createEncounterMdy(snapshot)
+  });
+}
+
+export { DEFAULT_ENCOUNTER_VISIT_DEFINITION, ENCOUNTER_DOCUMENT_FIELD_ID, EXAMPLE_ENCOUNTER_VISIT_RESPONSES, createEncounterFormDefinition, createEncounterMdy, createEncounterSnapshot, encounterDocumentResponse, getEncounterConcerns, getEncounterDocumentBody, getEncounterFieldId, getEncounterMdyFields, getEncounterSectionFieldId, getEncounterSectionFieldIds, isEncounterDate, parseEncounterAssessment, parseEncounterConditions, parseEncounterMdy, parseEncounterPlan, parseEncounterVitals, refreshEncounterMdyLinks, renderEncounterMdy, updateEncounterDocumentBody, validAssessmentItem, validateEncounterAllergyValue, validateEncounterAssessment, validateEncounterConditions, validateEncounterDefinition, validateEncounterMedicationValue, validateEncounterPlan, validateEncounterResponses, validateEncounterVitals };
+//# sourceMappingURL=chunk-7HFZL5V5.js.map
+//# sourceMappingURL=chunk-7HFZL5V5.js.map