@kenyaemr/esm-pcs-app 5.4.5-pre.1092

package/src/resources/hie-contacts.ts

@@ -0,0 +1,61 @@
+import { type PcsHieDependant } from '../types';
+
+/**
+ * Reads the dependants the HIE lists on a patient's record. The contact array is already in
+ * hand whenever a patient has been pulled from the HIE, so this needs no request.
+ */
+export const getDependentsFromContacts = (patient: any): Array<PcsHieDependant> => {
+  if (!patient?.contact) {
+    return [];
+  }
+
+  return patient.contact.map((contact: any, index: number) => {
+    const relationship = contact.relationship?.[0]?.coding?.[0]?.display || 'Unknown';
+
+    const name =
+      contact.name?.text?.trim() ||
+      `${contact.name?.given?.join(' ') || ''} ${contact.name?.family || ''}`.trim() ||
+      'Unknown';
+
+    const phoneContact = contact.telecom?.find((t) => t.system === 'phone');
+    const phoneNumber = phoneContact?.value || 'N/A';
+
+    const emailContact = contact.telecom?.find((t) => t.system === 'email');
+    const email = emailContact?.value || 'N/A';
+
+    const gender = contact.gender || 'Unknown';
+
+    const birthDateExtension = contact.extension?.find(
+      (ext) => ext.url === 'https://ts.kenya-hie.health/fhir/StructureDefinition/date_of_birth',
+    );
+    const birthDate = birthDateExtension?.valueString || 'Unknown';
+
+    const identifierExtensions = contact.extension?.filter((ext) => ext.url === 'identifiers') || [];
+    const shaNumber = identifierExtensions.find((ext) => ext.valueIdentifier?.type?.coding?.[0]?.code === 'sha-number')
+      ?.valueIdentifier?.value;
+    const shaIdNumber = identifierExtensions.find(
+      (ext) => ext.valueIdentifier?.type?.coding?.[0]?.code === 'sha-id-number',
+    )?.valueIdentifier?.value;
+    const nationalId = identifierExtensions.find(
+      (ext) => ext.valueIdentifier?.type?.coding?.[0]?.code === 'national-id',
+    )?.valueIdentifier?.value;
+    const birthCertificate = identifierExtensions.find(
+      (ext) => ext.valueIdentifier?.type?.coding?.[0]?.code === 'birth-certificate',
+    )?.valueIdentifier?.value;
+
+    return {
+      id: contact.id || `contact-${index}`,
+      name,
+      relationship,
+      phoneNumber,
+      email,
+      gender,
+      birthDate,
+      shaNumber,
+      nationalId,
+      birthCertificate,
+      contactData: contact,
+      shaIdNumber,
+    };
+  });
+};

package/src/resources/identifiers.ts

