sync: monorepo @ validator 0.1.4 / validation-types 0.1.1

Snapshot of medvertical/records monorepo state, exported via
oss:export-validator. Tracks the npm publication of:

  @records-fhir/validator@0.1.4
  @records-fhir/validation-types@0.1.1

Run npm i @records-fhir/validator@0.1.4 for the matching
distribution. The conformance evidence in conformance-results/
matches the published tarball.

Author: records-bot

packages/validator/CHANGELOG.md

@@ -10,6 +10,34 @@ ship together; package-only changes are noted under each release.
 
 ## [Unreleased]
 
+## [0.1.4] — 2026-05-06
+
+Patch release for the Firely validation triage and public package
+sync.
+
+### Fixes
+
+- Fixed false positives in slice matching for `$this` Coding slices and
+  slice child constraints.
+- Hardened StructureDefinition loading so R4/R5 core definitions and
+  cached package scans do not cross-contaminate validation runs.
+- Tightened unknown-property detection so internal enhancer fields and
+  valid primitive companion fields are not reported as structural
+  errors.
+- Improved terminology parity: display comparisons now ignore
+  case/whitespace-only differences, missing CodeSystem values are
+  warnings, and unvalidated terminology coverage uses stable issue
+  codes.
+- Improved reference parsing for contained references, absolute URLs,
+  versioned references, and Bundle entry contexts.
+
+### Tests
+
+- Added focused regression coverage for StructureDefinition cache
+  versioning, unknown-property walking, slice element matching,
+  terminology issue classification, and reference format/type
+  extraction.
+
 ## [0.1.3] — 2026-05-05
 
 Patch release fixing a public-export gap that shipped in 0.1.2. No

packages/validator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@records-fhir/validator",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Pure-TypeScript FHIR R4/R5/R6 validation engine. Validates resources against StructureDefinitions, terminology, references, and custom rules with no database required.",
   "type": "module",
   "license": "Apache-2.0",
@@ -10,7 +10,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/medvertical/records-fhir-validator.git",
+    "url": "git+https://github.com/medvertical/records-fhir-validator.git",
     "directory": "packages/validator"
   },
   "homepage": "https://github.com/medvertical/records-fhir-validator/tree/main/packages/validator#readme",
