@ampath/esm-dha-workflow-app 4.0.0-next.43 → 4.0.0-next.445

package/src/billing/dashboard/v3/preauth/preauth.workspace.tsx

@@ -0,0 +1,2458 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import {
+  Button,
+  ButtonSet,
+  Checkbox,
+  ComboBox,
+  DatePicker,
+  DatePickerInput,
+  Dropdown,
+  Form,
+  InlineLoading,
+  InlineNotification,
+  RadioButton,
+  RadioButtonGroup,
+  Tag,
+  TextArea,
+  TextInput,
+} from '@carbon/react';
+import {
+  showSnackbar,
+  useConfig,
+  useSession,
+  Workspace2,
+  type Workspace2DefinitionProps,
+} from '@openmrs/esm-framework';
+import { useTranslation } from 'react-i18next';
+import dayjs from 'dayjs';
+import {
+  cancelPreauth,
+  createPreauth,
+  extractHieErrorMessage,
+  fetchShaInterventionByCode,
+  findExistingPreauthForCrAndShaCode,
+  getServiceType,
+  pollPreauthUntilSubmitted,
+  preauthAttachmentFieldName,
+  type ExistingPreauthMatch,
+  type PreauthFormPayload,
+} from '../../../../claims/claims.resource';
+import { resolvePreVisitConsentAuthorization, sendClaimsOTP } from '../../../../registry/hie.resource';
+import type { PatientContactResult } from '../../../../registry/hie.types';
+import {
+  createElectivePreauth,
+  extractElectiveAuthorizationToken,
+  fetchElectivePatientContacts,
+  resolveOrCreateElectivePreVisitAuthorization,
+  sendElectivePreauthOtp,
+} from './elective/elective-authorize.resource';
+import { addClaimDiagnosis, fetchPatientDiagnosesForBilling, preferredDiagnosisForPreauth } from '../../../billing-claims.resource';
+import { ensureInterventionOnVisit } from '../../../../claims/interventions.resource';
+import type { ConfigObject } from '../../../../config-schema';
+import { type AmrsVisitDiagnosis } from '../../../types';
+import { type PatientFacilityBillDetails } from '../types';
+import PreauthAttachments, { type PreauthAttachmentRow } from './preauth-attachments.component';
+import {
+  billingDateToVisitDate,
+  dateToServiceIso,
+  fetchTodaysTriageVitalsConcat,
+  mergeSpecialtyFlags,
+  preauthFormLabel,
+  readSpecialtyFlags,
+  resolveAndLoadRaisePrefill,
+  resolvePatientUuidFromCr,
+  resolveUnitPriceFromPatientBills,
+  searchDiagnosisConcepts,
+  searchHealthWorkerRegistry,
+  searchOpenMrsProviders,
+  storePreauthCode,
+  usePreauthBillableServices,
+  type DiagnosisConceptHit,
+  type HwrSearchResult,
+  type OpenMrsProviderHit,
+  type PreauthFormFieldKey,
+  type PreauthInterventionProps,
+} from './preauth.resource';
+import styles from './preauth.workspace.scss';
+
+export type { PreauthInterventionProps };
+
+type ServicePrice = {
+  uuid?: string;
+  name?: string;
+  price?: number;
+  paymentMode?: { uuid?: string; name?: string };
+};
+
+type BillableServiceOption = {
+  uuid: string;
+  name: string;
+  servicePrices?: ServicePrice[];
+};
+
+function unitPriceFromBillableService(
+  item: BillableServiceOption | null | undefined,
+  shaPaymentModeUuid: string,
+): string {
+  const prices = item?.servicePrices ?? [];
+  if (!prices.length) return '';
+  const sha = prices.find((sp) => sp.paymentMode?.uuid === shaPaymentModeUuid);
+  const pick = sha ?? prices[0];
+  if (pick?.price == null || Number.isNaN(Number(pick.price))) return '';
+  return String(pick.price);
+}
+
+/** ComboBox row: visit diagnosis (ETL) or concept-dictionary hit. */
+type DiagnosisPick =
+  | { kind: 'visit'; key: string; dx: AmrsVisitDiagnosis }
+  | { kind: 'concept'; key: string; hit: DiagnosisConceptHit };
+
+const visitDxPick = (dx: AmrsVisitDiagnosis): DiagnosisPick => ({
+  kind: 'visit',
+  key: `visit-${dx.encounter_id}-${dx.icd11_code}-${dx.diagnosis_coded ?? dx.value_coded ?? ''}`,
+  dx,
+});
+
+const conceptDxPick = (hit: DiagnosisConceptHit): DiagnosisPick => ({
+  kind: 'concept',
+  key: `concept-${hit.uuid}-${hit.icd11Code}`,
+  hit,
+});
+
+const diagnosisPickLabel = (item: DiagnosisPick | null) => {
+  if (!item) return '';
+  if (item.kind === 'visit') {
+    const d = item.dx;
+    const rank =
+      d.dx_rank != null && Number.isFinite(Number(d.dx_rank)) ? ` · Rank ${Number(d.dx_rank)}` : '';
+    return `${d.icd11_code ?? '—'} · ${d.concept_source_name || d.encounter_type || 'Visit diagnosis'}${rank}`;
+  }
+  return `${item.hit.icd11Code} · ${item.hit.display}`;
+};
+
+const diagnosisPickCode = (item: DiagnosisPick | null) => {
+  if (!item) return '';
+  return item.kind === 'visit' ? item.dx.icd11_code ?? '' : item.hit.icd11Code;
+};
+
+const DEFAULT_DOCTOR_ID_TYPE = 'National ID' as const;
+
+type FormFieldLoadStatus = 'idle' | 'loading' | 'from_form' | 'missing';
+
+const FORM_MISSING_HINT =
+  'Missing on the Pre-authorization form. Complete the form on the patient chart, then reopen Raise preauth.';
+
+const SURGICAL_FORM_KEYS: PreauthFormFieldKey[] = [
+  'chiefComplaint',
+  'hpi',
+  'physicalExam',
+  'investigations',
+  'anaesthesia',
+  'surgeryDate',
+  'relatedToEmployment',
+  'relatedToAccident',
+  'isCoInsured',
+  'coInsuranceDetails',
+];
+
+const RENAL_FORM_KEYS: PreauthFormFieldKey[] = [
+  'clinicalIndications',
+  'startDate',
+  'sessionsRequired',
+  'frequency',
+  'isCoInsured',
+  'coInsuranceDetails',
+];
+
+interface PreauthWorkspaceProps {
+  consentToken: string;
+  patientUuid?: string;
+  locationUuid: string;
+  /** Elective (pre-visit) mode — uses authorize token + expected_service_start_date */
+  isElective?: boolean;
+  /** Elective hold encounter — Raise loads prefill from this encounter only */
+  encounterUuid?: string;
+  initialDoctorNationalId?: string;
+  initialProviderDisplay?: string;
+  initialExpectedServiceStartDate?: string;
+  billItem: Partial<PatientFacilityBillDetails> & {
+    intervention_code: string;
+    patient_uuid?: string;
+    cr_no?: string;
+    service_type?: string;
+  };
+  intervention: PreauthInterventionProps;
+  onSuccess?: (result: { consentToken: string; preauthCode?: string; status: string }) => void;
+}
+
+const ANAESTHESIA = ['GENERAL', 'LOCAL', 'SPINAL', 'SEDATION'];
+const FREQUENCY = ['TWICE_A_WEEK', 'ONCE_A_WEEK', 'ONCE_EVERY_2_WEEKS', 'ONCE_EVERY_3_WEEKS', 'ONCE_A_MONTH'];
+const STAGING = ['STAGE_1', 'STAGE_2', 'STAGE_3', 'STAGE_4'];
+const METASTASES = ['LUNG', 'BRAIN', 'LIVER', 'OTHER'];
+const TREATMENT = ['DAY_WARD', 'RECLINING_CHAIR', 'SIDE_ROOM'];
+const LENS = ['FRAMES_LENSES', 'FRAMED', 'CONTACT'];
+const NEW_OR_REPL = ['NEW', 'REPLACEMENT'];
+
+const DOC_TYPE_OPTIONS = [
+  'LAB_TESTS',
+  'LAB_RESULTS',
+  'DISCHARGE_SUMMARY',
+  'INVOICE',
+  'FINAL_BILL',
+  'CLINICAL_DOCUMENTATION',
+  'MEDICAL_REPORT',
+  'IMAGING_RESULT',
+  'RADIOLOGICAL_EXAM',
+  'STAGING_RESULTS',
+  'TREATMENT_PLAN',
+  'THEATRE_LIST',
+  'DIALYSIS_CHART',
+  'PREAUTH_FORM',
+  'OTHER',
+];
+
+const toIsoLocal = (d: Date = new Date()) => dayjs(d).format('YYYY-MM-DDTHH:mm:ssZ');
+
+/** HIE regulation bodies (abbreviated): COC = Clinical Officers Council, NCK = Nursing Council of Kenya */
+const REGULATION_BODIES = ['KMPDC', 'COC', 'NCK'] as const;
+type RegulationBody = (typeof REGULATION_BODIES)[number];
+
+const normalizeRegulationBody = (value?: string | null): RegulationBody => {
+  if (!value) return 'KMPDC';
+  const raw = value.trim();
+  const exact = REGULATION_BODIES.find((b) => b.toLowerCase() === raw.toLowerCase());
+  if (exact) return exact;
+  const upper = raw.toUpperCase();
+  if (upper.includes('KMPDC') || upper.includes('MEDICAL PRACTITIONER') || upper.includes('DOCTOR')) {
+    return 'KMPDC';
+  }
+  if (
+    upper.includes('CLINICAL OFFICER') ||
+    upper === 'COC' ||
+    upper.includes('CLINICAL OFFICERS COUNCIL')
+  ) {
+    return 'COC';
+  }
+  if (upper.includes('NURS') || upper === 'NCK' || upper.includes('NURSING COUNCIL')) {
+    return 'NCK';
+  }
+  return 'KMPDC';
+};
+
+type PreauthFormProps = PreauthWorkspaceProps & Pick<Workspace2DefinitionProps, 'closeWorkspace'>;
+
+const PreauthForm: React.FC<PreauthFormProps> = ({
+  closeWorkspace,
+  consentToken: consentTokenProp,
+  patientUuid,
+  locationUuid,
+  isElective = false,
+  encounterUuid: encounterUuidProp,
+  initialDoctorNationalId,
+  initialProviderDisplay,
+  initialExpectedServiceStartDate,
+  billItem,
+  intervention,
+  onSuccess,
+}) => {
+  const { t } = useTranslation();
+  const session = useSession();
+  const { shaPaymentModeUuid } = useConfig<ConfigObject>();
+  const { lineItems: billableItems, isLoading: loadingBillableItems } = usePreauthBillableServices();
+  const [dirty, setDirty] = useState(false);
+  const [submitting, setSubmitting] = useState(false);
+  const [polling, setPolling] = useState(false);
+  const [consentMethod, setConsentMethod] = useState<'biometric' | 'otp'>('otp');
+  // Elective must mint a pre-visit authorization token (AUTHORIZED_PENDING_VISIT) —
+  // do not treat a prior visit claim token as ready consent.
+  const [consentDone, setConsentDone] = useState(isElective ? false : Boolean(consentTokenProp));
+  const [otpSent, setOtpSent] = useState(false);
+  const [otp, setOtp] = useState('');
+  const [sendingOtp, setSendingOtp] = useState(false);
+  /** Phase 2 step 6a — contact confirmed with patient before OTP. */
+  const [patientContacts, setPatientContacts] = useState<PatientContactResult[]>([]);
+  const [selectedContactId, setSelectedContactId] = useState('');
+  const [loadingContacts, setLoadingContacts] = useState(false);
+  const [activeConsentToken, setActiveConsentToken] = useState(isElective ? '' : consentTokenProp || '');
+  const [expectedServiceStartDate, setExpectedServiceStartDate] = useState(() => {
+    if (initialExpectedServiceStartDate) {
+      const d = dayjs(initialExpectedServiceStartDate);
+      if (d.isValid()) return d.format('YYYY-MM-DDTHH:mm:ssZ');
+    }
+    return toIsoLocal();
+  });
+  const abortRef = useRef<AbortController | null>(null);
+  /** Skip unsaved-changes prompt after a successful submit (state may still say submitting/dirty). */
+  const allowCloseWithoutPromptRef = useRef(false);
+  /** Encounter diagnoses[] already applied — ETL preferred must not overwrite. */
+  const encounterDxAppliedRef = useRef(false);
+  /** Provider National ID already applied from encounter / launch props. */
+  const providerPrefillAppliedRef = useRef(false);
+  const [existingPreauth, setExistingPreauth] = useState<ExistingPreauthMatch | null>(null);
+  const [checkingExistingPreauth, setCheckingExistingPreauth] = useState(false);
+  const [cancellingExistingPreauth, setCancellingExistingPreauth] = useState(false);
+
+  // Specialty from launch props + bill item; SHA coverage may enrich after mount
+  // (visit/claim payloads often omit requires_*_preauth even for oncology codes).
+  const [specialty, setSpecialty] = useState(() =>
+    mergeSpecialtyFlags(readSpecialtyFlags(intervention), readSpecialtyFlags(billItem)),
+  );
+  const specialtyLabel = preauthFormLabel(specialty);
+  const [requiredDocs, setRequiredDocs] = useState<string[]>(() => [
+    ...new Set(intervention.requiredPreauthDocumentTypes ?? []),
+  ]);
+  const [optionalDocs, setOptionalDocs] = useState<string[]>(() => {
+    const required = new Set(intervention.requiredPreauthDocumentTypes ?? []);
+    return [...new Set(intervention.applicableDocumentTypes ?? [])].filter((d) => !required.has(d));
+  });
+  const interventionForSubmit = useMemo(
+    () => ({
+      ...intervention,
+      ...specialty,
+      requiredPreauthDocumentTypes: requiredDocs,
+      applicableDocumentTypes: optionalDocs,
+    }),
+    [intervention, specialty, requiredDocs, optionalDocs],
+  );
+
+  /** Non-specialty “normal” preauth — needs clinical_indications in UI + HIE payload. */
+  const isPlainNormalPreauth =
+    !specialty.requiresSurgicalPreauth &&
+    !specialty.requiresRenalPreauth &&
+    !specialty.requiresOpticalPreauth &&
+    !specialty.requiresRadiologyPreauth &&
+    !specialty.requiresOncologyPreauth;
+
+  const [serviceStart, setServiceStart] = useState(toIsoLocal());
+  const [serviceEnd, setServiceEnd] = useState(toIsoLocal(dayjs().add(30, 'minute').toDate()));
+  const [providerEmail, setProviderEmail] = useState(session?.user?.username?.includes('@') ? session.user.username : '');
+  const [unitPrice, setUnitPrice] = useState(() =>
+    String(billItem.item_price ?? billItem.item_total_price ?? '').trim(),
+  );
+  const [billPriceLookupDone, setBillPriceLookupDone] = useState(false);
+  const [hasBillUnitPrice, setHasBillUnitPrice] = useState(() =>
+    Boolean(String(billItem.item_price ?? billItem.item_total_price ?? '').trim()),
+  );
+  const [selectedBillableService, setSelectedBillableService] = useState<BillableServiceOption | null>(null);
+
+  // Diagnosis: prefill from ETL encounter-diagnosis; search uses concept dictionary (ICD-11).
+  const [visitDiagnoses, setVisitDiagnoses] = useState<AmrsVisitDiagnosis[]>([]);
+  const [conceptDxHits, setConceptDxHits] = useState<DiagnosisConceptHit[]>([]);
+  const [loadingDx, setLoadingDx] = useState(false);
+  const [searchingDx, setSearchingDx] = useState(false);
+  const [selectedDx, setSelectedDx] = useState<DiagnosisPick | null>(null);
+  const [icdCode, setIcdCode] = useState('');
+  const dxSearchTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  // Provider — National ID for doctor; HWR for regulation body
+  const [providerHits, setProviderHits] = useState<OpenMrsProviderHit[]>([]);
+  const [searchingProviders, setSearchingProviders] = useState(false);
+  const [selectedProvider, setSelectedProvider] = useState<OpenMrsProviderHit | null>(null);
+  const providerSearchTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const [searchingHwr, setSearchingHwr] = useState(false);
+  const [hwrHit, setHwrHit] = useState<HwrSearchResult | null>(null);
+  const [doctorId, setDoctorId] = useState(() => (initialDoctorNationalId ?? '').trim());
+  const [regulationBody, setRegulationBody] = useState<RegulationBody>('KMPDC');
+
+  // Specialty fields — empty until Pre-authorization form obs (or bill unit price) loads.
+  const [clinicalIndications, setClinicalIndications] = useState('');
+  const [formLoadState, setFormLoadState] = useState<'idle' | 'loading' | 'done'>('idle');
+  const [formFound, setFormFound] = useState<Set<PreauthFormFieldKey>>(() => new Set());
+  const [formRelevant, setFormRelevant] = useState<Set<PreauthFormFieldKey>>(() => new Set());
+  const [chiefComplaint, setChiefComplaint] = useState('');
+  const [vitalSigns, setVitalSigns] = useState('');
+  const [hpi, setHpi] = useState('');
+  const [physicalExam, setPhysicalExam] = useState('');
+  const [investigations, setInvestigations] = useState('');
+  const [anaesthesia, setAnaesthesia] = useState('');
+  const [surgeryDate, setSurgeryDate] = useState('');
+  const [sessionsRequired, setSessionsRequired] = useState('');
+  const [costPerSession, setCostPerSession] = useState('');
+  const [frequency, setFrequency] = useState('');
+  const [startDate, setStartDate] = useState('');
+  const [isCoInsured, setIsCoInsured] = useState(false);
+  const [necessity, setNecessity] = useState('');
+  const [lensPrescription, setLensPrescription] = useState('');
+  const [lensAmount, setLensAmount] = useState('');
+  const [eyeExamAmount, setEyeExamAmount] = useState('');
+  const [frameAmount, setFrameAmount] = useState('');
+  const [newOrReplacement, setNewOrReplacement] = useState('');
+  const [carcinomaStaging, setCarcinomaStaging] = useState('');
+  const [comorbidity, setComorbidity] = useState('');
+  const [metastases, setMetastases] = useState('');
+  const [treatmentSetting, setTreatmentSetting] = useState('');
+  const [progressReport, setProgressReport] = useState('');
+  const [relatedToEmployment, setRelatedToEmployment] = useState(false);
+  const [relatedToAccident, setRelatedToAccident] = useState(false);
+  const [coInsuranceDetails, setCoInsuranceDetails] = useState('');
+
+  const formFieldStatus = (key: PreauthFormFieldKey): FormFieldLoadStatus => {
+    if (formLoadState === 'idle') return 'idle';
+    if (formLoadState === 'loading') return 'loading';
+    if (!formRelevant.has(key)) return 'idle';
+    return formFound.has(key) ? 'from_form' : 'missing';
+  };
+
+  const formFieldLocked = (key: PreauthFormFieldKey) => {
+    const s = formFieldStatus(key);
+    return s === 'from_form' || s === 'missing' || s === 'loading';
+  };
+
+  const formFieldInvalid = (key: PreauthFormFieldKey) => formFieldStatus(key) === 'missing';
+
+  const patientName = billItem.patient_name ?? '';
+  const crNo = billItem.cr_no ?? '';
+  const billableService = billItem.billable_service ?? intervention.name ?? intervention.code;
+
+  const [attachments, setAttachments] = useState<PreauthAttachmentRow[]>(() => {
+    const required = requiredDocs.map((document_type) => ({
+      id: crypto.randomUUID(),
+      document_type,
+      document_title: document_type.replace(/_/g, ' '),
+      required: true,
+    }));
+    if (required.length === 0) {
+      return [
+        {
+          id: crypto.randomUUID(),
+          document_type: 'LAB_TESTS',
+          document_title: 'Lab Results',
+          required: false,
+        },
+      ];
+    }
+    return required;
+  });
+
+  useEffect(() => {
+    // Normal Raise needs the claim visit consent token. Elective may open without one
+    // and resolve a pre-visit token via GET /claim-authorizations (not /claims-authorize).
+    if (!isElective && !consentTokenProp) {
+      showSnackbar({
+        kind: 'error',
+        title: t('missingConsentToken', 'Missing claim token'),
+        subtitle: t(
+          'missingConsentTokenDetail',
+          'A preexisting visit claim token is required to raise preauth.',
+        ),
+      });
+      void closeWorkspace();
+    }
+  }, [consentTokenProp, isElective, closeWorkspace, t]);
+
+  // Phase 2 step 6a — GET contacts so OTP can target beneficiary_contact_id.
+  useEffect(() => {
+    if (!isElective || consentMethod !== 'otp') return;
+    const patientId = crNo.trim();
+    if (!patientId || !locationUuid) {
+      setPatientContacts([]);
+      setSelectedContactId('');
+      return;
+    }
+    let cancelled = false;
+    setLoadingContacts(true);
+    (async () => {
+      try {
+        const rows = await fetchElectivePatientContacts(patientId, locationUuid);
+        if (cancelled) return;
+        setPatientContacts(rows);
+        const preferred = rows.find((c) => c.isConfirmed) ?? rows[0];
+        setSelectedContactId(preferred?.id != null ? String(preferred.id) : '');
+      } catch {
+        if (!cancelled) {
+          setPatientContacts([]);
+          setSelectedContactId('');
+        }
+      } finally {
+        if (!cancelled) setLoadingContacts(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [isElective, consentMethod, crNo, locationUuid]);
+
+  const consentToken = activeConsentToken;
+
+  // Detect an existing active preauth for the same CR + SHA intervention code.
+  useEffect(() => {
+    const patientId = (billItem.cr_no ?? '').trim();
+    const code = (intervention.code || billItem.intervention_code || '').trim();
+    const patientIdUuid = (patientUuid || billItem.patient_uuid || '').trim();
+    if (!locationUuid || !code || (!patientId && !consentTokenProp && !patientIdUuid)) {
+      setExistingPreauth(null);
+      return;
+    }
+
+    let cancelled = false;
+    setCheckingExistingPreauth(true);
+    (async () => {
+      try {
+        const match = await findExistingPreauthForCrAndShaCode({
+          beneficiaryCr: patientId,
+          interventionCode: code,
+          locationUuid,
+          consentToken: isElective ? undefined : consentTokenProp,
+          patientUuid: patientIdUuid || undefined,
+        });
+        if (!cancelled) setExistingPreauth(match);
+      } catch {
+        if (!cancelled) setExistingPreauth(null);
+      } finally {
+        if (!cancelled) setCheckingExistingPreauth(false);
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    billItem.cr_no,
+    billItem.intervention_code,
+    billItem.patient_uuid,
+    consentTokenProp,
+    intervention.code,
+    isElective,
+    locationUuid,
+    patientUuid,
+  ]);
+
+  // Enrich specialty flags + preauth document types from SHA interventions coverage.
+  useEffect(() => {
+    const patientId = (billItem.cr_no ?? '').trim();
+    const code = (intervention.code || billItem.intervention_code || '').trim();
+    if (!patientId || !locationUuid || !code) return;
+
+    let cancelled = false;
+    (async () => {
+      try {
+        const sha = await fetchShaInterventionByCode(patientId, locationUuid, code);
+        if (cancelled || !sha) return;
+        const fromSha = readSpecialtyFlags(sha);
+        setSpecialty((prev) => {
+          const next = mergeSpecialtyFlags(prev, fromSha);
+          if (
+            next.requiresSurgicalPreauth === prev.requiresSurgicalPreauth &&
+            next.requiresRenalPreauth === prev.requiresRenalPreauth &&
+            next.requiresOncologyPreauth === prev.requiresOncologyPreauth &&
+            next.requiresRadiologyPreauth === prev.requiresRadiologyPreauth &&
+            next.requiresOpticalPreauth === prev.requiresOpticalPreauth
+          ) {
+            return prev;
+          }
+          return next;
+        });
+
+        const shaRequired = [...new Set((sha.requiredPreauthDocumentTypes ?? []).filter(Boolean))];
+        const shaApplicable = [...new Set((sha.applicableDocumentTypes ?? []).filter(Boolean))];
+        if (shaRequired.length || shaApplicable.length) {
+          const nextRequired = shaRequired.length ? shaRequired : requiredDocs;
+          const requiredSet = new Set(nextRequired);
+          const nextOptional = (shaApplicable.length ? shaApplicable : optionalDocs).filter(
+            (d) => !requiredSet.has(d),
+          );
+          setRequiredDocs(nextRequired);
+          setOptionalDocs(nextOptional);
+          // Reseed required rows only when the user has not attached files yet.
+          setAttachments((prev) => {
+            const hasUserFiles = prev.some((a) => Boolean(a.file));
+            if (hasUserFiles) return prev;
+            if (!nextRequired.length) return prev;
+            return nextRequired.map((document_type) => ({
+              id: crypto.randomUUID(),
+              document_type,
+              document_title: document_type.replace(/_/g, ' '),
+              required: true,
+            }));
+          });
+        }
+      } catch {
+        // Keep launch-prop flags / docs if coverage lookup fails
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- seed once from SHA; avoid re-loop on doc state
+  }, [billItem.cr_no, billItem.intervention_code, intervention.code, locationUuid]);
+
+  useEffect(() => () => {
+    abortRef.current?.abort();
+    if (providerSearchTimer.current) clearTimeout(providerSearchTimer.current);
+    if (dxSearchTimer.current) clearTimeout(dxSearchTimer.current);
+  }, []);
+
+  const markDirty = () => setDirty(true);
+
+  const applyDiagnosisPick = (pick: DiagnosisPick | null, opts?: { fromUser?: boolean }) => {
+    // Prefill from visit load must not trip "unsaved changes" on close.
+    if (opts?.fromUser !== false) {
+      markDirty();
+    }
+    setSelectedDx(pick);
+    const code = diagnosisPickCode(pick);
+    if (code) {
+      setIcdCode(code);
+    }
+    if (pick?.kind === 'visit') {
+      const dx = pick.dx;
+      if (dx.practioner_nat_id && !providerPrefillAppliedRef.current) {
+        setDoctorId(dx.practioner_nat_id);
+      }
+      if (dx.practitioner_body) {
+        setRegulationBody(normalizeRegulationBody(dx.practitioner_body));
+      }
+    }
+  };
+
+  // Prefill from visit + maternity + encounter diagnoses (ETL) — fallback when no encounter.diagnoses[].
+  useEffect(() => {
+    const uuid = patientUuid || billItem.patient_uuid;
+    if (!uuid || !locationUuid) return;
+    let cancelled = false;
+    const run = async () => {
+      setLoadingDx(true);
+      try {
+        const visitDate = billingDateToVisitDate(billItem.bill_date);
+        const billingDate = visitDate;
+        const results = await fetchPatientDiagnosesForBilling({
+          visitDate,
+          billingDate,
+          patientUuid: uuid,
+          locationUuid,
+        });
+        if (!cancelled) {
+          setVisitDiagnoses(results ?? []);
+          if (!encounterDxAppliedRef.current) {
+            const preferred = preferredDiagnosisForPreauth(results ?? []);
+            if (preferred) {
+              applyDiagnosisPick(visitDxPick(preferred), { fromUser: false });
+            }
+          }
+        }
+      } catch {
+        if (!cancelled) {
+          showSnackbar({
+            kind: 'warning',
+            title: 'Could not load diagnoses',
+            subtitle: 'Search the concept dictionary, or retry after the visit has ICD-11 coded diagnoses.',
+          });
+        }
+      } finally {
+        if (!cancelled) setLoadingDx(false);
+      }
+    };
+    run();
+    return () => {
+      cancelled = true;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [patientUuid, billItem.patient_uuid, billItem.bill_date, locationUuid]);
+
+  const diagnosisItems = useMemo((): DiagnosisPick[] => {
+    const base =
+      conceptDxHits.length > 0
+        ? conceptDxHits.map(conceptDxPick)
+        : visitDiagnoses.filter((d) => d.icd11_code).map(visitDxPick);
+    if (!selectedDx) return base;
+    if (!base.some((i) => i.key === selectedDx.key)) {
+      return [selectedDx, ...base];
+    }
+    return base.map((i) => (i.key === selectedDx.key ? selectedDx : i));
+  }, [conceptDxHits, visitDiagnoses, selectedDx]);
+
+  const handleDiagnosisInputChange = (inputValue: string) => {
+    const selectedLabel = diagnosisPickLabel(selectedDx);
+    if (inputValue === selectedLabel) {
+      return;
+    }
+    if (selectedDx) {
+      setSelectedDx(null);
+    }
+    if (dxSearchTimer.current) {
+      clearTimeout(dxSearchTimer.current);
+    }
+    const q = (inputValue ?? '').trim();
+    if (q.length < 2) {
+      setConceptDxHits([]);
+      setSearchingDx(false);
+      return;
+    }
+    dxSearchTimer.current = setTimeout(async () => {
+      setSearchingDx(true);
+      try {
+        const hits = await searchDiagnosisConcepts(q);
+        setConceptDxHits(hits);
+      } catch {
+        setConceptDxHits([]);
+      } finally {
+        setSearchingDx(false);
+      }
+    }, 300);
+  };
+  // Resolve unit_price from patient facility bill lines (match intervention + service name).
+  // Elective holds often have no bill line yet — fall back to billable-service catalog picker.
+  useEffect(() => {
+    const uuid = patientUuid || billItem.patient_uuid;
+    const code = (intervention.code || billItem.intervention_code || '').trim();
+    if (!uuid || !locationUuid || !code) {
+      setBillPriceLookupDone(true);
+      return;
+    }
+
+    let cancelled = false;
+    setBillPriceLookupDone(false);
+    (async () => {
+      try {
+        const { unitPrice: fromBills, billLine } = await resolveUnitPriceFromPatientBills({
+          patientUuid: uuid,
+          locationUuid,
+          billingDate: billItem.bill_date,
+          interventionCode: code,
+          serviceHint: billItem.billable_service || intervention.name || code,
+        });
+        if (cancelled) return;
+        if (fromBills) {
+          setUnitPrice(fromBills);
+          setHasBillUnitPrice(true);
+          setSelectedBillableService(null);
+          setCostPerSession((prev) => (prev.trim() ? prev : fromBills));
+          // Prefer matched billable_service label when launch used intervention name only
+          if (billLine?.billable_service && !(billItem.billable_service || '').trim()) {
+            // billItem is a prop — display uses billableService derived from it; unit price is enough
+          }
+        } else {
+          setHasBillUnitPrice(false);
+        }
+      } finally {
+        if (!cancelled) setBillPriceLookupDone(true);
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    patientUuid,
+    billItem.patient_uuid,
+    billItem.bill_date,
+    billItem.intervention_code,
+    billItem.billable_service,
+    intervention.code,
+    intervention.name,
+    locationUuid,
+    specialty.requiresRenalPreauth,
+  ]);
+
+  // Elective preauth usually has no patient bill yet — always offer the catalog picker.
+  const needsBillableServicePicker = isElective;
+
+  // Unified Raise prefill: Preauth/Clinical (or explicit encounterUuid) → formValues + diagnoses + provider.
+  useEffect(() => {
+    const specialtyNeedsForm =
+      specialty.requiresSurgicalPreauth ||
+      specialty.requiresRenalPreauth ||
+      specialty.requiresRadiologyPreauth ||
+      specialty.requiresOpticalPreauth;
+    const needsForm = specialtyNeedsForm || isPlainNormalPreauth;
+    const uuid = patientUuid || billItem.patient_uuid;
+    if (!needsForm || !uuid) {
+      setFormLoadState('idle');
+      setFormFound(new Set());
+      setFormRelevant(new Set());
+      return;
+    }
+
+    let cancelled = false;
+
+    (async () => {
+      let uuid = (patientUuid || billItem.patient_uuid || '').trim();
+      if (!uuid) {
+        const cr = (billItem.cr_no || '').trim();
+        if (cr) {
+          uuid = await resolvePatientUuidFromCr(cr);
+        }
+      }
+      if (!uuid) {
+        if (!cancelled) {
+          setFormLoadState('idle');
+          setFormFound(new Set());
+          setFormRelevant(new Set());
+        }
+        return;
+      }
+
+      setFormLoadState('loading');
+      let model: Awaited<ReturnType<typeof resolveAndLoadRaisePrefill>> = null;
+      try {
+        model = await resolveAndLoadRaisePrefill({
+          patientUuid: uuid,
+          encounterUuid: encounterUuidProp,
+          specialtyNeedsForm,
+        });
+      } catch {
+        if (!cancelled) {
+          setFormLoadState(needsForm ? 'done' : 'idle');
+          setFormFound(new Set());
+          setFormRelevant(new Set());
+        }
+        return;
+      }
+      if (cancelled) return;
+
+      const values = model?.formValues;
+      if (values) {
+        if (values.found.has('clinicalIndications') || values.clinicalIndications.trim()) {
+          setClinicalIndications(values.clinicalIndications);
+        }
+        if (values.found.has('startDate')) setStartDate(values.startDate);
+        if (values.found.has('sessionsRequired')) setSessionsRequired(values.sessionsRequired);
+        if (values.found.has('frequency')) setFrequency(values.frequency);
+        if (values.found.has('chiefComplaint')) setChiefComplaint(values.chiefComplaint);
+        if (values.found.has('hpi')) setHpi(values.hpi);
+        if (values.found.has('physicalExam')) setPhysicalExam(values.physicalExam);
+        if (values.found.has('investigations')) setInvestigations(values.investigations);
+        if (values.found.has('anaesthesia')) setAnaesthesia(values.anaesthesia);
+        if (values.found.has('surgeryDate')) setSurgeryDate(values.surgeryDate);
+        if (values.found.has('relatedToEmployment') && values.relatedToEmployment !== null) {
+          setRelatedToEmployment(values.relatedToEmployment);
+        }
+        if (values.found.has('relatedToAccident') && values.relatedToAccident !== null) {
+          setRelatedToAccident(values.relatedToAccident);
+        }
+        if (values.found.has('isCoInsured') && values.isCoInsured !== null) {
+          setIsCoInsured(values.isCoInsured);
+        }
+        if (values.found.has('coInsuranceDetails')) {
+          setCoInsuranceDetails(values.coInsuranceDetails);
+        }
+        if (isElective && values.expectedServiceStartDate) {
+          const d = dayjs(values.expectedServiceStartDate);
+          if (d.isValid()) setExpectedServiceStartDate(d.format('YYYY-MM-DDTHH:mm:ssZ'));
+        }
+      }
+
+      const preferredDx = model?.diagnoses?.[0];
+      if (preferredDx?.conceptUuid) {
+        encounterDxAppliedRef.current = true;
+        const hit: DiagnosisConceptHit = {
+          uuid: preferredDx.conceptUuid,
+          display: preferredDx.display || preferredDx.icd11Code || preferredDx.conceptUuid,
+          icd11Code: preferredDx.icd11Code || '',
+        };
+        applyDiagnosisPick(conceptDxPick(hit), { fromUser: false });
+        setConceptDxHits((prev) => {
+          if (prev.some((p) => p.uuid === hit.uuid)) return prev;
+          return [hit, ...prev];
+        });
+      }
+
+      const natId =
+        (model?.providerNationalId || initialDoctorNationalId || '').trim() ||
+        (initialDoctorNationalId ?? '').trim();
+      if (natId && !providerPrefillAppliedRef.current) {
+        providerPrefillAppliedRef.current = true;
+        setDoctorId(natId);
+        if (model?.providerDisplay || initialProviderDisplay) {
+          setSelectedProvider({
+            uuid: model?.providerUuid || 'prefill',
+            display: model?.providerDisplay || initialProviderDisplay || natId,
+            nationalId: natId,
+          });
+        }
+        try {
+          const results = await searchHealthWorkerRegistry({
+            identifierType: DEFAULT_DOCTOR_ID_TYPE,
+            identifierValue: natId,
+            locationUuid,
+          });
+          if (!cancelled && results[0]) {
+            setHwrHit(results[0]);
+            setRegulationBody(normalizeRegulationBody(results[0].membership?.licensing_body));
+            if (results[0].contacts?.email) {
+              setProviderEmail(results[0].contacts.email);
+            }
+          }
+        } catch {
+          // soft-fail HWR
+        }
+      }
+
+      const relevant = new Set<PreauthFormFieldKey>();
+      if (
+        specialty.requiresRadiologyPreauth ||
+        specialty.requiresOpticalPreauth ||
+        specialty.requiresRenalPreauth
+      ) {
+        // Specialty: clinical indications must come from the Pre-authorization form (locked).
+        relevant.add('clinicalIndications');
+      }
+      // Plain normal: prefill when present but keep the field editable (not formRelevant).
+      if (specialty.requiresRenalPreauth) {
+        RENAL_FORM_KEYS.forEach((k) => relevant.add(k));
+      }
+      if (specialty.requiresSurgicalPreauth) {
+        SURGICAL_FORM_KEYS.forEach((k) => relevant.add(k));
+      }
+      if (values?.isCoInsured !== true) {
+        relevant.delete('coInsuranceDetails');
+      }
+
+      setFormRelevant(relevant);
+      setFormFound(
+        values ? new Set([...relevant].filter((k) => values.found.has(k))) : new Set(),
+      );
+      setFormLoadState(needsForm || model ? 'done' : 'idle');
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    patientUuid,
+    billItem.patient_uuid,
+    isPlainNormalPreauth,
+    specialty.requiresSurgicalPreauth,
+    specialty.requiresRenalPreauth,
+    specialty.requiresRadiologyPreauth,
+    specialty.requiresOpticalPreauth,
+    locationUuid,
+  ]);
+
+  // Surgical vital_signs — concatenate today's OPD Triage vitals (editable after prefill).
+  useEffect(() => {
+    if (!specialty.requiresSurgicalPreauth) return;
+    const uuid = patientUuid || billItem.patient_uuid;
+    if (!uuid) return;
+    let cancelled = false;
+    (async () => {
+      const concat = await fetchTodaysTriageVitalsConcat(uuid, locationUuid);
+      if (!cancelled && concat) {
+        setVitalSigns((prev) => (prev.trim() ? prev : concat));
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [patientUuid, billItem.patient_uuid, locationUuid, specialty.requiresSurgicalPreauth]);
+
+  const clinicalIndicationsFieldProps = {
+    labelText: 'Clinical indications',
+    value: formFieldStatus('clinicalIndications') === 'loading' ? '' : clinicalIndications,
+    readOnly: formFieldLocked('clinicalIndications'),
+    placeholder: formFieldStatus('clinicalIndications') === 'loading' ? 'Loading clinical notes…' : undefined,
+    invalid: formFieldInvalid('clinicalIndications'),
+    invalidText: formFieldInvalid('clinicalIndications') ? FORM_MISSING_HINT : undefined,
+    onChange: (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+      if (formFieldLocked('clinicalIndications')) return;
+      markDirty();
+      setClinicalIndications(e.target.value);
+    },
+  };
+
+  const providerItemLabel = (item: OpenMrsProviderHit | null) =>
+    item ? (item.nationalId ? `${item.display} · ${item.nationalId}` : item.display) : '';
+
+  const applyProviderSelection = (hit: OpenMrsProviderHit | null) => {
+    setSelectedProvider(hit);
+    if (!hit) return;
+    markDirty();
+    if (hit.nationalId) {
+      setDoctorId(hit.nationalId);
+      void handleSearchHwr(hit.nationalId);
+    } else {
+      setDoctorId('');
+      setHwrHit(null);
+      showSnackbar({
+        kind: 'warning',
+        title: 'No National ID on provider',
+        subtitle: 'Enter the doctor National ID, then Search HWR for the regulation body.',
+      });
+    }
+  };
+
+  const handleSearchHwr = async (idOverride?: string) => {
+    const idValue = (idOverride ?? doctorId).trim();
+    if (!idValue) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Enter National ID',
+        subtitle: 'Doctor National ID is required to look up the regulation body in HWR.',
+      });
+      return;
+    }
+    setSearchingHwr(true);
+    try {
+      const results = await searchHealthWorkerRegistry({
+        identifierType: DEFAULT_DOCTOR_ID_TYPE,
+        identifierValue: idValue,
+        locationUuid,
+      });
+      const hit = results[0];
+      if (!hit) {
+        setHwrHit(null);
+        showSnackbar({ kind: 'warning', title: 'No health worker found' });
+        return;
+      }
+      setHwrHit(hit);
+      // Keep doctor ID as National ID; only take regulation body (and email) from HWR
+      const body = normalizeRegulationBody(hit.membership?.licensing_body);
+      setRegulationBody(body);
+      if (hit.contacts?.email) {
+        setProviderEmail(hit.contacts.email);
+      }
+      markDirty();
+      showSnackbar({
+        kind: 'success',
+        title: 'Regulation body from HWR',
+        subtitle: `${hit.membership?.full_name || 'Match'} · ${body}`,
+      });
+    } catch (e: any) {
+      showSnackbar({ kind: 'error', title: 'HWR search failed', subtitle: String(e?.message ?? e) });
+    } finally {
+      setSearchingHwr(false);
+    }
+  };
+
+  const handleProviderInputChange = (inputValue: string) => {
+    const selectedLabel = providerItemLabel(selectedProvider);
+    if (inputValue === selectedLabel) {
+      return;
+    }
+    if (selectedProvider) {
+      setSelectedProvider(null);
+    }
+    if (providerSearchTimer.current) {
+      clearTimeout(providerSearchTimer.current);
+    }
+    if (!inputValue || inputValue.trim().length < 2) {
+      setProviderHits([]);
+      setSearchingProviders(false);
+      return;
+    }
+    providerSearchTimer.current = setTimeout(async () => {
+      setSearchingProviders(true);
+      try {
+        const hits = await searchOpenMrsProviders(inputValue);
+        setProviderHits(hits);
+      } catch (e: any) {
+        setProviderHits([]);
+        showSnackbar({ kind: 'error', title: 'Provider search failed', subtitle: String(e?.message ?? e) });
+      } finally {
+        setSearchingProviders(false);
+      }
+    }, 300);
+  };
+
+  const requiredAttachmentsReady = useMemo(() => {
+    return attachments.filter((a) => a.required).every((a) => Boolean(a.file));
+  }, [attachments]);
+
+  const handleSendOtp = async () => {
+    if (!crNo) {
+      showSnackbar({ kind: 'error', title: 'Missing CR number', subtitle: 'Cannot send OTP without patient CR id.' });
+      return;
+    }
+    if (isElective && !selectedContactId && patientContacts.length > 0) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Select a contact',
+        subtitle: 'Confirm which patient contact should receive the OTP.',
+      });
+      return;
+    }
+    setSendingOtp(true);
+    try {
+      if (isElective) {
+        // Phase 2 step 7a — elective-only OTP helper (not normal sendClaimsOTP).
+        const response = await sendElectivePreauthOtp({
+          patientId: crNo,
+          locationUuid,
+          interventionCode: intervention.code,
+          beneficiaryContactId: selectedContactId || undefined,
+        });
+        if ((response as any)?.message?.includes('OTP') || response) {
+          setOtpSent(true);
+          setConsentDone(false);
+          showSnackbar({ kind: 'success', title: 'OTP sent' });
+        }
+      } else {
+        // Do not cancelAllPendingAuthorizations — that can wipe in-flight consent for this CR.
+        const response = await sendClaimsOTP(crNo, locationUuid, intervention.code);
+        if (response?.message?.includes('OTP') || response) {
+          setOtpSent(true);
+          setConsentDone(false);
+          showSnackbar({ kind: 'success', title: 'OTP sent' });
+        }
+      }
+    } catch (e: any) {
+      showSnackbar({ kind: 'error', title: 'Failed to send OTP', subtitle: String(e?.message ?? e) });
+    } finally {
+      setSendingOtp(false);
+    }
+  };
+
+  const resolveElectiveServiceType = (): string => {
+    const fromBill = String(billItem.service_type ?? '').trim().toUpperCase();
+    if (fromBill === 'OUTPATIENT' || fromBill === 'INPATIENT' || fromBill === 'CAPITATION') {
+      return fromBill;
+    }
+    try {
+      return getServiceType(intervention as any, 'OUTPATIENT') || 'OUTPATIENT';
+    } catch {
+      return 'OUTPATIENT';
+    }
+  };
+
+  const handleVerifyOtp = async () => {
+    if (!otp || otp.length < 4) {
+      showSnackbar({ kind: 'error', title: 'Enter OTP' });
+      return;
+    }
+
+    // Elective: Confirm OTP locally only. HIE authorize runs on Submit so Send OTP /
+    // Confirm never hit /claims-authorize or create a preauth.
+    if (isElective) {
+      setConsentDone(true);
+      showSnackbar({
+        kind: 'success',
+        title: 'OTP confirmed',
+        subtitle: 'Pre-visit authorization will be created when you submit the preauth.',
+      });
+      return;
+    }
+
+    setSendingOtp(true);
+    try {
+      const token = String(activeConsentToken || consentTokenProp || '').trim();
+      if (!token) {
+        throw new Error('A claim consent token is required.');
+      }
+      setActiveConsentToken(token);
+      setConsentDone(true);
+      showSnackbar({
+        kind: 'success',
+        title: 'Consent verified',
+      });
+    } catch (e: any) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Consent token verification failed',
+        subtitle: String(e?.message ?? e),
+      });
+    } finally {
+      setSendingOtp(false);
+    }
+  };
+
+  const handleConfirmBiometric = async () => {
+    setSendingOtp(true);
+    try {
+      if (!isElective) {
+        const token = String(activeConsentToken || consentTokenProp || '').trim();
+        if (!token) {
+          throw new Error('A claim consent token is required.');
+        }
+        setActiveConsentToken(token);
+        setConsentDone(true);
+        showSnackbar({ kind: 'success', title: 'Consent verified' });
+        return;
+      }
+
+      // Elective biometrics: after iframe authorize, resolve AUTHORIZED_PENDING_VISIT only
+      // (do not accept a visit claim token).
+      const auth = await resolvePreVisitConsentAuthorization({
+        locationUuid,
+        beneficiaryCode: crNo,
+      });
+      const token = String(auth?.token ?? '').trim();
+      const status = String(auth?.status ?? '').trim().toUpperCase();
+      if (!token) {
+        throw new Error(
+          'No pre-visit authorization found. Finish biometric authorize, then confirm here.',
+        );
+      }
+      if (status && status !== 'AUTHORIZED_PENDING_VISIT') {
+        throw new Error(
+          `Expected AUTHORIZED_PENDING_VISIT for elective preauth, got ${status}. Complete pre-visit biometric authorize first.`,
+        );
+      }
+      setActiveConsentToken(token);
+      setConsentDone(true);
+      showSnackbar({
+        kind: 'success',
+        title: 'Pre-visit authorization verified',
+        subtitle: auth?.status ? `Status: ${auth.status}` : undefined,
+      });
+    } catch (e: any) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Consent token verification failed',
+        subtitle: String(e?.message ?? e),
+      });
+    } finally {
+      setSendingOtp(false);
+    }
+  };
+
+  const handleAttachmentsChange = (updater: (prev: PreauthAttachmentRow[]) => PreauthAttachmentRow[]) => {
+    markDirty();
+    setAttachments(updater);
+  };
+
+  const addableDocTypes = useMemo(() => {
+    const attached = new Set(attachments.map((a) => a.document_type));
+    const base = optionalDocs.length > 0 ? optionalDocs : DOC_TYPE_OPTIONS;
+    return [...new Set(base)].filter((d) => !attached.has(d));
+  }, [attachments, optionalDocs]);
+
+  useEffect(
+    () => () => {
+      attachments.forEach((a) => {
+        if (a.previewUrl) URL.revokeObjectURL(a.previewUrl);
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [],
+  );
+
+  const buildPayload = (): PreauthFormPayload => {
+    // Contiguous indexes: attachments[i] → attachments_i_file_blob
+    const withFiles = attachments.filter((a) => a.file);
+    const files: Record<string, File> = {};
+    const attachmentMeta = withFiles.map((a, index) => {
+      const field = preauthAttachmentFieldName(index);
+      files[field] = a.file!;
+      return {
+        document_title: a.document_title,
+        document_type: a.document_type,
+        file_field_name: field,
+      };
+    });
+
+    // Prefer the text-box value so edits are submitted, not the launch bill line.
+    const billUnitPrice = String(unitPrice ?? billItem.item_price ?? billItem.item_total_price ?? '').trim();
+    const resolvedUnitPrice = billUnitPrice;
+
+    const payload: PreauthFormPayload = {
+      service_start: serviceStart,
+      service_end: serviceEnd,
+      items: [{ unit_price: resolvedUnitPrice || '0' }],
+      diagnoses: [{ consent_token: consentToken, icd_code: icdCode.trim() }],
+      doctors: [
+        {
+          identification_number: doctorId.trim(),
+          identification_type: DEFAULT_DOCTOR_ID_TYPE,
+          regulation_body: normalizeRegulationBody(regulationBody),
+          intervention_code: intervention.code,
+          is_primary: true,
+        },
+      ],
+      attachments: attachmentMeta,
+      provider_notification_email: providerEmail.trim(),
+      locationUuid,
+      files,
+    };
+
+    if (specialty.requiresSurgicalPreauth) {
+      payload.chief_complaint = chiefComplaint.trim();
+      payload.vital_signs = vitalSigns.trim();
+      payload.history_of_present_illness = hpi.trim();
+      payload.physical_examination = physicalExam.trim();
+      payload.investigation_report_details = investigations.trim();
+      payload.type_of_anaesthesia = anaesthesia;
+      payload.surgery_date = surgeryDate;
+      payload.is_condition_related_to_employment = relatedToEmployment;
+      payload.is_condition_related_to_auto_or_other_accident = relatedToAccident;
+      payload.is_co_insured = isCoInsured;
+      if (isCoInsured && coInsuranceDetails.trim()) {
+        payload.co_insurance_details = coInsuranceDetails.trim();
+      }
+    }
+
+    if (specialty.requiresRenalPreauth) {
+      const sessionsNum = Number(sessionsRequired);
+      payload.number_of_sessions_required = Number.isFinite(sessionsNum) ? sessionsNum : sessionsRequired;
+      payload.cost_per_session = String(costPerSession || billUnitPrice || '').trim();
+      payload.frequency_of_sessions = frequency;
+      payload.start_date = startDate;
+      payload.is_co_insured = isCoInsured;
+      if (isCoInsured && coInsuranceDetails.trim()) {
+        payload.co_insurance_details = coInsuranceDetails.trim();
+      }
+    }
+
+    if (specialty.requiresOpticalPreauth) {
+      payload.necessity_of_service = necessity.trim();
+      payload.lens_prescription = lensPrescription;
+      payload.lens_amount = lensAmount;
+      payload.eye_examination_amount = eyeExamAmount;
+      payload.frame_amount = frameAmount;
+      payload.new_or_replacement = newOrReplacement;
+    }
+
+    if (specialty.requiresOncologyPreauth) {
+      payload.carcinoma_staging = carcinomaStaging;
+      payload.comorbidity = comorbidity.trim();
+      // Always arrays — HIE: "Expected a JSON list for metastases and treatment_setting"
+      payload.metastases = [metastases];
+      payload.treatment_setting = [treatmentSetting];
+      {
+        const sessionsNum = Number(sessionsRequired);
+        payload.number_of_sessions_required = Number.isFinite(sessionsNum) ? sessionsNum : sessionsRequired;
+      }
+      payload.cost_per_session = costPerSession;
+      payload.is_co_insured = isCoInsured;
+      payload.start_date = startDate;
+      if (progressReport.trim()) {
+        payload.progress_report = progressReport.trim();
+      }
+    }
+
+    // Renal / optical / imaging / plain normal — always send when captured.
+    if (clinicalIndications.trim()) {
+      payload.clinical_indications = clinicalIndications.trim();
+    }
+
+    if (isElective) {
+      payload.expected_service_start_date = expectedServiceStartDate;
+    }
+
+    return payload;
+  };
+
+  const handleCancelExistingPreauth = async () => {
+    const code = String(intervention.code || billItem.intervention_code || '').trim();
+    const token = String(
+      existingPreauth?.consentToken || activeConsentToken || consentTokenProp || '',
+    ).trim();
+    if (!token || !code || !locationUuid) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Cannot cancel preauth',
+        subtitle: 'Missing consent token or intervention code for this preauth.',
+      });
+      return;
+    }
+    setCancellingExistingPreauth(true);
+    try {
+      await cancelPreauth({
+        consentToken: token,
+        interventionCode: code,
+        locationUuid,
+      });
+      setExistingPreauth(null);
+      showSnackbar({
+        kind: 'success',
+        title: 'Preauth cancelled',
+        subtitle: `${code} was cancelled. You can raise a new preauth.`,
+      });
+    } catch (e: any) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Cancel failed',
+        subtitle: extractHieErrorMessage(e, 'Failed to cancel preauth'),
+      });
+    } finally {
+      setCancellingExistingPreauth(false);
+    }
+  };
+
+  const handleSubmit = async () => {
+    if (!consentDone) {
+      showSnackbar({ kind: 'error', title: 'Consent required', subtitle: 'Complete OTP or biometric consent first.' });
+      return;
+    }
+    if (existingPreauth?.blocking) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Existing preauth found',
+        subtitle: `An active preauth already exists for ${intervention.code} (status: ${existingPreauth.status}${
+          existingPreauth.preauthCode ? `, code: ${existingPreauth.preauthCode}` : ''
+        }).`,
+      });
+      return;
+    }
+    if (isElective && consentMethod === 'otp' && (!otp || otp.length < 4)) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Missing OTP',
+        subtitle: 'Send OTP, enter the code, confirm it, then submit.',
+      });
+      return;
+    }
+    if (!isElective && !consentToken) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Missing authorization',
+        subtitle: 'A claim token is required.',
+      });
+      return;
+    }
+    // Prefer the text-box value so edits are validated/submitted, not the launch bill line.
+    const billUnitPrice = String(unitPrice ?? billItem.item_price ?? billItem.item_total_price ?? '').trim();
+    const resolvedUnitPrice = billUnitPrice;
+    const needsClinicalIndications =
+      isPlainNormalPreauth ||
+      specialty.requiresRadiologyPreauth ||
+      specialty.requiresRenalPreauth ||
+      specialty.requiresOpticalPreauth;
+    const missingFormFields = [...formRelevant].filter((k) => !formFound.has(k));
+    const missingRequired = [
+      !icdCode.trim() && 'ICD-11 diagnosis',
+      !doctorId.trim() && 'Doctor National ID',
+      !providerEmail.trim() && 'Provider notification email',
+      !resolvedUnitPrice &&
+        (needsBillableServicePicker ? 'Unit price (select a billable service)' : 'Unit price (from bill)'),
+      isElective && !expectedServiceStartDate && 'Expected service start date',
+      needsClinicalIndications &&
+        !clinicalIndications.trim() &&
+        (isPlainNormalPreauth
+          ? 'Clinical indications'
+          : 'Clinical indications (complete Pre-authorization form on the patient chart)'),
+      missingFormFields.length > 0 &&
+        `Pre-authorization form fields (${missingFormFields.join(', ')})`,
+    ].filter(Boolean);
+    if (missingRequired.length) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Missing required fields',
+        subtitle: `Fill: ${missingRequired.join(', ')}`,
+      });
+      return;
+    }
+    if (!requiredAttachmentsReady) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Attachments required',
+        subtitle: 'Generate or add a file for every required document, then Submit preauth.',
+      });
+      return;
+    }
+
+    setSubmitting(true);
+    abortRef.current = new AbortController();
+    try {
+      let tokenForPreauth = consentToken;
+
+      if (isElective) {
+        // Elective is pre-visit: mint AUTHORIZED_PENDING_VISIT via authorize, then POST /preauths.
+        // Do not close/reject existing open claim visits.
+        if (consentMethod === 'otp') {
+          const auth = await resolveOrCreateElectivePreVisitAuthorization({
+            patientId: crNo,
+            otp,
+            interventions: [intervention.code],
+            serviceType: resolveElectiveServiceType(),
+            locationUuid,
+            beneficiaryContactId: selectedContactId || undefined,
+          });
+          tokenForPreauth = extractElectiveAuthorizationToken(auth);
+          if (!tokenForPreauth) {
+            throw new Error('Authorize succeeded but no authorization token was returned.');
+          }
+          setActiveConsentToken(tokenForPreauth);
+        } else if (!tokenForPreauth) {
+          throw new Error(
+            'Missing pre-visit authorization token. Confirm biometric consent, then submit.',
+          );
+        }
+      } else {
+        await ensureInterventionOnVisit(tokenForPreauth, intervention.code, locationUuid);
+      }
+
+      const payload = buildPayload();
+      if (isElective && tokenForPreauth) {
+        payload.diagnoses = (payload.diagnoses ?? []).map((d) => ({
+          ...d,
+          consent_token: tokenForPreauth,
+        }));
+      }
+      if (isElective) {
+        await createElectivePreauth(
+          payload,
+          {
+            code: interventionForSubmit.code,
+            requiresRadiologyPreauth: interventionForSubmit.requiresRadiologyPreauth,
+            requiresOncologyPreauth: interventionForSubmit.requiresOncologyPreauth,
+            requiresOpticalPreauth: interventionForSubmit.requiresOpticalPreauth,
+            requiresRenalPreauth: interventionForSubmit.requiresRenalPreauth,
+            requiresSurgicalPreauth: interventionForSubmit.requiresSurgicalPreauth,
+          },
+          tokenForPreauth,
+        );
+      } else {
+        await createPreauth(
+          payload,
+          {
+            code: interventionForSubmit.code,
+            requiresRadiologyPreauth: interventionForSubmit.requiresRadiologyPreauth,
+            requiresOncologyPreauth: interventionForSubmit.requiresOncologyPreauth,
+            requiresOpticalPreauth: interventionForSubmit.requiresOpticalPreauth,
+            requiresRenalPreauth: interventionForSubmit.requiresRenalPreauth,
+            requiresSurgicalPreauth: interventionForSubmit.requiresSurgicalPreauth,
+          },
+          tokenForPreauth,
+        );
+      }
+
+      setPolling(true);
+      const polled = await pollPreauthUntilSubmitted(
+        tokenForPreauth,
+        locationUuid,
+        intervention.code,
+        { signal: abortRef.current.signal },
+      );
+      const status = polled.status;
+      const preauthCode = polled.preauthCode;
+
+      if (preauthCode) {
+        storePreauthCode(tokenForPreauth, intervention.code, preauthCode);
+      }
+
+      // Sync selected ICD onto the claim (normal / post-claim only).
+      if (!isElective) {
+        try {
+          const visitDx = selectedDx?.kind === 'visit' ? selectedDx.dx : null;
+          await addClaimDiagnosis({
+            consentToken: tokenForPreauth,
+            interventionCode: intervention.code,
+            icdCode: icdCode.trim(),
+            locationUuid,
+            practitionerIdentificationNumber: (visitDx?.practioner_nat_id || doctorId || '').trim(),
+            practitionerIdentificationType: DEFAULT_DOCTOR_ID_TYPE,
+            practitionerRegulationBody: normalizeRegulationBody(
+              visitDx?.practitioner_body || regulationBody,
+            ),
+          });
+        } catch {
+          // Preauth succeeded; claim diagnosis can still be added from bill details.
+        }
+      }
+
+      const awaitingDoctor = status === 'PENDING_DOCTOR_APPROVAL';
+      showSnackbar({
+        kind: 'success',
+        title: awaitingDoctor
+          ? isElective
+            ? 'Elective preauth submitted'
+            : 'Preauth submitted'
+          : status === 'FINALISED' || status === 'FINALIZED'
+            ? 'Preauth finalised'
+            : 'Preauth submitted',
+        subtitle: awaitingDoctor
+          ? 'Awaiting doctor approval. Track progress on the Preauthorizations Status tab.'
+          : preauthCode
+            ? `Code: ${preauthCode}`
+            : `Status: ${status}`,
+      });
+      onSuccess?.({ consentToken: tokenForPreauth, preauthCode, status });
+      allowCloseWithoutPromptRef.current = true;
+      setDirty(false);
+      setSubmitting(false);
+      setPolling(false);
+      void closeWorkspace({ discardUnsavedChanges: true });
+    } catch (e: any) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Preauth failed',
+        subtitle: extractHieErrorMessage(e, 'Failed to create preauth'),
+      });
+    } finally {
+      if (!allowCloseWithoutPromptRef.current) {
+        setSubmitting(false);
+        setPolling(false);
+      }
+    }
+  };
+
+  if (!isElective && !consentToken) {
+    return null;
+  }
+
+  return (
+    <Workspace2
+      title={t('raisePreauth', 'Raise preauth')}
+      hasUnsavedChanges={!allowCloseWithoutPromptRef.current && (dirty || submitting || polling)}
+    >
+      <Form className={styles.form}>
+      <div className={styles.body}>
+        <div className={styles.header}>
+          <div>
+            <h4>{t('raisePreauth', 'Raise preauth')}</h4>
+            <p className={styles.muted}>
+              {patientName} · {intervention.code} · {billableService}
+            </p>
+          </div>
+          <Tag type={isElective ? 'magenta' : 'blue'} size="md">
+            {isElective ? 'Elective' : specialtyLabel} preauth
+          </Tag>
+        </div>
+
+        {checkingExistingPreauth ? (
+          <InlineLoading description="Checking for existing preauth…" />
+        ) : existingPreauth ? (
+          <div
+            className={`${styles.existingBanner} ${
+              existingPreauth.blocking ? styles.existingBannerError : styles.existingBannerWarning
+            }`}
+            role="status"
+          >
+            <p className={styles.existingBannerTitle}>
+              {existingPreauth.blocking ? 'Existing active preauth' : 'Prior preauth found'}
+            </p>
+            <p className={styles.existingBannerMeta}>
+              {[
+                `SHA ${intervention.code}`,
+                `Status: ${existingPreauth.status}`,
+                existingPreauth.preauthCode ? `Code: ${existingPreauth.preauthCode}` : null,
+              ]
+                .filter(Boolean)
+                .join(' · ')}
+            </p>
+            <p className={styles.existingBannerHint}>
+              {existingPreauth.blocking
+                ? 'Submit is blocked to avoid duplicates.'
+                : String(existingPreauth.status).toUpperCase().includes('EXPIRED')
+                  ? 'This preauth has expired. You can raise a new one.'
+                  : 'You may resubmit after correcting the prior request.'}
+            </p>
+            <div className={styles.existingBannerActions}>
+              <button
+                type="button"
+                className={styles.existingBannerCancel}
+                onClick={() => void handleCancelExistingPreauth()}
+                disabled={submitting || polling || cancellingExistingPreauth}
+              >
+                {cancellingExistingPreauth ? 'Cancelling…' : 'Cancel preauth'}
+              </button>
+            </div>
+          </div>
+        ) : null}
+
+        {isElective ? (
+          <section className={styles.section}>
+            <h5>Expected service start</h5>
+            <DatePicker
+              datePickerType="single"
+              dateFormat="Y-m-d"
+              value={expectedServiceStartDate ? dayjs(expectedServiceStartDate).toDate() : undefined}
+              onChange={(dates: Date[]) => {
+                markDirty();
+                if (dates?.[0]) setExpectedServiceStartDate(dateToServiceIso(dates[0]));
+              }}
+            >
+              <DatePickerInput
+                id="expected-service-start"
+                labelText="Expected service start date"
+                placeholder="yyyy-mm-dd"
+              />
+            </DatePicker>
+          </section>
+        ) : null}
+
+        <section className={styles.section}>
+          <h5>Consent</h5>
+          <RadioButtonGroup
+            legendText="Consent method"
+            name="consent-method"
+            valueSelected={consentMethod}
+            onChange={(v) => {
+              setConsentMethod(v as 'biometric' | 'otp');
+              setConsentDone(false);
+            }}
+          >
+            <RadioButton labelText="OTP" value="otp" id="preauth-otp" />
+            <RadioButton labelText="Biometrics" value="biometric" id="preauth-bio" />
+          </RadioButtonGroup>
+          {consentMethod === 'otp' ? (
+            <div className={styles.row}>
+              {isElective ? (
+                loadingContacts ? (
+                  <InlineLoading description="Loading contacts…" />
+                ) : (
+                  <Dropdown
+                    id="preauth-otp-contact"
+                    titleText="Patient contact (OTP)"
+                    label="Select contact"
+                    items={patientContacts}
+                    itemToString={(item: PatientContactResult | null) =>
+                      item
+                        ? `${item.contactType || 'Contact'}: ${item.contactValue}${
+                            item.isConfirmed ? ' (confirmed)' : ''
+                          }`
+                        : ''
+                    }
+                    selectedItem={
+                      patientContacts.find((c) => String(c.id) === selectedContactId) ?? null
+                    }
+                    onChange={({ selectedItem }) => {
+                      setSelectedContactId(selectedItem?.id != null ? String(selectedItem.id) : '');
+                      setOtpSent(false);
+                      setConsentDone(false);
+                      setOtp('');
+                    }}
+                  />
+                )
+              ) : null}
+              <Button
+                type="button"
+                kind="tertiary"
+                size="sm"
+                onClick={handleSendOtp}
+                disabled={
+                  sendingOtp ||
+                  consentDone ||
+                  (isElective && (loadingContacts || (!selectedContactId && patientContacts.length > 0)))
+                }
+              >
+                {sendingOtp ? <InlineLoading description="Sending…" /> : 'Send OTP'}
+              </Button>
+              <TextInput
+                id="preauth-otp-input"
+                labelText="OTP"
+                value={otp}
+                disabled={!otpSent || consentDone}
+                onChange={(e) => setOtp(e.target.value)}
+              />
+              <Button
+                type="button"
+                kind="primary"
+                size="sm"
+                onClick={handleVerifyOtp}
+                disabled={!otpSent || consentDone}
+              >
+                Confirm OTP
+              </Button>
+            </div>
+          ) : (
+            <div className={styles.row}>
+              <p className={styles.muted}>
+                Complete biometric capture on the patient device, then confirm below.
+              </p>
+              <Button kind="primary" size="sm" onClick={handleConfirmBiometric} disabled={consentDone}>
+                Confirm biometric consent
+              </Button>
+            </div>
+          )}
+          {consentDone ? <Tag type="green" size="sm">Consent complete</Tag> : null}
+        </section>
+
+        <section className={styles.section}>
+          <h5>Service &amp; provider</h5>
+          <div className={styles.row}>
+            <DatePicker
+              datePickerType="single"
+              dateFormat="Y-m-d"
+              value={serviceStart ? dayjs(serviceStart).toDate() : undefined}
+              onChange={([date]) => {
+                if (!date) return;
+                markDirty();
+                setServiceStart(dateToServiceIso(date, dayjs(serviceStart).format('HH:mm:ss')));
+              }}
+            >
+              <DatePickerInput id="preauth-service-start" labelText="Service start" placeholder="yyyy-mm-dd" />
+            </DatePicker>
+            <TextInput
+              id="preauth-service-start-time"
+              type="time"
+              labelText="Start time"
+              value={dayjs(serviceStart).format('HH:mm')}
+              onChange={(e) => {
+                markDirty();
+                setServiceStart(dateToServiceIso(dayjs(serviceStart).toDate(), `${e.target.value}:00`));
+              }}
+            />
+          </div>
+          <div className={styles.row}>
+            <DatePicker
+              datePickerType="single"
+              dateFormat="Y-m-d"
+              value={serviceEnd ? dayjs(serviceEnd).toDate() : undefined}
+              onChange={([date]) => {
+                if (!date) return;
+                markDirty();
+                setServiceEnd(dateToServiceIso(date, dayjs(serviceEnd).format('HH:mm:ss')));
+              }}
+            >
+              <DatePickerInput id="preauth-service-end" labelText="Service end" placeholder="yyyy-mm-dd" />
+            </DatePicker>
+            <TextInput
+              id="preauth-service-end-time"
+              type="time"
+              labelText="End time"
+              value={dayjs(serviceEnd).format('HH:mm')}
+              onChange={(e) => {
+                markDirty();
+                setServiceEnd(dateToServiceIso(dayjs(serviceEnd).toDate(), `${e.target.value}:00`));
+              }}
+            />
+          </div>
+
+          <TextInput
+            id="provider-email"
+            labelText="Provider notification email"
+            value={providerEmail}
+            onChange={(e) => {
+              markDirty();
+              setProviderEmail(e.target.value);
+            }}
+          />
+
+          {needsBillableServicePicker ? (
+            <div className={styles.searchBlock}>
+              <p className={styles.fieldHint}>
+                No unit price on a patient bill for this intervention. Select a billable service to
+                use its SHA tariff as the preauth unit price.
+              </p>
+              {loadingBillableItems ? (
+                <InlineLoading description="Loading billable services…" />
+              ) : (
+                <ComboBox
+                  id="preauth-billable-service"
+                  titleText="Billable service"
+                  placeholder="Search billable service"
+                  items={(billableItems ?? []) as BillableServiceOption[]}
+                  itemToString={(item: BillableServiceOption | null) => item?.name ?? ''}
+                  selectedItem={selectedBillableService}
+                  onChange={({ selectedItem }) => {
+                    markDirty();
+                    const item = (selectedItem as BillableServiceOption | null) ?? null;
+                    setSelectedBillableService(item);
+                    const price = unitPriceFromBillableService(item, shaPaymentModeUuid);
+                    setUnitPrice(price);
+                    if (price) {
+                      setCostPerSession((prev) => (prev.trim() ? prev : price));
+                    }
+                  }}
+                />
+              )}
+              {selectedBillableService && !unitPrice.trim() ? (
+                <InlineNotification
+                  kind="warning"
+                  lowContrast
+                  hideCloseButton
+                  title="No price on service"
+                  subtitle="This billable service has no SHA (or other) price configured."
+                />
+              ) : null}
+            </div>
+          ) : null}
+          {!billPriceLookupDone && isElective ? (
+            <InlineLoading description="Looking up unit price from patient bills…" />
+          ) : null}
+          <TextInput
+            id="unit-price"
+            labelText={
+              needsBillableServicePicker ? 'Unit price (from billable service)' : 'Unit price (from bill)'
+            }
+            type="number"
+            value={unitPrice}
+            onChange={(e) => {
+              markDirty();
+              setUnitPrice(e.target.value);
+            }}
+          />
+
+          <div className={styles.searchBlock}>
+            <p className={styles.fieldHint}>
+              Diagnosis (ICD-11). Prefills rank 1 when available; choose another if needed.
+            </p>
+            {loadingDx ? (
+              <InlineLoading description="Loading patient diagnoses…" />
+            ) : (
+              <ComboBox
+                id="preauth-diagnosis"
+                titleText="Select diagnosis"
+                placeholder="Search diagnosis / ICD-11 code"
+                items={diagnosisItems}
+                itemToString={diagnosisPickLabel}
+                selectedItem={selectedDx}
+                shouldFilterItem={() => true}
+                onInputChange={handleDiagnosisInputChange}
+                onChange={({ selectedItem }) => {
+                  applyDiagnosisPick(selectedItem as DiagnosisPick | null, { fromUser: true });
+                  if (selectedItem) {
+                    setConceptDxHits([]);
+                  }
+                }}
+              />
+            )}
+            {searchingDx ? <InlineLoading description="Searching concepts…" /> : null}
+            <TextInput
+              id="preauth-icd11"
+              labelText="ICD-11 code"
+              placeholder="Filled from selection (or type manually)"
+              value={icdCode}
+              onChange={(e) => {
+                markDirty();
+                setIcdCode(e.target.value.trim());
+              }}
+            />
+          </div>
+
+          <div className={styles.searchBlock}>
+            <p className={styles.fieldHint}>Search OpenMRS providers</p>
+            <ComboBox
+              id="preauth-provider"
+              titleText="Provider"
+              placeholder="Type at least 2 characters to search"
+              items={providerHits}
+              itemToString={providerItemLabel}
+              selectedItem={selectedProvider}
+              shouldFilterItem={() => true}
+              onInputChange={handleProviderInputChange}
+              onChange={({ selectedItem }) => applyProviderSelection(selectedItem as OpenMrsProviderHit | null)}
+            />
+            {searchingProviders ? <InlineLoading description="Searching providers…" /> : null}
+          </div>
+
+          <div className={styles.row}>
+            <TextInput
+              id="doctor-id"
+              labelText="Doctor National ID"
+              value={doctorId}
+              onChange={(e) => {
+                markDirty();
+                setDoctorId(e.target.value);
+                setHwrHit(null);
+              }}
+            />
+            <TextInput
+              id="doctor-id-type"
+              labelText="Doctor ID type"
+              value={DEFAULT_DOCTOR_ID_TYPE}
+              readOnly
+            />
+            <Button kind="tertiary" size="md" onClick={() => handleSearchHwr()} disabled={searchingHwr || !doctorId.trim()}>
+              {searchingHwr ? 'Searching HWR…' : 'Search HWR (body)'}
+            </Button>
+          </div>
+          {hwrHit ? (
+            <Tag type="green" size="sm">
+              {hwrHit.membership?.full_name || 'Match'} · {normalizeRegulationBody(hwrHit.membership?.licensing_body)}
+            </Tag>
+          ) : null}
+          <div className={styles.row}>
+            <Dropdown
+              id="reg-body"
+              titleText="Regulation body"
+              label="Select regulation body"
+              items={[...REGULATION_BODIES]}
+              selectedItem={normalizeRegulationBody(regulationBody)}
+              onChange={({ selectedItem }) => {
+                markDirty();
+                setRegulationBody(normalizeRegulationBody(selectedItem));
+              }}
+            />
+            <p className={styles.fieldHint}>COC = Clinical Officers Council · NCK = Nursing Council of Kenya</p>
+          </div>
+        </section>
+
+        {isPlainNormalPreauth ? (
+          <section className={styles.section}>
+            <h5>Clinical indications</h5>
+            <TextArea id="normal-clinical-indications" {...clinicalIndicationsFieldProps} />
+          </section>
+        ) : null}
+
+        {specialty.requiresSurgicalPreauth ? (
+          <section className={styles.section}>
+            <h5>Surgical preauth</h5>
+            <TextArea
+              id="chief-complaint"
+              labelText="Chief complaint"
+              value={formFieldStatus('chiefComplaint') === 'loading' ? '' : chiefComplaint}
+              readOnly={formFieldLocked('chiefComplaint')}
+              invalid={formFieldInvalid('chiefComplaint')}
+              invalidText={formFieldInvalid('chiefComplaint') ? FORM_MISSING_HINT : undefined}
+              onChange={(e) => {
+                if (formFieldLocked('chiefComplaint')) return;
+                markDirty();
+                setChiefComplaint(e.target.value);
+              }}
+            />
+            <TextInput
+              id="vital-signs"
+              labelText="Vital signs"
+              value={vitalSigns}
+              onChange={(e) => {
+                markDirty();
+                setVitalSigns(e.target.value);
+              }}
+            />
+            <TextArea
+              id="hpi"
+              labelText="History of present illness"
+              value={formFieldStatus('hpi') === 'loading' ? '' : hpi}
+              readOnly={formFieldLocked('hpi')}
+              invalid={formFieldInvalid('hpi')}
+              invalidText={formFieldInvalid('hpi') ? FORM_MISSING_HINT : undefined}
+              onChange={(e) => {
+                if (formFieldLocked('hpi')) return;
+                markDirty();
+                setHpi(e.target.value);
+              }}
+            />
+            <TextArea
+              id="physical-exam"
+              labelText="Physical examination"
+              value={formFieldStatus('physicalExam') === 'loading' ? '' : physicalExam}
+              readOnly={formFieldLocked('physicalExam')}
+              invalid={formFieldInvalid('physicalExam')}
+              invalidText={formFieldInvalid('physicalExam') ? FORM_MISSING_HINT : undefined}
+              onChange={(e) => {
+                if (formFieldLocked('physicalExam')) return;
+                markDirty();
+                setPhysicalExam(e.target.value);
+              }}
+            />
+            <TextArea
+              id="investigations"
+              labelText="Investigation report details"
+              value={formFieldStatus('investigations') === 'loading' ? '' : investigations}
+              readOnly={formFieldLocked('investigations')}
+              invalid={formFieldInvalid('investigations')}
+              invalidText={formFieldInvalid('investigations') ? FORM_MISSING_HINT : undefined}
+              onChange={(e) => {
+                if (formFieldLocked('investigations')) return;
+                markDirty();
+                setInvestigations(e.target.value);
+              }}
+            />
+            <div className={styles.row}>
+              <Dropdown
+                id="anaesthesia"
+                titleText="Type of anaesthesia"
+                label="Select"
+                items={ANAESTHESIA}
+                selectedItem={anaesthesia || null}
+                disabled={formFieldLocked('anaesthesia')}
+                invalid={formFieldInvalid('anaesthesia')}
+                invalidText={formFieldInvalid('anaesthesia') ? FORM_MISSING_HINT : undefined}
+                onChange={({ selectedItem }) => {
+                  if (formFieldLocked('anaesthesia')) return;
+                  markDirty();
+                  setAnaesthesia(selectedItem ?? '');
+                }}
+              />
+              <DatePicker
+                datePickerType="single"
+                dateFormat="Y-m-d"
+                value={surgeryDate ? dayjs(surgeryDate).toDate() : undefined}
+                onChange={(dates: Date[]) => {
+                  if (formFieldLocked('surgeryDate')) return;
+                  markDirty();
+                  if (dates?.[0]) setSurgeryDate(dateToServiceIso(dates[0]));
+                }}
+              >
+                <DatePickerInput
+                  id="surgery-date"
+                  labelText="Surgery date"
+                  placeholder="yyyy-mm-dd"
+                  readOnly={formFieldLocked('surgeryDate')}
+                  invalid={formFieldInvalid('surgeryDate')}
+                  invalidText={formFieldInvalid('surgeryDate') ? FORM_MISSING_HINT : undefined}
+                />
+              </DatePicker>
+            </div>
+            <div className={styles.row}>
+              <Checkbox
+                id="related-employment"
+                labelText="Related to employment"
+                checked={relatedToEmployment}
+                readOnly={formFieldLocked('relatedToEmployment')}
+                onChange={(_, { checked }) => {
+                  if (formFieldLocked('relatedToEmployment')) return;
+                  markDirty();
+                  setRelatedToEmployment(checked);
+                }}
+              />
+              <Checkbox
+                id="related-accident"
+                labelText="Related to auto/other accident"
+                checked={relatedToAccident}
+                readOnly={formFieldLocked('relatedToAccident')}
+                onChange={(_, { checked }) => {
+                  if (formFieldLocked('relatedToAccident')) return;
+                  markDirty();
+                  setRelatedToAccident(checked);
+                }}
+              />
+              <Checkbox
+                id="surgical-co-insured"
+                labelText="Is co-insured"
+                checked={isCoInsured}
+                readOnly={formFieldLocked('isCoInsured')}
+                onChange={(_, { checked }) => {
+                  if (formFieldLocked('isCoInsured')) return;
+                  markDirty();
+                  setIsCoInsured(checked);
+                }}
+              />
+            </div>
+            {formFieldInvalid('relatedToEmployment') ||
+            formFieldInvalid('relatedToAccident') ||
+            formFieldInvalid('isCoInsured') ? (
+              <InlineNotification
+                kind="error"
+                lowContrast
+                hideCloseButton
+                title="Missing Pre-authorization form answers"
+                subtitle={FORM_MISSING_HINT}
+              />
+            ) : null}
+            {isCoInsured ? (
+              <TextArea
+                id="co-insurance-details"
+                labelText="Co-insurance details"
+                value={formFieldStatus('coInsuranceDetails') === 'loading' ? '' : coInsuranceDetails}
+                readOnly={formFieldLocked('coInsuranceDetails')}
+                invalid={formFieldInvalid('coInsuranceDetails')}
+                invalidText={formFieldInvalid('coInsuranceDetails') ? FORM_MISSING_HINT : undefined}
+                onChange={(e) => {
+                  if (formFieldLocked('coInsuranceDetails')) return;
+                  markDirty();
+                  setCoInsuranceDetails(e.target.value);
+                }}
+              />
+            ) : null}
+          </section>
+        ) : null}
+
+        {specialty.requiresRenalPreauth ? (
+          <section className={styles.section}>
+            <h5>Renal preauth</h5>
+            <div className={styles.row}>
+              <TextInput
+                id="sessions-required"
+                labelText="Number of sessions required"
+                value={formFieldStatus('sessionsRequired') === 'loading' ? '' : sessionsRequired}
+                readOnly={formFieldLocked('sessionsRequired')}
+                invalid={formFieldInvalid('sessionsRequired')}
+                invalidText={formFieldInvalid('sessionsRequired') ? FORM_MISSING_HINT : undefined}
+                onChange={(e) => {
+                  if (formFieldLocked('sessionsRequired')) return;
+                  markDirty();
+                  setSessionsRequired(e.target.value);
+                }}
+              />
+              <TextInput
+                id="cost-per-session"
+                labelText="Cost per session"
+                value={costPerSession}
+                onChange={(e) => {
+                  markDirty();
+                  setCostPerSession(e.target.value);
+                }}
+              />
+              <Dropdown
+                id="frequency"
+                titleText="Frequency of sessions"
+                label="Select"
+                items={FREQUENCY}
+                selectedItem={frequency || null}
+                disabled={formFieldLocked('frequency')}
+                invalid={formFieldInvalid('frequency')}
+                invalidText={formFieldInvalid('frequency') ? FORM_MISSING_HINT : undefined}
+                onChange={({ selectedItem }) => {
+                  if (formFieldLocked('frequency')) return;
+                  markDirty();
+                  setFrequency(selectedItem ?? '');
+                }}
+              />
+            </div>
+            <TextArea id="renal-indications" {...clinicalIndicationsFieldProps} />
+            <div className={styles.row}>
+              <DatePicker
+                datePickerType="single"
+                dateFormat="Y-m-d"
+                value={startDate ? dayjs(startDate).toDate() : undefined}
+                onChange={(dates: Date[]) => {
+                  if (formFieldLocked('startDate')) return;
+                  markDirty();
+                  if (dates?.[0]) setStartDate(dateToServiceIso(dates[0]));
+                }}
+              >
+                <DatePickerInput
+                  id="renal-start"
+                  labelText="Start date"
+                  placeholder="yyyy-mm-dd"
+                  readOnly={formFieldLocked('startDate')}
+                  invalid={formFieldInvalid('startDate')}
+                  invalidText={formFieldInvalid('startDate') ? FORM_MISSING_HINT : undefined}
+                />
+              </DatePicker>
+              <Checkbox
+                id="renal-co-insured"
+                labelText="Is co-insured"
+                checked={isCoInsured}
+                readOnly={formFieldLocked('isCoInsured')}
+                onChange={(_, { checked }) => {
+                  if (formFieldLocked('isCoInsured')) return;
+                  markDirty();
+                  setIsCoInsured(checked);
+                }}
+              />
+            </div>
+            {formFieldInvalid('isCoInsured') ? (
+              <InlineNotification
+                kind="error"
+                lowContrast
+                hideCloseButton
+                title="Missing co-insured answer"
+                subtitle={FORM_MISSING_HINT}
+              />
+            ) : null}
+            {isCoInsured ? (
+              <TextArea
+                id="renal-co-insurance-details"
+                labelText="Co-insurance details"
+                value={formFieldStatus('coInsuranceDetails') === 'loading' ? '' : coInsuranceDetails}
+                readOnly={formFieldLocked('coInsuranceDetails')}
+                invalid={formFieldInvalid('coInsuranceDetails')}
+                invalidText={formFieldInvalid('coInsuranceDetails') ? FORM_MISSING_HINT : undefined}
+                onChange={(e) => {
+                  if (formFieldLocked('coInsuranceDetails')) return;
+                  markDirty();
+                  setCoInsuranceDetails(e.target.value);
+                }}
+              />
+            ) : null}
+          </section>
+        ) : null}
+
+        {specialty.requiresOpticalPreauth ? (
+          <section className={styles.section}>
+            <h5>Optical preauth</h5>
+            <TextArea id="optical-indications" {...clinicalIndicationsFieldProps} />
+            <TextArea
+              id="necessity"
+              labelText="Necessity of service"
+              value={necessity}
+              onChange={(e) => {
+                markDirty();
+                setNecessity(e.target.value);
+              }}
+            />
+            <div className={styles.row}>
+              <Dropdown
+                id="lens-rx"
+                titleText="Lens prescription"
+                label="Select"
+                items={LENS}
+                selectedItem={lensPrescription || null}
+                onChange={({ selectedItem }) => {
+                  markDirty();
+                  setLensPrescription(selectedItem ?? '');
+                }}
+              />
+              <Dropdown
+                id="new-or-repl"
+                titleText="New or replacement"
+                label="Select"
+                items={NEW_OR_REPL}
+                selectedItem={newOrReplacement || null}
+                onChange={({ selectedItem }) => {
+                  markDirty();
+                  setNewOrReplacement(selectedItem ?? '');
+                }}
+              />
+            </div>
+            <div className={styles.row}>
+              <TextInput
+                id="lens-amount"
+                labelText="Lens amount"
+                value={lensAmount}
+                onChange={(e) => {
+                  markDirty();
+                  setLensAmount(e.target.value);
+                }}
+              />
+              <TextInput
+                id="eye-exam-amount"
+                labelText="Eye examination amount"
+                value={eyeExamAmount}
+                onChange={(e) => {
+                  markDirty();
+                  setEyeExamAmount(e.target.value);
+                }}
+              />
+              <TextInput
+                id="frame-amount"
+                labelText="Frame amount"
+                value={frameAmount}
+                onChange={(e) => {
+                  markDirty();
+                  setFrameAmount(e.target.value);
+                }}
+              />
+            </div>
+          </section>
+        ) : null}
+
+        {specialty.requiresOncologyPreauth ? (
+          <section className={styles.section}>
+            <h5>Oncology preauth</h5>
+            <div className={styles.row}>
+              <Dropdown
+                id="carcinoma-staging"
+                titleText="Carcinoma staging"
+                label="Select"
+                items={STAGING}
+                selectedItem={carcinomaStaging || null}
+                onChange={({ selectedItem }) => {
+                  markDirty();
+                  setCarcinomaStaging(selectedItem ?? '');
+                }}
+              />
+              <Dropdown
+                id="metastases"
+                titleText="Metastases"
+                label="Select"
+                items={METASTASES}
+                selectedItem={metastases || null}
+                onChange={({ selectedItem }) => {
+                  markDirty();
+                  setMetastases(selectedItem ?? '');
+                }}
+              />
+              <Dropdown
+                id="treatment-setting"
+                titleText="Treatment setting"
+                label="Select"
+                items={TREATMENT}
+                selectedItem={treatmentSetting || null}
+                onChange={({ selectedItem }) => {
+                  markDirty();
+                  setTreatmentSetting(selectedItem ?? '');
+                }}
+              />
+            </div>
+            <TextArea
+              id="comorbidity"
+              labelText="Comorbidity"
+              value={comorbidity}
+              onChange={(e) => {
+                markDirty();
+                setComorbidity(e.target.value);
+              }}
+            />
+            <TextArea
+              id="progress-report"
+              labelText="Progress report"
+              value={progressReport}
+              onChange={(e) => {
+                markDirty();
+                setProgressReport(e.target.value);
+              }}
+            />
+            <div className={styles.row}>
+              <DatePicker
+                datePickerType="single"
+                dateFormat="Y-m-d"
+                value={startDate ? dayjs(startDate).toDate() : undefined}
+                onChange={(dates: Date[]) => {
+                  markDirty();
+                  if (dates?.[0]) setStartDate(dateToServiceIso(dates[0]));
+                }}
+              >
+                <DatePickerInput id="oncology-start" labelText="Start date" placeholder="yyyy-mm-dd" />
+              </DatePicker>
+            </div>
+            <div className={styles.row}>
+              <TextInput
+                id="onc-sessions"
+                labelText="Number of sessions required"
+                value={sessionsRequired}
+                onChange={(e) => {
+                  markDirty();
+                  setSessionsRequired(e.target.value);
+                }}
+              />
+              <TextInput
+                id="onc-cost"
+                labelText="Cost per session"
+                value={costPerSession}
+                onChange={(e) => {
+                  markDirty();
+                  setCostPerSession(e.target.value);
+                }}
+              />
+              <Checkbox
+                id="onc-co-insured"
+                labelText="Is co-insured"
+                checked={isCoInsured}
+                onChange={(_, { checked }) => {
+                  markDirty();
+                  setIsCoInsured(checked);
+                }}
+              />
+            </div>
+          </section>
+        ) : null}
+
+        {specialty.requiresRadiologyPreauth ? (
+          <section className={styles.section}>
+            <h5>Imaging / radiology preauth</h5>
+            <TextArea id="imaging-indications" {...clinicalIndicationsFieldProps} />
+          </section>
+        ) : null}
+
+        <PreauthAttachments
+          attachments={attachments}
+          onChange={handleAttachmentsChange}
+          addableDocTypes={addableDocTypes}
+          billItem={billItem as Record<string, unknown>}
+          intervention={interventionForSubmit}
+          disabled={submitting || polling}
+        />
+      </div>
+
+      <ButtonSet className={styles.buttonSet}>
+        <Button kind="secondary" onClick={() => closeWorkspace()} disabled={submitting || polling}>
+          Cancel
+        </Button>
+        <Button
+          kind="primary"
+          onClick={handleSubmit}
+          disabled={!consentDone || submitting || polling || Boolean(existingPreauth?.blocking) || checkingExistingPreauth}
+        >
+          {polling ? (
+            <InlineLoading description="Confirming submission…" />
+          ) : submitting ? (
+            <InlineLoading description="Submitting…" />
+          ) : (
+            t('submitPreauth', 'Submit preauth')
+          )}
+        </Button>
+      </ButtonSet>
+      </Form>
+    </Workspace2>
+  );
+};
+
+const PreauthWorkspace: React.FC<Workspace2DefinitionProps<PreauthWorkspaceProps>> = ({
+  workspaceProps,
+  closeWorkspace,
+}) => {
+  if (!workspaceProps) {
+    return (
+      <Workspace2 title="Raise Preauth">
+        <div />
+      </Workspace2>
+    );
+  }
+  const props = workspaceProps ?? ({} as PreauthWorkspaceProps);
+  return (
+    <PreauthForm
+      key={`${props.consentToken}::${props.intervention?.code ?? ''}`}
+      {...props}
+      closeWorkspace={closeWorkspace}
+    />
+  );
+};
+
+export default PreauthWorkspace;