fhir-resource-diff 0.2.0

package/dist/chunk-2UUKQJDB.js

@@ -0,0 +1,2318 @@
+// src/core/fhir-version.ts
+var SUPPORTED_FHIR_VERSIONS = ["R4", "R4B", "R5"];
+var DEFAULT_FHIR_VERSION = "R4";
+var VERSION_STRING_MAP = /* @__PURE__ */ new Map([
+  ["4.0.0", "R4"],
+  ["4.0.1", "R4"],
+  ["4.3.0", "R4B"],
+  ["4.3.0-snapshot1", "R4B"],
+  ["5.0.0", "R5"],
+  ["5.0.0-snapshot1", "R5"],
+  ["5.0.0-ballot", "R5"]
+]);
+function detectFhirVersion(resource) {
+  const versionStr = resource.meta?.fhirVersion;
+  if (typeof versionStr !== "string") return void 0;
+  return VERSION_STRING_MAP.get(versionStr);
+}
+function resolveFhirVersion(explicit, resource) {
+  if (explicit !== void 0) return explicit;
+  return detectFhirVersion(resource) ?? DEFAULT_FHIR_VERSION;
+}
+function fhirVersionLabel(version) {
+  const labels = {
+    R4: "FHIR R4 (v4.0.1)",
+    R4B: "FHIR R4B (v4.3.0)",
+    R5: "FHIR R5 (v5.0.0)"
+  };
+  return labels[version];
+}
+function fhirBaseUrl(version) {
+  return `https://hl7.org/fhir/${version}`;
+}
+function isSupportedFhirVersion(value) {
+  return SUPPORTED_FHIR_VERSIONS.includes(value);
+}
+
+// src/core/resource-registry.ts
+var RESOURCE_REGISTRY = [
+  // foundation
+  {
+    resourceType: "Bundle",
+    category: "foundation",
+    versions: ["R4", "R4B", "R5"],
+    description: "Container for a collection of resources",
+    maturityLevel: "N",
+    useCases: [
+      "Transaction: atomic write of multiple resources to a FHIR server",
+      "Search result set: server response to a search query",
+      "Document: a persistent clinical document (IPS, CCD)",
+      "Message: event notification"
+    ],
+    keyFields: [
+      {
+        name: "type",
+        required: true,
+        note: "document|message|transaction|transaction-response|batch|batch-response|history|searchset|collection|subscription-notification"
+      },
+      {
+        name: "entry[]",
+        required: false,
+        note: "the resources; shape of entry depends on Bundle.type"
+      },
+      {
+        name: "entry[].resource",
+        required: false,
+        note: "the actual resource"
+      },
+      {
+        name: "entry[].request",
+        required: false,
+        note: "for transaction/batch: method + url"
+      },
+      {
+        name: "entry[].response",
+        required: false,
+        note: "for transaction-response/batch-response: status"
+      },
+      {
+        name: "total",
+        required: false,
+        note: "only meaningful for searchset \u2014 total matching count"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "subscription-notification added as a new Bundle type; issues field added for server-reported problems with individual entries"
+    }
+  },
+  {
+    resourceType: "OperationOutcome",
+    category: "foundation",
+    versions: ["R4", "R4B", "R5"],
+    description: "Collection of processing messages (errors, warnings, information)",
+    maturityLevel: "N"
+  },
+  {
+    resourceType: "Parameters",
+    category: "foundation",
+    versions: ["R4", "R4B", "R5"],
+    description: "Operation request/response parameters",
+    maturityLevel: "N"
+  },
+  {
+    resourceType: "Binary",
+    category: "foundation",
+    versions: ["R4", "R4B", "R5"],
+    description: "Raw binary content",
+    maturityLevel: 3
+  },
+  // base
+  {
+    resourceType: "Patient",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "Demographics and administrative information about an individual",
+    maturityLevel: "N",
+    useCases: [
+      "Demographics and identity for individuals receiving healthcare",
+      "Linking clinical data (observations, conditions, encounters) to a person",
+      "Cross-system patient matching and identity resolution"
+    ],
+    keyFields: [
+      {
+        name: "identifier",
+        required: false,
+        note: "MRN, SSN, passport \u2014 systems commonly use multiple"
+      },
+      {
+        name: "name",
+        required: false,
+        note: "HumanName array; use[official] for the primary name"
+      },
+      {
+        name: "birthDate",
+        required: false,
+        note: "FHIR date: YYYY, YYYY-MM, or YYYY-MM-DD"
+      },
+      {
+        name: "gender",
+        required: false,
+        note: "administrative gender: male | female | other | unknown"
+      },
+      {
+        name: "address",
+        required: false,
+        note: "array \u2014 patients may have multiple (home, work, old)"
+      },
+      {
+        name: "telecom",
+        required: false,
+        note: "phone/email array; rank=1 is preferred contact"
+      },
+      {
+        name: "deceased[x]",
+        required: false,
+        note: "boolean or dateTime \u2014 affects active status logic"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "link field added for cross-version Patient links; contact.relationship binding relaxed"
+    }
+  },
+  {
+    resourceType: "Practitioner",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "A person with a formal responsibility in healthcare",
+    maturityLevel: 3,
+    useCases: [
+      "Identifying the author of a clinical note",
+      "Linking prescriptions and orders to a licensed provider",
+      "Directory listings for healthcare professionals"
+    ],
+    keyFields: [
+      {
+        name: "identifier",
+        required: false,
+        note: "NPI (US), provider number \u2014 systems usually require at least one"
+      },
+      {
+        name: "name",
+        required: false,
+        note: "HumanName array"
+      },
+      {
+        name: "qualification[]",
+        required: false,
+        note: "licenses and certifications with issuer and period"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "communication now includes proficiency level"
+    }
+  },
+  {
+    resourceType: "PractitionerRole",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "Roles and specialties a practitioner is authorized to perform",
+    maturityLevel: 2
+  },
+  {
+    resourceType: "Organization",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "A formally recognized grouping of people or organizations",
+    maturityLevel: 3
+  },
+  {
+    resourceType: "Location",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "Physical place where services are provided",
+    maturityLevel: 3
+  },
+  {
+    resourceType: "Endpoint",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "Technical connectivity details for a system",
+    maturityLevel: 2
+  },
+  {
+    resourceType: "RelatedPerson",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "Person related to the patient",
+    maturityLevel: 2
+  },
+  {
+    resourceType: "HealthcareService",
+    category: "base",
+    versions: ["R4", "R4B", "R5"],
+    description: "Details of a healthcare service available at a location",
+    maturityLevel: 2
+  },
+  // clinical
+  {
+    resourceType: "Observation",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Measurements and assertions about a patient or subject",
+    maturityLevel: "N",
+    useCases: [
+      "Lab results: glucose, HbA1c, CBC panels, lipid panels",
+      "Vital signs: blood pressure, heart rate, BMI, oxygen saturation",
+      "Clinical scores, assessment findings, and survey answers"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "registered|preliminary|final|amended|corrected|cancelled|entered-in-error|unknown"
+      },
+      {
+        name: "code",
+        required: true,
+        note: "what was observed \u2014 LOINC (preferred), SNOMED, local codes"
+      },
+      {
+        name: "subject",
+        required: true,
+        note: "usually Patient; can be Group, Device, or Location"
+      },
+      {
+        name: "effective[x]",
+        required: false,
+        note: "when the observation was made \u2014 dateTime or Period"
+      },
+      {
+        name: "value[x]",
+        required: false,
+        note: "the result \u2014 Quantity, CodeableConcept, string, boolean, integer, Range, Ratio, SampledData, time, dateTime, Period"
+      },
+      {
+        name: "component[]",
+        required: false,
+        note: "for panel observations; each component has its own code + value[x] (e.g. systolic + diastolic for BP)"
+      },
+      {
+        name: "referenceRange",
+        required: false,
+        note: "low/high bounds for interpreting Quantity values"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "bodyStructure field added (replaces bodySite extension); subject broadens to support more reference targets; triggeredBy added for derived observations"
+    }
+  },
+  {
+    resourceType: "Condition",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Detailed information about a clinical condition or diagnosis",
+    maturityLevel: 3,
+    useCases: [
+      "Problem list entries: active chronic conditions",
+      "Encounter diagnoses: the reason care was provided",
+      "Past medical history and resolved conditions"
+    ],
+    keyFields: [
+      {
+        name: "clinicalStatus",
+        required: false,
+        note: "CodeableConcept \u2014 active|recurrence|relapse|inactive|remission|resolved"
+      },
+      {
+        name: "verificationStatus",
+        required: false,
+        note: "CodeableConcept \u2014 unconfirmed|provisional|differential|confirmed|refuted|entered-in-error"
+      },
+      {
+        name: "code",
+        required: false,
+        note: "the diagnosis (SNOMED, ICD-10, local) \u2014 surprisingly not required in base spec"
+      },
+      {
+        name: "subject",
+        required: true,
+        note: "the patient"
+      },
+      {
+        name: "onset[x]",
+        required: false,
+        note: "when the condition started \u2014 dateTime, Age, Period, Range, string"
+      },
+      {
+        name: "abatement[x]",
+        required: false,
+        note: "when it resolved \u2014 same type choices as onset[x]"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "participant added (who was involved); stage moved to backbone element; encounter reference added directly to resource"
+    }
+  },
+  {
+    resourceType: "Encounter",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "An interaction during which services are provided",
+    maturityLevel: 2,
+    useCases: [
+      "Inpatient admission and discharge records",
+      "Outpatient visits and office appointments",
+      "Emergency department presentations"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "R4/R4B: planned|arrived|triaged|in-progress|onleave|finished|cancelled|... R5: planned|in-progress|on-hold|discharged|completed|cancelled|..."
+      },
+      {
+        name: "class",
+        required: true,
+        note: "R4/R4B: Coding (AMB=ambulatory, IMP=inpatient, EMER=emergency) R5: renamed to class and made CodeableConcept"
+      },
+      {
+        name: "subject",
+        required: true,
+        note: "the patient"
+      },
+      {
+        name: "period",
+        required: false,
+        note: "start and end datetime of the encounter"
+      },
+      {
+        name: "participant[]",
+        required: false,
+        note: "practitioners involved (type + individual reference)"
+      },
+      {
+        name: "diagnosis[]",
+        required: false,
+        note: "conditions and procedures linked to this encounter"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "class changed from Coding to CodeableConcept (CodeableReference); status values reworked; hospitalization renamed to admission; reason now a CodeableReference instead of CodeableConcept"
+    }
+  },
+  {
+    resourceType: "Procedure",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "An action performed on or for a patient",
+    maturityLevel: 3,
+    useCases: [
+      "Surgical procedures and interventions",
+      "Therapeutic procedures (dialysis, chemotherapy, physical therapy)",
+      "Diagnostic procedures (biopsy, colonoscopy)"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "preparation|in-progress|not-done|on-hold|stopped|completed|entered-in-error|unknown"
+      },
+      {
+        name: "code",
+        required: false,
+        note: "what was performed (SNOMED, CPT, local)"
+      },
+      {
+        name: "subject",
+        required: true,
+        note: "the patient"
+      },
+      {
+        name: "performed[x]",
+        required: false,
+        note: "when \u2014 dateTime, Period, string, Age, Range"
+      },
+      {
+        name: "report[]",
+        required: false,
+        note: "linked DiagnosticReport results"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "recorded field added; report made CodeableReference; performer uses new Actor type"
+    }
+  },
+  {
+    resourceType: "AllergyIntolerance",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Allergy or intolerance and its clinical consequences",
+    maturityLevel: 3,
+    useCases: [
+      "Medication allergies for prescribing safety checks",
+      "Food and environmental allergen records",
+      "Adverse reaction history"
+    ],
+    keyFields: [
+      {
+        name: "clinicalStatus",
+        required: false,
+        note: "CodeableConcept \u2014 active|inactive|resolved"
+      },
+      {
+        name: "verificationStatus",
+        required: false,
+        note: "CodeableConcept \u2014 unconfirmed|confirmed|refuted|entered-in-error"
+      },
+      {
+        name: "type",
+        required: false,
+        note: "allergy | intolerance"
+      },
+      {
+        name: "code",
+        required: false,
+        note: "the allergen (RxNorm for drugs, SNOMED for substances)"
+      },
+      {
+        name: "patient",
+        required: true,
+        note: "required (R4/R4B) renamed to subject in R5"
+      },
+      {
+        name: "reaction[]",
+        required: false,
+        note: "manifestation descriptions and severity"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "patient renamed to subject (breaking rename); participant added"
+    }
+  },
+  {
+    resourceType: "MedicationRequest",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Order or request for a medication",
+    maturityLevel: 3,
+    useCases: [
+      "Prescriptions from a prescriber to a pharmacy",
+      "Medication orders within inpatient care",
+      "Medication plans in chronic disease management"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "active|on-hold|cancelled|completed|entered-in-error|stopped|draft|unknown"
+      },
+      {
+        name: "intent",
+        required: true,
+        note: "proposal|plan|order|original-order|reflex-order|filler-order|instance-order|option"
+      },
+      {
+        name: "medication[x]",
+        required: true,
+        note: "reference to Medication resource or CodeableConcept \u2014 R5 uses CodeableReference"
+      },
+      {
+        name: "subject",
+        required: true,
+        note: "the patient"
+      },
+      {
+        name: "authoredOn",
+        required: false,
+        note: "when the prescription was written"
+      },
+      {
+        name: "dosageInstruction[]",
+        required: false,
+        note: "timing, route, dose \u2014 highly structured but verbose"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "medication[x] changed to CodeableReference; statusChanged added; informationSource added; renderedDosageInstruction added (human-readable summary)"
+    }
+  },
+  {
+    resourceType: "MedicationStatement",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Record of medication use",
+    maturityLevel: 3
+  },
+  {
+    resourceType: "DiagnosticReport",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Findings and interpretation of diagnostic investigations",
+    maturityLevel: 3,
+    useCases: [
+      "Lab report: a set of Observation results with interpretation",
+      "Radiology report: imaging study findings",
+      "Pathology report: tissue examination results"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "registered|partial|preliminary|final|amended|corrected|appended|cancelled|entered-in-error"
+      },
+      {
+        name: "code",
+        required: true,
+        note: "the type of report (LOINC panel code, local code)"
+      },
+      {
+        name: "subject",
+        required: false,
+        note: "the patient (technically optional in base spec)"
+      },
+      {
+        name: "result[]",
+        required: false,
+        note: "references to Observation resources in the report"
+      },
+      {
+        name: "conclusion",
+        required: false,
+        note: "free-text clinical interpretation"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "study replaces imagingStudy; note added; composition added for structured reports"
+    }
+  },
+  {
+    resourceType: "Immunization",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Immunization event record",
+    maturityLevel: 3,
+    useCases: [
+      "Vaccination records for immunization history",
+      "Reporting immunizations to public health registries",
+      "Immunization forecasting input"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "completed | entered-in-error | not-done"
+      },
+      {
+        name: "vaccineCode",
+        required: true,
+        note: "the vaccine administered (CVX codes in US, SNOMED)"
+      },
+      {
+        name: "patient",
+        required: true,
+        note: "the patient"
+      },
+      {
+        name: "occurrence[x]",
+        required: true,
+        note: "when administered \u2014 dateTime or string"
+      },
+      {
+        name: "lotNumber",
+        required: false,
+        note: "manufacturer lot for traceability"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "informationSource added; basedOn added for linking to immunization recommendations"
+    }
+  },
+  {
+    resourceType: "CarePlan",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Plan of care for a patient",
+    maturityLevel: 2
+  },
+  {
+    resourceType: "CareTeam",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Participants in coordinated care for a patient",
+    maturityLevel: 2
+  },
+  {
+    resourceType: "ServiceRequest",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Record of a request for a service",
+    maturityLevel: 2,
+    useCases: [
+      "Referral from a GP to a specialist",
+      "Lab test order (precedes DiagnosticReport)",
+      "Imaging order (precedes ImagingStudy)"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "draft|active|on-hold|revoked|completed|entered-in-error|unknown"
+      },
+      {
+        name: "intent",
+        required: true,
+        note: "proposal|plan|directive|order|original-order|reflex-order|filler-order|instance-order|option"
+      },
+      {
+        name: "code",
+        required: false,
+        note: "what is being requested"
+      },
+      {
+        name: "subject",
+        required: true,
+        note: "the patient"
+      },
+      {
+        name: "requester",
+        required: false,
+        note: "who is ordering"
+      },
+      {
+        name: "performer[]",
+        required: false,
+        note: "who should fulfill the request"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "code changed to CodeableReference; bodyStructure added; focus added"
+    }
+  },
+  {
+    resourceType: "DocumentReference",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Reference to a document",
+    maturityLevel: 3,
+    useCases: [
+      "Clinical notes (progress notes, discharge summaries, op reports)",
+      "Scanned or external documents attached to a patient record",
+      "CCDA and structured clinical documents"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "current | superseded | entered-in-error"
+      },
+      {
+        name: "type",
+        required: false,
+        note: "document type (LOINC document codes)"
+      },
+      {
+        name: "subject",
+        required: false,
+        note: "the patient"
+      },
+      {
+        name: "content[]",
+        required: true,
+        note: "the document itself \u2014 attachment with URL or base64 data"
+      },
+      {
+        name: "context",
+        required: false,
+        note: "encounter, period, and clinical setting"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "docStatus made more prominent; attester replaces author for formal attestation; version added; basedOn added"
+    }
+  },
+  {
+    resourceType: "Consent",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Record of a consent decision",
+    maturityLevel: 2
+  },
+  {
+    resourceType: "Goal",
+    category: "clinical",
+    versions: ["R4", "R4B", "R5"],
+    description: "Desired outcome for a patient",
+    maturityLevel: 2
+  },
+  // financial
+  {
+    resourceType: "Claim",
+    category: "financial",
+    versions: ["R4", "R4B", "R5"],
+    description: "Request for payment for products and/or services",
+    maturityLevel: 2
+  },
+  {
+    resourceType: "Coverage",
+    category: "financial",
+    versions: ["R4", "R4B", "R5"],
+    description: "Insurance or medical plan details",
+    maturityLevel: 2,
+    useCases: [
+      "Insurance plan and subscriber information for claims processing",
+      "Prior authorization eligibility checks",
+      "Patient cost-sharing determination"
+    ],
+    keyFields: [
+      {
+        name: "status",
+        required: true,
+        note: "active | cancelled | draft | entered-in-error"
+      },
+      {
+        name: "beneficiary",
+        required: true,
+        note: "the patient covered"
+      },
+      {
+        name: "payor[]",
+        required: true,
+        note: "the insurance organization(s)"
+      },
+      {
+        name: "class[]",
+        required: false,
+        note: "plan, group, and subgroup identifiers"
+      }
+    ],
+    versionNotes: {
+      "R4B\u2192R5": "kind field added (insurance|self-pay|other); paymentBy added for cost-sharing parties"
+    }
+  },
+  {
+    resourceType: "ExplanationOfBenefit",
+    category: "financial",
+    versions: ["R4", "R4B", "R5"],
+    description: "Processed claim adjudication details",
+    maturityLevel: 2
+  },
+  // specialized
+  {
+    resourceType: "Questionnaire",
+    category: "specialized",
+    versions: ["R4", "R4B", "R5"],
+    description: "Structured set of questions",
+    maturityLevel: 3
+  },
+  {
+    resourceType: "QuestionnaireResponse",
+    category: "specialized",
+    versions: ["R4", "R4B", "R5"],
+    description: "Responses to a questionnaire",
+    maturityLevel: 3
+  },
+  {
+    resourceType: "ResearchStudy",
+    category: "specialized",
+    versions: ["R4", "R4B", "R5"],
+    description: "Investigation and analysis plan",
+    maturityLevel: 1
+  },
+  // conformance
+  {
+    resourceType: "CapabilityStatement",
+    category: "conformance",
+    versions: ["R4", "R4B", "R5"],
+    description: "Server capability description",
+    maturityLevel: "N"
+  },
+  {
+    resourceType: "StructureDefinition",
+    category: "conformance",
+    versions: ["R4", "R4B", "R5"],
+    description: "Definition of a FHIR structure (resource or data type)",
+    maturityLevel: "N"
+  },
+  {
+    resourceType: "ValueSet",
+    category: "conformance",
+    versions: ["R4", "R4B", "R5"],
+    description: "Set of coded values",
+    maturityLevel: "N"
+  },
+  {
+    resourceType: "CodeSystem",
+    category: "conformance",
+    versions: ["R4", "R4B", "R5"],
+    description: "Definition of a code system",
+    maturityLevel: "N"
+  }
+];
+function getResourceInfo(resourceType) {
+  return RESOURCE_REGISTRY.find((r) => r.resourceType === resourceType);
+}
+function getResourceDocUrl(resourceType, version) {
+  return `${fhirBaseUrl(version ?? DEFAULT_FHIR_VERSION)}/${resourceType.toLowerCase()}.html`;
+}
+function isKnownResourceType(resourceType, version) {
+  const info = getResourceInfo(resourceType);
+  if (!info) return false;
+  if (version === void 0) return true;
+  return info.versions.includes(version);
+}
+function listResourceTypes(filters) {
+  if (!filters) return RESOURCE_REGISTRY;
+  return RESOURCE_REGISTRY.filter((r) => {
+    if (filters.version !== void 0 && !r.versions.includes(filters.version)) {
+      return false;
+    }
+    if (filters.category !== void 0 && r.category !== filters.category) {
+      return false;
+    }
+    return true;
+  });
+}
+
+// src/core/parse.ts
+function isFhirResource(value) {
+  return typeof value === "object" && value !== null && "resourceType" in value && typeof value.resourceType === "string";
+}
+function parseJson(input) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (e) {
+    const message = e instanceof SyntaxError ? e.message : "Invalid JSON";
+    return { success: false, error: message };
+  }
+  if (!isFhirResource(parsed)) {
+    return { success: false, error: "Missing or invalid resourceType" };
+  }
+  return { success: true, resource: parsed };
+}
+
+// src/core/rules/walk.ts
+var PROTOTYPE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function walkResource(resource, visitor) {
+  walkObject(resource, "", visitor);
+}
+function walkObject(obj, prefix, visitor) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (PROTOTYPE_KEYS.has(key)) continue;
+    if (value === null || value === void 0) continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    visitor(path, key, value, obj);
+    if (Array.isArray(value)) {
+      walkArray(value, path, visitor);
+    } else if (typeof value === "object") {
+      walkObject(value, path, visitor);
+    }
+  }
+}
+function walkArray(arr, prefix, visitor) {
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item === null || item === void 0) continue;
+    const path = `${prefix}[${i}]`;
+    if (Array.isArray(item)) {
+      walkArray(item, path, visitor);
+    } else if (typeof item === "object") {
+      walkObject(item, path, visitor);
+    }
+  }
+}
+
+// src/core/profile-registry.ts
+var KNOWN_PROFILES = [
+  // FHIR base profiles (defined in the spec itself)
+  {
+    canonical: "http://hl7.org/fhir/StructureDefinition/vitalsigns",
+    name: "Vital Signs",
+    igShort: "FHIR Base",
+    ig: "HL7 FHIR Base Specification",
+    docUrl: "https://hl7.org/fhir/R4/vitalsigns.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/StructureDefinition/bodyweight",
+    name: "Body Weight",
+    igShort: "FHIR Base",
+    ig: "HL7 FHIR Base Specification",
+    docUrl: "https://hl7.org/fhir/R4/bodyweight.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/StructureDefinition/heartrate",
+    name: "Heart Rate",
+    igShort: "FHIR Base",
+    ig: "HL7 FHIR Base Specification",
+    docUrl: "https://hl7.org/fhir/R4/heartrate.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/StructureDefinition/bp",
+    name: "Blood Pressure",
+    igShort: "FHIR Base",
+    ig: "HL7 FHIR Base Specification",
+    docUrl: "https://hl7.org/fhir/R4/bp.html"
+  },
+  // IPS
+  {
+    canonical: "http://hl7.org/fhir/uv/ips/StructureDefinition/Bundle-uv-ips",
+    name: "IPS Bundle",
+    igShort: "IPS",
+    ig: "International Patient Summary",
+    docUrl: "https://hl7.org/fhir/uv/ips/StructureDefinition-Bundle-uv-ips.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/uv/ips/StructureDefinition/Patient-uv-ips",
+    name: "IPS Patient",
+    igShort: "IPS",
+    ig: "International Patient Summary",
+    docUrl: "https://hl7.org/fhir/uv/ips/StructureDefinition-Patient-uv-ips.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/uv/ips/StructureDefinition/Composition-uv-ips",
+    name: "IPS Composition",
+    igShort: "IPS",
+    ig: "International Patient Summary",
+    docUrl: "https://hl7.org/fhir/uv/ips/StructureDefinition-Composition-uv-ips.html"
+  },
+  // US Core (selected high-traffic profiles)
+  {
+    canonical: "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient",
+    name: "US Core Patient",
+    igShort: "US Core",
+    ig: "US Core Implementation Guide",
+    docUrl: "https://hl7.org/fhir/us/core/StructureDefinition-us-core-patient.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/us/core/StructureDefinition/us-core-observation-lab",
+    name: "US Core Laboratory Result Observation",
+    igShort: "US Core",
+    ig: "US Core Implementation Guide",
+    docUrl: "https://hl7.org/fhir/us/core/StructureDefinition-us-core-observation-lab.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/us/core/StructureDefinition/us-core-condition",
+    name: "US Core Condition",
+    igShort: "US Core",
+    ig: "US Core Implementation Guide",
+    docUrl: "https://hl7.org/fhir/us/core/StructureDefinition-us-core-condition.html"
+  },
+  {
+    canonical: "http://hl7.org/fhir/us/core/StructureDefinition/us-core-medicationrequest",
+    name: "US Core MedicationRequest",
+    igShort: "US Core",
+    ig: "US Core Implementation Guide",
+    docUrl: "https://hl7.org/fhir/us/core/StructureDefinition-us-core-medicationrequest.html"
+  }
+];
+var PROFILE_NAMESPACES = [
+  // IPS
+  {
+    prefix: "http://hl7.org/fhir/uv/ips/",
+    igShort: "IPS",
+    ig: "International Patient Summary",
+    igUrl: "https://hl7.org/fhir/uv/ips/"
+  },
+  // US Core
+  {
+    prefix: "http://hl7.org/fhir/us/core/",
+    igShort: "US Core",
+    ig: "US Core Implementation Guide",
+    igUrl: "https://hl7.org/fhir/us/core/"
+  },
+  // AU Base
+  {
+    prefix: "http://hl7.org.au/fhir/StructureDefinition/",
+    igShort: "AU Base",
+    ig: "AU Base Implementation Guide",
+    igUrl: "https://build.fhir.org/ig/hl7au/au-fhir-base/"
+  },
+  // AU Core
+  {
+    prefix: "http://hl7.org.au/fhir/core/",
+    igShort: "AU Core",
+    ig: "AU Core Implementation Guide",
+    igUrl: "https://build.fhir.org/ig/hl7au/au-fhir-core/"
+  },
+  // mCode
+  {
+    prefix: "http://hl7.org/fhir/us/mcode/",
+    igShort: "mCode",
+    ig: "minimal Common Oncology Data Elements",
+    igUrl: "https://hl7.org/fhir/us/mcode/"
+  },
+  // QI Core
+  {
+    prefix: "http://hl7.org/fhir/us/qicore/",
+    igShort: "QI Core",
+    ig: "QI Core Implementation Guide",
+    igUrl: "https://hl7.org/fhir/us/qicore/"
+  },
+  // CARIN Blue Button
+  {
+    prefix: "http://hl7.org/fhir/us/carin-bb/",
+    igShort: "CARIN BB",
+    ig: "CARIN Blue Button Implementation Guide",
+    igUrl: "https://hl7.org/fhir/us/carin-bb/"
+  },
+  // Da Vinci
+  {
+    prefix: "http://hl7.org/fhir/us/davinci-",
+    igShort: "Da Vinci",
+    ig: "Da Vinci Implementation Guides",
+    igUrl: "https://confluence.hl7.org/display/DVP"
+  },
+  // SMART App Launch
+  {
+    prefix: "http://hl7.org/fhir/smart-app-launch/",
+    igShort: "SMART",
+    ig: "SMART App Launch",
+    igUrl: "https://hl7.org/fhir/smart-app-launch/"
+  },
+  // FHIR Base profiles
+  {
+    prefix: "http://hl7.org/fhir/StructureDefinition/",
+    igShort: "FHIR Base",
+    ig: "HL7 FHIR Base Specification",
+    igUrl: "https://hl7.org/fhir/R4/profiling.html"
+  }
+];
+var CANONICAL_URL_PATTERN = /^https?:\/\/.+/;
+var URN_PATTERN = /^urn:.+/;
+function isValidCanonicalUrl(url) {
+  return CANONICAL_URL_PATTERN.test(url) || URN_PATTERN.test(url);
+}
+function lookupProfile(canonical) {
+  return KNOWN_PROFILES.find((p) => p.canonical === canonical);
+}
+function lookupProfileNamespace(canonical) {
+  return PROFILE_NAMESPACES.find((ns) => canonical.startsWith(ns.prefix));
+}
+
+// src/core/rules/id-format.ts
+var FHIR_ID_PATTERN = /^[A-Za-z0-9\-.]{1,64}$/;
+var idFormatRule = {
+  id: "fhir-id-format",
+  description: "FHIR id values must match [A-Za-z0-9\\-.]{1,64}",
+  check(resource, _version) {
+    const findings = [];
+    walkResource(resource, (path, key, value) => {
+      if (key !== "id") return;
+      if (typeof value !== "string") return;
+      if (!FHIR_ID_PATTERN.test(value)) {
+        findings.push({
+          path,
+          message: `Invalid FHIR id '${value}': must match [A-Za-z0-9\\-.]{1,64}`,
+          severity: "warning",
+          ruleId: "fhir-id-format"
+        });
+      }
+    });
+    return findings;
+  }
+};
+
+// src/core/rules/date-format.ts
+var FHIR_DATE_PATTERN = /^\d{4}(-\d{2}(-\d{2})?)?$/;
+var FHIR_DATETIME_PATTERN = /^\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2}))?)?)?$/;
+var FHIR_INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var INSTANT_FIELD_NAMES = /* @__PURE__ */ new Set(["lastUpdated", "issued", "recorded"]);
+var DATETIME_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "authoredOn",
+  "occurrenceDateTime",
+  "onsetDateTime",
+  "abatementDateTime",
+  "performedDateTime"
+]);
+function classifyDateField(key) {
+  if (INSTANT_FIELD_NAMES.has(key)) return "instant";
+  if (DATETIME_FIELD_NAMES.has(key) || key.endsWith("DateTime")) return "dateTime";
+  if (key === "date" || key.endsWith("Date") || key.endsWith("date")) return "date";
+  return null;
+}
+function patternFor(type) {
+  if (type === "instant") return FHIR_INSTANT_PATTERN;
+  if (type === "dateTime") return FHIR_DATETIME_PATTERN;
+  return FHIR_DATE_PATTERN;
+}
+function exampleFor(type) {
+  if (type === "instant") return "e.g. 2024-03-15T10:30:00Z";
+  if (type === "dateTime") return "e.g. 2024-03-15T10:30:00Z or 2024-03-15";
+  return "e.g. 2024, 2024-03, or 2024-03-15";
+}
+var dateFormatRule = {
+  id: "fhir-date-format",
+  description: "FHIR date/dateTime/instant fields must follow the FHIR date format subset",
+  check(resource, _version) {
+    const findings = [];
+    walkResource(resource, (path, key, value) => {
+      const fieldType = classifyDateField(key);
+      if (fieldType === null) return;
+      if (typeof value !== "string") return;
+      if (!patternFor(fieldType).test(value)) {
+        findings.push({
+          path,
+          message: `Invalid FHIR ${fieldType} '${value}' at '${path}': ${exampleFor(fieldType)}`,
+          severity: "warning",
+          ruleId: "fhir-date-format"
+        });
+      }
+    });
+    return findings;
+  }
+};
+
+// src/core/rules/reference-format.ts
+var RELATIVE_REF_PATTERN = /^[A-Z][A-Za-z]+\/[A-Za-z0-9\-.]{1,64}$/;
+var FRAGMENT_REF_PATTERN = /^#.+$/;
+var ABSOLUTE_REF_PATTERN = /^https?:\/\/.+/;
+var URN_REF_PATTERN = /^urn:(uuid|oid):.+$/;
+function isValidReference(ref) {
+  return RELATIVE_REF_PATTERN.test(ref) || FRAGMENT_REF_PATTERN.test(ref) || ABSOLUTE_REF_PATTERN.test(ref) || URN_REF_PATTERN.test(ref);
+}
+var referenceFormatRule = {
+  id: "fhir-reference-format",
+  description: "FHIR reference values must be relative (ResourceType/id), absolute URL, fragment (#id), or URN",
+  check(resource, version) {
+    const findings = [];
+    walkResource(resource, (path, key, value) => {
+      if (key !== "reference") return;
+      if (typeof value !== "string") return;
+      if (!isValidReference(value)) {
+        findings.push({
+          path,
+          message: `Invalid FHIR reference '${value}' at '${path}': expected ResourceType/id, absolute URL, #fragment, or urn:uuid:/urn:oid:`,
+          severity: "warning",
+          ruleId: "fhir-reference-format"
+        });
+        return;
+      }
+      if (version !== void 0 && RELATIVE_REF_PATTERN.test(value)) {
+        const refResourceType = value.split("/")[0];
+        if (refResourceType && !isKnownResourceType(refResourceType, version)) {
+          findings.push({
+            path,
+            message: `Unknown resource type '${refResourceType}' in reference '${value}' for ${version}`,
+            severity: "warning",
+            ruleId: "fhir-reference-format"
+          });
+        }
+      }
+    });
+    return findings;
+  }
+};
+
+// src/core/rules/data/required-field-defs.ts
+var REQUIRED_FIELDS = {
+  Observation: [
+    { field: "status", label: "status" },
+    { field: "code", label: "code" }
+  ],
+  Condition: [
+    { field: "subject", label: "subject" }
+  ],
+  Procedure: [
+    { field: "status", label: "status" },
+    { field: "subject", label: "subject" }
+  ],
+  MedicationRequest: [
+    { field: "status", label: "status" },
+    { field: "intent", label: "intent" },
+    { field: "subject", label: "subject" }
+  ],
+  MedicationAdministration: [
+    { field: "status", label: "status" },
+    { field: "subject", label: "subject" }
+  ],
+  MedicationStatement: [
+    { field: "status", label: "status" },
+    { field: "subject", label: "subject" }
+  ],
+  DiagnosticReport: [
+    { field: "status", label: "status" },
+    { field: "code", label: "code" }
+  ],
+  Encounter: [
+    { field: "status", label: "status", versions: ["R4", "R4B"] },
+    { field: "class", label: "class", versions: ["R4", "R4B"] }
+  ],
+  AllergyIntolerance: [
+    { field: "patient", label: "patient", versions: ["R4", "R4B"] },
+    { field: "subject", label: "subject", versions: ["R5"] }
+  ],
+  Immunization: [
+    { field: "status", label: "status" },
+    { field: "vaccineCode", label: "vaccineCode" },
+    { field: "patient", label: "patient" }
+  ],
+  CarePlan: [
+    { field: "status", label: "status" },
+    { field: "intent", label: "intent" },
+    { field: "subject", label: "subject" }
+  ],
+  ServiceRequest: [
+    { field: "status", label: "status" },
+    { field: "intent", label: "intent" },
+    { field: "subject", label: "subject" }
+  ],
+  Bundle: [
+    { field: "type", label: "type" }
+  ],
+  Composition: [
+    { field: "status", label: "status" },
+    { field: "type", label: "type" },
+    { field: "date", label: "date" },
+    { field: "author", label: "author" }
+  ],
+  DocumentReference: [
+    { field: "status", label: "status" },
+    { field: "content", label: "content" }
+  ],
+  Claim: [
+    { field: "status", label: "status" },
+    { field: "type", label: "type" },
+    { field: "use", label: "use" },
+    { field: "patient", label: "patient" },
+    { field: "provider", label: "provider" }
+  ],
+  ExplanationOfBenefit: [
+    { field: "status", label: "status" },
+    { field: "type", label: "type" },
+    { field: "use", label: "use" },
+    { field: "patient", label: "patient" },
+    { field: "provider", label: "provider" },
+    { field: "insurer", label: "insurer" },
+    { field: "outcome", label: "outcome" }
+  ],
+  Coverage: [
+    { field: "status", label: "status" },
+    { field: "beneficiary", label: "beneficiary" }
+  ],
+  // Organization, Patient, Practitioner — nothing truly required beyond resourceType
+  Organization: [],
+  Patient: [],
+  Practitioner: []
+};
+
+// src/core/rules/required-fields.ts
+var RULE_ID = "fhir-required-fields";
+function resolvePath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function isPresent(value) {
+  if (value === null || value === void 0) return false;
+  if (Array.isArray(value)) return value.length > 0;
+  return true;
+}
+var requiredFieldsRule = {
+  id: RULE_ID,
+  description: "Required fields for common FHIR resource types must be present (curated top ~20 types)",
+  check(resource, version) {
+    const defs = REQUIRED_FIELDS[resource.resourceType];
+    if (defs === void 0) return [];
+    const findings = [];
+    const docUrl = version ? `${fhirBaseUrl(version)}/${resource.resourceType.toLowerCase()}.html` : `https://hl7.org/fhir/${resource.resourceType.toLowerCase()}.html`;
+    for (const def of defs) {
+      if (def.versions !== void 0 && version !== void 0) {
+        if (!def.versions.includes(version)) continue;
+      }
+      if (def.versions !== void 0 && version === void 0) continue;
+      const value = resolvePath(resource, def.field);
+      if (!isPresent(value)) {
+        findings.push({
+          path: def.field,
+          message: `Missing required field '${def.label}' for ${resource.resourceType}`,
+          severity: "warning",
+          ruleId: RULE_ID,
+          docUrl
+        });
+      }
+    }
+    return findings;
+  }
+};
+
+// src/core/rules/data/status-value-defs.ts
+var STATUS_VALUES = {
+  Observation: [
+    {
+      field: "status",
+      values: [
+        "registered",
+        "preliminary",
+        "final",
+        "amended",
+        "corrected",
+        "cancelled",
+        "entered-in-error",
+        "unknown"
+      ]
+    }
+  ],
+  Condition: [
+    {
+      field: "clinicalStatus.coding[].code",
+      values: ["active", "recurrence", "relapse", "inactive", "remission", "resolved"]
+    },
+    {
+      field: "verificationStatus.coding[].code",
+      values: [
+        "unconfirmed",
+        "provisional",
+        "differential",
+        "confirmed",
+        "refuted",
+        "entered-in-error"
+      ]
+    }
+  ],
+  Procedure: [
+    {
+      field: "status",
+      values: [
+        "preparation",
+        "in-progress",
+        "not-done",
+        "on-hold",
+        "stopped",
+        "completed",
+        "entered-in-error",
+        "unknown"
+      ]
+    }
+  ],
+  MedicationRequest: [
+    {
+      field: "status",
+      values: [
+        "active",
+        "on-hold",
+        "ended",
+        "cancelled",
+        "completed",
+        "entered-in-error",
+        "stopped",
+        "draft",
+        "unknown"
+      ]
+    },
+    {
+      field: "intent",
+      values: [
+        "proposal",
+        "plan",
+        "order",
+        "original-order",
+        "reflex-order",
+        "filler-order",
+        "instance-order",
+        "option"
+      ]
+    }
+  ],
+  DiagnosticReport: [
+    {
+      field: "status",
+      values: [
+        "registered",
+        "partial",
+        "preliminary",
+        "modified",
+        "final",
+        "amended",
+        "corrected",
+        "appended",
+        "cancelled",
+        "entered-in-error",
+        "unknown"
+      ]
+    }
+  ],
+  Encounter: [
+    {
+      field: "status",
+      values: [
+        "planned",
+        "arrived",
+        "triaged",
+        "in-progress",
+        "onleave",
+        "finished",
+        "cancelled",
+        "entered-in-error",
+        "unknown"
+      ],
+      versions: ["R4", "R4B"]
+    },
+    {
+      field: "status",
+      values: [
+        "planned",
+        "in-progress",
+        "on-hold",
+        "discharged",
+        "completed",
+        "cancelled",
+        "discontinued",
+        "entered-in-error",
+        "unknown"
+      ],
+      versions: ["R5"]
+    }
+  ],
+  Bundle: [
+    {
+      field: "type",
+      values: [
+        "document",
+        "message",
+        "transaction",
+        "transaction-response",
+        "batch",
+        "batch-response",
+        "history",
+        "searchset",
+        "collection",
+        "subscription-notification"
+      ]
+    }
+  ],
+  AllergyIntolerance: [
+    {
+      field: "clinicalStatus.coding[].code",
+      values: ["active", "inactive", "resolved"]
+    },
+    {
+      field: "verificationStatus.coding[].code",
+      values: ["unconfirmed", "confirmed", "refuted", "entered-in-error"]
+    }
+  ],
+  CarePlan: [
+    {
+      field: "status",
+      values: [
+        "draft",
+        "active",
+        "on-hold",
+        "revoked",
+        "completed",
+        "entered-in-error",
+        "unknown"
+      ]
+    },
+    {
+      field: "intent",
+      values: ["proposal", "plan", "order", "option", "directive"]
+    }
+  ],
+  ServiceRequest: [
+    {
+      field: "status",
+      values: [
+        "draft",
+        "active",
+        "on-hold",
+        "revoked",
+        "completed",
+        "entered-in-error",
+        "unknown"
+      ]
+    },
+    {
+      field: "intent",
+      values: [
+        "proposal",
+        "plan",
+        "directive",
+        "order",
+        "original-order",
+        "reflex-order",
+        "filler-order",
+        "instance-order",
+        "option"
+      ]
+    }
+  ],
+  DocumentReference: [
+    {
+      field: "status",
+      values: ["current", "superseded", "entered-in-error"]
+    }
+  ],
+  Immunization: [
+    {
+      field: "status",
+      values: ["completed", "entered-in-error", "not-done"]
+    }
+  ],
+  Coverage: [
+    {
+      field: "status",
+      values: ["active", "cancelled", "draft", "entered-in-error"]
+    }
+  ],
+  Claim: [
+    {
+      field: "status",
+      values: ["active", "cancelled", "draft", "entered-in-error"]
+    }
+  ],
+  ExplanationOfBenefit: [
+    {
+      field: "status",
+      values: ["active", "cancelled", "draft", "entered-in-error"]
+    },
+    {
+      field: "outcome",
+      values: ["queued", "complete", "error", "partial"]
+    }
+  ]
+};
+
+// src/core/rules/status-values.ts
+var RULE_ID2 = "fhir-status-values";
+function readFieldValues(resource, field) {
+  const CODING_ARRAY_PATTERN = /^(.+)\.coding\[\]\.code$/;
+  const match = CODING_ARRAY_PATTERN.exec(field);
+  if (match !== null) {
+    const parentPath = match[1];
+    if (parentPath === void 0) return [];
+    const parent = resource[parentPath];
+    if (parent === null || parent === void 0 || typeof parent !== "object") {
+      return [];
+    }
+    const codingArray = parent["coding"];
+    if (!Array.isArray(codingArray)) return [];
+    const codes = [];
+    for (const entry of codingArray) {
+      if (entry !== null && typeof entry === "object") {
+        const code = entry["code"];
+        if (typeof code === "string") codes.push(code);
+      }
+    }
+    return codes;
+  }
+  const value = resource[field];
+  if (typeof value === "string") return [value];
+  return [];
+}
+var statusValuesRule = {
+  id: RULE_ID2,
+  description: "Status field values must match the FHIR-required value set for each resource type",
+  check(resource, version) {
+    const defs = STATUS_VALUES[resource.resourceType];
+    if (defs === void 0) return [];
+    const findings = [];
+    for (const def of defs) {
+      if (def.versions !== void 0 && version !== void 0) {
+        if (!def.versions.includes(version)) continue;
+      }
+      const values = readFieldValues(resource, def.field);
+      if (values.length === 0) continue;
+      for (const actual of values) {
+        if (!def.values.includes(actual)) {
+          findings.push({
+            path: def.field.replace(".coding[].code", ""),
+            message: `Invalid value '${actual}' for ${resource.resourceType}.${def.field}. Expected one of: ${def.values.join(", ")}`,
+            severity: "warning",
+            ruleId: RULE_ID2
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// src/core/rules/codeable-concept.ts
+var RULE_ID3 = "fhir-codeable-concept";
+var URI_PREFIXES = ["http://", "https://", "urn:"];
+var KNOWN_CODEABLE_CONCEPT_FIELDS = {
+  Observation: ["code", "valueCodeableConcept", "category"],
+  Condition: ["code", "clinicalStatus", "verificationStatus", "category", "severity"],
+  Procedure: ["code", "category"],
+  MedicationRequest: ["medicationCodeableConcept"],
+  DiagnosticReport: ["code", "category"],
+  AllergyIntolerance: ["code", "clinicalStatus", "verificationStatus", "type", "category"],
+  Immunization: ["vaccineCode"],
+  ServiceRequest: ["code", "category"]
+};
+function isValidUri(value) {
+  return URI_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+function checkCodingEntry(coding, path, findings) {
+  const hasSystem = "system" in coding;
+  const hasCode = "code" in coding;
+  if (hasSystem && !hasCode) {
+    findings.push({
+      path,
+      message: `Coding at '${path}' has 'system' but is missing 'code'`,
+      severity: "warning",
+      ruleId: RULE_ID3
+    });
+    return;
+  }
+  if (hasCode && !hasSystem) {
+    findings.push({
+      path,
+      message: `Coding at '${path}' has 'code' but is missing 'system'`,
+      severity: "warning",
+      ruleId: RULE_ID3
+    });
+    return;
+  }
+  if (!hasSystem && !hasCode) return;
+  const systemVal = coding["system"];
+  const codeVal = coding["code"];
+  if (typeof systemVal === "string" && !isValidUri(systemVal)) {
+    findings.push({
+      path: `${path}.system`,
+      message: `Coding 'system' should be a URI starting with http://, https://, or urn: \u2014 got '${systemVal}'`,
+      severity: "warning",
+      ruleId: RULE_ID3
+    });
+  }
+  if (typeof codeVal === "string" && codeVal.trim() === "") {
+    findings.push({
+      path: `${path}.code`,
+      message: `Coding 'code' must be a non-empty string`,
+      severity: "warning",
+      ruleId: RULE_ID3
+    });
+  }
+}
+var codeableConceptRule = {
+  id: RULE_ID3,
+  description: "Coding and CodeableConcept objects must have correct shape; known CodeableConcept fields must not be plain strings",
+  check(resource, _version) {
+    const findings = [];
+    const knownFields = KNOWN_CODEABLE_CONCEPT_FIELDS[resource.resourceType];
+    if (knownFields !== void 0) {
+      for (const field of knownFields) {
+        const value = resource[field];
+        if (typeof value === "string") {
+          findings.push({
+            path: field,
+            message: `'${field}' should be a CodeableConcept object, not a plain string`,
+            severity: "warning",
+            ruleId: RULE_ID3
+          });
+        }
+      }
+    }
+    walkResource(resource, (path, key, value, parent) => {
+      if (key !== "coding") return;
+      const ccPath = path.endsWith(".coding") ? path.slice(0, -".coding".length) : path;
+      if (!Array.isArray(value)) {
+        findings.push({
+          path,
+          message: `'coding' must be an array`,
+          severity: "warning",
+          ruleId: RULE_ID3
+        });
+        return;
+      }
+      if (value.length === 0 && typeof parent["text"] !== "string") {
+        findings.push({
+          path: ccPath,
+          message: `CodeableConcept has empty 'coding' array and no 'text' \u2014 it carries no meaning`,
+          severity: "warning",
+          ruleId: RULE_ID3
+        });
+        return;
+      }
+      for (let i = 0; i < value.length; i++) {
+        const entry = value[i];
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry)) continue;
+        checkCodingEntry(
+          entry,
+          `${path}[${i}]`,
+          findings
+        );
+      }
+    });
+    return findings;
+  }
+};
+
+// src/core/rules/profile-aware.ts
+var HL7_VALIDATOR_URL = "https://confluence.hl7.org/display/FHIR/Using+the+FHIR+Validator";
+var RULE_ID4 = "fhir-profile-aware";
+var profileAwareRule = {
+  id: RULE_ID4,
+  description: "Validates meta.profile entries and identifies known IGs and profiles",
+  check(resource, _version) {
+    const findings = [];
+    const metaRaw = resource.meta;
+    if (!metaRaw) return findings;
+    const profileField = metaRaw["profile"];
+    if (!Array.isArray(profileField) || profileField.length === 0) return findings;
+    const profileArray = profileField;
+    for (let i = 0; i < profileArray.length; i++) {
+      const entry = profileArray[i];
+      const path = `meta.profile[${i}]`;
+      if (typeof entry !== "string") {
+        findings.push({
+          path,
+          message: "meta.profile entries must be strings",
+          severity: "warning",
+          ruleId: RULE_ID4
+        });
+        continue;
+      }
+      if (!isValidCanonicalUrl(entry)) {
+        findings.push({
+          path,
+          message: `Profile URL "${entry}" is not a valid canonical URL (must be an absolute URI)`,
+          severity: "warning",
+          ruleId: RULE_ID4
+        });
+        continue;
+      }
+      const exactMatch = lookupProfile(entry);
+      if (exactMatch !== void 0) {
+        findings.push({
+          path,
+          message: `Declares ${exactMatch.igShort} profile "${exactMatch.name}" \u2192 ${exactMatch.docUrl}`,
+          severity: "info",
+          docUrl: exactMatch.docUrl,
+          ruleId: RULE_ID4
+        });
+        continue;
+      }
+      const namespaceMatch = lookupProfileNamespace(entry);
+      if (namespaceMatch !== void 0) {
+        findings.push({
+          path,
+          message: `Declares ${namespaceMatch.igShort} profile (${namespaceMatch.ig}) \u2014 for conformance validation load the IG in the HL7 FHIR Validator \u2192 ${namespaceMatch.igUrl}`,
+          severity: "info",
+          docUrl: namespaceMatch.igUrl,
+          ruleId: RULE_ID4
+        });
+        continue;
+      }
+      findings.push({
+        path,
+        message: `Declares profile ${entry} \u2014 for conformance validation use the HL7 FHIR Validator with the relevant IG loaded \u2192 ${HL7_VALIDATOR_URL}`,
+        severity: "info",
+        docUrl: HL7_VALIDATOR_URL,
+        ruleId: RULE_ID4
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/rules/index.ts
+var FORMAT_RULES = [
+  idFormatRule,
+  dateFormatRule,
+  referenceFormatRule
+];
+var STRUCTURAL_RULES = [
+  requiredFieldsRule,
+  statusValuesRule,
+  codeableConceptRule
+];
+var PROFILE_RULES = [profileAwareRule];
+var ALL_RULES = [
+  ...FORMAT_RULES,
+  ...STRUCTURAL_RULES,
+  ...PROFILE_RULES
+];
+function runRules(resource, rules, version) {
+  const findings = [];
+  for (const rule of rules) {
+    findings.push(...rule.check(resource, version));
+  }
+  return findings;
+}
+
+// src/core/validate.ts
+import { z } from "zod";
+var fhirMetaSchema = z.object({
+  versionId: z.string().optional(),
+  lastUpdated: z.string().optional()
+}).passthrough();
+var fhirResourceSchema = z.object({
+  resourceType: z.string().min(1, "resourceType must be a non-empty string"),
+  id: z.string().optional(),
+  meta: fhirMetaSchema.optional()
+}).passthrough();
+function validate(resource, version) {
+  const result = fhirResourceSchema.safeParse(resource);
+  const errors = [];
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      errors.push({
+        path: issue.path.join("."),
+        message: issue.message,
+        severity: "error"
+      });
+    }
+  }
+  if (version !== void 0) {
+    if (!isKnownResourceType(resource.resourceType, version)) {
+      errors.push({
+        path: "resourceType",
+        message: `resourceType '${resource.resourceType}' is not in the known registry for ${version}. This may be valid \u2014 check https://hl7.org/fhir/resourcelist.html`,
+        severity: "warning",
+        docUrl: "https://hl7.org/fhir/resourcelist.html"
+      });
+    }
+    const metaRaw = resource.meta;
+    const metaFhirVersion = metaRaw?.["fhirVersion"];
+    if (typeof metaFhirVersion === "string") {
+      const mappedVersion = VERSION_STRING_MAP.get(metaFhirVersion);
+      if (mappedVersion !== version) {
+        errors.push({
+          path: "meta.fhirVersion",
+          message: `meta.fhirVersion '${metaFhirVersion}' does not match expected version ${version}`,
+          severity: "warning"
+        });
+      }
+    }
+    if (version === "R5") {
+      const textRaw = resource["text"];
+      if (textRaw !== void 0 && textRaw !== null && typeof textRaw === "object") {
+        if ("status" in textRaw && !("div" in textRaw)) {
+          errors.push({
+            path: "text",
+            message: "R5 recommends narrative text with a div element",
+            severity: "info"
+          });
+        }
+      }
+    }
+  }
+  errors.push(...runRules(resource, FORMAT_RULES, version));
+  if (version !== void 0) {
+    errors.push(...runRules(resource, STRUCTURAL_RULES, version));
+  }
+  errors.push(...runRules(resource, PROFILE_RULES, version));
+  const hint = version !== void 0 ? {
+    message: "For full FHIR schema validation, use the official HL7 FHIR Validator",
+    docUrl: "https://confluence.hl7.org/display/FHIR/Using+the+FHIR+Validator"
+  } : void 0;
+  if (errors.length === 0) {
+    return hint !== void 0 ? { valid: true, hint } : { valid: true };
+  }
+  return hint !== void 0 ? { valid: false, errors, hint } : { valid: false, errors };
+}
+
+// src/core/classify.ts
+function classifyChange(left, right) {
+  if (left === void 0) {
+    return "added";
+  }
+  if (right === void 0) {
+    return "removed";
+  }
+  if (typeof left !== typeof right) {
+    return "type-changed";
+  }
+  return "changed";
+}
+
+// src/core/diff.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function shouldIgnorePath(path, ignorePaths) {
+  for (const ignorePath of ignorePaths) {
+    if (ignorePath === path) {
+      return true;
+    }
+    if (ignorePath.endsWith(".*")) {
+      const prefix = ignorePath.slice(0, -2);
+      if (path.startsWith(prefix + ".")) {
+        const rest = path.slice(prefix.length + 1);
+        if (!rest.includes(".") && !rest.includes("[")) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function walkNodes(left, right, path, ignorePaths, entries) {
+  if (shouldIgnorePath(path, ignorePaths)) {
+    return;
+  }
+  const leftObj = left === void 0 && isPlainObject(right) ? {} : left;
+  const rightObj = right === void 0 && isPlainObject(left) ? {} : right;
+  const leftArr = left === void 0 && Array.isArray(right) ? [] : leftObj;
+  const rightArr = right === void 0 && Array.isArray(left) ? [] : rightObj;
+  if (isPlainObject(leftArr) && isPlainObject(rightArr)) {
+    const allKeys = Array.from(
+      /* @__PURE__ */ new Set([...Object.keys(leftArr), ...Object.keys(rightArr)])
+    ).sort();
+    for (const key of allKeys) {
+      const childPath = path === "" ? key : `${path}.${key}`;
+      walkNodes(leftArr[key], rightArr[key], childPath, ignorePaths, entries);
+    }
+    return;
+  }
+  if (Array.isArray(leftArr) && Array.isArray(rightArr)) {
+    const maxLen = Math.max(leftArr.length, rightArr.length);
+    for (let i = 0; i < maxLen; i++) {
+      const childPath = `${path}[${i}]`;
+      walkNodes(leftArr[i], rightArr[i], childPath, ignorePaths, entries);
+    }
+    return;
+  }
+  if (left === void 0 && right === void 0) {
+    return;
+  }
+  if (left === right) {
+    return;
+  }
+  const kind = classifyChange(left, right);
+  const entry = { kind, path };
+  if (left !== void 0) {
+    entry.left = left;
+  }
+  if (right !== void 0) {
+    entry.right = right;
+  }
+  entries.push(entry);
+}
+function diff(left, right, options) {
+  const ignorePaths = options?.ignorePaths ?? [];
+  const entries = [];
+  const allKeys = Array.from(
+    /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])
+  ).sort();
+  for (const key of allKeys) {
+    walkNodes(
+      left[key],
+      right[key],
+      key,
+      ignorePaths,
+      entries
+    );
+  }
+  return {
+    resourceType: left.resourceType,
+    identical: entries.length === 0,
+    entries
+  };
+}
+
+// src/core/utils/path.ts
+var PROTOTYPE_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function getPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object" || Array.isArray(current) || !Object.prototype.hasOwnProperty.call(current, part)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setPath(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (part === void 0 || PROTOTYPE_KEYS2.has(part) || current === null || typeof current !== "object" || Array.isArray(current) || !Object.prototype.hasOwnProperty.call(current, part)) {
+      return;
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  if (lastPart !== void 0 && !PROTOTYPE_KEYS2.has(lastPart) && current !== null && typeof current === "object" && !Array.isArray(current)) {
+    current[lastPart] = value;
+  }
+}
+
+// src/core/normalize.ts
+var DATETIME_WITH_TIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var PROTOTYPE_KEYS3 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function trimStringsDeep(value) {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (Array.isArray(value)) {
+    return value.map(trimStringsDeep);
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      if (PROTOTYPE_KEYS3.has(key)) continue;
+      result[key] = trimStringsDeep(
+        value[key]
+      );
+    }
+    return result;
+  }
+  return value;
+}
+function normalizeDatesDeep(value) {
+  if (typeof value === "string") {
+    if (DATETIME_WITH_TIME_PATTERN.test(value)) {
+      return new Date(value).toISOString();
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(normalizeDatesDeep);
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      if (PROTOTYPE_KEYS3.has(key)) continue;
+      result[key] = normalizeDatesDeep(
+        value[key]
+      );
+    }
+    return result;
+  }
+  return value;
+}
+function sortObjectKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortObjectKeysDeep);
+  }
+  if (value !== null && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      if (PROTOTYPE_KEYS3.has(key)) continue;
+      sorted[key] = sortObjectKeysDeep(
+        value[key]
+      );
+    }
+    return sorted;
+  }
+  return value;
+}
+function sortArrayAtPaths(obj, paths) {
+  for (const path of paths) {
+    const arr = getPath(obj, path);
+    if (Array.isArray(arr)) {
+      const sorted = [...arr].sort((a, b) => {
+        const aStr = JSON.stringify(a);
+        const bStr = JSON.stringify(b);
+        if (aStr < bStr) return -1;
+        if (aStr > bStr) return 1;
+        return 0;
+      });
+      setPath(obj, path, sorted);
+    }
+  }
+}
+function normalize(resource, options) {
+  let result = structuredClone(resource);
+  if (options.trimStrings === true) {
+    result = trimStringsDeep(result);
+  }
+  if (options.normalizeDates === true) {
+    result = normalizeDatesDeep(result);
+  }
+  if (options.sortObjectKeys === true) {
+    result = sortObjectKeysDeep(result);
+  }
+  if (options.sortArrayPaths !== void 0 && options.sortArrayPaths.length > 0) {
+    sortArrayAtPaths(result, options.sortArrayPaths);
+  }
+  return result;
+}
+
+// src/core/version.ts
+var TOOL_VERSION = "0.2.0";
+
+// src/core/summary.ts
+function summarizeDiff(result) {
+  let added = 0;
+  let removed = 0;
+  let changed = 0;
+  let typeChanged = 0;
+  for (const entry of result.entries) {
+    if (entry.kind === "added") added++;
+    else if (entry.kind === "removed") removed++;
+    else if (entry.kind === "changed") changed++;
+    else if (entry.kind === "type-changed") typeChanged++;
+  }
+  return {
+    added,
+    removed,
+    changed,
+    typeChanged,
+    total: added + removed + changed + typeChanged
+  };
+}
+
+// src/core/envelope.ts
+function buildEnvelope(command, fhirVersion, result) {
+  return {
+    tool: "fhir-resource-diff",
+    version: TOOL_VERSION,
+    command,
+    fhirVersion,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    result
+  };
+}
+
+// src/formatters/text.ts
+function formatValue(value) {
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
+  return JSON.stringify(value);
+}
+function formatText(result) {
+  const lines = [];
+  lines.push(`ResourceType: ${result.resourceType}`);
+  if (result.identical) {
+    lines.push("Status: identical");
+    return lines.join("\n");
+  }
+  const count = result.entries.length;
+  lines.push(`Status: ${count} difference(s) found`);
+  const changed = result.entries.filter((e) => e.kind === "changed");
+  const added = result.entries.filter((e) => e.kind === "added");
+  const removed = result.entries.filter((e) => e.kind === "removed");
+  const typeChanged = result.entries.filter((e) => e.kind === "type-changed");
+  if (changed.length > 0) {
+    lines.push("");
+    lines.push("Changed:");
+    for (const entry of changed) {
+      lines.push(
+        `  ${entry.path}: ${formatValue(entry.left)} \u2192 ${formatValue(entry.right)}`
+      );
+    }
+  }
+  if (added.length > 0) {
+    lines.push("");
+    lines.push("Added:");
+    for (const entry of added) {
+      lines.push(`  ${entry.path}`);
+    }
+  }
+  if (removed.length > 0) {
+    lines.push("");
+    lines.push("Removed:");
+    for (const entry of removed) {
+      lines.push(`  ${entry.path}`);
+    }
+  }
+  if (typeChanged.length > 0) {
+    lines.push("");
+    lines.push("Type-changed:");
+    for (const entry of typeChanged) {
+      lines.push(
+        `  ${entry.path}: ${formatValue(entry.left)} \u2192 ${formatValue(entry.right)}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+var SEVERITY_ICON = {
+  error: "\u2717",
+  warning: "\u26A0",
+  info: "\u2139"
+};
+function formatValidationText(result) {
+  const findings = result.valid ? [] : result.errors;
+  const hasErrors = findings.some((e) => e.severity === "error");
+  const hasWarnings = findings.some((e) => e.severity === "warning" || e.severity === "info");
+  const header = hasErrors ? "invalid" : hasWarnings ? "valid (with warnings)" : "valid";
+  const lines = [header];
+  for (const finding of findings) {
+    const icon = SEVERITY_ICON[finding.severity] ?? "\u2717";
+    const pathPrefix = finding.path !== "" ? `${finding.path}: ` : "";
+    lines.push(`  ${icon} ${pathPrefix}${finding.message}`);
+    if (finding.docUrl !== void 0) {
+      lines.push(`    \u2192 ${finding.docUrl}`);
+    }
+  }
+  if (result.hint !== void 0) {
+    if (findings.length > 0) lines.push("");
+    lines.push(`  \u2139 ${result.hint.message}`);
+    lines.push(`    \u2192 ${result.hint.docUrl}`);
+  }
+  return lines.join("\n");
+}
+
+// src/formatters/json.ts
+function formatJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+function formatValidationJson(result) {
+  const output = { valid: result.valid };
+  if (!result.valid) {
+    output["errors"] = result.errors;
+  }
+  if (result.hint !== void 0) {
+    output["hint"] = result.hint;
+  }
+  return JSON.stringify(output, null, 2);
+}
+
+// src/formatters/markdown.ts
+function formatCellValue(value) {
+  if (typeof value === "string") {
+    return `\`"${value}"\``;
+  }
+  return `\`${JSON.stringify(value)}\``;
+}
+function formatMarkdown(result) {
+  const lines = [];
+  lines.push(`## Diff: ${result.resourceType}`);
+  lines.push("");
+  if (result.identical) {
+    lines.push("**Status:** identical");
+    lines.push("");
+    lines.push("| Kind | Path | Left | Right |");
+    lines.push("|------|------|------|-------|");
+    return lines.join("\n");
+  }
+  const count = result.entries.length;
+  lines.push(`**Status:** ${count} difference(s) found`);
+  lines.push("");
+  lines.push("| Kind | Path | Left | Right |");
+  lines.push("|------|------|------|-------|");
+  for (const entry of result.entries) {
+    const path = `\`${entry.path}\``;
+    let left = "";
+    let right = "";
+    if (entry.kind === "changed" || entry.kind === "type-changed") {
+      left = formatCellValue(entry.left);
+      right = formatCellValue(entry.right);
+    }
+    lines.push(`| ${entry.kind} | ${path} | ${left} | ${right} |`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  SUPPORTED_FHIR_VERSIONS,
+  DEFAULT_FHIR_VERSION,
+  VERSION_STRING_MAP,
+  detectFhirVersion,
+  resolveFhirVersion,
+  fhirVersionLabel,
+  fhirBaseUrl,
+  isSupportedFhirVersion,
+  RESOURCE_REGISTRY,
+  getResourceInfo,
+  getResourceDocUrl,
+  isKnownResourceType,
+  listResourceTypes,
+  isFhirResource,
+  parseJson,
+  walkResource,
+  KNOWN_PROFILES,
+  PROFILE_NAMESPACES,
+  isValidCanonicalUrl,
+  lookupProfile,
+  lookupProfileNamespace,
+  FORMAT_RULES,
+  PROFILE_RULES,
+  runRules,
+  validate,
+  classifyChange,
+  diff,
+  normalize,
+  TOOL_VERSION,
+  summarizeDiff,
+  buildEnvelope,
+  formatText,
+  formatValidationText,
+  formatJson,
+  formatValidationJson,
+  formatMarkdown
+};
+//# sourceMappingURL=chunk-2UUKQJDB.js.map