@@ -90,7 +90,7 @@
     "pack:dry": "npm pack --dry-run"
   },
   "dependencies": {
-    "@records-fhir/validation-types": "^0.1.0",
+    "@records-fhir/validation-types": "^0.1.1",
     "axios": "^1.10.0",
     "date-fns": "^3.6.0",
     "fhirpath": "^4.8.2",

packages/validator/src/business-rules/validators/__tests__/observation-validators.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { validateObservationStatusValueConsistency } from '../observation-validators';
+
+describe('validateObservationStatusValueConsistency', () => {
+  it('does not warn for final panel observations with component values', async () => {
+    const issues = await validateObservationStatusValueConsistency({
+      resourceType: 'Observation',
+      status: 'final',
+      code: {
+        coding: [{ system: 'http://loinc.org', code: '85354-9' }],
+      },
+      component: [
+        {
+          code: { coding: [{ system: 'http://loinc.org', code: '8480-6' }] },
+          valueQuantity: { value: 112, system: 'http://unitsofmeasure.org', code: 'mm[Hg]' },
+        },
+        {
+          code: { coding: [{ system: 'http://loinc.org', code: '8462-4' }] },
+          valueQuantity: { value: 68, system: 'http://unitsofmeasure.org', code: 'mm[Hg]' },
+        },
+      ],
+    }, 'Observation');
+
+    expect(issues).toEqual([]);
+  });
+
+  it('does not warn when a final observation explains the missing value', async () => {
+    const issues = await validateObservationStatusValueConsistency({
+      resourceType: 'Observation',
+      status: 'final',
+      code: {
+        coding: [{ system: 'http://loinc.org', code: '72166-2' }],
+      },
+      dataAbsentReason: {
+        coding: [{ system: 'http://terminology.hl7.org/CodeSystem/data-absent-reason', code: 'unknown' }],
+      },
+    }, 'Observation');
+
+    expect(issues).toEqual([]);
+  });
+
+  it('still warns for final observations without value, components, or dataAbsentReason', async () => {
+    const issues = await validateObservationStatusValueConsistency({
+      resourceType: 'Observation',
+      status: 'final',
+      code: {
+        coding: [{ system: 'http://loinc.org', code: '72166-2' }],
+      },
+    }, 'Observation');
+
+    expect(issues).toHaveLength(1);
+    expect(issues[0].code).toBe('final-status-no-value');
+  });
+});

packages/validator/src/business-rules/validators/observation-validators.ts

@@ -224,21 +224,7 @@ export async function validateObservationEffectiveDate(resource: any, resourceTy
 export async function validateObservationStatusValueConsistency(resource: any, resourceType: string): Promise<ValidationIssue[]> {
   const issues: ValidationIssue[] = [];
 
-  // Check if observation has status 'final' but no value
-  // Check all possible value[x] types in FHIR Observation
-  const hasValue = !!(
-    resource.valueQuantity ||
-    resource.valueCodeableConcept ||
-    resource.valueString ||
-    resource.valueBoolean ||
-    resource.valueInteger ||
-    resource.valueRange ||
-    resource.valueRatio ||
-    resource.valueSampledData ||
-    resource.valueTime ||
-    resource.valueDateTime ||
-    resource.valuePeriod
-  );
+  const hasValue = hasObservationValue(resource);
 
   if (resource.status === 'final' && !hasValue) {
     issues.push({
@@ -265,3 +251,28 @@ export async function validateObservationStatusValueConsistency(resource: any, r
   return issues;
 }
 
+function hasObservationValue(observation: any): boolean {
+  if (hasValueX(observation) || observation.dataAbsentReason) {
+    return true;
+  }
+
+  return Array.isArray(observation.component) && observation.component.some((component: any) =>
+    hasValueX(component) || component.dataAbsentReason
+  );
+}
+
+function hasValueX(element: any): boolean {
+  return !!(
+    element.valueQuantity ||
+    element.valueCodeableConcept ||
+    element.valueString ||
+    element.valueBoolean ||
+    element.valueInteger ||
+    element.valueRange ||
+    element.valueRatio ||
+    element.valueSampledData ||
+    element.valueTime ||
+    element.valueDateTime ||
+    element.valuePeriod
+  );
+}

packages/validator/src/core/__tests__/profile-loader-utils.test.ts

@@ -122,6 +122,51 @@ describe('loadProfileWithSnapshot', () => {
     expect(mocks.sdLoader.loadProfile).not.toHaveBeenCalled();
   });
 
+  it('does not load core FHIR StructureDefinitions from the target server', async () => {
+    const coreUrl = 'http://hl7.org/fhir/StructureDefinition/Encounter';
+    const loaderSd = makeSD({ id: 'r4-encounter', url: coreUrl, type: 'Encounter', fhirVersion: '4.0.1' } as any);
+    mocks.profileCache.get.mockReturnValue(null);
+    mocks.fhirClient.searchResources.mockResolvedValue({
+      entry: [{ resource: makeSD({ id: 'r5-encounter-from-server', url: coreUrl, type: 'Encounter', fhirVersion: '5.0.0' } as any) }],
+    });
+    mocks.sdLoader.loadProfile.mockResolvedValue(loaderSd);
+
+    const result = await loadProfileWithSnapshot(
+      mocks.sdLoader as any,
+      mocks.profileCache as any,
+      mocks.snapshotGenerator as any,
+      coreUrl,
+      FHIR_VERSION,
+      mocks.fhirClient as any,
+    );
+
+    expect(result).toBe(loaderSd);
+    expect(mocks.fhirClient.searchResources).not.toHaveBeenCalled();
+    expect(mocks.sdLoader.loadProfile).toHaveBeenCalledWith(coreUrl, FHIR_VERSION);
+  });
+
+  it('ignores FHIR client profiles from the wrong FHIR version', async () => {
+    const r5ClientSd = makeSD({ id: 'from-client-r5', fhirVersion: '5.0.0' } as any);
+    const r4LoaderSd = makeSD({ id: 'from-loader-r4', fhirVersion: '4.0.1' } as any);
+    mocks.profileCache.get.mockReturnValue(null);
+    mocks.fhirClient.searchResources.mockResolvedValue({
+      entry: [{ resource: r5ClientSd }],
+    });
+    mocks.sdLoader.loadProfile.mockResolvedValue(r4LoaderSd);
+
+    const result = await loadProfileWithSnapshot(
+      mocks.sdLoader as any,
+      mocks.profileCache as any,
+      mocks.snapshotGenerator as any,
+      PROFILE_URL,
+      FHIR_VERSION,
+      mocks.fhirClient as any,
+    );
+
+    expect(result).toBe(r4LoaderSd);
+    expect(mocks.sdLoader.loadProfile).toHaveBeenCalledWith(PROFILE_URL, FHIR_VERSION);
+  });
+
   it('falls back to loader when FHIR client returns empty bundle', async () => {
     const loaderSd = makeSD({ id: 'from-loader' });
     mocks.profileCache.get.mockReturnValue(null);
@@ -308,4 +353,25 @@ describe('loadProfileForValidation', () => {
     expect(result).toBe(clientSd);
     expect(mocks.sdLoader.loadProfile).not.toHaveBeenCalled();
   });
+
+  it('falls back to loader when FHIR client returns wrong FHIR version', async () => {
+    const r5ClientSd = makeSD({ id: 'from-client-r5', fhirVersion: '5.0.0' } as any);
+    const r4LoaderSd = makeSD({ id: 'from-loader-r4', fhirVersion: '4.0.1' } as any);
+    mocks.fhirClient.searchResources.mockResolvedValue({
+      entry: [{ resource: r5ClientSd }],
+    });
+    mocks.sdLoader.loadProfile.mockResolvedValue(r4LoaderSd);
+
+    const result = await loadProfileForValidation(
+      mocks.sdLoader as any,
+      mocks.snapshotGenerator as any,
+      PROFILE_URL,
+      FHIR_VERSION,
+      undefined,
+      mocks.fhirClient as any,
+    );
+
+    expect(result).toBe(r4LoaderSd);
+    expect(mocks.sdLoader.loadProfile).toHaveBeenCalledWith(PROFILE_URL, FHIR_VERSION);
+  });
 });

packages/validator/src/core/__tests__/sd-loader-cache-version.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { mkdtemp, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { StructureDefinitionLoader } from '../structure-definition-loader';
+import type { StructureDefinition } from '../structure-definition-types';
+import { checkDatabaseCache } from '../sd-loader-db-cache';
+import { setProfileSource } from '../../persistence';
+
+const CORE_URL = 'http://hl7.org/fhir/StructureDefinition/MedicationRequest';
+
+function makeSd(id: string, fhirVersion: string): StructureDefinition {
+  return {
+    resourceType: 'StructureDefinition',
+    id,
+    url: CORE_URL,
+    name: id,
+    status: 'active',
+    kind: 'resource',
+    abstract: false,
+    type: 'MedicationRequest',
+    fhirVersion,
+    snapshot: {
+      element: [{ id: 'MedicationRequest', path: 'MedicationRequest' }],
+    },
+  } as unknown as StructureDefinition;
+}
+
+async function makeLoader(): Promise<{ loader: StructureDefinitionLoader; dir: string }> {
+  const dir = await mkdtemp(join(tmpdir(), 'records-sd-loader-'));
+  const loader = new StructureDefinitionLoader(dir, null, { autoDownload: false });
+  await loader.waitForInitialization();
+  return { loader, dir };
+}
+
+beforeEach(() => {
+  setProfileSource({});
+});
+
+afterEach(() => {
+  setProfileSource({});
+});
+
+describe('StructureDefinitionLoader versioned cache', () => {
+  it('does not return bare or R5 cached profiles for R4 batch loading', async () => {
+    const { loader, dir } = await makeLoader();
+    try {
+      const r4 = makeSd('medicationrequest-r4', '4.0.1');
+      const r5 = makeSd('medicationrequest-r5', '5.0.0');
+
+      (loader as any).cache.set(CORE_URL, r5);
+      (loader as any).cache.set(`${CORE_URL}:R5`, r5);
+
+      const r4Result = await loader.loadProfilesBatch([CORE_URL], 'R4');
+      expect((r4Result.get(CORE_URL) as any)?.fhirVersion).toMatch(/^4\./);
+
+      (loader as any).cache.set(`${CORE_URL}:R4`, r4);
+      const r4Hit = await loader.loadProfilesBatch([CORE_URL], 'R4');
+      expect(r4Hit.get(CORE_URL)?.id).toBe('medicationrequest-r4');
+
+      const r5Hit = await loader.loadProfilesBatch([CORE_URL], 'R5');
+      expect(r5Hit.get(CORE_URL)?.id).toBe('medicationrequest-r5');
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('stores ProfileSource warmup entries under their FHIR version family', async () => {
+    const r5 = makeSd('medicationrequest-r5', '5.0.0');
+    setProfileSource({
+      async loadAllForWarmup() {
+        return new Map([
+          [CORE_URL, { canonicalUrl: CORE_URL, profile: r5 }],
+        ]);
+      },
+    });
+
+    const { loader, dir } = await makeLoader();
+    try {
+      const r4Result = await loader.loadProfilesBatch([CORE_URL], 'R4');
+      expect((r4Result.get(CORE_URL) as any)?.fhirVersion).toMatch(/^4\./);
+
+      const r5Hit = await loader.loadProfilesBatch([CORE_URL], 'R5');
+      expect(r5Hit.get(CORE_URL)?.id).toBe('medicationrequest-r5');
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('checkDatabaseCache', () => {
+  it('rejects ProfileSource entries from the wrong FHIR version', async () => {
+    const r5 = makeSd('medicationrequest-r5', '5.0.0');
+    setProfileSource({
+      async findByUrl() {
+        return r5;
+      },
+    });
+
+    await expect(checkDatabaseCache(CORE_URL, new Set(), 'R4')).resolves.toBeNull();
+    await expect(checkDatabaseCache(CORE_URL, new Set(), 'R5')).resolves.toBe(r5);
+  });
+});