@@ -0,0 +1,52 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+/** The OpenMRS ID identifier type and the idgen source that mints values for it. */
+export const openmrsId = 'dfacd928-0370-4315-99d7-6ec1c9f7ae76';
+export const openmrsIdSource = 'fb034aac-2353-4940-abe2-7bc94e7c1e71';
+
+/** Mints the next OpenMRS ID from the configured identifier source. */
+export function generateIdentifier(source: string) {
+  const abortController = new AbortController();
+
+  return openmrsFetch<{ identifier: string }>(`${restBaseUrl}/idgen/identifiersource/${source}/identifier`, {
+    headers: { 'Content-Type': 'application/json' },
+    method: 'POST',
+    body: {},
+    signal: abortController.signal,
+  });
+}
+
+/** Reads one identifier off a local (REST) patient record by its type uuid. */
+export const getLocalIdentifierValue = (localPatient: any, typeUuid: string): string | undefined =>
+  localPatient?.identifiers
+    ?.find((identifier: any) => identifier?.identifierType?.uuid === typeUuid)
+    ?.identifier?.trim() || undefined;
+
+/** Strips anything OpenMRS will not accept in a person name. */
+export const sanitizeName = (name: string): string => name?.trim().replace(/[^\w\s'\-\.]/g, '') || '';
+
+export const getNationalIdFromPatient = (
+  patient: fhir.Patient,
+  nationalIdIdentifierTypeUuid?: string,
+): string | null => {
+  const nationalIdIdentifier = patient.identifier?.find((identifier) => {
+    const coding = identifier.type?.coding?.[0];
+    if (!coding) {
+      return false;
+    }
+    const code = coding.code?.trim();
+    const display = coding.display?.trim().toLowerCase();
+
+    return (
+      code === 'national-id' ||
+      display === 'national id' ||
+      (!!nationalIdIdentifierTypeUuid && code === nationalIdIdentifierTypeUuid)
+    );
+  });
+
+  return nationalIdIdentifier?.value?.trim() || null;
+};
+
+export const getPhoneFromFhirPatient = (patient?: fhir.Patient): string | undefined =>
+  patient?.telecom?.find((contact) => contact.system === 'phone' || contact.use === 'mobile')?.value?.trim() ||
+  undefined;

package/src/resources/link-dependant.resource.test.ts

@@ -0,0 +1,445 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getSessionLocation, launchWorkspace2, launchWorkspaceGroup2, openmrsFetch } from '@openmrs/esm-framework';
+import { createDependantPatient, createPatientFromHiePatient } from './patient-create.resource';
+import { findExistingLocalPatient } from './patient-search.resource';
+import {
+  createAndLinkFromParticipant,
+  createDependantWithTemporaryId,
+  linkDependantToParticipant,
+  linkHieDependantWithTemporaryId,
+  useHieDependantLinkState,
+} from './link-dependant.resource';
+import React from 'react';
+import { renderHook, waitFor } from '@testing-library/react';
+import { SWRConfig } from 'swr';
+import { type PcsParticipant } from '../types';
+
+vi.mock('@openmrs/esm-framework', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@openmrs/esm-framework')>()),
+  openmrsFetch: vi.fn(),
+  getSessionLocation: vi.fn(),
+  launchWorkspace2: vi.fn(),
+  launchWorkspaceGroup2: vi.fn(),
+}));
+
+vi.mock('./patient-create.resource', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('./patient-create.resource')>()),
+  createDependantPatient: vi.fn(),
+  createPatientFromHiePatient: vi.fn(),
+}));
+vi.mock('./patient-search.resource', () => ({ findExistingLocalPatient: vi.fn() }));
+vi.mock('./identifiers', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('./identifiers')>()),
+  openmrsId: 'openmrs-id-type',
+  openmrsIdSource: 'openmrs-id-source',
+  generateIdentifier: vi.fn(async () => ({ data: { identifier: 'MGH-0001' } })),
+}));
+
+const mockOpenmrsFetch = vi.mocked(openmrsFetch);
+const mockCreateDependantPatient = vi.mocked(createDependantPatient);
+const mockCreatePatientFromHie = vi.mocked(createPatientFromHiePatient);
+const mockFindExistingLocalPatient = vi.mocked(findExistingLocalPatient);
+
+const uuids = {
+  nationalIdUUID: 'national-id-type',
+  shaNumberUUID: 'sha-number-type',
+  passportUUID: 'passport-type',
+  birthCertificateUUID: 'birth-certificate-type',
+  crIdentificationNumberUUID: 'cr-number-type',
+  phoneAttributeTypeUUID: 'phone-attr-type',
+};
+
+const STUDY_ID_TYPE = 'study-id-type-uuid';
+const PBIDS_ENROLLMENT_TYPE = 'pbids-enrollment-type-uuid';
+const CARDSE_ENROLLMENT_TYPE = 'cardse-enrollment-type-uuid';
+
+const participant = {
+  individualId: '901-1-1-3',
+  firstName: 'DENNIS',
+  lastName: 'ODONGO',
+  sex: 'M',
+  pbidsEnrolled: true,
+  cardse: false,
+  mother: null,
+  compound: { compoundId: '901-1', headIndividualId: '901-1-1-1', headFirstName: 'JOHN', headLastName: 'ODONGO' },
+  village: { code: '901', name: 'TEST ABUYA' },
+  contacts: [],
+  matchedOn: null,
+  matchType: null,
+} as PcsParticipant;
+
+const dependant = { id: 'CR-123', name: 'Dennis Odongo', gender: 'M', contactData: { id: 'CR-123' } };
+
+const link = () =>
+  linkDependantToParticipant({
+    dependant,
+    parentPhoneNumber: '0712345678',
+    participant,
+    studyParticipantIdentifierType: STUDY_ID_TYPE,
+    pbidsEnrollmentAttributeType: PBIDS_ENROLLMENT_TYPE,
+    cardseEnrollmentAttributeType: CARDSE_ENROLLMENT_TYPE,
+    uuids,
+  });
+
+const writes = () =>
+  mockOpenmrsFetch.mock.calls.filter(([, options]) => (options as any)?.method === 'POST').map(([url]) => url);
+
+/**
+ * The by-uuid re-read is tagged so tests can tell the refreshed record apart from the one
+ * resolved before the writes — that distinction is the bug this file guards.
+ */
+const rereadFor = (url: string) => ({
+  uuid: url.split('/patient/')[1]?.split('?')[0],
+  identifiers: [],
+  reread: true,
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockGetSessionLocationDefault();
+  mockOpenmrsFetch.mockImplementation((url: string, options?: any) => {
+    if (url.includes('?v=custom')) {
+      return Promise.resolve({ data: rereadFor(url) } as any);
+    }
+    if (url.endsWith('/patient') && options?.method === 'POST') {
+      return Promise.resolve({ data: { uuid: 'created-uuid', identifiers: [] } } as any);
+    }
+    return Promise.resolve({ data: { results: [] } } as any);
+  });
+});
+
+function mockGetSessionLocationDefault() {
+  vi.mocked(getSessionLocation).mockResolvedValue({ uuid: 'location-uuid' } as any);
+}
+
+describe('linkDependantToParticipant', () => {
+  it('uses the existing local record and never creates one', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue({ uuid: 'dependant-uuid', identifiers: [] } as any);
+
+    await link();
+
+    expect(mockCreateDependantPatient).not.toHaveBeenCalled();
+    // isDependent must be true, or household-number would match the parent's record.
+    expect(mockFindExistingLocalPatient).toHaveBeenCalledWith(dependant.contactData, true);
+    expect(writes()).toContain('/ws/rest/v1/patient/dependant-uuid/identifier');
+  });
+
+  it('creates the dependant, then stamps, then checks in exactly once', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue(null);
+    mockCreateDependantPatient.mockResolvedValue({ uuid: 'new-uuid', identifiers: [] } as any);
+
+    await link();
+
+    expect(mockCreateDependantPatient).toHaveBeenCalledOnce();
+    // The dependant and the parent's number reach the creator; the identifier types come from
+    // config rather than being resolved inside it.
+    expect(mockCreateDependantPatient).toHaveBeenCalledWith(dependant, uuids, '0712345678');
+    expect(writes()).toEqual([
+      '/ws/rest/v1/patient/new-uuid/identifier',
+      '/ws/rest/v1/person/new-uuid/attribute',
+      '/ws/rest/v1/person/new-uuid/attribute',
+    ]);
+    // createDependentPatient would have launched inside itself, before the writes.
+    expect(vi.mocked(launchWorkspaceGroup2).mock.invocationCallOrder[0]).toBeGreaterThan(
+      Math.max(...mockOpenmrsFetch.mock.invocationCallOrder),
+    );
+    expect(launchWorkspace2).toHaveBeenCalledOnce();
+  });
+
+  it('throws without checking in when a write fails', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue({ uuid: 'dependant-uuid', identifiers: [] } as any);
+    mockOpenmrsFetch.mockImplementation((_url: string, options?: any) =>
+      options?.method === 'POST'
+        ? Promise.reject(new Error('Identifier already in use'))
+        : Promise.resolve({ data: { results: [] } } as any),
+    );
+
+    await expect(link()).rejects.toThrow('Identifier already in use');
+    expect(launchWorkspace2).not.toHaveBeenCalled();
+  });
+});
+
+describe('createAndLinkFromParticipant', () => {
+  const withContacts = {
+    ...participant,
+    contacts: [{ phone: '0712345678', nationalId: '12345678' }],
+  } as PcsParticipant;
+
+  const createAndLink = (subject: PcsParticipant = withContacts) =>
+    createAndLinkFromParticipant({
+      participant: subject,
+      nationalIdUUID: uuids.nationalIdUUID,
+      phoneAttributeTypeUUID: uuids.phoneAttributeTypeUUID,
+      studyParticipantIdentifierType: STUDY_ID_TYPE,
+      pbidsEnrollmentAttributeType: PBIDS_ENROLLMENT_TYPE,
+      cardseEnrollmentAttributeType: CARDSE_ENROLLMENT_TYPE,
+    });
+
+  const createBody = () =>
+    (mockOpenmrsFetch.mock.calls.find(([u, o]) => u.endsWith('/patient') && (o as any)?.method === 'POST')![1] as any)
+      .body;
+
+  it('carries the phone and national ID across from the PCS contact', async () => {
+    await createAndLink();
+
+    const body = createBody();
+    // The national ID is what lets `findExistingLocalPatient` match this child later, and what
+    // makes OpenMRS reject a duplicate rather than silently creating a second patient.
+    // Asserted by content rather than position: `preferred` is what designates the primary
+    // identifier, so the order within the array carries no meaning.
+    expect(body.identifiers).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ identifierType: 'openmrs-id-type', preferred: true }),
+        expect.objectContaining({ identifier: '12345678', identifierType: 'national-id-type', preferred: false }),
+      ]),
+    );
+    expect(body.identifiers).toHaveLength(2);
+    expect(body.person.attributes).toEqual([{ attributeType: 'phone-attr-type', value: '0712345678' }]);
+  });
+
+  it('creates cleanly for a participant with no contacts', async () => {
+    await createAndLink(participant);
+
+    const body = createBody();
+    // An identifier entry with an empty value would be rejected outright.
+    expect(body.identifiers).toHaveLength(1);
+    expect(body.person.attributes).toEqual([]);
+  });
+
+  it("registers the patient from the participant's own demographics", async () => {
+    await createAndLink();
+
+    const [url, options] = mockOpenmrsFetch.mock.calls.find(
+      ([u, o]) => u.endsWith('/patient') && (o as any)?.method === 'POST',
+    )!;
+    expect(url).toBe('/ws/rest/v1/patient');
+    expect((options as any).body.person).toMatchObject({
+      names: [{ preferred: true, givenName: 'DENNIS', familyName: 'ODONGO' }],
+      gender: 'M',
+    });
+  });
+
+  it("stamps the participant's own id rather than minting a temporary one", async () => {
+    await createAndLink();
+
+    const identifierPost = mockOpenmrsFetch.mock.calls.find(
+      ([url, options]) => url.includes('/identifier') && (options as any)?.method === 'POST',
+    );
+
+    // Writing a temporary id here was the other reading of the request — this is the guard.
+    expect((identifierPost![1] as any).body).toMatchObject({
+      identifier: '901-1-1-3',
+      identifierType: STUDY_ID_TYPE,
+    });
+    expect(mockOpenmrsFetch.mock.calls.some(([url]) => url.endsWith('/pbids-participants'))).toBe(false);
+    expect(launchWorkspace2).toHaveBeenCalledOnce();
+  });
+});
+
+describe('createDependantWithTemporaryId', () => {
+  const demographics = {
+    firstName: 'BABY',
+    middleName: 'A',
+    lastName: 'ODONGO',
+    sex: 'F',
+    dateOfBirth: '2026-08-01',
+  };
+
+  const addDependant = () =>
+    createDependantWithTemporaryId({
+      demographics,
+      motherIndividualId: '901-1-1-2',
+      nationalIdUUID: uuids.nationalIdUUID,
+      phoneAttributeTypeUUID: uuids.phoneAttributeTypeUUID,
+    });
+
+  beforeEach(() => {
+    mockOpenmrsFetch.mockImplementation((url: string, options?: any) => {
+      if (url.includes('?v=custom')) {
+        return Promise.resolve({ data: rereadFor(url) } as any);
+      }
+      if (url.endsWith('/patient') && options?.method === 'POST') {
+        return Promise.resolve({ data: { uuid: 'infant-uuid', identifiers: [] } } as any);
+      }
+      if (url.endsWith('/pbids-participants') && options?.method === 'POST') {
+        return Promise.resolve({ data: { ...participant, individualId: 'TMP-901-1-1-9' } } as any);
+      }
+      return Promise.resolve({ data: { results: [] } } as any);
+    });
+  });
+
+  it('registers the patient from the form values', async () => {
+    await addDependant();
+
+    const [, options] = mockOpenmrsFetch.mock.calls.find(
+      ([u, o]) => u.endsWith('/patient') && (o as any)?.method === 'POST',
+    )!;
+    expect((options as any).body.person).toMatchObject({
+      names: [{ preferred: true, givenName: 'BABY', middleName: 'A', familyName: 'ODONGO' }],
+      gender: 'F',
+      birthdate: '2026-08-01',
+    });
+  });
+
+  it("posts the new patient against the mother's individual ID", async () => {
+    await addDependant();
+
+    const [url, options] = mockOpenmrsFetch.mock.calls.find(
+      ([u, o]) => u.endsWith('/pbids-participants') && (o as any)?.method === 'POST',
+    )!;
+    expect(url).toBe('/ws/rest/v1/pbids-participants');
+    // Both field names are the module's, and neither is guessable from this side.
+    expect((options as any).body).toEqual({ patientUuid: 'infant-uuid', motherId: '901-1-1-2' });
+  });
+
+  it('writes no identifier or attribute of its own', async () => {
+    await addDependant();
+
+    // The module sets the temporary ID and both enrolment attributes as one unit with the PCS
+    // row. A client write here is exactly what would break that pairing.
+    expect(writes()).toEqual(['/ws/rest/v1/patient', '/ws/rest/v1/pbids-participants']);
+  });
+
+  it('checks in once, with the record as the server left it', async () => {
+    const { localPatient } = await addDependant();
+
+    // The patient we created cannot carry what the module wrote; only the re-read can.
+    expect(localPatient).toMatchObject({ uuid: 'infant-uuid', reread: true });
+    expect(launchWorkspace2).toHaveBeenCalledOnce();
+  });
+
+  it('does not check in when the participant cannot be created', async () => {
+    mockOpenmrsFetch.mockImplementation((url: string, options?: any) => {
+      if (url.endsWith('/patient') && options?.method === 'POST') {
+        return Promise.resolve({ data: { uuid: 'infant-uuid', identifiers: [] } } as any);
+      }
+      if (url.endsWith('/pbids-participants') && options?.method === 'POST') {
+        return Promise.reject(new Error('Patient already has a study participant identifier'));
+      }
+      return Promise.resolve({ data: { results: [] } } as any);
+    });
+
+    await expect(addDependant()).rejects.toThrow('Patient already has a study participant identifier');
+    expect(launchWorkspace2).not.toHaveBeenCalled();
+  });
+});
+
+describe('linkHieDependantWithTemporaryId', () => {
+  const addFromHie = () =>
+    linkHieDependantWithTemporaryId({
+      dependant,
+      parentPhoneNumber: '0712345678',
+      motherIndividualId: '901-1-1-2',
+      uuids,
+    });
+
+  beforeEach(() => {
+    mockOpenmrsFetch.mockImplementation((url: string, options?: any) => {
+      if (url.includes('?v=custom')) {
+        return Promise.resolve({ data: rereadFor(url) } as any);
+      }
+      if (url.endsWith('/pbids-participants') && options?.method === 'POST') {
+        return Promise.resolve({ data: { ...participant, individualId: 'TMP-901-1-1-9' } } as any);
+      }
+      return Promise.resolve({ data: { results: [] } } as any);
+    });
+  });
+
+  it('reuses the local record when the child is already registered here', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue({ uuid: 'existing-uuid', identifiers: [] } as any);
+
+    await addFromHie();
+
+    // Creating here would duplicate a patient the HIE contact already resolves to.
+    expect(mockCreateDependantPatient).not.toHaveBeenCalled();
+    // isDependent must be true, or household-number would match the mother's own record.
+    expect(mockFindExistingLocalPatient).toHaveBeenCalledWith(dependant.contactData, true);
+    expect(
+      mockOpenmrsFetch.mock.calls.find(
+        ([u, o]) => u.endsWith('/pbids-participants') && (o as any)?.method === 'POST',
+      )![1],
+    ).toMatchObject({ body: { patientUuid: 'existing-uuid' } });
+  });
+
+  it('creates the child from the HIE contact when she is not registered here', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue(null);
+    mockCreateDependantPatient.mockResolvedValue({ uuid: 'new-uuid', identifiers: [] } as any);
+
+    await addFromHie();
+
+    expect(mockCreateDependantPatient).toHaveBeenCalledOnce();
+    expect(mockCreateDependantPatient).toHaveBeenCalledWith(dependant, uuids, '0712345678');
+  });
+
+  it("posts the resolved patient against the mother's individual ID", async () => {
+    mockFindExistingLocalPatient.mockResolvedValue({ uuid: 'existing-uuid', identifiers: [] } as any);
+
+    await addFromHie();
+
+    const [url, options] = mockOpenmrsFetch.mock.calls.find(
+      ([u, o]) => u.endsWith('/pbids-participants') && (o as any)?.method === 'POST',
+    )!;
+    expect(url).toBe('/ws/rest/v1/pbids-participants');
+    // Both field names are the module's, and neither is guessable from this side.
+    expect((options as any).body).toEqual({ patientUuid: 'existing-uuid', motherId: '901-1-1-2' });
+  });
+
+  it('writes no identifier or attribute of its own', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue({ uuid: 'existing-uuid', identifiers: [] } as any);
+
+    await addFromHie();
+
+    // The module sets the temporary ID and both enrolment attributes as one unit with the PCS
+    // row. A client write here is exactly what would break that pairing.
+    expect(writes()).toEqual(['/ws/rest/v1/pbids-participants']);
+  });
+
+  it('starts the visit once, with the record as the server left it', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue({ uuid: 'existing-uuid', identifiers: [] } as any);
+
+    const { localPatient } = await addFromHie();
+
+    // The record we resolved cannot carry what the module wrote; only the re-read can.
+    expect(localPatient).toMatchObject({ uuid: 'existing-uuid', reread: true });
+    expect(launchWorkspace2).toHaveBeenCalledOnce();
+  });
+
+  it('does not start a visit when the participant cannot be created', async () => {
+    mockFindExistingLocalPatient.mockResolvedValue({ uuid: 'existing-uuid', identifiers: [] } as any);
+    mockOpenmrsFetch.mockImplementation((url: string, options?: any) =>
+      url.endsWith('/pbids-participants') && options?.method === 'POST'
+        ? Promise.reject(new Error('Patient already has a study participant identifier'))
+        : Promise.resolve({ data: { results: [] } } as any),
+    );
+
+    await expect(addFromHie()).rejects.toThrow('Patient already has a study participant identifier');
+    expect(launchWorkspace2).not.toHaveBeenCalled();
+  });
+});
+
+describe('useHieDependantLinkState', () => {
+  const candidates = [
+    { id: 'CR-linked', contactData: { id: 'CR-linked' } },
+    { id: 'CR-free', contactData: { id: 'CR-free' } },
+  ];
+
+  it('marks the candidates whose local patient already holds a study ID', async () => {
+    mockFindExistingLocalPatient.mockImplementation(async (contactData: any) =>
+      contactData.id === 'CR-linked'
+        ? { uuid: 'p1', identifiers: [{ identifier: '901-1-1-3', identifierType: { uuid: STUDY_ID_TYPE } }] }
+        : null,
+    );
+
+    // Fresh SWR cache per render, so nothing leaks between cases.
+    const { result } = renderHook(() => useHieDependantLinkState(candidates, [STUDY_ID_TYPE, 'temp-id-type']), {
+      wrapper: ({ children }) => React.createElement(SWRConfig, { value: { provider: () => new Map() } }, children),
+    });
+
+    // Waiting on the data itself rather than on isChecking, which is briefly false before
+    // SWR has begun.
+    await waitFor(() => expect(result.current.linkedById['CR-linked']).toBe('901-1-1-3'));
+
+    // The marked one is what the modal disables; the unmarked one stays selectable.
+    expect(result.current.linkedById).toEqual({ 'CR-linked': '901-1-1-3', 'CR-free': undefined });
+  });
+});