; PhUCKIT RC30 - ambulatory and acute reconciliation
; © 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.
; =================================================================================================
;  Pharmacist Utility for Clinical Knowledge & Inpatient Tools.ahk — COMPLETE
;
;  2026-07-23  PATIENT HUB REBUILD (implements TEst_Improvements_to_PhUCKIT.txt)
;    DONE  Phase 1-6 clinical workspace modules:
;          - shared patient context with provenance, units, timestamps (PCtx_*)
;          - multi-screen capture session, identity reconciliation, merge rules, captures panel
;          - screen-type recognition; lab time series
;          - ingredient-level drug normalization + brand/salt/combination handling (RxN_*)
;          - tiered allergy engine: exact -> combination-ingredient -> class caution (Allergy_*)
;          - six-column safety strip RENAL/QT/BEERS/MG/G6P/CRUSH (Safety_*)
;          - versioned reference data under <script>\data\ with seed + graceful failure (RefData_*)
;          - rebuilt Ctrl-held screen capture patient hub, tabbed Edit Captured Data, structured report
;          - RSI presentation redesign
;          - Renal Dose Screening, Lab Corrections, Medication Risk Stack
;          - Anticoagulation, TLS Surveillance, Infusion/MAR, Nutrition & Electrolytes
;    Deferred: data-driven Quick Links menu restructure (§6), full indication-specific renal
;              monographs and institution-reviewed dose targets.
; vNext9: integration-audit build; adds version-aware reference seed migration with backups.
; vNext10: hardened integration build; unifies renal rule lookup, scopes tube logic per order,
;          adds OCR safety gates, and sizes the patient workspace to the monitor work area.
;
;  FUTURE TASK LIST:
;    - Renal Dosing Library (separate Renal_Dosing.ahk project) — paused pending redesign
;        of the paste/parse workflow. Re-add "Renal Dosing…" menu item + LaunchRenalDosing()
;        once that script is stable.
; =================================================================================================

#Requires AutoHotkey v2.0
#SingleInstance Force
; #Warn VarUnset, Off   ; <- was hiding exactly the class of bug that produced
;                      ;    "This local variable has not been assigned a value."
#Warn VarUnset, OutputDebug

; -------------------------------------------------------------------------------------------------
; APP IDENTITY / FILE PATHS
; -------------------------------------------------------------------------------------------------

global BUD_AnchorOffsetSec := 0
global CombinedSmoke := A_Args.Length > 0 && A_Args[1] = "--smoke-test"
global MCDS_SearchText := "Override Reason"
global MCDS_OverrideOption := "Pharmacist Clinical Judgement"
global MCDS_AutoContinue := true ; pharmacist-supervised automation continues automatically
global MCDS_DropdownXFromRight := 139
global MCDS_DropdownYFromHighlight := 14
global MCDS_ContinueXFromRight := 163
global MCDS_ContinueYFromHighlight := 76

global AppDisplayName := "PhUCKIT"
global AppBackronym   := "Pharmacist Utility for Clinical Knowledge && Inpatient Tools"
; NOTE: AppBackronym is a GUI string - the doubled && renders as a single & in Gui controls.
; Use AppBackronymPlain for MsgBox, clipboard, logs, and window titles.
global AppBackronymPlain := "Pharmacist Utility for Clinical Knowledge & Inpatient Tools"
global AppFileStem := "Drug_Information_Clinical_Knowledgebase"
global AppVersion := "2026.09.25-medrec-rc30"
global PhuckitUserDataRoot := A_ScriptDir
global PhuckitUserMarkerPath := A_ScriptDir "\phuckit.user.marker.json"
global PrimaryLinksCsvPath := A_ScriptDir "\primary_links.csv"
global OtherLinksCsvPath   := A_ScriptDir "\other_links.csv"
global CustomMenusCsvPath  := A_ScriptDir "\custom_dropdown_menus.csv"
global AutoTextCsvPath     := A_ScriptDir "\autotext_phrases.csv"
global OsmolarityCsvPath   := A_ScriptDir "\osmolarity_library.csv"
global VancoTrackerCsvPath := A_ScriptDir "\vancomycin_tracker.csv"
global CriticalDripTrackerCsvPath := A_ScriptDir "\critical_drip_tracker.csv"
global CriticalDripLibraryCsvPath := A_ScriptDir "\critical_drip_library.csv"
global OpioidFactorsCsvPath := A_ScriptDir "\opioid_mme_factors.csv"
global WorkflowMacrosCsvPath := A_ScriptDir "\workflow_tools.csv"
global RemindersCsvPath := A_ScriptDir "\reminders.csv"
global HandoffCsvPath   := A_ScriptDir "\shift_handoff.csv"
global RemindersCheckMs := 60000   ; poll every 60 s
global RemindersLastAlert := Map()

; ---- patient-context session + clinical reference cache (added 2026-07-23) ----------------------
; PCtxSession holds the active multi-screen patient session. It lives in memory only: MRN/FIN and
; raw clinical text are never written to any CSV, log, or handoff file.
global PCtxSession := 0
global PCtxIdleTimeoutMin := 45
global RefDataCache := Map()
global RxNAliasCache := Map()
global AllergyClassCache := Map()
global MedicationManagerWindowCache := {hwnd: 0, checkedAt: 0, isMedicationManager: false}
global _HubGui := 0
global _HubQuickState := 0
global _SplashGui := 0
global _SplashState := 0
global LocalSettingsDir := CombinedSmoke ? A_ScriptDir "\smoke-settings" : A_AppData "\Drug Information and Clinical Knowledgebase"
global AppSettingsIniPath := LocalSettingsDir "\local_settings.ini"
global StartupShortcutPath := A_Startup "\Drug Information and Clinical Knowledgebase.lnk"
global SharedMasterDefaultSubdir := ""
global PopupCloserImagePath := A_ScriptDir "\assets\arrow_button.png"
global PopupCloserTimerActive := false

; User data is never part of the replaceable application payload.  Existing v1
; installations may keep these files beside the script or in a OneDrive copy;
; the startup resolver selects an existing source before any default file is
; created.  Backups are intentionally excluded from discovery.
Phuckit_UserData_Initialize() {
    global AppSettingsIniPath, PhuckitUserDataRoot, PhuckitUserMarkerPath
    global PrimaryLinksCsvPath, OtherLinksCsvPath, CustomMenusCsvPath, AutoTextCsvPath
    global OsmolarityCsvPath, VancoTrackerCsvPath, CriticalDripTrackerCsvPath
    global CriticalDripLibraryCsvPath, OpioidFactorsCsvPath, WorkflowMacrosCsvPath
    global RemindersCsvPath, HandoffCsvPath, _rc2SettingsPath
    global LogPath, ParsingDiagnosticsPath, QNP_DataPath, QNP_BackupDir
    global QNP_ChangeRequestExportPath

    global CombinedSmoke
    if CombinedSmoke
        return
    root := A_ScriptDir
    try {
        EnsureLocalSettingsDir()
        configured := Trim(IniRead(AppSettingsIniPath, "UserData", "Root", ""))
        if configured != "" && DirExist(configured)
            root := configured
    }

    ; Current install files always win.  Only scan OneDrive when this copy has
    ; no recognizable user data and no configured root, which keeps startup fast.
    if root = A_ScriptDir && !Phuckit_UserDataHasFiles(A_ScriptDir) {
        for envName in ["OneDrive", "OneDriveCommercial", "OneDriveConsumer"] {
            oneDrive := EnvGet(envName)
            if oneDrive = "" || !DirExist(oneDrive)
                continue
            candidate := Phuckit_FindOneDriveUserRoot(oneDrive)
            if candidate != "" {
                root := candidate
                break
            }
        }
    }

    ; A packaged release may include the v1-safe migrator.  It runs once per
    ; user-data root, backs up every discovered source, merges only unique CSV
    ; rows, and never deletes legacy files.  If the sidecar is absent or fails,
    ; the app continues with the existing root and no defaults replace data.
    Phuckit_RunBundledDataMigrator(root)

    PhuckitUserDataRoot := root
    try IniWrite(root, AppSettingsIniPath, "UserData", "Root")
    PhuckitUserMarkerPath := root "\phuckit.user.marker.json"

    PrimaryLinksCsvPath := Phuckit_UserDataFile(root, "primary_links.csv")
    OtherLinksCsvPath := Phuckit_UserDataFile(root, "other_links.csv")
    CustomMenusCsvPath := Phuckit_UserDataFile(root, "custom_dropdown_menus.csv")
    AutoTextCsvPath := Phuckit_UserDataFile(root, "autotext_phrases.csv")
    OsmolarityCsvPath := Phuckit_UserDataFile(root, "osmolarity_library.csv")
    VancoTrackerCsvPath := Phuckit_UserDataFile(root, "vancomycin_tracker.csv")
    CriticalDripTrackerCsvPath := Phuckit_UserDataFile(root, "critical_drip_tracker.csv")
    CriticalDripLibraryCsvPath := Phuckit_UserDataFile(root, "critical_drip_library.csv")
    OpioidFactorsCsvPath := Phuckit_UserDataFile(root, "opioid_mme_factors.csv")
    WorkflowMacrosCsvPath := Phuckit_UserDataFile(root, "workflow_tools.csv")
    RemindersCsvPath := Phuckit_UserDataFile(root, "reminders.csv")
    HandoffCsvPath := Phuckit_UserDataFile(root, "shift_handoff.csv")
    _rc2SettingsPath := Phuckit_UserDataFile(root, "data\rc2_user.ini")
    LogPath := Phuckit_UserDataFile(root, "quickmenu.log")
    ParsingDiagnosticsPath := Phuckit_UserDataFile(root, "parsing_diagnostics.csv")
    QNP_DataPath := Phuckit_UserDataFile(root, "quicknotes.txt")
    QNP_BackupDir := root "\QuickNotes_Backups"
    QNP_ChangeRequestExportPath := Phuckit_UserDataFile(root, "change_requests.txt")

    if !FileExist(PhuckitUserMarkerPath) {
        try FileAppend "{`"app_id`":`"PhUCKIT`",`"schema`":1,`"root`":`"" root "`"}`r`n", PhuckitUserMarkerPath, "UTF-8"
    }
}

Phuckit_RunBundledDataMigrator(root) {
    global AppSettingsIniPath
    migrator := A_ScriptDir "\userdata\phuckit_userdata_migrator.exe"
    if !FileExist(migrator)
        return
    try completed := IniRead(AppSettingsIniPath, "UserData", "MigrationCompleted", "")
    catch
        completed := ""
    if completed = "1"
        return
    searchRoots := [A_ScriptDir]
    for envName in ["OneDrive", "OneDriveCommercial", "OneDriveConsumer"] {
        oneDrive := EnvGet(envName)
        if oneDrive = "" || !DirExist(oneDrive)
            continue
        duplicate := false
        for searchRoot in searchRoots {
            if StrLower(searchRoot) = StrLower(oneDrive) {
                duplicate := true
                break
            }
        }
        if !duplicate
            searchRoots.Push(oneDrive)
    }
    command := Chr(34) migrator Chr(34)
        . " --destination-root " Chr(34) root Chr(34)
        . " --backup-root " Chr(34) root "\backups\migration" Chr(34)
    for searchRoot in searchRoots
        command .= " --search-root " Chr(34) searchRoot Chr(34)
    try {
        exitCode := RunWait(command, , "Hide")
        if exitCode = 0
            IniWrite("1", AppSettingsIniPath, "UserData", "MigrationCompleted")
    }
}

Phuckit_UserDataFile(root, relativeName) {
    direct := root "\" relativeName
    if FileExist(direct)
        return direct
    ; Preserve a legacy data\rc2_user.ini location if the caller points at the
    ; old application root.  No file is moved or overwritten here.
    if relativeName = "data\rc2_user.ini" {
        legacy := root "\data\rc2_user.ini"
        if FileExist(legacy)
            return legacy
    }
    return direct
}

Phuckit_UserDataHasFiles(root) {
    for name in ["primary_links.csv", "other_links.csv", "custom_dropdown_menus.csv",
                 "autotext_phrases.csv", "osmolarity_library.csv", "vancomycin_tracker.csv",
                 "critical_drip_tracker.csv", "critical_drip_library.csv", "opioid_mme_factors.csv",
                 "workflow_tools.csv", "reminders.csv", "shift_handoff.csv", "quicknotes.txt"] {
        if FileExist(root "\" name) || FileExist(root "\data\" name)
            return true
    }
    return FileExist(root "\data\rc2_user.ini")
}

Phuckit_IsBackupPath(path) {
    lower := StrLower(String(path))
    for marker in ["\backups\", "\quicknotes_backups\", ".backup", "\migration-backups\"]
        if InStr(lower, marker)
            return true
    return false
}

Phuckit_FindOneDriveUserRoot(oneDrive) {
    candidates := []
    known := Map()
    for name in ["primary_links.csv", "other_links.csv", "custom_dropdown_menus.csv",
                 "autotext_phrases.csv", "osmolarity_library.csv", "vancomycin_tracker.csv",
                 "critical_drip_tracker.csv", "critical_drip_library.csv", "opioid_mme_factors.csv",
                 "workflow_tools.csv", "reminders.csv", "shift_handoff.csv", "quicknotes.txt", "rc2_user.ini"]
        known[name] := true
    try Loop Files oneDrive "\*", "FR" {
        if Phuckit_IsBackupPath(A_LoopFileFullPath)
            continue
        if !known.Has(StrLower(A_LoopFileName))
            continue
        dir := RegExReplace(A_LoopFileFullPath, "\\[^\\]+$", "")
        ; A legacy rc2 file lives under data; use its parent application folder.
        if StrLower(A_LoopFileName) = "rc2_user.ini" && StrLower(RegExReplace(dir, ".*\\", "")) = "data"
            dir := RegExReplace(dir, "\\data$", "")
        candidates.Push(dir)
    }
    if candidates.Length = 0
        return ""
    best := "", bestScore := -1
    for candidate in candidates {
        score := InStr(StrLower(candidate), "phuckit") ? 20 : 0
        for peer in candidates
            if StrLower(peer) = StrLower(candidate)
                score += 1
        if score > bestScore {
            bestScore := score
            best := candidate
        }
    }
    return best
}


; ---- Clinical Reasoning Database bootstrap (vNext15) ---------------------------------------------
; These globals must initialize during the auto-execute section, before the script reaches its first
; hotkey definition. The complete function implementations remain later in this file.
global ClinicalMedicationRepository := Map()
global ClinicalMedicationAliasIndex := Map()
global ClinicalSchemaVersion := "1.0.0"
global ClinicalMedicationFields := [
    "generic", "brands", "ocrAliases", "commonMisspellings",
    "pharmacologicClass", "therapeuticClass", "indications",
    "doseByIndication", "renalDosing", "hepaticDosing", "hd", "crrt", "pd",
    "loadingDose", "maximumDose", "administration", "infusionRates",
    "extendedInfusion", "ySiteCompatibility", "stability", "extravasation",
    "vesicantClassification", "antidote", "tubeAdministration", "crushability",
    "hazardousHandling", "pregnancy", "lactation", "blackBoxWarnings",
    "contraindications", "monitoring", "majorInteractions",
    "highYieldInteractions", "therapeuticSubstitutions", "formularyAlternatives",
    "clinicalPearls", "references", "versionHistory"
]
global CRD2_EvidenceIndex := Map()
global CRD2_SchemaVersion := "2.0.0"
global CRD2_ClaimStatuses := [
    "draft", "source_attached", "locator_verified", "clinical_reviewed",
    "independent_reviewed", "approved", "published", "changes_requested",
    "rejected", "conflicted"
]
global CRD2_ReviewStages := [
    "locator", "primary_clinical", "secondary_independent", "publication"
]
global CRD3_SchemaVersion := "3.0.0"
global CRD3_Migrations := Map()
Clinical_SeedReasoningDatabase()
; -------------------------------------------------------------------------------------------------

global _registeredAutoTextHotstrings := Map()
global _quickMenuOwnerHwnd := 0
global _PreFillDemographics := Map()

global BuiltInPrimaryLinks := [
    { name: "Lexicomp / Lexidrug", key: "lexicomp",    url: "builtin" },
    { name: "UpToDate",            key: "uptodate",    url: "builtin" },
    { name: "VancoPK",             key: "vancopk",     url: "builtin" },
    { name: "Liverpool HIV",       key: "liverpool",   url: "builtin" },
    { name: "ExtravaSafe",         key: "extravasafe", url: "builtin" },
    { name: "Quick Notes Pro",     key: "quicknotes",  url: "builtin" }
]

global BuiltInWorkflowTools := [
    { key: "fehr_ticket", name: "Open FEHR Ticket", hotkey: "Ctrl+F1", visible: true, data1: "https://tinyurl.com/FEHR-TICKET", data2: "", data3: "", notes: "Opens Edge/new tab to the FEHR ticket URL. Data1 = URL." },
    { key: "eyedrop_order", name: "Select Preservative-Free Eye Drops", hotkey: "eye", visible: true, data1: "carboxymethylcellulose 0.5% (PF) eye drops UD", data2: "Verify Med Order", data3: "", notes: "Only runs in Verify Med Order. Requires confirmation before submitting." },
    { key: "new_patient_search", name: "New Patient Search", hotkey: "F2", visible: true, data1: "", data2: "", data3: "", notes: "Legacy VA workflow macro." },
    { key: "new_bve", name: "New BVE Workflow", hotkey: "F6", visible: true, data1: "539 CINCINNATI OH VA MEDICAL CENTER", data2: "539 B", data3: "539-PHARM-SVC", notes: "Data1 = facility, Data2 = location code, Data3 = service." },
    { key: "location", name: "Fill Location Fields", hotkey: "F12", visible: true, data1: "539 CINCINNATI OH VA MEDICAL CENTER", data2: "539 B", data3: "539-PHARM-SVC", notes: "Data1 = facility, Data2 = location code, Data3 = service." },
    { key: "midnight_datetime", name: "Today + 2359", hotkey: "``MID", visible: true, data1: "MM/dd/yyyy", data2: "2359", data3: "", notes: "Replaces current field with today's date, tabs, then enters 2359." },
    { key: "now_datetime", name: "Current Date/Time", hotkey: "``N", visible: true, data1: "MM/dd/yyyy HH:mm", data2: "", data3: "", notes: "Replaces current field with current date/time, then tabs." }
]

; ENSURE CSV FILES EXIST
; -------------------------------------------------------------------------------------------------
EnsurePrimaryCsv() {
    global PrimaryLinksCsvPath, BuiltInPrimaryLinks
    if FileExist(PrimaryLinksCsvPath)
        return
    content := "Name,Key,Url,Visible`r`n"
    for item in BuiltInPrimaryLinks
        content .= CsvEscape(item.name) "," CsvEscape(item.key) "," CsvEscape(item.url) ",1`r`n"
    FileAppend content, PrimaryLinksCsvPath, "UTF-8"
}

EnsureOtherCsv() {
    global OtherLinksCsvPath
    if FileExist(OtherLinksCsvPath)
        return
    FileAppend "Name,Url`r`n", OtherLinksCsvPath, "UTF-8"
}

EnsureCustomMenusCsv() {
    global CustomMenusCsvPath
    if FileExist(CustomMenusCsvPath)
        return
    FileAppend "Type,Category,Name,Target,Visible`r`n", CustomMenusCsvPath, "UTF-8"
}

EnsureAutoTextCsv() {
    global AutoTextCsvPath, BuiltInAutoTextPhrases
    rows := FileExist(AutoTextCsvPath) ? LoadAutoTextPhrases() : []
    changed := !FileExist(AutoTextCsvPath)

    existing := Map()
    for row in rows {
        mode := AutoTextGetMode(row)
        triggerKey := StrLower(NormalizeAutoTextTriggerForMode(row.trigger, mode))
        if triggerKey != ""
            existing["trigger:" mode ":" triggerKey] := true
        else if Trim(row.name) != ""
            existing["name:" StrLower(Trim(row.name))] := true
    }

    for item in BuiltInAutoTextPhrases {
        mode := AutoTextGetMode(item)
        trigger := NormalizeAutoTextTriggerForMode(item.trigger, mode)
        key := trigger != "" ? "trigger:" mode ":" StrLower(trigger) : "name:" StrLower(Trim(item.name))
        if existing.Has(key)
            continue
        rows.Push({ name: item.name, mode: mode, trigger: trigger, expansion: item.expansion, visible: item.visible })
        existing[key] := true
        changed := true
    }

    if changed
        SaveAutoTextPhrases(rows)
}

EnsureVancoTrackerCsv() {
    global VancoTrackerCsvPath
    if FileExist(VancoTrackerCsvPath)
        return
    FileAppend "PatientId,Timestamp,EventType,DoseMg,IntervalHr,LevelMcgMl,Scr,Notes`r`n", VancoTrackerCsvPath, "UTF-8"
}

EnsureCriticalDripTrackerCsv() {
    global CriticalDripTrackerCsvPath
    if FileExist(CriticalDripTrackerCsvPath)
        return
    FileAppend "PatientId,DripName,Concentration,BagVolumeMl,RateMlHr,LastHung,BagLifeHours,ExtraBags,NextDue,CoverageUntil,Notes`r`n", CriticalDripTrackerCsvPath, "UTF-8"
}

EnsureCriticalDripLibraryCsv() {
    global CriticalDripLibraryCsvPath
    if FileExist(CriticalDripLibraryCsvPath)
        return
    CriticalDripLibrary_SaveRows(CriticalDripLibrary_DefaultRows())
}

EnsureWorkflowMacrosCsv() {
    global WorkflowMacrosCsvPath, BuiltInWorkflowTools
    rows := FileExist(WorkflowMacrosCsvPath) ? LoadWorkflowToolRows() : []
    changed := !FileExist(WorkflowMacrosCsvPath)

    existing := Map()
    for row in rows {
        if Trim(row.key) != ""
            existing[StrLower(Trim(row.key))] := true
    }

    for item in BuiltInWorkflowTools {
        key := StrLower(Trim(item.key))
        if existing.Has(key)
            continue
        rows.Push({ key: item.key, name: item.name, hotkey: item.hotkey, visible: item.visible, data1: item.data1, data2: item.data2, data3: item.data3, notes: item.notes })
        existing[key] := true
        changed := true
    }

    ; Migrate the pharmacist override display label from the old wording.
    ; The actual hotkey still uses the physical tilde/backtick key plus P.
    for row in rows {
        if StrLower(Trim(row.key)) = "mcds_override" {
            hk := StrLower(Trim(row.hotkey))
            if hk = "hold ` + p" or hk = "hold + p" or hk = "` + p" {
                row.hotkey := "~P"
                changed := true
            }
        }
    }

    if changed
        SaveWorkflowToolRows(rows)
}

global BuiltInAutoTextPhrases := [
    { name: "Pharmacist note template", trigger: ".pharmnote", expansion: "Assessment: `nPlan: `nMonitoring: ", visible: true },
    { name: "Renal dose note", trigger: ".renal", expansion: "Renal function reviewed. Dose adjusted per current renal function and indication.", visible: true },
    { name: "acetazolamide", trigger: ".acetazolamide", expansion: "Reconstitute with 5mL SWFI and Administer via IV Push over at least 3 minutes *final concentration not to exceed 100mg/mL*", visible: true },
    { name: "apap", trigger: ".apap", expansion: "Not to exceed 3000mg per 24 hour period *COUNT ALL SOURCES*", visible: true },
    { name: "belbuca", trigger: ".belbuca", expansion: "Place yellow side of film against the inside of the moistened cheek; press and hold the film in place for 5 seconds with finger (film should stay in place after this period). Keep film in place until it dissolves completely (usually within 30 minutes of application). Do not chew, swallow, touch, or move film after placement.", visible: true },
    { name: "BOTOX", trigger: ".BOTOX", expansion: "Exclusion Criteria`nIf the answer to ANY item below is met, then the patient should NOT receive`nbotulinum toxin injections:`n[-] Hypersensitivity to botulinum toxins or any components in the formulation`n(e.g., human serum albumin, lactose, sucrose, disodium succinate)`n[-] Co-administration with neuromuscular blockade`n[-] Neurologic condition where botulinum toxins pose risk for additive`nneuromuscular compromise (e.g., myasthenia gravis, amyotrophic lateral`nsclerosis) unless risks/benefits have been`n        discussed with the patient and documented in the medical record`n[-] Used for cosmetic purposes`n`nInclusion Criteria`n[+] Chronic migraine prevention and patient has contraindication, intolerance,`nor lack of therapeutic response after at least 12 weeks each of a therapeutic`ndose of at least 2 of the following: beta blocker, topiramate, divalproex, and`nACE inhibitor or ARB", visible: true },
    { name: "cathflo", trigger: ".cathflo", expansion: "Reconstitute with 2.2mL SWFI and gently swirl. Instill Dose into occluded catheter", visible: true },
    { name: "cefepime", trigger: ".cefepime", expansion: "Reconstitute with 10mL SWFI and Administer via slow IV push over 3-5 minutes", visible: true },
    { name: "cefoxitin", trigger: ".cefoxitin", expansion: "Reconstitute with 10mL SWFI and Administer via slow IV push over 3-5 minutes", visible: true },
    { name: "ceftazidime", trigger: ".ceftazidime", expansion: "Reconstitute with 10mL SWFI and Administer via slow IV push over 3-5 minutes", visible: true },
    { name: "ceftriaxone", trigger: ".ceftriaxone", expansion: "Reconstitute with 10mL (1g) or 20mL (2g) SWFI and Administer via slow IV Push over 5-10 minutes", visible: true },
    { name: "chipotle", trigger: ".chipotle", expansion: "Burrito`n`nSteak`n`nWhite Rice`n`nNo beans`n`nRoasted Chili-corn salsa`n`nFresh tomato salsa`n`nfajita veggies`n`nCheese`n`nLettuce`n`nqueso", visible: true },
    { name: "chlorpro", trigger: ".chlorpro", expansion: "*Must be diluted* *Use orderset for Hiccups* For Direct injection: Dilute wth NS to 1mg/mL. Administer via Syringe Pump over 30 - 60 minutes. Not to exceed 1mg/min. Patient must remain lying down for 30 minutes after administration.", visible: true },
    { name: "chlorpromazine", trigger: ".chlorpromazine", expansion: "*Must be diluted* *Use orderset for Hiccups* For Direct injection: Dilute wth NS to 1mg/mL. Administer via Syringe Pump over 30 - 60 minutes. Not to exceed 1mg/min. Patient must remain lying down for 30 minutes after administration.", visible: true },
    { name: "chlorthiazide", trigger: ".chlorthiazide", expansion: "Add 18mL SWFI to reconstitute for a 28mg/mL solution. Administer over 3-5 Minutes", visible: true },
    { name: "cosyntropin", trigger: ".cosyntropin", expansion: "Reconstitute with 1mL NS and gently swirl. Further dilute with 4mL NS - total volume 5mL -", visible: true },
    { name: "durolane", trigger: ".durolane", expansion: "EXCLUSION CRITERIA (If one is selected, patient is not eligible)`n`n(-) Known hypersensitivity or allergy to hyaluronate preparations`n`n(-) Knee joint infection, skin disease or infection in the area of the injection`nsite`n`nINCLUSION CRITERIA (All must be selected for patient to be eligible)`n`n(+) Documented symptomatic (pain/stiffness) OA of the knee which interferes with`nfunctional activities`n`n(+) Adequate trial (e.g. 2 to 3 months) of non-pharmacologic measures, as`nappropriate.`n`n(+) Therapeutic trial of at least 3 analgesics`n`n(+) Patient and/or provider have elected to continue conservative (non-surgical) treatment for OA", visible: true },
    { name: "ertapenem", trigger: ".ertapenem", expansion: "Reconstitute 1g vial with 10mL SWFI and Administer via Slow IV Push over 5 Minutes", visible: true },
    { name: "etomidate", trigger: ".etomidate", expansion: "RSI Dosing: 0.3mg/kg   (0.2-0.3mg/kg)", visible: true },
    { name: "finasteride", trigger: ".finasteride", expansion: "IF THIS MEDICATION IS CRUSHED FOR ADMINISTRATION, IT MUST NOT BE HANDLED`nBY WOMEN WHO ARE PREGNANT OR WHO MAY BECOME PREGNANT.", visible: true },
    { name: "folic", trigger: ".folic", expansion: "*Dose to be drawn up by Pharmacy* Place missing dose when ready to administer. May be given via IV Push over at least 2 minutes", visible: true },
    { name: "glucagon", trigger: ".glucagon", expansion: "Reconstitute with Manufacturer-Supplied diluent (1mL) and shake gently. Final concentration 1mg/mL", visible: true },
    { name: "h2o", trigger: ".h2o", expansion: "TAKE WITH A FULL GLASS OF WATER", visible: true },
    { name: "injectafer", trigger: ".injectafer", expansion: "May administer doses up to 750mg undiluted over 8 minutes via Syringe Pump. If extravasation occurs, STOP administration at that site. *Please obtain medication from the Omnicell to print label for syringe. *", visible: true },
    { name: "iron", trigger: ".iron", expansion: "Administer total dose via Slow IV Push over 3-5 Minutes.", visible: true },
    { name: "JJ", trigger: ".JJ", expansion: "Big John (the big one)`nLight tomato`nregular onion`nadd provolone`nKickin Ranch x 2`nJimmy chips BBQ", visible: true },
    { name: "lacosamide", trigger: ".lacosamide", expansion: "May administer over 30-60 minutes via Syringe Pump. **Monitor closeley for possible ADEs (CV,CNS)** *Please obtain medication from the Omnicell to print label for syringe.*", visible: true },
    { name: "lai", trigger: ".lai", expansion: "**Confirm date of last injection prior to administration**", visible: true },
    { name: "lasix", trigger: ".lasix", expansion: "May adminster via slow IV Push *Not To Exceed 40mg/min* Doses greater than 120mg should be compounded & supplied by Pharmacy.", visible: true },
    { name: "levothyroxine", trigger: ".levothyroxine", expansion: "Reconstitute with 5mL NS, shake well, and use immediately after reconstitution. Do not exceed 100mcg/minute.   **CONCENTRATIONS VARY BY VIAL SIZE, NOTE FINAL CONCENTRATION**", visible: true },
    { name: "m", trigger: ".m", expansion: "Hawthorne, Meredith Miller, PA-C", visible: true },
    { name: "molnupiravir", trigger: ".molnupiravir", expansion: "CFU`nPatients who are eligible:`n*       Laboratory confirmed mild-moderate COVID-19 diagnosis`n*       High risk for progression to severe COVID-19 (per provider based on CDC`ncriteria)`n*       <5 days since symptom initiation (MUST START WITHIN 5 DAYS)`n`n`nPatients who are not eligible:`n*       Hospitalized due to COVID-19`n*       Asymptomatic infection`n*         Pregnant (relative contraindication)`n`n`nPrecautions:`n*       Advise on need for reliable method of contraception`n*       Females childbearing age for duration of therapy and 4 days after last`n        dose`n*       Males if sexually active with females with childbearing potential: for 3`n        months after the last dose`n`nPregnancy: (use alternative treatment if possible)`n*       Make individual aware of pregnancy surveillance program.`n*       If the pregnant individual agrees to participate in the pregnancy`nsurveillance program and allows the prescribing healthcare provider to disclose`npatient specific information to Merck, the prescribing healthcare provider must`nprovide the patient's name and contact information to Merck (at 1-877-888-4231`nor pregnancyreporting.msd.com)`n`n`n`n`nA/P`n`nPt meets criteria for EUA use of MOLNUPIRAVIR.`n- COVID positive with mild/moderate symptoms not requiring hospitalization or`n  oxygen`n`n- High risk for hospitalization criterion: _____________________`n`n- Symptom onset _____ day(s) ago (< or = 5 days)`n`n- Provider reviewed risk vs benefit for treatment and pt aware of risk and that`nmedication is not FDA approved, but approved for emergency use and documented in`npatient's chart.`n`nAfter review of above, this patient is appropriate to receive`nMolnupiravir under Emergency Use Authorization (EUA)`n`n`n`nRecommendations:`n- Molnupiravir 200mg caps take 4 caps po BID for 5 days.`n- If patient is admitted counsel patient to bring supply into hospital (may be`ncontinued if admitted)`n- Pharmacy will complete required documentation and follow up via Sharepoint", visible: true },
    { name: "n", trigger: ".n", expansion: "nicolas,joseph", visible: true },
    { name: "naloxone", trigger: ".naloxone", expansion: "For Opioid Overdose. Administer via ordered route. May be administered IV/IM/SUBQ. May repeat doses every 2-3 minutes as directed. Call Provider/Rapid Response if used", visible: true },
    { name: "NARCAN", trigger: ".NARCAN", expansion: "For Opioid Overdose. Administer entire spray into nostril. DO NOT PRIME.  May repeat doses every 2-3 minutes as directed alternating nostrils.`n`n**Call Provider/Rapid Response if used**", visible: true },
    { name: "nd", trigger: ".nd", expansion: "**NOTE DOSE & WASTE REMAINDER**", visible: true },
    { name: "norph", trigger: ".norph", expansion: "**Administered Prior to Pharmacist Verification**", visible: true },
    { name: "NPH", trigger: ".NPH", expansion: "*One-time dose to be drawn up & delivered by pharmacy*", visible: true },
    { name: "olanzapine", trigger: ".olanzapine", expansion: "Reconstitute 10mg vial with 2.1mL SWFI. Final concentration: 5mg/mL. Inject slowly, deep into muscle. Not to exceed 30mg/day. Count all sources", visible: true },
    { name: "omni", trigger: ".omni", expansion: "**Please pull from Omnicell**", visible: true },
    { name: "p1", trigger: ".p1", expansion: "FOR PAIN >1", visible: true },
    { name: "p6", trigger: ".p6", expansion: "FOR PAIN >6", visible: true },
    { name: "pharmd", trigger: ".pharmd", expansion: "Action completed consistent with VHA Handbook 1108.11 (Clinical Pharmacy`nServices), VHA Directive 1108.08, VHA Directive 1108.12, & Clinical Pharmacist -`nInpatient Programs Functional Statement GS-660-12.", visible: true },
    { name: "pom", trigger: ".pom", expansion: "**Patient's Own Medication**`n**Please Send Home With Patient Upon Discharge**", visible: true },
    { name: "PPI", trigger: ".PPI", expansion: "Reconstitute with 10mL NS and administer IV Push over at least 2 minutes", visible: true },
    { name: "PPR", trigger: ".PPR", expansion: "FOR PAIN >1 OR PATIENT REQUEST", visible: true },
    { name: "prochlor", trigger: ".prochlor", expansion: "Administer via IV Push slowly over at least 2 minutes. Monitor for hypotension for 30 minutes after administration", visible: true },
    { name: "r", trigger: ".r", expansion: "robertson,eliza e md", visible: true },
    { name: "rabiesig", trigger: ".rabiesig", expansion: "Standard dose: 20 units/kg. Administer full dose into/around wound if anatomically feasible. Remaining volume should be administered IM at a site distant from the vaccine administration site (i.e. opposite deltoid)", visible: true },
    { name: "rabiesvaccine", trigger: ".rabiesvaccine", expansion: "Reconstitute with provided diluent. Gently swirl to prevent foaming and use immediately after reconstitution. Administer in deltoid muscle opposite from Rabies Immune Globulin if giving. Dosing shedule varies between patients, note vaccination/immune status", visible: true },
    { name: "rig", trigger: ".rig", expansion: "Standard dose: 20 units/kg. Administer full dose into/around wound if anatomically feasible. Remaining volume should be administered IM at a site distant from the vaccine administration site (i.e. opposite deltoid)", visible: true },
    { name: "rs", trigger: ".rs", expansion: "**Rinse Mouth & Spit After Use**", visible: true },
    { name: "RSI", trigger: ".RSI", expansion: "1. Pre-treatment (3 min before induction) :`nLidocaine: 1.5mg/kg IV (Contraindicated: severe bradycardia, severe heart block, amide anesthetic allergy)`nFentanyl: 1-3 mcg/kg IV (Contraindicated: decompensated shock, HD unstable)`n`n2. Induction:`nEtomidate: 0.3 mg/kg IV`n- Caution in: sepsis, suppresses adrenal cortisol production`nKetamine: 1-2 mg/kg IV`n- DRIP: 500MG in NS 250ML (C)`n- Avoid in cardiac conditions, hi BP, and hi ICP`nPropofol: 1.5-2.5 mg/kg IV`n- administer as 20mg doses until adequate sedation to limit hypotension`n- Caution: dose related hypotension`n- DRIP: 1% in 100 or 50ML vials (P)`nMidazolam: 0.2-0.3 mg/kg IV`n- DRIP: 100MG in D5W 100ML (C)`n- Caution: slow onset, dose related resp`n  depression + hypotension`n`n3. Paralysis:`nSuccinylcholine: 1-2 mg/kg IV`n- Avoid in hi K, bradycardia/hypotension with`n  repeated doses, may inc ICP`n- Duration of action: up to 10 min`nRocuronium: 0.6-1.2 mg/kg IV`n- Caution in liver dysfunction, minimal in renal`n- Duration of action: 45-60 min`n- reversal agent: sugammadex 16mg/kg IV over`n  3 min", visible: true },
    { name: "rv", trigger: ".rv", expansion: "Reconstitute with provided diluent. Gently swirl to prevent foaming and use immediately after reconstitution. Administer in deltoid muscle opposite from Rabies Immune Globulin if giving. Dosing shedule varies between patients, note vaccination/immune status", visible: true },
    { name: "thiamine", trigger: ".thiamine", expansion: "Administer total dose over 4-5 minutes. Doses up to 200mg may be administered undiluted", visible: true },
    { name: "TNK", trigger: ".TNK", expansion: "Contraindications (treat w/in 3 hrs):`n- Any of the following w/in the past 3 months:`n  acute ischemic stroke, severe head trauma,`n  intracranial/spinal surgery,`n- H/o intracerebral hemorrhage`n- Intra-axial intracranial neoplasm if hi risk for`n  hemorrhage`n- Suspicion of subarachnoid hemorrhage`n- Active internal bleeding`n- Structural GI malignancy or GIB w/in 21 days`n- Tx dose of LMWH w/in past 24 hrs (prophylactic dosing ok)`n- DOAC w/in past 48 hrs`n- Aortic arch dissection`n- S/Sx consistent w/ infective endocarditis", visible: true },
    { name: "unasyn", trigger: ".unasyn", expansion: "Reconstitute 1.5g vial with 5mL SWFI and 3g Vial with 10mL SWFI. Administer via Syringe Pump over 15 minutes", visible: true },
    { name: "vanco", trigger: ".vanco", expansion: "**Placeholder order** Pharmacy to monitor levels & Place New Vancomycin order when indicated. The presence of this order indicates active vancomycin therapy", visible: true },
    { name: "vec", trigger: ".vec", expansion: "RSI Dosing: 0.1 to 0.2 mg/kg", visible: true },
    { name: "ziprasidone", trigger: ".ziprasidone", expansion: "Reconstitute with 1.2mL SWFI & shake vigorously. Final concentration: 20mg/mL. **FOR IM ADMINISTRATION ONLY** Not to exceed 40mg/day", visible: true },
    { name: "chlor", trigger: ".chlor", expansion: "Add 18mL SWFI to reconstitute for a 28mg/mL solution. Administer over 3-5 Minutes", visible: true },
    { name: "asa", mode: "inline", trigger: "asa", expansion: "aspirin", visible: true },
    { name: "qhs", mode: "inline", trigger: "qhs", expansion: "every day at bedtime", visible: true },
    { name: "q6h", mode: "inline", trigger: "q6h", expansion: "every 6 hr", visible: true },
    { name: "q1h", mode: "inline", trigger: "q1h", expansion: "every 1 hr", visible: true },
    { name: "inh", trigger: ".inh", expansion: "inh(s)", visible: true },
    { name: "appl", trigger: ".appl", expansion: "appl(s)", visible: true }
]

Phuckit_UserData_Initialize()
Combined_Tray()
A_TrayMenu.Add("Preparation BUD Library", Preparation29_Open)
A_TrayMenu.Add("Shortcut Guide", Review_Guide)
A_TrayMenu.Add("Replay de-identified capture", Review_Replay)
EnsurePrimaryCsv()
EnsureOtherCsv()
EnsureCustomMenusCsv()
EnsureAutoTextCsv()
EnsureVancoTrackerCsv()
EnsureCriticalDripTrackerCsv()
EnsureCriticalDripLibraryCsv()
EnsureWorkflowMacrosCsv()
Pkg_Bootstrap()
EnsureLaunchAtLogin()

; -------------------------------------------------------------------------------------------------
; OSMOLARITY LIBRARY — seeded on first run, then fully user-editable via Manage Quick Menu
; -------------------------------------------------------------------------------------------------
global BuiltInOsmolarityLibrary := [
    ; Core IV/PN components supplied by user. Values are mOsm/mL.
    { name: "Calcium Chloride 10%",              mosmPerMl: 2.04 },
    { name: "Calcium Gluconate 10%",             mosmPerMl: 0.680 },
    { name: "Chromium Trace",                    mosmPerMl: 0.03 },
    { name: "Copper Trace",                      mosmPerMl: 0.01 },
    { name: "Cyanocobalamin 1000 mcg/mL",        mosmPerMl: 0.45 },
    { name: "Folic Acid 5 mg/mL",                mosmPerMl: 0.20 },
    { name: "Heparin 5,000 units/mL",            mosmPerMl: 0.46 },
    { name: "Lidocaine 2%",                      mosmPerMl: 0.15 },
    { name: "Magnesium Sulfate 50%",             mosmPerMl: 4.06 },
    { name: "Manganese Trace",                   mosmPerMl: 0.87 },
    { name: "Molybdenum Trace",                  mosmPerMl: 0.80 },
    { name: "Multi-trace Elements (MTE-4)",      mosmPerMl: 0.36 },
    { name: "Multivitamin Injection (Adult)",    mosmPerMl: 4.11 },
    { name: "Potassium Acetate 2 mEq/mL",        mosmPerMl: 4.00 },
    { name: "Potassium Chloride 2 mEq/mL",       mosmPerMl: 4.00 },
    { name: "Potassium Phosphate 4.4 mEq/mL",    mosmPerMl: 7.40 },
    { name: "Pyridoxine HCl 100 mg/mL",          mosmPerMl: 1.11 },
    { name: "Selenium Trace",                    mosmPerMl: 0.09 },
    { name: "Sodium Acetate 2 mEq/mL",           mosmPerMl: 4.00 },
    { name: "Sodium Bicarbonate 4.2%",           mosmPerMl: 1.00 },
    { name: "Sodium Bicarbonate 8.4%",           mosmPerMl: 2.00 },
    { name: "Sodium Chloride 14.6%",             mosmPerMl: 5.00 },
    { name: "Sodium Phosphate 4 mEq/mL",         mosmPerMl: 12.00 },
    { name: "Thiamine HCl 100 mg/mL",            mosmPerMl: 0.62 },
    { name: "Water for Injection",               mosmPerMl: 0.00,  synonyms: "WFI, SWFI" },
    { name: "Zinc Trace",                        mosmPerMl: 0.11 },
    { name: "Sterile Water",                     mosmPerMl: 0.00,  synonyms: "SWFI, Sterile Water for Injection, WFI" },
    { name: "Dextrose 5%",                       mosmPerMl: 0.25,  synonyms: "D5W, D5, 5% Dextrose in Water" },
    { name: "Dextrose 10%",                      mosmPerMl: 0.505, synonyms: "D10W, D10, 10% Dextrose in Water" },
    { name: "Dextrose 30%",                      mosmPerMl: 1.51,  synonyms: "D30W, D30" },
    { name: "Dextrose 50%",                      mosmPerMl: 2.52,  synonyms: "D50W, D50" },
    { name: "Dextrose 70%",                      mosmPerMl: 3.53,  synonyms: "D70W, D70" },
    { name: "Lactated Ringers",                  mosmPerMl: 0.28,  synonyms: "LR, Lactated Ringer's" },
    { name: "Sodium Chloride 0.45%",             mosmPerMl: 0.154, synonyms: "1/2 NS, Half Normal Saline, 0.45% NaCl" },
    { name: "Sodium Chloride 0.9%",              mosmPerMl: 0.31,  synonyms: "NS, Normal Saline, 0.9% NaCl" },
    { name: "Amino Acid 3.5%",                   mosmPerMl: 0.357, synonyms: "AA 3.5%, Aminosyn 3.5%" },
    { name: "Amino Acid 8.5%",                   mosmPerMl: 0.85,  synonyms: "AA 8.5%, Aminosyn 8.5%" },
    { name: "Amino Acid 10%",                    mosmPerMl: 1.00,  synonyms: "AA 10%, Aminosyn 10%" },
    { name: "Intralipid 10%",                    mosmPerMl: 0.26,  synonyms: "IVFE 10%, Lipid 10%" },
    { name: "Intralipid 20%",                    mosmPerMl: 0.26,  synonyms: "IVFE 20%, Lipid 20%" },
    { name: "Liposyn III 30%",                   mosmPerMl: 0.293, synonyms: "IVFE 30%, Lipid 30%" },

    ; Premixed PN products. Label values are calculated mOsm/L divided by 1000.
    { name: "CLINIMIX 4.25/5 (calc)",            mosmPerMl: 0.675 },
    { name: "CLINIMIX 4.25/10 (calc)",           mosmPerMl: 0.930 },
    { name: "CLINIMIX 5/15 (calc)",              mosmPerMl: 1.255 },
    { name: "CLINIMIX 5/20 (calc)",              mosmPerMl: 1.505 },
    { name: "CLINIMIX 6/5 (calc)",               mosmPerMl: 0.850 },
    { name: "CLINIMIX 8/10 (calc)",              mosmPerMl: 1.308 },
    { name: "CLINIMIX 8/14 (calc)",              mosmPerMl: 1.520 },
    { name: "CLINIMIX E 2.75/5 (calc)",          mosmPerMl: 0.665 },
    { name: "CLINIMIX E 4.25/5 (calc)",          mosmPerMl: 0.815 },
    { name: "CLINIMIX E 4.25/10 (calc)",         mosmPerMl: 1.070 },
    { name: "CLINIMIX E 5/15 (calc)",            mosmPerMl: 1.395 },
    { name: "CLINIMIX E 5/20 (calc)",            mosmPerMl: 1.650 },
    { name: "CLINIMIX E 8/10 (calc)",            mosmPerMl: 1.450 },
    { name: "CLINIMIX E 8/14 (calc)",            mosmPerMl: 1.650 },
    { name: "KABIVEN (mixed bag, calc)",         mosmPerMl: 1.060 },
    { name: "PERIKABIVEN (mixed bag, calc)",     mosmPerMl: 0.750 },
    { name: "ProcalAmine 3% AA / 3% Glycerin",   mosmPerMl: 0.735 }
]

EnsureOsmolarityCsv() {
    global OsmolarityCsvPath, BuiltInOsmolarityLibrary

    if !FileExist(OsmolarityCsvPath) {
        content := "Name,MosmPerMl,Synonyms`r`n"
        for item in BuiltInOsmolarityLibrary
            content .= CsvEscape(item.name) "," item.mosmPerMl "," CsvEscape(OsmoGetSynonyms(item)) "`r`n"
        AtomicWrite(OsmolarityCsvPath, content)
        return
    }

    ; Existing users keep their edited rows, but receive any newly shipped built-in rows.
    existing := LoadOsmolarityLibrary()
    seen := Map()
    for idx, item in existing
        seen[StrLower(Trim(item.name))] := idx

    changed := false
    for item in BuiltInOsmolarityLibrary {
        key := StrLower(Trim(item.name))
        if !seen.Has(key) {
            existing.Push({ name: item.name, mosmPerMl: item.mosmPerMl, synonyms: OsmoGetSynonyms(item) })
            seen[key] := existing.Length
            changed := true
        } else {
            idx := seen[key]
            mergedSynonyms := OsmoMergeSynonyms(OsmoGetSynonyms(existing[idx]), OsmoGetSynonyms(item))
            if mergedSynonyms != OsmoGetSynonyms(existing[idx]) {
                existing[idx].synonyms := mergedSynonyms
                changed := true
            }
        }
    }

    if changed
        SaveOsmolarityLibrary(existing)
}

OsmoGetSynonyms(item) {
    try
        return Trim(item.synonyms)
    return ""
}

OsmoMergeSynonyms(existingSynonyms, newSynonyms) {
    existingSynonyms := Trim(existingSynonyms)
    newSynonyms := Trim(newSynonyms)
    if newSynonyms = ""
        return existingSynonyms

    seen := Map()
    out := []
    for syn in StrSplit(existingSynonyms, ",") {
        syn := Trim(syn)
        if syn = ""
            continue
        key := StrLower(syn)
        if !seen.Has(key) {
            seen[key] := true
            out.Push(syn)
        }
    }
    for syn in StrSplit(newSynonyms, ",") {
        syn := Trim(syn)
        if syn = ""
            continue
        key := StrLower(syn)
        if !seen.Has(key) {
            seen[key] := true
            out.Push(syn)
        }
    }

    text := ""
    for syn in out
        text .= (text = "" ? "" : ", ") syn
    return text
}

; BuiltInOsmolarityLibrary must be initialized before this seed/merge step.
EnsureOsmolarityCsv()

LoadOsmolarityLibrary() {
    global OsmolarityCsvPath
    list := []
    try {
        content := FileRead(OsmolarityCsvPath, "UTF-8")
    } catch {
        return list
    }
    lines := StrSplit(content, "`n")
    first := true
    for line in lines {
        line := Trim(line, " `r`t")
        if line = ""
            continue
        if first {
            first := false
            continue
        }
        fields := CsvParseLine(line)
        if fields.Length < 2
            continue
        value := Trim(fields[2])
        if !IsNumber(value) or value < 0 {
            Log("Skipping invalid osmolarity CSV row: " line)
            continue
        }
        list.Push({ name: fields[1], mosmPerMl: Number(value), synonyms: (fields.Length >= 3 ? fields[3] : "") })
    }
    return list
}

SaveOsmolarityLibrary(list) {
    global OsmolarityCsvPath
    text := "Name,MosmPerMl,Synonyms`r`n"
    for item in list
        text .= CsvEscape(item.name) "," item.mosmPerMl "," CsvEscape(OsmoGetSynonyms(item)) "`r`n"
    AtomicWrite(OsmolarityCsvPath, text)
}

; -------------------------------------------------------------------------------------------------
; LOAD PRIMARY LINKS
; -------------------------------------------------------------------------------------------------
LoadPrimaryLinks() {
    global PrimaryLinksCsvPath
    list := []
    try {
        content := FileRead(PrimaryLinksCsvPath, "UTF-8")
    } catch {
        return list
    }
    lines := StrSplit(content, "`n")
    first := true
    for line in lines {
        line := Trim(line, " `r`t")
        if line = ""
            continue
        if first {
            first := false
            continue
        }
        fields := CsvParseLine(line)
        if fields.Length < 4
            continue
        list.Push({
            name:    fields[1],
            key:     fields[2],
            url:     fields[3],
            visible: (fields[4] = "1")
        })
    }
    return list
}

; -------------------------------------------------------------------------------------------------
; LOAD OTHER LINKS
; -------------------------------------------------------------------------------------------------
LoadOtherLinks() {
    global OtherLinksCsvPath
    links := []
    try {
        content := FileRead(OtherLinksCsvPath, "UTF-8")
    } catch {
        return links
    }
    lines := StrSplit(content, "`n")
    first := true
    for line in lines {
        line := Trim(line, " `r`t")
        if line = ""
            continue
        if first {
            first := false
            continue
        }
        fields := CsvParseLine(line)
        if fields.Length < 2
            continue
        links.Push({ name: fields[1], url: fields[2] })
    }
    return links
}

; -------------------------------------------------------------------------------------------------
; SAVE PRIMARY LINKS
; -------------------------------------------------------------------------------------------------
SavePrimaryLinks(list) {
    global PrimaryLinksCsvPath
    text := "Name,Key,Url,Visible`r`n"
    for item in list
        text .= CsvEscape(item.name) "," CsvEscape(item.key) "," CsvEscape(item.url) "," (item.visible ? "1" : "0") "`r`n"
    AtomicWrite(PrimaryLinksCsvPath, text)
}

; -------------------------------------------------------------------------------------------------
; SAVE OTHER LINKS
; -------------------------------------------------------------------------------------------------
SaveOtherLinks(links) {
    global OtherLinksCsvPath
    text := "Name,Url`r`n"
    for link in links
        text .= CsvEscape(link.name) "," CsvEscape(link.url) "`r`n"
    AtomicWrite(OtherLinksCsvPath, text)
}

; -------------------------------------------------------------------------------------------------
; CUSTOM DROP-DOWN MENUS
;   CSV schema:
;     Type     = menu | item
;     Category = drop-down menu name
;     Name     = item display name for item rows
;     Target   = URL/path, builtin:<key>, or calc:<code>
;     Visible  = 1 | 0
; -------------------------------------------------------------------------------------------------
LoadCustomMenuRows() {
    global CustomMenusCsvPath
    rows := []
    try {
        content := FileRead(CustomMenusCsvPath, "UTF-8")
    } catch {
        return rows
    }
    lines := StrSplit(content, "`n")
    first := true
    for line in lines {
        line := Trim(line, " `r`t")
        if line = ""
            continue
        if first {
            first := false
            continue
        }
        fields := CsvParseLine(line)
        if fields.Length < 5
            continue
        rowType := StrLower(Trim(fields[1]))
        if rowType != "menu" and rowType != "item"
            continue
        rows.Push({
            type:     rowType,
            category: Trim(fields[2]),
            name:     Trim(fields[3]),
            target:   Trim(fields[4]),
            visible:  (fields[5] = "1")
        })
    }
    return rows
}

SaveCustomMenuRows(rows) {
    global CustomMenusCsvPath
    text := "Type,Category,Name,Target,Visible`r`n"
    for row in rows
        text .= CsvEscape(row.type) "," CsvEscape(row.category) "," CsvEscape(row.name) "," CsvEscape(row.target) "," (row.visible ? "1" : "0") "`r`n"
    AtomicWrite(CustomMenusCsvPath, text)
}


; -------------------------------------------------------------------------------------------------
; AUTO TEXT / DOT PHRASES / INLINE SHORTCUTS
;   CSV schema:
;     Name      = display name in Manage Quick Menu
;     Mode      = dot | inline
;     Trigger   = optional dot phrase or inline shortcut, for example .renal or qhs
;     Expansion = text inserted/copied; newlines are stored encoded so CSV remains one row per phrase
;     Visible   = 1 | 0
; -------------------------------------------------------------------------------------------------
LoadAutoTextPhrases() {
    global AutoTextCsvPath
    rows := []
    try {
        content := FileRead(AutoTextCsvPath, "UTF-8")
    } catch {
        return rows
    }
    lines := StrSplit(content, "`n")
    first := true
    for line in lines {
        line := Trim(line, " `r`t")
        if line = ""
            continue
        if first {
            first := false
            continue
        }
        fields := CsvParseLine(line)
        if fields.Length < 4
            continue

        ; Backward compatibility:
        ;   old schema = Name,Trigger,Expansion,Visible
        ;   new schema = Name,Mode,Trigger,Expansion,Visible
        if fields.Length >= 5 and AutoTextIsValidMode(fields[2]) {
            mode := AutoTextNormalizeMode(fields[2])
            trigger := fields[3]
            expansion := fields[4]
            visibleValue := fields[5]
        } else {
            mode := "dot"
            trigger := fields[2]
            expansion := fields[3]
            visibleValue := fields[4]
        }

        rows.Push({
            name: Trim(fields[1]),
            mode: mode,
            trigger: NormalizeAutoTextTriggerForMode(trigger, mode),
            expansion: DecodeMultiline(expansion),
            visible: (visibleValue = "1")
        })
    }
    return rows
}

SaveAutoTextPhrases(rows) {
    global AutoTextCsvPath
    text := "Name,Mode,Trigger,Expansion,Visible`r`n"
    for row in rows {
        mode := AutoTextGetMode(row)
        trigger := NormalizeAutoTextTriggerForMode(row.trigger, mode)
        text .= CsvEscape(row.name) "," CsvEscape(mode) "," CsvEscape(trigger) "," CsvEscape(EncodeMultiline(row.expansion)) "," (row.visible ? "1" : "0") "`r`n"
    }
    AtomicWrite(AutoTextCsvPath, text)
    RegisterAutoTextHotstrings()
}

EncodeMultiline(value) {
    value := StrReplace(value, "\\", "\\\\")
    value := StrReplace(value, "`r`n", "\\n")
    value := StrReplace(value, "`n", "\\n")
    value := StrReplace(value, "`r", "\\n")
    value := StrReplace(value, "`t", "\\t")
    return value
}

DecodeMultiline(value) {
    out := ""
    i := 1
    while i <= StrLen(value) {
        ch := SubStr(value, i, 1)
        if ch = "\\" and i < StrLen(value) {
            nxt := SubStr(value, i + 1, 1)
            switch nxt {
                case "n": out .= "`r`n"
                case "t": out .= "`t"
                case "\\": out .= "\\"
                default: out .= nxt
            }
            i += 2
            continue
        }
        out .= ch
        i += 1
    }
    return out
}

AutoTextIsValidMode(mode) {
    mode := StrLower(Trim(mode))
    return mode = "dot" or mode = "dot phrase" or mode = "inline" or mode = "shortcut" or mode = "text shortcut"
}

AutoTextNormalizeMode(mode) {
    mode := StrLower(Trim(mode))
    if mode = "inline" or mode = "shortcut" or mode = "text shortcut"
        return "inline"
    return "dot"
}

AutoTextGetMode(row) {
    try {
        return AutoTextNormalizeMode(row.mode)
    } catch {
        return "dot"
    }
}

NormalizeAutoTextTrigger(trigger) {
    return NormalizeAutoTextTriggerForMode(trigger, "dot")
}

NormalizeAutoTextTriggerForMode(trigger, mode := "dot") {
    trigger := Trim(trigger)
    if trigger = ""
        return ""
    mode := AutoTextNormalizeMode(mode)
    if mode = "inline" {
        ; Inline shortcuts intentionally do not require a dot.
        ; They expand after an ending key such as Space, Tab, or Enter.
        if SubStr(trigger, 1, 1) = "."
            trigger := SubStr(trigger, 2)
        return Trim(trigger)
    }
    if SubStr(trigger, 1, 1) != "."
        trigger := "." trigger
    return trigger
}

AutoTextModeLabel(mode) {
    mode := AutoTextNormalizeMode(mode)
    return mode = "inline" ? "Inline" : "Dot phrase"
}

AutoTextHotstringSpec(trigger, mode := "dot") {
    trigger := NormalizeAutoTextTriggerForMode(trigger, mode)
    if trigger = ""
        return ""
    return "::" trigger
}

RegisterAutoTextHotstrings() {
    ; Registers visible dot phrases and inline shortcuts as AutoHotkey hotstrings.
    ; Inline examples: qhs + Space/Tab/Enter => every day at bedtime.
    global _registeredAutoTextHotstrings

    for hs, enabled in _registeredAutoTextHotstrings {
        try Hotstring(hs, "Off")
    }
    _registeredAutoTextHotstrings := Map()

    rows := LoadAutoTextPhrases()
    for row in rows {
        if !row.visible or Trim(row.trigger) = "" or Trim(row.expansion) = ""
            continue
        mode := AutoTextGetMode(row)
        trigger := NormalizeAutoTextTriggerForMode(row.trigger, mode)
        if !AutoTextTriggerLooksSafe(trigger, mode) {
            Log("AutoText hotstring registration skipped for " trigger ": unsafe trigger text")
            continue
        }
        hs := AutoTextHotstringSpec(trigger, mode)
        try {
            Hotstring(hs, row.expansion, "On")
            _registeredAutoTextHotstrings[hs] := true
        } catch as e {
            Log("AutoText hotstring registration skipped for " trigger ": " e.Message)
        }
    }
}

AutoTextTriggerLooksSafe(trigger, mode := "dot") {
    trigger := NormalizeAutoTextTriggerForMode(trigger, mode)
    if trigger = ""
        return true
    ; Avoid whitespace/control characters in shortcuts. Plain letters/numbers and common
    ; medication-sig punctuation are allowed.
    return !RegExMatch(trigger, "[\s\r\n\t]")
}



LoadWorkflowToolRows() {
    global WorkflowMacrosCsvPath
    rows := []
    if !FileExist(WorkflowMacrosCsvPath)
        return rows
    content := FileRead(WorkflowMacrosCsvPath, "UTF-8")
    for lineNo, line in StrSplit(content, "`n", "`r") {
        if lineNo = 1 or Trim(line) = ""
            continue
        f := CsvParseLine(line)
        while f.Length < 8
            f.Push("")
        rows.Push({
            key: Trim(f[1]),
            name: f[2],
            hotkey: f[3],
            visible: (Trim(f[4]) != "0"),
            data1: f[5],
            data2: f[6],
            data3: f[7],
            notes: f[8]
        })
    }
    return rows
}

SaveWorkflowToolRows(rows) {
    global WorkflowMacrosCsvPath
    content := "Key,Name,Hotkey,Visible,Data1,Data2,Data3,Notes`r`n"
    for row in rows {
        content .= CsvEscape(row.key) "," CsvEscape(row.name) "," CsvEscape(row.hotkey) "," (row.visible ? "1" : "0") "," CsvEscape(row.data1) "," CsvEscape(row.data2) "," CsvEscape(row.data3) "," CsvEscape(row.notes) "`r`n"
    }
    AtomicWrite(WorkflowMacrosCsvPath, content)
}

WorkflowToolByKey(key) {
    key := StrLower(Trim(key))
    for row in LoadWorkflowToolRows() {
        if StrLower(Trim(row.key)) = key
            return row
    }
    for row in BuiltInWorkflowTools {
        if StrLower(Trim(row.key)) = key
            return row
    }
    return { key: key, name: key, hotkey: "", visible: false, data1: "", data2: "", data3: "", notes: "" }
}

WorkflowToolData(key, fieldName, defaultValue := "") {
    row := WorkflowToolByKey(key)
    try {
        val := row.%fieldName%
        return val != "" ? val : defaultValue
    }
    return defaultValue
}

BuildWorkflowToolsMenu() {
    m := Menu()
    added := 0
    for row in LoadWorkflowToolRows() {
        if !row.visible
            continue
        ; Background-only helpers remain available by hotkey/hotstring but are not shown in the click menu.
        if WorkflowToolIsBackgroundOnly(row.key)
            continue
        name := row.name
        if row.hotkey != ""
            name .= " (" . row.hotkey . ")"
        m.Add(name, MakeWorkflowToolHandler(row.key))
        added += 1
    }
    if added = 0
        m.Add("No visible workflow tools", (*) => MsgBox("Enable workflow tools in workflow_tools.csv.", "Workflow Tools"))
    m.Add()
    return m
}

WorkflowToolIsBackgroundOnly(key) {
    key := StrLower(Trim(key))
    return key = "bmi_ocr"
        or key = "midnight_datetime"
        or key = "now_datetime"
}

MakeWorkflowToolHandler(key) {
    keyCopy := key
    return (*) => SafeRun(OpenWorkflowToolFromMenuKey, keyCopy)
}

OpenWorkflowToolFromMenuKey(key) {
    global _quickMenuOwnerHwnd
    OpenWorkflowToolByKey(key, _quickMenuOwnerHwnd)
}

WorkflowToolNeedsReturnFocus(key) {
    key := StrLower(Trim(key))
    return key = "eyedrop_order"
        or key = "new_patient_search"
        or key = "new_bve"
        or key = "location"
        or key = "mcds_override"
        or key = "midnight_datetime"
        or key = "now_datetime"
}

RestoreWorkflowTargetWindow(hwnd := 0) {
    if !hwnd
        return
    try {
        if WinExist("ahk_id " hwnd) {
            WinActivate "ahk_id " hwnd
            WinWaitActive "ahk_id " hwnd, , 1.5
            Sleep 150
        }
    }
}

OpenWorkflowToolByKey(key, returnHwnd := 0) {
    keyNorm := StrLower(Trim(key))
    if WorkflowToolNeedsReturnFocus(keyNorm)
        RestoreWorkflowTargetWindow(returnHwnd)

    switch keyNorm {
        case "bmi_ocr": BMI_FromRegion()
        case "fehr_ticket": Workflow_OpenFehrTicket()
        case "eyedrop_order": Workflow_EyeDropOrder()
        case "new_patient_search": Workflow_NewPatientSearch()
        case "new_bve": Workflow_NewBVE()
        case "location": Workflow_FillLocation()
        case "mcds_override": Workflow_MCDSOverride()
        case "midnight_datetime": Workflow_MID()
        case "now_datetime": Workflow_NowDateTime()
        default: MsgBox "Unknown workflow tool: " key, "Workflow Tools", "Icon!"
    }
}

CustomMenuCategoryExists(rows, category) {
    category := StrLower(Trim(category))
    if category = ""
        return false
    for row in rows {
        if row.type = "menu" and StrLower(row.category) = category
            return true
    }
    return false
}

EnsureCustomMenuCategory(rows, category) {
    if !CustomMenuCategoryExists(rows, category)
        rows.Push({ type: "menu", category: category, name: "", target: "", visible: true })
}

CustomTargetHelpText() {
    return "Target examples:`n"
        . "  https://example.com`n"
        . "  C:\Path\file.pdf`n"
        . "  calc:crcl`n"
        . "  calc:osmolarity`n"
        . "  calc:apap-tox`n"
        . "  calc:anticoag-reversal`n"
        . "  calc:digifab`n"
        . "  calc:crofab`n"
        . "  calc:crrt`n"
        . "  calc:dka`n"
        . "  calc:vanco`n"
        . "  workflow:bmi_ocr`n"
        . "  calc:exposure-pep`n"
        . "  calc:tnk-stroke`n"
        . "  calc:rsi`n"
        . "  calc:rabies-pep`n"
        . "  calc:bodyweight`n"
        . "  calc:corrected-calcium`n"
        . "  calc:4t`n"
        . "  calc:benzo`n"
        . "  calc:iron`n"
        . "  calc:opioid-mme`n"
        . "  calc:pcn-cross-reactivity`n"
        . "  builtin:quicknotes"
}

IsCalcTarget(target) {
    return RegExMatch(Trim(target), "i)^calc:")
}

IsBuiltinTarget(target) {
    return RegExMatch(Trim(target), "i)^builtin:")
}

NormalizeCustomTarget(target) {
    target := Trim(target)
    if RegExMatch(target, "i)^calc:")
        return "calc:" StrLower(Trim(SubStr(target, 6)))
    if RegExMatch(target, "i)^builtin:")
        return "builtin:" StrLower(Trim(SubStr(target, 9)))
    if RegExMatch(target, "i)^workflow:")
        return "workflow:" StrLower(Trim(SubStr(target, 10)))
    return target
}

ValidateCustomTargetForSave(target) {
    target := NormalizeCustomTarget(target)
    if target = "" {
        MsgBox "Enter a target. It can be a URL/path, calc:<code>, or builtin:<key>.`n`n" CustomTargetHelpText(), "Invalid Target", "Icon!"
        return false
    }
    if IsCalcTarget(target)
        return IsKnownCalculatorTarget(target, true)
    if IsBuiltinTarget(target)
        return IsKnownBuiltinTarget(target, true)
    if RegExMatch(target, "i)^workflow:")
        return IsKnownWorkflowTarget(target, true)
    return ValidateLaunchTargetForSave(target)
}

IsKnownBuiltinTarget(target, showMessage := false) {
    key := StrLower(Trim(SubStr(NormalizeCustomTarget(target), 9)))
    if IsProtectedPrimaryKey(key)
        return true
    if showMessage
        MsgBox "Unknown built-in target: " key "`n`nKnown examples: builtin:quicknotes, builtin:lexicomp, builtin:uptodate", "Invalid Target", "Icon!"
    return false
}


IsKnownWorkflowTarget(target, showMessage := false) {
    code := StrLower(Trim(SubStr(NormalizeCustomTarget(target), 10)))
    knownCodes := "|bmi_ocr|fehr_ticket|new_patient_search|new_bve|location|mcds_override|midnight_datetime|now_datetime|"
    if InStr(knownCodes, "|" code "|")
        return true
    if showMessage
        MsgBox "Unknown workflow target: " code, "Invalid Target", "Icon!"
    return false
}

IsKnownCalculatorTarget(target, showMessage := false) {
    code := StrLower(Trim(SubStr(NormalizeCustomTarget(target), 6)))
    knownCodes := "|4t|benzo|corrected-calcium|calcium|crcl|bodyweight|iron|opioid-mme|opioid|daysupply|day-supply|taper|pcn-cross-reactivity|pcn|osmolarity|iv-osmolarity|apap-tox|acetaminophen|nac|anticoag-reversal|reversal|kcentra|digifab|digoxin-fab|crofab|snakebite|crrt|rrt|renal-replacement|renal-library|renal-rules|renal-dosing-library|dka|diabetic-ketoacidosis|hyperglycemic-crisis|vanco|vancomycin|vancomycin-dosing|vancopk|critical-drip|critical-drips|drip-tracker|exposure-pep|pep|hiv-pep|std-pep|sti-pep|occupational-pep|body-fluid-exposure|tnk-stroke|tnk|rsi|rabies-pep|rabies|medrec|medication-reconciliation|"
    if InStr(knownCodes, "|" code "|")
        return true
    if showMessage
        MsgBox "Unknown calculator target: " code "`n`n" CustomTargetHelpText(), "Invalid Target", "Icon!"
    return false
}

OpenCustomMenuTarget(target) {
    target := NormalizeCustomTarget(target)
    if IsCalcTarget(target) {
        code := StrLower(Trim(SubStr(target, 6)))
        switch code {
            case "4t":                    Calc_Open4TScore()
            case "benzo":                 Calc_OpenBenzoConversion()
            case "corrected-calcium", "calcium": Calc_OpenCorrectedCalcium()
            case "crcl":                  Calc_OpenCrCl()
            case "bodyweight":            Calc_OpenBodyWeight()
            case "iron":                  Calc_OpenIronDeficit()
            case "opioid-mme", "opioid":  Calc_OpenOpioidConversion()
            case "daysupply", "day-supply", "taper": Calc_OpenDaySupply()
            case "pcn-cross-reactivity", "pcn": Calc_OpenPcnCrossReactivity()
            case "osmolarity", "iv-osmolarity": Calc_OpenOsmolarity()
            case "apap-tox", "acetaminophen", "nac": Calc_OpenAcetaminophenToxicity()
            case "anticoag-reversal", "reversal", "kcentra": Calc_OpenAnticoagReversal()
            case "digifab", "digoxin-fab": Calc_OpenDigiFab()
            case "crofab", "snakebite": Calc_OpenCroFab()
            case "crrt", "rrt", "renal-replacement": Calc_OpenCrrtDosing()
            case "renal-library", "renal-rules", "renal-dosing-library": Hub_OpenRenalLibrary()
            case "dka", "diabetic-ketoacidosis", "hyperglycemic-crisis": Calc_OpenDkaTreatment()
            case "vanco", "vancomycin", "vancomycin-dosing", "vancopk": Calc_OpenVancomycinDosing()
            case "critical-drip", "critical-drips", "drip-tracker": Calc_OpenCriticalDripTracker()
            case "exposure-pep", "pep", "hiv-pep", "std-pep", "sti-pep", "occupational-pep", "body-fluid-exposure": Calc_OpenExposurePep()
            case "tnk-stroke", "tnk": Calc_OpenTnkStroke()
            case "rsi": Calc_OpenRsiDosing()
            case "rabies-pep", "rabies": Calc_OpenRabiesPep()
            case "aminoglycoside", "gentamicin", "tobramycin", "amikacin", "ag": Calc_OpenAminoglycoside()
            case "antibiotic", "abx", "id", "empiric", "infection": Calc_OpenAntibiotic()
            case "qtc", "qt": Calc_OpenQTc()
            case "medrec", "medication-reconciliation": Menu_OpenMedRec()
            case "anion-gap", "aniongap", "gap", "delta": Calc_OpenAnionGap()
            case "sodium", "na", "hyponatremia", "hypernatremia", "free-water": Calc_OpenSodium()
            case "steroid", "corticosteroid", "prednisone", "dexamethasone": Calc_OpenSteroid()
            case "fentanyl", "fentanyl-patch", "patch-mme": Calc_OpenFentanylMME()
            case "emergency", "code", "code-blue", "acls", "hyperkalemia", "hyperk", "status-epilepticus", "seizure", "naloxone", "narcan", "massive-transfusion", "mtp": Calc_OpenEmergency()
            default: MsgBox "Unknown calculator target: " code, "Custom Menu", "Icon!"
        }
        return
    }
    if IsBuiltinTarget(target) {
        key := StrLower(Trim(SubStr(target, 9)))
        LaunchBuiltInPrimary(key)
        return
    }
    if RegExMatch(target, "i)^workflow:") {
        key := StrLower(Trim(SubStr(target, 10)))
        OpenWorkflowToolByKey(key)
        return
    }
    SafeLaunchTarget(target)
}

AtomicWrite(path, text) {
    ; Retry with backoff. OneDrive sync and antivirus can briefly lock the target
    ; file mid-write; a short wait-and-retry makes those transient locks invisible.
    ; Each attempt writes a fresh temp file, backs up the original, then moves into place.
    static maxAttempts := 5
    static backoffMs := [80, 200, 450, 900]   ; waits BETWEEN attempts (last attempt has no wait after)
    lastErr := ""

    loop maxAttempts {
        attempt := A_Index
        tmp := path "." A_TickCount "." Random(1000, 9999) ".tmp"
        bak := path ".bak"
        try {
            FileAppend text, tmp, "UTF-8"

            ; Keep a one-file backup before replacing. Avoid deleting the original first,
            ; so a failed write/move does not leave the user with no CSV/notes file.
            if FileExist(path) {
                if FileExist(bak)
                    FileDelete bak
                FileCopy path, bak, true
            }

            FileMove tmp, path, true
            return   ; success
        } catch as e {
            lastErr := e
            ; clean up the temp file from this failed attempt
            try {
                if FileExist(tmp)
                    FileDelete tmp
            }
            ; if attempts remain, wait then retry; otherwise fall through to throw
            if attempt < maxAttempts
                Sleep backoffMs[attempt]
        }
    }

    ; All attempts failed — surface a clear, actionable error.
    msg := "Could not save '" path "' after " maxAttempts " attempts."
        . "`nThe file may be locked by OneDrive sync or antivirus. Your previous data is unchanged."
    try Log("AtomicWrite failed: " path " :: " (IsObject(lastErr) ? lastErr.Message : lastErr))
    throw Error(msg)
}

; -------------------------------------------------------------------------------------------------
; CSV HELPERS
; -------------------------------------------------------------------------------------------------
CsvEscape(value) {
    value := StrReplace(value, "`r", " ")
    value := StrReplace(value, "`n", " ")
    value := StrReplace(value, '"', '""')
    return '"' value '"'
}

CsvParseLine(line) {
    fields   := []
    field    := ""
    inQuotes := false
    skipNext := false

    Loop StrLen(line) {
        if skipNext {
            skipNext := false
            continue
        }
        ch   := SubStr(line, A_Index, 1)
        next := SubStr(line, A_Index + 1, 1)

        if ch = '"' {
            if inQuotes and next = '"' {
                field    .= '"'
                skipNext := true
                continue
            }
            inQuotes := !inQuotes
            continue
        }

        if ch = "," and !inQuotes {
            fields.Push(field)
            field := ""
            continue
        }

        field .= ch
    }
    fields.Push(field)
    return fields
}

; -------------------------------------------------------------------------------------------------
; KEY HELPERS
; -------------------------------------------------------------------------------------------------
FindPrimaryByKey(key, list) {
    for idx, item in list {
        if item.key = key
            return idx
    }
    return 0
}

GenerateUniqueKey(prefix, list) {
    Loop {
        candidate := prefix "_" A_TickCount "_" Random(1000, 9999)
        if !FindPrimaryByKey(candidate, list)
            return candidate
    }
}

; =================================================================================================
;  EDITING, DELETING, MOVING, MANAGE GUI
; =================================================================================================

global _pending_edit_context := {}

IsWebOrMailUrl(s) {
    return RegExMatch(s, "i)^(https?://|mailto:)")
}

IsLocalLaunchPath(s) {
    s := Trim(s)
    return RegExMatch(s, "i)^[a-z]:\\") or SubStr(s, 1, 2) = "\\"
}

IsAllowedLaunchTarget(s) {
    return IsWebOrMailUrl(s) or IsLocalLaunchPath(s)
}

IsPotentiallyExecutableTarget(s) {
    s := Trim(s)
    if RegExMatch(s, "i)^[a-z][a-z0-9+.-]*:") and !IsWebOrMailUrl(s)
        return true

    ; Strip URL query/fragment text before checking a local file extension.
    s := RegExReplace(s, "[?#].*$")
    return RegExMatch(s, "i)\.(exe|bat|cmd|com|msi|msp|ps1|psm1|vbs|vbe|js|jse|wsf|wsh|scr|hta|lnk|ahk)$")
}

ValidateLaunchTargetForSave(target) {
    target := Trim(target)
    if target = ""
        return true

    if !IsAllowedLaunchTarget(target) {
        MsgBox "Only http://, https://, mailto:, drive-letter paths, and UNC paths are allowed.`n`nBlocked target:`n" target, "Invalid Link", "Icon!"
        return false
    }

    if IsLocalLaunchPath(target) {
        msg := "This is a local or network path. Only save it if you trust the target and its location."
        if IsPotentiallyExecutableTarget(target)
            msg .= "`n`nWarning: this target appears executable or script-like."
        msg .= "`n`nSave this target?`n" target
        if MsgBox(msg, "Confirm Local Path", 0x24) != "Yes"
            return false
    }
    return true
}

SafeLaunchTarget(target) {
    target := Trim(target)
    if target = ""
        return false

    if !IsAllowedLaunchTarget(target) {
        Log("Blocked unsupported launch target: " target)
        MsgBox "Blocked unsupported link target.`n`nAllowed targets: http://, https://, mailto:, drive-letter paths, and UNC paths.`n`nTarget:`n" target, "Blocked Link", "Icon!"
        return false
    }

    if IsLocalLaunchPath(target) {
        msg := "Open this local/network target?`n`n" target
        if IsPotentiallyExecutableTarget(target)
            msg := "This target appears executable or script-like. Run only if you trust it.`n`n" target
        if MsgBox(msg, "Confirm Launch", 0x24) != "Yes"
            return false
    }

    Run target
    return true
}

IsProtectedPrimaryKey(key) {
    switch key {
        case "lexicomp", "uptodate", "vancopk", "liverpool", "extravasafe", "quicknotes":
            return true
        default:
            return false
    }
}

IsProtectedPrimaryItem(item) {
    return HasProp(item, "key") and IsProtectedPrimaryKey(item.key)
}

; Default URLs for built-in links — used to seed the edit field and as a fallback
; if a built-in link's stored URL was ever cleared.
GetBuiltInDefaultUrl(key) {
    switch key {
        case "lexicomp":    return "https://online.lexi.com"
        case "uptodate":    return "https://www.uptodate.com"
        case "vancopk":     return "https://globalrph.com/vancomycin/"
        case "liverpool":   return "https://www.hiv-druginteractions.org/checker"
        case "extravasafe": return "https://www.extravasafe.com"
        default:            return ""
    }
}

EditLinkPopup(linkObj, isPrimary, primaryIndex := 0, otherIndex := 0) {
    global _pending_edit_context
    _pending_edit_context := { isPrimary: isPrimary, pIndex: primaryIndex, oIndex: otherIndex }

    g := Gui("-Resize", "Edit Link")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text",, "Name:")
    tName := g.Add("Edit", "w260", linkObj.name)

    g.Add("Text",, "URL:")
    ; Built-in links now allow URL edits too — except Quick Notes Pro, which launches
    ; the in-script notes window and has no meaningful URL to edit.
    isQuickNotesLink := isPrimary and HasProp(linkObj, "key") and linkObj.key = "quicknotes"
    urlFieldValue := (linkObj.url = "builtin" and !isQuickNotesLink) ? GetBuiltInDefaultUrl(linkObj.key) : linkObj.url
    tUrl := g.Add("Edit", "w260", isQuickNotesLink ? "" : urlFieldValue)
    if isQuickNotesLink
        tUrl.Enabled := false

    g.Add("Button", "w90 Default", "Save").OnEvent("Click", (*) => SafeRun(EditLinkPopup_Save, g, tName, tUrl, linkObj))
    g.Add("Button", "x+10 w90", "Cancel").OnEvent("Click", (*) => g.Destroy())
    g.Show()
}

EditLinkPopup_Save(g, tName, tUrl, linkObj) {
    global _pending_edit_context
    newName := Trim(tName.Value)
    newUrl  := Trim(tUrl.Value)

    if newName = "" {
        MsgBox "Name cannot be empty."
        return
    }
    if !_pending_edit_context.isPrimary and newUrl = "" {
        MsgBox "URL cannot be empty for non-primary items."
        return
    }
    if newUrl != "" and !ValidateLaunchTargetForSave(newUrl)
        return

    if _pending_edit_context.isPrimary {
        list := LoadPrimaryLinks()
        idx  := _pending_edit_context.pIndex
        if idx {
            list[idx].name := newName
            isQuickNotesLink := HasProp(list[idx], "key") and list[idx].key = "quicknotes"
            ; Any protected primary link except Quick Notes Pro may have its URL edited,
            ; but its key remains protected for delete/hide behavior.
            if !isQuickNotesLink and newUrl != ""
                list[idx].url := newUrl
            SavePrimaryLinks(list)
        }
    } else {
        links := LoadOtherLinks()
        idx   := _pending_edit_context.oIndex
        if idx {
            links[idx].name := newName
            links[idx].url  := newUrl
            SaveOtherLinks(links)
        }
    }
    g.Destroy()
    RefreshManageLinksGui()
}

DeleteOtherLink(idx) {
    links := LoadOtherLinks()
    if idx > 0 and idx <= links.Length {
        if MsgBox("Delete '" links[idx].name "'?", "Confirm", 0x24) = "Yes" {
            links.RemoveAt(idx)
            SaveOtherLinks(links)
            RefreshManageLinksGui()
        }
    }
}

MoveToPrimary(idx) {
    links := LoadOtherLinks()
    if idx = 0 or idx > links.Length
        return
    moved := links[idx]
    oldId := "link:other:" RC2_StableLinkId(moved.name, moved.url)
    primary := LoadPrimaryLinks()
    newKey := GenerateUniqueKey("user", primary)
    primary.Push({ name: moved.name, key: newKey, url: moved.url, visible: true })
    SavePrimaryLinks(primary)
    links.RemoveAt(idx)
    SaveOtherLinks(links)
    RC2_RemapFavoriteId(oldId, "link:primary:" newKey)
    RefreshManageLinksGui()
}

; -------------------------------------------------------------------------------------------------
; MANAGE GUI
; -------------------------------------------------------------------------------------------------
global _manageGui       := 0
global _favoritesListView := 0
global _primaryListView := 0
global _otherListView   := 0

global _osmoLibListView := 0
global _autoTextListView := 0
global _quickGlanceListBox := 0
global _quickGlanceShowMissingCheck := 0
global _quickGlanceSettingsRows := []
global _quickGlanceDragIndex := 0
global _quickGlanceDragListHwnd := 0
global _quickGlanceMessagesRegistered := false
global _customMenuDragIndex := 0
global _customMenuDragListHwnd := 0
global _customMenuMessagesRegistered := false

OpenManageLinksGui(startTab := 1) {
    global _manageGui, _favoritesListView, _primaryListView, _otherListView, _customMenuListView, _autoTextListView, _osmoLibListView
    global _quickGlanceListBox, _quickGlanceShowMissingCheck, _quickGlanceSettingsRows
    if IsObject(_manageGui)
        _manageGui.Destroy()

    g := Gui("+Resize +Border", "Settings & Database Management - " AppDisplayName)
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    _manageGui := g

    tabs := g.Add("Tab3", "xm ym w760 h830", ["Main Menu (Favorites + Links)", "Auto Text / Dot Phrases", "Calculator Database", "Patient Display", "Middle-Click Submenus"])

    tabs.UseTab(1)
    g.Add("Text", "xm+18 ym+42 w250 Section", "Favorites")
    g.Add("Text", "x+60 yp", "Tools and links always shown on the main menu · sorted A-Z")

    _favoritesListView := g.Add("ListView", "xm+18 y+6 w720 r6 Grid -Multi", ["Type", "Name"])
    _favoritesListView.ModifyCol(1, 100)
    _favoritesListView.ModifyCol(2, 590)
    _favoritesListView.OnEvent("DoubleClick", (*) => SafeRun(Manage_Favorite_Remove))
    g.Add("Button", "xm+18 y+6 w124", "Remove Favorite").OnEvent("Click", (*) => SafeRun(Manage_Favorite_Remove))
    g.Add("Button", "x+6 yp w150", "Add from Search").OnEvent("Click", (*) => SafeRun(RC2_OpenPalette))

    g.Add("Text", "xm+18 y+18 w240 Section", "Quick Menu Links")
    g.Add("Text", "x+110 yp", "Additional links assigned to Main or All · sorted A-Z")

    _primaryListView := g.Add("ListView", "xm+18 y+6 w720 r5 Grid -Multi", ["Name", "Location"])
    _primaryListView.ModifyCol(1, 420)
    _primaryListView.ModifyCol(2, 100)
    _primaryListView.OnEvent("DoubleClick", (LV, row) => SafeRun(Manage_Primary_Edit, LV, row))

    g.Add("Button", "xm+18 y+6 w150",  "Switch Main / All").OnEvent("Click", (*) => SafeRun(Manage_Primary_ToggleVisible))
    g.Add("Button", "x+6 yp w72",  "Up").OnEvent("Click", (*) => SafeRun(Manage_Primary_Move, -1))
    g.Add("Button", "x+6 yp w72",  "Down").OnEvent("Click", (*) => SafeRun(Manage_Primary_Move, 1))
    g.Add("Button", "x+6 yp w104",  "Add Link").OnEvent("Click",    (*) => SafeRun(Manage_AddPrimary))
    g.Add("Button", "x+6 yp w104",  "Delete").OnEvent("Click",         (*) => SafeRun(Manage_Primary_Delete))

    g.Add("Text", "xm+18 y+20 w240 Section", "More Links")
    g.Add("Text", "x+110 yp", "Shown under All Tools & Links · double-click to edit")

    _otherListView := g.Add("ListView", "xm+18 y+6 w720 r4 Grid -Multi", ["Name", "URL"])
    _otherListView.ModifyCol(1, 180)
    _otherListView.ModifyCol(2, 520)
    _otherListView.OnEvent("DoubleClick", (LV, row) => SafeRun(Manage_Other_Edit, LV, row))

    g.Add("Button", "xm+18 y+6 w130",  "Add New").OnEvent("Click",         (*) => SafeRun(Manage_AddOther))
    g.Add("Button", "x+8  yp w72", "Up").OnEvent("Click", (*) => SafeRun(Manage_Other_Move, -1))
    g.Add("Button", "x+8  yp w72", "Down").OnEvent("Click", (*) => SafeRun(Manage_Other_Move, 1))
    g.Add("Button", "x+8  yp w130", "Delete").OnEvent("Click",          (*) => SafeRun(Manage_Other_Delete))
    g.Add("Button", "x+8  yp w160", "Show on Main Menu").OnEvent("Click", (*) => SafeRun(Manage_Other_MoveToPrimary))
  
  
    tabs.UseTab(2)
    g.Add("Text", "xm+18 ym+42 w480 Section", "Auto Text / Dot Phrases / Quick Type Notes")
    g.Add("Text", "xm+18 y+4 w720", "Manage saved text snippets and optional dot-phrase triggers here. These are not shown as a separate quick-menu submenu.")
    g.Add("Text", "xm+18 y+4 w720", "Visible triggers auto-expand when typed. Dot phrases use a leading dot, such as .renal. Inline shortcuts can expand after Space/Tab/Enter, such as qhs.")

    _autoTextListView := g.Add("ListView", "xm+18 y+10 w720 r22 Grid -Multi", ["Name", "Type", "Shortcut", "Preview", "Visible"])
    _autoTextListView.ModifyCol(1, 170)
    _autoTextListView.ModifyCol(2, 90)
    _autoTextListView.ModifyCol(3, 110)
    _autoTextListView.ModifyCol(4, 275)
    _autoTextListView.ModifyCol(5, 70)
    _autoTextListView.OnEvent("DoubleClick", (LV, row) => SafeRun(Manage_AutoText_Edit, LV, row))

    g.Add("Button", "xm+18 y+8 w110", "Add Phrase").OnEvent("Click", (*) => SafeRun(Manage_AutoText_Add))
    g.Add("Button", "x+6 yp w80",  "Edit").OnEvent("Click",       (*) => SafeRun(Manage_AutoText_EditSelected))
    g.Add("Button", "x+6 yp w80",  "Move Up").OnEvent("Click",    (*) => SafeRun(Manage_AutoText_Move, -1))
    g.Add("Button", "x+6 yp w90",  "Move Down").OnEvent("Click",  (*) => SafeRun(Manage_AutoText_Move, 1))
    g.Add("Button", "x+6 yp w100", "Toggle Vis").OnEvent("Click", (*) => SafeRun(Manage_AutoText_ToggleVisible))
    g.Add("Button", "x+6 yp w110", "Copy Text").OnEvent("Click",  (*) => SafeRun(Manage_AutoText_CopySelected))
    g.Add("Button", "x+6 yp w80",  "Delete").OnEvent("Click",     (*) => SafeRun(Manage_AutoText_Delete))
    g.Add("Button", "x+8 yp w110", "Move Up").OnEvent("Click",   (*) => SafeRun(Manage_OsmoLib_Move, -1))
    g.Add("Button", "x+8 yp w110", "Move Down").OnEvent("Click", (*) => SafeRun(Manage_OsmoLib_Move, 1))

    tabs.UseTab(3)
    g.Add("Text", "xm+18 ym+42 w480 Section", "Calculator Database")
    g.Add("Text", "xm+18 y+4 w720", "Manage local reference data used by built-in clinical calculators. Calculator formulas and logic are admin-controlled through app updates.")
    g.Add("Text", "xm+18 y+14 w300 Section", "Osmolarity / Additive Library")
    g.Add("Text", "x+30 yp", "(double-click to edit)")

    _osmoLibListView := g.Add("ListView", "xm+18 y+6 w720 r24 Grid -Multi", ["Substance", "mOsm/mL", "Synonyms"])
    _osmoLibListView.ModifyCol(1, 260)
    _osmoLibListView.ModifyCol(2, 90)
    _osmoLibListView.ModifyCol(3, 370)
    _osmoLibListView.OnEvent("DoubleClick", (LV, row) => SafeRun(Manage_OsmoLib_Edit, LV, row))

    g.Add("Button", "xm+18 y+8 w130", "Add New").OnEvent("Click", (*) => SafeRun(Manage_OsmoLib_Add))
    g.Add("Button", "x+8 yp w130", "Edit").OnEvent("Click", (*) => SafeRun(Manage_OsmoLib_EditSelected))
    g.Add("Button", "x+8 yp w130", "Delete").OnEvent("Click",  (*) => SafeRun(Manage_OsmoLib_Delete))
    g.Add("Button", "xm+18 y+12 w230", "Edit Critical Drip Presets").OnEvent("Click", (*) => SafeRun(CriticalDripLibrary_SettingsOpen))
    g.Add("Button", "x+8 yp w230", "Edit Opioid MME Factors").OnEvent("Click", (*) => SafeRun(OpioidSettings_Open))
    Theme_Subtle(g.Add("Text", "xm+18 y+6 w720", "Drip presets are editable starter options, not facility protocol. Opioid factors remain exposure-screening references, not dose-conversion instructions."))

    tabs.UseTab(4)
    g.SetFont("s12 Bold", "Segoe UI")
    g.Add("Text", "xm+18 ym+42 w720", "Patient quick glance")
    g.SetFont("s10", "Segoe UI")
    g.Add("Text", "xm+18 y+6 w720", "Choose the results shown after a screen capture. Use Move Up / Move Down to set the clinical reading order; double-click a row to show or hide it.")
    g.Add("Text", "xm+18 y+6 w720", "The default starts with every electrolyte, followed by renal/dosing values, CBC, albumin, and lactate.")

    _quickGlanceSettingsRows := QuickGlance_LoadConfig().rows
    _quickGlanceListBox := g.Add("ListBox", "xm+18 y+12 w720 r24 AltSubmit")
    _quickGlanceListBox.OnEvent("DoubleClick", (*) => SafeRun(QuickGlance_SettingsToggle))
    _quickGlanceListBox.OnEvent("Change", (*) => QuickGlance_SettingsRememberSelection())

    g.Add("Button", "xm+18 y+10 w120", "Show / Hide").OnEvent("Click", (*) => SafeRun(QuickGlance_SettingsToggle))
    g.Add("Button", "x+8 yp w100", "Move Up").OnEvent("Click", (*) => SafeRun(QuickGlance_SettingsMove, -1))
    g.Add("Button", "x+8 yp w110", "Move Down").OnEvent("Click", (*) => SafeRun(QuickGlance_SettingsMove, 1))
    g.Add("Button", "x+8 yp w170", "Edit Default Result Units").OnEvent("Click", (*) => SafeRun(LabUnitSettings_Open))
    g.Add("Button", "x+8 yp w150", "Edit Normal Ranges").OnEvent("Click", (*) => SafeRun(LabRangeSettings_Open))
    g.Add("Button", "xm+18 y+8 w150", "Edit Result Colors").OnEvent("Click", (*) => SafeRun(QuickGlanceColorSettings_Open))
    g.Add("Button", "x+8 yp w150", "Reset F defaults").OnEvent("Click", (*) => SafeRun(QuickGlance_SettingsReset))

    config := QuickGlance_LoadConfig()
    _quickGlanceShowMissingCheck := g.Add("CheckBox", "xm+18 y+16 w720", "Keep selected rows visible when a value was not captured")
    _quickGlanceShowMissingCheck.Value := config.showMissing ? 1 : 0
    _quickGlanceShowMissingCheck.OnEvent("Click", (*) => SafeRun(QuickGlance_SettingsSave))
    Theme_Subtle(g.Add("Text", "xm+38 y+3 w690", "Blank values remain an em dash; PhUCKIT never fills in an uncaptured result."))
    QuickGlance_EnsureDragMessages()

    tabs.UseTab(5)
    g.SetFont("s12 Bold", "Segoe UI")
    g.Add("Text", "xm+18 ym+42 w720", "Build your middle-click menu")
    g.SetFont("s10", "Segoe UI")
    g.Add("Text", "xm+18 y+6 w720", "Use the arrows to reorder items. Items stay with their submenu, and submenu arrows move the entire submenu with its links. Add and edit menus or launchable items below.")
    _customMenuListView := g.Add("ListView", "xm+18 y+12 w720 r24 Grid -Multi", ["Type", "Submenu", "Name", "Target", "Visible"])
    _customMenuListView.ModifyCol(1, 70)
    _customMenuListView.ModifyCol(2, 180)
    _customMenuListView.ModifyCol(3, 210)
    _customMenuListView.ModifyCol(4, 190)
    _customMenuListView.ModifyCol(5, 60)
    _customMenuListView.OnEvent("DoubleClick", (LV, row) => SafeRun(Manage_Custom_Edit, LV, row))
    g.Add("Button", "xm+18 y+8 w120", "Add Submenu").OnEvent("Click", (*) => SafeRun(Manage_Custom_AddMenu))
    g.Add("Button", "x+8 yp w120", "Add Item").OnEvent("Click", (*) => SafeRun(Manage_Custom_AddItem))
    g.Add("Button", "x+8 yp w100", "Edit").OnEvent("Click", (*) => SafeRun(Manage_Custom_EditSelected))
    g.Add("Button", "x+8 yp w95", "▲ Move Up").OnEvent("Click", (*) => SafeRun(Manage_Custom_Move, -1))
    g.Add("Button", "x+8 yp w105", "▼ Move Down").OnEvent("Click", (*) => SafeRun(Manage_Custom_Move, 1))
    g.Add("Button", "x+8 yp w90", "Delete").OnEvent("Click", (*) => SafeRun(Manage_Custom_Delete))
    g.Add("Button", "x+8 yp w105", "Show / Hide").OnEvent("Click", (*) => SafeRun(Manage_Custom_ToggleVisible))
    Theme_Subtle(g.Add("Text", "xm+38 y+8 w690", "Targets can be websites, files, calc:crcl, calc:medrec, workflow:bmi_ocr, or builtin:quicknotes. Custom submenus appear on the main middle-click menu."))

    tabs.UseTab()
    tabs.Value := Max(1, Min(startTab, 5))
    g.Add("Button", "xm y+12 w90", "Close").OnEvent("Click", (*) => g.Destroy())

    g.Show("w780 h900")
    RefreshManageLinksGui()
}

RefreshManageLinksGui() {
    global _manageGui, _favoritesListView, _primaryListView, _otherListView, _customMenuListView, _autoTextListView, _osmoLibListView
    if !IsObject(_manageGui)
        return
    primary := LoadPrimaryLinks()
    other   := LoadOtherLinks()
    autoText := LoadAutoTextPhrases()
    osmoLib := LoadOsmolarityLibrary()

    _favoritesListView.Delete()
    for entry in RC2_FavoriteEntries()
        _favoritesListView.Add(, entry.kind = "link" ? "Link" : "Tool", entry.name)

    _primaryListView.Delete()
    for p in primary
        _primaryListView.Add(, p.name, p.visible ? "Main menu" : "All Tools & Links")

    _otherListView.Delete()
    for o in other
        _otherListView.Add(, o.name, o.url)

    if IsObject(_customMenuListView) {
        _customMenuListView.Delete()
        for row in LoadCustomMenuRows()
            _customMenuListView.Add(, row.type = "menu" ? "SUBMENU" : "ITEM", row.category,
                row.type = "menu" ? "" : row.name, row.type = "menu" ? "" : row.target,
                row.visible ? "Yes" : "No")
        _customMenuListView.ModifyCol(1, 70)
        _customMenuListView.ModifyCol(2, 180)
        _customMenuListView.ModifyCol(3, 210)
        _customMenuListView.ModifyCol(4, 190)
        _customMenuListView.ModifyCol(5, 60)
    }


    _autoTextListView.Delete()
    for phrase in autoText {
        mode := AutoTextGetMode(phrase)
        _autoTextListView.Add(, phrase.name, AutoTextModeLabel(mode), NormalizeAutoTextTriggerForMode(phrase.trigger, mode), AutoTextPreview(phrase.expansion), phrase.visible ? "Yes" : "Hidden")
    }

    _osmoLibListView.Delete()
    for item in osmoLib
        _osmoLibListView.Add(, item.name, item.mosmPerMl, OsmoGetSynonyms(item))

    QuickGlance_SettingsRefresh()
}

QuickGlance_SettingsSelectedIndex() {
    global _quickGlanceListBox
    try return Number(_quickGlanceListBox.Value)
    return 0
}

QuickGlance_SettingsRememberSelection(*) {
    ; Selection is read directly from the AltSubmit list box when an action occurs.
}

QuickGlance_SettingsLabel(row) {
    state := row.visible ? "SHOWN" : "HIDDEN"
    return "[" state "]  " row.label "   ·   " row.group
}

QuickGlance_SettingsRefresh(selected := 0) {
    global _quickGlanceListBox, _quickGlanceSettingsRows
    if !IsObject(_quickGlanceListBox)
        return
    if !IsObject(_quickGlanceSettingsRows) || _quickGlanceSettingsRows.Length = 0
        _quickGlanceSettingsRows := QuickGlance_LoadConfig().rows

    if selected = 0
        selected := QuickGlance_SettingsSelectedIndex()
    labels := []
    for row in _quickGlanceSettingsRows
        labels.Push(QuickGlance_SettingsLabel(row))

    try {
        _quickGlanceListBox.Delete()
        _quickGlanceListBox.Add(labels)
        if labels.Length > 0
            _quickGlanceListBox.Choose(Max(1, Min(selected = 0 ? 1 : selected, labels.Length)))
    }
}

QuickGlance_SettingsSave(*) {
    global _quickGlanceSettingsRows, _quickGlanceShowMissingCheck
    showMissing := true
    try showMissing := _quickGlanceShowMissingCheck.Value = 1
    QuickGlance_SaveConfig(_quickGlanceSettingsRows, showMissing)
    QuickGlance_RefreshOpenHub()
}

QuickGlance_SettingsToggle(*) {
    global _quickGlanceSettingsRows
    idx := QuickGlance_SettingsSelectedIndex()
    if idx < 1 || idx > _quickGlanceSettingsRows.Length
        return
    _quickGlanceSettingsRows[idx].visible := !_quickGlanceSettingsRows[idx].visible
    QuickGlance_SettingsSave()
    QuickGlance_SettingsRefresh(idx)
}

QuickGlance_SettingsMove(direction, *) {
    global _quickGlanceSettingsRows
    idx := QuickGlance_SettingsSelectedIndex()
    destination := idx + direction
    if idx < 1 || idx > _quickGlanceSettingsRows.Length
        return
    if destination < 1 || destination > _quickGlanceSettingsRows.Length
        return
    moving := _quickGlanceSettingsRows[idx]
    _quickGlanceSettingsRows[idx] := _quickGlanceSettingsRows[destination]
    _quickGlanceSettingsRows[destination] := moving
    QuickGlance_SettingsSave()
    QuickGlance_SettingsRefresh(destination)
}

QuickGlance_SettingsReset(*) {
    global _quickGlanceSettingsRows, _quickGlanceShowMissingCheck
    _quickGlanceSettingsRows := QuickGlance_DefaultSettingsRows()
    try _quickGlanceShowMissingCheck.Value := 1
    QuickGlance_SettingsSave()
    QuickGlance_SettingsRefresh(1)
}

QuickGlance_EnsureDragMessages() {
    global _quickGlanceMessagesRegistered
    if _quickGlanceMessagesRegistered
        return
    OnMessage(0x0201, QuickGlance_OnLButtonDown)
    OnMessage(0x0200, QuickGlance_OnMouseMove)
    OnMessage(0x0202, QuickGlance_OnLButtonUp)
    _quickGlanceMessagesRegistered := true
}

QuickGlance_ListIndexFromPoint(hwnd, lParam) {
    result := DllCall("SendMessage", "Ptr", hwnd, "UInt", 0x01A9, "Ptr", 0, "Ptr", lParam, "Ptr")
    return (result & 0xFFFF) + 1
}

QuickGlance_OnLButtonDown(wParam, lParam, msg, hwnd) {
    global _quickGlanceListBox, _quickGlanceSettingsRows, _quickGlanceDragIndex, _quickGlanceDragListHwnd
    if !IsObject(_quickGlanceListBox) || hwnd != _quickGlanceListBox.Hwnd
        return
    idx := QuickGlance_ListIndexFromPoint(hwnd, lParam)
    if idx < 1 || idx > _quickGlanceSettingsRows.Length
        return
    _quickGlanceDragIndex := idx
    _quickGlanceDragListHwnd := hwnd
    try _quickGlanceListBox.Choose(idx)
    DllCall("SetCapture", "Ptr", hwnd)
}

QuickGlance_OnMouseMove(wParam, lParam, msg, hwnd) {
    global _quickGlanceListBox, _quickGlanceSettingsRows, _quickGlanceDragIndex, _quickGlanceDragListHwnd
    if _quickGlanceDragIndex = 0 || _quickGlanceDragListHwnd = 0
        return
    idx := QuickGlance_ListIndexFromPoint(_quickGlanceDragListHwnd, lParam)
    if idx >= 1 && idx <= _quickGlanceSettingsRows.Length
        try _quickGlanceListBox.Choose(idx)
}

QuickGlance_OnLButtonUp(wParam, lParam, msg, hwnd) {
    global _quickGlanceSettingsRows, _quickGlanceDragIndex, _quickGlanceDragListHwnd
    if _quickGlanceDragIndex = 0 || _quickGlanceDragListHwnd = 0
        return
    source := _quickGlanceDragIndex
    destination := QuickGlance_ListIndexFromPoint(_quickGlanceDragListHwnd, lParam)
    _quickGlanceDragIndex := 0
    _quickGlanceDragListHwnd := 0
    DllCall("ReleaseCapture")
    if destination < 1 || destination > _quickGlanceSettingsRows.Length {
        QuickGlance_SettingsRefresh(source)
        return
    }
    if destination = source
        return
    moving := _quickGlanceSettingsRows.RemoveAt(source)
    _quickGlanceSettingsRows.InsertAt(destination, moving)
    QuickGlance_SettingsSave()
    QuickGlance_SettingsRefresh(destination)
}

CustomMenu_EnsureDragMessages() {
    global _customMenuMessagesRegistered
    if _customMenuMessagesRegistered
        return
    OnMessage(0x0201, CustomMenu_OnLButtonDown)
    OnMessage(0x0200, CustomMenu_OnMouseMove)
    OnMessage(0x0202, CustomMenu_OnLButtonUp)
    _customMenuMessagesRegistered := true
}

CustomMenu_ListIndexFromPoint(hwnd, lParam) {
    x := lParam & 0xFFFF
    y := (lParam >> 16) & 0xFFFF
    if x > 0x7FFF
        x -= 0x10000
    if y > 0x7FFF
        y -= 0x10000
    info := Buffer(16, 0)
    NumPut("Int", x, info, 0)
    NumPut("Int", y, info, 4)
    item := DllCall("SendMessage", "Ptr", hwnd, "UInt", 0x1012, "Ptr", 0, "Ptr", info, "Ptr")
    return NumGet(info, 8, "Int") + 1
}

CustomMenu_OnLButtonDown(wParam, lParam, msg, hwnd) {
    global _customMenuListView, _customMenuDragIndex, _customMenuDragListHwnd
    if !IsObject(_customMenuListView) || hwnd != _customMenuListView.Hwnd
        return
    idx := CustomMenu_ListIndexFromPoint(hwnd, lParam)
    rows := LoadCustomMenuRows()
    if idx < 1 || idx > rows.Length
        return
    _customMenuDragIndex := idx
    _customMenuDragListHwnd := hwnd
    try _customMenuListView.Modify(idx, "Select Focus")
    DllCall("SetCapture", "Ptr", hwnd)
}

CustomMenu_OnMouseMove(wParam, lParam, msg, hwnd) {
    global _customMenuListView, _customMenuDragIndex, _customMenuDragListHwnd
    if _customMenuDragIndex = 0 || _customMenuDragListHwnd = 0
        return
    idx := CustomMenu_ListIndexFromPoint(_customMenuDragListHwnd, lParam)
    if idx > 0
        try _customMenuListView.Modify(idx, "Select Focus")
}

CustomMenu_OnLButtonUp(wParam, lParam, msg, hwnd) {
    global _customMenuDragIndex, _customMenuDragListHwnd
    if _customMenuDragIndex = 0 || _customMenuDragListHwnd = 0
        return
    source := _customMenuDragIndex
    destination := CustomMenu_ListIndexFromPoint(_customMenuDragListHwnd, lParam)
    _customMenuDragIndex := 0
    _customMenuDragListHwnd := 0
    DllCall("ReleaseCapture")
    rows := LoadCustomMenuRows()
    if source < 1 || source > rows.Length || destination < 1 || destination > rows.Length || source = destination
        return

    moving := rows[source]
    target := rows[destination]
    ; Dropping an item onto a submenu (or another item in one) changes its
    ; parent. Dropping a submenu reorders the submenu block.
    if moving.type = "item" {
        if target.type = "menu"
            moving.category := target.category
        else if target.type = "item"
            moving.category := target.category
    }
    rows.RemoveAt(source)
    if destination > source
        destination -= 1
    rows.InsertAt(destination, moving)
    SaveCustomMenuRows(rows)
    RefreshManageLinksGui()
}

AutoTextPreview(text) {
    text := StrReplace(text, "``r``n", "  /  ")
    text := StrReplace(text, "``n", "  /  ")
    if StrLen(text) > 100
        return SubStr(text, 1, 97) "..."
    return text
}

; -------------------------------------------------------------------------------------------------
; CUSTOM DROP-DOWN MENU MANAGEMENT
; -------------------------------------------------------------------------------------------------
Manage_Custom_SelectedRow() {
    global _customMenuListView
    return _customMenuListView.GetNext(0, "Focused")
}

Manage_Custom_AddMenu(*) {
    rows := LoadCustomMenuRows()
    ib := InputBox("New drop-down menu name:`nExample: Pharmacist Workflow", "Add Drop-down Menu", "w420 h140")
    if ib.Result != "OK" or Trim(ib.Value) = ""
        return
    category := Trim(ib.Value)
    if CustomMenuCategoryExists(rows, category) {
        MsgBox "That drop-down menu already exists.", "Add Drop-down Menu", "Icon!"
        return
    }
    rows.Push({ type: "menu", category: category, name: "", target: "", visible: true })
    SaveCustomMenuRows(rows)
    RefreshManageLinksGui()
}

Manage_Custom_AddItem(*) {
    rows := LoadCustomMenuRows()
    categoryDefault := ""
    row := Manage_Custom_SelectedRow()
    if row > 0 and row <= rows.Length
        categoryDefault := rows[row].category

    cb := InputBox("Drop-down menu/category name:`nExample: Pharmacist Workflow", "Add Custom Menu Item", "w420 h140", categoryDefault)
    if cb.Result != "OK" or Trim(cb.Value) = ""
        return
    category := Trim(cb.Value)

    nb := InputBox("Item name shown under '" category "':`nExample: CrCl Calculator", "Add Custom Menu Item", "w420 h140")
    if nb.Result != "OK" or Trim(nb.Value) = ""
        return
    name := Trim(nb.Value)

    tb := InputBox(CustomTargetHelpText(), "Add Custom Menu Item Target", "w520 h260", "calc:")
    if tb.Result != "OK"
        return
    target := NormalizeCustomTarget(tb.Value)
    if !ValidateCustomTargetForSave(target)
        return

    EnsureCustomMenuCategory(rows, category)
    rows.Push({ type: "item", category: category, name: name, target: target, visible: true })
    SaveCustomMenuRows(rows)
    RefreshManageLinksGui()
}

Manage_Custom_EditSelected(*) {
    row := Manage_Custom_SelectedRow()
    if row
        Manage_Custom_Edit(0, row)
}

Manage_Custom_Edit(LV, row) {
    rows := LoadCustomMenuRows()
    if row = 0 or row > rows.Length
        return
    item := rows[row]

    if item.type = "menu" {
        ib := InputBox("Drop-down menu name:", "Edit Drop-down Menu", "w420 h140", item.category)
        if ib.Result != "OK" or Trim(ib.Value) = ""
            return
        oldCategory := item.category
        newCategory := Trim(ib.Value)
        if StrLower(oldCategory) != StrLower(newCategory) and CustomMenuCategoryExists(rows, newCategory) {
            MsgBox "That drop-down menu already exists.", "Edit Drop-down Menu", "Icon!"
            return
        }
        for idx, r in rows {
            if StrLower(r.category) = StrLower(oldCategory)
                rows[idx].category := newCategory
        }
        SaveCustomMenuRows(rows)
        RefreshManageLinksGui()
        return
    }

    cb := InputBox("Drop-down menu/category name:", "Edit Custom Menu Item", "w420 h140", item.category)
    if cb.Result != "OK" or Trim(cb.Value) = ""
        return
    newCategory := Trim(cb.Value)

    nb := InputBox("Item name:", "Edit Custom Menu Item", "w420 h140", item.name)
    if nb.Result != "OK" or Trim(nb.Value) = ""
        return
    newName := Trim(nb.Value)

    tb := InputBox(CustomTargetHelpText(), "Edit Custom Menu Item Target", "w520 h260", item.target)
    if tb.Result != "OK"
        return
    newTarget := NormalizeCustomTarget(tb.Value)
    if !ValidateCustomTargetForSave(newTarget)
        return

    EnsureCustomMenuCategory(rows, newCategory)
    rows[row].category := newCategory
    rows[row].name := newName
    rows[row].target := newTarget
    SaveCustomMenuRows(rows)
    RefreshManageLinksGui()
}

CustomMenu_ReorderRows(rows, row, direction) {
    if !IsObject(rows) || row < 1 || row > rows.Length || (direction != -1 && direction != 1)
        return {rows: rows, index: row, moved: false}

    selected := rows[row]
    if selected.type = "item" {
        target := 0
        idx := row + direction
        while idx >= 1 && idx <= rows.Length {
            if rows[idx].type = "item" && StrLower(rows[idx].category) = StrLower(selected.category) {
                target := idx
                break
            }
            idx += direction
        }
        if target = 0
            return {rows: rows, index: row, moved: false}
        moving := rows[row]
        rows[row] := rows[target]
        rows[target] := moving
        return {rows: rows, index: target, moved: true}
    }

    ; A submenu moves as one block so its custom links cannot be separated or lost.
    category := selected.category
    block := []
    remaining := []
    for item in rows {
        if StrLower(item.category) = StrLower(category)
            block.Push(item)
        else
            remaining.Push(item)
    }

    menuCategories := []
    for item in rows {
        if item.type = "menu" && StrLower(item.category) != StrLower(category)
            menuCategories.Push(item.category)
    }
    currentMenu := 0
    for item in rows {
        if item.type = "menu" {
            if StrLower(item.category) = StrLower(category)
                break
            currentMenu += 1
        }
    }
    targetMenu := currentMenu + (direction > 0 ? 1 : 0)
    if targetMenu < 1 || targetMenu > menuCategories.Length
        return {rows: rows, index: row, moved: false}
    targetCategory := menuCategories[targetMenu]

    insertAt := remaining.Length + 1
    if direction < 0 {
        for idx, item in remaining {
            if StrLower(item.category) = StrLower(targetCategory) {
                insertAt := idx
                break
            }
        }
    } else {
        last := 0
        for idx, item in remaining {
            if StrLower(item.category) = StrLower(targetCategory)
                last := idx
        }
        if last > 0
            insertAt := last + 1
    }
    for idx, item in block
        remaining.InsertAt(insertAt + idx - 1, item)

    newIndex := insertAt
    return {rows: remaining, index: newIndex, moved: true}
}

Manage_Custom_Move(direction) {
    global _customMenuListView
    rows := LoadCustomMenuRows()
    row := Manage_Custom_SelectedRow()
    if row = 0
        return
    result := CustomMenu_ReorderRows(rows, row, direction)
    if !result.moved
        return
    SaveCustomMenuRows(result.rows)
    RefreshManageLinksGui()
    _customMenuListView.Modify(result.index, "Select Focus")
}

Manage_Custom_ToggleVisible(*) {
    global _customMenuListView
    rows := LoadCustomMenuRows()
    row := Manage_Custom_SelectedRow()
    if row = 0 or row > rows.Length
        return
    rows[row].visible := !rows[row].visible
    SaveCustomMenuRows(rows)
    RefreshManageLinksGui()
    _customMenuListView.Modify(row, "Select Focus")
}

Manage_Custom_Delete(*) {
    rows := LoadCustomMenuRows()
    row := Manage_Custom_SelectedRow()
    if row = 0 or row > rows.Length {
        MsgBox "Select a custom menu or item first.", "Delete Custom Menu", "Icon!"
        return
    }
    item := rows[row]
    if item.type = "menu" {
        count := 0
        for r in rows {
            if r.type = "item" and StrLower(r.category) = StrLower(item.category)
                count += 1
        }
        msg := "Delete the drop-down menu '" item.category "'?"
        if count > 0
            msg .= "`n`nThis also deletes " count " item(s) under it."
        if MsgBox(msg, "Confirm", 0x24) != "Yes"
            return
        idx := rows.Length
        while idx >= 1 {
            if StrLower(rows[idx].category) = StrLower(item.category)
                rows.RemoveAt(idx)
            idx -= 1
        }
    } else {
        if MsgBox("Delete '" item.name "' from '" item.category "'?", "Confirm", 0x24) != "Yes"
            return
        rows.RemoveAt(row)
    }
    SaveCustomMenuRows(rows)
    RefreshManageLinksGui()
}


; -------------------------------------------------------------------------------------------------
; AUTO TEXT / DOT PHRASE MANAGEMENT
; -------------------------------------------------------------------------------------------------
Manage_AutoText_SelectedRow() {
    global _autoTextListView
    return _autoTextListView.GetNext(0, "Focused")
}

Manage_AutoText_PromptMode(defaultMode := "dot") {
    defaultMode := AutoTextNormalizeMode(defaultMode)
    prompt := "Shortcut type:`n`n"
        . "dot    = dot phrase, such as .renal or .vanco`n"
        . "inline = plain text shortcut, such as qhs + Space/Tab/Enter`n`n"
        . "Enter dot or inline."
    mb := InputBox(prompt, "Auto Text Shortcut Type", "w520 h230", defaultMode)
    if mb.Result != "OK"
        return ""
    mode := AutoTextNormalizeMode(mb.Value)
    if !AutoTextIsValidMode(mode) {
        MsgBox "Enter dot or inline.", "Auto Text Shortcut Type", "Icon!"
        return ""
    }
    return mode
}

Manage_AutoText_Add(*) {
    rows := LoadAutoTextPhrases()
    nb := InputBox("Phrase name shown in Manage Quick Menu:`nExample: Vanco monitoring note", "Add Auto Text Phrase", "w440 h140")
    if nb.Result != "OK" or Trim(nb.Value) = ""
        return
    name := Trim(nb.Value)

    mode := Manage_AutoText_PromptMode("dot")
    if mode = ""
        return

    triggerPrompt := mode = "inline"
        ? "Inline shortcut, optional:`nExamples: qhs, asa, q6h`nTyping the shortcut followed by Space/Tab/Enter expands it.`nLeave blank to store it only for Copy Text."
        : "Dot phrase trigger, optional:`nExamples: .vanco, .renal, .d5w`nLeave blank to store it only for Copy Text."
    defaultTrigger := mode = "inline" ? "" : "."
    tb := InputBox(triggerPrompt, "Add Auto Text Shortcut", "w520 h210", defaultTrigger)
    if tb.Result != "OK"
        return
    trigger := NormalizeAutoTextTriggerForMode(tb.Value, mode)
    if trigger != "" and !AutoTextTriggerLooksSafe(trigger, mode) {
        MsgBox "Shortcut triggers cannot contain spaces, tabs, or line breaks.", "Invalid Shortcut", "Icon!"
        return
    }
    if trigger != "" and AutoTextTriggerExists(rows, trigger, mode) {
        MsgBox "That " AutoTextModeLabel(mode) " trigger already exists: " trigger, "Duplicate Trigger", "Icon!"
        return
    }

    eb := InputBox("Expansion text / quick type note:`nUse \n for intentional line breaks if typing in this small box.", "Add Auto Text Expansion", "w560 h220")
    if eb.Result != "OK" or Trim(eb.Value) = ""
        return
    expansion := StrReplace(eb.Value, "\n", "`r`n")

    rows.Push({ name: name, mode: mode, trigger: trigger, expansion: expansion, visible: true })
    SaveAutoTextPhrases(rows)
    RefreshManageLinksGui()
}

Manage_AutoText_EditSelected(*) {
    row := Manage_AutoText_SelectedRow()
    if row
        Manage_AutoText_Edit(0, row)
}

Manage_AutoText_Edit(LV, row) {
    rows := LoadAutoTextPhrases()
    if row = 0 or row > rows.Length
        return
    item := rows[row]
    oldMode := AutoTextGetMode(item)

    nb := InputBox("Phrase name:", "Edit Auto Text Phrase", "w440 h140", item.name)
    if nb.Result != "OK" or Trim(nb.Value) = ""
        return
    name := Trim(nb.Value)

    mode := Manage_AutoText_PromptMode(oldMode)
    if mode = ""
        return

    triggerPrompt := mode = "inline"
        ? "Inline shortcut, optional:`nExamples: qhs, asa, q6h`nTyping the shortcut followed by Space/Tab/Enter expands it."
        : "Dot phrase trigger, optional:"
    tb := InputBox(triggerPrompt, "Edit Auto Text Shortcut", "w520 h190", NormalizeAutoTextTriggerForMode(item.trigger, mode))
    if tb.Result != "OK"
        return
    trigger := NormalizeAutoTextTriggerForMode(tb.Value, mode)
    if trigger != "" and !AutoTextTriggerLooksSafe(trigger, mode) {
        MsgBox "Shortcut triggers cannot contain spaces, tabs, or line breaks.", "Invalid Shortcut", "Icon!"
        return
    }
    if trigger != "" and AutoTextTriggerExists(rows, trigger, mode, row) {
        MsgBox "That " AutoTextModeLabel(mode) " trigger already exists: " trigger, "Duplicate Trigger", "Icon!"
        return
    }

    eb := InputBox("Expansion text / quick type note:`nExisting line breaks display as \n for easier editing.", "Edit Auto Text Expansion", "w600 h240", StrReplace(item.expansion, "`r`n", "\n"))
    if eb.Result != "OK" or Trim(eb.Value) = ""
        return

    rows[row].name := name
    rows[row].mode := mode
    rows[row].trigger := trigger
    rows[row].expansion := StrReplace(eb.Value, "\n", "`r`n")
    SaveAutoTextPhrases(rows)
    RefreshManageLinksGui()
}

Manage_AutoText_Move(direction) {
    global _autoTextListView
    rows := LoadAutoTextPhrases()
    row := Manage_AutoText_SelectedRow()
    if row = 0
        return
    newPos := row + direction
    if newPos < 1 or newPos > rows.Length
        return
    temp := rows[row]
    rows[row] := rows[newPos]
    rows[newPos] := temp
    SaveAutoTextPhrases(rows)
    RefreshManageLinksGui()
    _autoTextListView.Modify(newPos, "Select Focus")
}

Manage_AutoText_ToggleVisible(*) {
    global _autoTextListView
    rows := LoadAutoTextPhrases()
    row := Manage_AutoText_SelectedRow()
    if row = 0 or row > rows.Length
        return
    rows[row].visible := !rows[row].visible
    SaveAutoTextPhrases(rows)
    RefreshManageLinksGui()
    _autoTextListView.Modify(row, "Select Focus")
}

Manage_AutoText_CopySelected(*) {
    rows := LoadAutoTextPhrases()
    row := Manage_AutoText_SelectedRow()
    if row = 0 or row > rows.Length {
        MsgBox "Select an auto text phrase first.", "Copy Auto Text", "Icon!"
        return
    }
    A_Clipboard := rows[row].expansion
    ToolTip "Copied auto text: " rows[row].name
    SetTimer(() => ToolTip(), -1200)
}

Manage_AutoText_Delete(*) {
    rows := LoadAutoTextPhrases()
    row := Manage_AutoText_SelectedRow()
    if row = 0 or row > rows.Length {
        MsgBox "Select an auto text phrase first.", "Delete Auto Text", "Icon!"
        return
    }
    if MsgBox("Delete auto text phrase '" rows[row].name "'?", "Confirm", 0x24) != "Yes"
        return
    rows.RemoveAt(row)
    SaveAutoTextPhrases(rows)
    RefreshManageLinksGui()
}

AutoTextTriggerExists(rows, trigger, mode := "dot", skipIndex := 0) {
    mode := AutoTextNormalizeMode(mode)
    trigger := StrLower(NormalizeAutoTextTriggerForMode(trigger, mode))
    if trigger = ""
        return false
    for idx, row in rows {
        if idx = skipIndex
            continue
        rowMode := AutoTextGetMode(row)
        if rowMode != mode
            continue
        if StrLower(NormalizeAutoTextTriggerForMode(row.trigger, rowMode)) = trigger
            return true
    }
    return false
}

; -------------------------------------------------------------------------------------------------
; OSMOLARITY LIBRARY MANAGEMENT (Calculator Database section)
; -------------------------------------------------------------------------------------------------
Manage_OsmoLib_Add(*) {
    ib := InputBox("Substance name:", "Add Substance", "w360 h130")
    if ib.Result != "OK" or Trim(ib.Value) = ""
        return
    name := Trim(ib.Value)

    lib := LoadOsmolarityLibrary()
    for item in lib {
        if StrLower(item.name) = StrLower(name) {
            MsgBox "'" name "' is already in the library.", "Duplicate", "Icon!"
            return
        }
    }

    mb := InputBox("mOsm/mL for '" name "':", "Add Substance", "w360 h130")
    if mb.Result != "OK" or !IsNumber(Trim(mb.Value)) or Trim(mb.Value) < 0 {
        MsgBox "Enter a valid non-negative number for mOsm/mL.", "Add Substance", "Icon!"
        return
    }

    sb := InputBox("Synonyms / shorthand terms, comma-separated:`nExample: D5W, D5, 5% dextrose in water", "Add Substance Synonyms", "w420 h150")
    synonyms := (sb.Result = "OK" ? Trim(sb.Value) : "")

    lib.Push({ name: name, mosmPerMl: Number(Trim(mb.Value)), synonyms: synonyms })
    SaveOsmolarityLibrary(lib)
    RefreshManageLinksGui()
}

Manage_OsmoLib_Edit(LV, row) {
    if row = 0
        return
    lib := LoadOsmolarityLibrary()
    if row > lib.Length
        return
    item := lib[row]

    ib := InputBox("Substance name:", "Edit Substance", "w360 h130", item.name)
    if ib.Result != "OK" or Trim(ib.Value) = ""
        return
    newName := Trim(ib.Value)

    mb := InputBox("mOsm/mL for '" newName "':", "Edit Substance", "w360 h130", item.mosmPerMl)
    if mb.Result != "OK" or !IsNumber(Trim(mb.Value)) or Trim(mb.Value) < 0 {
        MsgBox "Enter a valid non-negative number for mOsm/mL.", "Edit Substance", "Icon!"
        return
    }

    sb := InputBox("Synonyms / shorthand terms, comma-separated:`nExample: D5W, D5, 5% dextrose in water", "Edit Substance Synonyms", "w420 h150", OsmoGetSynonyms(item))
    if sb.Result != "OK"
        return

    lib[row].name := newName
    lib[row].mosmPerMl := Number(Trim(mb.Value))
    lib[row].synonyms := Trim(sb.Value)
    SaveOsmolarityLibrary(lib)
    RefreshManageLinksGui()
}


Manage_OsmoLib_EditSelected(*) {
    global _osmoLibListView
    row := _osmoLibListView.GetNext(0, "Focused")
    if row = 0 {
        MsgBox "Select a substance first.", "Edit", "Icon!"
        return
    }
    Manage_OsmoLib_Edit(_osmoLibListView, row)
}

Manage_OsmoLib_Delete(*) {
    global _osmoLibListView
    row := _osmoLibListView.GetNext(0, "Focused")
    if row = 0 {
        MsgBox "Select a substance first.", "Delete", "Icon!"
        return
    }
    lib := LoadOsmolarityLibrary()
    if row > lib.Length
        return
    item := lib[row]
    if MsgBox("Delete '" item.name "' from the osmolarity library?", "Confirm", 0x24) != "Yes"
        return
    lib.RemoveAt(row)
    SaveOsmolarityLibrary(lib)
    RefreshManageLinksGui()
}

Manage_Favorite_Move(direction) {
    global _favoritesListView
    favorites := RC2_GetFavorites()
    row := _favoritesListView.GetNext(0, "Focused")
    if row = 0
        row := _favoritesListView.GetNext(0, "Selected")
    newPos := row + direction
    if row < 1 || newPos < 1 || newPos > favorites.Length
        return
    moved := favorites[row]
    favorites.RemoveAt(row)
    favorites.InsertAt(newPos, moved)
    RC2_WriteList("Launcher", "Favorites", favorites)
    RefreshManageLinksGui()
    _favoritesListView.Modify(newPos, "Select Focus")
}

Manage_Favorite_Remove(*) {
    global _favoritesListView
    favorites := RC2_GetFavorites()
    row := _favoritesListView.GetNext(0, "Focused")
    if row = 0
        row := _favoritesListView.GetNext(0, "Selected")
    if row < 1 || row > favorites.Length
        return
    favorites.RemoveAt(row)
    RC2_WriteList("Launcher", "Favorites", favorites)
    RefreshManageLinksGui()
    if favorites.Length > 0
        _favoritesListView.Modify(Min(row, favorites.Length), "Select Focus")
}

Manage_Primary_Move(direction) {
    global _primaryListView
    primary := LoadPrimaryLinks()
    row     := _primaryListView.GetNext(0, "Focused")
    if row = 0
        return
    newPos := row + direction
    if newPos < 1 or newPos > primary.Length
        return
    temp            := primary[row]
    primary[row]    := primary[newPos]
    primary[newPos] := temp
    SavePrimaryLinks(primary)
    RefreshManageLinksGui()
    _primaryListView.Modify(newPos, "Select Focus")
}

Manage_Primary_ToggleVisible(*) {
    global _primaryListView
    primary := LoadPrimaryLinks()
    row     := _primaryListView.GetNext(0, "Focused")
    if row = 0 or row > primary.Length
        return
    primary[row].visible := !primary[row].visible
    SavePrimaryLinks(primary)
    RefreshManageLinksGui()
    _primaryListView.Modify(row, "Select Focus")
}

Manage_AddPrimary(*) {
    primary := LoadPrimaryLinks()
    newItem := { name: "New Primary", key: GenerateUniqueKey("user", primary), url: "https://example.com", visible: true }
    primary.Push(newItem)
    SavePrimaryLinks(primary)
    RefreshManageLinksGui()
    EditLinkPopup(newItem, true, primary.Length, 0)
}

Manage_Primary_Delete(*) {
    global _primaryListView
    primary := LoadPrimaryLinks()
    row := _primaryListView.GetNext(0, "Focused")
    if row = 0 or row > primary.Length {
        MsgBox "Select a primary link first.", "Delete Primary", "Icon!"
        return
    }
    item := primary[row]
    if IsProtectedPrimaryItem(item) {
        MsgBox "'" item.name "' is a protected built-in link and can't be deleted.`nUse Switch Main / All to choose where it appears.", "Protected", "Icon!"
        return
    }
    if MsgBox("Delete '" item.name "' from primary links?", "Confirm", 0x24) != "Yes"
        return
    primary.RemoveAt(row)
    SavePrimaryLinks(primary)
    RefreshManageLinksGui()
}

Manage_Primary_Edit(LV, row) {
    primary := LoadPrimaryLinks()
    if row > 0 and row <= primary.Length
        EditLinkPopup(primary[row], true, row, 0)
}

Manage_Other_Edit(LV, row) {
    other := LoadOtherLinks()
    if row > 0 and row <= other.Length
        EditLinkPopup(other[row], false, 0, row)
}

Manage_Other_Delete(*) {
    global _otherListView
    row := _otherListView.GetNext(0, "Focused")
    if row
        DeleteOtherLink(row)
}

Manage_Other_MoveToPrimary(*) {
    global _otherListView
    row := _otherListView.GetNext(0, "Focused")
    if row
        MoveToPrimary(row)
}

Manage_AddOther(*) {
    other   := LoadOtherLinks()
    newItem := { name: "New Item", url: "https://example.com" }
    other.Push(newItem)
    SaveOtherLinks(other)
    RefreshManageLinksGui()
    EditLinkPopup(newItem, false, 0, other.Length)
}


; =================================================================================================
;  RC2 — UNIVERSAL TOOL SEARCH, FAVORITES, RECENTS, AND WINDOW CLOSE
; =================================================================================================

global _rc2PaletteGui := 0
global _rc2PaletteEdit := 0
global _rc2PaletteList := 0
global _rc2PaletteRows := []
global _rc2SettingsPath := PhuckitUserDataRoot "\data\rc2_user.ini"
global _quickLauncherGui := 0
global _quickLauncherTree := 0
global _quickLauncherFilter := 0
global _quickLauncherItemMap := Map()
global _quickMenuActive := false
global _middleClickPending := false
global _quickMenuWheelRegistered := false

; Native Windows popup menus do not reliably route wheel hotkeys through #HotIf.
; Register the message hook once so the visible All Tools & Links menu scrolls
; with the physical wheel just like a normal Windows menu.
OnMessage(0x020A, QuickLauncher_OnMouseWheel)
_quickMenuWheelRegistered := true

RC2_ToolRegistry() {
    static tools := [
        { id: "daysupply", name: "Days Supply / Taper Calculator", aliases: "day supply days supply sig prednisone taper tablets quantity", action: Calc_OpenDaySupply },
        { id: "crcl", name: "Creatinine Clearance (Cockcroft-Gault)", aliases: "crcl cockcroft renal kidney", action: Calc_OpenCrCl },
        { id: "bodyweight", name: "Ideal / Adjusted Body Weight", aliases: "ibw adjbw obesity weight", action: Calc_OpenBodyWeight },
        { id: "vancomycin", name: "Vancomycin AUC / Dosing Support", aliases: "vanc vanco auc trough", action: Calc_OpenVancomycinDosing },
        { id: "critical-drip", name: "Critical Drip Tracker", aliases: "critical drip infusion bag volume concentration rate hang time stability coverage", action: Calc_OpenCriticalDripTracker },
        { id: "aminoglycoside", name: "Aminoglycoside Dosing", aliases: "gent tobra amikacin", action: Calc_OpenAminoglycoside },
        { id: "crrt", name: "CRRT Solution / Electrolyte Support", aliases: "crrt dialysis renal replacement", action: Calc_OpenCrrtDosing },
        { id: "renal-library", name: "Renal Rules Library (screening)", aliases: "renal dosing renal rules dose adjustment kidney crcl", action: Hub_OpenRenalLibrary },
        { id: "calcium", name: "Corrected Calcium", aliases: "calcium albumin corrected ca", action: Calc_OpenCorrectedCalcium },
        { id: "aniongap", name: "Anion Gap / Delta-Delta", aliases: "anion gap delta acidosis", action: Calc_OpenAnionGap },
        { id: "sodium", name: "Sodium Correction / Free Water Deficit", aliases: "sodium na hypernatremia water deficit", action: Calc_OpenSodium },
        { id: "osmolarity", name: "IV Solution Osmolarity / Tonicity", aliases: "osm osmolarity tonicity iv", action: Calc_OpenOsmolarity },
        { id: "iron", name: "Iron Deficit (Ganzoni)", aliases: "iron ganzoni anemia", action: Calc_OpenIronDeficit },
        { id: "mme", name: "Opioid MME Estimate", aliases: "mme opioid morphine conversion", action: Calc_OpenOpioidConversion },
        { id: "fentanyl", name: "Fentanyl Patch / Oral MME", aliases: "fentanyl patch mme", action: Calc_OpenFentanylMME },
        { id: "benzo", name: "Benzodiazepine Conversion", aliases: "benzo lorazepam diazepam conversion", action: Calc_OpenBenzoConversion },
        { id: "steroid", name: "Corticosteroid Equivalency", aliases: "steroid prednisone dexamethasone", action: Calc_OpenSteroid },
        { id: "rsi", name: "RSI Dosing Support", aliases: "rsi intubation sedation paralytic", action: Calc_OpenRsiDosing },
        { id: "tnk", name: "TNK Stroke Eligibility / Dose", aliases: "tnk tenecteplase stroke", action: Calc_OpenTnkStroke },
        { id: "dka", name: "DKA Treatment Support", aliases: "dka insulin ketoacidosis", action: Calc_OpenDkaTreatment },
        { id: "emergency", name: "Emergency / Code Algorithms", aliases: "code emergency aclS", action: Calc_OpenEmergency },
        { id: "apap", name: "Acetaminophen Toxicity + NAC", aliases: "apap tylenol nac toxicity", action: Calc_OpenAcetaminophenToxicity },
        { id: "digifab", name: "DigiFab Digoxin Toxicity Support", aliases: "digoxin digifab toxicity", action: Calc_OpenDigiFab },
        { id: "crofab", name: "CroFab Crotalid Envenomation Support", aliases: "snake crofab envenomation", action: Calc_OpenCroFab },
        { id: "reversal", name: "Anticoagulant Reversal Agents", aliases: "reversal anticoagulation warfarin doac", action: Calc_OpenAnticoagReversal },
        { id: "antibiotics", name: "Infectious Disease — Empiric Antibiotics", aliases: "antibiotic id empiric infection", action: Calc_OpenAntibiotic },
        { id: "pep", name: "Exposure PEP Decision Engine", aliases: "pep hiv exposure", action: Calc_OpenExposurePep },
        { id: "rabies", name: "Rabies PEP Decision Support", aliases: "rabies bite pep", action: Calc_OpenRabiesPep },
        { id: "pcn", name: "Penicillin Cross-Reactivity", aliases: "penicillin allergy cephalosporin cross", action: Calc_OpenPcnCrossReactivity },
        { id: "4t", name: "4T Score (HIT Probability)", aliases: "4t hit heparin thrombocytopenia", action: Calc_Open4TScore },
        { id: "qtc", name: "QTc Calculator", aliases: "qtc bazett fridericia", action: Calc_OpenQTc },
        { id: "reminders", name: "Lab / Dose Reminders", aliases: "reminder lab dose", action: Calc_OpenReminders },
        { id: "handoff", name: "Shift Handoff Builder", aliases: "handoff shift signout", action: Calc_OpenHandoff },
        { id: "patient", name: "Patient Workspace", aliases: "patient hub workspace", action: Menu_OpenPatientHub },
        { id: "medrec", name: "Medication Reconciliation", aliases: "medrec medication reconciliation acute ambulatory home medication comparison", action: Menu_OpenMedRec },
        { id: "order-review", name: "Order Review Queue", aliases: "order review pharmacy verification medication checklist safety", action: Menu_OpenOrderReview },
        { id: "capture-evidence", name: "Capture Evidence Review", aliases: "ocr capture evidence raw text conflict confirmation", action: Menu_OpenCaptureEvidence },
        { id: "background-lookups", name: "Background Patient Lookups", aliases: "sql lsv lab trend fill history formulary referral coverage background data", action: Menu_OpenBackgroundLookups }
    ]
    return tools
}

RC2_LinkRegistry(primary := 0, other := 0, custom := 0) {
    if !IsObject(primary)
        primary := LoadPrimaryLinks()
    if !IsObject(other)
        other := LoadOtherLinks()
    if !IsObject(custom)
        custom := LoadCustomMenuRows()

    links := []
    for idx, item in primary {
        links.Push({
            id: "link:primary:" item.key,
            kind: "link",
            name: item.name,
            aliases: item.key " " item.url " primary link website",
            label: "LINK · PRIMARY   " item.name,
            action: RC2_OpenPrimaryLink.Bind(item, idx)
        })
    }

    for idx, item in other {
        links.Push({
            id: "link:other:" RC2_StableLinkId(item.name, item.url),
            kind: "link",
            name: item.name,
            aliases: item.url " other link website",
            label: "LINK · OTHER   " item.name,
            action: RC2_OpenOtherLink.Bind(item, idx)
        })
    }

    for idx, row in custom {
        if row.type != "item" || !row.visible
            continue
        category := row.category != "" ? row.category : "CUSTOM"
        links.Push({
            id: "link:custom:" RC2_StableLinkId(category " " row.name, row.target),
            kind: "link",
            name: row.name,
            aliases: category " " row.target " custom link website",
            label: "LINK · " StrUpper(category) "   " row.name,
            action: RC2_OpenCustomLink.Bind(row.target)
        })
    }
    return links
}

RC2_StableLinkId(name, target) {
    key := PatientV2_NormalizeMatch(name) "-" PatientV2_NormalizeMatch(target)
    return key = "-" ? "configured-link" : key
}

RC2_SearchRegistry(primary := 0, other := 0, custom := 0) {
    entries := []
    for tool in RC2_ToolRegistry() {
        entries.Push({
            id: tool.id,
            kind: "tool",
            name: tool.name,
            aliases: tool.aliases,
            label: tool.name,
            action: tool.action
        })
    }
    for link in RC2_LinkRegistry(primary, other, custom)
        entries.Push(link)
    return entries
}

RC2_FilterSearchEntries(entries, query := "") {
    matches := []
    query := StrLower(Trim(query))
    for entry in entries {
        haystack := StrLower(entry.name " " entry.aliases " " entry.id)
        if query = "" || InStr(haystack, query)
            matches.Push(entry)
    }
    return matches
}

RC2_OpenPrimaryLink(item, idx := 0) {
    OpenItem(item, true, idx, 0)
}

RC2_OpenOtherLink(item, idx := 0) {
    OpenItem(item, false, 0, idx)
}

RC2_OpenCustomLink(target) {
    OpenCustomMenuTarget(target)
}

RC2_FindTool(id) {
    for tool in RC2_ToolRegistry()
        if tool.id = id
            return tool
    return ""
}

RC2_FindEntry(id) {
    for entry in RC2_SearchRegistry()
        if entry.id = id
            return entry
    return ""
}

RC2_ReadList(section, key, fallback := "") {
    try value := IniRead(_rc2SettingsPath, section, key, fallback)
    catch
        value := fallback
    out := []
    for item in StrSplit(value, "|") {
        item := Trim(item)
        if item != ""
            out.Push(item)
    }
    return out
}

RC2_WriteList(section, key, values) {
    try DirCreate(A_ScriptDir "\data")
    joined := ""
    for idx, value in values
        joined .= (idx > 1 ? "|" : "") value
    IniWrite(joined, _rc2SettingsPath, section, key)
}

RC2_GetFavorites() {
    favorites := RC2_ReadList("Launcher", "Favorites", "crcl|vancomycin|osmolarity|medrec")
    valid := []
    for id in favorites
        if IsObject(RC2_FindEntry(id))
            valid.Push(id)
    return valid
}

RC2_FavoriteEntries() {
    entries := []
    for id in RC2_GetFavorites() {
        entry := RC2_FindEntry(id)
        if IsObject(entry)
            entries.Push(entry)
    }
    return entries
}

RC2_GetRecents() {
    return RC2_ReadList("Launcher", "Recents", "")
}

RC2_RecordRecent(id) {
    current := RC2_GetRecents()
    next := [id]
    for oldId in current {
        ; Recents may contain either a clinical tool or a configured link.
        ; Validate against the complete registry so links survive and remain
        ; launchable after the menu is rebuilt.
        if oldId != id && IsObject(RC2_FindEntry(oldId))
            next.Push(oldId)
        if next.Length >= 8
            break
    }
    RC2_WriteList("Launcher", "Recents", next)
}

RC2_ToggleFavorite(id) {
    favorites := RC2_GetFavorites()
    next := []
    found := false
    for oldId in favorites {
        if oldId = id
            found := true
        else
            next.Push(oldId)
    }
    if !found
        next.InsertAt(1, id)
    RC2_WriteList("Launcher", "Favorites", next)
    RC2_PaletteRefresh()
}

RC2_RemapFavoriteId(oldId, newId) {
    favorites := RC2_ReadList("Launcher", "Favorites", "")
    changed := false
    for idx, id in favorites {
        if id = oldId {
            favorites[idx] := newId
            changed := true
        }
    }
    if !changed
        return
    unique := []
    seen := Map()
    for id in favorites {
        if id = "" || seen.Has(id)
            continue
        seen[id] := true
        unique.Push(id)
    }
    RC2_WriteList("Launcher", "Favorites", unique)
}

RC2_LaunchTool(id) {
    tool := RC2_FindTool(id)
    if !IsObject(tool) {
        MsgBox "Tool is unavailable: " id, "PhUCKIT"
        return
    }
    RC2_RecordRecent(id)
    try tool.action.Call()
    catch as err
        MsgBox "Could not open " tool.name ".`n`n" err.Message, "PhUCKIT"
}

RC2_LaunchSearchEntry(entry) {
    if !IsObject(entry)
        return
    ; Recent is a launcher history, not only a calculator history. Record
    ; tools, workbenches, and configured links from the same entry path.
    RC2_RecordRecent(entry.id)
    try entry.action.Call()
    catch as err
        MsgBox "Could not open " entry.name ".`n`n" err.Message, "PhUCKIT"
}

RC2_AddLauncherSections(menuObj) {
    favorites := RC2_GetFavorites()
    if favorites.Length {
        favMenu := Menu()
        for id in favorites {
            entry := RC2_FindEntry(id)
            if IsObject(entry)
          favMenu.Add(entry.name, RC2_MenuLaunchEntryHandler(id))
        }
        menuObj.Add("★ Favorites", favMenu)
    }

    recents := RC2_GetRecents()
    if recents.Length {
        recentMenu := Menu()
        for id in recents {
            entry := RC2_FindEntry(id)
            if IsObject(entry)
                recentMenu.Add(entry.name, RC2_MenuLaunchEntryHandler(id))
        }
        menuObj.Add("Recent", recentMenu)
    }

    menuObj.Add("Patient workspace / Med Rec   Ctrl+Space", (*) => Menu_OpenPatientContext())
    menuObj.Add()
}

RC2_MenuLaunchHandler(id) {
    copy := id
    return (*) => RC2_LaunchTool(copy)
}

RC2_MenuLaunchEntryHandler(id) {
    copy := id
    return (*) => RC2_LaunchSearchEntry(RC2_FindEntry(copy))
}

RC2_OpenPalette(*) {
    global _rc2PaletteGui, _rc2PaletteEdit, _rc2PaletteList

    if IsObject(_rc2PaletteGui) {
        try _rc2PaletteGui.Show()
        try _rc2PaletteEdit.Focus()
        return
    }

    g := Gui("+ToolWindow", "PhUCKIT — Search Everything")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym", "Search calculators, workflows, patient tools, and configured links")
    edit := g.Add("Edit", "xm y+6 w500")
    list := g.Add("ListBox", "xm y+8 w500 r14")
    openBtn := g.Add("Button", "xm y+8 w110 Default", "Open")
    pinBtn := g.Add("Button", "x+8 yp w150", "Favorite / Unfavorite")
    closeBtn := g.Add("Button", "x+8 yp w100", "Close")

    _rc2PaletteGui := g
    _rc2PaletteEdit := edit
    _rc2PaletteList := list

    edit.OnEvent("Change", (*) => RC2_PaletteRefresh())
    list.OnEvent("DoubleClick", (*) => RC2_PaletteLaunchSelected())
    openBtn.OnEvent("Click", (*) => RC2_PaletteLaunchSelected())
    pinBtn.OnEvent("Click", (*) => RC2_PaletteToggleSelected())
    closeBtn.OnEvent("Click", (*) => g.Hide())
    g.OnEvent("Escape", (*) => g.Hide())
    g.OnEvent("Close", (*) => g.Hide())

    RC2_PaletteRefresh()
    g.Show("AutoSize")
    edit.Focus()
}

RC2_PaletteRefresh(*) {
    global _rc2PaletteEdit, _rc2PaletteList, _rc2PaletteRows
    if !IsObject(_rc2PaletteList)
        return

    query := IsObject(_rc2PaletteEdit) ? StrLower(Trim(_rc2PaletteEdit.Value)) : ""
    rows := []
    labels := []
    favorites := RC2_GetFavorites()

    for entry in RC2_FilterSearchEntries(RC2_SearchRegistry(), query) {
        pinned := false
        for id in favorites
            if id = entry.id
                pinned := true
        labels.Push((pinned ? "★ " : "") entry.label)
        rows.Push(entry)
    }

    _rc2PaletteRows := rows
    _rc2PaletteList.Delete()
    if labels.Length
        _rc2PaletteList.Add(labels)
    if rows.Length
        _rc2PaletteList.Choose(1)
}

RC2_PaletteSelectedEntry() {
    global _rc2PaletteList, _rc2PaletteRows
    if !IsObject(_rc2PaletteList)
        return 0
    idx := _rc2PaletteList.Value
    return (idx >= 1 && idx <= _rc2PaletteRows.Length) ? _rc2PaletteRows[idx] : 0
}

RC2_PaletteLaunchSelected(*) {
    global _rc2PaletteGui
    entry := RC2_PaletteSelectedEntry()
    if !IsObject(entry)
        return
    if IsObject(_rc2PaletteGui)
        _rc2PaletteGui.Hide()
    RC2_LaunchSearchEntry(entry)
}

RC2_PaletteToggleSelected(*) {
    entry := RC2_PaletteSelectedEntry()
    if !IsObject(entry)
        return
    RC2_ToggleFavorite(entry.id)
    RefreshManageLinksGui()
}

RC2_CloseActivePhuckitWindow(*) {
    try {
        hwnd := WinGetID("A")
        if !hwnd
            return
        pid := WinGetPID("ahk_id " hwnd)
        if pid = A_Pid
            WinClose("ahk_id " hwnd)
    }
}


; =================================================================================================
;  QUICK MENU BUILDER + HOTKEYS
; =================================================================================================


; -------------------------------------------------------------------------------------------------
; WORKFLOW TOOL HOTKEYS IMPORTED FROM LEGACY SCRIPTS
; -------------------------------------------------------------------------------------------------
#HotIf GetKeyState("Ctrl", "P")
*LButton::SafeRun(BMI_FromRegion)
#HotIf

#HotIf Inpatient_IsPowerChartWindow()
!LButton::SafeRun(Inpatient_HandoffSelectedPatient)
#HotIf

#HotIf IsMedicationManagerWindow()
!LButton::SafeRun(Inpatient_CaptureMedicationManagerHeader)
#HotIf

#HotIf IsVerifyMedOrderWindow()
~h::SafeRun(Workflow_VerifyMedOrderDoubleH)
#HotIf

#HotIf IsVerifyMedOrderWindow()
:*?:eye::SafeRun(Workflow_EyeDropOrder)
#HotIf

Inpatient_IsPowerChartWindow() {
    hwnd := WinGetID("A")
    if !hwnd
        return false
    title := WinGetTitle("ahk_id " hwnd)
    windowClass := WinGetClass("ahk_id " hwnd)
    processName := WinGetProcessName("ahk_id " hwnd)

    ; Explicit PowerChart or inpatient-banner evidence wins over generic profile text.
    if Inpatient_PowerChartTitleEvidence(title, windowClass, processName)
        return true

    if IsMedicationManagerWindow()
        return false
    return false
}

Inpatient_PowerChartTitleEvidence(title, windowClass := "", processName := "") {
    if RegExMatch(title, "i)(?:PowerChart|PowerChart Organizer|Opened by)")
        return true
    if windowClass != "Transparent Windows Client" && processName != "wfica32.exe"
        return false
    if RegExMatch(title, "i)Custom Information")
        return false
    return RegExMatch(title, "i)(?:Inpatient|Admit\s*Dt|FIN\s*[:#]|Service\s*:|Attending\s*:)")
}

Inpatient_LogWindowEvidence(eventCode, hwnd, title, fields := 0) {
    try {
        className := ParsingDiagnostics_SafeToken(WinGetClass("ahk_id " hwnd), "unknown")
        processName := ParsingDiagnostics_SafeToken(WinGetProcessName("ahk_id " hwnd), "unknown")
        titleHasPowerChart := RegExMatch(title, "i)(?:PowerChart|Opened by)") ? 1 : 0
        titleHasVerify := RegExMatch(title, "i)Verify\s+Med\s+Order") ? 1 : 0
        detail := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "detail", "none"), "none")
        source := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "source", "none"), "none")
        Log("WindowEvidence event=" ParsingDiagnostics_SafeToken(eventCode, "window_event")
            " class=" className " process=" processName " titleLen=" StrLen(title)
            " titlePowerChart=" titleHasPowerChart " titleVerify=" titleHasVerify
            " source=" source " detail=" detail)
    }
}

IsVerifyMedOrderWindow() {
    hwnd := WinGetID("A")
    if !hwnd || IsMedicationManagerWindow()
        return false
    title := WinGetTitle("ahk_id " hwnd)
    if RegExMatch(title, "i)Verify\s+Med\s+Order") {
        Inpatient_LogWindowEvidence("verify_match", hwnd, title, Map("source", "title"))
        return true
    }
    controlText := ""
    for control in WinGetControls("ahk_id " hwnd) {
        try controlText .= " " Trim(ControlGetText(control, "ahk_id " hwnd))
    }
    hasVerifyControl := InStr(controlText, "Verify Med Order", true) ? 1 : 0
    hasRxOrderEvidence := InStr(controlText, "Rx date", true) && InStr(controlText, "Order", true) ? 1 : 0
    matched := hasVerifyControl || hasRxOrderEvidence
    Inpatient_LogWindowEvidence(matched ? "verify_match" : "verify_miss", hwnd, title,
        Map("source", hasVerifyControl ? "control_verify" : hasRxOrderEvidence ? "control_rx_order" : "none",
            "detail", "controlVerify=" hasVerifyControl "_controlRxOrder=" hasRxOrderEvidence))
    return matched
}

IsMedicationManagerWindow() {
    global AppSettingsIniPath, MedicationManagerWindowCache
    hwnd := WinGetID("A")
    if !hwnd
        return false

    title := WinGetTitle("ahk_id " hwnd)
    if MedicationManager_TitleExcluded(title)
        return false
    if RegExMatch(title, "i)PharmNet: (?:Pharmacy|Retail) Med")
        return true
    configuredTitle := ""
    try configuredTitle := Trim(IniRead(AppSettingsIniPath, "Integration", "MedicationManagerWindow", ""))
    if configuredTitle != "" && WinActive(configuredTitle)
        return true

    now := A_TickCount
    if MedicationManagerWindowCache.hwnd = hwnd
        && now - MedicationManagerWindowCache.checkedAt < 500
        return MedicationManagerWindowCache.isMedicationManager

    result := MedicationManager_ScanControls(hwnd)
    MedicationManagerWindowCache := {hwnd: hwnd, checkedAt: now, isMedicationManager: result}
    return result
}

MedicationManager_ScanControls(hwnd) {
    controlText := ""
    for control in WinGetControls("ahk_id " hwnd) {
        try controlText .= " " Trim(ControlGetText(control, "ahk_id " hwnd))
    }
    return MedicationManager_ControlTextEvidence(controlText)
}

MedicationManager_TitleExcluded(title) {
    return RegExMatch(title, "i)(?:PowerChart|Opened by|Custom Information)")
}

MedicationManager_RemoteWrapperEvidence(hwnd, title) {
    try {
        if MedicationManager_TitleExcluded(title)
            return false
        return MedicationManager_RemoteWrapperTitleEvidence(WinGetClass("ahk_id " hwnd), title)
            && MedicationManager_ScanControls(hwnd)
    }
    return false
}

MedicationManager_RemoteWrapperTitleEvidence(windowClass, title) {
    if windowClass != "Transparent Windows Client"
        return false
    return title != "" && !RegExMatch(title, "i)^(?:Home|Work|Desktop|Start)$")
}

MedicationManager_ControlTextEvidence(controlText) {
    if !InStr(controlText, "Acute Profile", true)
        && !InStr(controlText, "Ambulatory Profile", true)
        return false
    hasResults := InStr(controlText, "Results", true) > 0
    hasInterventions := InStr(controlText, "Interventions", true) > 0
    hasMedicationOrder := InStr(controlText, "Medication Orders", true) > 0
    hasMedicationList := InStr(controlText, "Medication List", true) > 0
    hasRxPriority := InStr(controlText, "Rx priority", true) > 0
    return (hasResults && (hasInterventions || hasMedicationOrder)) || hasMedicationList || hasRxPriority
}

Inpatient_HandoffSelectedPatient(*) {
    global AppSettingsIniPath
    activeHwnd := WinGetID("A")
    activeTitle := activeHwnd ? WinGetTitle("ahk_id " activeHwnd) : ""
    MouseGetPos(&mouseX, &mouseY)
    ToolTip("Reading FIN/MRN near Alt-click...")
    KeyWait("LButton", "U")
    ; The trigger uses Alt+left-click. Wait for Alt to be released before
    ; copying, otherwise Cerner can receive Ctrl+Alt+C instead of Ctrl+C.
    KeyWait("Alt", "U T2")
    previousClipboard := ClipboardAll()
    A_Clipboard := ""
    Send("^c")
    selected := ClipWait(0.8) ? Trim(A_Clipboard) : ""
    A_Clipboard := previousClipboard
    identifier := RegExMatch(selected, "\b\d{7,16}\b", &match) ? match[0] : ""
    identifierSource := identifier != "" ? "clipboard" : "none"
    if identifier = "" {
        identifier := Inpatient_HandoffIdentifierAtPoint(mouseX, mouseY)
        identifierSource := identifier != "" ? "ocr" : identifierSource
    }
    if identifier = "" {
        identifier := Inpatient_HandoffIdentifierFromPowerChartTitle()
        identifierSource := identifier != "" ? "title" : identifierSource
    }
    Inpatient_LogWindowEvidence(identifier != "" ? "handoff_identifier_found" : "handoff_identifier_missing",
        activeHwnd, activeTitle, Map("source", identifierSource, "detail", "identifierDigits=" (identifier != "" ? StrLen(identifier) : 0)))
    if identifier = "" {
        ToolTip()
        ToolTip("Patient handoff: no FIN or MRN was found near the Alt-click.")
        SetTimer(() => ToolTip(), -1800)
        return
    }

    global PCtxSession
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        ctx := PCtx_New()
        PCtxSession := ctx
    }
    PCtx_MergeCapture(ctx, {mrn: identifier}, "PowerChart handoff identifier", "PowerChart handoff")

    targetTitle := IniRead(AppSettingsIniPath, "Integration", "MedicationManagerWindow", "PharmNet: Pharmacy Med")
    lookupShortcut := IniRead(AppSettingsIniPath, "Integration", "MedicationManagerLookupShortcut", "^p")
    targetHwnd := Inpatient_FindMedicationManagerTarget(activeHwnd, targetTitle)
    if !targetHwnd {
        ToolTip()
        Inpatient_LogWindowEvidence("handoff_target_missing", activeHwnd, activeTitle, Map("source", "target_scan"))
        MsgBox("Medication Manager was not found. Open it first, then Alt+left-click the MRN or FIN in PowerChart.", "Patient Handoff", "Icon!")
        return
    }
    targetSpec := "ahk_id " targetHwnd
    WinActivate(targetSpec)
    if !WinWaitActive(targetSpec,,3) {
        ToolTip()
        Inpatient_LogWindowEvidence("handoff_target_inactive", targetHwnd, WinGetTitle(targetSpec), Map("source", "target_activate"))
        MsgBox("Medication Manager could not be activated. No patient lookup was sent.", "Patient Handoff", "Icon!")
        return
    }
    Inpatient_LogWindowEvidence("handoff_lookup_dispatch", targetHwnd, WinGetTitle(targetSpec), Map("source", "direct_fin_field"))
    Inpatient_SendMedicationManagerLookup(targetSpec, identifier, lookupShortcut)
    ToolTip("Patient handoff sent to Medication Manager.")
    SetTimer(() => ToolTip(), -1800)
}

Inpatient_SendMedicationManagerLookup(targetSpec, identifier, lookupShortcut := "^p") {
    WinGetPos(&windowX, &windowY, &windowW, &windowH, targetSpec)
    if windowW <= 0 || windowH <= 0
        throw Error("Medication Manager window coordinates were unavailable.")

    ; Medication Manager's FIN search field is in the upper-left search band.
    MouseClick("left", windowX + 110, windowY + 128)
    Sleep(150)
    Send(lookupShortcut)
    Sleep(250)
    Send("^a")
    SendText(identifier)
    Send("{Enter}")
    Sleep(500)
}

Inpatient_FindMedicationManagerTarget(activeHwnd, configuredTitle := "") {
    if configuredTitle != "" {
        configuredHwnd := WinExist(configuredTitle)
        configuredWindowTitle := configuredHwnd ? WinGetTitle("ahk_id " configuredHwnd) : ""
        if configuredHwnd && configuredHwnd != activeHwnd
            && !Inpatient_IsRetailMedicationManagerTitle(configuredWindowTitle)
            return configuredHwnd
    }

    bestHwnd := 0
    bestScore := 0
    for hwnd in WinGetList() {
        if hwnd = activeHwnd
            continue
        title := WinGetTitle("ahk_id " hwnd)
        windowClass := WinGetClass("ahk_id " hwnd)
        processName := WinGetProcessName("ahk_id " hwnd)
        if Inpatient_IsRetailMedicationManagerTitle(title)
            continue
        if Inpatient_PowerChartTitleEvidence(title, windowClass, processName)
            continue
        titleEvidence := RegExMatch(title, "i)PharmNet: Pharmacy Med") ? 1 : 0
        controlEvidence := MedicationManager_ScanControls(hwnd) ? 1 : 0
        remoteEvidence := MedicationManager_RemoteWrapperEvidence(hwnd, title) ? 1 : 0
        score := Inpatient_MedicationManagerCandidateScore(titleEvidence, controlEvidence, remoteEvidence)
        if score > bestScore {
            bestScore := score
            bestHwnd := hwnd
        }
    }
    return bestHwnd
}

Inpatient_IsRetailMedicationManagerTitle(title) {
    return RegExMatch(title, "i)PharmNet:\s*Retail\s+Medication\s+Manager")
        || RegExMatch(title, "i)PharmNet:\s*Retail\s+Med")
}

Inpatient_MedicationManagerCandidateScore(titleEvidence, controlEvidence, remoteEvidence) {
    if titleEvidence
        return 100
    if controlEvidence
        return 80
    if remoteEvidence
        return 20
    return 0
}

Inpatient_HandoffIdentifierFromPowerChartTitle(title := "") {
    if title = ""
        title := WinGetTitle("A")
    if RegExMatch(title, "i)\b(?:FIN|MRN)\s*[:#=-]?\s*([1-9]\d{6,15})\b", &match)
        return match[1]
    if RegExMatch(title, "i)\s-\s([1-9]\d{6,15})\s+Opened\s+by\b", &match)
        return match[1]
    return ""
}

Inpatient_HandoffIdentifierAtPoint(mouseX, mouseY) {
    left := Max(0, mouseX - 320)
    top := Max(0, mouseY - 55)
    width := Min(640, A_ScreenWidth - left)
    height := Min(110, A_ScreenHeight - top)
    if width < 120 || height < 30
        return ""

    try {
        capture := PatientV2_CaptureAndParse(left, top, width, height)
        if IsObject(capture) && IsObject(capture.parsed) {
            parsed := PatientV2_NormalizeParsedShape(capture.parsed)
            for key in ["fin", "mrn"] {
                if parsed.HasOwnProp(key) && RegExMatch(String(parsed.%key%), "\b\d{7,16}\b", &match)
                    return match[0]
            }
        }
        text := IsObject(capture) && capture.HasOwnProp("text") ? String(capture.text) : ""
        if RegExMatch(text, "i)\b(?:FIN|MRN)\s*[:#=-]?\s*(\d{7,16})\b", &match)
            return match[1]
        if RegExMatch(text, "\b\d{7,16}\b", &match)
            return match[0]
    }
    return ""
}

Inpatient_CaptureMedicationManagerHeader(interactive := true, *) {
    global PCtxSession
    MouseGetPos(&mouseX, &mouseY)
    WinGetPos(&windowX, &windowY, &windowW, &windowH, "A")
    if interactive && mouseY > windowY + 145 {
        ToolTip("Patient header capture: Alt+click the top blue patient banner in Medication Manager.")
        SetTimer(() => ToolTip(), -1800)
        return
    }
    if interactive {
        KeyWait("LButton", "U")
        KeyWait("Alt", "U T2")
    }
    ToolTip("Reading Medication Manager patient header...")
    try {
        capture := PatientV2_CaptureAndParse(windowX, windowY, windowW, Min(windowH, 145))
        if !IsObject(capture) || !IsObject(capture.parsed)
            throw Error("The header could not be read.")
        parsed := PatientV2_NormalizeParsedShape(capture.parsed)
        identifierBand := Inpatient_CaptureMedicationManagerIdentifierBand(
            windowX,
            windowY,
            windowW,
            Min(windowH, 145)
        )
        if IsObject(identifierBand) {
            identifierParsed := PatientV2_NormalizeParsedShape(Vanco_ParseDemographics(identifierBand))
            parsedMrn := parsed.HasOwnProp("mrn") ? Trim(String(parsed.mrn)) : ""
            parsedFin := parsed.HasOwnProp("fin") ? Trim(String(parsed.fin)) : ""
            identifierMrn := identifierParsed.HasOwnProp("mrn") ? Trim(String(identifierParsed.mrn)) : ""
            identifierFin := identifierParsed.HasOwnProp("fin") ? Trim(String(identifierParsed.fin)) : ""
            if parsedMrn = "" && identifierMrn != ""
                parsed.mrn := identifierMrn
            if parsedFin = "" && identifierFin != ""
                parsed.fin := identifierFin
        }
        parsedMrn := parsed.HasOwnProp("mrn") ? Trim(String(parsed.mrn)) : ""
        parsedFin := parsed.HasOwnProp("fin") ? Trim(String(parsed.fin)) : ""
        if parsedMrn = "" && parsedFin = "" {
            ToolTip()
            MsgBox("No MRN or FIN was recognized. Alt+click directly in the top blue patient banner and try again.", "Patient Header Capture", "Icon!")
            return
        }
        ctx := PCtx_Active()
        if !IsObject(ctx) {
            ctx := PCtx_New()
            PCtxSession := ctx
        }
        PCtx_MergeCapture(ctx, parsed, capture.text, "Patient Profile")
        ToolTip("Medication Manager header captured into the active in-memory patient session.")
        SetTimer(() => ToolTip(), -2200)
    } catch as e {
        ToolTip()
        MsgBox("Could not capture the Medication Manager header.`r`n`r`n" e.Message, "Patient Header Capture", "Icon!")
    }
}

Inpatient_CaptureMedicationManagerIdentifierBand(left, top, width, height) {
    bandTop := top + Min(48, Max(0, height - 60))
    bandHeight := Min(58, height - (bandTop - top))
    if width < 400 || bandHeight < 24
        return 0
    return PatientV2_MergeOcrResults([
        PatientV2_TryOcrRect(left, bandTop, width, bandHeight, 4.0),
        PatientV2_TryOcrRect(left, bandTop, width, bandHeight, 4.4, true),
        PatientV2_TryOcrRect(left, bandTop, width, bandHeight, 4.4, true, 112, true)
    ])
}

InpatientSql_QuerySelect(query, timeoutSeconds := 120) {
    query := Trim(String(query))
    if !RegExMatch(query, "i)^\s*(?:select|with)\b")
        || InStr(query, ";")
        throw ValueError("Only one read-only SELECT or CTE query is allowed.")
    timeoutSeconds := Max(1, Min(180, Integer(timeoutSeconds)))
    connection := ComObject("ADODB.Connection")
    connection.ConnectionTimeout := 15
    connection.CursorLocation := 3
    connection.CommandTimeout := timeoutSeconds
    try {
        connection.Open("Provider=MSDASQL;DRIVER={ODBC Driver 18 for SQL Server};SERVER=vhacdwdwhsql33.vha.med.va.gov;DATABASE=LSV;Trusted_Connection=Yes;TrustServerCertificate=Yes;")
        recordset := connection.Execute(query)
        return recordset.EOF || recordset.BOF ? "" : recordset.GetString(1, -1, "`t", "`r`n", "")
    } finally {
        try connection.Close()
    }
}

InpatientSql_SnapshotRecord(key, identifier, data, elapsedMs, source := "LSV") {
    return {
        key: key,
        identifierDigits: StrLen(String(identifier)),
        retrievedAt: FormatTime(, "MM/dd/yyyy HH:mm:ss"),
        elapsedMs: elapsedMs,
        source: source,
        rowCount: InpatientSql_RowCount(data),
        data: data,
        stale: false,
        error: ""
    }
}

InpatientSql_RowCount(data) {
    text := Trim(String(data))
    if text = ""
        return 0
    count := 0
    for line in StrSplit(text, "`n", "`r") {
        if Trim(line) != ""
            count += 1
    }
    return count
}

InpatientSql_TemplateSlots() {
    return [
        {key: "admission_medrec", label: "Admission medication comparison", purpose: "Side-by-side outpatient and inpatient medication review"},
        {key: "outpatient_active_meds", label: "Active outpatient medications", purpose: "Current outpatient medication profile for admission reconciliation"},
        {key: "inpatient_active_orders", label: "Active inpatient medication orders", purpose: "Current acute orders; not a medication administration record"},
        {key: "inpatient_order_context", label: "Inpatient order context", purpose: "Encounter, indication, location, status, and timing context for acute orders"},
        {key: "fill_history", label: "Medication fill history", purpose: "Dispense history and refill context"},
        {key: "item_attributes", label: "Formulary and item attributes", purpose: "Formulary, product, and dispensing attributes"},
        {key: "lab_trends", label: "Relevant laboratory trends", purpose: "Time-ordered laboratory results for the active patient"},
        {key: "lab_trends_detail", label: "Detailed laboratory context", purpose: "Critical ranges, service, encounter, and collection/verification timestamps"},
        {key: "encounter_fin_context", label: "Encounter / FIN context", purpose: "Patient-scoped FIN and appointment context; not an order-specific encounter join"},
        {key: "referral_coverage", label: "Referral and coverage context", purpose: "Coverage or referral data needed for the review"}
    ]
}

InpatientSql_TemplateQuery(key) {
    global AppSettingsIniPath
    try {
        configured := Trim(IniRead(AppSettingsIniPath, "ReviewedSqlTemplates", key, ""))
        if configured != ""
            return configured
    }
    if key = "outpatient_active_meds"
        return "SELECT TOP (100) rx.ItemDescription AS Medication, rx.OrderStatus, rx.DepartmentalStatus, rx.Sig, rx.Instructions, rx.DaysSupply, rx.TotalRxQuantity, rx.QuantityRemaining, rx.RefillsRemaining, rx.AmbProfileLastFillDateTime AS LastFillDateTime, rx.CurrentStartDateTime, rx.ProjectedStopDateTime, rx.ExpireDateTime, CASE WHEN NULLIF(openRx.TransmittedCMOPID, '') IS NOT NULL AND openRx.CMOPTransmitStage = 1 AND openRx.CMOPReceived = 1 THEN 'CMOP transmitted - received' WHEN NULLIF(openRx.TransmittedCMOPID, '') IS NOT NULL AND openRx.CMOPTransmitStage = 1 THEN 'CMOP transmitted - receipt pending' WHEN NULLIF(openRx.LocalDispenseStep, '') IS NOT NULL THEN 'Local processing' ELSE 'Route pending / unavailable' END AS RouteState, openRx.DispensePriority, openRx.FillDevice, openRx.FillAnchorDateTime AS RouteEventTime, rx.ModifiedDateTime AS PrescriptionModifiedTime FROM D05_VISN20.Cerner_Patient AS patient INNER JOIN D05_VISN20.Cerner_Rx_Prescription AS rx ON rx.PersonSID = patient.PersonSID OUTER APPLY (SELECT TOP (1) o.TransmittedCMOPID, o.CMOPTransmitStage, o.CMOPReceived, o.LocalDispenseStep, o.DispensePriority, o.FillDevice, o.FillAnchorDateTime FROM D05_VISN20.Cerner_Rx_Open_Dispenses AS o WHERE o.RxNumber = rx.RxNumber ORDER BY o.FillAnchorDateTime DESC, o.DispenseHistorySID DESC) AS openRx WHERE patient.MRN = '{{patient_id}}' AND rx.OrderStatus = 'Ordered' AND rx.DepartmentalStatus = 'On File' ORDER BY rx.ItemDescription"
    if key = "inpatient_active_orders"
        return "SELECT TOP (100) parent.ClinicalDisplayLine AS MedicationOrder, parent.OrderCatalog, parent.OrderMnemonic, parent.OrderStatus, parent.DepartmentalStatus, parent.Routing, parent.OrderedQty, parent.Duration, parent.Indication, parent.OrderLocation, parent.RoutingPharmacyName, parent.OrderDateTime, parent.CurrentStartDateTime, parent.ProjectedStopDateTime, parent.ModifiedDateTime AS OrderModifiedTime, detail.RXFILLDEVICESR AS FillDevice, detail.RXAROUTINGOPTION AS RoutingOption, detail.DAYSSUPPLY AS DaysSupply, detail.RXDISPENSEQTY AS DispenseQuantity, detail.SIG, detail.SCRIPTORIGIN AS ScriptOrigin, detail.DAW FROM D05_VISN20.Cerner_Patient AS patient INNER JOIN D05_VISN20.Cerner_Rx_Parent_Order AS parent ON parent.PersonSID = patient.PersonSID OUTER APPLY (SELECT TOP (1) d.RXFILLDEVICESR, d.RXAROUTINGOPTION, d.DAYSSUPPLY, d.RXDISPENSEQTY, d.SIG, d.SCRIPTORIGIN, d.DAW FROM D05_VISN20.Cerner_Rx_Prescription_Order_Detail AS d WHERE d.PersonOrderSID = parent.PersonOrderSID ORDER BY d.ActionSequence DESC, d.ModifiedDateTime DESC) AS detail WHERE patient.MRN = '{{patient_id}}' AND (parent.OrderStatus IS NULL OR parent.OrderStatus NOT IN ('Discontinued', 'Canceled', 'Cancelled', 'Voided', 'Deleted', 'Completed', 'Expired')) ORDER BY parent.CurrentStartDateTime DESC, parent.OrderDateTime DESC"
    if key = "inpatient_order_context"
        return "SELECT TOP (200) parent.PersonOrderSID, parent.PersonSID, parent.EncounterSID, parent.ClinicalDisplayLine AS MedicationOrder, parent.OrderCatalog, parent.OrderMnemonic, parent.Indication, parent.OrderLocation, parent.ClinicLocation, parent.RoutingPharmacyName, parent.OrderStatus, parent.DepartmentalStatus, parent.StatusDateTime, parent.CurrentStartDateTime, parent.ProjectedStopDateTime, parent.ModifiedDateTime, detail.SIG, detail.DAYSSUPPLY, detail.RXDISPENSEQTY, detail.RXFILLDEVICESR, detail.RXAROUTINGOPTION, detail.DAW FROM D05_VISN20.Cerner_Patient AS patient INNER JOIN D05_VISN20.Cerner_Rx_Parent_Order AS parent ON parent.PersonSID = patient.PersonSID OUTER APPLY (SELECT TOP (1) d.SIG, d.DAYSSUPPLY, d.RXDISPENSEQTY, d.RXFILLDEVICESR, d.RXAROUTINGOPTION, d.DAW FROM D05_VISN20.Cerner_Rx_Prescription_Order_Detail AS d WHERE d.PersonOrderSID = parent.PersonOrderSID ORDER BY d.ActionSequence DESC, d.ModifiedDateTime DESC) AS detail WHERE patient.MRN = '{{patient_id}}' AND (parent.OrderStatus IS NULL OR parent.OrderStatus NOT IN ('Discontinued', 'Canceled', 'Cancelled', 'Voided', 'Deleted', 'Completed', 'Expired')) ORDER BY parent.CurrentStartDateTime DESC, parent.ModifiedDateTime DESC"
    if key = "admission_medrec"
        return "WITH patient AS (SELECT PersonSID FROM D05_VISN20.Cerner_Patient WHERE MRN = '{{patient_id}}'), outpatient AS (SELECT TOP (100) 'outpatient' AS Profile, CONCAT(rx.ItemDescription, ' ', COALESCE(rx.Sig, ''), ' ', COALESCE(rx.Instructions, '')) AS MedicationText FROM D05_VISN20.Cerner_Rx_Prescription AS rx INNER JOIN patient ON patient.PersonSID = rx.PersonSID WHERE rx.OrderStatus = 'Ordered' AND rx.DepartmentalStatus = 'On File' ORDER BY rx.ItemDescription), inpatient AS (SELECT TOP (100) 'inpatient' AS Profile, CONCAT(parent.ClinicalDisplayLine, ' ', COALESCE(detail.SIG, '')) AS MedicationText FROM D05_VISN20.Cerner_Rx_Parent_Order AS parent INNER JOIN patient ON patient.PersonSID = parent.PersonSID OUTER APPLY (SELECT TOP (1) d.SIG FROM D05_VISN20.Cerner_Rx_Prescription_Order_Detail AS d WHERE d.PersonOrderSID = parent.PersonOrderSID ORDER BY d.ActionSequence DESC, d.ModifiedDateTime DESC) AS detail WHERE parent.OrderStatus IS NULL OR parent.OrderStatus NOT IN ('Discontinued', 'Canceled', 'Cancelled', 'Voided', 'Deleted', 'Completed', 'Expired') ORDER BY parent.CurrentStartDateTime DESC, parent.OrderDateTime DESC) SELECT Profile, MedicationText FROM outpatient UNION ALL SELECT Profile, MedicationText FROM inpatient"
    if key = "lab_trends"
        return "SELECT TOP (200) labs.Display AS Lab, labs.ResultValue, labs.UnitsDisplay, labs.Normalcy, labs.CollectedDateTime, labs.PerformedDateTime, labs.VerifiedDateTime, labs.DepartmentalStatus, labs.EncounterSID FROM D05_VISN20.Cerner_MostRecentLabs_1Y AS labs INNER JOIN D05_VISN20.Cerner_Patient AS patient ON patient.PersonSID = labs.PersonSID WHERE patient.MRN = '{{patient_id}}' AND (labs.DepartmentalStatus IS NULL OR labs.DepartmentalStatus NOT IN ('Canceled', 'Cancelled', 'Deleted', 'Voided')) ORDER BY labs.CollectedDateTime DESC, labs.Display"
    if key = "lab_trends_detail"
        return "SELECT TOP (500) labs.Display AS Lab, labs.ResultValue, labs.UnitsDisplay, labs.Normalcy, labs.CriticalLow, labs.CriticalHigh, labs.ServiceResource, labs.EncounterSID, labs.CollectedDateTime, labs.PerformedDateTime, labs.VerifiedDateTime, labs.DepartmentalStatus FROM D05_VISN20.Cerner_MostRecentLabs_1Y AS labs INNER JOIN D05_VISN20.Cerner_Patient AS patient ON patient.PersonSID = labs.PersonSID WHERE patient.MRN = '{{patient_id}}' AND (labs.DepartmentalStatus IS NULL OR labs.DepartmentalStatus NOT IN ('Canceled', 'Cancelled', 'Deleted', 'Voided')) ORDER BY labs.CollectedDateTime DESC, labs.Display"
    if key = "encounter_fin_context"
        return "SELECT TOP (50) appt.FIN, appt.MRN, appt.BeginUTCDateTime, appt.AdjBeginDateTime, appt.AppointmentType, appt.AppointmentReason, appt.AppointmentLocation, appt.ScheduleState, appt.PersonSID, appt.RefreshDate FROM D05_VISN20.SPO_CPP_Appt_Hx AS appt WHERE appt.MRN = '{{patient_id}}' ORDER BY appt.BeginUTCDateTime DESC, appt.RefreshDate DESC"
    return ""
}

InpatientSql_SelectedIdentifier(ctx) {
    if ctx.ident.Has("mrn") && Trim(ctx.ident["mrn"]) != ""
        return Trim(ctx.ident["mrn"])
    if ctx.ident.Has("fin") && Trim(ctx.ident["fin"]) != ""
        return Trim(ctx.ident["fin"])
    return ""
}

InpatientSql_ExpandPatientTemplate(query, identifier) {
    if identifier = ""
        throw ValueError("Capture an MRN or FIN before running a patient lookup.")
    if !InStr(query, "{{patient_id}}")
        throw ValueError("The reviewed template must contain {{patient_id}}.")
    if !RegExMatch(identifier, "^[A-Za-z0-9-]{4,20}$")
        throw ValueError("The captured patient identifier has an unsupported format.")
    escaped := StrReplace(identifier, "'", "''")
    expanded := StrReplace(query, "{{patient_id}}", escaped)
    expanded := RegExReplace(expanded, "i)\b(\w+\.)?MRN\s*=\s*'([^']+)'", "EXISTS (SELECT 1 FROM STRING_SPLIT($1MRN, CHAR(59)) AS patientMrn WHERE LTRIM(RTRIM(patientMrn.value)) = '$2')")
    return expanded
}

InpatientSql_CaptureSelectedRow(timeoutSeconds := 1) {
    previousClipboard := ClipboardAll()
    try {
        A_Clipboard := ""
        Send("^c")
        if !ClipWait(timeoutSeconds)
            return ""
        return A_Clipboard
    } finally {
        A_Clipboard := previousClipboard
    }
}

Hub_OpenBackgroundLookups(ctx := 0, parsed := 0, label := "", selectedKey := "") {
    if !IsObject(ctx)
        ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("Capture a patient screen with an MRN or FIN before opening background lookups.", "Background Patient Lookups", "Iconi")
        return
    }
    identifier := InpatientSql_SelectedIdentifier(ctx)
    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Background Patient Lookups")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w980", "Read-only background patient lookups"))
    Theme_Subtle(g.Add("Text", "xm y+3 w980", "Results remain only in this in-memory patient session. Reviewed patient-scoped SQL runs after confirmation."))
    status := g.Add("Text", "xm y+10 w980", identifier = "" ? "No captured MRN or FIN available." : "Captured identifier available for this session only.")
    slots := g.Add("ListView", "xm y+8 w980 h145 Grid -Multi", ["Lookup", "Purpose", "Local template", "Status"])
    selectedRow := 0
    for index, template in InpatientSql_TemplateSlots() {
        query := InpatientSql_TemplateQuery(template.key)
        state := query = "" ? "Not configured" : (InStr(query, "{{patient_id}}") ? "Ready for review" : "Missing {{patient_id}}")
        slots.Add("", template.label, template.purpose, query = "" ? "No" : "Yes", state)
        if template.key = selectedKey
            selectedRow := index
    }
    slots.ModifyCol(1, 220), slots.ModifyCol(2, 400), slots.ModifyCol(3, 120), slots.ModifyCol(4, 220)
    if selectedRow
        slots.Modify(selectedRow, "Select Focus")
    result := g.Add("Edit", "xm y+10 w980 h245 ReadOnly VScroll -Wrap", "Select a configured lookup, then choose Run Selected. Query output is not written to logs, diagnostics, files, or source control.")
    Theme_OutputFont(result)
    g.Add("Button", "xm y+10 w150 h32", "Run Selected").OnEvent("Click", (*) => Hub_RunBackgroundLookup(ctx, slots, result, status))
    g.Add("Button", "x+8 yp w180 h32", "Capture Selected Row").OnEvent("Click", (*) => Hub_CaptureLookupRow(result))
    g.Add("Button", "x+8 yp w130 h32", "Copy Result").OnEvent("Click", (*) => (A_Clipboard := result.Value))
    g.Add("Button", "x+8 yp w170 h32", "Open Local Settings").OnEvent("Click", (*) => Run('notepad.exe "' AppSettingsIniPath '"'))
    g.Add("Button", "x+8 yp w100 h32", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w1020 h520")
    if selectedRow && selectedKey != ""
        SetTimer(() => Hub_RunBackgroundLookup(ctx, slots, result, status), -50)
}

Hub_RunBackgroundLookup(ctx, slots, result, status) {
    row := slots.GetNext(0, "Focused")
    if !row {
        MsgBox("Select a lookup first.", "Background Patient Lookups", "Iconi")
        return
    }
    template := InpatientSql_TemplateSlots()[row]
    query := InpatientSql_TemplateQuery(template.key)
    if query = "" {
        MsgBox("This lookup has no local reviewed template. Add one under [ReviewedSqlTemplates] in local settings before use.", "Background Patient Lookups", "Iconi")
        return
    }
    try {
        identifier := InpatientSql_SelectedIdentifier(ctx)
        expanded := InpatientSql_ExpandPatientTemplate(query, identifier)
        if MsgBox("Run the reviewed, read-only lookup for " template.label "? Results remain in memory only.", "Confirm Background Lookup", "YesNo Icon? Default2") != "Yes"
            return
        started := A_TickCount
        status.Value := "Waiting for the reviewed LSV query to complete..."
        data := InpatientSql_QuerySelect(expanded, 120)
        if template.key = "admission_medrec" {
            if !InStr(data, "outpatient`t")
                data .= InpatientSql_ProfileRows("outpatient_active_meds", identifier, "outpatient")
            if !InStr(data, "inpatient`t")
                data .= InpatientSql_ProfileRows("inpatient_active_orders", identifier, "inpatient")
        }
        sourceLabel := "LSV background source"
        if data = "" && (template.key = "inpatient_active_orders" || template.key = "admission_medrec") {
            directProbe := InpatientSql_DirectPrescriptionProbe(template.key)
            directProbeExpanded := InpatientSql_ExpandPatientTemplate(directProbe, identifier)
            data := InpatientSql_QuerySelect(directProbeExpanded, 120)
            sourceLabel := data = ""
                ? "Direct MRN lookup returned no rows from the reviewed LSV sources"
                : "Direct MRN lookup from LSV prescription source (acute status requires verification)"
        }
        elapsed := A_TickCount - started
        snapshot := InpatientSql_SnapshotRecord(template.key, identifier, data, elapsed, sourceLabel)
        snapshot.label := template.label
        ctx.backgroundLookups.Push(snapshot)
        if template.key = "admission_medrec" {
            Hub_ShowBackgroundMedicationComparison(ctx, data, elapsed)
            status.Text := "Completed admission medication comparison in " elapsed " ms. Result retained in memory only."
            return
        }
        if template.key = "inpatient_active_orders" {
            Hub_ShowBackgroundInpatientOrders(data, elapsed, sourceLabel)
            status.Text := "Completed active inpatient medication orders in " elapsed " ms. Result retained in memory only."
            return
        }
        result.Value := template.label "`r`nRetrieved: " FormatTime(, "MM/dd/yyyy HH:mm:ss") " · " elapsed " ms`r`n======================================================================`r`n" (data != "" ? data : "No rows returned.")
        status.Text := "Completed " template.label " in " elapsed " ms. Result retained in memory only."
    } catch as e {
        result.Value := "Lookup was not run.`r`n" e.Message
        status.Text := "Lookup did not complete. Review the configured template and connection."
    }
}

InpatientSql_AcutePrescriptionFallback(key) {
    if key = "inpatient_active_orders"
        return "SELECT TOP (100) COALESCE(NULLIF(parent.OrderMnemonic, ''), NULLIF(parent.OrderCatalog, ''), parent.ClinicalDisplayLine) AS DrugName, parent.ClinicalDisplayLine AS MedicationOrder, parent.OrderCatalog, parent.OrderMnemonic, parent.OrderStatus, parent.DepartmentalStatus, parent.OrderLocation, parent.OrderDateTime, parent.CurrentStartDateTime, parent.ProjectedStopDateTime FROM D05_VISN20.Cerner_Rx_Parent_Order AS parent WHERE parent.PersonSID IN (SELECT patient.PersonSID FROM D05_VISN20.Cerner_Patient AS patient WHERE patient.MRN = '{{patient_id}}') AND (parent.OrderStatus IS NULL OR parent.OrderStatus NOT IN ('Discontinued', 'Canceled', 'Cancelled', 'Voided', 'Deleted', 'Completed', 'Expired')) ORDER BY parent.CurrentStartDateTime DESC, parent.OrderDateTime DESC"
    if key = "admission_medrec"
        return "SELECT TOP (100) 'inpatient' AS Profile, CONCAT(COALESCE(NULLIF(parent.OrderMnemonic, ''), NULLIF(parent.OrderCatalog, ''), ''), ' ', COALESCE(parent.ClinicalDisplayLine, '')) AS MedicationText FROM D05_VISN20.Cerner_Rx_Parent_Order AS parent WHERE parent.PersonSID IN (SELECT patient.PersonSID FROM D05_VISN20.Cerner_Patient AS patient WHERE patient.MRN = '{{patient_id}}') AND (parent.OrderStatus IS NULL OR parent.OrderStatus NOT IN ('Discontinued', 'Canceled', 'Cancelled', 'Voided', 'Deleted', 'Completed', 'Expired')) ORDER BY parent.CurrentStartDateTime DESC, parent.OrderDateTime DESC"
    return ""
}

InpatientSql_DirectPrescriptionProbe(key) {
    if key = "inpatient_active_orders"
        return InpatientSql_AcutePrescriptionFallback(key)
    if key = "admission_medrec"
        return "SELECT TOP (100) 'inpatient-candidate' AS Profile, CONCAT(rx.ItemDescription, ' ', COALESCE(rx.Sig, ''), ' ', COALESCE(rx.Instructions, '')) AS MedicationText FROM D05_VISN20.Cerner_Rx_Prescription AS rx WHERE rx.PersonSID IN (SELECT patient.PersonSID FROM D05_VISN20.Cerner_Patient AS patient WHERE patient.MRN = '{{patient_id}}') AND (rx.OrderStatus IS NULL OR rx.OrderStatus NOT IN ('Discontinued', 'Canceled', 'Cancelled', 'Voided', 'Deleted', 'Completed', 'Expired')) ORDER BY rx.CurrentStartDateTime DESC, rx.OrderDateTime DESC"
    return ""
}

InpatientSql_ProfileRows(key, identifier, profile) {
    query := InpatientSql_TemplateQuery(key)
    if query = ""
        return ""
    expanded := InpatientSql_ExpandPatientTemplate(query, identifier)
    data := InpatientSql_QuerySelect(expanded, 120)
    out := ""
    for line in StrSplit(data, "`n", "`r") {
        if Trim(line) != ""
            out .= profile "`t" line "`r`n"
    }
    return out
}

InpatientSql_CapturedProfileData(ctx, profile := "acute") {
    if !IsObject(ctx)
        return ""
    out := ""
    profiles := profile = "both" ? ["ambulatory", "acute"] : [profile]
    for selectedProfile in profiles {
        for med in PCtx_ProfileMeds(ctx, selectedProfile) {
            raw := Trim(MedRec_Value(med, "raw"))
            if raw != ""
                out .= selectedProfile "`t" raw "`r`n"
        }
    }
    return out
}

Hub_ShowBackgroundInpatientOrders(data, elapsedMs, sourceLabel := "LSV background source") {
    rows := []
    for line in StrSplit(data, "`n", "`r") {
        fields := StrSplit(line, "`t")
        if fields.Length < 1 || Trim(fields[1]) = ""
            continue
        rawOrder := fields.Length >= 2 ? Trim(fields[2]) : Trim(fields[1])
        parsed := RxN_Normalize(rawOrder)
        medicationName := fields.Length >= 5 && Trim(fields[1]) != "" ? Trim(fields[1]) : parsed.name
        status := fields.Length >= 5 ? Trim(fields[5]) : (parsed.status != "" ? parsed.status : "Captured")
        strength := parsed.dose != "" ? parsed.dose : parsed.conc
        sig := rawOrder
        if parsed.name != ""
            sig := Trim(StrReplace(sig, parsed.name, "", false))
        rows.Push({fields: fields, raw: rawOrder, drugName: medicationName, status: status, strength: strength, sig: sig})
    }

    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Active Inpatient Medication Orders")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w1180", "Active inpatient medication orders"))
    Theme_Subtle(g.Add("Text", "xm y+3 w1180", sourceLabel ". Retrieved in " elapsedMs " ms. This is an order source, not a medication administration record."))
    list := g.Add("ListView", "xm y+10 w1180 h385 Grid -Multi", ["Order status", "Medication name", "Strength", "SIG", "Departmental status", "Order source", "Location", "Order date", "Start", "Stop"])
    for order in rows {
        fields := order.fields
        list.Add("", order.status, order.drugName, order.strength, order.sig, fields.Length >= 6 ? fields[6] : "", fields.Length >= 7 ? fields[7] : "", fields.Length >= 8 ? fields[8] : "", fields.Length >= 9 ? fields[9] : "", fields.Length >= 10 ? fields[10] : "")
    }
    list.ModifyCol(1, 110), list.ModifyCol(2, 190), list.ModifyCol(3, 100), list.ModifyCol(4, 350), list.ModifyCol(5, 130), list.ModifyCol(6, 140), list.ModifyCol(7, 130), list.ModifyCol(8, 120), list.ModifyCol(9, 120), list.ModifyCol(10, 120)
    details := g.Add("Edit", "xm y+10 w1180 h105 ReadOnly VScroll -Wrap", rows.Length = 0 ? "NO INPATIENT SOURCE ROWS RETURNED" : "Select a row to inspect the complete returned source record.")
    Theme_OutputFont(details)
    list.OnEvent("ItemSelect", (*) => Hub_BackgroundOrderSelected(rows, list, details))
    g.Add("Button", "xm y+10 w145 h32", "Copy Orders").OnEvent("Click", (*) => (A_Clipboard := data))
    g.Add("Button", "x+8 yp w100 h32", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w1220 h590")
}

Hub_BackgroundOrderSelected(rows, list, details) {
    row := list.GetNext(0, "Focused")
    if !row || row > rows.Length
        return
    raw := ""
    for index, field in rows[row]
        raw .= (index = 1 ? "" : "`t") field
    details.Value := "RAW INPATIENT ORDER SOURCE`r`n`r`n" raw
}



Hub_BackgroundComparisonSelected(rows, list, details) {
    row := list.GetNext(0, "Focused")
    if !row || row > rows.Length
        return
    pair := rows[row]
    details.Value := "OUTPATIENT SOURCE`r`n" MedRec_EvidenceText(pair.home) "`r`n`r`nINPATIENT SOURCE`r`n" MedRec_EvidenceText(pair.acute) "`r`n`r`nREVIEW`r`n" pair.finding
}

Hub_BackgroundComparisonText(rows) {
    out := "BACKGROUND ADMISSION MEDICATION COMPARISON`r`n"
        . "Retrieved from read-only LSV context. Verify against the live chart before use.`r`n"
        . "======================================================================`r`n"
    for pair in rows
        out .= "Outpatient: " MedRec_Display(pair.home) "`r`nInpatient: " MedRec_Display(pair.acute) "`r`nReview: " pair.finding "`r`n`r`n"
    return out
}

Hub_CaptureLookupRow(result) {
    captured := InpatientSql_CaptureSelectedRow()
    if captured = "" {
        ToolTip("No selected row could be copied. The clipboard was restored.")
        SetTimer(() => ToolTip(), -1800)
        return
    }
    result.Value .= "`r`n`r`nSELECTED ROW (clipboard restored)`r`n----------------------------------------------------------------------`r`n" captured
}

Hub_OpenOutpatientMedicationLookup(ctx) {
    Hub_OpenBackgroundLookups(ctx, 0, "", "outpatient_active_meds")
}
^F1::SafeRun(OpenWorkflowToolByKey, "fehr_ticket")
F2::SafeRun(OpenWorkflowToolByKey, "new_patient_search")
F6::SafeRun(OpenWorkflowToolByKey, "new_bve")
F12::SafeRun(OpenWorkflowToolByKey, "location")

; Backtick/tilde + P
; The physical backtick key must be held when P is pressed.
#HotIf GetKeyState("SC029", "P")
*p::SafeRun(OpenWorkflowToolByKey, "mcds_override")
#HotIf

; Ctrl+Alt+E — Emergency / Code Algorithms (one keypress away during a code)
^!e::SafeRun(Calc_OpenEmergency)

:*?:``MID::
{
    SafeRun(OpenWorkflowToolByKey, "midnight_datetime")
}

:*?:``N::
{
    SafeRun(OpenWorkflowToolByKey, "now_datetime")
}



^Space::     SafeRun(Menu_OpenPatientContext)
~Esc::       RC2_CloseActivePhuckitWindow()   ; Close active PhUCKIT calculator/window

MButton:: {                    ; single middle-click = menu; double = screen capture
    global _middleClickPending
    if _middleClickPending {
        _middleClickPending := false
        SetTimer(QuickLauncher_ShowPendingMenu, 0)
        SafeRun(BMI_FromRegion)
        return
    }
    _middleClickPending := true
    SetTimer(QuickLauncher_ShowPendingMenu, -300)
}
^!q::       ShowQuickMenu()   ; Ctrl+Alt+Q
^!MButton:: ShowQuickMenu()   ; Ctrl+Alt+middle-click

QuickLauncher_ShowPendingMenu() {
    global _middleClickPending
    if !_middleClickPending
        return
    _middleClickPending := false
    ShowQuickMenu()
}

QuickLauncher_OnMouseWheel(wParam, lParam, msg, hwnd) {
    global _quickMenuActive
    if !_quickMenuActive
        return
    try {
        if WinGetClass(hwnd) != "#32768"
            return
    } catch {
        return
    }
    delta := (wParam >> 16) & 0xFFFF
    if delta > 0x7FFF
        delta -= 0x10000
    if delta = 0
        return 0
    steps := Max(1, Floor(Abs(delta) / 120)) * 3
    if delta < 0
        SendInput("{Down " steps "}")
    else
        SendInput("{Up " steps "}")
    return 0
}

ShowQuickMenu() {
    global _quickMenuOwnerHwnd, _quickMenuActive
    try _quickMenuOwnerHwnd := WinGetID("A")
    catch
        _quickMenuOwnerHwnd := 0
    MouseGetPos(&mx, &my)
    quickMenu := Menu()
    QuickLauncher_BuildFlatMenu(quickMenu)
    _quickMenuActive := true
    try
        quickMenu.Show(mx, my)
    finally
        _quickMenuActive := false
}

QuickLauncher_BuildFlatMenu(menuObj) {
    usedLabels := Map()
    menuObj.Add("Patient workspace / Med Rec   Ctrl+Space", (*) => Menu_OpenPatientContext())
    menuObj.Add()

    model := QuickLauncher_BuildMainModel()
    QuickLauncher_AddNativeSections(menuObj, model.sections, usedLabels)

    allMenu := Menu()
    allUsedLabels := Map()
    QuickLauncher_AddNativeSections(allMenu, QuickLauncher_BuildRemainderSections(model.exclude), allUsedLabels)
    menuObj.Add()
    menuObj.Add("All Tools && Links", allMenu)
    menuObj.Add()
    settingsMenu := Menu()
    settingsMenu.Add("Customize Favorites && Links…", (*) => SafeRun(OpenManageLinksGui))
    settingsMenu.Add("Run DailyMed Renal Inquiry", (*) => SafeRun(RunDailyMedEvidenceInquiry))
    settingsMenu.Add("Review DailyMed Evidence", (*) => SafeRun(RenalEvidence_ReviewGui))
    settingsMenu.Add("Open DailyMed Evidence", (*) => SafeRun(OpenDailyMedEvidenceSummary))
    menuObj.Add("Settings && Database Management", settingsMenu)
}

QuickLauncher_BuildMainModel() {
    sections := []
    exclude := Map()

    favorites := RC2_FavoriteEntries()
    for entry in favorites
        exclude[entry.id] := true
    primary := LoadPrimaryLinks()
    mainIds := Map()
    for item in primary
        if item.visible
            mainIds["link:primary:" item.key] := true
    quickLinks := []
    for entry in RC2_LinkRegistry(primary, [], []) {
        if !mainIds.Has(entry.id)
            continue
        exclude[entry.id] := true
        if !QuickLauncher_IdIsExcluded(entry.id, favorites)
            quickLinks.Push(entry)
    }
    ; Favorites and links are one user-facing middle-click menu. Favorites stay
    ; first, followed by configured links that are not already favorited.
    for entry in quickLinks
        favorites.Push(entry)
    QuickLauncher_AddSection(sections, "Favorites & Links", favorites)
    for section in QuickLauncher_CustomMenuSections() {
        QuickLauncher_AddSection(sections, section.title, section.entries)
    }
    return { sections: sections, exclude: exclude }
}

QuickLauncher_CustomMenuSections() {
    rows := LoadCustomMenuRows()
    sections := []
    for menu in rows {
        if menu.type != "menu" || !menu.visible || Trim(menu.category) = ""
            continue
        entries := []
        for item in rows {
            if item.type != "item" || !item.visible || StrLower(item.category) != StrLower(menu.category)
                continue
            entries.Push({
                id: "custom:" item.category ":" item.name,
                kind: "action",
                name: item.name,
                aliases: item.name " " item.target " custom submenu",
                action: MakeCustomTargetHandler(item.target)
            })
        }
        if entries.Length > 0
            QuickLauncher_AddSection(sections, menu.category, entries)
    }
    return sections
}

QuickLauncher_IdIsExcluded(id, entries) {
    for entry in entries
        if entry.id = id
            return true
    return false
}

QuickLauncher_BuildRemainderSections(exclude) {
    sections := []

    recentEntries := []
    for id in RC2_GetRecents() {
        entry := RC2_FindEntry(id)
        if IsObject(entry) && !exclude.Has(id)
            recentEntries.Push(QuickLauncher_AsEntry(entry, entry.kind))
    }
    QuickLauncher_AddSection(sections, "Recent", recentEntries)

    remainingLinks := QuickLauncher_RemainingConfiguredLinks(exclude)
    QuickLauncher_AddSection(sections, "Links", remainingLinks)

    custom := LoadCustomMenuRows()
    customCategories := Map()
    for entry in RC2_LinkRegistry([], [], custom) {
        if exclude.Has(entry.id)
            continue
        category := QuickLauncher_CustomCategory(entry, custom)
        if !customCategories.Has(category)
            customCategories[category] := []
        customCategories[category].Push(entry)
    }
    categoryNames := []
    for category, entries in customCategories
        categoryNames.Push(category)
    QuickLauncher_SortNames(categoryNames)
    for category in categoryNames
        QuickLauncher_AddSection(sections, category, customCategories[category])

    workflows := []
    for row in LoadWorkflowToolRows() {
        if !row.visible || WorkflowToolIsBackgroundOnly(row.key)
            continue
        displayName := row.name . (row.hotkey != "" ? "   " row.hotkey : "")
        workflows.Push({
            id: "workflow:" row.key, kind: "action", name: displayName,
            aliases: row.key " " row.hotkey " " row.notes,
            action: QuickLauncher_OpenWorkflow.Bind(row.key)
        })
    }
    QuickLauncher_AddSection(sections, "Workflow Tools", workflows)

    clinicalSections := QuickLauncher_ClinicalSectionMap()
    clinicalOrder := QuickLauncher_ClinicalSectionOrder()
    buckets := Map()
    for section in clinicalOrder
        buckets[section] := []
    for tool in RC2_ToolRegistry() {
        if clinicalSections.Has(tool.id) && !exclude.Has(tool.id)
            buckets[clinicalSections[tool.id]].Push(QuickLauncher_AsEntry(tool, "tool"))
    }
    for section in clinicalOrder
        QuickLauncher_AddSection(sections, section, buckets[section])
    return sections
}

QuickLauncher_RemainingConfiguredLinks(exclude) {
    links := []
    primary := LoadPrimaryLinks()
    for idx, item in primary {
        if item.visible
            continue
        entry := {
            id: "link:primary:" item.key, kind: "link", name: item.name,
            aliases: item.key " " item.url " link website",
            label: "LINK · ALL   " item.name,
            action: RC2_OpenPrimaryLink.Bind(item, idx)
        }
        if !exclude.Has(entry.id)
            links.Push(entry)
    }
    for entry in RC2_LinkRegistry([], LoadOtherLinks(), [])
        if !exclude.Has(entry.id)
            links.Push(entry)
    return links
}

QuickLauncher_AddNativeSections(menuObj, sections, usedLabels) {
    firstSection := true
    for section in sections {
        if !firstSection
            menuObj.Add()
        firstSection := false
        ; Keep the configured Favorites & Links on the main menu. Collapse
        ; every other section into a native Windows submenu so the launcher
        ; remains scannable even with a large tool library.
        if StrLower(section.title) = "favorites & links" {
            for entry in section.entries {
          visibleLabel := entry.name
                label := QuickLauncher_UniqueMenuLabel(visibleLabel, usedLabels)
                menuObj.Add(label, QuickLauncher_MenuEntryHandler(entry))
            }
            continue
        }
        subMenu := Menu()
        subUsed := Map()
        for entry in section.entries {
          visibleLabel := entry.name
            label := QuickLauncher_UniqueMenuLabel(visibleLabel, subUsed)
            subMenu.Add(label, QuickLauncher_MenuEntryHandler(entry))
        }
        menuLabel := QuickLauncher_UniqueMenuLabel(StrUpper(section.title), usedLabels)
        menuObj.Add(menuLabel, subMenu)
    }
}

QuickLauncher_UniqueMenuLabel(label, usedLabels) {
    if !usedLabels.Has(label) {
        usedLabels[label] := 1
        return label
    }
    usedLabels[label] += 1
    suffix := ""
    Loop usedLabels[label]
        suffix .= Chr(0x200B)
    return label suffix
}

QuickLauncher_MenuEntryHandler(entry) {
    entryCopy := entry
    return (*) => RC2_LaunchSearchEntry(entryCopy)
}

QuickLauncher_BuildSections() {
    sections := []
    QuickLauncher_AddSection(sections, "Favorites", RC2_FavoriteEntries())

    recentEntries := []
    for id in RC2_GetRecents() {
        entry := RC2_FindEntry(id)
        if IsObject(entry)
            recentEntries.Push(QuickLauncher_AsEntry(entry, entry.kind))
    }
    QuickLauncher_AddSection(sections, "Recent", recentEntries)

    primary := LoadPrimaryLinks(), other := LoadOtherLinks(), custom := LoadCustomMenuRows()
    configuredLinks := []
    for entry in RC2_LinkRegistry(primary, other, [])
        configuredLinks.Push(entry)
    QuickLauncher_AddSection(sections, "Links", configuredLinks)

    customCategories := Map()
    for entry in RC2_LinkRegistry([], [], custom) {
        category := QuickLauncher_CustomCategory(entry, custom)
        if !customCategories.Has(category)
            customCategories[category] := []
        customCategories[category].Push(entry)
    }
    categoryNames := []
    for category, entries in customCategories
        categoryNames.Push(category)
    QuickLauncher_SortNames(categoryNames)
    for category in categoryNames
        QuickLauncher_AddSection(sections, category, customCategories[category])

    workflows := []
    for row in LoadWorkflowToolRows() {
        if !row.visible || WorkflowToolIsBackgroundOnly(row.key)
            continue
        displayName := row.name . (row.hotkey != "" ? "   " row.hotkey : "")
        workflows.Push({
            id: "workflow:" row.key, kind: "action", name: displayName,
            aliases: row.key " " row.hotkey " " row.notes,
            action: QuickLauncher_OpenWorkflow.Bind(row.key)
        })
    }
    QuickLauncher_AddSection(sections, "Workflow Tools", workflows)

    clinicalSections := QuickLauncher_ClinicalSectionMap()
    clinicalOrder := QuickLauncher_ClinicalSectionOrder()
    buckets := Map()
    for section in clinicalOrder
        buckets[section] := []
    for tool in RC2_ToolRegistry() {
        if clinicalSections.Has(tool.id)
            buckets[clinicalSections[tool.id]].Push(QuickLauncher_AsEntry(tool, "tool"))
    }
    for section in clinicalOrder
        QuickLauncher_AddSection(sections, section, buckets[section])
    return sections
}

QuickLauncher_ClinicalSectionMap() {
    return Map(
        "patient", "Patient Workspace", "medrec", "Patient Workspace",
        "crcl", "Renal / Pharmacokinetics", "bodyweight", "Renal / Pharmacokinetics", "vancomycin", "Renal / Pharmacokinetics", "aminoglycoside", "Renal / Pharmacokinetics", "crrt", "Renal / Pharmacokinetics", "renal-library", "Renal / Pharmacokinetics",
        "calcium", "Electrolytes / Labs & Trends", "aniongap", "Electrolytes / Labs & Trends", "sodium", "Electrolytes / Labs & Trends", "osmolarity", "Electrolytes / Labs & Trends", "iron", "Electrolytes / Labs & Trends",
        "mme", "Medication Conversions", "fentanyl", "Medication Conversions", "benzo", "Medication Conversions", "steroid", "Medication Conversions",
        "rsi", "Emergency / Critical Care", "tnk", "Emergency / Critical Care", "dka", "Emergency / Critical Care", "emergency", "Emergency / Critical Care",
        "apap", "Toxicology / Reversal", "digifab", "Toxicology / Reversal", "crofab", "Toxicology / Reversal", "reversal", "Toxicology / Reversal",
        "antibiotics", "Infectious Diseases / PEP", "pep", "Infectious Diseases / PEP", "rabies", "Infectious Diseases / PEP", "pcn", "Infectious Diseases / PEP",
        "4t", "Scores / Screening", "qtc", "Scores / Screening",
        "daysupply", "Workflow Utilities", "reminders", "Workflow Utilities", "handoff", "Workflow Utilities"
    )
}

QuickLauncher_ClinicalSectionOrder() {
    return ["Patient Workspace", "Renal / Pharmacokinetics", "Electrolytes / Labs & Trends", "Medication Conversions", "Emergency / Critical Care", "Toxicology / Reversal", "Infectious Diseases / PEP", "Scores / Screening", "Workflow Utilities"]
}

QuickLauncher_AsEntry(item, kind := "action") {
    return { id: item.id, kind: kind, name: item.name, aliases: item.aliases, action: item.action }
}

QuickLauncher_CustomCategory(entry, rows) {
    for row in rows {
        if row.type = "item" && entry.name = row.name && InStr(entry.aliases, row.target)
            return row.category != "" ? row.category : "Custom Links"
    }
    return "Custom Links"
}

QuickLauncher_AddSection(sections, title, entries) {
    if !IsObject(entries) || entries.Length = 0
        return
    QuickLauncher_SortEntries(entries)
    sections.Push({ title: title, entries: entries })
}

QuickLauncher_SortEntries(entries) {
    Loop entries.Length - 1 {
        idx := A_Index + 1
        current := entries[idx]
        pos := idx - 1
        while pos >= 1 && StrCompare(entries[pos].name, current.name, false) > 0 {
            entries[pos + 1] := entries[pos]
            pos -= 1
        }
        entries[pos + 1] := current
    }
}

QuickLauncher_SortNames(names) {
    Loop names.Length - 1 {
        idx := A_Index + 1
        current := names[idx]
        pos := idx - 1
        while pos >= 1 && StrCompare(names[pos], current, false) > 0 {
            names[pos + 1] := names[pos]
            pos -= 1
        }
        names[pos + 1] := current
    }
}

QuickLauncher_Render(query := "") {
    global _quickLauncherTree, _quickLauncherItemMap
    if !IsObject(_quickLauncherTree)
        return
    _quickLauncherTree.Delete()
    _quickLauncherItemMap := Map()
    query := StrLower(Trim(query))
    model := QuickLauncher_BuildMainModel()
    for section in model.sections {
        visible := []
        for entry in section.entries {
            haystack := StrLower(section.title " " entry.name " " entry.aliases)
            if query = "" || InStr(haystack, query)
                visible.Push(entry)
        }
        if visible.Length = 0
            continue
        headerId := _quickLauncherTree.Add(StrUpper(section.title), 0, "Bold Expand")
        for entry in visible {
            itemId := _quickLauncherTree.Add(entry.name, headerId)
            _quickLauncherItemMap[itemId] := entry
        }
    }
    remainderRoot := 0
    remainderSections := QuickLauncher_BuildRemainderSections(model.exclude)
    for section in remainderSections {
        visible := []
        for entry in section.entries {
            haystack := StrLower(section.title " " entry.name " " entry.aliases)
            if query = "" || InStr(haystack, query)
                visible.Push(entry)
        }
        if visible.Length = 0
            continue
        if !remainderRoot
            remainderRoot := _quickLauncherTree.Add("ALL TOOLS & LINKS", 0, "Bold Expand")
        headerId := _quickLauncherTree.Add(StrUpper(section.title), remainderRoot, "Bold Expand")
        for entry in visible {
            itemId := _quickLauncherTree.Add(entry.name, headerId)
            _quickLauncherItemMap[itemId] := entry
        }
    }
}

QuickLauncher_FilterChanged(ctrl, *) {
    QuickLauncher_Render(ctrl.Value)
}

QuickLauncher_OpenSelected(ctrl, itemId := 0) {
    global _quickLauncherItemMap, _quickLauncherGui
    if !itemId
        itemId := ctrl.GetSelection()
    if !_quickLauncherItemMap.Has(itemId) {
        if itemId
            ctrl.Modify(itemId, "Expand")
        return
    }
    entry := _quickLauncherItemMap[itemId]
    try _quickLauncherGui.Destroy()
    _quickLauncherGui := 0
    RC2_LaunchSearchEntry(entry)
}

QuickLauncher_OpenWorkflow(key) {
    global _quickMenuOwnerHwnd
    OpenWorkflowToolByKey(key, _quickMenuOwnerHwnd)
}

QuickLauncher_OpenCustomize() {
    global _quickLauncherGui
    try _quickLauncherGui.Destroy()
    _quickLauncherGui := 0
    OpenManageLinksGui()
}

QuickLauncher_Resize(g, minMax, width, height) {
    global _quickLauncherTree, _quickLauncherFilter
    if minMax = -1 || !IsObject(_quickLauncherTree)
        return
    _quickLauncherFilter.Move(,, Max(440, width - 40))
    _quickLauncherTree.Move(,, Max(440, width - 40), Max(370, height - 170))
}

BuildQuickMenu(menuObj) {
    RC2_AddLauncherSections(menuObj)
    primary := LoadPrimaryLinks()
    other   := LoadOtherLinks()
    custom  := LoadCustomMenuRows()

    for idx, item in primary {
        if !item.visible
            continue
        menuObj.Add(item.name, MakeItemHandler(item, true, idx, 0))
    }

    menuObj.Add()

    if other.Length > 0 {
        subMenu := Menu()
        for idx, item in other
            subMenu.Add(item.name, MakeItemHandler(item, false, 0, idx))
        menuObj.Add("Other Links", subMenu)
    }

    AddCustomDropDownMenus(menuObj, custom)

    menuObj.Add("Workflow Tools", BuildWorkflowToolsMenu())
    menuObj.Add("Calculators", BuildCalculatorsMenu())

}


AddCustomDropDownMenus(menuObj, rows) {
    ; Menus are shown in the order of their menu rows. Items are shown in CSV order
    ; under their matching category. Empty menus are hidden from the quick menu.
    for menuRow in rows {
        if menuRow.type != "menu" or !menuRow.visible or menuRow.category = ""
            continue
        subMenu := Menu()
        itemCount := 0
        for itemRow in rows {
            if itemRow.type != "item" or !itemRow.visible
                continue
            if StrLower(itemRow.category) != StrLower(menuRow.category)
                continue
            subMenu.Add(itemRow.name, MakeCustomTargetHandler(itemRow.target))
            itemCount += 1
        }
        if itemCount > 0
            menuObj.Add(menuRow.category, subMenu)
    }

    ; If an item references a category but the menu row was deleted/corrupted, still show it
    ; under an implicit category rather than silently hiding the user's link.
    addedImplicit := Map()
    for itemRow in rows {
        if itemRow.type != "item" or !itemRow.visible or itemRow.category = ""
            continue
        categoryKey := StrLower(itemRow.category)
        if addedImplicit.Has(categoryKey)
            continue
        found := false
        for menuRow in rows {
            if menuRow.type = "menu" and StrLower(menuRow.category) = categoryKey {
                found := true
                break
            }
        }
        if found
            continue
        subMenu := Menu()
        for child in rows {
            if child.type = "item" and child.visible and StrLower(child.category) = categoryKey
                subMenu.Add(child.name, MakeCustomTargetHandler(child.target))
        }
        menuObj.Add(itemRow.category, subMenu)
        addedImplicit[categoryKey] := true
    }
}

MakeCustomTargetHandler(target) {
    targetCopy := target
    return (*) => SafeRun(OpenCustomMenuTarget, targetCopy)
}

MakeItemHandler(item, isPrimary, primaryIndex, otherIndex) {
    return (*) => SafeRun(OpenItem, item, isPrimary, primaryIndex, otherIndex)
}

OpenItem(item, isPrimary, primaryIndex, otherIndex) {
    ; Quick Notes Pro always opens the in-script notes window, regardless of its URL field.
    if isPrimary and HasProp(item, "key") and item.key = "quicknotes" {
        LaunchQuickNotesPro()
        return
    }
    ; Any other primary link that still says "builtin" uses the hardcoded default.
    ; Once the user edits its URL, it's stored as a real URL and just gets Run directly.
    if isPrimary and item.url = "builtin" {
        LaunchBuiltInPrimary(item.key)
        return
    }
    if item.url != ""
        SafeLaunchTarget(item.url)
}

LaunchBuiltInPrimary(key) {
    switch key {
        case "lexicomp":    SafeLaunchTarget("https://online.lexi.com")
        case "uptodate":    SafeLaunchTarget("https://www.uptodate.com")
        case "vancopk":     SafeLaunchTarget("https://globalrph.com/vancomycin/")
        case "liverpool":   SafeLaunchTarget("https://www.hiv-druginteractions.org/checker")
        case "extravasafe": SafeLaunchTarget("https://www.extravasafe.com")
        case "quicknotes":  LaunchQuickNotesPro()
        default:            MsgBox "Unknown built-in primary link: " key
    }
}

LaunchQuickNotesPro() {
    QNP_Open()
}

; =================================================================================================
;  CALCULATORS  (built into AHK — no external site required)
; =================================================================================================

BuildCalculatorsMenu() {
    m := Menu()

    patient := Menu()
    patient.Add("Patient Workspace (current session)", (*) => SafeRun(Menu_OpenPatientHub))
    patient.Add("Capture-Based Renal Dose Screening", (*) => SafeRun(Menu_OpenPatientModule, "renal"))
    patient.Add("Capture-Based Labs && Trends", (*) => SafeRun(Menu_OpenPatientModule, "labs"))
    patient.Add("Medication Risk Stack", (*) => SafeRun(Menu_OpenPatientModule, "riskstack"))
    patient.Add("Medication Reconciliation", (*) => SafeRun(Menu_OpenMedRec))
    patient.Add("Allergy / Order Conflicts", (*) => SafeRun(Menu_OpenPatientModule, "allergy"))
    patient.Add("Order Review Queue", (*) => SafeRun(Menu_OpenOrderReview))
    patient.Add("Capture Evidence Review", (*) => SafeRun(Menu_OpenCaptureEvidence))
    patient.Add()
    patient.Add("Reference Source Versions", (*) => SafeRun(Hub_ShowRefStatus))
    patient.Add("Clear Patient Session", (*) => SafeRun(PCtx_ClearSession, true))

    renalPk := Menu()
    renalPk.Add("Creatinine Clearance (Cockcroft-Gault)", (*) => SafeRun(Calc_OpenCrCl))
    renalPk.Add("Ideal / Adjusted Body Weight", (*) => SafeRun(Calc_OpenBodyWeight))
    renalPk.Add("Vancomycin AUC / Dosing Support", (*) => SafeRun(Calc_OpenVancomycinDosing))
    renalPk.Add("Critical Drip Tracker", (*) => SafeRun(Calc_OpenCriticalDripTracker))
    renalPk.Add("Aminoglycoside Dosing", (*) => SafeRun(Calc_OpenAminoglycoside))
    renalPk.Add("CRRT Solution / Electrolyte Support", (*) => SafeRun(Calc_OpenCrrtDosing))
    renalPk.Add("Renal Rules Library (screening)", (*) => SafeRun(Hub_OpenRenalLibrary))

    labs := Menu()
    labs.Add("Corrected Calcium", (*) => SafeRun(Calc_OpenCorrectedCalcium))
    labs.Add("Anion Gap / Delta-Delta", (*) => SafeRun(Calc_OpenAnionGap))
    labs.Add("Sodium Correction / Free Water Deficit", (*) => SafeRun(Calc_OpenSodium))
    labs.Add("IV Solution Osmolarity / Tonicity", (*) => SafeRun(Calc_OpenOsmolarity))
    labs.Add("Iron Deficit (Ganzoni)", (*) => SafeRun(Calc_OpenIronDeficit))

    conversions := Menu()
    conversions.Add("Opioid MME Estimate", (*) => SafeRun(Calc_OpenOpioidConversion))
    conversions.Add("Fentanyl Patch / Oral MME", (*) => SafeRun(Calc_OpenFentanylMME))
    conversions.Add("Benzodiazepine Conversion", (*) => SafeRun(Calc_OpenBenzoConversion))
    conversions.Add("Corticosteroid Equivalency", (*) => SafeRun(Calc_OpenSteroid))

    emergency := Menu()
    emergency.Add("RSI Dosing Support", (*) => SafeRun(Calc_OpenRsiDosing))
    emergency.Add("TNK Stroke Eligibility / Dose", (*) => SafeRun(Calc_OpenTnkStroke))
    emergency.Add("DKA Treatment Support", (*) => SafeRun(Calc_OpenDkaTreatment))
    emergency.Add("Critical Drip Tracker", (*) => SafeRun(Calc_OpenCriticalDripTracker))
    emergency.Add("EMERGENCY / Code Algorithms", (*) => SafeRun(Calc_OpenEmergency))

    tox := Menu()
    tox.Add("Acetaminophen Toxicity + NAC", (*) => SafeRun(Calc_OpenAcetaminophenToxicity))
    tox.Add("DigiFab Digoxin Toxicity Support", (*) => SafeRun(Calc_OpenDigiFab))
    tox.Add("CroFab Crotalid Envenomation Support", (*) => SafeRun(Calc_OpenCroFab))
    tox.Add("Anticoagulant Reversal Agents", (*) => SafeRun(Calc_OpenAnticoagReversal))

    id := Menu()
    id.Add("Infectious Disease - Empiric Antibiotics", (*) => SafeRun(Calc_OpenAntibiotic))
    id.Add("Exposure PEP Decision Engine", (*) => SafeRun(Calc_OpenExposurePep))
    id.Add("Rabies PEP Decision Support", (*) => SafeRun(Calc_OpenRabiesPep))
    id.Add("Penicillin Cross-Reactivity", (*) => SafeRun(Calc_OpenPcnCrossReactivity))

    screening := Menu()
    screening.Add("4T Score (HIT Probability)", (*) => SafeRun(Calc_Open4TScore))
    screening.Add("QTc Calculator (Bazett / Fridericia)", (*) => SafeRun(Calc_OpenQTc))

    workflow := Menu()
    workflow.Add("Days Supply / Taper Calculator", (*) => SafeRun(Calc_OpenDaySupply))
    workflow.Add("Lab / Dose Reminders", (*) => SafeRun(Calc_OpenReminders))
    workflow.Add("Shift Handoff Builder", (*) => SafeRun(Calc_OpenHandoff))

    m.Add("Patient Workspace", patient)
    m.Add("Renal / Pharmacokinetics", renalPk)
    m.Add("Electrolytes / Labs && Trends", labs)
    m.Add("Medication Conversions", conversions)
    m.Add("Emergency / Critical Care", emergency)
    m.Add("Toxicology / Reversal", tox)
    m.Add("Infectious Diseases / PEP", id)
    m.Add("Scores / Screening", screening)
    m.Add("Workflow Utilities", workflow)
    return m
}

; -------------------------------------------------------------------------------------------------
; DAYS SUPPLY / TAPER CALCULATOR
; Parses each explicit SIG stage independently so long tapers are not flattened into one frequency.
; Ambiguous PRN directions and incomplete intermediate stages are withheld instead of guessed.
; -------------------------------------------------------------------------------------------------


DaySupply_Run(quantityCtrl, sigCtrl, outputCtrl) {
    result := DaySupply_Calculate(sigCtrl.Value, quantityCtrl.Value)
    outputCtrl.Value := DaySupply_BuildReport(result, sigCtrl.Value, quantityCtrl.Value)
}

DaySupply_NormalizeSig(sig) {
    text := StrLower(String(sig))
    text := RegExReplace(text, "\R+", " | ")
    replacements := [
        ["one and one-half", "1.5"], ["one and a half", "1.5"],
        ["two and one-half", "2.5"], ["two and a half", "2.5"],
        ["three and one-half", "3.5"], ["three and a half", "3.5"],
        ["one-half", "0.5"], ["one half", "0.5"], ["a half", "0.5"], ["half", "0.5"],
        ["twelve", "12"], ["eleven", "11"], ["ten", "10"], ["nine", "9"],
        ["eight", "8"], ["seven", "7"], ["six", "6"], ["five", "5"],
        ["four", "4"], ["three", "3"], ["two", "2"], ["one", "1"]
    ]
    for pair in replacements
        text := RegExReplace(text, "i)\b" StrReplace(pair[1], "-", "[- ]") "\b", pair[2])
    text := StrReplace(text, Chr(189), "0.5")
    text := RegExReplace(text, "\s+", " ")
    return Trim(text)
}

DaySupply_NumberPattern() {
    return "(?:\d+\s+\d+\s*/\s*\d+|\d+\s*/\s*\d+|\d+(?:\.\d+)?)"
}

DaySupply_ParseNumber(raw) {
    value := Trim(String(raw))
    if IsNumber(value)
        return Number(value)
    if RegExMatch(value, "^(\d+)\s+(\d+)\s*/\s*(\d+)$", &mixed) && Number(mixed[3]) != 0
        return Number(mixed[1]) + Number(mixed[2]) / Number(mixed[3])
    if RegExMatch(value, "^(\d+)\s*/\s*(\d+)$", &fraction) && Number(fraction[2]) != 0
        return Number(fraction[1]) / Number(fraction[2])
    return ""
}

DaySupply_SplitStages(sig) {
    normalized := DaySupply_NormalizeSig(sig)
    normalized := RegExReplace(normalized,
        "i)\s*(?:,?\s*\b(?:and\s+)?then\b|,?\s*\bfollowed\s+by\b|;|\R)\s*", "|")
    ; Also accept comma-separated taper steps when the comma is followed by a new dose + dosage unit.
    normalized := RegExReplace(normalized,
        "i),\s*(?=(?:(?:take|use|reduce\s+to|decrease\s+to)\s+)?"
        . DaySupply_NumberPattern()
        . "\s*(?:tablets?(?:\(s\))?|tabs?(?:\(s\))?|capsules?(?:\(s\))?|caps?(?:\(s\))?|milliliters?|ml|puffs?|drops?|packets?|patches?|units?)\b)", "|")
    stages := []
    for part in StrSplit(normalized, "|") {
        part := Trim(part, " ,.`t`r`n")
        if part != ""
            stages.Push(part)
    }
    return stages
}

DaySupply_ParseFrequency(segment) {
    text := StrLower(segment)
    if RegExMatch(text, "\b(?:prn|as needed)\b")
        return { ok: false, error: "PRN/as-needed use requires a documented maximum use rate." }
    if RegExMatch(text, "\b(?:q|every\s*)\d+\s*[-–]\s*\d+\s*h(?:ours?)?\b")
        return { ok: false, error: "A frequency range cannot produce one exact days supply." }
    if RegExMatch(text, "i)\b(\d+(?:\.\d+)?)\s+times?\s+(?:daily|(?:a |per )?day)\b", &n) && n[1] > 0 && n[1] <= 24
        return {ok:true, perDay:Number(n[1]), label:n[1] " times daily", intervalDays:0}
    if RegExMatch(text, "\b(?:every other day|q\.?o\.?d\.?)\b")
        return { ok: true, perDay: 0.5, label: "every other day", intervalDays: 2 }
    if RegExMatch(text, "\b(?:four times daily|four times (?:a |per )?day|qid|q\.?i\.?d\.?|every 6 hours?|q6h)\b")
        return { ok: true, perDay: 4, label: "4 times daily", intervalDays: 0 }
    if RegExMatch(text, "\b(?:three times daily|three times (?:a |per )?day|tid|t\.?i\.?d\.?|every 8 hours?|q8h)\b")
        return { ok: true, perDay: 3, label: "3 times daily", intervalDays: 0 }
    if RegExMatch(text, "\b(?:twice daily|twice (?:a |per )?day|bid|b\.?i\.?d\.?|every 12 hours?|q12h|morning and evening)\b")
        return { ok: true, perDay: 2, label: "2 times daily", intervalDays: 0 }
    if RegExMatch(text, "\b(?:once (?:a |per )?day|daily|every day|every morning|each morning|q24h|q\.?d\.?|nightly|at bedtime|qhs)\b")
        return { ok: true, perDay: 1, label: "once daily", intervalDays: 0 }
    if RegExMatch(text, "\b(\d+(?:\.\d+)?)\s+times\s+(?:a |per )?day\b", &times) {
        perDay := Number(times[1])
        if perDay > 0 && perDay <= 24
            return { ok: true, perDay: perDay, label: DaySupply_FormatNumber(perDay) " times daily", intervalDays: 0 }
    }
    if RegExMatch(text, "\b(?:every\s*|q)(\d{1,2})\s*h(?:ours?)?\b", &hourly) {
        hours := Number(hourly[1])
        if hours > 0 && Mod(24, hours) = 0
            return { ok: true, perDay: 24 / hours, label: "every " hours " hours", intervalDays: 0 }
    }
    return { ok: false, error: "No exact daily frequency was recognized." }
}

DaySupply_ParseDuration(segment) {
    pattern := DaySupply_NumberPattern()
    if !RegExMatch(segment, "i)\b(?:for|x)\s*(" pattern ")\s*(d(?:ays?)?|w(?:eeks?|ks?)?)\b", &match)
        return ""
    amount := DaySupply_ParseNumber(match[1])
    if amount = "" || amount <= 0
        return ""
    unit := StrLower(match[2])
    return RegExMatch(unit, "^w") ? amount * 7 : amount
}

DaySupply_ParseStage(segment, index) {
    numberPattern := DaySupply_NumberPattern()
    unitPattern := "(?:tablets?(?:\(s\))?|tabs?(?:\(s\))?|capsules?(?:\(s\))?|caps?(?:\(s\))?|milliliters?|ml|puffs?|inhalations?|drops?|packets?|sachets?|patches?|suppositories?|units?|applications?|sprays?|teaspoons?|tsp)"
    pattern := "i)(?:\b(?:take|use|instill|inject|inhale|apply|administer|reduce\s+to|decrease\s+to)\s+|^\s*)(" numberPattern ")\s*(" unitPattern ")\b"
    if !RegExMatch(segment, pattern, &doseMatch)
        return { ok: false, error: "Step " index ": no dose amount plus dosage unit was recognized.", raw: segment }

    dose := DaySupply_ParseNumber(doseMatch[1])
    if dose = "" || dose <= 0
        return { ok: false, error: "Step " index ": the dose amount is invalid.", raw: segment }

    unit := StrLower(doseMatch[2])
    duration := DaySupply_ParseDuration(segment)
    frequency := DaySupply_ParseFrequency(segment)
    inferredFrequency := false
    if !frequency.ok {
        if duration != "" && !RegExMatch(segment, "i)\b(?:prn|as needed|divided|every|times|morning|evening|bedtime|night)\b") {
            frequency := { ok: true, perDay: 1, label: "once daily [inferred from taper step]", intervalDays: 0 }
            inferredFrequency := true
        } else {
            return { ok: false, error: "Step " index ": " frequency.error, raw: segment }
        }
    }
    return {
        ok: true,
        index: index,
        raw: segment,
        dose: dose,
        unit: unit,
        perDay: frequency.perDay,
        frequency: frequency.label,
        intervalDays: frequency.intervalDays,
        duration: duration,
        derivedDuration: false,
        inferredFrequency: inferredFrequency,
        units: ""
    }
}

DaySupply_StageUnits(stage, duration) {
    if stage.intervalDays = 2
        return Ceil(duration / 2) * stage.dose
    return stage.dose * stage.perDay * duration
}

DaySupply_DaysUntilDepleted(stages, quantity) {
    remaining := quantity
    days := 0
    for stage in stages {
        if stage.duration = ""
            return days + remaining / (stage.dose * stage.perDay)
        needed := DaySupply_StageUnits(stage, stage.duration)
        if remaining + 0.000001 >= needed {
            remaining -= needed
            days += stage.duration
            continue
        }
        if stage.intervalDays = 2
            return days + (remaining / stage.dose) * 2
        return days + remaining / (stage.dose * stage.perDay)
    }
    return days
}

DaySupply_Calculate(sig, quantityText) {
    if !IsNumber(Trim(String(quantityText))) || Number(quantityText) <= 0
        return { ok: false, error: "Enter a positive numeric quantity dispensed." }
    quantity := Number(quantityText)
    parts := DaySupply_SplitStages(sig)
    if parts.Length = 0
        return { ok: false, error: "Enter the complete SIG." }

    stages := []
    for idx, part in parts {
        stage := DaySupply_ParseStage(part, idx)
        if !stage.ok
            return { ok: false, error: stage.error, stages: stages }
        stages.Push(stage)
    }

    missingDuration := []
    totalFixedUnits := 0
    fixedDays := 0
    for idx, stage in stages {
        if stage.duration = "" {
            missingDuration.Push(idx)
            continue
        }
        stage.units := DaySupply_StageUnits(stage, stage.duration)
        totalFixedUnits += stage.units
        fixedDays += stage.duration
    }

    if stages.Length > 1 {
        if missingDuration.Length > 1
            return { ok: false, error: "More than one taper step has no duration. Add a duration to every step except one final 'until gone' step.", stages: stages }
        if missingDuration.Length = 1 && missingDuration[1] != stages.Length
            return { ok: false, error: "An intermediate taper step has no duration. The calculator will not guess where the next step begins.", stages: stages }
    }

    warnings := []
    for stage in stages {
        if stage.inferredFrequency
            warnings.Push("Step " stage.index " did not state a frequency; once-daily use was inferred from the finite taper step. Verify the source SIG.")
    }
    if stages.Length = 1 && missingDuration.Length = 1 {
        stage := stages[1]
        stage.duration := quantity / (stage.dose * stage.perDay)
        stage.derivedDuration := true
        stage.units := quantity
        totalUnits := quantity
        courseDays := stage.duration
        days := courseDays
    } else if missingDuration.Length = 1 {
        last := stages[missingDuration[1]]
        remaining := quantity - totalFixedUnits
        if remaining <= 0
            return { ok: false, error: "The dispensed quantity is exhausted before the final taper step begins.", stages: stages }
        last.duration := remaining / (last.dose * last.perDay)
        last.derivedDuration := true
        last.units := remaining
        totalUnits := quantity
        courseDays := fixedDays + last.duration
        days := courseDays
        warnings.Push("The final step duration was derived from the remaining quantity; verify that the SIG intends 'until gone'.")
    } else {
        totalUnits := totalFixedUnits
        courseDays := fixedDays
        if quantity + 0.000001 < totalUnits {
            days := DaySupply_DaysUntilDepleted(stages, quantity)
            warnings.Push("ALERT: the dispensed quantity runs out before the written schedule is complete.")
        } else {
            days := courseDays
            if quantity > totalUnits + 0.000001
                warnings.Push("The dispensed quantity exceeds the amount used by the explicit course; verify the quantity and intended days supply.")
        }
    }

    return {
        ok: true,
        days: days,
        courseDays: courseDays,
        quantity: quantity,
        totalUnits: totalUnits,
        stages: stages,
        warnings: warnings
    }
}

DaySupply_FormatNumber(value) {
    rounded := Round(Number(value), 2)
    return Mod(rounded, 1) = 0 ? String(Round(rounded)) : String(rounded)
}

DaySupply_BuildReport(result, sig, quantityText) {
    if !IsObject(result) || !result.ok
        return "DAYS SUPPLY NOT CALCULATED`r`n`r`n" result.error
            . "`r`n`r`nNo value was guessed. Correct the SIG or calculate manually from the verified prescription."

    out := "DAYS SUPPLY = " DaySupply_FormatNumber(result.days) " day(s)`r`n"
    out .= "Quantity dispensed: " DaySupply_FormatNumber(result.quantity) "`r`n"
    if Abs(result.days - result.courseDays) > 0.001
        out .= "Written course duration: " DaySupply_FormatNumber(result.courseDays) " day(s)`r`n"
    out .= "`r`nPARSED SCHEDULE`r`n"
    out .= "----------------------------------------------------------------------`r`n"
    for stage in result.stages {
        out .= stage.index ". " DaySupply_FormatNumber(stage.dose) " " stage.unit
            . " · " stage.frequency
            . " · " DaySupply_FormatNumber(stage.duration) " day(s)"
            . " · " DaySupply_FormatNumber(stage.units) " unit(s)"
            . (stage.derivedDuration ? " [duration derived from quantity]" : "") "`r`n"
    }
    out .= "----------------------------------------------------------------------`r`n"
    out .= "Schedule units: " DaySupply_FormatNumber(result.totalUnits) "`r`n"
    if result.warnings.Length {
        out .= "`r`nVERIFY`r`n"
        for warning in result.warnings
            out .= "- " warning "`r`n"
    }
    out .= "`r`nSource SIG (editable copy):`r`n" Trim(String(sig))
    out .= "`r`n`r`nArithmetic support only. Verify the source prescription and local billing rules."
    return out
}

; -------------------------------------------------------------------------------------------------
; CREATININE CLEARANCE — Cockcroft-Gault, with automatic weight selection by BMI
;   BMI < 18.5          -> use Actual Body Weight
;   BMI 18.5 - 29.9      -> use Ideal Body Weight
;   BMI >= 30            -> use Adjusted Body Weight
; -------------------------------------------------------------------------------------------------

; =================================================================================================
; RC15 — UNIVERSAL PATIENT CONTEXT BINDING
; Patient-aware tools consume the active parsed session. Parsed values prefill controls but remain
; editable. No calculator is modal and no standard window is forced above the pharmacist's workflow.
; =================================================================================================

PBind_CurrentParsed() {
    ctx := PCtx_Active()
    if !IsObject(ctx)
        return PatientV2_NewParsedResult()
    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    return parsed
}

PBind_Value(parsed, key, fallback := "") {
    if IsObject(parsed) && parsed.HasOwnProp(key) {
        value := parsed.%key%
        if value != ""
            return value
    }
    return fallback
}

PBind_Lab(key, fallback := "") {
    ctx := PCtx_Active()
    if !IsObject(ctx)
        return fallback
    value := PCtx_LabValue(ctx, key)
    return value != "" ? value : fallback
}

PBind_Set(ctrl, value, source := "Parsed") {
    if !IsObject(ctrl) || value = ""
        return false
    try ctrl.Value := value
    try ctrl.Opt("+BackgroundEAF4FF")
    ctrl._patientBindingSource := source
    ctrl._patientBindingOriginal := value
    return true
}

PBind_SetSex(ctrl, sex) {
    if !IsObject(ctrl) || sex = ""
        return false
    s := StrLower(String(sex))
    try {
        if InStr(s, "female") || s = "f"
            ctrl.Choose("Female")
        else if InStr(s, "male") || s = "m"
            ctrl.Choose("Male")
        else
            return false
        ctrl._patientBindingSource := "Parsed"
        return true
    }
    return false
}

PBind_HeightIn(parsed) {
    cm := PBind_Value(parsed, "heightCm", "")
    return IsNumber(cm) && Number(cm) > 0 ? Round(Number(cm) / 2.54, 1) : ""
}

PBind_HeightCm(parsed) {
    cm := PBind_Value(parsed, "heightCm", "")
    return IsNumber(cm) && Number(cm) > 0 ? Round(Number(cm), 1) : ""
}

PCtx_CompactStrip() {
    ctx := PCtx_Active()
    if !IsObject(ctx)
        return "No active patient capture"
    parts := []
    age := PCtx_Demo(ctx, "age")
    sex := PCtx_Demo(ctx, "sex")
    wt := PCtx_SelectedWeight(ctx)
    scr := PCtx_LabValue(ctx, "creatinine")
    k := PCtx_LabValue(ctx, "potassium")
    if age != ""
        parts.Push(age " yr")
    if sex != ""
        parts.Push(sex)
    if wt != ""
        parts.Push(Round(Number(wt), 1) " kg")
    if scr != ""
        parts.Push("SCr " Round(Number(scr), 2))
    if k != ""
        parts.Push("K " Round(Number(k), 1))
    if ctx.allergyRaw.Length > 0
        parts.Push("Allergies " DoseAware_Join(ctx.allergyRaw, ", "))
    return parts.Length > 0 ? DoseAware_Join(parts, "  ·  ") : "Active patient capture contains no recognized summary fields"
}

PBind_AddStatus(g, text := "Blue fields were populated from the active patient capture and remain editable.") {
    strip := g.Add("Text", "xm y+8 w720 c1F4E79", PCtx_CompactStrip())
    strip.SetFont("s9 bold")
    t := g.Add("Text", "xm y+3 w720 c4477AA", text)
    t.SetFont("s8")
    patientButton := g.Add("Button", "x+8 yp-5 w94 h25", "Patient")
    patientButton.OnEvent("Click", Patient_OpenFromAnyScreen)
    return t
}

Patient_OpenFromAnyScreen(*) {
    ctx := PCtx_Active()
    if IsObject(ctx) {
        Hub_Show(ctx)
        return
    }
    SafeRun(BMI_FromRegion)
}

PBind_MissingSummary(required) {
    missing := []
    for label, value in required {
        if value = ""
            missing.Push(label)
    }
    if missing.Length = 0
        return "All available patient inputs were populated."
    return "Missing from capture: " DoseAware_Join(missing, ", ")
}

Calc_OpenCrCl() {
    g := Gui("", "Creatinine Clearance (Cockcroft-Gault)")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "xm ym w130", "Age (years):")
    ageEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w130", "Height (inches):")
    htEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w130", "Actual weight (kg):")
    wtEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w130", "Serum Cr (mg/dL):")
    scrEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w130", "Sex:")
    sexDrop := g.Add("DropDownList", "x+8 yp-3 w100", ["Male", "Female"])
    sexDrop.Value := 1

    g.Add("Text", "xm y+16 w360 0x10")   ; divider

    bmiText    := g.Add("Text", "xm y+8 w360 cGray", "")
    weightText := g.Add("Text", "xm y+4 w360 cGray", "")

    result := g.Add("Text", "xm y+10 w360", "")
    result.SetFont("s12 bold")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+8 w360 cGray",
        "Weight used is selected automatically:`n"
        "  BMI < 18.5  ->  Actual Body Weight`n"
        "  BMI 18.5–29.9  ->  Ideal Body Weight`n"
        "  BMI >= 30  ->  Adjusted Body Weight")

    g.Add("Button", "xm y+14 w100 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_RunCrCl, ageEdit, htEdit, wtEdit, scrEdit, sexDrop, bmiText, weightText, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    parsed := PBind_CurrentParsed()
    PBind_Set(ageEdit, PBind_Value(parsed, "age"))
    PBind_Set(htEdit, PBind_HeightIn(parsed))
    PBind_Set(wtEdit, PBind_Value(parsed, "weightKg"))
    PBind_Set(scrEdit, PBind_Value(parsed, "scr"))
    PBind_SetSex(sexDrop, PBind_Value(parsed, "sex"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Age", ageEdit.Value, "Height", htEdit.Value, "Weight", wtEdit.Value, "SCr", scrEdit.Value)))
    Workbench29_Show(g,"w400")
}

Calc_RunCrCl(ageEdit, htEdit, wtEdit, scrEdit, sexDrop, bmiText, weightText, result) {
    age := Trim(ageEdit.Value)
    ht  := Trim(htEdit.Value)
    wt  := Trim(wtEdit.Value)
    scr := Trim(scrEdit.Value)
    isFemale := sexDrop.Text = "Female"

    if !IsNumber(age) or !IsNumber(ht) or !IsNumber(wt) or !IsNumber(scr)
        or age < 18 or age > 120 or ht <= 0 or wt <= 0 or scr <= 0 {
        bmiText.Text    := ""
        weightText.Text := ""
        result.SetFont("cRed")
        result.Text := "Enter valid positive numbers for all fields."
        return
    }

    ; --- BMI (using height in inches, weight in kg) ---
    heightMeters := ht * 0.0254
    bmi := wt / (heightMeters * heightMeters)

    ; --- IBW (Devine) ---
    inchesOver5ft := ht - 60
    if inchesOver5ft < 0
        inchesOver5ft := 0
    ibwBase := isFemale ? 45.5 : 50
    ibw := ibwBase + (2.3 * inchesOver5ft)

    ; --- AdjBW ---
    adjbw := ibw + 0.4 * (wt - ibw)

; --- Select weight: ABW<IBW -> actual; ABW>=1.3*IBW -> AdjBW; else IBW ---
if wt < ibw {
weightUsed  := wt
weightLabel := "Actual Body Weight"
} else if wt >= (1.3 * ibw) {
weightUsed  := adjbw
weightLabel := "Adjusted Body Weight"
} else {
weightUsed  := ibw
weightLabel := "Ideal Body Weight"
}

    bmiText.Text := "BMI: " Round(bmi, 1) " kg/m²   |   IBW: " Round(ibw, 1) " kg   |   AdjBW: " Round(adjbw, 1) " kg"

    weightText.Text := "Weight used: " Round(weightUsed, 1) " kg (" weightLabel ")"

    ; --- Cockcroft-Gault ---
    crcl := Calc_CockcroftGault(age, weightUsed, scr, isFemale)

    if crcl <= 0 {
        result.SetFont("cRed")
        result.Text := "Calculated CrCl is not clinically usable. Verify age, weight, and SCr."
        return
    }

    result.SetFont("cBlue")
    result.Text := "CrCl ≈ " Round(crcl, 1) " mL/min"
}

Calc_CockcroftGault(age, weightKg, scr, isFemale := false) {
    crcl := ((140 - age) * weightKg) / (72 * scr)
    return isFemale ? crcl * 0.85 : crcl
}


; -------------------------------------------------------------------------------------------------
; IDEAL / ADJUSTED BODY WEIGHT
; -------------------------------------------------------------------------------------------------
Calc_OpenBodyWeight() {
    g := Gui("", "Ideal / Adjusted Body Weight")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "xm ym w130", "Height (inches):")
    htEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w130", "Actual weight (kg):")
    wtEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w130", "Sex:")
    sexDrop := g.Add("DropDownList", "x+8 yp-3 w100", ["Male", "Female"])
    sexDrop.Value := 1

    ibwResult := g.Add("Text", "xm y+16 w320 cBlue", "")
    abwResult := g.Add("Text", "xm y+6 w320 cBlue", "")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+8 w320 cGray",
        "IBW (Devine): Male 50 + 2.3/in over 5ft. Female 45.5 + 2.3/in over 5ft.`nAdjBW = IBW + 0.4 x (actual - IBW), used when actual > 130% IBW.")

    g.Add("Button", "xm y+10 w100 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_RunBodyWeight, htEdit, wtEdit, sexDrop, ibwResult, abwResult))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    parsed := PBind_CurrentParsed()
    PBind_Set(htEdit, PBind_HeightIn(parsed))
    PBind_Set(wtEdit, PBind_Value(parsed, "weightKg"))
    PBind_SetSex(sexDrop, PBind_Value(parsed, "sex"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Height", htEdit.Value, "Weight", wtEdit.Value)))
    Workbench29_Show(g,"w360")
}

Calc_RunBodyWeight(htEdit, wtEdit, sexDrop, ibwResult, abwResult) {
    ht := Trim(htEdit.Value)
    wt := Trim(wtEdit.Value)

    if !IsNumber(ht) or ht <= 0 {
        ibwResult.Text := "Enter a valid height in inches."
        ibwResult.SetFont("cRed")
        abwResult.Text := ""
        return
    }

    inchesOver5ft := ht - 60
    if inchesOver5ft < 0
        inchesOver5ft := 0

    base := sexDrop.Text = "Female" ? 45.5 : 50
    ibw  := base + (2.3 * inchesOver5ft)

    ibwResult.SetFont("cBlue")
    ibwResult.Text := "IBW ≈ " Round(ibw, 1) " kg"

    if IsNumber(wt) and wt > 0 {
        if wt > (1.3 * ibw) {
            adjbw := ibw + 0.4 * (wt - ibw)
            abwResult.SetFont("cBlue")
            abwResult.Text := "AdjBW ≈ " Round(adjbw, 1) " kg  (actual weight exceeds 130% IBW)"
        } else {
            abwResult.SetFont("cGray")
            abwResult.Text := "AdjBW not needed (actual weight ≤ 130% IBW) — use actual or IBW per protocol."
        }
    } else {
        abwResult.Text := ""
    }
}

; -------------------------------------------------------------------------------------------------
; CORRECTED CALCIUM (for hypoalbuminemia)
; -------------------------------------------------------------------------------------------------
Calc_OpenCorrectedCalcium() {
    g := Gui("", "Corrected Calcium")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "xm ym w150", "Measured Ca (mg/dL):")
    caEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w150", "Serum albumin (g/dL):")
    albEdit := g.Add("Edit", "x+8 yp-3 w100")

    result := g.Add("Text", "xm y+16 w340", "")
    result.SetFont("s12 bold")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+8 w340 cGray",
        "Corrected Ca = Measured Ca + 0.8 x (4.0 - albumin)`n"
        "Formula assumes a normal albumin of 4.0 g/dL. Less reliable in`n"
        "critical illness — consider ionized calcium if available.")

    g.Add("Button", "xm y+14 w100 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_RunCorrectedCalcium, caEdit, albEdit, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    PBind_Set(caEdit, PBind_Lab("calcium"))
    PBind_Set(albEdit, PBind_Lab("albumin"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Calcium", caEdit.Value, "Albumin", albEdit.Value)))
    Workbench29_Show(g,"w380")
}

Calc_RunCorrectedCalcium(caEdit, albEdit, result) {
    ca  := Trim(caEdit.Value)
    alb := Trim(albEdit.Value)

    if !IsNumber(ca) or !IsNumber(alb) or ca <= 0 or alb <= 0 {
        result.SetFont("cRed")
        result.Text := "Enter valid positive numbers for both fields."
        return
    }

    corrected := ca + 0.8 * (4.0 - alb)

    result.SetFont("cBlue")
    result.Text := "Corrected Ca ≈ " Round(corrected, 2) " mg/dL"
}

; -------------------------------------------------------------------------------------------------
; OPIOID MME ESTIMATE
;   MME is an opioid exposure/risk screening tool, not an equianalgesic dose
;   converter. Do not use a calculated MME value to determine a new opioid dose.
;   Oral outpatient MME factors below were aligned with the CDC 2022 table for
;   common oral opioids; non-oral/non-CDC routes remain rough reference estimates
;   and should be verified against institutional guidance before clinical use.
; -------------------------------------------------------------------------------------------------

; Map structure: "Drug|Route" -> MME factor per 1 mg (or per 1 mcg for fentanyl)
global OpioidMmeFactors := Map(
    "Morphine|Oral",                 1,
    "Morphine|IV",                   3,
    "Morphine|SubQ",                 3,
    "Morphine|Rectal",               1,
    "Oxycodone|Oral",                1.5,
    "Oxymorphone|Oral",              3,
    "Oxymorphone|IV",                10,
    "Hydrocodone|Oral",              1,
    "Hydromorphone|Oral",            4,
    "Hydromorphone|IV",              20,
    "Hydromorphone|SubQ",            20,
    "Fentanyl|IV (mcg)",             0.3,
    "Fentanyl|Transdermal (mcg/hr)", 2.4,
    "Fentanyl|Intranasal (mcg)",     0.16,
    "Fentanyl|Buccal/SL (mcg)",      0.13,
    "Codeine|Oral",                  0.15,
    "Tramadol|Oral",                 0.1,
    "Tapentadol|Oral",               0.4,
    "Methadone|Oral",                4.7      ; nonlinear — MME only, not dose conversion
)

; Which routes are valid for a given drug (controls the Route dropdown per drug)
global OpioidRoutesByDrug := Map(
    "Morphine",      ["Oral", "IV", "SubQ", "Rectal"],
    "Oxycodone",     ["Oral"],
    "Oxymorphone",   ["Oral", "IV"],
    "Hydrocodone",   ["Oral"],
    "Hydromorphone", ["Oral", "IV", "SubQ"],
    "Fentanyl",      ["IV (mcg)", "Transdermal (mcg/hr)", "Intranasal (mcg)", "Buccal/SL (mcg)"],
    "Codeine",       ["Oral"],
    "Tramadol",      ["Oral"],
    "Tapentadol",    ["Oral"],
    "Methadone",     ["Oral"]
)

Calc_OpenOpioidConversion() {
    Opioid_LoadFactors()
    g := Gui("", "Opioid MME Estimate (not dose conversion)")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    drugNames := []
    for k in OpioidRoutesByDrug
        drugNames.Push(k)

    g.Add("Text", "xm ym w130", "From drug:")
    fromDrugDrop := g.Add("DropDownList", "x+8 yp-3 w160", drugNames)
    fromDrugDrop.Value := 1
    g.Add("Text", "x+8 yp w50", "Route:")
    fromRouteDrop := g.Add("DropDownList", "x+4 yp-3 w150")

    g.Add("Text", "xm y+10 w130", "Current daily dose:")
    doseEdit := g.Add("Edit", "x+8 yp-3 w100")
    doseUnitText := g.Add("Text", "x+6 yp w60 cGray", "mg")

    g.Add("Text", "xm y+14 w130", "To drug:")
    toDrugDrop := g.Add("DropDownList", "x+8 yp-3 w160", drugNames)
    toDrugDrop.Value := 2
    g.Add("Text", "x+8 yp w50", "Route:")
    toRouteDrop := g.Add("DropDownList", "x+4 yp-3 w150")

    Calc_RefreshOpioidRoutes(fromDrugDrop, fromRouteDrop)
    Calc_RefreshOpioidRoutes(toDrugDrop, toRouteDrop)
    fromDrugDrop.OnEvent("Change", (*) => Calc_RefreshOpioidRoutes(fromDrugDrop, fromRouteDrop))
    toDrugDrop.OnEvent("Change",   (*) => Calc_RefreshOpioidRoutes(toDrugDrop, toRouteDrop))
    fromDrugDrop.OnEvent("Change", (*) => Calc_UpdateDoseUnitLabel(fromDrugDrop, doseUnitText))
    Calc_UpdateDoseUnitLabel(fromDrugDrop, doseUnitText)

    g.Add("Text", "xm y+14 w170", "Optional reference reduction:")
    reductionDrop := g.Add("DropDownList", "x+8 yp-3 w210",
        ["None (show equal-MME amount)", "25% lower reference", "33% lower reference", "50% lower reference"])
    reductionDrop.Value := 3

    result := g.Add("Text", "xm y+18 w420", "")
    result.SetFont("s11 bold")

    reducedResult := g.Add("Text", "xm y+6 w420", "")
    reducedResult.SetFont("s11 bold")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+10 w420 cRed",
        "CAUTION: MME is for exposure/risk screening only.`n"
        "Do NOT use this output to choose a new opioid dose.`n"
        "When rotating opioids, use patient-specific assessment, incomplete`n"
        "cross-tolerance reduction, product labeling, and local protocol.`n"
        "Methadone and fentanyl require particular specialist-level caution.")

    g.Add("Button", "xm y+14 w100 Default", "Convert").OnEvent("Click",
        (*) => SafeRun(Calc_RunOpioidConversion, fromDrugDrop, fromRouteDrop, doseEdit,
                                         toDrugDrop, toRouteDrop, reductionDrop, result, reducedResult))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    Workbench29_Show(g,"w460")
}

Calc_RefreshOpioidRoutes(drugDrop, routeDrop) {
    global OpioidRoutesByDrug
    routes := OpioidRoutesByDrug[drugDrop.Text]
    routeDrop.Delete()
    routeDrop.Add(routes)
    routeDrop.Value := 1
}

Calc_UpdateDoseUnitLabel(drugDrop, unitText) {
    unitText.Text := drugDrop.Text = "Fentanyl" ? "mcg" : "mg"
}

Calc_RunOpioidConversion(fromDrugDrop, fromRouteDrop, doseEdit, toDrugDrop, toRouteDrop,
                          reductionDrop, result, reducedResult) {
    global OpioidMmeFactors
    dose := Trim(doseEdit.Value)

    if !IsNumber(dose) or dose <= 0 {
        result.SetFont("cRed")
        result.Text := "Enter a valid positive dose."
        reducedResult.Text := ""
        return
    }

    fromKey := fromDrugDrop.Text "|" fromRouteDrop.Text
    toKey   := toDrugDrop.Text "|" toRouteDrop.Text
	if (toDrugDrop.Text = "Methadone") {
	result.SetFont("cRed")
	result.Text := "Converting TO methadone by MME is not supported. Methadone induction/rotation requires specialist assessment, not an MME estimate."
	reducedResult.Text := ""
	return
	}
    if !OpioidMmeFactors.Has(fromKey) or !OpioidMmeFactors.Has(toKey) {
        result.SetFont("cRed")
        result.Text := "No conversion factor available for that drug/route combination."
        reducedResult.Text := ""
        return
    }

    fromFactor := Calc_OpioidSourceFactor(fromDrugDrop.Text, dose, OpioidMmeFactors[fromKey])
    toFactor   := OpioidMmeFactors[toKey]

    mme := dose * fromFactor
    equivDose := mme / toFactor

    toUnit := toDrugDrop.Text = "Fentanyl" ? "mcg" : "mg"

    result.SetFont("cBlue")
    result.Text := "Estimated current exposure: " Round(mme, 1) " MME/day. Equal-MME reference amount, NOT a dose recommendation: " Round(equivDose, 2) " " toUnit " (" toDrugDrop.Text " " toRouteDrop.Text ")"

    ; Apply the user-selected reduction (or none)
    switch reductionDrop.Value {
        case 1:  ; None
            reducedResult.SetFont("cGray")
            reducedResult.Text := "No reduction applied — equal-MME reference amount shown above only."
        case 2:  ; 25%
            reduced := equivDose * 0.75
            reducedResult.SetFont("cGreen")
            reducedResult.Text := "25% lower reference amount, not a dose recommendation: " Round(reduced, 2) " " toUnit
        case 3:  ; 33%
            reduced := equivDose * 0.67
            reducedResult.SetFont("cGreen")
            reducedResult.Text := "33% lower reference amount, not a dose recommendation: " Round(reduced, 2) " " toUnit
        case 4:  ; 50%
            reduced := equivDose * 0.5
            reducedResult.SetFont("cGreen")
            reducedResult.Text := "50% lower reference amount, not a dose recommendation: " Round(reduced, 2) " " toUnit
    }
}

Calc_OpioidSourceFactor(drugName, dose, configuredFactor) {
    if drugName != "Methadone"
        return configuredFactor
    return dose <= 20 ? 4 : dose <= 40 ? 8 : dose <= 60 ? 10 : 12
}

; -------------------------------------------------------------------------------------------------
; BENZODIAZEPINE CONVERSION (via diazepam-equivalent)
;   Drug and route selected independently where a drug has multiple routes.
; -------------------------------------------------------------------------------------------------

; "Drug|Route" -> mg diazepam-equivalent per 1 mg of that drug/route
global BenzoDiazepamFactors := Map(
    "Diazepam|Oral",         1,
    "Diazepam|IV",           1,
    "Diazepam|Rectal",       1,
    "Lorazepam|Oral",        5,
    "Lorazepam|IV",          5,
    "Lorazepam|SubQ",        5,
    "Lorazepam|Sublingual",  5,
    "Alprazolam|Oral",       10,
    "Clonazepam|Oral",       10,
    "Chlordiazepoxide|Oral", 0.4,
    "Oxazepam|Oral",         0.33,
    "Temazepam|Oral",        0.5,
    "Midazolam|IV",          2,
    "Midazolam|IM",          2,
    "Midazolam|Intranasal",  4,
    "Midazolam|Buccal",      2.7
)

global BenzoRoutesByDrug := Map(
    "Diazepam",         ["Oral", "IV", "Rectal"],
    "Lorazepam",        ["Oral", "IV", "SubQ", "Sublingual"],
    "Alprazolam",       ["Oral"],
    "Clonazepam",       ["Oral"],
    "Chlordiazepoxide", ["Oral"],
    "Oxazepam",         ["Oral"],
    "Temazepam",        ["Oral"],
    "Midazolam",        ["IV", "IM", "Intranasal", "Buccal"]
)

Calc_OpenBenzoConversion() {
    g := Gui("", "Benzodiazepine Conversion (diazepam-equivalent)")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    drugNames := []
    for k in BenzoRoutesByDrug
        drugNames.Push(k)

    g.Add("Text", "xm ym w130", "From drug:")
    fromDrugDrop := g.Add("DropDownList", "x+8 yp-3 w150", drugNames)
    fromDrugDrop.Value := 1
    g.Add("Text", "x+8 yp w50", "Route:")
    fromRouteDrop := g.Add("DropDownList", "x+4 yp-3 w120")

    g.Add("Text", "xm y+10 w130", "Current daily dose (mg):")
    doseEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+14 w130", "To drug:")
    toDrugDrop := g.Add("DropDownList", "x+8 yp-3 w150", drugNames)
    toDrugDrop.Value := 2
    g.Add("Text", "x+8 yp w50", "Route:")
    toRouteDrop := g.Add("DropDownList", "x+4 yp-3 w120")

    Calc_RefreshBenzoRoutes(fromDrugDrop, fromRouteDrop)
    Calc_RefreshBenzoRoutes(toDrugDrop, toRouteDrop)
    fromDrugDrop.OnEvent("Change", (*) => Calc_RefreshBenzoRoutes(fromDrugDrop, fromRouteDrop))
    toDrugDrop.OnEvent("Change",   (*) => Calc_RefreshBenzoRoutes(toDrugDrop, toRouteDrop))

    g.Add("Text", "xm y+14 w170", "Dose reduction (if switching):")
    reductionDrop := g.Add("DropDownList", "x+8 yp-3 w160",
        ["None (full calculated dose)", "25% reduction", "33% reduction", "50% reduction"])
    reductionDrop.Value := 1   ; default None — benzo switches are commonly done at full calculated dose

    result := g.Add("Text", "xm y+18 w400", "")
    result.SetFont("s11 bold")

    reducedResult := g.Add("Text", "xm y+6 w400", "")
    reducedResult.SetFont("s11 bold")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+10 w400 cRed",
        "CAUTION: Equivalency tables are approximate and vary by reference, and`n"
        "do not always account for route-specific bioavailability differences.`n"
        "Consider a conservative starting dose, especially in elderly patients`n"
        "or those with hepatic impairment (avoid agents requiring oxidation:`n"
        "diazepam, chlordiazepoxide — prefer lorazepam, oxazepam, temazepam).")

    g.Add("Button", "xm y+14 w100 Default", "Convert").OnEvent("Click",
        (*) => SafeRun(Calc_RunBenzoConversion, fromDrugDrop, fromRouteDrop, doseEdit,
                                        toDrugDrop, toRouteDrop, reductionDrop, result, reducedResult))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    Workbench29_Show(g,"w440")
}

Calc_RefreshBenzoRoutes(drugDrop, routeDrop) {
    global BenzoRoutesByDrug
    routes := BenzoRoutesByDrug[drugDrop.Text]
    routeDrop.Delete()
    routeDrop.Add(routes)
    routeDrop.Value := 1
}

Calc_RunBenzoConversion(fromDrugDrop, fromRouteDrop, doseEdit, toDrugDrop, toRouteDrop,
                         reductionDrop, result, reducedResult) {
    global BenzoDiazepamFactors
    dose := Trim(doseEdit.Value)

    if !IsNumber(dose) or dose <= 0 {
        result.SetFont("cRed")
        result.Text := "Enter a valid positive dose."
        reducedResult.Text := ""
        return
    }

    fromKey := fromDrugDrop.Text "|" fromRouteDrop.Text
    toKey   := toDrugDrop.Text "|" toRouteDrop.Text

    if !BenzoDiazepamFactors.Has(fromKey) or !BenzoDiazepamFactors.Has(toKey) {
        result.SetFont("cRed")
        result.Text := "No conversion factor available for that drug/route combination."
        reducedResult.Text := ""
        return
    }

    fromFactor := BenzoDiazepamFactors[fromKey]
    toFactor   := BenzoDiazepamFactors[toKey]

    diazepamEquiv := dose * fromFactor
    equivDose := diazepamEquiv / toFactor

    result.SetFont("cBlue")
    result.Text := "Calculated equivalent: " Round(equivDose, 2) " mg (" toDrugDrop.Text " " toRouteDrop.Text ")  [≈ " Round(diazepamEquiv, 1) " mg diazepam-equivalent]"

    switch reductionDrop.Value {
        case 1:
            reducedResult.SetFont("cGray")
            reducedResult.Text := "No reduction applied — equal-MME reference amount shown above only."
        case 2:
            reduced := equivDose * 0.75
            reducedResult.SetFont("cGreen")
            reducedResult.Text := "With 25% reduction: " Round(reduced, 2) " mg"
        case 3:
            reduced := equivDose * 0.67
            reducedResult.SetFont("cGreen")
            reducedResult.Text := "With 33% reduction: " Round(reduced, 2) " mg"
        case 4:
            reduced := equivDose * 0.5
            reducedResult.SetFont("cGreen")
            reducedResult.Text := "With 50% reduction: " Round(reduced, 2) " mg"
    }
}


; -------------------------------------------------------------------------------------------------
; PENICILLIN CROSS-REACTIVITY CHECKER
;   Dropdown-based lookup, not a formula. Organized by beta-lactam class with
;   representative drugs. Cross-reactivity is driven mainly by R1 side-chain
;   similarity, not just class — so this flags "similar side chain" cases
;   specifically rather than blanket class-based warnings.
; -------------------------------------------------------------------------------------------------
Calc_OpenPcnCrossReactivity() {
    g := Gui("", "Penicillin Cross-Reactivity Checker")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    drugList := [
        "Penicillin G/VK", "Amoxicillin", "Ampicillin", "Piperacillin", "Dicloxacillin",
        "Cefazolin", "Cephalexin", "Cefuroxime", "Cefdinir", "Cefpodoxime",
        "Ceftriaxone", "Cefepime", "Ceftazidime",
        "Meropenem", "Ertapenem", "Imipenem-cilastatin",
        "Aztreonam"
    ]

    g.Add("Text", "xm ym w200", "Patient has documented allergy to:")
    allergyDrop := g.Add("DropDownList", "xm y+4 w280", drugList)
    allergyDrop.Value := 1

    g.Add("Text", "xm y+14 w200", "Considering giving:")
    targetDrop := g.Add("DropDownList", "xm y+4 w280", drugList)
    targetDrop.Value := 6

    result := g.Add("Text", "xm y+16 w420 h100", "")
    result.SetFont("s10")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+6 w420 cGray",
        "Based on beta-lactam class and R1 side-chain similarity where known.`n"
        "This is a screening aid, not a substitute for allergy history review`n"
        "or specialist consultation for severe reactions (anaphylaxis, SJS/TEN, DRESS).")

    g.Add("Button", "xm y+12 w100 Default", "Check").OnEvent("Click",
        (*) => SafeRun(Calc_RunPcnCrossReactivity, allergyDrop, targetDrop, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    Workbench29_Show(g,"w460")
}

; Classification: class + side-chain group (drugs sharing a side-chain group have
; meaningfully higher cross-reactivity risk than class alone would suggest).
Calc_PcnDrugInfo(name) {
    data := Map(
        "Penicillin G/VK",     { class: "Penicillin", sideChain: "none" },
        "Amoxicillin",         { class: "Penicillin", sideChain: "aminopenicillin" },
        "Ampicillin",          { class: "Penicillin", sideChain: "aminopenicillin" },
        "Piperacillin",        { class: "Penicillin", sideChain: "ureidopenicillin" },
        "Dicloxacillin",       { class: "Penicillin", sideChain: "isoxazolyl" },
        "Cefazolin",           { class: "Cephalosporin (1st gen)", sideChain: "unique" },
        "Cephalexin",          { class: "Cephalosporin (1st gen)", sideChain: "aminopenicillin" },
        "Cefuroxime",          { class: "Cephalosporin (2nd gen)", sideChain: "unique" },
        "Cefdinir",            { class: "Cephalosporin (3rd gen)", sideChain: "unique" },
        "Cefpodoxime",         { class: "Cephalosporin (3rd gen)", sideChain: "unique" },
        "Ceftriaxone",         { class: "Cephalosporin (3rd gen)", sideChain: "unique" },
        "Cefepime",            { class: "Cephalosporin (4th gen)", sideChain: "unique" },
        "Ceftazidime",         { class: "Cephalosporin (3rd gen)", sideChain: "unique" },
        "Meropenem",           { class: "Carbapenem", sideChain: "none" },
        "Ertapenem",           { class: "Carbapenem", sideChain: "none" },
        "Imipenem-cilastatin", { class: "Carbapenem", sideChain: "none" },
        "Aztreonam",           { class: "Monobactam", sideChain: "ceftazidime-like" }
    )
    return data[name]
}

Calc_RunPcnCrossReactivity(allergyDrop, targetDrop, result) {
    allergy := allergyDrop.Text
    target  := targetDrop.Text

    if allergy = target {
        result.SetFont("cRed")
        result.Text := "Same drug selected for both fields — this IS the documented allergy."
        return
    }

    aInfo := Calc_PcnDrugInfo(allergy)
    tInfo := Calc_PcnDrugInfo(target)

    riskLevel := ""
    explanation := ""

    ; Aztreonam is safe in penicillin/most cephalosporin allergy EXCEPT shares
    ; side chain with ceftazidime specifically.
    if target = "Aztreonam" {
        if allergy = "Ceftazidime" {
            riskLevel := "ELEVATED RISK"
            explanation := "Aztreonam shares an identical R1 side chain with ceftazidime. "
                . "Cross-reactivity risk is clinically significant here despite aztreonam's "
                . "monobactam class generally being safe in penicillin allergy."
        } else {
            riskLevel := "LOW RISK"
            explanation := "Aztreonam (monobactam) has minimal cross-reactivity with penicillins, "
                . "cephalosporins, and carbapenems — EXCEPT ceftazidime, due to shared side chain."
        }
    }
    else if allergy = "Aztreonam" {
        if target = "Ceftazidime" {
            riskLevel := "ELEVATED RISK"
            explanation := "Ceftazidime shares an identical R1 side chain with aztreonam."
        } else {
            riskLevel := "LOW RISK"
            explanation := "Aztreonam allergy does not meaningfully predict reactions to "
                . "penicillins, other cephalosporins, or carbapenems."
        }
    }
    ; Carbapenems: low cross-reactivity with penicillins/cephalosporins in most data
    else if (aInfo.class = "Carbapenem") != (tInfo.class = "Carbapenem") {
        riskLevel := "LOW RISK"
        explanation := "Cross-reactivity between penicillins/cephalosporins and carbapenems "
            . "is low (~1% or less in most studies), though case-by-case judgment is advised "
            . "for severe prior reactions (anaphylaxis, SJS/TEN)."
    }
    ; Same side chain group (not "none" or "unique") = elevated risk regardless of class
    else if aInfo.sideChain = tInfo.sideChain and aInfo.sideChain != "none" and aInfo.sideChain != "unique" {
        riskLevel := "ELEVATED RISK"
        explanation := "'" allergy "' and '" target "' share a similar R1 side chain ("
            . aInfo.sideChain "). Cross-reactivity risk is higher than class alone would suggest."
    }
    ; Same class, different/unique side chains = low-moderate
    else if aInfo.class = tInfo.class {
        riskLevel := "LOW-MODERATE RISK"
        explanation := "Same beta-lactam class, but side chains differ — true cross-reactivity "
            . "is uncertain. Consider severity of prior reaction and test-dose/graded challenge "
            . "protocols per allergy/ID guidance if this drug is preferred."
    }
    ; Different class, unique side chains = low risk
    else {
        riskLevel := "LOW RISK"
        explanation := "Different beta-lactam classes with dissimilar side chains. "
            . "Modern data suggests cross-reactivity is lower than historically assumed "
            . "(especially beyond first-generation cephalosporins), but clinical context "
            . "(reaction severity/type) should still guide the final decision."
    }

    colorMap := Map("LOW RISK", "cGreen", "LOW-MODERATE RISK", "c806600", "ELEVATED RISK", "cRed")
    result.SetFont(colorMap.Has(riskLevel) ? colorMap[riskLevel] : "cBlack")
    result.Text := riskLevel ": " allergy " -> " target "`n`n" explanation
}

; -------------------------------------------------------------------------------------------------
; IRON DEFICIT — Ganzoni equation
;   Total iron deficit (mg) = weight (kg) x (target Hb - actual Hb) (g/dL) x 2.4 + iron stores (mg)
; -------------------------------------------------------------------------------------------------
Calc_OpenIronDeficit() {
    g := Gui("", "Iron Deficit (Ganzoni Equation)")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "xm ym w160", "Actual weight (kg):")
    wtEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w160", "Current Hemoglobin (g/dL):")
    hgbEdit := g.Add("Edit", "x+8 yp-3 w100")

    g.Add("Text", "xm y+10 w160", "Target Hemoglobin (g/dL):")
    targetHgbEdit := g.Add("Edit", "x+8 yp-3 w100", "15")

    g.Add("Text", "xm y+10 w160", "Iron stores to replace (mg):")
    storesEdit := g.Add("Edit", "x+8 yp-3 w100", "500")

    result := g.Add("Text", "xm y+16 w360", "")
    result.SetFont("s12 bold")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+8 w360 cGray",
        "Ganzoni: Total deficit (mg) = weight x (target Hgb - actual Hgb) x 2.4 + iron stores`n"
        "Default target Hgb of 15 g/dL and stores of 500 mg are common conventions —`n"
        "adjust per patient and institutional protocol. Verify against product-specific`n"
        "dosing tables (weight bands) before administering IV iron.")

    g.Add("Button", "xm y+14 w100 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_RunIronDeficit, wtEdit, hgbEdit, targetHgbEdit, storesEdit, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    parsed := PBind_CurrentParsed()
    PBind_Set(wtEdit, PBind_Value(parsed, "weightKg"))
    PBind_Set(hgbEdit, PBind_Lab("hemoglobin"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wtEdit.Value, "Hemoglobin", hgbEdit.Value)))
    Workbench29_Show(g,"w400")
}

Calc_RunIronDeficit(wtEdit, hgbEdit, targetHgbEdit, storesEdit, result) {
    wt        := Trim(wtEdit.Value)
    hgb       := Trim(hgbEdit.Value)
    targetHgb := Trim(targetHgbEdit.Value)
    stores    := Trim(storesEdit.Value)

    if !IsNumber(wt) or !IsNumber(hgb) or !IsNumber(targetHgb) or !IsNumber(stores)
        or wt <= 0 or hgb < 0 or targetHgb <= 0 or stores < 0 {
        result.SetFont("cRed")
        result.Text := "Enter valid numbers for all fields."
        return
    }

    if targetHgb <= hgb {
        result.SetFont("cRed")
        result.Text := "Target Hgb must be greater than current Hgb."
        return
    }

    deficit := wt * (targetHgb - hgb) * 2.4 + stores

    result.SetFont("cBlue")
    result.Text := "Total iron deficit ≈ " Round(deficit, 0) " mg"
}

; -------------------------------------------------------------------------------------------------
; IV SOLUTION OSMOLARITY / TONICITY CALCULATOR
;   Build a solution from library components (mOsm/mL) and/or manual entries,
;   auto-calculate total volume, and calculate osmolarity + tonicity + line-access guidance.
; -------------------------------------------------------------------------------------------------
Calc_OpenOsmolarity() {
    g := Gui("+Resize", "IV Solution Osmolarity / Tonicity")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    lib := LoadOsmolarityLibrary()
    libNames := []
    for item in lib
        libNames.Push(item.name)

    g.Add("Text", "xm ym w530 Section", "Add component from library or type an additive name/synonym:")
    libDrop := g.Add("ComboBox", "xm y+4 w300", libNames)
    libDrop.OnEvent("Change", (*) => SafeRun(Calc_OsmoFilterLibraryCombo, libDrop, lib))
    if libNames.Length
        libDrop.Value := 1
    g.Add("Text", "x+10 yp+4", "Volume (mL):")
    libVolEdit := g.Add("Edit", "x+6 yp-3 w70")
    g.Add("Button", "x+10 yp-3 w90", "Add").OnEvent("Click",
        (*) => SafeRun(Calc_OsmoAddLibraryRow, libDrop, libVolEdit, lib, componentsLV, totalVolEdit))

    g.Add("Text", "xm y+14 w530", "Or add a manual/custom component:")
    g.Add("Text", "xm y+4 w100", "Label:")
    manLabelEdit := g.Add("Edit", "x+6 yp-3 w160")
    g.Add("Text", "x+10 yp+3", "mOsm/mL:")
    manMosmEdit := g.Add("Edit", "x+6 yp-3 w70")
    g.Add("Text", "x+10 yp+3", "Vol (mL):")
    manVolEdit := g.Add("Edit", "x+6 yp-3 w70")
    g.Add("Button", "x+10 yp-3 w90", "Add").OnEvent("Click",
        (*) => SafeRun(Calc_OsmoAddManualRow, manLabelEdit, manMosmEdit, manVolEdit, componentsLV, totalVolEdit))

    g.Add("Text", "xm y+14 w530", "Components in solution:")
    componentsLV := g.Add("ListView", "xm y+4 w530 r6 Grid -Multi",
        ["Component", "Volume (mL)", "mOsm/mL", "Total mOsm"])
    componentsLV.ModifyCol(1, 220)
    componentsLV.ModifyCol(2, 90)
    componentsLV.ModifyCol(3, 90)
    componentsLV.ModifyCol(4, 110)

    g.Add("Button", "xm y+6 w110", "Remove Selected").OnEvent("Click",
        (*) => SafeRun(Calc_OsmoRemoveRow, componentsLV, totalVolEdit))
    g.Add("Button", "x+8 yp w100", "Clear All").OnEvent("Click",
        (*) => SafeRun(Calc_OsmoClearAll, componentsLV, totalVolEdit))

    g.Add("Text", "xm y+16 w200", "Total solution volume (mL):")
    totalVolEdit := g.Add("Edit", "x+8 yp-3 w100 ReadOnly", "0")
    g.Add("Text", "x+8 yp+3 cGray", "auto-calculated from component volumes")

    result := g.Add("Text", "xm y+16 w530", "")
    result.SetFont("s12 bold")

    tonicityResult := g.Add("Text", "xm y+6 w530", "")
    tonicityResult.SetFont("s11 bold")

    lineResult := g.Add("Text", "xm y+6 w530", "")
    lineResult.SetFont("s11 bold")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+12 w530 cGray",
        "Tonicity reference: <250 mOsm/L hypotonic, 250-350 isotonic, >350 hypertonic.`n"
        "Peripheral line guidance: solutions >900 mOsm/L are generally recommended for`n"
        "central administration (INS/ASPEN guidance). These are estimates based on additive`n"
        "content alone — actual peripheral tolerability also depends on infusion rate, vessel`n"
        "size/condition, and duration. Use clinical judgment and institutional policy.")

    g.Add("Button", "xm y+12 w120 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_OsmoRunCalculation, componentsLV, totalVolEdit, result, tonicityResult, lineResult))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    Workbench29_Show(g,"w570 h620")
}

Calc_OsmoAddLibraryRow(libDrop, volEdit, lib, componentsLV, totalVolEdit := 0) {
    vol := Trim(volEdit.Value)
    if !IsNumber(vol) or vol <= 0 {
        MsgBox "Enter a valid positive volume in mL.", "Add Component", "Icon!"
        return
    }
    item := Calc_OsmoFindLibraryItem(libDrop, lib)
    if !IsObject(item) {
        typedName := Calc_OsmoGetComboText(libDrop)
        MsgBox "'" typedName "' is not in the osmolarity library. Select a listed component/synonym, add a synonym in Manage Quick Menu, or use the manual/custom component fields to add a new additive with its mOsm/mL value.", "Add Component", "Icon!"
        return
    }
    totalMosm := item.mosmPerMl * vol
    componentsLV.Add(, item.name, vol, item.mosmPerMl, Round(totalMosm, 1))
    volEdit.Value := ""
    Calc_OsmoUpdateTotalVolume(componentsLV, totalVolEdit)
}

Calc_OsmoAddManualRow(labelEdit, mosmEdit, volEdit, componentsLV, totalVolEdit := 0) {
    label := Trim(labelEdit.Value)
    mosm  := Trim(mosmEdit.Value)
    vol   := Trim(volEdit.Value)

    if label = "" {
        MsgBox "Enter a label for the custom component.", "Add Component", "Icon!"
        return
    }
    if !IsNumber(mosm) or mosm < 0 {
        MsgBox "Enter a valid non-negative mOsm/mL value.", "Add Component", "Icon!"
        return
    }
    if !IsNumber(vol) or vol <= 0 {
        MsgBox "Enter a valid positive volume in mL.", "Add Component", "Icon!"
        return
    }

    totalMosm := mosm * vol
    componentsLV.Add(, label " (custom)", vol, mosm, Round(totalMosm, 1))

    labelEdit.Value := ""
    mosmEdit.Value  := ""
    volEdit.Value   := ""
    Calc_OsmoUpdateTotalVolume(componentsLV, totalVolEdit)
}

Calc_OsmoRemoveRow(componentsLV, totalVolEdit := 0) {
    row := componentsLV.GetNext(0, "Focused")
    if row {
        componentsLV.Delete(row)
        Calc_OsmoUpdateTotalVolume(componentsLV, totalVolEdit)
    }
}

Calc_OsmoClearAll(componentsLV, totalVolEdit := 0) {
    if componentsLV.GetCount() = 0
        return
    if MsgBox("Clear all components?", "Confirm", 0x24) = "Yes" {
        componentsLV.Delete()
        Calc_OsmoUpdateTotalVolume(componentsLV, totalVolEdit)
    }
}



Calc_OsmoFilterLibraryCombo(comboCtrl, lib) {
    ; Type-ahead filtering for the osmolarity library ComboBox.
    ; Matches both substance names and comma-separated synonyms (for example D5W -> Dextrose 5%).
    static filtering := false
    if filtering
        return

    typed := Calc_OsmoGetComboText(comboCtrl)
    typedLower := StrLower(typed)

    matches := []
    seen := Map()
    if typed = "" {
        for item in lib {
            key := StrLower(item.name)
            if !seen.Has(key) {
                seen[key] := true
                matches.Push(item.name)
            }
        }
    } else {
        ; Prefer prefix matches first, then other substring matches. Search names and synonyms.
        for item in lib {
            if Calc_OsmoItemMatches(item, typedLower, true) {
                key := StrLower(item.name)
                if !seen.Has(key) {
                    seen[key] := true
                    matches.Push(item.name)
                }
            }
        }
        for item in lib {
            if !Calc_OsmoItemMatches(item, typedLower, true) && Calc_OsmoItemMatches(item, typedLower, false) {
                key := StrLower(item.name)
                if !seen.Has(key) {
                    seen[key] := true
                    matches.Push(item.name)
                }
            }
        }
    }

    filtering := true
    try {
        comboCtrl.Delete()
        if matches.Length
            comboCtrl.Add(matches)
        comboCtrl.Text := typed
        ; CB_SHOWDROPDOWN = 0x014F. This displays the filtered choices as the user types.
        DllCall("SendMessage", "Ptr", comboCtrl.Hwnd, "UInt", 0x014F, "Ptr", matches.Length ? 1 : 0, "Ptr", 0)
    } finally {
        filtering := false
    }
}

Calc_OsmoItemMatches(item, typedLower, prefixOnly := false) {
    if typedLower = ""
        return true

    candidates := [StrLower(item.name)]
    for syn in StrSplit(OsmoGetSynonyms(item), ",") {
        syn := StrLower(Trim(syn))
        if syn != ""
            candidates.Push(syn)
    }

    for candidate in candidates {
        if prefixOnly {
            if SubStr(candidate, 1, StrLen(typedLower)) = typedLower
                return true
        } else if InStr(candidate, typedLower) {
            return true
        }
    }
    return false
}

Calc_OsmoGetComboText(comboCtrl) {
    try {
        txt := Trim(comboCtrl.Text)
        if txt != ""
            return txt
    }
    try {
        txt := Trim(comboCtrl.Value)
        if txt != ""
            return txt
    }
    return ""
}

Calc_OsmoFindLibraryItem(libDrop, lib) {
    typedName := Calc_OsmoGetComboText(libDrop)
    typedLower := StrLower(typedName)

    ; The ComboBox list is filtered while typing, so its Value no longer reliably maps to
    ; the same index in the full library. Prefer text/synonym matching.
    if typedName != "" {
        for item in lib {
            if StrLower(Trim(item.name)) = typedLower
                return item
            for syn in StrSplit(OsmoGetSynonyms(item), ",") {
                if StrLower(Trim(syn)) = typedLower
                    return item
            }
        }

        ; Also accept a unique prefix/substring match across names and synonyms for faster typing.
        matches := []
        for item in lib {
            if Calc_OsmoItemMatches(item, typedLower, true)
                matches.Push(item)
        }
        if matches.Length = 1
            return matches[1]

        matches := []
        for item in lib {
            if Calc_OsmoItemMatches(item, typedLower, false)
                matches.Push(item)
        }
        if matches.Length = 1
            return matches[1]
    }

    idx := 0
    try {
        idx := libDrop.Value
    }
    if IsInteger(idx) and idx >= 1 and idx <= lib.Length
        return lib[idx]

    return 0
}

Calc_OsmoUpdateTotalVolume(componentsLV, totalVolEdit) {
    if !IsObject(totalVolEdit)
        return
    totalVol := 0
    Loop componentsLV.GetCount() {
        v := componentsLV.GetText(A_Index, 2)
        if IsNumber(v)
            totalVol += Number(v)
    }
    totalVolEdit.Value := Round(totalVol, 3)
}

Calc_OsmoRunCalculation(componentsLV, totalVolEdit, result, tonicityResult, lineResult) {
    if componentsLV.GetCount() = 0 {
        result.SetFont("cRed")
        result.Text := "Add at least one component first."
        tonicityResult.Text := ""
        lineResult.Text := ""
        return
    }

    totalVol := 0
    totalMosm := 0
    Loop componentsLV.GetCount() {
        vol := componentsLV.GetText(A_Index, 2)
        mosm := componentsLV.GetText(A_Index, 4)
        if IsNumber(vol)
            totalVol += Number(vol)
        if IsNumber(mosm)
            totalMosm += Number(mosm)
    }
    if IsObject(totalVolEdit)
        totalVolEdit.Value := Round(totalVol, 3)

    if totalVol <= 0 {
        result.SetFont("cRed")
        result.Text := "Component volumes must total more than 0 mL."
        tonicityResult.Text := ""
        lineResult.Text := ""
        return
    }

    ; mOsm/L = total mOsm / (total volume in mL) x 1000
    osmPerLiter := (totalMosm / totalVol) * 1000

    result.SetFont("cBlue")
    result.Text := "Total: " Round(totalMosm, 1) " mOsm in " totalVol " mL  =  " Round(osmPerLiter, 0) " mOsm/L"

    if osmPerLiter < 250 {
        tonicityResult.SetFont("cOrange")
        tonicityResult.Text := "Tonicity: HYPOTONIC (<250 mOsm/L)"
    } else if osmPerLiter <= 350 {
        tonicityResult.SetFont("cGreen")
        tonicityResult.Text := "Tonicity: ISOTONIC (250-350 mOsm/L)"
    } else {
        tonicityResult.SetFont("cRed")
        tonicityResult.Text := "Tonicity: HYPERTONIC (>350 mOsm/L)"
    }

    if osmPerLiter > 900 {
        lineResult.SetFont("cRed")
        lineResult.Text := "Line access: CENTRAL line generally recommended (>900 mOsm/L)"
    } else {
        lineResult.SetFont("cGreen")
        lineResult.Text := "Line access: Peripheral administration generally acceptable (≤900 mOsm/L)"
    }
}

; -------------------------------------------------------------------------------------------------
; 4T SCORE — Heparin-Induced Thrombocytopenia (HIT) probability
;   Four categories, each scored 0-2. Total 0-8, mapped to Low/Intermediate/High probability.
; -------------------------------------------------------------------------------------------------
Calc_Open4TScore() {
    g := Gui("+Resize", "4T Score (HIT Probability)")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "xm ym w600", "Thrombocytopenia (platelet fall):").SetFont("s10 bold")
    tcDrop := g.Add("DropDownList", "xm y+4 w600", [
        "2 pts — Fall >50% AND nadir ≥20 x10^9/L",
        "1 pt — Fall 30-50% OR nadir 10-19 x10^9/L",
        "0 pts — Fall <30% OR nadir <10 x10^9/L"
    ])
    tcDrop.Value := 1

    g.Add("Text", "xm y+14 w600", "Timing of platelet fall:").SetFont("s10 bold")
    timingDrop := g.Add("DropDownList", "xm y+4 w600", [
        "2 pts — Days 5-10, or ≤1 day if prior heparin exposure within 30 days",
        "1 pt — Fall after day 10, or timing unclear, or exposure 30-100 days ago",
        "0 pts — Fall <4 days without recent heparin exposure"
    ])
    timingDrop.Value := 1

    g.Add("Text", "xm y+14 w600", "Thrombosis or other sequelae:").SetFont("s10 bold")
    thromDrop := g.Add("DropDownList", "xm y+4 w600", [
        "2 pts — Confirmed new thrombosis, skin necrosis, or acute systemic reaction",
        "1 pt — Progressive/recurrent thrombosis, erythematous skin lesions, suspected thrombosis",
        "0 pts — None"
    ])
    thromDrop.Value := 1

    g.Add("Text", "xm y+14 w600", "Other causes of thrombocytopenia:").SetFont("s10 bold")
    otherDrop := g.Add("DropDownList", "xm y+4 w600", [
        "2 pts — None apparent",
        "1 pt — Possible other cause present",
        "0 pts — Definite other cause present"
    ])
    otherDrop.Value := 1

    result := g.Add("Text", "xm y+18 w600", "")
    result.SetFont("s13 bold")

    g.SetFont("s9", "Segoe UI")
    g.Add("Text", "xm y+8 w600 cGray",
        "Score 0-3: Low probability (~<5% HIT). Score 4-5: Intermediate probability (~15-20%).`n"
        "Score 6-8: High probability (~50-80%). The 4T score is a probability aid, not a`n"
        "diagnosis — correlate with clinical context and confirmatory lab testing (e.g. PF4 antibody,`n"
        "serotonin release assay) per institutional protocol.")

    g.Add("Button", "xm y+14 w100 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_Run4TScore, tcDrop, timingDrop, thromDrop, otherDrop, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())

    Workbench29_Show(g,"w640")
}

Calc_Run4TScore(tcDrop, timingDrop, thromDrop, otherDrop, result) {
    ; Each dropdown's Value is 1/2/3 corresponding to 2/1/0 points
    scoreFromChoice(v) => 2 - (v - 1)

    total := scoreFromChoice(tcDrop.Value)
        + scoreFromChoice(timingDrop.Value)
        + scoreFromChoice(thromDrop.Value)
        + scoreFromChoice(otherDrop.Value)

    if total <= 3 {
        category := "Low probability"
        color := "cGreen"
    } else if total <= 5 {
        category := "Intermediate probability"
        color := "c806600"
    } else {
        category := "High probability"
        color := "cRed"
    }

    result.SetFont(color)
    result.Text := "4T Score: " total " / 8  —  " category " of HIT"
}


; -------------------------------------------------------------------------------------------------
; ACETAMINOPHEN TOXICITY + NAC — structured decision support
; -------------------------------------------------------------------------------------------------
Calc_OpenAcetaminophenToxicity() {
    g := Gui("+Resize", "Acetaminophen Toxicity + NAC Decision Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "xm ym w620 cRed", "Decision support only. Use poison center / toxicologist and local protocol for actual care. Nomogram applies only to a single acute ingestion with reliable timing.").SetFont("s10 bold")
    g.Add("Text", "xm y+10", "Weight (kg):")
    wt := g.Add("Edit", "x170 yp w90 Number")
    g.Add("Text", "xm y+8", "Time since ingestion (hours):")
    hrs := g.Add("Edit", "x170 yp w90")
    g.Add("Text", "xm y+8", "Acetaminophen level:")
    lvl := g.Add("Edit", "x170 yp w90")
    unit := g.Add("DropDownList", "x+8 yp w120", ["mcg/mL", "mg/L", "mg/dL", "micromol/L"])
    unit.Value := 1

    g.Add("Text", "xm y+10", "Scenario:")
    scenario := g.Add("DropDownList", "x170 yp w360", [
        "Single acute ingestion, time reliable",
        "Unknown/unreliable time",
        "Repeated supratherapeutic/staggered ingestion",
        "Extended-release product or delayed absorption/coingestion",
        "Presentation > 24 hours after ingestion"
    ])
    scenario.Value := 1

    result := g.Add("Edit", "xm y+14 w700 h300 ReadOnly -Wrap")
    g.Add("Button", "xm y+10 w100 Default", "Assess").OnEvent("Click", (*) => SafeRun(Calc_RunAcetaminophenToxicity, wt, hrs, lvl, unit, scenario, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    parsed := PBind_CurrentParsed()
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_Set(lvl, PBind_Lab("acetaminophen"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wt.Value, "Acetaminophen level", lvl.Value)))
    Workbench29_Show(g,"w740")
}

Calc_RunAcetaminophenToxicity(wtCtrl, hrsCtrl, lvlCtrl, unitCtrl, scenarioCtrl, result) {
    wt := Trim(wtCtrl.Value)
    hrsText := Trim(hrsCtrl.Value)
    lvlText := Trim(lvlCtrl.Value)
    if !IsNumber(wt) or Number(wt) <= 0 {
        MsgBox "Enter a valid weight in kg.", "Acetaminophen", "Icon!"
        return
    }
    wt := Number(wt)
    out := "ACETAMINOPHEN TOXICITY ASSESSMENT`r`n"
        . "This tool does not replace poison center/toxicologist guidance. Use local protocol.`r`n`r`n"

    scenario := scenarioCtrl.Value
    apapMcgMl := ""
    if lvlText != "" and IsNumber(lvlText) and Number(lvlText) >= 0 {
        apapMcgMl := Calc_ConvertApapToMcgMl(Number(lvlText), unitCtrl.Text)
        out .= "Standardized APAP level: " Round(apapMcgMl, 1) " mcg/mL`r`n"
    } else if lvlText != "" {
        out .= "APAP level: invalid; enter a nonnegative numeric level or leave blank`r`n"
    } else {
        out .= "APAP level: not entered / unavailable`r`n"
    }

    nac := Calc_NacDosingText(wt)

    if scenario != 1 {
        out .= "Interpretation: NOMOGRAM NOT RELIABLE for this scenario.`r`n"
        if scenario = 2
            out .= "Reason: unknown or unreliable timing. Consider NAC when APAP is detectable or hepatic injury is present; discuss with poison center.`r`n"
        else if scenario = 3
            out .= "Reason: repeated/staggered ingestion. Rumack-Matthew nomogram does not apply; assess APAP level, AST/ALT, INR, symptoms, and dose history.`r`n"
        else if scenario = 4
            out .= "Reason: extended-release/delayed absorption may require repeat APAP levels even if the first level is below the line.`r`n"
        else
            out .= "Reason: >24 hours after ingestion. Use labs/clinical status and toxicology guidance; NAC may still be beneficial in liver injury.`r`n"
        out .= "Disposition: DISCUSS WITH POISON CENTER / TREATMENT TEAM. Do not use this as a binary yes/no tool.`r`n`r`n" nac
        result.Value := out
        return
    }

    if !IsNumber(hrsText) or Number(hrsText) <= 0 {
        MsgBox "Enter time since ingestion in hours, or select a non-nomogram scenario.", "Acetaminophen", "Icon!"
        return
    }
    hrs := Number(hrsText)

    if hrs < 4 {
        out .= "Interpretation: LEVEL BEFORE 4 HOURS CANNOT BE PLOTTED.`r`n"
        out .= "Action: obtain a 4-hour level or later. If treatment would be delayed beyond 8 hours or history is concerning, consider empiric NAC per protocol.`r`n`r`n" nac
    } else if hrs > 24 {
        out .= "Interpretation: Nomogram is generally limited to 4-24 hours after a single acute ingestion.`r`n"
        out .= "Action: discuss with poison center; assess APAP level, AST/ALT, INR, creatinine, acid-base status, and symptoms.`r`n`r`n" nac
    } else if apapMcgMl = "" {
        out .= "Interpretation: APAP level unavailable.`r`n"
        out .= "Action: if >8 hours after ingestion or level will be delayed, start NAC while awaiting results per protocol.`r`n`r`n" nac
    } else {
        threshold := 150 * (0.5 ** ((hrs - 4) / 4))
        out .= "Nomogram treatment-line threshold at " Round(hrs,2) " hr: " Round(threshold,1) " mcg/mL`r`n"
        if apapMcgMl >= threshold {
            out .= "Assessment: NAC INDICATED / above treatment line.`r`n"
        } else {
            out .= "Assessment: below treatment line for a reliable single acute ingestion; confirm timing, formulation, coingestions, and repeat level needs.`r`n"
        }
        out .= "Safety checks: consider NAC if time is uncertain, delayed absorption, repeated ingestion, detectable APAP with unknown time, liver injury, or toxicology recommends treatment.`r`n`r`n" nac
    }
    result.Value := out
}

Calc_ConvertApapToMcgMl(value, unit) {
    switch unit {
        case "mcg/mL", "mg/L": return value
        case "mg/dL": return value * 10
        case "micromol/L": return value / 6.62
        default: return value
    }
}

Calc_NacDosingText(wt) {
    load := 150 * wt
    bag2 := 50 * wt
    bag3 := 100 * wt
    oralLoad := 140 * wt
    oralMaint := 70 * wt
    return "NAC DOSING SUMMARY (verify product/concentration and local protocol):`r`n"
        . "IV 21-hour regimen: 150 mg/kg loading dose = " Round(load) " mg over 1 hr; then 50 mg/kg = " Round(bag2) " mg over 4 hr; then 100 mg/kg = " Round(bag3) " mg over 16 hr. Recheck APAP and liver tests before stopping.`r`n"
        . "Oral regimen often cited: 140 mg/kg loading dose = " Round(oralLoad) " mg, then 70 mg/kg = " Round(oralMaint) " mg every 4 hr for 17 doses. Verify whether oral NAC is available/appropriate.`r`n"
}

; -------------------------------------------------------------------------------------------------
; ANTICOAGULANT REVERSAL AGENTS — dynamic anticoagulant-specific support
; -------------------------------------------------------------------------------------------------
Calc_OpenAnticoagReversal() {
    g := Gui("+Resize", "Anticoagulant Reversal Agents")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w760 cRed", "Structured summary only. Reversal decisions are high-stakes; verify indication, agent, timing, renal function, labs, and institutional protocol.").SetFont("s10 bold")

    g.Add("Text", "xm y+10", "Anticoagulant:")
    anticoag := g.Add("DropDownList", "x185 yp w310", ["Warfarin / VKA", "Apixaban/Rivaroxaban/Edoxaban", "Dabigatran", "Unfractionated heparin", "LMWH/enoxaparin", "Unknown anticoagulant"])
    anticoag.Value := 1
    g.Add("Text", "xm y+8", "Bleeding/indication:")
    bleedType := g.Add("DropDownList", "x185 yp w360", ["Life-threatening hemorrhage / internal bleeding", "Urgent procedure or high-risk bleed", "Nonmajor bleeding / lab reversal discussion"])
    bleedType.Value := 1

    wtLbl := g.Add("Text", "xm y+8", "Weight (kg):")
    wt := g.Add("Edit", "x185 yp w90")
    inrLbl := g.Add("Text", "xm y+8", "INR:")
    inr := g.Add("Edit", "x185 yp w90")
    xaDrugLbl := g.Add("Text", "xm y+8", "Xa inhibitor:")
    xaDrug := g.Add("DropDownList", "x185 yp w180", ["Apixaban", "Rivaroxaban", "Edoxaban"])
    xaDrug.Value := 1
    xaDoseLbl := g.Add("Text", "xm y+8", "Last Xa dose (mg):")
    xaDose := g.Add("Edit", "x185 yp w90")
    xaHoursLbl := g.Add("Text", "xm y+8", "Hours since last dose:")
    xaHours := g.Add("Edit", "x185 yp w90")
    hepUnitsLbl := g.Add("Text", "xm y+8", "UFH units to neutralize:")
    hepUnits := g.Add("Edit", "x185 yp w90")
    hepMinLbl := g.Add("Text", "xm y+8", "Minutes since UFH:")
    hepMin := g.Add("Edit", "x185 yp w90")
    lmwhDoseLbl := g.Add("Text", "xm y+8", "Last LMWH dose (mg):")
    lmwhDose := g.Add("Edit", "x185 yp w90")

    helpText := g.Add("Text", "xm y+8 w760 cGray", "Required fields change based on the selected anticoagulant. For major hemorrhage/internal bleeding, output includes a reversal-dose pathway plus caveats.")
    result := g.Add("Edit", "xm y+10 w800 h330 ReadOnly -Wrap")
    ctrls := [wtLbl, wt, inrLbl, inr, xaDrugLbl, xaDrug, xaDoseLbl, xaDose, xaHoursLbl, xaHours, hepUnitsLbl, hepUnits, hepMinLbl, hepMin, lmwhDoseLbl, lmwhDose]
    anticoag.OnEvent("Change", (*) => Calc_UpdateAnticoagFields(anticoag, ctrls))
    Calc_UpdateAnticoagFields(anticoag, ctrls)
    g.Add("Button", "xm y+10 w120 Default", "Build Summary").OnEvent("Click", (*) => SafeRun(Calc_RunAnticoagReversal, anticoag, bleedType, wt, inr, xaDrug, xaDose, xaHours, hepUnits, hepMin, lmwhDose, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    parsed := PBind_CurrentParsed()
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_Set(inr, PBind_Lab("inr"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wt.Value, "INR", inr.Value)))
    Workbench29_Show(g,"w840")
}

Calc_UpdateAnticoagFields(anticoag, ctrls) {
    for c in ctrls
        c.Visible := false
    ; indices: 1 wtLbl 2 wt 3 inrLbl 4 inr 5 xaDrugLbl 6 xaDrug 7 xaDoseLbl 8 xaDose 9 xaHoursLbl 10 xaHours 11 hepUnitsLbl 12 hepUnits 13 hepMinLbl 14 hepMin 15 lmwhDoseLbl 16 lmwhDose
    idx := anticoag.Value
    if idx = 1 { ; warfarin
        for i in [1,2,3,4]
            ctrls[i].Visible := true
    } else if idx = 2 { ; Xa
        for i in [1,2,5,6,7,8,9,10]
            ctrls[i].Visible := true
    } else if idx = 3 { ; dabigatran
        ; no calculation fields required; weight optional for documentation not needed
    } else if idx = 4 { ; UFH
        for i in [11,12,13,14]
            ctrls[i].Visible := true
    } else if idx = 5 { ; LMWH
        for i in [15,16,9,10]
            ctrls[i].Visible := true
    } else {
        for i in [1,2]
            ctrls[i].Visible := true
    }
}

Calc_RunAnticoagReversal(anticoag, bleedType, wtCtrl, inrCtrl, xaDrug, xaDoseCtrl, xaHoursCtrl, hepUnitsCtrl, hepMinCtrl, lmwhDoseCtrl, result) {
    idx := anticoag.Value
    wtTxt := Trim(wtCtrl.Value)
    majorBleed := InStr(bleedType.Text, "Life-threatening") > 0 or InStr(bleedType.Text, "internal") > 0
    out := "ANTICOAGULANT REVERSAL STRUCTURED SUMMARY`r`n"
    out .= "Input anticoagulant: " anticoag.Text ". Indication: " bleedType.Text ".`r`n"
    out .= "Verify indication, last dose, renal/hepatic function, pregnancy status, thrombotic risk, anti-Xa/dTT/aPTT/INR where appropriate, product availability, and institutional protocol.`r`n`r`n"
    out .= "Hemorrhage/internal bleeding output: " (majorBleed ? "Treat as major/life-threatening bleeding until team rules otherwise; activate local hemorrhage/neurosurgery/GI/IR/stroke pathway as applicable." : "Nonmajor or procedural reversal: avoid automatically applying major-bleed doses without team/protocol review.") "`r`n`r`n"

    if idx = 1 {
        if !IsNumber(wtTxt) or !IsNumber(Trim(inrCtrl.Value)) {
            MsgBox "Enter weight and INR for warfarin/VKA reversal.", "Reversal", "Icon!"
            return
        }
        wt := Number(wtTxt), inr := Number(Trim(inrCtrl.Value))
        if inr < 2 {
            out .= "Warfarin/VKA:`r`n- INR <2: labeled KCentra INR-banded dosing is not generated. Consider vitamin K/supportive care or protocol-specific PCC only if bleeding severity warrants.`r`n"
        } else {
            unitsKg := inr < 4 ? 25 : inr <= 6 ? 35 : 50
            maxDose := inr < 4 ? 2500 : inr <= 6 ? 3500 : 5000
            dose := Min(unitsKg * wt, maxDose)
            out .= "Warfarin/VKA major bleeding dose pathway:`r`n"
            out .= "- KCentra 4F-PCC: " unitsKg " units factor IX/kg x " Round(wt,1) " kg = " Round(unitsKg*wt) " units; cap " maxDose " units -> " Round(dose) " units.`r`n"
            out .= "- Give vitamin K concurrently for sustained reversal; for life-threatening bleeding, protocols commonly use phytonadione 10 mg IV once, infused per policy, with repeat INR/clinical reassessment.`r`n"
            out .= "- INR correction does not guarantee hemostasis; monitor for thrombosis and recurrent bleeding.`r`n"
        }
    } else if idx = 2 {
        if majorBleed and (!IsNumber(wtTxt) or Number(wtTxt) <= 0) {
            MsgBox "Enter weight for PCC estimate in Xa inhibitor major bleeding.", "Reversal", "Icon!"
            return
        }
        out .= "Factor Xa inhibitor (" xaDrug.Text "):`r`n"
        out .= "- Andexanet alfa is not included in this tool because it was intentionally removed from your build.`r`n"
        if IsNumber(Trim(xaHoursCtrl.Value))
            out .= "- Last-dose timing entered: " Round(Number(Trim(xaHoursCtrl.Value)),1) " hr ago. Recent ingestion, renal dysfunction, or unknown timing increases concern for clinically relevant drug level.`r`n"
        if IsNumber(Trim(xaDoseCtrl.Value))
            out .= "- Last dose entered: " Trim(xaDoseCtrl.Value) " mg.`r`n"
        if majorBleed {
            wt := Number(wtTxt)
            low := Round(Min(25*wt, 2500)), high := Round(Min(50*wt, 5000))
            out .= "- Major hemorrhage/internal bleeding PCC discussion dose: many protocols use 4F-PCC 25-50 units/kg. For " Round(wt,1) " kg: " low "-" high " units using caps 2500-5000 units. Select exact dose by institutional protocol/bleed site/thrombotic risk.`r`n"
        } else {
            out .= "- Nonmajor bleeding: hold anticoagulant, local hemostasis/supportive care, check renal function and calibrated anti-Xa if available; reserve PCC for severe or high-risk bleeding per team.`r`n"
        }
    } else if idx = 3 {
        out .= "Dabigatran:`r`n- Idarucizumab dose for life-threatening/uncontrolled bleeding or urgent procedure: 5 g IV total, supplied as two 2.5 g/50 mL vials given consecutively.`r`n- Obtain thrombin time/dilute thrombin time or aPTT per local availability, renal function, and time since dose. Rebound anticoagulant effect can occur; reassess if bleeding persists.`r`n"
    } else if idx = 4 {
        if !IsNumber(Trim(hepUnitsCtrl.Value)) {
            MsgBox "Enter UFH units to neutralize.", "Protamine", "Icon!"
            return
        }
        units := Number(Trim(hepUnitsCtrl.Value))
        if units <= 0 {
            MsgBox "Enter a positive UFH dose.", "Protamine", "Icon!"
            return
        }
        if !IsNumber(Trim(hepMinCtrl.Value)) or Number(Trim(hepMinCtrl.Value)) < 0 {
            MsgBox "Enter nonnegative minutes since the UFH dose.", "Protamine", "Icon!"
            return
        }
        mins := Number(Trim(hepMinCtrl.Value))
        factor := mins <= 30 ? 1.0 : mins <= 60 ? 0.5 : mins <= 120 ? 0.375 : 0.25
        dose := Min((units / 100) * factor, 50)
        out .= "Unfractionated heparin:`r`n- Protamine estimate for hemorrhage/internal bleeding: " Round(dose,1) " mg IV slowly (cap 50 mg/dose) based on " units " units UFH and " mins " minutes elapsed.`r`n- Monitor for hypotension, bradycardia, pulmonary hypertension, and anaphylactoid reactions; repeat aPTT/anti-Xa per protocol.`r`n"
    } else if idx = 5 {
        if !IsNumber(Trim(lmwhDoseCtrl.Value)) {
            MsgBox "Enter last LMWH/enoxaparin dose in mg.", "Protamine", "Icon!"
            return
        }
        doseMg := Number(Trim(lmwhDoseCtrl.Value))
        if doseMg <= 0 {
            MsgBox "Enter a positive LMWH dose.", "Protamine", "Icon!"
            return
        }
        if !IsNumber(Trim(xaHoursCtrl.Value)) or Number(Trim(xaHoursCtrl.Value)) < 0 {
            MsgBox "Enter nonnegative hours since the LMWH dose.", "Protamine", "Icon!"
            return
        }
        hrs := Number(Trim(xaHoursCtrl.Value))
        prot := hrs <= 8 ? Min(doseMg, 50) : hrs <= 12 ? Min(doseMg*0.5, 50) : 0
        out .= "LMWH/enoxaparin:`r`n"
        if prot > 0
            out .= "- Protamine partial-reversal estimate: " Round(prot,1) " mg IV slowly (max 50 mg first dose) based on last enoxaparin dose " doseMg " mg and " hrs " hr elapsed. Anti-Xa reversal is incomplete; repeat smaller dose may be considered by protocol if bleeding continues.`r`n"
        else
            out .= "- >12 hr or timing unclear: protamine benefit may be limited; use anti-Xa/timing/renal function and local protocol. Reversal is incomplete.`r`n"
    } else {
        out .= "Unknown anticoagulant:`r`n- Do not guess a reversal product. Obtain medication history/pharmacy fill/MAR, INR, aPTT, thrombin time if dabigatran possible, anti-Xa if heparin/Xa inhibitor possible, renal function, CBC, fibrinogen, and consult hematology/toxicology/pharmacy urgently.`r`n"
    }
    out .= "`r`nSupportive care for major hemorrhage/internal bleeding: stop anticoagulant/antiplatelets when appropriate, source control, blood products per massive hemorrhage protocol when needed, BP/ICP/airway management by bleed site, and re-anticoagulation planning after hemostasis.`r`n"
    result.Value := out
}

; -------------------------------------------------------------------------------------------------
; TNK ELIGIBILITY / DOSE FOR ACUTE ISCHEMIC STROKE — checklist support
; -------------------------------------------------------------------------------------------------
Calc_OpenTnkStroke() {
    g := Gui("+Resize", "TNK Stroke Eligibility / Dose Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w760 cRed", "Time-critical checklist aid only. Do not treat this as a green light. Confirm imaging, diagnosis, contraindications, and institutional stroke protocol.").SetFont("s10 bold")
    g.Add("Text", "xm y+10", "Weight (kg):")
    wt := g.Add("Edit", "x260 yp w90")
    g.Add("Text", "xm y+8", "Last-known-well clock time:")
    lkw := g.Add("Edit", "x260 yp w90")
    g.Add("Text", "x+8 yp cGray", "HHMM or HH:MM, e.g. 1800")
    g.Add("Text", "xm y+8", "Age >=18?")
    adult := g.Add("DropDownList", "x260 yp w130", ["Yes", "No"])
    adult.Value := 1
    g.Add("Text", "xm y+8", "Disabling ischemic stroke deficit?")
    deficit := g.Add("DropDownList", "x260 yp w130", ["Yes", "No/unclear"])
    deficit.Value := 1
    g.Add("Text", "xm y+8", "CT/MRI excludes hemorrhage?")
    imaging := g.Add("DropDownList", "x260 yp w130", ["Yes", "No/unknown"])
    imaging.Value := 2
    g.Add("Text", "xm y+8", "BP <=185/110 or controlled before lytic?")
    bp := g.Add("DropDownList", "x260 yp w130", ["Yes", "No/unknown"])
    bp.Value := 2
    g.Add("Text", "xm y+8", "Glucose 50-400 mg/dL?")
    gluc := g.Add("DropDownList", "x260 yp w130", ["Yes", "No/unknown"])
    gluc.Value := 2
    g.Add("Text", "xm y+8", "Anticoagulant/coagulopathy concern?")
    anticoag := g.Add("DropDownList", "x260 yp w170", ["No known concern", "Yes/unknown"])
    anticoag.Value := 2
    g.Add("Text", "xm y+8", "Recent major bleed/surgery/head trauma/prior ICH?")
    bleed := g.Add("DropDownList", "x260 yp w170", ["No known concern", "Yes/unknown"])
    bleed.Value := 2
    result := g.Add("Edit", "xm y+14 w800 h270 ReadOnly -Wrap")
    g.Add("Button", "xm y+10 w120 Default", "Assess").OnEvent("Click", (*) => SafeRun(Calc_RunTnkStroke, wt, lkw, adult, deficit, imaging, bp, gluc, anticoag, bleed, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    parsed := PBind_CurrentParsed()
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    ageValue := PBind_Value(parsed, "age")
    if IsNumber(ageValue)
        adult.Choose(Number(ageValue) >= 18 ? "Yes" : "No")
    glucoseValue := PBind_Lab("glucose")
    if IsNumber(glucoseValue)
        gluc.Choose(Number(glucoseValue) >= 50 && Number(glucoseValue) <= 400 ? "Yes" : "No/unknown")
    sys := PBind_Lab("systolicBP"), dia := PBind_Lab("diastolicBP")
    if IsNumber(sys) && IsNumber(dia)
        bp.Choose(Number(sys) <= 185 && Number(dia) <= 110 ? "Yes" : "No/unknown")
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wt.Value, "Age", ageValue, "Glucose", glucoseValue)))
    Workbench29_Show(g,"w840")
}

Calc_RunTnkStroke(wtCtrl, lkwCtrl, adult, deficit, imaging, bp, gluc, anticoag, bleed, result) {
    flags := []
    discuss := []
    if adult.Value != 1
        flags.Push("not adult")
    if deficit.Value != 1
        discuss.Push("deficit not clearly disabling ischemic stroke")
    if imaging.Value != 1
        flags.Push("hemorrhage not excluded by imaging")
    if bp.Value != 1
        flags.Push("BP not documented controlled to <=185/110")
    if gluc.Value != 1
        discuss.Push("glucose not confirmed in usual protocol range")
    if anticoag.Value != 1
        flags.Push("anticoagulant/coagulopathy concern")
    if bleed.Value != 1
        flags.Push("recent major bleed/surgery/head trauma/prior ICH concern")

    lkwInfo := Calc_TnkElapsedFromClock(Trim(lkwCtrl.Value))
    if !lkwInfo.ok
        flags.Push(lkwInfo.error)
    else if lkwInfo.hours > 4.5
        flags.Push("outside typical 4.5-hour IV thrombolysis window")

    wtTxt := Trim(wtCtrl.Value)
    doseText := "TNK dose not calculated because weight missing."
    if IsNumber(wtTxt) and Number(wtTxt) > 0 {
        dose := Min(Number(wtTxt) * 0.25, 25)
        doseText := "TNK dose if team proceeds: 0.25 mg/kg x " Round(Number(wtTxt),1) " kg = " Round(Number(wtTxt)*0.25,2) " mg; max 25 mg -> " Round(dose,2) " mg IV bolus."
    }
    out := "TNK STROKE ELIGIBILITY / DOSE SUMMARY`r`nNot a green light. Confirm against current stroke protocol and attending/stroke neurologist.`r`n`r`n"
    if lkwInfo.ok
        out .= "Time since last-known-well: " Round(lkwInfo.hours,2) " hr based on entered time " lkwInfo.display " and current system time. Verify date/time history with witness/team.`r`n`r`n"
    else
        out .= "Time since last-known-well: not calculated (" lkwInfo.error ").`r`n`r`n"
    if flags.Length > 0 {
        out .= "Status: NOT ELIGIBLE / DO NOT PROCEED WITHOUT TEAM RESOLUTION`r`nBlocking issues:`r`n"
        for f in flags
            out .= "- " f "`r`n"
    } else if discuss.Length > 0 {
        out .= "Status: DISCUSS WITH TEAM`r`nIssues needing clarification:`r`n"
        for f in discuss
            out .= "- " f "`r`n"
    } else {
        out .= "Status: POTENTIALLY ELIGIBLE BY THIS LIMITED CHECKLIST — still verify full inclusion/exclusion criteria, imaging, labs, consent/process, and protocol.`r`n"
    }
    out .= "`r`n" doseText "`r`n"
    out .= "Post-lytic reminders: avoid antithrombotics/invasive lines per protocol, monitor BP/neuro status, obtain follow-up imaging per stroke pathway.`r`n"
    result.Value := out
}

Calc_TnkElapsedFromClock(text) {
    text := Trim(text)
    if text = ""
        return {ok:false, error:"last-known-well clock time missing"}
    cleaned := StrReplace(StrReplace(text, ":", ""), " ", "")
    if !RegExMatch(cleaned, "^\d{3,4}$")
        return {ok:false, error:"enter LKW as HHMM or HH:MM, e.g. 1800"}
    if StrLen(cleaned) = 3
        cleaned := "0" cleaned
    hh := Number(SubStr(cleaned, 1, 2)), mm := Number(SubStr(cleaned, 3, 2))
    if hh < 0 or hh > 23 or mm < 0 or mm > 59
        return {ok:false, error:"LKW clock time is outside valid 0000-2359 range"}
    lkwDt := SubStr(A_Now, 1, 8) Format("{:02}{:02}00", hh, mm)
    mins := DateDiff(A_Now, lkwDt, "Minutes")
    if mins < 0 {
        lkwDt := DateAdd(lkwDt, -1, "Days")
        mins := DateDiff(A_Now, lkwDt, "Minutes")
    }
    return {ok:true, hours: mins / 60.0, display: Format("{:02}:{:02}", hh, mm)}
}

; -------------------------------------------------------------------------------------------------
; RSI DOSING SUPPORT
; -------------------------------------------------------------------------------------------------

; Calc_OpenRsiDosing moved to the patient-hub / RSI redesign section below (see PATIENT HUB REBUILD).

; Calc_RunRsiDosing moved to the patient-hub / RSI redesign section below (see PATIENT HUB REBUILD).
; -------------------------------------------------------------------------------------------------
; RABIES PEP DECISION SUPPORT
; -------------------------------------------------------------------------------------------------
Calc_OpenRabiesPep() {
    g := Gui("+Resize", "Rabies PEP Decision Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w740 cRed", "Rabies PEP decisions are public-health decisions. Contact local/state health department for risk assessment, especially wildlife, bats, unavailable animals, or unusual exposures.").SetFont("s10 bold")
    g.Add("Text", "xm y+10", "Weight (kg):")
    wt := g.Add("Edit", "x220 yp w90")
    g.Add("Text", "xm y+8", "Exposure type:")
    exposure := g.Add("DropDownList", "x220 yp w260", ["Bite / saliva to open wound or mucosa", "Bat exposure possible", "Scratch only / uncertain saliva", "No exposure identified"])
    exposure.Value := 1
    g.Add("Text", "xm y+8", "Animal:")
    animal := g.Add("DropDownList", "x220 yp w260", ["Dog/cat/ferret", "Bat", "Raccoon/skunk/fox/other wild carnivore", "Livestock/other mammal", "Small rodent/rabbit/hare", "Unknown"])
    animal.Value := 1
    g.Add("Text", "xm y+8", "Animal available for observation/testing?")
    avail := g.Add("DropDownList", "x220 yp w160", ["Yes", "No/unknown"])
    avail.Value := 2
    g.Add("Text", "xm y+8", "Patient previously vaccinated/PrEP?")
    prev := g.Add("DropDownList", "x220 yp w160", ["No/unknown", "Yes"])
    prev.Value := 1
    g.Add("Text", "xm y+8", "Immunocompromised?")
    immuno := g.Add("DropDownList", "x220 yp w160", ["No/unknown", "Yes"])
    immuno.Value := 1
    result := g.Add("Edit", "xm y+14 w780 h300 ReadOnly -Wrap")
    g.Add("Button", "xm y+10 w120 Default", "Build Plan").OnEvent("Click", (*) => SafeRun(Calc_RunRabiesPep, wt, exposure, animal, avail, prev, immuno, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    Workbench29_Show(g,"w820")
}

Calc_RunRabiesPep(wtCtrl, exposure, animal, avail, prev, immuno, result) {
    out := "RABIES PEP DECISION SUPPORT`r`nContact public health for risk assessment; this is not a stand-alone decision rule.`r`n`r`n"
    if exposure.Value = 4 {
        out .= "Exposure: no qualifying exposure identified by selection. PEP usually not indicated, but verify history and public health guidance if uncertain.`r`n"
        result.Value := out
        return
    }
    highRisk := (animal.Value = 2 or animal.Value = 3 or animal.Value = 6 or exposure.Value = 2)
    observePossible := (animal.Value = 1 and avail.Value = 1)
    if observePossible {
        out .= "Risk branch: dog/cat/ferret available. Many protocols allow 10-day observation instead of immediate PEP if animal remains healthy; coordinate with animal control/public health.`r`n"
    } else if animal.Value = 5 {
        out .= "Risk branch: small rodents/rabbits/hares rarely require PEP unless unusual circumstances; discuss with public health if bite was severe, animal abnormal, or local concern.`r`n"
    } else if highRisk {
        out .= "Risk branch: higher concern (bat/wild carnivore/unknown/unavailable). PEP often considered unless testing/assessment rules out risk. Contact public health urgently.`r`n"
    } else {
        out .= "Risk branch: requires case-specific assessment based on local epidemiology, animal behavior, and availability for testing/observation.`r`n"
    }
    if prev.Value = 2 {
        out .= "`r`nPreviously vaccinated/PrEP:`r`n- HRIG: do NOT administer.`r`n- Vaccine: 1 mL IM on days 0 and 3 if PEP indicated.`r`n"
    } else {
        out .= "`r`nNot previously vaccinated / unknown:`r`n- Wound care: immediate thorough cleansing/irrigation.`r`n- Vaccine: 1 mL IM days 0, 3, 7, 14 if PEP indicated.`r`n"
        if immuno.Value = 2
            out .= "- Immunocompromised: add day 28 vaccine dose and arrange serologic confirmation per guidance.`r`n"
        wtTxt := Trim(wtCtrl.Value)
        if IsNumber(wtTxt) and Number(wtTxt) > 0 {
            hrig := 20 * Number(wtTxt)
            out .= "- HRIG: 20 IU/kg x " Round(Number(wtTxt),1) " kg = " Round(hrig) " IU once at start. Infiltrate into/around wound(s) if feasible; remainder IM distant from vaccine site. Do not exceed dose.`r`n"
        } else {
            out .= "- HRIG: 20 IU/kg once at start if PEP indicated; enter weight to calculate IU.`r`n"
        }
    }
    out .= "`r`nAdministration cautions: never give HRIG in the same syringe or same anatomical site as first vaccine dose; do not use gluteal site for vaccine.`r`n"
    result.Value := out
}

^#r:: Phuckit_RelaunchSafely()

Phuckit_RelaunchSafely(*) {
    root := RegExReplace(A_ScriptDir, "\\App$", "")
    relaunch := root "\RELAUNCH_PHUCKIT.ps1"
    if !FileExist(relaunch) {
        MsgBox "The safe relaunch wrapper was not found:`n`n" relaunch, "PhUCKIT Reload", "Icon!"
        return
    }
    Run('powershell.exe -NoProfile -ExecutionPolicy Bypass -File "' relaunch '"')
    ExitApp()
}

; =================================================================================================
;  LAUNCH AT WINDOWS LOGIN
; =================================================================================================

EnsureLocalSettingsDir() {
    global LocalSettingsDir
    try {
        if !DirExist(LocalSettingsDir)
            DirCreate LocalSettingsDir
    }
}

GetLaunchAtLoginSetting() {
    ; Portable/OneDrive note:
    ; This setting is intentionally stored in the local Windows user profile, not beside the app.
    ; Data/config CSVs stay portable in A_ScriptDir, but Startup registration is per-computer.
    global AppSettingsIniPath
    EnsureLocalSettingsDir()
    try
        return IniRead(AppSettingsIniPath, "ThisComputer", "LaunchAtLogin", "1") = "1"
    catch
        return true
}

SetLaunchAtLoginSetting(enabled) {
    global AppSettingsIniPath
    EnsureLocalSettingsDir()
    try {
        IniWrite(enabled ? "1" : "0", AppSettingsIniPath, "ThisComputer", "LaunchAtLogin")
        IniWrite(A_ScriptFullPath, AppSettingsIniPath, "ThisComputer", "ProgramPath")
        IniWrite(A_ComputerName, AppSettingsIniPath, "ThisComputer", "ComputerName")
    }
}

GetLaunchTargetInfo() {
    root := RegExReplace(A_ScriptDir, "\\App$", "")
    target := root "\START_PHUCKIT.cmd"
    return { target: target, args: "", icon: A_ScriptFullPath, workingDir: root }
}

StartupShortcutLooksCurrent() {
    global StartupShortcutPath
    if !FileExist(StartupShortcutPath)
        return false
    ; Windows shortcut parsing is intentionally avoided for portability/reliability.
    ; Recreating the shortcut on each launch is safe and repairs OneDrive path changes.
    return false
}

EnsureLaunchAtLogin(*) {
    global CombinedSmoke
    if CombinedSmoke
        return false
    if !GetLaunchAtLoginSetting()
        return false
    return InstallStartupShortcut(false)
}

InstallStartupShortcut(showMessage := true) {
    global StartupShortcutPath
    try {
        if !DirExist(A_Startup) {
            if showMessage
                MsgBox "Windows Startup folder was not found for this user.`r`n`r`nExpected:`r`n" A_Startup, "Launch at Login", "Icon!"
            return false
        }

        info := GetLaunchTargetInfo()
        if info.target = "" or !FileExist(info.target) {
            if showMessage
                MsgBox "AutoHotkey executable path could not be determined. Reinstall AutoHotkey v2 or compile this app, then try again.", "Launch at Login", "Icon!"
            return false
        }

        try FileDelete StartupShortcutPath
        workingDir := info.HasOwnProp("workingDir") ? info.workingDir : A_ScriptDir
        FileCreateShortcut(info.target, StartupShortcutPath, workingDir, info.args, "Launch PhUCKIT from its current OneDrive/local folder at Windows login", info.icon)
        SetLaunchAtLoginSetting(true)
        if showMessage
            MsgBox "Launch at login is enabled for this Windows user/computer.`r`n`r`nShortcut created:`r`n" StartupShortcutPath "`r`n`r`nTarget:`r`n" A_ScriptFullPath "`r`n`r`nBecause the app is portable, repeat this once on each computer that should auto-launch it.", "Launch at Login", "Iconi"
        return true
    } catch as err {
        if showMessage
            MsgBox "Could not create the Startup shortcut.`r`n`r`n" err.Message, "Launch at Login", "Icon!"
        return false
    }
}

EnableLaunchAtLogin(*) {
    ok := InstallStartupShortcut(true)
    InitTray()
    return ok
}

DisableLaunchAtLogin(*) {
    global StartupShortcutPath
    SetLaunchAtLoginSetting(false)
    try {
        if FileExist(StartupShortcutPath)
            FileDelete StartupShortcutPath
        MsgBox "Launch at login is disabled for this Windows user/computer only.`r`n`r`nPortable app files in OneDrive were not changed.", "Launch at Login", "Iconi"
    } catch as err {
        MsgBox "Launch-at-login setting was disabled locally, but the Startup shortcut could not be deleted.`r`n`r`n" err.Message, "Launch at Login", "Icon!"
    }
    InitTray()
}

OpenStartupFolder(*) {
    try Run A_Startup
}

OpenAppFolder(*) {
    try Run A_ScriptDir
}

ShowPortableInstallInfo(*) {
    MsgBox "PhUCKIT portable / OneDrive setup:`r`n`r`n- Keep this app and its CSV databases in the same OneDrive folder.`r`n- Data files sync across computers because they are stored beside the app.`r`n- Windows Startup registration is local to each computer and is stored in that computer's Startup folder.`r`n- Run the app once on each computer and choose Launch at Login: On if it is not already enabled.`r`n`r`nCurrent app path:`r`n" A_ScriptFullPath "`r`n`r`nCurrent local settings:`r`n" AppSettingsIniPath "`r`n`r`nShared master path:`r`n" (GetSharedMasterPath() != "" ? GetSharedMasterPath() : "Not set"), "Portable Setup", "Iconi"
}


; =================================================================================================
;  ADMIN UPDATE MANAGER — shared-drive master, local OneDrive user data preserved
; =================================================================================================

GetSharedMasterPath() {
    global AppSettingsIniPath
    EnsureLocalSettingsDir()
    try
        return IniRead(AppSettingsIniPath, "AdminUpdate", "SharedMasterPath", "")
    catch
        return ""
}

SetSharedMasterPath(path) {
    global AppSettingsIniPath
    EnsureLocalSettingsDir()
    path := Trim(path)
    try IniWrite(path, AppSettingsIniPath, "AdminUpdate", "SharedMasterPath")
}

ChooseSharedMasterPath(*) {
    current := GetSharedMasterPath()
    selected := DirSelect(current != "" ? current : A_ScriptDir, 3, "Select the shared/admin master folder for PhUCKIT")
    if selected = ""
        return
    SetSharedMasterPath(selected)
    MsgBox "Shared master path saved:`r`n`r`n" selected, "Admin Updates", "Iconi"
}

OpenSharedMasterFolder(*) {
    path := GetSharedMasterPath()
    if path = "" {
        ChooseSharedMasterPath()
        path := GetSharedMasterPath()
    }
    if path != "" and DirExist(path)
        Run path
    else
        MsgBox "Shared master path is not set or cannot be reached.", "Admin Updates", "Icon!"
}

GetSharedVersion(masterPath) {
    vfile := masterPath "\version.txt"
    if FileExist(vfile) {
        try return Trim(FileRead(vfile, "UTF-8"))
    }
    script := FindSharedMasterScript(masterPath)
    if script != "" {
        try return "file modified " FormatTime(FileGetTime(script, "M"), "yyyy-MM-dd HH:mm")
    }
    return "Unknown"
}

FindSharedMasterScript(masterPath) {
    global AppFileStem
    if masterPath = "" or !DirExist(masterPath)
        return ""
    candidates := [ masterPath "\" AppFileStem ".ahk"
                  , masterPath "\Drug Information and Clinical Knowledgebase.ahk"
                  , masterPath "\Drug_Information_Clinical_Knowledgebase.ahk"
                  , masterPath "\Fast_Utility_for_Clinical_Knowledge.ahk" ]
    for candidate in candidates {
        if FileExist(candidate)
            return candidate
    }
    Loop Files masterPath "\*.ahk", "F" {
        if A_LoopFileFullPath != A_ScriptFullPath
            return A_LoopFileFullPath
    }
    return ""
}

CheckForAdminUpdates(*) {
    global AppDisplayName, AppVersion
    path := GetSharedMasterPath()
    if path = "" or !DirExist(path) {
        MsgBox "Shared master path is not set or cannot be reached.`r`n`r`nUse Set Shared Master Path first.", "Check for Updates", "Icon!"
        return
    }
    sharedScript := FindSharedMasterScript(path)
    sharedVersion := GetSharedVersion(path)
    msg := AppDisplayName "`r`n`r`nLocal version:`r`n" AppVersion "`r`n`r`nShared version/source:`r`n" sharedVersion "`r`n`r`nShared script:`r`n" (sharedScript != "" ? sharedScript : "No .ahk script found")
    if sharedScript != "" {
        try {
            localTime := FileGetTime(A_ScriptFullPath, "M")
            sharedTime := FileGetTime(sharedScript, "M")
            msg .= "`r`n`r`nLocal modified: " FormatTime(localTime, "yyyy-MM-dd HH:mm")
            msg .= "`r`nShared modified: " FormatTime(sharedTime, "yyyy-MM-dd HH:mm")
            if sharedTime > localTime
                msg .= "`r`n`r`nAn update may be available."
            else
                msg .= "`r`n`r`nNo newer script file detected by modified time."
        }
    }
    MsgBox msg, "Check for Updates", "Iconi"
}

BackupUserDataNow(showMessage := true) {
    global AppSettingsIniPath, _rc2SettingsPath, QNP_DataPath, PhuckitUserDataRoot
    global PrimaryLinksCsvPath, OtherLinksCsvPath, CustomMenusCsvPath, AutoTextCsvPath
    global OsmolarityCsvPath, WorkflowMacrosCsvPath, VancoTrackerCsvPath
    global CriticalDripTrackerCsvPath, CriticalDripLibraryCsvPath, OpioidFactorsCsvPath
    global RemindersCsvPath, HandoffCsvPath, LogPath, ParsingDiagnosticsPath
    global QNP_ChangeRequestExportPath
    timestamp := FormatTime(, "yyyyMMdd_HHmmss")
    backupDir := PhuckitUserDataRoot "\backups\" FormatTime(, "yyyy-MM-dd_HHmmss")
    try {
        if !DirExist(PhuckitUserDataRoot "\backups")
            DirCreate PhuckitUserDataRoot "\backups"
        DirCreate backupDir "\program"
        DirCreate backupDir "\userdata"
        manifest := "PhUCKIT update backup`r`ncreated=" A_Now "`r`noldVersion=" AppVersion "`r`n"
        files := Map(
            "primary_links.csv", PrimaryLinksCsvPath,
            "other_links.csv", OtherLinksCsvPath,
            "custom_dropdown_menus.csv", CustomMenusCsvPath,
            "autotext_phrases.csv", AutoTextCsvPath,
            "osmolarity_library.csv", OsmolarityCsvPath,
            "workflow_tools.csv", WorkflowMacrosCsvPath,
            "vancomycin_tracker.csv", VancoTrackerCsvPath,
            "critical_drip_tracker.csv", CriticalDripTrackerCsvPath,
            "critical_drip_library.csv", CriticalDripLibraryCsvPath,
            "opioid_mme_factors.csv", OpioidFactorsCsvPath,
            "reminders.csv", RemindersCsvPath,
            "shift_handoff.csv", HandoffCsvPath,
            "quickmenu.log", LogPath,
            "quicknotes.txt", QNP_DataPath,
            "parsing_diagnostics.csv", ParsingDiagnosticsPath,
            "parsing_diagnostics.csv.previous", ParsingDiagnosticsPath ".previous",
            "change_requests.txt", QNP_ChangeRequestExportPath
        )
        for fileName, src in files {
            if FileExist(src) {
                FileCopy src, backupDir "\userdata\" fileName, true
                if !FileExist(backupDir "\userdata\" fileName)
                    throw Error("User-data backup copy failed: " fileName)
                manifest .= "userdata=" fileName "`r`n"
            }
        }
        if FileExist(_rc2SettingsPath) {
            FileCopy _rc2SettingsPath, backupDir "\userdata\rc2_user.ini", true
            if !FileExist(backupDir "\userdata\rc2_user.ini")
                throw Error("User-data backup copy failed: data\\rc2_user.ini")
            manifest .= "userdata=data\\rc2_user.ini`r`n"
        }
        if FileExist(AppSettingsIniPath) {
            FileCopy AppSettingsIniPath, backupDir "\userdata\local_settings.ini", true
            if !FileExist(backupDir "\userdata\local_settings.ini")
                throw Error("User-data backup copy failed: local_settings.ini")
            manifest .= "userdata=%AppData%\\Drug Information and Clinical Knowledgebase\\local_settings.ini`r`n"
        }
        FileAppend manifest, backupDir "\manifest.txt", "UTF-8"
        if !FileExist(backupDir "\manifest.txt")
            throw Error("Backup manifest could not be written.")
        if showMessage
            MsgBox "User data backup created:`r`n`r`n" backupDir, "Backup User Data", "Iconi"
        return backupDir
    } catch as err {
        if showMessage
            MsgBox "Backup failed:`r`n`r`n" err.Message, "Backup User Data", "Icon!"
        return ""
    }
}

UpdateAppFromSharedMaster(*) {
    global AppDisplayName, AppVersion, AppSettingsIniPath
    if A_IsCompiled {
        MsgBox "This running copy is compiled as an EXE. In-place EXE replacement while running is not supported by this updater.`r`n`r`nClose the app, then copy the new EXE from the shared/admin folder, or distribute updates through your packaging tool.", "Update from Shared Drive", "Icon!"
        return
    }
    path := GetSharedMasterPath()
    if path = "" or !DirExist(path) {
        ChooseSharedMasterPath()
        path := GetSharedMasterPath()
    }
    if path = "" or !DirExist(path) {
        MsgBox "Update cancelled. Shared master path is not set or cannot be reached.", "Update from Shared Drive", "Icon!"
        return
    }
    sharedScript := FindSharedMasterScript(path)
    if sharedScript = "" {
        MsgBox "No shared .ahk script was found in:`r`n`r`n" path, "Update from Shared Drive", "Icon!"
        return
    }
    if sharedScript = A_ScriptFullPath {
        MsgBox "The shared script and the running script are the same file. No update is needed.", "Update from Shared Drive", "Iconi"
        return
    }
    choice := MsgBox("Update " AppDisplayName " from the shared/admin master?`r`n`r`nProgram logic and calculators will be replaced with the admin version.`r`nUser CSVs, custom menus, auto text, tracker data, and local startup settings will be backed up and preserved.`r`n`r`nShared script:`r`n" sharedScript, "Update from Shared Drive", "YesNo Icon? Default2")
    if choice != "Yes"
        return
    backupDir := BackupUserDataNow(false)
    if backupDir = "" {
        MsgBox "Update stopped because user-data backup could not be created.", "Update from Shared Drive", "Icon!"
        return
    }
    try {
        scriptBackup := backupDir "\program\PhUCKIT.ahk"
        FileCopy A_ScriptFullPath, scriptBackup, true
        if !FileExist(scriptBackup)
            throw Error("Current program backup could not be verified.")
        tmp := A_ScriptFullPath ".update_tmp"
        FileCopy sharedScript, tmp, true
        if !FileExist(tmp) || FileGetSize(tmp) < 10000
            throw Error("Candidate update is missing or implausibly small.")
        FileMove tmp, A_ScriptFullPath, true
        if !FileExist(A_ScriptFullPath) || FileGetSize(A_ScriptFullPath) < 10000
            throw Error("Updated program could not be verified after replacement.")
        try IniWrite(GetSharedVersion(path), AppSettingsIniPath, "AdminUpdate", "LastInstalledSharedVersion")
        try IniWrite(A_Now, AppSettingsIniPath, "AdminUpdate", "LastUpdateTime")
        MsgBox "Update installed.`r`n`r`nUser data backup:`r`n" backupDir "`r`n`r`nProgram backup:`r`n" scriptBackup "`r`n`r`nThe app will reload now.", "Update Complete", "Iconi"
                Phuckit_RelaunchSafely()
    } catch as err {
        try {
            if IsSet(scriptBackup) && FileExist(scriptBackup)
                FileCopy scriptBackup, A_ScriptFullPath, true
        }
        MsgBox "Update failed:`r`n`r`n" err.Message "`r`n`r`nUser-data backup was created at:`r`n" backupDir, "Update from Shared Drive", "Icon!"
    }
}

; =================================================================================================
;  TRAY, LOGGING, AUTO-REFRESH, THEMES
; =================================================================================================

InitTray() {
    A_IconHidden := false
    iconPath := A_ScriptDir "\tray_icon.ico"
    if FileExist(iconPath)
        TraySetIcon(iconPath,, true)

    Tray := A_TrayMenu
    Tray.Delete()
    Tray.Add("Open Quick Menu",     (*) => ShowQuickMenu())
    Tray.Add("Settings && Database Management",  (*) => OpenManageLinksGui())
    Tray.Add("Open Notes",          (*) => QNP_Open())
    Tray.Add("Lab / Dose Reminders", (*) => SafeRun(Calc_OpenReminders))
    Tray.Add("Shift Handoff Builder", (*) => SafeRun(Calc_OpenHandoff))
    Tray.Add("Open Log File",       (*) => OpenLogFile())
    Tray.Add()
    if GetLaunchAtLoginSetting() {
        Tray.Add("Launch at Login on This PC: On", (*) => DisableLaunchAtLogin())
        Tray.Check("Launch at Login on This PC: On")
    } else {
        Tray.Add("Launch at Login on This PC: Off", (*) => EnableLaunchAtLogin())
    }
    Tray.Add("Repair Startup Shortcut", (*) => InstallStartupShortcut(true))
    Tray.Add("Open Startup Folder",  (*) => OpenStartupFolder())
    Tray.Add("Open App Folder",      (*) => OpenAppFolder())
    Tray.Add("Portable Setup Info", (*) => ShowPortableInstallInfo())
    if Splash_Enabled() {
        Tray.Add("Startup Splash: On", (*) => SafeRun(Splash_ToggleEnabled))
        Tray.Check("Startup Splash: On")
    } else {
        Tray.Add("Startup Splash: Off", (*) => SafeRun(Splash_ToggleEnabled))
    }
    Tray.Add("Show Splash Now", (*) => SafeRun(Splash_Show))
    Tray.Add("Run Setup Self-Check", (*) => SafeRun(Pkg_SelfCheck))
    if PopupCloser_IsEnabled() {
        Tray.Add("Notification Popup Closer: On", (*) => PopupCloser_Toggle())
        Tray.Check("Notification Popup Closer: On")
    } else {
        Tray.Add("Notification Popup Closer: Off", (*) => PopupCloser_Toggle())
    }
    Tray.Add("Patient Hub (current session)", (*) => SafeRun(Menu_OpenPatientHub))
    Tray.Add("Clear Patient Session", (*) => SafeRun(PCtx_ClearSession, true))
    Tray.Add()
    Tray.Add("Set Shared Master Path", (*) => ChooseSharedMasterPath())
    Tray.Add("Check for Updates", (*) => CheckForAdminUpdates())
    Tray.Add("Update from Shared Drive", (*) => UpdateAppFromSharedMaster())
    Tray.Add()
    Tray.Add("Reload Script",       (*) => Phuckit_RelaunchSafely())
    Tray.Add("Exit",                (*) => ExitApp())
}
InitTray()
PopupCloser_Refresh()

; -------------------------------------------------------------------------------------------------
; LOGGING
; -------------------------------------------------------------------------------------------------
global LogPath := PhuckitUserDataRoot "\quickmenu.log"
global ParsingDiagnosticsPath := PhuckitUserDataRoot "\parsing_diagnostics.csv"
global ParsingDiagnosticsMaxBytes := 2000000

Log(msg) {
    global LogPath
    try {
        timestamp := FormatTime(, "yyyy-MM-dd HH:mm:ss")
        entry     := "[" timestamp "] " msg "`r`n"
        if FileExist(LogPath) {
            f  := FileOpen(LogPath, "r")
            sz := f.Length
            f.Close()
            if sz > 100000 {
                if FileExist(LogPath ".bak")
                    FileDelete LogPath ".bak"
                FileMove LogPath, LogPath ".bak", true
            }
        }
        FileAppend entry, LogPath, "UTF-8"
    }
}

ParsingDiagnostics_Get(fields, key, fallback := "") {
    if IsObject(fields) && fields is Map && fields.Has(key)
        return fields[key]
    return fallback
}

ParsingDiagnostics_SafeToken(value, fallback := "unknown") {
    token := StrLower(Trim(String(value)))
    token := RegExReplace(token, "[^a-z0-9_.:-]+", "_")
    token := Trim(token, "_")
    if token = "" || StrLen(token) > 48
        return fallback
    return token
}

ParsingDiagnostics_Count(value) {
    try {
        n := Integer(value)
        return Max(0, Min(n, 9999))
    }
    return 0
}

ParsingDiagnostics_Log(eventCode, fields := 0) {
    global ParsingDiagnosticsPath, ParsingDiagnosticsMaxBytes, AppVersion
    try {
        eventCode := ParsingDiagnostics_SafeToken(eventCode, "parser_event")
        component := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "component", "parser"), "parser")
        screenType := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "screenType", "unknown"), "unknown")
        profile := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "profile", "unknown"), "unknown")
        quality := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "quality", "unknown"), "unknown")
        warningCode := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "warningCode", "none"), "none")
        detail := ParsingDiagnostics_SafeToken(ParsingDiagnostics_Get(fields, "detail", "none"), "none")
        labs := ParsingDiagnostics_Count(ParsingDiagnostics_Get(fields, "labs", 0))
        meds := ParsingDiagnostics_Count(ParsingDiagnostics_Get(fields, "meds", 0))
        allergies := ParsingDiagnostics_Count(ParsingDiagnostics_Get(fields, "allergies", 0))
        warnings := ParsingDiagnostics_Count(ParsingDiagnostics_Get(fields, "warnings", 0))

        if FileExist(ParsingDiagnosticsPath) {
            f := FileOpen(ParsingDiagnosticsPath, "r")
            size := f.Length
            f.Close()
            if size > ParsingDiagnosticsMaxBytes {
                backup := ParsingDiagnosticsPath ".previous"
                if FileExist(backup)
                    FileDelete backup
                FileMove ParsingDiagnosticsPath, backup, true
            }
        }

        if !FileExist(ParsingDiagnosticsPath)
            FileAppend "timestamp,app_version,event_code,component,screen_type,profile,capture_quality,warning_code,accepted_labs,accepted_meds,allergies,warnings,detail`r`n", ParsingDiagnosticsPath, "UTF-8"

        row := CsvEscape(FormatTime(, "yyyy-MM-dd HH:mm:ss"))
            . "," CsvEscape(AppVersion)
            . "," CsvEscape(eventCode)
            . "," CsvEscape(component)
            . "," CsvEscape(screenType)
            . "," CsvEscape(profile)
            . "," CsvEscape(quality)
            . "," CsvEscape(warningCode)
            . "," labs "," meds "," allergies "," warnings
            . "," CsvEscape(detail) "`r`n"
        FileAppend row, ParsingDiagnosticsPath, "UTF-8"
    }
}

ParsingDiagnostics_WarningCode(message) {
    message := StrLower(String(message))
    if InStr(message, "too low to accept laboratory")
        return "capture_unreadable"
    if InStr(message, "screen was readable but degraded")
        return "capture_degraded"
    if InStr(message, "dose confirmation") || InStr(message, "no medication dose plus unit")
        return "medication_missing_dose"
    if InStr(message, "unique medication match") || InStr(message, "outside the local drug library") || InStr(message, "drug name could not be matched uniquely")
        return "medication_name_unmatched"
    if InStr(message, "conflicting height")
        return "height_conflict"
    if InStr(message, "conflicting")
        return "field_conflict"
    if InStr(message, "needs confirmation")
        return "manual_confirmation_required"
    return "parser_warning"
}

ParsingDiagnostics_LogCapture(parsed, rawText := "") {
    try {
        screenType := PCtx_ClassifyScreen(rawText)
        profile := PCtx_ProfileFromCapture(rawText, screenType)
        quality := "unknown"
        labs := 0
        meds := 0
        allergies := 0
        warnings := 0
        try quality := parsed.captureQuality.status
        try labs := parsed.gridLabs.Length
        try meds := parsed.medications.Length
        try allergies := parsed.allergies.Length
        try warnings := parsed.captureWarnings.Length
        ParsingDiagnostics_Log("capture_complete", Map(
            "component", "patient_capture",
            "screenType", screenType,
            "profile", profile,
            "quality", quality,
            "labs", labs,
            "meds", meds,
            "allergies", allergies,
            "warnings", warnings,
            "detail", warnings > 0 ? "review_required" : "accepted"
        ))
    }
}

OpenParsingDiagnostics() {
    global ParsingDiagnosticsPath
    if FileExist(ParsingDiagnosticsPath)
        SafeLaunchTarget(ParsingDiagnosticsPath)
    else
        MsgBox "No parsing diagnostics have been recorded yet."
}

CopyParsingDiagnosticsPath() {
    global ParsingDiagnosticsPath
    A_Clipboard := ParsingDiagnosticsPath
    MsgBox "The privacy-safe parsing diagnostics path was copied.`n`n" ParsingDiagnosticsPath
}

OpenLogFile() {
    global LogPath
    if FileExist(LogPath)
        SafeLaunchTarget(LogPath)
    else
        MsgBox "Log file does not yet exist."
}

; -------------------------------------------------------------------------------------------------
; SAFETY WRAPPER
; -------------------------------------------------------------------------------------------------
SafeRun(func, params*) {
    global LogPath, AppDisplayName
    try {
        return func(params*)
    } catch as e {
        name := HasProp(func, "Name") ? func.Name : "anonymous"

        ; e.Message alone is useless for diagnosis - the identifying detail lives in
        ; Extra (e.g. the unset variable's name) and File/Line (where it actually threw,
        ; which is NOT necessarily the function SafeRun was handed).
        detail := (e is Error && e.HasProp("Message")) ? String(e.Message) : String(e)
        extra  := (e is Error && e.HasProp("Extra")  && e.Extra  != "") ? String(e.Extra)  : ""
        what   := (e is Error && e.HasProp("What")   && e.What   != "") ? String(e.What)   : ""
        file   := (e is Error && e.HasProp("File")   && e.File   != "") ? String(e.File)   : ""
        line   := (e is Error && e.HasProp("Line")   && e.Line   != "") ? String(e.Line)   : ""
        stack  := (e is Error && e.HasProp("Stack")  && e.Stack  != "") ? String(e.Stack)  : ""

        where := ""
        if what != ""
            where .= what
        if line != ""
            where .= (where != "" ? "  " : "") "line " line
        if file != ""
            where .= (where != "" ? "  " : "") file

        Log("ERROR in " name ": " detail
            . (extra != "" ? " | Specifically: " extra : "")
            . (where != "" ? " | At: " where : "")
            . (stack != "" ? "`r`n--- Stack ---`r`n" stack "`r`n-------------" : ""))

        msg := "An unexpected error occurred:`n" detail
        if extra != ""
            msg .= "`n`nSpecifically: " extra
        if where != ""
            msg .= "`n`nWhere: " where
        msg .= "`n`nTriggered by: " name
        msg .= "`n`nFull details (including call stack) were written to:`n" LogPath

        MsgBox msg, AppDisplayName " - Error", "Icon!"
    }
}

; -------------------------------------------------------------------------------------------------
; AUTO-REFRESH CSV WATCHER
; -------------------------------------------------------------------------------------------------
global _lastPrimaryWrite := ""
global _lastOtherWrite   := ""
global _lastCustomWrite  := ""
global _lastAutoTextWrite := ""
global _lastOsmoWrite    := ""
global _lastWorkflowWrite := ""

RegisterAutoTextHotstrings()
SetTimer(WatchCsvChanges, 1500)
SetTimer(Rem_Poll, RemindersCheckMs)
if !CombinedSmoke {
    Pkg_FirstRunGreetingIfNeeded()
    Splash_StartupIfEnabled()
}

WatchCsvChanges() {
    global PrimaryLinksCsvPath, OtherLinksCsvPath, CustomMenusCsvPath, AutoTextCsvPath, OsmolarityCsvPath, WorkflowMacrosCsvPath, _lastPrimaryWrite, _lastOtherWrite, _lastCustomWrite, _lastAutoTextWrite, _lastOsmoWrite, _lastWorkflowWrite, _manageGui
    changed := false
    if FileExist(PrimaryLinksCsvPath) {
        t := FileGetTime(PrimaryLinksCsvPath, "M")
        if t != _lastPrimaryWrite {
            _lastPrimaryWrite := t
            changed := true
        }
    }
    if FileExist(OtherLinksCsvPath) {
        t := FileGetTime(OtherLinksCsvPath, "M")
        if t != _lastOtherWrite {
            _lastOtherWrite := t
            changed := true
        }
    }
    if FileExist(CustomMenusCsvPath) {
        t := FileGetTime(CustomMenusCsvPath, "M")
        if t != _lastCustomWrite {
            _lastCustomWrite := t
            changed := true
        }
    }
    if FileExist(AutoTextCsvPath) {
        t := FileGetTime(AutoTextCsvPath, "M")
        if t != _lastAutoTextWrite {
            _lastAutoTextWrite := t
            RegisterAutoTextHotstrings()
            changed := true
        }
    }
    if FileExist(OsmolarityCsvPath) {
        t := FileGetTime(OsmolarityCsvPath, "M")
        if t != _lastOsmoWrite {
            _lastOsmoWrite := t
            changed := true
        }
    }
    if FileExist(WorkflowMacrosCsvPath) {
        t := FileGetTime(WorkflowMacrosCsvPath, "M")
        if t != _lastWorkflowWrite {
            _lastWorkflowWrite := t
            changed := true
        }
    }
    if changed and IsObject(_manageGui) {
        Log("Detected CSV change → refreshing Manage GUI.")
        RefreshManageLinksGui()
    }
}

; -------------------------------------------------------------------------------------------------
; THEMES
; -------------------------------------------------------------------------------------------------
global GuiTheme := "light"

; =================================================================================================
; VISUAL THEME ENGINE  (upgraded 2026-07-19)
; -------------------------------------------------------------------------------------------------
; A single palette drives every GUI. ApplyTheme() now sets a refined default font, a soft
; background, and consistent control colors so windows read as a designed application rather than
; raw system defaults. Named-accent helpers (Theme_Accent) give semantic colors that stay legible
; on both light and dark backgrounds. Existing calls to ApplyTheme(g) automatically inherit this.
; =================================================================================================

; ---- palette -----------------------------------------------------------------------------------
Theme_Palette() {
    global GuiTheme
    if IsSet(GuiTheme) && GuiTheme = "dark" {
        return {
            bg:        "090A0A",   ; installer canvas
            surface:   "121413",   ; raised panels
            text:      "F4F2ED",   ; warm primary text
            subtle:    "AAA9A4",   ; secondary text
            accent:    "40CBDA",   ; clinical cyan
            good:      "C8FF3D",   ; signal lime
            warn:      "FFBE4E",   ; caution amber
            bad:       "FF776D",   ; alert coral
            heading:   "FFFFFF"    ; section headings
        }
    }
    return {
        bg:        "F4F2ED",
        surface:   "FFFFFF",
        text:      "101820",
        subtle:    "5E6A72",
        accent:    "007C91",
        good:      "5B7F00",
        warn:      "A86600",
        bad:       "B3261E",
        heading:   "071725"
    }
}

; Map a semantic name to the current palette hex (no leading c).
Theme_Accent(name) {
    p := Theme_Palette()
    switch name {
        case "accent":  return p.accent
        case "good":    return p.good
        case "warn":    return p.warn
        case "bad":     return p.bad
        case "subtle":  return p.subtle
        case "heading": return p.heading
        default:        return p.text
    }
}

; ---- main entry: applied to every GUI -----------------------------------------------------------
ApplyTheme(g) {
    p := Theme_Palette()
    g.BackColor := p.bg
    ; Segoe UI at a comfortable size is the single biggest legibility upgrade.
    g.SetFont("s10 c" p.text, "Segoe UI")
    g.MarginX := 16
    g.MarginY := 14
}

; Style a control as a section heading (larger, accent color, semibold).
Theme_Heading(ctrl) {
    ctrl.SetFont("s12 bold c" Theme_Accent("heading"), "Segoe UI")
    return ctrl
}

; Style a control as subtle secondary text.
Theme_Subtle(ctrl) {
    ctrl.SetFont("s9 c" Theme_Accent("subtle"), "Segoe UI")
    return ctrl
}

; Add a colored pill/status line. severity: "good" | "warn" | "bad" | "accent".
Theme_Status(g, opts, severity, textStr) {
    c := Theme_Accent(severity)
    ctrl := g.Add("Text", opts " c" c, textStr)
    ctrl.SetFont("s10 bold", "Segoe UI")
    return ctrl
}

; Consistent monospace block for calculator output (aligns numbers, reads like a report).
Theme_OutputFont(ctrl) {
    ctrl.SetFont("s10", "Consolas")
    return ctrl
}


; -------------------------------------------------------------------------------------------------
; DEBUG HOTKEY
; -------------------------------------------------------------------------------------------------
^!#d:: {
    p   := LoadPrimaryLinks()
    o   := LoadOtherLinks()
    msg := "PRIMARY:`r`n"
    for a in p
        msg .= "- " a.name " (" (a.visible ? "visible" : "hidden") ")`r`n"
    msg .= "`r`nOTHER:`r`n"
    for b in o
        msg .= "- " b.name " => " b.url "`r`n"
    MsgBox msg
}

; =================================================================================================
;  QUICK NOTES PRO (v1)
; =================================================================================================

global QNP_DataPath    := PhuckitUserDataRoot "\quicknotes.txt"
global QNP_BackupDir   := PhuckitUserDataRoot "\QuickNotes_Backups"
global QNP_ChangeRequestExportPath := PhuckitUserDataRoot "\change_requests.txt"
global QNP_MaxBackups  := 10
global QNP_AutosaveMs  := 1200

global QNP_Gui         := 0
global QNP_Tabs        := []
global QNP_ActiveIndex := 1
global QNP_TabCtrl     := 0
global QNP_Edit        := 0
global QNP_Dirty       := false
global QNP_ListMode    := false
global QNP_HotIfActive := false

QNP_Encode(s) {
    s := StrReplace(s, "\", "\\")
    s := StrReplace(s, "`r`n", "`n")
    s := StrReplace(s, "`r", "`n")
    s := StrReplace(s, "`n", "\n")
    return s
}

QNP_Decode(s) {
    out := ""
    i := 1
    len := StrLen(s)
    while i <= len {
        c := SubStr(s, i, 1)
        if c = "\" {
            nxt := SubStr(s, i + 1, 1)
            if nxt = "n" {
                out .= "`r`n"
                i += 2
                continue
            }
            if nxt = "\" {
                out .= "\"
                i += 2
                continue
            }
        }
        out .= c
        i += 1
    }
    return out
}

QNP_Load() {
    global QNP_DataPath, QNP_Tabs, QNP_ActiveIndex
    QNP_Tabs := []
    QNP_ActiveIndex := 1
    if !FileExist(QNP_DataPath) {
        QNP_Tabs.Push({ title: "General", body: "", caret: 0 })
        QNP_EnsureSystemTabs()
        return
    }
    try {
        content := FileRead(QNP_DataPath, "UTF-8")
    } catch as e {
        Log("QNP: failed to read notes file: " e.Message)
        QNP_Tabs.Push({ title: "General", body: "", caret: 0 })
        QNP_EnsureSystemTabs()
        return
    }
    lines := StrSplit(content, "`n", "`r")
    i := 1
    if i <= lines.Length and SubStr(lines[i], 1, 7) = "ACTIVE=" {
        QNP_ActiveIndex := Integer(SubStr(lines[i], 8))
        i += 1
    }
    while i <= lines.Length {
        line := lines[i]
        if SubStr(line, 1, 4) = "TAB=" {
            title := SubStr(line, 5)
            body  := (i + 1 <= lines.Length) ? QNP_Decode(lines[i + 1]) : ""
            QNP_Tabs.Push({ title: title, body: body, caret: 0 })
            i += 2
        } else {
            i += 1
        }
    }
    if QNP_Tabs.Length = 0
        QNP_Tabs.Push({ title: "General", body: "", caret: 0 })
    if QNP_ActiveIndex < 1 or QNP_ActiveIndex > QNP_Tabs.Length
        QNP_ActiveIndex := 1
    QNP_EnsureSystemTabs()
}

QNP_EnsureSystemTabs() {
    global QNP_Tabs
    for tab in QNP_Tabs {
        if StrLower(Trim(tab.title)) = "change requests"
            return false
    }
    QNP_Tabs.Push({
        title: "Change Requests",
        body: "Use this tab to document fixes, workflow friction, parsing misses, and ideas for the next PhUCKIT update.`r`n`r`nDo not include patient names, identifiers, or other protected health information.",
        caret: 0
    })
    return true
}

QNP_Save() {
    global QNP_DataPath, QNP_Tabs, QNP_ActiveIndex, QNP_Dirty
    QNP_SyncActiveFromEditor()
    text := "ACTIVE=" QNP_ActiveIndex "`r`n"
    for t in QNP_Tabs
        text .= "TAB=" t.title "`r`n" QNP_Encode(t.body) "`r`n"
    QNP_Backup()
    AtomicWrite(QNP_DataPath, text)
    QNP_ExportChangeRequests(false)
    QNP_Dirty := false
}

QNP_ChangeRequestIndex() {
    global QNP_Tabs
    for idx, tab in QNP_Tabs {
        if StrLower(Trim(tab.title)) = "change requests"
            return idx
    }
    return 0
}

QNP_OpenChangeRequests() {
    global QNP_TabCtrl, QNP_ActiveIndex
    QNP_SyncActiveFromEditor()
    idx := QNP_ChangeRequestIndex()
    if idx < 1
        return
    QNP_ActiveIndex := idx
    QNP_TabCtrl.Value := idx
    QNP_LoadTabIntoEditor(idx)
}

QNP_ExportChangeRequests(showConfirmation := true) {
    global QNP_Tabs, QNP_ChangeRequestExportPath, AppVersion
    idx := QNP_ChangeRequestIndex()
    if idx < 1
        return ""
    body := QNP_Tabs[idx].body
    export := "PhUCKIT change requests`r`n"
        . "Application version: " AppVersion "`r`n"
        . "Exported: " FormatTime(, "yyyy-MM-dd HH:mm:ss") "`r`n"
        . "Privacy reminder: remove patient identifiers before sharing.`r`n"
        . "============================================================`r`n`r`n"
        . body
    AtomicWrite(QNP_ChangeRequestExportPath, export)
    if showConfirmation {
        A_Clipboard := export
        MsgBox "Change Requests were saved and copied to the clipboard.`n`n" QNP_ChangeRequestExportPath
    }
    return export
}

QNP_PrepareUpdateFeedback() {
    global ParsingDiagnosticsPath, QNP_ChangeRequestExportPath, AppVersion
    QNP_Save()
    warning := "This export contains the privacy-safe parser diagnostics and your Change Requests text.`n`n"
        . "PhUCKIT never adds raw OCR or patient identifiers to the diagnostic log. Change Requests are user-entered, so review that tab and remove any patient information before sharing.`n`n"
        . "Prepare the feedback folder now?"
    if MsgBox(warning, "Prepare PhUCKIT Update Feedback", 0x24) != "Yes"
        return

    stamp := FormatTime(, "yyyyMMdd_HHmmss")
    folder := A_Desktop "\PhUCKIT-Update-Feedback-" stamp
    DirCreate folder
    if FileExist(QNP_ChangeRequestExportPath)
        FileCopy QNP_ChangeRequestExportPath, folder "\change_requests.txt", true
    if FileExist(ParsingDiagnosticsPath)
        FileCopy ParsingDiagnosticsPath, folder "\parsing_diagnostics.csv", true
    if FileExist(ParsingDiagnosticsPath ".previous")
        FileCopy ParsingDiagnosticsPath ".previous", folder "\parsing_diagnostics.previous.csv", true

    manifest := "PhUCKIT update feedback package`r`n"
        . "Application version: " AppVersion "`r`n"
        . "Created: " FormatTime(, "yyyy-MM-dd HH:mm:ss") "`r`n"
        . "Includes raw OCR: no`r`n"
        . "Includes screenshots: no`r`n"
        . "Includes Quick Notes outside Change Requests: no`r`n"
        . "Diagnostic schema: controlled event codes, screen/profile category, capture quality, and counts only`r`n"
        . "User action: review change_requests.txt for accidentally entered patient information before sharing.`r`n"
    AtomicWrite(folder "\README.txt", manifest)
    A_Clipboard := folder
    SafeLaunchTarget(folder)
    MsgBox "Feedback folder prepared and its path copied to the clipboard.`n`n" folder, "PhUCKIT"
}

QNP_SyncActiveFromEditor() {
    global QNP_Edit, QNP_Tabs, QNP_ActiveIndex
    if !IsObject(QNP_Edit)
        return
    if QNP_ActiveIndex < 1 or QNP_ActiveIndex > QNP_Tabs.Length
        return
    QNP_Tabs[QNP_ActiveIndex].body  := QNP_Edit.Value
    QNP_Tabs[QNP_ActiveIndex].caret := QNP_GetCaretPos(QNP_Edit)
}

QNP_Backup() {
    global QNP_DataPath, QNP_BackupDir, QNP_MaxBackups
    if !FileExist(QNP_DataPath)
        return
    if !DirExist(QNP_BackupDir)
        DirCreate QNP_BackupDir
    stamp := FormatTime(, "yyyyMMdd_HHmmss")
    FileCopy QNP_DataPath, QNP_BackupDir "\quicknotes_" stamp ".txt", true
    files := []
    Loop Files QNP_BackupDir "\quicknotes_*.txt"
        files.Push(A_LoopFileFullPath)
    if files.Length > QNP_MaxBackups {
        files := QNP_SortStrings(files)
        excess := files.Length - QNP_MaxBackups
        Loop excess
            FileDelete files[A_Index]
    }
}

QNP_SortStrings(arr) {
    n := arr.Length
    Loop n - 1 {
        i := A_Index + 1
        key := arr[i]
        j := i - 1
        while (j >= 1 and StrCompare(arr[j], key) > 0) {
            arr[j + 1] := arr[j]
            j -= 1
        }
        arr[j + 1] := key
    }
    return arr
}

QNP_Open() {
    global QNP_Gui, QNP_Tabs, QNP_ActiveIndex, QNP_TabCtrl, QNP_Edit
    if IsObject(QNP_Gui) {
        try {
            QNP_Gui.Show()
            return
        }
    }
    QNP_Load()
    QNP_Save()
    g := Gui("+Resize +MinSize620x420", "Quick Notes Pro")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    QNP_Gui := g

    g.Add("Button", "xm ym w90",  "+ New Tab").OnEvent("Click", (*) => SafeRun(QNP_NewTab))
    g.Add("Button", "x+6 yp w90", "Rename").OnEvent("Click",    (*) => SafeRun(QNP_RenameTab))
    g.Add("Button", "x+6 yp w90", "Close Tab").OnEvent("Click", (*) => SafeRun(QNP_CloseTab))
    g.Add("Button", "x+6 yp w90", "Timestamp").OnEvent("Click", (*) => SafeRun(QNP_InsertTimestamp))
    g.Add("Button", "x+6 yp w70", "Save").OnEvent("Click",      (*) => SafeRun(QNP_Save))
    global QNP_ListBtnRef := g.Add("Button", "x+6 yp w75", "Bullets")
    QNP_ListBtnRef.OnEvent("Click", (*) => SafeRun(QNP_ToggleListMode))

    g.Add("Button", "xm y+8 w130", "Change Requests").OnEvent("Click", (*) => SafeRun(QNP_OpenChangeRequests))
    g.Add("Button", "x+6 yp w140", "Copy / Export Changes").OnEvent("Click", (*) => SafeRun(QNP_ExportChangeRequests))
    g.Add("Button", "x+6 yp w125", "Parser Diagnostics").OnEvent("Click", (*) => SafeRun(OpenParsingDiagnostics))
    g.Add("Button", "x+6 yp w125", "Copy Log Path").OnEvent("Click", (*) => SafeRun(CopyParsingDiagnosticsPath))
    g.Add("Button", "x+6 yp w140", "Prepare Feedback").OnEvent("Click", (*) => SafeRun(QNP_PrepareUpdateFeedback))

    tabTitles := []
    for t in QNP_Tabs
        tabTitles.Push(t.title)
    QNP_TabCtrl := g.Add("Tab3", "xm y+8 w680 h24 -Theme", tabTitles)
    QNP_TabCtrl.OnEvent("Change", QNP_OnTabChange)
    QNP_TabCtrl.UseTab()

    QNP_Edit := g.Add("Edit", "xm y+4 w680 h300 Multi WantTab VScroll")
    QNP_Edit.OnEvent("Change", QNP_OnEditChange)

    if QNP_ActiveIndex >= 1 and QNP_ActiveIndex <= QNP_Tabs.Length
        QNP_TabCtrl.Value := QNP_ActiveIndex
    QNP_LoadTabIntoEditor(QNP_ActiveIndex)

    g.OnEvent("Close", QNP_OnClose)
    g.OnEvent("Size", QNP_OnResize)
    g.Show("w700 h460")
}

QNP_LoadTabIntoEditor(idx) {
    global QNP_Edit, QNP_Tabs
    if idx < 1 or idx > QNP_Tabs.Length
        return
    QNP_Edit.Value := QNP_Tabs[idx].body
    QNP_SetCaretPos(QNP_Edit, QNP_Tabs[idx].caret)
}

QNP_OnTabChange(ctrl, *) {
    global QNP_Tabs, QNP_ActiveIndex
    QNP_SyncActiveFromEditor()
    newIdx := ctrl.Value
    if newIdx < 1 or newIdx > QNP_Tabs.Length
        return
    QNP_ActiveIndex := newIdx
    QNP_LoadTabIntoEditor(newIdx)
    QNP_Save()
}

QNP_OnEditChange(*) {
    global QNP_Dirty, QNP_AutosaveMs
    QNP_Dirty := true
    SetTimer(QNP_AutosaveTick, -QNP_AutosaveMs)
}

QNP_AutosaveTick() {
    global QNP_Dirty
    if QNP_Dirty
        QNP_Save()
}

QNP_NewTab() {
    global QNP_Tabs, QNP_TabCtrl, QNP_ActiveIndex
    QNP_SyncActiveFromEditor()
    title := QNP_PromptText("New tab name:", "New Tab", "Notes " (QNP_Tabs.Length + 1))
    if title = ""
        return
    QNP_Tabs.Push({ title: title, body: "", caret: 0 })
    QNP_RebuildTabStrip()
    QNP_ActiveIndex := QNP_Tabs.Length
    QNP_TabCtrl.Value := QNP_ActiveIndex
    QNP_LoadTabIntoEditor(QNP_ActiveIndex)
    QNP_Save()
}

QNP_RenameTab() {
    global QNP_Tabs, QNP_ActiveIndex
    if QNP_ActiveIndex < 1 or QNP_ActiveIndex > QNP_Tabs.Length
        return
    cur := QNP_Tabs[QNP_ActiveIndex].title
    if StrLower(Trim(cur)) = "change requests" {
        MsgBox "The Change Requests tab has a fixed name so it remains easy to find and export."
        return
    }
    newTitle := QNP_PromptText("Rename tab:", "Rename Tab", cur)
    if newTitle = ""
        return
    QNP_Tabs[QNP_ActiveIndex].title := newTitle
    QNP_RebuildTabStrip()
    QNP_TabCtrl.Value := QNP_ActiveIndex
    QNP_Save()
}

QNP_CloseTab() {
    global QNP_Tabs, QNP_ActiveIndex
    if QNP_Tabs.Length <= 1 {
        MsgBox "Can't close the last tab."
        return
    }
    if StrLower(Trim(QNP_Tabs[QNP_ActiveIndex].title)) = "change requests" {
        MsgBox "The Change Requests tab is kept as an update-safe system tab. Its contents remain fully editable."
        return
    }
    if MsgBox("Close tab '" QNP_Tabs[QNP_ActiveIndex].title "'?`nIts contents will be deleted.", "Confirm", 0x24) != "Yes"
        return
    QNP_Tabs.RemoveAt(QNP_ActiveIndex)
    if QNP_ActiveIndex > QNP_Tabs.Length
        QNP_ActiveIndex := QNP_Tabs.Length
    QNP_RebuildTabStrip()
    QNP_TabCtrl.Value := QNP_ActiveIndex
    QNP_LoadTabIntoEditor(QNP_ActiveIndex)
    QNP_Save()
}

QNP_RebuildTabStrip() {
    global QNP_TabCtrl, QNP_Tabs
    titles := []
    for t in QNP_Tabs
        titles.Push(t.title)
    QNP_TabCtrl.Delete()
    QNP_TabCtrl.Add(titles)
}

QNP_InsertTimestamp() {
    global QNP_Edit
    if !IsObject(QNP_Edit)
        return
    stamp := FormatTime(, "yyyy-MM-dd HH:mm") " — "
    QNP_InsertAtCaret(stamp)
    QNP_Edit.Focus()
}

QNP_GetCaretPos(editCtrl) {
    res := SendMessage(0x00B0, 0, 0, editCtrl)
    return res & 0xFFFF
}

QNP_SetCaretPos(editCtrl, pos) {
    try {
        SendMessage(0x00B1, pos, pos, editCtrl)
        SendMessage(0x00B7, 0, 0, editCtrl)
    }
}

QNP_OnClose(*) {
    global QNP_Gui
    QNP_Save()
    try QNP_Gui.Destroy()
    QNP_Gui := 0
}

QNP_OnResize(guiObj, minMax, w, h) {
    global QNP_TabCtrl, QNP_Edit
    if minMax = -1
        return
    if !IsObject(QNP_TabCtrl) or !IsObject(QNP_Edit)
        return
    QNP_TabCtrl.Move(, , w - 20)
    QNP_Edit.Move(, , w - 20, h - 150)
}

QNP_ToggleListMode() {
    global QNP_ListMode, QNP_ListBtnRef, QNP_Edit, QNP_Bullet
    QNP_ListMode := !QNP_ListMode
    try QNP_ListBtnRef.Text := QNP_ListMode ? "Bullets ✓" : "Bullets"
    if QNP_ListMode {
        QNP_InstallListHotkeys()
        line := QNP_GetCurrentLineText()
        if LTrim(line, "`t") = ""
            QNP_InsertAtCaret(QNP_Bullet)
    }
    QNP_Edit.Focus()
}

QNP_InsertAtCaret(str) {
    global QNP_Edit
    full  := QNP_Edit.Value
    caret := QNP_GetCaretPos(QNP_Edit)
    QNP_Edit.Value := SubStr(full, 1, caret) str SubStr(full, caret + 1)
    QNP_SetCaretPos(QNP_Edit, caret + StrLen(str))
}

global QNP_Bullet := "• "

QNP_LineDepth(line) {
    d := 0
    while SubStr(line, d + 1, 1) = "`t"
        d += 1
    return d
}

QNP_IsEmptyBullet(line) {
    global QNP_Bullet
    t := LTrim(line, "`t")
    return (t = Trim(QNP_Bullet) or t = QNP_Bullet or Trim(t) = Trim(QNP_Bullet))
}

QNP_InstallListHotkeys() {
    global QNP_HotIfActive
    if QNP_HotIfActive
        return
    QNP_HotIfActive := true
    HotIfWinActive("Quick Notes Pro")
    Hotkey "Enter", QNP_ListEnter
    Hotkey "Tab",   QNP_ListTab
    Hotkey "+Tab",  QNP_ListShiftTab
    HotIfWinActive()
}

QNP_ListActive() {
    global QNP_ListMode, QNP_Edit
    return QNP_ListMode and IsObject(QNP_Edit) and ControlGetFocus("A") = QNP_Edit.Hwnd
}

QNP_ListEnter(*) {
    global QNP_Edit, QNP_Bullet
    if !QNP_ListActive() {
        Send "{Enter}"
        return
    }
    line := QNP_GetCurrentLineText()
    if QNP_IsEmptyBullet(line) {
        QNP_ClearCurrentLine()
        return
    }
    depth := QNP_LineDepth(line)
    tabs := ""
    Loop depth
        tabs .= "`t"
    Send "{Enter}"
    SendText tabs QNP_Bullet
}

QNP_ListTab(*) {
    global QNP_Bullet
    if !QNP_ListActive() {
        Send "{Tab}"
        return
    }
    QNP_ChangeCurrentLineDepth(1)
}

QNP_ListShiftTab(*) {
    if !QNP_ListActive() {
        Send "+{Tab}"
        return
    }
    QNP_ChangeCurrentLineDepth(-1)
}

QNP_CurrentLineDepth() {
    return QNP_LineDepth(QNP_GetCurrentLineText())
}

QNP_GetCurrentLineText() {
    global QNP_Edit
    full := QNP_Edit.Value
    caret := QNP_GetCaretPos(QNP_Edit)
    before := SubStr(full, 1, caret)
    lineStart := InStr(before, "`n", , -1)
    lineStart := lineStart ? lineStart + 1 : 1
    rest := SubStr(full, lineStart)
    nl := InStr(rest, "`n")
    return nl ? SubStr(rest, 1, nl - 1) : rest
}

QNP_ClearCurrentLine() {
    global QNP_Edit
    full := QNP_Edit.Value
    caret := QNP_GetCaretPos(QNP_Edit)
    before := SubStr(full, 1, caret)
    lineStart := InStr(before, "`n", , -1)
    lineStart := lineStart ? lineStart + 1 : 1
    rest := SubStr(full, lineStart)
    nl := InStr(rest, "`n")
    after := nl ? SubStr(rest, nl) : ""
    newFull := SubStr(full, 1, lineStart - 1) after
    QNP_Edit.Value := newFull
    QNP_SetCaretPos(QNP_Edit, lineStart - 1)
}

QNP_ChangeCurrentLineDepth(delta) {
    global QNP_Edit, QNP_Bullet
    full := QNP_Edit.Value
    caret := QNP_GetCaretPos(QNP_Edit)
    before := SubStr(full, 1, caret)
    lineStart := InStr(before, "`n", , -1)
    lineStart := lineStart ? lineStart + 1 : 1
    rest := SubStr(full, lineStart)
    nl := InStr(rest, "`n")
    lineText := nl ? SubStr(rest, 1, nl - 1) : rest
    after := nl ? SubStr(rest, nl) : ""
    depth := QNP_LineDepth(lineText)
    body  := LTrim(lineText, "`t")
    if SubStr(body, 1, StrLen(QNP_Bullet)) != QNP_Bullet
        body := QNP_Bullet body
    newDepth := depth + delta
    if newDepth < 0
        newDepth := 0
    tabs := ""
    Loop newDepth
        tabs .= "`t"
    newFull := SubStr(full, 1, lineStart - 1) tabs body after
    QNP_Edit.Value := newFull
    newCaret := lineStart - 1 + StrLen(tabs body)
    QNP_SetCaretPos(QNP_Edit, newCaret)
}

QNP_PromptText(prompt, title, default := "") {
    ib := InputBox(prompt, title, "w320 h130", default)
    if ib.Result != "OK"
        return ""
    return Trim(ib.Value)
}

; -------------------------------------------------------------------------------------------------
; DIGIFAB — digoxin immune Fab structured dosing support
; -------------------------------------------------------------------------------------------------
Calc_OpenDigiFab() {
    g := Gui("+Resize", "DigiFab Digoxin Toxicity Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w780 cRed", "Structured antidote support only. Call poison control/toxicology and verify ECG, potassium, renal function, ingestion history, and local protocol.").SetFont("s10 bold")
    g.Add("Text", "xm y+10", "Scenario:")
    scenario := g.Add("DropDownList", "x230 yp w370", ["Acute ingestion - known amount", "Acute ingestion - unknown amount", "Chronic toxicity - known digoxin level", "Chronic toxicity - unknown level"])
    scenario.Value := 1
    wtLbl := g.Add("Text", "xm y+8", "Weight (kg):")
    wt := g.Add("Edit", "x230 yp w90")
    ingLbl := g.Add("Text", "xm y+8", "Amount ingested (mg):")
    ingested := g.Add("Edit", "x230 yp w90")
    levelLbl := g.Add("Text", "xm y+8", "Serum digoxin (ng/mL):")
    level := g.Add("Edit", "x230 yp w90")
    g.Add("Text", "xm y+8", "Life-threatening features present?")
    severe := g.Add("CheckBox", "x230 yp", "Yes / suspected")
    help := g.Add("Text", "xm y+8 w780 cGray", "The required inputs change by scenario. Known acute amount uses mg ingested; chronic known level uses weight plus steady-state level.")
    result := g.Add("Edit", "xm y+12 w800 h330 ReadOnly -Wrap")
    scenario.OnEvent("Change", (*) => Calc_UpdateDigiFabFields(scenario, wtLbl, wt, ingLbl, ingested, levelLbl, level))
    Calc_UpdateDigiFabFields(scenario, wtLbl, wt, ingLbl, ingested, levelLbl, level)
    g.Add("Button", "xm y+10 w120 Default", "Build Summary").OnEvent("Click", (*) => SafeRun(Calc_RunDigiFab, scenario, wt, ingested, level, severe, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    parsed := PBind_CurrentParsed()
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_Set(level, PBind_Lab("digoxin"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wt.Value, "Digoxin level", level.Value)))
    Workbench29_Show(g,"w840")
}

Calc_UpdateDigiFabFields(scenario, wtLbl, wt, ingLbl, ingested, levelLbl, level) {
    for c in [wtLbl, wt, ingLbl, ingested, levelLbl, level]
        c.Visible := false
    if scenario.Value = 1 {
        ingLbl.Visible := true, ingested.Visible := true
    } else if scenario.Value = 3 {
        wtLbl.Visible := true, wt.Visible := true, levelLbl.Visible := true, level.Visible := true
    } else if scenario.Value = 4 {
        wtLbl.Visible := true, wt.Visible := true
    }
}

Calc_RunDigiFab(scenario, wtCtrl, ingestedCtrl, levelCtrl, severeCtrl, result) {
    idx := scenario.Value
    wtTxt := Trim(wtCtrl.Value)
    ingTxt := Trim(ingestedCtrl.Value)
    levTxt := Trim(levelCtrl.Value)
    out := "DIGIFAB / DIGOXIN IMMUNE FAB STRUCTURED SUMMARY`r`n"
    out .= "Use for life-threatening or potentially life-threatening digoxin toxicity/overdose. Call poison control/toxicology. Obtain ECG, potassium, renal function, magnesium, and a pre-Fab digoxin level when feasible.`r`n`r`n"
    try {
        if idx = 1 {
            if !IsNumber(ingTxt) or Number(ingTxt) <= 0 {
                MsgBox "Enter known/estimated amount ingested in mg.", "DigiFab", "Icon!"
                return
            }
            ing := Number(ingTxt)
            vials := Max(1, Ceil(ing * 0.8 / 0.5))
            out .= "Scenario: acute ingestion, known/estimated amount.`r`n"
            out .= "Calculated dose: " vials " vial(s) DigiFab (" (vials*40) " mg).`r`n"
            out .= "Formula: " ing " mg x 0.8 bioavailability / 0.5 mg bound per vial = " Round(ing*0.8/0.5,2) ", rounded up.`r`n"
        } else if idx = 2 {
            out .= "Scenario: acute ingestion, unknown amount.`r`nCalculated dose: 20 vials DigiFab (800 mg) default adult/large-child starting estimate. In small children <20 kg, some guidance starts with 10 vials then reassesses.`r`n"
        } else if idx = 3 {
            if !IsNumber(wtTxt) or Number(wtTxt) <= 0 or !IsNumber(levTxt) or Number(levTxt) <= 0 {
                MsgBox "Enter weight and steady-state serum digoxin concentration.", "DigiFab", "Icon!"
                return
            }
            wt := Number(wtTxt), lev := Number(levTxt)
            vials := Max(1, Ceil((lev * wt) / 100))
            out .= "Scenario: chronic toxicity with known steady-state serum digoxin concentration.`r`n"
            out .= "Calculated dose: " vials " vial(s) DigiFab (" (vials*40) " mg).`r`n"
            out .= "Formula: " lev " ng/mL x " Round(wt,1) " kg / 100 = " Round(lev*wt/100,2) ", rounded up.`r`n"
        } else {
            if IsNumber(wtTxt) and Number(wtTxt) > 0 and Number(wtTxt) < 20
                out .= "Scenario: chronic toxicity, unknown level, patient <20 kg.`r`nCalculated dose: 1 vial DigiFab (40 mg) default.`r`n"
            else
                out .= "Scenario: chronic toxicity, unknown level, adult/child >=20 kg or weight not entered.`r`nCalculated dose: 6 vials DigiFab (240 mg) default.`r`n"
        }
    } catch as e {
        MsgBox "DigiFab calculation error: " e.Message, "DigiFab", "Icon!"
        return
    }
    if severeCtrl.Value = 1
        out .= "`r`nLife-threatening features were checked: prioritize immediate expert consultation and bedside resuscitation. Indications can include severe ventricular arrhythmias, progressive bradycardia/AV block not responsive to atropine, or hyperkalemia with digoxin toxicity.`r`n"
    out .= "`r`nMonitoring / caveats:`r`n- Potassium may fall rapidly after Fab; monitor frequently, especially in the first several hours.`r`n- Total serum digoxin levels become misleading after Fab because assays measure Fab-bound drug; use clinical status/free digoxin if available.`r`n- Monitor for worsening heart failure/atrial fibrillation after reversal of digoxin effect.`r`n- Hypersensitivity is possible; use caution with sheep protein, papaya/papain/chymopapain, or bromelain allergy.`r`n"
    out .= "`r`nSource note: formulas and defaults follow DigiFab prescribing information: known acute amount x 0.8/0.5; chronic level x weight/100; unknown acute 20 vials; unknown chronic 6 vials if >=20 kg and 1 vial if <20 kg."
    result.Value := out
}

; -------------------------------------------------------------------------------------------------
; CROFAB — North American crotalid envenomation structured support
; -------------------------------------------------------------------------------------------------
Calc_OpenCroFab() {
    g := Gui("+Resize", "CroFab Crotalid Envenomation Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w760 cRed", "Structured antivenom support only. Call poison control/toxicology and verify species/exposure, local protocol, labs, and patient trajectory.").SetFont("s10 bold")
    g.Add("Text", "xm y+10", "Clinical status:")
    status := g.Add("DropDownList", "x210 yp w360", ["Signs of envenomation - initial dose", "Initial control not achieved", "Initial control achieved - maintenance", "Observe / no clear envenomation yet"])
    status.Value := 1
    g.Add("Text", "xm y+8", "Severity impression:")
    severity := g.Add("DropDownList", "x210 yp w220", ["Typical", "Severe / rapidly progressive"])
    severity.Value := 1
    localProg := g.Add("CheckBox", "xm y+10", "Progressive local swelling/ecchymosis/pain")
    systemic := g.Add("CheckBox", "xm y+4", "Systemic signs: hypotension, neurotoxicity, vomiting, dizziness, tachycardia")
    heme := g.Add("CheckBox", "xm y+4", "Hematologic toxicity: thrombocytopenia, coagulopathy, low fibrinogen, bleeding")
    result := g.Add("Edit", "xm y+14 w780 h330 ReadOnly -Wrap")
    g.Add("Button", "xm y+10 w120 Default", "Build Summary").OnEvent("Click", (*) => SafeRun(Calc_RunCroFab, status, severity, localProg, systemic, heme, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    Workbench29_Show(g,"w820")
}

Calc_RunCroFab(status, severity, localProg, systemic, heme, result) {
    idx := status.Value
    sev := severity.Text
    out := "CROFAB / CROTALID ENVENOMATION STRUCTURED SUMMARY`r`n"
    out .= "CroFab is for North American crotalid envenomation, including rattlesnake, copperhead, and cottonmouth/water moccasin. Call poison control/toxicology early. Dosing is driven by clinical response, not patient weight, and is the same for adults and pediatric patients.`r`n`r`n"
    signs := []
    if localProg.Value
        signs.Push("progressive local effects")
    if systemic.Value
        signs.Push("systemic effects")
    if heme.Value
        signs.Push("hematologic effects")
    if signs.Length
        out .= "Entered signs: " JoinArray(signs, ", ") ".`r`n`r`n"

    if idx = 1 {
        dose := sev = "Severe / rapidly progressive" ? "4 to 12 vials, commonly starting above 6 vials depending on severity and toxicology guidance" : "4 to 6 vials"
        out .= "Status: signs of envenomation present / initial treatment.`r`n- Recommended initial dose: " dose ".`r`n- Assess for initial control after completion of the dose, usually up to 1 hour after infusion.`r`n"
    } else if idx = 2 {
        out .= "Status: initial control not achieved.`r`n- Give an additional 4 to 6 vials and reassess. Repeat additional 4 to 6 vial doses until initial control is achieved.`r`n"
    } else if idx = 3 {
        out .= "Status: initial control achieved.`r`n- Maintenance dosing: 2 vials every 6 hours for up to 18 hours, for 3 scheduled maintenance doses.`r`n- Additional 2-vial doses after scheduled maintenance may be needed based on clinical course and toxicology guidance.`r`n"
    } else {
        out .= "Status: no clear envenomation yet / observation branch.`r`n- No antivenom dose generated by this tool. Observe, mark leading edge of swelling, repeat exams/labs per protocol, and involve poison control/toxicology.`r`n"
    }

    out .= "`r`nInitial control means all relevant domains are controlled:`r`n- Local: leading edge of swelling/local injury is no longer progressing.`r`n- Systemic: hypotension/neurotoxicity/GI or cardiovascular symptoms are resolved or improving.`r`n- Hematologic: platelets/coagulation/fibrinogen are normalized or trending toward normal.`r`n"
    out .= "`r`nAdministration / monitoring reminders:`r`n- Reconstitute and infuse per product labeling/local policy; monitor for infusion reactions and anaphylaxis.`r`n- Recurrent coagulopathy can occur and may persist or recur for 1 to 2 weeks or longer; arrange follow-up labs/monitoring.`r`n- Use caution with hypersensitivity to papaya/papain or ovine proteins; benefits may outweigh risks in serious envenomation with preparedness for anaphylaxis.`r`n"
    out .= "`r`nSource note: dosing summary follows CroFab prescribing information: initial 4-6 vials, repeat 4-6 vials until initial control, then 2 vials every 6 hours for 18 hours after initial control."
    result.Value := out
}

JoinArray(arr, sep := ", ") {
    out := ""
    for i, v in arr
        out .= (i = 1 ? "" : sep) v
    return out
}




; -------------------------------------------------------------------------------------------------
; DKA TREATMENT — structured initial and ongoing management support
; -------------------------------------------------------------------------------------------------
Calc_OpenDkaTreatment() {
    g := Gui("+Resize", "DKA Treatment Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w900 cRed", "Structured DKA decision support only. Verify adult/pediatric status, pregnancy, ESRD/CHF, SGLT2 inhibitor use, local insulin/electrolyte protocols, and ICU/endocrinology guidance. This does not diagnose DKA by itself or replace bedside orders.").SetFont("s10 bold")

    g.Add("GroupBox", "xm y+10 w430 h230", "Patient / Severity")
    g.Add("Text", "xp+14 yp+28", "Weight (kg):")
    wt := g.Add("Edit", "x175 yp w70")
    quickFluid := g.Add("CheckBox", "xm+14 y+8", "Quick fluid-only mode (requires only K+ and glucose)")
    g.Add("Text", "xm+14 y+8", "Current phase:")
    phase := g.Add("DropDownList", "x175 yp w210", ["Initial ED/ICU management", "Ongoing after first fluids", "Glucose <250 mg/dL / dextrose phase", "Transition planning"])
    phase.Value := 1
    g.Add("Text", "xm+14 y+8", "Mental/clinical status:")
    mental := g.Add("DropDownList", "x175 yp w210", ["Alert/stable", "Drowsy or concerning", "Stupor/coma/critical illness"])
    mental.Value := 1
    g.Add("Text", "xm+14 y+8", "Volume/renal/cardiac risk:")
    fluidRisk := g.Add("DropDownList", "x175 yp w230", ["No CHF/ESRD/major overload risk", "Older/CHF/ESRD/overload risk", "Shock/hypoperfusion"])
    fluidRisk.Value := 1
    sglt2 := g.Add("CheckBox", "xm+14 y+10", "SGLT2 inhibitor or euglycemic DKA concern")
    preg := g.Add("CheckBox", "xm+14 y+6", "Pregnancy / pediatric / institutional special population")

    g.Add("GroupBox", "x450 ym+38 w450 h230", "BMP / Ketosis / Acid-Base")
    g.Add("Text", "xp+14 yp+28", "Glucose mg/dL:")
    gluc := g.Add("Edit", "x585 yp w70")
    g.Add("Text", "x+14 yp", "Na mEq/L:")
    na := g.Add("Edit", "x+4 yp w60")
    g.Add("Text", "x+14 yp", "K mEq/L:")
    k := g.Add("Edit", "x+4 yp w60")
    g.Add("Text", "x464 y+10", "Cl mEq/L:")
    cl := g.Add("Edit", "x585 yp w70")
    g.Add("Text", "x+14 yp", "CO2/HCO3:")
    bicarb := g.Add("Edit", "x+4 yp w60")
    g.Add("Text", "x464 y+10", "pH:")
    ph := g.Add("Edit", "x585 yp w70")
    g.Add("Text", "x+14 yp", "BHB mmol/L:")
    bhb := g.Add("Edit", "x+4 yp w60")
    g.Add("Text", "x464 y+10", "Phos mg/dL:")
    phos := g.Add("Edit", "x585 yp w70")
    g.Add("Text", "x+14 yp", "Mg mg/dL:")
    mg := g.Add("Edit", "x+4 yp w60")
    g.Add("Text", "x464 y+10", "Insulin infusion running?")
    insulinRunning := g.Add("DropDownList", "x635 yp w170", ["No / not yet", "Yes", "SQ protocol"])
    insulinRunning.Value := 1
    g.Add("Text", "x464 y+10", "Current drip rate units/hr:")
    insulinRate := g.Add("Edit", "x635 yp w70")
    g.Add("Text", "x464 y+10 w410", "Leave unavailable fields blank. Anion gap and osmolality are calculated when enough BMP data is entered.")

    result := g.Add("Edit", "xm y+20 w900 h470 ReadOnly -Wrap")
    g.Add("Button", "xm y+10 w155 Default", "Build DKA Summary").OnEvent("Click", (*) => SafeRun(Calc_RunDkaTreatment, wt, quickFluid, phase, mental, fluidRisk, sglt2, preg, gluc, na, k, cl, bicarb, ph, bhb, phos, mg, insulinRunning, insulinRate, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    parsed := PBind_CurrentParsed()
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_Set(gluc, PBind_Lab("glucose"))
    PBind_Set(na, PBind_Lab("sodium"))
    PBind_Set(k, PBind_Lab("potassium"))
    PBind_Set(cl, PBind_Lab("chloride"))
    PBind_Set(bicarb, PBind_Lab("bicarbonate"))
    PBind_Set(ph, PBind_Lab("ph"))
    PBind_Set(bhb, PBind_Lab("betahydroxybutyrate"))
    PBind_Set(phos, PBind_Lab("phosphate"))
    PBind_Set(mg, PBind_Lab("magnesium"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wt.Value, "Glucose", gluc.Value, "Potassium", k.Value)))
    Workbench29_Show(g,"w940")
}

Calc_RunDkaTreatment(wtCtrl, quickFluidCtrl, phaseCtrl, mentalCtrl, fluidRiskCtrl, sglt2Ctrl, pregCtrl, glucCtrl, naCtrl, kCtrl, clCtrl, bicarbCtrl, phCtrl, bhbCtrl, phosCtrl, mgCtrl, insulinRunningCtrl, insulinRateCtrl, result) {
    wtTxt := Trim(wtCtrl.Value)
    gluc := DkaMaybeNumber(glucCtrl.Value), na := DkaMaybeNumber(naCtrl.Value), k := DkaMaybeNumber(kCtrl.Value)
    if quickFluidCtrl.Value = 1 {
        result.Value := DkaQuickFluidOnlyPlan(gluc, k, fluidRiskCtrl.Text, insulinRunningCtrl.Text, insulinRateCtrl.Value)
        return
    }
    if !IsNumber(wtTxt) or Number(wtTxt) <= 0 {
        MsgBox "Enter weight in kg, or check quick fluid-only mode.", "DKA Treatment", "Icon!"
        return
    }
    wt := Number(wtTxt)
    cl := DkaMaybeNumber(clCtrl.Value), bicarb := DkaMaybeNumber(bicarbCtrl.Value), ph := DkaMaybeNumber(phCtrl.Value)
    bhb := DkaMaybeNumber(bhbCtrl.Value), phos := DkaMaybeNumber(phosCtrl.Value), mg := DkaMaybeNumber(mgCtrl.Value)
    currentInsulinRate := DkaMaybeNumber(insulinRateCtrl.Value)

    corrNa := ""
    effOsm := ""
    gap := ""
    corrNaText := "Not calculated"
    effOsmText := "Not calculated"
    gapText := "Not calculated"
    if DkaHas(gluc) and DkaHas(na) {
        corrNa := na + 1.6 * Max(0, ((gluc - 100) / 100))
        effOsm := 2 * na + gluc / 18
        corrNaText := Round(corrNa, 1) " mEq/L using +1.6 per 100 mg/dL glucose above 100; some protocols use larger correction factors in marked hyperglycemia."
        effOsmText := Round(effOsm, 1) " mOsm/kg = 2 x Na + glucose/18"
    }
    if DkaHas(na) and DkaHas(cl) and DkaHas(bicarb) {
        gap := na - cl - bicarb
        gapText := Round(gap, 1) " mEq/L. Use cautiously; beta-hydroxybutyrate and pH/bicarbonate are preferred for diagnosis/resolution when available."
    }

    severity := DkaSeveritySummary(bhb, ph, bicarb, mentalCtrl.Text, pregCtrl.Value)
    fluidPlan := DkaFluidPlan(wt, gluc, na, DkaHas(gluc) && DkaHas(na) ? corrNa : "", phaseCtrl.Text, fluidRiskCtrl.Text)
    insulinPlan := DkaInsulinPlan(wt, gluc, k, phaseCtrl.Text, insulinRunningCtrl.Text, currentInsulinRate)
    electrolytePlan := DkaElectrolytePlan(k, phos, mg, bicarb, ph)
    monitoringPlan := DkaMonitoringPlan(phaseCtrl.Text, sglt2Ctrl.Value, pregCtrl.Value)
    transitionPlan := DkaTransitionPlan(wt, gluc, bhb, ph, bicarb, gapText)

    out := "DKA TREATMENT SUPPORT SUMMARY`r`n"
    out .= "Use with institutional DKA order set and clinician judgment. Treat precipitating cause, assess infection/MI/stroke/pancreatitis/insulin omission/SGLT2 inhibitor use, and reassess frequently.`r`n`r`n"
    out .= "INPUTS / CALCULATED CONTEXT`r`n"
    out .= "- Weight: " Round(wt, 1) " kg`r`n"
    out .= "- Phase: " phaseCtrl.Text "; clinical status: " mentalCtrl.Text "; fluid risk: " fluidRiskCtrl.Text "`r`n"
    out .= "- Corrected sodium: " corrNaText "`r`n"
    out .= "- Effective osmolality: " effOsmText "`r`n"
    out .= "- Anion gap: " gapText "`r`n"
    if sglt2Ctrl.Value
        out .= "- SGLT2/euglycemic DKA flag: do not exclude DKA solely because glucose is <250 mg/dL; prioritize ketones, pH, bicarbonate, clinical context.`r`n"
    if pregCtrl.Value
        out .= "- Special population flag: pregnancy/pediatric/special population requires local specialist protocol; thresholds and disposition may differ.`r`n"

    out .= "`r`nSEVERITY / DISPOSITION SIGNAL`r`n" severity
    out .= "`r`nINITIAL + ONGOING FLUID STRATEGY`r`n" fluidPlan
    out .= "`r`nINSULIN STRATEGY`r`n" insulinPlan
    out .= "`r`nELECTROLYTE SUPPLEMENTATION`r`n" electrolytePlan
    out .= "`r`nMONITORING / SAFETY CHECKS`r`n" monitoringPlan
    out .= "`r`nTRANSITION / RESOLUTION CHECKLIST`r`n" transitionPlan
    out .= "`r`nSource note: adult DKA/HHS guidance follows the 2024 international consensus report. Key points: isotonic saline or balanced crystalloid 500-1000 mL/hr for 2-4 hr in patients without cardiac/renal compromise; add D5-D10 when glucose <250 mg/dL; IV insulin 0.1 units/kg/hr for DKA; postpone insulin when K <3.5 mEq/L; target K 4-5 mEq/L; routine bicarbonate/phosphate are not recommended, with bicarbonate considered for pH <7.0 and phosphate considered for significant hypophosphatemia or cardiopulmonary/muscle weakness."
    result.Value := out
}

DkaQuickFluidOnlyPlan(gluc, k, fluidRisk, insulinRunning, insulinRateText) {
    out := "DKA QUICK FLUID-ONLY SUPPORT`r`n"
    out .= "This quick mode uses only glucose and potassium plus volume-risk flag. It does not diagnose DKA or replace the full DKA order set.`r`n`r`n"
    if InStr(fluidRisk, "Shock")
        out .= "Fluid rate: shock/hypoperfusion -> isotonic crystalloid boluses with bedside reassessment; consider ICU/vasopressors/source workup.`r`n"
    else if InStr(fluidRisk, "Older")
        out .= "Fluid rate: CHF/ESRD/older/overload risk -> smaller boluses or slower isotonic crystalloid, commonly 250-500 mL/hr or protocol-specific, with frequent reassessment.`r`n"
    else
        out .= "Fluid rate: initial isotonic crystalloid 500-1000 mL/hr for first 2-4 hours, then reassess hemodynamics, urine output, corrected sodium, and glucose fall.`r`n"
    if DkaHas(gluc) {
        if gluc < 250
            out .= "Fluid selection by glucose: glucose <250 -> add dextrose-containing fluid now, typically D5-0.45% saline or D5/D10-containing protocol fluid, so insulin can continue until ketosis/acidosis resolves.`r`n"
        else if gluc <= 300
            out .= "Fluid selection by glucose: glucose approaching 250 -> prepare dextrose-containing fluid; switch/add dextrose when <250 or earlier if rapid fall/euglycemic DKA risk.`r`n"
        else
            out .= "Fluid selection by glucose: glucose >=300 -> dextrose usually not needed initially; use isotonic crystalloid unless euglycemic DKA/SGLT2 or rapid glucose fall risk.`r`n"
    } else
        out .= "Fluid selection by glucose: glucose not entered; enter glucose to decide whether dextrose-containing fluid is needed.`r`n"
    if DkaHas(k) {
        if k < 3.5
            out .= "Potassium: K <3.5 -> hold insulin and replace potassium before/while continuing fluids; telemetry/central-line protocol may be needed for aggressive replacement.`r`n"
        else if k < 5.0
            out .= "Potassium: K 3.5-<5.0 -> potassium supplementation is usually needed with ongoing fluids/IVPB, targeting K 4-5 while insulin runs.`r`n"
        else
            out .= "Potassium: K >=5.0 -> do not add potassium initially; monitor frequently and begin replacement once K falls below 5 and renal/urine output status allows.`r`n"
    } else
        out .= "Potassium: K not entered. Obtain K before starting insulin.`r`n"
    if InStr(insulinRunning, "Yes") {
        rate := DkaMaybeNumber(insulinRateText)
        out .= "Insulin infusion: marked running" (DkaHas(rate) ? " at " Round(rate,2) " units/hr" : "") ". Continue insulin with dextrose as needed until ketosis/acidosis resolves; do not stop solely because glucose normalizes.`r`n"
    }
    out .= "`r`nUse the full DKA calculator when sodium/corrected sodium, bicarbonate/pH, anion gap, phosphate, magnesium, severity, or transition planning is needed."
    return out
}

DkaMaybeNumber(v) {
    v := Trim(v)
    if v = ""
        return ""
    return IsNumber(v) ? Number(v) : ""
}

DkaHas(v) {
    return IsNumber(v)
}

DkaSeveritySummary(bhb, ph, bicarb, mentalText, specialPop) {
    out := ""
    flags := []
    if DkaHas(bhb) {
        if bhb > 6
            flags.Push("BHB >6 mmol/L: severe DKA signal")
        else if bhb >= 3
            flags.Push("BHB >=3 mmol/L: DKA ketosis criterion met")
    } else
        flags.Push("BHB not entered; quantitative beta-hydroxybutyrate is preferred when available")
    if DkaHas(ph) {
        if ph < 7.0
            flags.Push("pH <7.0: severe acidosis / ICU-level concern")
        else if ph < 7.25
            flags.Push("pH 7.0-7.25: moderate acidosis signal")
        else if ph < 7.3
            flags.Push("pH <7.3: acidosis criterion met")
    }
    if DkaHas(bicarb) {
        if bicarb < 10
            flags.Push("bicarbonate <10: severe DKA signal")
        else if bicarb < 15
            flags.Push("bicarbonate 10-<15: moderate DKA signal")
        else if bicarb < 18
            flags.Push("bicarbonate <18: acidosis criterion met")
    }
    if InStr(mentalText, "Stupor") or InStr(mentalText, "critical")
        flags.Push("altered mental status/critical illness: ICU-level concern")
    else if InStr(mentalText, "Drowsy")
        flags.Push("drowsy/concerning mental status: step-down/ICU discussion")
    if specialPop
        flags.Push("special population: use specialist/institutional pathway")

    if flags.Length = 0
        return "- No severity inputs entered. Confirm DKA diagnosis with glucose/history, BHB or ketones, and pH/bicarbonate before relying on this pathway.`r`n"
    for _, f in flags
        out .= "- " f ".`r`n"
    out .= "- Suggested framing: mild/moderate uncomplicated DKA may be protocol-managed with close nursing; severe DKA, HHS/mixed crisis, critical illness, pregnancy/pediatric, ESRD/CHF complexity, or altered mental status needs higher-level team involvement.`r`n"
    return out
}

DkaFluidPlan(wt, gluc, na, corrNa, phase, fluidRisk) {
    out := ""
    if InStr(fluidRisk, "Shock") {
        out .= "- Shock/hypoperfusion: prioritize resuscitation with isotonic crystalloid boluses and bedside reassessment. Consider ICU, vasopressors, infection/bleeding/cardiac workup as appropriate.`r`n"
    } else if InStr(fluidRisk, "Older") {
        out .= "- CHF/ESRD/older/overload risk: use smaller boluses or slower isotonic crystalloid with frequent lung exam, I/O, hemodynamics, and nephrology/ICU input; avoid automatic large-volume replacement.`r`n"
    } else {
        out .= "- Initial fluid: balanced crystalloid or 0.9% saline 500-1000 mL/hr for the first 2-4 hours, then reassess hemodynamics, urine output, sodium trend, and corrected sodium.`r`n"
    }

    if DkaHas(corrNa) {
        if corrNa < 135
            out .= "- Corrected Na low: after initial resuscitation, continue isotonic fluid strategy rather than hypotonic fluid unless team directs otherwise.`r`n"
        else if corrNa > 145
            out .= "- Corrected Na high: after intravascular volume is restored, consider hypotonic maintenance strategy such as 0.45% saline per protocol while avoiding rapid osmolality/sodium shifts.`r`n"
        else
            out .= "- Corrected Na near normal: after initial resuscitation, choose balanced crystalloid/0.9% saline vs 0.45% saline based on sodium trend, osmolality change, chloride/acidosis, and protocol.`r`n"
    } else
        out .= "- Corrected sodium not available: enter glucose and sodium to support ongoing fluid selection.`r`n"

    if DkaHas(gluc) {
        if gluc < 250
            out .= "- Glucose <250: add dextrose now, usually D5-D10 containing fluid, so insulin can continue until ketosis/acidosis resolves. Do not stop insulin solely because glucose normalized.`r`n"
        else if gluc <= 300
            out .= "- Glucose approaching 250: prepare to add D5-D10 when below threshold while continuing insulin to clear ketones.`r`n"
        else
            out .= "- Glucose >=300: dextrose usually not needed yet unless euglycemic DKA/SGLT2, rapid glucose fall, or hypoglycemia risk; monitor hourly or q1-2h.`r`n"
    }

    if InStr(phase, "dextrose")
        out .= "- Dextrose phase: titrate D5 vs D10 and insulin rate to maintain glucose around 150-250/approximately 200 mg/dL while closing ketosis/acidosis.`r`n"
    return out
}

DkaInsulinPlan(wt, gluc, k, phase, insulinRunning, currentRate := "") {
    out := ""
    stdRate := Round(wt * 0.1, 2)
    hhsRate := Round(wt * 0.05, 2)
    if DkaHas(k) and k < 3.5 {
        out .= "- Potassium <3.5 mEq/L: hold/postpone insulin; give potassium replacement and recheck until K >3.5 because insulin can precipitate life-threatening hypokalemia.`r`n"
    } else {
        out .= "- IV insulin for DKA: fixed-rate regular insulin infusion 0.1 units/kg/hr = " stdRate " units/hr. Bolus is usually unnecessary when infusion is started promptly.`r`n"
        out .= "- If HHS without significant ketonemia/acidosis is actually the dominant syndrome, typical fixed rate is 0.05 units/kg/hr = " hhsRate " units/hr; mixed HHS/DKA should be treated as DKA.`r`n"
    }
    if InStr(insulinRunning, "Yes") and DkaHas(currentRate)
        out .= "- Current insulin infusion entered: " Round(currentRate,2) " units/hr. Weight-based DKA target displayed above is " stdRate " units/hr; reconcile with local titration protocol and current glucose/K trend.`r`n"
    else if InStr(insulinRunning, "Yes")
        out .= "- Insulin infusion is marked running; enter current units/hr if you want this output to compare current vs weight-based rate.`r`n"
    if DkaHas(gluc) and gluc < 250
        out .= "- Because glucose is <250, continue insulin but pair with dextrose-containing fluid and titrate to prevent hypoglycemia while clearing ketones.`r`n"
    if InStr(insulinRunning, "SQ")
        out .= "- SQ rapid-acting insulin protocols may be appropriate only for uncomplicated mild/moderate DKA with close nursing and local protocol support; not for severe DKA/HHS/critical illness.`r`n"
    if InStr(phase, "Transition")
        out .= "- Before stopping infusion: give basal insulin at least 1-2 hours before discontinuation, ensure patient can eat or has nutrition plan, and confirm DKA resolution criteria.`r`n"
    return out
}

DkaElectrolytePlan(k, phos, mg, bicarb, ph) {
    out := ""
    if DkaHas(k) {
        if k < 3.5
            out .= "- Potassium: K <3.5. Hold insulin; replace potassium, commonly 10 mEq/hr or per central-line/telemetry protocol if more aggressive replacement is required; reassess frequently.`r`n"
        else if k < 5.0
            out .= "- Potassium: K 3.5-<5.0. Add potassium to IV fluids or provide IVPB replacement per protocol, commonly 20-30 mEq/L equivalent, targeting K 4-5 mEq/L.`r`n"
        else
            out .= "- Potassium: K >=5.0. Do not give potassium initially; monitor q2-4h and start replacement once K falls below 5.0 and urine output/renal status permit.`r`n"
    } else
        out .= "- Potassium: not entered. Obtain potassium before insulin; potassium status determines whether insulin can safely start.`r`n"

    if DkaHas(mg) {
        if mg < 1.8
            out .= "- Magnesium: low. Replace magnesium IVPB per protocol, especially if hypokalemia is present or refractory.`r`n"
        else
            out .= "- Magnesium: monitor with potassium/phosphate; replace per local protocol if trending low.`r`n"
    }

    if DkaHas(phos) {
        if phos < 1.0
            out .= "- Phosphate: very low. Give IV phosphate per protocol; choose potassium phosphate vs sodium phosphate based on potassium level and renal status.`r`n"
        else if phos < 2.0
            out .= "- Phosphate: low. Consider IV phosphate if weakness, respiratory/cardiac dysfunction, hemolysis, or ongoing decline; otherwise monitor and replace per protocol.`r`n"
        else
            out .= "- Phosphate: routine phosphate is not recommended; monitor because insulin therapy can lower phosphate.`r`n"
    } else
        out .= "- Phosphate: not entered. Check baseline and serial phosphate; replace IVPB when clinically indicated rather than routine replacement.`r`n"

    if (DkaHas(ph) and ph < 7.0) or (DkaHas(bicarb) and bicarb < 5) {
        out .= "- Bicarbonate: severe acidosis flag. Consider sodium bicarbonate only for pH <7.0 per protocol; one common regimen is 100 mmol sodium bicarbonate in 400 mL sterile water, repeated q2h until pH >7.0. Watch potassium closely.`r`n"
    } else
        out .= "- Bicarbonate: routine bicarbonate is not recommended; fluids and insulin usually correct ketoacidosis.`r`n"
    return out
}

DkaMonitoringPlan(phase, sglt2, specialPop) {
    out := "- Bedside glucose every 1-2 hours until stable; avoid overly rapid glucose/osmolality shifts.`r`n"
    out .= "- Electrolytes, creatinine, phosphate, beta-hydroxybutyrate, and venous pH about every 4 hours until resolution; potassium often needs earlier repeat about 2 hours after insulin starts and q4h thereafter.`r`n"
    out .= "- Strict I/O, mental status, hemodynamics, precipitating cause treatment, infection/cardiac evaluation when indicated.`r`n"
    if sglt2
        out .= "- SGLT2/euglycemic DKA: expect glucose may be lower; dextrose plus insulin may be needed earlier to clear ketones safely.`r`n"
    if specialPop
        out .= "- Special population: use local pediatric/pregnancy/dialysis protocol; fluid and insulin thresholds may differ.`r`n"
    return out
}

DkaTransitionPlan(wt, gluc, bhb, ph, bicarb, gapText) {
    out := "- Resolution targets generally include improving/cleared ketonemia, pH >=7.3 and/or bicarbonate >=18, clinical improvement, and ability to transition safely. Do not use glucose alone as the resolution endpoint.`r`n"
    tddLow := Round(wt * 0.3, 1), tddHigh := Round(wt * 0.6, 1)
    out .= "- If new insulin regimen is needed, rough total daily dose estimate is 0.3-0.6 units/kg/day = " tddLow "-" tddHigh " units/day, individualized for insulin sensitivity, renal function, nutrition, home regimen, and hypoglycemia risk.`r`n"
    out .= "- Give basal insulin at least 1-2 hours before stopping IV insulin; longer overlap may be used with long-acting analog timing or local protocol.`r`n"
    out .= "- Confirm precipitating cause addressed, sick-day education/ketone testing plan, supplies, and follow-up before discharge.`r`n"
    return out
}

; -------------------------------------------------------------------------------------------------
; CRRT — premade solution and electrolyte supplementation structured support
; -------------------------------------------------------------------------------------------------
Calc_OpenCrrtDosing() {
    g := Gui("+Resize", "CRRT Solution / Electrolyte Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w840 cRed", "Structured CRRT support only. Verify CRRT mode, anticoagulation strategy, hemodynamics, local nephrology/ICU protocol, and product availability. This tool selects premade solutions and suggests IVPB supplementation rather than customizing CRRT bags.").SetFont("s10 bold")

    g.Add("GroupBox", "xm y+10 w410 h205", "Prescription / CRRT Mode")
    g.Add("Text", "xp+14 yp+28", "CRRT modality:")
    mode := g.Add("DropDownList", "x170 yp w150", ["CVVHDF", "CVVHD", "CVVH"])
    mode.Value := 1
    g.Add("Text", "xm+14 y+8", "Anticoagulation:")
    anticoag := g.Add("DropDownList", "x170 yp w220", ["None / heparin / not citrate", "Regional citrate anticoagulation"])
    anticoag.Value := 1
    g.Add("Text", "xm+14 y+8", "Weight (kg):")
    wt := g.Add("Edit", "x170 yp w80")
    g.Add("Text", "xm+14 y+8", "Prescribed target:")
    target := g.Add("DropDownList", "x170 yp w150", ["25 mL/kg/hr", "30 mL/kg/hr", "20 mL/kg/hr", "Custom"])
    target.Value := 1
    g.Add("Text", "xm+14 y+8", "Custom target mL/kg/hr:")
    customTarget := g.Add("Edit", "x210 yp w70")
    g.Add("Text", "xm+14 y+8", "Current total effluent mL/hr:")
    effluent := g.Add("Edit", "x210 yp w80")

    g.Add("GroupBox", "x430 ym+38 w430 h205", "BMP / Chemistry Input")
    g.Add("Text", "xp+14 yp+28", "Na:")
    na := g.Add("Edit", "x490 yp w55")
    g.Add("Text", "x+12 yp", "K:")
    k := g.Add("Edit", "x+4 yp w55")
    g.Add("Text", "x+12 yp", "Cl:")
    cl := g.Add("Edit", "x+4 yp w55")
    g.Add("Text", "x+12 yp", "CO2/HCO3:")
    bicarb := g.Add("Edit", "x+4 yp w55")
    g.Add("Text", "x444 y+10", "Ca:")
    ca := g.Add("Edit", "x490 yp w55")
    g.Add("Text", "x+12 yp", "Mg:")
    mg := g.Add("Edit", "x+4 yp w55")
    g.Add("Text", "x+12 yp", "Phos:")
    phos := g.Add("Edit", "x+4 yp w55")
    g.Add("Text", "x+12 yp", "Glucose:")
    gluc := g.Add("Edit", "x+4 yp w60")
    g.Add("Text", "x444 y+10", "Units assumed: Na/K/Cl/CO2 mEq/L; Ca/Mg/Phos mg/dL; glucose mg/dL.")
    g.Add("Text", "x444 y+8", "Optional context:")
    context := g.Add("Edit", "x550 yp w280", "e.g., DKA, tumor lysis, rhabdo, shock, liver failure")
    unstable := g.Add("CheckBox", "x444 y+8", "Hemodynamic instability/shock or rapidly changing electrolytes")

    result := g.Add("Edit", "xm y+20 w860 h430 ReadOnly -Wrap")
    g.Add("Button", "xm y+10 w140 Default", "Build CRRT Summary").OnEvent("Click", (*) => SafeRun(Calc_RunCrrtDosing, mode, anticoag, wt, target, customTarget, effluent, na, k, cl, bicarb, ca, mg, phos, gluc, context, unstable, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    parsed := PBind_CurrentParsed()
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_Set(na, PBind_Lab("sodium"))
    PBind_Set(k, PBind_Lab("potassium"))
    PBind_Set(cl, PBind_Lab("chloride"))
    PBind_Set(bicarb, PBind_Lab("bicarbonate"))
    PBind_Set(ca, PBind_Lab("calcium"))
    PBind_Set(mg, PBind_Lab("magnesium"))
    PBind_Set(phos, PBind_Lab("phosphate"))
    PBind_Set(gluc, PBind_Lab("glucose"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wt.Value, "Potassium", k.Value, "Bicarbonate", bicarb.Value)))
    Workbench29_Show(g,"w900")
}

Calc_RunCrrtDosing(modeCtrl, anticoagCtrl, wtCtrl, targetCtrl, customTargetCtrl, effluentCtrl, naCtrl, kCtrl, clCtrl, bicarbCtrl, caCtrl, mgCtrl, phosCtrl, glucCtrl, contextCtrl, unstableCtrl, result) {
    wtTxt := Trim(wtCtrl.Value)
    if !IsNumber(wtTxt) or Number(wtTxt) <= 0 {
        MsgBox "Enter weight in kg.", "CRRT", "Icon!"
        return
    }
    wt := Number(wtTxt)
    targetDose := 25
    if targetCtrl.Text = "20 mL/kg/hr"
        targetDose := 20
    else if targetCtrl.Text = "30 mL/kg/hr"
        targetDose := 30
    else if targetCtrl.Text = "Custom" {
        if !IsNumber(Trim(customTargetCtrl.Value)) or Number(Trim(customTargetCtrl.Value)) <= 0 {
            MsgBox "Enter a custom target dose in mL/kg/hr, or choose a standard target.", "CRRT", "Icon!"
            return
        }
        targetDose := Number(Trim(customTargetCtrl.Value))
    }
    k := Calc_ReadOptionalNumber(kCtrl)
    bicarb := Calc_ReadOptionalNumber(bicarbCtrl)
    ca := Calc_ReadOptionalNumber(caCtrl)
    mg := Calc_ReadOptionalNumber(mgCtrl)
    phos := Calc_ReadOptionalNumber(phosCtrl)
    na := Calc_ReadOptionalNumber(naCtrl)
    gluc := Calc_ReadOptionalNumber(glucCtrl)
    citrate := (anticoagCtrl.Text = "Regional citrate anticoagulation")

    out := "CRRT SOLUTION / ELECTROLYTE SUPPORT SUMMARY`r`n"
    out .= "Use as decision support only. Final CRRT orders require nephrology/ICU verification, local protocol, product availability, and frequent lab reassessment. Do not customize premade CRRT bags in this workflow; use premade solutions and separate IVPB electrolyte replacement.`r`n`r`n"

    out .= "CRRT mode: " modeCtrl.Text ". Anticoagulation: " anticoagCtrl.Text ".`r`n"
    out .= "Weight: " Round(wt,1) " kg. Prescribed target selected: " targetDose " mL/kg/hr.`r`n"
    targetEff := Round(wt * targetDose)
    out .= "Target total effluent: approximately " targetEff " mL/hr. Practical bedside range: " Round(wt*20) " to " Round(wt*25) " mL/hr for delivered 20-25 mL/kg/hr; many sites prescribe about 25-30 mL/kg/hr to account for interruptions/downtime.`r`n"
    if IsNumber(Trim(effluentCtrl.Value)) and Number(Trim(effluentCtrl.Value)) > 0 {
        eff := Number(Trim(effluentCtrl.Value))
        out .= "Current entered effluent: " Round(eff) " mL/hr = " Round(eff/wt,1) " mL/kg/hr.`r`n"
    }
    out .= "Suggested flow framing: " Calc_CrrtFlowSuggestion(modeCtrl.Text, targetEff) "`r`n`r`n"

    flags := []
    if CrrtHas(k) {
        if k >= 6.0
            flags.Push("severe hyperkalemia")
        else if k >= 5.5
            flags.Push("hyperkalemia")
        else if k < 3.5
            flags.Push("hypokalemia")
    }
    if CrrtHas(phos) {
        if phos < 1.5
            flags.Push("severe hypophosphatemia")
        else if phos < 2.5
            flags.Push("hypophosphatemia")
        else if phos > 5.5
            flags.Push("hyperphosphatemia")
    }
    if CrrtHas(bicarb) {
        if bicarb < 18
            flags.Push("metabolic acidosis/low bicarbonate")
        else if bicarb > 30
            flags.Push("alkalosis/high bicarbonate")
    }
    if CrrtHas(na) {
        if na < 130
            flags.Push("hyponatremia - avoid rapid correction")
        else if na > 150
            flags.Push("hypernatremia - avoid rapid correction")
    }
    if unstableCtrl.Value
        flags.Push("unstable/rapidly changing course")
    if flags.Length
        out .= "Key flags from input: " JoinArray(flags, ", ") ".`r`n`r`n"

    rec := Calc_CrrtRecommendSolutions(k, phos, bicarb, ca, citrate)
    out .= "PREMADE CRRT SOLUTION RECOMMENDATION`r`n"
    out .= rec.primary "`r`n"
    if rec.alternate != ""
        out .= "Alternative / conditional: " rec.alternate "`r`n"
    out .= "Rationale: " rec.reason "`r`n`r`n"

    out .= "ELECTROLYTE SUPPLEMENTATION / MONITORING PLAN`r`n"
    out .= Calc_CrrtSupplementPlan(k, phos, mg, ca, bicarb, na, gluc, citrate)
    out .= "`r`n"

    out .= "Premade solution reference library used by this tool:`r`n"
    out .= "- PRISMASOL BGK0/2.5: K 0, Ca 2.5, Mg 1.5, HCO3 32, phosphate 0.`r`n"
    out .= "- PRISMASOL BGK4/2.5: K 4, Ca 2.5, Mg 1.5, HCO3 32, phosphate 0.`r`n"
    out .= "- PRISMASOL BGK2/3.5: K 2, Ca 3.5, Mg 1, HCO3 32, phosphate 0.`r`n"
    out .= "- PRISMASOL BGK2/0: K 2, Ca 0, Mg 1, HCO3 32, phosphate 0.`r`n"
    out .= "- PRISMASOL B22GK4/0: K 4, Ca 0, Mg 1.5, HCO3 22, phosphate 0.`r`n"
    out .= "- PRISMASOL BGK4/0/1.2: K 4, Ca 0, Mg 1.2, HCO3 32, phosphate 0.`r`n"
    out .= "- PRISMASOL BK0/0/1.2: K 0, Ca 0, Mg 1.2, HCO3 32, phosphate 0.`r`n"
    out .= "- PHOXILLUM BK4/2.5: K 4, Ca 2.5, Mg 1.5, HCO3 32, phosphate 1 mmol/L.`r`n"
    out .= "- PHOXILLUM B22K4/0: K 4, Ca 0, Mg 1.5, HCO3 22, phosphate 1 mmol/L.`r`n`r`n"

    out .= "Clinical caveats:`r`n"
    out .= "- CRRT solution choice does not replace IVPB electrolyte replacement; hypophosphatemia, hypokalemia, and hypomagnesemia commonly require separate replacement protocols.`r`n"
    out .= "- For regional citrate anticoagulation, calcium-free solutions are usually used with a separate calcium infusion/titration protocol; monitor systemic and post-filter ionized calcium, total calcium/ionized calcium ratio, acid-base status, and citrate accumulation risk.`r`n"
    out .= "- If using phosphate-containing solutions, avoid additional phosphate in the CRRT bag; give IVPB sodium/potassium phosphate only when clinically needed and compatible with potassium status.`r`n"
    out .= "- Sodium disorders require controlled correction goals. Adjust replacement/dialysate strategy only with nephrology oversight rather than ad hoc bag manipulation.`r`n"
    out .= "- Recheck BMP/Mg/Phos/ionized Ca frequently, often every 4-6 hours during initiation or instability, then per protocol.`r`n"
    out .= "`r`nSource note: effluent dose framing follows KDIGO-style delivered CRRT dose targets of 20-25 mL/kg/hr. Premade solution compositions follow PRISMASOL/PHOXILLUM labeling. Product labels state therapy must be individualized to clinical condition, fluid/electrolyte/acid-base/glucose balance, and that phosphate additions to bags have product-specific limits; this tool intentionally recommends IVPB supplementation rather than CRRT-bag customization."
    result.Value := out
}

Calc_ReadOptionalNumber(ctrl) {
    txt := Trim(ctrl.Value)
    if txt = ""
        return ""
    if !IsNumber(txt)
        return ""
    return Number(txt)
}

CrrtHas(value) {
    return value != ""
}

Calc_CrrtFlowSuggestion(mode, targetEff) {
    if mode = "CVVHD"
        return "dialysate about " targetEff " mL/hr; replacement fluid 0 unless needed by protocol; net fluid removal ordered separately from solute-dose target."
    if mode = "CVVH"
        return "replacement fluid total about " targetEff " mL/hr, split pre/post filter per filter-life and clearance needs; remember pre-dilution lowers effective solute clearance."
    return "dialysate plus pre/post replacement should sum to about " targetEff " mL/hr, split per protocol; net patient fluid removal is ordered separately."
}

Calc_CrrtRecommendSolutions(k, phos, bicarb, ca, citrate) {
    primary := ""
    alternate := ""
    reason := ""
    highK := CrrtHas(k) and k >= 5.5
    severeHighK := CrrtHas(k) and k >= 6.0
    lowK := CrrtHas(k) and k < 3.5
    lowPhos := CrrtHas(phos) and phos < 2.5
    severeLowPhos := CrrtHas(phos) and phos < 1.5
    highPhos := CrrtHas(phos) and phos > 5.5
    lowBicarb := CrrtHas(bicarb) and bicarb < 18
    highBicarb := CrrtHas(bicarb) and bicarb > 30
    highCa := CrrtHas(ca) and ca > 10.5

    if citrate or highCa {
        if highK {
            primary := "Use a calcium-free, potassium-free premade solution if available: PRISMASOL BK0/0/1.2."
            alternate := "If potassium falls or is not severely elevated, PRISMASOL BGK2/0 may be a transition option; with hypophosphatemia, supplement phosphate IVPB rather than choosing K4 Phoxillum during hyperkalemia."
            reason := "Citrate/high calcium favors calcium-free fluid; hyperkalemia favors K0 or K2 rather than K4."
        } else if lowPhos and !highK {
            primary := "Use PHOXILLUM B22K4/0 if bicarbonate/alkalosis favors HCO3 22, or consider calcium-free PRISMASOL plus IVPB phosphate if HCO3 32 is desired."
            alternate := "PHOXILLUM contains K 4 and phosphate 1 mmol/L, so avoid it if potassium is high or rising."
            reason := "Calcium-free fluid is preferred with citrate; phosphate-containing fluid helps reduce IVPB phosphate needs only when potassium status allows."
        } else if highBicarb {
            primary := "Use calcium-free lower-bicarbonate fluid: PRISMASOL B22GK4/0 if K 4 is acceptable; avoid if potassium is high."
            alternate := "PRISMASOL BGK2/0 or BK0/0/1.2 if potassium is elevated and alkalosis management requires nephrology adjustment."
            reason := "Alkalosis favors a lower bicarbonate premade solution; citrate/high calcium favors calcium-free solution."
        } else {
            primary := "Use a calcium-free premade solution matched to potassium: PRISMASOL BGK2/0 for K around normal/high-normal, BGK4/0/1.2 if K is low/normal, or BK0/0/1.2 if K is high."
            alternate := "Add phosphate by IVPB if phosphate is low; use separate calcium infusion/titration for citrate protocols."
            reason := "Calcium-free solutions support citrate protocols or hypercalcemia management while potassium content is selected from serum trend."
        }
    } else if severeHighK {
        primary := "Use potassium-free premade solution: PRISMASOL BGK0/2.5."
        alternate := "If calcium-free fluid is needed, use PRISMASOL BK0/0/1.2 with separate calcium management. Transition to K2/K4 solution only after potassium is controlled."
        reason := "Severe hyperkalemia favors K0 CRRT fluid initially; avoid K4 phosphate-containing solutions until potassium is safer."
    } else if highK {
        primary := "Use potassium-free or low-potassium premade solution: PRISMASOL BGK0/2.5 or BGK2/3.5 depending on potassium trajectory and ECG urgency."
        alternate := "If phosphate is very low, replace phosphate IVPB with sodium phosphate preferentially while potassium remains high."
        reason := "Hyperkalemia favors K0/K2 fluid; phosphate-containing Phoxillum has K 4 and may worsen potassium management."
    } else if lowPhos and !lowK {
        if highBicarb
            primary := "Use phosphate-containing lower-bicarbonate premade solution: PHOXILLUM B22K4/0 if K 4 and calcium-free fluid are acceptable."
        else
            primary := "Use phosphate-containing premade solution: PHOXILLUM BK4/2.5 if K 4 and Ca 2.5 are acceptable."
        alternate := "For severe hypophosphatemia or ongoing losses, give IVPB phosphate per protocol in addition to phosphate-containing CRRT fluid."
        reason := "Hypophosphatemia favors Phoxillum (phosphate 1 mmol/L), but it supplies K 4 so potassium must be monitored."
    } else if lowK {
        primary := "Use potassium-containing premade solution: PRISMASOL BGK4/2.5 or PHOXILLUM BK4/2.5 if phosphate is also low."
        alternate := "Give IVPB potassium replacement per protocol; do not add potassium to the CRRT bag outside approved local compounding process."
        reason := "Hypokalemia favors K4 fluid plus separate potassium replacement when needed."
    } else if highPhos {
        primary := "Use phosphate-free premade solution matched to potassium: PRISMASOL BGK2/3.5 or BGK4/2.5; use BGK0/2.5 if potassium is high."
        alternate := "Avoid Phoxillum until phosphate is controlled."
        reason := "Hyperphosphatemia favors phosphate-free CRRT fluid."
    } else if highBicarb {
        primary := "Consider lower-bicarbonate premade solution if potassium/calcium status permits: PRISMASOL B22GK4/0 or PHOXILLUM B22K4/0."
        alternate := "If K4 or calcium-free fluid is not appropriate, continue standard HCO3 32 solution with nephrology-directed adjustments."
        reason := "High bicarbonate/alkalosis favors lower-bicarbonate premade fluid when compatible with electrolytes and anticoagulation."
    } else if lowBicarb {
        primary := "Use standard bicarbonate 32 premade solution matched to potassium/phosphate: PRISMASOL BGK2/3.5 or BGK4/2.5; PHOXILLUM BK4/2.5 if phosphate is low and K4 acceptable."
        alternate := "Severe acidosis may require CRRT dose/flow adjustment, shock management, and/or separate bicarbonate strategy per ICU/nephrology protocol."
        reason := "Low bicarbonate favors standard HCO3 32 solutions rather than B22 products."
    } else {
        primary := "Use a standard premade solution matched to potassium trend: PRISMASOL BGK2/3.5 or BGK4/2.5."
        alternate := "If phosphate begins to fall, transition to PHOXILLUM BK4/2.5 when K4 is acceptable or give IVPB phosphate per protocol."
        reason := "No dominant BMP flag was entered; choose premade solution based on potassium, phosphate trend, calcium strategy, and local stock."
    }
    return { primary: primary, alternate: alternate, reason: reason }
}

Calc_CrrtSupplementPlan(k, phos, mg, ca, bicarb, na, gluc, citrate) {
    out := ""
    if CrrtHas(k) {
        if k < 3.0
            out .= "- Potassium: K <3.0. Use K4 premade solution if compatible and give IVPB potassium replacement urgently per protocol with telemetry/rechecks; assess Mg.`r`n"
        else if k < 3.5
            out .= "- Potassium: low. Prefer K4 premade solution and IVPB potassium supplementation per protocol; recheck frequently.`r`n"
        else if k >= 6.0
            out .= "- Potassium: severe hyperkalemia. Prefer K0 CRRT fluid initially plus standard hyperkalemia stabilization/shift/removal protocol; avoid K-containing phosphate replacement unless directed.`r`n"
        else if k >= 5.5
            out .= "- Potassium: elevated. Prefer K0/K2 fluid, hold potassium supplementation, and use sodium phosphate rather than potassium phosphate if phosphate replacement is needed.`r`n"
        else
            out .= "- Potassium: no major flag from entered value; trend with CRRT intensity and replacement needs.`r`n"
    } else
        out .= "- Potassium: not entered; select solution only after current potassium and trend are known.`r`n"

    if CrrtHas(phos) {
        if phos < 1.5
            out .= "- Phosphate: severe hypophosphatemia. Use phosphate-containing CRRT fluid if potassium allows and give IVPB phosphate per protocol; consider sodium phosphate if potassium is high or high-normal.`r`n"
        else if phos < 2.5
            out .= "- Phosphate: low. Consider Phoxillum if K4 is acceptable; otherwise replace phosphate IVPB, choosing sodium vs potassium phosphate based on K.`r`n"
        else if phos > 5.5
            out .= "- Phosphate: high. Use phosphate-free CRRT solutions and avoid scheduled phosphate replacement until improving.`r`n"
        else
            out .= "- Phosphate: no major flag from entered value; monitor for CRRT-associated decline and replace IVPB as needed.`r`n"
    } else
        out .= "- Phosphate: not entered; CRRT often lowers phosphate, so obtain baseline and serial levels.`r`n"

    if CrrtHas(mg) {
        if mg < 1.8
            out .= "- Magnesium: low. Give IVPB magnesium per protocol; CRRT fluids provide modest magnesium and may not correct deficit.`r`n"
        else if mg > 3.0
            out .= "- Magnesium: high. Avoid magnesium supplementation and reassess solution magnesium/load.`r`n"
        else
            out .= "- Magnesium: no major flag from entered value; continue protocolized monitoring.`r`n"
    }

    if CrrtHas(ca) {
        if citrate
            out .= "- Calcium: citrate selected. Use ionized calcium-based citrate protocol; total serum calcium alone is insufficient. Separate calcium infusion is expected.`r`n"
        else if ca < 8.0
            out .= "- Calcium: low total calcium. Check ionized calcium/albumin; replace IV calcium if clinically indicated. Premade calcium-containing fluid may help but should not replace symptomatic hypocalcemia management.`r`n"
        else if ca > 10.5
            out .= "- Calcium: high. Consider calcium-free solution and avoid calcium-containing replacement unless citrate protocol demands separate titration.`r`n"
    } else if citrate
        out .= "- Calcium: citrate selected; enter/monitor systemic and post-filter ionized calcium per protocol.`r`n"

    if CrrtHas(bicarb) {
        if bicarb < 18
            out .= "- Acid-base: low CO2/HCO3. Favor HCO3 32 premade solutions and reassess CRRT dose, shock/lactate, ketoacidosis, and bicarbonate strategy with team.`r`n"
        else if bicarb > 30
            out .= "- Acid-base: high CO2/HCO3. Consider B22 lower-bicarbonate solutions when compatible; evaluate citrate metabolism, ventilation, and alkali sources.`r`n"
    }

    if CrrtHas(na) {
        if na < 130
            out .= "- Sodium: low. Avoid overly rapid correction; coordinate controlled sodium correction plan with nephrology rather than adding sodium to bags ad hoc.`r`n"
        else if na > 150
            out .= "- Sodium: high. Avoid overly rapid correction; coordinate replacement/dialysate sodium strategy and free-water plan with nephrology.`r`n"
    }

    if CrrtHas(gluc) {
        if gluc < 70
            out .= "- Glucose: low. Treat hypoglycemia and consider dextrose-containing fluids/nutrition/insulin adjustment; some CRRT fluids contain dextrose and some do not.`r`n"
        else if gluc > 250
            out .= "- Glucose: high. Adjust insulin/nutrition and note dextrose-containing CRRT fluids may add glucose load.`r`n"
    }
    return out
}


; -------------------------------------------------------------------------------------------------
; EXPOSURE PEP DECISION ENGINE — occupational and non-occupational HIV/STI/HBV/HCV/body-fluid support
; -------------------------------------------------------------------------------------------------
Calc_OpenExposurePep() {
    g := Gui("+Resize", "Exposure PEP Decision Engine")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w940 cRed", "Structured decision support for occupational and non-occupational blood/body-fluid exposures. This is not an automatic clearance to treat or withhold treatment. Start time-sensitive HIV PEP promptly when indicated; consult PEPline/ID/occupational health/forensics/public health when uncertainty exists.").SetFont("s10 bold")

    g.Add("GroupBox", "xm y+10 w455 h270", "Exposure Context")
    g.Add("Text", "xp+14 yp+28", "Setting:")
    setting := g.Add("DropDownList", "x170 yp w250", ["Occupational healthcare exposure", "Non-occupational sexual exposure", "Sexual assault / forensic case", "Injection / shared equipment", "Bite / fight / community blood exposure", "Other / unclear"])
    setting.Value := 1
    g.Add("Text", "xm+14 y+8", "Hours since exposure:")
    hours := g.Add("Edit", "x170 yp w70")
    g.Add("Text", "xm+14 y+8", "Exposure route:")
    route := g.Add("DropDownList", "x170 yp w260", ["Percutaneous sharps/needle injury", "Mucous membrane splash", "Non-intact skin contact", "Intact skin only", "Receptive anal sex", "Insertive anal sex", "Receptive vaginal/front-hole sex", "Insertive vaginal sex", "Oral sex only", "Shared injection equipment", "Human bite with blood exposure", "Other/unclear"])
    route.Value := 1
    g.Add("Text", "xm+14 y+8", "Fluid/material:")
    fluid := g.Add("DropDownList", "x170 yp w260", ["Blood or visibly bloody fluid", "Semen/vaginal/rectal secretions", "CSF/synovial/pleural/peritoneal/pericardial/amniotic fluid", "Saliva/urine/tears/sweat not visibly bloody", "Unknown fluid"])
    fluid.Value := 1
    g.Add("Text", "xm+14 y+8", "Source status:")
    source := g.Add("DropDownList", "x170 yp w260", ["Known HIV positive - not suppressed or unknown viral load", "Known HIV positive - sustained viral suppression", "HIV negative / rapid negative", "Unknown source or status", "Source testing pending"])
    source.Value := 4
    prep := g.Add("CheckBox", "xm+14 y+10", "Exposed person currently on PrEP with missed doses / uncertain adherence")
    preg := g.Add("CheckBox", "xm+14 y+6", "Pregnant / could be pregnant")

    g.Add("GroupBox", "x470 ym+38 w470 h270", "Patient Factors / Contraindication Flags")
    g.Add("Text", "xp+14 yp+28", "Age group:")
    agegrp := g.Add("DropDownList", "x625 yp w210", ["Adult/adolescent >=12 yr", "Child <12 yr", "Unknown"])
    agegrp.Value := 1
    g.Add("Text", "x484 y+8", "Weight kg:")
    wt := g.Add("Edit", "x625 yp w70")
    g.Add("Text", "x484 y+8", "eGFR/CrCl:")
    renal := g.Add("DropDownList", "x625 yp w260", ["Unknown/not entered", ">=60 mL/min", "30-59 mL/min", "<30 mL/min or dialysis"])
    renal.Value := 1
    g.Add("Text", "x484 y+8", "Allergy/intolerance:")
    allergy := g.Add("DropDownList", "x625 yp w260", ["None known", "Severe beta-lactam allergy", "Doxycycline contraindicated", "Metronidazole intolerance", "Antiretroviral interaction concern", "Multiple/unclear"])
    allergy.Value := 1
    g.Add("Text", "x484 y+8", "HBV vaccination/response:")
    hbvStatus := g.Add("DropDownList", "x625 yp w300", ["Documented responder after complete series", "Response unknown after complete series", "Documented non-responder after two complete series", "Unvaccinated/incomplete/refused", "Unknown"])
    hbvStatus.Value := 5
    g.Add("Text", "x484 y+8", "Source HBsAg:")
    hbvSource := g.Add("DropDownList", "x625 yp w260", ["Positive", "Negative", "Unknown/pending"])
    hbvSource.Value := 3
    doxyPepCandidate := g.Add("CheckBox", "x484 y+10", "Doxy-PEP discussion candidate (MSM/TGW with bacterial STI in past 12 mo or local high-risk protocol)")
    contraception := g.Add("CheckBox", "x484 y+6", "Pregnancy risk from sexual exposure - emergency contraception discussion needed")

    result := g.Add("Edit", "xm y+20 w940 h520 ReadOnly -Wrap")
    g.Add("Button", "xm y+10 w190 Default", "Build PEP Summary").OnEvent("Click", (*) => SafeRun(Calc_RunExposurePep, setting, hours, route, fluid, source, prep, preg, agegrp, wt, renal, allergy, hbvStatus, hbvSource, doxyPepCandidate, contraception, result))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*) => g.Destroy())
    parsed := PBind_CurrentParsed()
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    ageValue := PBind_Value(parsed, "age")
    if IsNumber(ageValue)
        agegrp.Choose(Number(ageValue) >= 12 ? "Adult/adolescent >=12 yr" : "Child <12 yr")
    crclValue := PBind_Value(parsed, "crcl")
    if IsNumber(crclValue) {
        if Number(crclValue) >= 60
            renal.Choose(">=60 mL/min")
        else if Number(crclValue) >= 30
            renal.Choose("30-59 mL/min")
        else
            renal.Choose("<30 mL/min or dialysis")
    }
    PBind_AddStatus(g, PBind_MissingSummary(Map("Weight", wt.Value, "Age", ageValue, "CrCl", crclValue)))
    Workbench29_Show(g,"w980")
}

Calc_RunExposurePep(setting, hoursCtrl, route, fluid, source, prep, preg, agegrp, wtCtrl, renal, allergy, hbvStatus, hbvSource, doxyPepCandidate, contraception, result) {
    hTxt := Trim(hoursCtrl.Value)
    hours := ""
    if hTxt != "" {
        if !IsNumber(hTxt) or Number(hTxt) < 0 {
            MsgBox "Enter hours since exposure as a non-negative number, or leave blank if unknown.", "Exposure PEP", "Icon!"
            return
        }
        hours := Number(hTxt)
    }
    wt := DkaMaybeNumber(wtCtrl.Value)
    substantial := PepSubstantialHivExposure(route.Text, fluid.Text)
    noRiskFluid := InStr(fluid.Text, "not visibly bloody") > 0
    intactOnly := InStr(route.Text, "Intact skin") > 0
    sexualCase := InStr(setting.Text, "sexual") > 0 or InStr(setting.Text, "assault") > 0
    occupational := InStr(setting.Text, "Occupational") > 0

    out := "POST-EXPOSURE DECISION SUPPORT SUMMARY`r`n"
    out .= "Use with local occupational-health/ED/ID/forensic protocols. Document exposure details, cleanse wound/irrigate mucous membranes, report occupational exposures immediately, and do not delay indicated HIV PEP while waiting for nonessential labs.`r`n`r`n"
    out .= "INPUTS`r`n"
    out .= "- Setting: " setting.Text "`r`n- Time since exposure: " (hours = "" ? "unknown" : Round(hours, 1) " hr") "`r`n- Route: " route.Text "`r`n- Fluid/material: " fluid.Text "`r`n- Source: " source.Text "`r`n"
    out .= "- Patient factors: " agegrp.Text "; renal: " renal.Text "; allergy/intolerance: " allergy.Text "; HBV status: " hbvStatus.Text "; source HBsAg: " hbvSource.Text "`r`n"
    if preg.Value
        out .= "- Pregnancy flag selected: use pregnancy-compatible regimens and urgent expert input; do not delay indicated HIV PEP.`r`n"
    if prep.Value
        out .= "- PrEP adherence concern selected: manage as possible HIV exposure; assess adherence, last doses, and transition plan after PEP.`r`n"

    out .= "`r`nHIV PEP DECISION`r`n"
    out .= Calc_HivPepDecision(hours, substantial, noRiskFluid, intactOnly, source.Text, prep.Value, occupational, renal.Text, allergy.Text, preg.Value, agegrp.Text)
    out .= "`r`nBASELINE / FOLLOW-UP TESTING`r`n"
    out .= Calc_PepTestingPlan(sexualCase, occupational, source.Text)
    out .= "`r`nHBV POST-EXPOSURE MANAGEMENT`r`n"
    out .= Calc_HbvPepPlan(hbvStatus.Text, hbvSource.Text, sexualCase)
    out .= "`r`nHCV / OTHER BLOOD-BORNE PATHOGENS`r`n"
    out .= "- No routinely recommended HCV PEP. Obtain baseline exposed-person HCV Ab with reflex RNA or RNA per protocol; test source for HCV Ab/RNA when possible; follow early HCV RNA/ALT schedule per occupational-health/local policy.`r`n"
    out .= "- For bites: evaluate both parties when blood exposure occurred; manage tetanus and bacterial wound infection risk separately.`r`n"
    out .= "- Non-bloody urine, saliva, sweat, tears, or nasal secretions generally do not warrant HIV PEP unless blood contamination or another substantial route is present.`r`n"
    out .= "`r`nSTI / STD PROPHYLAXIS AND SEXUAL-EXPOSURE BRANCH`r`n"
    out .= Calc_StiPepPlan(sexualCase, setting.Text, allergy.Text, preg.Value, doxyPepCandidate.Value, contraception.Value, wt)
    out .= "`r`nCONTRAINDICATION / SELECTION FLAGS`r`n"
    out .= Calc_PepContraindicationPlan(renal.Text, allergy.Text, preg.Value, agegrp.Text)
    out .= "`r`nWHEN TO ESCALATE`r`n"
    out .= "- Call PEPline/ID/occupational health urgently for source drug resistance, pregnancy/pediatric cases, renal/hepatic disease, interacting medications, delayed presentation, source with sustained viral suppression but high-anxiety/high-severity exposure, or disagreement about whether PEP is indicated.`r`n"
    out .= "- Sexual assault cases need trauma-informed forensic workflow, mandated reporting rules as applicable, emergency contraception, HBV/HPV vaccination assessment, and follow-up planning.`r`n"
    out .= "`r`nSource note: HIV PEP timing/course/regimen framing follows CDC/U.S. Public Health Service 2025 PEP guidance; HBV occupational logic follows CDC HCP exposure table; sexual-assault empiric STI prophylaxis follows CDC STI Treatment Guidelines; doxy-PEP discussion follows CDC 2024 doxycycline PEP guidance. Verify local formulary, resistance, renal dose policies, and legal/forensic requirements."
    result.Value := out
}

PepSubstantialHivExposure(routeText, fluidText) {
    if InStr(routeText, "Intact skin")
        return false
    if InStr(fluidText, "not visibly bloody")
        return false
    if InStr(routeText, "Oral sex only") and !InStr(fluidText, "Blood")
        return false
    return InStr(routeText, "Percutaneous") or InStr(routeText, "Mucous") or InStr(routeText, "Non-intact") or InStr(routeText, "anal") or InStr(routeText, "vaginal") or InStr(routeText, "injection") or InStr(routeText, "bite") or InStr(fluidText, "Blood") or InStr(fluidText, "semen") or InStr(fluidText, "CSF") or InStr(fluidText, "Unknown")
}

Calc_HivPepDecision(hours, substantial, noRiskFluid, intactOnly, sourceText, prepConcern, occupational, renalText, allergyText, pregFlag, ageText) {
    out := ""
    if intactOnly or noRiskFluid or !substantial {
        out .= "Recommendation signal: HIV PEP generally NOT indicated from the entered exposure because it does not appear to be a substantial-risk route/material. If details are uncertain, manage as unclear and consult.`r`n"
    } else if hours != "" and hours > 72 {
        out .= "Recommendation signal: >72 hours since exposure. HIV PEP is generally not recommended because efficacy is unlikely after this window; consult urgently for exceptional circumstances and arrange testing/follow-up/PrEP discussion if ongoing risk.`r`n"
    } else if InStr(sourceText, "HIV negative") {
        out .= "Recommendation signal: HIV PEP generally NOT indicated if the source is confirmed HIV negative and there is no concern for acute HIV/window-period infection. Continue HBV/HCV/STI assessment as appropriate.`r`n"
    } else if InStr(sourceText, "sustained viral suppression") {
        out .= "Recommendation signal: Discuss with team/PEPline. Sustained source viral suppression markedly lowers risk; individualize based on exposure severity, adherence certainty, and patient preference.`r`n"
    } else if InStr(sourceText, "Known HIV positive") or InStr(sourceText, "Unknown") or InStr(sourceText, "pending") {
        out .= "Recommendation signal: HIV PEP indicated or case-by-case but time-sensitive. Start as soon as possible and ideally within 24 hours when exposure is substantial; do not wait for all baseline labs if PEP is indicated.`r`n"
    } else {
        out .= "Recommendation signal: unclear. Treat as time-sensitive and consult while source testing proceeds.`r`n"
    }

    if substantial and (hours = "" or hours <= 72) and !InStr(sourceText, "HIV negative") and !intactOnly and !noRiskFluid {
        out .= Calc_PepTreatmentSelection(renalText, allergyText, pregFlag, ageText, prepConcern)
    }
    return out
}


Calc_PepTreatmentSelection(renalText, allergyText, pregFlag, ageText, prepConcern) {
    out := "TREATMENT SELECTION SUGGESTION`r`n"
    if !InStr(ageText, ">=12") {
        out .= "- Pediatric/unknown age: do not use adult fixed-dose assumptions. Start urgent pediatric PEP selection with PEPline/ID/local pediatric protocol.`r`n"
        return out
    }
    if InStr(allergyText, "Antiretroviral") or InStr(allergyText, "Multiple") {
        out .= "- ARV allergy/interaction flag: no single default regimen selected. Call PEPline/ID/pharmacy urgently; do not delay a safe first dose when HIV PEP is clearly indicated.`r`n"
    } else if InStr(renalText, "<30") {
        out .= "- Suggested HIV PEP path: severe renal impairment/dialysis -> avoid default TDF/FTC assumptions; use PEPline/ID and renal-adjusted/local formulary option. Consider INSTI-based backbone with renal-appropriate NRTIs per protocol.`r`n"
    } else if InStr(renalText, "30-59") {
        out .= "- Suggested HIV PEP path: prefer bictegravir/emtricitabine/tenofovir alafenamide once daily for 28 days when formulary/interaction screen allows, or dolutegravir plus TAF/FTC or TAF/3TC per protocol.`r`n"
    } else {
        out .= "- Suggested HIV PEP path: bictegravir/emtricitabine/tenofovir alafenamide once daily for 28 days when available and no interactions; alternative is dolutegravir once daily plus tenofovir alafenamide or tenofovir disoproxil fumarate plus emtricitabine or lamivudine for 28 days.`r`n"
    }
    out .= "- Backup/alternative when INSTI option unsuitable: boosted darunavir plus two NRTIs only after interaction review.`r`n"
    out .= "- Avoid abacavir for urgent starts because HLA-B*5701 status is usually unavailable.`r`n"
    if pregFlag
        out .= "- Pregnancy flag: selected regimen should be pregnancy-compatible; BIC/FTC/TAF or DTG plus two NRTIs are common preferred pathways, but verify obstetric/ID guidance and interactions.`r`n"
    if prepConcern
        out .= "- Current PrEP with missed/uncertain adherence: treat as possible exposure if substantial; after 28 days, transition back to PrEP if HIV testing supports it and ongoing risk continues.`r`n"
    return out
}

Calc_PepTestingPlan(sexualCase, occupational, sourceText) {
    out := "- Exposed person baseline: HIV Ag/Ab test, renal function, liver enzymes; pregnancy test when applicable; HBV serology; HCV Ab with reflex RNA or RNA per protocol.`r`n"
    if sexualCase
        out .= "- Sexual exposure: collect NAATs for gonorrhea/chlamydia at sites of exposure, syphilis serology, HIV testing, HBV/HCV testing; do not let testing delay time-sensitive prophylaxis.`r`n"
    if occupational
        out .= "- Occupational source testing: rapid HIV/Ag-Ab, HBsAg, HCV testing per policy; reassess within about 72 hours as source data returns.`r`n"
    if InStr(sourceText, "pending") or InStr(sourceText, "Unknown")
        out .= "- Source unknown/pending: start indicated PEP now; stop HIV PEP if source is later confirmed HIV negative and no acute HIV concern exists.`r`n"
    out .= "- Follow-up HIV testing schedule should follow current protocol; confirm completion/adherence and adverse effects during the 28-day course if started.`r`n"
    return out
}

Calc_HbvPepPlan(hcpStatus, sourceHbsAg, sexualCase) {
    sourcePosOrUnknown := sourceHbsAg != "Negative"
    out := ""
    if hcpStatus = "Documented responder after complete series" {
        out .= "- Documented anti-HBs responder: no HBV PEP needed regardless of source status.`r`n"
    } else if hcpStatus = "Documented non-responder after two complete series" {
        if sourcePosOrUnknown
            out .= "- Documented non-responder after two complete series + source positive/unknown: HBIG x2 separated by 1 month; no further vaccine series expected.`r`n"
        else
            out .= "- Documented non-responder + source negative: no HBIG needed; document and follow local policy.`r`n"
    } else if hcpStatus = "Response unknown after complete series" {
        if sourcePosOrUnknown
            out .= "- Completed vaccine series but response unknown + source positive/unknown: check exposed-person anti-HBs. If <10 mIU/mL, give HBIG x1 and initiate revaccination; if >=10, no action.`r`n"
        else
            out .= "- Completed series/response unknown + source negative: check anti-HBs; if <10 mIU/mL initiate revaccination, if >=10 no action.`r`n"
    } else {
        if sourcePosOrUnknown
            out .= "- Unvaccinated/incomplete/unknown + source positive/unknown: give HBIG x1 and start/complete HBV vaccine series as soon as possible.`r`n"
        else
            out .= "- Unvaccinated/incomplete/unknown + source negative: start/complete HBV vaccine series; HBIG not needed.`r`n"
    }
    if sexualCase
        out .= "- Sexual assault/nonoccupational sexual exposure: HBV vaccine at initial visit if not previously vaccinated; add HBIG if source known HBsAg positive and patient unvaccinated/incompletely vaccinated.`r`n"
    return out
}

Calc_StiPepPlan(sexualCase, settingText, allergyText, pregFlag, doxyPepCandidate, ecNeeded, wt) {
    out := ""
    if !sexualCase and !InStr(settingText, "Injection") {
        out .= "- No routine bacterial STI prophylaxis generated for a non-sexual/non-injection occupational splash/sharps exposure. Manage wound/tetanus/HBV/HCV/HIV as above.`r`n"
        return out
    }
    if sexualCase {
        cefDose := "ceftriaxone 500 mg IM once"
        if DkaHas(wt) and wt >= 150
            cefDose := "ceftriaxone 1 g IM once because weight >=150 kg"
        out .= "- For sexual assault or situations where follow-up is uncertain, CDC supports presumptive treatment rather than waiting for results.`r`n"
        if pregFlag {
            out .= "- Pregnancy flag: avoid doxycycline; typical pregnancy-compatible chlamydia option is azithromycin 1 g PO once, with gonorrhea treatment per current guidance and allergy review. Metronidazole use depends on scenario/trimester/local protocol.`r`n"
        } else if InStr(allergyText, "beta-lactam") {
            out .= "- Severe beta-lactam allergy: do not auto-select ceftriaxone; obtain ID/STD expert guidance for gonorrhea coverage and test-directed therapy.`r`n"
            out .= "- If treating chlamydia/trichomonas empirically and no contraindication: doxycycline 100 mg PO BID x7 days plus metronidazole 500 mg PO BID x7 days when vaginal exposure/trichomonas coverage is needed; verify local protocol.`r`n"
        } else {
            out .= "- Typical empiric sexual-assault regimen for adults/adolescents: " cefDose " PLUS doxycycline 100 mg PO BID x7 days PLUS metronidazole 500 mg PO BID x7 days when vaginal exposure/trichomonas coverage is applicable. Male survivor regimens commonly omit metronidazole unless trichomonas/anaerobic coverage is clinically indicated by protocol.`r`n"
        }
        out .= "- Offer/assess HPV vaccination when age-appropriate and not fully vaccinated.`r`n"
        if ecNeeded
            out .= "- Emergency contraception: discuss and provide/arrange urgently when pregnancy risk exists.`r`n"
    }
    if doxyPepCandidate {
        if pregFlag or InStr(allergyText, "Doxycycline")
            out .= "- Doxy-PEP flag selected but pregnancy/doxycycline contraindication noted: do not auto-recommend; use expert/public-health guidance.`r`n"
        else
            out .= "- Doxy-PEP discussion candidate: for eligible MSM/TGW populations per CDC/local policy, doxycycline 200 mg once as soon as possible within 72 hr after sex, max 200 mg per 24 hr, with STI testing every 3-6 months. This is not a substitute for sexual-assault empiric treatment or HIV PEP.`r`n"
    }
    if InStr(settingText, "Injection")
        out .= "- Injection/shared equipment: prioritize HIV/HBV/HCV testing and HIV PEP decision; provide harm-reduction counseling, sterile supplies, HBV vaccination, and PrEP linkage after PEP if ongoing risk.`r`n"
    return out
}

Calc_PepContraindicationPlan(renalText, allergyText, pregFlag, ageText) {
    out := "- Drug interaction check: review anticonvulsants, rifamycins, polyvalent cations, transplant/chemotherapy meds, anticoagulants, and boosted-protease-inhibitor interactions if using darunavir/ritonavir/cobicistat.`r`n"
    if InStr(renalText, "<30")
        out .= "- Severe renal impairment/dialysis: default TDF/FTC assumptions may be unsafe; use PEPline/ID and renal-adjusted/local formulary options. Do not delay the first safe dose if HIV PEP is clearly indicated.`r`n"
    if InStr(allergyText, "Antiretroviral") or InStr(allergyText, "Multiple")
        out .= "- ARV allergy/interaction concern: call PEPline/ID for regimen selection and substitutions.`r`n"
    if InStr(allergyText, "Doxycycline")
        out .= "- Doxycycline contraindication: avoid doxycycline treatment/PEP; use diagnosis-specific alternatives such as pregnancy-compatible chlamydia regimens when indicated.`r`n"
    if InStr(allergyText, "Metronidazole")
        out .= "- Metronidazole intolerance: avoid automatic trichomonas/anaerobic empiric dosing; consider test-directed therapy or alternative consultation.`r`n"
    if pregFlag
        out .= "- Pregnancy/could be pregnant: assess fetal-compatible HIV PEP, avoid doxycycline, offer emergency contraception if appropriate, and coordinate obstetric/forensic care.`r`n"
    if !InStr(ageText, ">=12")
        out .= "- Pediatric case: use pediatric-specific dosing and mandatory reporting/forensic protocols where applicable.`r`n"
    return out
}



; =================================================================================================
; VANCOMYCIN KINETIC / BAYESIAN ENGINE  (added 2026-07-19)
; -------------------------------------------------------------------------------------------------
; Decision-support only. One-compartment kinetics with population priors, first-order two-level
; (Sawchuk-Zaske) estimation, and a MAP-Bayesian posterior over CL and Vd. AUC by the analytic
; mass-balance identity (AUC_tau = Dose/CL) cross-checked against the log-linear trapezoidal
; method when levels are present. Not a validated replacement for commercial Bayesian software
; (PrecisePK / DoseMeRx / BestDose); pharmacist must verify every value.
; =================================================================================================

; ---- Core one-compartment steady-state concentration ------------------------------------------
; Concentration (mcg/mL) at t hours AFTER THE START of the infusion, at steady state.
VancoK_SsConc(dose, tau, tinf, cl, vd, tAfterStart) {
    if cl <= 0 || vd <= 0 || tinf <= 0 || tau <= 0
        return 0
    ke := cl / vd
    R := dose / tinf                                  ; infusion rate mg/hr
    cmax := (R / cl) * (1 - Exp(-ke * tinf)) / (1 - Exp(-ke * tau))
    cmin := cmax * Exp(-ke * (tau - tinf))
    if tAfterStart <= tinf {
        ; during infusion: SS rise superimposed on residual from prior dose
        return (R / cl) * (1 - Exp(-ke * tAfterStart)) / (1 - Exp(-ke * tau))
            + cmin * Exp(-ke * tAfterStart)
    }
    return cmax * Exp(-ke * (tAfterStart - tinf))
}

VancoK_SsPeak(dose, tau, tinf, cl, vd) {
    return VancoK_SsConc(dose, tau, tinf, cl, vd, tinf)
}
VancoK_SsTrough(dose, tau, tinf, cl, vd) {
    return VancoK_SsConc(dose, tau, tinf, cl, vd, tau)
}

; AUC24 by mass balance: AUC over one interval = Dose/CL, scaled to 24 h. Independent of Vd.
VancoK_Auc24(dose, tau, cl) {
    if cl <= 0 || tau <= 0
        return 0
    return (dose / cl) * (24 / tau)
}

; AUC24 by log-linear trapezoid from an explicit peak/trough pair (used as a cross-check).
VancoK_Auc24Trapezoid(cmax, cmin, ke, tinf, tau) {
    if ke <= 0 || tau <= 0 || cmax <= 0 || cmin <= 0 || cmax <= cmin
        return 0
    aucInf  := (cmin + cmax) / 2 * tinf               ; linear during infusion
    aucElim := (cmax - cmin) / ke                      ; log-linear during elimination
    return (aucInf + aucElim) * (24 / tau)
}

; ---- Population priors -------------------------------------------------------------------------
; Matzke-style vancomycin clearance: CLvanco (L/hr) = 0.75 * CrCl(mL/min) * 0.06.
; Vd = 0.7 L/kg (actual body weight). RRT scenarios override with fixed clearances.
VancoK_PopPriors(crcl, wtKg, renalText) {
    vd := Max(0.7 * wtKg, 10)
    if InStr(renalText, "iHD") {
        cl := 0.4                                      ; interdialytic residual clearance
        return { cl: cl, vd: vd, source: "iHD population prior (interdialytic residual)" }
    }
    if InStr(renalText, "CRRT") {
        cl := 2.0                                      ; effluent-rate dependent; placeholder
        return { cl: cl, vd: vd, source: "CRRT population prior (verify effluent rate)" }
    }
    crclVal := (crcl = "" || !IsNumber(crcl)) ? 30 : Number(crcl)
    cl := Max(0.3, 0.75 * crclVal * 0.06)
    if InStr(renalText, "AKI")
        cl := Max(0.3, cl * 0.7)
    return { cl: cl, vd: vd, source: "Cockcroft-Gault-based population prior" }
}

; ---- Two-level first-order (Sawchuk-Zaske) -----------------------------------------------------
; c1,c2 measured dtHr apart, same interval, both post-distribution. Returns ke, t1/2, and
; (if a regimen is supplied) a Vd estimate from the infusion model.
VancoK_TwoLevel(c1, c2, dtHr, dose := 0, tinf := 1) {
    if c1 <= 0 || c2 <= 0 || dtHr <= 0 || c1 <= c2
        return { ok: false, reason: "Need c1 > c2 > 0 with a positive time gap." }
    ke := Ln(c1 / c2) / dtHr
    out := { ok: true, ke: ke, thalf: 0.693 / ke }
    if dose > 0 && tinf > 0 {
        ; back-extrapolate c1 to true peak (end of infusion) is caller's job; here we give Vd
        ; from the standard infusion equation assuming c1 is the immediate post-infusion peak.
        vd := (dose / tinf) * (1 - Exp(-ke * tinf)) / (ke * (c1 - c2 * Exp(-ke * tinf)))
        if vd > 0
            out.vd := vd, out.cl := ke * vd
    }
    return out
}

; ---- MAP-Bayesian posterior over (CL, Vd) ------------------------------------------------------
; levels: array of { c: conc, t: hoursAfterInfusionStart }.  regimen: { dose, tau, tinf }.
; Log-normal priors; grid-search MAP with successive refinement (deterministic, verifiable).
VancoK_BayesMap(levels, regimen, priorCl, priorVd, clCv := 0.4, vdCv := 0.25, assayCv := 0.12) {
    dose := regimen.dose, tau := regimen.tau, tinf := regimen.tinf
    if priorCl <= 0 || priorVd <= 0
        return { ok: false, reason: "Invalid population priors." }
    if !IsObject(levels) || levels.Length = 0
        return { ok: false, reason: "No levels supplied for Bayesian update." }

    wCl := 1 / Ln(1 + clCv * clCv)
    wVd := 1 / Ln(1 + vdCv * vdCv)
    wAs := 1 / Ln(1 + assayCv * assayCv)

    objFn(cl, vd) {
        j := wCl * (Ln(cl / priorCl)) ** 2 + wVd * (Ln(vd / priorVd)) ** 2
        for lv in levels {
            pred := VancoK_SsConc(dose, tau, tinf, cl, vd, lv.t)
            if pred <= 0
                return 1e9
            j += wAs * (Ln(lv.c / pred)) ** 2
        }
        return j
    }

    clLo := priorCl * 0.3, clHi := priorCl * 3.0
    vdLo := priorVd * 0.4, vdHi := priorVd * 2.2
    bestCl := priorCl, bestVd := priorVd, bestJ := 1e18

    loop 4 {
        localBestJ := 1e18, localCl := bestCl, localVd := bestVd
        i := 0
        loop 31 {
            cl := clLo + (clHi - clLo) * (A_Index - 1) / 30
            k := 0
            loop 31 {
                vd := vdLo + (vdHi - vdLo) * (A_Index - 1) / 30
                j := objFn(cl, vd)
                if j < localBestJ
                    localBestJ := j, localCl := cl, localVd := vd
            }
        }
        bestCl := localCl, bestVd := localVd, bestJ := localBestJ
        spanCl := (clHi - clLo) / 8, spanVd := (vdHi - vdLo) / 8
        clLo := Max(0.05, bestCl - spanCl), clHi := bestCl + spanCl
        vdLo := Max(1, bestVd - spanVd),   vdHi := bestVd + spanVd
    }

    return { ok: true, cl: bestCl, vd: bestVd, ke: bestCl / bestVd, thalf: 0.693 * bestVd / bestCl }
}

; ---- Dose optimizer: smallest formulary regimen hitting the AUC target ------------------------
; Searches interval x dose grid, returns the regimen whose AUC24 is closest to targetAuc while
; keeping projected trough under troughCap. Uses posterior (or population) CL and Vd.
VancoK_OptimizeRegimen(cl, vd, targetAuc, tinf := 1, troughCap := 20, sereneAuc := 400, ceilingAuc := 600) {
    static doses := [500, 750, 1000, 1250, 1500, 1750, 2000]
    static taus  := [8, 12, 18, 24, 36, 48]
    best := ""
    for tau in taus {
        for dose in doses {
            auc := VancoK_Auc24(dose, tau, cl)
            trough := VancoK_SsTrough(dose, tau, tinf, cl, vd)
            peak := VancoK_SsPeak(dose, tau, tinf, cl, vd)
            ; score: distance from target AUC, penalize trough over cap and out-of-band AUC
            score := Abs(auc - targetAuc)
            if trough > troughCap
                score += (trough - troughCap) * 30
            if auc < sereneAuc || auc > ceilingAuc
                score += 40
            cand := { dose: dose, tau: tau, auc: auc, trough: trough, peak: peak, score: score,
                      tdd: dose * (24 / tau) }
            if best = "" || cand.score < best.score
                best := cand
        }
    }
    return best
}


; -------------------------------------------------------------------------------------------------
; VANCOMYCIN AUC / DOSING SUPPORT — initial dosing, maintenance estimates, tracking, notes
; -------------------------------------------------------------------------------------------------
Calc_OpenVancomycinDosing() {
    g := Gui("+Resize", "Vancomycin AUC / Dosing Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "x20 y14 w1100 cRed", "Decision-support only. Verify local vancomycin policy, indication, MIC, renal replacement details, levels, and timing. Bayesian software is preferred when available.").SetFont("s10 bold")

    tabs := g.Add("Tab3", "x20 y42 w1120 h760", ["Minimum Info / Dose", "Dose-Lab Tracking", "Note Writer"])

    ; -------------------- Tab 1: cleaner four-section layout --------------------
    tabs.UseTab(1)

   
    g.Add("GroupBox", "x40 y86 w520 h265", "1) Minimum patient information")
    g.Add("Text", "x60 y118 w90", "Age:")
    age := g.Add("Edit", "x150 y114 w75")
    g.Add("Text", "x250 y118 w45", "Sex:")
    sex := g.Add("DropDownList", "x300 y114 w115", ["Male", "Female"]), sex.Value := 1
    g.Add("Text", "x430 y118 w80", "Height (cm):")
    ht := g.Add("Edit", "x500 y114 w55")

    g.Add("Text", "x60 y154 w90", "Actual wt kg:")
    wt := g.Add("Edit", "x150 y150 w75")
    g.Add("Text", "x250 y154 w45", "SCr:")
    scr := g.Add("Edit", "x300 y150 w75")
    g.Add("Text", "x430 y154 w45", "MIC:")
    mic := g.Add("Edit", "x500 y150 w45", "1")

    g.Add("Text", "x60 y190 w90", "Indication:")
    severity := g.Add("DropDownList", "x150 y186 w390", ["Serious MRSA / severe infection", "Non-severe / lower AUC acceptable by protocol", "Empiric unclear indication"]), severity.Value := 1

    g.Add("Button", "x60 y212 w240 h24", "Autofill Demographics from Screen").OnEvent("Click",
        (*) => SafeRun(Vanco_OCRCapture, age, sex, ht, wt, scr))

    ampCheck := g.Add("CheckBox", "x60 y242 w290", "Amputation / weight interpretation issue")
    g.Add("Text", "x60 y278 w105", "Amputation:")
    ampSite := g.Add("DropDownList", "x150 y274 w250", ["None", "Hand", "Forearm + hand", "Entire arm", "Foot", "Below-knee", "Above-knee", "Entire leg", "Bilateral below-knee", "Bilateral above-knee", "Custom %"]), ampSite.Value := 1
    g.Add("Text", "x410 y278 w75", "% missing:")
    ampPct := g.Add("Edit", "x485 y274 w60", "0")
    ampSite.OnEvent("Change", (*) => SafeRun(Vanco_UpdateAmputationPct, ampSite, ampPct, ampCheck))
    g.Add("Text", "x60 y310 w470 cGray", "Select amputation type to auto-fill approximate % body mass missing. Use Custom % if documented locally; verify manually.")

    g.Add("GroupBox", "x590 y86 w520 h245", "2) Renal / RRT context")
    g.Add("Text", "x610 y118 w105", "Renal status:")
    renal := g.Add("DropDownList", "x720 y114 w300", ["Stable renal function", "Current AKI / unstable SCr", "iHD", "CRRT"]), renal.Value := 1
    g.Add("Text", "x610 y158 w460 cGray", "Stable renal function allows a population PK estimate. AKI, iHD, and CRRT should be treated as level-guided dosing scenarios.")
    g.Add("Text", "x610 y218 w460 cGray", "Tip: use Dose-Lab Tracking for repeated levels, dose times, SCr changes, and patient-specific trend review.")

    g.Add("GroupBox", "x40 y350 w520 h185", "3) Optional current regimen / level")
    g.Add("Text", "x60 y382 w120", "Already on vanco?")
    onVanco := g.Add("DropDownList", "x185 y378 w95", ["No", "Yes"]), onVanco.Value := 1
    g.Add("Text", "x305 y382 w95", "Dose mg:")
    curDose := g.Add("Edit", "x400 y378 w80")
    g.Add("Text", "x490 y382 w35", "q hr:")
    curTau := g.Add("Edit", "x525 y378 w35")

    g.Add("Text", "x60 y418 w120", "Infusion hr:")
    infHr := g.Add("Edit", "x185 y414 w70", "1")
    g.Add("Text", "x305 y418 w95", "Level:")
    level := g.Add("Edit", "x400 y414 w80")
    g.Add("Text", "x490 y418 w110", "hr after inf:")
    levelHr := g.Add("Edit", "x525 y414 w35")

    g.Add("Text", "x60 y454 w120", "Second level:")
    level2 := g.Add("Edit", "x185 y450 w70")
    g.Add("Text", "x305 y454 w125", "hr after first:")
    level2Hr := g.Add("Edit", "x430 y450 w70")
    g.Add("Text", "x60 y492 w470 cGray", "Two accurately timed post-distribution levels improve first-order estimates. A single level is only context unless Bayesian software is used.")

    g.Add("GroupBox", "x590 y350 w520 h185", "4) Optional regimen to project")
    g.Add("Text", "x610 y382 w120", "Dose mg:")
    projDose := g.Add("Edit", "x735 y378 w95")
    g.Add("Text", "x855 y382 w75", "Interval hr:")
    projTau := g.Add("Edit", "x930 y378 w60")
    g.Add("Text", "x610 y418 w120", "Infusion hr:")
    projInf := g.Add("Edit", "x735 y414 w95", "1")
    g.Add("Button", "x855 y414 w185 h28", "Use suggested regimen").OnEvent("Click", (*) => SafeRun(Vanco_FillSuggestedRegimen, projDose, projTau, result))
    g.Add("Text", "x610 y462 w470 cGray", "Leave blank to use the suggested regimen. Projection is a simple first-order estimate and should not replace Bayesian/local protocol review.")

    result := g.Add("Edit", "x40 y555 w1070 h185 ReadOnly -Wrap")
    g.Add("Button", "x40 y755 w160 h30 Default", "Build Dosing Plan").OnEvent("Click", (*) => SafeRun(Calc_RunVancomycinDosing, age, sex, ht, wt, scr, mic, renal, severity, ampCheck, ampSite, ampPct, onVanco, curDose, curTau, infHr, level, levelHr, level2, level2Hr, projDose, projTau, projInf, result))
    g.Add("Button", "x210 y755 w130 h30", "Copy Result").OnEvent("Click", (*) => A_Clipboard := result.Value)

    ; -------------------- Tab 2: guided dose/lab tracking --------------------
    tabs.UseTab(2)
    g.Add("GroupBox", "x40 y84 w1070 h92", "1) Patient tracker")
    g.Add("Text", "x60 y116 w120", "Patient/tracker ID:")
    patId := g.Add("Edit", "x185 y112 w210")
    g.Add("Button", "x410 y111 w90 h28", "Load").OnEvent("Click", (*) => SafeRun(Vanco_LoadTrackerRows, patId, trackLV))
    g.Add("Button", "x510 y111 w120 h28", "Analyze / Plan").OnEvent("Click", (*) => SafeRun(Vanco_AnalyzeHistory, patId, wt, projDose, projTau, projInf, trackResult))
    g.Add("Text", "x655 y116 w420 cGray", "Use a de-identified ID. Load the patient, then add doses, levels, SCr, and notes below.")

    g.Add("GroupBox", "x40 y190 w1070 h170", "2) Add one event")
    g.Add("Text", "x60 y222 w80", "Time:")
    trackTime := g.Add("Edit", "x145 y218 w160", FormatTime(A_Now, "yyyy-MM-dd HHmm"))
    g.Add("Button", "x315 y217 w70 h28", "Now").OnEvent("Click", (*) => SafeRun(Vanco_SetNow, trackTime))
    g.Add("Text", "x405 y222 w80", "Type:")
    trackType := g.Add("DropDownList", "x485 y218 w155", ["Dose given", "Level drawn", "SCr/BMP", "Dose held", "Regimen changed", "Dialysis/CRRT", "Clinical note"]), trackType.Value := 1
    g.Add("Text", "x665 y222 w90", "Dose mg:")
    trackDose := g.Add("Edit", "x745 y218 w80")
    g.Add("Text", "x835 y222 w50", "q hr:")
    trackTau := g.Add("Edit", "x885 y218 w55")

    g.Add("Text", "x60 y260 w80", "Level:")
    trackLevel := g.Add("Edit", "x145 y256 w80")
    g.Add("Text", "x245 y260 w80", "SCr:")
    trackScr := g.Add("Edit", "x315 y256 w80")
    g.Add("Text", "x405 y260 w80", "Notes:")
    trackNotes := g.Add("Edit", "x485 y256 w420")
    g.Add("Button", "x920 y254 w85 h30", "Add").OnEvent("Click", (*) => SafeRun(Vanco_AddTrackerEventFromFields, patId, trackTime, trackType, trackDose, trackTau, trackLevel, trackScr, trackNotes, trackLV))
    g.Add("Button", "x1015 y254 w75 h30", "Clear").OnEvent("Click", (*) => SafeRun(Vanco_ClearTrackerFields, trackTime, trackType, trackDose, trackTau, trackLevel, trackScr, trackNotes))
    g.Add("Text", "x60 y308 w1010 cGray", "Examples: Dose given = dose mg and optional interval; Level drawn = level concentration with exact draw time; SCr/BMP = SCr; Dialysis/CRRT = notes describing session or settings.")

    g.Add("GroupBox", "x40 y378 w1070 h275", "3) Patient timeline")
    g.Add("Button", "x60 y405 w100 h28", "Delete row").OnEvent("Click", (*) => SafeRun(Vanco_DeleteTrackerEvent, patId, trackLV))
    trackLV := g.Add("ListView", "x60 y442 w1030 h190", ["Timestamp", "Type", "Dose mg", "q hr", "Level", "SCr", "Notes"])
    trackLV.ModifyCol(1, 145), trackLV.ModifyCol(2, 120), trackLV.ModifyCol(3, 80), trackLV.ModifyCol(4, 60), trackLV.ModifyCol(5, 75), trackLV.ModifyCol(6, 65), trackLV.ModifyCol(7, 430)

    g.Add("GroupBox", "x40 y665 w1070 h90", "4) Summary / next action")
    trackResult := g.Add("Edit", "x60 y690 w1030 h50 ReadOnly -Wrap")
    g.Add("Text", "x60 y760 w1050 cGray", "Tracker is stored locally in vancomycin_tracker.csv beside the script. Verify MAR/lab timestamps before using any trend for dosing.")

    ; -------------------- Tab 3: note writer --------------------
    tabs.UseTab(3)
    g.Add("Text", "x40 y88 w80", "Note type:")
    noteType := g.Add("DropDownList", "x130 y84 w190", ["Initial consult", "Follow-up adjustment", "Level assessment / redose", "Hold / AKI / RRT note"]), noteType.Value := 1
    g.Add("Text", "x345 y88 w180", "Assessment/culture context:")
    noteContext := g.Add("Edit", "x530 y84 w580")
    noteOut := g.Add("Edit", "x40 y125 w1070 h580 -Wrap")
    g.Add("Button", "x40 y720 w150 h30", "Build Note").OnEvent("Click", (*) => SafeRun(Vanco_BuildNote, noteType, noteContext, result, trackResult, noteOut))
    g.Add("Button", "x200 y720 w120 h30", "Copy Note").OnEvent("Click", (*) => A_Clipboard := noteOut.Value)

    tabs.UseTab()
    g.Add("Button", "x1030 y815 w80 h30", "Close").OnEvent("Click", (*) => g.Destroy())

    ; Auto-fill from OCR picker if launched via Ctrl+B
    global _PreFillDemographics
    if _PreFillDemographics.Count > 0 {
        pf := _PreFillDemographics

        if pf.Has("age") && pf["age"] != ""
            age.Value := pf["age"]

        if pf.Has("heightCm") && pf["heightCm"] != ""
            ht.Value := String(pf["heightCm"])

        if pf.Has("weightKg") && pf["weightKg"] != ""
            wt.Value := String(pf["weightKg"])

        if pf.Has("scr") && pf["scr"] != ""
            scr.Value := pf["scr"]

        if pf.Has("sex") && pf["sex"] != ""
            sex.Value := (pf["sex"] = "Female") ? 2 : 1

        _PreFillDemographics := Map()

        ; Demographics arrived from the OCR picker — compute a plan immediately so
        ; the pharmacist sees loading + Bayesian-optimized maintenance on open.
        if Trim(age.Value) != "" && Trim(ht.Value) != "" && Trim(wt.Value) != "" && Trim(scr.Value) != ""
            SafeRun(Calc_RunVancomycinDosing, age, sex, ht, wt, scr, mic, renal, severity, ampCheck, ampSite, ampPct, onVanco, curDose, curTau, infHr, level, levelHr, level2, level2Hr, projDose, projTau, projInf, result)
    }

    parsed := PBind_CurrentParsed()
    PBind_Set(age, PBind_Value(parsed, "age"))
    PBind_Set(ht, PBind_HeightCm(parsed))
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_Set(scr, PBind_Value(parsed, "scr"))
    PBind_SetSex(sex, PBind_Value(parsed, "sex"))
    Workbench29_Show(g,"w1165 h860")
}

Calc_RunVancomycinDosing(ageCtrl, sexCtrl, htCtrl, wtCtrl, scrCtrl, micCtrl, renalCtrl, severityCtrl, ampCheckCtrl, ampSiteCtrl, ampPctCtrl, onVancoCtrl, curDoseCtrl, curTauCtrl, infHrCtrl, levelCtrl, levelHrCtrl, level2Ctrl, level2HrCtrl, projDoseCtrl, projTauCtrl, projInfCtrl, result) {
    ageTxt := Trim(ageCtrl.Value), htTxt := Trim(htCtrl.Value), wtTxt := Trim(wtCtrl.Value), scrTxt := Trim(scrCtrl.Value)
    if !IsNumber(ageTxt) or !IsNumber(htTxt) or !IsNumber(wtTxt) or !IsNumber(scrTxt) or Number(ageTxt) <= 0 or Number(htTxt) <= 0 or Number(wtTxt) <= 0 or Number(scrTxt) <= 0 {
        result.Value := "Enter age, sex, height (cm), actual weight (kg), and SCr, then click Build Dosing Plan.`r`n`r`nThese five values are the minimum for a population estimate. Add a current regimen and one or two timed levels to switch to a Bayesian posterior."
        return
    }
    age := Number(ageTxt), ht := Number(htTxt), wt := Number(wtTxt), scr := Number(scrTxt)
    isFemale := sexCtrl.Text = "Female"
    mic := IsNumber(Trim(micCtrl.Value)) && Number(Trim(micCtrl.Value)) > 0 ? Number(Trim(micCtrl.Value)) : 1

    ; ---- amputation-adjusted weight ----
    ampPct := IsNumber(Trim(ampPctCtrl.Value)) ? Number(Trim(ampPctCtrl.Value)) : 0
    ampSite := IsSet(ampSiteCtrl) ? ampSiteCtrl.Text : "Custom %"
    if ampCheckCtrl.Value = 1 and (ampSite = "" or ampSite = "None") and ampPct > 0
        ampSite := "Custom %"
    effectiveWt := wt
    ampText := ""
    if ampCheckCtrl.Value = 1 and ampPct > 0 and ampPct < 50 {
        effectiveWt := wt / (1 - ampPct/100)
        ampText := "Amputation " ampSite ": post-amputation weight " Round(wt,1) " kg; estimated intact-body weight " Round(effectiveWt,1) " kg (" Round(ampPct,1) "% mass missing). Verify against an amputation-specific method."
    } else if ampCheckCtrl.Value = 1 {
        ampText := "Amputation flag checked but no valid % entered; using actual weight — CrCl/weight estimates may be biased."
    }

    ; ---- population PK backbone ----
    pk := Vanco_BasicPatientPk(age, ht, effectiveWt, scr, isFemale, renalCtrl.Text)
    priors := VancoK_PopPriors(pk.crcl, effectiveWt, renalCtrl.Text)
    infHr := Vanco_NumOrDefault(infHrCtrl.Value, 1)

    ; ---- collect any levels for a Bayesian update ----
    ; Interpret the "current regimen" fields as the regimen the levels were drawn on.
    curDose := Vanco_NumOrDefault(curDoseCtrl.Value, 0)
    curTau  := Vanco_NumOrDefault(curTauCtrl.Value, 0)
    lvls := []
    lvl1 := Trim(levelCtrl.Value), lvl1Hr := Trim(levelHrCtrl.Value)
    lvl2 := Trim(level2Ctrl.Value), lvl2Gap := Trim(level2HrCtrl.Value)
    ; level 1 time is entered as "hr after infusion END"; convert to hr after infusion START.
    if IsNumber(lvl1) && Number(lvl1) > 0 {
        if IsNumber(lvl1Hr) && Number(lvl1Hr) >= 0 {
            t1 := Number(lvl1Hr) + infHr
            lvls.Push({ c: Number(lvl1), t: t1 })
            if IsNumber(lvl2) && Number(lvl2) > 0 && IsNumber(lvl2Gap) && Number(lvl2Gap) > 0 {
                lvls.Push({ c: Number(lvl2), t: t1 + Number(lvl2Gap) })
            }
        }
    }

    haveBayes := false
    post := priors
    twoLevelText := ""
    if lvls.Length >= 1 && curDose > 0 && curTau > 0 {
        regimen := { dose: curDose, tau: curTau, tinf: infHr }
        bm := VancoK_BayesMap(lvls, regimen, priors.cl, priors.vd)
        if bm.ok {
            post := bm
            haveBayes := true
        }
        ; if two raw levels in one interval, also give the model-free Sawchuk-Zaske ke
        if lvls.Length = 2 {
            dtHr := lvls[2].t - lvls[1].t
            sz := VancoK_TwoLevel(lvls[1].c, lvls[2].c, dtHr, curDose, infHr)
            if sz.ok
                twoLevelText := "- First-order (Sawchuk-Zaske) ke " Round(sz.ke,4) " hr^-1, t1/2 " Round(sz.thalf,1) " hr" (sz.HasOwnProp("vd") ? ", Vd " Round(sz.vd,1) " L, CL " Round(sz.cl,2) " L/hr" : "") ". Valid only if both levels were post-distribution, same interval, correctly timed.`r`n"
        }
    }

    ; ---- target AUC ----
    targetAuc := InStr(severityCtrl.Text, "Non-severe") ? 450 : 500

    ; ---- loading dose ----
    mgkgLoad := InStr(severityCtrl.Text, "Serious") ? 25 : 20
    loadDose := Vanco_RoundDose(mgkgLoad * effectiveWt)

    ; ---- optimized maintenance from posterior (or population) ----
    opt := VancoK_OptimizeRegimen(post.cl, post.vd, targetAuc, infHr, 20)

    ; ---- honor a user-entered projection regimen if present ----
    userDose := Vanco_NumOrDefault(projDoseCtrl.Value, 0)
    userTau  := Vanco_NumOrDefault(projTauCtrl.Value, 0)
    userInf  := Vanco_NumOrDefault(projInfCtrl.Value, infHr)

    out := "VANCOMYCIN " (haveBayes ? "BAYESIAN" : "POPULATION") " DOSING SUPPORT`r`n"
    out .= "Decision-support only; verify indication, MIC, timing, renal trajectory, and local protocol. Not a validated Bayesian program.`r`n`r`n"

    out .= "PATIENT / PK CONTEXT`r`n"
    if ampText != ""
        out .= "- " ampText "`r`n"
    out .= "- Weight basis " Round(effectiveWt,1) " kg; BMI " Round(pk.bmi,1) "; IBW " Round(pk.ibw,1) " kg; AdjBW " Round(pk.adjbw,1) " kg; CG weight " Round(pk.cgWt,1) " kg (" pk.cgWtLabel ").`r`n"
    out .= "- Estimated CrCl " (pk.crcl = "" ? "n/a (RRT)" : Round(pk.crcl,1) " mL/min") ".`r`n"
    out .= "- " (haveBayes ? "Posterior (Bayesian)" : "Population") " PK: CL " Round(post.cl,2) " L/hr; Vd " Round(post.vd,1) " L; ke " Round(post.cl/post.vd,4) " hr^-1; t1/2 " Round(0.693*post.vd/post.cl,1) " hr.`r`n"
    out .= "- Renal status: " renalCtrl.Text ". " Vanco_RenalCaveat(renalCtrl.Text) "`r`n"
    if twoLevelText != ""
        out .= twoLevelText

    out .= "`r`nTARGET`r`n"
    out .= "- " (InStr(severityCtrl.Text,"Non-severe") ? "Non-severe: target AUC24 ~400-500." : "Serious MRSA: target AUC24/MIC 400-600 (assuming MIC 1).") "`r`n"
    if mic != 1
        out .= "- MIC entered " mic ": if MIC >1, target attainment without toxicity is unlikely; discuss ID/alternative therapy.`r`n"

    out .= "`r`nLOADING DOSE`r`n"
    out .= "- " loadDose " mg IV once (~" mgkgLoad " mg/kg on " Round(effectiveWt,1) " kg = " Round(mgkgLoad*effectiveWt) " mg raw; 2000 mg facility cap). Infuse <=1 g/hr.`r`n"

    out .= "`r`nSUGGESTED MAINTENANCE (" (haveBayes ? "Bayesian-optimized" : "population-optimized") ")`r`n"
    out .= "- " opt.dose " mg IV q" opt.tau "h  ->  AUC24 " Round(opt.auc,0) " mg*hr/L, projected trough " Round(opt.trough,1) " mcg/mL, peak " Round(opt.peak,1) " mcg/mL (TDD " Round(opt.tdd,0) " mg/day).`r`n"
    if opt.auc < 400 || opt.auc > 600
        out .= "- NOTE: closest formulary regimen lands AUC outside 400-600. Consider nonstandard dose/interval, extended infusion, or level-guided adjustment.`r`n"

    ; also mirror into the projection fields for the tracker/note flow
    projDoseCtrl.Value := opt.dose
    projTauCtrl.Value := opt.tau

    if userDose > 0 && userTau > 0 {
        uAuc := VancoK_Auc24(userDose, userTau, post.cl)
        uTr := VancoK_SsTrough(userDose, userTau, userInf, post.cl, post.vd)
        uPk := VancoK_SsPeak(userDose, userTau, userInf, post.cl, post.vd)
        out .= "`r`nYOUR ENTERED REGIMEN`r`n"
        out .= "- " userDose " mg q" userTau "h over " userInf " hr  ->  AUC24 " Round(uAuc,0) ", trough " Round(uTr,1) ", peak " Round(uPk,1) ".`r`n"
        out .= Vanco_AucInterpretation(uAuc, uTr, renalCtrl.Text)
    }

    if lvls.Length >= 1 {
        out .= "`r`nLEVELS USED`r`n"
        for lv in lvls
            out .= "- " Round(lv.c,1) " mcg/mL at " Round(lv.t,1) " hr after infusion start.`r`n"
        if !haveBayes
            out .= "- Levels entered but current regimen (dose + interval) missing, so no Bayesian update was performed. Fill 'Already on vanco' dose and interval.`r`n"
    } else {
        out .= "`r`nLEVELS`r`n- None entered. Plan an early AUC/level (first 24-48 hr; sooner in AKI/RRT).`r`n"
    }

    out .= "`r`nMONITORING`r`n"
    out .= "- Recheck level before the next meaningful change or sooner with AKI/RRT. Monitor SCr/urine output daily or more often if unstable.`r`n"
    out .= "- Bayesian posterior sharpens with accurately timed levels; garbage-in timing = garbage-out. Confirm MAR administration and exact draw times.`r`n"
    result.Value := out
}


Vanco_BasicPatientPk(age, ht, wt, scr, isFemale, renalText) {
    ; ht is now in cm
    heightM := ht / 100
    bmi := wt / (heightM * heightM)
    ; Devine IBW uses feet/inches internally; convert cm once here
    inchesOver5ft := Max((ht / 2.54) - 60, 0)
    ibw := (isFemale ? 45.5 : 50) + 2.3 * inchesOver5ft
    adjbw := ibw + 0.4 * (wt - ibw)
    if bmi < 18.5 {
        cgWt := wt, label := "actual body weight"
    } else if bmi < 30 {
        cgWt := ibw, label := "ideal body weight"
    } else {
        cgWt := adjbw, label := "adjusted body weight"
    }
    crcl := ((140 - age) * cgWt) / (72 * scr)
    if isFemale
        crcl *= 0.85
    vd := Max(0.5 * wt, 0.7 * wt)
    if InStr(renalText, "iHD") {
        cl := 0.35
        crcl := ""
    } else if InStr(renalText, "CRRT") {
        cl := 2.0
        crcl := ""
    } else {
        cl := Max(0.25, 0.05 * Max(crcl, 1))
        if InStr(renalText, "AKI")
            cl := Max(0.25, cl * 0.6)
    }
    halfLife := 0.693 * vd / cl
    return { bmi: bmi, ibw: ibw, adjbw: adjbw, cgWt: cgWt, cgWtLabel: label,
             crcl: crcl, vd: vd, cl: cl, halfLife: halfLife }
}


Vanco_TargetSummary(severityText, mic) {
    out := "- Serious invasive MRSA target: AUC24/MIC 400-600, generally assuming MIC 1 mg/L by broth microdilution.`r`n"
    if InStr(severityText, "Non-severe")
        out .= "- Non-severe indication selected: many local protocols allow less aggressive exposure; do not force AUC 400-600 if indication does not require it.`r`n"
    if mic != 1
        out .= "- MIC entered as " mic ". If MIC >1, vancomycin target attainment may be unlikely without toxicity; discuss alternative therapy/ID.`r`n"
    return out
}


Vanco_LoadingDose(wt, severityText) {
    ; 25 mg/kg for serious/MRSA, 20 mg/kg for non-severe / empiric.
    ; Vanco_RoundDose caps at 2000 mg and snaps to the nearest available dose.
    mgkg := InStr(severityText, "Serious") ? 25 : 20
    return Vanco_RoundDose(mgkg * wt)
}


Vanco_InitialMaintenanceSuggestion(wt, crcl, renalText) {
    ; All maintenance doses are snapped to the formulary and capped at 2000 mg via Vanco_RoundDose.
    if InStr(renalText, "iHD")
        return { dose: Vanco_RoundDose(25 * wt),
                 tau: "post-HD",
                 note: "iHD: initial dose at start or after HD, then dose by pre-HD trough or level-guided protocol; typical supplemental dose is 500–1000 mg after each session once steady state is reached." }

    if InStr(renalText, "CRRT")
        return { dose: Vanco_RoundDose(15 * wt),
                 tau: 24,
                 note: "CRRT: clearance varies widely with effluent rate, filter type, and downtime. Use early levels and adjust per local protocol." }

    if InStr(renalText, "AKI")
        return { dose: Vanco_RoundDose(15 * wt),
                 tau: 24,
                 note: "AKI/unstable SCr: start with a loading dose then dose-by-level until renal trajectory is clear; avoid fixed intervals." }

    if crcl = "" or crcl < 20
        return { dose: Vanco_RoundDose(15 * wt),
                 tau: 48,
                 note: "Very low renal function (CrCl <20): extended interval; dose by levels." }

    if crcl < 40
        return { dose: Vanco_RoundDose(15 * wt),
                 tau: 24,
                 note: "Reduced renal function (CrCl 20–39): obtain early level; consider extending interval if trough / AUC is high." }

    if crcl < 65
        return { dose: Vanco_RoundDose(15 * wt),
                 tau: 24,
                 note: "Moderate renal function (CrCl 40–64): verify with early AUC / level." }

    if crcl < 100
        return { dose: Vanco_RoundDose(15 * wt),
                 tau: 12,
                 note: "Normal renal function (CrCl 65–99): standard q12h starting point; obtain level at third dose or per protocol." }

    return { dose: Vanco_RoundDose(15 * wt),
             tau: 8,
             note: "High estimated CrCl (≥100): augmented renal clearance possible; obtain early level — q8h or even q6h may be needed to reach target AUC." }
}


Vanco_ProjectRegimen(dose, tau, infHr, pk) {
    tau := (IsNumber(tau) && Number(tau) > 0) ? Number(tau) : 24
    infHr := (IsNumber(infHr) && Number(infHr) > 0) ? Number(infHr) : 1
    dose := Number(dose)
    k := pk.cl / pk.vd
    auc := dose * (24 / tau) / pk.cl
    accum := 1 / (1 - Exp(-k*tau))
    infusionFactor := (1 - Exp(-k*infHr)) / (k*infHr)
    peak := (dose / pk.vd) * accum * infusionFactor
    trough := peak * Exp(-k * (tau - infHr))
    return { auc: auc, peak: peak, trough: trough, k: k }
}

Vanco_LevelSummary(level1Text, hr1Text, level2Text, hr2Text, pk) {
    out := ""
    if IsNumber(Trim(level1Text)) and IsNumber(Trim(level2Text)) and IsNumber(Trim(hr2Text)) and Number(Trim(level1Text)) > 0 and Number(Trim(level2Text)) > 0 and Number(Trim(hr2Text)) > 0 {
        c1 := Number(Trim(level1Text)), c2 := Number(Trim(level2Text)), dt := Number(Trim(hr2Text))
        if c1 > c2 {
            k := Ln(c1/c2) / dt
            tHalf := 0.693 / k
            cl := k * pk.vd
            out .= "- Two-level patient-specific elimination estimate: ke " Round(k,4) " hr^-1; half-life " Round(tHalf,1) " hr; CL " Round(cl,2) " L/hr using Vd " Round(pk.vd,1) " L.`r`n"
            out .= "- This estimate is valid only if both levels were post-distribution, accurately timed, and during the same elimination phase without intervening dialysis/filter changes or doses.`r`n"
        } else {
            out .= "- Two levels entered but second is not lower than first; cannot estimate elimination. Check dose/level timing or distribution phase.`r`n"
        }
    } else if IsNumber(Trim(level1Text)) {
        lvl := Number(Trim(level1Text))
        out .= "- Single level entered: " Round(lvl,1) " mcg/mL"
        if IsNumber(Trim(hr1Text))
            out .= " at " Round(Number(Trim(hr1Text)),1) " hr after infusion end"
        out .= ". A single level can guide hold/redose decisions but is less reliable for AUC without Bayesian software or assumptions.`r`n"
        if lvl > 25
            out .= "- Level is high by most trough/random contexts: consider holding and repeating level/SCr before redosing unless timing explains peak/post-infusion value.`r`n"
        else if lvl < 10
            out .= "- Level is low by most serious-infection contexts: consider whether a dose/redose is needed, but interpret with timing and indication.`r`n"
    } else {
        out .= "- No level entered. For serious infection, plan early AUC/level assessment, especially within first 24-48 hr and sooner in AKI/RRT.`r`n"
    }
    return out
}

Vanco_CurrentLevelAucEstimate(doseText, tauText, infText, levelText, levelHrText, pk) {
    if !IsNumber(Trim(doseText)) or !IsNumber(Trim(tauText)) or !IsNumber(Trim(levelText))
        return ""
    dose := Number(Trim(doseText)), tau := Number(Trim(tauText)), lvl := Number(Trim(levelText))
    if dose <= 0 or tau <= 0 or lvl <= 0
        return ""
    infHr := Vanco_NumOrDefault(infText, 1)
    model := Vanco_ProjectRegimen(dose, tau, infHr, pk)
    t := IsNumber(Trim(levelHrText)) ? Number(Trim(levelHrText)) : (tau - infHr)
    if t < 0
        t := tau - infHr
    expected := model.peak * Exp(-model.k * t)
    if expected <= 0
        return ""
    scaledAuc := model.auc * (lvl / expected)
    timing := IsNumber(Trim(levelHrText)) ? (Round(t,1) " hr after infusion end") : "assumed trough timing because no post-infusion time was entered"
    out := "- Level-calibrated rough exposure: current regimen " dose " mg q" tau "h has model expected concentration " Round(expected,1) " mcg/mL at " timing "; entered level " Round(lvl,1) " gives proportional AUC estimate ~" Round(scaledAuc,0) " mg*hr/L.`r`n"
    out .= "- This proportional estimate is not Bayesian and is invalid if timing/MAR is wrong, not at steady state, distribution phase, AKI/RRT changed, or doses were missed/held.`r`n"
    return out
}

Vanco_AucInterpretation(auc, trough, renalText) {
    out := ""
    if auc < 400
        out .= "- Interpretation: projected AUC below 400; may be underexposed for serious MRSA if MIC 1, unless indication allows lower exposure.`r`n"
    else if auc <= 600
        out .= "- Interpretation: projected AUC within 400-600 target range for serious MRSA with MIC 1.`r`n"
    else
        out .= "- Interpretation: projected AUC above 600; nephrotoxicity risk increases. Consider lower total daily dose/longer interval and level-guided reassessment.`r`n"
    if trough > 20
        out .= "- Projected trough >20 mcg/mL: increased accumulation/toxicity concern; verify before continuing fixed regimen.`r`n"
    if InStr(renalText, "AKI") or InStr(renalText, "iHD") or InStr(renalText, "CRRT")
        out .= "- RRT/AKI caveat: projected AUC/trough from simple one-compartment equations is a rough estimate only; prefer dose-by-level/Bayesian/local RRT protocol.`r`n"
    return out
}

Vanco_RenalCaveat(renalText) {
    if InStr(renalText, "AKI")
        return "Unstable renal function makes AUC prediction unreliable; avoid overconfidence and dose by levels."
    if InStr(renalText, "iHD")
        return "Use pre-HD concentration targets and post-HD redosing; dialysis schedule and high-flux filter matter."
    if InStr(renalText, "CRRT")
        return "Use CRRT protocol and early levels; effluent rate/filter downtime substantially change clearance."
    return "Stable renal function assumption used for population PK estimate."
}


; Snaps a raw dose to the nearest available formulary dose.
; Anything above 2000 mg returns 2000 mg (facility max).
; Anything below 500 mg returns 500 mg (smallest available).
Vanco_RoundDose(rawDose) {
    static available := [500, 750, 1000, 1250, 1500, 1750, 2000]
    raw := Min(Max(rawDose, 0), 2100)   ; clamp before comparing
    best := available[1]
    bestDiff := Abs(raw - best)
    for d in available {
        diff := Abs(raw - d)
        if diff < bestDiff
            bestDiff := diff, best := d
    }
    return best
}

Vanco_DoseRound(dose) {
    return Vanco_RoundDose(dose) " mg"
}

Vanco_NumOrDefault(txt, def) {
    txt := Trim(txt)
    return (IsNumber(txt) && Number(txt) > 0) ? Number(txt) : def
}

Vanco_FillSuggestedRegimen(projDoseCtrl, projTauCtrl, resultCtrl) {
    txt := resultCtrl.Value
    if RegExMatch(txt, "Initial maintenance suggestion: (\d+) mg IV q([^\. ]+)", &m) {
        projDoseCtrl.Value := m[1]
        projTauCtrl.Value := m[2]
    } else {
        MsgBox "Build a dosing plan first, then click this button.", "Vancomycin", "Icon!"
    }
}


Vanco_UpdateAmputationPct(siteCtrl, pctCtrl, checkCtrl) {
    site := siteCtrl.Text
    pct := Vanco_AmputationPercent(site)
    if site = "None" {
        pctCtrl.Value := "0"
        checkCtrl.Value := 0
        return
    }
    checkCtrl.Value := 1
    if site != "Custom %"
        pctCtrl.Value := Format("{:.1f}", pct)
    else if !IsNumber(Trim(pctCtrl.Value))
        pctCtrl.Value := ""
}

Vanco_AmputationPercent(site) {
    switch site {
        case "Hand": return 0.7
        case "Forearm + hand": return 2.3
        case "Entire arm": return 5.0
        case "Foot": return 1.5
        case "Below-knee": return 5.9
        case "Above-knee": return 11.0
        case "Entire leg": return 16.0
        case "Bilateral below-knee": return 11.8
        case "Bilateral above-knee": return 22.0
        default: return 0
    }
}

Vanco_SetNow(timeCtrl) {
    timeCtrl.Value := FormatTime(A_Now, "yyyy-MM-dd HHmm")
}

Vanco_ClearTrackerFields(timeCtrl, typeCtrl, doseCtrl, tauCtrl, levelCtrl, scrCtrl, notesCtrl) {
    timeCtrl.Value := FormatTime(A_Now, "yyyy-MM-dd HHmm")
    typeCtrl.Value := 1
    doseCtrl.Value := ""
    tauCtrl.Value := ""
    levelCtrl.Value := ""
    scrCtrl.Value := ""
    notesCtrl.Value := ""
}

Vanco_AddTrackerEventFromFields(patientCtrl, timeCtrl, typeCtrl, doseCtrl, tauCtrl, levelCtrl, scrCtrl, notesCtrl, lv) {
    pid := Trim(patientCtrl.Value)
    if pid = "" {
        MsgBox "Enter a patient/tracker ID first.", "Vancomycin Tracker", "Icon!"
        return
    }
    ts := Trim(timeCtrl.Value)
    if ts = "" {
        MsgBox "Enter the event time or click Now.", "Vancomycin Tracker", "Icon!"
        return
    }
    typ := typeCtrl.Text
    dose := Trim(doseCtrl.Value), tau := Trim(tauCtrl.Value), lvl := Trim(levelCtrl.Value), scr := Trim(scrCtrl.Value)
    if (typ = "Dose given" or typ = "Regimen changed") and !IsNumber(dose) {
        MsgBox "For a dose/regimen event, enter the dose in mg.", "Vancomycin Tracker", "Icon!"
        return
    }
    if typ = "Level drawn" and !IsNumber(lvl) {
        MsgBox "For a level event, enter the vancomycin level.", "Vancomycin Tracker", "Icon!"
        return
    }
    if typ = "SCr/BMP" and !IsNumber(scr) {
        MsgBox "For an SCr/BMP event, enter the SCr.", "Vancomycin Tracker", "Icon!"
        return
    }
    row := { patientId: pid, timestamp: ts, eventType: typ, doseMg: dose, intervalHr: tau, level: lvl, scr: scr, notes: Trim(notesCtrl.Value) }
    rows := Vanco_ReadAllTrackerRows()
    rows.Push(row)
    Vanco_SaveAllTrackerRows(rows)
    Vanco_LoadTrackerRows(patientCtrl, lv)
    Vanco_ClearTrackerFields(timeCtrl, typeCtrl, doseCtrl, tauCtrl, levelCtrl, scrCtrl, notesCtrl)
}

Vanco_LoadTrackerRows(patientCtrl, lv) {
    global VancoTrackerCsvPath
    pid := Trim(patientCtrl.Value)
    lv.Delete()
    if pid = "" {
        MsgBox "Enter a patient/tracker ID first.", "Vancomycin Tracker", "Icon!"
        return
    }
    rows := Vanco_ReadTrackerRows(pid)
    for r in rows
        lv.Add(, r.timestamp, r.eventType, r.doseMg, r.intervalHr, r.level, r.scr, r.notes)
}

Vanco_AddTrackerEvent(patientCtrl, lv) {
    global VancoTrackerCsvPath
    pid := Trim(patientCtrl.Value)
    if pid = "" {
        MsgBox "Enter a patient/tracker ID first.", "Vancomycin Tracker", "Icon!"
        return
    }
    ib := InputBox("Enter event as:`nTimestamp | Type | DoseMg | qHr | Level | SCr | Notes`n`nExample:`n2026-07-04 1800 | dose | 1500 | 12 | | 1.1 | load", "Add Vancomycin Event", "w700 h220")
    if ib.Result != "OK"
        return
    parts := StrSplit(ib.Value, "|")
    while parts.Length < 7
        parts.Push("")
    row := { patientId: pid, timestamp: Trim(parts[1]), eventType: Trim(parts[2]), doseMg: Trim(parts[3]), intervalHr: Trim(parts[4]), level: Trim(parts[5]), scr: Trim(parts[6]), notes: Trim(parts[7]) }
    rows := Vanco_ReadAllTrackerRows()
    rows.Push(row)
    Vanco_SaveAllTrackerRows(rows)
    Vanco_LoadTrackerRows(patientCtrl, lv)
}

Vanco_DeleteTrackerEvent(patientCtrl, lv) {
    pid := Trim(patientCtrl.Value)
    rowNum := lv.GetNext()
    if pid = "" or rowNum = 0 {
        MsgBox "Enter patient ID and select a tracker row.", "Vancomycin Tracker", "Icon!"
        return
    }
    ts := lv.GetText(rowNum, 1), typ := lv.GetText(rowNum, 2), notes := lv.GetText(rowNum, 7)
    rows := Vanco_ReadAllTrackerRows()
    newRows := []
    removed := false
    for r in rows {
        if !removed and r.patientId = pid and r.timestamp = ts and r.eventType = typ and r.notes = notes {
            removed := true
            continue
        }
        newRows.Push(r)
    }
    Vanco_SaveAllTrackerRows(newRows)
    Vanco_LoadTrackerRows(patientCtrl, lv)
}

Vanco_AnalyzeHistory(patientCtrl, wtCtrl, projDoseCtrl, projTauCtrl, projInfCtrl, output) {
    pid := Trim(patientCtrl.Value)
    if pid = "" {
        MsgBox "Enter a patient/tracker ID first.", "Vancomycin Tracker", "Icon!"
        return
    }
    rows := Vanco_ReadTrackerRows(pid)
    levels := []
    doses := []
    scrs := []
    for r in rows {
        if IsNumber(r.level)
            levels.Push(r)
        if IsNumber(r.doseMg)
            doses.Push(r)
        if IsNumber(r.scr)
            scrs.Push(r)
    }
    out := "VANCOMYCIN TRACKER SUMMARY for " pid "`r`n"
    out .= "- Events: " rows.Length "; dose rows: " doses.Length "; level rows: " levels.Length "; SCr rows: " scrs.Length ".`r`n"
    if doses.Length
        out .= "- Last dose row: " doses[doses.Length].timestamp ", " doses[doses.Length].doseMg " mg q" doses[doses.Length].intervalHr "h. " doses[doses.Length].notes "`r`n"
    if levels.Length
        out .= "- Last level row: " levels[levels.Length].timestamp ", level " levels[levels.Length].level " mcg/mL. " levels[levels.Length].notes "`r`n"
    if scrs.Length
        out .= "- Last SCr row: " scrs[scrs.Length].timestamp ", SCr " scrs[scrs.Length].scr ".`r`n"
    if levels.Length >= 2 {
        l1 := levels[levels.Length-1], l2 := levels[levels.Length]
        out .= "- Two most recent levels are available: " l1.level " then " l2.level " mcg/mL. If no dose/RRT occurred between them and both are post-distribution, enter them on the Minimum Info tab with hours between levels for a numeric ke estimate.`r`n"
    }
    if IsNumber(Trim(wtCtrl.Value)) and IsNumber(Trim(projDoseCtrl.Value)) and IsNumber(Trim(projTauCtrl.Value)) {
        out .= "- Current projected regimen fields: " Trim(projDoseCtrl.Value) " mg q" Trim(projTauCtrl.Value) "h for " Trim(wtCtrl.Value) " kg. Rebuild the dosing plan after updating SCr/renal status/levels.`r`n"
    }
    out .= "`r`nSuggested next action: verify exact administration times in MAR, exact level collection time, current SCr/urine output/RRT settings, and whether a dose was given between levels before changing the regimen."
    output.Value := out
}

Vanco_ReadTrackerRows(pid) {
    rows := Vanco_ReadAllTrackerRows()
    out := []
    for r in rows {
        if r.patientId = pid
            out.Push(r)
    }
    return out
}

Vanco_ReadAllTrackerRows() {
    global VancoTrackerCsvPath
    rows := []
    if !FileExist(VancoTrackerCsvPath)
        return rows
    content := FileRead(VancoTrackerCsvPath, "UTF-8")
    for i, line in StrSplit(content, "`n", "`r") {
        if i = 1 or Trim(line) = ""
            continue
        f := CsvParseLine(line)
        while f.Length < 8
            f.Push("")
        rows.Push({ patientId: f[1], timestamp: f[2], eventType: f[3], doseMg: f[4], intervalHr: f[5], level: f[6], scr: f[7], notes: f[8] })
    }
    return rows
}

Vanco_SaveAllTrackerRows(rows) {
    global VancoTrackerCsvPath
    text := "PatientId,Timestamp,EventType,DoseMg,IntervalHr,LevelMcgMl,Scr,Notes`r`n"
    for r in rows
        text .= CsvEscape(r.patientId) "," CsvEscape(r.timestamp) "," CsvEscape(r.eventType) "," CsvEscape(r.doseMg) "," CsvEscape(r.intervalHr) "," CsvEscape(r.level) "," CsvEscape(r.scr) "," CsvEscape(r.notes) "`r`n"
    AtomicWrite(VancoTrackerCsvPath, text)
}

Vanco_BuildNote(noteTypeCtrl, contextCtrl, doseResultCtrl, trackResultCtrl, noteOutCtrl) {
    typ := noteTypeCtrl.Text
    context := Trim(contextCtrl.Value)
    plan := Trim(doseResultCtrl.Value)
    hist := Trim(trackResultCtrl.Value)
    note := "Vancomycin Pharmacy Note - " typ "`r`n"
    note .= "Assessment/Indication: " (context != "" ? context : "Vancomycin therapy reviewed for indication, renal function, cultures/MIC, and levels.") "`r`n`r`n"
    if typ = "Initial consult" {
        note .= "Plan:`r`n- Initiate vancomycin per AUC-guided dosing strategy when clinically indicated.`r`n- Target AUC24/MIC 400-600 for serious MRSA infection when MIC assumed 1; verify if a lower target is appropriate for non-severe indication.`r`n- Obtain levels per protocol and monitor renal function/urine output.`r`n"
    } else if typ = "Follow-up adjustment" {
        note .= "Plan:`r`n- Vancomycin regimen adjusted based on level/timing, renal function trend, and projected exposure.`r`n- Recheck level at next protocol-appropriate time or sooner if renal function/RRT changes.`r`n"
    } else if typ = "Level assessment / redose" {
        note .= "Plan:`r`n- Level interpreted with collection time and last administration time. Redose/hold decision should account for renal trajectory and target exposure.`r`n"
    } else {
        note .= "Plan:`r`n- Hold or dose-by-level due to AKI/RRT/unstable kinetics. Repeat level and BMP/SCr per protocol before next dose unless clinical urgency requires otherwise.`r`n"
    }
    if plan != ""
        note .= "`r`nCalculator summary:`r`n" Vanco_CompactForNote(plan) "`r`n"
    if hist != ""
        note .= "`r`nTracker summary:`r`n" Vanco_CompactForNote(hist) "`r`n"
    note .= "`r`nMonitoring: SCr/urine output, vancomycin levels/AUC, culture results/de-escalation opportunity, infusion reactions, and nephrotoxin exposure. Bayesian/local protocol verification preferred."
    noteOutCtrl.Value := note
}

Vanco_CompactForNote(txt) {
    lines := StrSplit(txt, "`r`n")
    out := ""
    keep := ["- Loading dose:", "- Initial maintenance suggestion:", "- Entered/projected regimen:", "- Projected AUC24:", "- Projected steady-state trough:", "- Interpretation:", "- Last dose row:", "- Last level row:", "- Last SCr row:"]
    for line in lines {
        for k in keep {
            if InStr(line, k) = 1 {
                out .= line "`r`n"
                break
            }
        }
    }
    return out != "" ? out : txt
}

; =================================================================================================
; END OF SCRIPT
; =================================================================================================
;  WORKFLOW TOOLS IMPORTED FROM LEGACY UTILITY SCRIPTS
; =================================================================================================
Workflow_TypeText(str, delayMs := 60) {
    for ch in StrSplit(str, "") {
        Send ch
        Sleep delayMs
    }
}

Workflow_OpenFehrTicket() {
    SetTitleMatchMode 2
    CoordMode "Mouse", "Screen"
    url := WorkflowToolData("fehr_ticket", "data1", "https://tinyurl.com/FEHR-TICKET")

    if !WinExist("ahk_exe msedge.exe") {
        Run "msedge.exe"
        if !WinWait("ahk_exe msedge.exe", , 15) {
            MsgBox "Edge did not open within 15 seconds.", "FEHR Ticket", "Icon!"
            return
        }
    }

    WinActivate "ahk_exe msedge.exe"
    if !WinWaitActive("ahk_exe msedge.exe", , 10) {
        MsgBox "Edge did not become active.", "FEHR Ticket", "Icon!"
        return
    }

    if (MonitorGetCount() >= 2) {
        MonitorGet 2, &L, &T, &R, &B
        WinMove L, T, R - L, B - T, "ahk_exe msedge.exe"
        Sleep 500
    }

    Send "^t"
    Sleep 500
    SendText url
    Send "{Enter}"
    Sleep 1000
    Click 2841, 549
}

Workflow_MCDSOverride() {
    static running := false
    if running
        return
    running := true
    try MCDS_RunOverrideAutomation()
    finally running := false
}

Workflow_EyeDropOrder() {
    dialogTitle := WorkflowToolData("eyedrop_order", "data2", "Verify Med Order")
    product := WorkflowToolData("eyedrop_order", "data1", "carboxymethylcellulose 0.5% (PF) eye drops UD")
    if !IsVerifyMedOrderWindow() {
        MsgBox("Open the Verify Med Order dialog before using this workflow.", "Eye Drop Selection", "Icon!")
        return
    }
    dialogHwnd := WinGetID("A")
    Combined_RequireWindow(dialogHwnd)
    Send("{Tab}")
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    Send("{Enter}")
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    Send("{Tab 2}")
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    SendText(product)
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    Send("{Tab}")
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    Send("{Enter}")
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    Send("{Tab 14}")
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    Send("^a")
    Sleep(50)
    Combined_RequireWindow(dialogHwnd)
    Send("{Backspace}")
    if !WinExist("ahk_id " dialogHwnd) {
        MsgBox("The order dialog has closed. No submission was sent.")
        return
    }
    WinActivate("ahk_id " dialogHwnd)
    if !WinWaitActive("ahk_id " dialogHwnd, , 2) {
        MsgBox("The Verify Med Order dialog is no longer available. No submission was sent.", "Eye Drop Selection", "Icon!")
        return
    }
    Combined_RequireWindow(dialogHwnd)
    Send("!o")
}

Workflow_VerifyMedOrderDoubleH(*) {
    static lastH := 0
    now := A_TickCount
    if now - lastH > 300 {
        lastH := now
        return
    }
    lastH := 0

    if !IsVerifyMedOrderWindow()
        return

    SendEvent("!d")
    Sleep(150)
    SendEvent("{Tab}")
    Sleep(100)
    SendEvent("{Up 2}")
    Sleep(100)
    SendEvent("{Tab 3}")
    Sleep(100)
    SendEvent("{Down 4}")
    Sleep(100)
    SendEvent("{Tab}")
    Sleep(100)
    SendEvent("{Enter}")
    Sleep(200)
    SendEvent("{Tab}")
    Sleep(100)
    SendEvent("{Down}")
    Sleep(100)
    SendEvent("{Up}")
    Sleep(100)
    SendEvent("+{Tab}")
    Sleep(100)
    SendEvent("{Enter}")
    Sleep(200)
    SendEvent("!o")
    Sleep(200)
    SendEvent("!o")
}

Workflow_MID() {
    dateFmt := WorkflowToolData("midnight_datetime", "data1", "MM/dd/yyyy")
    timeText := WorkflowToolData("midnight_datetime", "data2", "2359")
    Send "^a"
    Sleep 50
    Send "{Delete}"
    Sleep 50
    SendText FormatTime(, dateFmt)
    Sleep 50
    Send "{Tab}"
    Sleep 50
    SendText timeText
}

Workflow_NowDateTime() {
    dateFmt := WorkflowToolData("now_datetime", "data1", "MM/dd/yyyy HH:mm")
    Send "^a"
    Sleep 50
    Send "{Delete}"
    Sleep 50
    SendText FormatTime(, dateFmt)
    Sleep 50
    Send "{Tab}"
}

Workflow_FillLocation() {
    CoordMode "Mouse", "Window"
    facility := WorkflowToolData("location", "data1", "539 CINCINNATI OH VA MEDICAL CENTER")
    locCode := WorkflowToolData("location", "data2", "539 B")
    service := WorkflowToolData("location", "data3", "539-PHARM-SVC")
    Workflow_TypeText(facility)
    Send "{Enter}"
    Sleep 2000
    Loop 11 {
        Send "{Tab}"
        Sleep 80
    }
    Workflow_TypeText(locCode)
    Send "{Tab}"
    Sleep 100
    Workflow_TypeText(service)
}

Workflow_NewPatientSearch() {
    SetKeyDelay 70, 70
    Send "{Alt}"
    Send "P"
    Send "{Enter}"
    Send "S"
    Send "{Enter}"
    Sleep 500
    Send "{Tab 3}"
}

Workflow_NewBVE() {
    CoordMode "Mouse", "Screen"
    facility := WorkflowToolData("new_bve", "data1", "539 CINCINNATI OH VA MEDICAL CENTER")
    locCode := WorkflowToolData("new_bve", "data2", "539 B")
    service := WorkflowToolData("new_bve", "data3", "539-PHARM-SVC")

    Send "{Alt}"
    Sleep 1000
    Send "P"
    Send "{Enter}"
    Send "P"
    Send "{Enter}"
    Sleep 5000
    Workflow_TypeText(facility)
    Send "{Enter}"
    Sleep 1000
    Loop 11 {
        Send "{Tab}"
        Sleep 80
    }
    Workflow_TypeText(locCode)
    Send "{Tab}"
    Sleep 100
    Workflow_TypeText(service)
    Sleep 500
    Click 1575, 876
    Sleep 2000
    Click 166, 294
    Sleep 2000
    Click 746, 253
}

Patient_SelectScreenRegion(prompt := "Drag over the patient information") {
    CoordMode "Mouse", "Screen"

    ToolTip "CAPTURE READY  ·  click + drag`n" prompt
    KeyWait "LButton", "D"
    MouseGetPos &x1, &y1
    ToolTip

    fill := Gui("-Caption +ToolWindow +AlwaysOnTop +E0x20")
    fill.BackColor := "40CBDA"
    WinSetTransparent 42, fill
    fill.Show("x" x1 " y" y1 " w1 h1 NoActivate")

    borders := []
    Loop 4 {
        edge := Gui("-Caption +ToolWindow +AlwaysOnTop +E0x20")
        edge.BackColor := "C8FF3D"
        WinSetTransparent 238, edge
        edge.Show("x" x1 " y" y1 " w1 h1 NoActivate")
        borders.Push(edge)
    }

    tick := 0
    canceled := false

    while GetKeyState("LButton", "P") {
        if GetKeyState("Esc", "P") {
            canceled := true
            break
        }

        MouseGetPos &cx, &cy

        rx := Min(x1, cx)
        ry := Min(y1, cy)
        rw := Abs(cx - x1)
        rh := Abs(cy - y1)

        if rw > 0 && rh > 0 {
            thickness := 4
            fill.Move(rx, ry, rw, rh)
            borders[1].Move(rx, ry, rw, thickness)
            borders[2].Move(rx, ry + rh - thickness, rw, thickness)
            borders[3].Move(rx, ry, thickness, rh)
            borders[4].Move(rx + rw - thickness, ry, thickness, rh)

            tick += 1
            pulse := Mod(Floor(tick / 10), 2) = 0 ? "C8FF3D" : "40CBDA"
            for edge in borders
                edge.BackColor := pulse

            ToolTip "CAPTURING  ·  " rw " × " rh " px`nRelease to analyze", cx + 18, cy + 18
        }

        Sleep 16
    }

    ToolTip
    fill.Destroy()
    for edge in borders
        edge.Destroy()

    if canceled
        return { left: 0, top: 0, w: 0, h: 0, canceled: true }

    MouseGetPos &x2, &y2

    left := Min(x1, x2)
    top := Min(y1, y2)
    w := Abs(x2 - x1)
    h := Abs(y2 - y1)

    return { left: left, top: top, w: w, h: h, canceled: false }
}

BMI_FromRegion() {
    region := Patient_SelectScreenRegion("Select demographics, medication orders, or labs")
    left := region.left
    top := region.top
    w := region.w
    h := region.h

    if w < 20 || h < 10 {
        MsgBox(
            "Selection too small — try again.",
            "Patient Information",
            "Icon!"
        )
        return
    }

    captureResult := 0
    ToolTip "CAPTURE LOCKED  ·  reading patient data..."

    try {
        captureResult := PatientV2_CaptureAndParse(
            left,
            top,
            w,
            h
        )
    } catch as e {
        ToolTip
        MsgBox(
            "OCR error: " e.Message,
            "Patient Information",
            "Icon!"
        )
        return
    }
    ToolTip

    if !IsObject(captureResult)
        || Trim(captureResult.text) = "" {
        MsgBox(
            "Nothing was recognized in that region. Try selecting a larger area.",
            "Patient Information",
            "Icon!"
        )
        return
    }

    Demo_ShowPicker(
        captureResult.parsed,
        captureResult.text
    )
}


; Demo_ShowPicker moved to the patient-hub / RSI redesign section below (see PATIENT HUB REBUILD).

Demo_EditParsedData(parsed, previewCtrl, detailsCtrl) {
    g := Gui("+Owner", "Edit Parsed Patient Data")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add("Text", "xm w440",
        "Correct any misread values, then Save & Recompute. "
        . "All dosing below uses these confirmed numbers.")

    g.Add("Text", "xm y+12 w120", "Age (years):")
    ageE := g.Add("Edit", "x+8 yp-3 w120", CaptureV1_EditValue(parsed, "age"))

    g.Add("Text", "xm y+12 w120", "Sex:")
    sexE := g.Add("DropDownList", "x+8 yp-3 w120", ["Select...", "Male", "Female"])
    sexValue := CaptureV1_EditValue(parsed, "sex")
    sexE.Value := sexValue = "Female" ? 3 : (sexValue = "Male" ? 2 : 1)

    g.Add("Text", "xm y+12 w120", "Height (cm):")
    htE := g.Add("Edit", "x+8 yp-3 w120", CaptureV1_EditValue(parsed, "heightCm"))

    g.Add("Text", "xm y+12 w120", "Weight (kg):")
    wtE := g.Add("Edit", "x+8 yp-3 w120", CaptureV1_EditValue(parsed, "weightKg"))

    g.Add("Text", "xm y+12 w120", "SCr (mg/dL):")
    scrE := g.Add("Edit", "x+8 yp-3 w120", CaptureV1_EditValue(parsed, "scr"))

    g.Add("Button", "xm y+18 w140 Default", "Save && Recompute").OnEvent("Click",
        (*) => Demo_SaveEditedData(g, parsed, previewCtrl, detailsCtrl, ageE, sexE, htE, wtE, scrE))
    g.Add("Button", "x+8 yp w100", "Cancel").OnEvent("Click", (*) => g.Destroy())

    g.Show("w480")
}

Demo_SaveEditedData(g, parsed, previewCtrl, detailsCtrl, ageE, sexE, htE, wtE, scrE) {
    parsed.age      := Trim(ageE.Value)
    parsed.sex      := sexE.Value > 1 ? sexE.Text : ""
    parsed.heightCm := Trim(htE.Value)
    parsed.weightKg := Trim(wtE.Value)
    parsed.scr      := Trim(scrE.Value)

    for field in ["age", "sex", "heightCm", "weightKg", "scr"]
        CaptureV1_MarkManual(parsed, field, parsed.%field%)

    PatientCalc_Enrich(parsed)

    preview := ""
    if parsed.age != ""
        preview .= "Age " parsed.age " yr   "
    if parsed.sex != ""
        preview .= parsed.sex "   "
    if parsed.heightCm != ""
        preview .= parsed.heightCm " cm   "
    if parsed.weightKg != ""
        preview .= parsed.weightKg " kg   "
    if parsed.scr != ""
        preview .= "SCr " parsed.scr "   "
    preview .= parsed.allergies.Length " allergies   " parsed.medications.Length " medications"
    previewCtrl.Text := Trim(preview)

    detailsCtrl.Value := Demo_BuildParsedDetails(parsed)
    g.Destroy()
}

Demo_BuildDoseRecommendations(parsed) {
    if !parsed.HasOwnProp("crcl") || parsed.crcl = "" {
        return "`r`n=== DOSE RECOMMENDATIONS ===`r`n"
            . "Cannot calculate - use Edit Data to supply age, sex, height, weight, SCr.`r`n"
    }
    crcl := Number(parsed.crcl)
    actual := parsed.HasOwnProp("weightKg") && parsed.weightKg != "" ? Number(parsed.weightKg) : 0
    if actual <= 0 {
        return "`r`n=== DOSE RECOMMENDATIONS ===`r`n"
            . "Cannot calculate - weight missing. Use Edit Data.`r`n"
    }
    ibw := parsed.HasOwnProp("ibwKg") && parsed.ibwKg != "" ? Number(parsed.ibwKg) : actual
    adjbw := parsed.HasOwnProp("adjbwKg") && parsed.adjbwKg != "" ? Number(parsed.adjbwKg) : actual
    dosingWt := (actual > 1.2 * ibw) ? adjbw : actual
    dosingLabel := (actual > 1.2 * ibw) ? "AdjBW" : "actual"

    out := "`r`n=== DOSE RECOMMENDATIONS (confirmed data) ===`r`n"
    out .= "CrCl " Round(crcl,1) " mL/min | actual " Round(actual,1) " | IBW " Round(ibw,1)
        . " | AdjBW " Round(adjbw,1) " | dosing wt " Round(dosingWt,1) " kg (" dosingLabel ")`r`n"
    out .= "Renal context: " RenalContext_Label(parsed) "`r`n"
    if parsed.HasOwnProp("ocrNeedsReview") && parsed.ocrNeedsReview {
        out .= "OCR SAFETY GATE: one or more medication orders or critical patient values require visual verification. Automatic equivalence statements are withheld until confirmed.`r`n"
    }
    if RenalContext_HasPostHDTiming(parsed)
        out .= "DIALYSIS TIMING CUE: capture contains post-HD / after-dialysis language. Verify whether the order is scheduled after each session and whether a supplemental dose is intended.`r`n"
    if RenalContext_IsRRT(parsed)
        out .= "RRT SAFETY GATE: fixed CrCl-band maintenance comparisons are suppressed; confirm modality, timing, effluent/session details, residual function, and post-treatment supplementation.`r`n"
    else if RenalContext_IsUnstable(parsed)
        out .= "UNSTABLE RENAL FUNCTION: interpret Cockcroft-Gault cautiously; favor trend/levels and reassessment over automatic fixed-interval changes.`r`n"

    flagged := Map()
    for medication in parsed.medications {
        key := PatientV4_MedicationNameKey(medication)
        rec := Demo_DoseForDrug(key, crcl, actual, ibw, adjbw, dosingWt, parsed)
        if rec != "" && !flagged.Has(key) {
            flagged[key] := true
            regimen := DoseAware_ParseRegimen(medication)
            out .= "`r`n" DoseAware_FormatMedicationHeader(medication, regimen)
            sharedContext := PatientRenal_RuleContext(key)
            if sharedContext != ""
                out .= sharedContext
            out .= rec
            if RenalContext_IsRRT(parsed)
                out .= "   RENAL COMPARISON`r`n   Status: WITHHELD FOR RRT CONTEXT`r`n   Confirm modality-specific regimen and treatment timing before comparison.`r`n"
            else if DoseAware_IsLoadingOrder(medication)
                out .= "   RENAL COMPARISON`r`n   Status: LOADING DOSE IDENTIFIED`r`n   Loading doses are intentionally excluded from maintenance-dose variance checks.`r`n"
            else if parsed.HasOwnProp("ocrNeedsReview") && parsed.ocrNeedsReview
                out .= "   RENAL COMPARISON`r`n   Status: WITHHELD FOR OCR VERIFICATION`r`n   Confirm the source order and critical patient values before comparison.`r`n"
            else
                out .= DoseAware_ComparisonNote(medication, regimen, rec, actual, "actual body weight")
        }
    }
    if flagged.Count = 0
        out .= "`r`nNo doseable drugs from the current tables matched the visible meds.`r`n"
    return out
}

Demo_DoseForDrug(key, crcl, actual, ibw, adjbw, dosingWt, parsed := 0) {
    sharedRule := PatientRenal_FindRuleForKey(key)
    if !IsObject(sharedRule)
        return ""

    if IsObject(parsed) && RenalContext_IsRRT(parsed) {
        mode := parsed.renalContext.mode
        if InStr(key,"vancomycin")=1 || InStr(key,"gentamicin")=1 || InStr(key,"tobramycin")=1 || InStr(key,"amikacin")=1
            return "   " mode ": use a loading-dose/level-guided pathway; maintenance depends on modality, treatment timing, residual function, and measured concentrations.`r`n"
        if InStr(key,"cefepime")=1 || InStr(key,"piperacillin")=1 || InStr(key,"meropenem")=1 || InStr(key,"levofloxacin")=1 || InStr(key,"ciprofloxacin")=1 || InStr(key,"acyclovir")=1 || InStr(key,"fluconazole")=1
            return "   " mode ": fixed CrCl-band target withheld. Confirm modality/session or effluent settings, downtime, residual function, infection severity, and post-dialysis supplemental-dose requirements.`r`n"
        if InStr(key,"enoxaparin")=1 || InStr(key,"apixaban")=1 || InStr(key,"rivaroxaban")=1
            return "   " mode ": eligibility and regimen are indication- and modality-specific. Verify product labeling, bleeding risk, local policy, and whether an alternative anticoagulant is preferred.`r`n"
    }
    if InStr(key,"vancomycin")=1 {
        load := Demo_RoundTo(25 * actual, 250)
        maint := Demo_RoundTo(15 * dosingWt, 250)
        interval := crcl >= 90 ? "q8-12h" : crcl >= 50 ? "q12h" : crcl >= 20 ? "q24h" : "dose by level"
        return "   Loading: 25 mg/kg (actual) = " load " mg`r`n"
             . "   Maint: 15 mg/kg (" Round(dosingWt,1) " kg) = " maint " mg " interval "`r`n"
             . "   Target AUC 400-600; obtain level, confirm with Bayesian.`r`n"
    }
    if InStr(key,"enoxaparin")=1 {
        treat := Demo_RoundTo(1 * actual, 5)
        treatDaily := Demo_RoundTo(1.5 * actual, 5)
        if crcl < 30 {
            return "   Treatment (CrCl<30): 1 mg/kg (actual) = " treat " mg SC q24h`r`n"
                 . "   Prophylaxis (CrCl<30): 30 mg SC daily`r`n"
                 . "   Consider anti-Xa monitoring.`r`n"
        }
        return "   Treatment: 1 mg/kg = " treat " mg SC q12h  OR  1.5 mg/kg = " treatDaily " mg SC q24h`r`n"
             . "   Prophylaxis: 40 mg SC daily`r`n"
    }
    if InStr(key,"tobramycin")=1 || InStr(key,"gentamicin")=1 {
        agWt := (actual > 1.2 * ibw) ? adjbw : ibw
        ext := Demo_RoundTo(7 * agWt, 10)
        trad := Demo_RoundTo(2 * agWt, 10)
        interval := crcl >= 60 ? "q24h" : crcl >= 40 ? "q36h" : "q48h / by level"
        return "   Extended-interval: 7 mg/kg (" Round(agWt,1) " kg) = " ext " mg " interval "`r`n"
             . "   Traditional: 2 mg/kg = " trad " mg q8h (adjust by level)`r`n"
             . "   Verify against nomogram; obtain levels.`r`n"
    }
    if InStr(key,"amikacin")=1 {
        agWt := (actual > 1.2 * ibw) ? adjbw : ibw
        ext := Demo_RoundTo(15 * agWt, 50)
        interval := crcl >= 60 ? "q24h" : crcl >= 40 ? "q36h" : "q48h / by level"
        return "   Extended-interval: 15 mg/kg (" Round(agWt,1) " kg) = " ext " mg " interval "`r`n"
             . "   Obtain levels; verify nomogram.`r`n"
    }
    if InStr(key,"cefepime")=1 {
        band := crcl >= 60 ? "2 g q8-12h" : crcl >= 30 ? "2 g q12h" : crcl >= 11 ? "2 g q24h" : "1 g q24h"
        return "   CrCl " Round(crcl,1) ": " band " (severe infection basis)`r`n"
    }
    if InStr(key,"piperacillin")=1 {
        band := crcl > 40 ? "4.5 g q6h (or ext infusion)" : crcl >= 20 ? "3.375 g q6h" : "2.25 g q6h"
        return "   CrCl " Round(crcl,1) ": " band "`r`n"
    }
    if InStr(key,"levofloxacin")=1 {
        band := crcl >= 50 ? "750 mg q24h" : crcl >= 20 ? "750 mg q48h" : "750 mg x1 then 500 mg q48h"
        return "   CrCl " Round(crcl,1) ": " band "`r`n"
    }
    if InStr(key,"ciprofloxacin")=1 {
        band := crcl > 30 ? "400 mg IV q12h / 500-750 mg PO q12h" : "400 mg IV q24h / 500 mg PO q24h"
        return "   CrCl " Round(crcl,1) ": " band "`r`n"
    }
    if InStr(key,"meropenem")=1 {
        band := crcl >= 50 ? "1-2 g q8h" : crcl >= 26 ? "1 g q12h" : crcl >= 10 ? "500 mg q12h" : "500 mg q24h"
        return "   CrCl " Round(crcl,1) ": " band "`r`n"
    }
    if InStr(key,"acyclovir")=1 {
        acWt := (actual > 1.2 * ibw) ? ibw : actual
        dose := Demo_RoundTo(10 * acWt, 50)
        band := crcl > 50 ? "q8h" : crcl >= 25 ? "q12h" : crcl >= 10 ? "q24h" : "50% dose q24h"
        return "   IV: 10 mg/kg (" Round(acWt,1) " kg, IBW if obese) = " dose " mg " band "`r`n"
    }
    if InStr(key,"fluconazole")=1 {
        band := crcl > 50 ? "standard dose" : "50% of maintenance dose (CrCl<=50)"
        return "   Load full; maintenance: " band "`r`n"
    }
    if InStr(key,"apixaban")=1 {
        return "   Standard 5 mg BID; 2.5 mg BID if >=2 of: age>=80, wt<=60 kg, SCr>=1.5.`r`n"
             . "   (AFib dosing; VTE differs.)`r`n"
    }
    if InStr(key,"rivaroxaban")=1 {
        band := crcl >= 50 ? "20 mg daily w/ evening meal" : crcl >= 15 ? "15 mg daily" : "avoid <15"
        return "   AFib, CrCl " Round(crcl,1) ": " band "`r`n"
    }
    return ""
}



; =================================================================================================
; DOSE-AWARE ORDER PARSING (vNext8)
; -------------------------------------------------------------------------------------------------
; Extracts only what is visibly present in the captured order text. It deliberately does not infer
; indication, dialysis modality, infection severity, treatment day, or institutional protocol.
; Comparison language is therefore framed as a pharmacist review cue rather than an autonomous
; dose recommendation.
; =================================================================================================


DoseAware_IsLoadingOrder(orderText) {
    return RegExMatch(orderText, "i)\b(load(?:ing)?|LD|initial dose|first dose|x\s*1|once now|NOW dose|bolus)\b")
}

DoseAware_ParseRegimen(orderText) {
    rec := {
        raw: Trim(orderText),
        dose: "",
        unit: "",
        route: "",
        frequency: "",
        release: "",
        doseBasis: "absolute",
        perKgDose: "",
        complete: false
    }

    clean := RegExReplace(orderText, "i)\s*\[(?:VERIFY OCR|SIDEBAR ONLY.*?)\]\s*$", "")

    ; Parse weight-based expressions first so 15 mg/kg is never misread as an absolute 15 mg dose.
    if RegExMatch(clean, "i)\b(\d+(?:[.,]\d+)?)\s*(mcg|mg|g)\s*/\s*kg\b", &m) {
        rec.dose := StrReplace(m[1], ",", ".")
        rec.unit := StrLower(m[2]) "/kg"
        rec.doseBasis := "weight-based"
        rec.perKgDose := rec.dose
    } else if RegExMatch(clean, "i)\b(\d+(?:[.,]\d+)?)\s*(mcg|mg|g|mL|units?|%)\b(?!\s*/\s*kg)", &m) {
        rec.dose := StrReplace(m[1], ",", ".")
        rec.unit := StrLower(m[2])
    }

    if RegExMatch(clean, "i)\b(IV|IM|SC|SQ|PO|oral|PEG|NG|NJ|G[- ]?tube|J[- ]?tube|SL|buccal|inhaled|topical|rectal)\b", &m)
        rec.route := StrUpper(m[1])

    if RegExMatch(clean, "i)\b(q\s*\d+(?:-\d+)?\s*h(?:ours?)?|qday|daily|once daily|BID|TID|QID|qhs|qam|weekly|every other day|qod|once)\b", &m)
        rec.frequency := DoseAware_NormalizeFrequency(m[1])

    if RegExMatch(clean, "i)\b(extended release|delayed release|enteric coated|ER|XR|XL|SR|CR|DR|EC|LA)\b", &m)
        rec.release := StrUpper(m[1])

    rec.complete := rec.dose != "" && rec.unit != "" && rec.frequency != ""
    return rec
}

DoseAware_NormalizeFrequency(value) {
    f := StrLower(RegExReplace(Trim(value), "\s+", ""))
    aliases := Map(
        "daily", "q24h", "oncedaily", "q24h", "qday", "q24h",
        "bid", "q12h", "tid", "q8h", "qid", "q6h",
        "qhs", "qHS", "qam", "qAM", "qod", "q48h", "everyotherday", "q48h"
    )
    return aliases.Has(f) ? aliases[f] : f
}

DoseAware_FormatMedicationHeader(orderText, regimen) {
    line := orderText "`r`n"
    parts := []
    if regimen.dose != ""
        parts.Push(regimen.dose " " regimen.unit)
    if regimen.route != ""
        parts.Push(regimen.route)
    if regimen.frequency != ""
        parts.Push(regimen.frequency)
    if regimen.release != ""
        parts.Push(regimen.release)
    if regimen.doseBasis = "weight-based"
        parts.Push("weight-based")

    if parts.Length = 0
        return line . "   Captured regimen: not reliably parsed from visible order text.`r`n"

    return line . "   Captured regimen: " DoseAware_Join(parts, " | ") "`r`n"
}

DoseAware_Join(items, separator) {
    out := ""
    for item in items
        out .= (out = "" ? "" : separator) item
    return out
}

DoseAware_ComparisonNote(orderText, regimen, recommendationText, patientWeightKg := "", weightLabel := "patient weight") {
    if regimen.dose = "" && regimen.frequency = ""
        return "   RENAL COMPARISON`r`n   Status: insufficient structured order data.`r`n"
            . "   Action: manually compare the visible order with the renal target above.`r`n"

    if regimen.doseBasis = "weight-based" {
        out := "   RENAL COMPARISON`r`n   Status: WEIGHT-BASED ORDER IDENTIFIED`r`n"
        if patientWeightKg != "" && IsNumber(patientWeightKg) {
            totalMg := DoseAware_WeightBasedTotalMg(regimen.dose, regimen.unit, Number(patientWeightKg))
            if totalMg != ""
                out .= "   Calculated visible dose: " regimen.dose " " regimen.unit " x " Round(Number(patientWeightKg),1) " kg (" weightLabel ") = " DoseAware_FormatMg(totalMg) ".`r`n"
        }
        out .= "   Automated equivalence is withheld until the intended dosing-weight basis, dose cap, indication, and rounded administered dose are confirmed.`r`n"
        return out
    }

    captured := DoseAware_BuildRegimenMetrics(regimen.dose, regimen.unit, regimen.frequency)
    targets := DoseAware_ExtractTargetRegimens(recommendationText)

    ; Keep legacy frequency/dose extraction as a fallback when the recommendation text cannot be paired.
    if targets.Length = 0 {
        freqTargets := DoseAware_ExtractTargetFrequencies(recommendationText)
        doseTargets := DoseAware_ExtractTargetDoses(recommendationText)
        notes := []

        if regimen.frequency != "" && freqTargets.Length > 0 {
            matched := false
            for target in freqTargets {
                if DoseAware_FrequencyCompatible(regimen.frequency, target) {
                    matched := true
                    break
                }
            }
            if !matched
                notes.Push("frequency " regimen.frequency " differs from listed target(s) " DoseAware_Join(freqTargets, "/"))
        }

        if regimen.dose != "" && doseTargets.Length > 0 {
            matched := false
            for target in doseTargets {
                if DoseAware_DosesEquivalent(regimen.dose, regimen.unit, target.dose, target.unit) {
                    matched := true
                    break
                }
            }
            if !matched
                notes.Push("dose " regimen.dose " " regimen.unit " is not an equivalent listed target")
        }

        if notes.Length = 0
            return "   RENAL COMPARISON`r`n   Status: no obvious variance detected from captured text.`r`n"
                . "   Verify: indication, route, dialysis/RRT, infection severity, and local protocol.`r`n"

        return "   RENAL COMPARISON`r`n   Status: REVIEW DIFFERENCE`r`n"
            . "   Difference: " DoseAware_Join(notes, "; ") ".`r`n"
            . "   Verify before action: indication, route, dialysis/RRT, treatment phase, and local protocol.`r`n"
    }

    compatible := []
    sameDaily := []
    for target in targets {
        if DoseAware_RegimensEquivalent(captured, target)
            compatible.Push(target)
        else if captured.tddMg != "" && target.tddMg != "" && DoseAware_NearlyEqual(captured.tddMg, target.tddMg, 0.02)
            sameDaily.Push(target)
    }

    capturedLine := DoseAware_MetricsLabel(captured)
    targetLabels := []
    for target in targets
        targetLabels.Push(DoseAware_MetricsLabel(target))

    out := "   RENAL COMPARISON`r`n"
        . "   Current: " capturedLine "`r`n"
        . "   Listed target" (targets.Length = 1 ? ": " : "s: ") DoseAware_Join(targetLabels, " OR ") "`r`n"

    if compatible.Length > 0 {
        out .= "   Status: no obvious dose/frequency variance detected.`r`n"
    } else if sameDaily.Length > 0 {
        out .= "   Status: REVIEW SCHEDULE`r`n"
            . "   The normalized total daily dose is similar, but the dose size or interval differs.`r`n"
    } else {
        diffs := []
        best := targets[1]
        if captured.doseMg != "" && best.doseMg != "" && !DoseAware_NearlyEqual(captured.doseMg, best.doseMg, 0.02)
            diffs.Push("per-dose amount differs")
        if captured.intervalHours != "" && best.intervalHours != "" && captured.intervalHours != best.intervalHours
            diffs.Push("administration interval differs")
        if captured.tddMg != "" && best.tddMg != "" && !DoseAware_NearlyEqual(captured.tddMg, best.tddMg, 0.02)
            diffs.Push("normalized total daily dose differs")
        if diffs.Length = 0
            diffs.Push("captured regimen is not equivalent to a listed target")

        out .= "   Status: REVIEW DIFFERENCE`r`n"
            . "   Difference: " DoseAware_Join(diffs, "; ") ".`r`n"
    }

    out .= "   Verify before action: indication, route, dialysis/RRT, infection severity, treatment phase, and local protocol.`r`n"
    return out
}


DoseAware_WeightBasedTotalMg(dose, unit, weightKg) {
    if dose = "" || unit = "" || weightKg = "" || !IsNumber(weightKg)
        return ""
    u := StrLower(unit)
    value := Number(dose) * Number(weightKg)
    if u = "mg/kg"
        return value
    if u = "g/kg"
        return value * 1000
    if u = "mcg/kg"
        return value / 1000
    return ""
}

DoseAware_BuildRegimenMetrics(dose, unit, frequency) {
    rec := {
        dose: dose,
        unit: StrLower(unit),
        frequency: DoseAware_NormalizeFrequency(frequency),
        doseMg: "",
        intervalHours: "",
        dosesPerDay: "",
        tddMg: ""
    }

    rec.doseMg := DoseAware_ToMg(dose, unit)
    rec.intervalHours := DoseAware_FrequencyHours(rec.frequency)
    if rec.intervalHours != "" && rec.intervalHours > 0
        rec.dosesPerDay := 24 / rec.intervalHours
    if rec.doseMg != "" && rec.dosesPerDay != ""
        rec.tddMg := rec.doseMg * rec.dosesPerDay
    return rec
}

DoseAware_ToMg(dose, unit) {
    if dose = "" || unit = ""
        return ""
    value := Number(dose)
    u := StrLower(unit)
    if u = "mg"
        return value
    if u = "g"
        return value * 1000
    if u = "mcg"
        return value / 1000
    return ""
}

DoseAware_FrequencyHours(frequency) {
    f := DoseAware_NormalizeFrequency(frequency)
    if RegExMatch(f, "i)^q(\d+)h$", &m)
        return Number(m[1])
    if f = "q24h" || f = "qam" || f = "qhs"
        return 24
    if f = "q48h"
        return 48
    return ""
}

DoseAware_ExtractTargetRegimens(text) {
    result := []
    seen := Map()
    pos := 1

    ; Pair a mass dose with the first nearby explicit interval. This intentionally ignores
    ; percentages, fluid volumes, loading-only phrases without an interval, and unpaired numbers.
    pattern := "i)\b(\d+(?:[.]\d+)?)\s*(mcg|mg|g)\b(?:(?!`r|`n).){0,45}?\b(q\d+(?:-\d+)?h|daily|BID|TID|QID)\b"
    while RegExMatch(text, pattern, &m, pos) {
        freq := DoseAware_NormalizeFrequency(m[3])
        if RegExMatch(freq, "i)^q(\d+)-(\d+)h$", &range) {
            for boundary in [range[1], range[2]] {
                target := DoseAware_BuildRegimenMetrics(m[1], m[2], "q" boundary "h")
                key := target.doseMg "|" target.intervalHours
                if !seen.Has(key) {
                    seen[key] := true
                    result.Push(target)
                }
            }
        } else {
            target := DoseAware_BuildRegimenMetrics(m[1], m[2], freq)
            key := target.doseMg "|" target.intervalHours
            if !seen.Has(key) {
                seen[key] := true
                result.Push(target)
            }
        }
        pos := m.Pos + m.Len
    }
    return result
}

DoseAware_DosesEquivalent(dose1, unit1, dose2, unit2) {
    a := DoseAware_ToMg(dose1, unit1)
    b := DoseAware_ToMg(dose2, unit2)
    if a = "" || b = ""
        return String(dose1) = String(dose2) && StrLower(unit1) = StrLower(unit2)
    return DoseAware_NearlyEqual(a, b, 0.001)
}

DoseAware_RegimensEquivalent(a, b) {
    if a.doseMg = "" || b.doseMg = "" || a.intervalHours = "" || b.intervalHours = ""
        return false
    return DoseAware_NearlyEqual(a.doseMg, b.doseMg, 0.02)
        && DoseAware_NearlyEqual(a.intervalHours, b.intervalHours, 0.001)
}

DoseAware_NearlyEqual(a, b, relativeTolerance := 0.01) {
    av := Number(a)
    bv := Number(b)
    scale := Max(Abs(av), Abs(bv), 1)
    return Abs(av - bv) <= scale * relativeTolerance
}

DoseAware_MetricsLabel(rec) {
    label := rec.dose " " rec.unit
    if rec.frequency != ""
        label .= " " rec.frequency
    if rec.tddMg != ""
        label .= "  [" DoseAware_FormatMg(rec.tddMg) "/day]"
    return label
}

DoseAware_FormatMg(value) {
    v := Number(value)
    if v >= 1000 && Mod(v, 1000) = 0
        return Round(v / 1000, 2) " g"
    if v >= 1000
        return Round(v / 1000, 3) " g"
    return Round(v, 2) " mg"
}

DoseAware_ExtractTargetFrequencies(text) {
    result := []
    seen := Map()
    pos := 1
    while RegExMatch(text, "i)\b(q\d+(?:-\d+)?h|q24h|q12h|q8h|q6h|q36h|q48h|daily|BID|TID|QID)\b", &m, pos) {
        f := DoseAware_NormalizeFrequency(m[1])
        if !seen.Has(f) {
            seen[f] := true
            result.Push(f)
        }
        pos := m.Pos + m.Len
    }
    return result
}

DoseAware_ExtractTargetDoses(text) {
    result := []
    seen := Map()
    pos := 1
    while RegExMatch(text, "i)\b(\d+(?:[.]\d+)?)\s*(mcg|mg|g|mL|units?)\b", &m, pos) {
        key := m[1] "|" StrLower(m[2])
        if !seen.Has(key) {
            seen[key] := true
            result.Push({dose: m[1], unit: StrLower(m[2])})
        }
        pos := m.Pos + m.Len
    }
    return result
}

DoseAware_FrequencyCompatible(captured, target) {
    c := DoseAware_NormalizeFrequency(captured)
    t := DoseAware_NormalizeFrequency(target)
    if c = t
        return true
    ; A target range such as q8-12h is compatible with either boundary.
    if RegExMatch(t, "i)^q(\d+)-(\d+)h$", &m)
        return c = "q" m[1] "h" || c = "q" m[2] "h"
    return false
}

Demo_RoundTo(value, multiple) {
    if multiple <= 0
        return Round(value)
    return Round(value / multiple) * multiple
}


Demo_PickerRun(action, parsed, buttonCtrl, *) {
    pickerGui := buttonCtrl.Gui
    pickerGui.Destroy()

    SafeRun(action, parsed)
    return true
}


Demo_PickerCancel(buttonCtrl, *) {
    buttonCtrl.Gui.Destroy()
    return true
}

PatientRenal_KeyMatchesAny(
    medicationKey,
    medicationNames
) {
    for medicationName in medicationNames {
        configuredKey :=
            PatientV2_NormalizeMatch(
                medicationName
            )

        if medicationKey = configuredKey
            || InStr(
                medicationKey,
                configuredKey
            ) = 1 {

            return true
        }
    }

    return false
}


RenalEvidence_Path() {
    root := RegExReplace(A_ScriptDir, "\\(?:App|Tests)$", "")
    return root "\\renal-test\\renal_evidence.json"
}

RenalEvidence_Load(force := false) {
    global RenalEvidenceCache
    if !IsSet(RenalEvidenceCache)
        RenalEvidenceCache := 0
    if !force && IsObject(RenalEvidenceCache)
        return RenalEvidenceCache
    path := RenalEvidence_Path()
    result := {ok: false, path: path, schemaVersion: 0, generatedAt: "", records: [], error: ""}
    try {
        payload := CRD3_ReadJson(path)
        if !IsObject(payload) || !payload.Has("schemaVersion") || Integer(payload["schemaVersion"]) != 1
            throw Error("Unsupported DailyMed evidence schema version.")
        if !payload.Has("records") || !IsObject(payload["records"])
            throw Error("DailyMed evidence records are missing or invalid.")
        result.ok := true
        result.schemaVersion := Integer(payload["schemaVersion"])
        result.generatedAt := payload.Has("generatedAt") ? String(payload["generatedAt"]) : ""
        result.records := payload["records"]
    } catch as err {
        result.error := err.Message
    }
    RenalEvidenceCache := result
    return result
}

RenalEvidence_MatchesIngredient(record, medicationKey) {
    if !IsObject(record) || medicationKey = ""
        return false
    names := []
    if record.Has("query")
        names.Push(String(record["query"]))
    if record.Has("selected") && IsObject(record["selected"]) {
        for selected in record["selected"] {
            if selected.Has("title")
                names.Push(String(selected["title"]))
        }
    }
    for name in names {
        normalized := RxN_IngredientKey(name)
        alternate := RxN_IngredientKey(RegExReplace(name, "i)\s+and\s+", "-"))
        if normalized != "" && (medicationKey = normalized || InStr(medicationKey, normalized) = 1 || InStr(normalized, medicationKey) = 1)
            return true
        if alternate != "" && (medicationKey = alternate || InStr(medicationKey, alternate) = 1 || InStr(alternate, medicationKey) = 1)
            return true
        if PatientRenal_KeyMatchesAny(medicationKey, [name])
            return true
    }
    return false
}

RenalEvidence_ForIngredient(ingredient) {
    loaded := RenalEvidence_Load()
    if !loaded.ok
        return []
    medicationKey := RxN_IngredientKey(ingredient)
    matches := []
    for record in loaded.records {
        if RenalEvidence_MatchesIngredient(record, medicationKey)
            matches.Push(record)
    }
    return matches
}

RenalEvidence_TableRows(ingredient) {
    rows := []
    for record in RenalEvidence_ForIngredient(ingredient) {
        if !record.Has("selected") || !IsObject(record["selected"])
            continue
        for selected in record["selected"] {
            if !selected.Has("evidence") || !IsObject(selected["evidence"])
                continue
            for evidence in selected["evidence"] {
                tableData := RenalEvidence_Value(evidence, "tableData")
                if tableData = ""
                    continue
                for line in StrSplit(tableData, "`n", "`r") {
                    line := Trim(line)
                    if line = ""
                        continue
                    cells := []
                    for cell in StrSplit(line, "|")
                        cells.Push(Trim(cell))
                    rows.Push({section: RenalEvidence_Value(evidence, "sectionTitle"), cells: cells,
                        warning: RenalEvidence_Value(evidence, "extractionWarning"),
                        source: RenalEvidence_Value(selected, "sourceUrl"),
                        setid: RenalEvidence_Value(selected, "setid"),
                        reviewStatus: RenalEvidence_Value(record, "reviewStatus", "NOT_REVIEWED")})
                }
            }
        }
    }
    return rows
}

RenalEvidence_MatrixRows(ingredient) {
    rows := []
    for record in RenalEvidence_ForIngredient(ingredient) {
        recordStatus := RenalEvidence_Value(record, "reviewStatus", "NOT_REVIEWED")
        if !record.Has("selected") || !IsObject(record["selected"])
            continue
        for selected in record["selected"] {
            if !selected.Has("evidence") || !IsObject(selected["evidence"])
                continue
            for evidence in selected["evidence"] {
                tableData := RenalEvidence_Value(evidence, "tableData")
                if tableData = ""
                    continue
                for line in StrSplit(tableData, "`n", "`r") {
                    line := Trim(line)
                    if line = ""
                        continue
                    cells := []
                    for cell in StrSplit(line, "|")
                        cells.Push(Trim(cell))
                    rows.Push({
                        ingredient: ingredient,
                        product: RenalEvidence_Value(selected, "title"),
                        indication: "",
                        route: "",
                        formulation: "",
                        renalMetric: "",
                        lowerBound: "",
                        upperBound: "",
                        dose: "",
                        interval: "",
                        dialysis: "",
                        section: RenalEvidence_Value(evidence, "sectionTitle"),
                        cells: cells,
                        verbatim: line,
                        warning: RenalEvidence_Value(evidence, "extractionWarning"),
                        source: RenalEvidence_Value(selected, "sourceUrl"),
                        setid: RenalEvidence_Value(selected, "setid"),
                        splVersion: RenalEvidence_Value(selected, "splVersion"),
                        publishedDate: RenalEvidence_Value(selected, "publishedDate"),
                        reviewStatus: recordStatus,
                        provisional: recordStatus != "APPROVED"
                    })
                }
            }
        }
    }
    return rows
}

RenalEvidence_SummaryText(ingredient) {
    rows := RenalEvidence_TableRows(ingredient)
    if rows.Length = 0 {
        if RenalEvidence_ForIngredient(ingredient).Length > 0
            return "Evidence / review"
        return "No table"
    }

    seen := []
    for row in rows {
        if !IsObject(row) || !IsObject(row.cells)
            continue
        text := ""
        for idx, cell in row.cells {
            if cell = ""
                continue
            cleaned := cell
            cleaned := StrReplace(cleaned, "CreatinineClearance", "CrCl")
            cleaned := StrReplace(cleaned, "Creatinine clearance", "CrCl")
            cleaned := StrReplace(cleaned, "Creatinine Clearance", "CrCl")
            if text != ""
                text .= " · "
            text .= cleaned
            if seen.Length >= 2
                break
        }
        if text != "" {
            seen.Push(text)
            if seen.Length >= 2
                break
        }
    }

    if seen.Length = 0
        return "Detailed label table"
    summary := seen[1]
    if !InStr(summary, "CrCl") && !InStr(summary, "renal") && !InStr(summary, "Adults")
        summary .= " · CrCl / renal"
    if seen.Length = 1
        return summary
    return summary " | " seen[2]
}

RenalEvidence_RecordSummary(record) {
    if !IsObject(record)
        return "No record"
    query := RenalEvidence_Value(record, "query", "")
    if query = ""
        query := "unknown medication"
    out := query
    if record.Has("selected") && IsObject(record["selected"]) {
        for selected in record["selected"] {
            if !IsObject(selected)
                continue
            if selected.Has("title") && String(selected["title"]) != ""
                out .= " · " String(selected["title"])
            if selected.Has("evidence") && IsObject(selected["evidence"]) {
                for evidence in selected["evidence"] {
                    tableData := RenalEvidence_Value(evidence, "tableData")
                    if tableData = ""
                        continue
                    lines := StrSplit(tableData, "`n", "`r")
                    for line in lines {
                        line := Trim(line)
                        if line = ""
                            continue
                        out .= " | " line
                        break 2
                    }
                }
            }
        }
    }
    return out
}

RenalEvidence_ReviewEntries() {
    loaded := RenalEvidence_Load()
    if !loaded.ok
        return []
    out := []
    for record in loaded.records {
        if !IsObject(record)
            continue
        if record.Has("query") && String(record["query"]) != ""
            out.Push(record)
    }
    return out
}

RenalEvidence_SetReviewStatus(ingredient, status, notes := "") {
    loaded := RenalEvidence_Load(true)
    if !loaded.ok
        return false
    normalizedStatus := Trim(String(status))
    if normalizedStatus = ""
        normalizedStatus := "NOT_REVIEWED"
    changed := false
    medKey := RxN_IngredientKey(ingredient)
    for record in loaded.records {
        if !IsObject(record)
            continue
        if medKey != "" && !RenalEvidence_MatchesIngredient(record, medKey)
            continue
        record["reviewStatus"] := normalizedStatus
        if notes != ""
            record["reviewNotes"] := notes
        changed := true
    }
    if !changed
        return false
    payload := Map("schemaVersion", loaded.schemaVersion, "generatedAt", loaded.generatedAt, "records", loaded.records)
    CRD3_WriteJson(RenalEvidence_Path(), payload)
    RenalEvidenceCache := loaded
    return true
}

RenalEvidence_ReviewSelected(listCtrl, detailCtrl) {
    row := listCtrl.GetNext(0, "Focused")
    if row = 0
        return
    entries := RenalEvidence_ReviewEntries()
    if row > entries.Length
        return
    record := entries[row]
    detailCtrl.Value := RenalEvidence_DetailText(RenalEvidence_Value(record, "query", "unknown"), Map("mode", "threshold"))
}

RenalEvidence_SaveCurrentEdit(g, ingredient, statusBox, textEdit) {
    RenalEvidence_SetReviewStatus(ingredient, statusBox.Text, textEdit.Value)
    g.Destroy()
}

RenalEvidence_ApproveSelectedEntry(listCtrl, detailCtrl) {
    row := listCtrl.GetNext(0, "Focused")
    if row = 0
        return
    entries := RenalEvidence_ReviewEntries()
    if row > entries.Length
        return
    name := RenalEvidence_Value(entries[row], "query", "")
    if name = ""
        return
    RenalEvidence_SetReviewStatus(name, "APPROVED")
    RenalEvidence_ReviewSelected(listCtrl, detailCtrl)
    listCtrl.Modify(row, 2, "APPROVED")
}

RenalEvidence_RejectSelectedEntry(listCtrl, detailCtrl) {
    row := listCtrl.GetNext(0, "Focused")
    if row = 0
        return
    entries := RenalEvidence_ReviewEntries()
    if row > entries.Length
        return
    name := RenalEvidence_Value(entries[row], "query", "")
    if name = ""
        return
    RenalEvidence_SetReviewStatus(name, "REJECTED")
    RenalEvidence_ReviewSelected(listCtrl, detailCtrl)
    listCtrl.Modify(row, 2, "REJECTED")
}

RenalEvidence_EditSelectedRecord(listCtrl, ownerGui) {
    row := listCtrl.GetNext(0, "Focused")
    if row = 0
        return
    entries := RenalEvidence_ReviewEntries()
    if row > entries.Length
        return
    record := entries[row]
    ingredient := RenalEvidence_Value(record, "query", "unknown")
    currentStatus := RenalEvidence_Value(record, "reviewStatus", "NOT_REVIEWED")
    g := Gui(, "Edit DailyMed evidence - " ingredient)
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w980", "Edit DailyMed evidence: " ingredient))
    textEdit := g.Add("Edit", "xm y+10 w980 h380 VScroll -Wrap", RenalEvidence_DetailText(ingredient, Map("mode", "threshold")))
    Theme_OutputFont(textEdit)
    statusBox := g.Add("ComboBox", "xm y+10 w180", ["NOT_REVIEWED", "APPROVED", "REJECTED", "REVIEW_REQUIRED"])
    statusBox.Text := currentStatus
    g.Add("Button", "xm y+10 w110", "Save").OnEvent("Click", RenalEvidence_SaveCurrentEdit.Bind(g, ingredient, statusBox, textEdit))
    g.Add("Button", "x+8 yp w110", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w1020 h560")
}

RenalEvidence_ReviewGui(*) {
    loaded := RenalEvidence_Load()
    if !loaded.ok {
        MsgBox("The DailyMed evidence file could not be loaded:`n`n" loaded.error, "DailyMed Evidence Review", "Icon!")
        return
    }
    g := Gui("+Resize", "DailyMed Evidence Review")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w1200", "DailyMed evidence review queue"))
    Theme_Subtle(g.Add("Text", "xm y+3 w1200", "Review product-specific renal evidence, edit the extracted rows, and approve or reject the entry before it is used in the Renal Rules Library."))
    list := g.Add("ListView", "xm y+10 w1200 h350 Grid -Multi", ["Medication", "Status", "Summary", "Source"])
    entries := RenalEvidence_ReviewEntries()
    for index, record in entries {
        query := RenalEvidence_Value(record, "query", "unknown")
        status := RenalEvidence_Value(record, "reviewStatus", "NOT_REVIEWED")
        summary := RenalEvidence_RecordSummary(record)
        source := ""
        if record.Has("selected") && IsObject(record["selected"]) && record["selected"].Length > 0 {
            source := RenalEvidence_Value(record["selected"][1], "sourceUrl", "")
        }
        list.Add("", query, status, summary, source)
    }
    list.ModifyCol(1, 180), list.ModifyCol(2, 100), list.ModifyCol(3, 560), list.ModifyCol(4, 320)
    detail := g.Add("Edit", "xm y+10 w1200 h200 ReadOnly VScroll -Wrap", "Select a medication to review the extracted label evidence.")
    Theme_OutputFont(detail)
    list.OnEvent("ItemSelect", RenalEvidence_ReviewSelected.Bind(list, detail))

    btnApprove := g.Add("Button", "xm y+10 w130", "Approve")
    btnApprove.OnEvent("Click", RenalEvidence_ApproveSelectedEntry.Bind(list, detail))
    btnReject := g.Add("Button", "x+8 yp w130", "Reject")
    btnReject.OnEvent("Click", RenalEvidence_RejectSelectedEntry.Bind(list, detail))
    btnEdit := g.Add("Button", "x+8 yp w140", "Edit & Save")
    btnEdit.OnEvent("Click", (*) => RenalEvidence_EditSelectedRecord(list, g))
    btnClose := g.Add("Button", "x+8 yp w100", "Close")
    btnClose.OnEvent("Click", (*) => g.Destroy())
    g.Show("w1240 h700")
}

RenalEvidence_Value(object, key, fallback := "") {
    return IsObject(object) && object.Has(key) ? String(object[key]) : fallback
}

RenalEvidence_DetailText(ingredient, rule) {
    loaded := RenalEvidence_Load()
    if !loaded.ok
        return "DAILYMED EVIDENCE`r`n`r`nEvidence unavailable: " loaded.error "`r`n`r`nPath: " loaded.path
    matches := RenalEvidence_ForIngredient(ingredient)
    out := "DAILYMED EVIDENCE — " StrUpper(ingredient) "`r`n"
        . "Evidence is informational and NOT a stand-alone dosing recommendation.`r`n"
        . "Current renal rule remains authoritative for screening: " RenalEvidence_Value(rule, "mode", "threshold") "`r`n`r`n"
    if matches.Length = 0
        return out "No matching DailyMed evidence record was found. This is not proof that no renal considerations exist.`r`n"
    hasEvidence := false
    for record in matches {
        if record.Has("selected") && IsObject(record["selected"]) {
            for selected in record["selected"] {
                if selected.Has("evidence") && IsObject(selected["evidence"]) && selected["evidence"].Length > 0
                    hasEvidence := true
            }
        }
    }
    if !hasEvidence
        return out "A matching DailyMed record was found, but no renal/dialysis evidence block was extracted. This is not proof that no renal considerations exist.`r`n"
    for index, record in matches {
        out .= "Record " index " — query: " RenalEvidence_Value(record, "query") "`r`n"
        out .= "Review status: " RenalEvidence_Value(record, "reviewStatus", "NOT_REVIEWED") " — REVIEW REQUIRED`r`n"
        out .= "Retrieved: " RenalEvidence_Value(record, "retrievedAt") "`r`n"
        if record.Has("warnings") && IsObject(record["warnings"])
            for warning in record["warnings"]
                out .= "Warning: " String(warning) "`r`n"
        if record.Has("selected") && IsObject(record["selected"]) {
            for selected in record["selected"] {
                out .= "Product: " RenalEvidence_Value(selected, "title") "`r`n"
                out .= "SPL set ID: " RenalEvidence_Value(selected, "setid") "`r`n"
                out .= "SPL version/date: " RenalEvidence_Value(selected, "splVersion") "/" RenalEvidence_Value(selected, "publishedDate") "`r`n"
                out .= "Source: " RenalEvidence_Value(selected, "sourceUrl") "`r`n"
                out .= "Content hash: " RenalEvidence_Value(selected, "contentHash") "`r`n"
                if selected.Has("warnings") && IsObject(selected["warnings"])
                    for warning in selected["warnings"]
                        out .= "Warning: " String(warning) "`r`n"
                if selected.Has("evidence") && IsObject(selected["evidence"]) {
                    for evidence in selected["evidence"] {
                        out .= "`r`nSection " RenalEvidence_Value(evidence, "sectionCode") ": " RenalEvidence_Value(evidence, "sectionTitle") "`r`n"
                        if RenalEvidence_Value(evidence, "verbatimText") != ""
                            out .= RenalEvidence_Value(evidence, "verbatimText") "`r`n"
                        if RenalEvidence_Value(evidence, "tableData") != ""
                            out .= "Table evidence:`r`n" RenalEvidence_Value(evidence, "tableData") "`r`n"
                        if RenalEvidence_Value(evidence, "extractionWarning") != ""
                            out .= "Warning: " RenalEvidence_Value(evidence, "extractionWarning") "`r`n"
                    }
                }
            }
        }
        out .= "`r`n"
    }
    return out "`r`nVerify indication, route, formulation, renal trajectory, dialysis/RRT status, levels, interactions, current labeling, and local policy before acting."
}

PatientRenal_FindRuleForKey(medicationKey) {
    if medicationKey = "" || !RefData_Available("renal_rules")
        return 0
    for rule in RefData_Rows("renal_rules") {
        ingredient := rule.Has("ingredient") ? rule["ingredient"] : ""
        if ingredient != "" && PatientRenal_KeyMatchesAny(medicationKey, [ingredient])
            return rule
    }
    return 0
}

PatientRenal_RuleContext(medicationKey) {
    rule := PatientRenal_FindRuleForKey(medicationKey)
    if !IsObject(rule)
        return ""
    note := rule.Has("note") ? Trim(rule["note"]) : ""
    return note = "" ? "" : "   Shared renal rule: " note "`r`n"
}

PatientRenal_LegacyFlagForMedication(
    medication,
    parsed
) {
    medicationKey := PatientV4_MedicationNameKey(medication)
    if medicationKey = ""
        return ""

    hasCrCl := parsed.HasOwnProp("crcl")
        && IsNumber(parsed.crcl)
        && Number(parsed.crcl) > 0

    if !RefData_Available("renal_rules")
        return ""

    rule := PatientRenal_FindRuleForKey(medicationKey)
    if !IsObject(rule)
        return ""

    mode := StrLower(rule.Has("mode") ? rule["mode"] : "threshold")
    note := rule.Has("note") ? Trim(rule["note"]) : ""

    if mode = "level" {
            if !hasCrCl
                return "RENAL/LEVEL REVIEW — renal function not calculated; " note
            return "RENAL/LEVEL REVIEW — CrCl " Round(Number(parsed.crcl), 1) " mL/min; " note
        }

    if !hasCrCl
        return ""

    crcl := Number(parsed.crcl)
    reviewBelow := (rule.Has("review_below") && IsNumber(rule["review_below"]))
            ? Number(rule["review_below"])
            : 0
    avoidBelow := (rule.Has("avoid_below") && IsNumber(rule["avoid_below"]))
            ? Number(rule["avoid_below"])
            : 0

    if avoidBelow > 0 && crcl < avoidBelow {
            return "AVOID/ELIGIBILITY REVIEW — CrCl " Round(crcl, 1)
                . " mL/min; " note
        }

    if reviewBelow > 0 && crcl < reviewBelow {
            priority := crcl < 30 ? "HIGH-PRIORITY RENAL REVIEW" : "RENAL REVIEW"
            return priority " — CrCl " Round(crcl, 1) " mL/min; " note
        }

    return ""
}

Demo_BuildParsedDetails(parsed) {
    PatientCalc_Enrich(parsed)

    output := CaptureV1_ActionBlock(parsed)

    output .= "Age: "
        . (
            parsed.age != ""
            ? parsed.age
            : "Not recognized"
        )
        . "`r`n"

    output .= "Sex: "
        . (
            parsed.sex != ""
            ? parsed.sex
            : "Not recognized"
        )
        . "`r`n"

    output .= "Location: "
        . (
            parsed.location != ""
            ? parsed.location
            : "Not recognized"
        )
        . "`r`n"

    output .= "Height: "
        . (
            parsed.heightCm != ""
            ? parsed.heightCm " cm"
            : "Not recognized"
        )
        . "`r`n"

    output .= "Weight: "
        . (
            parsed.weightKg != ""
            ? parsed.weightKg " kg"
            : "Not recognized"
        )
        . "`r`n"

    output .= "SCr: "
        . (
            parsed.scr != ""
            ? parsed.scr " mg/dL"
            : "Not recognized"
        )
        . "`r`n"

    output .= "BMI: "
        . (
            parsed.bmi != ""
            ? parsed.bmi " kg/m²"
            : "Not calculated"
        )
        . "`r`n"

    output .= "CrCl: "
        . PatientCalc_CrClDisplay(parsed)
        . "`r`n`r`n"

    output .= "Allergies ("
        . parsed.allergies.Length
        . "):`r`n"

    if parsed.allergies.Length {
        for allergy in parsed.allergies
            output .= "• " allergy "`r`n"
    } else {
        output .= "• No Known Allergies`r`n"
    }

    output .= "`r`nVisible medications ("
        . parsed.medications.Length
        . "):`r`n"

    renalFlagCount := 0

    if parsed.medications.Length {
        for medication in parsed.medications {
            output .= "• " medication

            renalFlag :=
                PatientRenal_FlagForMedication(
                    medication,
                    parsed
                )

            if renalFlag != "" {
                output .= "  [" renalFlag "]"
                renalFlagCount += 1
            }

            output .= "`r`n"
        }
    } else {
        output .= "• None recognized from the visible screen`r`n"
    }

    if renalFlagCount > 0 {
        output .= "`r`n"
            . renalFlagCount
            . " renal screening flag"
            . (renalFlagCount = 1 ? "" : "s")
            . " above. These are screening prompts only, based on a "
            . "Cockcroft-Gault CrCl calculated from OCR-captured values. "
            . "Some product labels use eGFR instead of CrCl. Verify the "
            . "current label, actual labs, dialysis/RRT status, "
            . "indication, and local policy before acting.`r`n"
    }

     output .= Demo_BuildDoseRecommendations(parsed)

    output .= MedFlag_BuildBlock(parsed)

    return output
}

Demo_CopyPatientSnapshot(parsed, *) {
    A_Clipboard := Demo_BuildParsedDetails(parsed)

    ToolTip "Patient snapshot copied"
    SetTimer(() => ToolTip(), -1200)
}


; BMI — calculate inline from captured demographics, no separate calculator needed.
Demo_ShowBMI(parsed) {
    PatientCalc_Enrich(parsed)

    if parsed.bmi = "" {
        MsgBox(
            "BMI could not be calculated.`r`n`r`n"
            . "Parsed height: "
            . (
                parsed.heightCm != ""
                ? parsed.heightCm " cm"
                : "Not recognized"
            )
            . "`r`nParsed weight: "
            . (
                parsed.weightKg != ""
                ? parsed.weightKg " kg"
                : "Not recognized"
            ),
            "BMI from Parsed Patient Data",
            "Icon!"
        )
        return
    }

    output := "BMI: "
        . parsed.bmi
        . " kg/m² ("
        . BMI_Cat(Number(parsed.bmi))
        . ")`r`n`r`n"

    output .= "Height: "
        . parsed.heightCm
        . " cm`r`n"

    output .= "Weight: "
        . parsed.weightKg
        . " kg`r`n"

    if parsed.ibwKg != "" {
        output .= "IBW: "
            . parsed.ibwKg
            . " kg`r`n"

        output .= "AdjBW: "
            . parsed.adjbwKg
            . " kg`r`n"
    }

    output .= "`r`nCrCl: "
        . PatientCalc_CrClDisplay(parsed)

    MsgBox(
        output,
        "BMI from Parsed Patient Data",
        "Iconi"
    )
}

; Adult BMI category (WHO / CDC classification). Adults only — not valid for pediatrics.
BMI_Cat(bmi) {
    if bmi < 18.5
        return "Underweight"
    if bmi < 25
        return "Normal weight"
    if bmi < 30
        return "Overweight"
    if bmi < 35
        return "Obesity class I"
    if bmi < 40
        return "Obesity class II"
    return "Obesity class III"
}

; Vanco_ParseDemographics returns a plain object, but the prefill consumers
; (Calc_OpenVancomycinDosing / Calc_OpenRsiDosing) expect a Map. Convert here.
Demo_ParsedToMap(parsed) {
    PatientCalc_Enrich(parsed)

    output := Map()

    for key in [
        "age",
        "sex",
        "heightCm",
        "weightKg",
        "scr",
        "location",
        "bmi",
        "ibwKg",
        "adjbwKg",
        "crclWeightKg",
        "crclWeightLabel",
        "crcl",
        "mrn",
        "fin"
    ] {
        if parsed.HasOwnProp(key)
            && parsed.%key% != "" {
            output[key] := parsed.%key%
        }
    }

    if parsed.HasOwnProp("allergies")
        output["allergies"] := parsed.allergies.Clone()

    if parsed.HasOwnProp("allergies") && parsed.allergies.Length > 0 {
        allergyText := ""
        for a in parsed.allergies
            allergyText .= (allergyText = "" ? "" : ", ") a
        output["allergiesText"] := allergyText
    }

    if parsed.HasOwnProp("medications")
        output["medications"] := parsed.medications.Clone()

    return output
}

Demo_LaunchVanco(parsed) {
    global _PreFillDemographics

    PatientCalc_Enrich(parsed)

    ; Replace any previous patient's information.
    _PreFillDemographics := Demo_ParsedToMap(parsed)

    Calc_OpenVancomycinDosing()
}

Demo_LaunchRSI(parsed) {
    Demo_SetCalculatorPrefill(parsed)
    Calc_OpenRsiDosing()
}

Demo_LaunchAminoglycoside(parsed) {
    Demo_SetCalculatorPrefill(parsed)
    Calc_OpenAminoglycoside()
}

Demo_LaunchAntibiotic(parsed) {
    Demo_SetCalculatorPrefill(parsed)
    Calc_OpenAntibiotic()
}


Demo_SetCalculatorPrefill(parsed) {
    global _PreFillDemographics

    PatientCalc_Enrich(parsed)
    _PreFillDemographics := Demo_ParsedToMap(parsed)
}
; ---- Vancomycin OCR autofill ----

Vanco_OCRCapture(
    ageCtrl,
    sexCtrl,
    htCtrl,
    wtCtrl,
    scrCtrl
) {
    region := Patient_SelectScreenRegion("Select the demographics needed for vancomycin dosing")
    left := region.left
    top := region.top
    w := region.w
    h := region.h

    if w < 20 || h < 10 {
        MsgBox(
            "Selection too small — try again with a larger region.",
            "Autofill",
            "Icon!"
        )
        return
    }

    captureResult := 0
    ToolTip "CAPTURE LOCKED  ·  reading patient data..."

    try {
        captureResult := PatientV2_CaptureAndParse(
            left,
            top,
            w,
            h
        )
    } catch as e {
        ToolTip
        MsgBox(
            "OCR error: " e.Message,
            "Autofill",
            "Icon!"
        )
        return
    }
    ToolTip

    if !IsObject(captureResult)
        || Trim(captureResult.text) = "" {
        MsgBox(
            "Nothing was recognized. Try selecting a larger area with better contrast.",
            "Autofill",
            "Icon!"
        )
        return
    }

    Vanco_ConfirmAndApply(
        captureResult.parsed,
        ageCtrl,
        sexCtrl,
        htCtrl,
        wtCtrl,
        scrCtrl,
        captureResult.text
    )
}

Vanco_ConfirmAndApply(
    parsed,
    ageCtrl,
    sexCtrl,
    htCtrl,
    wtCtrl,
    scrCtrl,
    rawText
) {
    anyFound := (
        parsed.age != ""
        || parsed.sex != ""
        || parsed.heightCm != ""
        || parsed.weightKg != ""
        || parsed.scr != ""
    )

    if !anyFound {
        MsgBox(
            "No recognizable demographic values were found."
            . "`r`n`r`nCaptured text:`r`n"
            . rawText,
            "Autofill — Nothing Found",
            "Icon!"
        )
        return
    }

    g := Gui(
        "-MinimizeBox",
        "Review Captured Demographics"
    )

    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    g.Add(
        "Text",
        "xm w520",
        "Review each field. Uncheck any you don't want applied, then click Apply."
    )

    g.Add(
        "Text",
        "xm y+4 w520 cGray",
        "Values marked Not found will not overwrite the calculator."
    )

    ; Age
    g.Add("Text", "xm y+14 w120", "Age (years):")
    ageE := g.Add(
        "Edit",
        "x+8 yp-3 w120",
        parsed.age
    )
    ageC := g.Add(
        "CheckBox",
        "x+10 yp+3 w100",
        parsed.age != "" ? "Apply" : "Not found"
    )
    if parsed.age != ""
        ageC.Value := 1
    else {
        ageE.Enabled := false
        ageC.Enabled := false
    }

    ; Sex
    g.Add("Text", "xm y+14 w120", "Sex:")
    sexE := g.Add(
        "DropDownList",
        "x+8 yp-3 w120",
        ["Male", "Female"]
    )

    if parsed.sex = "Female"
        sexE.Value := 2
    else
        sexE.Value := 1

    sexC := g.Add(
        "CheckBox",
        "x+10 yp+3 w100",
        parsed.sex != "" ? "Apply" : "Not found"
    )

    if parsed.sex != ""
        sexC.Value := 1
    else {
        sexE.Enabled := false
        sexC.Enabled := false
    }

    ; Height
    g.Add("Text", "xm y+14 w120", "Height (cm):")
    htE := g.Add(
        "Edit",
        "x+8 yp-3 w120",
        parsed.heightCm
    )
    htC := g.Add(
        "CheckBox",
        "x+10 yp+3 w100",
        parsed.heightCm != "" ? "Apply" : "Not found"
    )

    if parsed.heightCm != ""
        htC.Value := 1
    else {
        htE.Enabled := false
        htC.Enabled := false
    }

    ; Weight
    g.Add("Text", "xm y+14 w120", "Weight (kg):")
    wtE := g.Add(
        "Edit",
        "x+8 yp-3 w120",
        parsed.weightKg
    )
    wtC := g.Add(
        "CheckBox",
        "x+10 yp+3 w100",
        parsed.weightKg != "" ? "Apply" : "Not found"
    )

    if parsed.weightKg != ""
        wtC.Value := 1
    else {
        wtE.Enabled := false
        wtC.Enabled := false
    }

    ; Serum creatinine
    g.Add("Text", "xm y+14 w120", "SCr:")
    scrE := g.Add(
        "Edit",
        "x+8 yp-3 w120",
        parsed.scr
    )
    scrC := g.Add(
        "CheckBox",
        "x+10 yp+3 w100",
        parsed.scr != "" ? "Apply" : "Not found"
    )

    if parsed.scr != ""
        scrC.Value := 1
    else {
        scrE.Enabled := false
        scrC.Enabled := false
    }

    applyBtn := g.Add(
        "Button",
        "xm y+22 w100 Default",
        "Apply"
    )

    applyBtn.OnEvent(
        "Click",
        (*) => Vanco_ApplyConfirmedDemographics(
            g,
            ageCtrl,
            sexCtrl,
            htCtrl,
            wtCtrl,
            scrCtrl,
            ageE,
            ageC,
            sexE,
            sexC,
            htE,
            htC,
            wtE,
            wtC,
            scrE,
            scrC
        )
    )

    g.Add(
        "Button",
        "x+8 yp w100",
        "Cancel"
    ).OnEvent(
        "Click",
        (*) => g.Destroy()
    )

    g.Show("w560")
}

Vanco_ApplyConfirmedDemographics(
    g,
    ageCtrl,
    sexCtrl,
    htCtrl,
    wtCtrl,
    scrCtrl,
    ageE,
    ageC,
    sexE,
    sexC,
    htE,
    htC,
    wtE,
    wtC,
    scrE,
    scrC
) {
    if ageC.Value
        ageCtrl.Value := ageE.Value

    if sexC.Value
        sexCtrl.Choose(sexE.Value)

    if htC.Value {
        heightCm := Trim(htE.Value)

        ; The vancomycin calculator's height field is in cm - do not convert to inches.
        if IsNumber(heightCm)
            htCtrl.Value := Round(Number(heightCm), 1)
    }

    if wtC.Value
        wtCtrl.Value := wtE.Value

    if scrC.Value
        scrCtrl.Value := scrE.Value

    g.Destroy()
}
   
Vanco_ParseDemographics(ocrInput, capture := 0) {
    rawText := IsObject(ocrInput)
        ? ocrInput.Text
        : String(ocrInput)

    lines := Patient_GetOcrLines(ocrInput)
    lines := Patient_SortOcrLines(lines)

    leftCutoff := Patient_GetLeftPanelCutoff(lines, capture)
    leftLines := []

    for item in lines {
        if item.x <= leftCutoff
            leftLines.Push(item)
    }

    result := {
        age: "",
        sex: "",
        location: "",
        heightCm: "",
        weightKg: "",
        scr: "",
        systolicBP: "",
        diastolicBP: "",
        vitalEvidence: [],
        allergies: [],
        medications: [],
        captureWarnings: []
    }

    flat := Patient_NormalizeOcrText(rawText)

    ; -------------------------------------------------------------------------
    ; HEADER: AGE, SEX, LOCATION
    ; -------------------------------------------------------------------------
    for item in lines {
        lineText := Patient_CleanOcrLine(item.text)

        if result.age = "" && RegExMatch(
            lineText,
            "i)\bAge\s*[:=-]?\s*(\d{1,3})\b",
            &match
        ) {
            value := Number(match[1])

            if value >= 0 && value <= 120
                result.age := value
        }

        if result.sex = "" && RegExMatch(
            lineText,
            "i)\bS\s*e\s*x\s*[:=-]?\s*(Male|Female|M|F)\b",
            &match
        ) {
            sexValue := StrLower(match[1])

            result.sex := (
                sexValue = "female"
                || sexValue = "f"
            ) ? "Female" : "Male"
        }

        if result.location = "" && RegExMatch(
            lineText,
            "i)\bLocation\s*[:=-]?\s*(.+)$",
            &match
        ) {
            result.location := Patient_CleanLocation(match[1])
        }

        ; Session-only patient identifiers. Captured for on-screen use (prefilling the
        ; handoff note pasted into the chart) but NEVER written to any persisted file.
        if (!result.HasOwnProp("mrn") || result.mrn = "") && RegExMatch(
            lineText,
            "i)\bMRN\s*[:=-]?\s*([A-Za-z0-9-]{4,20})\b",
            &match
        ) {
            result.mrn := Trim(match[1])
        }

        if (!result.HasOwnProp("fin") || result.fin = "") && RegExMatch(
            lineText,
            "i)\bFIN\s*[:=-]?\s*([A-Za-z0-9-]{4,20})\b",
            &match
        ) {
            result.fin := Trim(match[1])
        }
    }

    ; Header fallbacks if OCR combined multiple fields into one text line.
    if result.age = "" && RegExMatch(
        flat,
        "i)\bAge\s*[:=-]?\s*(\d{1,3})\b",
        &match
    ) {
        value := Number(match[1])

        if value >= 0 && value <= 120
            result.age := value
    }

    if result.sex = "" && RegExMatch(
        flat,
        "i)\bS\s*e\s*x\s*[:=-]?\s*(Male|Female|M|F)\b",
        &match
    ) {
        sexValue := StrLower(match[1])

        result.sex := (
            sexValue = "female"
            || sexValue = "f"
        ) ? "Female" : "Male"
    }

    if result.mrn = "" && RegExMatch(
        flat,
        "i)\bMRN\s*[:=-]?\s*([A-Za-z0-9-]{4,20})\b",
        &match
    ) {
        result.mrn := Trim(match[1])
    }

    if result.fin = "" && RegExMatch(
        flat,
        "i)\bFIN\s*[:=-]?\s*([A-Za-z0-9-]{4,20})\b",
        &match
    ) {
        result.fin := Trim(match[1])
    }

    ; -------------------------------------------------------------------------
    ; HEIGHT
    ; Prefer the specifically labeled Height/Length field.
    ; -------------------------------------------------------------------------
    if RegExMatch(
        flat,
        "i)\bHeight\s*/?\s*Length\b"
        . ".{0,140}?"
        . "(\d{2,3}(?:[.,]\d+)?)\s*c\s*m\b",
        &match
    ) {
        value := Patient_ParseNumber(match[1])

        if value >= 100 && value <= 250
            result.heightCm := Round(value, 1)
    }

    if result.heightCm = "" && RegExMatch(
        flat,
        "i)\b(\d{3}(?:[.,]\d+)?)\s*c\s*m\b",
        &match
    ) {
        value := Patient_ParseNumber(match[1])

        if value >= 100 && value <= 250
            result.heightCm := Round(value, 1)
    }

    if result.heightCm = "" && RegExMatch(
        flat,
        "i)\b(\d)\s*(?:'|ft\.?|feet)"
        . "\s*[- ]*(\d{1,2})"
        . "\s*(?:\x22|in\.?|inches?|inch)?",
        &match
    ) {
        feet := Number(match[1])
        inches := Number(match[2])
        heightCm := ((feet * 12) + inches) * 2.54

        if inches <= 11
            && heightCm >= 100
            && heightCm <= 250 {
            result.heightCm := Round(heightCm, 1)
        }
    }

    ; -------------------------------------------------------------------------
    ; WEIGHT
    ; Prefer Weight Dosing so the later IBW line is not selected.
    ; -------------------------------------------------------------------------
    if RegExMatch(
        flat,
        "i)\bWeight\s+Dosing\b"
        . ".{0,140}?"
        . "(\d{2,3}(?:[.,]\d+)?)\s*k\s*g\b",
        &match
    ) {
        value := Patient_ParseNumber(match[1])

        if value >= 10 && value <= 400
            result.weightKg := Round(value, 1)
    }

    if result.weightKg = "" && RegExMatch(
        flat,
        "i)\bWeight\b"
        . ".{0,100}?"
        . "(\d{2,3}(?:[.,]\d+)?)\s*k\s*g\b",
        &match
    ) {
        value := Patient_ParseNumber(match[1])

        if value >= 10 && value <= 400
            result.weightKg := Round(value, 1)
    }

    ; -------------------------------------------------------------------------
    ; SERUM CREATININE
    ; -------------------------------------------------------------------------
    if RegExMatch(
        flat,
        "i)\b(?:"
        . "s[\s-]*cr"
        . "|serum\s+creatinine"
        . "|creatinine(?:\s+level)?"
        . ")\b"
        . ".{0,100}?"
        . "(\d{1,2}(?:[.,]\d+)?)"
        . "\s*m\s*g\s*[/\\]?\s*d\s*[l1i]\b",
        &match
    ) {
        value := Patient_ParseNumber(match[1])

        if value > 0 && value <= 25
            result.scr := value
    }

    ; -------------------------------------------------------------------------
    ; LEFT PANEL: ALLERGIES
    ; -------------------------------------------------------------------------
    result.allergies := Patient_ExtractAllergies(leftLines)

    ; -------------------------------------------------------------------------
    ; MAIN TABLE: VISIBLE MEDICATION ORDERS
    ; -------------------------------------------------------------------------
    result.medications := Patient_ExtractMedicationOrders(
        lines,
        leftCutoff
    )

    ; Fall back to the small left-panel medication list if the main table was
    ; not included in the selected region.
    if result.medications.Length = 0 {
        result.medications := Patient_ExtractSidebarMedications(
            leftLines
        )
    }

    return result
}


Patient_GetOcrLines(ocrInput) {
    output := []

    if IsObject(ocrInput) {
        try {
            for line in ocrInput.Lines {
                text := Patient_CleanOcrLine(line.Text)

                if text = ""
                    continue

                output.Push({
                    text: text,
                    x: line.x,
                    y: line.y,
                    w: line.w,
                    h: line.h
                })
            }
        } catch {
            output := []
        }
    }

    ; Fallback when this function receives only plain text.
    if output.Length = 0 {
        rawText := IsObject(ocrInput)
            ? ocrInput.Text
            : String(ocrInput)

        rowNumber := 0

        for text in StrSplit(rawText, "`n", "`r") {
            text := Patient_CleanOcrLine(text)

            if text = ""
                continue

            rowNumber += 1

            output.Push({
                text: text,
                x: 0,
                y: rowNumber * 20,
                w: StrLen(text) * 8,
                h: 16
            })
        }
    }

    return output
}


Patient_SortOcrLines(lines) {
    output := []

    for item in lines {
        inserted := false

        for index, existing in output {
            sameRow := Abs(item.y - existing.y) <= 5

            if item.y < existing.y - 5
                || (sameRow && item.x < existing.x) {
                output.InsertAt(index, item)
                inserted := true
                break
            }
        }

        if !inserted
            output.Push(item)
    }

    return output
}


Patient_GetLeftPanelCutoff(lines, capture := 0) {
    ; When only a narrow sidebar was selected, all captured lines belong to it.
    if IsObject(capture)
        && capture.HasOwnProp("w")
        && capture.HasOwnProp("x") {

        if capture.w <= 500
            return capture.x + capture.w

        ; The CPRS sidebar in a full-window capture is about the left 15%.
        return capture.x + Min(280, capture.w * 0.15)
    }

    if lines.Length = 0
        return 0

    minX := lines[1].x
    maxRight := lines[1].x + lines[1].w

    for item in lines {
        minX := Min(minX, item.x)
        maxRight := Max(maxRight, item.x + item.w)
    }

    span := maxRight - minX

    if span <= 500
        return maxRight

    return minX + Min(280, span * 0.15)
}


Patient_NormalizeOcrText(text) {
    text := StrReplace(text, Chr(160), " ")

    ; Correct common OCR substitutions only when adjacent to digits.
    text := RegExReplace(
        text,
        "i)(?<=[0-9])[Il|](?=[0-9])",
        "1"
    )

    text := RegExReplace(
        text,
        "i)(?<=[0-9])O(?=[0-9])",
        "0"
    )

    text := StrReplace(text, "`r`n", " ")
    text := StrReplace(text, "`n", " ")
    text := StrReplace(text, "`r", " ")
    text := RegExReplace(text, "\s+", " ")

    return Trim(text)
}


Patient_CleanOcrLine(text) {
    text := StrReplace(text, Chr(160), " ")
    text := Trim(text, " `t`r`n")
    text := RegExReplace(text, "^[^A-Za-z0-9]+", "")
    text := RegExReplace(text, "\s+", " ")

    return Trim(text)
}


Patient_CleanLocation(value) {
    value := Patient_CleanOcrLine(value)

    ; Stop if OCR merged another labeled header field onto the location line.
    value := RegExReplace(
        value,
        "i)\s+\b(?:"
        . "Physician"
        . "|DOD\s*ID"
        . "|Age"
        . "|Sex"
        . "|Race"
        . "|Admitted"
        . "|MRN"
        . "|FIN"
        . "|Rx\s+Clinical\s+Note"
        . ")\b\s*:.*$",
        ""
    )

    return Trim(value)
}


Patient_ParseNumber(value) {
    return Number(
        StrReplace(
            Trim(value),
            ",",
            "."
        )
    )
}


Patient_ExtractAllergies(lines) {
    output := []
    seen := Map()
    collecting := false

    for item in lines {
        text := Patient_CleanOcrLine(item.text)

        if !collecting {
            if RegExMatch(
                text,
                "i)^Allergies(?:\s*\[\d+\])?\b"
            ) {
                collecting := true
            }

            continue
        }

        if RegExMatch(
            text,
            "i)^(?:"
            . "Medications"
            . "|Problems\s+and\s+Diagnoses"
            . "|Rx\s+Clinical\s+Note"
            . "|Rx\s+Interventions"
            . ")\b"
        ) {
            break
        }

        if !Patient_IsAllergyCandidate(text)
            continue

        key := StrLower(text)

        if !seen.Has(key) {
            seen[key] := true
            output.Push(text)
        }
    }

    return output
}


Patient_IsAllergyCandidate(text) {
    if text = ""
        return false

    if RegExMatch(
        text,
        "i)^(?:"
        . "Click here"
        . "|Allergies\b"
        . "|Adverse\s+type"
        . "|Result\s+Dt/?Tm"
        . "|Patient\s+Note"
        . "|Reason\s+for\s+Visit"
        . ")"
    ) {
        return false
    }

    if StrLen(text) > 100
        return false

    ; Prevent medication-looking rows from entering the allergy list.
    if RegExMatch(
        text,
        "i)\b(?:"
        . "mcg"
        . "|mg"
        . "|mL"
        . "|tablet"
        . "|capsule"
        . "|injection"
        . ")\b"
    ) {
        return false
    }

    return true
}


Patient_ExtractSidebarMedications(lines) {
    output := []
    seen := Map()
    collecting := false

    for item in lines {
        text := Patient_CleanOcrLine(item.text)

        if !collecting {
            if RegExMatch(text, "i)^Medications\b")
                collecting := true

            continue
        }

        if RegExMatch(
            text,
            "i)^(?:"
            . "Problems\s+and\s+Diagnoses"
            . "|Rx\s+Clinical\s+Note"
            . "|Rx\s+Interventions"
            . "|Reason\s+for\s+Visit"
            . ")\b"
        ) {
            break
        }

        if !RegExMatch(
            text,
            "i)\b\d[\d,.]*\s*(?:"
            . "mcg"
            . "|mg"
            . "|g"
            . "|mL"
            . "|units?"
            . "|%"
            . ")\b"
        ) {
            continue
        }

        key := Patient_MedicationKey(text)

        if key != "" && !seen.Has(key) {
            seen[key] := true
            output.Push(text)
        }
    }

    return output
}


Patient_ExtractMedicationOrders(lines, leftCutoff) {
    output := []
    seen := Map()
    discontinuedRows := []

    ; In CPRS the status may be a separate OCR line from the order sentence.
    ; Record the Y-coordinate of every visible Discontinued status.
    for item in lines {
        text := Patient_CleanOcrLine(item.text)

        if RegExMatch(text, "i)^Discontinued\b")
            discontinuedRows.Push(item.y)
    }

    for item in lines {
        if item.x <= leftCutoff
            continue

        if Patient_RowIsDiscontinued(
            item.y,
            item.h,
            discontinuedRows
        ) {
            continue
        }

        text := Patient_NormalizeMedicationOrder(item.text)

        if text = ""
            continue

        if RegExMatch(text, "i)\bDiscontinued\b")
            continue

        if !Patient_IsMedicationOrder(text)
            continue

        key := Patient_MedicationKey(text)

        if key != "" && !seen.Has(key) {
            seen[key] := true
            output.Push(text)
        }
    }

    return output
}


Patient_RowIsDiscontinued(y, height, discontinuedRows) {
    tolerance := Max(7, Round(height * 0.8))

    for discontinuedY in discontinuedRows {
        if Abs(y - discontinuedY) <= tolerance
            return true
    }

    return false
}


Patient_NormalizeMedicationOrder(text) {
    text := Patient_CleanOcrLine(text)

    text := RegExReplace(
        text,
        "i)^(?:"
        . "Action"
        . "|Status"
        . "|Verify"
        . "|Active"
        . ")\s+",
        ""
    )

    ; Remove start/stop date columns when OCR combined them with the order.
    text := RegExReplace(
        text,
        "\s+\d{2}/\d{2}/\d{4}\b.*$",
        ""
    )

    text := RegExReplace(
        text,
        "i)\s+(?:MED|PROTOCOL)\s*$",
        ""
    )

    return Trim(text)
}


Patient_IsMedicationOrder(text) {
    if text = ""
        return false

    if RegExMatch(
        text,
        "i)^(?:"
        . "Order\s+Sentence"
        . "|Start"
        . "|Stop"
        . "|Order\s+Type"
        . "|Drug:"
        . ")"
    ) {
        return false
    }

    hasDose := RegExMatch(
        text,
        "i)\b\d+(?:[.,]\d+)?\s*(?:"
        . "mcg"
        . "|mg"
        . "|g"
        . "|mL"
        . "|units?(?:\(s\))?"
        . "|%"
        . "|drops?(?:\(s\))?"
        . "|puffs?(?:\(s\))?"
        . ")\b"
    )

    hasMedicationForm := RegExMatch(
        text,
        "i)\b(?:"
        . "tablet"
        . "|capsule"
        . "|injection"
        . "|solution"
        . "|suspension"
        . "|cream"
        . "|ointment"
        . "|spray"
        . "|inhalation"
        . "|oral"
        . "|intravenous"
        . "|intramuscular"
        . "|subcutaneous"
        . "|ophthalmic"
        . "|topical"
        . "|transdermal"
        . "|piggyback"
        . "|powder"
        . "|patch"
        . "|suppository"
        . ")\b"
    )

    isDemographicOrLab := RegExMatch(
        text,
        "i)\b(?:"
        . "Glucose\s+Lvl"
        . "|Creatinine\s+Level"
        . "|Height"
        . "|Weight\s+Dosing"
        . "|BSA"
        . "|BMI"
        . "|CrCl"
        . "|eGFR"
        . "|INR"
        . ")\b"
    )

    return hasDose
        && hasMedicationForm
        && !isDemographicOrLab
}


Patient_MedicationKey(text) {
    text := Patient_CleanOcrLine(text)

    text := RegExReplace(
        text,
        "i)^(?:Active|Verify|Discontinued)\s+",
        ""
    )

    name := text

    if RegExMatch(
        text,
        "i)^(.+?)\s+\d+(?:[.,]\d+)?\s*(?:"
        . "mcg"
        . "|mg"
        . "|g"
        . "|mL"
        . "|units?(?:\(s\))?"
        . "|%"
        . "|drops?(?:\(s\))?"
        . "|puffs?(?:\(s\))?"
        . ")\b",
        &match
    ) {
        name := match[1]
    }

    name := StrLower(Trim(name))
    name := RegExReplace(name, "\s+", " ")

    return name
}

; =================================================================================================
; PATIENT SCREEN OCR V2
; Multi-region, high-resolution OCR with conservative spelling correction.
; Existing Vanco_ParseDemographics() remains available as the baseline parser.
; =================================================================================================

PatientV2_IsMedicationProfileCapture(bundle, text := "") {
    lower := StrLower(text)
    hasProfile := InStr(lower, "acute profile") || InStr(lower, "ambulatory profile")
    if !hasProfile
        return false

    ; Require one additional Cerner medication-grid marker. This avoids
    ; treating a generic note that merely mentions an acute profile as a
    ; medication screen, while reliably recognizing the tabbed profile shown
    ; in the Cerner captures.
    for marker in [
        "order sentence",
        "rx number",
        "order type",
        "last fill",
        "source type",
        "start",
        "stop",
        "discontinued"
    ] {
        if InStr(lower, marker)
            return true
    }
    return false
}

; A photographed Cerner profile can lose the tab labels while retaining the grid headers.
; Treat the grid itself as the screen-type anchor so the expensive laboratory tiling pass is
; never launched against an Acute/Ambulatory medication profile.
PatientV2_TextLooksLikeMedicationGrid(text) {
    lower := StrLower(String(text))
    markerCount := 0
    for marker in ["order sentence", "rx number", "order type", "last fill", "source type", "start", "stop"]
        if InStr(lower, marker)
            markerCount += 1
    if markerCount < 2
        return false
    ; Require at least one dose/form/frequency-looking fragment in addition to headers.
    return RegExMatch(lower, "i)\b\d+(?:\.\d+)?\s*(?:mg|mcg|g|unit|units|mL|ml|%|tab|tabs|tablet|capsule|cap|drop|spray)\b")
}

PatientV2_CaptureAndParse(left, top, w, h) {
    bundle := PatientV2_CaptureBundle(
        left,
        top,
        w,
        h
    )

    text := PatientV2_BundleText(bundle)
    ; Cerner exposes both profile labels in the same capture. OCR text alone
    ; cannot tell which tab is active because the selected state is visual.
    ; Read the tab contrast while the source screen is still visible, then
    ; carry that evidence with the parsed capture instead of guessing later.
    profileEvidence := PatientV2_DetectActiveProfile(bundle)
    if profileEvidence.profile = "unassigned"
        profileEvidence := PCtx_ProfileEvidence(text, PatientV2_IsMedicationProfileCapture(bundle, text) ? "medication profile" : "")
    profileCapture := PatientV2_IsMedicationProfileCapture(bundle, text)
        || PatientV2_TextLooksLikeMedicationGrid(text)
        || (profileEvidence.profile = "acute" || profileEvidence.profile = "ambulatory")
    if !profileCapture && (Trim(text) = "" || PatientV7_LooksLikeLabGridText(text)) {
        ; Dense Cerner Group view needs horizontal as well as vertical batches.
        ; Keep this separate from the medication-order result so split tiles do
        ; not fragment otherwise valid order sentences.
        normalGrid := PatientV2_TryOcrTiles(
            left,
            top,
            w,
            h,
            3.4,
            620,
            215,
            48,
            28,
            "laboratory grid"
        )
        ; Most clean Cerner captures are complete on the first pass.  Do not
        ; pay for a second full contrast tiling pass when the fixed-order
        ; parser already has enough visible headers and row evidence.  The
        ; contrast pass remains available for degraded/moire-heavy captures.
        if PatientV11_GridEvidenceSufficient(normalGrid) {
            bundle.labGrid := normalGrid
        } else {
            grayGrid := PatientV2_TryOcrTiles(
                left,
                top,
                w,
                h,
                4.0,
                620,
                215,
                48,
                28,
                "laboratory grid contrast pass",
                true,
                112
            )
            bundle.labGrid := PatientV2_MergeOcrResults([normalGrid, grayGrid])
        }
        text := PatientV2_BundleText(bundle)
    }
    parsed := PatientV2_ParseBundle(bundle)

    ; Repair any missing/odd fields before downstream calculators and the
    ; picker read them. This is the single choke point every capture passes
    ; through, so guaranteeing the shape here protects every consumer.
    parsed := PatientV2_NormalizeParsedShape(parsed)
    parsed.profileEvidence := profileEvidence

    ; Optional bundled evidence pass. It is deliberately fallback-only: the
    ; existing local Windows OCR remains the fast path, while RapidOCR is used
    ; only when a Cerner demographics panel is visibly present but critical
    ; labeled values are still missing. The bridge emits evidence/semantic
    ; fields only; values never replace an already accepted field.
    rapid := PatientV2_TryRapidBridgeForCapture(left, top, w, h, text, parsed)
    if IsObject(rapid)
        PatientV2_ApplyRapidSemantic(parsed, rapid)

    quality := PatientV10_AssessCaptureQuality(bundle, text)
    parsed.captureQuality := quality
    if quality.status = "unreadable" {
        parsed.gridLabs := []
        PatientV6_AddWarning(parsed,
            "Capture quality was too low to accept laboratory values. Enlarge the chart or capture a smaller, sharper region and try again."
        )
    } else if profileCapture {
        ; Acute/Ambulatory medication profiles can contain analyte names in
        ; medication sentences (for example sodium chloride or potassium).
        ; Never treat those rows as a laboratory grid, and avoid the costly
        ; 24-tile lab pass entirely for this screen type.
        parsed.gridLabs := []
        parsed.qualitativeFindings := []
    } else {
        ; Use the deterministic Cerner order parser first.  It accepts values
        ; only under a visible analyte header and only on rows identified by a
        ; real timestamp or an already observed sibling value.  The former
        ; adaptive V9/V10 passes could probe predicted/nearest cells and were
        ; the source of plausible-looking values that were not on the screen.
        gridLabs := PatientV11_ExtractFixedOrderGridLabs(bundle)
        parsed.gridLabs := PatientV7_VerifyScreenGridLabs(gridLabs)
        parsed.qualitativeFindings := PatientV7_ExtractQualitativeFindings(bundle)
        ; Use the bundled semantic bridge only when the fast local parser did
        ; not recover the core Cerner analytes or the medication profile is
        ; obviously incomplete. This keeps ordinary captures fast while
        ; giving missing values a second, geometry-aware evidence path.
        if PatientV2_RapidNeedsLabFallback(text, parsed.gridLabs) {
            rapidLabs := PatientV2_TryRapidBridgeForCapture(left, top, w, h, text, parsed, "labs")
            if IsObject(rapidLabs)
                PatientV2_ApplyRapidSemantic(parsed, rapidLabs, true, false)
        }
        if quality.status = "degraded"
            PatientV6_AddWarning(parsed,
                "The screen was readable but degraded. Only independently confirmed cells were accepted; review missing values against the chart."
            )
    }

    ; Medication fallback remains available for Acute/Ambulatory profiles,
    ; but is intentionally independent of laboratory extraction.
    if quality.status != "unreadable" && PatientV2_RapidNeedsMedicationFallback(text, parsed.medications) {
        rapidMeds := PatientV2_TryRapidBridgeForCapture(left, top, w, h, text, parsed, "medications")
        if IsObject(rapidMeds)
            PatientV2_ApplyRapidSemantic(parsed, rapidMeds, false, true)
    }

    ParsingDiagnostics_LogCapture(parsed, text)

    return {
        bundle: bundle,
        text: text,
        parsed: parsed
    }
}

; Detect the selected Cerner Acute/Ambulatory tab from the visible tab
; background. The words are anchors; PixelGetColor supplies the state that
; OCR cannot represent. If contrast is not decisive, return unassigned so
; Med Rec never silently puts an order on the wrong side.
PatientV2_DetectActiveProfile(bundle) {
    acute := PatientV2_FindProfileTab(bundle, "acute")
    ambulatory := PatientV2_FindProfileTab(bundle, "ambulatory")
    if !IsObject(acute) || !IsObject(ambulatory)
        return {profile:"unassigned", confidence:"low", reason:"Both profile tabs were not visually recoverable"}

    acuteLuma := PatientV2_ProfileTabLuma(acute)
    ambulatoryLuma := PatientV2_ProfileTabLuma(ambulatory)
    if acuteLuma < 0 || ambulatoryLuma < 0
        return {profile:"unassigned", confidence:"low", reason:"Profile tab contrast could not be read"}

    delta := acuteLuma - ambulatoryLuma
    if Abs(delta) < 8
        return {profile:"unassigned", confidence:"low", reason:"Both profile tabs had indistinguishable visual contrast"}
    if delta > 0
        return {profile:"acute", confidence:"high", reason:"Acute Profile tab selected by visible tab contrast"}
    return {profile:"ambulatory", confidence:"high", reason:"Ambulatory Profile tab selected by visible tab contrast"}
}

PatientV2_FindProfileTab(bundle, kind) {
    target := kind = "acute" ? "acute" : "ambulatory"
    for partName in ["headerLeft", "headerRight", "sidebar", "orders", "labGrid"] {
        try part := bundle.%partName%
        catch
            part := 0
        if !IsObject(part)
            continue
        try words := part.Words
        catch
            continue
        if !IsObject(words)
            continue
        for word in words {
            if PatientV2_NormalizeMatch(word.Text) != target
                continue
            for nextWord in words {
                if PatientV2_NormalizeMatch(nextWord.Text) != "profile"
                    continue
                if Abs(nextWord.y - word.y) > Max(24, word.h * 2.5)
                    continue
                if nextWord.x + nextWord.w < word.x
                    continue
                return {
                    x: word.x - 12,
                    y: Min(word.y, nextWord.y) - 10,
                    w: (nextWord.x + nextWord.w) - word.x + 24,
                    h: Max(word.h, nextWord.h) + 22
                }
            }
        }
    }
    return 0
}

PatientV2_ProfileTabLuma(rect) {
    samples := [
        [rect.x + 4, rect.y + 3],
        [rect.x + rect.w - 4, rect.y + 3],
        [rect.x + 4, rect.y + rect.h - 4],
        [rect.x + rect.w - 4, rect.y + rect.h - 4]
    ]
    total := 0
    count := 0
    for point in samples {
        try {
            color := PixelGetColor(point[1], point[2], "RGB")
            hex := Format("{:06X}", color & 0xFFFFFF)
            r := Integer("0x" SubStr(hex, 1, 2))
            g := Integer("0x" SubStr(hex, 3, 2))
            b := Integer("0x" SubStr(hex, 5, 2))
            total += (r + g + b) / 3
            count += 1
        }
    }
    return count = 0 ? -1 : total / count
}


PatientV2_TryRapidBridgeForCapture(left, top, w, h, text, parsed, mode := "") {
    lowerText := StrLower(text)
    if w < 700
        return 0
    if mode = "" {
        if !InStr(lowerText, "demographics")
            return 0
        if parsed.sex != "" && parsed.heightCm != "" && parsed.weightKg != "" && parsed.scr != ""
            return 0
    } else if mode = "labs" {
        if !PatientV7_LooksLikeLabGridText(text)
            && !InStr(lowerText, "quick view")
            && !InStr(lowerText, "automated hematology")
            && !InStr(lowerText, "routine chemistry")
            return 0
    } else if mode = "medications" {
        if !InStr(lowerText, "acute profile") && !InStr(lowerText, "ambulatory profile")
            return 0
    } else {
        return 0
    }

    rapidBridge := A_ScriptDir "\ocr\rapidocr_bridge.exe"
    paddleBridge := A_ScriptDir "\ocr\paddleocr_bridge.exe"
    consensusBridge := A_ScriptDir "\ocr\ocr_consensus_bridge.exe"
    ; RapidOCR is the verified, practical bundled path.  The experimental
    ; PaddleX consensus sidecar is intentionally opt-in so a slow/unsupported
    ; CPU runtime can never block capture or silently replace evidence.
    useExperimentalPaddle := EnvGet("PHUCKIT_ENABLE_PADDLE") = "1"
    bridge := useExperimentalPaddle && FileExist(consensusBridge) && FileExist(rapidBridge) && FileExist(paddleBridge)
        ? consensusBridge
        : rapidBridge
    if !FileExist(bridge)
        return 0

    ; Cerner's sidebar is the left edge of the full capture. Bound the bridge
    ; region so this fallback remains a small local pass instead of re-reading
    ; the entire medication/lab screen.
    bridgeW := mode = "" ? Min(w, 360) : w
    bridgeH := mode = "" ? Min(h, 900) : h
    output := A_Temp "\PhUCKIT-RapidOCR-" A_TickCount "-" Random(1000, 9999) ".json"
    quote := Chr(34)
    if bridge = consensusBridge {
        activeProfile := "unknown"
        try activeProfile := IsObject(parsed.profileEvidence) && parsed.profileEvidence.Has("profile") ? parsed.profileEvidence.profile : "unknown"
        command := quote bridge quote " --rapid " quote rapidBridge quote " --paddle " quote paddleBridge quote " --capture " Round(left) " " Round(top) " " Round(bridgeW) " " Round(bridgeH) " --semantic --profile " activeProfile " --output " quote output quote
    } else {
        command := quote bridge quote " --capture " Round(left) " " Round(top) " " Round(bridgeW) " " Round(bridgeH) " --semantic --output " quote output quote
    }

    try RunWait(command, , "Hide")
    catch
        return 0

    if !FileExist(output)
        return 0
    try payload := CRD3_JSON_Parse(FileRead(output, "UTF-8"))
    catch {
        try FileDelete(output)
        return 0
    }
    try FileDelete(output)
    if !IsObject(payload) || !payload.Has("ok") || !payload["ok"] || !payload.Has("semantic")
        return 0
    return payload["semantic"]
}


PatientV2_ApplyRapidSemantic(parsed, semantic, includeLabs := false, includeMeds := false) {
    if !IsObject(semantic) || !semantic.Has("fields")
        return
    fields := semantic["fields"]
    if !IsObject(fields)
        return

    mappings := Map(
        "height", "heightCm",
        "dosing_weight", "weightKg",
        "serum_creatinine", "scr"
    )
    for sourceKey, targetKey in mappings {
        if !fields.Has(sourceKey)
            continue
        evidence := fields[sourceKey]
        if !IsObject(evidence) || !evidence.Has("value") || !evidence.Has("confidence")
            continue
        if !PatientV2_RapidEvidenceUsable(evidence, targetKey, "field")
            continue
        if parsed.%targetKey% != ""
            continue
        parsed.%targetKey% := evidence["value"]
        if !parsed.captureEvidence.Has(targetKey)
            parsed.captureEvidence[targetKey] := Map(
                "value", evidence["value"],
                "unit", evidence.Has("unit") ? evidence["unit"] : "",
                "raw", evidence.Has("source_text") ? evidence["source_text"] : "",
                "source", "rapidocr-onnxruntime",
                "confidence", evidence["confidence"]
            )
    }
    if includeLabs && semantic.Has("labs") {
        labPack := semantic["labs"]
        if IsObject(labPack) && labPack.Has("labs") {
            for key, evidence in labPack["labs"] {
                if !IsObject(evidence) || !evidence.Has("value")
                    continue
                if !PatientV2_RapidEvidenceUsable(evidence, key, "lab")
                    continue
                already := false
                for existing in parsed.gridLabs {
                    if existing.HasOwnProp("key") && existing.key = key {
                        already := true
                        break
                    }
                }
                if already
                    continue
                sourceUnit := evidence.Has("unit") ? evidence["unit"] : LabMetric_InputUnit(key, "")
                canonical := LabMetric_CanonicalizeGridValue(key, Number(evidence["value"]), sourceUnit)
                parsed.gridLabs.Push({
                    key: key,
                    value: canonical,
                    unit: LabMetric_DisplayUnit(key),
                    when: "",
                    accepted: true,
                    conf: "rapidocr",
                    source: "RapidOCR anchor parser",
                    raw: evidence.Has("source_text") ? evidence["source_text"] : ""
                })
                parsed.captureEvidence["lab:" key] := Map(
                    "value", canonical,
                    "unit", LabMetric_DisplayUnit(key),
                    "sourceUnit", sourceUnit,
                    "raw", evidence.Has("source_text") ? evidence["source_text"] : "",
                    "source", "rapidocr-onnxruntime",
                    "confidence", evidence.Has("confidence") ? evidence["confidence"] : ""
                )
            }
        }
    }
    if includeMeds && semantic.Has("medications") {
        medPack := semantic["medications"]
        if IsObject(medPack) && medPack.Has("rows") {
            for row in medPack["rows"] {
                if !IsObject(row) || !row.Has("normalized")
                    continue
                if row.Has("kind") && row["kind"] != "medication"
                    continue
                if !PatientV2_RapidMedicationUsable(row)
                    continue
                normalized := Trim(String(row["normalized"]))
                if normalized = ""
                    continue
                if !PatientV2_IsMedicationOrder(normalized)
                    continue
                duplicate := false
                normalizedKey := StrLower(RegExReplace(normalized, "[^a-z0-9]+", ""))
                for existing in parsed.medications {
                    existingKey := StrLower(RegExReplace(String(existing), "[^a-z0-9]+", ""))
                    if existingKey = normalizedKey {
                        duplicate := true
                        break
                    }
                }
                if duplicate
                    continue
                parsed.medications.Push(normalized)
            }
        }
    }
    try PatientCalc_Enrich(parsed)
}

; Semantic OCR is a fallback, never an authority.  Require direct provenance
; before a bridge result can enter the clinical record: a visible anchor, an
; explicit value separator, source coordinates, and no inference/review flag.
; This deliberately prefers a blank/review cell over a plausible-looking guess.
PatientV2_RapidEvidenceUsable(evidence, key := "", kind := "") {
    if !IsObject(evidence) || !evidence.Has("value") || !evidence.Has("confidence")
        return false
    if evidence.Has("review") || (evidence.Has("inference") && evidence["inference"])
        return false
    if !evidence.Has("source_text") || Trim(String(evidence["source_text"])) = ""
        return false
    if !evidence.Has("x") || !evidence.Has("y")
        return false
    if Number(evidence["confidence"]) < (kind = "lab" ? 0.78 : 0.70)
        return false

    source := String(evidence["source_text"])
    if !InStr(source, "->") && !InStr(source, ":")
        return false

    if kind = "lab" {
        def := PatientV7_GridDefByKey(key)
        if !IsObject(def)
            return false
        normalizedSource := PatientV2_NormalizeMatch(source)
        hits := 0
        for alias in def.aliases {
            aliasText := PatientV2_NormalizeMatch(alias)
            if aliasText != "" && InStr(normalizedSource, aliasText)
                hits += 1
        }
        ; A source line that contains several analyte labels is a geometry
        ; neighborhood, not direct evidence for one value. Do not accept it.
        if hits != 1
            return false
    } else if key = "heightCm" {
        if !RegExMatch(source, "i)\b(?:height|height/length|length)\b")
            return false
    } else if key = "weightKg" {
        if !RegExMatch(source, "i)\b(?:dosing\s+weight|weight\s+dosing|weight)\b")
            return false
    } else if key = "scr" {
        if !RegExMatch(source, "i)\b(?:creatinine|scr)\b")
            return false
    }
    return true
}

PatientV2_RapidMedicationUsable(row) {
    if !IsObject(row)
        return false
    if row.Has("inference") && row["inference"]
        return false
    if row.Has("review")
        return false
    if !row.Has("raw") || Trim(String(row["raw"])) = ""
        return false
    if !row.Has("source") || Trim(String(row["source"])) = ""
        return false
    if !row.Has("x") || !row.Has("y")
        return false
    return !row.Has("confidence") || Number(row["confidence"]) >= 0.70
}

PatientV2_RapidNeedsLabFallback(text, gridLabs) {
    lowerText := StrLower(text)
    if !PatientV7_LooksLikeLabGridText(text)
        && !InStr(lowerText, "quick view")
        && !InStr(lowerText, "automated hematology")
        && !InStr(lowerText, "routine chemistry")
        return false
    required := [
        "sodium", "potassium", "chloride", "bicarbonate", "bun", "creatinine",
        "glucose", "albumin", "platelets", "wbc", "rbc", "hemoglobin", "hematocrit"
    ]
    present := Map()
    for lab in gridLabs {
        if lab.HasOwnProp("key") && lab.HasOwnProp("accepted") && lab.accepted
            present[lab.key] := true
    }
    for key in required {
        if !present.Has(key)
            return true
    }
    return false
}

PatientV2_RapidNeedsMedicationFallback(text, medications) {
    lowerText := StrLower(text)
    if !InStr(lowerText, "acute profile") && !InStr(lowerText, "ambulatory profile")
        return false
    return !IsObject(medications) || medications.Length < 12
}


PatientV2_CaptureBundle(left, top, w, h) {
    ; A small selection is treated as one region.
    if w < 700 || h < 400 {
        ; Keep the fast path small, but use two independent transforms so
        ; faint CBC headers (especially WBC/RBC) are not lost to one pass.
        single := PatientV2_MergeOcrResults([
            PatientV2_TryOcrBatches(left, top, w, h, 2.8, 240, 28, "selected region"),
            PatientV2_TryOcrBatches(left, top, w, h, 3.4, 240, 28, "selected region contrast", true),
            PatientV2_TryOcrBatches(left, top, w, h, 4.0, 240, 28, "selected region mono", true, 110)
        ])

        orderOnly := PatientV2_LooksLikeMedicationGridText(single.Text)
        return {
            headerLeft: single,
            headerRight: 0,
            sidebar: single,
            ; A user may capture only Cerner's Order Sentence column. Treat
            ; that small crop as an order grid so row grouping and medication
            ; normalization still run instead of falling back to generic
            ; sidebar OCR.
            orders: orderOnly ? single : 0,
            labGrid: 0
        }
    }

    headerH := Max(
        105,
        Min(
            180,
            Round(h * 0.18)
        )
    )

    sidebarW := Max(
        215,
        Min(
            325,
            Round(w * 0.15)
        )
    )

    ordersTopOffset := Max(
        125,
        Round(h * 0.17)
    )

       ; Keep nearly the entire visible medication grid.
    ; The row parser filters buttons and footer controls.
    ordersBottomMargin := Max(
        20,
        Round(h * 0.035)
    )

    ordersH := Max(
        100,
        h - ordersTopOffset - ordersBottomMargin
    )

    headerLeftW := Round(w * 0.64)
    headerRightOffset := Round(w * 0.40)
    headerRightX := left + headerRightOffset
    headerRightW := w - headerRightOffset

    return {
        headerLeft: PatientV2_MergeOcrResults([
            PatientV2_TryOcrRect(left, top, headerLeftW, headerH, 2.8),
            PatientV2_TryOcrRect(left, top, headerLeftW, headerH, 4.2),
            PatientV2_TryOcrRect(left, top, headerLeftW, headerH, 4.0, true, 112)
        ]),

        headerRight: PatientV2_MergeOcrResults([
            PatientV2_TryOcrRect(headerRightX, top, headerRightW, headerH, 2.8),
            PatientV2_TryOcrRect(headerRightX, top, headerRightW, headerH, 4.2),
            PatientV2_TryOcrRect(headerRightX, top, headerRightW, headerH, 4.0, true, 112)
        ]),

        sidebar: PatientV2_MergeOcrResults([
            PatientV2_TryOcrBatches(
                left,
                top,
                sidebarW,
                h,
                3.4,
                225,
                30,
                "patient sidebar"
            ),
            PatientV2_TryOcrBatches(
                left,
                top,
                sidebarW,
                h,
                4.2,
                225,
                30,
                "patient sidebar contrast",
                true
            ),
            PatientV2_TryOcrBatches(
                left,
                top,
                sidebarW,
                h,
                4.0,
                225,
                30,
                "patient sidebar monochrome",
                true,
                112
            )
        ]),

        orders: PatientV12_CaptureMedicationRegion(
            left + sidebarW,
            top + ordersTopOffset,
            w - sidebarW,
            ordersH
        ),

        labGrid: 0
    }
}

PatientV2_LooksLikeMedicationGridText(text) {
    lower := StrLower(String(text))
    if InStr(lower, "order sentence")
        return true
    hits := 0
    for token in [" mg ", " mcg ", " tablet", " capsule", " injection", " solution", " oral ", " intravenous", " piggyback"] {
        if InStr(lower, token)
            hits += 1
    }
    return hits >= 3 && StrSplit(lower, "`n").Length >= 3
}


PatientV12_CaptureMedicationRegion(x, y, w, h) {
    ; Medication names are rendered in a much smaller font than most Cerner
    ; sidebar fields. Keep a whole-row pass for continuity, then add overlapping
    ; high-resolution tiles so a wide profile does not force the OCR scale down.
    wholeRows := PatientV2_TryOcrBatches(
        x, y, w, h, 2.8, 220, 34, "medication profile rows"
    )
    detailTiles := PatientV2_TryOcrTiles(
        x, y, w, h, 4.2, 720, 190, 96, 34,
        "medication profile detail"
    )
    contrastTiles := PatientV2_TryOcrTiles(
        x, y, w, h, 4.0, 720, 190, 96, 34,
        "medication profile contrast", true, 112
    )
    return PatientV2_MergeOcrResults([wholeRows, detailTiles, contrastTiles])
}


PatientV2_TryOcrBatches(
    x,
    y,
    w,
    h,
    preferredScale := 2.5,
    batchHeight := 240,
    overlap := 28,
    label := "screen data",
    grayscale := false,
    monochrome := 0
) {
    if h <= batchHeight + 20
        return PatientV2_TryOcrRect(x, y, w, h, preferredScale)

    step := Max(80, batchHeight - overlap)
    batchCount := Ceil(Max(1, h - overlap) / step)
    results := []
    offset := 0
    batchNumber := 0

    while offset < h {
        currentH := Min(batchHeight, h - offset)
        batchNumber += 1
        ToolTip "OCR BATCH " batchNumber " / " batchCount "  ·  " label
        result := PatientV2_TryOcrRect(x, y + offset, w, currentH, preferredScale, grayscale, monochrome)
        if IsObject(result)
            results.Push(result)
        if offset + currentH >= h
            break
        offset += step
    }

    return PatientV2_MergeOcrResults(results)
}


PatientV2_TryOcrTiles(
    x,
    y,
    w,
    h,
    preferredScale := 3.2,
    tileWidth := 620,
    tileHeight := 215,
    overlapX := 48,
    overlapY := 28,
    label := "grid data",
    grayscale := false,
    monochrome := 0,
    invertColors := false
) {
    if w <= tileWidth && h <= tileHeight
        return PatientV2_TryOcrRect(x, y, w, h, preferredScale, grayscale, monochrome, invertColors)

    stepX := Max(160, tileWidth - overlapX)
    stepY := Max(80, tileHeight - overlapY)
    columns := Ceil(Max(1, w - overlapX) / stepX)
    rows := Ceil(Max(1, h - overlapY) / stepY)
    total := columns * rows
    results := []
    tileNumber := 0
    offsetY := 0

    while offsetY < h {
        currentH := Min(tileHeight, h - offsetY)
        offsetX := 0
        while offsetX < w {
            currentW := Min(tileWidth, w - offsetX)
            tileNumber += 1
            ToolTip "OCR TILE " tileNumber " / " total "  ·  " label
            result := PatientV2_TryOcrRect(
                x + offsetX,
                y + offsetY,
                currentW,
                currentH,
                preferredScale,
                grayscale,
                monochrome,
                invertColors
            )
            if IsObject(result)
                results.Push(result)
            if offsetX + currentW >= w
                break
            offsetX += stepX
        }
        if offsetY + currentH >= h
            break
        offsetY += stepY
    }
    return PatientV2_MergeOcrResults(results)
}


PatientV2_MergeOcrResults(results) {
    if !IsObject(results) || results.Length = 0
        return 0
    if results.Length = 1
        return results[1]

    rawLines := []
    rawWords := []
    seenWords := Map()
    for result in results {
        try {
            for line in result.Lines {
                clean := PatientV2_CleanLine(line.Text)
                if clean = ""
                    continue
                rawLines.Push({ text: clean, x: line.x, y: line.y, w: line.w, h: line.h })
            }
        }
        try {
            for word in result.Words {
                clean := PatientV2_CleanLine(word.Text)
                if clean = ""
                    continue
                key := StrLower(clean) "|" Round(word.x / 4) "|" Round(word.y / 4)
                support := word.HasOwnProp("support") ? word.support : 1
                if seenWords.Has(key) {
                    rawWords[seenWords[key]].support += support
                    continue
                }
                rawWords.Push({ Text: clean, x: word.x, y: word.y, w: word.w, h: word.h, support:support })
                seenWords[key] := rawWords.Length
            }
        }
    }

    ; Different transforms can return different text for the same row. Keep
    ; one voted line per spatial cluster so a weak pass cannot reintroduce a
    ; conflicting value into the downstream parser.
    lineGroups := Map()
    for line in rawLines {
        key := Round(line.x / 8) "|" Round(line.y / 8)
        if !lineGroups.Has(key)
            lineGroups[key] := []
        lineGroups[key].Push(line)
    }
    votedLines := []
    for _, candidates in lineGroups {
        votes := Map()
        for candidate in candidates {
            textKey := StrLower(candidate.text)
            if !votes.Has(textKey)
                votes[textKey] := { count: 0, candidate: candidate }
            votes[textKey].count += 1
        }
        winner := 0
        for _, vote in votes {
            if !IsObject(winner) || vote.count > winner.count
                winner := vote
        }
        if IsObject(winner)
            votedLines.Push(winner.candidate)
    }

    sorted := PatientV2_SortLines(votedLines)
    mergedLines := []
    text := ""
    for item in sorted {
        mergedLines.Push({ Text: item.text, x: item.x, y: item.y, w: item.w, h: item.h })
        text .= (text = "" ? "" : "`r`n") item.text
    }

    if text = "" {
        for result in results {
            try partText := Trim(result.Text)
            catch
                partText := ""
            if partText != ""
                text .= (text = "" ? "" : "`r`n") partText
        }
    }
    return { Text: text, Lines: mergedLines, Words: rawWords }
}


PatientV2_TryOcrRect(
    x,
    y,
    w,
    h,
    preferredScale := 2.5,
    grayscale := false,
    monochrome := 0,
    invertColors := false
) {
    if w < 10 || h < 10
        return 0

    maxDimension := 3800

    try {
        if OCR.MaxImageDimension > 200
            maxDimension := OCR.MaxImageDimension - 100
    }

    safeScale := Min(
        preferredScale,
        maxDimension / Max(1, w),
        maxDimension / Max(1, h)
    )

    safeScale := Max(
        1.0,
        safeScale
    )

    options := {
        scale: safeScale
    }

    if grayscale
        options.grayscale := true
    if monochrome
        options.monochrome := monochrome
    if invertColors
        options.invertcolors := true

    try {
        return OCR.FromRect(
            Round(x),
            Round(y),
            Round(w),
            Round(h),
            options
        )
    } catch as e {
        ParsingDiagnostics_Log("ocr_region_failed", Map(
            "component", "ocr",
            "detail", "engine_exception"
        ))
        Log(
            "Patient OCR region failed at "
            . Round(x)
            . ","
            . Round(y)
            . " "
            . Round(w)
            . "x"
            . Round(h)
            . ": "
            . e.Message
        )

        return 0
    }
}


PatientV2_BundleText(bundle) {
    output := ""

    for key in [
        "headerLeft",
        "headerRight",
        "sidebar",
        "orders",
        "labGrid"
    ] {
        part := 0
        partText := ""

        try part := bundle.%key%

        if !IsObject(part)
            continue

        try partText := Trim(part.Text)

        if partText = ""
            continue

        if output != ""
            output .= "`r`n`r`n"

        output .= "["
            . key
            . "]`r`n"
            . partText
    }

    return output
}


PatientV2_NewParsedResult() {
    return {
        age: "",
        dob: "",
        sex: "",
        location: "",
        heightCm: "",
        weightKg: "",
        scr: "",
        allergies: [],
        medications: [],
        captureEvidence: Map(),
        qualitativeFindings: []
    }
}


; Guarantee the canonical parsed shape before any consumer (picker, BMI,
; renal flags, calc prefill) reads a property. OCR/merge paths can, on
; unusual screens, hand back an object that is missing a field or whose
; allergies/medications came through as a non-array. Reading a missing
; local-scope value downstream is exactly what produced the intermittent
; UnsetError, so we repair the shape here instead of trusting every caller.



PatientV2_ParseBundle(bundle) {
    parsed := PatientV2_NewParsedResult()
    sideParsed := 0

    ; Start with the existing parser for basic demographic values.
    for headerResult in [
        bundle.headerLeft,
        bundle.headerRight
    ] {
        if !IsObject(headerResult)
            continue

        try {
            headerParsed := Vanco_ParseDemographics(
                headerResult
            )

            PatientV2_MergeScalars(
                parsed,
                headerParsed
            )
        }
    }

    if IsObject(bundle.sidebar) {
        try {
            sideParsed := Vanco_ParseDemographics(
                bundle.sidebar
            )

            PatientV2_MergeScalars(
                parsed,
                sideParsed
            )
        }
    }

    PatientV2_ApplyHeaderFallbacks(
        parsed,
        bundle
    )

    if IsObject(bundle.sidebar) {
        PatientV2_ApplySidebarFallbacks(
            parsed,
            bundle.sidebar
        )

        parsed.allergies :=
            PatientV2_ExtractAllergies(
                bundle.sidebar
            )
    }

    if IsObject(bundle.orders) {
        parsed.medications :=
            PatientV2_ExtractMedications(
                bundle.orders
            )
    } else if IsObject(sideParsed) {
        try parsed.medications :=
            sideParsed.medications.Clone()
    }

    for partName in ["headerLeft", "headerRight", "sidebar", "orders"] {
        try part := bundle.%partName%
        catch
            part := 0
        if !IsObject(part)
            continue
        bp := PatientV11_ExtractAnchoredBloodPressure(part)
        if bp.confidence = "high" {
            parsed.systolicBP := bp.systolic
            parsed.diastolicBP := bp.diastolic
            parsed.vitalEvidence.Push({field: "blood pressure", value: bp.systolic "/" bp.diastolic, unit: bp.unit, raw: bp.raw, source: partName, confidence: bp.confidence})
            break
        }
    }

    if parsed.location != ""
        parsed.location :=
            PatientV2_CleanLocation(
                parsed.location
            )

    return PatientV4_Finalize(parsed, bundle)
}





PatientV2_ApplyHeaderFallbacks(parsed, bundle) {
    composite := ""

    for part in [
        bundle.headerLeft,
        bundle.headerRight
    ] {
        if !IsObject(part)
            continue

        partText := PatientV2_ResultText(part)

        if partText != ""
            composite .= " " partText

        ; Re-read specifically labeled header rows at higher resolution.
        for item in PatientV2_GetLines(part) {
            lineText := StrLower(item.text)

            if InStr(lineText, "age")
                || InStr(lineText, "sex")
                || InStr(lineText, "location") {

                refined := PatientV2_ReOcrLine(
                    item,
                    3.8,
                    80
                )

                if refined != ""
                    composite .= " " refined
            }
        }
    }

    flat := PatientV2_NormalizeText(composite)

    if parsed.age = ""
        && RegExMatch(
            flat,
            "i)\bAge\s*[:=-]?\s*(\d{1,3})\b",
            &match
        ) {

        value := Number(match[1])

        if value >= 0 && value <= 120
            parsed.age := value
    }

    if parsed.sex = ""
        && RegExMatch(
            flat,
            "i)\bS\s*e\s*x\s*[:=-]?\s*(Male|Female|M|F)\b",
            &match
        ) {

        sexValue := StrLower(match[1])

        parsed.sex := (
            sexValue = "female"
            || sexValue = "f"
        ) ? "Female" : "Male"
    }

    if parsed.location = ""
        && RegExMatch(
            flat,
            "i)\bLocation\s*[:=-]?\s*(.+?)"
            . "(?=\s+(?:"
            . "Physician"
            . "|DOD\s*ID"
            . "|Age"
            . "|Sex"
            . "|Race"
            . "|Admitted"
            . "|MRN"
            . "|FIN"
            . "|Rx\s+Clinical\s+Note"
            . ")\s*:|$)",
            &match
        ) {

        parsed.location :=
            PatientV2_CleanLocation(
                match[1]
            )
    }
}


PatientV2_ApplySidebarFallbacks(
    parsed,
    sidebarResult
) {
    composite := PatientV2_ResultText(
        sidebarResult
    )

    ; Re-read the three important demographic rows individually.
    for item in PatientV2_GetLines(sidebarResult) {
        lineText := StrLower(item.text)

        if InStr(lineText, "height")
            || InStr(lineText, "weight")
            || InStr(lineText, "creat")
            || InStr(lineText, "s-cr")
            || InStr(lineText, "scr") {

            refined := PatientV2_ReOcrLine(
                item,
                4.0,
                70
            )

            if refined != ""
                composite .= " " refined
        }
    }

    flat := PatientV2_NormalizeText(composite)

    ; Height with a recognizable cm unit.
    if parsed.heightCm = ""
        && RegExMatch(
            flat,
            "i)\bHeight\s*/?\s*Length\b"
            . ".{0,100}?"
            . "(\d{2,3}(?:[.,]\d+)?)"
            . "\s*(?:c\s*m|cm|em)\b",
            &match
        ) {

        value := PatientV2_Number(match[1])

        if value >= 100 && value <= 250
            parsed.heightCm := Round(value, 1)
    }

    ; Height fallback when OCR loses the letters cm.
    if parsed.heightCm = ""
        && RegExMatch(
            flat,
            "i)\bHeight\s*/?\s*Length\b"
            . ".{0,55}?"
            . "(\d{3}(?:[.,]\d+)?)\b",
            &match
        ) {

        value := PatientV2_Number(match[1])

        if value >= 100 && value <= 250
            parsed.heightCm := Round(value, 1)
    }

    ; Weight with kg, kq, or k9 OCR variants.
    if parsed.weightKg = ""
        && RegExMatch(
            flat,
            "i)\bWeight\s*"
            . "(?:D[o0]s[i1l]ng)?\b"
            . ".{0,100}?"
            . "(\d{2,3}(?:[.,]\d+)?)"
            . "\s*k\s*[gq9]\b",
            &match
        ) {

        value := PatientV2_Number(match[1])

        if value >= 20 && value <= 400
            parsed.weightKg := Round(value, 1)
    }

    ; Weight fallback when OCR loses the unit.
    if parsed.weightKg = ""
        && RegExMatch(
            flat,
            "i)\bWeight\s*"
            . "(?:D[o0]s[i1l]ng)?\b"
            . ".{0,55}?"
            . "(\d{2,3}(?:[.,]\d+)?)\b",
            &match
        ) {

        value := PatientV2_Number(match[1])

        if value >= 20 && value <= 400
            parsed.weightKg := Round(value, 1)
    }

    ; Creatinine with a recognizable mg/dL unit.
    if parsed.scr = ""
        && RegExMatch(
            flat,
            "i)\b(?:"
            . "s[\s-]*cr"
            . "|serum\s+creatinine"
            . "|creat[i1l]n[i1l]ne"
            . "(?:\s+(?:level|lvl|leve[1lI]))?"
            . ")\b"
            . ".{0,100}?"
            . "(\d{1,2}(?:[.,]\d+)?)"
            . "\s*m\s*[gq9]"
            . "\s*[/\\|]?\s*d\s*[l1iI]\b",
            &match
        ) {

        value := PatientV2_Number(match[1])

        if value > 0 && value <= 25
            parsed.scr := value
    }

    ; Creatinine fallback when OCR loses mg/dL.
    if parsed.scr = ""
        && RegExMatch(
            flat,
            "i)\b(?:"
            . "s[\s-]*cr"
            . "|serum\s+creatinine"
            . "|creat[i1l]n[i1l]ne"
            . "(?:\s+(?:level|lvl|leve[1lI]))?"
            . ")\b"
            . ".{0,55}?"
            . "(\d{1,2}(?:[.,]\d+)?)\b",
            &match
        ) {

        value := PatientV2_Number(match[1])

        if value > 0 && value <= 25
            parsed.scr := value
    }
}


PatientV2_GetLines(ocrResult) {
    output := []

    if !IsObject(ocrResult)
        return output

    try {
        for line in ocrResult.Lines {
            text := PatientV2_CleanLine(
                line.Text
            )

            if text = ""
                continue

            output.Push({
                text: text,
                x: line.x,
                y: line.y,
                w: line.w,
                h: line.h
            })
        }
    }

    return PatientV2_SortLines(output)
}


PatientV2_SortLines(lines) {
    output := []

    for item in lines {
        inserted := false

        for index, existing in output {
            sameRow :=
                Abs(item.y - existing.y) <= 5

            if item.y < existing.y - 5
                || (
                    sameRow
                    && item.x < existing.x
                ) {

                output.InsertAt(
                    index,
                    item
                )

                inserted := true
                break
            }
        }

        if !inserted
            output.Push(item)
    }

    return output
}


PatientV2_ExtractAllergies(ocrResult) {
    output := []
    seen := Map()
    collecting := false

    for item in PatientV2_GetLines(ocrResult) {
        original := PatientV2_CleanLine(
            item.text
        )

        if !collecting {
            if RegExMatch(
                original,
                "i)^Allerg"
            ) {
                collecting := true
            }

            continue
        }

        if RegExMatch(
            original,
            "i)^(?:"
            . "Medications"
            . "|Problems\s+and\s+Diagnoses"
            . "|Rx\s+Clinical\s+Note"
            . "|Rx\s+Interventions"
            . "|Reason\s+for\s+Visit"
            . ")\b"
        ) {
            break
        }

        if !PatientV2_AllergyCandidate(
            original
        ) {
            continue
        }

        refined := PatientV2_ReOcrLine(
            item,
            4.2,
            35
        )

        bestText := PatientV2_BestText(
            original,
            refined
        )

        corrected :=
            PatientV2_CorrectAllergy(
                bestText
            )

        if corrected = ""
            continue

        key := PatientV2_NormalizeMatch(
            corrected
        )

        if key = "" || seen.Has(key)
            continue

        seen[key] := true
        output.Push(corrected)
    }

    return output
}


PatientV2_AllergyCandidate(text) {
    if text = ""
        return false

    if RegExMatch(
        text,
        "i)^(?:"
        . "Click here"
        . "|Allerg"
        . "|Adverse\s+type"
        . "|Result\s+Dt/?Tm"
        . "|Patient\s+Note"
        . "|Reason\s+for\s+Visit"
        . ")"
    ) {
        return false
    }

    if StrLen(text) > 100
        return false

    if RegExMatch(
        text,
        "i)\b(?:"
        . "mcg"
        . "|mg"
        . "|mL"
        . "|tablet"
        . "|capsule"
        . "|injection"
        . ")\b"
    ) {
        return false
    }

    return true
}


PatientV2_CorrectAllergy(text) {
    text := PatientV2_CleanLine(text)

    normalized := PatientV2_NormalizeMatch(
        text
    )

    static aliases := Map(
        "oupropion", "bupropion",
        "bupropion", "bupropion",

        "geevenom", "bee venom",
        "beevenom", "bee venom",

        "pregain", "pregabalin",
        "pregalin", "pregabalin",
        "pregabalin", "pregabalin",

        "iamatriqine", "lamotrigine",
        "lamatriqine", "lamotrigine",
        "lamotriqine", "lamotrigine",
        "lamotrigine", "lamotrigine",

        "adhesivetape", "adhesive tape",
        "advesivetape", "adhesive tape",

        "duloxetine", "duloxetine",
        "atorvastatin", "atorvastatin",
        "oxycodone", "oxycodone",
        "gabapentin", "gabapentin",
        "penicillins", "penicillins"
    )

    if aliases.Has(normalized)
        return aliases[normalized]

    static knownAllergens := [
        "adhesive tape",
        "amoxicillin",
        "ampicillin",
        "aspirin",
        "atorvastatin",
        "bee venom",
        "bupropion",
        "cefazolin",
        "cephalexin",
        "ceftriaxone",
        "codeine",
        "duloxetine",
        "gabapentin",
        "hydrocodone",
        "ibuprofen",
        "iodinated contrast media",
        "lamotrigine",
        "latex",
        "lisinopril",
        "losartan",
        "morphine",
        "naproxen",
        "oxycodone",
        "peanut",
        "penicillin",
        "penicillins",
        "piperacillin-tazobactam",
        "pregabalin",
        "shellfish",
        "sulfonamides",
        "sulfamethoxazole-trimethoprim",
        "tramadol",
        "tree nuts",
        "vancomycin"
    ]

    return PatientV2_ClosestTerm(
        text,
        knownAllergens,
        0.40
    )
}


PatientV2_ExtractMedications(ocrResult) {
    output := []
    seen := Map()
    discontinuedRows := []

    lines := PatientV2_GetLines(ocrResult)

    ; Status text may be in a separate column from the order sentence.
    for item in lines {
        text := PatientV2_CleanLine(
            item.text
        )

        if RegExMatch(
            text,
            "i)^Discontinued\b"
        ) {
            discontinuedRows.Push(item.y)
        }
    }

    for item in lines {
        if PatientV2_RowIsDiscontinued(
            item.y,
            item.h,
            discontinuedRows
        ) {
            continue
        }

        original :=
            PatientV2_NormalizeOrder(
                item.text
            )

        if !PatientV2_LooksLikeMedication(
            original
        ) {
            continue
        }

        refined := PatientV2_ReOcrLine(
            item,
            3.8,
            120
        )

        refined :=
            PatientV2_NormalizeOrder(
                refined
            )

        text := PatientV2_BestText(
            original,
            refined
        )

        text := PatientV2_FixClinicalWords(
            text
        )

        text :=
            PatientV2_CorrectMedicationName(
                text
            )

        if text = ""
            continue

        if RegExMatch(
            text,
            "i)\bDiscontinued\b"
        ) {
            continue
        }

        ; These are generally component/dispense rows rather than
        ; a separate active medication order.
        if RegExMatch(
            text,
            "i)\bADM\s+Dispense\b"
        ) {
            continue
        }

        if !PatientV2_IsMedicationOrder(
            text
        ) {
            continue
        }

        identity :=
            PatientV2_MedicationIdentity(
                text
            )

        if identity = ""
            || seen.Has(identity) {
            continue
        }

        seen[identity] := true

        if PatientV2_MedicationNeedsReview(
            text
        ) && !InStr(text, "[VERIFY OCR]") {
            text .= "  [VERIFY OCR]"
        }

        output.Push(text)
    }

    return output
}


PatientV2_RowIsDiscontinued(
    y,
    height,
    discontinuedRows
) {
    tolerance := Max(
        7,
        Round(height * 0.85)
    )

    for discontinuedY in discontinuedRows {
        if Abs(y - discontinuedY)
            <= tolerance {
            return true
        }
    }

    return false
}


PatientV2_NormalizeOrder(text) {
    text := PatientV2_CleanLine(text)

    if text = ""
        return ""

    text := RegExReplace(
        text,
        "i)^.*?\b(?:Active|Verify)\b\s+",
        ""
    )

    text := RegExReplace(
        text,
        "i)^(?:"
        . "Action"
        . "|Status"
        . "|Active"
        . "|Verify"
        . ")\s+",
        ""
    )

    text := RegExReplace(
        text,
        "i)^Drug\s*:\s*",
        ""
    )

    ; Remove start/stop-date columns when OCR joins them to the order.
    text := RegExReplace(
        text,
        "\s+\d{2}/\d{2}/\d{4}\b.*$",
        ""
    )

    text := RegExReplace(
        text,
        "i)\s+(?:MED|PROTOCOL)\s*$",
        ""
    )

    return PatientV2_CleanLine(text)
}


PatientV2_LooksLikeMedication(text) {
    if text = ""
        return false

    if RegExMatch(
        text,
        "i)^(?:"
        . "Order\s+Sentence"
        . "|Action"
        . "|Status"
        . "|Start"
        . "|Stop"
        . "|Order\s+Type"
        . "|Active$"
        . "|Verify$"
        . "|Discontinued$"
        . ")\b"
    ) {
        return false
    }

    if RegExMatch(
        text,
        "^\d{2}/\d{2}/\d{4}"
    ) {
        return false
    }

    return RegExMatch(
        text,
        "i)\b(?:"
        . "mcg"
        . "|mg"
        . "|mL"
        . "|units?"
        . "|tablet"
        . "|capsule"
        . "|injection"
        . "|solution"
        . "|liquid"
        . "|oral"
        . "|intravenous"
        . "|piggyback"
        . "|nebulized"
        . "|inhalation"
        . "|topical"
        . "|subcutaneous"
        . "|ophthalmic"
        . "|cream"
        . "|spray"
        . "|suppository"
        . ")\b"
    )
}


PatientV2_IsMedicationOrder(text) {
    if text = ""
        return false

    if RegExMatch(
        text,
        "i)^(?:"
        . "Order\s+Sentence"
        . "|Start"
        . "|Stop"
        . "|Order\s+Type"
        . "|Drug:"
        . ")"
    ) {
        return false
    }

    if RegExMatch(
        text,
        "i)\bADM\s+Dispense\b"
    ) {
        return false
    }

    isLabOrDemographic := RegExMatch(
        text,
        "i)\b(?:"
        . "Glucose\s+Lvl"
        . "|Creatinine\s+Level"
        . "|Height"
        . "|Weight\s+Dosing"
        . "|BSA"
        . "|BMI"
        . "|CrCl"
        . "|eGFR"
        . "|INR"
        . ")\b"
    )

    if isLabOrDemographic
        return false

    hasDose := RegExMatch(
        text,
        "i)\b\d+(?:[.,]\d+)?\s*(?:"
        . "mcg"
        . "|mg"
        . "|g"
        . "|mL"
        . "|units?(?:\(s\))?"
        . "|%"
        . "|drops?(?:\(s\))?"
        . "|puffs?(?:\(s\))?"
        . ")\b"
    )

    hasForm := RegExMatch(
        text,
        "i)\b(?:"
        . "tablet"
        . "|capsule"
        . "|injection"
        . "|solution"
        . "|suspension"
        . "|liquid"
        . "|cream"
        . "|ointment"
        . "|spray"
        . "|inhalation"
        . "|nebulized"
        . "|oral"
        . "|intravenous"
        . "|intramuscular"
        . "|subcutaneous"
        . "|ophthalmic"
        . "|topical"
        . "|transdermal"
        . "|piggyback"
        . "|powder"
        . "|patch"
        . "|suppository"
        . ")\b"
    )

    return hasDose
        && (
            hasForm
            || PatientV2_KnownMedicationPrefix(text)
        )
}


PatientV2_FixClinicalWords(text) {
    text := PatientV2_CleanLine(text)

    text := RegExReplace(
        text,
        "i)\bSaluti(?:a|o)n\b",
        "Solution"
    )

    text := RegExReplace(
        text,
        "i)\b[lI]nhalation\b",
        "Inhalation"
    )

    text := RegExReplace(
        text,
        "i)\bevely\b",
        "every"
    )

    text := RegExReplace(
        text,
        "i)\bP[LlI]ish\b",
        "Push"
    )

    text := RegExReplace(
        text,
        "i)\bIniection\b",
        "Injection"
    )

    text := RegExReplace(
        text,
        "i)\b[lI]?njection\b",
        "Injection"
    )

    text := RegExReplace(
        text,
        "i)\bIntrevenous\b",
        "Intravenous"
    )

    text := RegExReplace(
        text,
        "i)\bIntravenaus\b",
        "Intravenous"
    )

    text := RegExReplace(
        text,
        "i)\bSubCutaneous\b",
        "Subcutaneous"
    )

    text := RegExReplace(
        text,
        "i)\bII/\s*Piggyback\b",
        "IV Piggyback"
    )

    text := RegExReplace(
        text,
        "i)\bmL\s*[_JIl|/\\]\s*hr\b",
        "mL/hr"
    )

    text := RegExReplace(
        text,
        "i)\bmL[JIl]\s*hr\b",
        "mL/hr"
    )

    text := RegExReplace(
        text,
        "i)(?<=mg)[fJ](?=\d)",
        "/"
    )

    text := RegExReplace(
        text,
        "\s+",
        " "
    )

    return Trim(text)
}


PatientV2_CorrectMedicationName(text) {
    if !RegExMatch(
        text,
        "i)^(.+?)"
        . "(?=\s+\d+(?:[.,]\d+)?\s*"
        . "(?:mcg|mg|g|mL|units?|%))",
        &match
    ) {
        return text
    }

    rawPrefix := Trim(match[1])

    rest := SubStr(
        text,
        StrLen(match[1]) + 1
    )

    baseName := rawPrefix
    descriptor := ""

    if RegExMatch(
        baseName,
        "i)^(.+?)(\s+(?:"
        . "topical"
        . "|unit\(s\)"
        . "|units?"
        . "))$",
        &descriptorMatch
    ) {
        baseName := descriptorMatch[1]
        descriptor := descriptorMatch[2]
    }

    ; Discard an OCR-corrupted premix equivalency phrase,
    ; while retaining the standard medication name.
    if RegExMatch(
        baseName,
        "i)^(.+?)/premix.*$",
        &premixMatch
    ) {
        baseName := premixMatch[1]
    }

    correctedName :=
        PatientV2_CorrectMedicationBase(
            baseName
        )

    correctedLine := PatientV2_CleanLine(
        correctedName
        . descriptor
        . rest
    )

    if PatientV2_NormalizeMatch(correctedName) != PatientV2_NormalizeMatch(baseName)
        correctedLine .= "  [VERIFY OCR]"

    return correctedLine
}


PatientV2_CorrectMedicationBase(baseName) {
    normalized :=
        PatientV2_NormalizeMatch(
            baseName
        )

    static aliases := Map(
        "albuterolipratropium", "albuterol-ipratropium",

        "alteplaese", "alteplase",
        "alteplase", "alteplase",

        "chlorhexidine", "chlorhexidine",

        "heperin", "heparin",
        "heparin", "heparin",

        "docaine", "lidocaine",
        "lidocaine", "lidocaine",

        "ouloxetine", "duloxetine",
        "duloxetine", "duloxetine",

        "pantoprazole", "pantoprazole",

        "piperecillintaezcbectaem", "piperacillin-tazobactam",
        "piperecillintazcbectam", "piperacillin-tazobactam",
        "piperecillintazobactam", "piperacillin-tazobactam",
        "piperacillintazobactam", "piperacillin-tazobactam",

        "vancomycin", "vancomycin"
    )

    if aliases.Has(normalized)
        return aliases[normalized]

    return PatientV2_ClosestTerm(
        baseName,
        PatientV2_KnownMedications(),
        0.36
    )
}


PatientV2_KnownMedications() {
    static medications := [
        "acetaminophen",
        "albuterol",
        "albuterol-ipratropium",
        "allopurinol",
        "alteplase",
        "amlodipine",
        "aspirin",
        "atorvastatin",
        "bisacodyl",
        "chlorhexidine",
        "clopidogrel",
        "cyanocobalamin",
        "diphenhydramine",
        "docusate",
        "duloxetine",
        "enoxaparin",
        "escitalopram",
        "ezetimibe",
        "famotidine",
        "fluticasone",
        "furosemide",
        "gabapentin",
        "glucagon",
        "glucose",
        "guaifenesin",
        "heparin",
        "hydrochlorothiazide",
        "hydrocodone-acetaminophen",
        "insulin aspart",
        "insulin glargine",
        "isosorbide mononitrate",
        "lidocaine",
        "magnesium oxide",
        "meperidine",
        "metformin",
        "methylprednisolone",
        "metoprolol",
        "miconazole",
        "mirabegron",
        "multivitamin",
        "ocular lubricant",
        "oxycodone",
        "pantoprazole",
        "piperacillin-tazobactam",
        "rituximab",
        "rosuvastatin",
        "sodium chloride",
        "spironolactone",
        "tamsulosin",
        "thiamine",
        "tuberculin purified protein derivative",
        "vancomycin"
    ]

    return medications
}


PatientV2_KnownMedicationPrefix(text) {
    textLower := StrLower(
        Trim(text)
    )

    for medication in PatientV2_KnownMedications() {
        if InStr(
            textLower,
            StrLower(medication)
        ) = 1 {
            return true
        }
    }

    return false
}


PatientV2_MedicationNeedsReview(text) {
    if RegExMatch(
        text,
        "[æœ _]"
    ) {
        return true
    }

    ; A likely missing decimal, such as 2 5 mg.
    if RegExMatch(
        text,
        "\b\d+\s+\d+\s*(?:mg|mcg|mL)\b"
    ) {
        return true
    }

    ; A period may be acting as a thousands separator.
    if RegExMatch(
        text,
        "\b\d+\.\d{3}\s*mg\b"
    ) {
        return true
    }

    ; A frequency digit may have been read as g or q.
    if RegExMatch(
        text,
        "i)\bevery\s+[gq]\s*hr\b"
    ) {
        return true
    }

    if RegExMatch(
        text,
        "i)\bmL[JIl]"
    ) {
        return true
    }

    if RegExMatch(
        text,
        "i)\b0\d{2}\s*%"
    ) {
        return true
    }

    if RegExMatch(
        text,
        "i)\b[lI]{2}\s*\d"
    ) {
        return true
    }

    return false
}


PatientV2_MedicationIdentity(text) {
    text := StrReplace(
        text,
        "[VERIFY OCR]",
        ""
    )

    text := StrLower(
        PatientV2_CleanLine(text)
    )

    text := RegExReplace(
        text,
        "\s+",
        " "
    )

    return text
}


PatientV2_ReOcrLine(
    item,
    scale := 3.8,
    extraRight := 60
) {
    paddingX := 10
    paddingY := 5

    x := item.x - paddingX
    y := item.y - paddingY

    w := item.w
        + paddingX
        + extraRight

    h := item.h
        + (paddingY * 2)

    normalResult := PatientV2_TryOcrRect(
        x,
        y,
        w,
        h,
        scale,
        false
    )

    grayResult := PatientV2_TryOcrRect(
        x,
        y,
        w,
        h,
        scale,
        true
    )

    normalText :=
        PatientV2_ResultText(
            normalResult
        )

    grayText :=
        PatientV2_ResultText(
            grayResult
        )

    if normalText = ""
        return grayText

    if grayText = ""
        return normalText

    normalScore :=
        PatientV2_QualityScore(
            normalText
        )

    grayScore :=
        PatientV2_QualityScore(
            grayText
        )

    return grayScore > normalScore
        ? grayText
        : normalText
}


PatientV2_BestText(original, refined) {
    original := PatientV2_CleanLine(
        original
    )

    refined := PatientV2_CleanLine(
        refined
    )

    if refined = ""
        return original

    if original = ""
        return refined

    originalScore :=
        PatientV2_QualityScore(
            original
        )

    refinedScore :=
        PatientV2_QualityScore(
            refined
        )

    ; Avoid using a much shorter re-read that dropped most of the sig.
    if StrLen(refined)
        < StrLen(original) * 0.55 {
        return original
    }

    return refinedScore >= originalScore - 4
        ? refined
        : original
}


PatientV2_QualityScore(text) {
    text := PatientV2_CleanLine(text)
    score := StrLen(text)

    for badCharacter in [
        "æ",
        "œ",
        " ",
        "|",
        "_"
    ] {
        count :=
            StrLen(text)
            - StrLen(
                StrReplace(
                    text,
                    badCharacter,
                    ""
                )
            )

        score -= count * 18
    }

    if RegExMatch(
        text,
        "\b\d+\s+\d+\s*mg\b"
    ) {
        score -= 12
    }

    for usefulWord in [
        "mg",
        "mcg",
        "mL",
        "tablet",
        "capsule",
        "injection",
        "solution",
        "oral",
        "intravenous",
        "every",
        "daily",
        "PRN",
        "piggyback"
    ] {
        if RegExMatch(
            text,
            "i)\b"
            . usefulWord
            . "\b"
        ) {
            score += 8
        }
    }

    return score
}


PatientV2_ClosestTerm(
    original,
    terms,
    maxRatio := 0.36
) {
    candidate :=
        PatientV2_NormalizeMatch(
            original
        )

    if StrLen(candidate) < 3
        return original

    bestTerm := original
    bestDistance := 1000000
    secondDistance := 1000000

    for term in terms {
        normalizedTerm :=
            PatientV2_NormalizeMatch(
                term
            )

        distance :=
            PatientV2_EditDistance(
                candidate,
                normalizedTerm
            )

        if distance < bestDistance {
            secondDistance := bestDistance
            bestDistance := distance
            bestTerm := term
        } else if distance < secondDistance {
            secondDistance := distance
        }
    }

    bestLength := Max(
        StrLen(candidate),
        StrLen(
            PatientV2_NormalizeMatch(
                bestTerm
            )
        )
    )

    allowedDistance := Max(
        1,
        Floor(
            bestLength * maxRatio
        )
    )

    if bestDistance <= allowedDistance
        && (
            bestDistance <= 1
            || secondDistance - bestDistance >= 2
        ) {
        return bestTerm
    }

    return original
}


PatientV2_NormalizeMatch(text) {
    text := StrLower(
        PatientV2_CleanLine(text)
    )

    for source, target in Map(
        "ö", "o", "ó", "o", "ò", "o",
        "é", "e", "è", "e", "á", "a", "í", "i", "ü", "u"
    )
        text := StrReplace(text, source, target)

    text := StrReplace(
        text,
        "æ",
        "ae"
    )

    text := StrReplace(
        text,
        "œ",
        "oe"
    )

    text := StrReplace(
        text,
        "|",
        "l"
    )

    text := StrReplace(
        text,
        "0",
        "o"
    )

    text := StrReplace(
        text,
        "1",
        "l"
    )

    text := RegExReplace(
        text,
        "[^a-z0-9]+",
        ""
    )

    return text
}


PatientV2_EditDistance(a, b) {
    previous := []

    Loop StrLen(b) + 1
        previous.Push(A_Index - 1)

    Loop StrLen(a) {
        row := A_Index
        current := [row]
        charA := SubStr(a, row, 1)

        Loop StrLen(b) {
            column := A_Index
            charB := SubStr(b, column, 1)

            cost := charA = charB
                ? 0
                : 1

            insertion :=
                current[column] + 1

            deletion :=
                previous[column + 1] + 1

            substitution :=
                previous[column] + cost

            current.Push(
                Min(
                    insertion,
                    Min(
                        deletion,
                        substitution
                    )
                )
            )
        }

        previous := current
    }

    return previous[
        StrLen(b) + 1
    ]
}


PatientV2_CleanLocation(value) {
    value := PatientV2_CleanLine(
        value
    )

    value := RegExReplace(
        value,
        "i)\s+\b(?:"
        . "Physician"
        . "|DOD\s*ID"
        . "|Age"
        . "|Sex"
        . "|Race"
        . "|Admitted"
        . "|MRN"
        . "|FIN"
        . "|Rx\s+Clinical\s+Note"
        . ")\b\s*:.*$",
        ""
    )

    value := RegExReplace(
        value,
        "i)\bslcu\b",
        "SICU"
    )

    value := RegExReplace(
        value,
        "i)\blcu\b",
        "ICU"
    )

    value := RegExReplace(
        value,
        "\s+(?:J|\|)\s+",
        " / "
    )

    value := RegExReplace(
        value,
        "\s+",
        " "
    )

    return Trim(value)
}


PatientV2_ResultText(result) {
    if !IsObject(result)
        return ""

    try {
        return PatientV2_CleanLine(
            result.Text
        )
    }

    return ""
}


PatientV2_NormalizeText(text) {
    text := StrReplace(
        text,
        Chr(160),
        " "
    )

    text := RegExReplace(
        text,
        "i)(?<=[0-9])[Il|](?=[0-9])",
        "1"
    )

    text := RegExReplace(
        text,
        "i)(?<=[0-9])O(?=[0-9])",
        "0"
    )

    text := StrReplace(
        text,
        "`r`n",
        " "
    )

    text := StrReplace(
        text,
        "`n",
        " "
    )

    text := StrReplace(
        text,
        "`r",
        " "
    )

    text := RegExReplace(
        text,
        "\s+",
        " "
    )

    return Trim(text)
}


PatientV2_CleanLine(text) {
    text := StrReplace(
        text,
        Chr(160),
        " "
    )

    text := Trim(
        text,
        " `t`r`n"
    )

    text := RegExReplace(
        text,
        "^[^A-Za-z0-9]+",
        ""
    )

    text := RegExReplace(
        text,
        "\s+",
        " "
    )

    return Trim(text)
}


PatientV2_Number(value) {
    return Number(
        StrReplace(
            Trim(value),
            ",",
            "."
        )
    )
}

; =================================================================================================
; PATIENT OCR V3 POST-PROCESSING
; Cleans the V2 results without replacing the existing V2 OCR code.
; =================================================================================================

PatientV3_PostProcess(parsed, bundle) {
    PatientV3_FillSex(parsed, bundle)

    if parsed.scr != ""
        && IsNumber(parsed.scr) {
        parsed.scr := Round(
            Number(parsed.scr),
            2
        )
    }

    if parsed.location != ""
        parsed.location :=
            PatientV3_CleanLocation(
                parsed.location
            )

    parsed.allergies :=
        PatientV3_CleanAllergies(
            parsed.allergies
        )

    parsed.medications :=
        PatientV3_CleanMedications(
            parsed.medications
        )

    return parsed
}


; -------------------------------------------------------------------------------------------------
; SEX FALLBACK
; -------------------------------------------------------------------------------------------------

PatientV3_FillSex(parsed, bundle) {
    if parsed.sex != ""
        return

    headerText := ""

    for key in [
        "headerLeft",
        "headerRight"
    ] {
        part := 0

        try part := bundle.%key%

        if !IsObject(part)
            continue

        headerText .= " "
            . PatientV2_ResultText(part)

        ; Try a high-resolution re-read of lines that may contain sex.
        for item in PatientV2_GetLines(part) {
            normalized :=
                PatientV2_NormalizeMatch(
                    item.text
                )

            if InStr(normalized, "sex")
                || InStr(normalized, "male")
                || InStr(normalized, "female") {

                refined :=
                    PatientV2_ReOcrLine(
                        item,
                        4.2,
                        110
                    )

                if refined != ""
                    headerText .= " " refined
            }
        }
    }

    headerText :=
        PatientV2_NormalizeText(
            headerText
        )

    ; Accept common OCR substitutions:
    ; Male, MaIe, Ma1e, Maie
    ; Female, FemaIe, Fema1e
    if RegExMatch(
        headerText,
        "i)\b(?:"
        . "Sex"
        . "|S[e3]x"
        . "|5ex"
        . ")\s*[:=-]?\s*"
        . "(Fema(?:le|[lI1]e|ie)"
        . "|Ma(?:le|[lI1]e|ie)"
        . "|F"
        . "|M)\b",
        &match
    ) {
        value := StrLower(match[1])

        parsed.sex := (
            SubStr(value, 1, 1) = "f"
        ) ? "Female" : "Male"

        return
    }

    ; Last fallback: look for the standalone word in the header only.
    if RegExMatch(
        headerText,
        "i)\bFema(?:le|[lI1]e|ie)\b"
    ) {
        parsed.sex := "Female"
        return
    }

    if RegExMatch(
        headerText,
        "i)\bMa(?:le|[lI1]e|ie)\b"
    ) {
        parsed.sex := "Male"
    }
}


; -------------------------------------------------------------------------------------------------
; LOCATION CLEANUP
; -------------------------------------------------------------------------------------------------

PatientV3_CleanLocation(value) {
    value :=
        PatientV2_CleanLocation(
            value
        )

    ; Example:
    ;   539-1P-MS-6N A614 1
    ; becomes:
    ;   539-1P-MS-6N / A614 1
    ;
    ; This applies only when the ending resembles a room/bed code.
    if !InStr(value, "/")
        && RegExMatch(
            value,
            "i)^(.+?-[A-Z0-9]+)\s+"
            . "([A-Z]\d{2,5}(?:\s+\d+)?)$",
            &match
        ) {

        value := match[1]
            . " / "
            . match[2]
    }

    value := RegExReplace(
        value,
        "\s+",
        " "
    )

    return Trim(value)
}


; -------------------------------------------------------------------------------------------------
; ALLERGY CLEANUP
; -------------------------------------------------------------------------------------------------

PatientV3_CleanAllergies(allergies) {
    output := []
    seen := Map()

    ; First pass:
    ; "No Known Allergies" overrides every other OCR fragment.
    for rawText in allergies {
        text := PatientV2_CleanLine(rawText)

        normalized := PatientV2_NormalizeMatch(
            text
        )

        if normalized = "noknownallergies"
            || normalized = "noknownallergy"
            || normalized = "nka"
            || InStr(normalized, "noknownallerg") {
            return []
        }
    }

    ; Second pass:
    ; Retain only genuine allergy names and stop at the next sidebar section.
    for rawText in allergies {
        text := PatientV2_CleanLine(rawText)

        if text = ""
            continue

        normalized := PatientV2_NormalizeMatch(
            text
        )

        ; Once OCR reaches another section, allergy collection is finished.
        if PatientV3_IsAllergySectionBoundary(normalized)
            break

        ; Skip instructional/status text.
        if normalized = "clickheretoaddanewallergy"
            || InStr(normalized, "clickheretoadd")
            || normalized = "allergies" {
            continue
        }

       ; Reject dose-pattern digits (a number attached to a unit) rather than
        ; all digits, so vaccine allergens like "pneumococcal 23-valent" survive.
        if RegExMatch(
            text,
            "i)\b\d+(?:[.,]\d+)?\s*"
            . "(?:mg|mcg|g|mL|units?|%|"
            . "tab(?:let)?s?|cap(?:sule)?s?|"
            . "appl|application|drops?|puffs?)\b"
        ) {
            continue
        }

        if RegExMatch(
            text,
            "i)\b(?:"
            . "mg"
            . "|mcg"
            . "|mL"
            . "|tab(?:s)?"
            . "|tablet"
            . "|capsule"
            . "|appl"
            . "|application"
            . "|injection"
            . "|solution"
            . "|oral"
            . "|intravenous"
            . ")\b"
        ) {
            continue
        }

        corrected := PatientV3_CorrectAllergyName(
            text
        )

        if corrected = ""
            continue

        key := PatientV2_NormalizeMatch(
            corrected
        )

        if key = "" || seen.Has(key)
            continue

        seen[key] := true
        output.Push(corrected)
    }

    return output
}


PatientV3_IsAllergySectionBoundary(normalizedText) {
    for prefix in [
        "medications",
        "medication",
        "problemsanddiagnoses",
        "problemsand",
        "problems",
        "diagnoses",
        "diagnosis",
        "rxclinicalnote",
        "rxinterventions",
        "reasonforvisit",
        "patientnote",
        "clinicalnote",
        "interventions",
        "readvy",
        "ready",
        "seal",
        "search"
    ] {
        if InStr(normalizedText, prefix) = 1
            return true
    }

    return false
}


PatientV3_IsSidebarLabel(normalizedText) {
    for prefix in [
        "medications",
        "medication",
        "problemsanddiagnoses",
        "problemsand",
        "rxclinicalnote",
        "rxinterventions",
        "reasonforvisit",
        "patientnote",
        "allergies"
    ] {
        if InStr(
            normalizedText,
            prefix
        ) = 1 {
            return true
        }
    }

    return false
}


PatientV3_CorrectAllergyName(text) {
    normalized :=
        PatientV2_NormalizeMatch(
            text
        )

    static aliases := Map(
        "amloolpine", "amlodipine",
        "amlodlpine", "amlodipine",
        "amlodipine", "amlodipine",

        "lisinopril", "lisinopril",

        "penicillinvpotassium", "penicillin V potassium",
        "penicillinpotassium", "penicillin V potassium",

        "chlorhexidinetopical", "chlorhexidine topical",
        "chlorhexidine", "chlorhexidine",

        "ampicillin", "ampicillin",

        "oupropion", "bupropion",
        "bupropion", "bupropion",

        "geevenom", "bee venom",
        "beevenom", "bee venom",

        "pregain", "pregabalin",
        "pregalin", "pregabalin",
        "pregabalin", "pregabalin",

        "iamatriqine", "lamotrigine",
        "lamatriqine", "lamotrigine",
        "lamotriqine", "lamotrigine",
        "lamotrigine", "lamotrigine"
    )

    if aliases.Has(normalized)
        return aliases[normalized]

    static knownAllergens := [
        "adhesive tape",
        "amlodipine",
        "amoxicillin",
        "ampicillin",
        "aspirin",
        "atorvastatin",
        "bee venom",
        "bupropion",
        "cefazolin",
        "cephalexin",
        "ceftriaxone",
        "chlorhexidine",
        "chlorhexidine topical",
        "codeine",
        "duloxetine",
        "gabapentin",
        "hydrocodone",
        "ibuprofen",
        "iodinated contrast media",
        "lamotrigine",
        "latex",
        "lisinopril",
        "losartan",
        "morphine",
        "naproxen",
        "oxycodone",
        "peanut",
        "penicillin",
        "penicillins",
        "penicillin V potassium",
        "piperacillin-tazobactam",
        "pregabalin",
        "shellfish",
        "sulfonamides",
        "sulfamethoxazole-trimethoprim",
        "tramadol",
        "tree nuts",
        "vancomycin"
    ]

    return PatientV2_ClosestTerm(
        text,
        knownAllergens,
        0.40
    )
}


; -------------------------------------------------------------------------------------------------
; MEDICATION CLEANUP
; -------------------------------------------------------------------------------------------------

PatientV3_CleanMedications(medications) {
    output := []
    seen := Map()

    if !IsObject(medications)
        return output

    for rawText in medications {
        ; Always initialize text before any RegExMatch or RegExReplace call.
        text := ""

        try {
            text := rawText ""
        } catch {
            continue
        }

        hadReviewMarker := InStr(text, "[VERIFY OCR]") > 0

        text := RegExReplace(
            text,
            "i)\s*\[VERIFY OCR\]\s*$",
            ""
        )

        text := Trim(text)

        if text = ""
            continue

        ; Remove headings and non-medication sidebar rows.
        if RegExMatch(
            text,
            "i)^(?:"
            . "Order\s+Profile(?:\s+as\s+of)?"
            . "|Nursing\s*\("
            . "|Medical\s*\("
            . "|Diagnoses\s*\("
            . "|Problems\s*\("
            . "|Rx\s+Clinical\s+Note"
            . "|Rx\s+Interventions"
            . ")"
        ) {
            continue
        }

        text := PatientV3_FixSigText(text)
        text := PatientV3_CorrectMedicationLine(text)
        text := PatientV3_ApplyMedicationContext(text)
        text := PatientV3_FixSigText(text)

        if text = ""
            continue

        if RegExMatch(
            text,
            "i)\bADM\s+Dispense\b"
        ) {
            continue
        }

        identity := PatientV3_MedicationIdentity(text)

        if identity = ""
            || seen.Has(identity) {
            continue
        }

        seen[identity] := true

        needsReview := hadReviewMarker || PatientV3_SigNeedsReview(text)

        try {
            if PatientV2_MedicationNeedsReview(text)
                needsReview := true
        }

        if needsReview && !InStr(text, "[VERIFY OCR]")
            text .= "  [VERIFY OCR]"

        output.Push(text)
    }

    return output
}

PatientV3_FixSigText(text) {
    text :=
        PatientV2_CleanLine(
            text
        )

    text := StrReplace(text, "ö", "o")
    text := StrReplace(text, "Ö", "O")

    ; Cerner's small-font medication column commonly turns the first glyph of
    ; duloxetine into OUL/OULoxetine. Correct only this known medication token;
    ; do not apply a broad first-letter substitution to arbitrary patient text.
    text := RegExReplace(text, "i)\bouloxetine\b", "duloxetine")
    text := RegExReplace(text, "i)\bou[lI1]oxetine\b", "duloxetine")
    text := RegExReplace(text, "i)\bdulo\s*xetine\b", "duloxetine")
    text := RegExReplace(text, "i)\bhydro\s*chl[oö]r[oö]thi[a-z0-9]*\b", "hydrochlorothiazide")
    text := RegExReplace(text, "i)(\d+(?:\.\d+)?)\s*m[qg]\s*(?=tablet|tab\b)", "$1 mg ")
    text := RegExReplace(text, "i)\bB[rv]\s+M[oö](?:u)?[lI1](?:i)?t[hH]\b", "BY MOUTH")

    ; Internal bullet/special-character OCR errors.
    text := StrReplace(
        text,
        "•odium",
        "sodium"
    )

    text := StrReplace(
        text,
        "·odium",
        "sodium"
    )

    ; Day-of-treatment phrases.
    text := RegExReplace(
        text,
        "i)\b(?:"
        . "OayofTx"
        . "|Oay\s*of\s*Tx"
        . "|DayofTx"
        . ")\b",
        "Day of Tx"
    )

    text := RegExReplace(
        text,
        "i)\bOay\b",
        "Day"
    )

    text := RegExReplace(
        text,
        "i)\bDayl\b",
        "Day 1"
    )

    ; Form and route words.
    text := RegExReplace(
        text,
        "i)\bTabletOral\b",
        "Tablet Oral"
    )

    text := RegExReplace(
        text,
        "i)\b(?:"
        . "PIqqvback"
        . "|Piqqyback"
        . "|Piqgyback"
        . "|Pigqvback"
        . ")\b",
        "Piggyback"
    )

    text := RegExReplace(
        text,
        "i)\bII\W{0,2}Piggyback\b",
        "IV Piggyback"
    )

    text := RegExReplace(
        text,
        "i)\bIV\W{1,2}Push\b",
        "IV Push"
    )

    text := RegExReplace(
        text,
        "i)\bIntrevenous\b",
        "Intravenous"
    )

    text := RegExReplace(
        text,
        "i)\bIntravenaus\b",
        "Intravenous"
    )

    text := RegExReplace(
        text,
        "i)\bIniection\b",
        "Injection"
    )

    ; Common frequency and indication errors.
    text := RegExReplace(
        text,
        "i)\bBIO\b",
        "BID"
    )

    text := RegExReplace(
        text,
        "i)\bTIO\b",
        "TID"
    )

    text := RegExReplace(
        text,
        "i)\bdrveves\b",
        "dry eyes"
    )

    text := RegExReplace(
        text,
        "i)\bdryeves\b",
        "dry eyes"
    )

    text := RegExReplace(
        text,
        "i)\bTue\W*Th[ui]\W*Sa\b",
        "Tue/Thu/Sat"
    )

    text := RegExReplace(
        text,
        "i)\b(?:"
        . "MonPNeiFr"
        . "|MonWeiFr"
        . "|MonWedFr"
        . ")\b",
        "Mon/Wed/Fri"
    )

    ; Infusion rate OCR.
    text := RegExReplace(
        text,
        "i)\bmL\W*[JIl]\s*hr\b",
        "mL/hr"
    )

    text := RegExReplace(
        text,
        "i)\bml\W*Jhr\b",
        "mL/hr"
    )

    ; Example:
    ;   10 mg 1 2 tab(s)
    ; becomes:
    ;   10 mg / 2 tab(s)
    text := RegExReplace(
        text,
        "i)(\b\d+(?:[.,]\d+)?\s*"
        . "(?:mg|mcg|g))"
        . "\s+[iIl1/|]\s*"
        . "(\d+\s*tab)",
        "$1 / $2"
    )

    ; A period is often OCR's thousands separator for units:
    ;   2.000 units -> 2,000 units
    ; It remains marked VERIFY OCR.
    text := RegExReplace(
        text,
        "i)\b(\d{1,3})\.(\d{3})"
        . "(?=\s*unit)",
        "$1,$2"
    )

    text := RegExReplace(
        text,
        "\s+",
        " "
    )

    return Trim(text)
}


PatientV3_CorrectMedicationLine(text) {
    if !RegExMatch(
        text,
        "i)^(.+?)"
        . "(?=\s+\d+(?:[.,]\d+)?\s*"
        . "(?:mcg|mg|g|mL|units?|%))",
        &match
    ) {
        return text
    }

    rawName := Trim(match[1])

    rest := SubStr(
        text,
        StrLen(match[1]) + 1
    )

    normalized :=
        PatientV2_NormalizeMatch(
            rawName
        )

    static aliases := Map(
        "acetaminophen", "acetaminophen",

        "ccsyntropin", "cosyntropin",
        "cosyntropin", "cosyntropin",

        "darbepoetinalfa", "darbepoetin alfa",

        "ertapenem", "ertapenem",
        "ertapenemsodiumchloride", "ertapenem + sodium chloride",

        "ferroussulfate", "ferrous sulfate",

        "refreshplus", "ocular lubricant",

        "heparin", "heparin",
        "heperin", "heparin",

        "methocarbamol", "methocarbamol",

        "midodrine", "midodrine",

        "lidocaine", "lidocaine",
        "docaine", "lidocaine",

        "ouloxetine", "duloxetine",
        "duloxetine", "duloxetine",

        "ocularlubricant", "ocular lubricant",

        "ondansetron", "ondansetron"
    )

    correctedName := ""
    correctedFromOcr := false
    resolvedByCurated := false

    if aliases.Has(normalized) {
        correctedName := aliases[normalized]
        correctedFromOcr := PatientV2_NormalizeMatch(correctedName) != normalized
        resolvedByCurated := true
    } else {
        for knownMedication in PatientV3_KnownMedications() {
            if RegExMatch(rawName, "i)^" RegExReplace(knownMedication, "[- /+]", "\W*") "(?:\b|\s*\+)") {
                correctedName := rawName
                resolvedByCurated := true
                break
            }
        }
        if !resolvedByCurated {
            correctedName :=
                PatientV2_ClosestTerm(
                    rawName,
                    PatientV3_KnownMedications(),
                    0.28
                )
            correctedFromOcr := PatientV2_NormalizeMatch(correctedName) != normalized
            for knownMedication in PatientV3_KnownMedications() {
                if PatientV2_NormalizeMatch(knownMedication) = PatientV2_NormalizeMatch(correctedName) {
                    resolvedByCurated := true
                    break
                }
            }
        }

        ; The curated OCR list is intentionally small. If it cannot resolve the
        ; name, use the larger Clinical Reasoning Database alias index with a
        ; conservative edit-distance gate. This turns OULoxetine into
        ; Duloxetine, but ambiguous near-matches remain untouched.
        if !resolvedByCurated {
            resolved := CRD5_ResolveMedicationName(rawName)
            if IsObject(resolved) {
                correctedName := resolved.rec["generic"]
                correctedFromOcr := resolved.distance > 0
            }
        }
    }

    correctedLine := PatientV2_CleanLine(
        correctedName
        . rest
    )

    if correctedFromOcr
        correctedLine .= "  [VERIFY OCR]"

    return correctedLine
}


PatientV3_ApplyMedicationContext(text) {
    ; Lidocaine is not an oral-tablet treatment for hypotension.
    ; In this exact context, the OCR/correction result is consistent with
    ; midodrine 10 mg tablets.
    if RegExMatch(
        text,
        "i)^lidocaine\b"
    )
        && RegExMatch(
            text,
            "i)\bTablet\s+Oral\b"
        )
        && RegExMatch(
            text,
            "i)\bhypotension\b"
        ) {

        text := RegExReplace(
            text,
            "i)^lidocaine\b",
            "midodrine"
        )
    }

    return text
}


PatientV3_KnownMedications() {
    static medications := [
        "acetaminophen",
        "albuterol",
        "albuterol-ipratropium",
        "allopurinol",
        "alteplase",
        "amlodipine",
        "aspirin",
        "atorvastatin",
        "bisacodyl",
        "chlorhexidine",
        "clopidogrel",
        "collagenase",
        "cosyntropin",
        "cyanocobalamin",
        "darbepoetin alfa",
        "diphenhydramine",
        "docusate",
        "duloxetine",
        "enoxaparin",
        "ertapenem",
        "ertapenem + sodium chloride",
        "escitalopram",
        "ezetimibe",
        "famotidine",
        "ferrous sulfate",
        "fluticasone",
        "furosemide",
        "gabapentin",
        "guaifenesin",
        "heparin",
        "hydrochlorothiazide",
        "hydrocodone-acetaminophen",
        "insulin aspart",
        "insulin glargine",
        "isosorbide mononitrate",
        "lidocaine",
        "lorazepam",
        "magnesium oxide",
        "meperidine",
        "metformin",
        "methocarbamol",
        "methylprednisolone",
        "metoprolol",
        "miconazole",
        "midodrine",
        "mirabegron",
        "multivitamin",
        "ocular lubricant",
        "ondansetron",
        "oxycodone",
        "pantoprazole",
        "piperacillin-tazobactam",
        "rituximab",
        "rosuvastatin",
        "sodium chloride",
        "spironolactone",
        "tamsulosin",
        "thiamine",
        "tuberculin purified protein derivative",
        "vancomycin"
    ]

    return medications
}


PatientV3_MedicationIdentity(text) {
    ; Remove display-only warning markers before comparison.
    text := RegExReplace(
        text,
        "i)\s*\[(?:VERIFY OCR|SIDEBAR ONLY[^\]]*)\]\s*$",
        ""
    )

    text := StrLower(
        PatientV2_CleanLine(text)
    )

    ; Remove date/time columns accidentally joined to the order sentence.
    text := RegExReplace(
        text,
        "\s+\d{2}/\d{2}/\d{4}\b.*$",
        ""
    )

    text := RegExReplace(
        text,
        "\s+\d{1,2}:\d{2}\b.*$",
        ""
    )

    ; Existing day-of-treatment normalization.
    text := StrReplace(
        text,
        "oay of tx",
        "day of tx"
    )

    text := StrReplace(
        text,
        "oayoftx",
        "day of tx"
    )

    ; Normalize OCR separator variants between a dose and quantity:
    ;
    ;   975 mg / 3 tab(s)
    ;   975 mg i/' 3 tab(s)
    ;   975 mg | 3 tab(s)
    ;
    ; All become the same identity.
    text := RegExReplace(
        text,
        "i)(\b\d+(?:[.,]\d+)?\s*"
        . "(?:mcg|mg|g|mL|units?|%))"
        . "\s*[iIl1jJ|/\\'´’]+\s*(?=\d)",
        "$1 / "
    )

    text := RegExReplace(
        text,
        "i)\btab\s*\(\s*s\s*\)",
        "tabs"
    )

    ; Final comparison key.
    text := RegExReplace(
        text,
        "[^a-z0-9]+",
        ""
    )

    return text
}


PatientV3_SigNeedsReview(text) {
    if InStr(text, "[VERIFY OCR]")
        return true

    ; Unrecognized OCR glyphs.
    if RegExMatch(
        text,
        "[æœ _]"
    ) {
        return true
    }

    ; Likely lost decimal:
    ;   0 3 mL
    ;   2 5 mg
    if RegExMatch(
        text,
        "\b\d+\s+\d+\s*"
        . "(?:mg|mcg|mL)\b"
    ) {
        return true
    }

    ; A value such as 1.250 mg may mean 1,250 mg.
    if RegExMatch(
        text,
        "\b\d+\.\d{3}\s*mg\b"
    ) {
        return true
    }

    ; Thousands separators still require visual verification.
    if RegExMatch(
        text,
        "\b\d{1,3},\d{3}\s*unit"
    ) {
        return true
    }

    ; Frequency digit read as a letter.
    if RegExMatch(
        text,
        "i)\bevery\s+[gq]\s*hr\b"
    ) {
        return true
    }

    ; Unresolved OCR fragments.
    if RegExMatch(
        text,
        "i)\b(?:"
        . "Oay"
        . "|PIqq"
        . "|Piqg"
        . "|drve"
        . ")\w*\b"
    ) {
        return true
    }

    ; Day list displayed with decimal-like periods.
    if RegExMatch(
        text,
        "i)\bDay\s+\d+"
        . "(?:\.\d+){2,}"
    ) {
        return true
    }

    return false
}

; =================================================================================================
; SHARED PATIENT CALCULATIONS
; Used by review display, BMI, vancomycin prefill, and RSI prefill.
; =================================================================================================

PatientCalc_ReadNumber(value) {
    text := ""

    try {
        text := Trim(value "")
    } catch {
        return ""
    }

    if text = ""
        return ""

    text := StrReplace(
        text,
        ",",
        "."
    )

    ; Extract a number even when the value contains units,
    ; such as "90.3 kg" or "1.00 mg/dL".
    if !RegExMatch(
        text,
        "(-?\d+(?:\.\d+)?)",
        &match
    ) {
        return ""
    }

    try {
        return Number(match[1])
    } catch {
        return ""
    }
}

PatientCalc_Compute(parsed) {
    result := {
        ok: false,
        crcl: "",
        weightKg: "",
        weightLabel: "",
        reason: ""
    }

    ; A captured candidate is not a calculator input until consensus/cross-check
    ; or an explicit user edit accepts it. Objects created directly by a
    ; calculator have no captureEvidence and continue to behave as before.
    for field in ["age", "sex", "heightCm", "weightKg", "scr"] {
        if CaptureV1_HasEvidence(parsed, field)
            && !CaptureV1_IsAccepted(parsed, field) {
            result.reason := "captured data needs confirmation"
            return result
        }
    }

    ageYears := PatientCalc_ReadNumber(
        parsed.HasOwnProp("age")
            ? parsed.age
            : ""
    )

    heightCm := PatientCalc_ReadNumber(
        parsed.HasOwnProp("heightCm")
            ? parsed.heightCm
            : ""
    )

    actualWeightKg := PatientCalc_ReadNumber(
        parsed.HasOwnProp("weightKg")
            ? parsed.weightKg
            : ""
    )

    scrMgDl := PatientCalc_ReadNumber(
        parsed.HasOwnProp("scr")
            ? parsed.scr
            : ""
    )

; Preserve the accepted SCr exactly; corrections belong in source review.
    sexRaw := ""

    if parsed.HasOwnProp("sex")
        sexRaw := parsed.sex

    sexText := RegExReplace(
        StrLower(Trim(sexRaw "")),
        "[^a-z]",
        ""
    )

    if ageYears = ""
        || heightCm = ""
        || actualWeightKg = ""
        || scrMgDl = "" {

        result.reason := "missing data"
        return result
    }

    if ageYears <= 0
        || ageYears >= 140
        || heightCm < 100
        || heightCm > 250
        || actualWeightKg < 20
        || actualWeightKg > 400
        || scrMgDl <= 0
        || scrMgDl > 25 {

        result.reason := "value outside expected range"
        return result
    }

    if sexText = "female"
        || sexText = "f" {

        isFemale := true
        parsed.sex := "Female"

    } else if sexText = "male"
        || sexText = "m" {

        isFemale := false
        parsed.sex := "Male"

    } else {
        result.reason := "sex not recognized"
        return result
    }

    heightMeters := heightCm / 100

    bmi := actualWeightKg
        / (
            heightMeters
            * heightMeters
        )

    heightInches := heightCm / 2.54

    inchesOverFiveFeet := Max(
        0,
        heightInches - 60
    )

    ibwBase := isFemale
        ? 45.5
        : 50

    ibwKg := ibwBase
        + (
            2.3
            * inchesOverFiveFeet
        )

    adjbwKg := ibwKg
        + (
            0.4
            * (
                actualWeightKg
                - ibwKg
            )
        )


	if actualWeightKg < ibwKg {
	selectedWeightKg := actualWeightKg
	selectedWeightLabel := "Actual body weight"
	} else if actualWeightKg >= (1.3 * ibwKg) {
	selectedWeightKg := adjbwKg
	selectedWeightLabel := "Adjusted body weight"
	} else {
	selectedWeightKg := ibwKg
	selectedWeightLabel := "Ideal body weight"
}
	



    ageFactor := 140.0 - ageYears

    if ageFactor <= 0
        || selectedWeightKg <= 0 {

        result.reason := "invalid calculation input"
        return result
    }

    ; Keep this expression on one line.
    crclValue := ageFactor * selectedWeightKg / (72.0 * scrMgDl)

    if isFemale
        crclValue *= 0.85

    if crclValue <= 0
        || crclValue > 500 {

        result.reason := "invalid result"
        return result
    }

    parsed.scr := Round(scrMgDl, 2)
    parsed.bmi := Round(bmi, 1)
    parsed.ibwKg := Round(ibwKg, 1)
    parsed.adjbwKg := Round(adjbwKg, 1)

    parsed.crclWeightKg := Round(
        selectedWeightKg,
        1
    )

    parsed.crclWeightLabel :=
        selectedWeightLabel

    parsed.crcl := Round(
        crclValue,
        1
    )

    result.ok := true
    result.crcl := parsed.crcl
    result.weightKg := parsed.crclWeightKg
    result.weightLabel := selectedWeightLabel

    return result
}


PatientCalc_Enrich(parsed) {
    ; Clear stale results first.
    parsed.bmi := ""
    parsed.ibwKg := ""
    parsed.adjbwKg := ""
    parsed.crclWeightKg := ""
    parsed.crclWeightLabel := ""
    parsed.crcl := ""

    PatientCalc_Compute(parsed)

    return parsed
}


PatientCalc_CrClDisplay(parsed) {
    calculation := PatientCalc_Compute(parsed)

    if !calculation.ok {
        return "Not calculated - "
            . calculation.reason
    }

    return Format(
        "{:.1f} mL/min using {} ({:.1f} kg)",
        calculation.crcl,
        calculation.weightLabel,
        calculation.weightKg
    )
}

; PATIENT OCR V4 FINALIZATION
; Adds row-based medication recovery and sidebar fallback.
; =================================================================================================

PatientV4_Finalize(parsed, bundle) {
    parsed := PatientV3_PostProcess(
        parsed,
        bundle
    )

    ; Final clinical values are rebuilt from evidence-anchored rows. Broad OCR
    ; guesses are discarded here so unlabeled numbers never reach a calculator.
    PatientV6_ApplyEvidenceAnchoredValues(
        parsed,
        bundle
    )

    parsed.medications :=
        PatientV4_BuildMedicationList(
            parsed.medications,
            bundle
        )

    parsed.medications :=
        PatientV6_GroundMedicationList(
            parsed.medications,
            parsed
        )

    ; Recover allergy rows from semantic section anchors when the sidebar is
    ; absent or rendered in a different panel. Preserve existing values and
    ; let the normal allergy cleaner remove headings/non-drug noise.
    anchoredAllergies := []
    for partName in ["sidebar", "orders"] {
        try part := bundle.%partName%
        catch
            part := 0
        if IsObject(part) {
            for allergy in PatientV11_ExtractAnchoredAllergies(part)
                anchoredAllergies.Push(allergy)
        }
    }
    for allergy in anchoredAllergies
        parsed.allergies.Push(allergy)
    parsed.allergies := PatientV3_CleanAllergies(parsed.allergies)

    ; Clear calculations that may have used incorrect OCR values.
    for key in [
        "bmi",
        "ibwKg",
        "adjbwKg",
        "crclWeightKg",
        "crclWeightLabel",
        "crcl"
    ] {
        if parsed.HasOwnProp(key)
            parsed.%key% := ""
    }

    PatientCalc_Enrich(parsed)

    return parsed
}



PatientV4_BuildMedicationList(
    existingMedications,
    bundle
) {
    candidates := []

    if IsObject(existingMedications) {
        for medication in existingMedications
            candidates.Push(medication)
    }

    ordersResult := 0

    try ordersResult := bundle.orders

    if IsObject(ordersResult) {
        for medication in PatientV4_ExtractOrderRows(
            ordersResult
        ) {
            candidates.Push(medication)
        }

        ; When a profile is rendered as a section rather than a clean order
        ; table, recover rows by heading boundaries instead of assuming fixed
        ; Cerner columns. The existing order parser still wins when both paths
        ; see the same medication.
        for medication in PatientV11_ExtractAnchoredMedicationRows(ordersResult)
            candidates.Push(medication)
    }

    try sidebarResult := bundle.sidebar
    catch
        sidebarResult := 0
    if IsObject(sidebarResult) {
        for medication in PatientV11_ExtractAnchoredMedicationRows(sidebarResult)
            candidates.Push(medication)
    }

    cleaned := PatientV3_CleanMedications(
        candidates
    )

    output := []
    seen := Map()

    for medication in cleaned {
        text := Trim(medication)

        if text = ""
            continue

        ; Never treat sidebar headings as medications.
        if RegExMatch(
            text,
            "i)^(?:"
            . "Nursing\s*\("
            . "|Medical\s*\("
            . "|Diagnoses\s*\("
            . "|Problems\s*\("
            . "|Order\s+Profile"
            . "|Rx\s+Clinical\s+Note"
            . "|Rx\s+Interventions"
            . "|Patient\s+Note"
            . "|Reason\s+for\s+Visit"
            . ")"
        ) {
            continue
        }

        if InStr(
            text,
            "[SIDEBAR ONLY"
        ) {
            continue
        }

        identity :=
            PatientV7_MedicationIdentity(
                text
            )

        if identity = ""
            || seen.Has(identity) {
            continue
        }

        seen[identity] := true
        output.Push(text)
    }

    return output
}

PatientV7_MedicationIdentity(text) {
    text := RegExReplace(
        text,
        "i)\s*\[(?:"
        . "VERIFY OCR"
        . "|SIDEBAR ONLY[^\]]*"
        . ")\]\s*$",
        ""
    )

    text := StrLower(
        PatientV2_CleanLine(text)
    )

    ; Remove appended dates and times.
    text := RegExReplace(
        text,
        "\s+\d{2}/\d{2}/\d{4}\b.*$",
        ""
    )

    text := RegExReplace(
        text,
        "\s+\d{1,2}:\d{2}\b.*$",
        ""
    )

    ; Normalize OCR artifacts between the dose and tablet quantity.
    ; Examples:
    ;   975 mg / 3 tab(s)
    ;   975 mg j 3 tab(s)
    ;   975 mg i/' 3 tab(s)
    text := RegExReplace(
        text,
        "i)(\b\d+(?:[.,]\d+)?\s*"
        . "(?:mcg|mg|g|mL|units?|%))"
        . "\s*[iIl1jJ|/\\'´’]*\s*"
        . "(?=\d+\s*(?:tab|cap|mL|vial|amp))",
        "$1 "
    )

    text := RegExReplace(
        text,
        "i)\btab\s*\(\s*s\s*\)",
        "tabs"
    )

    text := RegExReplace(
        text,
        "\s+",
        " "
    )

    return RegExReplace(
        text,
        "[^a-z0-9]+",
        ""
    )
}

; =================================================================================================
; PATIENT OCR V11 — ANCHOR-BASED SECTION RECOVERY
; Headings are semantic anchors; coordinates are used only to preserve row
; order. This is a fallback for profile layouts that do not expose stable
; order-sentence columns.
; =================================================================================================
PatientV11_AnchorAliases(field) {
    switch field {
        case "medications":
            return ["current medications", "current medication", "active medications", "active medication", "medication list", "medication profile", "medications"]
        case "allergies":
            return ["allergies", "drug allergies", "known allergies", "allergies/adverse reactions"]
        case "vitals":
            return ["vitals", "vital signs", "current vital signs"]
        case "diagnoses":
            return ["diagnoses", "problems and diagnoses", "active problems", "problem list"]
        default:
            return []
    }
}

PatientV11_NormalizeAnchor(text) {
    text := StrLower(PatientV2_CleanLine(text))
    text := StrReplace(text, ":", "")
    text := RegExReplace(text, "[^a-z0-9 ]", " ")
    return Trim(RegExReplace(text, "\s+", " "))
}

PatientV11_IsAnchorLine(text, field) {
    normalized := PatientV11_NormalizeAnchor(text)
    if normalized = ""
        return false
    ; Cerner commonly appends a count or an asterisk to sidebar headings,
    ; e.g. "Allergies [2]" and "Problems and Diagnoses[*]".  The count is
    ; metadata, not part of the semantic section name.
    normalized := RegExReplace(normalized, "\s+(?:\d+|star|asterisk)$", "")
    for alias in PatientV11_AnchorAliases(field) {
        a := PatientV11_NormalizeAnchor(alias)
        if normalized = a
            return true
    }
    return false
}

PatientV11_IsAnySectionHeading(text) {
    for field in ["medications", "allergies", "vitals", "diagnoses"] {
        if PatientV11_IsAnchorLine(text, field)
            return true
    }
    return RegExMatch(text, "i)^(?:Problems|Patient Notes?|Reason for Visit|Orders?|Interventions?)\b")
}

PatientV11_ExtractAnchoredMedicationRows(ocrResult) {
    output := []
    if !IsObject(ocrResult)
        return output

    lines := PatientV2_GetLines(ocrResult)
    collecting := false
    for item in lines {
        text := PatientV2_CleanLine(item.text)
        if !collecting {
            if PatientV11_IsAnchorLine(text, "medications")
                collecting := true
            continue
        }
        if PatientV11_IsAnySectionHeading(text)
            break
        normalized := PatientV2_NormalizeOrder(text)
        if normalized = "" || !PatientV2_LooksLikeMedication(normalized)
            continue
        ; Keep discontinued rows in the capture.  RxN_Normalize classifies
        ; them as inactive so Med Rec can show the complete profile while
        ; active-order comparisons still exclude them safely.
        output.Push(normalized)
    }
    return output
}

PatientV11_ExtractAnchoredAllergies(ocrResult) {
    output := []
    if !IsObject(ocrResult)
        return output
    lines := PatientV2_GetLines(ocrResult)
    collecting := false
    for item in lines {
        text := PatientV2_CleanLine(item.text)
        if !collecting {
            if PatientV11_IsAnchorLine(text, "allergies")
                collecting := true
            continue
        }
        if PatientV11_IsAnySectionHeading(text)
            break
        if Patient_IsAllergyCandidate(text)
            output.Push(text)
    }
    return output
}

PatientV11_ExtractAnchoredBloodPressure(ocrResult) {
    result := {systolic: "", diastolic: "", unit: "mmHg", raw: "", confidence: "none"}
    if !IsObject(ocrResult)
        return result
    lines := PatientV2_GetLines(ocrResult)
    inVitals := false
    for item in lines {
        text := PatientV2_CleanLine(item.text)
        if PatientV11_IsAnchorLine(text, "vitals") {
            inVitals := true
            continue
        }
        if inVitals && PatientV11_IsAnySectionHeading(text)
            break
        if !inVitals && !RegExMatch(text, "i)\b(?:blood\s+pressure|current\s+bp|\bbp\b)")
            continue
        if RegExMatch(text, "i)\b(?:blood\s+pressure|current\s+bp|\bbp\b)\D{0,30}(\d{2,3})\s*/\s*(\d{2,3})\b", &m)
            || RegExMatch(text, "^\s*(\d{2,3})\s*/\s*(\d{2,3})\s*(?:mm\s*hg)?\s*$", &m) {
            sys := Number(m[1]), dia := Number(m[2])
            if sys >= 50 && sys <= 300 && dia >= 20 && dia <= 200 {
                result.systolic := sys
                result.diastolic := dia
                result.raw := text
                result.confidence := "high"
                return result
            }
        }
    }
    return result
}

PatientV4_ExtractOrderRows(ocrResult, enableFocusedReOcr := true) {
    output := []

    lines := PatientV2_GetLines(
        ocrResult
    )

    if lines.Length = 0
        return output

    bounds := PatientV4_GetOrderBounds(
        lines
    )

    rows := PatientV4_GroupRows(
        lines,
        bounds.headerY
    )

    for row in rows {
        rowItems :=
            PatientV4_SortByX(
                row.items
            )

        entireRowText := ""
        orderText := ""

        for item in rowItems {
            piece :=
                PatientV2_CleanLine(
                    item.text
                )

            if piece = ""
                continue

            entireRowText .= (
                entireRowText = ""
                ? ""
                : " "
            ) piece

            ; Include any OCR fragment that overlaps the
            ; order-sentence column.
            if item.x + item.w >= bounds.left
                && item.x <= bounds.right {

                orderText .= (
                    orderText = ""
                    ? ""
                    : " "
                ) piece
            }
        }

        ; Do not discard discontinued rows here.  Their status is clinically
        ; useful for reconciliation and is normalized downstream.

        orderText :=
            PatientV2_NormalizeOrder(
                orderText
            )

        ; Re-OCR only the order-sentence area for this row.
        ; A small row crop can be enlarged much more than
        ; the complete application window.
        if enableFocusedReOcr {
            rowCrop := PatientV2_TryOcrRect(
                bounds.left - 5,
                row.y - 4,
                bounds.right - bounds.left + 10,
                row.h + 8,
                4.0,
                false
            )

            refinedText :=
                PatientV2_NormalizeOrder(
                    PatientV2_ResultText(
                        rowCrop
                    )
                )

            orderText :=
                PatientV2_BestText(
                    orderText,
                    refinedText
                )
        }

        if PatientV4_IsOrderNoise(
            orderText
        ) {
            continue
        }

        if !RegExMatch(
            orderText,
            "[A-Za-z]{3}"
        ) {
            continue
        }

        if !RegExMatch(
            orderText,
            "\d"
        ) {
            continue
        }

        ; Reuse all existing V3 medication corrections.
        correctedRows :=
            PatientV3_CleanMedications(
                [orderText]
            )

        rowStatus := PatientV12_OrderStatus(entireRowText)
        for corrected in correctedRows {
            ; Active is the safe default and does not need to alter identity.
            ; Preserve non-active/pending status found in a separate Cerner
            ; column so Med Rec does not silently treat it as an active order.
            if rowStatus != "" && StrLower(rowStatus) != "active"
                corrected .= " " rowStatus
            corrected := PatientV13_AppendMedicationRowMetadata(corrected, entireRowText)
            output.Push(corrected)
        }
    }

    return output
}

PatientV13_AppendMedicationRowMetadata(orderText, rowText) {
    result := orderText
    rowText := PatientV2_CleanLine(rowText)

    ; Ambulatory Profile tail: Last Fill, days supply, and refills. These are
    ; evidence attributes only and never change medication identity or status.
    if RegExMatch(rowText, "i)(\d{2}/\d{2}/\d{4})\s+(\d{1,3})\s+(\d{1,2})\s*$", &am) {
        result := PatientV13_AddMetadataTag(result, "LASTFILL", am[1])
        result := PatientV13_AddMetadataTag(result, "DS", am[2])
        result := PatientV13_AddMetadataTag(result, "RR", am[3])
        return result
    }

    ; Acute Profile tail: one or two Start/Stop timestamps followed by the
    ; Cerner order type. Keep the visible values for source review.
    dates := []
    pos := 1
    while pos := RegExMatch(rowText, "i)(\d{2}/\d{2}/\d{4}(?:\s+\d{1,2}:\d{2}(?:\s+[A-Z]{2,4})?)?)", &dm, pos) {
        dates.Push(Trim(dm[1]))
        pos := dm.Pos + dm.Len
    }
    if dates.Length > 0
        result := PatientV13_AddMetadataTag(result, "START", dates[1])
    if dates.Length > 1
        result := PatientV13_AddMetadataTag(result, "STOP", dates[2])
    if RegExMatch(rowText, "i)\b(MED|INT|CONT|PROTOCOL)\s*$", &tm)
        result := PatientV13_AddMetadataTag(result, "ORDERTYPE", StrUpper(tm[1]))
    return result
}

PatientV13_AddMetadataTag(text, key, value) {
    if value = "" || InStr(text, "[" key "=")
        return text
    return RTrim(text) " [" key "=" value "]"
}


PatientV12_OrderStatus(rowText) {
    for status in [
        "Pending Verify", "Discontinued", "Held", "Administered",
        "Expired", "Suspended", "Completed", "On File", "Active"
    ] {
        if RegExMatch(rowText, "i)\b" RegExReplace(status, " ", "\s+") "\b")
            return status
    }
    return ""
}


PatientV4_GetOrderBounds(lines) {
    minX := lines[1].x
    maxRight := lines[1].x + lines[1].w
    minY := lines[1].y

    orderX := ""
    startX := ""
    headerY := minY

    for item in lines {
        minX := Min(
            minX,
            item.x
        )

        maxRight := Max(
            maxRight,
            item.x + item.w
        )

        minY := Min(
            minY,
            item.y
        )

        text :=
            PatientV2_CleanLine(
                item.text
            )

        ; Use exact, isolated headings when OCR provides them.
        if RegExMatch(
            text,
            "i)^Order\s+Sentence$"
        ) {
            orderX := item.x
            headerY := item.y
        }

        if RegExMatch(
            text,
            "i)^Start$"
        ) {
            startX := item.x
            headerY := Max(
                headerY,
                item.y
            )
        }
    }

    span := maxRight - minX

    ; A crop containing only the Order Sentence column has no Start header.
    ; Do not invent a 23%/80% column split in that case: it truncates drug
    ; names and long SIGs. Use the complete captured row width.
    orderOnly := orderX != "" && startX = ""
    if orderX = ""
        orderX := minX + (PatientV4_IsOrderOnlyGrid(lines) ? 0 : Round(span * 0.23))

    if startX = ""
        startX := PatientV4_IsOrderOnlyGrid(lines) ? maxRight + 1 : minX + Round(span * 0.80)

    if startX <= orderX
        startX := maxRight

    return {
        left: orderX,
        right: startX - 5,
        headerY: headerY
    }
}

PatientV4_IsOrderOnlyGrid(lines) {
    hits := 0
    hasStartStop := false
    for item in lines {
        text := StrLower(PatientV2_CleanLine(item.text))
        if RegExMatch(text, "i)^(?:start|stop|order\s+type)$")
            hasStartStop := true
        if RegExMatch(text, "i)\b(?:mg|mcg|tablet|capsule|injection|solution|oral|intravenous|piggyback)\b")
            hits += 1
    }
    return hits >= 3 && !hasStartStop
}


PatientV4_GroupRows(lines, headerY) {
    rows := []

    for item in lines {
        if item.y <= headerY + 3
            continue

        assigned := false

        for row in rows {
            tolerance := Max(
                4,
                Round(
                    Max(
                        row.h,
                        item.h
                    ) * 0.45
                )
            )

            if Abs(item.y - row.y)
                <= tolerance {

                row.items.Push(item)

                row.y := (
                    row.y + item.y
                ) / 2

                row.h := Max(
                    row.h,
                    item.h
                )

                assigned := true
                break
            }
        }

        if !assigned {
            rows.Push({
                y: item.y,
                h: item.h,
                items: [item]
            })
        }
    }

    return rows
}


PatientV4_SortByX(items) {
    output := []

    for item in items {
        inserted := false

        for index, existing in output {
            if item.x < existing.x {
                output.InsertAt(
                    index,
                    item
                )

                inserted := true
                break
            }
        }

        if !inserted
            output.Push(item)
    }

    return output
}


PatientV4_IsOrderNoise(text) {
    if text = ""
        return true

    if RegExMatch(
        text,
        "i)^(?:"
        . "Action"
        . "|Status"
        . "|Order\s+Sentence"
        . "|Start"
        . "|Stop"
        . "|Order\s+Type"
        . "|Drug:"
        . "|Active$"
        . "|Verify$"
        . "|Discontinued$"
        . "|Submit$"
        . "|Cancel$"
        . "|Apply$"
        . ")\b"
    ) {
        return true
    }

    if RegExMatch(
        text,
        "^\d{2}/\d{2}/\d{4}"
    ) {
        return true
    }

    return false
}



PatientV4_MedicationNameKey(text) {
    text := RegExReplace(
        text,
        "i)\s*\[(?:"
        . "VERIFY OCR"
        . "|SIDEBAR ONLY.*"
        . ")\]\s*$",
        ""
    )

    name := ""

    if RegExMatch(
        text,
        "i)^(.+?)"
        . "(?=\s+\d+(?:[.,]\d+)?\s*"
        . "(?:mcg|mg|g|mL|units?|%))",
        &match
    ) {
        name := match[1]
    } else {
        name := text
    }

    return PatientV2_NormalizeMatch(
        name
    )
}

; =================================================================================================
; PATIENT OCR V6 — EVIDENCE-ANCHORED CAPTURE
; Rebuilds clinical values from recognizable labels and trailing units. Missing
; evidence stays missing; ambiguous OCR never becomes a calculator input.
; =================================================================================================

PatientV6_SexLabelCore() {
    return "(?<![A-Za-z0-9])(?:(?:Legal|Administrative|Birth|Biological)\s+)?"
        . "(?:S\s*[e3]\s*[x×]|S\s*[o0]\s*x|5\s*[e3]\s*x|G\s*[e3]\s*n\s*d\s*[e3a]\s*r)"
        . "(?!\s*(?:Identity|Orientation))\b"
}

PatientV6_HeightLabelCore() {
    return "(?<![A-Za-z0-9])(?:H\s*[e3]\s*[i1lI]\s*[gq9]\s*[hln]\s*t|Ht)"
        . "(?:\s*(?:/|-)?\s*(?:L\s*[e3]\s*n\s*[gq9]\s*t\s*[hln]|Len(?:gth)?))?\b"
}

PatientV6_SexValueCore() {
    return "F(?:e|3)(?:m|rn)a(?:le|[lI1]e|ie)|Ma(?:le|[lI1]e|ie)"
}

PatientV6_ParseSexValues(variants, allowStandaloneWords := false) {
    values := []
    seen := Map()
    labelCore := PatientV6_SexLabelCore()
    valueCore := PatientV6_SexValueCore()

    for text in variants {
        clean := PatientV2_NormalizeText(text)
        value := ""
        if RegExMatch(clean,
            "i)" labelCore ".{0,30}?(" valueCore "|F|M)\b", &match) {
            value := SubStr(StrLower(match[1]), 1, 1) = "f" ? "Female" : "Male"
        } else if allowStandaloneWords
            && RegExMatch(clean, "i)(?:^|\s)(" valueCore ")(?:\s|$)", &match) {
            value := SubStr(StrLower(match[1]), 1, 1) = "f" ? "Female" : "Male"
        }
        if value != "" && !seen.Has(value) {
            seen[value] := true
            values.Push(value)
        }
    }
    return values
}

PatientV6_AddHeightCandidate(output, seen, value) {
    if value = "" || !IsNumber(value)
        return
    v := Number(value)
    if v < 100 || v > 250
        return
    key := Format("{:.1f}", v)
    if seen.Has(key)
        return
    seen[key] := true
    output.Push(Round(v, 1))
}

PatientV6_HeightCandidates(variants) {
    output := []
    seen := Map()
    labelCore := PatientV6_HeightLabelCore()
    numberCore := "\d{1,3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?"

    for text in variants {
        clean := PatientV2_NormalizeText(text)

        if RegExMatch(clean,
            "i)" labelCore ".{0,45}?(\d)\s*(?:'|ft\.?|feet)\s*[- ]*(\d{1,2})\s*(?:\x22|in\.?|inches?|inch)?\b",
            &match) {
            feet := Number(match[1]), inches := Number(match[2])
            if feet >= 4 && feet <= 7 && inches >= 0 && inches <= 11
                PatientV6_AddHeightCandidate(output, seen, ((feet * 12) + inches) * 2.54)
            continue
        }

        if RegExMatch(clean,
            "i)" labelCore ".{0,45}?(" numberCore ")\s*(?:c\s*[mni]|c\s*r\s*n|e\s*m)\b",
            &match) {
            PatientV6_AddHeightCandidate(output, seen, PatientV5_ParseNumberToken(match[1]))
            continue
        }

        if RegExMatch(clean,
            "i)" labelCore ".{0,45}?([12](?:(?:\s*[.,]\s*|\s+)\d{1,2}))\s*(?:m|meters?|metres?)\b",
            &match) {
            meters := PatientV5_ParseNumberToken(match[1])
            if meters != ""
                PatientV6_AddHeightCandidate(output, seen, meters * 100)
            continue
        }

        if RegExMatch(clean,
            "i)" labelCore ".{0,45}?(\d{2}(?:[.,]\d+)?)\s*(?:\x22|in\.?|inches?|inch)\b",
            &match) {
            inches := PatientV5_ParseNumberToken(match[1])
            if inches != ""
                PatientV6_AddHeightCandidate(output, seen, inches * 2.54)
            continue
        }

        ; Unitless values remain allowed only on an explicitly labeled height row.
        if RegExMatch(clean,
            "i)" labelCore ".{0,32}?(\d{3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)\b",
            &match) {
            PatientV6_AddHeightCandidate(output, seen, PatientV5_ParseNumberToken(match[1]))
        }
    }
    return output
}

PatientV6_SelectHeightValue(candidates, parsed) {
    if candidates.Length = 0
        return ""
    if candidates.Length = 1
        return candidates[1]

    low := Number(candidates[1]), high := Number(candidates[1])
    for value in candidates {
        low := Min(low, Number(value))
        high := Max(high, Number(value))
    }
    if high - low <= 1
        return candidates[1]

    PatientV6_AddWarning(parsed, "Conflicting Height values were excluded from this capture.")
    return ""
}

PatientV6_ApplyEvidenceAnchoredValues(parsed, bundle) {
    parsed.age := ""
    parsed.dob := ""
    parsed.sex := ""
    parsed.heightCm := ""
    parsed.weightKg := ""
    parsed.scr := ""
    parsed.captureWarnings := []

    parsed.captureEvidence := Map()

    ageObs := CaptureV1_RowObservations(bundle, "i)\bAge\b")
    ageRes := CaptureV1_Resolve(
        CaptureV1_Tally(ageObs, "i)\bAge\b.{0,24}?(\d{1,3})\s*(?:y(?:ears?)?|yrs?)?\b", 0, 120),
        "Age"
    )
    if ageRes.value != ""
        ageRes.value := Round(ageRes.value)
    CaptureV1_Record(parsed, "age", ageRes, "yr")

    dobObs := CaptureV1_RowObservations(bundle, "i)\b(?:Date\s+of\s+Birth|DOB|Birth\s+Date)\b")
    dobRes := CaptureV1_ResolveDate(
        dobObs,
        "i)\b(?:Date\s+of\s+Birth|DOB|Birth\s+Date)\b\s*[:=-]?\s*(\d{1,2})\s*[/.-]\s*(\d{1,2})\s*[/.-]\s*(\d{2,4})\b",
        "Date of birth"
    )
    if dobRes.value != "" && RegExMatch(dobRes.value, "^(\d{1,2})[/.-](\d{1,2})[/.-](\d{2,4})$", &dobMatch) {
        year := Number(dobMatch[3])
        if year < 100
            year += year >= 30 ? 1900 : 2000
        if year >= 1900 && year <= Integer(SubStr(A_YYYY, 1, 4))
            dobRes.value := Format("{:02}/{:02}/{:04}", Number(dobMatch[1]), Number(dobMatch[2]), year)
        else
            dobRes := {value: "", status: "needs_confirmation", accepted: false, detail: "DOB year outside plausible range"}
    }
    CaptureV1_Record(parsed, "dob", dobRes, "")

    sexObs := CaptureV1_RowObservations(bundle, "i)\b(?:Sex|Gender)\b")
    ; A full Male/Female word in the dedicated header is usable even when the
    ; short Sex label is lost. Standalone M/F remains intentionally excluded.
    if sexObs.Length = 0 {
        for headerText in PatientV6_HeaderTexts(bundle)
            sexObs.Push({text: headerText, source: "header/fallback"})
    }
    CaptureV1_Record(parsed, "sex", CaptureV1_ResolveText(
        sexObs, "i)\b(Female|Male)\b", "Sex"), "")

    heightObs := CaptureV1_RowObservations(bundle, "i)" PatientV6_HeightLabelCore())
    heightRes := CaptureV1_Resolve(
        CaptureV1_MergeNear(
            CaptureV1_TallyWithParser(heightObs, PatientV6_HeightCandidates, 100, 250),
            1.0
        ),
        "Height"
    )
    if heightRes.value != ""
        heightRes.value := Round(heightRes.value, 1)
    CaptureV1_Record(parsed, "heightCm", heightRes, "cm")

    dosingLabel := "(?:Weight|Weigh[tIl1]|Wt)\s*(?:D[o0]s[i1l]ng|O[o0]e[i1l]ng|O[o0]s[i1l]ng)"
    weightObs := CaptureV1_RowObservations(bundle, "i)\b" dosingLabel "\b")
    weightTally := CaptureV1_DecimalGuard(CaptureV1_Tally(
        weightObs,
        "i)\b" dosingLabel "\b.{0,40}?(\d{2,3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)\s*k\s*[gq9]\b",
        20,
        400
    ))
    if weightTally.Length = 0 {
        otherWeightLabel := "(?:(?:Actual|Current|Admission|Body)\s+)?(?:Weight|Wt)"
        weightObs := CaptureV1_RowObservations(bundle, "i)^" otherWeightLabel "\b")
        weightTally := CaptureV1_DecimalGuard(CaptureV1_Tally(
            weightObs,
            "i)\b" otherWeightLabel "\b.{0,40}?(\d{2,3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)\s*k\s*[gq9]\b",
            20,
            400
        ))
    }
    weightRes := CaptureV1_Resolve(weightTally, "Weight")
    if weightRes.value != ""
        weightRes.value := Round(weightRes.value, 1)
    CaptureV1_Record(parsed, "weightKg", weightRes, "kg")

    scrLabel := "(?:S[\s-]*Cr|Serum\s+Creatinine|Creat\s*[i1l]\s*n\s*[i1l]\s*ne(?:\s+(?:Level|Lvl))?)"
    scrObs := CaptureV1_RowObservations(bundle, "i)^" scrLabel "\b")
    scrRes := CaptureV1_Resolve(CaptureV1_DecimalGuard(CaptureV1_Tally(
        scrObs,
        "i)\b" scrLabel "\b.{0,42}?(\d{1,2}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)\s*m\s*[gq9]\s*[/\\|]?\s*d\s*[l1iI]\b",
        0.1,
        25
    )), "Serum creatinine")
    if scrRes.value != ""
        scrRes.value := Round(scrRes.value, 2)
    ; High SCr values are clinically plausible, so never decimal-correct them.
    ; Without a displayed renal anchor they remain visible for confirmation.
    if scrRes.status = "accepted" && scrRes.value > 3 {
        scrRes.status := "needs_confirmation"
        scrRes.accepted := false
        scrRes.detail .= "; high value requires renal cross-check or user confirmation"
    }
    CaptureV1_Record(parsed, "scr", scrRes, "mg/dL")

    ; Sidebar summary rows are explicitly labeled and may not include a
    ; specimen-style unit. Send them through the established accepted-lab
    ; channel so session merge preserves their provenance and safety checks.
    if !parsed.HasOwnProp("gridLabs") || !IsObject(parsed.gridLabs)
        parsed.gridLabs := []
    for lab in PatientV6_ExtractSidebarSummaryLabs(bundle) {
        parsed.gridLabs.Push(lab)
    }

    CaptureV1_RecordAnchor(parsed, bundle, "reportedCrCl", "i)\bCr\s*Cl(?:\s*\(\s*est\.?\s*\))?\b",
        "i)\bCr\s*Cl(?:\s*\(\s*est\.?\s*\))?\b.{0,36}?(\d{1,3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)(?:\s*m\s*[lI1]\s*(?:[/\\|]|\s*)\s*m\s*[i1l]n\b|\s*m[o0]r?n[i1l]n\b)?", 1, 250, "mL/min")
    CaptureV1_RecordAnchor(parsed, bundle, "reportedBsa", "i)^\s*[BR8]SA\b",
        "i)\b[BR8]SA\b.{0,30}?(\d(?:[.,]\d{1,2})?)\s*m", 0.5, 4, "m2")
    CaptureV1_RecordAnchor(parsed, bundle, "reportedIbw", "i)^\s*IBW\b",
        "i)\bIBW\b.{0,30}?(\d{2,3}(?:[.,]\d+)?)\s*k\s*[gq9]\b", 20, 200, "kg")
    CaptureV1_RecordAnchor(parsed, bundle, "reportedEgfr", "i)\beGFR(?:\s+CKD\s+EPI)?\b",
        "i)\beGFR(?:\s+CKD\s+EPI)?\b.{0,35}?(\d{1,3}(?:[.,]\d+)?)\b", 1, 200, "mL/min/1.73m2")

    CaptureV1_AssessConsistency(parsed)
    CaptureV1_ApplyAccepted(parsed)
    CaptureV1_AddActionWarnings(parsed)

    return parsed
}

PatientV6_ExtractSidebarSummaryLabs(bundle) {
    output := []
    sidebar := 0
    try sidebar := bundle.sidebar
    if !IsObject(sidebar)
        return output

    for line in PatientV2_GetLines(sidebar) {
        text := PatientV2_NormalizeText(line.text)
        key := ""
        unit := ""
        pattern := ""
        if RegExMatch(text, "i)^\s*Glucose\s*(?:Lvl|Level|Result)?\s*[:=-]?\s*([<>]?\s*\d+(?:[.,]\d+)?)\s*(?:mg\s*/\s*dL|mgdL)\b", &match)
            key := "glucose", unit := "mg/dL", value := PCtx_NormalizeNumericToken(match[1])
        else if RegExMatch(text, "i)^\s*INR\s*[:=-]?\s*([<>]?\s*\d+(?:[.,]\d+)?)\b", &match)
            key := "inr", unit := "", value := PCtx_NormalizeNumericToken(match[1])
        else if RegExMatch(text, "i)^\s*e\s*GFR(?:\s+CKD\s*[- ]?\s*EPI)?\s*[:=-]?\s*([<>]?\s*\d+(?:[.,]\d+)?)\b", &match)
            key := "egfr", unit := "mL/min/1.73", value := PCtx_NormalizeNumericToken(match[1])
        else
            continue

        if value = "" || !IsNumber(value)
            continue
        if !PCtx_ValidateLabValue(key, value)
            continue
        output.Push({
            key: key,
            value: value,
            unit: unit,
            when: "",
            source: "labeled patient sidebar summary",
            raw: text,
            accepted: true,
            status: "accepted",
            sourceCount: 1,
            conf: "high"
        })
    }
    return output
}

PatientV6_CollectLabeledRowVariants(bundle, labelPattern) {
    variants := []
    seen := Map()

    for key in ["headerLeft", "headerRight", "sidebar"] {
        part := 0
        try part := bundle.%key%
        if !IsObject(part)
            continue

        for text in PatientV5_GetSidebarRowVariants(part, labelPattern) {
            clean := PatientV2_CleanLine(text)
            if clean = "" || seen.Has(clean)
                continue
            seen[clean] := true
            variants.Push(clean)
        }
    }

    return variants
}

PatientV6_HeaderTexts(bundle) {
    output := []
    seen := Map()
    for key in ["headerLeft", "headerRight"] {
        part := 0
        try part := bundle.%key%
        if !IsObject(part)
            continue
        text := PatientV2_CleanLine(PatientV2_ResultText(part))
        if text != "" && !seen.Has(text) {
            seen[text] := true
            output.Push(text)
        }
        for item in PatientV2_GetLines(part) {
            line := PatientV2_CleanLine(item.text)
            if line != "" && !seen.Has(line) {
                seen[line] := true
                output.Push(line)
            }
        }
    }
    return output
}

PatientV6_CollectDemographicVariants(bundle, labelCore, includeHeaderText := false) {
    variants := []
    seen := Map()
    labelPattern := "i)" labelCore

    for text in PatientV6_CollectLabeledRowVariants(bundle, labelPattern) {
        clean := PatientV2_CleanLine(text)
        if clean != "" && !seen.Has(clean) {
            seen[clean] := true
            variants.Push(clean)
        }
    }

    for key in ["headerLeft", "headerRight", "sidebar"] {
        part := 0
        try part := bundle.%key%
        if !IsObject(part)
            continue

        fullText := PatientV2_CleanLine(PatientV2_ResultText(part))
        if (includeHeaderText || key = "sidebar") && RegExMatch(fullText, labelPattern)
            && !seen.Has(fullText) {
            seen[fullText] := true
            variants.Push(fullText)
        }

        lines := PatientV2_GetLines(part)
        for labelItem in lines {
            labelText := PatientV2_CleanLine(labelItem.text)
            if !RegExMatch(labelText, labelPattern)
                continue

            ; Cerner can render the label above its value. Pair only nearby
            ; fragments in the same demographic column; the parser still
            ; requires an accepted sex token or physiologic height unit/range.
            for item in lines {
                if item.y <= labelItem.y
                    continue
                verticalGap := item.y - labelItem.y
                if verticalGap > Max(65, labelItem.h * 3.2)
                    continue
                if item.x < labelItem.x - 28 || item.x > labelItem.x + Max(360, labelItem.w + 300)
                    continue
                combined := labelText " " PatientV2_CleanLine(item.text)
                if combined != "" && !seen.Has(combined) {
                    seen[combined] := true
                    variants.Push(combined)
                }
            }
        }
    }
    return variants
}

PatientV6_UniqueValue(candidates, parsed, label) {
    if candidates.Length = 1
        return candidates[1]
    if candidates.Length > 1
        PatientV6_AddWarning(parsed, "Conflicting " label " values were excluded from this capture.")
    return ""
}

PatientV6_StandaloneKgCandidates(bundle) {
    output := []
    seenValues := Map()
    seenLines := Map()

    for key in ["headerLeft", "headerRight", "sidebar"] {
        part := 0
        try part := bundle.%key%
        if !IsObject(part)
            continue

        for item in PatientV2_GetLines(part) {
            text := PatientV2_CleanLine(item.text)
            if text = "" || seenLines.Has(text)
                continue
            seenLines[text] := true

            if RegExMatch(text, "i)\b(?:mg|mcg|g|mL|units?)\s*/\s*kg\b")
                continue
            if RegExMatch(text, "i)\b(?:BMI|BSA|IBW|ideal\s+body|adjusted\s+body|dose|dosage|infusion|tablet|capsule|injection)\b")
                continue

            pos := 1
            while (pos := RegExMatch(text, "i)(\d{2,3}(?:[.,]\d{1,2})?)\s*k\s*[gq9]\b", &match, pos)) {
                value := PatientV2_Number(match[1])
                pos := match.Pos + match.Len
                if value < 20 || value > 400
                    continue
                keyValue := Format("{:.2f}", value)
                if !seenValues.Has(keyValue) {
                    seenValues[keyValue] := true
                    output.Push(value)
                }
            }
        }
    }

    return output
}



PatientV6_AddWarning(parsed, message) {
    if !parsed.HasOwnProp("captureWarnings") || !IsObject(parsed.captureWarnings)
        parsed.captureWarnings := []
    for existing in parsed.captureWarnings {
        if existing = message
            return
    }
    parsed.captureWarnings.Push(message)
    ParsingDiagnostics_Log("parser_warning", Map(
        "component", "patient_capture",
        "warningCode", ParsingDiagnostics_WarningCode(message),
        "warnings", parsed.captureWarnings.Length,
        "detail", "review_required"
    ))
}

; =================================================================================================
; PATIENT OCR V5 — LABELED SIDEBAR OVERRIDES
; Prevents unrelated numbers elsewhere on the screen from replacing the patient's
; Height/Length, Weight Dosing, or Creatinine Level values.
; =================================================================================================

PatientV5_OverrideSidebarValues(parsed, bundle) {
    sidebar := 0

    try sidebar := bundle.sidebar

    if !IsObject(sidebar)
        return parsed

    ; -------------------------------------------------------------------------
    ; HEIGHT/LENGTH
    ; -------------------------------------------------------------------------
    heightVariants :=
        PatientV5_GetSidebarRowVariants(
            sidebar,
            "i)\bHeight\s*/?\s*Length\b"
        )

    heightCandidates :=
        PatientV5_NumberCandidates(
            heightVariants,
            "i)\bHeight\s*/?\s*Length\b"
            . ".{0,50}?"
            . "(\d{2,3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)"
            . "\s*(?:c\s*m|cm|em)?\b",
            100,
            250
        )

    if heightCandidates.Length
        parsed.heightCm := Round(
            heightCandidates[1],
            1
        )

    ; -------------------------------------------------------------------------
    ; BSA — used only to select among conflicting weight OCR readings.
    ; -------------------------------------------------------------------------
    bsaVariants :=
        PatientV5_GetSidebarRowVariants(
            sidebar,
            "i)^BSA\b(?!\s*Method)"
        )

    bsaCandidates :=
        PatientV5_NumberCandidates(
            bsaVariants,
            "i)^BSA\b"
            . ".{0,40}?"
            . "(\d(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)"
            . "\s*m",
            0.5,
            4
        )

    displayedBsa := bsaCandidates.Length
        ? bsaCandidates[1]
        : ""

    ; -------------------------------------------------------------------------
    ; WEIGHT DOSING
    ; This specifically reads the labeled row. It does not search the medication
    ; table or the rest of the flattened OCR text.
    ; -------------------------------------------------------------------------
    weightVariants :=
        PatientV5_GetSidebarRowVariants(
            sidebar,
            "i)\bWeight\s*D[o0]s[i1l]ng\b"
        )

    weightCandidates :=
        PatientV5_NumberCandidates(
            weightVariants,
            "i)\bWeight\s*D[o0]s[i1l]ng\b"
            . ".{0,50}?"
            . "(\d{2,3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)"
            . "\s*k\s*[gq9]\b",
            20,
            400
        )

    if weightCandidates.Length {
        selectedWeight :=
            PatientV5_SelectWeight(
                weightCandidates,
                parsed.heightCm,
                displayedBsa
            )

        if selectedWeight != ""
            parsed.weightKg := Round(
                selectedWeight,
                1
            )
    }

    ; -------------------------------------------------------------------------
    ; DISPLAYED CPRS CRCL
    ; Used only to distinguish an obvious decimal OCR error such as 11 versus 1.1.
    ; -------------------------------------------------------------------------
    crclVariants :=
        PatientV5_GetSidebarRowVariants(
            sidebar,
            "i)\bCrCl\s*\(?est"
        )

    crclCandidates :=
        PatientV5_NumberCandidates(
            crclVariants,
            "i)\bCrCl\s*\(?est\.?\)?"
            . ".{0,40}?"
            . "(\d{1,3}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)"
            . "\s*mL\s*/?\s*min",
            1,
            250
        )

    displayedCrCl := crclCandidates.Length
        ? crclCandidates[1]
        : ""

    ; -------------------------------------------------------------------------
    ; CREATININE LEVEL
    ; -------------------------------------------------------------------------
    scrVariants :=
        PatientV5_GetSidebarRowVariants(
            sidebar,
            "i)\bCreat[i1l]n[i1l]ne\s*(?:Level|Lvl)?\b"
        )

    scrCandidates :=
        PatientV5_NumberCandidates(
            scrVariants,
            "i)\bCreat[i1l]n[i1l]ne\s*(?:Level|Lvl)?\b"
            . ".{0,50}?"
            . "(\d{1,2}(?:(?:\s*[.,]\s*|\s+)\d{1,2})?)"
            . "\s*m\s*[gq9]"
            . "\s*[/\\|]?\s*d\s*[l1iI]\b",
            0.1,
            25
        )

    if scrCandidates.Length {
        selectedScr :=
            PatientV5_SelectScr(
                scrCandidates,
                parsed,
                displayedCrCl
            )

        if selectedScr != ""
            parsed.scr := Round(
                selectedScr,
                2
            )
    }

    ; "No Known Allergies" is a status, not one allergy.
    if parsed.HasOwnProp("allergies")
        && parsed.allergies.Length = 1 {

        allergyText :=
            PatientV2_NormalizeMatch(
                parsed.allergies[1]
            )

        if allergyText = "noknownallergies"
            || allergyText = "nka" {
            parsed.allergies := []
        }
    }

    return parsed
}


PatientV5_GetSidebarRowVariants(
    sidebarResult,
    labelPattern
) {
    variants := []
    lines := PatientV2_GetLines(
        sidebarResult
    )

    if lines.Length = 0
        return variants

    minX := lines[1].x
    maxRight := lines[1].x + lines[1].w

    for line in lines {
        minX := Min(
            minX,
            line.x
        )

        maxRight := Max(
            maxRight,
            line.x + line.w
        )
    }

    for labelItem in lines {
        labelText :=
            PatientV2_CleanLine(
                labelItem.text
            )

        if !RegExMatch(
            labelText,
            labelPattern
        ) {
            continue
        }

        rowItems := []
        tolerance := Max(
            7,
            Round(labelItem.h * 0.9)
        )

        for item in lines {
            if Abs(item.y - labelItem.y)
                <= tolerance {
                rowItems.Push(item)
            }
        }

        rowItems :=
            PatientV4_SortByX(
                rowItems
            )

        rowText := ""

        for item in rowItems {
            piece :=
                PatientV2_CleanLine(
                    item.text
                )

            if piece = ""
                continue

            rowText .= (
                rowText = ""
                ? ""
                : " "
            ) piece
        }

        if rowText != ""
            variants.Push(rowText)

        cropY := Max(
            0,
            labelItem.y - 5
        )

        cropH := labelItem.h + 12
        cropW := maxRight - minX + 15

        ; The row text above is already part of the high-resolution sidebar
        ; batch. Re-OCRing every labeled row (normal + grayscale) was both a
        ; major latency multiplier and a source of conflicting nearby values.
        ; Only run the focused fallback when the row itself was not readable.
        if rowText = "" {
            normalResult := PatientV2_TryOcrRect(
                minX,
                cropY,
                cropW,
                cropH,
                4.5,
                false
            )

            normalText := PatientV2_ResultText(normalResult)
            if normalText != ""
                variants.Push(normalText)

            if normalText = "" {
                grayResult := PatientV2_TryOcrRect(
                    minX,
                    cropY,
                    cropW,
                    cropH,
                    4.5,
                    true
                )

                grayText := PatientV2_ResultText(grayResult)
                if grayText != ""
                    variants.Push(grayText)
            }
        }

        break
    }

    return variants
}


PatientV5_NumberCandidates(
    variants,
    pattern,
    minimum,
    maximum
) {
    output := []
    seen := Map()

    for text in variants {
        normalized :=
            PatientV2_NormalizeText(
                text
            )

        if !RegExMatch(
            normalized,
            pattern,
            &match
        ) {
            continue
        }

        value :=
            PatientV5_ParseNumberToken(
                match[1]
            )

        if value = ""
            || value < minimum
            || value > maximum {
            continue
        }

        key := Format(
            "{:.4f}",
            value
        )

        if seen.Has(key)
            continue

        seen[key] := true
        output.Push(value)
    }

    return output
}


PatientV5_ParseNumberToken(token) {
    token := Trim(token)

    if token = ""
        return ""

    token := StrReplace(
        token,
        ",",
        "."
    )

    ; Preserve explicit decimal punctuation.
    if InStr(token, ".") {
        token := StrReplace(
            token,
            " ",
            ""
        )

        return IsNumber(token)
            ? Number(token)
            : ""
    }

    ; OCR may render 79.1 as "79 1" or 1.1 as "1 1".
    if RegExMatch(
        token,
        "^(\d{1,3})\s+(\d{1,2})$",
        &match
    ) {
        valueText := match[1]
            . "."
            . match[2]

        return IsNumber(valueText)
            ? Number(valueText)
            : ""
    }

    token := StrReplace(
        token,
        " ",
        ""
    )

    return IsNumber(token)
        ? Number(token)
        : ""
}


PatientV5_SelectWeight(
    candidates,
    heightCm,
    displayedBsa
) {
    if candidates.Length = 0
        return ""

    ; If BSA and height are visible, use the Mosteller relationship only as a
    ; tie-breaker among OCR candidates:
    ;     BSA = sqrt(height(cm) × weight(kg) / 3600)
    if IsNumber(heightCm)
        && Number(heightCm) > 0
        && IsNumber(displayedBsa)
        && Number(displayedBsa) > 0 {

        expectedWeight := (
            Number(displayedBsa)
            * Number(displayedBsa)
            * 3600
        ) / Number(heightCm)

        bestValue := candidates[1]
        bestDifference := Abs(
            bestValue - expectedWeight
        )

        for value in candidates {
            difference := Abs(
                value - expectedWeight
            )

            if difference < bestDifference {
                bestDifference := difference
                bestValue := value
            }
        }

        return bestValue
    }

    return candidates[1]
}


PatientV5_SelectScr(
    candidates,
    parsed,
    displayedCrCl
) {
    if candidates.Length = 0
        return ""

    haveDemographics := parsed.HasOwnProp("age") && parsed.HasOwnProp("sex")
        && parsed.HasOwnProp("weightKg") && IsNumber(parsed.age)
        && IsNumber(parsed.weightKg) && Number(parsed.age) > 0
        && Number(parsed.weightKg) > 0

    ; If we can't reconcile against a displayed CrCl but we DO have demographics,
    ; still reject an SCr whose implied CrCl is physiologically implausible when a
    ; decimal-shifted alternative lands in a normal range. Guards against 0.8 -> 8.0.
    if (!IsNumber(displayedCrCl) || Number(displayedCrCl) <= 0) {
        if !haveDemographics
            return candidates[1]

        first := candidates[1]
        firstCrCl := PatientV5_ImpliedCrCl(first, parsed)
        ; Plausible SCr-implied CrCl window; outside this, try a /10 or x10 shift.
        if firstCrCl >= 5 && firstCrCl <= 200
            return first
        for shift in [first/10, first*10] {
            if shift < 0.1 || shift > 25
                continue
            shiftCrCl := PatientV5_ImpliedCrCl(shift, parsed)
            if shiftCrCl >= 5 && shiftCrCl <= 200
                return shift
        }
        return first
    }

    if !haveDemographics
        return candidates[1]

    testCandidates := []

    for value in candidates {
        testCandidates.Push(value)

        ; OCR loses or misplaces the decimal point in both directions:
        ;   real 6.0 read as "60"  (value 60  -> test 6.0)
        ;   real 0.6 read as "6"   (value 6   -> test 0.6)
        ; So we test BOTH a /10 and a x10 alternative for every candidate and
        ; let the displayed CPRS CrCl decide which is physiologic. Bounds keep
        ; SCr in a plausible assay range (0.1-25 mg/dL).
        shiftedDown := value / 10
        if shiftedDown >= 0.1
            testCandidates.Push(shiftedDown)

        shiftedUp := value * 10
        if shiftedUp <= 25
            testCandidates.Push(shiftedUp)
    }

    bestValue := candidates[1]
    bestRelativeError := 1000000

    for value in testCandidates {
        if value <= 0
            continue

        calculatedCrCl := (
            (
                140 - Number(parsed.age)
            )
            * Number(parsed.weightKg)
        ) / (
            72 * value
        )

        if parsed.sex = "Female"
            calculatedCrCl *= 0.85

        relativeError := Abs(
            calculatedCrCl
            - Number(displayedCrCl)
        ) / Number(displayedCrCl)

        if relativeError < bestRelativeError {
            bestRelativeError := relativeError
            bestValue := value
        }
    }

    ; Only use the CrCl-supported correction when the values agree reasonably.
    if bestRelativeError <= 0.35
        return bestValue

    return candidates[1]
}

PatientV5_ImpliedCrCl(scr, parsed) {
    if !IsNumber(scr) || scr <= 0
        return 0
    crcl := ((140 - Number(parsed.age)) * Number(parsed.weightKg)) / (72 * scr)
    if parsed.sex = "Female"
        crcl *= 0.85
    return crcl
}

; ---- Other Links and Osmolarity reordering ----

Manage_Other_Move(direction) {
    global _otherListView
    links := LoadOtherLinks()
    row   := _otherListView.GetNext(0, "Focused")
    if row = 0
        return
    j := row + direction
    if j < 1 or j > links.Length
        return
    tmp := links[row], links[row] := links[j], links[j] := tmp
    SaveOtherLinks(links)
    RefreshManageLinksGui()
    _otherListView.Modify(j, "Select Focus")
}

Manage_OsmoLib_Move(direction) {
    global _osmoLibListView
    lib := LoadOsmolarityLibrary()
    row := _osmoLibListView.GetNext(0, "Focused")
    if row = 0
        return
    j := row + direction
    if j < 1 or j > lib.Length
        return
    tmp := lib[row], lib[row] := lib[j], lib[j] := tmp
    SaveOsmolarityLibrary(lib)
    RefreshManageLinksGui()
    _osmoLibListView.Modify(j, "Select Focus")
}



; =================================================================================================
;  EMBEDDED OCR LIBRARY (Descolada OCR.ahk) FOR BMI OCR TOOL
; =================================================================================================

/**
 * OCR library: a wrapper for the the UWP Windows.Media.Ocr library.
 * Based on the UWP OCR function for AHK v1 by malcev.
 * 
 * Ways of initiating OCR:
 * OCR(RandomAccessStreamOrSoftwareBitmap, Options?)
 * OCR.FromDesktop(Options?)
 * OCR.FromMonitor(Monitor?, Options?)
 * OCR.FromRect(X, Y, W, H, Options?)
 * OCR.FromWindow(WinTitle:="", Options?, WinText:="", ExcludeTitle:="", ExcludeText:="")
 *      Note: the result object coordinates will be in CoordMode "Pixel"
 * OCR.FromFile(FileName, Options?)
 * OCR.FromBitmap(bitmap, Options?, hDC?)
 * OCR.FromPDF(FileName, Options?, Start:=1, End?, Password:="") => returns an array of results for each PDF page
 * OCR.FromPDFPage(FileName, page, Options?)
 *   Helper functions for PDF OCR:
 *      OCR.GetPdfPageCount(FileName, Password:="")
 *      OCR.GetPdfPageProperties(FileName, Page, Password:="")
 * 
 * Options can be an object containing none or all of these elements:
 * {
 *      lang: OCR language. Default is first from available languages. This can also be a function which evaluates to a language string.
 *      scale: a Float scale factor to zoom the image in or out, which might improve detection. 
 *             The resulting coordinates will be adjusted to scale. Default is 1.
 *      grayscale: Boolean 0 | 1 whether to convert the image to black-and-white. Default is 0.
 *      monochrome: 0-255, converts all pixels with luminosity less than the threshold to black, otherwise to white. Default is 0 (no conversion).
 *      invertcolors: Boolean 0 | 1, whether to invert the colors of the image. Default is 0.
 *      rotate: 0 | 90 | 180 | 270, can be used to rotate the image clock-wise by degrees. Default is 0.
 *      flip: 0 | "x" | "y", can be used to flip the image on the x- or y-axis. Default is 0.
 *      x, y, w, h: can be used to crop the image. This is applied before scaling. Default is no cropping.
 *      decoder: gif | ico | jpeg | jpegxr | png | tiff | bmp. Optional bitmap codec name to decode RandomAccessStream. Default is automatic detection. 
 * }
 * 
 * Note: Options also accepts any optional parameters after it like named parameters.
 * Eg. OCR.FromMonitor({lang:"en-us", monitor:2})
 * 
 * Additional methods:
 * OCR.GetAvailableLanguages()
 * OCR.LoadLanguage(lang:="FirstFromAvailableLanguages")
 * OCR.WaitText(needle, timeout:=-1, func?, casesense:=False, comparefunc?)
 *      Calls a func (the provided OCR method) until a string is found
 * OCR.WordsBoundingRect(words*)
 *      Returns the bounding rectangle for multiple words
 * OCR.ClearAllHighlights()
 *      Removes all highlights created by Result.Highlight
 * OCR.Cluster(objs, eps_x:=-1, eps_y:=-1, minPts:=1, compareFunc?, &noise?)
 *      Clusters objects (by default based on distance from eachother). Can be used to create more
 *      accurate "Line" results.
 * OCR.SortArray(arr, optionsOrCallback:="N", key?)
 *      Sorts an array in-place, optionally by object keys or using a callback function.
 * OCR.ReverseArray(arr)
 *      Reverses an array in-place.
 * OCR.UniqueArray(arr)
 *      Returns an array with unique values.
 * OCR.FlattenArray(arr)
 *      Returns a one-dimensional array from a multi-dimensional array
 * 
 * Properties:
 * OCR.MaxImageDimension
 * MinImageDimension is not documented, but appears to be 40 pixels (source: user FanaticGuru in AutoHotkey forums)
 * OCR.PerformanceMode
 *      Increases speed of OCR acquisition by about 20-50ms if set to 1, but also increases CPU usage. Default is 0.
 * OCR.DisplayImage
 *      If set to True then the captured image is displayed on the screen before proceeding to OCR-ing the image.
 * 
 * OCR returns an OCR.Result object:
 * Result.Text         => All recognized text
 * Result.TextAngle    => Clockwise rotation of the recognized text 
 * Result.Lines        => Array of all OCR.Line objects
 * Result.Words        => Array of all OCR.Word objects
 * Result.ImageWidth   => Used image width
 * Result.ImageHeight  => Used image height
 * 
 * Result.FindString(Needle, Options?)
 *      Finds a string in the result. Possible options (see descriptions at the function definition): 
 *      {CaseSense: False, IgnoreLinebreaks: False, AllowOverlap: false, i: 1, x, y, w, h, SearchFunc}
 * Result.FindStrings(Needle, Options?)
 *      Finds all strings in the result. 
 * Result.Filter(callback)
 *      Returns a filtered result object that contains only words that satisfy the callback function
 * Result.Crop(x1, y1, x2, y2)
 *      Crops the result object to contain only results from an area defined by points (x1,y1) and (x2,y2). 
 * 
 * OCR.Line object:
 * Line.Text         => Recognized text of the line
 * Line.Words        => Array of Word objects for the Line
 * Line.x,y,w,h      => Size and location of the Line. 
 * 
 * OCR.Word object:
 * Word.Text         => Recognized text of the word
 * Word.x,y,w,h      => Size and location of the Word. 
 * Word.BoundingRect => Bounding rectangle of the Word in format {x,y,w,h}. 
 * 
 * OCR.Result, OCR.Line, and OCR.Word also all have some common methods:
 * 
 * Result.Click(WhichButton?, ClickCount?, DownOrUp?)
 *      Clicks an object (Word, FindString result etc)
 * Result.ControlClick(WinTitle?, WinText?, WhichButton?, ClickCount?, Options?, ExcludeTitle?, ExcludeText?)
 *      ControlClicks an object (Word, FindString result etc)
 * Result.Highlight(showTime?, color:="Red", d:=2)
 *      Highlights a Word, Line, or object with {x,y,w,h} properties on the screen (default: 2 seconds), or removes the highlighting
 * 
 * Additional notes:
 * Languages are recognized in BCP-47 language tags. Eg. OCR.FromFile("myfile.bmp", {lang: "en-AU"})
 * Languages can be installed for example with PowerShell (run as admin): Install-Language <language-tag>
 *      or from Language settings in Settings.
 * Not all language packs support OCR though. A list of supported language can be gotten from 
 * Powershell (run as admin) with the following command: Get-WindowsCapability -Online | Where-Object { $_.Name -Like 'Language.OCR*' } 
 */



; =================================================================================================
; BATCH 1 — AMINOGLYCOSIDE DOSING + INFECTIOUS DISEASE / ANTIBIOTIC SELECTION  (added 2026-07-19)
; -------------------------------------------------------------------------------------------------
; Decision-support only. Empiric guidance reflects common inpatient practice and must be verified
; against the local antibiogram, stewardship protocol, current guidelines, and patient specifics
; (allergies, renal function, cultures, source control). Not a substitute for ID consultation.
; =================================================================================================

; ---- shared weight helpers ---------------------------------------------------------------------
AG_Ibw(isFemale, htCm) {
    over := Max(htCm / 2.54 - 60, 0)
    return (isFemale ? 45.5 : 50) + 2.3 * over
}

AG_DosingWeight(actual, ibw) {
    ; obesity -> adjusted BW (0.4 factor); underweight -> actual; otherwise IBW
    if actual > 1.2 * ibw
        return { wt: ibw + 0.4 * (actual - ibw), label: "AdjBW" }
    if actual < ibw
        return { wt: actual, label: "actual (underweight)" }
    return { wt: ibw, label: "IBW" }
}

AG_RoundTo(value, multiple) {
    if multiple <= 0
        return Round(value)
    return Round(value / multiple) * multiple
}

; Hartford/extended-interval nomogram interval from CrCl.
AG_ExtInterval(crcl) {
    if crcl >= 60
        return "q24h"
    if crcl >= 40
        return "q36h"
    if crcl >= 20
        return "q48h"
    return "level-guided (CrCl <20 is off-nomogram)"
}

; ---- aminoglycoside plan ------------------------------------------------------------------------
; drug: "gentamicin" | "tobramycin" | "amikacin".  indication: "extended" | "traditional" | "synergy"
AG_BuildPlan(drug, isFemale, htCm, actualWt, scr, age, indication) {
    ibw := AG_Ibw(isFemale, htCm)
    dw := AG_DosingWeight(actualWt, ibw)
    crcl := ((140 - age) * dw.wt) / (72 * scr)
    if isFemale
        crcl *= 0.85

    out := "AMINOGLYCOSIDE PLAN — " StrTitle(drug) "`r`n"
    out .= "IBW " Round(ibw, 1) " kg | dosing weight " Round(dw.wt, 1) " kg (" dw.label ") | CrCl " Round(crcl, 1) " mL/min`r`n`r`n"

    isAmikacin := InStr(drug, "amikacin")

    if indication = "synergy" {
        ; gram-positive synergy (e.g., endocarditis) — low dose, traditional targets
        dose := isAmikacin ? "" : AG_RoundTo(1 * dw.wt, 10)
        if isAmikacin
            return out . "Amikacin is not used for gram-positive synergy. Choose gentamicin.`r`n"
        out .= "Synergy (gram-positive, e.g., endocarditis):`r`n"
        out .= "  " dose " mg IV q8h (~1 mg/kg). Target peak 3-4, trough <1 mcg/mL.`r`n"
        out .= "  Verify indication; nephrotoxicity accrues — shortest effective course.`r`n"
        return out
    }

    if indication = "traditional" {
        loadPerKg := isAmikacin ? 7.5 : 2
        maintPerKg := isAmikacin ? 7.5 : 1.7
        load := AG_RoundTo(loadPerKg * dw.wt, isAmikacin ? 50 : 10)
        maint := AG_RoundTo(maintPerKg * dw.wt, isAmikacin ? 50 : 10)
        out .= "Traditional (conventional) dosing:`r`n"
        out .= "  Load " load " mg IV once (" loadPerKg " mg/kg), then " maint " mg IV q8h (adjust by levels).`r`n"
        if isAmikacin
            out .= "  Targets: peak 20-30, trough <5-8 mcg/mL (serious infection).`r`n"
        else
            out .= "  Targets: peak 6-10, trough <2 mcg/mL (serious gram-negative).`r`n"
        out .= "  Draw peak 30 min after end of infusion, trough within 30 min before next dose.`r`n"
        return out
    }

    ; extended-interval (default)
    perKg := isAmikacin ? 15 : 7
    dose := AG_RoundTo(perKg * dw.wt, isAmikacin ? 50 : 10)
    interval := AG_ExtInterval(crcl)
    out .= "Extended-interval (once-daily) dosing:`r`n"
    out .= "  " dose " mg IV " interval " (" perKg " mg/kg on " Round(dw.wt, 1) " kg).`r`n"
    if isAmikacin
        out .= "  Amikacin extended-interval; verify local nomogram and draw a random level per protocol.`r`n"
    else
        out .= "  Draw a random level 6-14 h after the dose and plot on the Hartford nomogram to set the interval.`r`n"
    out .= "  Avoid extended-interval in pregnancy, ascites, major burns, endocarditis, or CrCl <20 — use traditional/level-guided.`r`n"
    return out
}


; =================================================================================================
; INFECTIOUS DISEASE / ANTIBIOTIC SELECTION
; =================================================================================================
; A curated empiric-therapy reference indexed by syndrome, with penicillin-allergy alternatives and
; a de-escalation prompt. Content is intentionally conservative and generic; the pharmacist tailors
; to the local antibiogram, severity, source control, and cultures.

ID_Syndromes() {
    ; Each entry: display name -> { empiric, pcnAllergy, mrsa, pseudomonas, notes, deescalation }
    m := Map()

    m["CAP — non-severe (ward)"] := {
        empiric: "Ceftriaxone 1-2 g IV q24h + azithromycin 500 mg IV/PO q24h  (or levofloxacin 750 mg q24h monotherapy).",
        pcnAllergy: "Levofloxacin 750 mg q24h monotherapy, or (mild allergy) cefuroxime-based regimen per allergy severity.",
        mrsa: "Not routine. Add vancomycin/linezolid only with risk factors (prior MRSA, post-influenza necrotizing, empyema).",
        pseudomonas: "Not routine unless structural lung disease/recent broad abx.",
        notes: "Assess CURB-65/PSI. Blood cultures + resp pathogen panel where indicated. Steroids per current CAP guidance only in select cases.",
        deescalation: "Narrow to oral once afebrile 48 h and clinically improving; typical total 5 days if rapid response."
    }

    m["CAP — severe (ICU)"] := {
        empiric: "Ceftriaxone 2 g IV q24h + azithromycin  OR  beta-lactam + respiratory fluoroquinolone.",
        pcnAllergy: "Respiratory fluoroquinolone (levofloxacin/moxifloxacin) + aztreonam if beta-lactam needed.",
        mrsa: "Add vancomycin (AUC-guided) or linezolid 600 mg q12h if MRSA risk/necrotizing.",
        pseudomonas: "If risk: antipseudomonal beta-lactam (pip-tazo, cefepime, meropenem) replacing ceftriaxone.",
        notes: "Blood cultures, sputum, Legionella + pneumococcal urinary antigens. Reassess at 48-72 h.",
        deescalation: "De-escalate per cultures/antigens; stop MRSA/Pseudomonas coverage if not recovered and low risk."
    }

    m["HAP / VAP"] := {
        empiric: "Antipseudomonal beta-lactam (pip-tazo 4.5 g q6h ext-infusion, cefepime 2 g q8h, or meropenem 1 g q8h) + MRSA coverage.",
        pcnAllergy: "Aztreonam 2 g q8h (+/- fluoroquinolone or aminoglycoside for double gram-negative) + vancomycin/linezolid.",
        mrsa: "Vancomycin (AUC-guided) or linezolid 600 mg q12h.",
        pseudomonas: "Covered by the antipseudomonal beta-lactam; add a second antipseudomonal agent only with high resistance risk.",
        notes: "Follow unit antibiogram. Obtain lower-resp cultures before starting when feasible.",
        deescalation: "Narrow to a single agent by culture; typical duration 7 days if good response."
    }

    m["Uncomplicated cystitis"] := {
        empiric: "Nitrofurantoin 100 mg PO BID x5 d, or TMP-SMX DS BID x3 d, or fosfomycin 3 g x1.",
        pcnAllergy: "All first-line options are non-beta-lactam; no change needed.",
        mrsa: "N/A.",
        pseudomonas: "N/A for uncomplicated.",
        notes: "Avoid nitrofurantoin if CrCl <30 or suspected pyelonephritis. Confirm it is not catheter-associated.",
        deescalation: "Tailor to susceptibilities; shortest effective course."
    }

    m["Pyelonephritis / complicated UTI"] := {
        empiric: "Ceftriaxone 1-2 g IV q24h  (or ciprofloxacin/levofloxacin if local resistance low).",
        pcnAllergy: "Fluoroquinolone, or aztreonam, or aminoglycoside depending on severity/allergy.",
        mrsa: "N/A.",
        pseudomonas: "If risk (recent instrumentation, prior Pseudomonas): antipseudomonal beta-lactam.",
        notes: "Blood + urine cultures. Assess for obstruction/source control (stone, retention).",
        deescalation: "Step down to oral by susceptibility; 7 days for fluoroquinolone-susceptible pyelo, 10-14 d otherwise."
    }

    m["Intra-abdominal (community)"] := {
        empiric: "Ceftriaxone 2 g q24h + metronidazole 500 mg q8h  (or pip-tazo monotherapy).",
        pcnAllergy: "Fluoroquinolone + metronidazole, or aztreonam + metronidazole (+/- vancomycin if gram-positive concern).",
        mrsa: "Not routine.",
        pseudomonas: "Community: not routine. Healthcare-associated: cover with pip-tazo/cefepime/meropenem.",
        notes: "Source control is essential. Enterococcus/Candida coverage in healthcare-associated or immunocompromised.",
        deescalation: "4 days after adequate source control (STOP-IT) in most; tailor to cultures."
    }

    m["Skin/soft tissue — non-purulent (cellulitis)"] := {
        empiric: "Cefazolin 2 g IV q8h  (or antistreptococcal agent). Targets beta-hemolytic strep.",
        pcnAllergy: "Clindamycin 600 mg q8h (mild-moderate) or vancomycin if severe.",
        mrsa: "Not routine for non-purulent unless systemic toxicity/failure.",
        pseudomonas: "N/A.",
        notes: "Elevate limb, mark borders, rule out abscess/necrotizing infection.",
        deescalation: "Oral step-down (cephalexin) once improving; 5-6 days total if uncomplicated."
    }

    m["Skin/soft tissue — purulent / MRSA risk"] := {
        empiric: "Incision & drainage + vancomycin (AUC-guided) or linezolid.",
        pcnAllergy: "Vancomycin/linezolid are non-beta-lactam; no change.",
        mrsa: "Yes — this is MRSA-directed.",
        pseudomonas: "N/A.",
        notes: "Culture drainage. Oral options for stable outpatients: TMP-SMX or doxycycline.",
        deescalation: "Tailor to culture; 5-7 days for drained abscess with cellulitis."
    }

    m["Sepsis — unknown source"] := {
        empiric: "Broad: antipseudomonal beta-lactam (pip-tazo/cefepime/meropenem) + vancomycin. Add source-specific coverage once identified.",
        pcnAllergy: "Aztreonam + vancomycin (+/- aminoglycoside or fluoroquinolone for gram-negative breadth).",
        mrsa: "Vancomycin (AUC-guided) or linezolid pending cultures.",
        pseudomonas: "Covered empirically; reassess with cultures.",
        notes: "Cultures BEFORE antibiotics if it does not delay therapy >45 min. Lactate, source hunt, timely source control. Antibiotics within 1 h for septic shock.",
        deescalation: "Aggressively narrow at 48-72 h by culture/clinical trajectory; stop redundant coverage."
    }

    m["Meningitis (community, adult)"] := {
        empiric: "Ceftriaxone 2 g IV q12h + vancomycin (AUC-guided) + dexamethasone. Add ampicillin 2 g q4h if >50 y or immunocompromised (Listeria).",
        pcnAllergy: "Moxifloxacin + vancomycin (+ TMP-SMX for Listeria if ampicillin cannot be used). ID consult.",
        mrsa: "Vancomycin included for resistant pneumococcus, not primarily MRSA.",
        pseudomonas: "Post-neurosurgical/shunt: cefepime or meropenem instead of ceftriaxone.",
        notes: "Do not delay antibiotics for imaging/LP. Dexamethasone with/before first dose for pneumococcal.",
        deescalation: "Tailor to organism/susceptibility; durations organism-specific."
    }

    m["C. difficile infection"] := {
        empiric: "Fidaxomicin 200 mg PO BID x10 d (preferred), or vancomycin 125 mg PO QID x10 d. Fulminant: PO/PR vancomycin 500 mg QID + IV metronidazole.",
        pcnAllergy: "N/A.",
        mrsa: "N/A.",
        pseudomonas: "N/A.",
        notes: "Stop the inciting antibiotic if possible. Avoid antiperistaltics. Oral metronidazole only if others unavailable.",
        deescalation: "Assess for recurrence; consider fidaxomicin or bezlotoxumab strategy for recurrent disease."
    }

    return m
}

; Cross-check a chosen regimen against a free-text allergy string; return warnings.
ID_AllergyCheck(regimenText, allergyText) {
    if Trim(allergyText) = ""
        return ""
    a := StrLower(allergyText)
    warn := ""
    if (InStr(a, "penicillin") || InStr(a, "pcn") || InStr(a, "amoxicillin") || InStr(a, "ampicillin")) {
        if RegExMatch(regimenText, "i)\b(cef|ceftriaxone|cefepime|cefazolin|cephalexin|cefuroxime|pip|piperacillin|tazo|ampicillin|amox|meropenem|ertapenem|imipenem|aztreonam)")
            warn .= "  ! Beta-lactam in regimen with a documented penicillin allergy — assess reaction severity. Cephalosporin cross-reactivity is low (~1-2%) with dissimilar side chains; aztreonam is safe except with ceftazidime allergy; carbapenems low cross-reactivity. Avoid all beta-lactams if history of anaphylaxis/SJS/DRESS.`r`n"
    }
    if InStr(a, "sulfa") && RegExMatch(regimenText, "i)\b(tmp|smx|sulfamethoxazole|bactrim|septra)")
        warn .= "  ! Sulfonamide in regimen with a sulfa allergy — avoid unless allergy is non-antibiotic sulfa and reaction was mild.`r`n"
    if InStr(a, "vancomycin") && InStr(StrLower(regimenText), "vancomycin")
        warn .= "  ! Vancomycin listed as an allergy — clarify infusion reaction (red-man, rate-related) vs true allergy before avoiding.`r`n"
    if (InStr(a, "fluoroquinolone") || InStr(a, "cipro") || InStr(a, "levofloxacin") || InStr(a, "moxifloxacin")) && RegExMatch(regimenText, "i)\b(cipro|levofloxacin|moxifloxacin|floxacin)")
        warn .= "  ! Fluoroquinolone in regimen with a documented fluoroquinolone allergy.`r`n"
    return warn
}



; =================================================================================================
; NEW CALCULATOR & TOOL GUIs — Batches 1, 4, 2  (added 2026-07-19)
; Decision-support only. Verify every value against current references and local protocol.
; =================================================================================================

; -------------------------------------------------------------------------------------------------
; BATCH 1a — AMINOGLYCOSIDE DOSING GUI
; -------------------------------------------------------------------------------------------------
Calc_OpenAminoglycoside() {
    g := Gui("+Resize", "Aminoglycoside Dosing Support")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w560", "Aminoglycoside Dosing"))
    Theme_Subtle(g.Add("Text", "xm y+2 w560", "Extended-interval (Hartford), traditional, or gram-positive synergy. Verify levels and nomogram."))

    g.Add("Text", "xm y+14 w110", "Drug:")
    drug := g.Add("DropDownList", "x+8 yp-3 w200", ["Gentamicin", "Tobramycin", "Amikacin"]), drug.Value := 1
    g.Add("Text", "xm y+12 w110", "Strategy:")
    strat := g.Add("DropDownList", "x+8 yp-3 w200", ["Extended-interval (once daily)", "Traditional (conventional)", "Synergy (gram-positive)"]), strat.Value := 1

    g.Add("Text", "xm y+12 w110", "Age (yr):")
    age := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Text", "x+16 yp+3 w45", "Sex:")
    sex := g.Add("DropDownList", "x+6 yp-3 w100", ["Male", "Female"]), sex.Value := 1
    g.Add("Text", "xm y+12 w110", "Height (cm):")
    ht := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Text", "x+16 yp+3 w75", "Weight (kg):")
    wt := g.Add("Edit", "x+6 yp-3 w90")
    g.Add("Text", "xm y+12 w110", "SCr (mg/dL):")
    scr := g.Add("Edit", "x+8 yp-3 w90")

    g.Add("Button", "xm y+16 w150 h30 Default", "Build Plan").OnEvent("Click",
        (*) => SafeRun(Calc_RunAminoglycoside, drug, strat, age, sex, ht, wt, scr, out))
    g.Add("Button", "x+8 yp w120 h30", "Copy").OnEvent("Click", (*) => A_Clipboard := out.Value)

    out := g.Add("Edit", "xm y+14 w560 h280 ReadOnly -Wrap")
    Theme_OutputFont(out)

    ; OCR prefill
    global _PreFillDemographics
    if IsSet(_PreFillDemographics) && _PreFillDemographics.Count > 0 {
        pf := _PreFillDemographics
        if pf.Has("age") && pf["age"] != ""
            age.Value := pf["age"]
        if pf.Has("heightCm") && pf["heightCm"] != ""
            ht.Value := String(pf["heightCm"])
        if pf.Has("weightKg") && pf["weightKg"] != ""
            wt.Value := String(pf["weightKg"])
        if pf.Has("scr") && pf["scr"] != ""
            scr.Value := pf["scr"]
        if pf.Has("sex") && pf["sex"] != ""
            sex.Value := (pf["sex"] = "Female") ? 2 : 1
        _PreFillDemographics := Map()
    }

    parsed := PBind_CurrentParsed()
    PBind_Set(age, PBind_Value(parsed, "age"))
    PBind_Set(ht, PBind_HeightCm(parsed))
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_Set(scr, PBind_Value(parsed, "scr"))
    PBind_SetSex(sex, PBind_Value(parsed, "sex"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Age", age.Value, "Height", ht.Value, "Weight", wt.Value, "SCr", scr.Value)))
    Workbench29_Show(g,"w600")
}

Calc_RunAminoglycoside(drugCtrl, stratCtrl, ageCtrl, sexCtrl, htCtrl, wtCtrl, scrCtrl, out) {
    ageT := Trim(ageCtrl.Value), htT := Trim(htCtrl.Value), wtT := Trim(wtCtrl.Value), scrT := Trim(scrCtrl.Value)
    if !IsNumber(ageT) || !IsNumber(htT) || !IsNumber(wtT) || !IsNumber(scrT)
        || Number(ageT) <= 0 || Number(htT) <= 0 || Number(wtT) <= 0 || Number(scrT) <= 0 {
        out.Value := "Enter age, sex, height (cm), weight (kg), and SCr."
        return
    }
    drug := StrLower(drugCtrl.Text)
    indication := InStr(stratCtrl.Text, "Traditional") ? "traditional"
        : InStr(stratCtrl.Text, "Synergy") ? "synergy" : "extended"
    out.Value := AG_BuildPlan(drug, sexCtrl.Text = "Female", Number(htT), Number(wtT), Number(scrT), Number(ageT), indication)
}


; -------------------------------------------------------------------------------------------------
; BATCH 1b — INFECTIOUS DISEASE / ANTIBIOTIC SELECTION GUI
; -------------------------------------------------------------------------------------------------
Calc_OpenAntibiotic() {
    g := Gui("+Resize", "Infectious Disease — Empiric Antibiotic Support")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w720", "Empiric Antibiotic Selection"))
    Theme_Subtle(g.Add("Text", "xm y+2 w720", "Curated empiric starting points. Tailor to local antibiogram, severity, source control, cultures, and allergies. Not a substitute for ID consult."))

    syndromes := ID_Syndromes()
    names := []
    for k in syndromes
        names.Push(k)

    g.Add("Text", "xm y+14 w110", "Syndrome:")
    synCtrl := g.Add("DropDownList", "x+8 yp-3 w440", names), synCtrl.Value := 1

    g.Add("Text", "xm y+12 w110", "Allergies:")
    allergyCtrl := g.Add("Edit", "x+8 yp-3 w440", "")
    Theme_Subtle(g.Add("Text", "xm y+4 w720", "Free text (e.g., 'penicillin - anaphylaxis, sulfa'). The tool flags conflicts with the displayed regimen."))

    g.Add("Text", "xm y+10 w150", "MRSA risk?")
    mrsaCtrl := g.Add("CheckBox", "x+8 yp w130", "Yes")
    g.Add("Text", "x+10 yp w150", "Pseudomonas risk?")
    pseudoCtrl := g.Add("CheckBox", "x+8 yp w130", "Yes")

    g.Add("Button", "xm y+16 w160 h30 Default", "Show Guidance").OnEvent("Click",
        (*) => SafeRun(Calc_RunAntibiotic, synCtrl, allergyCtrl, mrsaCtrl, pseudoCtrl, out))
    g.Add("Button", "x+8 yp w120 h30", "Copy").OnEvent("Click", (*) => A_Clipboard := out.Value)

    out := g.Add("Edit", "xm y+14 w720 h360 ReadOnly -Wrap")
    Theme_OutputFont(out)

    ; OCR prefill of allergies from the picker, if available
    global _PreFillDemographics
    if IsSet(_PreFillDemographics) && _PreFillDemographics.Has("allergiesText") && _PreFillDemographics["allergiesText"] != ""
        allergyCtrl.Value := _PreFillDemographics["allergiesText"]

    ctx := PCtx_Active()
    if IsObject(ctx) && ctx.allergyRaw.Length > 0
        PBind_Set(allergyCtrl, DoseAware_Join(ctx.allergyRaw, "; "))
    PBind_AddStatus(g, allergyCtrl.Value != "" ? "Allergies populated from the active patient capture." : "No allergy text was captured.")
    Workbench29_Show(g,"w760")
}

Calc_RunAntibiotic(synCtrl, allergyCtrl, mrsaCtrl, pseudoCtrl, out) {
    syndromes := ID_Syndromes()
    key := synCtrl.Text
    if !syndromes.Has(key) {
        out.Value := "Select a syndrome."
        return
    }
    s := syndromes[key]
    allergy := Trim(allergyCtrl.Value)
    hasPcnAllergy := allergy != "" && RegExMatch(StrLower(allergy), "penicillin|pcn|amoxicillin|ampicillin|cephalosporin|beta.?lactam")

    regimen := hasPcnAllergy ? s.pcnAllergy : s.empiric

    o := "EMPIRIC GUIDANCE — " key "`r`n"
    o .= "======================================================`r`n`r`n"
    o .= "FIRST-LINE EMPIRIC:`r`n  " s.empiric "`r`n`r`n"
    if hasPcnAllergy
        o .= "PENICILLIN/BETA-LACTAM ALLERGY ALTERNATIVE:`r`n  " s.pcnAllergy "`r`n`r`n"

    if mrsaCtrl.Value = 1
        o .= "MRSA COVERAGE:`r`n  " s.mrsa "`r`n`r`n"
    if pseudoCtrl.Value = 1
        o .= "PSEUDOMONAS COVERAGE:`r`n  " s.pseudomonas "`r`n`r`n"

    o .= "KEY POINTS:`r`n  " s.notes "`r`n`r`n"
    o .= "DE-ESCALATION / DURATION:`r`n  " s.deescalation "`r`n"

    ; allergy cross-check against the regimen actually recommended
    warn := ID_AllergyCheck(regimen (mrsaCtrl.Value=1 ? " " s.mrsa : "") (pseudoCtrl.Value=1 ? " " s.pseudomonas : ""), allergy)
    if warn != ""
        o .= "`r`nALLERGY CROSS-CHECK:`r`n" warn
    else if allergy != ""
        o .= "`r`nALLERGY CROSS-CHECK:`r`n  No obvious conflict detected between the listed allergies and the shown regimen. Always verify reaction history.`r`n"

    o .= "`r`n------------------------------------------------------`r`n"
    o .= "Verify doses for renal function (see renal flags / CrCl calculator), confirm cultures, and de-escalate promptly."
    out.Value := o
}


; -------------------------------------------------------------------------------------------------
; BATCH 4a — QTc CALCULATOR (Bazett + Fridericia) with risk banding
; -------------------------------------------------------------------------------------------------
Calc_OpenQTc() {
    g := Gui("", "QTc Calculator")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w420", "QTc Calculator"))
    Theme_Subtle(g.Add("Text", "xm y+2 w420", "Bazett and Fridericia correction with risk banding."))

    g.Add("Text", "xm y+14 w150", "QT interval (ms):")
    qt := g.Add("Edit", "x+8 yp-3 w120")
    g.Add("Text", "xm y+12 w150", "Heart rate (bpm):")
    hr := g.Add("Edit", "x+8 yp-3 w120")

    g.Add("Button", "xm y+16 w140 h30 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_RunQTc, qt, hr, sexCtrl, out))
    g.Add("Text", "x+12 yp+4 w60", "Sex:")
    sexCtrl := g.Add("DropDownList", "x+6 yp-4 w100", ["Male", "Female"]), sexCtrl.Value := 1

    out := g.Add("Edit", "xm y+14 w420 h200 ReadOnly -Wrap")
    Theme_OutputFont(out)
    parsed := PBind_CurrentParsed()
    PBind_Set(qt, PBind_Lab("qt"))
    PBind_Set(hr, PBind_Lab("heartRate"))
    PBind_SetSex(sexCtrl, PBind_Value(parsed, "sex"))
    PBind_AddStatus(g, PBind_MissingSummary(Map("QT", qt.Value, "Heart rate", hr.Value)))
    Workbench29_Show(g,"w460")
}

Calc_RunQTc(qtCtrl, hrCtrl, sexCtrl, out) {
    qtT := Trim(qtCtrl.Value), hrT := Trim(hrCtrl.Value)
    if !IsNumber(qtT) || !IsNumber(hrT) || Number(qtT) <= 0 || Number(hrT) <= 0 {
        out.Value := "Enter QT in ms and heart rate in bpm."
        return
    }
    qt := Number(qtT), hr := Number(hrT)
    rr := 60 / hr                          ; seconds
    bazett := qt / Sqrt(rr)
    frid := qt / (rr ** (1/3))
    isFemale := sexCtrl.Text = "Female"
    threshold := isFemale ? 470 : 450
    concern := 500

    o := "QTc RESULTS`r`n===============================`r`n"
    o .= "Bazett QTc:       " Round(bazett, 0) " ms`r`n"
    o .= "Fridericia QTc:   " Round(frid, 0) " ms`r`n"
    o .= "(RR interval " Round(rr, 3) " s from HR " hr ")`r`n`r`n"
    band := ""
    ref := Round(bazett, 0)
    if ref >= concern
        band := ">=500 ms: HIGH torsades risk. Review/stop QT-prolonging agents, correct K/Mg/Ca, telemetry, consider cardiology."
    else if ref >= threshold
        band := "Prolonged for sex (>" threshold " ms). Minimize QT-prolonging drugs, correct electrolytes, monitor."
    else
        band := "Within normal range for sex. Reassess if new QT-prolonging agents added."
    o .= "Interpretation (Bazett): " band "`r`n`r`n"
    o .= "Fridericia is preferred at HR extremes (Bazett over-corrects at high HR, under-corrects at low HR)."
    out.Value := o
}


; -------------------------------------------------------------------------------------------------
; BATCH 4b — ANION GAP + DELTA-DELTA
; -------------------------------------------------------------------------------------------------
Calc_OpenAnionGap() {
    g := Gui("", "Anion Gap / Delta-Delta")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w420", "Anion Gap"))
    Theme_Subtle(g.Add("Text", "xm y+2 w420", "Albumin-corrected AG with delta ratio."))

    g.Add("Text", "xm y+14 w140", "Na (mEq/L):")
    na := g.Add("Edit", "x+8 yp-3 w110")
    g.Add("Text", "xm y+10 w140", "Cl (mEq/L):")
    cl := g.Add("Edit", "x+8 yp-3 w110")
    g.Add("Text", "xm y+10 w140", "HCO3 (mEq/L):")
    hco3 := g.Add("Edit", "x+8 yp-3 w110")
    g.Add("Text", "xm y+10 w140", "Albumin (g/dL):")
    alb := g.Add("Edit", "x+8 yp-3 w110", "4.0")

    g.Add("Button", "xm y+16 w140 h30 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_RunAnionGap, na, cl, hco3, alb, out))
    out := g.Add("Edit", "xm y+14 w420 h220 ReadOnly -Wrap")
    Theme_OutputFont(out)
    PBind_Set(na, PBind_Lab("sodium"))
    PBind_Set(cl, PBind_Lab("chloride"))
    PBind_Set(hco3, PBind_Lab("bicarbonate"))
    PBind_Set(alb, PBind_Lab("albumin", alb.Value))
    PBind_AddStatus(g, PBind_MissingSummary(Map("Sodium", na.Value, "Chloride", cl.Value, "Bicarbonate", hco3.Value)))
    Workbench29_Show(g,"w460")
}

Calc_RunAnionGap(naCtrl, clCtrl, hco3Ctrl, albCtrl, out) {
    naT := Trim(naCtrl.Value), clT := Trim(clCtrl.Value), hcoT := Trim(hco3Ctrl.Value), albT := Trim(albCtrl.Value)
    if !IsNumber(naT) || !IsNumber(clT) || !IsNumber(hcoT) {
        out.Value := "Enter Na, Cl, and HCO3."
        return
    }
    na := Number(naT), cl := Number(clT), hco3 := Number(hcoT)
    alb := IsNumber(albT) ? Number(albT) : 4.0
    ag := na - (cl + hco3)
    agCorr := ag + 2.5 * (4.0 - alb)

    o := "ANION GAP`r`n===============================`r`n"
    o .= "Measured AG:     " Round(ag, 1) " mEq/L   (Na - Cl - HCO3)`r`n"
    o .= "Albumin-corrected AG: " Round(agCorr, 1) " mEq/L`r`n"
    o .= "(Normal ~8-12; add ~2.5 per 1 g/dL albumin below 4)`r`n`r`n"
    if agCorr > 12 {
        o .= "HIGH anion gap metabolic acidosis. Consider GOLD-MARK / MUDPILES (lactate, ketones, toxins, uremia).`r`n`r`n"
        ; delta ratio needs the excess AG vs the HCO3 deficit
        deltaAG := agCorr - 12
        deltaHCO3 := 24 - hco3
        if deltaHCO3 != 0 {
            ratio := deltaAG / deltaHCO3
            o .= "Delta ratio: " Round(ratio, 2) "`r`n"
            if ratio < 0.4
                o .= "  <0.4: concurrent normal-AG (hyperchloremic) metabolic acidosis.`r`n"
            else if ratio < 1
                o .= "  0.4-1: mixed high-AG and normal-AG acidosis.`r`n"
            else if ratio <= 2
                o .= "  1-2: pure high-AG metabolic acidosis.`r`n"
            else
                o .= "  >2: concurrent metabolic alkalosis or pre-existing high HCO3 (e.g., chronic respiratory acidosis).`r`n"
        }
    } else {
        o .= "Normal anion gap. If acidotic, consider normal-AG (hyperchloremic) causes.`r`n"
    }
    out.Value := o
}


; -------------------------------------------------------------------------------------------------
; BATCH 4c — SODIUM CORRECTION / FREE WATER DEFICIT
; -------------------------------------------------------------------------------------------------
Calc_OpenSodium() {
    g := Gui("", "Sodium Correction / Free Water Deficit")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w460", "Sodium Correction"))
    Theme_Subtle(g.Add("Text", "xm y+2 w460", "Free water deficit (hypernatremia) and safe correction limits."))

    g.Add("Text", "xm y+14 w160", "Current Na (mEq/L):")
    na := g.Add("Edit", "x+8 yp-3 w110")
    g.Add("Text", "xm y+10 w160", "Weight (kg):")
    wt := g.Add("Edit", "x+8 yp-3 w110")
    g.Add("Text", "xm y+10 w160", "Sex:")
    sex := g.Add("DropDownList", "x+8 yp-3 w110", ["Male", "Female"]), sex.Value := 1
    g.Add("Text", "xm y+10 w160", "Elderly / low TBW?")
    elderly := g.Add("CheckBox", "x+8 yp w120", "Yes")

    g.Add("Button", "xm y+16 w150 h30 Default", "Calculate").OnEvent("Click",
        (*) => SafeRun(Calc_RunSodium, na, wt, sex, elderly, out))
    out := g.Add("Edit", "xm y+14 w460 h240 ReadOnly -Wrap")
    Theme_OutputFont(out)
    parsed := PBind_CurrentParsed()
    PBind_Set(na, PBind_Lab("sodium"))
    PBind_Set(wt, PBind_Value(parsed, "weightKg"))
    PBind_SetSex(sex, PBind_Value(parsed, "sex"))
    ageValue := PBind_Value(parsed, "age")
    if IsNumber(ageValue) && Number(ageValue) >= 65
        elderly.Value := 1
    PBind_AddStatus(g, PBind_MissingSummary(Map("Sodium", na.Value, "Weight", wt.Value)))
    Workbench29_Show(g,"w500")
}

Calc_RunSodium(naCtrl, wtCtrl, sexCtrl, elderlyCtrl, out) {
    naT := Trim(naCtrl.Value), wtT := Trim(wtCtrl.Value)
    if !IsNumber(naT) || !IsNumber(wtT) || Number(naT) <= 0 || Number(wtT) <= 0 {
        out.Value := "Enter current Na and weight."
        return
    }
    na := Number(naT), wt := Number(wtT)
    isFemale := sexCtrl.Text = "Female"
    ; TBW fraction: adult M 0.6 / F 0.5; elderly reduce by 0.1
    frac := isFemale ? 0.5 : 0.6
    if elderlyCtrl.Value = 1
        frac -= 0.1
    tbw := frac * wt

    o := "SODIUM / FREE WATER`r`n===============================`r`n"
    o .= "Total body water estimate: " Round(tbw, 1) " L (fraction " frac ")`r`n`r`n"
    if na > 145 {
        fwd := tbw * ((na / 140) - 1)
        o .= "HYPERNATREMIA`r`n"
        o .= "Free water deficit (to Na 140): " Round(fwd, 1) " L`r`n"
        o .= "Plus ongoing/insensible losses (~1-1.5 L/day) — replace on top of the deficit.`r`n`r`n"
        o .= "SAFETY: lower Na no faster than ~10 mEq/L per 24 h (many target 8) to avoid cerebral edema.`r`n"
        o .= "Replace deficit over ~48 h; recheck Na q4-6h initially.`r`n"
    } else if na < 135 {
        o .= "HYPONATREMIA`r`n"
        o .= "Correction limit: <=8 mEq/L per 24 h (osmotic demyelination risk; stricter in high-risk: alcohol use, malnutrition, hypokalemia, liver disease).`r`n"
        o .= "Use Adrogue-Madias to estimate the Na change per liter of a chosen fluid; recheck Na q2-4h during active correction.`r`n"
        o .= "For severe symptomatic hyponatremia: 3% saline boluses per protocol, targeting a 4-6 mEq/L rise to stop seizures — do NOT exceed daily limit.`r`n"
    } else {
        o .= "Na is within normal range (135-145). No deficit calculation needed.`r`n"
    }
    out.Value := o
}


; -------------------------------------------------------------------------------------------------
; BATCH 4d — CORTICOSTEROID EQUIVALENCY
; -------------------------------------------------------------------------------------------------
Calc_OpenSteroid() {
    g := Gui("", "Corticosteroid Equivalency")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w460", "Corticosteroid Conversion"))
    Theme_Subtle(g.Add("Text", "xm y+2 w460", "Glucocorticoid equivalence. Does not capture mineralocorticoid effect or duration."))

    steroids := ["Hydrocortisone", "Prednisone", "Prednisolone", "Methylprednisolone", "Dexamethasone", "Triamcinolone"]
    g.Add("Text", "xm y+14 w120", "From:")
    frm := g.Add("DropDownList", "x+8 yp-3 w200", steroids), frm.Value := 2
    g.Add("Text", "xm y+10 w120", "Dose (mg):")
    dose := g.Add("Edit", "x+8 yp-3 w110")
    g.Add("Text", "xm y+10 w120", "To:")
    to := g.Add("DropDownList", "x+8 yp-3 w200", steroids), to.Value := 4

    g.Add("Button", "xm y+16 w140 h30 Default", "Convert").OnEvent("Click",
        (*) => SafeRun(Calc_RunSteroid, frm, dose, to, out))
    out := g.Add("Edit", "xm y+14 w460 h180 ReadOnly -Wrap")
    Theme_OutputFont(out)
    Workbench29_Show(g,"w500")
}

Steroid_Potency(name) {
    ; glucocorticoid potency relative to hydrocortisone
    switch StrLower(name) {
        case "hydrocortisone":     return 1
        case "prednisone":         return 4
        case "prednisolone":       return 4
        case "methylprednisolone": return 5
        case "triamcinolone":      return 5
        case "dexamethasone":      return 25
    }
    return 0
}

Calc_RunSteroid(frmCtrl, doseCtrl, toCtrl, out) {
    doseT := Trim(doseCtrl.Value)
    if !IsNumber(doseT) || Number(doseT) <= 0 {
        out.Value := "Enter a dose in mg."
        return
    }
    dose := Number(doseT)
    pf := Steroid_Potency(frmCtrl.Text), pt := Steroid_Potency(toCtrl.Text)
    if pf = 0 || pt = 0 {
        out.Value := "Unknown agent."
        return
    }
    hydroEq := dose * pf
    result := hydroEq / pt
    o := "STEROID CONVERSION`r`n===============================`r`n"
    o .= dose " mg " frmCtrl.Text "`r`n   = " Round(result, 1) " mg " toCtrl.Text "`r`n`r`n"
    o .= "(Hydrocortisone-equivalent: " Round(hydroEq, 0) " mg)`r`n`r`n"
    o .= "Glucocorticoid potency only. Dexamethasone has negligible mineralocorticoid activity and a long duration; hydrocortisone is short-acting with mineralocorticoid effect. Adjust for indication and taper."
    out.Value := o
}


; -------------------------------------------------------------------------------------------------
; BATCH 4e — FENTANYL PATCH <-> ORAL MME
; -------------------------------------------------------------------------------------------------
Calc_OpenFentanylMME() {
    g := Gui("", "Fentanyl Patch / MME")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w460", "Fentanyl Patch <-> Oral MME"))
    Theme_Subtle(g.Add("Text", "xm y+2 w460", "Approximate conversion. Cross-tolerance is incomplete — reduce 25-50% when switching."))

    g.Add("Text", "xm y+14 w180", "Direction:")
    dir := g.Add("DropDownList", "x+8 yp-3 w240", ["Patch (mcg/hr) -> MME/day", "MME/day -> Patch (mcg/hr)"]), dir.Value := 1
    g.Add("Text", "xm y+12 w180", "Value:")
    val := g.Add("Edit", "x+8 yp-3 w120")

    g.Add("Button", "xm y+16 w140 h30 Default", "Convert").OnEvent("Click",
        (*) => SafeRun(Calc_RunFentanylMME, dir, val, out))
    out := g.Add("Edit", "xm y+14 w460 h180 ReadOnly -Wrap")
    Theme_OutputFont(out)
    Workbench29_Show(g,"w500")
}

Calc_RunFentanylMME(dirCtrl, valCtrl, out) {
    vT := Trim(valCtrl.Value)
    if !IsNumber(vT) || Number(vT) <= 0 {
        out.Value := "Enter a value."
        return
    }
    v := Number(vT)
    ; 25 mcg/hr fentanyl patch ~ 60 mg oral morphine/day -> factor 2.4
    factor := 2.4
    o := "FENTANYL CONVERSION`r`n===============================`r`n"
    if InStr(dirCtrl.Text, "Patch (mcg/hr) ->") {
        mme := v * factor
        o .= v " mcg/hr fentanyl patch`r`n   ~ " Round(mme, 0) " MME/day (oral morphine equivalents)`r`n`r`n"
    } else {
        static patches := [12, 25, 37, 50, 62, 75, 87, 100]
        raw := v / factor
        best := patches[1], bd := Abs(raw - best)
        for p in patches {
            if Abs(raw - p) < bd
                bd := Abs(raw - p), best := p
        }
        o .= v " MME/day`r`n   ~ " Round(raw, 1) " mcg/hr (nearest patch strength " best " mcg/hr)`r`n`r`n"
    }
    o .= "SAFETY: fentanyl patches are for opioid-tolerant patients only (>=60 MME/day for >=1 week). When rotating opioids, reduce the calculated equianalgesic dose by 25-50% for incomplete cross-tolerance and titrate. Verify against your institution's conversion table."
    out.Value := o
}


; =================================================================================================
; BATCH 2 — MEDICATION-LIST FLAG ENGINE (QTc, interactions, anticholinergic burden)
; Reuses the OCR medication list. These run inside Demo_BuildParsedDetails alongside renal flags.
; =================================================================================================

; QT-prolonging drug detection (curated common inpatient list).
MedFlag_QTDrugs() {
    return ["amiodarone", "sotalol", "dofetilide", "haloperidol", "droperidol", "quetiapine",
        "ziprasidone", "citalopram", "escitalopram", "ondansetron", "azithromycin",
        "levofloxacin", "ciprofloxacin", "moxifloxacin", "fluconazole", "methadone",
        "hydroxyzine", "chlorpromazine", "erythromycin", "clarithromycin"]
}

; Anticholinergic burden (curated; approximate ACB-style scoring).
MedFlag_AnticholinergicScore(key) {
    ; score 3 (strong), 2 (moderate), 1 (mild)
    strong := ["diphenhydramine", "hydroxyzine", "oxybutynin", "tolterodine", "amitriptyline",
        "nortriptyline", "chlorpromazine", "promethazine", "hyoscyamine", "dicyclomine",
        "meclizine", "cyproheptadine", "benztropine", "scopolamine", "paroxetine"]
    moderate := ["cyclobenzaprine", "loratadine", "cetirizine", "olanzapine", "quetiapine"]
    mild := ["trazodone", "mirtazapine", "ranitidine", "metoclopramide", "haloperidol",
        "risperidone", "digoxin", "prednisone", "furosemide"]
    for d in strong
        if InStr(key, d) = 1
            return 3
    for d in moderate
        if InStr(key, d) = 1
            return 2
    for d in mild
        if InStr(key, d) = 1
            return 1
    return 0
}

; High-risk pairwise interactions (curated). Returns array of warning strings for the med set.
MedFlag_Interactions(keys) {
    ; each rule: [drugA, drugB, message]
    static rules := [
        ["warfarin", "sulfamethoxazole", "Warfarin + TMP-SMX: marked INR elevation/bleeding risk."],
        ["warfarin", "fluconazole", "Warfarin + fluconazole: potent CYP2C9 inhibition, INR rises."],
        ["warfarin", "amiodarone", "Warfarin + amiodarone: reduce warfarin ~30-50%, INR rises over weeks."],
        ["warfarin", "metronidazole", "Warfarin + metronidazole: increased INR/bleeding."],
        ["linezolid", "sertraline", "Linezolid + SSRI/SNRI: serotonin syndrome risk (MAO inhibition)."],
        ["linezolid", "fluoxetine", "Linezolid + SSRI/SNRI: serotonin syndrome risk."],
        ["linezolid", "escitalopram", "Linezolid + SSRI/SNRI: serotonin syndrome risk."],
        ["linezolid", "duloxetine", "Linezolid + SNRI: serotonin syndrome risk."],
        ["linezolid", "venlafaxine", "Linezolid + SNRI: serotonin syndrome risk."],
        ["clarithromycin", "simvastatin", "Macrolide + simvastatin/lovastatin: rhabdomyolysis risk (CYP3A4)."],
        ["clarithromycin", "lovastatin", "Macrolide + lovastatin: rhabdomyolysis risk (CYP3A4)."],
        ["amiodarone", "simvastatin", "Amiodarone + simvastatin: limit simvastatin to 20 mg (myopathy)."],
        ["allopurinol", "azathioprine", "Allopurinol + azathioprine/6-MP: profound myelosuppression."],
        ["methotrexate", "trimethoprim", "Methotrexate + TMP-SMX: additive antifolate, pancytopenia risk."],
        ["potassium", "spironolactone", "K supplement + K-sparing diuretic/ACEi/ARB: hyperkalemia."],
        ["spironolactone", "lisinopril", "K-sparing diuretic + ACEi: hyperkalemia risk."],
        ["digoxin", "amiodarone", "Digoxin + amiodarone: digoxin levels rise ~2x, reduce dose."],
        ["clopidogrel", "omeprazole", "Clopidogrel + omeprazole/esomeprazole: reduced activation (CYP2C19)."],
        ["ciprofloxacin", "tizanidine", "Ciprofloxacin + tizanidine: contraindicated, marked hypotension/sedation."]
    ]
    out := []
    for rule in rules {
        aFound := false, bFound := false
        for k in keys {
            if InStr(k, rule[1])
                aFound := true
            if InStr(k, rule[2])
                bFound := true
        }
        if aFound && bFound
            out.Push(rule[3])
    }
    return out
}

; Build the full Batch-2 flag block for the OCR picker details pane.
MedFlag_BuildBlock(parsed) {
    if !parsed.HasOwnProp("medications") || parsed.medications.Length = 0
        return ""

    keys := []
    for m in parsed.medications
        keys.Push(PatientV4_MedicationNameKey(m))

    ; QT drugs present
    qtHits := []
    for m in parsed.medications {
        k := PatientV4_MedicationNameKey(m)
        for q in MedFlag_QTDrugs() {
            if InStr(k, q) = 1 {
                qtHits.Push(m)
                break
            }
        }
    }

    ; anticholinergic burden
    acbTotal := 0, acbContrib := []
    for m in parsed.medications {
        s := MedFlag_AnticholinergicScore(PatientV4_MedicationNameKey(m))
        if s > 0 {
            acbTotal += s
            acbContrib.Push(m " (" s ")")
        }
    }

    interactions := MedFlag_Interactions(keys)

    if qtHits.Length = 0 && acbTotal = 0 && interactions.Length = 0
        return ""

    out := "`r`n=== MEDICATION SAFETY FLAGS ===`r`n"

    if interactions.Length > 0 {
        out .= "`r`nHIGH-RISK INTERACTIONS:`r`n"
        for w in interactions
            out .= "  ! " w "`r`n"
    }

    if qtHits.Length >= 1 {
        out .= "`r`nQT-PROLONGING AGENTS (" qtHits.Length "):`r`n  "
        first := true
        for m in qtHits {
            out .= (first ? "" : ", ") m
            first := false
        }
        out .= "`r`n"
        if qtHits.Length >= 2
            out .= "  Multiple QT-prolonging agents — check a baseline/interval ECG, correct K/Mg, review necessity.`r`n"
    }

    if acbTotal > 0 {
        out .= "`r`nANTICHOLINERGIC BURDEN: total score " acbTotal "`r`n  "
        first := true
        for c in acbContrib {
            out .= (first ? "" : ", ") c
            first := false
        }
        out .= "`r`n"
        if acbTotal >= 3
            out .= "  Score >=3 is associated with increased confusion/falls/urinary retention, especially in older adults — consider deprescribing.`r`n"
    }

    out .= "`r`nFlags are screening prompts from the visible medication list only (not a full profile). Verify against the complete MAR and interaction database.`r`n"
    return out
}





; =================================================================================================
; BATCH 3 — EMERGENCY / CODE ALGORITHMS  (added 2026-07-19)
; -------------------------------------------------------------------------------------------------
; Decision-support only, for a trained clinician during a resuscitation. Doses reflect ACLS 2020
; and standard hyperkalemia / status epilepticus protocols. ALWAYS verify against your facility's
; code protocol and current guidelines. Weight-based doses use actual body weight unless noted.
; =================================================================================================

Emerg_RoundDose(value, multiple) {
    if multiple <= 0
        return Round(value, 1)
    return Round(value / multiple) * multiple
}

; ---- HYPERKALEMIA ------------------------------------------------------------------------------
Emerg_Hyperkalemia(kLevel, ecgChanges, glucose, renalFailure) {
    o := "HYPERKALEMIA MANAGEMENT`r`n"
    o .= "==================================================`r`n"
    if kLevel != ""
        o .= "Reported K+: " kLevel " mEq/L`r`n"
    o .= "Sequence: STABILIZE the membrane -> SHIFT K+ intracellularly -> ELIMINATE K+ from body.`r`n`r`n"

    o .= "1) STABILIZE MYOCARDIUM (if ECG changes or K+ >6.5)`r`n"
    if ecgChanges
        o .= "   >> ECG changes present — give calcium NOW.`r`n"
    o .= "   Calcium gluconate 10% 1-2 g (10-20 mL) IV over 2-3 min (peripheral-safe), OR`r`n"
    o .= "   Calcium chloride 10% 1 g (10 mL) IV via central line (3x more elemental Ca).`r`n"
    o .= "   Onset 1-3 min, lasts ~30-60 min; repeat if ECG changes persist. Does NOT lower K+.`r`n`r`n"

    o .= "2) SHIFT K+ INTO CELLS`r`n"
    insulinUnits := renalFailure ? "5" : "10"
    o .= "   Regular insulin " insulinUnits " units IV push"
    if glucose != "" && IsNumber(glucose) && Number(glucose) > 250
        o .= "  (glucose " glucose " >250 — dextrose may be withheld; recheck glucose).`r`n"
    else
        o .= "  + Dextrose 50% 25 g (1 amp) IV to prevent hypoglycemia.`r`n"
    if renalFailure
        o .= "   (Reduced insulin dose given renal failure — high delayed-hypoglycemia risk.)`r`n"
    o .= "   >> Check glucose at 30-60 min and hourly for several hours (delayed hypoglycemia common).`r`n"
    o .= "   Albuterol 10-20 mg nebulized (4-8x standard) — additive with insulin.`r`n"
    o .= "   Sodium bicarbonate ONLY if metabolic acidosis (not a reliable K-shifter alone).`r`n`r`n"

    o .= "3) ELIMINATE K+ FROM BODY`r`n"
    o .= "   Loop diuretic (e.g., furosemide) if making urine and volume permits.`r`n"
    o .= "   GI binder: patiromer or sodium zirconium cyclosilicate (not for acute emergent lowering).`r`n"
    o .= "   Hemodialysis — definitive, especially in renal failure / refractory hyperkalemia.`r`n`r`n"

    o .= "MONITORING: continuous ECG, recheck K+ after shift therapy, glucose per above, and treat the cause.`r`n"
    o .= "AVOID: potassium-containing fluids, K-sparing diuretics, ACEi/ARB, NSAIDs during the event."
    return o
}

; ---- STATUS EPILEPTICUS -------------------------------------------------------------------------
Emerg_StatusEpilepticus(wtKg, ivAccess) {
    o := "STATUS EPILEPTICUS ALGORITHM`r`n"
    o .= "==================================================`r`n"
    hasWt := IsNumber(wtKg) && Number(wtKg) > 0
    if hasWt
        o .= "Weight: " Round(Number(wtKg), 1) " kg`r`n`r`n"
    else
        o .= "No weight entered — doses shown per kg; enter weight for absolute doses.`r`n`r`n"

    o .= "STABILIZATION (0-5 min): ABCs, O2, IV access, fingerstick glucose, time the seizure.`r`n`r`n"

    o .= "PHASE 1 — BENZODIAZEPINE (5-20 min)`r`n"
    if ivAccess {
        lz := hasWt ? Min(0.1 * Number(wtKg), 4) : 0
        o .= "   Lorazepam 0.1 mg/kg IV (max 4 mg/dose), may repeat x1"
        o .= hasWt ? "  =>  " Round(lz, 1) " mg IV.`r`n" : ".`r`n"
        dz := hasWt ? Min(0.15 * Number(wtKg), 10) : 0
        o .= "   OR Diazepam 0.15-0.2 mg/kg IV (max 10 mg)"
        o .= hasWt ? "  =>  ~" Round(dz, 1) " mg IV.`r`n" : ".`r`n"
    } else {
        mid := (hasWt && Number(wtKg) < 40) ? "5 mg" : "10 mg"
        o .= "   NO IV: Midazolam " mid " IM (>=40 kg: 10 mg; 13-40 kg: 5 mg), OR`r`n"
        o .= "   Diazepam rectal / midazolam intranasal or buccal per availability.`r`n"
    }
    o .= "   Give a FULL benzo dose — underdosing is the most common error.`r`n`r`n"

    o .= "PHASE 2 — SECOND-LINE ANTISEIZURE (20-40 min), pick ONE:`r`n"
    if hasWt {
        lev := Min(60 * Number(wtKg), 4500)
        fos := 20 * Number(wtKg)
        vpa := Min(40 * Number(wtKg), 3000)
        o .= "   Levetiracetam 60 mg/kg IV (max 4500 mg)   =>  " Round(lev, 0) " mg.`r`n"
        o .= "   Fosphenytoin 20 mg PE/kg IV (max ~1500 mg PE)  =>  " Round(fos, 0) " mg PE.`r`n"
        o .= "   Valproate 40 mg/kg IV (max 3000 mg)       =>  " Round(vpa, 0) " mg.`r`n"
    } else {
        o .= "   Levetiracetam 60 mg/kg IV (max 4500 mg).`r`n"
        o .= "   Fosphenytoin 20 mg PE/kg IV (max ~1500 mg PE); watch hypotension/arrhythmia.`r`n"
        o .= "   Valproate 40 mg/kg IV (max 3000 mg); avoid in hepatic disease/pregnancy.`r`n"
    }
    o .= "`r`nPHASE 3 — REFRACTORY (>40 min): intubate + continuous infusion (midazolam, propofol,`r`n"
    o .= "   or pentobarbital) with continuous EEG. Call neurology / ICU.`r`n`r`n"
    o .= "Always check and treat glucose, sodium, and other reversible causes. Thiamine before glucose if malnourished/alcohol use."
    return o
}

; ---- ACLS CODE DOSES ---------------------------------------------------------------------------
Emerg_AclsDoses(wtKg) {
    hasWt := IsNumber(wtKg) && Number(wtKg) > 0
    o := "ACLS CODE MEDICATION QUICK REFERENCE`r`n"
    o .= "==================================================`r`n`r`n"
    o .= "CARDIAC ARREST (VF / pVT / asystole / PEA)`r`n"
    o .= "   Epinephrine 1 mg IV/IO q3-5 min (every other rhythm check).`r`n"
    o .= "   Amiodarone 300 mg IV/IO push (1st), then 150 mg (2nd) for refractory VF/pVT.`r`n"
    if hasWt {
        li1lo := Round(1 * Number(wtKg)), li1hi := Round(1.5 * Number(wtKg))
        li2lo := Round(0.5 * Number(wtKg)), li2hi := Round(0.75 * Number(wtKg))
        o .= "   Lidocaine (alt) 1-1.5 mg/kg (" li1lo "-" li1hi " mg), repeat 0.5-0.75 mg/kg (" li2lo "-" li2hi " mg).`r`n"
    } else {
        o .= "   Lidocaine (alt) 1-1.5 mg/kg, then 0.5-0.75 mg/kg (enter weight for mg).`r`n"
    }
    o .= "   Magnesium 1-2 g IV/IO for torsades / suspected hypomagnesemia (not routine).`r`n`r`n"

    o .= "PERI-ARREST`r`n"
    o .= "   Bradycardia: Atropine 1 mg IV q3-5 min (max 3 mg); if refractory, transcutaneous pacing,`r`n"
    o .= "     dopamine 5-20 mcg/kg/min, or epinephrine 2-10 mcg/min infusion.`r`n"
    o .= "   Stable SVT: Adenosine 6 mg rapid IV push (large vein, fast flush), then 12 mg if needed.`r`n"
    o .= "   Symptomatic tachyarrhythmia with a pulse: consider synchronized cardioversion.`r`n`r`n"
    o .= "REVERSIBLE CAUSES (Hs & Ts): Hypovolemia, Hypoxia, H+ (acidosis), Hypo/Hyperkalemia,`r`n"
    o .= "   Hypothermia; Tension pneumothorax, Tamponade, Toxins, Thrombosis (coronary/pulmonary).`r`n`r`n"
    o .= "High-quality CPR (100-120/min, depth 2-2.4 in, full recoil, minimize interruptions) drives outcomes."
    return o
}

; ---- NALOXONE -----------------------------------------------------------------------------------
Emerg_Naloxone(arrest, opioidDependent) {
    o := "NALOXONE (OPIOID REVERSAL)`r`n"
    o .= "==================================================`r`n`r`n"
    if arrest {
        o .= "RESPIRATORY/CARDIAC ARREST: 2 mg IV/IO/IM now; support ventilation. Repeat q2-3 min as needed.`r`n`r`n"
    } else if opioidDependent {
        o .= "SPONTANEOUS BREATHING + chronic opioid use: titrate to ADEQUATE VENTILATION, not full arousal.`r`n"
        o .= "   Start 0.04-0.1 mg IV, repeat/escalate q2-3 min (0.1 -> 0.2 -> 0.4 -> 1 -> 2 mg) to effect.`r`n"
        o .= "   Goal: restore respiratory drive while avoiding precipitated withdrawal.`r`n`r`n"
    } else {
        o .= "Hypoventilation, not arrested: 0.4 mg IV/IM, repeat q2-3 min; escalate to 2 mg if no response.`r`n`r`n"
    }
    o .= "ALTERNATE ROUTES: intranasal 4 mg (one device per nostril option), IM 0.4-2 mg if no IV.`r`n`r`n"
    o .= "RE-SEDATION: naloxone half-life (~30-90 min) is SHORTER than many opioids (methadone, ER products,`r`n"
    o .= "   fentanyl analogs). Observe >=2-4 h (longer for long-acting agents).`r`n"
    o .= "   Recurrent sedation -> repeat bolus and start an infusion at ~2/3 of the effective bolus per hour.`r`n`r`n"
    o .= "Consider non-opioid causes if no response after ~10 mg total."
    return o
}

; ---- MASSIVE TRANSFUSION ------------------------------------------------------------------------
Emerg_MassiveTransfusion(wtKg, hoursFromInjury) {
    o := "MASSIVE TRANSFUSION / HEMORRHAGIC SHOCK`r`n"
    o .= "==================================================`r`n`r`n"
    o .= "ACTIVATE the facility Massive Transfusion Protocol early.`r`n`r`n"
    o .= "RATIO: transfuse RBC : FFP : platelets in a balanced 1:1:1 ratio (by unit).`r`n`r`n"
    o .= "TRANEXAMIC ACID (trauma, within 3 h of injury):`r`n"
    if hoursFromInjury != "" && IsNumber(hoursFromInjury) && Number(hoursFromInjury) > 3
        o .= "   >> " hoursFromInjury " h from injury: TXA benefit is lost and may increase harm after 3 h.`r`n"
    else
        o .= "   TXA 1 g IV over 10 min, then 1 g IV over 8 h. Give as early as possible.`r`n"
    o .= "`r`nCALCIUM (citrate in stored blood chelates Ca -> hypocalcemia impairs clotting):`r`n"
    o .= "   Monitor ionized Ca; replace with calcium gluconate/chloride during rapid transfusion.`r`n`r`n"
    o .= "MONITOR THE LETHAL TRIAD + complications:`r`n"
    o .= "   Hypothermia (warm all fluids/blood), acidosis, coagulopathy; also hyperkalemia and hypocalcemia.`r`n"
    o .= "   Follow serial ionized Ca, K+, lactate, pH, fibrinogen; give cryoprecipitate if fibrinogen low.`r`n`r`n"
    o .= "SOURCE CONTROL is definitive — surgery / IR / endoscopy as appropriate. Permissive hypotension`r`n"
    o .= "   (e.g., SBP ~90) until hemorrhage controlled in trauma without TBI, per local protocol."
    return o
}



; -------------------------------------------------------------------------------------------------
; EMERGENCY / CODE ALGORITHMS — single tabbed window
; -------------------------------------------------------------------------------------------------
Calc_OpenEmergency() {
    g := Gui("+Resize", "Emergency / Code Algorithms")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w720", "Emergency / Code Algorithms"))
    Theme_Status(g, "xm y+2 w720", "bad", "Decision-support for a trained clinician. Verify against your facility code protocol. Doses = ACLS 2020 / standard protocols.")

    tabs := g.Add("Tab3", "xm y+10 w720 h560", ["Hyperkalemia", "Status Epilepticus", "ACLS Doses", "Naloxone", "Massive Transfusion"])

    ; ---- Tab 1: Hyperkalemia ----
    tabs.UseTab(1)
    g.Add("Text", "xm+16 yp+40 w120", "K+ (mEq/L):")
    hkK := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Text", "x+16 yp+3 w120", "Glucose (mg/dL):")
    hkGlu := g.Add("Edit", "x+8 yp-3 w90")
    hkEcg := g.Add("CheckBox", "xm+16 y+12", "ECG changes (peaked T, wide QRS)")
    hkRenal := g.Add("CheckBox", "x+20 yp", "Renal failure / dialysis")
    g.Add("Button", "xm+16 y+12 w150 h30 Default", "Build Plan").OnEvent("Click",
        (*) => hkOut.Value := Emerg_Hyperkalemia(Trim(hkK.Value), hkEcg.Value = 1, Trim(hkGlu.Value), hkRenal.Value = 1))
    g.Add("Button", "x+8 yp w100 h30", "Copy").OnEvent("Click", (*) => A_Clipboard := hkOut.Value)
    hkOut := g.Add("Edit", "xm+16 y+12 w680 h360 ReadOnly -Wrap")
    Theme_OutputFont(hkOut)

    ; ---- Tab 2: Status Epilepticus ----
    tabs.UseTab(2)
    g.Add("Text", "xm+16 yp+40 w120", "Weight (kg):")
    seWt := g.Add("Edit", "x+8 yp-3 w90")
    seIv := g.Add("CheckBox", "x+20 yp+3", "IV access available")
    seIv.Value := 1
    g.Add("Button", "xm+16 y+12 w150 h30 Default", "Build Algorithm").OnEvent("Click",
        (*) => seOut.Value := Emerg_StatusEpilepticus(Trim(seWt.Value), seIv.Value = 1))
    g.Add("Button", "x+8 yp w100 h30", "Copy").OnEvent("Click", (*) => A_Clipboard := seOut.Value)
    seOut := g.Add("Edit", "xm+16 y+12 w680 h400 ReadOnly -Wrap")
    Theme_OutputFont(seOut)

    ; ---- Tab 3: ACLS Doses ----
    tabs.UseTab(3)
    g.Add("Text", "xm+16 yp+40 w120", "Weight (kg):")
    aclsWt := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Button", "x+20 yp-1 w150 h30 Default", "Show Doses").OnEvent("Click",
        (*) => aclsOut.Value := Emerg_AclsDoses(Trim(aclsWt.Value)))
    g.Add("Button", "x+8 yp w100 h30", "Copy").OnEvent("Click", (*) => A_Clipboard := aclsOut.Value)
    aclsOut := g.Add("Edit", "xm+16 y+12 w680 h420 ReadOnly -Wrap")
    Theme_OutputFont(aclsOut)
    aclsOut.Value := Emerg_AclsDoses("")

    ; ---- Tab 4: Naloxone ----
    tabs.UseTab(4)
    naxArrest := g.Add("CheckBox", "xm+16 yp+40", "Respiratory / cardiac arrest")
    naxDep := g.Add("CheckBox", "x+20 yp", "Known chronic opioid use")
    g.Add("Button", "xm+16 y+12 w150 h30 Default", "Show Guidance").OnEvent("Click",
        (*) => naxOut.Value := Emerg_Naloxone(naxArrest.Value = 1, naxDep.Value = 1))
    g.Add("Button", "x+8 yp w100 h30", "Copy").OnEvent("Click", (*) => A_Clipboard := naxOut.Value)
    naxOut := g.Add("Edit", "xm+16 y+12 w680 h420 ReadOnly -Wrap")
    Theme_OutputFont(naxOut)
    naxOut.Value := Emerg_Naloxone(false, false)

    ; ---- Tab 5: Massive Transfusion ----
    tabs.UseTab(5)
    g.Add("Text", "xm+16 yp+40 w120", "Weight (kg):")
    mtWt := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Text", "x+16 yp+3 w140", "Hours from injury:")
    mtHrs := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Button", "xm+16 y+12 w150 h30 Default", "Build Plan").OnEvent("Click",
        (*) => mtOut.Value := Emerg_MassiveTransfusion(Trim(mtWt.Value), Trim(mtHrs.Value)))
    g.Add("Button", "x+8 yp w100 h30", "Copy").OnEvent("Click", (*) => A_Clipboard := mtOut.Value)
    mtOut := g.Add("Edit", "xm+16 y+12 w680 h380 ReadOnly -Wrap")
    Theme_OutputFont(mtOut)
    mtOut.Value := Emerg_MassiveTransfusion("", "")

    tabs.UseTab()
    ; OCR weight prefill into all weight fields
    global _PreFillDemographics
    if IsSet(_PreFillDemographics) && _PreFillDemographics.Has("weightKg") && _PreFillDemographics["weightKg"] != "" {
        wtVal := String(_PreFillDemographics["weightKg"])
        seWt.Value := wtVal
        aclsWt.Value := wtVal
        mtWt.Value := wtVal
    }

    Workbench29_Show(g,"w760 h640")
}





; =================================================================================================
; =================================================================================================
; CRITICAL DRIP TRACKER
; Operational timing only. Concentration, rate, volume, and bag-life are explicit user inputs.
; =================================================================================================
Calc_OpenCriticalDripTracker() {
    g := Gui("+Resize +MinimizeBox", "Critical Drip Tracker")
    g.SetFont("s10", "Segoe UI"), ApplyTheme(g)
    h := g.Add("Text", "xm ym w900", "CRITICAL DRIP TRACKER"), Theme_Heading(h)
    Theme_Subtle(g.Add("Text", "xm y+3 w900", "Track the bag actually hanging, the next bag due, and coverage from prepared extras. Enter the facility/local stability limit explicitly; no concentration or stability values are inferred."))
    g.Add("Text", "xm y+14 w125", "Patient / ID:"), patient := g.Add("Edit", "x+8 yp-3 w190")
    dripNames := CriticalDripLibrary_DrugNames()
    g.Add("Text", "x+18 yp+3 w55", "Drip:"), drip := g.Add("ComboBox", "x+8 yp-3 w300", dripNames)
    if dripNames.Length
        drip.Value := 1
    g.Add("Text", "xm y+14 w125", "Concentration:"), conc := g.Add("ComboBox", "x+8 yp-3 w220")
    g.Add("Text", "x+18 yp+3 w105", "Bag volume (mL):"), vol := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Text", "x+18 yp+3 w90", "Rate (mL/hr):"), rate := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Text", "xm y+14 w125", "Last hung local:"), hung := g.Add("Edit", "x+8 yp-3 w190"), hung.Value := FormatTime(A_Now, "yyyy-MM-dd HH:mm")
    g.Add("Text", "x+18 yp+3 w105", "Bag life (hr):"), life := g.Add("Edit", "x+8 yp-3 w90")
    g.Add("Text", "x+18 yp+3 w75", "Extra bags:"), extra := g.Add("Edit", "x+8 yp-3 w70"), extra.Value := "0"
    g.Add("Text", "xm y+14 w125", "Notes / policy:"), notes := g.Add("Edit", "x+8 yp-3 w770")
    drip.OnEvent("Change", (*) => CriticalDrip_LoadConcentrationOptions(drip, conc, vol, life))
    g.Add("Button", "xm y+12 w150 h32 Default", "Calculate / Save").OnEvent("Click", (*) => CriticalDrip_Save(patient, drip, conc, vol, rate, hung, life, extra, notes, out, lv))
    g.Add("Button", "x+8 yp w95 h32", "Load ID").OnEvent("Click", (*) => CriticalDrip_Refresh(patient, lv))
    g.Add("Button", "x+8 yp w95 h32", "Delete").OnEvent("Click", (*) => CriticalDrip_Delete(patient, lv))
    g.Add("Button", "x+8 yp w95 h32", "Copy").OnEvent("Click", (*) => A_Clipboard := out.Value)
    g.Add("Button", "x+8 yp w95 h32", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Add("Text", "xm y+12 w900", "Current calculation:")
    out := g.Add("Edit", "xm y+5 w900 h125 Multi VScroll WantTab +Wrap"), Theme_OutputFont(out)
    lv := g.Add("ListView", "xm y+12 w900 h210 Grid", ["Patient", "Drip", "Concentration", "Bag mL", "Last hung", "Next due", "Extras", "Coverage through", "Status"])
    for spec in [[1,100],[2,170],[3,150],[4,65],[5,125],[6,125],[7,55],[8,135],[9,120]]
        lv.ModifyCol(spec[1], spec[2])
    lv.OnEvent("DoubleClick", (*) => CriticalDrip_LoadSelected(patient, drip, conc, vol, rate, hung, life, extra, notes, lv, out))
    Theme_Subtle(g.Add("Text", "xm y+8 w900", "Next due is the earlier of volume ÷ rate run-out or the entered bag-life limit. Coverage assumes each extra bag is ready and has the same entered limit. Confirm MAR, pump, label, and local policy."))
    Theme_Subtle(g.Add("Text", "xm y+5 w900", "© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC."))
    Workbench29_Show(g,"w940 h680")
    CriticalDrip_LoadConcentrationOptions(drip, conc, vol, life)
    CriticalDrip_Refresh(patient, lv)
}

CriticalDrip_Calc(pid, name, conc, vol, rate, hung, life, extra) {
    pid:=Trim(pid), name:=Trim(name), conc:=Trim(conc), vol:=Trim(vol), rate:=Trim(rate), hung:=Trim(hung), life:=Trim(life), extra:=Trim(extra)
    if pid="" || name="" || conc="" || !IsNumber(vol) || Number(vol)<=0 || !IsNumber(life) || Number(life)<=0
        return {ok:false, report:"REVIEW REQUIRED: patient/ID, drip, concentration, positive bag volume, and positive bag-life hours are required."}
    if rate!="" && (!IsNumber(rate) || Number(rate)<=0)
        return {ok:false, report:"REVIEW REQUIRED: rate must be blank or a positive mL/hr value."}
    if extra=""
        extra:="0"
    if !IsNumber(extra) || Number(extra)<0 || Mod(Number(extra),1)!=0
        return {ok:false, report:"REVIEW REQUIRED: extra bags must be a whole number zero or greater."}
    if !RegExMatch(hung,"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?$")
        return {ok:false, report:"REVIEW REQUIRED: last hung must use YYYY-MM-DD HH:MM local time."}
    try {
        start:=SubStr(hung,1,4) SubStr(hung,6,2) SubStr(hung,9,2) SubStr(hung,12,2) SubStr(hung,15,2) (RegExMatch(hung,":\d{2}$")?SubStr(hung,18,2):"00"), lifeHours:=Number(life), runHours:=rate!=""?Number(vol)/Number(rate):lifeHours, dueHours:=Min(runHours,lifeHours)
        reason:=rate!=""&&runHours<=lifeHours?"volume/rate run-out":"bag-life limit"
        nextStamp:=DateAdd(start,dueHours,"Hours"), coverageStamp:=DateAdd(start,dueHours*(1+Number(extra)),"Hours"), next:=FormatTime(nextStamp,"yyyy-MM-dd HH:mm"), coverage:=FormatTime(coverageStamp,"yyyy-MM-dd HH:mm")
    } catch
        return {ok:false, report:"REVIEW REQUIRED: last hung could not be parsed as a real local date/time."}
    status:="scheduled"
    try delta:=DateDiff(A_Now,nextStamp,"Minutes"), status:=delta>=0?"due now / overdue":(-delta<=120?"due within 2 hours":"scheduled")
    report:="CRITICAL DRIP TRACKER · " pid "`r`nDrip: " name "`r`nConcentration: " conc "`r`nBag: " vol " mL"
    report.=rate!=""?"`r`nRate: " rate " mL/hr (estimated run time " Round(runHours,2) " h)":"`r`nRate: not entered (run-out time not calculated)"
    report.="`r`nLast hung: " hung " local`r`nBag-life limit: " life " h`r`nNext bag due: " next " (" reason ")`r`nExtra bags ready: " extra "`r`nCoverage through: " coverage "`r`nStatus: " status "`r`nAssumption: extras are sequential ready bags with the same entered limit; verify MAR, pump, label, and local stability policy."
    return {ok:true, report:report, next:next, coverage:coverage}
}

CriticalDrip_Save(patient, drip, conc, vol, rate, hung, life, extra, notes, out, lv) {
    dripText := CriticalDrip_ControlText(drip), concText := CriticalDrip_ControlText(conc)
    calc:=CriticalDrip_Calc(patient.Value,dripText,concText,vol.Value,rate.Value,hung.Value,life.Value,extra.Value), out.Value:=calc.report
    if !calc.ok
        return
    rows:=CriticalDrip_ReadRows(), row:={patientId:Pkg_ScrubForPersistence(Trim(patient.Value)),dripName:Pkg_ScrubForPersistence(dripText),concentration:Pkg_ScrubForPersistence(concText),bagVolumeMl:Trim(vol.Value),rateMlHr:Trim(rate.Value),lastHung:Trim(hung.Value),bagLifeHours:Trim(life.Value),extraBags:Trim(extra.Value),nextDue:calc.next,coverageUntil:calc.coverage,notes:Pkg_ScrubForPersistence(Trim(notes.Value))}, replaced:=false
    for i, old in rows {
        if old.patientId=row.patientId && old.dripName=row.dripName && old.lastHung=row.lastHung {
            rows[i]:=row
            replaced:=true
            break
        }

    }
    if !replaced
        rows.Push(row)
    CriticalDrip_SaveRows(rows), CriticalDrip_Refresh(patient,lv)
}

CriticalDrip_Refresh(patient,lv) {
    lv.Delete(), pid:=Trim(patient.Value)
    if pid=""
        return
    for row in CriticalDrip_ReadRows() {
        if row.patientId!=pid
            continue
        lv.Add(,row.patientId,row.dripName,row.concentration,row.bagVolumeMl,row.lastHung,row.nextDue,row.extraBags,row.coverageUntil,"saved")
    }
}

CriticalDrip_LoadSelected(patient,drip,conc,vol,rate,hung,life,extra,notes,lv,out) {
    n:=lv.GetNext()
    if !n
        return
    pid:=lv.GetText(n,1), name:=lv.GetText(n,2), stamp:=lv.GetText(n,5)
    for row in CriticalDrip_ReadRows()
        if row.patientId=pid && row.dripName=name && row.lastHung=stamp {
            patient.Value:=row.patientId,drip.Text:=row.dripName,conc.Text:=row.concentration,vol.Value:=row.bagVolumeMl,rate.Value:=row.rateMlHr,hung.Value:=row.lastHung,life.Value:=row.bagLifeHours,extra.Value:=row.extraBags,notes.Value:=row.notes,out.Value:=CriticalDrip_Calc(row.patientId,row.dripName,row.concentration,row.bagVolumeMl,row.rateMlHr,row.lastHung,row.bagLifeHours,row.extraBags).report
            return
        }
}

CriticalDrip_ControlText(ctrl) {
    try return ctrl.Text
    catch
        return ctrl.Value
}

CriticalDrip_LoadConcentrationOptions(drip, conc, vol, life) {
    name := Trim(CriticalDrip_ControlText(drip))
    options := CriticalDripLibrary_Concentrations(name)
    conc.Delete()
    if options.Length {
        labels := []
        for option in options
            labels.Push(option.concentration)
        conc.Add(labels)
        conc.Text := options[1].concentration
        if Trim(vol.Value) = "" && options[1].bagVolumeMl != ""
            vol.Value := options[1].bagVolumeMl
        if Trim(life.Value) = "" && options[1].bagLifeHours != ""
            life.Value := options[1].bagLifeHours
    }
}

CriticalDrip_Delete(patient,lv) {
    n:=lv.GetNext()
    if !n
        return
    pid:=lv.GetText(n,1), name:=lv.GetText(n,2), stamp:=lv.GetText(n,5), rows:=[], removed:=false
    for row in CriticalDrip_ReadRows() {
        if !removed && row.patientId=pid && row.dripName=name && row.lastHung=stamp {
            removed:=true
            continue
        }
        rows.Push(row)
    }
    CriticalDrip_SaveRows(rows), CriticalDrip_Refresh(patient,lv)
}

CriticalDrip_ReadRows() {
    global CriticalDripTrackerCsvPath
    rows:=[]
    if !FileExist(CriticalDripTrackerCsvPath)
        return rows
    for i,line in StrSplit(FileRead(CriticalDripTrackerCsvPath,"UTF-8"),"`n","`r") {
        if i=1 || Trim(line)=""
            continue
        f:=CsvParseLine(line)
        while f.Length<11
            f.Push("")
        rows.Push({patientId:f[1],dripName:f[2],concentration:f[3],bagVolumeMl:f[4],rateMlHr:f[5],lastHung:f[6],bagLifeHours:f[7],extraBags:f[8],nextDue:f[9],coverageUntil:f[10],notes:f[11]})
    }
    return rows
}

CriticalDrip_SaveRows(rows) {
    global CriticalDripTrackerCsvPath
    text:="PatientId,DripName,Concentration,BagVolumeMl,RateMlHr,LastHung,BagLifeHours,ExtraBags,NextDue,CoverageUntil,Notes`r`n"
    for row in rows
        text.=CsvEscape(row.patientId) "," CsvEscape(row.dripName) "," CsvEscape(row.concentration) "," CsvEscape(row.bagVolumeMl) "," CsvEscape(row.rateMlHr) "," CsvEscape(row.lastHung) "," CsvEscape(row.bagLifeHours) "," CsvEscape(row.extraBags) "," CsvEscape(row.nextDue) "," CsvEscape(row.coverageUntil) "," CsvEscape(row.notes) "`r`n"
    AtomicWrite(CriticalDripTrackerCsvPath,text)
}

CriticalDripLibrary_DefaultRows() {
    starter := "Starter option — verify local formulary/protocol before use"
    return [
        {drugName:"Amiodarone", concentration:"900 mg/500 mL", bagVolumeMl:"500", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Dobutamine", concentration:"250 mg/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Epinephrine", concentration:"4 mg/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Esmolol", concentration:"2,500 mg/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Heparin", concentration:"25,000 units/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Nicardipine", concentration:"25 mg/240 mL", bagVolumeMl:"240", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Nitroglycerin", concentration:"50 mg/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Norepinephrine", concentration:"4 mg/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Norepinephrine", concentration:"8 mg/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Phenylephrine", concentration:"10 mg/250 mL", bagVolumeMl:"250", rateMlHr:"", bagLifeHours:"", notes:starter},
        {drugName:"Vasopressin", concentration:"20 units/100 mL", bagVolumeMl:"100", rateMlHr:"", bagLifeHours:"", notes:starter}
    ]
}

CriticalDripLibrary_ReadRows() {
    global CriticalDripLibraryCsvPath
    rows := []
    if !FileExist(CriticalDripLibraryCsvPath)
        return rows
    for i,line in StrSplit(FileRead(CriticalDripLibraryCsvPath,"UTF-8"),"`n","`r") {
        if i=1 || Trim(line)=""
            continue
        f:=CsvParseLine(line)
        while f.Length<6
            f.Push("")
        rows.Push({drugName:f[1],concentration:f[2],bagVolumeMl:f[3],rateMlHr:f[4],bagLifeHours:f[5],notes:f[6]})
    }
    return rows
}

CriticalDripLibrary_SaveRows(rows) {
    global CriticalDripLibraryCsvPath
    text:="DrugName,Concentration,BagVolumeMl,RateMlHr,BagLifeHours,Notes`r`n"
    for row in rows
        text.=CsvEscape(row.drugName) "," CsvEscape(row.concentration) "," CsvEscape(row.bagVolumeMl) "," CsvEscape(row.rateMlHr) "," CsvEscape(row.bagLifeHours) "," CsvEscape(row.notes) "`r`n"
    AtomicWrite(CriticalDripLibraryCsvPath,text)
}

CriticalDripLibrary_DrugNames() {
    names := []
    seen := Map()
    for row in CriticalDripLibrary_ReadRows() {
        key:=StrLower(Trim(row.drugName))
        if key!="" && !seen.Has(key)
            names.Push(row.drugName), seen[key]:=true
    }
    return names
}

CriticalDripLibrary_Concentrations(drugName) {
    rows:=[]
    for row in CriticalDripLibrary_ReadRows()
        if StrLower(Trim(row.drugName))=StrLower(Trim(drugName))
            rows.Push(row)
    return rows
}

CriticalDripLibrary_SettingsOpen(*) {
    g:=Gui("+Resize", "Critical Drip Presets")
    g.SetFont("s10", "Segoe UI"), ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm ym w760", "CRITICAL DRIP PRESETS"))
    Theme_Subtle(g.Add("Text", "xm y+4 w760", "Edit concentration options, default bag volume, optional default bag-life, and notes. These are starter values only; verify local pharmacy protocol before using them."))
    lv:=g.Add("ListView", "xm y+12 w760 h420 Grid", ["Drug", "Concentration", "Bag mL", "Default rate", "Bag life h", "Notes"])
    for spec in [[1,140],[2,180],[3,70],[4,90],[5,80],[6,190]]
        lv.ModifyCol(spec[1],spec[2])
    refresh:=(*)=>CriticalDripLibrary_SettingsRefresh(lv)
    g.Add("Button", "xm y+10 w105", "Add option").OnEvent("Click", (*)=>CriticalDripLibrary_SettingsEdit(lv,0))
    g.Add("Button", "x+8 yp w105", "Edit").OnEvent("Click", (*)=>CriticalDripLibrary_SettingsEdit(lv,lv.GetNext()))
    g.Add("Button", "x+8 yp w105", "Delete").OnEvent("Click", (*)=>CriticalDripLibrary_SettingsDelete(lv))
    g.Add("Button", "x+8 yp w155", "Restore starter options").OnEvent("Click", (*)=>CriticalDripLibrary_SettingsReset(lv))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*)=>g.Destroy())
    Theme_Subtle(g.Add("Text", "xm y+10 w760", "A blank bag-life keeps a preset from being treated as a complete timing record. Rate is intentionally optional because patient-specific pump settings change."))
    g.Show("w800 h540")
    CriticalDripLibrary_SettingsRefresh(lv)
}

CriticalDripLibrary_SettingsRefresh(lv) {
    lv.Delete()
    for row in CriticalDripLibrary_ReadRows()
        lv.Add(,row.drugName,row.concentration,row.bagVolumeMl,row.rateMlHr,row.bagLifeHours,row.notes)
}

CriticalDripLibrary_SettingsEdit(lv,rowNum) {
    rows:=CriticalDripLibrary_ReadRows(), existing:=""
    if rowNum>0 && rowNum<=rows.Length {
        row:=rows[rowNum]
        existing:=row.drugName " | " row.concentration " | " row.bagVolumeMl " | " row.rateMlHr " | " row.bagLifeHours " | " row.notes
    }
    ib:=InputBox("Enter one preset as:`nDrug | Concentration | Bag mL | Default rate mL/hr (optional) | Bag life hours (optional) | Notes`n`nExample:`nNorepinephrine | 4 mg/250 mL | 250 | | 24 | Verify local protocol", rowNum>0?"Edit Critical Drip Preset":"Add Critical Drip Preset", "w720 h220", existing)
    if ib.Result!="OK"
        return
    parts:=StrSplit(ib.Value,"|")
    while parts.Length<6
        parts.Push("")
    newRow:={drugName:Trim(parts[1]),concentration:Trim(parts[2]),bagVolumeMl:Trim(parts[3]),rateMlHr:Trim(parts[4]),bagLifeHours:Trim(parts[5]),notes:Trim(parts[6])}
    if newRow.drugName="" || newRow.concentration="" {
        MsgBox "Drug and concentration are required.", "Critical Drip Presets", "Icon!"
        return
    }
    if rowNum>0 && rowNum<=rows.Length
        rows[rowNum]:=newRow
    else
        rows.Push(newRow)
    CriticalDripLibrary_SaveRows(rows), CriticalDripLibrary_SettingsRefresh(lv)
}

CriticalDripLibrary_SettingsDelete(lv) {
    n:=lv.GetNext()
    if !n
        return
    rows:=CriticalDripLibrary_ReadRows(), rows.RemoveAt(n), CriticalDripLibrary_SaveRows(rows), CriticalDripLibrary_SettingsRefresh(lv)
}

CriticalDripLibrary_SettingsReset(lv) {
    if MsgBox("Restore the starter drip options? Existing custom presets will be replaced.", "Critical Drip Presets", "YesNo Icon?")!="Yes"
        return
    CriticalDripLibrary_SaveRows(CriticalDripLibrary_DefaultRows()), CriticalDripLibrary_SettingsRefresh(lv)
}

Opioid_SeedRows() {
    return [
        {drug:"Codeine",route:"Oral",factor:"0.15",notes:"MME exposure reference"},
        {drug:"Fentanyl",route:"Buccal/SL (mcg)",factor:"0.13",notes:"MME exposure reference"},
        {drug:"Fentanyl",route:"IV (mcg)",factor:"0.3",notes:"MME exposure reference"},
        {drug:"Fentanyl",route:"Intranasal (mcg)",factor:"0.16",notes:"MME exposure reference"},
        {drug:"Fentanyl",route:"Transdermal (mcg/hr)",factor:"2.4",notes:"MME exposure reference"},
        {drug:"Hydrocodone",route:"Oral",factor:"1",notes:"MME exposure reference"},
        {drug:"Hydromorphone",route:"IV",factor:"20",notes:"MME exposure reference"},
        {drug:"Hydromorphone",route:"Oral",factor:"4",notes:"MME exposure reference"},
        {drug:"Hydromorphone",route:"SubQ",factor:"20",notes:"MME exposure reference"},
        {drug:"Methadone",route:"Oral",factor:"4.7",notes:"Nonlinear; MME screening only"},
        {drug:"Morphine",route:"IV",factor:"3",notes:"MME exposure reference"},
        {drug:"Morphine",route:"Oral",factor:"1",notes:"MME exposure reference"},
        {drug:"Morphine",route:"Rectal",factor:"1",notes:"MME exposure reference"},
        {drug:"Morphine",route:"SubQ",factor:"3",notes:"MME exposure reference"},
        {drug:"Oxycodone",route:"Oral",factor:"1.5",notes:"MME exposure reference"},
        {drug:"Oxymorphone",route:"IV",factor:"10",notes:"MME exposure reference"},
        {drug:"Oxymorphone",route:"Oral",factor:"3",notes:"MME exposure reference"},
        {drug:"Tapentadol",route:"Oral",factor:"0.4",notes:"MME exposure reference"},
        {drug:"Tramadol",route:"Oral",factor:"0.1",notes:"MME exposure reference"}
    ]
}

Opioid_EnsureFactorsCsv() {
    global OpioidFactorsCsvPath
    if FileExist(OpioidFactorsCsvPath)
        return
    Opioid_SaveFactorRows(Opioid_SeedRows())
}

Opioid_ReadFactorRows() {
    global OpioidFactorsCsvPath
    Opioid_EnsureFactorsCsv(), rows:=[]
    for i,line in StrSplit(FileRead(OpioidFactorsCsvPath,"UTF-8"),"`n","`r") {
        if i=1 || Trim(line)=""
            continue
        f:=CsvParseLine(line)
        while f.Length<4
            f.Push("")
        rows.Push({drug:f[1],route:f[2],factor:f[3],notes:f[4]})
    }
    return rows
}

Opioid_LoadFactors() {
    global OpioidMmeFactors, OpioidRoutesByDrug
    OpioidMmeFactors:=Map(), OpioidRoutesByDrug:=Map()
    for row in Opioid_ReadFactorRows() {
        if row.drug="" || row.route="" || !IsNumber(row.factor)
            continue
        key:=row.drug "|" row.route
        OpioidMmeFactors[key]:=Number(row.factor)
        if !OpioidRoutesByDrug.Has(row.drug)
            OpioidRoutesByDrug[row.drug]:=[]
        OpioidRoutesByDrug[row.drug].Push(row.route)
    }
}

Opioid_SaveFactorRows(rows) {
    global OpioidFactorsCsvPath
    text:="Drug,Route,Factor,Notes`r`n"
    for row in rows
        text.=CsvEscape(row.drug) "," CsvEscape(row.route) "," CsvEscape(row.factor) "," CsvEscape(row.notes) "`r`n"
    AtomicWrite(OpioidFactorsCsvPath,text)
}

OpioidSettings_Open(*) {
    Opioid_LoadFactors()
    g:=Gui("+Resize", "Opioid MME Factors")
    g.SetFont("s10", "Segoe UI"), ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm ym w700", "OPIOID MME FACTORS"))
    Theme_Subtle(g.Add("Text", "xm y+4 w700", "Edit the exposure-screening factors used by the MME tool. These are not equianalgesic dose conversions and should be verified against current institutional guidance."))
    lv:=g.Add("ListView", "xm y+12 w700 h390 Grid", ["Drug","Route","Factor","Notes"])
    lv.ModifyCol(1,140),lv.ModifyCol(2,190),lv.ModifyCol(3,80),lv.ModifyCol(4,270)
    refresh:=(*)=>OpioidSettings_Refresh(lv)
    g.Add("Button", "xm y+10 w100", "Add").OnEvent("Click", (*)=>OpioidSettings_Edit(lv,0))
    g.Add("Button", "x+8 yp w100", "Edit").OnEvent("Click", (*)=>OpioidSettings_Edit(lv,lv.GetNext()))
    g.Add("Button", "x+8 yp w100", "Delete").OnEvent("Click", (*)=>OpioidSettings_Delete(lv))
    g.Add("Button", "x+8 yp w170", "Restore starter factors").OnEvent("Click", (*)=>OpioidSettings_Reset(lv))
    g.Add("Button", "x+8 yp w80", "Close").OnEvent("Click", (*)=>g.Destroy())
    Theme_Subtle(g.Add("Text", "xm y+10 w700", "Changes are stored in opioid_mme_factors.csv and included in update backups."))
    g.Show("w740 h500"), OpioidSettings_Refresh(lv)
}

OpioidSettings_Refresh(lv) {
    lv.Delete()
    for row in Opioid_ReadFactorRows()
        lv.Add(,row.drug,row.route,row.factor,row.notes)
}

OpioidSettings_Edit(lv,n) {
    rows:=Opioid_ReadFactorRows(), existing:=""
    if n>0 && n<=rows.Length {
        row:=rows[n], existing:=row.drug " | " row.route " | " row.factor " | " row.notes
    }
    ib:=InputBox("Enter one factor as:`nDrug | Route | Factor per mg (or mcg for fentanyl) | Notes", n>0?"Edit Opioid Factor":"Add Opioid Factor", "w650 h180", existing)
    if ib.Result!="OK"
        return
    p:=StrSplit(ib.Value,"|")
    while p.Length<4
        p.Push("")
    row:={drug:Trim(p[1]),route:Trim(p[2]),factor:Trim(p[3]),notes:Trim(p[4])}
    if row.drug="" || row.route="" || !IsNumber(row.factor) || Number(row.factor)<=0 {
        MsgBox "Drug, route, and a positive numeric factor are required.", "Opioid MME Factors", "Icon!"
        return
    }
    if n>0 && n<=rows.Length
        rows[n]:=row
    else
        rows.Push(row)
    Opioid_SaveFactorRows(rows), Opioid_LoadFactors(), OpioidSettings_Refresh(lv)
}

OpioidSettings_Delete(lv) {
    n:=lv.GetNext()
    if !n
        return
    rows:=Opioid_ReadFactorRows(),rows.RemoveAt(n),Opioid_SaveFactorRows(rows),Opioid_LoadFactors(),OpioidSettings_Refresh(lv)
}

OpioidSettings_Reset(lv) {
    if MsgBox("Restore the bundled opioid factors? Existing custom factors will be replaced.", "Opioid MME Factors", "YesNo Icon?")!="Yes"
        return
    Opioid_SaveFactorRows(Opioid_SeedRows()), Opioid_LoadFactors(), OpioidSettings_Refresh(lv)
}

; PACKAGING BOOTSTRAP + SELF-CHECK  (added 2026-07-19)
; -------------------------------------------------------------------------------------------------
; Makes the app truly "copy one file and run." Every data file already resolves relative to
; A_ScriptDir and each has an Ensure*/DirExist guard, so the app self-heals — but a NEW user has
; no way to confirm setup worked. Pkg_Bootstrap() creates the full folder structure up front and
; Pkg_SelfCheck() reports/repairs on demand. Reminders and the shift handoff live beside the script.
; =================================================================================================


; ---- one-shot bootstrap run at startup ----------------------------------------------------------
Pkg_Bootstrap() {
    ; versioned clinical reference tables under <script>\data\ (seeded on first run)
    RefData_EnsureSeeds()

    ; Directories the app writes into during normal use.
    for d in [
        PhuckitUserDataRoot "\backups",
        PhuckitUserDataRoot "\QuickNotes_Backups"
    ] {
        if !DirExist(d)
            try DirCreate d
    }

    ; Data files that should exist with a header on a fresh copy.
    Pkg_EnsureRemindersCsv()
    Pkg_EnsureHandoffCsv()
}

Pkg_EnsureRemindersCsv() {
    global RemindersCsvPath
    if FileExist(RemindersCsvPath)
        return
    FileAppend "Id,PatientId,Kind,DueTimestamp,Detail,Done,Created`r`n", RemindersCsvPath, "UTF-8"
}

; Defense-in-depth: strip anything that looks like an MRN/FIN label+number out of a
; string before it is PERSISTED. Session-only fields (handoff note) bypass this on
; purpose; this only guards values headed for a CSV on disk/OneDrive.
Pkg_ScrubForPersistence(s) {
    s := Trim(s)
    if s = ""
        return s
    ; "MRN: 12345678" / "FIN 9001234" -> redacted marker
    s := RegExReplace(s, "i)\b(MRN|FIN|Medical\s*Record(\s*Number)?)\s*[:#=-]?\s*[A-Za-z0-9-]{4,20}\b", "[id removed]")
    ; a bare long digit run (>=6) that is likely an identifier
    s := RegExReplace(s, "\b\d{6,}\b", "[id removed]")
    return Trim(s)
}

; Derive a privacy-safe short identifier from a full MRN/FIN: last 4 characters only,
; prefixed so it reads as a partial (e.g. ...4821). Last-4 alone is not a direct
; identifier and is safe to persist alongside room/initials.
Pkg_Last4Tag(fullId) {
    fullId := Trim(fullId)
    fullId := RegExReplace(fullId, "[^A-Za-z0-9]", "")   ; strip separators
    if StrLen(fullId) < 4
        return ""
    return "..." SubStr(fullId, -3)   ; last 4 characters
}

Pkg_EnsureHandoffCsv() {
    global HandoffCsvPath
    if FileExist(HandoffCsvPath)
        return
    FileAppend "Timestamp,PatientId,Location,Category,Text,Status`r`n", HandoffCsvPath, "UTF-8"
}

; ---- on-demand self-check the user can run from the tray ----------------------------------------
Pkg_SelfCheck() {
    files := Map(
        "primary_links.csv",          PrimaryLinksCsvPath,
        "other_links.csv",            OtherLinksCsvPath,
        "custom_dropdown_menus.csv",  CustomMenusCsvPath,
        "autotext_phrases.csv",       AutoTextCsvPath,
        "osmolarity_library.csv",     OsmolarityCsvPath,
        "vancomycin_tracker.csv",     VancoTrackerCsvPath,
        "critical_drip_tracker.csv",  CriticalDripTrackerCsvPath,
        "critical_drip_library.csv",   CriticalDripLibraryCsvPath,
        "opioid_mme_factors.csv",       OpioidFactorsCsvPath,
        "workflow_tools.csv",         WorkflowMacrosCsvPath,
        "reminders.csv",              RemindersCsvPath,
        "shift_handoff.csv",          HandoffCsvPath
    )

    report := "SETUP SELF-CHECK`r`n=================================`r`n"
    report .= "App folder: " A_ScriptDir "`r`n"
    report .= "Protected user-data root: " PhuckitUserDataRoot "`r`n`r`n"
    missing := 0
    for label, path in files {
        exists := FileExist(path)
        report .= (exists ? "  OK    " : "  MISS  ") label "`r`n"
        if !exists
            missing += 1
    }

    report .= "`r`nDirectories:`r`n"
    for d in ["backups", "QuickNotes_Backups"] {
        exists := DirExist(PhuckitUserDataRoot "\" d)
        report .= (exists ? "  OK    " : "  MISS  ") d "\`r`n"
    }

    if missing > 0 {
        report .= "`r`n" missing " data file(s) missing. Click Repair to recreate them with defaults."
        res := MsgBox(report, "Self-Check", "YesNo Icon!")
        if res = "Yes" {
            EnsurePrimaryCsv()
            EnsureOtherCsv()
            EnsureCustomMenusCsv()
            EnsureAutoTextCsv()
            EnsureVancoTrackerCsv()
            EnsureCriticalDripTrackerCsv()
            EnsureCriticalDripLibraryCsv()
            Opioid_EnsureFactorsCsv()
            EnsureWorkflowMacrosCsv()
            Pkg_EnsureRemindersCsv()
            Pkg_EnsureHandoffCsv()
            if !FileExist(OsmolarityCsvPath)
                EnsureOsmolarityCsv()
            MsgBox "Repair complete. All missing files recreated with defaults.", "Self-Check", "Iconi"
        }
    } else {
        report .= "`r`nAll data files and folders present. The app is fully set up."
        MsgBox report, "Self-Check", "Iconi"
    }
}

; =================================================================================================
; STARTUP SPLASH
; -------------------------------------------------------------------------------------------------
; Non-blocking confirmation that the script actually loaded, shown bottom-right above the tray.
; Auto-dismisses; never steals focus (NoActivate) so it cannot swallow a keystroke on login.
; Toggle: tray > Settings > Show startup splash, or [General] ShowStartupSplash in local_settings.ini.
; =================================================================================================

Splash_Phrases() {
    static phrases := [
        "Can't find it? PhUCK IT.",
        "No monograph? PhUCK IT.",
        "Micromedex is down. PhUCK IT.",
        "CPRS timed out again. PhUCK IT.",
        "Order set won't load? PhUCK IT.",
        "Renal dosing unclear? PhUCK IT.",
        "Crush it? PhUCK IT.",
        "Formulary says no. PhUCK IT.",
        "Trough drawn at the wrong time? PhUCK IT.",
        "AUC won't converge? PhUCK IT.",
        "Allergy listed as 'reaction unknown'? PhUCK IT.",
        "Weight documented in pounds? PhUCK IT.",
        "Home med list says 'as directed'? PhUCK IT.",
        "Nine drips, one lumen. PhUCK IT.",
        "Consult says 'per pharmacy'. PhUCK IT.",
        "Chart says NPO, MAR says PO. PhUCK IT.",
        "Package insert is a 2009 PDF. PhUCK IT.",
        "Level came back hemolyzed. PhUCK IT.",
        "Pt takes it 'sometimes'. PhUCK IT.",
        "Nobody documented the height. PhUCK IT.",
        "Two MRNs, one patient. PhUCK IT.",
        "Third-line agent, no data. PhUCK IT.",
        "Compatibility not in Trissel's? PhUCK IT.",
        "Ordered 'now' at 1659. PhUCK IT.",
        "Peak drawn 20 minutes after the trough? PhUCK IT.",
        "Weight last documented in 2019. PhUCK IT.",
        "Allergy listed as 'meds'. PhUCK IT.",
        "Rate says 999 mL/hr. PhUCK IT.",
        "Code called during your only lunch. PhUCK IT.",
        "Phone rings at sign-out. PhUCK IT.",
        "Insulin ordered in 'U'. PhUCK IT.",
        "PRN for pain, anxiety, sleep, and mood. PhUCK IT.",
        "Prior auth denied. Again. PhUCK IT.",
        "Levophed through a 22g in the hand. PhUCK IT.",
        "Non-formulary, non-negotiable, nonexistent. PhUCK IT.",
        "'Just give it IV push.' PhUCK IT.",
        "Shortage on the one drug that works. PhUCK IT.",
        "Fourteen meds, takes none of them. PhUCK IT.",
        "Dose is per protocol. There is no protocol. PhUCK IT.",
        "Tube feeds running, med says do not crush. PhUCK IT.",
        "'The other pharmacist said it was fine.' PhUCK IT.",
        "Vanc, Zosyn, and 'renal protection'. PhUCK IT.",
        "Stat order placed three hours ago. PhUCK IT.",
        "pH of 2, peripheral line. PhUCK IT.",
        "NPO except meds. All meds are IV only. PhUCK IT.",
        "Held for a procedure that got cancelled. PhUCK IT.",
        "Consult resolved itself before you got there. PhUCK IT."
    ]
    return phrases
}

; ---- standalone one-liner, rotates independently of the punchline --------------------------
Splash_Zingers() {
    static zingers := [
        "The trough is always drawn wrong. This is a law of nature.",
        "Every 'quick question' costs twenty minutes.",
        "Renal function is a suggestion, not a constraint.",
        "If it's compatible, someone is about to prove otherwise.",
        "The protocol exists. Nobody can find it.",
        "Half-life: the time it takes for the plan to change.",
        "First do no harm. Second, check the weight.",
        "The pharmacy phone knows exactly when you sat down.",
        "Somewhere a dose is being held and nobody told you.",
        "'As directed' is not a sig. It's a dare.",
        "Every drip is compatible until it isn't.",
        "The order is stat. The elevator is not.",
        "Steady state is a story we tell new residents.",
        "Nobody has ever documented a height. Nobody.",
        "The answer is in the insert. Page 61. Table 14.",
        "There are no stable patients, only unfinished workups.",
        "Dark humor: the only formulary-approved coping mechanism.",
        "Two pharmacists, three opinions, one order to verify.",
        "The interaction is theoretical. The phone call is not.",
        "Everything is once daily until you read the renal dosing."
    ]
    return zingers
}

Splash_RandomZinger() {
    z := Splash_Zingers()
    return z[Random(1, z.Length)]
}

Splash_RandomPhrase() {
    p := Splash_Phrases()
    return p[Random(1, p.Length)]
}

Splash_Enabled() {
    global AppSettingsIniPath
    try
        return IniRead(AppSettingsIniPath, "General", "ShowStartupSplash", "1") = "1"
    catch
        return true
}

Splash_SetEnabled(on) {
    global AppSettingsIniPath
    EnsureLocalSettingsDir()
    try IniWrite(on ? "1" : "0", AppSettingsIniPath, "General", "ShowStartupSplash")
}

Splash_ToggleEnabled() {
    on := !Splash_Enabled()
    Splash_SetEnabled(on)
    try InitTray()          ; rebuild so the menu label reflects the new state
    ToolTip("Startup splash " (on ? "ON" : "OFF"))
    SetTimer(() => ToolTip(), -1600)
}

Splash_StartupIfEnabled() {
    if Splash_Enabled()
        SafeRun(Splash_Show)
}

; ---- fake boot sequence -------------------------------------------------------------------------
; Dot-leader lines that appear one at a time before the punchline. Realistic checks, honest results.
Splash_BootLines() {
    static lines := [
        ["Checking formulary",            "still no"],
        ["Contacting Micromedex",         "timed out"],
        ["Reconciling home med list",     "'as directed'"],
        ["Locating documented height",    "not found"],
        ["Parsing allergy reaction",      "'unknown'"],
        ["Verifying weight units",        "lbs"],
        ["Loading package insert",        "2009 PDF"],
        ["Counting available lumens",     "1"],
        ["Asking the team",               "'per pharmacy'"],
        ["Checking NPO status",           "disputed"],
        ["Resolving MRN",                 "2 found"],
        ["Calculating AUC",               "diverging"],
        ["Paging the provider",           "no answer"],
        ["Reading the order comment",     "blank"],
        ["Checking IV compatibility",     "not studied"],
        ["Reading provider comment",      "'ok per pharmacy'"],
        ["Finding the protocol",          "does not exist"],
        ["Confirming the indication",     "'per admitting'"],
        ["Checking the shortage list",    "12 new"],
        ["Estimating CrCl",               "no weight"],
        ["Reviewing anticoag plan",       "3 conflicting"],
        ["Checking last dose given",      "'unable to obtain'"],
        ["Counting stat orders",          "17"],
        ["Auditing duplicate therapy",    "intentional?"],
        ["Checking allergy severity",     "'per pt'"],
        ["Timing the vanc trough",        "already drawn"],
        ["Verifying tube feed hold",      "not held"],
        ["Trending renal function",       "one value"],
        ["Checking pharmacy voicemail",   "9 new"],
        ["Confirming pt is still here",   "discharged"],
        ["Locating the med rec",          "blank"],
        ["Finding a pharmacist on break", "none found"]
    ]
    return lines
}

; "Checking formulary ................. still no"
Splash_Leader(label, result, width := 46) {
    dots := width - StrLen(label) - StrLen(result)
    if dots < 2
        dots := 2
    pad := ""
    Loop dots
        pad .= "."
    return label " " pad " " result
}

Splash_PickBootLines(n) {
    pool := Splash_BootLines().Clone()
    out := []
    Loop n {
        if pool.Length = 0
            break
        i := Random(1, pool.Length)
        out.Push(pool[i])
        pool.RemoveAt(i)
    }
    return out
}

Splash_Animate() {
    global AppSettingsIniPath
    try
        return IniRead(AppSettingsIniPath, "General", "SplashAnimate", "1") = "1"
    catch
        return true
}

; =================================================================================================
; The splash is driven by ONE timer and an explicit phase machine (_SplashState). Nested timers
; were avoided on purpose: a destroyed GUI must not leave an orphan callback firing into nothing.
; Phases: in -> boot -> type -> hold -> out. Every tick is wrapped so a closed window ends quietly.
; =================================================================================================

Splash_Show() {
    global AppBackronym, AppVersion, _SplashGui, _SplashState

    Splash_Close()

    w := 520
    inner := w - 36

    g := Gui("-Caption +ToolWindow +Border", "PhUCKIT")
    _SplashGui := g
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.MarginX := 18
    g.MarginY := 14

    t1 := g.Add("Text", "xm ym w" inner " r1", "PhUCKIT is running.")
    t1.SetFont("s15 bold c" Theme_Accent("heading"), "Segoe UI")

    t2 := g.Add("Text", "xm y+2 w" inner " r1", AppBackronym)
    Theme_Subtle(t2)

    ; three fixed-height monospace rows so the window never resizes mid-animation
    bootCtrls := []
    Loop 3 {
        b := g.Add("Text", "xm " (A_Index = 1 ? "y+12" : "y+2") " w" inner " r1", "")
        b.SetFont("s10", "Consolas")
        bootCtrls.Push(b)
    }
    ready := g.Add("Text", "xm y+2 w" inner " r1", "")
    ready.SetFont("s10 bold c" Theme_Accent("good"), "Consolas")

    phrase := g.Add("Text", "xm y+12 w" inner " r2", "")
    phrase.SetFont("s13 italic c" Theme_Accent("accent"), "Segoe UI")

    zing := g.Add("Text", "xm y+6 w" inner " r1", "")
    zing.SetFont("s9 italic c" Theme_Accent("subtle"), "Segoe UI")

    bar := g.Add("Progress", "xm y+10 w" inner " h3 Range0-1000 c" Theme_Accent("accent"), "1000")

    hint := g.Add("Text", "xm y+10 w" inner " r1",
        "Ctrl+B  patient hub     Ctrl+Alt+E  code algorithms     tray icon  everything else")
    Theme_Subtle(hint)

    ver := g.Add("Text", "xm y+8 w" (inner - 170) " r1", "v" AppVersion)
    Theme_Subtle(ver)
    dismiss := g.Add("Button", "x+8 yp-6 w160", "Dismiss")
    dismiss.OnEvent("Click", (*) => Splash_Close())

    text  := Splash_RandomPhrase()
    zinger := Splash_RandomZinger()

    if !Splash_Animate() {
        ; static mode - render the finished frame and leave
        for idx, pair in Splash_PickBootLines(3)
            bootCtrls[idx].Text := Splash_Leader(pair[1], pair[2])
        ready.Text := "PhUCKIT ready."
        phrase.Text := text
        zing.Text := zinger
        pos := Splash_Geometry(g)
        g.Move(pos.x, pos.y)
        SetTimer(Splash_Close, -10000)
        return
    }

    pos := Splash_Geometry(g)
    WinSetTransparent(0, g.Hwnd)
    g.Move(pos.x, pos.y + 44)

    _SplashState := Map(
        "gui",    g,
        "phase",  "in",
        "t",      0,
        "boot",   bootCtrls,
        "lines",  Splash_PickBootLines(3),
        "shown",  0,
        "ready",  ready,
        "phrase", phrase,
        "bar",    bar,
        "zing",   zing,
        "zinger", zinger,
        "text",   text,
        "chars",  0,
        "x",      pos.x,
        "baseY",  pos.y
    )

    SetTimer(Splash_Tick, 25)
}

; Realize the window off-screen so AutoSize can measure it and transparency can be applied before
; it is ever painted, then hand back its resting position (bottom-right, clear of the taskbar).
Splash_Geometry(g) {
    g.Show("NoActivate AutoSize x-32000 y-32000")
    g.GetPos(, , &gw, &gh)
    return { x: A_ScreenWidth - gw - 24, y: A_ScreenHeight - gh - 80, w: gw, h: gh }
}

Splash_Tick() {
    global _SplashState

    if !IsObject(_SplashState) || !_SplashState.Has("gui") {
        SetTimer(Splash_Tick, 0)
        return
    }
    st := _SplashState
    g  := st["gui"]
    if !IsObject(g) {
        SetTimer(Splash_Tick, 0)
        return
    }

    try {
        st["t"] += 25
        switch st["phase"] {
            case "in":       Splash_PhaseIn(st, g)
            case "boot":     Splash_PhaseBoot(st, g)
            case "type":     Splash_PhaseType(st, g)
            case "hold":     Splash_PhaseHold(st, g)
            case "out":      Splash_PhaseOut(st, g)
        }
    } catch {
        Splash_Close()
    }
}

Splash_NextPhase(st, name) {
    st["phase"] := name
    st["t"] := 0
}

; slide up from below while fading in
Splash_PhaseIn(st, g) {
    dur := 260
    f := st["t"] / dur
    if f > 1
        f := 1
    ease := 1 - (1 - f) * (1 - f)          ; ease-out quad
    g.Move(st["x"], Round(st["baseY"] + 44 * (1 - ease)))
    WinSetTransparent(Round(255 * ease), g.Hwnd)
    if f >= 1
        Splash_NextPhase(st, "boot")
}

; reveal one dot-leader line every 260 ms
Splash_PhaseBoot(st, g) {
    per := 260
    want := Floor(st["t"] / per)
    if want > st["lines"].Length
        want := st["lines"].Length
    while st["shown"] < want {
        st["shown"] += 1
        i := st["shown"]
        st["boot"][i].Text := Splash_Leader(st["lines"][i][1], st["lines"][i][2])
    }
    if st["shown"] >= st["lines"].Length && st["t"] >= per * (st["lines"].Length + 1) {
        st["ready"].Text := "PhUCKIT ready."
        Splash_NextPhase(st, "type")
    }
}

; typewriter the punchline with a blinking block cursor
Splash_PhaseType(st, g) {
    per := 22
    want := Floor(st["t"] / per)
    total := StrLen(st["text"])
    if want > total
        want := total
    st["chars"] := want
    cursor := (Mod(Floor(st["t"] / 450), 2) = 0) ? "_" : " "
    st["phrase"].Text := SubStr(st["text"], 1, want) (want < total ? cursor : "")
    if want >= total {
        st["phrase"].Text := st["text"]
        st["zing"].Text := st["zinger"]          ; lands one beat after the punchline
        Splash_NextPhase(st, "hold")
    }
}

; drain the countdown bar, then leave
Splash_PhaseHold(st, g) {
    dur := 6000
    left := 1000 - Round(1000 * st["t"] / dur)
    if left < 0
        left := 0
    st["bar"].Value := left
    if st["t"] >= dur
        Splash_NextPhase(st, "out")
}

; fade out and drop away
Splash_PhaseOut(st, g) {
    dur := 240
    f := st["t"] / dur
    if f > 1
        f := 1
    g.Move(st["x"], Round(st["baseY"] + 30 * f))
    WinSetTransparent(Round(255 * (1 - f)), g.Hwnd)
    if f >= 1
        Splash_Close()
}

Splash_Close(*) {
    global _SplashGui, _SplashState
    SetTimer(Splash_Tick, 0)
    _SplashState := 0
    if IsObject(_SplashGui) {
        try _SplashGui.Destroy()
        _SplashGui := 0
    }
}

; First-run greeting so a new user knows the copy-and-run worked.
Pkg_FirstRunGreetingIfNeeded() {
    global AppSettingsIniPath
    EnsureLocalSettingsDir()
    seen := IniRead(AppSettingsIniPath, "General", "FirstRunGreeted", "0")
    if seen = "1"
        return
    IniWrite "1", AppSettingsIniPath, "General", "FirstRunGreeted"
    MsgBox(
        "PhUCKIT is set up.`r`n`r`n"
        . "All data files were created in this folder:`r`n"
        . A_ScriptDir "`r`n`r`n"
        . "Everything runs from here — keep the script and its files together. "
        . "Use the tray icon for the Quick Menu, calculators, notes, and settings.`r`n`r`n"
        . "Tip: Ctrl+Alt+E opens Emergency/Code Algorithms.",
        "Welcome", "Iconi"
    )
}


; =================================================================================================
; LAB / DOSE REMINDERS  (added 2026-07-19)
; -------------------------------------------------------------------------------------------------
; Lightweight, de-identified reminder store beside the script. A background timer surfaces due
; reminders with a tray notification. Built for a solo pharmacist: "vanco trough due 0600",
; "recheck BMP after K replacement", "aminoglycoside random level at 2200".
; =================================================================================================


Rem_ReadAll() {
    global RemindersCsvPath
    rows := []
    if !FileExist(RemindersCsvPath)
        return rows
    content := FileRead(RemindersCsvPath, "UTF-8")
    for i, line in StrSplit(content, "`n", "`r") {
        if i = 1 || Trim(line) = ""
            continue
        f := CsvParseLine(line)
        while f.Length < 7
            f.Push("")
        rows.Push({ id: f[1], patientId: f[2], kind: f[3], due: f[4], detail: f[5], done: f[6], created: f[7] })
    }
    return rows
}

Rem_SaveAll(rows) {
    global RemindersCsvPath
    text := "Id,PatientId,Kind,DueTimestamp,Detail,Done,Created`r`n"
    for r in rows
        text .= CsvEscape(r.id) "," CsvEscape(r.patientId) "," CsvEscape(r.kind) "," CsvEscape(r.due) "," CsvEscape(r.detail) "," CsvEscape(r.done) "," CsvEscape(r.created) "`r`n"
    AtomicWrite(RemindersCsvPath, text)
}

Rem_Add(patientId, kind, dueTs, detail) {
    rows := Rem_ReadAll()
    id := Format("{}", A_TickCount) "-" Random(1000, 9999)
    rows.Push({ id: id, patientId: patientId, kind: kind, due: dueTs, detail: detail, done: "0", created: FormatTime(A_Now, "yyyy-MM-dd HH:mm") })
    Rem_SaveAll(rows)
    return id
}

; Background poll: fire tray notifications for due, not-done reminders.
Rem_Poll() {
    global RemindersLastAlert
    rows := Rem_ReadAll()
    now := A_Now
    for r in rows {
        if r.done = "1" || Trim(r.due) = ""
            continue
        dueDt := Rem_ParseTs(r.due)
        if dueDt = ""
            continue
        if DateDiff(now, dueDt, "Minutes") >= 0 {
            if RemindersLastAlert.Has(r.id)
                continue
            RemindersLastAlert[r.id] := true
            TrayTip "Pharmacy reminder — " r.kind, (r.patientId != "" ? "[" r.patientId "] " : "") r.detail, 0x10
        }
    }
}

; Accept "yyyy-MM-dd HH:mm", "HHmm" (today, or tomorrow if past), or "+90" (minutes from now).
Rem_ParseTs(s) {
    s := Trim(s)
    if s = ""
        return ""
    if SubStr(s, 1, 1) = "+" && IsNumber(SubStr(s, 2))
        return DateAdd(A_Now, Number(SubStr(s, 2)), "Minutes")
    if RegExMatch(s, "^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}") {
        y := SubStr(s, 1, 4), mo := SubStr(s, 6, 2), d := SubStr(s, 9, 2)
        hh := SubStr(s, 12, 2), mi := SubStr(s, 15, 2)
        return y mo d hh mi "00"
    }
    if RegExMatch(s, "^\d{3,4}$") {
        hhmm := Format("{:04}", Number(s))
        cand := SubStr(A_Now, 1, 8) SubStr(hhmm, 1, 2) SubStr(hhmm, 3, 2) "00"
        if DateDiff(A_Now, cand, "Minutes") > 0
            cand := DateAdd(cand, 1, "Days")   ; already passed today -> tomorrow
        return cand
    }
    return ""
}

Calc_OpenReminders() {
    g := Gui("+Resize", "Lab / Dose Reminders")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w640", "Lab / Dose Reminders"))
    Theme_Subtle(g.Add("Text", "xm y+2 w640", "Reminders are SAVED to disk, so keep them de-identified: use a room number or initials — not MRN/FIN or full names."))

    g.Add("Text", "xm y+14 w120", "Room / Initials:")
    pid := g.Add("Edit", "x+8 yp-3 w150")
    g.Add("Button", "x+6 yp-1 w110 h26", "+ MRN last-4").OnEvent("Click", (*) => Rem_InsertLast4(pid))
    g.Add("Text", "x+12 yp+4 w60", "Kind:")
    kind := g.Add("DropDownList", "x+6 yp-4 w200", ["Vanco trough", "Vanco level (random)", "Aminoglycoside level", "BMP / lytes recheck", "SCr recheck", "INR recheck", "Glucose recheck", "Redose / next dose", "General"]), kind.Value := 1

    g.Add("Text", "xm y+12 w120", "Due:")
    due := g.Add("Edit", "x+8 yp-3 w150")
    Theme_Subtle(g.Add("Text", "x+12 yp+3 w360", "Formats: 0600 (clock, tomorrow if passed), +90 (minutes from now), or 2026-07-20 06:00"))

    g.Add("Text", "xm y+12 w120", "Detail:")
    detail := g.Add("Edit", "x+8 yp-3 w480")

    g.Add("Button", "xm y+14 w150 h30 Default", "Add Reminder").OnEvent("Click",
        (*) => SafeRun(Rem_AddFromFields, pid, kind, due, detail, lv))
    g.Add("Button", "x+8 yp w130 h30", "Mark Done").OnEvent("Click", (*) => SafeRun(Rem_MarkDone, lv))
    g.Add("Button", "x+8 yp w130 h30", "Delete").OnEvent("Click", (*) => SafeRun(Rem_DeleteSelected, lv))
    g.Add("Button", "x+8 yp w110 h30", "Refresh").OnEvent("Click", (*) => SafeRun(Rem_Refresh, lv))

    lv := g.Add("ListView", "xm y+14 w640 h300", ["Due", "Kind", "Patient", "Detail", "Status"])
    lv.ModifyCol(1, 120), lv.ModifyCol(2, 130), lv.ModifyCol(3, 90), lv.ModifyCol(4, 220), lv.ModifyCol(5, 70)

    ; OCR prefill of patient id (location) if available
    global _PreFillDemographics
    if IsSet(_PreFillDemographics) && _PreFillDemographics.Has("location") && _PreFillDemographics["location"] != ""
        pid.Value := _PreFillDemographics["location"]

    Rem_Refresh(lv)
    Workbench29_Show(g,"w680")
}

; Insert a privacy-safe MRN last-4 into the persisted Room/Initials field, pulling from
; the session-only OCR capture. Only the last 4 characters are ever used or stored.
Rem_InsertLast4(pidCtrl) {
    global _PreFillDemographics
    mrn := (IsSet(_PreFillDemographics) && _PreFillDemographics.Has("mrn")) ? _PreFillDemographics["mrn"] : ""
    tag := Pkg_Last4Tag(mrn)
    if tag = "" {
        MsgBox "No MRN captured this session. Capture a patient (Ctrl+B) first, or type room/initials manually.", "Reminders", "Icon!"
        return
    }
    cur := Trim(pidCtrl.Value)
    pidCtrl.Value := cur = "" ? tag : cur " " tag
}

Rem_AddFromFields(pidCtrl, kindCtrl, dueCtrl, detailCtrl, lv) {
    dueRaw := Trim(dueCtrl.Value)
    if dueRaw = "" {
        MsgBox "Enter a due time (e.g. 0600, +90, or 2026-07-20 06:00).", "Reminders", "Icon!"
        return
    }
    if Rem_ParseTs(dueRaw) = "" {
        MsgBox "Could not read that due time. Use 0600, +90, or yyyy-MM-dd HH:mm.", "Reminders", "Icon!"
        return
    }
    Rem_Add(Pkg_ScrubForPersistence(pidCtrl.Value), kindCtrl.Text, dueRaw, Pkg_ScrubForPersistence(detailCtrl.Value))
    detailCtrl.Value := "", dueCtrl.Value := ""
    Rem_Refresh(lv)
}

Rem_Refresh(lv) {
    lv.Delete()
    rows := Rem_ReadAll()
    ; sort by parsed due time ascending
    parsed := []
    for r in rows
        parsed.Push({ r: r, ts: Rem_ParseTs(r.due) })
    ; simple insertion sort by ts (blanks last)
    loop parsed.Length {
        i := A_Index
        loop parsed.Length - i {
            j := A_Index
            a := parsed[j], b := parsed[j+1]
            if (a.ts = "" && b.ts != "") || (a.ts != "" && b.ts != "" && a.ts > b.ts) {
                parsed[j] := b, parsed[j+1] := a
            }
        }
    }
    for p in parsed {
        r := p.r
        dueDisp := p.ts != "" ? FormatTime(p.ts, "MM-dd HH:mm") : r.due
        status := r.done = "1" ? "Done" : (p.ts != "" && DateDiff(A_Now, p.ts, "Minutes") >= 0 ? "DUE" : "pending")
        lv.Add(, dueDisp, r.kind, r.patientId, r.detail, status)
    }
}

Rem_SelectedId(lv) {
    n := lv.GetNext()
    if n = 0
        return ""
    due := lv.GetText(n, 1), kind := lv.GetText(n, 2), pid := lv.GetText(n, 3), detail := lv.GetText(n, 4)
    for r in Rem_ReadAll() {
        dd := Rem_ParseTs(r.due)
        disp := dd != "" ? FormatTime(dd, "MM-dd HH:mm") : r.due
        if disp = due && r.kind = kind && r.patientId = pid && r.detail = detail
            return r.id
    }
    return ""
}

Rem_MarkDone(lv) {
    id := Rem_SelectedId(lv)
    if id = "" {
        MsgBox "Select a reminder first.", "Reminders", "Icon!"
        return
    }
    rows := Rem_ReadAll()
    for r in rows {
        if r.id = id
            r.done := "1"
    }
    Rem_SaveAll(rows)
    Rem_Refresh(lv)
}

Rem_DeleteSelected(lv) {
    id := Rem_SelectedId(lv)
    if id = "" {
        MsgBox "Select a reminder first.", "Reminders", "Icon!"
        return
    }
    newRows := []
    for r in Rem_ReadAll() {
        if r.id != id
            newRows.Push(r)
    }
    Rem_SaveAll(newRows)
    Rem_Refresh(lv)
}


; =================================================================================================
; SHIFT HANDOFF BUILDER  (added 2026-07-19)
; -------------------------------------------------------------------------------------------------
; Collects open items over a shift (active vanco/AG patients, pending levels, interventions,
; follow-ups) into one formatted, de-identified note to paste at handoff. Stored beside the script;
; can also pull still-pending reminders automatically.
; =================================================================================================

Handoff_ReadAll() {
    global HandoffCsvPath
    rows := []
    if !FileExist(HandoffCsvPath)
        return rows
    content := FileRead(HandoffCsvPath, "UTF-8")
    for i, line in StrSplit(content, "`n", "`r") {
        if i = 1 || Trim(line) = ""
            continue
        f := CsvParseLine(line)
        while f.Length < 6
            f.Push("")
        rows.Push({ ts: f[1], patientId: f[2], location: f[3], category: f[4], text: f[5], status: f[6] })
    }
    return rows
}

Handoff_SaveAll(rows) {
    global HandoffCsvPath
    text := "Timestamp,PatientId,Location,Category,Text,Status`r`n"
    for r in rows
        text .= CsvEscape(r.ts) "," CsvEscape(r.patientId) "," CsvEscape(r.location) "," CsvEscape(r.category) "," CsvEscape(r.text) "," CsvEscape(r.status) "`r`n"
    AtomicWrite(HandoffCsvPath, text)
}

Handoff_Add(patientId, location, category, textStr, status) {
    rows := Handoff_ReadAll()
    rows.Push({ ts: FormatTime(A_Now, "yyyy-MM-dd HH:mm"), patientId: patientId, location: location, category: category, text: textStr, status: status })
    Handoff_SaveAll(rows)
}

Calc_OpenHandoff() {
    g := Gui("+Resize", "Shift Handoff Builder")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w720", "Shift Handoff Builder"))
    Theme_Subtle(g.Add("Text", "xm y+2 w720", "Log open items through the shift, then generate one handoff note. Saved rows stay de-identified (room/initials)."))

    ; Session-only patient identifiers: used ONLY in the generated note you paste into the
    ; chart. These are never written to shift_handoff.csv. They clear when the app closes.
    g.Add("Text", "xm y+12 w150", "MRN (session only):")
    sessMrn := g.Add("Edit", "x+8 yp-3 w150")
    g.Add("Text", "x+16 yp+3 w130", "FIN (session only):")
    sessFin := g.Add("Edit", "x+8 yp-3 w150")
    Theme_Status(g, "xm y+4 w720", "warn", "MRN/FIN appear only in the generated note (for the chart) and are NEVER saved to disk. Saved rows use room/initials only.")

    g.Add("Text", "xm y+14 w110", "Room / Initials:")
    pid := g.Add("Edit", "x+8 yp-3 w130")
    g.Add("Button", "x+6 yp-1 w130 h26", "+ MRN last-4").OnEvent("Click", (*) => Handoff_InsertLast4(pid, sessMrn))
    g.Add("Text", "x+12 yp+4 w70", "Location:")
    loc := g.Add("Edit", "x+6 yp-4 w150")
    g.Add("Text", "x+12 yp+3 w70", "Category:")
    cat := g.Add("DropDownList", "x+6 yp-3 w200", ["Active vanco", "Active aminoglycoside", "Pending level", "Pending lab", "Intervention", "Renal/dose adjust", "Anticoagulation", "Follow-up", "Other"]), cat.Value := 1

    g.Add("Text", "xm y+12 w110", "Item:")
    itemTxt := g.Add("Edit", "x+8 yp-3 w520")
    g.Add("Text", "xm y+12 w110", "Status:")
    stat := g.Add("DropDownList", "x+8 yp-3 w200", ["Open", "In progress", "Awaiting result", "Resolved"]), stat.Value := 1

    g.Add("Button", "xm y+14 w150 h30 Default", "Add Item").OnEvent("Click",
        (*) => SafeRun(Handoff_AddFromFields, pid, loc, cat, itemTxt, stat, lv))
    g.Add("Button", "x+8 yp w150 h30", "Delete Selected").OnEvent("Click", (*) => SafeRun(Handoff_DeleteSelected, lv))
    g.Add("Button", "x+8 yp w180 h30", "Generate Handoff Note").OnEvent("Click", (*) => SafeRun(Handoff_Generate, lv, noteOut, sessMrn, sessFin))
    g.Add("Button", "x+8 yp w120 h30", "Clear Resolved").OnEvent("Click", (*) => SafeRun(Handoff_ClearResolved, lv))

    lv := g.Add("ListView", "xm y+14 w720 h220", ["Time", "Patient", "Location", "Category", "Item", "Status"])
    lv.ModifyCol(1, 100), lv.ModifyCol(2, 80), lv.ModifyCol(3, 100), lv.ModifyCol(4, 130), lv.ModifyCol(5, 210), lv.ModifyCol(6, 90)

    g.Add("Text", "xm y+12 w200", "Generated handoff note:")
    g.Add("Button", "x+8 yp-3 w120 h26", "Copy Note").OnEvent("Click", (*) => A_Clipboard := noteOut.Value)
    noteOut := g.Add("Edit", "xm y+6 w720 h240 -Wrap")
    Theme_OutputFont(noteOut)

    ; Prefill session-only identifiers from the last OCR capture, if present.
    global _PreFillDemographics
    if IsSet(_PreFillDemographics) {
        if _PreFillDemographics.Has("mrn") && _PreFillDemographics["mrn"] != ""
            sessMrn.Value := _PreFillDemographics["mrn"]
        if _PreFillDemographics.Has("fin") && _PreFillDemographics["fin"] != ""
            sessFin.Value := _PreFillDemographics["fin"]
        if _PreFillDemographics.Has("location") && _PreFillDemographics["location"] != ""
            loc.Value := _PreFillDemographics["location"]
    }

    Handoff_Refresh(lv)
    Workbench29_Show(g,"w760")
}

; Insert a privacy-safe MRN last-4 tag into the persisted Room/Initials field.
; Pulls from the session-only MRN field; only the last 4 characters are used.
Handoff_InsertLast4(pidCtrl, sessMrnCtrl) {
    tag := Pkg_Last4Tag(sessMrnCtrl.Value)
    if tag = "" {
        MsgBox "Enter a full MRN in the session-only field first (or type a room/initials manually). Only the last 4 characters are added.", "Handoff", "Icon!"
        return
    }
    cur := Trim(pidCtrl.Value)
    pidCtrl.Value := cur = "" ? tag : cur " " tag
}

Handoff_AddFromFields(pidCtrl, locCtrl, catCtrl, itemCtrl, statCtrl, lv) {
    if Trim(itemCtrl.Value) = "" {
        MsgBox "Enter the item text.", "Handoff", "Icon!"
        return
    }
    Handoff_Add(Pkg_ScrubForPersistence(pidCtrl.Value), Pkg_ScrubForPersistence(locCtrl.Value), catCtrl.Text, Pkg_ScrubForPersistence(itemCtrl.Value), statCtrl.Text)
    itemCtrl.Value := ""
    Handoff_Refresh(lv)
}

Handoff_Refresh(lv) {
    lv.Delete()
    for r in Handoff_ReadAll()
        lv.Add(, r.ts, r.patientId, r.location, r.category, r.text, r.status)
}

Handoff_DeleteSelected(lv) {
    n := lv.GetNext()
    if n = 0 {
        MsgBox "Select a row first.", "Handoff", "Icon!"
        return
    }
    ts := lv.GetText(n, 1), item := lv.GetText(n, 5)
    newRows := []
    removed := false
    for r in Handoff_ReadAll() {
        if !removed && r.ts = ts && r.text = item {
            removed := true
            continue
        }
        newRows.Push(r)
    }
    Handoff_SaveAll(newRows)
    Handoff_Refresh(lv)
}

Handoff_ClearResolved(lv) {
    newRows := []
    for r in Handoff_ReadAll() {
        if r.status != "Resolved"
            newRows.Push(r)
    }
    Handoff_SaveAll(newRows)
    Handoff_Refresh(lv)
}

Handoff_Generate(lv, noteOut, sessMrn := "", sessFin := "") {
    rows := Handoff_ReadAll()
    ; group by category, skip resolved
    order := ["Active vanco", "Active aminoglycoside", "Pending level", "Pending lab", "Intervention", "Renal/dose adjust", "Anticoagulation", "Follow-up", "Other"]
    note := "PHARMACY SHIFT HANDOFF — " FormatTime(A_Now, "yyyy-MM-dd HH:mm") "`r`n"
    note .= "======================================================`r`n"
    ; Session-only identifiers appear in the note (for pasting into the chart) but were
    ; never written to disk. sessMrn/sessFin are GUI-field values, not stored data.
    mrnVal := IsObject(sessMrn) ? Trim(sessMrn.Value) : Trim(sessMrn)
    finVal := IsObject(sessFin) ? Trim(sessFin.Value) : Trim(sessFin)
    if mrnVal != "" || finVal != "" {
        idLine := ""
        if mrnVal != ""
            idLine .= "MRN " mrnVal "  "
        if finVal != ""
            idLine .= "FIN " finVal
        note .= "Patient: " Trim(idLine) "`r`n"
    }
    openCount := 0
    for cat in order {
        catRows := []
        for r in rows {
            if r.category = cat && r.status != "Resolved"
                catRows.Push(r)
        }
        if catRows.Length = 0
            continue
        note .= "`r`n" StrUpper(cat) ":`r`n"
        for r in catRows {
            openCount += 1
            tag := (r.patientId != "" || r.location != "") ? "[" Trim(r.patientId " " r.location) "] " : ""
            note .= "  - " tag r.text " (" r.status ")`r`n"
        }
    }

    ; append still-pending reminders as a due-list
    pend := []
    for rr in Rem_ReadAll() {
        if rr.done != "1" {
            dd := Rem_ParseTs(rr.due)
            pend.Push({ disp: dd != "" ? FormatTime(dd, "MM-dd HH:mm") : rr.due, kind: rr.kind, pid: rr.patientId, detail: rr.detail })
        }
    }
    if pend.Length > 0 {
        note .= "`r`nPENDING REMINDERS / DUE ITEMS:`r`n"
        for p in pend
            note .= "  - " p.disp "  " p.kind (p.pid != "" ? " [" p.pid "]" : "") ": " p.detail "`r`n"
    }

    if openCount = 0 && pend.Length = 0
        note .= "`r`nNo open items logged this shift.`r`n"

    note .= "`r`n------------------------------------------------------`r`n"
    note .= "De-identified pharmacy handoff. Verify all pending labs/levels and timing in the chart before acting."
    noteOut.Value := note
}




; #################################################################################################
; #  PATIENT HUB REBUILD - implementation of TEst_Improvements_to_PhUCKIT.txt phases 2-5
; #  Added 2026-07-23. Sections: reference data engine, drug normalization, allergy engine,
; #  patient context/session, six-column safety strip, patient hub GUI, RSI redesign.
; #################################################################################################

; =================================================================================================
; CLINICAL REFERENCE DATA ENGINE   (blueprint §5 "Medication safety reference data", §8 failure)
; -------------------------------------------------------------------------------------------------
; Rules live in versioned CSVs under <script>\data\. Seeds are written on first run so the
; "copy one file and it runs" property is preserved. A missing or corrupt file never crashes the
; script: RefData_Load falls back to the in-memory seed, records the reason, and the consuming
; column reports "reference unavailable" instead of a false negative.
; =================================================================================================

RefData_Dir() {
    return A_ScriptDir "\data"
}

RefData_Catalog() {
    static cat := 0
    if IsObject(cat)
        return cat

    cat := Map()
    cat["drug_aliases"] := {
        header: "alias,ingredient",
        ver: "seed-2026.07",
        src: "RxNorm ingredient/brand/synonym concepts - locally curated subset",
        rows: RefSeed_DrugAliases()
    }
    cat["allergy_relationships"] := {
        header: "class,ingredient",
        ver: "seed-2026.07",
        src: "Structural/class relationships - locally curated",
        rows: RefSeed_AllergyClasses()
    }
    cat["qt_rules"] := {
        header: "ingredient,risk,note",
        ver: "seed-2026.07",
        src: "Curated QT list - NOT CredibleMeds; licensed list required for institutional use",
        rows: RefSeed_QT()
    }
    cat["beers_rules"] := {
        header: "ingredient,category,note",
        ver: "seed-2026.07",
        src: "AGS 2023 Beers Criteria - curated subset, age 65+ only",
        rows: RefSeed_Beers()
    }
    cat["mg_cautions"] := {
        header: "ingredient,level,note",
        ver: "seed-2026.07",
        src: "MGFA cautionary drug classifications - cautions, not absolute prohibitions",
        rows: RefSeed_MG()
    }
    cat["g6pd_rules"] := {
        header: "ingredient,level,note",
        ver: "seed-2026.07",
        src: "CPIC G6PD drug-risk classifications - curated subset",
        rows: RefSeed_G6PD()
    }
    cat["renal_rules"] := {
        header: "ingredient,mode,review_below,avoid_below,note",
        ver: "seed-2026.07.29",
        src: "Curated renal screening rules; screening only, not a dosing monograph",
        rows: RefSeed_RenalRules()
    }
    cat["crush_rules_v2"] := {
        header: "pattern,kind,form_match,route_scope,action,note",
        ver: "seed-2026.07.29.2",
        src: "Manufacturer labeling + enteral administration guidance - curated subset",
        rows: RefSeed_CrushV2()
    }
    return cat
}

RefData_CsvJoin(fields) {
    out := ""
    for f in fields {
        v := String(f)
        if InStr(v, ",") || InStr(v, '"')
            v := '"' StrReplace(v, '"', '""') '"'
        out .= (out = "" ? "" : ",") v
    }
    return out
}

RefData_SeedText(name, spec) {
    txt := "# " name "  |  source: " spec.src "`r`n"
    txt .= "# version: " spec.ver "  |  institutional review: NOT REVIEWED`r`n"
    txt .= spec.header "`r`n"
    for r in spec.rows
        txt .= RefData_CsvJoin(r) "`r`n"
    return txt
}

RefData_FileVersion(raw) {
    if RegExMatch(raw, "im)^#\s*version:\s*([^|`r`n]+)", &m)
        return Trim(m[1])
    return ""
}

RefData_IsManagedSeed(raw) {
    ; Only files created by PhUCKIT and still explicitly marked NOT REVIEWED may be auto-migrated.
    ; Any reviewed or manually managed institutional file is preserved untouched.
    return InStr(raw, "institutional review: NOT REVIEWED")
        && RegExMatch(raw, "im)^#\s*[A-Za-z0-9_]+\s*\|\s*source:")
}

RefData_EnsureSeeds() {
    dir := RefData_Dir()
    if !DirExist(dir) {
        try {
            DirCreate dir
        } catch as e {
            Log("RefData: cannot create data dir - " e.Message)
            return
        }
    }

    for name, spec in RefData_Catalog() {
        path := dir "\" name ".csv"
        seedText := RefData_SeedText(name, spec)

        if !FileExist(path) {
            try {
                AtomicWrite(path, seedText)
            } catch as e {
                Log("RefData: seed write failed for " name " - " e.Message)
            }
            continue
        }

        try {
            raw := FileRead(path, "UTF-8")
            fileVersion := RefData_FileVersion(raw)
            if fileVersion = spec.ver
                continue

            if !RefData_IsManagedSeed(raw) {
                Log("RefData: preserving custom/reviewed " name " file at version "
                    . (fileVersion != "" ? fileVersion : "unversioned")
                    . "; bundled seed is " spec.ver)
                continue
            }

            backup := path ".backup-" FormatTime(, "yyyyMMdd-HHmmss")
            FileCopy(path, backup, true)
            AtomicWrite(path, seedText)
            Log("RefData: migrated managed seed " name " from "
                . (fileVersion != "" ? fileVersion : "unversioned")
                . " to " spec.ver "; backup " backup)
        } catch as e {
            Log("RefData: seed migration failed for " name " - " e.Message)
        }
    }
}

; Returns Map: ok, rows (array of Maps keyed by header), ver, src, err, fromSeed, loadedAt
RefData_Load(name) {
    global RefDataCache
    if !IsSet(RefDataCache) || !IsObject(RefDataCache)
        RefDataCache := Map()
    if RefDataCache.Has(name)
        return RefDataCache[name]

    catalog := RefData_Catalog()
    spec := catalog.Has(name) ? catalog[name] : { header: "", ver: "", src: "", rows: [] }

    st := Map()
    st["ok"] := false
    st["rows"] := []
    st["ver"] := spec.ver
    st["src"] := spec.src
    st["err"] := ""
    st["fromSeed"] := false
    st["loadedAt"] := ""

    cols := StrSplit(spec.header, ",")
    path := RefData_Dir() "\" name ".csv"

    if FileExist(path) {
        try {
            raw := FileRead(path, "UTF-8")
            fileVersion := RefData_FileVersion(raw)
            st["ver"] := fileVersion != "" ? fileVersion : "unversioned"
            gotHeader := false
            rows := []
            for line in StrSplit(raw, "`n", "`r") {
                t := Trim(line)
                if t = "" || SubStr(t, 1, 1) = "#"
                    continue
                f := CsvParseLine(t)
                if !gotHeader {
                    gotHeader := true
                    if f.Length >= 1 && Trim(f[1]) != "" {
                        cols := []
                        for c in f
                            cols.Push(Trim(c))
                    }
                    continue
                }
                rec := Map()
                for idx, c in cols
                    rec[c] := (idx <= f.Length ? Trim(f[idx]) : "")
                rows.Push(rec)
            }
            if rows.Length = 0
                throw Error("file contained no data rows")
            st["rows"] := rows
            st["ok"] := true
            st["loadedAt"] := FormatTime(, "MM/dd/yyyy HH:mm")
        } catch as e {
            st["err"] := e.Message
        }
    } else {
        st["err"] := "file not found"
    }

    if !st["ok"] {
        rows := []
        for r in spec.rows {
            rec := Map()
            for idx, c in cols
                rec[Trim(c)] := (idx <= r.Length ? String(r[idx]) : "")
            rows.Push(rec)
        }
        st["rows"] := rows
        st["fromSeed"] := true
        st["loadedAt"] := "in-memory seed"
        Log("RefData: " name " " st["err"] " - using in-memory seed")
    }

    RefDataCache[name] := st
    return st
}

RefData_Rows(name) {
    return RefData_Load(name)["rows"]
}

RefData_Available(name) {
    st := RefData_Load(name)
    return st["ok"] || st["fromSeed"]
}

RefData_StatusLine(name) {
    st := RefData_Load(name)
    if st["ok"]
        return name ": loaded " st["loadedAt"] "  (version " st["ver"] ")"
    return name ": FILE UNAVAILABLE (" st["err"] ") - using built-in seed, version " st["ver"]
}

RefData_Reload() {
    global RefDataCache
    RefDataCache := Map()
    RefData_EnsureSeeds()
}

; -------------------------------------------------------------------------------------------------
; SEED DATA
; -------------------------------------------------------------------------------------------------

RefSeed_DrugAliases() {
    return [
        ["dilaudid", "hydromorphone"], ["hydromorphone hcl", "hydromorphone"],
        ["ms contin", "morphine"], ["morphine sulfate", "morphine"], ["duramorph", "morphine"],
        ["oxycontin", "oxycodone"], ["roxicodone", "oxycodone"], ["percocet", "oxycodone/acetaminophen"],
        ["norco", "hydrocodone/acetaminophen"], ["vicodin", "hydrocodone/acetaminophen"],
        ["dolophine", "methadone"], ["demerol", "meperidine"], ["sublimaze", "fentanyl"],
        ["nubain", "nalbuphine"], ["subutex", "buprenorphine"], ["suboxone", "buprenorphine/naloxone"],
        ["narcan", "naloxone"], ["tylenol", "acetaminophen"], ["apap", "acetaminophen"],
        ["paracetamol", "acetaminophen"], ["motrin", "ibuprofen"], ["advil", "ibuprofen"],
        ["toradol", "ketorolac"], ["aleve", "naproxen"], ["asa", "aspirin"],
        ["acetylsalicylic acid", "aspirin"], ["coumadin", "warfarin"], ["jantoven", "warfarin"],
        ["eliquis", "apixaban"], ["xarelto", "rivaroxaban"], ["pradaxa", "dabigatran"],
        ["savaysa", "edoxaban"], ["lovenox", "enoxaparin"], ["arixtra", "fondaparinux"],
        ["plavix", "clopidogrel"], ["brilinta", "ticagrelor"], ["effient", "prasugrel"],
        ["vancocin", "vancomycin"], ["zosyn", "piperacillin/tazobactam"],
        ["pip tazo", "piperacillin/tazobactam"], ["pip-tazo", "piperacillin/tazobactam"],
        ["maxipime", "cefepime"], ["rocephin", "ceftriaxone"], ["ancef", "cefazolin"],
        ["kefzol", "cefazolin"], ["fortaz", "ceftazidime"], ["avycaz", "ceftazidime/avibactam"],
        ["zerbaxa", "ceftolozane/tazobactam"], ["merrem", "meropenem"], ["primaxin", "imipenem/cilastatin"],
        ["invanz", "ertapenem"], ["azactam", "aztreonam"], ["cipro", "ciprofloxacin"],
        ["levaquin", "levofloxacin"], ["avelox", "moxifloxacin"], ["zithromax", "azithromycin"],
        ["biaxin", "clarithromycin"], ["flagyl", "metronidazole"], ["cleocin", "clindamycin"],
        ["zyvox", "linezolid"], ["cubicin", "daptomycin"], ["tygacil", "tigecycline"],
        ["bactrim", "sulfamethoxazole/trimethoprim"], ["septra", "sulfamethoxazole/trimethoprim"],
        ["tmp smx", "sulfamethoxazole/trimethoprim"], ["tmp-smx", "sulfamethoxazole/trimethoprim"],
        ["smz tmp", "sulfamethoxazole/trimethoprim"], ["augmentin", "amoxicillin/clavulanate"],
        ["unasyn", "ampicillin/sulbactam"], ["macrobid", "nitrofurantoin"],
        ["macrodantin", "nitrofurantoin"], ["diflucan", "fluconazole"], ["vfend", "voriconazole"],
        ["noxafil", "posaconazole"], ["cresemba", "isavuconazonium"], ["ambisome", "amphotericin b"],
        ["cancidas", "caspofungin"], ["mycamine", "micafungin"], ["valtrex", "valacyclovir"],
        ["zovirax", "acyclovir"], ["tamiflu", "oseltamivir"], ["lasix", "furosemide"],
        ["bumex", "bumetanide"], ["demadex", "torsemide"], ["aldactone", "spironolactone"],
        ["hctz", "hydrochlorothiazide"], ["zaroxolyn", "metolazone"], ["diamox", "acetazolamide"],
        ["lopressor", "metoprolol"], ["toprol", "metoprolol"], ["toprol xl", "metoprolol"],
        ["coreg", "carvedilol"], ["tenormin", "atenolol"], ["inderal", "propranolol"],
        ["norvasc", "amlodipine"], ["cardizem", "diltiazem"], ["calan", "verapamil"],
        ["prinivil", "lisinopril"], ["zestril", "lisinopril"], ["vasotec", "enalapril"],
        ["cozaar", "losartan"], ["diovan", "valsartan"], ["entresto", "sacubitril/valsartan"],
        ["catapres", "clonidine"], ["cardura", "doxazosin"], ["hytrin", "terazosin"],
        ["flomax", "tamsulosin"], ["lanoxin", "digoxin"], ["cordarone", "amiodarone"],
        ["pacerone", "amiodarone"], ["betapace", "sotalol"], ["tikosyn", "dofetilide"],
        ["lipitor", "atorvastatin"], ["zocor", "simvastatin"], ["crestor", "rosuvastatin"],
        ["pravachol", "pravastatin"], ["zetia", "ezetimibe"], ["glucophage", "metformin"],
        ["januvia", "sitagliptin"], ["jardiance", "empagliflozin"], ["farxiga", "dapagliflozin"],
        ["ozempic", "semaglutide"], ["trulicity", "dulaglutide"], ["victoza", "liraglutide"],
        ["lantus", "insulin glargine"], ["levemir", "insulin detemir"], ["tresiba", "insulin degludec"],
        ["humalog", "insulin lispro"], ["novolog", "insulin aspart"], ["diabeta", "glyburide"],
        ["amaryl", "glimepiride"], ["glucotrol", "glipizide"], ["synthroid", "levothyroxine"],
        ["prilosec", "omeprazole"], ["protonix", "pantoprazole"], ["nexium", "esomeprazole"],
        ["pepcid", "famotidine"], ["zofran", "ondansetron"], ["reglan", "metoclopramide"],
        ["phenergan", "promethazine"], ["compazine", "prochlorperazine"], ["ativan", "lorazepam"],
        ["valium", "diazepam"], ["versed", "midazolam"], ["xanax", "alprazolam"],
        ["klonopin", "clonazepam"], ["ambien", "zolpidem"], ["lunesta", "eszopiclone"],
        ["seroquel", "quetiapine"], ["zyprexa", "olanzapine"], ["risperdal", "risperidone"],
        ["abilify", "aripiprazole"], ["haldol", "haloperidol"], ["thorazine", "chlorpromazine"],
        ["zoloft", "sertraline"], ["prozac", "fluoxetine"], ["lexapro", "escitalopram"],
        ["celexa", "citalopram"], ["paxil", "paroxetine"], ["effexor", "venlafaxine"],
        ["cymbalta", "duloxetine"], ["wellbutrin", "bupropion"], ["remeron", "mirtazapine"],
        ["desyrel", "trazodone"], ["elavil", "amitriptyline"], ["pamelor", "nortriptyline"],
        ["neurontin", "gabapentin"], ["lyrica", "pregabalin"], ["keppra", "levetiracetam"],
        ["dilantin", "phenytoin"], ["cerebyx", "fosphenytoin"], ["depakote", "valproate"],
        ["valproic acid", "valproate"], ["tegretol", "carbamazepine"], ["lamictal", "lamotrigine"],
        ["topamax", "topiramate"], ["vimpat", "lacosamide"], ["benadryl", "diphenhydramine"],
        ["vistaril", "hydroxyzine"], ["atarax", "hydroxyzine"], ["antivert", "meclizine"],
        ["ditropan", "oxybutynin"], ["detrol", "tolterodine"], ["cogentin", "benztropine"],
        ["flexeril", "cyclobenzaprine"], ["robaxin", "methocarbamol"], ["soma", "carisoprodol"],
        ["baclofen", "baclofen"], ["deltasone", "prednisone"], ["medrol", "methylprednisolone"],
        ["solu-medrol", "methylprednisolone"], ["solu medrol", "methylprednisolone"],
        ["decadron", "dexamethasone"], ["solu-cortef", "hydrocortisone"],
        ["kcl", "potassium chloride"], ["potassium chloride", "potassium chloride"],
        ["k-dur", "potassium chloride"], ["klor-con", "potassium chloride"],
        ["magnesium sulfate", "magnesium sulfate"], ["mag sulfate", "magnesium sulfate"],
        ["calcium gluconate", "calcium gluconate"], ["calcium chloride", "calcium chloride"],
        ["sodium bicarbonate", "sodium bicarbonate"], ["sodium chloride", "sodium chloride"],
        ["sodium phosphate", "sodium phosphate"], ["potassium phosphate", "potassium phosphate"],
        ["elitek", "rasburicase"], ["zyloprim", "allopurinol"], ["krystexxa", "pegloticase"],
        ["colcrys", "colchicine"], ["imuran", "azathioprine"], ["cellcept", "mycophenolate"],
        ["prograf", "tacrolimus"], ["neoral", "cyclosporine"], ["rapamune", "sirolimus"],
        ["trexall", "methotrexate"], ["aranesp", "darbepoetin"], ["procrit", "epoetin alfa"],
        ["neupogen", "filgrastim"], ["revlimid", "lenalidomide"], ["keytruda", "pembrolizumab"],
        ["opdivo", "nivolumab"], ["pyridium", "phenazopyridine"], ["dapsone", "dapsone"],
        ["primaquine", "primaquine"], ["plaquenil", "hydroxychloroquine"],
        ["methylene blue", "methylene blue"], ["provigil", "modafinil"],
        ["megace", "megestrol"], ["theo-24", "theophylline"], ["ventolin", "albuterol"],
        ["proair", "albuterol"], ["atrovent", "ipratropium"], ["spiriva", "tiotropium"],
        ["symbicort", "budesonide/formoterol"], ["advair", "fluticasone/salmeterol"],
        ["singulair", "montelukast"], ["mucomyst", "acetylcysteine"],
        ["acetadote", "acetylcysteine"], ["romazicon", "flumazenil"], ["digifab", "digoxin immune fab"],
        ["kcentra", "prothrombin complex concentrate"], ["praxbind", "idarucizumab"],
        ["andexxa", "andexanet alfa"], ["protamine", "protamine"], ["vitamin k", "phytonadione"],
        ["mephyton", "phytonadione"], ["aquamephyton", "phytonadione"],
        ["sulfa", "sulfamethoxazole"], ["sulfa drugs", "sulfamethoxazole"],
        ["sulfonamide", "sulfamethoxazole"], ["sulfonamides", "sulfamethoxazole"],
        ["sulfa antibiotics", "sulfamethoxazole"], ["pcn", "penicillin"],
        ["penicillins", "penicillin"], ["penicillin g", "penicillin"],
        ["penicillin vk", "penicillin"], ["amox", "amoxicillin"], ["keflex", "cephalexin"],
        ["cephalosporins", "cefazolin"], ["ceph", "cefazolin"],
        ["nsaids", "ibuprofen"], ["nsaid", "ibuprofen"], ["statins", "atorvastatin"],
        ["ace inhibitors", "lisinopril"], ["ace inhibitor", "lisinopril"],
        ["quinolones", "ciprofloxacin"], ["fluoroquinolones", "ciprofloxacin"],
        ["macrolides", "azithromycin"], ["opioids", "morphine"], ["opiates", "morphine"],
        ["benzodiazepines", "lorazepam"], ["tetracyclines", "doxycycline"],
        ["aminoglycosides", "gentamicin"], ["carbapenems", "meropenem"],
        ["heparins", "heparin"], ["contrast", "iohexol"], ["contrast dye", "iohexol"],
        ["iodinated contrast", "iohexol"], ["hydromorphone hydrochloride", "hydromorphone"]
    ]
}

RefSeed_AllergyClasses() {
    return [
        ["opioid-phenanthrene", "morphine"], ["opioid-phenanthrene", "hydromorphone"],
        ["opioid-phenanthrene", "codeine"], ["opioid-phenanthrene", "hydrocodone"],
        ["opioid-phenanthrene", "oxycodone"], ["opioid-phenanthrene", "oxymorphone"],
        ["opioid-phenanthrene", "buprenorphine"], ["opioid-phenanthrene", "nalbuphine"],
        ["opioid-phenanthrene", "butorphanol"], ["opioid-phenanthrene", "levorphanol"],
        ["opioid-phenylpiperidine", "fentanyl"], ["opioid-phenylpiperidine", "meperidine"],
        ["opioid-phenylpiperidine", "sufentanil"], ["opioid-phenylpiperidine", "remifentanil"],
        ["opioid-phenylpiperidine", "alfentanil"],
        ["opioid-diphenylheptane", "methadone"], ["opioid-diphenylheptane", "propoxyphene"],
        ["penicillin", "penicillin"], ["penicillin", "amoxicillin"], ["penicillin", "ampicillin"],
        ["penicillin", "nafcillin"], ["penicillin", "oxacillin"], ["penicillin", "dicloxacillin"],
        ["penicillin", "piperacillin"], ["penicillin", "clavulanate"], ["penicillin", "sulbactam"],
        ["cephalosporin", "cefazolin"], ["cephalosporin", "cephalexin"], ["cephalosporin", "cefuroxime"],
        ["cephalosporin", "ceftriaxone"], ["cephalosporin", "cefotaxime"], ["cephalosporin", "ceftazidime"],
        ["cephalosporin", "cefepime"], ["cephalosporin", "cefdinir"], ["cephalosporin", "cefpodoxime"],
        ["cephalosporin", "ceftaroline"], ["cephalosporin", "ceftolozane"],
        ["carbapenem", "meropenem"], ["carbapenem", "imipenem"], ["carbapenem", "ertapenem"],
        ["carbapenem", "doripenem"],
        ["sulfonamide-antibiotic", "sulfamethoxazole"], ["sulfonamide-antibiotic", "sulfadiazine"],
        ["sulfonamide-antibiotic", "sulfasalazine"],
        ["fluoroquinolone", "ciprofloxacin"], ["fluoroquinolone", "levofloxacin"],
        ["fluoroquinolone", "moxifloxacin"], ["fluoroquinolone", "ofloxacin"],
        ["macrolide", "azithromycin"], ["macrolide", "erythromycin"], ["macrolide", "clarithromycin"],
        ["aminoglycoside", "gentamicin"], ["aminoglycoside", "tobramycin"],
        ["aminoglycoside", "amikacin"], ["aminoglycoside", "neomycin"], ["aminoglycoside", "streptomycin"],
        ["tetracycline", "doxycycline"], ["tetracycline", "minocycline"],
        ["tetracycline", "tetracycline"], ["tetracycline", "tigecycline"],
        ["nsaid", "ibuprofen"], ["nsaid", "naproxen"], ["nsaid", "ketorolac"],
        ["nsaid", "indomethacin"], ["nsaid", "diclofenac"], ["nsaid", "meloxicam"],
        ["nsaid", "celecoxib"], ["nsaid", "aspirin"],
        ["statin", "atorvastatin"], ["statin", "simvastatin"], ["statin", "rosuvastatin"],
        ["statin", "pravastatin"], ["statin", "lovastatin"], ["statin", "pitavastatin"],
        ["acei", "lisinopril"], ["acei", "enalapril"], ["acei", "ramipril"], ["acei", "captopril"],
        ["acei", "benazepril"], ["acei", "quinapril"],
        ["arb", "losartan"], ["arb", "valsartan"], ["arb", "irbesartan"], ["arb", "olmesartan"],
        ["arb", "candesartan"], ["arb", "telmisartan"],
        ["heparinoid", "heparin"], ["heparinoid", "enoxaparin"], ["heparinoid", "dalteparin"],
        ["heparinoid", "fondaparinux"],
        ["iodinated-contrast", "iohexol"], ["iodinated-contrast", "iopamidol"],
        ["iodinated-contrast", "ioversol"],
        ["benzodiazepine", "lorazepam"], ["benzodiazepine", "midazolam"], ["benzodiazepine", "diazepam"],
        ["benzodiazepine", "alprazolam"], ["benzodiazepine", "clonazepam"], ["benzodiazepine", "temazepam"],
        ["benzodiazepine", "chlordiazepoxide"], ["benzodiazepine", "oxazepam"],
        ["opioid-other", "tramadol"], ["opioid-other", "tapentadol"],
        ["beta-lactam", "aztreonam"],
        ["ssri", "sertraline"], ["ssri", "fluoxetine"], ["ssri", "escitalopram"],
        ["ssri", "citalopram"], ["ssri", "paroxetine"], ["ssri", "fluvoxamine"],
        ["beta-lactam", "penicillin"], ["beta-lactam", "amoxicillin"], ["beta-lactam", "ampicillin"],
        ["beta-lactam", "nafcillin"], ["beta-lactam", "oxacillin"], ["beta-lactam", "dicloxacillin"],
        ["beta-lactam", "piperacillin"], ["beta-lactam", "cefazolin"], ["beta-lactam", "cephalexin"],
        ["beta-lactam", "cefuroxime"], ["beta-lactam", "ceftriaxone"], ["beta-lactam", "cefotaxime"],
        ["beta-lactam", "ceftazidime"], ["beta-lactam", "cefepime"], ["beta-lactam", "cefdinir"],
        ["beta-lactam", "cefpodoxime"], ["beta-lactam", "ceftaroline"], ["beta-lactam", "ceftolozane"],
        ["beta-lactam", "meropenem"], ["beta-lactam", "imipenem"], ["beta-lactam", "ertapenem"],
        ["beta-lactam", "doripenem"]
    ]
}

RefSeed_QT() {
    return [
        ["amiodarone", "known", "Known TdP risk; monitor QTc and electrolytes"],
        ["sotalol", "known", "Known TdP risk; dose by renal function, inpatient initiation"],
        ["dofetilide", "known", "Known TdP risk; mandatory renal dosing and QTc protocol"],
        ["ibutilide", "known", "Known TdP risk"],
        ["procainamide", "known", "Known TdP risk"],
        ["quinidine", "known", "Known TdP risk"],
        ["haloperidol", "known", "Higher risk with IV administration"],
        ["droperidol", "known", "Boxed warning for QT/TdP"],
        ["methadone", "known", "Dose-related QT prolongation"],
        ["citalopram", "known", "Max 20 mg/day if age >60, hepatic impairment, or CYP2C19 PM"],
        ["escitalopram", "possible", "Lower risk than citalopram; still dose-related"],
        ["ondansetron", "known", "Avoid single IV doses >16 mg"],
        ["azithromycin", "known", "QT prolongation reported"],
        ["clarithromycin", "known", "QT prolongation plus CYP3A4 interaction risk"],
        ["erythromycin", "known", "Known TdP risk, especially IV"],
        ["levofloxacin", "known", "Fluoroquinolone class QT effect"],
        ["moxifloxacin", "known", "Highest QT effect of the class"],
        ["ciprofloxacin", "possible", "Lower QT effect than moxifloxacin"],
        ["fluconazole", "known", "Dose-related QT prolongation"],
        ["voriconazole", "known", "QT prolongation reported"],
        ["chlorpromazine", "known", "Known TdP risk"],
        ["quetiapine", "possible", "Conditional/possible risk"],
        ["olanzapine", "possible", "Conditional risk"],
        ["risperidone", "possible", "Conditional risk"],
        ["ziprasidone", "known", "Greatest QT effect among atypicals"],
        ["hydroxyzine", "possible", "QT prolongation reported"],
        ["promethazine", "possible", "Conditional risk"],
        ["donepezil", "possible", "Conditional risk"],
        ["hydroxychloroquine", "possible", "Conditional risk, additive with other QT drugs"],
        ["sevoflurane", "possible", "Conditional risk"],
        ["tacrolimus", "possible", "Conditional risk"],
        ["famotidine", "conditional", "Risk mainly with renal impairment/high dose"],
        ["loperamide", "conditional", "Risk at supratherapeutic doses"]
    ]
}

RefSeed_Beers() {
    return [
        ["diphenhydramine", "Avoid", "First-generation antihistamine; anticholinergic, sedation, delirium"],
        ["hydroxyzine", "Avoid", "First-generation antihistamine; anticholinergic burden"],
        ["promethazine", "Avoid", "First-generation antihistamine; anticholinergic, sedation"],
        ["meclizine", "Avoid", "First-generation antihistamine; anticholinergic"],
        ["cyproheptadine", "Avoid", "First-generation antihistamine; anticholinergic"],
        ["lorazepam", "Avoid", "Benzodiazepine; falls, fractures, delirium"],
        ["diazepam", "Avoid", "Long-acting benzodiazepine; accumulates"],
        ["alprazolam", "Avoid", "Benzodiazepine; falls, cognitive impairment"],
        ["clonazepam", "Avoid", "Benzodiazepine; falls, cognitive impairment"],
        ["temazepam", "Avoid", "Benzodiazepine; falls, cognitive impairment"],
        ["midazolam", "Avoid", "Benzodiazepine; procedural use is an exception"],
        ["zolpidem", "Avoid", "Z-drug; falls, fractures, delirium"],
        ["eszopiclone", "Avoid", "Z-drug; falls, fractures, delirium"],
        ["zaleplon", "Avoid", "Z-drug; falls, fractures"],
        ["amitriptyline", "Avoid", "TCA; strongly anticholinergic, orthostasis"],
        ["nortriptyline", "Use with caution", "TCA; less anticholinergic but still cautioned"],
        ["doxepin", "Avoid", "Avoid doses >6 mg/day"],
        ["paroxetine", "Avoid", "Most anticholinergic SSRI"],
        ["haloperidol", "Avoid", "Antipsychotic; increased mortality in dementia"],
        ["quetiapine", "Avoid", "Antipsychotic; exception for Parkinson disease psychosis"],
        ["olanzapine", "Avoid", "Antipsychotic; increased mortality in dementia"],
        ["risperidone", "Avoid", "Antipsychotic; increased mortality in dementia"],
        ["cyclobenzaprine", "Avoid", "Skeletal muscle relaxant; anticholinergic, sedation, falls"],
        ["methocarbamol", "Avoid", "Skeletal muscle relaxant; sedation, falls"],
        ["carisoprodol", "Avoid", "Skeletal muscle relaxant; sedation, dependence"],
        ["metaxalone", "Avoid", "Skeletal muscle relaxant; sedation"],
        ["oxybutynin", "Avoid", "Strongly anticholinergic; delirium risk"],
        ["tolterodine", "Use with caution", "Anticholinergic; prefer lower-risk agents"],
        ["ketorolac", "Avoid", "GI bleeding and AKI risk in older adults"],
        ["indomethacin", "Avoid", "Highest CNS adverse effects of the NSAIDs"],
        ["ibuprofen", "Use with caution", "Avoid chronic use without GI protection"],
        ["naproxen", "Use with caution", "Avoid chronic use without GI protection"],
        ["meperidine", "Avoid", "Neurotoxic metabolite; especially in renal impairment"],
        ["glyburide", "Avoid", "Prolonged hypoglycemia in older adults"],
        ["chlorpropamide", "Avoid", "Prolonged hypoglycemia, SIADH"],
        ["glimepiride", "Avoid", "Sulfonylurea hypoglycemia risk"],
        ["digoxin", "Use with caution", "Avoid >0.125 mg/day; not first line for AF or HF"],
        ["amiodarone", "Use with caution", "Not first line for AF unless HF or LVH"],
        ["nitrofurantoin", "Avoid", "Avoid if CrCl <30 mL/min or for long-term suppression"],
        ["doxazosin", "Avoid", "Alpha-1 blocker; orthostatic hypotension if used for hypertension"],
        ["terazosin", "Avoid", "Alpha-1 blocker; orthostatic hypotension if used for hypertension"],
        ["prazosin", "Use with caution", "Orthostasis"],
        ["clonidine", "Avoid", "Central alpha agonist; CNS effects, bradycardia, orthostasis"],
        ["methyldopa", "Avoid", "Central alpha agonist; bradycardia, CNS effects"],
        ["megestrol", "Avoid", "Minimal effect on weight, increases thrombosis risk"],
        ["metoclopramide", "Avoid", "Avoid >12 weeks; extrapyramidal effects"],
        ["proton pump inhibitor", "Use with caution", "Avoid >8 weeks without indication"],
        ["omeprazole", "Use with caution", "Avoid >8 weeks without documented indication"],
        ["pantoprazole", "Use with caution", "Avoid >8 weeks without documented indication"],
        ["phenobarbital", "Avoid", "Barbiturate; high dependence and sedation risk"],
        ["theophylline", "Avoid", "Narrow therapeutic index, toxicity risk"],
        ["dipyridamole", "Avoid", "Orthostatic hypotension (oral short-acting)"],
        ["benztropine", "Avoid", "Anticholinergic; avoid for prevention of EPS"],
        ["scopolamine", "Avoid", "Strongly anticholinergic"],
        ["dicyclomine", "Avoid", "Antispasmodic; strongly anticholinergic"],
        ["hyoscyamine", "Avoid", "Antispasmodic; strongly anticholinergic"],
        ["estrogen", "Avoid", "Systemic estrogen; vaginal formulations are an exception"],
        ["testosterone", "Use with caution", "Cardiac risk unless confirmed hypogonadism"],
        ["aspirin", "Use with caution", "Avoid for primary prevention of ASCVD in adults 70+"]
    ]
}

RefSeed_MG() {
    return [
        ["gentamicin", "avoid", "Aminoglycosides can worsen neuromuscular transmission"],
        ["tobramycin", "avoid", "Aminoglycoside neuromuscular blockade"],
        ["amikacin", "avoid", "Aminoglycoside neuromuscular blockade"],
        ["neomycin", "avoid", "Aminoglycoside neuromuscular blockade"],
        ["streptomycin", "avoid", "Aminoglycoside neuromuscular blockade"],
        ["telithromycin", "avoid", "Contraindicated in myasthenia gravis"],
        ["ciprofloxacin", "caution", "Fluoroquinolone class exacerbation reports"],
        ["levofloxacin", "caution", "Fluoroquinolone class exacerbation reports"],
        ["moxifloxacin", "caution", "Fluoroquinolone class exacerbation reports"],
        ["azithromycin", "caution", "Macrolide exacerbation reports"],
        ["erythromycin", "caution", "Macrolide exacerbation reports"],
        ["clarithromycin", "caution", "Macrolide exacerbation reports"],
        ["magnesium sulfate", "avoid", "IV magnesium can precipitate crisis; obstetric use requires monitoring"],
        ["propranolol", "caution", "Beta-blockers may worsen weakness"],
        ["metoprolol", "caution", "Beta-blockers may worsen weakness"],
        ["atenolol", "caution", "Beta-blockers may worsen weakness"],
        ["timolol", "caution", "Includes ophthalmic absorption"],
        ["verapamil", "caution", "Calcium channel blocker reports"],
        ["quinine", "avoid", "Well-documented worsening"],
        ["quinidine", "avoid", "Well-documented worsening"],
        ["procainamide", "caution", "May worsen neuromuscular transmission"],
        ["chloroquine", "caution", "Reported exacerbation"],
        ["hydroxychloroquine", "caution", "Reported exacerbation"],
        ["penicillamine", "avoid", "Can induce myasthenia gravis"],
        ["atorvastatin", "caution", "Statin class exacerbation reports"],
        ["simvastatin", "caution", "Statin class exacerbation reports"],
        ["rosuvastatin", "caution", "Statin class exacerbation reports"],
        ["succinylcholine", "caution", "Altered/unpredictable response; anesthesia consult"],
        ["rocuronium", "caution", "Marked sensitivity; reduce dose, use monitoring"],
        ["vecuronium", "caution", "Marked sensitivity; reduce dose, use monitoring"],
        ["phenytoin", "caution", "May worsen weakness"],
        ["lithium", "caution", "May worsen weakness"],
        ["interferon alfa", "caution", "Reported induction/exacerbation"],
        ["pembrolizumab", "caution", "Checkpoint inhibitor myasthenic syndrome reported"],
        ["nivolumab", "caution", "Checkpoint inhibitor myasthenic syndrome reported"],
        ["iohexol", "caution", "Iodinated contrast exacerbation reports"],
        ["prednisone", "caution", "Transient worsening during initiation is expected"],
        ["methylprednisolone", "caution", "Transient worsening during high-dose initiation"],
        ["botulinum toxin", "avoid", "Direct neuromuscular blockade"]
    ]
}

RefSeed_G6PD() {
    return [
        ["rasburicase", "high", "Labeling states do not administer with G6PD deficiency; screen at-risk patients"],
        ["dapsone", "high", "Dose-dependent hemolysis and methemoglobinemia"],
        ["primaquine", "high", "Screen G6PD before use"],
        ["tafenoquine", "high", "Screen G6PD before use"],
        ["methylene blue", "high", "Can cause hemolysis and is ineffective for methemoglobinemia in G6PD deficiency"],
        ["pegloticase", "high", "Contraindicated in G6PD deficiency"],
        ["toluidine blue", "high", "Hemolysis risk"],
        ["nitrofurantoin", "medium", "Hemolysis reported"],
        ["phenazopyridine", "medium", "Hemolysis reported"],
        ["sulfamethoxazole", "medium", "Variable evidence; hemolysis reported"],
        ["sulfadiazine", "medium", "Hemolysis reported"],
        ["quinine", "medium", "Hemolysis reported"],
        ["chloroquine", "medium", "Hemolysis reported, usually with higher doses"],
        ["hydroxychloroquine", "low", "Low risk at usual doses"],
        ["ciprofloxacin", "low", "Low risk; case reports only"],
        ["ascorbic acid", "low", "High-dose IV vitamin C associated with hemolysis"],
        ["glyburide", "low", "Low risk"],
        ["aspirin", "low", "Risk mainly at high antipyretic doses"]
    ]
}

RefSeed_RenalRules() {
    return [
        ["vancomycin", "level", "", "", "AUC/level and renal-trajectory guided"],
        ["gentamicin", "level", "", "", "Level and renal-function guided"],
        ["tobramycin", "level", "", "", "Level and renal-function guided"],
        ["amikacin", "level", "", "", "Level and renal-function guided"],
        ["digoxin", "level", "", "", "Dose, level, indication, and renal function require review"],
        ["lithium", "level", "", "", "Level, hydration, interactions, and renal function require review"],
        ["acyclovir", "threshold", "60", "", "Verify dose/interval and hydration; IV therapy carries crystal-nephropathy risk"],
        ["valacyclovir", "threshold", "60", "", "Verify indication-specific dose and interval"],
        ["valganciclovir", "threshold", "60", "", "Dose is strongly renal-function dependent"],
        ["oseltamivir", "threshold", "60", "", "Verify treatment vs prophylaxis regimen and renal interval"],
        ["cefepime", "threshold", "60", "", "Verify indication, infusion strategy, and neurotoxicity risk"],
        ["ceftazidime", "threshold", "60", "", "Verify dose and interval"],
        ["cefazolin", "threshold", "60", "", "Verify indication and interval"],
        ["cephalexin", "threshold", "60", "", "Verify dose and interval"],
        ["ciprofloxacin", "threshold", "60", "", "Verify route, indication, and interval"],
        ["levofloxacin", "threshold", "60", "", "Verify indication-specific loading and interval"],
        ["ertapenem", "threshold", "60", "30", "Dose reduction is commonly required in severe impairment"],
        ["meropenem", "threshold", "60", "", "Verify indication, dose, and interval"],
        ["imipenem-cilastatin", "threshold", "60", "", "Verify dose and seizure risk"],
        ["piperacillin-tazobactam", "threshold", "60", "", "Verify infusion strategy and interval"],
        ["trimethoprim-sulfamethoxazole", "threshold", "60", "15", "Verify indication, dose, potassium, and marrow toxicity"],
        ["sulfamethoxazole-trimethoprim", "threshold", "60", "15", "Verify indication, dose, potassium, and marrow toxicity"],
        ["fluconazole", "threshold", "60", "", "Full loading dose is generally retained; verify maintenance adjustment"],
        ["enoxaparin", "threshold", "60", "30", "Verify indication-specific dose; accumulation increases in severe impairment"],
        ["apixaban", "threshold", "60", "", "Renal criteria differ by indication; do not apply AF criteria to VTE"],
        ["rivaroxaban", "threshold", "60", "15", "Verify indication-specific eligibility and dose"],
        ["dabigatran", "threshold", "60", "30", "Strong renal dependence; verify indication and interaction profile"],
        ["edoxaban", "threshold", "60", "15", "Verify indication-specific eligibility and dose"],
        ["fondaparinux", "threshold", "50", "30", "Avoid in severe renal impairment per labeling"],
        ["sotalol", "threshold", "60", "40", "Interval and eligibility depend on renal function and indication"],
        ["dofetilide", "threshold", "60", "20", "Dose must use Cockcroft-Gault CrCl; contraindicated below labeled threshold"],
        ["metformin", "threshold", "45", "30", "Use eGFR-based labeling for initiation/continuation decisions"],
        ["sitagliptin", "threshold", "45", "", "Dose is renal-function dependent"],
        ["glyburide", "threshold", "60", "30", "Higher prolonged hypoglycemia risk; generally avoid in significant impairment"],
        ["gabapentin", "threshold", "60", "", "Total daily dose and interval are renal-function dependent"],
        ["pregabalin", "threshold", "60", "", "Total daily dose is renal-function dependent"],
        ["baclofen", "threshold", "60", "30", "Neurotoxicity can occur with accumulation; avoid or use extreme caution in advanced CKD"],
        ["tramadol", "threshold", "30", "", "Verify interval and maximum dose"],
        ["morphine", "threshold", "60", "30", "Active metabolites accumulate; consider alternative opioid in advanced CKD"],
        ["duloxetine", "threshold", "30", "30", "Generally avoid below labeled renal threshold"],
        ["topiramate", "threshold", "70", "", "Dose reduction may be needed"],
        ["levetiracetam", "threshold", "80", "", "Maintenance dose is renal-function dependent"],
        ["famotidine", "threshold", "60", "", "Dose/interval adjustment may be needed"],
        ["metoclopramide", "threshold", "60", "", "Dose reduction may be needed; monitor EPS"],
        ["nitrofurantoin", "threshold", "45", "30", "Verify indication and renal eligibility; avoid for pyelonephritis regardless"],
        ["alendronate", "threshold", "35", "35", "Not recommended below labeled threshold"],
        ["risedronate", "threshold", "30", "30", "Not recommended below labeled threshold"],
        ["zoledronic", "threshold", "35", "35", "Product/indication thresholds differ; verify label and SCr"],
        ["methotrexate", "threshold", "60", "30", "Clearance is renal; toxicity risk rises sharply with impairment"],
        ["spironolactone", "threshold", "45", "30", "Verify potassium, indication, and renal eligibility"],
        ["eplerenone", "threshold", "50", "30", "Eligibility differs by indication; verify potassium and label"]
        , ["amoxicillin-clavulanate", "threshold", "30", "", "Verify indication, formulation, dose, and interval"]
        , ["cefdinir", "threshold", "60", "", "Verify dose and interval"]
        , ["famciclovir", "threshold", "60", "", "Verify indication-specific dose and interval"]
        , ["fluoxetine", "review", "", "", "Usually no routine renal adjustment; review active metabolites and clinical context"]
        , ["venlafaxine", "threshold", "70", "", "Reduce total daily dose or adjust interval per product labeling and indication"]
        , ["allopurinol", "threshold", "60", "", "Start/maintain dose requires indication, urate response, toxicity, and renal review"]
        , ["colchicine", "threshold", "60", "30", "Indication- and repeat-course-specific renal restrictions; review interacting CYP3A4/P-gp drugs"]
        , ["insulin", "review", "", "", "Insulin requirements and hypoglycemia risk may change as kidney function declines"]
    ]
}

RefSeed_CrushV2() {
    return [
        ["extended release", "form", "extended release|\\ber\\b|\\bxr\\b|\\bxl\\b|\\bsr\\b|\\bcr\\b|\\bla\\b", "any", "DO NOT CRUSH", "Modified-release product; crushing may cause dose dumping"],
        ["delayed release", "form", "delayed release|\\bdr\\b", "any", "DO NOT CRUSH", "Delayed-release coating protects drug or stomach"],
        ["enteric coated", "form", "enteric coated|enteric-coated|\\bec\\b", "any", "DO NOT CRUSH", "Enteric coating protects drug or gastric mucosa"],
        ["sublingual", "form", "sublingual|\\bsl\\b", "oral", "DO NOT CRUSH", "Designed for sublingual absorption"],
        ["buccal", "form", "buccal", "oral", "DO NOT CRUSH", "Designed for buccal absorption"],
        ["dabigatran", "drug", "capsule|cap", "any", "DO NOT OPEN", "Opening the capsule substantially increases bioavailability"],
        ["mycophenolate", "drug", "", "any", "HAZARDOUS - USE ALTERNATIVE", "Hazardous/teratogenic handling; use an appropriate commercial liquid when indicated"],
        ["methotrexate", "drug", "", "any", "HAZARDOUS - DO NOT CRUSH", "Hazardous drug handling precautions apply"],
        ["finasteride", "drug", "", "any", "DO NOT CRUSH", "Pregnancy handling precaution for broken/crushed tablets"],
        ["dutasteride", "drug", "capsule|cap", "any", "DO NOT OPEN", "Pregnancy handling precaution; avoid contact with leaking capsules"],
        ["temozolomide", "drug", "capsule|cap", "any", "CYTOTOXIC - DO NOT OPEN", "Cytotoxic capsule"],
        ["capecitabine", "drug", "", "any", "CYTOTOXIC - DO NOT CRUSH", "Cytotoxic tablet"],
        ["lenalidomide", "drug", "capsule|cap", "any", "HAZARDOUS - DO NOT OPEN", "Hazardous capsule"],
        ["potassium chloride", "drug", "extended release|wax matrix|\\ber\\b|\\bcr\\b|\\bsr\\b", "any", "DO NOT CRUSH", "Modified-release potassium can cause dose dumping and GI injury"],
        ["nifedipine", "drug", "extended release|\\ber\\b|\\bxl\\b|\\bcr\\b", "any", "DO NOT CRUSH", "Applies to modified-release products"],
        ["diltiazem", "drug", "extended release|\\bcd\\b|\\bxr\\b|\\bla\\b|\\ber\\b", "any", "DO NOT CRUSH", "Applies to modified-release products; some capsules have bead-specific instructions"],
        ["metoprolol succinate", "drug", "", "any", "MAY SPLIT IF SCORED - DO NOT CRUSH OR CHEW", "Extended-release succinate tablets may be divided only when the specific tablet is scored and the product labeling permits splitting; swallow each half whole"],
        ["bupropion", "drug", "\\bsr\\b|\\bxl\\b|extended release|sustained release", "any", "DO NOT CRUSH", "Applies to SR/XL products"],
        ["venlafaxine", "drug", "\\bxr\\b|extended release", "any", "PRODUCT-SPECIFIC", "XR capsules may have labeled sprinkle instructions; do not crush pellets/tablets"],
        ["oxycodone", "drug", "extended release|\\ber\\b|\\bcr\\b|oxycontin", "any", "DO NOT CRUSH", "Modified-release opioid; potentially fatal dose dumping"],
        ["morphine", "drug", "extended release|\\ber\\b|\\bsr\\b|\\bcr\\b|ms contin", "any", "DO NOT CRUSH", "Modified-release opioid; potentially fatal dose dumping"],
        ["hydromorphone", "drug", "extended release|\\ber\\b|exalgo", "any", "DO NOT CRUSH", "Modified-release opioid; potentially fatal dose dumping"],
        ["tamsulosin", "drug", "capsule|cap", "any", "DO NOT CRUSH", "Modified-release capsule; product-specific administration"],
        ["pancrelipase", "drug", "", "enteral", "DO NOT CRUSH MICROSPHERES", "Enteric-coated microspheres; tube administration requires product/tube-specific technique"],
        ["alendronate", "drug", "", "any", "DO NOT CRUSH", "Esophageal/mucosal injury risk and administration requirements"],
        ["omeprazole", "drug", "delayed release|\\bdr\\b|capsule|cap", "enteral", "PRODUCT-SPECIFIC", "Granules may be administered only using labeled product-specific instructions"],
        ["pantoprazole", "drug", "delayed release|\\bdr\\b|tablet|tab", "enteral", "USE SUSPENSION PACKET", "Delayed-release tablet should not be crushed"],
        ["esomeprazole", "drug", "delayed release|\\bdr\\b|capsule|cap", "enteral", "PRODUCT-SPECIFIC", "Use labeled granule/capsule administration instructions"],
        ["levetiracetam", "drug", "extended release|\\bxr\\b", "any", "DO NOT CRUSH", "Applies to XR product; immediate-release tablets differ"],
        ["carbamazepine", "drug", "extended release|\\bxr\\b|\\bcr\\b", "any", "DO NOT CRUSH", "Applies to modified-release products"],
        ["nitroglycerin", "drug", "sublingual|\\bsl\\b", "oral", "DO NOT CRUSH", "Designed for sublingual absorption"],
        ["isosorbide mononitrate", "drug", "extended release|\\ber\\b", "any", "DO NOT CRUSH", "Applies to extended-release products"]
    ]
}

RefSeed_Crush() {
    return [
        ["extended release", "form", "Extended-release matrix; crushing causes dose dumping"],
        ["delayed release", "form", "Delayed-release coating protects drug or stomach"],
        ["enteric coated", "form", "Enteric coating protects drug or gastric mucosa"],
        ["sustained release", "form", "Modified release; do not crush"],
        ["controlled release", "form", "Modified release; do not crush"],
        ["sublingual", "form", "Designed for sublingual absorption"],
        ["buccal", "form", "Designed for buccal absorption"],
        [" er ", "form", "ER designation; do not crush"],
        [" xr ", "form", "XR designation; do not crush"],
        [" xl ", "form", "XL designation; do not crush"],
        [" sr ", "form", "SR designation; do not crush"],
        [" cr ", "form", "CR designation; do not crush"],
        [" dr ", "form", "DR designation; do not crush"],
        [" ec ", "form", "EC designation; do not crush"],
        [" la ", "form", "LA designation; do not crush"],
        ["dabigatran", "drug", "Capsule must not be opened; bioavailability increases about 75 percent"],
        ["mycophenolate", "drug", "Hazardous and teratogenic; avoid crushing, use suspension"],
        ["methotrexate", "drug", "Hazardous drug; do not crush"],
        ["finasteride", "drug", "Teratogen handling precaution; do not crush"],
        ["dutasteride", "drug", "Teratogen handling precaution; do not open"],
        ["temozolomide", "drug", "Cytotoxic; do not open capsule"],
        ["capecitabine", "drug", "Cytotoxic; do not crush"],
        ["lenalidomide", "drug", "Hazardous; do not open capsule"],
        ["potassium chloride", "drug", "Wax matrix or ER products; do not crush"],
        ["nifedipine", "drug", "ER products only; immediate-release forms differ"],
        ["diltiazem", "drug", "CD/XR/LA products; do not crush"],
        ["metoprolol succinate", "drug", "ER product; scored tablets may be split when labeling permits, but do not crush or chew"],
        ["bupropion", "drug", "SR/XL products; do not crush"],
        ["venlafaxine", "drug", "XR capsule may be opened onto food; tablets ER should not be crushed"],
        ["oxycodone", "drug", "ER products; crushing causes fatal dose dumping"],
        ["morphine", "drug", "ER products; crushing causes fatal dose dumping"],
        ["hydromorphone", "drug", "ER products; crushing causes fatal dose dumping"],
        ["tamsulosin", "drug", "Modified release capsule; do not crush"],
        ["pancrelipase", "drug", "Enteric-coated microspheres; do not crush"],
        ["alendronate", "drug", "Esophageal irritant; do not crush"],
        ["omeprazole", "drug", "Delayed release; granules may be given per labeling instructions"],
        ["pantoprazole", "drug", "Delayed release tablet should not be crushed; use suspension packet"],
        ["esomeprazole", "drug", "Delayed release; open capsule per labeling only"],
        ["levetiracetam", "drug", "XR products only; immediate-release tablets may be crushed"],
        ["carbamazepine", "drug", "XR products; do not crush"],
        ["nitroglycerin", "drug", "Sublingual; do not crush"],
        ["isosorbide mononitrate", "drug", "ER products; do not crush"]
    ]
}

; =================================================================================================
; DRUG NORMALIZATION  (blueprint §3 "Medication normalization will use ingredient-level concepts")
; =================================================================================================

RxN_AliasMap() {
    global RxNAliasCache
    if !IsSet(RxNAliasCache) || !IsObject(RxNAliasCache)
        RxNAliasCache := Map()
    if IsObject(RxNAliasCache) && RxNAliasCache.Count > 0
        return RxNAliasCache
    m := Map()
    for r in RefData_Rows("drug_aliases") {
        a := RxN_Simplify(r.Has("alias") ? r["alias"] : "")
        g := Trim(r.Has("ingredient") ? r["ingredient"] : "")
        if a != "" && g != ""
            m[a] := StrLower(g)
    }
    RxNAliasCache := m
    return m
}

RxN_Simplify(s) {
    s := StrLower(Trim(String(s)))
    s := RegExReplace(s, "[^a-z0-9/\- ]", " ")
    s := RegExReplace(s, "\s+", " ")
    return Trim(s)
}

RxN_SaltTokens() {
    static t := ["hcl", "hydrochloride", "hbr", "hydrobromide", "sulfate", "sulphate", "mesylate",
        "besylate", "tartrate", "bitartrate", "maleate", "fumarate", "succinate", "citrate",
        "acetate", "tromethamine", "tosylate", "napsylate", "pamoate", "valerate", "propionate",
        "dipropionate", "furoate", "xinafoate", "lactate", "gluconate", "bromide", "nitrate",
        "oxalate", "monohydrate", "dihydrate", "anhydrous", "micronized", "base", "salt",
        "hemihydrate", "sesquihydrate", "disodium", "dipotassium", "hyclate", "monohydrate"]
    return t
}

; Canonical ingredient key for one drug name fragment.
RxN_IngredientKey(name) {
    s := RxN_Simplify(name)
    if s = ""
        return ""

    ; strip dosage-form and release descriptors that are not part of the ingredient
    s := RegExReplace(s, "i)\b(tab|tabs|tablet|tablets|cap|caps|capsule|capsules|inj|injection|"
        . "soln|solution|susp|suspension|syrup|elixir|patch|cream|ointment|gel|drops|"
        . "supp|suppository|inhaler|neb|nebulizer|vial|syringe|premix|piggyback|ivpb|"
        . "er|xr|xl|sr|cr|dr|ec|la|ds|odt|hfa|extended|delayed|sustained|controlled|release|"
        . "oral|intravenous)\b", " ")
    s := RegExReplace(s, "\s+", " ")
    s := Trim(s)
    if s = ""
        return ""

    alias := RxN_AliasMap()
    if alias.Has(s)
        return alias[s]

    ; salt/ester stripping, but never down to an empty string
    words := StrSplit(s, " ")
    kept := []
    for w in words {
        isSalt := false
        for t in RxN_SaltTokens() {
            if w = t {
                isSalt := true
                break
            }
        }
        if !isSalt
            kept.Push(w)
    }
    if kept.Length > 0 {
        cand := Trim(RegExReplace(Format("{1}", RxN_JoinWords(kept)), "\s+", " "))
        if cand != "" {
            if alias.Has(cand)
                return alias[cand]
            s := cand
        }
    }

    ; salt words that are also ingredients (sodium/potassium/calcium/magnesium) handled by alias map
    if alias.Has(s)
        return alias[s]

    return s
}

RxN_JoinWords(arr) {
    out := ""
    for w in arr
        out .= (out = "" ? "" : " ") w
    return out
}

; Split a product name into ingredient keys (handles combination products).
RxN_Ingredients(name) {
    s := RxN_Simplify(name)
    if s = ""
        return []

    alias := RxN_AliasMap()
    if alias.Has(s) {
        mapped := alias[s]
        if InStr(mapped, "/") {
            out := []
            for part in StrSplit(mapped, "/") {
                k := RxN_IngredientKey(part)
                if k != "" && !RxN_HasKey(out, k)
                    out.Push(k)
            }
            return out
        }
        return [mapped]
    }

    parts := []
    tmp := StrReplace(s, "/", "|")
    tmp := RegExReplace(tmp, "\s+-\s+", "|")
    for p in StrSplit(tmp, "|")
        parts.Push(p)

    ; a single hyphenated token may still be a combination (sulfamethoxazole-trimethoprim)
    if parts.Length = 1 && InStr(parts[1], "-") {
        left := ""
        right := ""
        if RegExMatch(parts[1], "^([a-z]{5,})-([a-z]{5,})$", &mm) {
            left := mm[1]
            right := mm[2]
            parts := [left, right]
        }
    }

    out := []
    for p in parts {
        k := RxN_IngredientKey(p)
        if k = ""
            continue
        ; an alias may resolve to a combination concept ("bactrim ds" -> a/b); expand it
        if InStr(k, "/") {
            for sub in StrSplit(k, "/") {
                sk := Trim(sub)
                if sk != "" && !RxN_HasKey(out, sk)
                    out.Push(sk)
            }
            continue
        }
        if !RxN_HasKey(out, k)
            out.Push(k)
    }
    return out
}

RxN_HasKey(arr, k) {
    for v in arr {
        if v = k
            return true
    }
    return false
}


; RC6 compact medication SIG normalization.
; The MedRec output intentionally uses short clinical frequencies instead of reproducing a full sig.
Sig_CompactFrequency(value, isPrn := false) {
    v := StrLower(Trim(value))
    v := RegExReplace(v, "[\.\,]", "")
    v := RegExReplace(v, "\s+", " ")
    if RegExMatch(v, "i)\b(?:prn|as\s+needed)\b")
        isPrn := true

    out := ""
    if v = ""
        out := ""
    else if RegExMatch(v, "i)\b(q\s*day|every\s*day|once\s*daily|daily|qd)\b")
        out := "QD"
    else if RegExMatch(v, "i)\b(twice\s*daily|two\s*times\s*daily|bid)\b")
        out := "BID"
    else if RegExMatch(v, "i)\b(three\s*times\s*daily|tid)\b")
        out := "TID"
    else if RegExMatch(v, "i)\b(four\s*times\s*daily|qid)\b")
        out := "QID"
    else if RegExMatch(v, "i)\b(at\s*bedtime|bedtime|nightly|qhs|hs)\b")
        out := "QHS"
    else if RegExMatch(v, "i)\b(every\s*other\s*day|qod)\b")
        out := "QOD"
    else if RegExMatch(v, "i)\b(every\s*morning|qam)\b")
        out := "QAM"
    else if RegExMatch(v, "i)\b(every\s*evening|qpm)\b")
        out := "QPM"
    else if RegExMatch(v, "i)\b(weekly|once\s*weekly|qweek)\b")
        out := "QWEEK"
    else if RegExMatch(v, "i)\b(mon(?:day)?\s*/?\s*wed(?:nesday)?\s*/?\s*fri(?:day)?|mwf)\b")
        out := "MWF"
    else if RegExMatch(v, "i)\bq\s*(\d+)\s*(?:h|hr|hrs|hour|hours)\b", &m)
        out := "Q" m[1] "H"
    else if RegExMatch(v, "i)\bevery\s*(\d+)\s*(?:h|hr|hrs|hour|hours)\b", &m)
        out := "Q" m[1] "H"
    else if RegExMatch(v, "i)\bq\s*(\d+)\s*(?:min|mins|minute|minutes)\b", &m)
        out := "Q" m[1] "MIN"
    else if RegExMatch(v, "i)\bevery\s*(\d+)\s*(?:min|mins|minute|minutes)\b", &m)
        out := "Q" m[1] "MIN"
    else if RegExMatch(v, "i)\b(x\s*1|once)\b")
        out := "X1"
    else
        out := StrUpper(Trim(value))

    if isPrn && !InStr(out, "PRN")
        out .= (out = "" ? "" : " ") "PRN"
    return out
}

Sig_CompactFromMedication(med) {
    freq := ""
    prn := false
    if IsObject(med) {
        if med.HasOwnProp("freq")
            freq := med.freq
        if med.HasOwnProp("prn")
            prn := med.prn
    }
    return Sig_CompactFrequency(freq, prn)
}


; Full order-line normalization. Returns an object, never throws.
RxN_Normalize(text) {
    raw := Trim(String(text))
    rec := {
        raw: raw,
        name: "",
        ingredients: [],
        primary: "",
        brand: "",
        strength: "",
        dose: "",
        doseNum: "",
        doseUnit: "",
        conc: "",
        route: "",
        form: "",
        freq: "",
        status: "",
        statusCategory: "active",
        prn: false,
        lowConfidence: false,
        captureState: "captured",
        captureReason: "",
        lastFill: "",
        daysSupply: "",
        refills: "",
        startAt: "",
        stopAt: "",
        orderType: ""
    }
    if raw = ""
        return rec

    work := raw
    if InStr(work, "[MISSING DOSE]")
        rec.lowConfidence := true
    if InStr(work, "[VERIFY OCR]") {
        rec.lowConfidence := true
        work := StrReplace(work, "[VERIFY OCR]", "")
    }
    if RegExMatch(work, "i)\[LASTFILL=([^\]]+)\]", &lf)
        rec.lastFill := Trim(lf[1])
    if RegExMatch(work, "i)\[DS=([^\]]+)\]", &ds)
        rec.daysSupply := Trim(ds[1])
    if RegExMatch(work, "i)\[RR=([^\]]+)\]", &rr)
        rec.refills := Trim(rr[1])
    if RegExMatch(work, "i)\[START=([^\]]+)\]", &st)
        rec.startAt := Trim(st[1])
    if RegExMatch(work, "i)\[STOP=([^\]]+)\]", &sp)
        rec.stopAt := Trim(sp[1])
    if RegExMatch(work, "i)\[ORDERTYPE=([^\]]+)\]", &ot)
        rec.orderType := Trim(ot[1])
    work := RegExReplace(work, "i)\s*\[(?:MISSING\s+DOSE|LASTFILL|DS|RR|START|STOP|ORDERTYPE)(?:=[^\]]*)?\]", " ")

    if RegExMatch(work, "i)\b(Pending Verify|Pending|Verify|Active|On File|Discontinued|Held|Administered|"
        . "Ordered|Expired|Suspended|Completed|Stopped|Cancelled|Canceled|Inactive)\b", &sm) {
        rec.status := sm[1]
    rec.statusCategory := RxN_StatusCategory(rec.status)
    }
    if RegExMatch(work, "i)\bPRN\b|\bas needed\b")
        rec.prn := true

    if RegExMatch(work, "i)\b(\d+(?:\.\d+)?)\s*(mcg|mg|g|gram|grams|units?|milliunits?|meq|mmol|mL|L|%)\b", &dm) {
        rec.doseNum := dm[1]
        rec.doseUnit := StrLower(dm[2])
        rec.dose := dm[1] " " dm[2]
    }
    if RegExMatch(work, "i)(\d+(?:\.\d+)?\s*(?:mcg|mg|g|units?|meq|mmol)\s*/\s*\d*(?:\.\d+)?\s*mL)", &cm)
        rec.conc := Trim(cm[1])
    if RegExMatch(work, "i)\b(IV\s*Push|IVP|IV\s*Piggyback|IVPB|IV|PO|by mouth|oral|SUBQ|SubQ|SQ|"
        . "subcutaneous|IM|intramuscular|PR|rectal|topical|TOP|inhalation|INH|nebulized|"
        . "NG|OG|PEG|G-tube|GT|J-tube|JT|SL|sublingual|transdermal|TD|ophthalmic|otic|intranasal)\b", &rm) {
        rec.route := Trim(rm[1])
    }
    if RegExMatch(work, "i)\b(tablet|tabs?|capsule|caps?|injection|solution|suspension|syrup|elixir|"
        . "patch|cream|ointment|gel|drops|suppository|inhaler|nebulizer|powder|granules)\b", &fm) {
        rec.form := Trim(fm[1])
    }
    ; Resolve longer natural-language frequencies before the broad `daily`
    ; token so "twice daily" cannot be reduced to QD by OCR text scanning.
    if RegExMatch(work, "i)\b(?:twice\s+daily|two\s+times\s+daily)\b") {
        rec.freq := "BID"
    } else if RegExMatch(work, "i)\bthree\s+times\s+daily\b") {
        rec.freq := "TID"
    } else if RegExMatch(work, "i)\bfour\s+times\s+daily\b") {
        rec.freq := "QID"
    } else if RegExMatch(work, "i)\bonce\s+daily\b") {
        rec.freq := "QD"
    } else if RegExMatch(work, "i)\b(q\s*\d+\s*(?:h|hr|hrs|hours?)|q\s*\d+\s*(?:min|mins|minutes?)|"
        . "every\s+\d+\s+(?:hours?|minutes?)|BID|TID|QID|once\s+daily|twice\s+daily|"
        . "three\s+times\s+daily|four\s+times\s+daily|daily|QD|nightly|bedtime|qHS|HS|QAM|QPM|"
        . "every\s+morning|every\s+evening|once|x\s*1|q\s*day|weekly|once\s+weekly|QOD|MWF)\b", &qm) {
        rec.freq := Sig_CompactFrequency(Trim(qm[1]), rec.prn)
    } else if rec.prn {
        rec.freq := "PRN"
    }

    ; product name = leading text before the first number, dose, or route token
    namePart := work
    if RegExMatch(namePart, "^(.*?)(?=\s*\d)", &nm) && Trim(nm[1]) != ""
        namePart := nm[1]
    namePart := RegExReplace(namePart, "i)\b(Pending Verify|Pending|Verify|Active|On File|Discontinued|Held|"
        . "Administered|Ordered|Expired|Suspended|Completed|Stopped|Cancelled|Canceled|Inactive)\b", " ")
    namePart := RegExReplace(namePart, "[^A-Za-z0-9/\- ]", " ")
    namePart := Trim(RegExReplace(namePart, "\s+", " "))

    if namePart = ""
        namePart := work

    rec.name := namePart
    rec.ingredients := RxN_Ingredients(namePart)
    if rec.ingredients.Length > 0
        rec.primary := rec.ingredients[1]

    ; A medication can be displayed for review without being safe to treat as
    ; confirmed clinical data. Keep the raw order, but make uncertainty
    ; explicit so Med Rec and downstream tools cannot silently promote weak OCR.
    RxN_ApplyCaptureConfidence(rec)

    simple := RxN_Simplify(namePart)
    if RxN_AliasMap().Has(simple) && RxN_AliasMap()[simple] != simple
        rec.brand := namePart

    return rec
}

RxN_ApplyCaptureConfidence(rec) {
    if !IsObject(rec)
        return rec

    reasons := []
    if rec.lowConfidence
        reasons.Push("OCR marked for verification")
    if rec.name = "" || rec.ingredients.Length = 0
        reasons.Push("medication name not resolved")
    if rec.doseNum = "" || rec.doseUnit = ""
        reasons.Push("dose not resolved")
    if rec.route = ""
        reasons.Push("route not resolved")

    if reasons.Length > 0 {
        rec.captureState := "uncertain"
        rec.captureReason := DoseAware_Join(reasons, "; ")
    } else {
        rec.captureState := "captured"
        rec.captureReason := "name, dose, and route resolved from order text"
    }
    return rec
}

RxN_StatusCategory(status) {
    s := StrLower(Trim(String(status)))
    if s = ""
        return "active"
    if InStr(s, "pending") || s = "verify"
        return "pending"
    if s = "discontinued" || s = "expired" || s = "completed" || s = "suspended"
        || s = "stopped" || s = "cancelled" || s = "canceled" || s = "inactive"
        return "inactive"
    if s = "held"
        return "held"
    if s = "administered"
        return "administered"
    return "active"
}

RxN_IsUncertain(rec) {
    if !IsObject(rec)
        return true
    if rec.HasOwnProp("captureState")
        return rec.captureState != "captured"
    return rec.HasOwnProp("lowConfidence") && rec.lowConfidence
}

RxN_IsActiveStatus(status) {
    ; Only an explicitly active/on-file/ordered status is eligible for
    ; automated clinical screening.  Pending, held, administered, and
    ; inactive orders remain visible to Med Rec but must not feed calculators
    ; or safety engines as if they were current therapy.
    return RxN_StatusCategory(status) = "active"
}

; Stable signature used for de-duplicating medication records across captures.


; =================================================================================================
; ALLERGY ENGINE  (blueprint §2 hard alert, §4 risk-stack items 1-3, Phase 3)
; =================================================================================================

; Text that is documented in an allergy field but is not a drug ingredient.
Allergy_IsNonDrug(text) {
    return RegExMatch(text, "i)\b(pill\s*crusher|splitter|crusher|tape|adhesive|latex|"
        . "contrast\s*dye\s*unspecified|no\s*known|nka|nkda|none|environmental|food|"
        . "shellfish|peanut|dust|pollen|bee\s*sting|iodine\s*\(topical\)|betadine|"
        . "chlorhexidine|dressing|electrode)\b") ? true : false
}

; Convert the raw allergy string list into structured records.
Allergy_Parse(list) {
    out := []
    seen := Map()
    for item in list {
        raw := Trim(String(item))
        if raw = ""
            continue

        reaction := ""
        namePart := raw
        if RegExMatch(raw, "^(.*?)[\(\[\-:]\s*(.+)$", &m) {
            cand := Trim(m[1])
            rest := Trim(RegExReplace(m[2], "[\)\]]$", ""))
            if cand != "" && StrLen(cand) >= 3 && RegExMatch(rest, "i)(rash|hives|itch|swell|anaphyla|"
                . "nausea|vomit|sob|short|breath|angioedema|reaction|intoleran|gi\b|unknown)") {
                namePart := cand
                reaction := rest
            }
        }

        isDrug := !Allergy_IsNonDrug(namePart)
        ings := isDrug ? RxN_Ingredients(namePart) : []
        key := StrLower(namePart)
        if seen.Has(key)
            continue
        seen[key] := true

        out.Push({
            raw: raw,
            name: namePart,
            reaction: reaction,
            isDrug: isDrug && ings.Length > 0,
            ingredients: ings
        })
    }
    return out
}

Allergy_ClassMap() {
    global AllergyClassCache
    if !IsSet(AllergyClassCache) || !IsObject(AllergyClassCache)
        AllergyClassCache := Map()
    if IsObject(AllergyClassCache) && AllergyClassCache.Count > 0
        return AllergyClassCache
    m := Map()
    for r in RefData_Rows("allergy_relationships") {
        cls := Trim(r.Has("class") ? r["class"] : "")
        ing := StrLower(Trim(r.Has("ingredient") ? r["ingredient"] : ""))
        if cls = "" || ing = ""
            continue
        if !m.Has(ing)
            m[ing] := []
        m[ing].Push(cls)
    }
    AllergyClassCache := m
    return m
}

Allergy_ClassesFor(ing) {
    cm := Allergy_ClassMap()
    return cm.Has(ing) ? cm[ing] : []
}

Allergy_ClassLabel(cls) {
    switch cls {
        case "opioid-phenanthrene": return "phenanthrene opioid"
        case "opioid-phenylpiperidine": return "phenylpiperidine opioid"
        case "opioid-diphenylheptane": return "diphenylheptane opioid"
        case "sulfonamide-antibiotic": return "sulfonamide antibiotic"
        case "acei": return "ACE inhibitor"
        case "arb": return "angiotensin receptor blocker"
        case "nsaid": return "NSAID"
        case "ssri": return "SSRI"
        case "iodinated-contrast": return "iodinated contrast"
        default: return cls
    }
}

; Scan every medication record against every allergy record.
; Returns array of { sev, tier, title, detail, med, allergy }
; sev: RED (exact/ingredient) or ORANGE (class relationship). Class findings never
; replace or downgrade an exact match - both are emitted.
Allergy_ScanOrders(allergyRecs, medRecs) {
    findings := []
    seen := Map()

    for a in allergyRecs {
        if !a.isDrug
            continue
        for m in medRecs {
            if !RxN_IsActiveStatus(m.status)
                continue
            if m.ingredients.Length = 0
                continue

            exactHit := ""
            for ai in a.ingredients {
                for mi in m.ingredients {
                    if ai = mi {
                        exactHit := ai
                        break
                    }
                }
                if exactHit != ""
                    break
            }

            if exactHit != "" {
                isCombo := m.ingredients.Length > 1
                title := isCombo
                    ? "ALLERGY CONFLICT - combination product ingredient"
                    : "ALLERGY CONFLICT"
                detail := (m.status != "" ? m.status " " : "") "order "
                    . Allergy_Display(m.name) " matches documented "
                    . Allergy_Display(a.name) " allergy."
                if isCombo
                    detail .= " Shared ingredient: " exactHit "."
                detail .= a.reaction != ""
                    ? " Documented reaction: " a.reaction "."
                    : " Reaction was not captured."
                k := "R|" exactHit "|" m.raw
                if !seen.Has(k) {
                    seen[k] := true
                    findings.Push({ sev: "RED", tier: (isCombo ? 2 : 1), title: title,
                        detail: detail, med: m.raw, allergy: a.raw })
                }
                continue
            }

            sharedList := []
            for ai in a.ingredients {
                for cls in Allergy_ClassesFor(ai) {
                    for mi in m.ingredients {
                        if ai = mi
                            continue
                        for mcls in Allergy_ClassesFor(mi) {
                            if cls = mcls && !RxN_HasKey(sharedList, cls)
                                sharedList.Push(cls)
                        }
                    }
                }
            }
            shared := Allergy_MostSpecificClass(sharedList)

            if shared != "" {
                k := "O|" shared "|" m.raw "|" a.raw
                if seen.Has(k)
                    continue
                seen[k] := true
                findings.Push({
                    sev: "ORANGE",
                    tier: 3,
                    title: "Class caution - " Allergy_ClassLabel(shared),
                    detail: Allergy_Display(a.name) " allergy documented; "
                        . Allergy_Display(m.name) " is another "
                        . Allergy_ClassLabel(shared)
                        . ". Review the documented reaction before use."
                        . (a.reaction != "" ? " Reaction on file: " a.reaction "." : " Reaction was not captured."),
                    med: m.raw,
                    allergy: a.raw
                })
            }
        }
    }

    ; RED first, then ORANGE
    sorted := []
    for f in findings {
        if f.sev = "RED"
            sorted.Push(f)
    }
    for f in findings {
        if f.sev != "RED"
            sorted.Push(f)
    }
    return sorted
}

; A pair can share more than one class (piperacillin is both "penicillin" and "beta-lactam").
; Report the most specific one so the same pair does not generate two cautions.
Allergy_MostSpecificClass(classList) {
    if classList.Length = 0
        return ""
    for c in classList {
        if c != "beta-lactam"
            return c
    }
    return classList[1]
}

Allergy_Display(name) {
    s := Trim(String(name))
    return s = "" ? "(unnamed)" : s
}

Allergy_Unclassified(allergyRecs) {
    out := []
    for a in allergyRecs {
        if !a.isDrug
            out.Push(a.raw)
    }
    return out
}


; =================================================================================================
; SHARED PATIENT CONTEXT + MULTI-CAPTURE SESSION
; (blueprint §3 shared structure, §11 multi-screen capture, §12 identity, §13 screen type,
;  §14 merge rules, §15 provenance, §18 session lifecycle, §21 safety controls)
; -------------------------------------------------------------------------------------------------
; The session lives in memory only. MRN/FIN/name are held for identity reconciliation and are
; never written to any CSV, log, or handoff file - the existing Pkg_ScrubForPersistence line is
; unchanged and still applies to everything that does reach disk.
;
; PCtx_ToParsed() emits the legacy `parsed` object, so every existing calculator, prefill path,
; and renal/flag routine keeps working with no change.
; =================================================================================================

PCtx_NewField(value, unit := "", when := "", conf := "", section := "", capture := 0) {
    return {
        raw: String(value),
        value: String(value),
        unit: unit,
        when: when,
        conf: conf,
        section: section,
        capture: capture,
        edited: false
    }
}

PCtx_New() {
    return {
        sessionId: FormatTime(, "yyyyMMddHHmmss"),
        startedAt: FormatTime(, "MM/dd/yyyy HH:mm"),
        lastCaptureAt: "",
        lastTouch: A_TickCount,
        finalized: false,
        ident: Map(),
        demo: Map(),
        captureCandidates: Map(),
        weights: [],
        labs: Map(),
        labCandidates: Map(),
        dx: [],
        allergyRecs: [],
        allergyRaw: [],
        medRecs: [],
        mar: [],
        qualitativeFindings: [],
        captures: [],
        conflicts: [],
        notes: [],
        backgroundLookups: []
    }
}

PCtx_Active() {
    global PCtxSession, PCtxIdleTimeoutMin
    if !IsObject(PCtxSession)
        return 0
    if PCtxIdleTimeoutMin > 0 {
        idleMs := A_TickCount - PCtxSession.lastTouch
        if idleMs > (PCtxIdleTimeoutMin * 60000) {
            PCtxSession := 0
            return 0
        }
    }
    return PCtxSession
}

PCtx_Touch(ctx) {
    ctx.lastTouch := A_TickCount
}

; -------------------------------------------------------------------------------------------------
; §13 SCREEN-TYPE RECOGNITION
; -------------------------------------------------------------------------------------------------
PCtx_ClassifyScreen(rawText) {
    t := rawText
    score := Map(
        "Patient Profile", 0, "Laboratory Results", 0, "Medication Orders", 0,
        "MAR", 0, "Allergies", 0, "Diagnoses / Problems", 0, "Vitals", 0,
        "Pharmacy Verification", 0
    )

    PCtx_Score(score, "Patient Profile", t, "i)\b(Age|DOB|Date of Birth|Height|Weight|BSA|Sex|Gender)\b", 1)
    PCtx_Score(score, "Patient Profile", t, "i)\bPatient (Profile|Summary|Information)\b", 3)
    PCtx_Score(score, "Laboratory Results", t, "i)\b(Results?|Reference Range|Collected|Specimen|Lab)\b", 1)
    PCtx_Score(score, "Laboratory Results", t, "i)\b(WBC|Hgb|Hemoglobin|Platelet|Creatinine|BUN|Sodium|Potassium)\b", 1)
    PCtx_Score(score, "Medication Orders", t, "i)\b(Order|Orders|Ordered|Pending Verify|Start Date|Stop Date|Frequency|Sig)\b", 1)
    PCtx_Score(score, "Medication Orders", t, "i)\b(Medication Orders|Active Orders|Order Profile)\b", 3)
    PCtx_Score(score, "MAR", t, "i)\b(MAR|Administration|Administered|Given|Scheduled|Due|Not Given|Held)\b", 1)
    PCtx_Score(score, "MAR", t, "i)\bMedication Administration Record\b", 4)
    PCtx_Score(score, "Allergies", t, "i)\b(Allerg\w*|Reaction|Severity|Allergen|Intolerance)\b", 1)
    PCtx_Score(score, "Diagnoses / Problems", t, "i)\b(Diagnos\w*|Problem List|ICD|Encounter Diagnosis|Active Problem)\b", 1)
    PCtx_Score(score, "Vitals", t, "i)\b(Blood Pressure|BP|Pulse|Temp|Temperature|SpO2|Respirations|Vitals)\b", 1)
    PCtx_Score(score, "Pharmacy Verification", t, "i)\b(Verify|Verification|Pharmacist Review|Pending Verify)\b", 1)

    best := "Unknown / Mixed Screen"
    bestScore := 0
    second := 0
    for k, v in score {
        if v > bestScore {
            second := bestScore
            bestScore := v
            best := k
        } else if v > second {
            second := v
        }
    }
    if bestScore < 2
        return "Unknown / Mixed Screen"
    if second > 0 && (bestScore - second) <= 1
        return best " (mixed)"
    return best
}

PCtx_Score(score, key, text, pattern, weight) {
    pos := 1
    hits := 0
    while (pos := RegExMatch(text, pattern, &m, pos)) {
        hits += 1
        pos += Max(1, StrLen(m[0]))
        if hits >= 6
            break
    }
    if hits > 0
        score[key] := score[key] + (hits * weight)
}

; -------------------------------------------------------------------------------------------------
; LAB EXTRACTION - labeled analyte + plausible value, stored as a time series (§14)
; -------------------------------------------------------------------------------------------------
PCtx_LabDefs() {
    static defs := [
        { key: "sodium",      pat: "Sodium|\bNa\b",                 lo: 90,   hi: 190,  unit: "mmol/L" },
        { key: "potassium",   pat: "Potassium|\bK\b",               lo: 1,    hi: 9.5,  unit: "mmol/L" },
        { key: "chloride",    pat: "Chloride|\bCl\b",               lo: 60,   hi: 140,  unit: "mmol/L" },
        { key: "bicarbonate", pat: "Bicarbonate|\bCO2\b|\bHCO3\b|Total CO2", lo: 5, hi: 50, unit: "mmol/L" },
        { key: "bun",         pat: "\bBUN\b|Urea Nitrogen",         lo: 1,    hi: 200,  unit: "mg/dL" },
        { key: "creatinine",  pat: "Creatinine|Creatlnine|Creatinlne|Creatininc|Serum\s*(?:Cr|Creat)|\bS\s*C\s*[rIln]\b|\bSrCr\b|\bCREA\b|\bCREAT\b|\bCreat\b", lo: 0.1, hi: 25, unit: "mg/dL" },
        { key: "glucose",     pat: "Glucose|\bBG\b|Blood Sugar",    lo: 10,   hi: 1500, unit: "mg/dL" },
        { key: "calcium",     pat: "\bCalcium\b|\bCa\b",            lo: 3,    hi: 20,   unit: "mg/dL" },
        { key: "magnesium",   pat: "Magnesium|\bMg\b",              lo: 0.3,  hi: 12,   unit: "mg/dL" },
        { key: "phosphate",   pat: "Phosph\w*|\bPhos\b",            lo: 0.3,  hi: 20,   unit: "mg/dL" },
        { key: "albumin",     pat: "Albumin|\bAlb\b",               lo: 0.5,  hi: 7,    unit: "g/dL" },
        { key: "rbc",         pat: "\bRBC\b|Red Blood",             lo: 0.5,  hi: 10,   unit: "M/uL" },
        { key: "wbc",         pat: "\bWBC\b|White Blood",           lo: 0.1,  hi: 400,  unit: "K/uL" },
        { key: "hemoglobin",  pat: "Hemoglobin|\bHgb\b|\bHb\b",     lo: 2,    hi: 25,   unit: "g/dL" },
        { key: "hematocrit",  pat: "Hematocrit|\bHct\b",            lo: 8,    hi: 70,   unit: "%" },
        { key: "platelets",   pat: "Platelet\w*|\bPlt\b",           lo: 1,    hi: 1500, unit: "K/uL" },
        { key: "inr",         pat: "\bINR\b",                       lo: 0.5,  hi: 15,   unit: "" },
        { key: "ptt",         pat: "\baPTT\b|\bPTT\b",              lo: 10,   hi: 250,  unit: "sec" },
        { key: "ast",         pat: "\bAST\b|\bSGOT\b",              lo: 1,    hi: 20000, unit: "U/L" },
        { key: "alt",         pat: "\bALT\b|\bSGPT\b",              lo: 1,    hi: 20000, unit: "U/L" },
        { key: "bilirubin",   pat: "Bilirubin|\bT\.?\s*Bili\b",     lo: 0.1,  hi: 60,   unit: "mg/dL" },
        { key: "alkphos",     pat: "Alkaline Phosphatase|\bALP\b|\bAlk Phos\b", lo: 5, hi: 3000, unit: "U/L" },
        { key: "ldh",         pat: "\bLDH\b",                       lo: 20,   hi: 20000, unit: "U/L" },
        { key: "uricacid",    pat: "Uric Acid",                     lo: 0.5,  hi: 40,   unit: "mg/dL" },
        { key: "lactate",     pat: "Lactate|Lactic Acid",           lo: 0.2,  hi: 30,   unit: "mmol/L" },
        { key: "anc",         pat: "\bANC\b|Absolute Neutrophil",   lo: 0,    hi: 100,  unit: "K/uL" },
        { key: "osmolality",  pat: "Osmolality|\bOsm\b",            lo: 200,  hi: 450,  unit: "mOsm/kg" },
        { key: "troponin",    pat: "Troponin",                      lo: 0,    hi: 100000, unit: "" },
        { key: "egfr",        pat: "\beGFR\b|GFR",                  lo: 1,    hi: 200,  unit: "mL/min/1.73" },
        { key: "phenytoin",   pat: "Phenytoin|Dilantin",            lo: 0.5,  hi: 80,   unit: "mcg/mL" },
        { key: "vancomycin",  pat: "Vancomycin (?:Level|Trough|Random)", lo: 1, hi: 120, unit: "mcg/mL" },
        { key: "iron",        pat: "\bIron\b",                      lo: 5,    hi: 600,  unit: "mcg/dL" },
        { key: "tibc",        pat: "\bTIBC\b",                      lo: 50,   hi: 900,  unit: "mcg/dL" },
        { key: "ferritin",    pat: "Ferritin",                      lo: 1,    hi: 20000, unit: "ng/mL" },
        { key: "ph",          pat: "\bpH\b|Arterial pH|Venous pH", lo: 6.5,  hi: 8.0, unit: "" },
        { key: "betahydroxybutyrate", pat: "Beta[- ]?Hydroxybutyrate|\bBHB\b", lo: 0, hi: 20, unit: "mmol/L" },
        { key: "acetaminophen", pat: "Acetaminophen|Paracetamol|\bAPAP\b", lo: 0, hi: 1000, unit: "mcg/mL" },
        { key: "digoxin",     pat: "Digoxin(?: Level)?",             lo: 0, hi: 20, unit: "ng/mL" },
        { key: "heartRate",   pat: "Heart Rate|Pulse|\bHR\b",      lo: 15, hi: 300, unit: "bpm" },
        { key: "respiratoryRate", pat: "Respiratory Rate|Respirations|\bRR\b", lo: 2, hi: 80, unit: "/min" },
        { key: "temperature", pat: "Temperature|\bTemp\b",          lo: 25, hi: 45, unit: "C" },
        { key: "spo2",        pat: "SpO2|Oxygen Saturation|O2 Sat",   lo: 40, hi: 100, unit: "%" },
        { key: "qt",          pat: "QT Interval|\bQT\b",            lo: 150, hi: 800, unit: "ms" },
        { key: "qtc",         pat: "QTc|Corrected QT",                lo: 200, hi: 900, unit: "ms" },
        { key: "mcv",          pat: "\\bMCV\\b",                       lo: 40, hi: 150, unit: "fL" },
        { key: "mpv",          pat: "\\bMPV\\b",                       lo: 3, hi: 25, unit: "fL" },
        { key: "sedrate",      pat: "Sed(?:imentation)?\\s*Rate|\\bESR\\b", lo: 0, hi: 200, unit: "mm/hr" },
        { key: "totalprotein", pat: "Protein\\s+Total|Total\\s+Protein", lo: 0.5, hi: 15, unit: "g/dL" },
        { key: "tsh",          pat: "\\bTSH\\b",                       lo: 0.001, hi: 100, unit: "mIU/L" },
        { key: "freet4",       pat: "Free\\s+T4|T4\\s+Free",             lo: 0.01, hi: 20, unit: "ng/dL" },
        { key: "cholesterol",  pat: "Cholesterol\\s+Total|Total\\s+Cholesterol", lo: 20, hi: 1500, unit: "mg/dL" },
        { key: "hdl",          pat: "HDL(?:\\s+Cholesterol)?",           lo: 1, hi: 300, unit: "mg/dL" },
        { key: "ldl",          pat: "\\bLDL\\b",                        lo: 1, hi: 1000, unit: "mg/dL" },
        { key: "triglycerides", pat: "Triglycerides?",                   lo: 1, hi: 5000, unit: "mg/dL" },
        { key: "crp",          pat: "CRP(?:\\s+UltraSens)?|hsCRP",       lo: 0, hi: 1000, unit: "mg/L" },
        { key: "folate",       pat: "Folate",                             lo: 0, hi: 100, unit: "ng/mL" }
        ,{ key: "neutrophilPercent", pat: "Neutrophil\s*%|Neutrophils?\s*%", lo: 0, hi: 100, unit: "%" }
        ,{ key: "lymphocytePercent", pat: "Lymphocyte\s*%", lo: 0, hi: 100, unit: "%" }
        ,{ key: "monocytePercent", pat: "Monocyte\s*%", lo: 0, hi: 100, unit: "%" }
        ,{ key: "eosinophilPercent", pat: "Eosinophil\s*%", lo: 0, hi: 100, unit: "%" }
        ,{ key: "basophilPercent", pat: "Basophil\s*%", lo: 0, hi: 100, unit: "%" }
        ,{ key: "immatureGranulocytePercent", pat: "Immature\s+Granulocyte\s*%", lo: 0, hi: 100, unit: "%" }
        ,{ key: "neutroAbsolute", pat: "Neutro\s+Absolute|Absolute\s+Neutrophil", lo: 0, hi: 400, unit: "K/uL" }
        ,{ key: "lymphAbsolute", pat: "Lymph\s+Absolute|Absolute\s+Lymphocyte", lo: 0, hi: 400, unit: "K/uL" }
        ,{ key: "monoAbsolute", pat: "Mono\s+Absolute|Absolute\s+Monocyte", lo: 0, hi: 400, unit: "K/uL" }
        ,{ key: "eosAbsolute", pat: "Eos\s+Absolute|Absolute\s+Eosinophil", lo: 0, hi: 400, unit: "K/uL" }
        ,{ key: "basoAbsolute", pat: "Baso\s+Absolute|Absolute\s+Basophil", lo: 0, hi: 400, unit: "K/uL" }
        ,{ key: "nrbcs", pat: "nRBC|NRBC", lo: 0, hi: 100, unit: "K/uL" }
        ,{ key: "bnp", pat: "B[- ]?Type\s+Natriuretic\s+Peptide|BNP", lo: 0, hi: 100000, unit: "pg/mL" }
    ]
    return defs
}

; -------------------------------------------------------------------------------------------------
; CERNER QUICK VIEW GRID EXTRACTION
; -------------------------------------------------------------------------------------------------
; Cerner's Group view is a two-dimensional table: analytes are column headers and result rows sit
; below them. Flattening Windows OCR into text separates the labels from their values and, because
; this view does not display units in each cell, the strict labeled-line parser correctly rejects
; everything. This pass keeps OCR geometry and accepts a value only when it is vertically grounded
; beneath one unambiguous known analyte header and falls inside that analyte's plausible range.
; Unknown, malformed, or multiply-assigned cells are omitted rather than guessed.

PatientV7_GridLabDefs() {
    static defs := [
        { key:"sodium", aliases:["sodium", "sodlum"], lo:90, hi:190, unit:"mmol/L" },
        { key:"potassium", aliases:["potassium", "potasslum", "potassiumlvl"], lo:1, hi:9.5, unit:"mmol/L" },
        { key:"chloride", aliases:["chloride", "chlorlde", "chloridelvl"], lo:60, hi:140, unit:"mmol/L" },
        { key:"bicarbonate", aliases:["co2", "c02", "bicarbonate", "totalco2"], lo:5, hi:50, unit:"mmol/L" },
        { key:"bun", aliases:["bun", "ureanitrogen"], lo:1, hi:200, unit:"mg/dL" },
        { key:"creatinine", aliases:["creatinine", "creatlnine", "creatinlne", "creatininelevel"], lo:0.1, hi:25, unit:"mg/dL" },
        { key:"egfr", aliases:["egfr", "egfrckdepi"], lo:1, hi:200, unit:"mL/min/1.73" },
        { key:"glucose", aliases:["glucose", "glucoselvl"], lo:10, hi:1500, unit:"mg/dL" },
        { key:"calcium", aliases:["calcium", "calclum"], lo:3, hi:20, unit:"mg/dL" },
        { key:"magnesium", aliases:["magnesium", "magneslum", "magnesiumlvl"], lo:0.3, hi:12, unit:"mg/dL" },
        { key:"phosphate", aliases:["phosphorus", "phosphate", "phosphoruslvl"], lo:0.3, hi:20, unit:"mg/dL" },
        { key:"albumin", aliases:["albumin", "albumln"], lo:0.5, hi:7, unit:"g/dL" },
        { key:"wbc", aliases:["wbc", "wsc", "whitebloodcell"], lo:0.1, hi:400, unit:"K/uL" },
        { key:"rbc", aliases:["rbc", "redbloodcell"], lo:0.5, hi:10, unit:"M/uL" },
        { key:"hemoglobin", aliases:["hemoglobin", "hemaglobin", "hgb"], lo:2, hi:25, unit:"g/dL" },
        { key:"hematocrit", aliases:["hematocrit", "hematocrlt", "hct"], lo:8, hi:70, unit:"%" },
        { key:"platelets", aliases:["platelets", "platelet", "plateiets"], lo:1, hi:1500, unit:"K/uL" },
        { key:"lactate", aliases:["lactate", "lacticacid"], lo:0.2, hi:30, unit:"mmol/L" },
        { key:"mcv", aliases:["mcv"], lo:40, hi:150, unit:"fL" },
        { key:"mpv", aliases:["mpv"], lo:3, hi:25, unit:"fL" },
        { key:"ast", aliases:["ast", "sgot"], lo:1, hi:20000, unit:"U/L" },
        { key:"alt", aliases:["alt", "sgpt"], lo:1, hi:20000, unit:"U/L" },
        { key:"sedrate", aliases:["sedrate", "sedimentationrate", "esr"], lo:0, hi:200, unit:"mm/hr" },
        { key:"totalprotein", aliases:["proteintotal", "totalprotein"], lo:0.5, hi:15, unit:"g/dL" },
        { key:"tsh", aliases:["tsh"], lo:0.001, hi:100, unit:"mIU/L" },
        { key:"free t4", aliases:["t4free", "freet4"], lo:0.01, hi:20, unit:"ng/dL" },
        { key:"cholesterol", aliases:["cholesteroltotal", "totalcholesterol"], lo:20, hi:1500, unit:"mg/dL" },
        { key:"hdl", aliases:["hdlcholesterol", "hdl"], lo:1, hi:300, unit:"mg/dL" },
        { key:"ldl", aliases:["ldl"], lo:1, hi:1000, unit:"mg/dL" },
        { key:"triglycerides", aliases:["triglycerides", "triglyceride"], lo:1, hi:5000, unit:"mg/dL" },
        { key:"crp", aliases:["crpultrasens", "crp", "hscrp"], lo:0, hi:1000, unit:"mg/L" },
        { key:"folate", aliases:["folate", "folatelvl"], lo:0, hi:100, unit:"ng/mL" }
        ,{ key:"neutrophilPercent", aliases:["neutrophil%auto", "neutrophilpercent", "neutrophils%"], lo:0, hi:100, unit:"%" }
        ,{ key:"lymphocytePercent", aliases:["lymphocyte%auto", "lymphocytepercent"], lo:0, hi:100, unit:"%" }
        ,{ key:"monocytePercent", aliases:["monocyte%auto", "monocytepercent"], lo:0, hi:100, unit:"%" }
        ,{ key:"eosinophilPercent", aliases:["eosinophil%auto", "eosinophilpercent"], lo:0, hi:100, unit:"%" }
        ,{ key:"basophilPercent", aliases:["basophil%auto", "basophilpercent"], lo:0, hi:100, unit:"%" }
        ,{ key:"immatureGranulocytePercent", aliases:["immaturegranulocyte%", "immaturegranulocytepercent"], lo:0, hi:100, unit:"%" }
        ,{ key:"neutroAbsolute", aliases:["neutroabsolute", "absolute neutrophil"], lo:0, hi:400, unit:"K/uL" }
        ,{ key:"lymphAbsolute", aliases:["lymphabsolute", "absolute lymphocyte"], lo:0, hi:400, unit:"K/uL" }
        ,{ key:"monoAbsolute", aliases:["monoabsolute", "absolute monocyte"], lo:0, hi:400, unit:"K/uL" }
        ,{ key:"eosAbsolute", aliases:["eosabsolute", "absolute eosinophil"], lo:0, hi:400, unit:"K/uL" }
        ,{ key:"basoAbsolute", aliases:["basoabsolute", "absolute basophil"], lo:0, hi:400, unit:"K/uL" }
        ,{ key:"nrbcs", aliases:["nrbcs", "nrbcs"], lo:0, hi:100, unit:"K/uL" }
        ,{ key:"bnp", aliases:["btypenatriureticpeptide", "bnp"], lo:0, hi:100000, unit:"pg/mL" }
    ]
    return defs
}

PatientV7_LooksLikeLabGridText(text) {
    hits := 0
    for pattern in [
        "\bSodium\b", "\bPotassium\b", "\bChloride\b", "\bCO2\b",
        "\bBUN\b", "\bCreat(?:inine|lnine|inlne)\b", "\beGFR\b",
        "\bWBC\b", "\bRBC\b", "\bHemoglobin\b", "\bHematocrit\b",
        "\bPlatelets?\b", "\bAlbumin\b", "\bMagnesium\b", "\bPhosph(?:orus|ate)\b"
    ] {
        if RegExMatch(text, "i)" pattern)
            hits += 1
        if hits >= 3
            return true
    }
    return RegExMatch(text, "i)\bQuick\s+View\b")
        && RegExMatch(text, "i)\b(?:Chemistry|Hematology)\b")
}

PatientV7_ResultWords(result) {
    out := []
    if !IsObject(result)
        return out

    try {
        for word in result.Words {
            text := PatientV2_CleanLine(word.Text)
            if text = ""
                continue
            support := word.HasOwnProp("support") ? word.support : 1
            out.Push({ text:text, x:word.x, y:word.y, w:word.w, h:word.h, support:support })
        }
    }
    return out
}

PatientV7_BundleWords(bundle) {
    out := []
    seen := Map()
    processedParts := []
    for key in ["headerLeft", "headerRight", "sidebar", "orders", "labGrid"] {
        part := 0
        try part := bundle.%key%
        if !IsObject(part)
            continue
        alreadyProcessed := false
        for priorPart in processedParts {
            if priorPart = part {
                alreadyProcessed := true
                break
            }
        }
        if alreadyProcessed
            continue
        processedParts.Push(part)
        for word in PatientV7_ResultWords(part) {
            sig := StrLower(word.text) "|" Round(word.x / 4) "|" Round(word.y / 4)
            if seen.Has(sig) {
                out[seen[sig]].support += word.support
                continue
            }
            out.Push(word)
            seen[sig] := out.Length
        }
    }
    return out
}

; Lab geometry is meaningful only within the result canvas.  The capture
; bundle contains several independently cropped OCR regions whose x/y values
; are local to that crop.  Never merge sidebar/header coordinates with the
; result grid when assigning a numeric cell to an analyte.
PatientV7_LabBundleWords(bundle) {
    selected := 0
    try selected := bundle.labGrid
    if !IsObject(selected) {
        try selected := bundle.orders
        if IsObject(selected) {
            try selectedText := String(selected.Text)
            catch
                selectedText := ""
            if !PatientV7_LooksLikeLabGridText(selectedText)
                && !InStr(StrLower(selectedText), "quick view")
                && !InStr(StrLower(selectedText), "automated hematology")
                && !InStr(StrLower(selectedText), "routine chemistry") {
                selected := 0
            }
        }
    }
    if !IsObject(selected) {
        try selected := bundle.sidebar
        if IsObject(selected) {
            ; For a deliberately small user selection the sidebar and the
            ; selected canvas are the same OCR result. There is no second
            ; coordinate space to contaminate it, so allow geometry parsing
            ; even when the tiny OCR text misses a grid heading.
            try ordersPresent := IsObject(bundle.orders)
            catch
                ordersPresent := false
            try selectedText := String(selected.Text)
            catch
                selectedText := ""
            if ordersPresent
                && !PatientV7_LooksLikeLabGridText(selectedText)
                && !InStr(StrLower(selectedText), "quick view")
                && !InStr(StrLower(selectedText), "automated hematology")
                && !InStr(StrLower(selectedText), "routine chemistry")
                selected := 0
        }
    }
    if !IsObject(selected)
        return []
    ; A small selection stores the same OCR result in headerLeft and sidebar;
    ; retaining both passes preserves independent support without mixing two
    ; different screen regions. Full captures use only the selected result
    ; canvas above, keeping sidebar coordinates out of lab geometry.
    try hasOrders := IsObject(bundle.orders)
    catch
        hasOrders := false
    return hasOrders ? PatientV7_ResultWords(selected) : PatientV7_BundleWords(bundle)
}

PatientV7_SortGeometry(items, byX := false, descendingY := false) {
    out := []
    for item in items {
        inserted := false
        for index, existing in out {
            before := false
            if byX {
                before := item.x < existing.x
            } else if descendingY {
                before := item.y > existing.y
                    || (Abs(item.y - existing.y) <= 3 && item.x < existing.x)
            } else {
                before := item.y < existing.y
                    || (Abs(item.y - existing.y) <= 3 && item.x < existing.x)
            }
            if before {
                out.InsertAt(index, item)
                inserted := true
                break
            }
        }
        if !inserted
            out.Push(item)
    }
    return out
}

PatientV7_GridHeaderMatch(text) {
    candidate := PatientV2_NormalizeMatch(text)
    if StrLen(candidate) < 3
        return 0

    best := 0
    bestDistance := 1000000
    tied := false
    for def in PatientV7_GridLabDefs() {
        for alias in def.aliases {
            normalizedAlias := PatientV2_NormalizeMatch(alias)
            if candidate = normalizedAlias
                return { def:def, distance:0 }

            ; Fuzzy recovery is restricted to long, unique analyte names. Short
            ; abbreviations (K, Cl, Hb, etc.) are never inferred from similarity.
            if StrLen(normalizedAlias) < 5
                continue
            if Abs(StrLen(candidate) - StrLen(normalizedAlias)) > 2
                continue
            distance := PatientV2_EditDistance(candidate, normalizedAlias)
            allowed := StrLen(normalizedAlias) >= 9 ? 2 : 1
            if distance > allowed
                continue
            if distance < bestDistance {
                best := { def:def, distance:distance }
                bestDistance := distance
                tied := false
            } else if distance = bestDistance && IsObject(best) && best.def.key != def.key {
                tied := true
            }
        }
    }
    return tied ? 0 : best
}

PatientV7_GridHeaders(words) {
    headers := []
    seen := Map()

    for start in words {
        nearby := [start]
        centerY := start.y + (start.h / 2)
        for other in words {
            if other.x <= start.x
                continue
            if Abs((other.y + other.h / 2) - centerY) > Max(12, start.h * 0.9)
                continue
            if other.x - (start.x + start.w) > Max(220, start.h * 8)
                continue
            nearby.Push(other)
        }
        nearby := PatientV7_SortGeometry(nearby, true)

        phrase := ""
        right := start.x + start.w
        best := 0
        bestRight := right
        Loop Min(3, nearby.Length) {
            item := nearby[A_Index]
            if A_Index > 1 && item.x - right > Max(80, start.h * 3.2)
                break
            phrase .= (phrase = "" ? "" : " ") item.text
            right := Max(right, item.x + item.w)
            match := PatientV7_GridHeaderMatch(phrase)
            if IsObject(match) {
                best := match
                bestRight := right
                if match.distance = 0
                    break
            }
        }
        if !IsObject(best)
            continue
        if PatientV7_GridHeaderExcluded(words, start, best.def.key)
            continue

        sig := best.def.key "|" Round(start.x / 20) "|" Round(start.y / 12)
        if seen.Has(sig)
            continue
        seen[sig] := true
        headers.Push({
            key:best.def.key,
            def:best.def,
            text:phrase,
            x:start.x,
            y:start.y,
            w:Max(start.w, bestRight - start.x),
            h:start.h,
            distance:best.distance
        })
    }
    return headers
}

PatientV7_GridHeaderExcluded(words, start, key) {
    ; Do not place POC glucose or urinalysis cell counts into the serum/CBC
    ; analyte slots. They can be modeled separately later, but silently mixing
    ; specimen types is worse than leaving the serum value blank.
    if key != "glucose" && key != "wbc" && key != "rbc"
        return false
    centerY := start.y + start.h / 2
    for other in words {
        if other.x >= start.x || start.x - (other.x + other.w) > Max(180, start.h * 7)
            continue
        if Abs((other.y + other.h / 2) - centerY) > Max(14, start.h * 0.9)
            continue
        qualifier := PatientV2_NormalizeMatch(other.text)
        if qualifier = "poc" || qualifier = "ua" || qualifier = "urine"
            return true
    }

    ; CBC WBC/RBC labels are short enough to recur in urinalysis tables. They
    ; must also be surrounded by a hematology anchor or another CBC analyte.
    ; If the photo has degraded that context, leave the value blank rather than
    ; silently crossing specimen types.
    if key = "wbc" || key = "rbc" {
        hasCbcContext := false
        for other in words {
            if other = start
                continue
            ; A Cerner CBC header row can be spread across a wide screen; use
            ; the row band, not a narrow text-neighborhood, while still
            ; requiring an explicit hematology anchor nearby.
            if Abs((other.y + other.h / 2) - centerY) > Max(110, start.h * 6.5)
                continue
            context := PatientV2_NormalizeMatch(other.text)
            if RegExMatch(context, "i)^(?:hematology|hemoglobin|hemaglobin|hematocrit|platelet|platelets|wbc|wsc|rbc)$") {
                hasCbcContext := true
                break
            }
        }
        if !hasCbcContext
            return true
    }
    return false
}

PatientV7_GridTimes(words) {
    times := []
    seen := Map()
    for word in words {
        if !RegExMatch(word.text, "(\d{1,2}/\d{1,2}/\d{2,4})", &dm)
            continue
        when := dm[1]
        if RegExMatch(word.text, "\b(\d{1,2}:\d{2})\b", &tm) {
            when .= " " tm[1]
        } else {
            bestTime := ""
            bestGap := 1000000
            for other in words {
                if other.x <= word.x
                    continue
                if Abs((other.y + other.h / 2) - (word.y + word.h / 2)) > Max(14, word.h * 0.8)
                    continue
                if other.x - (word.x + word.w) > Max(260, word.h * 10)
                    continue
                if !RegExMatch(other.text, "^\s*(\d{1,2}:\d{2})\s*$", &ot)
                    continue
                gap := other.x - (word.x + word.w)
                if gap < bestGap {
                    bestGap := gap
                    bestTime := ot[1]
                }
            }
            if bestTime != ""
                when .= " " bestTime
        }
        sig := when "|" Round(word.y / 8)
        if seen.Has(sig)
            continue
        seen[sig] := true
        times.Push({ when:when, y:word.y + word.h / 2, h:word.h })
    }
    return times
}

PatientV7_GridNearestTime(times, valueY, valueH) {
    best := ""
    bestDistance := 1000000
    for stamp in times {
        distance := Abs(stamp.y - (valueY + valueH / 2))
        if distance > Max(36, valueH * 1.6)
            continue
        if distance < bestDistance {
            bestDistance := distance
            best := stamp.when
        }
    }
    return best
}

PatientV7_GridNumericToken(text) {
    t := Trim(String(text))
    if !RegExMatch(t, "i)^[\[\(\{\s]*([0-9]{1,4}(?:[\.,][0-9]{1,3})?)[\]\)\}\s*!*HL]*$", &m)
        return ""
    valueText := StrReplace(m[1], ",", ".")
    return IsNumber(valueText) ? valueText : ""
}

PatientV7_GridColumnBounds(headers, header) {
    left := header.x - Max(120, header.h * 5)
    right := header.x + Max(260, header.w + 160)
    centerY := header.y + header.h / 2
    nearestLeft := 0
    nearestRight := 0

    for other in headers {
        if other = header
            continue
        if Abs((other.y + other.h / 2) - centerY) > Max(40, header.h * 1.7)
            continue
        if other.x < header.x && (!IsObject(nearestLeft) || other.x > nearestLeft.x)
            nearestLeft := other
        if other.x > header.x && (!IsObject(nearestRight) || other.x < nearestRight.x)
            nearestRight := other
    }
    if IsObject(nearestLeft)
        left := (nearestLeft.x + header.x) / 2
    if IsObject(nearestRight)
        right := (header.x + nearestRight.x) / 2

    bottom := header.y + Max(64, header.h * 4.8)
    for other in headers {
        if other = header || other.y <= header.y + header.h
            continue
        if Abs(other.x - header.x) > Max(170, header.w)
            continue
        candidateBottom := other.y - Max(4, header.h * 0.35)
        if candidateBottom < bottom
            bottom := candidateBottom
    }
    return { left:left, right:right, top:header.y + header.h * 0.45, bottom:bottom }
}

PatientV7_GridValuesForHeader(words, headers, header, times) {
    bounds := PatientV7_GridColumnBounds(headers, header)
    candidates := []
    seen := Map()

    for word in words {
        centerX := word.x + word.w / 2
        centerY := word.y + word.h / 2
        if centerX < bounds.left || centerX >= bounds.right
            continue
        if centerY <= bounds.top || centerY >= bounds.bottom
            continue
        token := PatientV7_GridNumericToken(word.text)
        if token = ""
            continue
        sourceUnit := LabMetric_InputUnit(header.key, header.def.unit)
        value := LabMetric_CanonicalizeGridValue(header.key, Number(token), sourceUnit)
        if value < header.def.lo || value > header.def.hi
            continue
        sig := token "|" Round(word.x / 5) "|" Round(word.y / 5)
        if seen.Has(sig)
            continue
        seen[sig] := true
        candidates.Push({
            value:token,
            x:word.x,
            y:word.y,
            w:word.w,
            h:word.h,
            raw:word.text,
            support:word.HasOwnProp("support") ? word.support : 1
        })
    }

    ; Multiple different numeric tokens on the same visual row are ambiguous.
    ; Keep only rows with a single grounded candidate.
    ordered := PatientV7_SortGeometry(candidates, false, true)
    output := []
    index := 1
    while index <= ordered.Length {
        group := [ordered[index]]
        baseY := ordered[index].y
        nextIndex := index + 1
        while nextIndex <= ordered.Length
            && Abs(ordered[nextIndex].y - baseY) <= Max(8, ordered[index].h * 0.45) {
            group.Push(ordered[nextIndex])
            nextIndex += 1
        }

        uniqueValues := Map()
        for item in group
            uniqueValues[item.value] := true
        if uniqueValues.Count = 1 {
            item := group[1]
            ocrSupport := 0
            for candidate in group {
                if candidate.value = item.value
                    ocrSupport += candidate.support
            }
            canonical := LabMetric_CanonicalizeGridValue(header.key, Number(item.value), LabMetric_InputUnit(header.key, header.def.unit))
            output.Push({
                key:header.key,
                value:PatientV7_NormalizedGridNumber(canonical),
                unit:header.def.unit,
                when:PatientV7_GridNearestTime(times, item.y, item.h),
                conf:"moderate",
                source:"Cerner Quick View grid; analyte column grounded; source unit inferred from the configured analyte profile (" header.def.unit ")",
                raw:PCtx_LabLabel(header.key) " grid value " item.raw,
                screenY:item.y,
                x:item.x,
                y:item.y,
                w:item.w,
                h:item.h,
                ocrSupport:ocrSupport,
                rowSupport:1
            })
        }
        index := nextIndex
    }
    return output
}

LabMetric_CanonicalizeGridValue(key, value, sourceUnit) {
    u := StrLower(RegExReplace(String(sourceUnit), "\s+", ""))
    u := StrReplace(u, "µ", "u")
    switch key {
        case "bun": return InStr(u, "mmol/l") ? value / 0.357 : value
        case "creatinine": return InStr(u, "umol/l") ? value / 88.4 : value
        case "glucose": return InStr(u, "mmol/l") ? value * 18 : value
        case "calcium": return InStr(u, "mmol/l") ? value / 0.2495 : value
        case "magnesium": return InStr(u, "mmol/l") ? value / 0.4114 : value
        case "phosphate": return InStr(u, "mmol/l") ? value / 0.3229 : value
        case "albumin", "hemoglobin": return InStr(u, "g/l") && !InStr(u, "g/dl") ? value / 10 : value
        default: return value
    }
}

PatientV7_ExtractGridLabsFromBundle(bundle) {
    words := PatientV7_LabBundleWords(bundle)
    if words.Length = 0
        return []
    headers := PatientV7_GridHeaders(words)
    if headers.Length = 0
        return []
    times := PatientV7_GridTimes(words)
    values := []
    seen := Map()

    for header in headers {
        for rec in PatientV7_GridValuesForHeader(words, headers, header, times) {
            sig := rec.key "|" rec.value "|" rec.when "|" Round(rec.screenY / 6)
            if seen.Has(sig) {
                values[seen[sig]].ocrSupport += rec.ocrSupport
                continue
            }
            values.Push(rec)
            seen[sig] := values.Length
        }
    }

    ; A valid result row normally contains multiple different analytes at the
    ; same vertical position. Preserve that structural evidence so common labs
    ; do not disappear merely because a tiny focused re-read loses punctuation.
    for rec in values {
        rowKeys := Map(rec.key, true)
        for other in values {
            if other.key = rec.key
                continue
            if Abs(other.screenY - rec.screenY) <= Max(12, rec.h * 0.9)
                rowKeys[other.key] := true
        }
        rec.rowSupport := rowKeys.Count
    }

    ; Oldest/lower rows first. PCtx_AddLab inserts each record at the front,
    ; making the top/newest Cerner row the current value without date guessing.
    return PatientV7_SortGeometry(values, false, true)
}

PatientV13_TableTimeForX(times, valueX) {
    best := ""
    bestDistance := 1000000
    for stamp in times {
        distance := Abs(stamp.x - valueX)
        if distance < bestDistance {
            bestDistance := distance
            best := stamp.when
        }
    }
    return best
}

PatientV13_MergeTableLayoutLabs(bundle, labs) {
    words := PatientV7_LabBundleWords(bundle)
    if words.Length = 0
        return labs
    headers := PatientV7_GridHeaders(words)
    times := PatientV7_GridTimes(words)
    if headers.Length = 0
        return labs

    additions := []
    tableRows := Map()
    for header in headers {
        for word in words {
            if word.x <= header.x + header.w
                || Abs((word.y + word.h / 2) - (header.y + header.h / 2)) > Max(10, header.h * 0.9)
                continue
            token := PatientV7_GridNumericToken(word.text)
            if token = ""
                continue
            value := Number(token)
            if value < header.def.lo || value > header.def.hi
                continue

            blocked := false
            for other in headers {
                if other = header
                    continue
                if other.x > header.x + header.w
                    && other.x < word.x
                    && Abs((other.y + other.h / 2) - (header.y + header.h / 2)) <= Max(10, header.h * 0.9) {
                    blocked := true
                    break
                }
            }
            if blocked
                continue

            rowKey := Round((word.y + word.h / 2) / 8)
            tableRows[rowKey] := true

            additions.Push({
                key:header.key,
                value:PatientV7_NormalizedGridNumber(value),
                unit:header.def.unit,
                when:PatientV13_TableTimeForX(times, word.x + word.w / 2),
                conf:"moderate",
                source:"Cerner table view; analyte label and numeric value share a row; collection time matched by result column",
                raw:PCtx_LabLabel(header.key) " table value " word.text,
                screenY:word.y,
                x:word.x,
                y:word.y,
                w:word.w,
                h:word.h,
                ocrSupport:word.HasOwnProp("support") ? word.support : 1,
                rowSupport:1
            })
        }
    }

    ; A stacked card can contain one same-row label/value pair by chance.
    ; Require at least two such rows before treating the capture as a table.
    if tableRows.Count < 2
        return labs

    for candidate in additions {
        duplicate := false
        for existing in labs {
            if existing.key = candidate.key
                && existing.value = candidate.value
                && Abs(existing.screenY - candidate.screenY) <= Max(10, candidate.h) {
                duplicate := true
                break
            }
        }
        if !duplicate
            labs.Push(candidate)
    }
    return PatientV7_SortGeometry(labs, false, true)
}

PatientV7_ExtractQualitativeFindings(bundle) {
    findings := []
    seen := Map()
    for partName in ["labGrid", "orders", "sidebar"] {
        part := 0
        try part := bundle.%partName%
        if !IsObject(part)
            continue
        for item in PatientV2_GetLines(part) {
            text := PatientV2_CleanLine(item.text)
            if text = ""
                continue
            kind := ""
            label := ""
            value := ""
            if RegExMatch(text, "i)\b(UA\s+(?:Color|Clarity|pH|Spec(?:ific)?\s+Gravity|Glucose|Ketones|Blood|Protein|Nitrite|Leuk\s+Esterase|Bili|Urobilinogen|WBC|RBC|Bacteria))\b\s*[:=-]?\s*(.+)$", &m) {
                kind := "urinalysis", label := m[1], value := Trim(m[2])
            } else if RegExMatch(text, "i)\b(Oxygen\s+Therapy|O2\s+Therapy)\b\s*[:=-]?\s*(.+)$", &m) {
                kind := "oxygen", label := m[1], value := Trim(m[2])
            } else if RegExMatch(text, "i)\b(Room\s+Air|Nasal\s+Cannula|Non[- ]?rebreather|High[- ]?Flow|Ventilator)\b", &m) {
                kind := "oxygen", label := "Oxygen therapy", value := Trim(text)
            } else if RegExMatch(text, "i)\b((?:XR|X[- ]?ray|CT|MRI|Computed\s+Tomography|Magnetic\s+Resonance)[^:]{0,80})\b.*\b(In\s+Progress|Completed|Ordered|Pending)\b", &m) {
                kind := "imaging", label := Trim(m[1]), value := RegExMatch(text, "i)\b(In\s+Progress|Completed|Ordered|Pending)\b", &status) ? status[1] : ""
            }
            if kind = ""
                continue
            key := kind "|" StrLower(label) "|" StrLower(value)
            if seen.Has(key)
                continue
            seen[key] := true
            findings.Push({kind:kind, label:label, value:value, raw:text, source:partName, when:""})
        }
    }
    return findings
}

; -------------------------------------------------------------------------------------------------
; CERNER GRID CELL RECOVERY
; -------------------------------------------------------------------------------------------------
; Windows OCR often reads a Cerner column header but skips the tiny result directly beneath it.
; Cerner's Quick View column order is stable inside each visible result band. We use two or more
; recognized headers to learn the band spacing, then re-read only the missing cells at the actual
; row coordinates. No patient value is inferred from the schema: the schema supplies coordinates
; only, and a number still has to be visibly read inside that exact cell and pass the analyte range.

PatientV8_CernerSchemas() {
    static schemas := [
        { name:"chemistry-primary", minAnchors:2, maxRows:2, keys:[
            "sodium", "potassium", "chloride", "bicarbonate", "__agap", "bun", "creatinine", "egfr"
        ] },
        { name:"chemistry-secondary", minAnchors:2, maxRows:2, keys:[
            "glucose", "calcium", "totalprotein", "albumin", "phosphate", "bilirubintotal", "alkphos", "alt", "ast", "magnesium"
        ] },
        { name:"cbc-primary", minAnchors:2, maxRows:2, keys:[
            "wbc", "rbc", "hemoglobin", "hematocrit", "mcv", "mch", "mchc", "rdw"
        ] },
        { name:"platelets", minAnchors:1, maxRows:1, keys:["platelets"] }
    ]
    return schemas
}

PatientV8_SchemaKeyIndex(keys, wanted) {
    for index, key in keys {
        if key = wanted
            return index
    }
    return 0
}

PatientV8_BuildBandPlan(headers, schema, fallbackStep := 0) {
    candidates := []
    for header in headers {
        index := PatientV8_SchemaKeyIndex(schema.keys, header.key)
        if index > 0
            candidates.Push({ header:header, index:index })
    }
    if candidates.Length = 0
        return 0

    best := Map()
    bestSpread := 1000000
    for seed in candidates {
        selected := Map()
        minY := seed.header.y
        maxY := seed.header.y
        tolerance := Max(38, seed.header.h * 2.4)
        for candidate in candidates {
            if Abs(candidate.header.y - seed.header.y) > tolerance
                continue
            key := candidate.header.key
            if !selected.Has(key)
                || candidate.header.distance < selected[key].header.distance {
                selected[key] := candidate
            }
            minY := Min(minY, candidate.header.y)
            maxY := Max(maxY, candidate.header.y)
        }
        spread := maxY - minY
        if selected.Count > best.Count
            || (selected.Count = best.Count && spread < bestSpread) {
            best := selected
            bestSpread := spread
        }
    }
    if best.Count < schema.minAnchors
        return 0

    count := 0
    sumI := 0.0
    sumX := 0.0
    sumII := 0.0
    sumIX := 0.0
    sumY := 0.0
    sumH := 0.0
    for _, candidate in best {
        i := candidate.index - 1
        x := candidate.header.x
        count += 1
        sumI += i
        sumX += x
        sumII += i * i
        sumIX += i * x
        sumY += candidate.header.y
        sumH += candidate.header.h
    }

    if count >= 2 {
        denominator := count * sumII - sumI * sumI
        if Abs(denominator) < 0.001
            return 0
        step := (count * sumIX - sumI * sumX) / denominator
        baseX := (sumX - step * sumI) / count
    } else {
        step := fallbackStep > 0 ? fallbackStep : Max(90, sumH * 17)
        only := 0
        for _, candidate in best {
            only := candidate
            break
        }
        baseX := only.header.x - (only.index - 1) * step
    }
    if step < 45 || step > 900
        return 0

    return {
        schema:schema,
        anchors:best,
        anchorCount:best.Count,
        baseX:baseX,
        step:step,
        y:sumY / count,
        h:Max(6, sumH / count)
    }
}

PatientV8_BuildBandPlans(headers) {
    plans := []
    deferred := []
    stepTotal := 0.0
    stepCount := 0
    for schema in PatientV8_CernerSchemas() {
        if schema.minAnchors = 1 {
            deferred.Push(schema)
            continue
        }
        plan := PatientV8_BuildBandPlan(headers, schema)
        if !IsObject(plan)
            continue
        plans.Push(plan)
        stepTotal += plan.step
        stepCount += 1
    }
    fallbackStep := stepCount > 0 ? stepTotal / stepCount : 0
    for schema in deferred {
        plan := PatientV8_BuildBandPlan(headers, schema, fallbackStep)
        if IsObject(plan)
            plans.Push(plan)
    }
    return plans
}

PatientV8_NextBandY(plans, current) {
    nextY := current.y + Max(100, current.h * 8)
    minimumGap := Max(24, current.h * 1.4)
    for other in plans {
        if other = current || other.y <= current.y + minimumGap
            continue
        if other.y < nextY
            nextY := other.y
    }
    return nextY
}

PatientV8_RowAlreadyAdded(rows, y, tolerance) {
    for row in rows {
        if Abs(row.y - y) <= tolerance
            return true
    }
    return false
}

PatientV8_BandRows(words, times, plan, nextY, labs := 0, allowPredictedRows := true) {
    rows := []
    ; OCR bounding boxes for a Cerner header and its same-row value often
    ; share the baseline. Start just below the header's upper quarter so that
    ; a real value is not discarded merely because the font boxes overlap;
    ; the numeric-token and analyte-range gates below still reject header
    ; artifacts and unsupported values.
    minY := plan.y + plan.h * 0.30
    maxY := nextY - Max(2, plan.h * 0.15)
    tolerance := Max(7, plan.h * 0.42)

    for stamp in times {
        if stamp.y <= minY || stamp.y >= maxY
            continue
        if PatientV8_RowAlreadyAdded(rows, stamp.y, tolerance)
            continue
        rows.Push({ y:stamp.y, h:Max(6, stamp.h), when:stamp.when, x:0 })
    }

    ; Cerner sometimes loses the date but retains the time at the far left of
    ; the result row. A standalone HH:MM is safe as row geometry only.
    for word in words {
        if word.x >= plan.baseX - plan.step * 0.35
            continue
        centerY := word.y + word.h / 2
        if centerY <= minY || centerY >= maxY
            continue
        if !RegExMatch(word.text, "^\s*(\d{1,2}:\d{2})\s*$", &tm)
            continue
        if PatientV8_RowAlreadyAdded(rows, centerY, tolerance)
            continue
        rows.Push({ y:centerY, h:Max(6, word.h), when:tm[1], x:0 })
    }

    ; Already-grounded values also identify their own visual row and let the
    ; focused pass recover sibling analytes that Windows OCR skipped.
    if IsObject(labs) {
        for lab in labs {
            if PatientV8_SchemaKeyIndex(plan.schema.keys, lab.key) = 0
                continue
            centerY := lab.screenY + lab.h / 2
            if centerY <= minY || centerY >= maxY
                continue
            if PatientV8_RowAlreadyAdded(rows, centerY, tolerance)
                continue
            rows.Push({ y:centerY, h:Max(6, lab.h), when:lab.when, x:0 })
        }
    }

    ; If the timestamp was damaged, a horizontal cluster of at least two
    ; numeric cells still identifies a result row. Single orphan numbers do not.
    clusters := []
    left := plan.baseX - plan.step * 0.38
    right := plan.baseX + plan.step * (plan.schema.keys.Length - 0.30)
    for word in words {
        centerX := word.x + word.w / 2
        centerY := word.y + word.h / 2
        if centerX < left || centerX > right || centerY <= minY || centerY >= maxY
            continue
        if PatientV7_GridNumericToken(word.text) = ""
            continue
        target := 0
        for cluster in clusters {
            if Abs(cluster.y - centerY) <= Max(8, word.h * 0.55) {
                target := cluster
                break
            }
        }
        if !IsObject(target) {
            target := { y:centerY, h:word.h, count:0, columns:Map(), x:0 }
            clusters.Push(target)
        }
        column := Round((centerX - plan.baseX) / plan.step) + 1
        if column < 1 || column > plan.schema.keys.Length
            continue
        key := plan.schema.keys[column]
        if SubStr(key, 1, 2) = "__"
            continue
        target.columns[key] := true
        target.count += 1
        target.y := (target.y * (target.count - 1) + centerY) / target.count
        target.h := Max(target.h, word.h)
    }
    for cluster in clusters {
        if cluster.columns.Count < 2
            continue
        if PatientV8_RowAlreadyAdded(rows, cluster.y, tolerance)
            continue
        rows.Push({ y:cluster.y, h:Max(6, cluster.h), when:"", x:0 })
    }

    ; A strict capture must never invent row coordinates from a template.  The
    ; legacy diagnostic path can still request the old geometry-only probes,
    ; but production parsing leaves an absent timestamp/row absent.
    if allowPredictedRows {
        predictedY := plan.y + plan.h * 2.4
        predictedGap := Max(14, plan.h * 1.95)
        predictedCount := 0
        while predictedY < maxY && predictedCount < plan.schema.maxRows {
            if !PatientV8_RowAlreadyAdded(rows, predictedY, tolerance)
                rows.Push({ y:predictedY, h:Max(6, plan.h), when:"", x:0 })
            predictedY += predictedGap
            predictedCount += 1
        }
    }

    rows := PatientV7_SortGeometry(rows)
    while rows.Length > plan.schema.maxRows
        rows.Pop()
    return rows
}

PatientV8_CellRowHalfHeight(rows, row) {
    nearest := 1000000
    for other in rows {
        if other = row
            continue
        nearest := Min(nearest, Abs(other.y - row.y))
    }
    half := Max(8, row.h * 0.90)
    if nearest < 1000000
        half := Min(half, Max(8, nearest * 0.48))
    return Max(8, half)
}

PatientV8_FocusedCellValue(x, y, w, h, def, anchorCount) {
    passes := [
        PatientV2_TryOcrRect(x, y, w, h, 3.2, false),
        PatientV2_TryOcrRect(x, y, w, h, 4.6, true),
        PatientV2_TryOcrRect(x, y, w, h, 4.0, true, 110)
    ]
    values := Map()
    raw := ""
    for result in passes {
        value := PatientV7_SingleGridNumber(result, def)
        try raw .= (raw = "" ? "" : " | ") Trim(result.Text)
        if value = ""
            continue
        values[value] := values.Has(value) ? values[value] + 1 : 1
    }

    best := ""
    bestCount := 0
    tied := false
    for value, count in values {
        if count > bestCount {
            best := value
            bestCount := count
            tied := false
        } else if count = bestCount {
            tied := true
        }
    }
    if tied && values.Count > 1 {
        ; One final color pass is a tie-breaker only; disagreement remains blank.
        result := PatientV2_TryOcrRect(x, y, w, h, 2.5, false)
        value := PatientV7_SingleGridNumber(result, def)
        try raw .= (raw = "" ? "" : " | ") Trim(result.Text)
        if value != "" {
            values[value] := values.Has(value) ? values[value] + 1 : 1
            if values[value] > bestCount
                best := value, bestCount := values[value], tied := false
        }
    }

    if best = "" || tied
        return 0
    ; No grid value is allowed through on a single OCR observation. Header
    ; anchors establish which analyte column a cell belongs to; they do not
    ; validate the digits inside the cell. Two independent transforms must
    ; agree, including for display-only values.
    if bestCount < 2
        return 0
    return { value:best, support:bestCount, raw:raw }
}

PatientV8_LabAtRow(labs, key, y, tolerance) {
    for lab in labs {
        if lab.key = key && Abs(lab.screenY - y) <= tolerance
            return true
    }
    return false
}

PatientV8_RecomputeRowSupport(labs) {
    for lab in labs {
        rowKeys := Map(lab.key, true)
        for other in labs {
            if other.key = lab.key
                continue
            if Abs(other.screenY - lab.screenY) <= Max(12, lab.h * 0.9)
                rowKeys[other.key] := true
        }
        lab.rowSupport := rowKeys.Count
    }
    return labs
}

; -------------------------------------------------------------------------------------------------
; ADAPTIVE GRID RECOVERY
; -------------------------------------------------------------------------------------------------
; Patient result pages may place any analyte in any column and may omit entire panels. Recovery is
; therefore driven only by the headers and rows actually visible in this capture. There is no BMP,
; CBC, or Cerner column-order template here. A recognized header owns a local column bounded by its
; visible neighbors; timestamps, already-read values, or a horizontal numeric cluster identify the
; visible result rows. The focused OCR consensus still has to read the number twice.

PatientV9_HeaderBands(headers) {
    bands := []
    for header in PatientV7_SortGeometry(headers) {
        centerY := header.y + header.h / 2
        target := 0
        for band in bands {
            if Abs(band.y - centerY) <= Max(28, header.h * 1.8) {
                target := band
                break
            }
        }
        if !IsObject(target) {
            target := { y:centerY, h:header.h, x:header.x, headers:[], keys:Map(), count:0 }
            bands.Push(target)
        }
        ; A duplicated OCR header contributes no new geometry.
        if target.keys.Has(header.key)
            continue
        target.headers.Push(header)
        target.keys[header.key] := true
        target.count += 1
        target.y := (target.y * (target.count - 1) + centerY) / target.count
        target.h := Max(target.h, header.h)
        target.x := Min(target.x, header.x)
    }
    for band in bands
        band.headers := PatientV7_SortGeometry(band.headers, true)
    return PatientV7_SortGeometry(bands)
}

PatientV9_NextBandY(bands, current) {
    nextY := current.y + Max(140, current.h * 10)
    for band in bands {
        if band = current || band.y <= current.y + Max(24, current.h * 1.4)
            continue
        nextY := Min(nextY, band.y)
    }
    return nextY
}

PatientV9_HeaderBounds(band, header) {
    index := 0
    for i, candidate in band.headers {
        if candidate = header {
            index := i
            break
        }
    }
    if index = 0
        return { left:header.x - 60, right:header.x + Max(120, header.w + 50) }

    center := header.x + header.w / 2
    previous := index > 1 ? band.headers[index - 1] : 0
    following := index < band.headers.Length ? band.headers[index + 1] : 0
    if IsObject(previous) {
        previousCenter := previous.x + previous.w / 2
        left := (previousCenter + center) / 2
    } else if IsObject(following) {
        nextCenter := following.x + following.w / 2
        left := center - Min(220, Max(60, (nextCenter - center) / 2))
    } else {
        left := header.x - Max(45, header.h * 3)
    }

    if IsObject(following) {
        nextCenter := following.x + following.w / 2
        right := (center + nextCenter) / 2
    } else if IsObject(previous) {
        previousCenter := previous.x + previous.w / 2
        right := center + Min(220, Max(60, (center - previousCenter) / 2))
    } else {
        right := header.x + Max(120, header.w + 50)
    }
    return { left:Max(0, left), right:Max(left + 40, right) }
}

PatientV9_BandRows(words, times, band, nextY, labs := 0) {
    rows := []
    minY := band.y + band.h * 0.45
    maxY := nextY - Max(3, band.h * 0.2)
    tolerance := Max(7, band.h * 0.48)

    ; A visible collection timestamp is direct row evidence, regardless of its
    ; horizontal position or the analyte mix on that row.
    for stamp in times {
        if stamp.y <= minY || stamp.y >= maxY
            continue
        if PatientV8_RowAlreadyAdded(rows, stamp.y, tolerance)
            continue
        rows.Push({ y:stamp.y, h:Max(6, stamp.h), when:stamp.when, x:0 })
    }

    ; A value already grounded beneath any header in this band identifies the
    ; same result row for sibling columns that broad OCR skipped.
    if IsObject(labs) {
        for lab in labs {
            if !band.keys.Has(lab.key)
                continue
            centerY := lab.screenY + lab.h / 2
            if centerY <= minY || centerY >= maxY
                continue
            if PatientV8_RowAlreadyAdded(rows, centerY, tolerance)
                continue
            rows.Push({ y:centerY, h:Max(6, lab.h), when:lab.when, x:0 })
        }
    }

    ; If timestamps are absent, two visible numeric cells aligned across actual
    ; header columns establish a row. A one-column panel needs one visible cell;
    ; this identifies geometry only and never supplies the recovered value.
    clusters := []
    for word in words {
        centerY := word.y + word.h / 2
        if centerY <= minY || centerY >= maxY
            continue
        token := PatientV7_GridNumericToken(word.text)
        if token = ""
            continue
        centerX := word.x + word.w / 2
        columnKey := ""
        for header in band.headers {
            bounds := PatientV9_HeaderBounds(band, header)
            if centerX >= bounds.left && centerX < bounds.right {
                columnKey := header.key
                break
            }
        }
        if columnKey = ""
            continue
        target := 0
        for cluster in clusters {
            if Abs(cluster.y - centerY) <= Max(8, word.h * 0.55) {
                target := cluster
                break
            }
        }
        if !IsObject(target) {
            target := { y:centerY, h:word.h, count:0, columns:Map(), x:0 }
            clusters.Push(target)
        }
        target.columns[columnKey] := true
        target.count += 1
        target.y := (target.y * (target.count - 1) + centerY) / target.count
        target.h := Max(target.h, word.h)
    }
    requiredColumns := band.headers.Length > 1 ? 2 : 1
    for cluster in clusters {
        if cluster.columns.Count < requiredColumns
            continue
        if PatientV8_RowAlreadyAdded(rows, cluster.y, tolerance)
            continue
        rows.Push({ y:cluster.y, h:Max(6, cluster.h),
            when:PatientV7_GridNearestTime(times, cluster.y, cluster.h), x:0 })
    }

    rows := PatientV7_SortGeometry(rows)
    while rows.Length > 20
        rows.Pop()
    return rows
}

PatientV9_RecoverMissingScreenGridLabs(bundle, labs) {
    gridResult := 0
    try gridResult := bundle.labGrid
    if !IsObject(gridResult)
        return labs

    words := PatientV7_LabBundleWords(bundle)
    headers := PatientV7_GridHeaders(words)
    if headers.Length = 0
        return labs
    bands := PatientV9_HeaderBands(headers)
    times := PatientV7_GridTimes(words)

    for band in bands {
        rows := PatientV9_BandRows(words, times, band, PatientV9_NextBandY(bands, band), labs)
        if rows.Length = 0
            continue
        for row in rows {
            halfHeight := PatientV8_CellRowHalfHeight(rows, row)
            for header in band.headers {
                if PatientV8_LabAtRow(labs, header.key, row.y, Max(10, row.h * 0.9))
                    continue
                bounds := PatientV9_HeaderBounds(band, header)
                cropX := Round(bounds.left)
                cropW := Max(40, Round(bounds.right - bounds.left))
                cropY := Round(row.y - halfHeight)
                cropH := Max(10, Round(halfHeight * 2))
                ToolTip "READING " StrUpper(PCtx_LabLabel(header.key)) "  ·  ADAPTIVE CELL"
                focused := PatientV8_FocusedCellValue(cropX, cropY, cropW, cropH, header.def, band.headers.Length)
                if !IsObject(focused)
                    continue
                labs.Push({
                    key:header.key,
                    value:focused.value,
                    unit:header.def.unit,
                    when:row.when,
                    conf:"moderate",
                    source:"Visible result grid; focused numeric cell read; analyte and local column grounded by its captured header; no panel order assumed; source unit inferred from the configured analyte profile (" header.def.unit ")",
                    raw:PCtx_LabLabel(header.key) " adaptive focused grid cell " focused.raw,
                    screenY:row.y,
                    x:cropX,
                    y:cropY,
                    w:cropW,
                    h:cropH,
                    ocrSupport:focused.support,
                    rowSupport:1,
                    focusedConfirmed:true,
                    verifyOriginal:focused.value,
                    verifyNormal:"",
                    verifyGray:""
                })
            }
        }
    }
    return PatientV7_SortGeometry(PatientV8_RecomputeRowSupport(labs), false, true)
}

; -------------------------------------------------------------------------------------------------
; STACKED / SPLIT-PANEL RECOVERY AND CAPTURE QUALITY
; -------------------------------------------------------------------------------------------------
; Some Cerner views render an analyte and value as a vertical card or a two-column label/value list
; instead of a horizontal laboratory grid. A recognized label may nominate only a nearby visible
; number. The number is accepted only when two focused OCR transforms agree and it passes that
; analyte's physiologic bounds. This recovers layout changes without guessing a panel or a value.

PatientV10_HeaderBetween(headers, header, word) {
    headerCenterY := header.y + header.h / 2
    wordCenterY := word.y + word.h / 2
    for other in headers {
        if other = header
            continue
        otherCenterY := other.y + other.h / 2
        ; Same-row label between a label and its proposed value.
        if Abs(otherCenterY - headerCenterY) <= Max(12, header.h * 0.8)
            && other.x > header.x && other.x < word.x
            return true
        ; Vertical label between a stacked label and its proposed value.
        if wordCenterY > headerCenterY
            && otherCenterY > headerCenterY && otherCenterY < wordCenterY
            && Abs((other.x + other.w / 2) - (header.x + header.w / 2))
                <= Max(90, header.w * 0.8)
            return true
    }
    return false
}

PatientV10_RecoverStackedLabPairs(bundle, labs) {
    words := PatientV7_LabBundleWords(bundle)
    headers := PatientV7_GridHeaders(words)
    if headers.Length = 0
        return labs
    times := PatientV7_GridTimes(words)
    used := Map()

    for header in PatientV7_SortGeometry(headers) {
        best := 0
        bestScore := 1000000
        headerCenterX := header.x + header.w / 2
        headerCenterY := header.y + header.h / 2
        for word in words {
            token := PatientV7_GridNumericToken(word.text)
            if token = ""
                continue
            numericValue := Number(token)
            if numericValue < header.def.lo || numericValue > header.def.hi
                continue
            sig := Round(word.x / 4) "|" Round(word.y / 4) "|" token
            if used.Has(sig)
                continue

            wordCenterX := word.x + word.w / 2
            wordCenterY := word.y + word.h / 2
            dx := wordCenterX - headerCenterX
            dy := wordCenterY - headerCenterY
            sameRow := Abs(dy) <= Max(13, header.h * 0.85)
                && dx >= Max(8, header.w * 0.12)
                && dx <= Max(280, header.w * 2.8)
            stacked := dy >= Max(10, header.h * 0.60)
                && dy <= Max(95, header.h * 4.8)
                && Abs(dx) <= Max(100, header.w * 0.72)
            if !sameRow && !stacked
                continue
            if PatientV10_HeaderBetween(headers, header, word)
                continue
            score := sameRow ? Abs(dx) + Abs(dy) * 4 : dy + Abs(dx) * 0.35
            ; When two transforms land on the same glyphs, prefer an explicitly
            ; observed decimal token over the otherwise identical integer read.
            ; The focused consensus must still independently match it below.
            sameGlyph := IsObject(best)
                && Abs(word.x - best.word.x) <= Max(14, word.h)
                && Abs(word.y - best.word.y) <= Max(7, word.h * 0.45)
            preferDecimal := IsObject(best) && (Abs(score - bestScore) <= 8 || sameGlyph)
                && InStr(token, ".") && !InStr(best.token, ".")
            if score < bestScore || preferDecimal {
                best := { word:word, token:token, sig:sig }
                bestScore := score
            }
        }
        if !IsObject(best)
            continue
        rowY := best.word.y + best.word.h / 2
        if PatientV8_LabAtRow(labs, header.key, rowY, Max(12, best.word.h))
            continue

        padX := Max(14, Round(best.word.h * 1.8))
        padY := Max(8, Round(best.word.h * 0.9))
        cropX := Round(best.word.x - padX)
        cropY := Round(best.word.y - padY)
        cropW := Round(best.word.w + padX * 2)
        cropH := Round(best.word.h + padY * 2)
        ToolTip "READING " StrUpper(PCtx_LabLabel(header.key)) "  ·  STACKED CELL"
        focused := PatientV8_FocusedCellValue(
            cropX, cropY, cropW, cropH, header.def, 1
        )
        if !IsObject(focused) {
            ; The focused crop can be too narrow for a photographed decimal
            ; even when the same numeric token was independently observed in
            ; two full-grid OCR transforms. That is still direct cell
            ; evidence, so retain it only with repeated full-pass support.
            fullSupport := best.word.HasOwnProp("support") ? best.word.support : 1
            if fullSupport < 2
                continue
            focused := { value:best.token, support:fullSupport, raw:best.word.text }
        }
        focusedConfirmed := Number(focused.value) = Number(best.token)
        decimalShift := !focusedConfirmed && InStr(best.token, ".")
            && Abs(Number(focused.value) - Number(best.token) * 10) < 0.001
        if !focusedConfirmed && !decimalShift
            continue
        used[best.sig] := true
        labs.Push({
            key:header.key,
            value:best.token,
            unit:header.def.unit,
            when:PatientV7_GridNearestTime(times, best.word.y, best.word.h),
            conf:"moderate",
            source:"Visible stacked or split result; analyte grounded by its adjacent captured label; numeric cell confirmed by independent focused OCR; source unit inferred from the configured analyte profile (" header.def.unit ")",
            raw:PCtx_LabLabel(header.key) " stacked focused cell " focused.raw,
            screenY:rowY,
            x:cropX,
            y:cropY,
            w:cropW,
            h:cropH,
            headerX:header.x,
            headerY:header.y,
            ocrSupport:focused.support,
            rowSupport:1,
            focusedConfirmed:focusedConfirmed,
            verifyOriginal:best.token,
            verifyNormal:"",
            verifyGray:""
        })
    }
    return PatientV7_SortGeometry(PatientV8_RecomputeRowSupport(labs), false, true)
}

PatientV10_AssessCaptureQuality(bundle, text := "") {
    words := PatientV7_LabBundleWords(bundle)
    total := words.Length
    usable := 0
    numeric := 0
    corrupt := 0
    for word in words {
        clean := Trim(String(word.text))
        if RegExMatch(clean, "[A-Za-z0-9]") && StrLen(clean) >= 2
            usable += 1
        if PatientV7_GridNumericToken(clean) != ""
            numeric += 1
        if RegExMatch(clean, "[^\x20-\x7E]")
            corrupt += 1
    }
    headers := PatientV7_GridHeaders(words)
    labLike := PatientV7_LooksLikeLabGridText(text) || headers.Length >= 3
    ratio := total > 0 ? usable / total : 0
    status := "readable"
    reason := "screen text and geometry are usable"
    if total = 0 || (total >= 8 && ratio < 0.30) || (total >= 8 && corrupt / total > 0.45) {
        status := "unreadable"
        reason := "insufficient reliable text geometry"
    } else if labLike && (headers.Length < 2 || numeric < 2) {
        status := "unreadable"
        reason := "laboratory screen lacks enough grounded headers or numeric cells"
    } else if labLike && (headers.Length < 3 || numeric < 4 || ratio < 0.55) {
        status := "degraded"
        reason := "laboratory screen is partially readable"
    }
    return {
        status:status,
        reason:reason,
        wordCount:total,
        usableWordCount:usable,
        numericWordCount:numeric,
        headerCount:headers.Length,
        labLike:labLike,
        score:Round(ratio * 100)
    }
}

PatientV8_RecoverMissingScreenGridLabs(bundle, labs) {
    gridResult := 0
    try gridResult := bundle.labGrid
    if !IsObject(gridResult)
        return labs

    words := PatientV7_LabBundleWords(bundle)
    headers := PatientV7_GridHeaders(words)
    plans := PatientV8_BuildBandPlans(headers)
    if plans.Length = 0
        return labs
    times := PatientV7_GridTimes(words)

    for plan in plans {
        nextY := PatientV8_NextBandY(plans, plan)
        rows := PatientV8_BandRows(words, times, plan, nextY, labs)
        for row in rows {
            halfHeight := PatientV8_CellRowHalfHeight(rows, row)
            for index, key in plan.schema.keys {
                if SubStr(key, 1, 2) = "__"
                    continue
                def := PatientV7_GridDefByKey(key)
                if !IsObject(def)
                    continue
                if PatientV8_LabAtRow(labs, key, row.y, Max(10, row.h * 0.9))
                    continue

                expectedX := plan.baseX + (index - 1) * plan.step
                cropX := Round(expectedX - plan.step * 0.28)
                cropW := Round(plan.step * 0.72)
                cropY := Round(row.y - halfHeight)
                cropH := Max(10, Round(halfHeight * 2))
                ToolTip "READING " StrUpper(PCtx_LabLabel(key)) "  ·  FOCUSED CELL"
                focused := PatientV8_FocusedCellValue(
                    cropX, cropY, cropW, cropH, def, plan.anchorCount
                )
                if !IsObject(focused)
                    continue

                labs.Push({
                    key:key,
                    value:focused.value,
                    unit:def.unit,
                    when:row.when,
                    conf:"moderate",
                    source:"Cerner Quick View grid; focused numeric cell read; analyte coordinate grounded by " plan.anchorCount " visible header anchor(s); source unit inferred from the configured analyte profile (" def.unit ")",
                    raw:PCtx_LabLabel(key) " focused grid cell " focused.raw,
                    screenY:row.y,
                    x:cropX,
                    y:cropY,
                    w:cropW,
                    h:cropH,
                    ocrSupport:focused.support,
                    rowSupport:1,
                    focusedConfirmed:true,
                    verifyOriginal:focused.value,
                    verifyNormal:"",
                    verifyGray:""
                })
            }
        }
    }
    return PatientV7_SortGeometry(PatientV8_RecomputeRowSupport(labs), false, true)
}

PatientV7_GridDefByKey(key) {
    for def in PatientV7_GridLabDefs() {
        if def.key = key
            return def
    }
    return 0
}

PatientV7_NormalizedGridNumber(value) {
    if value = "" || !IsNumber(value)
        return ""
    text := Format("{:.4f}", Number(value))
    text := RegExReplace(text, "0+$", "")
    return RegExReplace(text, "\.$", "")
}

PatientV7_SingleGridNumber(result, def) {
    if !IsObject(result) || !IsObject(def)
        return ""
    values := Map()
    numericWords := []
    try {
        for word in result.Words {
            fragment := PatientV7_GridNumericFragment(word.Text)
            if fragment != ""
                numericWords.Push({ token:fragment, x:word.x, y:word.y, w:word.w, h:word.h })
        }
    }
    ; Keep a decimal that OCR split into adjacent tokens ("1" + "60" or
    ; "1" + ".60") together. This is a cell-local formatting repair, not a
    ; guess from another analyte; it is still subject to the range gate and to
    ; two independent OCR passes in PatientV11_FocusedCellValue.
    for index, first in numericWords {
        if index >= numericWords.Length
            continue
        second := numericWords[index + 1]
        if second.x < first.x
            continue
        if Abs((second.y + second.h / 2) - (first.y + first.h / 2)) > Max(12, first.h * 0.9)
            continue
        if second.x - (first.x + first.w) > Max(24, first.h * 2.5)
            continue
        if InStr(second.token, ".") = 1
            joined := first.token SubStr(second.token, 1)
        else
            joined := first.token "." second.token
        if !RegExMatch(joined, "^\d{1,4}\.\d{1,4}$")
            continue
        joinedValue := Number(joined)
        if joinedValue < def.lo || joinedValue > def.hi
            continue
        normalizedJoined := PatientV7_NormalizedGridNumber(joinedValue)
        values[normalizedJoined] := Max(values.Has(normalizedJoined) ? values[normalizedJoined] : 0, 100000 + first.w * first.h + second.w * second.h)
    }
    try {
        for word in result.Words {
            token := PatientV7_GridNumericToken(word.Text)
            if token = ""
                continue
            value := Number(token)
            ; Photograph/OCR engines frequently drop a decimal point in a
            ; compact Cerner cell (for example 4.7 -> 47).  Permit one
            ; deterministic repair only when the unrepaired token is outside
            ; the analyte range and exactly one decimal placement lands inside
            ; that range.  The surrounding caller still requires independent
            ; OCR passes to agree, so this cannot turn a single noisy read into
            ; an accepted value.
            if (value < def.lo || value > def.hi) && RegExMatch(token, "^\d{2,4}$") {
                repaired := PatientV7_UniqueDecimalRepair(token, def)
                if repaired != ""
                    value := Number(repaired), token := repaired
            }
            if value < def.lo || value > def.hi
                continue
            normalized := PatientV7_NormalizedGridNumber(value)
            score := StrLen(token) * 100 + Max(0, word.w * word.h)
            if !values.Has(normalized) || score > values[normalized]
                values[normalized] := score
        }
    }
    if values.Count = 0 {
        try token := PatientV7_GridNumericToken(result.Text)
        catch
            token := ""
        if token != "" {
            value := Number(token)
            if (value < def.lo || value > def.hi) && RegExMatch(token, "^\d{2,4}$") {
                repaired := PatientV7_UniqueDecimalRepair(token, def)
                if repaired != ""
                    value := Number(repaired), token := repaired
            }
            if value >= def.lo && value <= def.hi
                values[PatientV7_NormalizedGridNumber(value)] := StrLen(token) * 100
        }
    }
    if values.Count = 0
        return ""
    if values.Count = 1 {
        for value, _ in values
            return value
    }

    bestValue := ""
    bestScore := -1
    secondScore := -1
    for value, score in values {
        if score > bestScore {
            secondScore := bestScore
            bestScore := score
            bestValue := value
        } else if score > secondScore {
            secondScore := score
        }
    }
    ; A longer, materially larger token can outrank a one-character grid/flag
    ; artifact. Similar-sized competing numbers remain ambiguous and are dropped.
    return bestScore - secondScore >= 90 ? bestValue : ""
}

PatientV7_VerifyScreenGridLabs(labs) {
    if !IsObject(labs) || labs.Length = 0
        return []
    verified := []
    total := labs.Length

    for index, lab in labs {
        def := PatientV7_GridDefByKey(lab.key)
        if !IsObject(def)
            continue

        if lab.HasOwnProp("focusedConfirmed") && lab.focusedConfirmed
            && lab.HasOwnProp("ocrSupport") && lab.ocrSupport >= 2 {
            lab.status := "accepted"
            lab.accepted := true
            lab.sourceCount := lab.ocrSupport
            lab.geometry := {
                x: lab.x,
                y: lab.y,
                w: lab.w,
                h: lab.h,
                headerX: lab.HasOwnProp("headerX") ? lab.headerX : "",
                headerY: lab.HasOwnProp("headerY") ? lab.headerY : ""
            }
            verified.Push(lab)
            continue
        }

        ocrSupport := lab.HasOwnProp("ocrSupport") ? lab.ocrSupport : 1
        rowSupport := lab.HasOwnProp("rowSupport") ? lab.rowSupport : 1
        originalValue := PatientV7_NormalizedGridNumber(lab.value)
        isCreatinine := lab.key = "creatinine"

        ToolTip "VERIFYING LAB CELL " index " / " total

        padX := Max(18, Round(lab.h * 2.5))
        padY := Max(10, Round(lab.h * 1.25))
        cropX := Round(lab.x - padX)
        cropY := Round(lab.y - padY)
        cropW := Round(lab.w + padX * 2)
        cropH := Round(lab.h + padY * 2)

        ; Two deliberately different transforms reduce shared OCR failure:
        ; the lower-scale color pass preserves decimal punctuation that can
        ; disappear when aggressively enlarged, while the high-scale gray pass
        ; improves faint glyph recognition.
        normalResult := PatientV2_TryOcrRect(cropX, cropY, cropW, cropH, 3.2, false)
        grayResult := PatientV2_TryOcrRect(cropX, cropY, cropW, cropH, 4.8, true)
        monoResult := PatientV2_TryOcrRect(cropX, cropY, cropW, cropH, 4.0, true, 110)
        normalValue := PatientV7_SingleGridNumber(normalResult, def)
        grayValue := PatientV7_SingleGridNumber(grayResult, def)
        monoValue := PatientV7_SingleGridNumber(monoResult, def)
        votes := Map()
        for value in [originalValue, normalValue, grayValue, monoValue] {
            if value = ""
                continue
            votes[value] := votes.Has(value) ? votes[value] + 1 : 1
        }

        bestValue := ""
        bestCount := 0
        tied := false
        for value, count in votes {
            if count > bestCount {
                bestValue := value
                bestCount := count
                tied := false
            } else if count = bestCount {
                tied := true
            }
        }

        ; A tight OCR crop can lose a decimal point even when the wider grid
        ; pass saw it explicitly (1.7 -> 17). Preserve the directly observed
        ; decimal when the focused consensus differs by exactly one decimal
        ; place; never invent a decimal for an integer-only original token.
        if originalValue != "" && InStr(String(lab.value), ".")
            && bestValue != "" && !InStr(bestValue, ".") {
            originalNumber := Number(originalValue)
            bestNumber := Number(bestValue)
            if Abs(bestNumber - originalNumber * 10) < 0.001
                bestValue := originalValue, bestCount := Max(bestCount, 2), tied := false
        }
        if bestCount < 2 || tied {
            ; A decimal creatinine may survive when two independent full-grid
            ; passes agree and it sits on a dense chemistry row. This is a
            ; structural fallback, never a guessed decimal or isolated token.
            if isCreatinine
                && ocrSupport >= 2
                && rowSupport >= 3
                && InStr(String(lab.value), ".") {
                bestValue := originalValue
                bestCount := 2
                tied := false
            } else {
                continue
            }
        }

        lab.value := bestValue
        lab.conf := "moderate"
        lab.source .= isCreatinine && bestCount = 2
            ? "; numeric cell confirmed by focused OCR consensus or repeated coherent chemistry-row OCR"
            : "; numeric cell confirmed by focused OCR consensus"
        lab.verifyOriginal := originalValue
        lab.verifyNormal := normalValue
        lab.verifyGray := grayValue
        lab.verifyMono := monoValue
        lab.status := "accepted"
        lab.accepted := true
        lab.sourceCount := bestCount
        lab.geometry := {
            x: lab.x,
            y: lab.y,
            w: lab.w,
            h: lab.h,
            headerX: lab.HasOwnProp("headerX") ? lab.headerX : "",
            headerY: lab.HasOwnProp("headerY") ? lab.headerY : ""
        }
        verified.Push(lab)
    }
    return verified
}

PCtx_LabLabel(key) {
    switch key {
        case "sodium": return "Sodium"
        case "potassium": return "Potassium"
        case "chloride": return "Chloride"
        case "bicarbonate": return "Bicarbonate"
        case "bun": return "BUN"
        case "creatinine": return "Creatinine"
        case "glucose": return "Glucose"
        case "calcium": return "Calcium"
        case "magnesium": return "Magnesium"
        case "phosphate": return "Phosphate"
        case "albumin": return "Albumin"
        case "rbc": return "RBC"
        case "wbc": return "WBC"
        case "hemoglobin": return "Hemoglobin"
        case "hematocrit": return "Hematocrit"
        case "platelets": return "Platelets"
        case "inr": return "INR"
        case "ptt": return "aPTT"
        case "ast": return "AST"
        case "alt": return "ALT"
        case "bilirubin": return "Total bilirubin"
        case "alkphos": return "Alkaline phosphatase"
        case "ldh": return "LDH"
        case "uricacid": return "Uric acid"
        case "lactate": return "Lactate"
        case "anc": return "ANC"
        case "osmolality": return "Measured osmolality"
        case "troponin": return "Troponin"
        case "neutrophilPercent": return "Neutrophil %"
        case "lymphocytePercent": return "Lymphocyte %"
        case "monocytePercent": return "Monocyte %"
        case "eosinophilPercent": return "Eosinophil %"
        case "basophilPercent": return "Basophil %"
        case "immatureGranulocytePercent": return "Immature granulocyte %"
        case "neutroAbsolute": return "Neutrophil absolute"
        case "lymphAbsolute": return "Lymphocyte absolute"
        case "monoAbsolute": return "Monocyte absolute"
        case "eosAbsolute": return "Eosinophil absolute"
        case "basoAbsolute": return "Basophil absolute"
        case "nrbcs": return "nRBC"
        case "bnp": return "B-type natriuretic peptide"
        case "egfr": return "eGFR"
        case "phenytoin": return "Phenytoin"
        case "vancomycin": return "Vancomycin level"
        case "iron": return "Iron"
        case "tibc": return "TIBC"
        case "ferritin": return "Ferritin"
        case "ph": return "pH"
        case "betahydroxybutyrate": return "Beta-hydroxybutyrate"
        case "acetaminophen": return "Acetaminophen level"
        case "digoxin": return "Digoxin level"
        case "heartRate": return "Heart rate"
        case "respiratoryRate": return "Respiratory rate"
        case "temperature": return "Temperature"
        case "spo2": return "SpO2"
        case "qt": return "QT interval"
        case "qtc": return "QTc"
        case "systolicBP": return "Systolic BP"
        case "diastolicBP": return "Diastolic BP"
        default: return key
    }
}

PCtx_LabUnitPattern(key) {
    switch key {
        case "sodium", "potassium", "chloride", "bicarbonate", "lactate", "betahydroxybutyrate":
            return "(?:mmol|mEq)\s*/\s*L"
        case "bun", "glucose", "calcium", "magnesium", "phosphate":
            return "(?:mg\s*/\s*dL|mmol\s*/\s*L)"
        case "creatinine":
            return "(?:mg\s*/\s*dL|(?:µ|u)mol\s*/\s*L)"
        case "bilirubin", "uricacid":
            return "mg\s*/\s*dL"
        case "albumin", "hemoglobin":
            return "(?:g\s*/\s*dL|g\s*/\s*L)"
        case "rbc":
            return "(?:(?:M|[x×]?\s*10\s*[\^*]?\s*6)\s*/\s*(?:u|µ)L|[x×]?\s*10\s*[\^*]?\s*12\s*/\s*L)"
        case "wbc", "platelets", "anc":
            return "(?:(?:K|[x×]?\s*10\s*[\^*]?\s*3)\s*/\s*(?:u|µ)L|[x×]?\s*10\s*[\^*]?\s*9\s*/\s*L)"
        case "hematocrit":
            return "(?:%|L\s*/\s*L)"
        case "spo2":
            return "%"
        case "ptt":
            return "(?:sec|seconds?)"
        case "ast", "alt", "alkphos", "ldh":
            return "U\s*/\s*L"
        case "osmolality":
            return "mOsm\s*/\s*kg"
        case "egfr":
            return "mL\s*/\s*min(?:\s*/\s*1\.73\s*m2)?"
        case "phenytoin", "vancomycin", "acetaminophen":
            return "mcg\s*/\s*mL"
        case "digoxin":
            return "ng\s*/\s*mL"
        case "iron", "tibc":
            return "mcg\s*/\s*dL"
        case "ferritin":
            return "ng\s*/\s*mL"
        case "neutrophilPercent", "lymphocytePercent", "monocytePercent", "eosinophilPercent", "basophilPercent", "immatureGranulocytePercent":
            return "%"
        case "neutroAbsolute", "lymphAbsolute", "monoAbsolute", "eosAbsolute", "basoAbsolute", "nrbcs":
            return "(?:(?:K|[x×]?\s*10\s*[\^*]?\s*3)\s*/\s*(?:u|µ)L|[x×]?\s*10\s*[\^*]?\s*9\s*/\s*L)"
        case "bnp":
            return "(?:pg\s*/\s*mL|ng\s*/\s*L)"
        case "heartRate":
            return "bpm"
        case "respiratoryRate":
            return "(?:/\s*min|breaths?\s*/\s*min)"
        case "temperature":
            return "(?:°?\s*C|Celsius)"
        case "qt", "qtc":
            return "ms"
        default:
            return ""
    }
}

; Calculators retain their established canonical units. OCR rows that already
; use SI units are converted at the evidence boundary, then every presentation
; surface converts canonical values back to the metric display standard.
PCtx_CanonicalizeLabValue(key, value, sourceUnit) {
    v := Number(value)
    u := StrLower(RegExReplace(String(sourceUnit), "\s+", ""))
    u := StrReplace(u, "µ", "u")

    switch key {
        case "bun":
            if InStr(u, "mmol/l")
                return v / 0.357
        case "glucose":
            if InStr(u, "mmol/l")
                return v * 18
        case "calcium":
            if InStr(u, "mmol/l")
                return v / 0.2495
        case "magnesium":
            if InStr(u, "mmol/l")
                return v / 0.4114
        case "phosphate":
            if InStr(u, "mmol/l")
                return v / 0.3229
        case "albumin", "hemoglobin":
            if InStr(u, "g/l") && !InStr(u, "g/dl")
                return v / 10
        case "hematocrit":
            if u = "l/l"
                return v * 100
    }
    return v
}

LabMetric_DisplayUnit(key) {
    override := LabMetric_UnitOverride(key)
    if override != ""
        return override
    switch key {
        case "sodium", "potassium", "chloride", "bicarbonate", "bun", "glucose", "calcium", "magnesium", "phosphate", "lactate", "betahydroxybutyrate":
            return "mmol/L"
        case "creatinine":
            return "µmol/L"
        case "albumin", "hemoglobin":
            return "g/L"
        case "rbc":
            return "×10^12/L"
        case "wbc", "platelets", "anc":
            return "×10^9/L"
        case "hematocrit", "spo2":
            return "%"
        default:
            for def in PCtx_LabDefs() {
                if def.key = key
                    return def.unit
            }
            return ""
    }
}

LabMetric_UnitOverride(key) {
    global AppSettingsIniPath
    try return Trim(IniRead(AppSettingsIniPath, "LabUnits", key, ""))
    return ""
}

LabMetric_SetUnitOverride(key, unit) {
    global AppSettingsIniPath, LocalSettingsDir
    try DirCreate(LocalSettingsDir)
    if unit = "" {
        try IniDelete(AppSettingsIniPath, "LabUnits", key)
    } else {
        try IniWrite(unit, AppSettingsIniPath, "LabUnits", key)
    }
}

LabMetric_InputUnit(key, defaultUnit := "") {
    override := LabMetric_UnitOverride(key)
    return override != "" ? override : defaultUnit
}

LabUnitSettings_Options(key) {
    switch key {
        case "albumin", "hemoglobin": return ["g/dL", "g/L"]
        case "bun": return ["mg/dL", "mmol/L"]
        case "creatinine": return ["mg/dL", "µmol/L"]
        case "glucose": return ["mg/dL", "mmol/L"]
        case "calcium": return ["mg/dL", "mmol/L"]
        case "magnesium": return ["mg/dL", "mmol/L"]
        case "phosphate": return ["mg/dL", "mmol/L"]
        case "rbc": return ["M/uL", "×10^12/L"]
        case "wbc", "platelets", "anc": return ["K/uL", "×10^9/L"]
        default: return []
    }
}

LabUnitSettings_Open(*) {
    global _labUnitsGui, _labUnitsList
    if IsObject(_labUnitsGui) {
        _labUnitsGui.Show()
        return
    }
    g := Gui("+ToolWindow", "PhUCKIT Lab Units")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm ym w500", "Default result units").SetFont("s11 bold")
    g.Add("Text", "xm y+4 w500", "Set the facility unit used when a Cerner result does not print one. Values are converted to the canonical unit before calculations; missing tests remain blank.")
    list := g.Add("ListView", "xm y+10 w500 r16 Grid -Multi", ["Lab", "Capture unit", "Display unit"])
    list.ModifyCol(1, 220), list.ModifyCol(2, 125), list.ModifyCol(3, 125)
    for def in PCtx_LabDefs() {
        opts := LabUnitSettings_Options(def.key)
        if opts.Length = 0
            continue
        unit := LabMetric_UnitOverride(def.key)
        if unit = ""
            unit := def.unit
        list.Add(, PCtx_LabLabel(def.key), unit, LabMetric_DisplayUnit(def.key))
    }
    g.Add("Button", "xm y+10 w130", "Edit Selected").OnEvent("Click", (*) => SafeRun(LabUnitSettings_EditSelected, list))
    g.Add("Button", "x+8 yp w100", "Reset Unit").OnEvent("Click", (*) => SafeRun(LabUnitSettings_ResetSelected, list))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    _labUnitsGui := g, _labUnitsList := list
    g.OnEvent("Close", (*) => (_labUnitsGui := 0, _labUnitsList := 0))
    g.Show("w540 h430")
}

LabUnitSettings_EditSelected(list) {
    row := list.GetNext(0, "Focused")
    if !row
        return
    key := ""
    label := list.GetText(row, 1)
    for def in PCtx_LabDefs()
        if PCtx_LabLabel(def.key) = label
            key := def.key
    if key = ""
        return
    opts := LabUnitSettings_Options(key)
    ib := InputBox("Enter one of: " DoseAware_Join(opts, ", "), "Capture Unit", "w360 h150", LabMetric_InputUnit(key, opts[1]))
    if ib.Result != "OK"
        return
    chosen := Trim(ib.Value)
    valid := false
    for opt in opts
        if StrLower(opt) = StrLower(chosen)
            chosen := opt, valid := true
    if !valid {
        MsgBox "That unit is not supported for this lab.", "Lab Units", "Icon!"
        return
    }
    LabMetric_SetUnitOverride(key, chosen)
    list.Modify(row, , , chosen, LabMetric_DisplayUnit(key))
}

LabUnitSettings_ResetSelected(list) {
    row := list.GetNext(0, "Focused")
    if !row
        return
    label := list.GetText(row, 1)
    for def in PCtx_LabDefs()
        if PCtx_LabLabel(def.key) = label {
            LabMetric_SetUnitOverride(def.key, "")
            list.Modify(row, , , def.unit, LabMetric_DisplayUnit(def.key))
            return
    }
}

LabRangeSettings_Keys() {
    return [
        "sodium", "potassium", "chloride", "bicarbonate", "bun", "glucose",
        "calcium", "magnesium", "phosphate", "wbc", "rbc", "hemoglobin",
        "hematocrit", "platelets", "albumin", "lactate"
    ]
}

LabRange_Override(key) {
    global AppSettingsIniPath
    low := "", high := "", unit := ""
    try low := Trim(IniRead(AppSettingsIniPath, "LabReferenceRanges", key "Low", ""))
    try high := Trim(IniRead(AppSettingsIniPath, "LabReferenceRanges", key "High", ""))
    try unit := Trim(IniRead(AppSettingsIniPath, "LabReferenceRanges", key "Unit", ""))
    if !IsNumber(low) || !IsNumber(high) || Number(low) >= Number(high) || unit = ""
        return 0
    canonicalLow := PCtx_CanonicalizeLabValue(key, Number(low), unit)
    canonicalHigh := PCtx_CanonicalizeLabValue(key, Number(high), unit)
    if !IsNumber(canonicalLow) || !IsNumber(canonicalHigh) || Number(canonicalLow) >= Number(canonicalHigh)
        return 0
    return { low: Number(canonicalLow), high: Number(canonicalHigh), canonicalUnit: unit,
        status: "owner_override", version: "local", source: "Facility override" }
}

LabRange_SetOverride(key, low, high, unit) {
    global AppSettingsIniPath, LocalSettingsDir
    if !IsNumber(low) || !IsNumber(high) || Number(low) >= Number(high)
        throw Error("Low must be numeric and less than high.")
    try DirCreate(LocalSettingsDir)
    IniWrite(Number(low), AppSettingsIniPath, "LabReferenceRanges", key "Low")
    IniWrite(Number(high), AppSettingsIniPath, "LabReferenceRanges", key "High")
    IniWrite(unit, AppSettingsIniPath, "LabReferenceRanges", key "Unit")
}

LabRange_ResetOverride(key) {
    global AppSettingsIniPath
    for suffix in ["Low", "High", "Unit"]
        try IniDelete(AppSettingsIniPath, "LabReferenceRanges", key suffix)
}

Truth_LabRange(key) {
    override := LabRange_Override(key)
    if IsObject(override)
        return override

    Truth_LoadRuntimeBundles()
    global _TruthCalcLoaded, _TruthCalcPath
    if !_TruthCalcLoaded
        return 0
    section := "lab_range_" key
    status := ""
    try status := StrLower(Trim(IniRead(_TruthCalcPath, section, "status", "")))
    if status != "active_test" && status != "approved" && status != "released"
        return 0
    low := "", high := "", unit := "", version := ""
    try low := Trim(IniRead(_TruthCalcPath, section, "low", ""))
    try high := Trim(IniRead(_TruthCalcPath, section, "high", ""))
    try unit := Trim(IniRead(_TruthCalcPath, section, "canonicalUnit", ""))
    try version := Trim(IniRead(_TruthCalcPath, section, "version", ""))
    if !IsNumber(low) || !IsNumber(high) || Number(low) >= Number(high) || unit = ""
        return 0
    return { low: Number(low), high: Number(high), canonicalUnit: unit,
        status: status, version: version, source: "Truth bundle" }
}

QuickGlance_RangeState(row) {
    if !IsObject(row) || row.currentNumeric = "" || !IsNumber(row.currentNumeric)
        return "unknown"
    range := Truth_LabRange(row.key)
    if !IsObject(range)
        return "unknown"
    displayLow := LabMetric_Convert(row.key, range.low)
    displayHigh := LabMetric_Convert(row.key, range.high)
    if !IsNumber(displayLow) || !IsNumber(displayHigh) || Number(displayLow) >= Number(displayHigh)
        return "unknown"
    return QuickGlance_ClassifyValue(row.currentNumeric, displayLow, displayHigh)
}

QuickGlance_ClassifyValue(value, low, high) {
    if !IsNumber(value) || !IsNumber(low) || !IsNumber(high) || Number(low) >= Number(high)
        return "unknown"
    value := Number(value)
    if value < Number(low)
        return "low"
    if value > Number(high)
        return "high"
    return "normal"
}

QuickGlance_ColorValue(kind) {
    global AppSettingsIniPath
    fallback := kind = "high" ? "B3261E" : kind = "low" ? "1565C0" : Theme_Accent("heading")
    value := ""
    try value := Trim(IniRead(AppSettingsIniPath, "QuickGlanceColors", kind, ""))
    value := RegExReplace(value, "^#", "")
    return RegExMatch(value, "i)^[0-9a-f]{6}$") ? StrUpper(value) : fallback
}

QuickGlanceColorSettings_Open(*) {
    g := Gui("+ToolWindow", "PhUCKIT Quick Glance Colors")
    g.SetFont("s10", "Segoe UI"), ApplyTheme(g)
    g.Add("Text", "xm ym w460", "Quick Glance result colors").SetFont("s11 bold")
    g.Add("Text", "xm y+4 w460", "Ranges remain clinical truth. These colors control presentation only; HIGH and LOW text remains visible for accessibility.")
    g.Add("Text", "xm y+14 w130", "High result color")
    highEdit := g.Add("Edit", "x+8 yp-3 w110", QuickGlance_ColorValue("high"))
    highPreview := g.Add("Text", "x+12 yp+3 w160", "HIGH result preview")
    highPreview.SetFont("s10 bold c" QuickGlance_ColorValue("high"), "Segoe UI")
    g.Add("Text", "xm y+14 w130", "Low result color")
    lowEdit := g.Add("Edit", "x+8 yp-3 w110", QuickGlance_ColorValue("low"))
    lowPreview := g.Add("Text", "x+12 yp+3 w160", "LOW result preview")
    lowPreview.SetFont("s10 bold c" QuickGlance_ColorValue("low"), "Segoe UI")
    g.Add("Button", "xm y+18 w110 Default", "Save").OnEvent("Click", (*) => SafeRun(QuickGlanceColorSettings_Save, g, highEdit, lowEdit))
    g.Add("Button", "x+8 yp w110", "Reset colors").OnEvent("Click", (*) => SafeRun(QuickGlanceColorSettings_Reset, g))
    g.Add("Button", "x+8 yp w90", "Cancel").OnEvent("Click", (*) => g.Destroy())
    g.Show("w500 h230")
}

QuickGlanceColorSettings_Save(g, highEdit, lowEdit) {
    global AppSettingsIniPath, LocalSettingsDir
    high := StrUpper(RegExReplace(Trim(highEdit.Value), "^#", ""))
    low := StrUpper(RegExReplace(Trim(lowEdit.Value), "^#", ""))
    if !RegExMatch(high, "i)^[0-9a-f]{6}$") || !RegExMatch(low, "i)^[0-9a-f]{6}$") {
        MsgBox "Enter six-digit hexadecimal colors, such as B3261E and 1565C0.", "Quick Glance Colors", "Icon!"
        return
    }
    try DirCreate(LocalSettingsDir)
    IniWrite(high, AppSettingsIniPath, "QuickGlanceColors", "high")
    IniWrite(low, AppSettingsIniPath, "QuickGlanceColors", "low")
    g.Destroy(), QuickGlance_RefreshOpenHub()
}

QuickGlanceColorSettings_Reset(g) {
    global AppSettingsIniPath
    try IniDelete(AppSettingsIniPath, "QuickGlanceColors")
    g.Destroy(), QuickGlance_RefreshOpenHub()
}

LabRangeSettings_Open(*) {
    global _labRangesGui
    if IsObject(_labRangesGui) {
        _labRangesGui.Show()
        return
    }
    g := Gui("+ToolWindow", "PhUCKIT Normal Range Truths")
    g.SetFont("s10", "Segoe UI"), ApplyTheme(g)
    g.Add("Text", "xm ym w680", "Quick Glance normal ranges").SetFont("s11 bold")
    g.Add("Text", "xm y+4 w680", "Facility overrides are preserved in local settings. Without a valid range, no high/low color is assigned. Reference intervals are not treatment targets.")
    list := g.Add("ListView", "xm y+10 w680 r16 Grid -Multi", ["Lab", "Low", "High", "Display unit", "Source"])
    list.ModifyCol(1, 180), list.ModifyCol(2, 90), list.ModifyCol(3, 90), list.ModifyCol(4, 120), list.ModifyCol(5, 160)
    for key in LabRangeSettings_Keys() {
        range := Truth_LabRange(key)
        low := IsObject(range) ? LabMetric_FormatConverted(key, LabMetric_Convert(key, range.low)) : "—"
        high := IsObject(range) ? LabMetric_FormatConverted(key, LabMetric_Convert(key, range.high)) : "—"
        source := IsObject(range) ? range.source : "Not configured"
        list.Add(, PCtx_LabLabel(key), low, high, LabMetric_DisplayUnit(key), source)
    }
    list.OnEvent("DoubleClick", (*) => SafeRun(LabRangeSettings_EditSelected, list))
    g.Add("Button", "xm y+10 w130 Default", "Edit Selected").OnEvent("Click", (*) => SafeRun(LabRangeSettings_EditSelected, list))
    g.Add("Button", "x+8 yp w150", "Reset Facility Override").OnEvent("Click", (*) => SafeRun(LabRangeSettings_ResetSelected, list))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    _labRangesGui := g
    g.OnEvent("Close", (*) => (_labRangesGui := 0))
    g.Show("w720 h485")
}

LabRangeSettings_KeyFromRow(list, row) {
    label := list.GetText(row, 1)
    for key in LabRangeSettings_Keys()
        if PCtx_LabLabel(key) = label
            return key
    return ""
}

LabRangeSettings_EditSelected(list) {
    row := list.GetNext(0, "Focused")
    if !row
        return
    key := LabRangeSettings_KeyFromRow(list, row)
    if key = ""
        return
    unit := LabMetric_DisplayUnit(key)
    currentLow := list.GetText(row, 2) = "—" ? "" : list.GetText(row, 2)
    currentHigh := list.GetText(row, 3) = "—" ? "" : list.GetText(row, 3)
    ib := InputBox("Enter low and high separated by | in " unit ". Example: 3.5|5.1", "Normal Range", "w440 h160", currentLow "|" currentHigh)
    if ib.Result != "OK"
        return
    pieces := StrSplit(Trim(ib.Value), "|")
    if pieces.Length != 2 || !IsNumber(Trim(pieces[1])) || !IsNumber(Trim(pieces[2])) || Number(Trim(pieces[1])) >= Number(Trim(pieces[2])) {
        MsgBox "Enter two numeric values with low less than high.", "Normal Range", "Icon!"
        return
    }
    LabRange_SetOverride(key, Trim(pieces[1]), Trim(pieces[2]), unit)
    list.Modify(row, , , LabMetric_FormatConverted(key, Number(Trim(pieces[1]))), LabMetric_FormatConverted(key, Number(Trim(pieces[2]))), unit, "Facility override")
    QuickGlance_RefreshOpenHub()
}

LabRangeSettings_ResetSelected(list) {
    row := list.GetNext(0, "Focused")
    if !row
        return
    key := LabRangeSettings_KeyFromRow(list, row)
    if key = ""
        return
    LabRange_ResetOverride(key)
    range := Truth_LabRange(key)
    low := IsObject(range) ? LabMetric_FormatConverted(key, LabMetric_Convert(key, range.low)) : "—"
    high := IsObject(range) ? LabMetric_FormatConverted(key, LabMetric_Convert(key, range.high)) : "—"
    source := IsObject(range) ? range.source : "Not configured"
    list.Modify(row, , , low, high, LabMetric_DisplayUnit(key), source)
    QuickGlance_RefreshOpenHub()
}

LabMetric_Convert(key, value) {
    if value = "" || !IsNumber(value)
        return ""
    v := Number(value)
    unit := StrLower(RegExReplace(LabMetric_DisplayUnit(key), "\s+", ""))
    switch key {
        case "bun": return InStr(unit, "mmol/l") ? v * 0.357 : v
        case "creatinine": return InStr(unit, "umol/l") || InStr(unit, "µmol/l") ? v * 88.4 : v
        case "glucose": return InStr(unit, "mmol/l") ? v / 18 : v
        case "calcium": return InStr(unit, "mmol/l") ? v * 0.2495 : v
        case "magnesium": return InStr(unit, "mmol/l") ? v * 0.4114 : v
        case "phosphate": return InStr(unit, "mmol/l") ? v * 0.3229 : v
        case "albumin", "hemoglobin": return InStr(unit, "g/l") && !InStr(unit, "g/dl") ? v * 10 : v
        case "rbc": return InStr(unit, "10^12/l") ? v : v
        case "wbc", "platelets", "anc": return InStr(unit, "10^9/l") ? v : v
        default: return v
    }
}

LabMetric_Precision(key) {
    switch key {
        case "sodium", "chloride", "bicarbonate", "creatinine", "albumin", "hemoglobin", "platelets": return 0
        case "potassium", "bun", "glucose", "calcium", "magnesium", "phosphate", "rbc", "wbc", "hematocrit", "lactate": return 1
        default: return 2
    }
}

LabMetric_FormatNumber(key, value) {
    converted := LabMetric_Convert(key, value)
    if converted = ""
        return "—"
    return LabMetric_FormatConverted(key, converted)
}

LabMetric_FormatConverted(key, converted) {
    if converted = "" || !IsNumber(converted)
        return "—"
    precision := LabMetric_Precision(key)
    return Format("{:." precision "f}", converted)
}

LabMetric_FormatValue(key, value) {
    if value = "" || !IsNumber(value)
        return "—"
    return LabMetric_FormatNumber(key, value) " " LabMetric_DisplayUnit(key)
}

PCtx_ExtractLabs(rawText) {
    out := []
    seen := Map()

    ; Creatinine gets a dedicated table-aware pass because it drives renal dosing and calculators.
    for rec in PCtx_ExtractCreatinine(rawText) {
        sig := rec.key "|" rec.value "|" rec.when "|" rec.raw
        if !seen.Has(sig) {
            seen[sig] := true
            out.Push(rec)
        }
    }

    ; General labeled-line extraction for all other analytes.
    for line in StrSplit(rawText, "`n", "`r") {
        t := Trim(line)
        if t = "" || StrLen(t) > 300
            continue

        collected := PCtx_ExtractCollectionTime(t)

        for def in PCtx_LabDefs() {
            if def.key = "creatinine"
                continue
            if !RegExMatch(t, "i)\b(?:" def.pat ")\b", &nm)
                continue
            rest := SubStr(t, nm.Pos + nm.Len)
            unitPattern := PCtx_LabUnitPattern(def.key)
            if unitPattern = ""
                continue

            ; A lab value must be followed by a compatible unit on the same
            ; OCR row. This rejects dates, reference limits, order doses, and
            ; unrelated numbers that merely happen to follow an analyte word.
            if RegExMatch(rest, "\d+(?:[\.,]\d+)?\s*[-–]\s*\d+(?:[\.,]\d+)?")
                continue
            ; Keep the value immediately next to its label. Searching farther
            ; down a noisy OCR row can attach a neighboring analyte/date to the
            ; wrong label and create data that was never actually displayed.
            if !RegExMatch(rest, "i)^\s*(?:(?:level|lvl|result|value)\s*)?([<>]?\s*\d+(?:[\.,]\d+)?)\s*(?:[HL*!]\s*)?(" unitPattern ")(?=\s|$|[),;])", &vm)
                continue
            valTxt := PCtx_NormalizeNumericToken(vm[1])
            if !IsNumber(valTxt)
                continue
            sourceUnit := vm[2]
            v := PCtx_CanonicalizeLabValue(def.key, Number(valTxt), sourceUnit)
            if v < def.lo || v > def.hi
                continue
            canonicalText := Format("{:.4f}", v)
            canonicalText := RegExReplace(canonicalText, "0+$", "")
            canonicalText := RegExReplace(canonicalText, "\.$", "")
            rec := { key: def.key, value: canonicalText, unit: def.unit, when: collected,
                raw: t, conf: "high", source: "labeled-line; source unit " sourceUnit }
            sig := rec.key "|" rec.value "|" rec.when "|" rec.raw
            if !seen.Has(sig) {
                seen[sig] := true
                out.Push(rec)
            }
            break
        }
    }

    ; Blood pressure requires two atomic values from one labeled observation.
    for line in StrSplit(rawText, "`n", "`r") {
        t := Trim(line)
        if RegExMatch(t, "i)\b(?:Blood Pressure|BP)\b[^0-9]{0,20}(\d{2,3})\s*/\s*(\d{2,3})", &bp) {
            sys := Number(bp[1]), dia := Number(bp[2])
            when := PCtx_ExtractCollectionTime(t)
            if sys >= 50 && sys <= 300 && dia >= 20 && dia <= 200 {
                out.Push({key:"systolicBP", value:String(sys), unit:"mmHg", when:when, raw:t, conf:"high", source:"vital-pair"})
                out.Push({key:"diastolicBP", value:String(dia), unit:"mmHg", when:when, raw:t, conf:"high", source:"vital-pair"})
            }
        }
        ; Convert clearly labeled Fahrenheit temperatures to Celsius for one canonical context value.
        if RegExMatch(t, "i)\b(?:Temperature|Temp)\b[^0-9]{0,20}(\d{2,3}(?:\.\d+)?)\s*°?\s*F\b", &tf) {
            f := Number(tf[1])
            if f >= 80 && f <= 115
                out.Push({key:"temperature", value:String(Round((f-32)*5/9,1)), unit:"C", when:PCtx_ExtractCollectionTime(t), raw:t, conf:"high", source:"fahrenheit-conversion"})
        }
    }
    return out
}

PCtx_ExtractCreatinine(rawText) {
    out := []
    lines := StrSplit(rawText, "`n", "`r")
    aliases := "i)(?:serum\s*)?(?:creatinine|creatlnine|creatinlne|creatininc|creat(?:inine)?|crea|s\s*c\s*[rIln]|srcr)"

    for rawLine in lines {
        line := Trim(rawLine)
        if line = "" || StrLen(line) > 500
            continue
        if !RegExMatch(line, aliases, &labelMatch)
            continue

        ; Serum creatinine must be label + result + compatible trailing unit on
        ; one OCR row. Do not reach into the next row or select a right-most
        ; number: those behaviors can turn dates/reference limits into data.
        if RegExMatch(line, "i)\b(?:creatinine clearance|crcl|urine creatinine|creatinine ratio|albumin.?creatinine)\b")
            continue

        when := PCtx_ExtractCollectionTime(line)
        normalizedLine := PCtx_NormalizeOcrNumbers(line)
        afterLabel := SubStr(normalizedLine, labelMatch.Pos + labelMatch.Len)
        if RegExMatch(afterLabel, "\d+(?:\.\d+)?\s*[-–]\s*\d+(?:\.\d+)?")
            continue

        if !RegExMatch(
            afterLabel,
            "i)^\s*(?:(?:level|lvl|result|value)\s*)?([<>]?\s*\d+(?:\.\d+)?)\s*(?:[HL*!]\s*)?(mg\s*/\s*dL|mgdL|µmol\s*/\s*L|umol\s*/\s*L)(?=\s|$|[),;])",
            &valueMatch
        )
            continue

        valueText := PCtx_NormalizeNumericToken(valueMatch[1])
        if !IsNumber(valueText)
            continue
        value := Number(valueText)
        sourceUnit := valueMatch[2]

        if RegExMatch(sourceUnit, "i)(?:µmol|umol)")
            value := Round(value / 88.4, 3)
        if value < 0.1 || value > 25
            continue

        out.Push({
            key: "creatinine",
            value: String(value),
            unit: "mg/dL",
            when: when,
            raw: line,
            conf: "high",
            source: "label-plus-unit"
        })
    }
    return PCtx_DedupeCreatinineCandidates(out)
}

PCtx_CreatinineCandidates(text, unit := "mg/dL") {
    out := []
    clean := PCtx_NormalizeOcrNumbers(text)
    pos := 1
    index := 0
    while RegExMatch(clean, "([<>]?\s*\d+(?:\.\d+)?)", &m, pos) {
        index += 1
        token := PCtx_NormalizeNumericToken(m[1])
        pos := m.Pos + m.Len
        if !IsNumber(token)
            continue
        value := Number(token)

        ; Adult serum creatinine plausibility in the explicitly displayed unit.
        if RegExMatch(unit, "i)(?:µmol|umol)") {
            if value < 10 || value > 2200
                continue
        } else if value < 0.1 || value > 25 {
            continue
        }

        ; Avoid accidentally selecting dates, times, reference ranges, or eGFR values.
        prefix := SubStr(clean, Max(1, m.Pos - 3), Min(3, m.Pos - 1))
        suffix := SubStr(clean, m.Pos + m.Len, 8)
        if InStr(prefix, "/") || InStr(suffix, "/")
            continue
        if RegExMatch(suffix, "^\s*[:]")
            continue

        conf := (value >= 0.2 && value <= 15) ? "high" : "moderate"
        out.Push({ value: token, index: index, conf: conf, source: "creatinine-row" })
    }
    return out
}

PCtx_SelectCreatinineCandidate(candidates, unit := "mg/dL") {
    if candidates.Length = 0
        return 0

    ; In Cerner-style horizontal result tables, newest values are commonly right-most.
    ; Prefer the right-most plausible value but reject likely reference-range boundaries.
    for i in PCtx_ReverseIndexes(candidates.Length) {
        c := candidates[i]
        v := Number(c.value)
        if RegExMatch(unit, "i)(?:µmol|umol)") {
            if v >= 10 && v <= 2200
                return c
        } else if v >= 0.1 && v <= 25 {
            return c
        }
    }
    return candidates[candidates.Length]
}

PCtx_ReverseIndexes(count) {
    out := []
    Loop count
        out.Push(count - A_Index + 1)
    return out
}

PCtx_DedupeCreatinineCandidates(items) {
    out := []
    seen := Map()
    for item in items {
        key := item.value "|" item.when
        if seen.Has(key)
            continue
        seen[key] := true
        out.Push(item)
    }
    return out
}

PCtx_RemoveLikelyReferenceRange(text) {
    t := String(text)
    ; Remove common trailing reference intervals after a result/unit, such as 0.70-1.30.
    t := RegExReplace(t, "i)\b(?:reference|ref(?:erence)?\s*range|normal)\s*:?\s*[<>]?\d+(?:\.\d+)?\s*[-–]\s*[<>]?\d+(?:\.\d+)?", " ")
    t := RegExReplace(t, "i)(mg\s*/\s*dL|mgdL|µmol\s*/\s*L|umol\s*/\s*L)\s+[<>]?\d+(?:\.\d+)?\s*[-–]\s*[<>]?\d+(?:\.\d+)?\s*$", "$1")
    return t
}

PCtx_NormalizeOcrNumbers(text) {
    t := String(text)
    ; Normalize decimal separators and common OCR substitutions only within number-like tokens.
    t := RegExReplace(t, "(\d)[,;:](\d)", "$1.$2")
    t := RegExReplace(t, "\b([0-9])[oO](?=\d|\b)", "$1" "0")
    t := RegExReplace(t, "\b[lI](?=[\.,]?\d)", "1")
    t := RegExReplace(t, "(\d)[oO]\b", "$1" "0")
    t := RegExReplace(t, "\b([0-9])\s*\.\s*([0-9])\b", "$1.$2")
    return t
}

PCtx_NormalizeNumericToken(token) {
    t := Trim(String(token))
    t := StrReplace(t, "<", "")
    t := StrReplace(t, ">", "")
    t := StrReplace(t, ",", ".")
    t := StrReplace(t, ";", ".")
    t := RegExReplace(t, "\s+", "")
    t := RegExReplace(t, "^[lI](?=\.)", "1")
    t := RegExReplace(t, "^[oO](?=\.)", "0")
    return t
}

PCtx_ExtractCollectionTime(text) {
    if RegExMatch(text, "(\d{1,2}/\d{1,2}/\d{2,4}(?:\s+\d{1,2}:\d{2})?)", &dm)
        return dm[1]
    if RegExMatch(text, "\b(\d{4}-\d{2}-\d{2}(?:[ T]\d{1,2}:\d{2})?)\b", &iso)
        return iso[1]
    if RegExMatch(text, "\b(\d{1,2}:\d{2})\b", &tm)
        return tm[1]
    return ""
}

PCtx_AddLab(ctx, key, value, unit, when, capNum, conf := "", source := "", raw := "") {
    if !ctx.labs.Has(key)
        ctx.labs[key] := []
    entries := ctx.labs[key]
    removeIndex := 0
    for index, e in entries {
        if e.value = value && e.when = when
            return false
        sameObservation := (when != "" && e.when = when)
            || (when = "" && e.when = "")
        if sameObservation && e.value != value {
            if conf = "manual" {
                removeIndex := index
                break
            }
            PCtx_AddLabCandidate(ctx, key, value, unit, when, capNum, conf, source, raw, "conflict")
            return false
        }
    }
    if removeIndex > 0
        entries.RemoveAt(removeIndex)
    entry := {
        value: value,
        unit: unit,
        when: when,
        capture: capNum,
        edited: false,
        conf: conf,
        source: source,
        raw: raw,
        status: "accepted",
        accepted: true
    }
    insertAt := entries.Length + 1
    for index, existing in entries {
        if PCtx_LabObservationIsNewer(entry, existing) {
            insertAt := index
            break
        }
    }
    entries.InsertAt(insertAt, entry)
    return true
}

PCtx_AddLabCandidate(ctx, key, value, unit, when, capNum, conf := "", source := "", raw := "", status := "needs_confirmation") {
    if !ctx.HasOwnProp("labCandidates") || !IsObject(ctx.labCandidates)
        ctx.labCandidates := Map()
    if !ctx.labCandidates.Has(key)
        ctx.labCandidates[key] := []
    for entry in ctx.labCandidates[key] {
        if entry.value = value && entry.when = when && entry.capture = capNum
            return false
    }
    ctx.labCandidates[key].InsertAt(1, {
        value: value,
        unit: unit,
        when: when,
        capture: capNum,
        conf: conf,
        source: source,
        raw: raw,
        status: status,
        accepted: false
    })
    return true
}

PCtx_LabCandidateCount(ctx) {
    if !ctx.HasOwnProp("labCandidates") || !IsObject(ctx.labCandidates)
        return 0
    count := 0
    for key, entries in ctx.labCandidates
        count += entries.Length
    return count
}

PCtx_AcceptLabCandidate(ctx, key, candidateIndex, overrideValue := "") {
    if !ctx.HasOwnProp("labCandidates") || !ctx.labCandidates.Has(key)
        || candidateIndex < 1 || candidateIndex > ctx.labCandidates[key].Length
        return 0
    entry := ctx.labCandidates[key][candidateIndex]
    value := Trim(String(overrideValue)) != "" ? Trim(String(overrideValue)) : entry.value
    value := PCtx_NormalizeNumericToken(value)
    if !PCtx_ValidateLabValue(key, value)
        return 0
    entry.value := value
    PCtx_AddLab(ctx, key, value, entry.unit, entry.when, entry.capture,
        "manual", "confirmed by user", entry.raw)
    ctx.labCandidates[key].RemoveAt(candidateIndex)
    if ctx.labCandidates[key].Length = 0
        ctx.labCandidates.Delete(key)
    return entry
}

PCtx_ValidateLabValue(key, value) {
    if value = "" || !IsNumber(value)
        return false
    numericValue := Number(value)
    for def in PCtx_LabDefs() {
        if def.key = key
            return numericValue >= def.lo && numericValue <= def.hi
    }
    return true
}

PCtx_LabWhenSortKey(when, capture := 0) {
    text := Trim(String(when))
    if RegExMatch(text, "^(\d{1,2})/(\d{1,2})/(\d{2,4})(?:\s+(\d{1,2}):(\d{2}))?", &m) {
        year := Number(m[3])
        if year < 100
            year += 2000
        hour := m[4] != "" ? Number(m[4]) : 0
        minute := m[5] != "" ? Number(m[5]) : 0
        return Format("{:04}{:02}{:02}{:02}{:02}00", year, Number(m[1]), Number(m[2]), hour, minute)
    }
    if RegExMatch(text, "^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{1,2}):(\d{2}))?", &m) {
        hour := m[4] != "" ? Number(m[4]) : 0
        minute := m[5] != "" ? Number(m[5]) : 0
        return Format("{:04}{:02}{:02}{:02}{:02}00", Number(m[1]), Number(m[2]), Number(m[3]), hour, minute)
    }
    ; Unknown collection time stays behind known timestamps; capture order is
    ; only a deterministic display tie-breaker and never presented as lab time.
    return Format("00000000{:06}", Max(0, Number(capture)))
}

PCtx_LabObservationIsNewer(a, b) {
    return StrCompare(
        PCtx_LabWhenSortKey(a.when, a.capture),
        PCtx_LabWhenSortKey(b.when, b.capture),
        false
    ) > 0
}

PCtx_LatestLab(ctx, key) {
    if !ctx.labs.Has(key) || ctx.labs[key].Length = 0
        return 0
    return ctx.labs[key][1]
}

PCtx_LabValue(ctx, key) {
    e := PCtx_LatestLab(ctx, key)
    return IsObject(e) ? e.value : ""
}


PCtx_CreatinineTrend(ctx) {
    if !ctx.labs.Has("creatinine") || ctx.labs["creatinine"].Length = 0
        return { count: 0, current: "", previous: "", delta: "", percent: "", direction: "unknown" }

    arr := ctx.labs["creatinine"]
    current := Number(arr[1].value)
    if arr.Length < 2
        return { count: 1, current: current, previous: "", delta: "", percent: "", direction: "single value" }

    previous := Number(arr[2].value)
    delta := current - previous
    percent := previous != 0 ? (delta / previous) * 100 : ""
    direction := Abs(delta) < 0.05 ? "stable" : (delta > 0 ? "increasing" : "decreasing")
    return {
        count: arr.Length,
        current: current,
        previous: previous,
        delta: delta,
        percent: percent,
        direction: direction
    }
}

PCtx_CreatinineSummary(ctx) {
    t := PCtx_CreatinineTrend(ctx)
    if t.count = 0
        return "Creatinine not captured"
    if t.count = 1
        return "SCr " Round(t.current, 2) " mg/dL (single captured value)"
    pct := t.percent = "" ? "" : ", " (t.percent >= 0 ? "+" : "") Round(t.percent, 1) "%"
    return "SCr " Round(t.current, 2) " mg/dL; prior " Round(t.previous, 2)
        . "; delta " (t.delta >= 0 ? "+" : "") Round(t.delta, 2) pct
        . "; trend " t.direction
}

; -------------------------------------------------------------------------------------------------
; §12 PATIENT IDENTITY RECONCILIATION
; -------------------------------------------------------------------------------------------------
; Returns Map: verdict = "match" | "conflict" | "weak", reason
PCtx_IdentityCheck(ctx, parsed) {
    res := Map("verdict", "weak", "reason", "No strong identifier visible on this capture.")

    newMrn := PCtx_Prop(parsed, "mrn")
    newFin := PCtx_Prop(parsed, "fin")
    curMrn := ctx.ident.Has("mrn") ? ctx.ident["mrn"] : ""
    curFin := ctx.ident.Has("fin") ? ctx.ident["fin"] : ""

    if (curMrn != "" && newMrn != "" && curMrn != newMrn)
        || (curFin != "" && newFin != "" && curFin != newFin) {
        res["verdict"] := "conflict"
        res["reason"] := "Patient or encounter identifier differs. Start a new session unless manually reconciled."
        return res
    }
    if curMrn != "" && newMrn != "" {
        if curMrn = newMrn {
            res["verdict"] := "match"
            res["reason"] := "MRN matches the active session."
            return res
        }
        res["verdict"] := "conflict"
        res["reason"] := "MRN on this capture does not match the active session."
        return res
    }

    if curFin != "" && newFin != "" {
        if curFin = newFin {
            res["verdict"] := "match"
            res["reason"] := "FIN matches the active session."
            return res
        }
        res["verdict"] := "conflict"
        res["reason"] := "FIN on this capture does not match the active session."
        return res
    }

    curAge := ctx.demo.Has("age") ? ctx.demo["age"].value : ""
    newAge := PCtx_Prop(parsed, "age")
    curSex := ctx.demo.Has("sex") ? ctx.demo["sex"].value : ""
    newSex := PCtx_Prop(parsed, "sex")

    if curAge != "" && newAge != "" && curAge != newAge {
        res["verdict"] := "conflict"
        res["reason"] := "Age differs (" curAge " vs " newAge ") and no MRN or FIN was visible."
        return res
    }
    if curSex != "" && newSex != "" && curSex != newSex {
        res["verdict"] := "conflict"
        res["reason"] := "Sex differs and no MRN or FIN was visible."
        return res
    }

    if (curAge != "" && newAge != "" && curAge = newAge)
        || (curSex != "" && newSex != "" && curSex = newSex) {
        res["verdict"] := "weak"
        res["reason"] := "Age/sex are consistent but no MRN or FIN was visible on this capture."
    }
    return res
}

PCtx_Prop(obj, name) {
    if !IsObject(obj)
        return ""
    if !obj.HasOwnProp(name)
        return ""
    return Trim(String(obj.%name%))
}

; -------------------------------------------------------------------------------------------------
; RC16B — ACUTE VS AMBULATORY MEDICATION PROFILE CLASSIFICATION
; -------------------------------------------------------------------------------------------------
PCtx_ProfileFromCapture(rawText, screenType := "") {
    return PCtx_ProfileEvidence(rawText, screenType).profile
}

PCtx_ProfileEvidence(rawText, screenType := "") {
    t := StrLower(String(rawText) " " String(screenType))
    ; Cerner may place the active marker after the tab label, e.g.
    ; “Acute Profile (Active)” or “Ambulatory Profile [Selected]”.
    ; Prefer an explicit marker in either direction before applying the
    ; conservative both-tabs-present rule below.
    if RegExMatch(t, "i)\bacute\s+profile\b\s*(?:\([^)]*\b(?:active|selected|current)\b[^)]*\)|\[[^]]*\b(?:active|selected|current)\b[^]]*\])")
        return {profile:"acute", confidence:"high", reason:"Acute Profile explicitly marked active/selected"}
    if RegExMatch(t, "i)\bambulatory\s+profile\b\s*(?:\([^)]*\b(?:active|selected|current)\b[^)]*\)|\[[^]]*\b(?:active|selected|current)\b[^]]*\])")
        return {profile:"ambulatory", confidence:"high", reason:"Ambulatory Profile explicitly marked active/selected"}
    if RegExMatch(t, "i)(?:active|selected|current)\s*[:=-]?\s*acute\s+profile")
        return {profile:"acute", confidence:"high", reason:"Acute Profile explicitly marked active/selected"}
    if RegExMatch(t, "i)(?:active|selected|current)\s*[:=-]?\s*ambulatory\s+profile")
        return {profile:"ambulatory", confidence:"high", reason:"Ambulatory Profile explicitly marked active/selected"}
    ; When the tab shading is subtle or lost in a photograph, the profile's
    ; column vocabulary is a safer secondary signal than coordinates. Acute
    ; orders expose Start/Stop/Order Type; ambulatory history exposes Last
    ; Fill, days supply (DS), and refill (RR).
    if RegExMatch(t, "i)\b(?:Start|Stop)\b.{0,40}\bOrder\s+Type\b")
        return {profile:"acute", confidence:"moderate", reason:"Acute Start/Stop/Order Type columns detected"}
    if RegExMatch(t, "i)\bLa[sc]t\s+Fill\b.{0,80}\b(?:DS|Days?\s+Supply)\b")
        return {profile:"ambulatory", confidence:"moderate", reason:"Ambulatory Last Fill/Days Supply columns detected"}
    ; Cerner exposes both profile tabs in the same capture. Seeing both labels
    ; is not evidence that either one is active, so keep the medication rows
    ; unassigned until the user confirms the profile rather than guessing.
    hasAcuteTab := RegExMatch(t, "i)\bacute\s+profile\b")
    hasAmbulatoryTab := RegExMatch(t, "i)\bambulatory\s+profile\b")
    if hasAcuteTab && hasAmbulatoryTab
        return {profile:"unassigned", confidence:"low", reason:"Both profile tabs visible without a reliable active-tab marker"}
    if hasAmbulatoryTab
        return {profile:"ambulatory", confidence:"moderate", reason:"Only the Ambulatory Profile tab was captured"}
    if hasAcuteTab
        return {profile:"acute", confidence:"moderate", reason:"Only the Acute Profile tab was captured"}
    if RegExMatch(t, "i)\b(home medications?|home med list|prior to admission|pta medications?|ambulatory medications?|outpatient medications?|medication history|med rec history|patient reported medications?)\b")
        return {profile:"ambulatory", confidence:"moderate", reason:"Home/ambulatory medication vocabulary detected"}
    if RegExMatch(t, "i)\b(mar|medication administration record|inpatient orders?|active orders?|current facility medications?|pending verify|pharmacy verification)\b")
        return {profile:"acute", confidence:"moderate", reason:"Inpatient/MAR medication vocabulary detected"}
    if InStr(StrLower(screenType), "mar") || InStr(StrLower(screenType), "pharmacy verification")
        return {profile:"acute", confidence:"moderate", reason:"Screen classified as MAR/pharmacy verification"}
    return {profile:"unassigned", confidence:"low", reason:"No reliable Acute/Ambulatory profile evidence"}
}

PCtx_ProfileLabel(profile) {
    switch profile {
        case "ambulatory": return "Home / ambulatory"
        case "acute": return "Acute / inpatient"
        default: return "Unassigned"
    }
}

PCtx_ProfileConfidence(rawText, screenType := "") {
    return PCtx_ProfileEvidence(rawText, screenType).confidence
}

PCtx_ProfileMeds(ctx, profile) {
    out := []
    for m in ctx.medRecs {
        p := m.HasOwnProp("profile") ? m.profile : "unassigned"
        ; Med Rec must see stopped, held, pending, and administered rows so
        ; it can classify start/stop and status discrepancies.  Downstream
        ; calculators use PCtx_ActiveMeds/PCtx_ConfirmedActiveMeds instead.
        if p = profile
            out.Push(m)
    }
    return out
}

PCtx_ProfileSummary(ctx) {
    counts := Map("acute", 0, "ambulatory", 0, "unassigned", 0)
    confidence := Map("high", 0, "moderate", 0, "low", 0)
    for capture in ctx.captures {
        p := capture.HasOwnProp("profile") ? capture.profile : "unassigned"
        if !counts.Has(p)
            p := "unassigned"
        counts[p] += 1
        c := capture.HasOwnProp("profileConfidence")
            ? capture.profileConfidence
            : PCtx_ProfileConfidence(capture.HasOwnProp("rawText") ? capture.rawText : "", capture.HasOwnProp("type") ? capture.type : "")
        confidence[c] += 1
    }
    parts := []
    if counts["ambulatory"] > 0
        parts.Push(counts["ambulatory"] " ambulatory capture" (counts["ambulatory"] = 1 ? "" : "s"))
    if counts["acute"] > 0
        parts.Push(counts["acute"] " acute capture" (counts["acute"] = 1 ? "" : "s"))
    if counts["unassigned"] > 0
        parts.Push(counts["unassigned"] " unassigned capture" (counts["unassigned"] = 1 ? "" : "s"))
    summary := parts.Length > 0 ? DoseAware_Join(parts, " · ") : "No profile captures yet"
    if confidence["low"] > 0
        summary .= " · " confidence["low"] " low-confidence source" (confidence["low"] = 1 ? "" : "s")
    return summary
}



MedRec_IngredientKey(med) {
    parts := []
    if med.HasOwnProp("ingredients") {
        for ing in med.ingredients
            parts.Push(StrLower(Trim(ing)))
    }
    if parts.Length = 0
        return StrLower(Trim(med.HasOwnProp("raw") ? med.raw : ""))
    ; preserve combination membership while making ingredient order independent.
    ordered := []
    while parts.Length {
        best := 1
        Loop parts.Length {
            if StrCompare(StrLower(parts[A_Index]), StrLower(parts[best])) < 0
                best := A_Index
        }
        ordered.Push(parts.RemoveAt(best))
    }
    return DoseAware_Join(ordered, "+")
}

MedRec_TherapeuticGroup(med) {
    rec := CRD5_FindMedication(med)
    if !IsObject(rec)
        return ""
    try return StrLower(Trim(rec["therapeuticGroup"]))
    catch
        return ""
}

MedRec_Value(med, field) {
    if !IsObject(med) || !med.HasOwnProp(field)
        return ""
    return Trim(String(med.%field%))
}

MedRec_DoseKey(med) {
    if !IsObject(med)
        return ""
    num := med.HasOwnProp("doseNum") ? med.doseNum : ""
    unit := med.HasOwnProp("doseUnit") ? med.doseUnit : ""
    if num = "" && RegExMatch(MedRec_Value(med, "dose"), "i)^\s*(\d+(?:\.\d+)?)\s*(mcg|mg|g|mL|units?|meq|mmol)\b", &m)
        num := m[1], unit := m[2]
    if num = "" || !IsNumber(num)
        return StrLower(RegExReplace(MedRec_Value(med, "dose"), "\s+", ""))
    v := Number(num)
    u := StrLower(unit)
    if u = "g" || u = "gram" || u = "grams"
        v *= 1000, u := "mg"
    else if u = "mcg"
        v /= 1000, u := "mg"
    return Format("{:.6f}", v) " " u
}

MedRec_RouteKey(med) {
    route := RegExReplace(StrLower(MedRec_Value(med, "route")), "[^a-z]", "")
    switch route {
        case "bymouth", "oral", "po": return "po"
        case "intravenous", "iv", "ivpush", "ivp", "ivpiggyback", "ivpb": return "iv"
        case "subcutaneous", "subq", "sq": return "sc"
        case "intramuscular", "im": return "im"
        case "intranasal", "nasal": return "intranasal"
        default: return route
    }
}





MedRec_AddFlag(flags, seen, text) {
    text := Trim(String(text))
    if text = ""
        return
    key := StrLower(text)
    if !seen.Has(key) {
        seen[key] := true
        flags.Push(text)
    }
}

; Build concise, evidence-backed clinical prompts for a comparison row.  This
; deliberately does not infer that a medication needs a change: it identifies
; the review trigger and preserves the source for the pharmacist.
MedRec_ClinicalFlags(ctx, meds, parsed := 0) {
    flags := []
    seen := Map()
    if !IsObject(ctx)
        return ""
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }

    seenMeds := Map()
    for med in meds {
        if !IsObject(med)
            continue
        key := MedRec_IngredientKey(med)
        if key = ""
            key := StrLower(MedRec_Value(med, "raw"))
        if seenMeds.Has(key)
            continue
        seenMeds[key] := true
        if !RxN_IsActiveStatus(MedRec_Value(med, "status"))
            continue

        renal := PatientRenal_FlagForMedication(MedRec_Value(med, "raw"), parsed)
        if renal != ""
            MedRec_AddFlag(flags, seen, "Renal review: " renal)

        regimen := DoseAware_ParseRegimen(MedRec_Value(med, "raw"))
        if IsObject(regimen) && regimen.doseBasis = "weight-based" {
            if parsed.HasOwnProp("bmi") && parsed.bmi != "" && parsed.HasOwnProp("weightKg") && parsed.weightKg != ""
                MedRec_AddFlag(flags, seen, "BMI/body-size review: weight-based order; verify dosing weight")
            else
                MedRec_AddFlag(flags, seen, "BMI/body-size review: weight-based order but height/weight is not captured")
        }

        allergyFindings := Allergy_ScanOrders(ctx.allergyRecs, [med])
        for finding in allergyFindings {
            label := finding.sev = "RED" ? "Allergy conflict" : "Allergy class caution"
            MedRec_AddFlag(flags, seen, label ": " finding.detail)
        }
    }
    return DoseAware_Join(flags, "; ")
}

; A missing row is only eligible for the word "omission" when the source
; capture looks like a complete medication/order profile.  Otherwise the UI
; deliberately says "not seen" and asks for a complete capture.




MedRec_Display(med) {
    if !IsObject(med)
        return "—"
    rec := CRD5_FindMedication(med)
    name := IsObject(rec) ? rec["generic"] : MedRec_Value(med, "raw")
    dose := MedRec_Value(med, "dose")
    route := MedRec_Value(med, "route")
    sig := Sig_CompactFromMedication(med)
    out := name
    if dose != ""
        out .= " | " dose
    if route != ""
        out .= " | " route
    if sig != ""
        out .= " | " sig
    out .= " | " MedRec_StatusLabel(med)
    if med.HasOwnProp("profileConfidence") && med.profileConfidence != "high"
        out .= " | PROFILE " StrUpper(med.profileConfidence)
    if MedRec_Value(med, "lastFill") != ""
        out .= " | Fill " MedRec_Value(med, "lastFill")
    if MedRec_Value(med, "daysSupply") != ""
        out .= " | DS " MedRec_Value(med, "daysSupply")
    if MedRec_Value(med, "refills") != ""
        out .= " | RR " MedRec_Value(med, "refills")
    if RxN_IsUncertain(med)
        out .= " | VERIFY OCR"
    return out
}

MedRec_EvidenceText(med) {
    if !IsObject(med)
        return "No medication is present on this side of the selected comparison."
    out := "Captured medication evidence`r`n`r`n"
    out .= "Medication: " MedRec_Display(med) "`r`n"
    out .= "Capture: " (med.HasOwnProp("capture") ? "#" med.capture : "unknown") "`r`n"
    out .= "Screen: " (MedRec_Value(med, "screen") != "" ? MedRec_Value(med, "screen") : "unknown") "`r`n"
    out .= "Profile: " PCtx_ProfileLabel(MedRec_Value(med, "profile")) "`r`n"
    out .= "Profile confidence: " (MedRec_Value(med, "profileConfidence") != "" ? MedRec_Value(med, "profileConfidence") : "unknown") "`r`n"
    if MedRec_Value(med, "profileReason") != ""
        out .= "Profile evidence: " MedRec_Value(med, "profileReason") "`r`n"
    out .= "Medication capture state: " (RxN_IsUncertain(med) ? "needs source review" : "captured") "`r`n"
    if MedRec_Value(med, "captureReason") != ""
        out .= "Capture evidence: " MedRec_Value(med, "captureReason") "`r`n"
    for pair in [
        ["Start", "startAt"], ["Stop", "stopAt"], ["Order type", "orderType"],
        ["Last fill", "lastFill"], ["Days supply", "daysSupply"], ["Refills", "refills"]
    ] {
        value := MedRec_Value(med, pair[2])
        if value != ""
            out .= pair[1] ": " value "`r`n"
    }
    out .= "`r`nSource order text:`r`n" MedRec_Value(med, "raw")
    return out
}

; -------------------------------------------------------------------------------------------------
; §14 MERGE
; -------------------------------------------------------------------------------------------------
PCtx_MergeCapture(ctx, parsed, rawText, screenType) {
    PCtx_Touch(ctx)
    capNum := ctx.captures.Length + 1
    profileEvidence := (IsObject(parsed) && parsed.HasOwnProp("profileEvidence") && IsObject(parsed.profileEvidence))
        ? parsed.profileEvidence
        : PCtx_ProfileEvidence(rawText, screenType)
    captureProfile := profileEvidence.profile
    added := Map("labs", 0, "meds", 0, "allergies", 0, "dx", 0, "mar", 0, "demo", 0, "weights", 0, "warnings", 0)

    if IsObject(parsed) && parsed.HasOwnProp("captureEvidence")
        && IsObject(parsed.captureEvidence) {
        for field, rec in parsed.captureEvidence {
            if !IsObject(rec) || rec.value = ""
                continue
            if !ctx.captureCandidates.Has(field) {
                ctx.captureCandidates[field] := rec
                continue
            }
            currentCandidate := ctx.captureCandidates[field]
            ; Preserve an already accepted/manual value when a later partial
            ; screen can only produce an unconfirmed candidate.
            if currentCandidate.accepted && !rec.accepted
                continue
            ctx.captureCandidates[field] := rec
        }
    }

    for name in ["mrn", "fin"] {
        v := PCtx_Prop(parsed, name)
        if v != "" && (!ctx.ident.Has(name) || ctx.ident[name] = "")
            ctx.ident[name] := v
    }

    ; stable demographics - conflicts become review items, they do not silently overwrite
    for name in ["age", "sex", "heightCm", "location"] {
        v := PCtx_Prop(parsed, name)
        if v = ""
            continue
        if !ctx.demo.Has(name) {
            ctx.demo[name] := PCtx_NewField(v, PCtx_UnitFor(name), "", "", screenType, capNum)
            added["demo"] := added["demo"] + 1
            continue
        }
        cur := ctx.demo[name]
        if cur.value = v
            continue
        if name = "location" {
            cur.value := v
            cur.capture := capNum
            continue
        }
        if cur.edited
            continue
        ctx.conflicts.Push({
            field: name,
            a: cur.value,
            b: v,
            capA: cur.capture,
            capB: capNum,
            resolved: false
        })
    }

    ; weights are preserved with labels rather than replaced (§14 Weight)
    wt := PCtx_Prop(parsed, "weightKg")
    if wt != "" {
        dupe := false
        for w in ctx.weights {
            if w.kg = wt
                dupe := true
        }
        if !dupe {
            ctx.weights.Push({ kg: wt, label: (ctx.weights.Length = 0 ? "captured weight" : "additional captured weight"),
                when: "", capture: capNum, selected: (ctx.weights.Length = 0) })
            added["weights"] := added["weights"] + 1
        }
    }

    ; labs - time series, never overwritten by an older capture
    scr := PCtx_Prop(parsed, "scr")
    if scr != "" {
        if PCtx_AddLab(ctx, "creatinine", scr, "mg/dL", "", capNum)
            added["labs"] := added["labs"] + 1
    }
    ; Promote strict, explicitly labeled sidebar summary labs. These records
    ; are separate from broad OCR candidates and never cross-feed calculators.
    if IsObject(parsed) && parsed.HasOwnProp("captureEvidence")
        && IsObject(parsed.captureEvidence) {
        for evidenceKey, evidence in parsed.captureEvidence {
            if !InStr(evidenceKey, "lab:") || !IsObject(evidence)
                continue
            if !evidence.Has("key") || !evidence.Has("value")
                continue
            key := evidence["key"]
            value := evidence["value"]
            if key = "creatinine" || !PCtx_ValidateLabValue(key, value)
                continue
            if PCtx_AddLab(ctx, key, value,
                evidence.Has("unit") ? evidence["unit"] : "",
                "", capNum, "high",
                evidence.Has("source") ? evidence["source"] : "labeled sidebar",
                evidence.Has("raw") ? evidence["raw"] : "") {
                added["labs"] := added["labs"] + 1
            }
        }
    }
    if IsObject(parsed) && parsed.HasOwnProp("systolicBP")
        && parsed.systolicBP != ""
        && parsed.HasOwnProp("diastolicBP")
        && parsed.diastolicBP != "" {
        if PCtx_AddLab(ctx, "systolicBP", parsed.systolicBP, "mmHg", "", capNum, "high", "anchored vital", parsed.vitalEvidence.Length > 0 ? parsed.vitalEvidence[1].raw : "")
            added["labs"] := added["labs"] + 1
        if PCtx_AddLab(ctx, "diastolicBP", parsed.diastolicBP, "mmHg", "", capNum, "high", "anchored vital", parsed.vitalEvidence.Length > 0 ? parsed.vitalEvidence[1].raw : "")
            added["labs"] := added["labs"] + 1
    }
    for lab in PCtx_ExtractLabs(rawText) {
        ; A single broad OCR line must never re-introduce an unconfirmed renal
        ; value after the field-level safety gate excluded it. Creatinine enters
        ; through an accepted sidebar field or the focused, consensus-verified
        ; result-grid path below.
        if lab.key = "creatinine"
            continue
        ; Broad text is useful evidence, but one pass is not accepted patient
        ; data. Keep it for confirmation instead of letting it trigger a rule.
        if PCtx_AddLabCandidate(ctx, lab.key, lab.value, lab.unit, lab.when, capNum,
            lab.HasOwnProp("conf") ? lab.conf : "",
            lab.HasOwnProp("source") ? lab.source : "broad screen text",
            lab.HasOwnProp("raw") ? lab.raw : "")
            added["warnings"] := added["warnings"] + 1
    }
    if IsObject(parsed) && parsed.HasOwnProp("gridLabs") && IsObject(parsed.gridLabs) {
        ; Grid-derived rows arrive oldest-to-newest. PCtx_AddLab inserts at the
        ; front, leaving the top/newest Cerner result as the current value.
        for lab in parsed.gridLabs {
            if lab.HasOwnProp("accepted") && !lab.accepted
                continue
            if PCtx_AddLab(ctx, lab.key, lab.value, lab.unit, lab.when, capNum,
                lab.HasOwnProp("conf") ? lab.conf : "moderate",
                lab.HasOwnProp("source") ? lab.source : "Cerner result grid",
                lab.HasOwnProp("raw") ? lab.raw : "") {
                added["labs"] := added["labs"] + 1
            }
        }
    }

    if IsObject(parsed) && parsed.HasOwnProp("qualitativeFindings") && IsObject(parsed.qualitativeFindings) {
        for finding in parsed.qualitativeFindings {
            duplicate := false
            for existing in ctx.qualitativeFindings {
                if existing.kind = finding.kind && existing.label = finding.label && existing.value = finding.value {
                    duplicate := true
                    break
                }
            }
            if !duplicate {
                finding.capture := capNum
                ctx.qualitativeFindings.Push(finding)
            }
        }
    }

    ; allergies - union at ingredient level, originals preserved
    newAllergyRaw := []
    if IsObject(parsed) && parsed.HasOwnProp("allergies") {
        for a in parsed.allergies {
            known := false
            for existing in ctx.allergyRaw {
                if StrLower(Trim(existing)) = StrLower(Trim(a))
                    known := true
            }
            if !known {
                ctx.allergyRaw.Push(a)
                newAllergyRaw.Push(a)
                added["allergies"] := added["allergies"] + 1
            }
        }
    }
    if newAllergyRaw.Length > 0
        ctx.allergyRecs := Allergy_Parse(ctx.allergyRaw)

    ; medications - dedupe on normalized signature, meaningful changes preserved
    if IsObject(parsed) && parsed.HasOwnProp("medications") {
        for m in parsed.medications {
            rec := RxN_Normalize(m)
            rec.capture := capNum
            rec.screen := screenType
            rec.profile := captureProfile
            rec.profileConfidence := profileEvidence.confidence
            rec.profileReason := profileEvidence.reason
            sig := RxN_Signature(rec)
            dupe := false
            for existing in ctx.medRecs {
                existingProfile := existing.HasOwnProp("profile") ? existing.profile : "unassigned"
                if RxN_Signature(existing) = sig && existingProfile = captureProfile
                    dupe := true
            }
            if dupe
                continue
            ctx.medRecs.Push(rec)
            added["meds"] := added["meds"] + 1
            if InStr(screenType, "MAR") {
                ctx.mar.Push({ text: rec.raw, capture: capNum, when: "" })
                added["mar"] := added["mar"] + 1
            }
        }
    }

    if IsObject(parsed) && parsed.HasOwnProp("captureWarnings") && IsObject(parsed.captureWarnings) {
        for warning in parsed.captureWarnings {
            ctx.notes.Push({ capture: capNum, text: String(warning) })
            added["warnings"] := added["warnings"] + 1
        }
    }

    ctx.captures.Push({
        n: capNum,
        type: screenType,
        profile: captureProfile,
        profileConfidence: profileEvidence.confidence,
        profileReason: profileEvidence.reason,
        at: FormatTime(, "HH:mm"),
        added: added,
        parsed: parsed,
        rawText: rawText,
        excluded: false
    })
    ctx.lastCaptureAt := FormatTime(, "MM/dd/yyyy HH:mm")
    return added
}

PCtx_UnitFor(name) {
    switch name {
        case "heightCm": return "cm"
        case "age": return "yr"
        default: return ""
    }
}

PCtx_AddedSummary(added) {
    parts := []
    if added["labs"] > 0
        parts.Push(added["labs"] " lab result" (added["labs"] = 1 ? "" : "s"))
    if added["meds"] > 0
        parts.Push(added["meds"] " medication order" (added["meds"] = 1 ? "" : "s"))
    if added["allergies"] > 0
        parts.Push(added["allergies"] " allerg" (added["allergies"] = 1 ? "y" : "ies"))
    if added["demo"] > 0
        parts.Push(added["demo"] " demographic field" (added["demo"] = 1 ? "" : "s"))
    if added["weights"] > 0
        parts.Push(added["weights"] " weight")
    if added["mar"] > 0
        parts.Push(added["mar"] " administration record" (added["mar"] = 1 ? "" : "s"))
    if added.Has("warnings") && added["warnings"] > 0
        parts.Push(added["warnings"] " capture review item" (added["warnings"] = 1 ? "" : "s"))
    if parts.Length = 0
        return "No new information"
    out := ""
    for p in parts
        out .= (out = "" ? "" : ", ") p
    return out
}

; -------------------------------------------------------------------------------------------------
; SELECTED VALUES + LEGACY BRIDGE
; -------------------------------------------------------------------------------------------------
PCtx_SelectedWeight(ctx) {
    for w in ctx.weights {
        if w.selected
            return w.kg
    }
    return ctx.weights.Length > 0 ? ctx.weights[1].kg : ""
}

PCtx_Demo(ctx, name) {
    return ctx.demo.Has(name) ? ctx.demo[name].value : ""
}

; Legacy `parsed` shape consumed by every pre-existing calculator and prefill path.
PCtx_ToParsed(ctx) {
    p := PatientV2_NewParsedResult()
    p.age := PCtx_Demo(ctx, "age")
    p.sex := PCtx_Demo(ctx, "sex")
    p.location := PCtx_Demo(ctx, "location")
    p.heightCm := PCtx_Demo(ctx, "heightCm")
    p.weightKg := PCtx_SelectedWeight(ctx)
    p.scr := PCtx_LabValue(ctx, "creatinine")
    p.egfr := PCtx_LabValue(ctx, "egfr")
    p.scrTrend := PCtx_CreatinineTrend(ctx)
    p.scrSummary := PCtx_CreatinineSummary(ctx)
    p.mrn := ctx.ident.Has("mrn") ? ctx.ident["mrn"] : ""
    p.fin := ctx.ident.Has("fin") ? ctx.ident["fin"] : ""
    if ctx.HasOwnProp("captureCandidates") && IsObject(ctx.captureCandidates)
        p.captureEvidence := ctx.captureCandidates.Clone()

    allergies := []
    for a in ctx.allergyRaw
        allergies.Push(a)
    p.allergies := allergies

    ; Only source-confirmed medication rows may feed calculators, renal rules,
    ; interaction checks, or other automated clinical findings. OCR-uncertain
    ; rows stay in the patient context and Med Rec UI for pharmacist review.
    meds := []
    for m in PCtx_ConfirmedActiveMeds(ctx)
        meds.Push(m.raw)
    p.medications := meds

    pendingMeds := []
    for m in PCtx_UncertainActiveMeds(ctx)
        pendingMeds.Push(m.raw)
    p.medicationsPendingReview := pendingMeds

    ; vNext7: retain renal-replacement / instability context from the capture corpus.
    ; This is a screening cue only and never substitutes for confirming modality or settings.
    p.renalContext := RenalContext_FromPatientSession(ctx)

    normalized := PatientV2_NormalizeParsedShape(p)
    normalized.ocrNeedsReview := PCtx_LowConfidenceCount(ctx) > 0
        || PCtx_UnresolvedConflicts(ctx) > 0
    return normalized
}


RenalContext_FromPatientSession(ctx) {
    corpus := ""
    for capture in ctx.captures {
        if capture.HasOwnProp("rawText")
            corpus .= "`n" capture.rawText
    }
    for dx in ctx.dx
        corpus .= "`n" dx
    for mar in ctx.mar
        corpus .= "`n" (IsObject(mar) && mar.HasOwnProp("text") ? mar.text : String(mar))

    t := StrLower(corpus)
    rec := {mode: "none", unstable: false, evidence: "", confidence: "none", timing: "unknown", timingEvidence: ""}

    if RegExMatch(t, "i)\b(crrt|cvvhd|cvvhdf|cvvh)\b", &m) {
        rec.mode := "CRRT"
        rec.evidence := m[1]
        rec.confidence := "high"
    } else if RegExMatch(t, "i)\b(peritoneal dialysis|\bpd\b|capd|apd)\b", &m) {
        rec.mode := "PD"
        rec.evidence := m[1]
        rec.confidence := "high"
    } else if RegExMatch(t, "i)\b(intermittent hemodialysis|hemodialysis|\biHD\b|\bHD\b)\b", &m) {
        rec.mode := "iHD"
        rec.evidence := m[1]
        rec.confidence := "high"
    } else if RegExMatch(t, "i)\b(dialysis|renal replacement therapy|\bRRT\b)\b", &m) {
        rec.mode := "RRT-UNSPECIFIED"
        rec.evidence := m[1]
        rec.confidence := "moderate"
    }

    if RegExMatch(t, "i)\b(post[- ]?(?:hemo)?dialysis|after (?:hemo)?dialysis|after HD|following (?:hemo)?dialysis|on dialysis days after treatment)\b", &tm) {
        rec.timing := "post-HD"
        rec.timingEvidence := tm[1]
        rec.confidence := rec.confidence = "none" ? "moderate" : rec.confidence
    } else if RegExMatch(t, "i)\b(pre[- ]?(?:hemo)?dialysis|before (?:hemo)?dialysis|before HD)\b", &tm) {
        rec.timing := "pre-HD"
        rec.timingEvidence := tm[1]
        rec.confidence := rec.confidence = "none" ? "moderate" : rec.confidence
    }

    if RegExMatch(t, "i)\b(acute kidney injury|\bAKI\b|unstable (?:renal function|creatinine|SCr)|rapid(?:ly)? (?:rising|changing) creatinine|oligur(?:ia|ic)|anur(?:ia|ic))\b", &m) {
        rec.unstable := true
        if rec.evidence = ""
            rec.evidence := m[1]
        rec.confidence := rec.confidence = "none" ? "moderate" : rec.confidence
    }

    scrTrend := PCtx_CreatinineTrend(ctx)
    if scrTrend.count >= 2 && scrTrend.delta != "" && Number(scrTrend.delta) >= 0.3 {
        rec.unstable := true
        rec.evidence := rec.evidence != "" ? rec.evidence : "SCr increased by " Round(scrTrend.delta, 2) " mg/dL across captured values"
        rec.confidence := "high"
    }
    return rec
}

RenalContext_Label(parsed) {
    if !parsed.HasOwnProp("renalContext") || !IsObject(parsed.renalContext)
        return "Renal context not detected from captured text"
    r := parsed.renalContext
    parts := []
    if r.mode != "none"
        parts.Push("Mode " r.mode)
    if r.unstable
        parts.Push("AKI / unstable renal function signal")
    if r.HasOwnProp("timing") && r.timing != "unknown"
        parts.Push("Timing " r.timing)
    if parts.Length = 0
        return "No dialysis/RRT or instability signal detected from captured text"
    return DoseAware_Join(parts, " | ") " (" r.confidence "-confidence text match)"
}

RenalContext_IsRRT(parsed) {
    return parsed.HasOwnProp("renalContext") && IsObject(parsed.renalContext)
        && parsed.renalContext.mode != "none"
}

RenalContext_IsUnstable(parsed) {
    return parsed.HasOwnProp("renalContext") && IsObject(parsed.renalContext)
        && parsed.renalContext.unstable
}

RenalContext_HasPostHDTiming(parsed) {
    return parsed.HasOwnProp("renalContext") && IsObject(parsed.renalContext)
        && parsed.renalContext.HasOwnProp("timing") && parsed.renalContext.timing = "post-HD"
}

PCtx_ActiveMeds(ctx) {
    out := []
    for m in ctx.medRecs {
        if RxN_IsActiveStatus(m.status)
            out.Push(m)
    }
    return out
}

PCtx_ConfirmedActiveMeds(ctx) {
    out := []
    for m in PCtx_ActiveMeds(ctx) {
        if !RxN_IsUncertain(m)
            out.Push(m)
    }
    return out
}

PCtx_UncertainActiveMeds(ctx) {
    out := []
    for m in PCtx_ActiveMeds(ctx) {
        if RxN_IsUncertain(m)
            out.Push(m)
    }
    return out
}

PCtx_FieldCount(ctx) {
    n := ctx.demo.Count + ctx.ident.Count + ctx.weights.Length
        + ctx.allergyRecs.Length + ctx.medRecs.Length + ctx.dx.Length + ctx.mar.Length
    for k, arr in ctx.labs
        n += arr.Length
    return n
}

PCtx_LowConfidenceCount(ctx) {
    n := (ctx.HasOwnProp("notes") && IsObject(ctx.notes) ? ctx.notes.Length : 0)
        + PCtx_LabCandidateCount(ctx)
    for m in ctx.medRecs {
        if m.lowConfidence
            n += 1
    }
    for key, entries in ctx.labs {
        for entry in entries {
            if entry.HasOwnProp("conf") && (entry.conf = "low" || entry.conf = "moderate")
                n += 1
        }
    }
    return n
}

PCtx_UnresolvedConflicts(ctx) {
    n := 0
    for c in ctx.conflicts {
        if !c.resolved
            n += 1
    }
    return n
}

PCtx_MaskedId(ctx) {
    for k in ["mrn", "fin"] {
        if ctx.ident.Has(k) && ctx.ident[k] != "" {
            v := ctx.ident[k]
            return StrUpper(k) " ending " (StrLen(v) > 4 ? SubStr(v, -3) : v)
        }
    }
    loc := PCtx_Demo(ctx, "location")
    return loc != "" ? "Location " loc : "Identifier not captured"
}

; -------------------------------------------------------------------------------------------------
; SESSION LIFECYCLE (§18)
; -------------------------------------------------------------------------------------------------
PCtx_ClearSession(confirm := true) {
    global PCtxSession, _PreFillDemographics
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        if confirm
            MsgBox("No active patient session.", "Patient Session", "Iconi")
        return
    }
    if confirm {
        msg := "Clear the current patient session?`n`n"
            . ctx.captures.Length " capture" (ctx.captures.Length = 1 ? "" : "s")
            . " and " PCtx_FieldCount(ctx) " extracted fields will be removed."
        if MsgBox(msg, "Clear Patient Session", "OKCancel Icon!") != "OK"
            return
    }
    PCtxSession := 0
    _PreFillDemographics := Map()
}

PCtx_FinalizeSession() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("No active patient session.", "Patient Session", "Iconi")
        return
    }
    ctx.finalized := true
    PCtx_Touch(ctx)
    MsgBox("Session finalized. The combined data stays available to calculators; "
        . "capture again to reopen it.", "Patient Session", "Iconi")
}

PCtx_UndoLastCapture() {
    global PCtxSession
    ctx := PCtx_Active()
    if !IsObject(ctx) || ctx.captures.Length = 0 {
        MsgBox("Nothing to undo.", "Patient Session", "Iconi")
        return 0
    }
    if ctx.captures.Length = 1 {
        PCtx_ClearSession(false)
        return 0
    }
    keep := []
    for i, c in ctx.captures {
        if i < ctx.captures.Length
            keep.Push(c)
    }
    fresh := PCtx_New()
    fresh.sessionId := ctx.sessionId
    fresh.startedAt := ctx.startedAt
    PCtxSession := fresh
    for c in keep
        PCtx_MergeCapture(fresh, c.parsed, c.rawText, c.type)
    return fresh
}

; -------------------------------------------------------------------------------------------------
; OPEN-CALCULATOR TRACKING (§19 "Calculator currently open")
; -------------------------------------------------------------------------------------------------
PCtx_TrackedCalcTitles() {
    static titles := ["RSI Dosing Support", "Vancomycin Dosing", "Aminoglycoside Dosing",
        "Empiric Antibiotic Selection", "BMI / Body Size", "Renal Dose Screening",
        "Lab Corrections", "Medication Risk Stack"]
    return titles
}

PCtx_CalcWindowOpen() {
    prev := A_TitleMatchMode
    SetTitleMatchMode 2
    found := ""
    for t in PCtx_TrackedCalcTitles() {
        if WinExist(t) {
            found := t
            break
        }
    }
    SetTitleMatchMode prev
    return found
}


; =================================================================================================
; SIX-COLUMN MEDICATION SAFETY STRIP   (blueprint §2, §4 risk stack, §20)
; -------------------------------------------------------------------------------------------------
; Column order is fixed: RENAL - QT - BEERS - MG - G6P - CRUSH.
; There is deliberately no green "safe" status. A capture cannot prove absence, so the possible
; statuses are: Alert, Review, No match found, Unknown, Not applicable.
; =================================================================================================

Safety_Columns() {
    static cols := ["RENAL", "QT", "BEERS", "MG", "G6P", "CRUSH"]
    return cols
}

Safety_MedMatchesIngredient(medRec, ruleIng) {
    ing := StrLower(Trim(ruleIng))
    if ing = ""
        return false
    for i in medRec.ingredients {
        if i = ing
            return true
    }
    ; multi-word rules (e.g. "metoprolol succinate") match against the order text
    if InStr(ing, " ") && InStr(StrLower(medRec.raw), ing)
        return true
    return false
}

Safety_NewCol(key, label) {
    return { key: key, label: label, status: "Unknown", short: "", findings: [], note: "" }
}

Safety_Evaluate(ctx) {
    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    meds := PCtx_ConfirmedActiveMeds(ctx)
    ageTxt := PCtx_Demo(ctx, "age")

    cols := Map()
    cols["RENAL"] := Safety_Renal(ctx, parsed, meds)
    cols["QT"] := Safety_Simple(ctx, meds, "qt_rules", "QT", "ingredient", "risk", "note")
    cols["BEERS"] := Safety_Beers(ctx, meds, ageTxt)
    cols["MG"] := Safety_Simple(ctx, meds, "mg_cautions", "MG", "ingredient", "level", "note")
    cols["G6P"] := Safety_Simple(ctx, meds, "g6pd_rules", "G6P", "ingredient", "level", "note")
    cols["CRUSH"] := Safety_Crush(ctx, meds)
    return cols
}

Safety_Renal(ctx, parsed, meds) {
    c := Safety_NewCol("RENAL", "RENAL")
    if meds.Length = 0 {
        c.status := "Unknown"
        c.short := "No orders captured"
        c.note := "No medication orders were captured. Capture the order profile screen."
        return c
    }

    hasCrCl := parsed.HasOwnProp("crcl") && IsNumber(parsed.crcl) && Number(parsed.crcl) > 0
    alert := 0
    review := 0
    for m in meds {
        flag := PatientRenal_FlagForMedication(m.raw, parsed)
        if flag = ""
            continue
        if InStr(flag, "AVOID") {
            alert += 1
            c.findings.Push("ALERT  " m.raw "  ->  " flag)
        } else {
            review += 1
            c.findings.Push("REVIEW " m.raw "  ->  " flag)
        }
    }

    if alert > 0 {
        c.status := "Alert"
        c.short := alert " med" (alert = 1 ? "" : "s")
    } else if review > 0 {
        c.status := "Review"
        c.short := review " med" (review = 1 ? "" : "s")
    } else if !hasCrCl {
        c.status := "Unknown"
        c.short := "No CrCl"
    } else {
        c.status := "No match found"
        c.short := "0 of " meds.Length
    }

    c.note := hasCrCl
        ? "Cockcroft-Gault CrCl " Round(Number(parsed.crcl), 1) " mL/min from captured values. "
            . "Some labels use eGFR. Verify labels, dialysis/RRT status, indication, and local policy."
        : "CrCl could not be calculated from the captured screens. Renal findings are incomplete."
    return c
}

Safety_Beers(ctx, meds, ageTxt) {
    c := Safety_NewCol("BEERS", "BEERS")
    if ageTxt = "" || !IsNumber(ageTxt) {
        c.status := "Unknown"
        c.short := "Age not captured"
        c.note := "Beers criteria apply to adults 65 and older. Age was not captured."
        return c
    }
    if Number(ageTxt) < 65 {
        c.status := "Not applicable"
        c.short := "N/A - age under 65"
        c.note := "Patient age " ageTxt ". AGS Beers Criteria apply to adults 65 and older."
        return c
    }
    if meds.Length = 0 {
        c.status := "Unknown"
        c.short := "No orders captured"
        c.note := "No medication orders were captured."
        return c
    }
    if !RefData_Available("beers_rules") {
        c.status := "Unknown"
        c.short := "Reference unavailable"
        c.note := RefData_StatusLine("beers_rules")
        return c
    }

    avoid := 0
    caution := 0
    for m in meds {
        for r in RefData_Rows("beers_rules") {
            if !Safety_MedMatchesIngredient(m, r["ingredient"])
                continue
            cat := r["category"]
            line := (cat = "Avoid" ? "ALERT  " : "REVIEW ") m.raw "  ->  " cat ": " r["note"]
            c.findings.Push(line)
            if cat = "Avoid"
                avoid += 1
            else
                caution += 1
            break
        }
    }

    if avoid > 0 {
        c.status := "Alert"
        c.short := avoid " avoid"
    } else if caution > 0 {
        c.status := "Review"
        c.short := caution " caution"
    } else {
        c.status := "No match found"
        c.short := "0 of " meds.Length
    }
    c.note := "AGS 2023 Beers Criteria, curated subset. Diagnosis-, renal-, and duration-dependent "
        . "criteria require information that may not be visible on the captured screens."
    return c
}

; Generic evaluator for QT / MG / G6PD reference tables.
Safety_Simple(ctx, meds, dataset, key, ingCol, levelCol, noteCol) {
    c := Safety_NewCol(key, key)
    if meds.Length = 0 {
        c.status := "Unknown"
        c.short := "No orders captured"
        c.note := "No medication orders were captured."
        return c
    }
    if !RefData_Available(dataset) {
        c.status := "Unknown"
        c.short := "Reference unavailable"
        c.note := RefData_StatusLine(dataset)
        return c
    }

    high := 0
    low := 0
    for m in meds {
        for r in RefData_Rows(dataset) {
            if !Safety_MedMatchesIngredient(m, r[ingCol])
                continue
            lvl := StrLower(r[levelCol])
            isHigh := (lvl = "known" || lvl = "avoid" || lvl = "high")
            c.findings.Push((isHigh ? "ALERT  " : "REVIEW ") m.raw "  ->  "
                . StrUpper(SubStr(r[levelCol], 1, 1)) SubStr(r[levelCol], 2) ": " r[noteCol])
            if isHigh
                high += 1
            else
                low += 1
            break
        }
    }

    total := high + low
    if key = "QT" {
        if high >= 2 {
            c.status := "Alert"
            c.short := high " known-risk"
        } else if total > 0 {
            c.status := "Review"
            c.short := total " med" (total = 1 ? "" : "s")
        } else {
            c.status := "No match found"
            c.short := "0 of " meds.Length
        }
        kTxt := PCtx_LabValue(ctx, "potassium")
        mgTxt := PCtx_LabValue(ctx, "magnesium")
        extra := ""
        if kTxt != "" && IsNumber(kTxt) && Number(kTxt) < 3.5
            extra .= " Potassium " kTxt " - correct before additive QT exposure."
        if mgTxt != "" && IsNumber(mgTxt) && Number(mgTxt) < 1.8
            extra .= " Magnesium " mgTxt " - correct before additive QT exposure."
        if kTxt = "" || mgTxt = ""
            extra .= " Potassium and/or magnesium were not captured."
        c.note := "Curated QT list, not CredibleMeds. An institutional CredibleMeds license is "
            . "required to embed their list. ECG QTc was not captured." extra
        return c
    }

    if key = "MG" {
        if total = 0 {
            c.status := "No match found"
            c.short := "0 of " meds.Length
            c.note := "No myasthenia gravis cautionary medications matched. "
                . "MG diagnosis status was not captured."
            return c
        }
        c.status := (high > 0 ? "Alert" : "Review")
        c.short := total " med" (total = 1 ? "" : "s")
        c.note := "MGFA classifications are cautions, not absolute prohibitions, except where "
            . "labeled contraindicated. Myasthenia gravis diagnosis status was NOT captured - "
            . "these findings apply only if the patient carries that diagnosis."
        return c
    }

    ; G6PD
    if total = 0 {
        c.status := "No match found"
        c.short := "0 of " meds.Length
        c.note := "No G6PD-relevant medications matched. G6PD status was not captured."
        return c
    }
    c.status := (high > 0 ? "Alert" : "Review")
    c.short := total " med" (total = 1 ? "" : "s")
    c.note := "G6PD status was NOT captured and is not assumed negative. CPIC-based risk "
        . "classification. Rasburicase labeling states it should not be given to patients with "
        . "G6PD deficiency; screen patients at increased risk before treatment."
    return c
}

Crush_Field(rule, name, fallback := "") {
    return rule.Has(name) ? Trim(rule[name]) : fallback
}

Crush_RouteScopeApplies(scope, tubeRoute) {
    scope := StrLower(Trim(scope))
    if scope = "" || scope = "any"
        return true
    if scope = "enteral"
        return tubeRoute
    if scope = "oral"
        return true
    return true
}

Crush_RuleAppliesToProduct(med, rule, padded, tubeRoute) {
    if !Crush_RouteScopeApplies(Crush_Field(rule, "route_scope", "any"), tubeRoute)
        return false

    formMatch := Crush_Field(rule, "form_match")
    if formMatch != ""
        return RegExMatch(padded, "i)(" formMatch ")")

    ; Backward compatibility for legacy three-column crush_rules.csv files.
    note := StrLower(Crush_Field(rule, "note"))
    conditional := RegExMatch(note,
        "i)(products?\s+only|forms?\s+differ|\ber\b|\bxr\b|\bxl\b|\bsr\b|\bcr\b|\bdr\b|delayed[- ]release|extended[- ]release|modified[- ]release|wax matrix)")
    if !conditional
        return true

    return RegExMatch(padded,
        "i)(extended release|delayed release|sustained release|controlled release|modified release|enteric coated|wax matrix|\s(?:er|xr|xl|sr|cr|dr|ec|la)\s)")
}

Safety_Crush(ctx, meds) {
    c := Safety_NewCol("CRUSH", "CRUSH")
    if meds.Length = 0 {
        c.status := "Unknown"
        c.short := "No orders captured"
        c.note := "No medication orders were captured."
        return c
    }
    if !RefData_Available("crush_rules_v2") {
        c.status := "Unknown"
        c.short := "Reference unavailable"
        c.note := RefData_StatusLine("crush_rules_v2")
        return c
    }

    anyTubeRoute := false
    tubeHits := 0

    hits := 0
    for m in meds {
        medTubeRoute := RegExMatch(m.route, "i)\b(NG|OG|PEG|GT|JT|G-tube|J-tube)\b")
        if medTubeRoute
            anyTubeRoute := true
        padded := " " StrLower(RegExReplace(m.raw, "[^A-Za-z0-9 ]", " ")) " "
        padded := RegExReplace(padded, "\s+", " ")
        for r in RefData_Rows("crush_rules_v2") {
            pat := StrLower(Crush_Field(r, "pattern"))
            if pat = ""
                continue

            matched := false
            kind := StrLower(Crush_Field(r, "kind", "drug"))
            if kind = "form" {
                formMatch := Crush_Field(r, "form_match", pat)
                matched := RegExMatch(padded, "i)(" formMatch ")")
                    && Crush_RouteScopeApplies(Crush_Field(r, "route_scope", "any"), medTubeRoute)
            } else if Safety_MedMatchesIngredient(m, pat) {
                matched := Crush_RuleAppliesToProduct(m, r, padded, medTubeRoute)
            }
            if !matched
                continue

            action := Crush_Field(r, "action", medTubeRoute ? "DO NOT CRUSH / VERIFY" : "FORMULATION REVIEW")
            note := Crush_Field(r, "note")
            c.findings.Push((medTubeRoute ? "ALERT  " : "REVIEW ") m.raw "  ->  " action ": " note)
            if medTubeRoute
                tubeHits += 1
            hits += 1
            break
        }
    }

    if hits = 0 {
        c.status := "No match found"
        c.short := "0 of " meds.Length
    } else if tubeHits > 0 {
        c.status := "Alert"
        c.short := hits " med" (hits = 1 ? "" : "s")
    } else {
        c.status := "Review"
        c.short := hits " med" (hits = 1 ? "" : "s")
    }

    c.note := anyTubeRoute
        ? "Enteral-route findings are applied only to the medication order carrying the tube route. Confirm the exact product, dosage form, tube location/size, and labeled administration method for each flagged order."
        : "Formulation screening only. Confirm the exact product when swallowing difficulty or manipulation is being considered."
    return c
}

Safety_StatusColorName(status) {
    switch status {
        case "Alert": return "bad"
        case "Review": return "warn"
        case "Unknown": return "subtle"
        case "Not applicable": return "subtle"
        default: return "text"
    }
}

Safety_ShowDetail(ctx, key) {
    cols := Safety_Evaluate(ctx)
    if !cols.Has(key)
        return
    c := cols[key]

    g := Gui("+MinimizeBox", c.label " - findings")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    h := g.Add("Text", "xm w720", c.label "   -   " c.status
        . (c.short != "" ? "   (" c.short ")" : ""))
    Theme_Heading(h)

    body := ""
    if c.findings.Length = 0 {
        body := "No findings for this column."
    } else {
        for f in c.findings
            body .= f "`r`n"
    }
    body .= "`r`n----------------------------------------------------------------------`r`n"
    body .= c.note "`r`n"
    body .= "`r`nEvaluated: " PCtx_ActiveMeds(ctx).Length
        . " active/pending order(s) across " ctx.captures.Length " capture(s)."

    out := g.Add("Edit", "xm y+8 w720 h340 ReadOnly VScroll -Wrap", body)
    Theme_OutputFont(out)

    g.Add("Button", "xm y+10 w140", "Copy Findings").OnEvent("Click", (*) => (A_Clipboard := body))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w760")
}

; =================================================================================================
; CALCULATOR READINESS (§16 multi-capture GUI behavior)
; =================================================================================================
Safety_Readiness(ctx) {
    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)

    hasWt := PCtx_SelectedWeight(ctx) != ""
    hasHt := PCtx_Demo(ctx, "heightCm") != ""
    hasAge := PCtx_Demo(ctx, "age") != ""
    hasScr := PCtx_LabValue(ctx, "creatinine") != ""
    hasMeds := PCtx_ConfirmedActiveMeds(ctx).Length > 0
    labCount := 0
    for k, arr in ctx.labs
        labCount += 1
    hasMar := ctx.mar.Length > 0

    r := Map()
    r["bmi"] := Safety_Ready(hasWt && hasHt, hasWt || hasHt ? "Partial data" : "Needs height and weight")
    r["renal"] := Safety_Ready(hasScr && hasAge && hasWt, "Needs age, weight, and creatinine")
    r["vanco"] := Safety_Ready(hasWt && hasScr, "Needs weight and creatinine")
    r["ag"] := Safety_Ready(hasWt && hasScr, "Needs weight and creatinine")
    r["rsi"] := Safety_Ready(hasWt, "Needs weight")
    r["abx"] := Safety_Ready(true, "")
    r["riskstack"] := Safety_Ready(hasMeds, "Needs medication orders")
    r["labs"] := Safety_Ready(labCount >= 2, labCount = 0 ? "Needs laboratory results" : "Partial data")
    r["daysupply"] := Safety_Ready(true, "")
    r["anticoag"] := Safety_Ready(hasMeds || labCount > 0, "Open · capture meds or labs")
    r["tls"] := Safety_Ready(labCount > 0, "Open · capture TLS labs")
    r["infusion"] := Safety_Ready(hasMar || hasMeds, "Open · capture MAR or orders")
    r["nutrition"] := Safety_Ready(labCount > 0 || hasWt, "Open · capture labs or weight")
    return r
}

Safety_Ready(ok, missingLabel) {
    return { ready: ok, label: (ok ? "Ready" : missingLabel) }
}

; =================================================================================================
; STRUCTURED REPORT (replaces the single flat text block)
; =================================================================================================



; =================================================================================================
; RC12 PHASE 3 — RUNTIME TRUTH BUNDLES
; =================================================================================================

global _TruthCalcPath := A_ScriptDir "\data\runtime\active-calculator-truths.ini"
global _TruthFindingPath := A_ScriptDir "\data\runtime\active-finding-rules.ini"
global _TruthCalcBundleVersion := ""
global _TruthFindingBundleVersion := ""
global _TruthCalcLoaded := false
global _TruthFindingLoaded := false

Truth_LoadRuntimeBundles() {
    global _TruthCalcLoaded, _TruthFindingLoaded, _TruthCalcBundleVersion, _TruthFindingBundleVersion

    _TruthCalcLoaded := FileExist(_TruthCalcPath) ? true : false
    _TruthFindingLoaded := FileExist(_TruthFindingPath) ? true : false

    if _TruthCalcLoaded {
        try _TruthCalcBundleVersion := IniRead(_TruthCalcPath, "bundle", "version", "")
        catch
            _TruthCalcLoaded := false
    }
    if _TruthFindingLoaded {
        try _TruthFindingBundleVersion := IniRead(_TruthFindingPath, "bundle", "version", "")
        catch
            _TruthFindingLoaded := false
    }

    if _TruthCalcBundleVersion = ""
        _TruthCalcLoaded := false
    if _TruthFindingBundleVersion = ""
        _TruthFindingLoaded := false
}

Truth_CalculatorVersion(id) {
    Truth_LoadRuntimeBundles()
    global _TruthCalcLoaded, _TruthCalcPath
    if !_TruthCalcLoaded
        return "bundled fallback"
    try return IniRead(_TruthCalcPath, id, "version", "bundled fallback")
    catch
        return "bundled fallback"
}

Truth_FindingVersion(id) {
    Truth_LoadRuntimeBundles()
    global _TruthFindingLoaded, _TruthFindingPath
    if !_TruthFindingLoaded
        return "bundled fallback"
    try return IniRead(_TruthFindingPath, id, "version", "bundled fallback")
    catch
        return "bundled fallback"
}

Truth_RuntimeStatus() {
    Truth_LoadRuntimeBundles()
    global _TruthCalcLoaded, _TruthFindingLoaded, _TruthCalcBundleVersion, _TruthFindingBundleVersion
    calc := _TruthCalcLoaded ? "Calculator truths " _TruthCalcBundleVersion : "Calculator truths: bundled fallback"
    rules := _TruthFindingLoaded ? "Finding rules " _TruthFindingBundleVersion : "Finding rules: bundled fallback"
    return calc " | " rules
}

Truth_FindingSuffix(id) {
    return " [rule " id " v" Truth_FindingVersion(id) "]"
}


Truth_FindingEnabled(id) {
    Truth_LoadRuntimeBundles()
    global _TruthFindingLoaded, _TruthFindingPath
    if !_TruthFindingLoaded
        return true
    try status := StrLower(IniRead(_TruthFindingPath, id, "status", "active_test"))
    catch
        return true
    return !(status = "disabled" || status = "retired" || status = "superseded")
}

Truth_FindingText(id, fallback) {
    if !Truth_FindingEnabled(id)
        return ""
    global _TruthFindingLoaded, _TruthFindingPath
    text := fallback
    if _TruthFindingLoaded {
        try text := IniRead(_TruthFindingPath, id, "message", fallback)
    }
    return text Truth_FindingSuffix(id)
}



; =================================================================================================
; RC5 — TOP 300 ACTIVE CLINICAL KNOWLEDGE + SCREEN-GRAB MEDREC/PATIENT REVIEW
; Functional simulation mode: knowledge is treated as active in the user-facing review while the
; source-validation workflow continues in the database workbench.
; =================================================================================================

global _CRD5_ByKey := Map()
global _CRD5_Records := []
global _CRD5_Loaded := false

CRD5_Load() {
    global _CRD5_Loaded, _CRD5_ByKey, _CRD5_Records
    if !IsSet(_CRD5_Loaded)
        _CRD5_Loaded := false
    if !IsSet(_CRD5_ByKey) || !IsObject(_CRD5_ByKey)
        _CRD5_ByKey := Map()
    if !IsSet(_CRD5_Records) || !IsObject(_CRD5_Records)
        _CRD5_Records := []
    if _CRD5_Loaded
        return
    _CRD5_Loaded := true
    CRD5_AddRecord(1, "Atorvastatin", ["Atorvastatin", "atorvastatin", "Lipitor"], "HMG-CoA reductase inhibitor", "lipid lowering", "statin", ["hyperlipidemia", "ASCVD risk reduction"], "Agent-specific; rosuvastatin requires greater renal attention.", "Avoid active liver disease; assess clinically significant hepatic dysfunction.", ["lipid panel", "myalgia/weakness", "hepatic symptoms"], ["myopathy/rhabdomyolysis", "pregnancy avoidance"], ["strong CYP inhibitors for selected statins", "fibrates increase myopathy risk"], "Daily; simvastatin/lovastatin are generally evening-oriented.", "Formulation-specific; do not crush modified-release products.", ["myopathy", "hepatic"])
    CRD5_AddRecord(2, "Metformin", ["Metformin", "metformin", "Glucophage"], "biguanide", "oral antihyperglycemic", "biguanide", ["type 2 diabetes"], "Dose by eGFR and hold in selected acute/contrast situations.", "Agent-specific; assess current labeling and clinical status.", ["glucose", "renal function", "vitamin B12 with long-term use"], ["lactic acidosis risk in severe illness/organ dysfunction"], ["iodinated contrast/acute kidney injury context"], "Take with food; ER products must not be crushed.", "Do not crush extended-release formulations.", ["renal", "hypoglycemia"])
    CRD5_AddRecord(3, "Levothyroxine", ["Levothyroxine", "levothyroxine", "Synthroid", "Levoxyl"], "thyroid-axis medication", "endocrine", "thyroid", ["hypothyroidism or hyperthyroidism depending on agent"], "Usually no direct adjustment.", "Usually limited adjustment.", ["TSH/free T4", "clinical response"], ["cardiac overstimulation if excessive", "agranulocytosis/hepatotoxicity for methimazole"], ["calcium/iron", "warfarin", "enzyme inducers"], "Levothyroxine requires consistent empty-stomach timing and separation from cations.", "Formulation-specific.", ["thyroid", "cation_interaction"])
    CRD5_AddRecord(4, "Lisinopril", ["Lisinopril", "lisinopril", "Prinivil", "Zestril"], "ACE inhibitor", "RAAS antihypertensive", "ace_inhibitor", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Usually no class-wide adjustment; agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["angioedema", "hyperkalemia", "pregnancy contraindication"], ["ARB/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(5, "Amlodipine", ["Amlodipine", "amlodipine", "Norvasc"], "dihydropyridine calcium channel blocker", "antihypertensive", "dhp_ccb", ["hypertension", "angina"], "Usually no major renal adjustment.", "Start conservatively in significant hepatic impairment.", ["blood pressure", "peripheral edema"], ["hypotension", "peripheral edema"], ["other antihypertensives", "CYP3A4 modifiers"], "Do not crush extended-release products.", "Do not crush extended-release products.", ["hypotension"])
    CRD5_AddRecord(6, "Metoprolol", ["Metoprolol", "metoprolol", "Lopressor", "Toprol XL"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(7, "Albuterol", ["Albuterol", "albuterol", "Ventolin", "ProAir", "Proventil"], "inhaled bronchodilator", "airway therapy", "bronchodilator", ["asthma", "COPD"], "No routine adjustment.", "Usually limited adjustment.", ["symptom control", "heart rate/tremor", "anticholinergic effects"], ["tachycardia", "paradoxical bronchospasm"], ["other sympathomimetics", "anticholinergic burden"], "Device technique is essential; LABA/LAMA are maintenance, not rescue.", "Not applicable.", ["bronchodilator", "tachycardia"])
    CRD5_AddRecord(8, "Losartan", ["Losartan", "losartan", "Cozaar"], "angiotensin II receptor blocker", "RAAS antihypertensive", "arb", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["hyperkalemia", "pregnancy contraindication"], ["ACE inhibitor/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(9, "Gabapentin", ["Gabapentin", "gabapentin", "Neurontin"], "gabapentinoid", "neuropathic pain/antiepileptic", "gabapentinoid", ["neuropathic pain", "seizure adjunct"], "Requires renal dose adjustment.", "Limited metabolism.", ["sedation", "edema", "misuse", "respiratory depression with opioids"], ["sedation", "respiratory depression with CNS depressants"], ["opioids", "other CNS depressants"], "Taper after sustained use.", "Do not crush extended-release products.", ["gabapentinoid", "cns_depressant", "resp_depression", "renal"])
    CRD5_AddRecord(10, "Omeprazole", ["Omeprazole", "omeprazole", "Prilosec"], "proton pump inhibitor", "acid suppression", "ppi", ["GERD", "peptic ulcer disease", "GI bleed therapy/prophylaxis"], "Usually no renal dose adjustment.", "Agent-specific limits in severe impairment.", ["ongoing indication", "magnesium with prolonged use", "enteric infection risk context"], ["long-term overuse", "hypomagnesemia", "enteric infection association"], ["omeprazole may reduce clopidogrel activation", "pH-dependent absorption interactions"], "Delayed-release handling is formulation-specific.", "Many delayed-release products should not be crushed.", ["acid_suppression"])
    CRD5_AddRecord(11, "Sertraline", ["Sertraline", "sertraline", "Zoloft"], "selective serotonin reuptake inhibitor", "antidepressant", "ssri", ["depression", "anxiety disorders"], "Agent-specific.", "Lower or less-frequent dosing may be needed.", ["suicidality during initiation/change", "serotonin toxicity", "sodium in at-risk patients"], ["serotonin syndrome", "hyponatremia", "bleeding risk"], ["MAO inhibitors", "other serotonergic drugs", "anticoagulants/antiplatelets"], "Taper rather than abruptly discontinue when feasible.", "Do not crush modified-release products.", ["serotonergic", "bleeding", "hyponatremia"])
    CRD5_AddRecord(12, "Rosuvastatin", ["Rosuvastatin", "rosuvastatin", "Crestor"], "HMG-CoA reductase inhibitor", "lipid lowering", "statin", ["hyperlipidemia", "ASCVD risk reduction"], "Agent-specific; rosuvastatin requires greater renal attention.", "Avoid active liver disease; assess clinically significant hepatic dysfunction.", ["lipid panel", "myalgia/weakness", "hepatic symptoms"], ["myopathy/rhabdomyolysis", "pregnancy avoidance"], ["strong CYP inhibitors for selected statins", "fibrates increase myopathy risk"], "Daily; simvastatin/lovastatin are generally evening-oriented.", "Formulation-specific; do not crush modified-release products.", ["myopathy", "hepatic"])
    CRD5_AddRecord(13, "Pantoprazole", ["Pantoprazole", "pantoprazole", "Protonix"], "proton pump inhibitor", "acid suppression", "ppi", ["GERD", "peptic ulcer disease", "GI bleed therapy/prophylaxis"], "Usually no renal dose adjustment.", "Agent-specific limits in severe impairment.", ["ongoing indication", "magnesium with prolonged use", "enteric infection risk context"], ["long-term overuse", "hypomagnesemia", "enteric infection association"], ["omeprazole may reduce clopidogrel activation", "pH-dependent absorption interactions"], "Delayed-release handling is formulation-specific.", "Many delayed-release products should not be crushed.", ["acid_suppression"])
    CRD5_AddRecord(14, "Escitalopram", ["Escitalopram", "escitalopram", "Lexapro"], "selective serotonin reuptake inhibitor", "antidepressant", "ssri", ["depression", "anxiety disorders"], "Agent-specific.", "Lower or less-frequent dosing may be needed.", ["suicidality during initiation/change", "serotonin toxicity", "sodium in at-risk patients"], ["serotonin syndrome", "hyponatremia", "bleeding risk"], ["MAO inhibitors", "other serotonergic drugs", "anticoagulants/antiplatelets"], "Taper rather than abruptly discontinue when feasible.", "Do not crush modified-release products.", ["serotonergic", "bleeding", "hyponatremia"])
    CRD5_AddRecord(15, "Dextroamphetamine; Dextroamphetamine Saccharate; Amphetamine; Amphetamine Aspartate", ["Dextroamphetamine; Dextroamphetamine Saccharate; Amphetamine; Amphetamine Aspartate", "dextroamphetamine", "dextroamphetamine saccharate", "amphetamine", "amphetamine aspartate", "Dextroamphetamine/ Dextroamphetamine Saccharate/ Amphetamine/ Amphetamine Aspartate", "Dextroamphetamine +  Dextroamphetamine Saccharate +  Amphetamine +  Amphetamine Aspartate"], "CNS stimulant/sympathomimetic", "ADHD/weight management", "stimulant", ["ADHD", "narcolepsy", "short-term weight management for phentermine"], "Agent-specific.", "Agent-specific.", ["blood pressure", "heart rate", "sleep", "appetite/weight", "misuse"], ["misuse/dependence", "cardiovascular effects", "psychiatric effects"], ["MAO inhibitors", "other sympathomimetics"], "Morning dosing; do not crush extended-release products.", "Do not crush extended-release products.", ["stimulant", "tachycardia", "hypertension"])
    CRD5_AddRecord(16, "Hydrochlorothiazide", ["Hydrochlorothiazide", "hydrochlorothiazide", "HCTZ", "Microzide"], "thiazide/thiazide-like diuretic", "antihypertensive/diuretic", "thiazide", ["hypertension", "edema"], "Effectiveness and safety depend on renal function.", "Monitor electrolytes closely.", ["sodium", "potassium", "magnesium", "uric acid", "blood pressure"], ["hyponatremia", "hypokalemia", "gout"], ["lithium", "NSAIDs", "other antihypertensives"], "Morning dosing often reduces nocturia.", "Usually immediate-release; verify formulation.", ["diuretic", "hypokalemia", "hyponatremia", "lithium_interaction"])
    CRD5_AddRecord(17, "Bupropion", ["Bupropion", "bupropion", "Wellbutrin", "Zyban"], "other antidepressant", "antidepressant", "other_antidepressant", ["depression"], "Agent-specific.", "Agent-specific; assess current labeling and clinical status.", ["mood/suicidality", "sedation or activation", "drug-specific effects"], ["drug-specific seizure, sedation, or metabolic risks"], ["MAO inhibitors and other CNS/serotonergic agents"], "Formulation-specific.", "Do not crush modified-release products.", ["cns_depressant"])
    CRD5_AddRecord(18, "Fluoxetine", ["Fluoxetine", "fluoxetine", "Prozac"], "selective serotonin reuptake inhibitor", "antidepressant", "ssri", ["depression", "anxiety disorders"], "Agent-specific.", "Lower or less-frequent dosing may be needed.", ["suicidality during initiation/change", "serotonin toxicity", "sodium in at-risk patients"], ["serotonin syndrome", "hyponatremia", "bleeding risk"], ["MAO inhibitors", "other serotonergic drugs", "anticoagulants/antiplatelets"], "Taper rather than abruptly discontinue when feasible.", "Do not crush modified-release products.", ["serotonergic", "bleeding", "hyponatremia"])
    CRD5_AddRecord(19, "Semaglutide", ["Semaglutide", "semaglutide", "Ozempic", "Wegovy", "Rybelsus"], "incretin-based GLP-1 therapy", "diabetes/weight management", "glp1", ["type 2 diabetes", "weight management for selected products"], "No simple class dose rule; dehydration can worsen renal function.", "Usually limited adjustment.", ["glucose", "GI tolerance", "weight", "pancreatitis/gallbladder symptoms"], ["severe GI effects", "pancreatitis warning", "thyroid C-cell tumor warning for selected products"], ["insulin/sulfonylurea hypoglycemia risk", "delayed gastric emptying"], "Follow product-specific titration and oral/injection timing.", "Oral semaglutide must be swallowed whole.", ["glp1", "hypoglycemia", "gi"])
    CRD5_AddRecord(20, "Montelukast", ["Montelukast", "montelukast", "Singulair"], "leukotriene receptor antagonist", "asthma/allergy maintenance", "leukotriene_modifier", ["asthma maintenance", "allergic rhinitis"], "No routine adjustment.", "Agent-specific; assess current labeling and clinical status.", ["neuropsychiatric symptoms", "asthma control"], ["boxed neuropsychiatric warning"], ["few major pharmacokinetic interactions"], "Not a rescue medication.", "Chewable/granule products have specific instructions.", [])
    CRD5_AddRecord(21, "Trazodone", ["Trazodone", "trazodone", "Desyrel"], "serotonergic antidepressant", "antidepressant/sedative", "serotonergic_sedative", ["depression", "insomnia-related use"], "Usually no simple adjustment; use cautiously.", "Agent-specific; assess current labeling and clinical status.", ["sedation", "orthostasis", "serotonin toxicity"], ["priapism", "falls"], ["other serotonergic drugs", "CNS depressants"], "Often administered at night.", "Immediate-release tablets are generally crushable; verify formulation.", ["serotonergic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(22, "Simvastatin", ["Simvastatin", "simvastatin", "Zocor"], "HMG-CoA reductase inhibitor", "lipid lowering", "statin", ["hyperlipidemia", "ASCVD risk reduction"], "Agent-specific; rosuvastatin requires greater renal attention.", "Avoid active liver disease; assess clinically significant hepatic dysfunction.", ["lipid panel", "myalgia/weakness", "hepatic symptoms"], ["myopathy/rhabdomyolysis", "pregnancy avoidance"], ["strong CYP inhibitors for selected statins", "fibrates increase myopathy risk"], "Daily; simvastatin/lovastatin are generally evening-oriented.", "Formulation-specific; do not crush modified-release products.", ["myopathy", "hepatic"])
    CRD5_AddRecord(23, "Amoxicillin", ["Amoxicillin", "amoxicillin", "Amoxil"], "penicillin-class antibiotic", "antimicrobial", "penicillin", ["susceptible bacterial infections"], "Most require renal adjustment.", "Amoxicillin/clavulanate requires hepatic review.", ["allergy", "renal function", "clinical response"], ["hypersensitivity", "C. difficile-associated diarrhea"], ["methotrexate", "warfarin monitoring context"], "Food and formulation advice are product-specific.", "Many immediate-release products have liquid alternatives.", ["antibiotic", "beta_lactam", "renal", "allergy"])
    CRD5_AddRecord(24, "Tamsulosin", ["Tamsulosin", "tamsulosin", "Flomax"], "alpha-1 adrenergic blocker", "BPH/antihypertensive", "alpha1_blocker", ["BPH", "hypertension for selected agents"], "Usually limited adjustment.", "Agent-specific.", ["orthostasis", "blood pressure", "falls"], ["syncope", "falls"], ["PDE-5 inhibitors", "other antihypertensives"], "Initial/retitration dosing may cause marked orthostasis.", "Do not crush modified-release products.", ["hypotension", "fall_risk"])
    CRD5_AddRecord(25, "Acetaminophen; Hydrocodone", ["Acetaminophen; Hydrocodone", "acetaminophen", "hydrocodone", "Tylenol", "APAP", "Norco", "Vicodin", "Acetaminophen/ Hydrocodone", "Acetaminophen +  Hydrocodone"], "opioid agonist + nonopioid analgesic or combination analgesic", "analgesic + pain/headache therapy", "opioid", ["moderate to severe pain", "pain", "fever", "headache"], "Metabolite accumulation varies; morphine requires high renal caution. | Usually limited adjustment, but chronic/high exposure requires caution.", "Start conservatively. | Acetaminophen total daily exposure is critical in hepatic risk.", ["pain response", "sedation", "respiratory rate", "bowel function", "total acetaminophen exposure", "sedation for butalbital combinations", "headache frequency"], ["respiratory depression", "dependence", "overdose", "hepatotoxicity", "medication-overuse headache", "sedation/dependence with butalbital"], ["benzodiazepines", "alcohol", "other CNS depressants", "serotonergic drugs for tramadol", "warfarin with sustained high acetaminophen exposure", "CNS depressants"], "Use bowel regimen when appropriate; never crush ER products. | Count all combination-product acetaminophen.", "Never crush extended-release or abuse-deterrent products. | Formulation-specific.", ["opioid", "cns_depressant", "resp_depression", "constipation", "acetaminophen"])
    CRD5_AddRecord(26, "Fluticasone", ["Fluticasone", "fluticasone", "Flonase", "Flovent"], "inhaled/intranasal corticosteroid", "airway anti-inflammatory", "inhaled_steroid", ["asthma/COPD maintenance", "allergic rhinitis"], "No routine renal adjustment.", "Systemic exposure may increase with strong CYP3A4 inhibitors.", ["symptom control", "oral candidiasis", "local nasal effects"], ["not a rescue inhaler", "local candidiasis"], ["strong CYP3A4 inhibitors"], "Rinse mouth after inhaled use; technique matters.", "Not applicable.", ["inhaled_steroid"])
    CRD5_AddRecord(27, "Meloxicam", ["Meloxicam", "meloxicam", "Mobic"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(28, "Apixaban", ["Apixaban", "apixaban", "Eliquis"], "oral anticoagulant", "anticoagulation", "anticoagulant", ["atrial fibrillation stroke prevention", "VTE treatment/prevention"], "Indication- and agent-specific renal criteria.", "Avoid significant hepatic coagulopathy; agent-specific.", ["bleeding", "renal function", "CBC", "adherence"], ["major bleeding", "neuraxial hematoma warning"], ["antiplatelets", "NSAIDs", "strong CYP/P-gp modifiers"], "Dose depends on indication; do not infer from drug name alone.", "Agent/formulation-specific.", ["anticoagulant", "bleeding", "renal"])
    CRD5_AddRecord(29, "Furosemide", ["Furosemide", "furosemide", "Lasix"], "loop diuretic", "diuretic", "loop_diuretic", ["edema", "heart failure"], "Dose to response; monitor renal function and volume status.", "Electrolyte shifts may worsen encephalopathy.", ["volume status", "sodium", "potassium", "magnesium", "renal function"], ["volume depletion", "electrolyte depletion", "ototoxicity at high exposure"], ["NSAIDs", "lithium", "other ototoxins"], "Morning timing when possible; IV rate is product-specific.", "Immediate-release generally; verify formulation.", ["diuretic", "hypokalemia", "renal", "volume_depletion"])
    CRD5_AddRecord(30, "Insulin Glargine", ["Insulin Glargine", "insulin glargine", "Lantus", "Basaglar", "Semglee"], "insulin", "antihyperglycemic", "insulin", ["diabetes", "hyperglycemia", "critical-care protocols for selected products"], "Requirements often decrease as renal function declines.", "Requirements may change.", ["blood glucose", "potassium in IV protocols", "hypoglycemia"], ["hypoglycemia", "hypokalemia", "medication errors"], ["other glucose-lowering drugs", "beta blockers may mask symptoms"], "Verify product, concentration, route, and meal timing; never interchange blindly.", "Not applicable.", ["insulin", "hypoglycemia", "potassium"])
    CRD5_AddRecord(31, "Duloxetine", ["Duloxetine", "duloxetine", "Cymbalta"], "serotonin-norepinephrine reuptake inhibitor", "antidepressant/neuropathic pain", "snri", ["depression", "anxiety", "neuropathic pain"], "Dose limits vary; duloxetine has significant severe-renal restrictions.", "Duloxetine requires major hepatic caution.", ["blood pressure", "serotonin toxicity", "withdrawal"], ["serotonin syndrome", "blood pressure elevation", "withdrawal"], ["MAO inhibitors", "other serotonergic drugs", "bleeding-risk drugs"], "Taper rather than abruptly discontinue.", "Do not crush extended-release formulations.", ["serotonergic", "bleeding"])
    CRD5_AddRecord(32, "Ibuprofen", ["Ibuprofen", "ibuprofen", "Motrin", "Advil"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(33, "Famotidine", ["Famotidine", "famotidine", "Pepcid"], "histamine-2 receptor antagonist", "acid suppression", "h2_blocker", ["GERD", "ulcer disease"], "Dose reduce in renal impairment.", "Usually limited adjustment.", ["mental status in older/renal patients", "ongoing indication"], ["confusion in susceptible patients"], ["pH-dependent absorption interactions"], "Separate from selected pH-dependent drugs.", "Immediate-release tablets are generally crushable; verify product.", ["acid_suppression", "renal"])
    CRD5_AddRecord(34, "Empagliflozin", ["Empagliflozin", "empagliflozin", "Jardiance"], "SGLT2 inhibitor", "diabetes/cardiorenal therapy", "sglt2", ["type 2 diabetes", "heart failure", "CKD"], "Indication-specific eGFR thresholds; verify current labeling.", "Usually limited adjustment.", ["renal function", "volume status", "ketones when ill", "genital infections"], ["euglycemic ketoacidosis", "volume depletion", "genital infection"], ["diuretics", "insulin/sulfonylureas"], "Hold around major surgery/prolonged fasting or severe illness per protocol.", "Product-specific.", ["sglt2", "renal", "volume_depletion", "ketoacidosis", "hypoglycemia"])
    CRD5_AddRecord(35, "Carvedilol", ["Carvedilol", "carvedilol", "Coreg"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(36, "Tramadol", ["Tramadol", "tramadol", "Ultram"], "opioid agonist", "analgesic", "opioid", ["moderate to severe pain"], "Metabolite accumulation varies; morphine requires high renal caution.", "Start conservatively.", ["pain response", "sedation", "respiratory rate", "bowel function"], ["respiratory depression", "dependence", "overdose"], ["benzodiazepines", "alcohol", "other CNS depressants", "serotonergic drugs for tramadol"], "Use bowel regimen when appropriate; never crush ER products.", "Never crush extended-release or abuse-deterrent products.", ["opioid", "cns_depressant", "resp_depression", "constipation"])
    CRD5_AddRecord(37, "Alprazolam", ["Alprazolam", "alprazolam", "Xanax"], "benzodiazepine", "anxiolytic/sedative", "benzodiazepine", ["anxiety", "acute agitation", "seizure", "alcohol withdrawal"], "Agent/metabolite-specific.", "Lorazepam/oxazepam/temazepam are often preferred in hepatic dysfunction.", ["sedation", "respiratory status", "falls", "withdrawal"], ["respiratory depression", "dependence", "falls/delirium"], ["opioids", "alcohol", "other CNS depressants"], "Avoid abrupt discontinuation after sustained use.", "Formulation-specific.", ["benzodiazepine", "cns_depressant", "fall_risk", "resp_depression"])
    CRD5_AddRecord(38, "Prednisone", ["Prednisone", "prednisone", "Deltasone"], "systemic corticosteroid", "anti-inflammatory/immunosuppressant", "systemic_steroid", ["inflammatory disease", "allergic disease", "adrenal replacement for selected agents"], "Usually no renal dose adjustment.", "Conversion/protein binding may vary.", ["glucose", "blood pressure", "infection", "psychiatric effects", "bone risk with prolonged use"], ["infection", "hyperglycemia", "adrenal suppression"], ["NSAIDs", "vaccines", "glucose-lowering therapy"], "Consider taper after prolonged exposure; give with food when appropriate.", "Immediate-release generally; verify formulation.", ["steroid", "hyperglycemia", "infection"])
    CRD5_AddRecord(39, "Hydroxyzine", ["Hydroxyzine", "hydroxyzine", "Atarax", "Vistaril"], "first-generation antihistamine", "antiallergic/anxiolytic", "sedating_antihistamine", ["allergy", "pruritus", "anxiety depending on agent"], "Dose adjust selected agents.", "Agent-specific; assess current labeling and clinical status.", ["sedation", "anticholinergic effects", "QT risk"], ["falls/delirium", "QT prolongation for selected agents"], ["CNS depressants", "anticholinergics", "QT drugs"], "Sedating; avoid unnecessary daytime use.", "Formulation-specific.", ["cns_depressant", "anticholinergic", "fall_risk", "qt"])
    CRD5_AddRecord(40, "Buspirone", ["Buspirone", "buspirone", "Buspar"], "serotonergic anxiolytic", "anxiolytic", "serotonergic", ["anxiety"], "Agent-specific.", "Agent-specific; assess current labeling and clinical status.", ["response", "dizziness", "serotonin toxicity"], ["serotonin syndrome"], ["MAO inhibitors", "other serotonergic drugs"], "Scheduled, not PRN, for chronic anxiety benefit.", "Generally crushable; verify product.", ["serotonergic"])
    CRD5_AddRecord(41, "Clopidogrel", ["Clopidogrel", "clopidogrel", "Plavix"], "antiplatelet agent", "platelet inhibition", "antiplatelet", ["ACS/PCI", "secondary cardiovascular prevention"], "Usually no simple renal adjustment.", "Agent-specific.", ["bleeding", "CBC when indicated", "adherence"], ["major bleeding"], ["anticoagulants", "NSAIDs", "other antiplatelets"], "Assess indication and procedure hold timing.", "Product-specific.", ["antiplatelet", "bleeding"])
    CRD5_AddRecord(42, "Glipizide", ["Glipizide", "glipizide", "Glucotrol"], "sulfonylurea", "oral antihyperglycemic", "sulfonylurea", ["type 2 diabetes"], "Hypoglycemia risk increases with renal dysfunction.", "Use cautiously.", ["glucose", "hypoglycemia", "weight"], ["prolonged hypoglycemia"], ["other glucose-lowering drugs", "agents masking hypoglycemia"], "Coordinate with meals.", "Do not crush extended-release formulations.", ["hypoglycemia"])
    CRD5_AddRecord(43, "Citalopram", ["Citalopram", "citalopram", "Celexa"], "selective serotonin reuptake inhibitor", "antidepressant", "ssri", ["depression", "anxiety disorders"], "Agent-specific.", "Lower or less-frequent dosing may be needed.", ["suicidality during initiation/change", "serotonin toxicity", "sodium in at-risk patients"], ["serotonin syndrome", "hyponatremia", "bleeding risk"], ["MAO inhibitors", "other serotonergic drugs", "anticoagulants/antiplatelets"], "Taper rather than abruptly discontinue when feasible.", "Do not crush modified-release products.", ["serotonergic", "bleeding", "hyponatremia"])
    CRD5_AddRecord(44, "Potassium Chloride", ["Potassium Chloride", "potassium chloride", "KCl", "Klor-Con"], "potassium replacement", "electrolyte", "potassium", ["hypokalemia prevention/treatment"], "Reduce/avoid when renal potassium clearance is impaired.", "Agent-specific; assess current labeling and clinical status.", ["potassium", "renal function", "ECG when severe"], ["hyperkalemia", "GI injury with solid products"], ["ACEI/ARB/ARNI", "spironolactone", "TMP-SMX"], "Never IV push; oral ER products require specific handling.", "Do not crush extended-release potassium products.", ["hyperkalemia", "renal", "potassium"])
    CRD5_AddRecord(45, "Allopurinol", ["Allopurinol", "allopurinol", "Zyloprim"], "xanthine oxidase inhibitor", "urate-lowering therapy", "urate_lowering", ["gout prevention", "hyperuricemia"], "Start low and adjust for renal function.", "Agent-specific; assess current labeling and clinical status.", ["uric acid", "renal function", "rash"], ["severe cutaneous reactions"], ["azathioprine/mercaptopurine", "warfarin monitoring"], "Continue prophylaxis/flare plan when initiating.", "Tablets are generally crushable; verify product.", ["renal"])
    CRD5_AddRecord(46, "Aspirin", ["Aspirin", "aspirin", "ASA", "Bayer"], "antiplatelet agent", "platelet inhibition", "antiplatelet", ["ACS/PCI", "secondary cardiovascular prevention"], "Usually no simple renal adjustment.", "Agent-specific.", ["bleeding", "CBC when indicated", "adherence"], ["major bleeding"], ["anticoagulants", "NSAIDs", "other antiplatelets"], "Assess indication and procedure hold timing.", "Product-specific.", ["antiplatelet", "bleeding"])
    CRD5_AddRecord(47, "Cyclobenzaprine", ["Cyclobenzaprine", "cyclobenzaprine", "Flexeril"], "centrally acting muscle relaxant", "musculoskeletal", "muscle_relaxant", ["muscle spasm", "spasticity depending on agent"], "Baclofen requires major renal caution.", "Tizanidine requires hepatic monitoring.", ["sedation", "falls", "blood pressure", "withdrawal"], ["sedation", "falls", "withdrawal"], ["opioids", "benzodiazepines", "other CNS depressants"], "Avoid abrupt stop after sustained baclofen/tizanidine.", "Formulation-specific.", ["cns_depressant", "fall_risk"])
    CRD5_AddRecord(48, "Ergocalciferol", ["Ergocalciferol", "ergocalciferol"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(49, "Oxycodone", ["Oxycodone", "oxycodone", "Roxicodone", "OxyContin"], "opioid agonist", "analgesic", "opioid", ["moderate to severe pain"], "Metabolite accumulation varies; morphine requires high renal caution.", "Start conservatively.", ["pain response", "sedation", "respiratory rate", "bowel function"], ["respiratory depression", "dependence", "overdose"], ["benzodiazepines", "alcohol", "other CNS depressants", "serotonergic drugs for tramadol"], "Use bowel regimen when appropriate; never crush ER products.", "Never crush extended-release or abuse-deterrent products.", ["opioid", "cns_depressant", "resp_depression", "constipation"])
    CRD5_AddRecord(50, "Methylphenidate", ["Methylphenidate", "methylphenidate", "Ritalin", "Concerta"], "CNS stimulant/sympathomimetic", "ADHD/weight management", "stimulant", ["ADHD", "narcolepsy", "short-term weight management for phentermine"], "Agent-specific.", "Agent-specific.", ["blood pressure", "heart rate", "sleep", "appetite/weight", "misuse"], ["misuse/dependence", "cardiovascular effects", "psychiatric effects"], ["MAO inhibitors", "other sympathomimetics"], "Morning dosing; do not crush extended-release products.", "Do not crush extended-release products.", ["stimulant", "tachycardia", "hypertension"])
    CRD5_AddRecord(51, "Venlafaxine", ["Venlafaxine", "venlafaxine", "Effexor"], "serotonin-norepinephrine reuptake inhibitor", "antidepressant/neuropathic pain", "snri", ["depression", "anxiety", "neuropathic pain"], "Dose limits vary; duloxetine has significant severe-renal restrictions.", "Duloxetine requires major hepatic caution.", ["blood pressure", "serotonin toxicity", "withdrawal"], ["serotonin syndrome", "blood pressure elevation", "withdrawal"], ["MAO inhibitors", "other serotonergic drugs", "bleeding-risk drugs"], "Taper rather than abruptly discontinue.", "Do not crush extended-release formulations.", ["serotonergic", "bleeding"])
    CRD5_AddRecord(52, "Spironolactone", ["Spironolactone", "spironolactone", "Aldactone"], "mineralocorticoid receptor antagonist", "potassium-sparing diuretic", "mra", ["heart failure", "resistant hypertension", "hyperaldosteronism"], "Avoid/use cautiously at low eGFR or elevated potassium.", "Agent-specific; assess current labeling and clinical status.", ["potassium", "creatinine", "blood pressure"], ["hyperkalemia"], ["ACEI/ARB/ARNI", "potassium supplements", "TMP-SMX"], "Review all potassium sources.", "Tablets generally crushable; verify product.", ["hyperkalemia", "renal", "diuretic"])
    CRD5_AddRecord(53, "Ondansetron", ["Ondansetron", "ondansetron", "Zofran"], "5-HT3 antagonist", "antiemetic", "antiemetic_qt", ["nausea/vomiting"], "No routine adjustment for most uses.", "Agent-specific; assess current labeling and clinical status.", ["QT risk", "electrolytes", "constipation"], ["QT prolongation"], ["other QT-prolonging drugs"], "Route and indication-specific dose limits.", "ODT should dissolve; verify formulation before crushing.", ["qt", "serotonergic"])
    CRD5_AddRecord(54, "Zolpidem", ["Zolpidem", "zolpidem", "Ambien"], "nonbenzodiazepine hypnotic", "sleep agent", "sedative_hypnotic", ["insomnia"], "Use cautiously in organ dysfunction.", "Agent-specific; assess current labeling and clinical status.", ["next-day impairment", "falls", "complex sleep behaviors"], ["boxed complex sleep-behavior warning"], ["opioids", "alcohol", "other CNS depressants"], "Administer immediately before bed when adequate sleep time is available.", "Do not crush extended-release products.", ["cns_depressant", "fall_risk", "resp_depression"])
    CRD5_AddRecord(55, "Cetirizine", ["Cetirizine", "cetirizine", "Zyrtec"], "second-generation antihistamine", "antiallergic", "antihistamine", ["allergic rhinitis", "urticaria"], "Dose adjust selected agents.", "Agent-specific; assess current labeling and clinical status.", ["sedation for selected agents", "renal function"], ["sedation possible"], ["CNS depressants for sedating agents"], "Product-specific food/antacid separation may apply.", "Product-specific.", [])
    CRD5_AddRecord(56, "Estradiol", ["Estradiol", "estradiol", "Estrace"], "hormonal therapy", "endocrine/reproductive therapy", "hormone", ["agent-specific endocrine or reproductive indication"], "Usually no simple adjustment.", "Avoid/use cautiously in significant hepatic disease depending on agent.", ["indication-specific response", "thrombotic or metabolic risk", "relevant labs"], ["thromboembolism or hormone-sensitive malignancy risk depending on agent"], ["enzyme inducers", "anticoagulants or hormone-sensitive therapies"], "Formulations/routes are not automatically interchangeable.", "Formulation-specific; hazardous-handling may apply.", ["hormone", "thrombosis"])
    CRD5_AddRecord(57, "Pravastatin", ["Pravastatin", "pravastatin", "Pravachol"], "HMG-CoA reductase inhibitor", "lipid lowering", "statin", ["hyperlipidemia", "ASCVD risk reduction"], "Agent-specific; rosuvastatin requires greater renal attention.", "Avoid active liver disease; assess clinically significant hepatic dysfunction.", ["lipid panel", "myalgia/weakness", "hepatic symptoms"], ["myopathy/rhabdomyolysis", "pregnancy avoidance"], ["strong CYP inhibitors for selected statins", "fibrates increase myopathy risk"], "Daily; simvastatin/lovastatin are generally evening-oriented.", "Formulation-specific; do not crush modified-release products.", ["myopathy", "hepatic"])
    CRD5_AddRecord(58, "Hydrochlorothiazide; Lisinopril", ["Hydrochlorothiazide; Lisinopril", "hydrochlorothiazide", "lisinopril", "HCTZ", "Microzide", "Prinivil", "Zestril", "Zestoretic", "Prinzide", "Hydrochlorothiazide/ Lisinopril", "Hydrochlorothiazide +  Lisinopril"], "ACE inhibitor + thiazide/thiazide-like diuretic", "RAAS antihypertensive + antihypertensive/diuretic", "ace_inhibitor", ["hypertension", "heart failure", "albuminuric CKD", "edema"], "Reassess creatinine and potassium after initiation or titration. | Effectiveness and safety depend on renal function.", "Usually no class-wide adjustment; agent-specific. | Monitor electrolytes closely.", ["serum creatinine", "potassium", "blood pressure", "sodium", "magnesium", "uric acid"], ["angioedema", "hyperkalemia", "pregnancy contraindication", "hyponatremia", "hypokalemia", "gout"], ["ARB/ARNI duplication", "potassium sources", "NSAIDs", "lithium", "other antihypertensives"], "Monitor hypotension in volume depletion. | Morning dosing often reduces nocturia.", "Formulation-specific. | Usually immediate-release; verify formulation.", ["raas", "hyperkalemia", "renal", "pregnancy", "diuretic", "hypokalemia", "hyponatremia", "lithium_interaction"])
    CRD5_AddRecord(59, "Lamotrigine", ["Lamotrigine", "lamotrigine", "Lamictal"], "antiepileptic/mood stabilizer", "neurologic", "antiepileptic", ["seizure disorders", "mood stabilization or migraine depending on agent"], "Many agents require renal adjustment.", "Valproate/carbamazepine/lamotrigine require hepatic attention.", ["seizure control", "mood/suicidality", "drug-specific labs/levels"], ["serious rash for selected agents", "teratogenicity varies", "CNS effects"], ["enzyme inducers/inhibitors", "oral contraceptives", "CNS depressants"], "Avoid abrupt discontinuation.", "Do not crush extended-release products.", ["antiepileptic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(60, "Quetiapine", ["Quetiapine", "quetiapine", "Seroquel"], "atypical antipsychotic", "antipsychotic/mood stabilization", "antipsychotic", ["schizophrenia", "bipolar disorder", "selected adjunctive depression"], "Agent-specific.", "Start conservatively.", ["metabolic parameters", "movement disorders", "QT risk", "orthostasis"], ["mortality warning in dementia-related psychosis", "metabolic effects", "NMS/tardive dyskinesia"], ["CNS depressants", "QT-prolonging drugs", "CYP modifiers"], "Formulations are not automatically interchangeable.", "Formulation-specific.", ["antipsychotic", "qt", "cns_depressant", "fall_risk", "metabolic"])
    CRD5_AddRecord(61, "Fluticasone; Salmeterol", ["Fluticasone; Salmeterol", "fluticasone", "salmeterol", "Flonase", "Flovent", "Advair", "Fluticasone/ Salmeterol", "Fluticasone +  Salmeterol"], "inhaled bronchodilator + inhaled/intranasal corticosteroid", "airway therapy + airway anti-inflammatory", "bronchodilator", ["asthma", "COPD", "asthma/COPD maintenance", "allergic rhinitis"], "No routine adjustment. | No routine renal adjustment.", "Usually limited adjustment. | Systemic exposure may increase with strong CYP3A4 inhibitors.", ["symptom control", "heart rate/tremor", "anticholinergic effects", "oral candidiasis", "local nasal effects"], ["tachycardia", "paradoxical bronchospasm", "not a rescue inhaler", "local candidiasis"], ["other sympathomimetics", "anticholinergic burden", "strong CYP3A4 inhibitors"], "Device technique is essential; LABA/LAMA are maintenance, not rescue. | Rinse mouth after inhaled use; technique matters.", "Not applicable.", ["bronchodilator", "tachycardia", "inhaled_steroid"])
    CRD5_AddRecord(62, "Clonazepam", ["Clonazepam", "clonazepam", "Klonopin"], "benzodiazepine", "anxiolytic/sedative", "benzodiazepine", ["anxiety", "acute agitation", "seizure", "alcohol withdrawal"], "Agent/metabolite-specific.", "Lorazepam/oxazepam/temazepam are often preferred in hepatic dysfunction.", ["sedation", "respiratory status", "falls", "withdrawal"], ["respiratory depression", "dependence", "falls/delirium"], ["opioids", "alcohol", "other CNS depressants"], "Avoid abrupt discontinuation after sustained use.", "Formulation-specific.", ["benzodiazepine", "cns_depressant", "fall_risk", "resp_depression"])
    CRD5_AddRecord(63, "Dulaglutide", ["Dulaglutide", "dulaglutide", "Trulicity"], "incretin-based GLP-1 therapy", "diabetes/weight management", "glp1", ["type 2 diabetes", "weight management for selected products"], "No simple class dose rule; dehydration can worsen renal function.", "Usually limited adjustment.", ["glucose", "GI tolerance", "weight", "pancreatitis/gallbladder symptoms"], ["severe GI effects", "pancreatitis warning", "thyroid C-cell tumor warning for selected products"], ["insulin/sulfonylurea hypoglycemia risk", "delayed gastric emptying"], "Follow product-specific titration and oral/injection timing.", "Oral semaglutide must be swallowed whole.", ["glp1", "hypoglycemia", "gi"])
    CRD5_AddRecord(64, "Azithromycin", ["Azithromycin", "azithromycin", "Zithromax", "Z-Pak"], "macrolide antibiotic", "antimicrobial", "macrolide", ["respiratory/atypical infections", "other susceptible infections"], "Azithromycin usually has limited renal adjustment.", "Use caution in significant hepatic disease.", ["QT risk", "hepatic function when indicated", "clinical response"], ["QT prolongation", "hepatotoxicity"], ["QT-prolonging drugs", "CYP3A4 interactions especially erythromycin"], "Formulation-specific antacid separation.", "Formulation-specific.", ["antibiotic", "qt", "hepatic"])
    CRD5_AddRecord(65, "Hydrochlorothiazide; Losartan", ["Hydrochlorothiazide; Losartan", "hydrochlorothiazide", "losartan", "HCTZ", "Microzide", "Cozaar", "Hyzaar", "Hydrochlorothiazide/ Losartan", "Hydrochlorothiazide +  Losartan"], "angiotensin II receptor blocker + thiazide/thiazide-like diuretic", "RAAS antihypertensive + antihypertensive/diuretic", "arb", ["hypertension", "heart failure", "albuminuric CKD", "edema"], "Reassess creatinine and potassium after initiation or titration. | Effectiveness and safety depend on renal function.", "Agent-specific. | Monitor electrolytes closely.", ["serum creatinine", "potassium", "blood pressure", "sodium", "magnesium", "uric acid"], ["hyperkalemia", "pregnancy contraindication", "hyponatremia", "hypokalemia", "gout"], ["ACE inhibitor/ARNI duplication", "potassium sources", "NSAIDs", "lithium", "other antihypertensives"], "Monitor hypotension in volume depletion. | Morning dosing often reduces nocturia.", "Formulation-specific. | Usually immediate-release; verify formulation.", ["raas", "hyperkalemia", "renal", "pregnancy", "diuretic", "hypokalemia", "hyponatremia", "lithium_interaction"])
    CRD5_AddRecord(66, "Amoxicillin; Clavulanate", ["Amoxicillin; Clavulanate", "amoxicillin", "clavulanate", "Amoxil", "Augmentin", "Amoxicillin/ Clavulanate", "Amoxicillin +  Clavulanate"], "penicillin-class antibiotic", "antimicrobial", "penicillin", ["susceptible bacterial infections"], "Most require renal adjustment.", "Amoxicillin/clavulanate requires hepatic review.", ["allergy", "renal function", "clinical response"], ["hypersensitivity", "C. difficile-associated diarrhea"], ["methotrexate", "warfarin monitoring context"], "Food and formulation advice are product-specific.", "Many immediate-release products have liquid alternatives.", ["antibiotic", "beta_lactam", "renal", "allergy"])
    CRD5_AddRecord(67, "Latanoprost", ["Latanoprost", "latanoprost", "Xalatan"], "ophthalmic medication", "ocular therapy", "ophthalmic", ["glaucoma, allergy, infection, or ocular condition depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment for topical use.", ["ocular response", "local irritation", "systemic beta-blockade when relevant"], ["contamination risk", "systemic effects possible with selected agents"], ["other ocular agents; separate drops by several minutes"], "Use proper drop technique and nasolacrimal occlusion when appropriate.", "Not applicable.", ["ophthalmic"])
    CRD5_AddRecord(68, "Cholecalciferol", ["Cholecalciferol", "cholecalciferol"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(69, "Propranolol", ["Propranolol", "propranolol", "Inderal"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(70, "Ezetimibe", ["Ezetimibe", "ezetimibe", "Zetia"], "non-statin lipid-lowering agent", "lipid lowering", "lipid_other", ["hyperlipidemia", "ASCVD risk reduction for selected agents"], "Agent-specific.", "Agent-specific; fibrates/niacin require hepatic attention.", ["lipid panel", "hepatic or muscle symptoms when relevant"], ["myopathy when combined with statins for selected agents", "hepatic effects"], ["statins", "warfarin for selected agents"], "Product-specific food and formulation directions.", "Formulation-specific.", ["lipid", "myopathy", "hepatic"])
    CRD5_AddRecord(71, "Topiramate", ["Topiramate", "topiramate", "Topamax"], "antiepileptic/mood stabilizer", "neurologic", "antiepileptic", ["seizure disorders", "mood stabilization or migraine depending on agent"], "Many agents require renal adjustment.", "Valproate/carbamazepine/lamotrigine require hepatic attention.", ["seizure control", "mood/suicidality", "drug-specific labs/levels"], ["serious rash for selected agents", "teratogenicity varies", "CNS effects"], ["enzyme inducers/inhibitors", "oral contraceptives", "CNS depressants"], "Avoid abrupt discontinuation.", "Do not crush extended-release products.", ["antiepileptic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(72, "Paroxetine", ["Paroxetine", "paroxetine", "Paxil"], "selective serotonin reuptake inhibitor", "antidepressant", "ssri", ["depression", "anxiety disorders"], "Agent-specific.", "Lower or less-frequent dosing may be needed.", ["suicidality during initiation/change", "serotonin toxicity", "sodium in at-risk patients"], ["serotonin syndrome", "hyponatremia", "bleeding risk"], ["MAO inhibitors", "other serotonergic drugs", "anticoagulants/antiplatelets"], "Taper rather than abruptly discontinue when feasible.", "Do not crush modified-release products.", ["serotonergic", "bleeding", "hyponatremia"])
    CRD5_AddRecord(73, "Diclofenac", ["Diclofenac", "diclofenac", "Voltaren"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(74, "Budesonide; Formoterol", ["Budesonide; Formoterol", "budesonide", "formoterol", "Symbicort", "Budesonide/ Formoterol", "Budesonide +  Formoterol"], "inhaled bronchodilator + inhaled/intranasal corticosteroid", "airway therapy + airway anti-inflammatory", "bronchodilator", ["asthma", "COPD", "asthma/COPD maintenance", "allergic rhinitis"], "No routine adjustment. | No routine renal adjustment.", "Usually limited adjustment. | Systemic exposure may increase with strong CYP3A4 inhibitors.", ["symptom control", "heart rate/tremor", "anticholinergic effects", "oral candidiasis", "local nasal effects"], ["tachycardia", "paradoxical bronchospasm", "not a rescue inhaler", "local candidiasis"], ["other sympathomimetics", "anticholinergic burden", "strong CYP3A4 inhibitors"], "Device technique is essential; LABA/LAMA are maintenance, not rescue. | Rinse mouth after inhaled use; technique matters.", "Not applicable.", ["bronchodilator", "tachycardia", "inhaled_steroid"])
    CRD5_AddRecord(75, "Atenolol", ["Atenolol", "atenolol", "Tenormin"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(76, "Lisdexamfetamine", ["Lisdexamfetamine", "lisdexamfetamine", "Vyvanse"], "CNS stimulant/sympathomimetic", "ADHD/weight management", "stimulant", ["ADHD", "narcolepsy", "short-term weight management for phentermine"], "Agent-specific.", "Agent-specific.", ["blood pressure", "heart rate", "sleep", "appetite/weight", "misuse"], ["misuse/dependence", "cardiovascular effects", "psychiatric effects"], ["MAO inhibitors", "other sympathomimetics"], "Morning dosing; do not crush extended-release products.", "Do not crush extended-release products.", ["stimulant", "tachycardia", "hypertension"])
    CRD5_AddRecord(77, "Doxycycline", ["Doxycycline", "doxycycline", "Vibramycin"], "cephalosporin antibiotic", "antimicrobial", "cephalosporin", ["susceptible bacterial infections"], "Most require renal adjustment.", "Usually limited adjustment.", ["allergy", "renal function", "clinical response"], ["hypersensitivity", "C. difficile-associated diarrhea"], ["warfarin monitoring context"], "Food/suspension handling is formulation-specific.", "Many immediate-release products have liquid alternatives.", ["antibiotic", "beta_lactam", "renal", "allergy"])
    CRD5_AddRecord(78, "Pregabalin", ["Pregabalin", "pregabalin", "Lyrica"], "gabapentinoid", "neuropathic pain/antiepileptic", "gabapentinoid", ["neuropathic pain", "seizure adjunct"], "Requires renal dose adjustment.", "Limited metabolism.", ["sedation", "edema", "misuse", "respiratory depression with opioids"], ["sedation", "respiratory depression with CNS depressants"], ["opioids", "other CNS depressants"], "Taper after sustained use.", "Do not crush extended-release products.", ["gabapentinoid", "cns_depressant", "resp_depression", "renal"])
    CRD5_AddRecord(79, "Ethinyl Estradiol; Norethindrone", ["Ethinyl Estradiol; Norethindrone", "ethinyl estradiol", "norethindrone", "Ethinyl Estradiol/ Norethindrone", "Ethinyl Estradiol +  Norethindrone"], "hormonal therapy + combined or progestin hormonal contraceptive", "endocrine/reproductive therapy + contraception/hormonal therapy", "hormone", ["agent-specific endocrine or reproductive indication", "contraception", "cycle control"], "Usually no simple adjustment. | Product-specific; drospirenone has potassium considerations.", "Avoid/use cautiously in significant hepatic disease depending on agent. | Avoid significant hepatic disease.", ["indication-specific response", "thrombotic or metabolic risk", "relevant labs", "blood pressure", "thrombotic risk", "adherence"], ["thromboembolism or hormone-sensitive malignancy risk depending on agent", "thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["enzyme inducers", "anticoagulants or hormone-sensitive therapies", "strong enzyme inducers", "selected antiepileptics"], "Formulations/routes are not automatically interchangeable. | Consistent daily use; missed-dose instructions are product-specific.", "Formulation-specific; hazardous-handling may apply. | Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(80, "Glimepiride", ["Glimepiride", "glimepiride", "Amaryl"], "sulfonylurea", "oral antihyperglycemic", "sulfonylurea", ["type 2 diabetes"], "Hypoglycemia risk increases with renal dysfunction.", "Use cautiously.", ["glucose", "hypoglycemia", "weight"], ["prolonged hypoglycemia"], ["other glucose-lowering drugs", "agents masking hypoglycemia"], "Coordinate with meals.", "Do not crush extended-release formulations.", ["hypoglycemia"])
    CRD5_AddRecord(81, "Tizanidine", ["Tizanidine", "tizanidine", "Zanaflex"], "centrally acting muscle relaxant", "musculoskeletal", "muscle_relaxant", ["muscle spasm", "spasticity depending on agent"], "Baclofen requires major renal caution.", "Tizanidine requires hepatic monitoring.", ["sedation", "falls", "blood pressure", "withdrawal"], ["sedation", "falls", "withdrawal"], ["opioids", "benzodiazepines", "other CNS depressants"], "Avoid abrupt stop after sustained baclofen/tizanidine.", "Formulation-specific.", ["cns_depressant", "fall_risk"])
    CRD5_AddRecord(82, "Clonidine", ["Clonidine", "clonidine", "Catapres"], "central alpha-2 agonist", "antihypertensive/ADHD", "central_alpha2", ["hypertension", "ADHD depending on product"], "Agent-specific.", "Agent-specific; assess current labeling and clinical status.", ["blood pressure", "heart rate", "sedation"], ["rebound hypertension with abrupt stop"], ["CNS depressants", "other antihypertensives"], "Taper rather than abruptly discontinue.", "Do not crush extended-release products.", ["bradycardia", "cns_depressant", "hypotension"])
    CRD5_AddRecord(83, "Fenofibrate", ["Fenofibrate", "fenofibrate", "Tricor"], "non-statin lipid-lowering agent", "lipid lowering", "lipid_other", ["hyperlipidemia", "ASCVD risk reduction for selected agents"], "Agent-specific.", "Agent-specific; fibrates/niacin require hepatic attention.", ["lipid panel", "hepatic or muscle symptoms when relevant"], ["myopathy when combined with statins for selected agents", "hepatic effects"], ["statins", "warfarin for selected agents"], "Product-specific food and formulation directions.", "Formulation-specific.", ["lipid", "myopathy", "hepatic"])
    CRD5_AddRecord(84, "Insulin Lispro", ["Insulin Lispro", "insulin lispro", "Humalog"], "insulin", "antihyperglycemic", "insulin", ["diabetes", "hyperglycemia", "critical-care protocols for selected products"], "Requirements often decrease as renal function declines.", "Requirements may change.", ["blood glucose", "potassium in IV protocols", "hypoglycemia"], ["hypoglycemia", "hypokalemia", "medication errors"], ["other glucose-lowering drugs", "beta blockers may mask symptoms"], "Verify product, concentration, route, and meal timing; never interchange blindly.", "Not applicable.", ["insulin", "hypoglycemia", "potassium"])
    CRD5_AddRecord(85, "Valsartan", ["Valsartan", "valsartan", "Diovan"], "angiotensin II receptor blocker", "RAAS antihypertensive", "arb", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["hyperkalemia", "pregnancy contraindication"], ["ACE inhibitor/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(86, "Cephalexin", ["Cephalexin", "cephalexin", "Keflex"], "cephalosporin antibiotic", "antimicrobial", "cephalosporin", ["susceptible bacterial infections"], "Most require renal adjustment.", "Usually limited adjustment.", ["allergy", "renal function", "clinical response"], ["hypersensitivity", "C. difficile-associated diarrhea"], ["warfarin monitoring context"], "Food/suspension handling is formulation-specific.", "Many immediate-release products have liquid alternatives.", ["antibiotic", "beta_lactam", "renal", "allergy"])
    CRD5_AddRecord(87, "Baclofen", ["Baclofen", "baclofen", "Lioresal"], "centrally acting muscle relaxant", "musculoskeletal", "muscle_relaxant", ["muscle spasm", "spasticity depending on agent"], "Baclofen requires major renal caution.", "Tizanidine requires hepatic monitoring.", ["sedation", "falls", "blood pressure", "withdrawal"], ["sedation", "falls", "withdrawal"], ["opioids", "benzodiazepines", "other CNS depressants"], "Avoid abrupt stop after sustained baclofen/tizanidine.", "Formulation-specific.", ["cns_depressant", "fall_risk"])
    CRD5_AddRecord(88, "Rivaroxaban", ["Rivaroxaban", "rivaroxaban", "Xarelto"], "oral anticoagulant", "anticoagulation", "anticoagulant", ["atrial fibrillation stroke prevention", "VTE treatment/prevention"], "Indication- and agent-specific renal criteria.", "Avoid significant hepatic coagulopathy; agent-specific.", ["bleeding", "renal function", "CBC", "adherence"], ["major bleeding", "neuraxial hematoma warning"], ["antiplatelets", "NSAIDs", "strong CYP/P-gp modifiers"], "Dose depends on indication; do not infer from drug name alone.", "Agent/formulation-specific.", ["anticoagulant", "bleeding", "renal"])
    CRD5_AddRecord(89, "Ferrous Sulfate", ["Ferrous Sulfate", "ferrous sulfate"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(90, "Amitriptyline", ["Amitriptyline", "amitriptyline", "Elavil"], "tricyclic antidepressant", "antidepressant/neuropathic pain", "tca", ["depression", "neuropathic pain", "sleep-related off-label use"], "Usually no simple adjustment; use cautiously.", "Start conservatively.", ["sedation", "orthostasis", "anticholinergic effects", "QT/conduction risk"], ["overdose cardiotoxicity", "falls", "anticholinergic burden"], ["MAO inhibitors", "other serotonergic/CNS depressant drugs", "QT-prolonging drugs"], "Often dosed at night because of sedation.", "Formulation-specific.", ["serotonergic", "anticholinergic", "cns_depressant", "qt", "fall_risk"])
    CRD5_AddRecord(91, "Finasteride", ["Finasteride", "finasteride", "Proscar", "Propecia"], "5-alpha-reductase inhibitor", "BPH/alopecia", "five_alpha_reductase", ["BPH", "androgenic alopecia for selected products"], "No routine adjustment.", "Agent-specific; assess current labeling and clinical status.", ["PSA interpretation", "symptom response"], ["pregnancy exposure handling warning"], ["few major interactions"], "Pregnant persons should not handle crushed/broken tablets.", "Do not crush; handling precautions apply.", ["hazardous"])
    CRD5_AddRecord(92, "Dapagliflozin", ["Dapagliflozin", "dapagliflozin", "Farxiga"], "SGLT2 inhibitor", "diabetes/cardiorenal therapy", "sglt2", ["type 2 diabetes", "heart failure", "CKD"], "Indication-specific eGFR thresholds; verify current labeling.", "Usually limited adjustment.", ["renal function", "volume status", "ketones when ill", "genital infections"], ["euglycemic ketoacidosis", "volume depletion", "genital infection"], ["diuretics", "insulin/sulfonylureas"], "Hold around major surgery/prolonged fasting or severe illness per protocol.", "Product-specific.", ["sglt2", "renal", "volume_depletion", "ketoacidosis", "hypoglycemia"])
    CRD5_AddRecord(93, "Acetaminophen; Oxycodone", ["Acetaminophen; Oxycodone", "acetaminophen", "oxycodone", "Tylenol", "APAP", "Roxicodone", "OxyContin", "Percocet", "Acetaminophen/ Oxycodone", "Acetaminophen +  Oxycodone"], "opioid agonist + nonopioid analgesic or combination analgesic", "analgesic + pain/headache therapy", "opioid", ["moderate to severe pain", "pain", "fever", "headache"], "Metabolite accumulation varies; morphine requires high renal caution. | Usually limited adjustment, but chronic/high exposure requires caution.", "Start conservatively. | Acetaminophen total daily exposure is critical in hepatic risk.", ["pain response", "sedation", "respiratory rate", "bowel function", "total acetaminophen exposure", "sedation for butalbital combinations", "headache frequency"], ["respiratory depression", "dependence", "overdose", "hepatotoxicity", "medication-overuse headache", "sedation/dependence with butalbital"], ["benzodiazepines", "alcohol", "other CNS depressants", "serotonergic drugs for tramadol", "warfarin with sustained high acetaminophen exposure", "CNS depressants"], "Use bowel regimen when appropriate; never crush ER products. | Count all combination-product acetaminophen.", "Never crush extended-release or abuse-deterrent products. | Formulation-specific.", ["opioid", "cns_depressant", "resp_depression", "constipation", "acetaminophen"])
    CRD5_AddRecord(94, "Folic Acid", ["Folic Acid", "folic acid"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(95, "Aripiprazole", ["Aripiprazole", "aripiprazole", "Abilify"], "atypical antipsychotic", "antipsychotic/mood stabilization", "antipsychotic", ["schizophrenia", "bipolar disorder", "selected adjunctive depression"], "Agent-specific.", "Start conservatively.", ["metabolic parameters", "movement disorders", "QT risk", "orthostasis"], ["mortality warning in dementia-related psychosis", "metabolic effects", "NMS/tardive dyskinesia"], ["CNS depressants", "QT-prolonging drugs", "CYP modifiers"], "Formulations are not automatically interchangeable.", "Formulation-specific.", ["antipsychotic", "qt", "cns_depressant", "fall_risk", "metabolic"])
    CRD5_AddRecord(96, "Olmesartan", ["Olmesartan", "olmesartan", "Benicar"], "angiotensin II receptor blocker", "RAAS antihypertensive", "arb", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["hyperkalemia", "pregnancy contraindication"], ["ACE inhibitor/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(97, "Ethinyl Estradiol; Norgestimate", ["Ethinyl Estradiol; Norgestimate", "ethinyl estradiol", "norgestimate", "Ethinyl Estradiol/ Norgestimate", "Ethinyl Estradiol +  Norgestimate"], "combined or progestin hormonal contraceptive", "contraception/hormonal therapy", "contraceptive", ["contraception", "cycle control"], "Product-specific; drospirenone has potassium considerations.", "Avoid significant hepatic disease.", ["blood pressure", "thrombotic risk", "adherence"], ["thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["strong enzyme inducers", "selected antiepileptics"], "Consistent daily use; missed-dose instructions are product-specific.", "Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(98, "Valacyclovir", ["Valacyclovir", "valacyclovir", "Valtrex"], "antiviral", "antiviral", "antiviral", ["virus-specific treatment/prophylaxis"], "Many require renal adjustment.", "Ritonavir-containing regimens require hepatic and interaction review.", ["renal function", "interaction burden", "virus-specific response"], ["drug interactions", "renal toxicity for selected agents"], ["nirmatrelvir/ritonavir has extensive CYP3A interaction burden", "nephrotoxins with acyclovir/tenofovir"], "Timing and duration are indication-specific.", "Formulation-specific.", ["antiviral", "renal", "cyp3a4"])
    CRD5_AddRecord(99, "Mirtazapine", ["Mirtazapine", "mirtazapine", "Remeron"], "other antidepressant", "antidepressant", "other_antidepressant", ["depression"], "Agent-specific.", "Agent-specific; assess current labeling and clinical status.", ["mood/suicidality", "sedation or activation", "drug-specific effects"], ["drug-specific seizure, sedation, or metabolic risks"], ["MAO inhibitors and other CNS/serotonergic agents"], "Formulation-specific.", "Do not crush modified-release products.", ["cns_depressant"])
    CRD5_AddRecord(100, "Lorazepam", ["Lorazepam", "lorazepam", "Ativan"], "benzodiazepine", "anxiolytic/sedative", "benzodiazepine", ["anxiety", "acute agitation", "seizure", "alcohol withdrawal"], "Agent/metabolite-specific.", "Lorazepam/oxazepam/temazepam are often preferred in hepatic dysfunction.", ["sedation", "respiratory status", "falls", "withdrawal"], ["respiratory depression", "dependence", "falls/delirium"], ["opioids", "alcohol", "other CNS depressants"], "Avoid abrupt discontinuation after sustained use.", "Formulation-specific.", ["benzodiazepine", "cns_depressant", "fall_risk", "resp_depression"])
    CRD5_AddRecord(101, "Levetiracetam", ["Levetiracetam", "levetiracetam", "Keppra"], "antiepileptic/mood stabilizer", "neurologic", "antiepileptic", ["seizure disorders", "mood stabilization or migraine depending on agent"], "Many agents require renal adjustment.", "Valproate/carbamazepine/lamotrigine require hepatic attention.", ["seizure control", "mood/suicidality", "drug-specific labs/levels"], ["serious rash for selected agents", "teratogenicity varies", "CNS effects"], ["enzyme inducers/inhibitors", "oral contraceptives", "CNS depressants"], "Avoid abrupt discontinuation.", "Do not crush extended-release products.", ["antiepileptic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(102, "Insulin Aspart", ["Insulin Aspart", "insulin aspart", "NovoLog"], "insulin", "antihyperglycemic", "insulin", ["diabetes", "hyperglycemia", "critical-care protocols for selected products"], "Requirements often decrease as renal function declines.", "Requirements may change.", ["blood glucose", "potassium in IV protocols", "hypoglycemia"], ["hypoglycemia", "hypokalemia", "medication errors"], ["other glucose-lowering drugs", "beta blockers may mask symptoms"], "Verify product, concentration, route, and meal timing; never interchange blindly.", "Not applicable.", ["insulin", "hypoglycemia", "potassium"])
    CRD5_AddRecord(103, "Naproxen", ["Naproxen", "naproxen", "Naprosyn", "Aleve"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(104, "Cyanocobalamin", ["Cyanocobalamin", "cyanocobalamin"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(105, "Loratadine", ["Loratadine", "loratadine"], "second-generation antihistamine", "antiallergic", "antihistamine", ["allergic rhinitis", "urticaria"], "Dose adjust selected agents.", "Agent-specific; assess current labeling and clinical status.", ["sedation for selected agents", "renal function"], ["sedation possible"], ["CNS depressants for sedating agents"], "Product-specific food/antacid separation may apply.", "Product-specific.", [])
    CRD5_AddRecord(106, "Diltiazem", ["Diltiazem", "diltiazem", "Cardizem"], "non-dihydropyridine calcium channel blocker", "rate control/antihypertensive", "non_dhp_ccb", ["atrial arrhythmia rate control", "angina", "hypertension"], "Usually limited renal adjustment.", "Dose conservatively in hepatic impairment.", ["heart rate", "blood pressure", "PR interval"], ["bradycardia", "heart block", "worsening HFrEF"], ["beta blockers", "other AV nodal blockers", "CYP3A4 substrates"], "Extended-release products must not be crushed.", "Do not crush extended-release products.", ["bradycardia", "av_node", "cyp3a4"])
    CRD5_AddRecord(107, "Sumatriptan", ["Sumatriptan", "sumatriptan", "Imitrex"], "serotonin 5-HT1B/1D agonist", "acute migraine therapy", "triptan", ["acute migraine"], "Agent-specific.", "Dose limits vary.", ["response", "blood pressure", "frequency of use"], ["vasoconstriction", "medication-overuse headache"], ["ergot drugs", "MAO inhibitors for selected agents", "serotonergic drugs"], "Not for routine prevention; observe maximum daily limits.", "Formulation-specific.", ["serotonergic", "vasoconstrictor"])
    CRD5_AddRecord(108, "Triamcinolone", ["Triamcinolone", "triamcinolone"], "topical corticosteroid", "dermatologic anti-inflammatory", "topical_steroid", ["inflammatory dermatoses"], "No routine adjustment.", "No routine adjustment.", ["skin atrophy", "treatment area/duration", "infection"], ["skin atrophy", "systemic absorption with extensive/high-potency use"], ["other local irritants"], "Use the lowest effective potency and duration; avoid inappropriate occlusion.", "Not applicable.", ["topical_steroid"])
    CRD5_AddRecord(109, "Hydralazine", ["Hydralazine", "hydralazine"], "medication", "general therapy", "general", ["indication-specific therapy"], "Review current product labeling and patient renal function when clinically relevant.", "Review current product labeling and hepatic function when clinically relevant.", ["clinical response", "adverse effects", "dose/route/frequency completeness"], ["Review contraindications, major warnings, and patient-specific precautions."], ["Review the complete medication list for clinically significant interactions."], "Use indication-, route-, and formulation-specific administration instructions.", "Formulation-specific; extended-release, delayed-release, enteric-coated, hazardous, and special-delivery products require explicit review.", [])
    CRD5_AddRecord(110, "Tirzepatide", ["Tirzepatide", "tirzepatide", "Mounjaro", "Zepbound"], "incretin-based GLP-1 therapy", "diabetes/weight management", "glp1", ["type 2 diabetes", "weight management for selected products"], "No simple class dose rule; dehydration can worsen renal function.", "Usually limited adjustment.", ["glucose", "GI tolerance", "weight", "pancreatitis/gallbladder symptoms"], ["severe GI effects", "pancreatitis warning", "thyroid C-cell tumor warning for selected products"], ["insulin/sulfonylurea hypoglycemia risk", "delayed gastric emptying"], "Follow product-specific titration and oral/injection timing.", "Oral semaglutide must be swallowed whole.", ["glp1", "hypoglycemia", "gi"])
    CRD5_AddRecord(111, "Celecoxib", ["Celecoxib", "celecoxib", "Celebrex"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(112, "Acetaminophen", ["Acetaminophen", "acetaminophen", "Tylenol", "APAP"], "nonopioid analgesic or combination analgesic", "pain/headache therapy", "analgesic_nonopioid", ["pain", "fever", "headache"], "Usually limited adjustment, but chronic/high exposure requires caution.", "Acetaminophen total daily exposure is critical in hepatic risk.", ["total acetaminophen exposure", "sedation for butalbital combinations", "headache frequency"], ["hepatotoxicity", "medication-overuse headache", "sedation/dependence with butalbital"], ["alcohol", "warfarin with sustained high acetaminophen exposure", "CNS depressants"], "Count all combination-product acetaminophen.", "Formulation-specific.", ["acetaminophen", "cns_depressant"])
    CRD5_AddRecord(113, "Alendronate", ["Alendronate", "alendronate", "Fosamax"], "bisphosphonate", "osteoporosis therapy", "bisphosphonate", ["osteoporosis"], "Avoid below product-specific renal thresholds.", "Agent-specific; assess current labeling and clinical status.", ["renal function", "calcium/vitamin D", "esophageal symptoms"], ["esophagitis", "osteonecrosis of jaw", "atypical fracture"], ["calcium/iron/antacids"], "Take fasting with plain water and remain upright.", "Do not crush because of upper-GI injury risk.", ["renal", "cation_interaction"])
    CRD5_AddRecord(114, "Oxybutynin", ["Oxybutynin", "oxybutynin", "Ditropan"], "anticholinergic agent", "symptom-specific", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk"], ["other anticholinergics", "CNS depressants"], "Avoid unnecessary cumulative anticholinergic burden.", "Do not crush extended-release products.", ["anticholinergic", "fall_risk", "constipation"])
    CRD5_AddRecord(115, "Hydrochlorothiazide; Triamterene", ["Hydrochlorothiazide; Triamterene", "hydrochlorothiazide", "triamterene", "HCTZ", "Microzide", "Hydrochlorothiazide/ Triamterene", "Hydrochlorothiazide +  Triamterene"], "thiazide/thiazide-like diuretic", "antihypertensive/diuretic", "thiazide", ["hypertension", "edema"], "Effectiveness and safety depend on renal function.", "Monitor electrolytes closely.", ["sodium", "potassium", "magnesium", "uric acid", "blood pressure"], ["hyponatremia", "hypokalemia", "gout"], ["lithium", "NSAIDs", "other antihypertensives"], "Morning dosing often reduces nocturia.", "Usually immediate-release; verify formulation.", ["diuretic", "hypokalemia", "hyponatremia", "lithium_interaction"])
    CRD5_AddRecord(116, "Warfarin", ["Warfarin", "warfarin", "Coumadin", "Jantoven"], "oral anticoagulant", "anticoagulation", "anticoagulant", ["atrial fibrillation stroke prevention", "VTE treatment/prevention"], "Indication- and agent-specific renal criteria.", "Avoid significant hepatic coagulopathy; agent-specific.", ["bleeding", "renal function", "CBC", "adherence"], ["major bleeding", "neuraxial hematoma warning"], ["antiplatelets", "NSAIDs", "strong CYP/P-gp modifiers"], "Dose depends on indication; do not infer from drug name alone.", "Agent/formulation-specific.", ["anticoagulant", "bleeding", "renal"])
    CRD5_AddRecord(117, "Progesterone", ["Progesterone", "progesterone"], "hormonal therapy", "endocrine/reproductive therapy", "hormone", ["agent-specific endocrine or reproductive indication"], "Usually no simple adjustment.", "Avoid/use cautiously in significant hepatic disease depending on agent.", ["indication-specific response", "thrombotic or metabolic risk", "relevant labs"], ["thromboembolism or hormone-sensitive malignancy risk depending on agent"], ["enzyme inducers", "anticoagulants or hormone-sensitive therapies"], "Formulations/routes are not automatically interchangeable.", "Formulation-specific; hazardous-handling may apply.", ["hormone", "thrombosis"])
    CRD5_AddRecord(118, "Fluticasone; Umeclidinium; Vilanterol", ["Fluticasone; Umeclidinium; Vilanterol", "fluticasone", "umeclidinium", "vilanterol", "Flonase", "Flovent", "Trelegy Ellipta", "Fluticasone/ Umeclidinium/ Vilanterol", "Fluticasone +  Umeclidinium +  Vilanterol"], "inhaled bronchodilator + inhaled/intranasal corticosteroid", "airway therapy + airway anti-inflammatory", "bronchodilator", ["asthma", "COPD", "asthma/COPD maintenance", "allergic rhinitis"], "No routine adjustment. | No routine renal adjustment.", "Usually limited adjustment. | Systemic exposure may increase with strong CYP3A4 inhibitors.", ["symptom control", "heart rate/tremor", "anticholinergic effects", "oral candidiasis", "local nasal effects"], ["tachycardia", "paradoxical bronchospasm", "not a rescue inhaler", "local candidiasis"], ["other sympathomimetics", "anticholinergic burden", "strong CYP3A4 inhibitors"], "Device technique is essential; LABA/LAMA are maintenance, not rescue. | Rinse mouth after inhaled use; technique matters.", "Not applicable.", ["bronchodilator", "tachycardia", "inhaled_steroid"])
    CRD5_AddRecord(119, "Testosterone", ["Testosterone", "testosterone"], "hormonal therapy", "endocrine/reproductive therapy", "hormone", ["agent-specific endocrine or reproductive indication"], "Usually no simple adjustment.", "Avoid/use cautiously in significant hepatic disease depending on agent.", ["indication-specific response", "thrombotic or metabolic risk", "relevant labs"], ["thromboembolism or hormone-sensitive malignancy risk depending on agent"], ["enzyme inducers", "anticoagulants or hormone-sensitive therapies"], "Formulations/routes are not automatically interchangeable.", "Formulation-specific; hazardous-handling may apply.", ["hormone", "thrombosis"])
    CRD5_AddRecord(120, "Nifedipine", ["Nifedipine", "nifedipine", "Procardia"], "dihydropyridine calcium channel blocker", "antihypertensive", "dhp_ccb", ["hypertension", "angina"], "Usually no major renal adjustment.", "Start conservatively in significant hepatic impairment.", ["blood pressure", "peripheral edema"], ["hypotension", "peripheral edema"], ["other antihypertensives", "CYP3A4 modifiers"], "Do not crush extended-release products.", "Do not crush extended-release products.", ["hypotension"])
    CRD5_AddRecord(121, "Methocarbamol", ["Methocarbamol", "methocarbamol", "Robaxin"], "centrally acting muscle relaxant", "musculoskeletal", "muscle_relaxant", ["muscle spasm", "spasticity depending on agent"], "Baclofen requires major renal caution.", "Tizanidine requires hepatic monitoring.", ["sedation", "falls", "blood pressure", "withdrawal"], ["sedation", "falls", "withdrawal"], ["opioids", "benzodiazepines", "other CNS depressants"], "Avoid abrupt stop after sustained baclofen/tizanidine.", "Formulation-specific.", ["cns_depressant", "fall_risk"])
    CRD5_AddRecord(122, "Benzonatate", ["Benzonatate", "benzonatate", "Tessalon"], "cough/cold symptomatic therapy", "respiratory symptom relief", "cough_cold", ["cough", "congestion", "upper-respiratory symptoms"], "Agent-specific.", "Agent-specific.", ["sedation", "blood pressure/heart rate", "duplicate ingredients"], ["sedation or hypertension depending on ingredient"], ["MAO inhibitors for decongestants/dextromethorphan", "CNS depressants"], "Avoid duplicate combination-product ingredients.", "Formulation-specific.", ["cns_depressant", "stimulant"])
    CRD5_AddRecord(123, "Sitagliptin", ["Sitagliptin", "sitagliptin", "Januvia"], "DPP-4 inhibitor", "oral antihyperglycemic", "dpp4", ["type 2 diabetes"], "Sitagliptin requires renal adjustment; linagliptin generally does not.", "Agent-specific.", ["glucose", "pancreatitis symptoms", "heart failure symptoms for selected agents"], ["pancreatitis warning", "severe joint pain"], ["other glucose-lowering drugs"], "Once-daily oral therapy.", "Product-specific.", ["hypoglycemia"])
    CRD5_AddRecord(124, "Chlorthalidone", ["Chlorthalidone", "chlorthalidone"], "thiazide/thiazide-like diuretic", "antihypertensive/diuretic", "thiazide", ["hypertension", "edema"], "Effectiveness and safety depend on renal function.", "Monitor electrolytes closely.", ["sodium", "potassium", "magnesium", "uric acid", "blood pressure"], ["hyponatremia", "hypokalemia", "gout"], ["lithium", "NSAIDs", "other antihypertensives"], "Morning dosing often reduces nocturia.", "Usually immediate-release; verify formulation.", ["diuretic", "hypokalemia", "hyponatremia", "lithium_interaction"])
    CRD5_AddRecord(125, "Isosorbide", ["Isosorbide", "isosorbide"], "organic nitrate", "antianginal/vasodilator", "nitrate", ["angina", "heart failure adjunct for selected regimens"], "Usually limited adjustment.", "Agent-specific; assess current labeling and clinical status.", ["blood pressure", "headache", "tolerance"], ["severe hypotension"], ["PDE-5 inhibitors", "riociguat"], "Use nitrate-free interval for chronic formulations when applicable.", "Do not crush extended-release products.", ["hypotension", "nitrate"])
    CRD5_AddRecord(126, "Donepezil", ["Donepezil", "donepezil", "Aricept"], "acetylcholinesterase inhibitor", "dementia therapy", "cholinesterase_inhibitor", ["Alzheimer disease"], "Agent-specific.", "Agent-specific; assess current labeling and clinical status.", ["heart rate", "weight", "GI effects", "syncope"], ["bradycardia/syncope"], ["anticholinergics", "other bradycardic drugs"], "Administer consistently; ODT available.", "Do not crush extended-release products.", ["bradycardia", "fall_risk"])
    CRD5_AddRecord(127, "Dexmethylphenidate", ["Dexmethylphenidate", "dexmethylphenidate"], "CNS stimulant/sympathomimetic", "ADHD/weight management", "stimulant", ["ADHD", "narcolepsy", "short-term weight management for phentermine"], "Agent-specific.", "Agent-specific.", ["blood pressure", "heart rate", "sleep", "appetite/weight", "misuse"], ["misuse/dependence", "cardiovascular effects", "psychiatric effects"], ["MAO inhibitors", "other sympathomimetics"], "Morning dosing; do not crush extended-release products.", "Do not crush extended-release products.", ["stimulant", "tachycardia", "hypertension"])
    CRD5_AddRecord(128, "Sulfamethoxazole; Trimethoprim", ["Sulfamethoxazole; Trimethoprim", "sulfamethoxazole", "trimethoprim", "Bactrim", "Septra", "TMP", "Sulfamethoxazole/ Trimethoprim", "Sulfamethoxazole +  Trimethoprim", "TMP-SMX", "SMX-TMP"], "sulfonamide/folate antagonist antibiotic", "antimicrobial", "sulfa_antibiotic", ["UTI", "skin infection", "Pneumocystis treatment/prophylaxis"], "Requires renal adjustment.", "Avoid severe hepatic dysfunction.", ["renal function", "potassium", "CBC", "rash"], ["severe cutaneous reactions", "hyperkalemia", "marrow suppression"], ["warfarin", "ACEI/ARB/spironolactone", "methotrexate"], "Ensure hydration when appropriate.", "Tablets are generally crushable; verify formulation.", ["antibiotic", "renal", "hyperkalemia", "marrow", "sulfa"])
    CRD5_AddRecord(129, "Clobetasol", ["Clobetasol", "clobetasol"], "topical corticosteroid", "dermatologic anti-inflammatory", "topical_steroid", ["inflammatory dermatoses"], "No routine adjustment.", "No routine adjustment.", ["skin atrophy", "treatment area/duration", "infection"], ["skin atrophy", "systemic absorption with extensive/high-potency use"], ["other local irritants"], "Use the lowest effective potency and duration; avoid inappropriate occlusion.", "Not applicable.", ["topical_steroid"])
    CRD5_AddRecord(130, "Methotrexate", ["Methotrexate", "methotrexate", "Trexall"], "immunomodulator/immunosuppressant", "rheumatology/transplant/immune therapy", "immunosuppressant", ["agent-specific inflammatory or transplant indications"], "Agent-specific; methotrexate/cyclosporine require major attention.", "Agent-specific; methotrexate requires major hepatic attention.", ["CBC", "hepatic/renal function as applicable", "infection", "agent-specific toxicity"], ["serious infection", "malignancy warnings for selected agents", "organ toxicity"], ["live vaccines", "other immunosuppressants", "agent-specific CYP or antifolate interactions"], "Verify weekly versus daily schedules and formulation-specific instructions.", "Hazardous-handling and formulation-specific review required.", ["immunosuppressant", "infection", "hazardous"])
    CRD5_AddRecord(131, "Hydroxychloroquine", ["Hydroxychloroquine", "hydroxychloroquine", "Plaquenil"], "immunomodulator/immunosuppressant", "rheumatology/transplant/immune therapy", "immunosuppressant", ["agent-specific inflammatory or transplant indications"], "Agent-specific; methotrexate/cyclosporine require major attention.", "Agent-specific; methotrexate requires major hepatic attention.", ["CBC", "hepatic/renal function as applicable", "infection", "agent-specific toxicity"], ["serious infection", "malignancy warnings for selected agents", "organ toxicity"], ["live vaccines", "other immunosuppressants", "agent-specific CYP or antifolate interactions"], "Verify weekly versus daily schedules and formulation-specific instructions.", "Hazardous-handling and formulation-specific review required.", ["immunosuppressant", "infection", "hazardous"])
    CRD5_AddRecord(132, "Lovastatin", ["Lovastatin", "lovastatin"], "HMG-CoA reductase inhibitor", "lipid lowering", "statin", ["hyperlipidemia", "ASCVD risk reduction"], "Agent-specific; rosuvastatin requires greater renal attention.", "Avoid active liver disease; assess clinically significant hepatic dysfunction.", ["lipid panel", "myalgia/weakness", "hepatic symptoms"], ["myopathy/rhabdomyolysis", "pregnancy avoidance"], ["strong CYP inhibitors for selected statins", "fibrates increase myopathy risk"], "Daily; simvastatin/lovastatin are generally evening-oriented.", "Formulation-specific; do not crush modified-release products.", ["myopathy", "hepatic"])
    CRD5_AddRecord(133, "Pioglitazone", ["Pioglitazone", "pioglitazone", "Actos"], "thiazolidinedione", "oral antihyperglycemic", "tz_d", ["type 2 diabetes"], "No routine renal adjustment.", "Agent-specific; assess current labeling and clinical status.", ["edema", "weight", "heart failure symptoms", "glucose"], ["boxed heart-failure warning"], ["insulin", "CYP modifiers"], "Avoid active liver disease; monitor clinically.", "Tablets generally crushable.", ["fluid_retention", "hypoglycemia"])
    CRD5_AddRecord(134, "Irbesartan", ["Irbesartan", "irbesartan"], "angiotensin II receptor blocker", "RAAS antihypertensive", "arb", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["hyperkalemia", "pregnancy contraindication"], ["ACE inhibitor/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(135, "Methylprednisolone", ["Methylprednisolone", "methylprednisolone", "Medrol", "Solu-Medrol"], "systemic corticosteroid", "anti-inflammatory/immunosuppressant", "systemic_steroid", ["inflammatory disease", "allergic disease", "adrenal replacement for selected agents"], "Usually no renal dose adjustment.", "Conversion/protein binding may vary.", ["glucose", "blood pressure", "infection", "psychiatric effects", "bone risk with prolonged use"], ["infection", "hyperglycemia", "adrenal suppression"], ["NSAIDs", "vaccines", "glucose-lowering therapy"], "Consider taper after prolonged exposure; give with food when appropriate.", "Immediate-release generally; verify formulation.", ["steroid", "hyperglycemia", "infection"])
    CRD5_AddRecord(136, "Norethindrone", ["Norethindrone", "norethindrone"], "hormonal therapy", "endocrine/reproductive therapy", "hormone", ["agent-specific endocrine or reproductive indication"], "Usually no simple adjustment.", "Avoid/use cautiously in significant hepatic disease depending on agent.", ["indication-specific response", "thrombotic or metabolic risk", "relevant labs"], ["thromboembolism or hormone-sensitive malignancy risk depending on agent"], ["enzyme inducers", "anticoagulants or hormone-sensitive therapies"], "Formulations/routes are not automatically interchangeable.", "Formulation-specific; hazardous-handling may apply.", ["hormone", "thrombosis"])
    CRD5_AddRecord(137, "Meclizine", ["Meclizine", "meclizine"], "anticholinergic agent", "symptom-specific", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk"], ["other anticholinergics", "CNS depressants"], "Avoid unnecessary cumulative anticholinergic burden.", "Do not crush extended-release products.", ["anticholinergic", "fall_risk", "constipation"])
    CRD5_AddRecord(138, "Ethinyl Estradiol; Levonorgestrel", ["Ethinyl Estradiol; Levonorgestrel", "ethinyl estradiol", "levonorgestrel", "Ethinyl Estradiol/ Levonorgestrel", "Ethinyl Estradiol +  Levonorgestrel"], "combined or progestin hormonal contraceptive", "contraception/hormonal therapy", "contraceptive", ["contraception", "cycle control"], "Product-specific; drospirenone has potassium considerations.", "Avoid significant hepatic disease.", ["blood pressure", "thrombotic risk", "adherence"], ["thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["strong enzyme inducers", "selected antiepileptics"], "Consistent daily use; missed-dose instructions are product-specific.", "Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(139, "Fluticasone; Vilanterol", ["Fluticasone; Vilanterol", "fluticasone", "vilanterol", "Flonase", "Flovent", "Fluticasone/ Vilanterol", "Fluticasone +  Vilanterol"], "inhaled bronchodilator + inhaled/intranasal corticosteroid", "airway therapy + airway anti-inflammatory", "bronchodilator", ["asthma", "COPD", "asthma/COPD maintenance", "allergic rhinitis"], "No routine adjustment. | No routine renal adjustment.", "Usually limited adjustment. | Systemic exposure may increase with strong CYP3A4 inhibitors.", ["symptom control", "heart rate/tremor", "anticholinergic effects", "oral candidiasis", "local nasal effects"], ["tachycardia", "paradoxical bronchospasm", "not a rescue inhaler", "local candidiasis"], ["other sympathomimetics", "anticholinergic burden", "strong CYP3A4 inhibitors"], "Device technique is essential; LABA/LAMA are maintenance, not rescue. | Rinse mouth after inhaled use; technique matters.", "Not applicable.", ["bronchodilator", "tachycardia", "inhaled_steroid"])
    CRD5_AddRecord(140, "Ketoconazole", ["Ketoconazole", "ketoconazole"], "azole antifungal", "antifungal", "azole", ["fungal infections"], "Fluconazole requires renal adjustment.", "Systemic azoles require hepatic caution.", ["hepatic function", "QT risk for systemic agents", "drug interactions"], ["hepatotoxicity", "QT effects for systemic agents"], ["CYP-mediated interactions", "warfarin", "QT-prolonging drugs"], "Route/formulation specific.", "Formulation-specific.", ["antifungal", "hepatic", "qt", "cyp"])
    CRD5_AddRecord(141, "Thyroid", ["Thyroid", "thyroid"], "thyroid-axis medication", "endocrine", "thyroid", ["hypothyroidism or hyperthyroidism depending on agent"], "Usually no direct adjustment.", "Usually limited adjustment.", ["TSH/free T4", "clinical response"], ["cardiac overstimulation if excessive", "agranulocytosis/hepatotoxicity for methimazole"], ["calcium/iron", "warfarin", "enzyme inducers"], "Levothyroxine requires consistent empty-stomach timing and separation from cations.", "Formulation-specific.", ["thyroid", "cation_interaction"])
    CRD5_AddRecord(142, "Azelastine", ["Azelastine", "azelastine"], "medication", "general therapy", "general", ["indication-specific therapy"], "Review current product labeling and patient renal function when clinically relevant.", "Review current product labeling and hepatic function when clinically relevant.", ["clinical response", "adverse effects", "dose/route/frequency completeness"], ["Review contraindications, major warnings, and patient-specific precautions."], ["Review the complete medication list for clinically significant interactions."], "Use indication-, route-, and formulation-specific administration instructions.", "Formulation-specific; extended-release, delayed-release, enteric-coated, hazardous, and special-delivery products require explicit review.", [])
    CRD5_AddRecord(143, "Nitrofurantoin", ["Nitrofurantoin", "nitrofurantoin", "Macrobid"], "antibiotic", "antimicrobial", "other_antibiotic", ["susceptible bacterial infections"], "Agent-specific; nitrofurantoin and tobramycin require renal attention.", "Clindamycin and nitrofurantoin require hepatic awareness.", ["clinical response", "renal/hepatic function as agent-specific", "toxicity"], ["C. difficile risk", "agent-specific pulmonary, hepatic, or ototoxicity"], ["agent-specific"], "Route/formulation and infection-site specific.", "Formulation-specific.", ["antibiotic", "renal"])
    CRD5_AddRecord(144, "Adalimumab", ["Adalimumab", "adalimumab", "Humira"], "immunomodulator/immunosuppressant", "rheumatology/transplant/immune therapy", "immunosuppressant", ["agent-specific inflammatory or transplant indications"], "Agent-specific; methotrexate/cyclosporine require major attention.", "Agent-specific; methotrexate requires major hepatic attention.", ["CBC", "hepatic/renal function as applicable", "infection", "agent-specific toxicity"], ["serious infection", "malignancy warnings for selected agents", "organ toxicity"], ["live vaccines", "other immunosuppressants", "agent-specific CYP or antifolate interactions"], "Verify weekly versus daily schedules and formulation-specific instructions.", "Hazardous-handling and formulation-specific review required.", ["immunosuppressant", "infection", "hazardous"])
    CRD5_AddRecord(145, "Memantine", ["Memantine", "memantine", "Namenda"], "NMDA receptor antagonist", "dementia therapy", "nmda_antagonist", ["Alzheimer disease"], "Requires renal adjustment in severe impairment.", "Agent-specific; assess current labeling and clinical status.", ["mental status", "renal function", "dizziness"], ["confusion/dizziness"], ["urine alkalinizing drugs"], "Extended-release formulations must remain intact.", "Do not crush extended-release products.", ["renal", "fall_risk"])
    CRD5_AddRecord(146, "Prednisolone", ["Prednisolone", "prednisolone"], "systemic corticosteroid", "anti-inflammatory/immunosuppressant", "systemic_steroid", ["inflammatory disease", "allergic disease", "adrenal replacement for selected agents"], "Usually no renal dose adjustment.", "Conversion/protein binding may vary.", ["glucose", "blood pressure", "infection", "psychiatric effects", "bone risk with prolonged use"], ["infection", "hyperglycemia", "adrenal suppression"], ["NSAIDs", "vaccines", "glucose-lowering therapy"], "Consider taper after prolonged exposure; give with food when appropriate.", "Immediate-release generally; verify formulation.", ["steroid", "hyperglycemia", "infection"])
    CRD5_AddRecord(147, "Esomeprazole", ["Esomeprazole", "esomeprazole", "Nexium"], "proton pump inhibitor", "acid suppression", "ppi", ["GERD", "peptic ulcer disease", "GI bleed therapy/prophylaxis"], "Usually no renal dose adjustment.", "Agent-specific limits in severe impairment.", ["ongoing indication", "magnesium with prolonged use", "enteric infection risk context"], ["long-term overuse", "hypomagnesemia", "enteric infection association"], ["omeprazole may reduce clopidogrel activation", "pH-dependent absorption interactions"], "Delayed-release handling is formulation-specific.", "Many delayed-release products should not be crushed.", ["acid_suppression"])
    CRD5_AddRecord(148, "Docusate", ["Docusate", "docusate", "Colace"], "bowel-regimen agent", "constipation therapy", "bowel_regimen", ["constipation", "bowel preparation depending on product"], "Use caution with electrolyte-containing products in renal dysfunction.", "Usually limited adjustment.", ["bowel response", "hydration", "electrolytes when intensive"], ["dehydration/electrolyte disturbance with overuse"], ["separate from selected oral drugs"], "Product-specific mixing and timing.", "Product-specific.", ["bowel_regimen"])
    CRD5_AddRecord(149, "Clindamycin", ["Clindamycin", "clindamycin", "Cleocin"], "antibiotic", "antimicrobial", "other_antibiotic", ["susceptible bacterial infections"], "Agent-specific; nitrofurantoin and tobramycin require renal attention.", "Clindamycin and nitrofurantoin require hepatic awareness.", ["clinical response", "renal/hepatic function as agent-specific", "toxicity"], ["C. difficile risk", "agent-specific pulmonary, hepatic, or ototoxicity"], ["agent-specific"], "Route/formulation and infection-site specific.", "Formulation-specific.", ["antibiotic", "renal"])
    CRD5_AddRecord(150, "Acyclovir", ["Acyclovir", "acyclovir", "Zovirax"], "antiviral", "antiviral", "antiviral", ["virus-specific treatment/prophylaxis"], "Many require renal adjustment.", "Ritonavir-containing regimens require hepatic and interaction review.", ["renal function", "interaction burden", "virus-specific response"], ["drug interactions", "renal toxicity for selected agents"], ["nirmatrelvir/ritonavir has extensive CYP3A interaction burden", "nephrotoxins with acyclovir/tenofovir"], "Timing and duration are indication-specific.", "Formulation-specific.", ["antiviral", "renal", "cyp3a4"])
    CRD5_AddRecord(151, "Sildenafil", ["Sildenafil", "sildenafil", "Viagra", "Revatio"], "PDE-5 inhibitor", "erectile dysfunction/pulmonary hypertension", "pde5", ["erectile dysfunction", "pulmonary arterial hypertension"], "Dose/interval changes may be needed.", "Dose limits may be needed.", ["blood pressure", "vision/hearing symptoms", "priapism"], ["profound hypotension with nitrates"], ["nitrates", "riociguat", "strong CYP3A4 inhibitors", "alpha blockers"], "Indication-specific dosing; products are not interchangeable.", "Product-specific.", ["pde5", "hypotension", "cyp3a4"])
    CRD5_AddRecord(152, "Insulin Degludec", ["Insulin Degludec", "insulin degludec", "Tresiba"], "insulin", "antihyperglycemic", "insulin", ["diabetes", "hyperglycemia", "critical-care protocols for selected products"], "Requirements often decrease as renal function declines.", "Requirements may change.", ["blood glucose", "potassium in IV protocols", "hypoglycemia"], ["hypoglycemia", "hypokalemia", "medication errors"], ["other glucose-lowering drugs", "beta blockers may mask symptoms"], "Verify product, concentration, route, and meal timing; never interchange blindly.", "Not applicable.", ["insulin", "hypoglycemia", "potassium"])
    CRD5_AddRecord(153, "Insulin Detemir", ["Insulin Detemir", "insulin detemir", "Levemir"], "insulin", "antihyperglycemic", "insulin", ["diabetes", "hyperglycemia", "critical-care protocols for selected products"], "Requirements often decrease as renal function declines.", "Requirements may change.", ["blood glucose", "potassium in IV protocols", "hypoglycemia"], ["hypoglycemia", "hypokalemia", "medication errors"], ["other glucose-lowering drugs", "beta blockers may mask symptoms"], "Verify product, concentration, route, and meal timing; never interchange blindly.", "Not applicable.", ["insulin", "hypoglycemia", "potassium"])
    CRD5_AddRecord(154, "Drospirenone; Ethinyl Estradiol", ["Drospirenone; Ethinyl Estradiol", "drospirenone", "ethinyl estradiol", "Drospirenone/ Ethinyl Estradiol", "Drospirenone +  Ethinyl Estradiol"], "combined or progestin hormonal contraceptive", "contraception/hormonal therapy", "contraceptive", ["contraception", "cycle control"], "Product-specific; drospirenone has potassium considerations.", "Avoid significant hepatic disease.", ["blood pressure", "thrombotic risk", "adherence"], ["thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["strong enzyme inducers", "selected antiepileptics"], "Consistent daily use; missed-dose instructions are product-specific.", "Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(155, "Ciprofloxacin", ["Ciprofloxacin", "ciprofloxacin", "Cipro"], "fluoroquinolone antibiotic", "antimicrobial", "fluoroquinolone", ["susceptible bacterial infections"], "Ciprofloxacin/levofloxacin require renal adjustment; moxifloxacin generally does not.", "Agent-specific.", ["renal function", "QT risk", "CNS/tendon symptoms", "glucose"], ["tendon rupture", "neuropathy/CNS effects", "aortic-risk warning", "QT prolongation"], ["cation products", "QT-prolonging drugs", "warfarin"], "Separate oral doses from polyvalent cations.", "Formulation-specific.", ["antibiotic", "qt", "renal", "cation_interaction"])
    CRD5_AddRecord(156, "Morphine", ["Morphine", "morphine", "MS Contin"], "opioid agonist", "analgesic", "opioid", ["moderate to severe pain"], "Metabolite accumulation varies; morphine requires high renal caution.", "Start conservatively.", ["pain response", "sedation", "respiratory rate", "bowel function"], ["respiratory depression", "dependence", "overdose"], ["benzodiazepines", "alcohol", "other CNS depressants", "serotonergic drugs for tramadol"], "Use bowel regimen when appropriate; never crush ER products.", "Never crush extended-release or abuse-deterrent products.", ["opioid", "cns_depressant", "resp_depression", "constipation"])
    CRD5_AddRecord(157, "Insulin Human; Insulin Isophane Human", ["Insulin Human; Insulin Isophane Human", "insulin human", "insulin isophane human", "Insulin Human/ Insulin Isophane Human", "Insulin Human +  Insulin Isophane Human"], "insulin", "antihyperglycemic", "insulin", ["diabetes", "hyperglycemia", "critical-care protocols for selected products"], "Requirements often decrease as renal function declines.", "Requirements may change.", ["blood glucose", "potassium in IV protocols", "hypoglycemia"], ["hypoglycemia", "hypokalemia", "medication errors"], ["other glucose-lowering drugs", "beta blockers may mask symptoms"], "Verify product, concentration, route, and meal timing; never interchange blindly.", "Not applicable.", ["insulin", "hypoglycemia", "potassium"])
    CRD5_AddRecord(158, "Levocetirizine", ["Levocetirizine", "levocetirizine"], "second-generation antihistamine", "antiallergic", "antihistamine", ["allergic rhinitis", "urticaria"], "Dose adjust selected agents.", "Agent-specific; assess current labeling and clinical status.", ["sedation for selected agents", "renal function"], ["sedation possible"], ["CNS depressants for sedating agents"], "Product-specific food/antacid separation may apply.", "Product-specific.", [])
    CRD5_AddRecord(159, "Nirmatrelvir; Ritonavir", ["Nirmatrelvir; Ritonavir", "nirmatrelvir", "ritonavir", "Paxlovid", "Nirmatrelvir/ Ritonavir", "Nirmatrelvir +  Ritonavir"], "antiviral", "antiviral", "antiviral", ["virus-specific treatment/prophylaxis"], "Many require renal adjustment.", "Ritonavir-containing regimens require hepatic and interaction review.", ["renal function", "interaction burden", "virus-specific response"], ["drug interactions", "renal toxicity for selected agents"], ["nirmatrelvir/ritonavir has extensive CYP3A interaction burden", "nephrotoxins with acyclovir/tenofovir"], "Timing and duration are indication-specific.", "Formulation-specific.", ["antiviral", "renal", "cyp3a4"])
    CRD5_AddRecord(160, "Valproate", ["Valproate", "valproate", "Depakote", "Depacon"], "antiepileptic/mood stabilizer", "neurologic", "antiepileptic", ["seizure disorders", "mood stabilization or migraine depending on agent"], "Many agents require renal adjustment.", "Valproate/carbamazepine/lamotrigine require hepatic attention.", ["seizure control", "mood/suicidality", "drug-specific labs/levels"], ["serious rash for selected agents", "teratogenicity varies", "CNS effects"], ["enzyme inducers/inhibitors", "oral contraceptives", "CNS depressants"], "Avoid abrupt discontinuation.", "Do not crush extended-release products.", ["antiepileptic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(161, "Atomoxetine", ["Atomoxetine", "atomoxetine", "Strattera"], "selective norepinephrine reuptake inhibitor", "ADHD therapy", "nonstimulant_adhd", ["ADHD"], "Usually no renal adjustment.", "Agent-specific; assess current labeling and clinical status.", ["blood pressure", "heart rate", "mood", "hepatic symptoms"], ["suicidality warning", "severe liver injury warning"], ["MAO inhibitors", "CYP2D6 inhibitors"], "Capsules should not be opened because contents are irritant.", "Do not open/crush capsules.", ["hypertension"])
    CRD5_AddRecord(162, "Budesonide", ["Budesonide", "budesonide"], "inhaled/intranasal corticosteroid", "airway anti-inflammatory", "inhaled_steroid", ["asthma/COPD maintenance", "allergic rhinitis"], "No routine renal adjustment.", "Systemic exposure may increase with strong CYP3A4 inhibitors.", ["symptom control", "oral candidiasis", "local nasal effects"], ["not a rescue inhaler", "local candidiasis"], ["strong CYP3A4 inhibitors"], "Rinse mouth after inhaled use; technique matters.", "Not applicable.", ["inhaled_steroid"])
    CRD5_AddRecord(163, "Tiotropium", ["Tiotropium", "tiotropium", "Spiriva"], "inhaled bronchodilator", "airway therapy", "bronchodilator", ["asthma", "COPD"], "No routine adjustment.", "Usually limited adjustment.", ["symptom control", "heart rate/tremor", "anticholinergic effects"], ["tachycardia", "paradoxical bronchospasm"], ["other sympathomimetics", "anticholinergic burden"], "Device technique is essential; LABA/LAMA are maintenance, not rescue.", "Not applicable.", ["bronchodilator", "tachycardia"])
    CRD5_AddRecord(164, "Melatonin", ["Melatonin", "melatonin"], "melatonin receptor supplement", "sleep aid", "sleep_supplement", ["sleep timing/insomnia-related use"], "No standard adjustment; evidence limited.", "Use cautiously.", ["sedation", "next-day impairment", "product consistency"], ["sedation"], ["CNS depressants", "warfarin monitoring context"], "Timing relative to desired sleep is important.", "Product-specific.", ["cns_depressant"])
    CRD5_AddRecord(165, "Cefdinir", ["Cefdinir", "cefdinir", "Omnicef"], "cephalosporin antibiotic", "antimicrobial", "cephalosporin", ["susceptible bacterial infections"], "Most require renal adjustment.", "Usually limited adjustment.", ["allergy", "renal function", "clinical response"], ["hypersensitivity", "C. difficile-associated diarrhea"], ["warfarin monitoring context"], "Food/suspension handling is formulation-specific.", "Many immediate-release products have liquid alternatives.", ["antibiotic", "beta_lactam", "renal", "allergy"])
    CRD5_AddRecord(166, "Doxepin", ["Doxepin", "doxepin", "Sinequan", "Silenor"], "tricyclic antidepressant", "antidepressant/neuropathic pain", "tca", ["depression", "neuropathic pain", "sleep-related off-label use"], "Usually no simple adjustment; use cautiously.", "Start conservatively.", ["sedation", "orthostasis", "anticholinergic effects", "QT/conduction risk"], ["overdose cardiotoxicity", "falls", "anticholinergic burden"], ["MAO inhibitors", "other serotonergic/CNS depressant drugs", "QT-prolonging drugs"], "Often dosed at night because of sedation.", "Formulation-specific.", ["serotonergic", "anticholinergic", "cns_depressant", "qt", "fall_risk"])
    CRD5_AddRecord(167, "Olanzapine", ["Olanzapine", "olanzapine", "Zyprexa"], "atypical antipsychotic", "antipsychotic/mood stabilization", "antipsychotic", ["schizophrenia", "bipolar disorder", "selected adjunctive depression"], "Agent-specific.", "Start conservatively.", ["metabolic parameters", "movement disorders", "QT risk", "orthostasis"], ["mortality warning in dementia-related psychosis", "metabolic effects", "NMS/tardive dyskinesia"], ["CNS depressants", "QT-prolonging drugs", "CYP modifiers"], "Formulations are not automatically interchangeable.", "Formulation-specific.", ["antipsychotic", "qt", "cns_depressant", "fall_risk", "metabolic"])
    CRD5_AddRecord(168, "Phentermine", ["Phentermine", "phentermine", "Adipex"], "CNS stimulant/sympathomimetic", "ADHD/weight management", "stimulant", ["ADHD", "narcolepsy", "short-term weight management for phentermine"], "Agent-specific.", "Agent-specific.", ["blood pressure", "heart rate", "sleep", "appetite/weight", "misuse"], ["misuse/dependence", "cardiovascular effects", "psychiatric effects"], ["MAO inhibitors", "other sympathomimetics"], "Morning dosing; do not crush extended-release products.", "Do not crush extended-release products.", ["stimulant", "tachycardia", "hypertension"])
    CRD5_AddRecord(169, "Ofloxacin", ["Ofloxacin", "ofloxacin"], "fluoroquinolone antibiotic", "antimicrobial", "fluoroquinolone", ["susceptible bacterial infections"], "Ciprofloxacin/levofloxacin require renal adjustment; moxifloxacin generally does not.", "Agent-specific.", ["renal function", "QT risk", "CNS/tendon symptoms", "glucose"], ["tendon rupture", "neuropathy/CNS effects", "aortic-risk warning", "QT prolongation"], ["cation products", "QT-prolonging drugs", "warfarin"], "Separate oral doses from polyvalent cations.", "Formulation-specific.", ["antibiotic", "qt", "renal", "cation_interaction"])
    CRD5_AddRecord(170, "Ethinyl Estradiol; Etonogestrel", ["Ethinyl Estradiol; Etonogestrel", "ethinyl estradiol", "etonogestrel", "Ethinyl Estradiol/ Etonogestrel", "Ethinyl Estradiol +  Etonogestrel"], "combined or progestin hormonal contraceptive", "contraception/hormonal therapy", "contraceptive", ["contraception", "cycle control"], "Product-specific; drospirenone has potassium considerations.", "Avoid significant hepatic disease.", ["blood pressure", "thrombotic risk", "adherence"], ["thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["strong enzyme inducers", "selected antiepileptics"], "Consistent daily use; missed-dose instructions are product-specific.", "Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(171, "Mupirocin", ["Mupirocin", "mupirocin", "Bactroban"], "topical antimicrobial/antiseptic", "local anti-infective", "topical_antimicrobial", ["localized bacterial/fungal infection or antisepsis"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment.", ["local response", "irritation", "treatment duration"], ["local hypersensitivity", "avoid inappropriate prolonged use"], ["few systemic interactions"], "Apply only to intended site; avoid contamination.", "Not applicable.", ["topical"])
    CRD5_AddRecord(172, "Benazepril", ["Benazepril", "benazepril"], "ACE inhibitor", "RAAS antihypertensive", "ace_inhibitor", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Usually no class-wide adjustment; agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["angioedema", "hyperkalemia", "pregnancy contraindication"], ["ARB/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(173, "Timolol", ["Timolol", "timolol", "Timoptic"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(174, "Magnesium Salts", ["Magnesium Salts", "magnesium salts"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(175, "Fluconazole", ["Fluconazole", "fluconazole", "Diflucan"], "azole antifungal", "antifungal", "azole", ["fungal infections"], "Fluconazole requires renal adjustment.", "Systemic azoles require hepatic caution.", ["hepatic function", "QT risk for systemic agents", "drug interactions"], ["hepatotoxicity", "QT effects for systemic agents"], ["CYP-mediated interactions", "warfarin", "QT-prolonging drugs"], "Route/formulation specific.", "Formulation-specific.", ["antifungal", "hepatic", "qt", "cyp"])
    CRD5_AddRecord(176, "Risperidone", ["Risperidone", "risperidone", "Risperdal"], "atypical antipsychotic", "antipsychotic/mood stabilization", "antipsychotic", ["schizophrenia", "bipolar disorder", "selected adjunctive depression"], "Agent-specific.", "Start conservatively.", ["metabolic parameters", "movement disorders", "QT risk", "orthostasis"], ["mortality warning in dementia-related psychosis", "metabolic effects", "NMS/tardive dyskinesia"], ["CNS depressants", "QT-prolonging drugs", "CYP modifiers"], "Formulations are not automatically interchangeable.", "Formulation-specific.", ["antipsychotic", "qt", "cns_depressant", "fall_risk", "metabolic"])
    CRD5_AddRecord(177, "Verapamil", ["Verapamil", "verapamil", "Calan", "Verelan"], "non-dihydropyridine calcium channel blocker", "rate control/antihypertensive", "non_dhp_ccb", ["atrial arrhythmia rate control", "angina", "hypertension"], "Usually limited renal adjustment.", "Dose conservatively in hepatic impairment.", ["heart rate", "blood pressure", "PR interval"], ["bradycardia", "heart block", "worsening HFrEF"], ["beta blockers", "other AV nodal blockers", "CYP3A4 substrates"], "Extended-release products must not be crushed.", "Do not crush extended-release products.", ["bradycardia", "av_node", "cyp3a4"])
    CRD5_AddRecord(178, "Linaclotide", ["Linaclotide", "linaclotide", "Linzess"], "guanylate cyclase-C agonist", "constipation/IBS therapy", "gi_secretagogue", ["chronic idiopathic constipation", "IBS-C"], "No routine adjustment.", "Agent-specific; assess current labeling and clinical status.", ["diarrhea", "hydration"], ["pediatric dehydration boxed warning"], ["few major systemic interactions"], "Take fasting before a meal; capsule contents may have specific administration options.", "Use product-specific opening instructions.", [])
    CRD5_AddRecord(179, "Cyclosporine", ["Cyclosporine", "cyclosporine", "Neoral", "Sandimmune", "Restasis"], "immunomodulator/immunosuppressant", "rheumatology/transplant/immune therapy", "immunosuppressant", ["agent-specific inflammatory or transplant indications"], "Agent-specific; methotrexate/cyclosporine require major attention.", "Agent-specific; methotrexate requires major hepatic attention.", ["CBC", "hepatic/renal function as applicable", "infection", "agent-specific toxicity"], ["serious infection", "malignancy warnings for selected agents", "organ toxicity"], ["live vaccines", "other immunosuppressants", "agent-specific CYP or antifolate interactions"], "Verify weekly versus daily schedules and formulation-specific instructions.", "Hazardous-handling and formulation-specific review required.", ["immunosuppressant", "infection", "hazardous"])
    CRD5_AddRecord(180, "Doxazosin", ["Doxazosin", "doxazosin", "Cardura"], "alpha-1 adrenergic blocker", "BPH/antihypertensive", "alpha1_blocker", ["BPH", "hypertension for selected agents"], "Usually limited adjustment.", "Agent-specific.", ["orthostasis", "blood pressure", "falls"], ["syncope", "falls"], ["PDE-5 inhibitors", "other antihypertensives"], "Initial/retitration dosing may cause marked orthostasis.", "Do not crush modified-release products.", ["hypotension", "fall_risk"])
    CRD5_AddRecord(181, "Albuterol; Ipratropium", ["Albuterol; Ipratropium", "albuterol", "ipratropium", "Ventolin", "ProAir", "Proventil", "Atrovent", "DuoNeb", "Combivent", "Albuterol/ Ipratropium", "Albuterol +  Ipratropium"], "inhaled bronchodilator", "airway therapy", "bronchodilator", ["asthma", "COPD"], "No routine adjustment.", "Usually limited adjustment.", ["symptom control", "heart rate/tremor", "anticholinergic effects"], ["tachycardia", "paradoxical bronchospasm"], ["other sympathomimetics", "anticholinergic burden"], "Device technique is essential; LABA/LAMA are maintenance, not rescue.", "Not applicable.", ["bronchodilator", "tachycardia"])
    CRD5_AddRecord(182, "Hydrocortisone", ["Hydrocortisone", "hydrocortisone", "Cortef"], "systemic corticosteroid", "anti-inflammatory/immunosuppressant", "systemic_steroid", ["inflammatory disease", "allergic disease", "adrenal replacement for selected agents"], "Usually no renal dose adjustment.", "Conversion/protein binding may vary.", ["glucose", "blood pressure", "infection", "psychiatric effects", "bone risk with prolonged use"], ["infection", "hyperglycemia", "adrenal suppression"], ["NSAIDs", "vaccines", "glucose-lowering therapy"], "Consider taper after prolonged exposure; give with food when appropriate.", "Immediate-release generally; verify formulation.", ["steroid", "hyperglycemia", "infection"])
    CRD5_AddRecord(183, "Diazepam", ["Diazepam", "diazepam", "Valium"], "benzodiazepine", "anxiolytic/sedative", "benzodiazepine", ["anxiety", "acute agitation", "seizure", "alcohol withdrawal"], "Agent/metabolite-specific.", "Lorazepam/oxazepam/temazepam are often preferred in hepatic dysfunction.", ["sedation", "respiratory status", "falls", "withdrawal"], ["respiratory depression", "dependence", "falls/delirium"], ["opioids", "alcohol", "other CNS depressants"], "Avoid abrupt discontinuation after sustained use.", "Formulation-specific.", ["benzodiazepine", "cns_depressant", "fall_risk", "resp_depression"])
    CRD5_AddRecord(184, "Telmisartan", ["Telmisartan", "telmisartan"], "angiotensin II receptor blocker", "RAAS antihypertensive", "arb", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["hyperkalemia", "pregnancy contraindication"], ["ACE inhibitor/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(185, "Carbamazepine", ["Carbamazepine", "carbamazepine", "Tegretol"], "antiepileptic/mood stabilizer", "neurologic", "antiepileptic", ["seizure disorders", "mood stabilization or migraine depending on agent"], "Many agents require renal adjustment.", "Valproate/carbamazepine/lamotrigine require hepatic attention.", ["seizure control", "mood/suicidality", "drug-specific labs/levels"], ["serious rash for selected agents", "teratogenicity varies", "CNS effects"], ["enzyme inducers/inhibitors", "oral contraceptives", "CNS depressants"], "Avoid abrupt discontinuation.", "Do not crush extended-release products.", ["antiepileptic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(186, "Amlodipine; Benazepril", ["Amlodipine; Benazepril", "amlodipine", "benazepril", "Norvasc", "Amlodipine/ Benazepril", "Amlodipine +  Benazepril"], "ACE inhibitor + dihydropyridine calcium channel blocker", "RAAS antihypertensive + antihypertensive", "ace_inhibitor", ["hypertension", "heart failure", "albuminuric CKD", "angina"], "Reassess creatinine and potassium after initiation or titration. | Usually no major renal adjustment.", "Usually no class-wide adjustment; agent-specific. | Start conservatively in significant hepatic impairment.", ["serum creatinine", "potassium", "blood pressure", "peripheral edema"], ["angioedema", "hyperkalemia", "pregnancy contraindication", "hypotension", "peripheral edema"], ["ARB/ARNI duplication", "potassium sources", "NSAIDs", "other antihypertensives", "CYP3A4 modifiers"], "Monitor hypotension in volume depletion. | Do not crush extended-release products.", "Formulation-specific. | Do not crush extended-release products.", ["raas", "hyperkalemia", "renal", "pregnancy", "hypotension"])
    CRD5_AddRecord(187, "Lithium", ["Lithium", "lithium", "Lithobid"], "mood stabilizer", "psychiatric", "lithium", ["bipolar disorder"], "Requires renal dosing and close level monitoring.", "Agent-specific; assess current labeling and clinical status.", ["serum lithium", "renal function", "thyroid", "sodium/fluid status"], ["narrow therapeutic index", "toxicity"], ["NSAIDs", "ACEI/ARB", "thiazide/loop diuretics"], "Maintain consistent sodium/fluid intake.", "Do not crush extended-release products.", ["lithium", "renal", "narrow_therapeutic_index"])
    CRD5_AddRecord(188, "Evolocumab", ["Evolocumab", "evolocumab", "Repatha"], "non-statin lipid-lowering agent", "lipid lowering", "lipid_other", ["hyperlipidemia", "ASCVD risk reduction for selected agents"], "Agent-specific.", "Agent-specific; fibrates/niacin require hepatic attention.", ["lipid panel", "hepatic or muscle symptoms when relevant"], ["myopathy when combined with statins for selected agents", "hepatic effects"], ["statins", "warfarin for selected agents"], "Product-specific food and formulation directions.", "Formulation-specific.", ["lipid", "myopathy", "hepatic"])
    CRD5_AddRecord(189, "Desvenlafaxine", ["Desvenlafaxine", "desvenlafaxine", "Pristiq"], "serotonin-norepinephrine reuptake inhibitor", "antidepressant/neuropathic pain", "snri", ["depression", "anxiety", "neuropathic pain"], "Dose limits vary; duloxetine has significant severe-renal restrictions.", "Duloxetine requires major hepatic caution.", ["blood pressure", "serotonin toxicity", "withdrawal"], ["serotonin syndrome", "blood pressure elevation", "withdrawal"], ["MAO inhibitors", "other serotonergic drugs", "bleeding-risk drugs"], "Taper rather than abruptly discontinue.", "Do not crush extended-release formulations.", ["serotonergic", "bleeding"])
    CRD5_AddRecord(190, "Dorzolamide", ["Dorzolamide", "dorzolamide"], "ophthalmic medication", "ocular therapy", "ophthalmic", ["glaucoma, allergy, infection, or ocular condition depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment for topical use.", ["ocular response", "local irritation", "systemic beta-blockade when relevant"], ["contamination risk", "systemic effects possible with selected agents"], ["other ocular agents; separate drops by several minutes"], "Use proper drop technique and nasolacrimal occlusion when appropriate.", "Not applicable.", ["ophthalmic"])
    CRD5_AddRecord(191, "Nebivolol", ["Nebivolol", "nebivolol", "Bystolic"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(192, "Dicyclomine", ["Dicyclomine", "dicyclomine", "Bentyl"], "anticholinergic agent", "symptom-specific", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk"], ["other anticholinergics", "CNS depressants"], "Avoid unnecessary cumulative anticholinergic burden.", "Do not crush extended-release products.", ["anticholinergic", "fall_risk", "constipation"])
    CRD5_AddRecord(193, "Torsemide", ["Torsemide", "torsemide", "Demadex"], "loop diuretic", "diuretic", "loop_diuretic", ["edema", "heart failure"], "Dose to response; monitor renal function and volume status.", "Electrolyte shifts may worsen encephalopathy.", ["volume status", "sodium", "potassium", "magnesium", "renal function"], ["volume depletion", "electrolyte depletion", "ototoxicity at high exposure"], ["NSAIDs", "lithium", "other ototoxins"], "Morning timing when possible; IV rate is product-specific.", "Immediate-release generally; verify formulation.", ["diuretic", "hypokalemia", "renal", "volume_depletion"])
    CRD5_AddRecord(194, "Anastrozole", ["Anastrozole", "anastrozole", "Arimidex"], "hormonal therapy", "endocrine/reproductive therapy", "hormone", ["agent-specific endocrine or reproductive indication"], "Usually no simple adjustment.", "Avoid/use cautiously in significant hepatic disease depending on agent.", ["indication-specific response", "thrombotic or metabolic risk", "relevant labs"], ["thromboembolism or hormone-sensitive malignancy risk depending on agent"], ["enzyme inducers", "anticoagulants or hormone-sensitive therapies"], "Formulations/routes are not automatically interchangeable.", "Formulation-specific; hazardous-handling may apply.", ["hormone", "thrombosis"])
    CRD5_AddRecord(195, "Enalapril", ["Enalapril", "enalapril", "Vasotec"], "ACE inhibitor", "RAAS antihypertensive", "ace_inhibitor", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Usually no class-wide adjustment; agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["angioedema", "hyperkalemia", "pregnancy contraindication"], ["ARB/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(196, "Polyethylene Glycol 3350", ["Polyethylene Glycol 3350", "polyethylene glycol 3350"], "laxative", "bowel regimen", "laxative", ["constipation", "bowel preparation depending on product"], "Use caution with fluid/electrolyte disorders.", "Agent-specific; assess current labeling and clinical status.", ["bowel response", "hydration", "electrolytes when intensive"], ["dehydration/electrolyte disturbance with overuse"], ["separation from selected oral drugs"], "Product-specific mixing and timing.", "Product-specific.", [])
    CRD5_AddRecord(197, "Tretinoin", ["Tretinoin", "tretinoin"], "dermatologic agent", "topical skin therapy", "dermatologic", ["acne, dyschromia, actinic damage, or neoplastic lesions depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment.", ["local irritation", "treatment response", "pregnancy risk when relevant"], ["photosensitivity/irritation", "pregnancy or hazardous-handling concerns for selected agents"], ["other irritating topical products"], "Use site- and product-specific application instructions.", "Not applicable.", ["topical", "hazardous"])
    CRD5_AddRecord(198, "Tadalafil", ["Tadalafil", "tadalafil", "Cialis", "Adcirca"], "PDE-5 inhibitor", "erectile dysfunction/pulmonary hypertension", "pde5", ["erectile dysfunction", "pulmonary arterial hypertension"], "Dose/interval changes may be needed.", "Dose limits may be needed.", ["blood pressure", "vision/hearing symptoms", "priapism"], ["profound hypotension with nitrates"], ["nitrates", "riociguat", "strong CYP3A4 inhibitors", "alpha blockers"], "Indication-specific dosing; products are not interchangeable.", "Product-specific.", ["pde5", "hypotension", "cyp3a4"])
    CRD5_AddRecord(199, "Sacubitril; Valsartan", ["Sacubitril; Valsartan", "sacubitril", "valsartan", "Entresto", "Diovan", "Sacubitril/ Valsartan", "Sacubitril +  Valsartan"], "angiotensin II receptor blocker + angiotensin receptor-neprilysin inhibitor", "RAAS antihypertensive + heart failure therapy", "arb", ["hypertension", "heart failure", "albuminuric CKD", "HFrEF"], "Reassess creatinine and potassium after initiation or titration. | Review renal function and starting dose.", "Agent-specific. | Agent-specific; assess current labeling and clinical status.", ["serum creatinine", "potassium", "blood pressure", "renal function"], ["hyperkalemia", "pregnancy contraindication", "angioedema"], ["ACE inhibitor/ARNI duplication", "potassium sources", "NSAIDs", "ACE inhibitor within washout period"], "Monitor hypotension in volume depletion. | ACE inhibitor washout is required.", "Formulation-specific. | Tablets may have product-specific suspension preparation.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(200, "Calcium", ["Calcium", "calcium"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(201, "Pramipexole", ["Pramipexole", "pramipexole", "Mirapex"], "dopamine agonist", "Parkinson disease/restless legs therapy", "dopamine_agonist", ["Parkinson disease", "restless legs syndrome"], "Requires agent-specific renal adjustment.", "Usually limited adjustment.", ["somnolence", "orthostasis", "impulse-control symptoms", "hallucinations"], ["sleep attacks", "impulse-control disorders"], ["CNS depressants", "dopamine antagonists"], "Titrate gradually; avoid abrupt discontinuation.", "Do not crush extended-release products.", ["cns_depressant", "fall_risk", "renal"])
    CRD5_AddRecord(202, "Mesalamine", ["Mesalamine", "mesalamine", "Lialda", "Pentasa"], "5-aminosalicylate", "inflammatory bowel disease therapy", "aminosalicylate", ["ulcerative colitis"], "Assess renal function before and during therapy.", "Agent-specific; assess current labeling and clinical status.", ["renal function", "CBC/hepatic function as indicated"], ["renal injury", "intolerance syndrome"], ["nephrotoxic drugs"], "Formulations release at different GI sites and are not automatically interchangeable.", "Do not crush delayed/extended-release formulations.", ["renal"])
    CRD5_AddRecord(203, "Metronidazole", ["Metronidazole", "metronidazole", "Flagyl"], "azole antifungal", "antifungal", "azole", ["fungal infections"], "Fluconazole requires renal adjustment.", "Systemic azoles require hepatic caution.", ["hepatic function", "QT risk for systemic agents", "drug interactions"], ["hepatotoxicity", "QT effects for systemic agents"], ["CYP-mediated interactions", "warfarin", "QT-prolonging drugs"], "Route/formulation specific.", "Formulation-specific.", ["antifungal", "hepatic", "qt", "cyp"])
    CRD5_AddRecord(204, "Nortriptyline", ["Nortriptyline", "nortriptyline", "Pamelor"], "tricyclic antidepressant", "antidepressant/neuropathic pain", "tca", ["depression", "neuropathic pain", "sleep-related off-label use"], "Usually no simple adjustment; use cautiously.", "Start conservatively.", ["sedation", "orthostasis", "anticholinergic effects", "QT/conduction risk"], ["overdose cardiotoxicity", "falls", "anticholinergic burden"], ["MAO inhibitors", "other serotonergic/CNS depressant drugs", "QT-prolonging drugs"], "Often dosed at night because of sedation.", "Formulation-specific.", ["serotonergic", "anticholinergic", "cns_depressant", "qt", "fall_risk"])
    CRD5_AddRecord(205, "Emtricitabine; Tenofovir", ["Emtricitabine; Tenofovir", "emtricitabine", "tenofovir", "Truvada", "Emtricitabine/ Tenofovir", "Emtricitabine +  Tenofovir"], "antiviral", "antiviral", "antiviral", ["virus-specific treatment/prophylaxis"], "Many require renal adjustment.", "Ritonavir-containing regimens require hepatic and interaction review.", ["renal function", "interaction burden", "virus-specific response"], ["drug interactions", "renal toxicity for selected agents"], ["nirmatrelvir/ritonavir has extensive CYP3A interaction burden", "nephrotoxins with acyclovir/tenofovir"], "Timing and duration are indication-specific.", "Formulation-specific.", ["antiviral", "renal", "cyp3a4"])
    CRD5_AddRecord(206, "Rimegepant", ["Rimegepant", "rimegepant", "Nurtec"], "CGRP receptor antagonist", "migraine therapy", "cgrp_migraine", ["acute migraine", "prevention for selected regimens"], "Avoid/use limits in severe renal impairment depending on product.", "Dose/avoidance limits may apply.", ["response", "hypersensitivity", "hepatic interaction burden"], ["hypersensitivity"], ["strong/moderate CYP3A4 and P-gp modifiers"], "ODT handling is product-specific.", "ODT should be allowed to dissolve.", ["cyp3a4"])
    CRD5_AddRecord(207, "Nitroglycerin", ["Nitroglycerin", "nitroglycerin", "Nitrostat"], "organic nitrate", "antianginal/vasodilator", "nitrate", ["angina", "heart failure adjunct for selected regimens"], "Usually limited adjustment.", "Agent-specific; assess current labeling and clinical status.", ["blood pressure", "headache", "tolerance"], ["severe hypotension"], ["PDE-5 inhibitors", "riociguat"], "Use nitrate-free interval for chronic formulations when applicable.", "Do not crush extended-release products.", ["hypotension", "nitrate"])
    CRD5_AddRecord(208, "Rizatriptan", ["Rizatriptan", "rizatriptan", "Maxalt"], "serotonin 5-HT1B/1D agonist", "acute migraine therapy", "triptan", ["acute migraine"], "Agent-specific.", "Dose limits vary.", ["response", "blood pressure", "frequency of use"], ["vasoconstriction", "medication-overuse headache"], ["ergot drugs", "MAO inhibitors for selected agents", "serotonergic drugs"], "Not for routine prevention; observe maximum daily limits.", "Formulation-specific.", ["serotonergic", "vasoconstrictor"])
    CRD5_AddRecord(209, "Liraglutide", ["Liraglutide", "liraglutide", "Victoza", "Saxenda"], "incretin-based GLP-1 therapy", "diabetes/weight management", "glp1", ["type 2 diabetes", "weight management for selected products"], "No simple class dose rule; dehydration can worsen renal function.", "Usually limited adjustment.", ["glucose", "GI tolerance", "weight", "pancreatitis/gallbladder symptoms"], ["severe GI effects", "pancreatitis warning", "thyroid C-cell tumor warning for selected products"], ["insulin/sulfonylurea hypoglycemia risk", "delayed gastric emptying"], "Follow product-specific titration and oral/injection timing.", "Oral semaglutide must be swallowed whole.", ["glp1", "hypoglycemia", "gi"])
    CRD5_AddRecord(210, "Acetaminophen; Codeine", ["Acetaminophen; Codeine", "acetaminophen", "codeine", "Tylenol", "APAP", "Tylenol with Codeine", "Acetaminophen/ Codeine", "Acetaminophen +  Codeine"], "opioid agonist + nonopioid analgesic or combination analgesic", "analgesic + pain/headache therapy", "opioid", ["moderate to severe pain", "pain", "fever", "headache"], "Metabolite accumulation varies; morphine requires high renal caution. | Usually limited adjustment, but chronic/high exposure requires caution.", "Start conservatively. | Acetaminophen total daily exposure is critical in hepatic risk.", ["pain response", "sedation", "respiratory rate", "bowel function", "total acetaminophen exposure", "sedation for butalbital combinations", "headache frequency"], ["respiratory depression", "dependence", "overdose", "hepatotoxicity", "medication-overuse headache", "sedation/dependence with butalbital"], ["benzodiazepines", "alcohol", "other CNS depressants", "serotonergic drugs for tramadol", "warfarin with sustained high acetaminophen exposure", "CNS depressants"], "Use bowel regimen when appropriate; never crush ER products. | Count all combination-product acetaminophen.", "Never crush extended-release or abuse-deterrent products. | Formulation-specific.", ["opioid", "cns_depressant", "resp_depression", "constipation", "acetaminophen"])
    CRD5_AddRecord(211, "Ramipril", ["Ramipril", "ramipril"], "ACE inhibitor", "RAAS antihypertensive", "ace_inhibitor", ["hypertension", "heart failure", "albuminuric CKD"], "Reassess creatinine and potassium after initiation or titration.", "Usually no class-wide adjustment; agent-specific.", ["serum creatinine", "potassium", "blood pressure"], ["angioedema", "hyperkalemia", "pregnancy contraindication"], ["ARB/ARNI duplication", "potassium sources", "NSAIDs"], "Monitor hypotension in volume depletion.", "Formulation-specific.", ["raas", "hyperkalemia", "renal", "pregnancy"])
    CRD5_AddRecord(212, "Ropinirole", ["Ropinirole", "ropinirole", "Requip"], "dopamine agonist", "Parkinson disease/restless legs therapy", "dopamine_agonist", ["Parkinson disease", "restless legs syndrome"], "Requires agent-specific renal adjustment.", "Usually limited adjustment.", ["somnolence", "orthostasis", "impulse-control symptoms", "hallucinations"], ["sleep attacks", "impulse-control disorders"], ["CNS depressants", "dopamine antagonists"], "Titrate gradually; avoid abrupt discontinuation.", "Do not crush extended-release products.", ["cns_depressant", "fall_risk", "renal"])
    CRD5_AddRecord(213, "Brimonidine", ["Brimonidine", "brimonidine"], "ophthalmic medication", "ocular therapy", "ophthalmic", ["glaucoma, allergy, infection, or ocular condition depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment for topical use.", ["ocular response", "local irritation", "systemic beta-blockade when relevant"], ["contamination risk", "systemic effects possible with selected agents"], ["other ocular agents; separate drops by several minutes"], "Use proper drop technique and nasolacrimal occlusion when appropriate.", "Not applicable.", ["ophthalmic"])
    CRD5_AddRecord(214, "Mirabegron", ["Mirabegron", "mirabegron", "Myrbetriq"], "beta-3 adrenergic agonist", "overactive bladder therapy", "beta3_agonist", ["overactive bladder"], "Dose limits vary with renal impairment.", "Agent-specific; assess current labeling and clinical status.", ["blood pressure", "urinary retention"], ["severe uncontrolled hypertension caution"], ["CYP2D6 substrates"], "Swallow extended-release tablets whole.", "Do not crush extended-release tablets.", ["hypertension"])
    CRD5_AddRecord(215, "Colchicine", ["Colchicine", "colchicine", "Colcrys"], "microtubule inhibitor", "acute gout/anti-inflammatory", "antigout", ["acute gout", "gout prophylaxis", "pericarditis"], "Requires renal/interaction-based adjustment.", "Agent-specific; assess current labeling and clinical status.", ["renal/hepatic function", "CBC/CK when indicated", "toxicity"], ["neuromyopathy", "marrow suppression"], ["strong CYP3A4/P-gp inhibitors"], "Toxicity risk rises sharply with interacting drugs.", "Tablets generally crushable; verify product.", ["renal", "cyp3a4", "myopathy"])
    CRD5_AddRecord(216, "Ticagrelor", ["Ticagrelor", "ticagrelor", "Brilinta"], "antiplatelet agent", "platelet inhibition", "antiplatelet", ["ACS/PCI", "secondary cardiovascular prevention"], "Usually no simple renal adjustment.", "Agent-specific.", ["bleeding", "CBC when indicated", "adherence"], ["major bleeding"], ["anticoagulants", "NSAIDs", "other antiplatelets"], "Assess indication and procedure hold timing.", "Product-specific.", ["antiplatelet", "bleeding"])
    CRD5_AddRecord(217, "Terazosin", ["Terazosin", "terazosin", "Hytrin"], "alpha-1 adrenergic blocker", "BPH/antihypertensive", "alpha1_blocker", ["BPH", "hypertension for selected agents"], "Usually limited adjustment.", "Agent-specific.", ["orthostasis", "blood pressure", "falls"], ["syncope", "falls"], ["PDE-5 inhibitors", "other antihypertensives"], "Initial/retitration dosing may cause marked orthostasis.", "Do not crush modified-release products.", ["hypotension", "fall_risk"])
    CRD5_AddRecord(218, "Amiodarone", ["Amiodarone", "amiodarone", "Cordarone", "Pacerone"], "class III antiarrhythmic", "antiarrhythmic", "antiarrhythmic_qt", ["atrial/ventricular arrhythmias"], "Usually no renal adjustment but interactions/organ toxicity dominate.", "Agent-specific; assess current labeling and clinical status.", ["ECG/QT", "thyroid", "hepatic", "pulmonary", "drug interactions"], ["bradycardia", "organ toxicity", "QT prolongation"], ["warfarin", "digoxin", "QT-prolonging drugs", "CYP/P-gp substrates"], "Loading and maintenance regimens differ.", "Formulation-specific.", ["qt", "bradycardia", "cyp3a4"])
    CRD5_AddRecord(219, "Fexofenadine", ["Fexofenadine", "fexofenadine", "Allegra"], "second-generation antihistamine", "antiallergic", "antihistamine", ["allergic rhinitis", "urticaria"], "Dose adjust selected agents.", "Agent-specific; assess current labeling and clinical status.", ["sedation for selected agents", "renal function"], ["sedation possible"], ["CNS depressants for sedating agents"], "Product-specific food/antacid separation may apply.", "Product-specific.", [])
    CRD5_AddRecord(220, "Liothyronine", ["Liothyronine", "liothyronine", "Cytomel"], "thyroid-axis medication", "endocrine", "thyroid", ["hypothyroidism or hyperthyroidism depending on agent"], "Usually no direct adjustment.", "Usually limited adjustment.", ["TSH/free T4", "clinical response"], ["cardiac overstimulation if excessive", "agranulocytosis/hepatotoxicity for methimazole"], ["calcium/iron", "warfarin", "enzyme inducers"], "Levothyroxine requires consistent empty-stomach timing and separation from cations.", "Formulation-specific.", ["thyroid", "cation_interaction"])
    CRD5_AddRecord(221, "Bisoprolol", ["Bisoprolol", "bisoprolol"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(222, "Omega-3-acid Ethyl Esters", ["Omega-3-acid Ethyl Esters", "omega-3-acid ethyl esters"], "non-statin lipid-lowering agent", "lipid lowering", "lipid_other", ["hyperlipidemia", "ASCVD risk reduction for selected agents"], "Agent-specific.", "Agent-specific; fibrates/niacin require hepatic attention.", ["lipid panel", "hepatic or muscle symptoms when relevant"], ["myopathy when combined with statins for selected agents", "hepatic effects"], ["statins", "warfarin for selected agents"], "Product-specific food and formulation directions.", "Formulation-specific.", ["lipid", "myopathy", "hepatic"])
    CRD5_AddRecord(223, "Flecainide", ["Flecainide", "flecainide", "Tambocor"], "antiarrhythmic", "antiarrhythmic", "antiarrhythmic", ["atrial/ventricular arrhythmias"], "Agent-specific.", "Agent-specific; assess current labeling and clinical status.", ["ECG", "QRS/QT", "renal/hepatic function"], ["proarrhythmia"], ["AV nodal blockers", "CYP modifiers"], "Specialist-directed dosing.", "Formulation-specific.", ["qt", "bradycardia"])
    CRD5_AddRecord(224, "Oxcarbazepine", ["Oxcarbazepine", "oxcarbazepine", "Trileptal"], "antiepileptic/mood stabilizer", "neurologic", "antiepileptic", ["seizure disorders", "mood stabilization or migraine depending on agent"], "Many agents require renal adjustment.", "Valproate/carbamazepine/lamotrigine require hepatic attention.", ["seizure control", "mood/suicidality", "drug-specific labs/levels"], ["serious rash for selected agents", "teratogenicity varies", "CNS effects"], ["enzyme inducers/inhibitors", "oral contraceptives", "CNS depressants"], "Avoid abrupt discontinuation.", "Do not crush extended-release products.", ["antiepileptic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(225, "Desogestrel; Ethinyl Estradiol", ["Desogestrel; Ethinyl Estradiol", "desogestrel", "ethinyl estradiol", "Desogestrel/ Ethinyl Estradiol", "Desogestrel +  Ethinyl Estradiol"], "combined or progestin hormonal contraceptive", "contraception/hormonal therapy", "contraceptive", ["contraception", "cycle control"], "Product-specific; drospirenone has potassium considerations.", "Avoid significant hepatic disease.", ["blood pressure", "thrombotic risk", "adherence"], ["thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["strong enzyme inducers", "selected antiepileptics"], "Consistent daily use; missed-dose instructions are product-specific.", "Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(226, "Ascorbic Acid", ["Ascorbic Acid", "ascorbic acid"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(227, "Sodium Salts", ["Sodium Salts", "sodium salts"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(228, "Ketorolac", ["Ketorolac", "ketorolac", "Toradol"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(229, "Dorzolamide; Timolol", ["Dorzolamide; Timolol", "dorzolamide", "timolol", "Timoptic", "Dorzolamide/ Timolol", "Dorzolamide +  Timolol"], "beta-adrenergic blocker + ophthalmic medication", "cardiovascular + ocular therapy", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure", "glaucoma, allergy, infection, or ocular condition depending on agent"], "Agent-specific; atenolol requires renal adjustment. | Usually no routine adjustment for topical use.", "Agent-specific. | Usually no routine adjustment for topical use.", ["heart rate", "blood pressure", "heart block", "glucose masking", "ocular response", "local irritation", "systemic beta-blockade when relevant"], ["bradycardia", "heart block", "bronchospasm risk", "contamination risk", "systemic effects possible with selected agents"], ["non-DHP calcium channel blockers", "other AV nodal blockers", "other ocular agents; separate drops by several minutes"], "Avoid abrupt discontinuation of chronic therapy. | Use proper drop technique and nasolacrimal occlusion when appropriate.", "Do not crush extended-release formulations. | Not applicable.", ["bradycardia", "av_node", "ophthalmic"])
    CRD5_AddRecord(230, "Promethazine", ["Promethazine", "promethazine", "Phenergan"], "anticholinergic agent", "symptom-specific", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk"], ["other anticholinergics", "CNS depressants"], "Avoid unnecessary cumulative anticholinergic burden.", "Do not crush extended-release products.", ["anticholinergic", "fall_risk", "constipation"])
    CRD5_AddRecord(231, "Levofloxacin", ["Levofloxacin", "levofloxacin", "Levaquin"], "fluoroquinolone antibiotic", "antimicrobial", "fluoroquinolone", ["susceptible bacterial infections"], "Ciprofloxacin/levofloxacin require renal adjustment; moxifloxacin generally does not.", "Agent-specific.", ["renal function", "QT risk", "CNS/tendon symptoms", "glucose"], ["tendon rupture", "neuropathy/CNS effects", "aortic-risk warning", "QT prolongation"], ["cation products", "QT-prolonging drugs", "warfarin"], "Separate oral doses from polyvalent cations.", "Formulation-specific.", ["antibiotic", "qt", "renal", "cation_interaction"])
    CRD5_AddRecord(232, "Labetalol", ["Labetalol", "labetalol", "Trandate"], "beta-adrenergic blocker", "cardiovascular", "beta_blocker", ["hypertension", "rate control", "ischemic heart disease", "selected heart failure"], "Agent-specific; atenolol requires renal adjustment.", "Agent-specific.", ["heart rate", "blood pressure", "heart block", "glucose masking"], ["bradycardia", "heart block", "bronchospasm risk"], ["non-DHP calcium channel blockers", "other AV nodal blockers"], "Avoid abrupt discontinuation of chronic therapy.", "Do not crush extended-release formulations.", ["bradycardia", "av_node"])
    CRD5_AddRecord(233, "Nystatin", ["Nystatin", "nystatin", "Mycostatin"], "antifungal", "antifungal", "other_antifungal", ["fungal infection"], "Agent-specific.", "Systemic terbinafine requires major hepatic attention.", ["clinical response", "hepatic function for systemic terbinafine"], ["hepatotoxicity for systemic therapy"], ["CYP-mediated interactions for selected agents"], "Route/site specific.", "Formulation-specific.", ["antifungal", "hepatic"])
    CRD5_AddRecord(234, "Cyproheptadine", ["Cyproheptadine", "cyproheptadine"], "anticholinergic agent", "symptom-specific", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk"], ["other anticholinergics", "CNS depressants"], "Avoid unnecessary cumulative anticholinergic burden.", "Do not crush extended-release products.", ["anticholinergic", "fall_risk", "constipation"])
    CRD5_AddRecord(235, "Erythromycin", ["Erythromycin", "erythromycin"], "macrolide antibiotic", "antimicrobial", "macrolide", ["respiratory/atypical infections", "other susceptible infections"], "Azithromycin usually has limited renal adjustment.", "Use caution in significant hepatic disease.", ["QT risk", "hepatic function when indicated", "clinical response"], ["QT prolongation", "hepatotoxicity"], ["QT-prolonging drugs", "CYP3A4 interactions especially erythromycin"], "Formulation-specific antacid separation.", "Formulation-specific.", ["antibiotic", "qt", "hepatic"])
    CRD5_AddRecord(236, "Dutasteride", ["Dutasteride", "dutasteride", "Avodart"], "5-alpha-reductase inhibitor", "BPH/alopecia", "five_alpha_reductase", ["BPH", "androgenic alopecia for selected products"], "No routine adjustment.", "Agent-specific; assess current labeling and clinical status.", ["PSA interpretation", "symptom response"], ["pregnancy exposure handling warning"], ["few major interactions"], "Pregnant persons should not handle crushed/broken tablets.", "Do not crush; handling precautions apply.", ["hazardous"])
    CRD5_AddRecord(237, "Moxifloxacin", ["Moxifloxacin", "moxifloxacin", "Avelox"], "fluoroquinolone antibiotic", "antimicrobial", "fluoroquinolone", ["susceptible bacterial infections"], "Ciprofloxacin/levofloxacin require renal adjustment; moxifloxacin generally does not.", "Agent-specific.", ["renal function", "QT risk", "CNS/tendon symptoms", "glucose"], ["tendon rupture", "neuropathy/CNS effects", "aortic-risk warning", "QT prolongation"], ["cation products", "QT-prolonging drugs", "warfarin"], "Separate oral doses from polyvalent cations.", "Formulation-specific.", ["antibiotic", "qt", "renal", "cation_interaction"])
    CRD5_AddRecord(238, "Bimatoprost", ["Bimatoprost", "bimatoprost", "Lumigan"], "ophthalmic medication", "ocular therapy", "ophthalmic", ["glaucoma, allergy, infection, or ocular condition depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment for topical use.", ["ocular response", "local irritation", "systemic beta-blockade when relevant"], ["contamination risk", "systemic effects possible with selected agents"], ["other ocular agents; separate drops by several minutes"], "Use proper drop technique and nasolacrimal occlusion when appropriate.", "Not applicable.", ["ophthalmic"])
    CRD5_AddRecord(239, "Primidone", ["Primidone", "primidone", "Mysoline"], "antiepileptic/mood stabilizer", "neurologic", "antiepileptic", ["seizure disorders", "mood stabilization or migraine depending on agent"], "Many agents require renal adjustment.", "Valproate/carbamazepine/lamotrigine require hepatic attention.", ["seizure control", "mood/suicidality", "drug-specific labs/levels"], ["serious rash for selected agents", "teratogenicity varies", "CNS effects"], ["enzyme inducers/inhibitors", "oral contraceptives", "CNS depressants"], "Avoid abrupt discontinuation.", "Do not crush extended-release products.", ["antiepileptic", "cns_depressant", "fall_risk"])
    CRD5_AddRecord(240, "Sucralfate", ["Sucralfate", "sucralfate", "Carafate"], "mucosal protective agent", "GI therapy", "mucosal_protectant", ["ulcer disease"], "Use caution in advanced renal dysfunction.", "Agent-specific; assess current labeling and clinical status.", ["symptom response", "constipation", "aluminum burden in renal failure"], ["bezoar/aspiration risk in susceptible patients"], ["binds many oral medications"], "Separate from other oral drugs.", "Tablets may be dispersed/crushed per product-specific practice.", ["renal", "cation_interaction"])
    CRD5_AddRecord(241, "Betamethasone; Clotrimazole", ["Betamethasone; Clotrimazole", "betamethasone", "clotrimazole", "Betamethasone/ Clotrimazole", "Betamethasone +  Clotrimazole"], "azole antifungal + topical corticosteroid", "antifungal + dermatologic anti-inflammatory", "azole", ["fungal infections", "inflammatory dermatoses"], "Fluconazole requires renal adjustment. | No routine adjustment.", "Systemic azoles require hepatic caution. | No routine adjustment.", ["hepatic function", "QT risk for systemic agents", "drug interactions", "skin atrophy", "treatment area/duration", "infection"], ["hepatotoxicity", "QT effects for systemic agents", "skin atrophy", "systemic absorption with extensive/high-potency use"], ["CYP-mediated interactions", "warfarin", "QT-prolonging drugs", "other local irritants"], "Route/formulation specific. | Use the lowest effective potency and duration; avoid inappropriate occlusion.", "Formulation-specific. | Not applicable.", ["antifungal", "hepatic", "qt", "cyp", "topical_steroid"])
    CRD5_AddRecord(242, "Senna; Docusate", ["Senna; Docusate", "senna", "docusate", "Colace", "Senna/ Docusate", "Senna +  Docusate"], "bowel-regimen agent", "constipation therapy", "bowel_regimen", ["constipation", "bowel preparation depending on product"], "Use caution with electrolyte-containing products in renal dysfunction.", "Usually limited adjustment.", ["bowel response", "hydration", "electrolytes when intensive"], ["dehydration/electrolyte disturbance with overuse"], ["separate from selected oral drugs"], "Product-specific mixing and timing.", "Product-specific.", ["bowel_regimen"])
    CRD5_AddRecord(243, "Bumetanide", ["Bumetanide", "bumetanide", "Bumex"], "loop diuretic", "diuretic", "loop_diuretic", ["edema", "heart failure"], "Dose to response; monitor renal function and volume status.", "Electrolyte shifts may worsen encephalopathy.", ["volume status", "sodium", "potassium", "magnesium", "renal function"], ["volume depletion", "electrolyte depletion", "ototoxicity at high exposure"], ["NSAIDs", "lithium", "other ototoxins"], "Morning timing when possible; IV rate is product-specific.", "Immediate-release generally; verify formulation.", ["diuretic", "hypokalemia", "renal", "volume_depletion"])
    CRD5_AddRecord(244, "Icosapent Ethyl", ["Icosapent Ethyl", "icosapent ethyl", "Vascepa"], "non-statin lipid-lowering agent", "lipid lowering", "lipid_other", ["hyperlipidemia", "ASCVD risk reduction for selected agents"], "Agent-specific.", "Agent-specific; fibrates/niacin require hepatic attention.", ["lipid panel", "hepatic or muscle symptoms when relevant"], ["myopathy when combined with statins for selected agents", "hepatic effects"], ["statins", "warfarin for selected agents"], "Product-specific food and formulation directions.", "Formulation-specific.", ["lipid", "myopathy", "hepatic"])
    CRD5_AddRecord(245, "Solifenacin", ["Solifenacin", "solifenacin", "Vesicare"], "anticholinergic agent", "symptom-specific", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk"], ["other anticholinergics", "CNS depressants"], "Avoid unnecessary cumulative anticholinergic burden.", "Do not crush extended-release products.", ["anticholinergic", "fall_risk", "constipation"])
    CRD5_AddRecord(246, "Dexamethasone", ["Dexamethasone", "dexamethasone", "Decadron"], "systemic corticosteroid", "anti-inflammatory/immunosuppressant", "systemic_steroid", ["inflammatory disease", "allergic disease", "adrenal replacement for selected agents"], "Usually no renal dose adjustment.", "Conversion/protein binding may vary.", ["glucose", "blood pressure", "infection", "psychiatric effects", "bone risk with prolonged use"], ["infection", "hyperglycemia", "adrenal suppression"], ["NSAIDs", "vaccines", "glucose-lowering therapy"], "Consider taper after prolonged exposure; give with food when appropriate.", "Immediate-release generally; verify formulation.", ["steroid", "hyperglycemia", "infection"])
    CRD5_AddRecord(247, "Epinephrine", ["Epinephrine", "epinephrine", "Adrenalin", "EpiPen"], "alpha/beta adrenergic agonist", "emergency cardiovascular/anaphylaxis therapy", "emergency_adrenergic", ["anaphylaxis", "cardiac arrest", "shock depending on formulation"], "No routine adjustment in emergencies.", "No routine adjustment in emergencies.", ["heart rate/rhythm", "blood pressure", "perfusion", "extravasation"], ["dosing/concentration errors", "arrhythmia", "ischemia"], ["other sympathomimetics", "beta blockers may blunt anaphylaxis response"], "Concentration, route, and indication must be verified before administration.", "Not applicable.", ["vasopressor", "tachycardia", "extravasation"])
    CRD5_AddRecord(248, "Penicillin V", ["Penicillin V", "penicillin v"], "penicillin-class antibiotic", "antimicrobial", "penicillin", ["susceptible bacterial infections"], "Most require renal adjustment.", "Amoxicillin/clavulanate requires hepatic review.", ["allergy", "renal function", "clinical response"], ["hypersensitivity", "C. difficile-associated diarrhea"], ["methotrexate", "warfarin monitoring context"], "Food and formulation advice are product-specific.", "Many immediate-release products have liquid alternatives.", ["antibiotic", "beta_lactam", "renal", "allergy"])
    CRD5_AddRecord(249, "Calcitriol", ["Calcitriol", "calcitriol"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(250, "Oseltamivir", ["Oseltamivir", "oseltamivir", "Tamiflu"], "antiviral", "antiviral", "antiviral", ["virus-specific treatment/prophylaxis"], "Many require renal adjustment.", "Ritonavir-containing regimens require hepatic and interaction review.", ["renal function", "interaction burden", "virus-specific response"], ["drug interactions", "renal toxicity for selected agents"], ["nirmatrelvir/ritonavir has extensive CYP3A interaction burden", "nephrotoxins with acyclovir/tenofovir"], "Timing and duration are indication-specific.", "Formulation-specific.", ["antiviral", "renal", "cyp3a4"])
    CRD5_AddRecord(251, "Polymyxin B; Trimethoprim", ["Polymyxin B; Trimethoprim", "polymyxin b", "trimethoprim", "TMP", "Polymyxin B/ Trimethoprim", "Polymyxin B +  Trimethoprim"], "sulfonamide/folate antagonist antibiotic", "antimicrobial", "sulfa_antibiotic", ["UTI", "skin infection", "Pneumocystis treatment/prophylaxis"], "Requires renal adjustment.", "Avoid severe hepatic dysfunction.", ["renal function", "potassium", "CBC", "rash"], ["severe cutaneous reactions", "hyperkalemia", "marrow suppression"], ["warfarin", "ACEI/ARB/spironolactone", "methotrexate"], "Ensure hydration when appropriate.", "Tablets are generally crushable; verify formulation.", ["antibiotic", "renal", "hyperkalemia", "marrow", "sulfa"])
    CRD5_AddRecord(252, "Dextromethorphan; Promethazine", ["Dextromethorphan; Promethazine", "dextromethorphan", "promethazine", "Phenergan", "Dextromethorphan/ Promethazine", "Dextromethorphan +  Promethazine"], "anticholinergic agent + cough/cold symptomatic therapy", "symptom-specific + respiratory symptom relief", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent", "cough", "congestion", "upper-respiratory symptoms"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth", "sedation", "blood pressure/heart rate", "duplicate ingredients"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk", "sedation or hypertension depending on ingredient"], ["other anticholinergics", "CNS depressants", "MAO inhibitors for decongestants/dextromethorphan"], "Avoid unnecessary cumulative anticholinergic burden. | Avoid duplicate combination-product ingredients.", "Do not crush extended-release products. | Formulation-specific.", ["anticholinergic", "fall_risk", "constipation", "cns_depressant", "stimulant"])
    CRD5_AddRecord(253, "Terbinafine", ["Terbinafine", "terbinafine", "Lamisil"], "antifungal", "antifungal", "other_antifungal", ["fungal infection"], "Agent-specific.", "Systemic terbinafine requires major hepatic attention.", ["clinical response", "hepatic function for systemic terbinafine"], ["hepatotoxicity for systemic therapy"], ["CYP-mediated interactions for selected agents"], "Route/site specific.", "Formulation-specific.", ["antifungal", "hepatic"])
    CRD5_AddRecord(254, "Linagliptin", ["Linagliptin", "linagliptin", "Tradjenta"], "DPP-4 inhibitor", "oral antihyperglycemic", "dpp4", ["type 2 diabetes"], "Sitagliptin requires renal adjustment; linagliptin generally does not.", "Agent-specific.", ["glucose", "pancreatitis symptoms", "heart failure symptoms for selected agents"], ["pancreatitis warning", "severe joint pain"], ["other glucose-lowering drugs"], "Once-daily oral therapy.", "Product-specific.", ["hypoglycemia"])
    CRD5_AddRecord(255, "Methimazole", ["Methimazole", "methimazole", "Tapazole"], "thyroid-axis medication", "endocrine", "thyroid", ["hypothyroidism or hyperthyroidism depending on agent"], "Usually no direct adjustment.", "Usually limited adjustment.", ["TSH/free T4", "clinical response"], ["cardiac overstimulation if excessive", "agranulocytosis/hepatotoxicity for methimazole"], ["calcium/iron", "warfarin", "enzyme inducers"], "Levothyroxine requires consistent empty-stomach timing and separation from cations.", "Formulation-specific.", ["thyroid", "cation_interaction"])
    CRD5_AddRecord(256, "Metoclopramide", ["Metoclopramide", "metoclopramide", "Reglan"], "dopamine antagonist/prokinetic", "antiemetic/prokinetic", "dopamine_antagonist", ["nausea/vomiting", "gastroparesis"], "Requires renal adjustment.", "Agent-specific; assess current labeling and clinical status.", ["movement symptoms", "QT", "mental status"], ["boxed tardive dyskinesia warning"], ["antipsychotics", "other dopamine antagonists", "QT-prolonging drugs"], "Limit duration when possible.", "Tablets generally crushable; verify product.", ["qt", "cns_depressant"])
    CRD5_AddRecord(257, "Medroxyprogesterone", ["Medroxyprogesterone", "medroxyprogesterone", "Provera", "Depo-Provera"], "hormonal therapy", "endocrine/reproductive therapy", "hormone", ["agent-specific endocrine or reproductive indication"], "Usually no simple adjustment.", "Avoid/use cautiously in significant hepatic disease depending on agent.", ["indication-specific response", "thrombotic or metabolic risk", "relevant labs"], ["thromboembolism or hormone-sensitive malignancy risk depending on agent"], ["enzyme inducers", "anticoagulants or hormone-sensitive therapies"], "Formulations/routes are not automatically interchangeable.", "Formulation-specific; hazardous-handling may apply.", ["hormone", "thrombosis"])
    CRD5_AddRecord(258, "Pancrelipase Amylase; Pancrelipase Lipase; Pancrelipase Protease", ["Pancrelipase Amylase; Pancrelipase Lipase; Pancrelipase Protease", "pancrelipase amylase", "pancrelipase lipase", "pancrelipase protease", "Pancrelipase Amylase/ Pancrelipase Lipase/ Pancrelipase Protease", "Pancrelipase Amylase +  Pancrelipase Lipase +  Pancrelipase Protease"], "pancreatic enzyme replacement", "digestive enzyme", "pancreatic_enzyme", ["exocrine pancreatic insufficiency"], "No standard renal adjustment.", "Agent-specific; assess current labeling and clinical status.", ["weight/nutrition", "stool response", "uric acid at high doses"], ["fibrosing colonopathy at high exposure"], ["acid suppression may affect response"], "Take with meals/snacks; do not crush enteric-coated beads.", "Do not crush or chew enteric-coated beads.", [])
    CRD5_AddRecord(259, "Clotrimazole", ["Clotrimazole", "clotrimazole"], "azole antifungal", "antifungal", "azole", ["fungal infections"], "Fluconazole requires renal adjustment.", "Systemic azoles require hepatic caution.", ["hepatic function", "QT risk for systemic agents", "drug interactions"], ["hepatotoxicity", "QT effects for systemic agents"], ["CYP-mediated interactions", "warfarin", "QT-prolonging drugs"], "Route/formulation specific.", "Formulation-specific.", ["antifungal", "hepatic", "qt", "cyp"])
    CRD5_AddRecord(260, "Dexamethasone; Neomycin; Polymyxin B", ["Dexamethasone; Neomycin; Polymyxin B", "dexamethasone", "neomycin", "polymyxin b", "Decadron", "Dexamethasone/ Neomycin/ Polymyxin B", "Dexamethasone +  Neomycin +  Polymyxin B"], "systemic corticosteroid", "anti-inflammatory/immunosuppressant", "systemic_steroid", ["inflammatory disease", "allergic disease", "adrenal replacement for selected agents"], "Usually no renal dose adjustment.", "Conversion/protein binding may vary.", ["glucose", "blood pressure", "infection", "psychiatric effects", "bone risk with prolonged use"], ["infection", "hyperglycemia", "adrenal suppression"], ["NSAIDs", "vaccines", "glucose-lowering therapy"], "Consider taper after prolonged exposure; give with food when appropriate.", "Immediate-release generally; verify formulation.", ["steroid", "hyperglycemia", "infection"])
    CRD5_AddRecord(261, "Calcium Phosphate; Cholecalciferol", ["Calcium Phosphate; Cholecalciferol", "calcium phosphate", "cholecalciferol", "Calcium Phosphate/ Cholecalciferol", "Calcium Phosphate +  Cholecalciferol"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(262, "Acetaminophen; Butalbital; Caffeine", ["Acetaminophen; Butalbital; Caffeine", "acetaminophen", "butalbital", "caffeine", "Tylenol", "APAP", "Acetaminophen/ Butalbital/ Caffeine", "Acetaminophen +  Butalbital +  Caffeine"], "nonopioid analgesic or combination analgesic", "pain/headache therapy", "analgesic_nonopioid", ["pain", "fever", "headache"], "Usually limited adjustment, but chronic/high exposure requires caution.", "Acetaminophen total daily exposure is critical in hepatic risk.", ["total acetaminophen exposure", "sedation for butalbital combinations", "headache frequency"], ["hepatotoxicity", "medication-overuse headache", "sedation/dependence with butalbital"], ["alcohol", "warfarin with sustained high acetaminophen exposure", "CNS depressants"], "Count all combination-product acetaminophen.", "Formulation-specific.", ["acetaminophen", "cns_depressant"])
    CRD5_AddRecord(263, "Guanfacine", ["Guanfacine", "guanfacine"], "central alpha-2 agonist", "antihypertensive/ADHD", "central_alpha2", ["hypertension", "ADHD depending on product"], "Agent-specific.", "Agent-specific; assess current labeling and clinical status.", ["blood pressure", "heart rate", "sedation"], ["rebound hypertension with abrupt stop"], ["CNS depressants", "other antihypertensives"], "Taper rather than abruptly discontinue.", "Do not crush extended-release products.", ["bradycardia", "cns_depressant", "hypotension"])
    CRD5_AddRecord(264, "Sodium Fluoride", ["Sodium Fluoride", "sodium fluoride"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(265, "Codeine; Guaifenesin", ["Codeine; Guaifenesin", "codeine", "guaifenesin", "Codeine/ Guaifenesin", "Codeine +  Guaifenesin"], "opioid agonist + cough/cold symptomatic therapy", "analgesic + respiratory symptom relief", "opioid", ["moderate to severe pain", "cough", "congestion", "upper-respiratory symptoms"], "Metabolite accumulation varies; morphine requires high renal caution. | Agent-specific.", "Start conservatively. | Agent-specific.", ["pain response", "sedation", "respiratory rate", "bowel function", "blood pressure/heart rate", "duplicate ingredients"], ["respiratory depression", "dependence", "overdose", "sedation or hypertension depending on ingredient"], ["benzodiazepines", "alcohol", "other CNS depressants", "serotonergic drugs for tramadol", "MAO inhibitors for decongestants/dextromethorphan", "CNS depressants"], "Use bowel regimen when appropriate; never crush ER products. | Avoid duplicate combination-product ingredients.", "Never crush extended-release or abuse-deterrent products. | Formulation-specific.", ["opioid", "cns_depressant", "resp_depression", "constipation", "stimulant"])
    CRD5_AddRecord(266, "Lactulose", ["Lactulose", "lactulose", "Enulose"], "laxative", "bowel regimen", "laxative", ["constipation", "bowel preparation depending on product"], "Use caution with fluid/electrolyte disorders.", "Agent-specific; assess current labeling and clinical status.", ["bowel response", "hydration", "electrolytes when intensive"], ["dehydration/electrolyte disturbance with overuse"], ["separation from selected oral drugs"], "Product-specific mixing and timing.", "Product-specific.", [])
    CRD5_AddRecord(267, "Fluorouracil", ["Fluorouracil", "fluorouracil"], "dermatologic agent", "topical skin therapy", "dermatologic", ["acne, dyschromia, actinic damage, or neoplastic lesions depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment.", ["local irritation", "treatment response", "pregnancy risk when relevant"], ["photosensitivity/irritation", "pregnancy or hazardous-handling concerns for selected agents"], ["other irritating topical products"], "Use site- and product-specific application instructions.", "Not applicable.", ["topical", "hazardous"])
    CRD5_AddRecord(268, "Ipratropium", ["Ipratropium", "ipratropium", "Atrovent"], "inhaled bronchodilator", "airway therapy", "bronchodilator", ["asthma", "COPD"], "No routine adjustment.", "Usually limited adjustment.", ["symptom control", "heart rate/tremor", "anticholinergic effects"], ["tachycardia", "paradoxical bronchospasm"], ["other sympathomimetics", "anticholinergic burden"], "Device technique is essential; LABA/LAMA are maintenance, not rescue.", "Not applicable.", ["bronchodilator", "tachycardia"])
    CRD5_AddRecord(269, "Olopatadine", ["Olopatadine", "olopatadine"], "ophthalmic medication", "ocular therapy", "ophthalmic", ["glaucoma, allergy, infection, or ocular condition depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment for topical use.", ["ocular response", "local irritation", "systemic beta-blockade when relevant"], ["contamination risk", "systemic effects possible with selected agents"], ["other ocular agents; separate drops by several minutes"], "Use proper drop technique and nasolacrimal occlusion when appropriate.", "Not applicable.", ["ophthalmic"])
    CRD5_AddRecord(270, "Chlorhexidine", ["Chlorhexidine", "chlorhexidine"], "topical antimicrobial/antiseptic", "local anti-infective", "topical_antimicrobial", ["localized bacterial/fungal infection or antisepsis"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment.", ["local response", "irritation", "treatment duration"], ["local hypersensitivity", "avoid inappropriate prolonged use"], ["few systemic interactions"], "Apply only to intended site; avoid contamination.", "Not applicable.", ["topical"])
    CRD5_AddRecord(271, "Nabumetone", ["Nabumetone", "nabumetone"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(272, "Mometasone", ["Mometasone", "mometasone"], "inhaled/intranasal corticosteroid", "airway anti-inflammatory", "inhaled_steroid", ["asthma/COPD maintenance", "allergic rhinitis"], "No routine renal adjustment.", "Systemic exposure may increase with strong CYP3A4 inhibitors.", ["symptom control", "oral candidiasis", "local nasal effects"], ["not a rescue inhaler", "local candidiasis"], ["strong CYP3A4 inhibitors"], "Rinse mouth after inhaled use; technique matters.", "Not applicable.", ["inhaled_steroid"])
    CRD5_AddRecord(273, "Polyethylene Glycol 3350 With Electrolytes", ["Polyethylene Glycol 3350 With Electrolytes", "polyethylene glycol 3350 with electrolytes"], "bowel-regimen agent", "constipation therapy", "bowel_regimen", ["constipation", "bowel preparation depending on product"], "Use caution with electrolyte-containing products in renal dysfunction.", "Usually limited adjustment.", ["bowel response", "hydration", "electrolytes when intensive"], ["dehydration/electrolyte disturbance with overuse"], ["separate from selected oral drugs"], "Product-specific mixing and timing.", "Product-specific.", ["bowel_regimen"])
    CRD5_AddRecord(274, "Hydroquinone", ["Hydroquinone", "hydroquinone"], "dermatologic agent", "topical skin therapy", "dermatologic", ["acne, dyschromia, actinic damage, or neoplastic lesions depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment.", ["local irritation", "treatment response", "pregnancy risk when relevant"], ["photosensitivity/irritation", "pregnancy or hazardous-handling concerns for selected agents"], ["other irritating topical products"], "Use site- and product-specific application instructions.", "Not applicable.", ["topical", "hazardous"])
    CRD5_AddRecord(275, "Phenazopyridine", ["Phenazopyridine", "phenazopyridine"], "urinary tract analgesic", "urinary symptom relief", "urinary_analgesic", ["short-term dysuria relief"], "Avoid or dose-limit in renal impairment.", "Use cautiously.", ["symptom duration", "renal function", "urine discoloration counseling"], ["hemolysis/methemoglobinemia risk", "masks ongoing symptoms"], ["few major interactions"], "Short-term symptomatic therapy; does not treat infection.", "Tablets generally swallow whole; verify product.", ["renal"])
    CRD5_AddRecord(276, "Loperamide", ["Loperamide", "loperamide", "Imodium"], "peripheral opioid antidiarrheal", "antidiarrheal", "antidiarrheal", ["acute diarrhea"], "Usually no adjustment at labeled use.", "Agent-specific; assess current labeling and clinical status.", ["stool output", "abdominal distension", "CNS/cardiac toxicity if excessive"], ["ileus/toxic megacolon risk", "arrhythmia with abuse"], ["P-gp/CYP inhibitors at excessive doses"], "Avoid in inflammatory/bloody diarrhea unless specifically directed.", "Capsules/tablets product-specific.", ["opioid"])
    CRD5_AddRecord(277, "Lidocaine", ["Lidocaine", "lidocaine", "Xylocaine", "Lidoderm"], "local anesthetic", "local analgesia/antiarrhythmic depending on route", "local_anesthetic", ["local anesthesia", "topical pain", "ventricular arrhythmia for IV use"], "Usually limited direct adjustment.", "Systemic clearance is hepatic; reduce exposure in severe dysfunction/low flow states.", ["dose by route/site", "CNS/cardiac toxicity"], ["local anesthetic systemic toxicity"], ["other local anesthetics/antiarrhythmics"], "Route and maximum dose are critical.", "Not applicable for patches/injections; oral forms uncommon.", ["narrow_therapeutic_index"])
    CRD5_AddRecord(278, "Ciclopirox", ["Ciclopirox", "ciclopirox"], "topical antimicrobial/antiseptic", "local anti-infective", "topical_antimicrobial", ["localized bacterial/fungal infection or antisepsis"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment.", ["local response", "irritation", "treatment duration"], ["local hypersensitivity", "avoid inappropriate prolonged use"], ["few systemic interactions"], "Apply only to intended site; avoid contamination.", "Not applicable.", ["topical"])
    CRD5_AddRecord(279, "Cefuroxime", ["Cefuroxime", "cefuroxime", "Ceftin"], "cephalosporin antibiotic", "antimicrobial", "cephalosporin", ["susceptible bacterial infections"], "Most require renal adjustment.", "Usually limited adjustment.", ["allergy", "renal function", "clinical response"], ["hypersensitivity", "C. difficile-associated diarrhea"], ["warfarin monitoring context"], "Food/suspension handling is formulation-specific.", "Many immediate-release products have liquid alternatives.", ["antibiotic", "beta_lactam", "renal", "allergy"])
    CRD5_AddRecord(280, "Betamethasone", ["Betamethasone", "betamethasone"], "topical corticosteroid", "dermatologic anti-inflammatory", "topical_steroid", ["inflammatory dermatoses"], "No routine adjustment.", "No routine adjustment.", ["skin atrophy", "treatment area/duration", "infection"], ["skin atrophy", "systemic absorption with extensive/high-potency use"], ["other local irritants"], "Use the lowest effective potency and duration; avoid inappropriate occlusion.", "Not applicable.", ["topical_steroid"])
    CRD5_AddRecord(281, "Brompheniramine; Dextromethorphan; Pseudoephedrine", ["Brompheniramine; Dextromethorphan; Pseudoephedrine", "brompheniramine", "dextromethorphan", "pseudoephedrine", "Sudafed", "Brompheniramine/ Dextromethorphan/ Pseudoephedrine", "Brompheniramine +  Dextromethorphan +  Pseudoephedrine"], "cough/cold symptomatic therapy", "respiratory symptom relief", "cough_cold", ["cough", "congestion", "upper-respiratory symptoms"], "Agent-specific.", "Agent-specific.", ["sedation", "blood pressure/heart rate", "duplicate ingredients"], ["sedation or hypertension depending on ingredient"], ["MAO inhibitors for decongestants/dextromethorphan", "CNS depressants"], "Avoid duplicate combination-product ingredients.", "Formulation-specific.", ["cns_depressant", "stimulant"])
    CRD5_AddRecord(282, "Ethinyl Estradiol; Norgestrel", ["Ethinyl Estradiol; Norgestrel", "ethinyl estradiol", "norgestrel", "Ethinyl Estradiol/ Norgestrel", "Ethinyl Estradiol +  Norgestrel"], "combined or progestin hormonal contraceptive", "contraception/hormonal therapy", "contraceptive", ["contraception", "cycle control"], "Product-specific; drospirenone has potassium considerations.", "Avoid significant hepatic disease.", ["blood pressure", "thrombotic risk", "adherence"], ["thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["strong enzyme inducers", "selected antiepileptics"], "Consistent daily use; missed-dose instructions are product-specific.", "Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(283, "Ciprofloxacin; Dexamethasone", ["Ciprofloxacin; Dexamethasone", "ciprofloxacin", "dexamethasone", "Cipro", "Decadron", "Ciprofloxacin/ Dexamethasone", "Ciprofloxacin +  Dexamethasone"], "systemic corticosteroid + fluoroquinolone antibiotic", "anti-inflammatory/immunosuppressant + antimicrobial", "systemic_steroid", ["inflammatory disease", "allergic disease", "adrenal replacement for selected agents", "susceptible bacterial infections"], "Usually no renal dose adjustment. | Ciprofloxacin/levofloxacin require renal adjustment; moxifloxacin generally does not.", "Conversion/protein binding may vary. | Agent-specific.", ["glucose", "blood pressure", "infection", "psychiatric effects", "bone risk with prolonged use", "renal function", "QT risk", "CNS/tendon symptoms"], ["infection", "hyperglycemia", "adrenal suppression", "tendon rupture", "neuropathy/CNS effects", "aortic-risk warning", "QT prolongation"], ["NSAIDs", "vaccines", "glucose-lowering therapy", "cation products", "QT-prolonging drugs", "warfarin"], "Consider taper after prolonged exposure; give with food when appropriate. | Separate oral doses from polyvalent cations.", "Immediate-release generally; verify formulation. | Formulation-specific.", ["steroid", "hyperglycemia", "infection", "antibiotic", "qt", "renal", "cation_interaction"])
    CRD5_AddRecord(284, "Diphenhydramine", ["Diphenhydramine", "diphenhydramine", "Benadryl"], "anticholinergic agent", "symptom-specific", "anticholinergic", ["overactive bladder", "GI spasm", "allergy/vertigo depending on agent"], "Agent-specific.", "Agent-specific.", ["urinary retention", "constipation", "confusion", "dry mouth"], ["delirium/falls", "urinary retention", "angle-closure glaucoma risk"], ["other anticholinergics", "CNS depressants"], "Avoid unnecessary cumulative anticholinergic burden.", "Do not crush extended-release products.", ["anticholinergic", "fall_risk", "constipation"])
    CRD5_AddRecord(285, "Ethinyl Estradiol; Norelgestromin", ["Ethinyl Estradiol; Norelgestromin", "ethinyl estradiol", "norelgestromin", "Ethinyl Estradiol/ Norelgestromin", "Ethinyl Estradiol +  Norelgestromin"], "combined or progestin hormonal contraceptive", "contraception/hormonal therapy", "contraceptive", ["contraception", "cycle control"], "Product-specific; drospirenone has potassium considerations.", "Avoid significant hepatic disease.", ["blood pressure", "thrombotic risk", "adherence"], ["thromboembolism", "smoking-related cardiovascular risk with estrogen"], ["strong enzyme inducers", "selected antiepileptics"], "Consistent daily use; missed-dose instructions are product-specific.", "Generally swallow whole; product-specific.", ["hormone", "thrombosis", "pregnancy"])
    CRD5_AddRecord(286, "Atropine; Diphenoxylate", ["Atropine; Diphenoxylate", "atropine", "diphenoxylate", "Atropine/ Diphenoxylate", "Atropine +  Diphenoxylate"], "opioid-anticholinergic antidiarrheal", "antidiarrheal", "antidiarrheal_combo", ["diarrhea"], "Usually limited adjustment.", "Use cautiously in hepatic dysfunction.", ["stool output", "sedation", "anticholinergic effects"], ["CNS/respiratory depression with overdose", "toxic megacolon risk"], ["CNS depressants", "anticholinergics"], "Avoid in infectious/inflammatory diarrhea unless directed.", "Tablets generally crushable; verify product.", ["opioid", "anticholinergic", "cns_depressant"])
    CRD5_AddRecord(287, "Indomethacin", ["Indomethacin", "indomethacin", "Indocin"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(288, "Niacin", ["Niacin", "niacin"], "non-statin lipid-lowering agent", "lipid lowering", "lipid_other", ["hyperlipidemia", "ASCVD risk reduction for selected agents"], "Agent-specific.", "Agent-specific; fibrates/niacin require hepatic attention.", ["lipid panel", "hepatic or muscle symptoms when relevant"], ["myopathy when combined with statins for selected agents", "hepatic effects"], ["statins", "warfarin for selected agents"], "Product-specific food and formulation directions.", "Formulation-specific.", ["lipid", "myopathy", "hepatic"])
    CRD5_AddRecord(289, "Lactate", ["Lactate", "lactate"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(290, "Vitamin E", ["Vitamin E", "vitamin e"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(291, "Guaifenesin", ["Guaifenesin", "guaifenesin"], "cough/cold symptomatic therapy", "respiratory symptom relief", "cough_cold", ["cough", "congestion", "upper-respiratory symptoms"], "Agent-specific.", "Agent-specific.", ["sedation", "blood pressure/heart rate", "duplicate ingredients"], ["sedation or hypertension depending on ingredient"], ["MAO inhibitors for decongestants/dextromethorphan", "CNS depressants"], "Avoid duplicate combination-product ingredients.", "Formulation-specific.", ["cns_depressant", "stimulant"])
    CRD5_AddRecord(292, "Pseudoephedrine", ["Pseudoephedrine", "pseudoephedrine", "Sudafed"], "cough/cold symptomatic therapy", "respiratory symptom relief", "cough_cold", ["cough", "congestion", "upper-respiratory symptoms"], "Agent-specific.", "Agent-specific.", ["sedation", "blood pressure/heart rate", "duplicate ingredients"], ["sedation or hypertension depending on ingredient"], ["MAO inhibitors for decongestants/dextromethorphan", "CNS depressants"], "Avoid duplicate combination-product ingredients.", "Formulation-specific.", ["cns_depressant", "stimulant"])
    CRD5_AddRecord(293, "Bisacodyl", ["Bisacodyl", "bisacodyl", "Dulcolax"], "laxative", "bowel regimen", "laxative", ["constipation", "bowel preparation depending on product"], "Use caution with fluid/electrolyte disorders.", "Agent-specific; assess current labeling and clinical status.", ["bowel response", "hydration", "electrolytes when intensive"], ["dehydration/electrolyte disturbance with overuse"], ["separation from selected oral drugs"], "Product-specific mixing and timing.", "Product-specific.", [])
    CRD5_AddRecord(294, "Riboflavin", ["Riboflavin", "riboflavin"], "vitamin/mineral/electrolyte supplement", "replacement/supplementation", "vitamin_mineral", ["documented deficiency", "replacement or prevention"], "Dose and accumulation risk are product- and electrolyte-specific.", "Usually limited adjustment.", ["relevant serum level", "renal function when accumulation is possible", "duplicate supplementation"], ["toxicity with excessive dosing", "electrolyte accumulation"], ["levothyroxine", "tetracyclines/fluoroquinolones", "bisphosphonates"], "Separate polyvalent cations from interacting medications when applicable.", "Product/formulation-specific.", ["supplement", "cation_interaction"])
    CRD5_AddRecord(295, "Ivermectin", ["Ivermectin", "ivermectin", "Stromectol"], "antiparasitic", "anti-infective", "antiparasitic", ["parasite-specific treatment"], "Usually limited adjustment.", "Use caution in significant hepatic disease.", ["clinical response", "neurologic or hepatic adverse effects when relevant"], ["neurotoxicity in susceptible contexts"], ["warfarin monitoring context"], "Dose is weight- and indication-specific.", "Tablets generally crushable; verify product.", ["antiparasitic"])
    CRD5_AddRecord(296, "Etodolac", ["Etodolac", "etodolac"], "nonsteroidal anti-inflammatory drug", "analgesic/anti-inflammatory", "nsaid", ["pain", "inflammation"], "Avoid or minimize in significant AKI/advanced CKD.", "Use cautiously in significant hepatic disease.", ["renal function", "blood pressure", "GI bleeding", "fluid retention"], ["GI bleeding", "renal injury", "cardiovascular risk"], ["anticoagulants/antiplatelets", "ACEI/ARB plus diuretic", "other NSAIDs"], "Use the lowest effective dose for the shortest necessary duration.", "Do not crush delayed/extended-release products.", ["nsaid", "bleeding", "renal", "nephrotoxin", "fluid_retention"])
    CRD5_AddRecord(297, "Lactobacillus Acidophilus", ["Lactobacillus Acidophilus", "lactobacillus acidophilus"], "bowel-regimen agent", "constipation therapy", "bowel_regimen", ["constipation", "bowel preparation depending on product"], "Use caution with electrolyte-containing products in renal dysfunction.", "Usually limited adjustment.", ["bowel response", "hydration", "electrolytes when intensive"], ["dehydration/electrolyte disturbance with overuse"], ["separate from selected oral drugs"], "Product-specific mixing and timing.", "Product-specific.", ["bowel_regimen"])
    CRD5_AddRecord(298, "Tobramycin", ["Tobramycin", "tobramycin", "Tobrex"], "ophthalmic medication + antibiotic", "ocular therapy + antimicrobial", "ophthalmic", ["glaucoma, allergy, infection, or ocular condition depending on agent", "susceptible bacterial infections"], "Usually no routine adjustment for topical use. | Agent-specific; nitrofurantoin and tobramycin require renal attention.", "Usually no routine adjustment for topical use. | Clindamycin and nitrofurantoin require hepatic awareness.", ["ocular response", "local irritation", "systemic beta-blockade when relevant", "clinical response", "renal/hepatic function as agent-specific", "toxicity"], ["contamination risk", "systemic effects possible with selected agents", "C. difficile risk", "agent-specific pulmonary, hepatic, or ototoxicity"], ["other ocular agents; separate drops by several minutes", "agent-specific"], "Use proper drop technique and nasolacrimal occlusion when appropriate. | Route/formulation and infection-site specific.", "Not applicable. | Formulation-specific.", ["ophthalmic", "antibiotic", "renal"])
    CRD5_AddRecord(299, "Ketotifen", ["Ketotifen", "ketotifen", "Zaditor"], "ophthalmic medication", "ocular therapy", "ophthalmic", ["glaucoma, allergy, infection, or ocular condition depending on agent"], "Usually no routine adjustment for topical use.", "Usually no routine adjustment for topical use.", ["ocular response", "local irritation", "systemic beta-blockade when relevant"], ["contamination risk", "systemic effects possible with selected agents"], ["other ocular agents; separate drops by several minutes"], "Use proper drop technique and nasolacrimal occlusion when appropriate.", "Not applicable.", ["ophthalmic"])
    CRD5_AddRecord(300, "Loratadine; Pseudoephedrine", ["Loratadine; Pseudoephedrine", "loratadine", "pseudoephedrine", "Sudafed", "Loratadine/ Pseudoephedrine", "Loratadine +  Pseudoephedrine"], "cough/cold symptomatic therapy + second-generation antihistamine", "respiratory symptom relief + antiallergic", "cough_cold", ["cough", "congestion", "upper-respiratory symptoms", "allergic rhinitis", "urticaria"], "Agent-specific. | Dose adjust selected agents.", "Agent-specific. | Agent-specific; assess current labeling and clinical status.", ["sedation", "blood pressure/heart rate", "duplicate ingredients", "sedation for selected agents", "renal function"], ["sedation or hypertension depending on ingredient", "sedation possible"], ["MAO inhibitors for decongestants/dextromethorphan", "CNS depressants", "CNS depressants for sedating agents"], "Avoid duplicate combination-product ingredients. | Product-specific food/antacid separation may apply.", "Formulation-specific. | Product-specific.", ["cns_depressant", "stimulant"])
}

CRD5_AddRecord(rank, generic, keys, pharmacologicClass, therapeuticClass, therapeuticGroup
    , indications, renal, hepatic, monitoring, warnings, interactions, administration, crushability, tags) {
    global _CRD5_ByKey, _CRD5_Records
    rec := Map(
        "rank", rank,
        "generic", generic,
        "keys", keys,
        "pharmacologicClass", pharmacologicClass,
        "therapeuticClass", therapeuticClass,
        "therapeuticGroup", therapeuticGroup,
        "indications", indications,
        "renal", renal,
        "hepatic", hepatic,
        "monitoring", monitoring,
        "warnings", warnings,
        "interactions", interactions,
        "administration", administration,
        "crushability", crushability,
        "tags", tags
    )
    _CRD5_Records.Push(rec)
    for key in keys {
        k := CRD5_NormalizeKey(key)
        if k != ""
            _CRD5_ByKey[k] := rec
    }
}

CRD5_NormalizeKey(value) {
    value := StrLower(Trim(value))
    value := RegExReplace(value, "\b(tablet|capsule|solution|suspension|injection|cream|ointment|patch|spray|inhaler|pen)\b", " ")
    value := RegExReplace(value, "\b(er|xr|xl|sr|dr|ec)\b", " ")
    value := RegExReplace(value, "\b\d+(\.\d+)?\s*(mg|mcg|g|ml|unit|units|%)\b", " ")
    value := StrReplace(value, "/", " ")
    value := StrReplace(value, ";", " ")
    value := StrReplace(value, "+", " ")
    value := RegExReplace(value, "[^a-z0-9 -]", " ")
    return Trim(RegExReplace(value, "\s+", " "))
}

CRD5_ResolveMedicationName(value) {
    CRD5_Load()
    global _CRD5_Records

    candidateKey := CRD5_NormalizeKey(value)
    candidateKey := RegExReplace(candidateKey, "i)\b(hcl|hydrochloride|sodium|potassium|calcium)\b", " ")
    candidateKey := Trim(RegExReplace(candidateKey, "\s+", " "))
    if StrLen(candidateKey) < 5
        return ""

    candidateWords := StrSplit(candidateKey, " ")
    bestRec := ""
    bestAlias := ""
    bestDistance := 1000000
    secondDistance := 1000000

    for rec in _CRD5_Records {
        recDistance := 1000000
        recAlias := ""

        for alias in rec["keys"] {
            aliasKey := CRD5_NormalizeKey(alias)
            aliasKey := RegExReplace(aliasKey, "i)\b(hcl|hydrochloride|sodium|potassium|calcium)\b", " ")
            aliasKey := Trim(RegExReplace(aliasKey, "\s+", " "))
            if StrLen(aliasKey) < 5
                continue

            comparisons := [candidateKey]
            if !InStr(aliasKey, " ") {
                for word in candidateWords {
                    if StrLen(word) >= 5
                        comparisons.Push(word)
                }
            }

            for comparison in comparisons {
                compactCandidate := RegExReplace(comparison, "[^a-z0-9]", "")
                compactAlias := RegExReplace(aliasKey, "[^a-z0-9]", "")
                if Abs(StrLen(compactCandidate) - StrLen(compactAlias)) > 2
                    continue
                distance := PatientV2_EditDistance(compactCandidate, compactAlias)
                if distance < recDistance {
                    recDistance := distance
                    recAlias := alias
                }
            }
        }

        if recDistance < bestDistance {
            secondDistance := bestDistance
            bestDistance := recDistance
            bestRec := rec
            bestAlias := recAlias
        } else if recDistance < secondDistance {
            secondDistance := recDistance
        }
    }

    if !IsObject(bestRec)
        return ""

    matchedLength := StrLen(RegExReplace(CRD5_NormalizeKey(bestAlias), "[^a-z0-9]", ""))
    allowedDistance := matchedLength <= 5 ? 0 : (matchedLength <= 7 ? 1 : 2)
    if bestDistance <= allowedDistance
        && (bestDistance = 0 || secondDistance > bestDistance) {
        return { rec: bestRec, alias: bestAlias, distance: bestDistance }
    }

    return ""
}

CRD5_FindMedication(med) {
    CRD5_Load()
    global _CRD5_ByKey
    candidates := []

    if IsObject(med) {
        if med.HasOwnProp("raw")
            candidates.Push(med.raw)
        if med.HasOwnProp("ingredients") {
            for ing in med.ingredients
                candidates.Push(ing)
        }
    } else {
        candidates.Push(med)
    }

    for candidate in candidates {
        key := CRD5_NormalizeKey(candidate)
        if _CRD5_ByKey.Has(key)
            return _CRD5_ByKey[key]
    }

    ; OCR/order lines usually contain a dose and route. Prefer the longest matching alias.
    best := ""
    bestLen := 0
    for candidate in candidates {
        key := " " CRD5_NormalizeKey(candidate) " "
        for alias, rec in _CRD5_ByKey {
            if StrLen(alias) < 4
                continue
            if InStr(key, " " alias " ") && StrLen(alias) > bestLen {
                best := rec
                bestLen := StrLen(alias)
            }
        }
    }

    ; Conservative OCR recovery. Only a unique close match is accepted; the
    ; medication cleanup pipeline still marks changed names for visual review.
    if !IsObject(best) {
        for candidate in candidates {
            resolved := CRD5_ResolveMedicationName(candidate)
            if IsObject(resolved)
                return resolved.rec
        }
    }
    return best
}

CRD5_ArrayText(arr, sep := ", ") {
    out := ""
    for item in arr
        out .= (out = "" ? "" : sep) item
    return out
}

CRD5_HasTag(rec, wanted) {
    if !IsObject(rec)
        return false
    for tag in rec["tags"]
        if tag = wanted
            return true
    return false
}

CRD5_ActiveRecords(ctx) {
    out := []
    seen := Map()
    for med in PCtx_ConfirmedActiveMeds(ctx) {
        rec := CRD5_FindMedication(med)
        if !IsObject(rec)
            continue
        key := rec["generic"]
        if !seen.Has(key) {
            seen[key] := true
            out.Push(Map("med", med, "rec", rec))
        }
    }
    return out
}

CRD5_PatientReview(ctx) {
    matches := CRD5_ActiveRecords(ctx)
    activeMeds := PCtx_ConfirmedActiveMeds(ctx)
    out := "PATIENT MEDICATION REVIEW`r`n"
        . "======================================================================`r`n"
        . "Medication knowledge evaluated in background: " matches.Length " of " activeMeds.Length " captured active orders.`r`n"
        . "Full class, renal, hepatic, monitoring, interaction, administration, and crush/tube knowledge remains stored in the backend database and is only surfaced when it creates a relevant finding.`r`n"

    if activeMeds.Length = 0
        out .= "`r`nNo active medication orders were recognized.`r`n"
    else if matches.Length < activeMeds.Length
        out .= "`r`n" (activeMeds.Length - matches.Length) " captured order(s) were not matched to the active Top-300 knowledge library.`r`n"
    return out
}

CRD5_MedRecReview(ctx) {
    meds := PCtx_ActiveMeds(ctx)
    matched := []
    unmatched := []
    seenGeneric := Map()
    groupMap := Map()

    out := "MEDICATION RECONCILIATION`r`n"
        . "======================================================================`r`n"
        . "Concise list from the captured session. Backend knowledge is used for findings but is not repeated under every medication.`r`n"

    for med in meds {
        rec := CRD5_FindMedication(med)
        if IsObject(rec) {
            generic := rec["generic"]
            matched.Push(Map("med", med, "rec", rec))
            if !seenGeneric.Has(generic)
                seenGeneric[generic] := []
            seenGeneric[generic].Push(med)

            grp := rec["therapeuticGroup"]
            if grp != "general" {
                if !groupMap.Has(grp)
                    groupMap[grp] := []
                groupMap[grp].Push(rec)
            }
        } else {
            unmatched.Push(med)
        }
    }

    out .= "`r`nRECONCILED MEDICATION LIST`r`n"
    out .= "----------------------------------------------------------------------`r`n"
    if meds.Length = 0 {
        out .= "No active medication list was recognized.`r`n"
    } else {
        n := 0
        for med in meds {
            n += 1
            rec := CRD5_FindMedication(med)
            raw := med.HasOwnProp("raw") ? med.raw : "Medication " n
            if IsObject(rec) {
                out .= n ". " rec["generic"]
                if med.HasOwnProp("dose") && med.dose != ""
                    out .= " | " med.dose
                if med.HasOwnProp("route") && med.route != ""
                    out .= " | " med.route
                compactSig := Sig_CompactFromMedication(med)
                if compactSig != ""
                    out .= " | " compactSig
                out .= "`r`n"
            } else {
                out .= n ". " raw " | NOT MATCHED TO TOP-300 LIBRARY`r`n"
            }
        }
    }

    issues := []
    for generic, list in seenGeneric {
        if list.Length > 1
            issues.Push("POSSIBLE DUPLICATE: " generic " appears " list.Length " times in the captured medication data.")
    }

    ; Therapeutic duplication is displayed, never silently reconciled.
    for grp, recs in groupMap {
        unique := Map()
        for rec in recs
            unique[rec["generic"]] := true
        if unique.Count > 1 {
            names := ""
            for name, _ in unique
                names .= (names = "" ? "" : ", ") name
            issues.Push("THERAPEUTIC DUPLICATION / SUBSTITUTION REVIEW: " names
                . " share the " grp " group. Determine whether this is intentional, formulary substitution, transition, or duplication."
                . Truth_FindingSuffix("therapeutic_duplication"))
        }
    }

    ; Cross-class medication safety patterns.
    CRD5_AddCombinationIssues(matched, issues)

    out .= "`r`nMEDREC FINDINGS`r`n"
    out .= "----------------------------------------------------------------------`r`n"
    if issues.Length = 0
        out .= "No duplicate, therapeutic-overlap, or high-yield combination rule matched the captured list.`r`n"
    else {
        for issue in issues
            out .= "• " issue "`r`n"
    }

    if unmatched.Length {
        out .= "`r`nUNMATCHED ITEMS`r`n"
        out .= "----------------------------------------------------------------------`r`n"
        for med in unmatched
            out .= "• " (med.HasOwnProp("raw") ? med.raw : "Unrecognized medication") "`r`n"
    }

    out .= "`r`nMEDREC DECISIONS TO COMPLETE`r`n"
    out .= "----------------------------------------------------------------------`r`n"
    out .= "• Continue / hold / discontinue decision for each medication`r`n"
    out .= "• Verify indication for drugs without an obvious captured indication`r`n"
    out .= "• Resolve exact duplicates and therapeutic substitutions`r`n"
    out .= "• Confirm dose, route, compact SIG, formulation, and last administration when relevant`r`n"
    out .= "• Prioritize high-risk medications and every item generating a finding`r`n"
    return out
}

CRD5_AddCombinationIssues(items, issues) {
    counts := Map()
    namesByTag := Map()
    groups := Map()

    for item in items {
        rec := item["rec"]
        groups[rec["therapeuticGroup"]] := true
        for tag in rec["tags"] {
            counts[tag] := counts.Has(tag) ? counts[tag] + 1 : 1
            if !namesByTag.Has(tag)
                namesByTag[tag] := []
            namesByTag[tag].Push(rec["generic"])
        }
    }

    if CRD5_GroupPresent(groups, "anticoagulant") && (CRD5_GroupPresent(groups, "antiplatelet") || CRD5_GroupPresent(groups, "nsaid"))
        issues.Push(Truth_FindingText("bleeding_combination", "BLEEDING RISK: anticoagulant plus antiplatelet and/or NSAID therapy is present."))

    if CRD5_TagCount(counts, "opioid") && (CRD5_TagCount(counts, "benzodiazepine")
        || CRD5_TagCount(counts, "gabapentinoid") || CRD5_TagCount(counts, "cns_depressant") > 1)
        issues.Push(Truth_FindingText("cns_respiratory_depression", "CNS/RESPIRATORY DEPRESSION: opioid therapy overlaps with another CNS depressant."))

    if CRD5_TagCount(counts, "serotonergic") > 1
        issues.Push("SEROTONERGIC BURDEN: multiple serotonergic medications are present." Truth_FindingSuffix("serotonergic_burden"))

    if CRD5_TagCount(counts, "qt") > 1
        issues.Push(Truth_FindingText("qt_burden", "QT BURDEN: multiple medications with QT-related review tags are present; assess ECG and electrolytes."))

    if CRD5_TagCount(counts, "hyperkalemia") > 1 || (CRD5_TagCount(counts, "potassium") && CRD5_TagCount(counts, "raas"))
        issues.Push(Truth_FindingText("hyperkalemia_burden", "HYPERKALEMIA RISK: multiple potassium-raising therapies or potassium plus RAAS blockade are present."))

    if CRD5_TagCount(counts, "bradycardia") > 1 || CRD5_TagCount(counts, "av_node") > 1
        issues.Push(Truth_FindingText("av_nodal_burden", "BRADYCARDIA / AV-NODAL BURDEN: multiple rate-slowing medications are present."))

    if CRD5_TagCount(counts, "nsaid") && CRD5_TagCount(counts, "raas") && CRD5_TagCount(counts, "diuretic")
        issues.Push(Truth_FindingText("triple_whammy_aki", "AKI RISK: NSAID + RAAS blockade + diuretic combination is present."))

    if CRD5_TagCount(counts, "hypoglycemia") > 1
        issues.Push(Truth_FindingText("hypoglycemia_burden", "HYPOGLYCEMIA RISK: multiple glucose-lowering medications with hypoglycemia potential are present."))

    if CRD5_TagCount(counts, "anticholinergic") > 1
        issues.Push(Truth_FindingText("anticholinergic_burden", "ANTICHOLINERGIC BURDEN: multiple anticholinergic medications are present."))

    if CRD5_TagCount(counts, "fall_risk") > 1
        issues.Push(Truth_FindingText("fall_risk_burden", "FALL RISK: multiple medications associated with sedation, orthostasis, or impaired coordination are present."))
}

CRD5_GroupPresent(groups, key) {
    return groups.Has(key)
}

CRD5_TagCount(counts, key) {
    return counts.Has(key) ? counts[key] : 0
}

CRD5_CombinedScreenGrabReview(ctx) {
    return CRD5_MedRecReview(ctx)
        . "`r`n`r`n"
        . CRD5_PatientReview(ctx)
}


Report_BuildPriority(ctx) {
    clinical := "ACTIVE TRUTH VERSIONS`r`n"
        . "======================================================================`r`n"
        . Truth_RuntimeStatus() "`r`n`r`n"
        . CRD5_CombinedScreenGrabReview(ctx)
    findings := Allergy_ScanOrders(ctx.allergyRecs, PCtx_ConfirmedActiveMeds(ctx))
    cols := Safety_Evaluate(ctx)
    alerts := ""
    urgent := 0
    review := 0

    if ctx.HasOwnProp("notes") && IsObject(ctx.notes) {
        for note in ctx.notes {
            alerts .= "REVIEW CAPTURE " note.capture "  " note.text "`r`n"
            review += 1
        }
    }

    for f in findings {
        if f.sev = "RED" {
            alerts .= "ALERT  " f.title "`r`n       " f.detail "`r`n"
            urgent += 1
        } else {
            alerts .= "REVIEW " f.title "`r`n       " f.detail "`r`n"
            review += 1
        }
    }

    for key in Safety_Columns() {
        c := cols[key]
        if c.status != "Alert" && c.status != "Review"
            continue
        for f in c.findings {
            alerts .= f "`r`n"
            if c.status = "Alert"
                urgent += 1
            else
                review += 1
        }
    }

    heading := "`r`n`r`nPRIORITY SAFETY FINDINGS`r`n"
        . "======================================================================`r`n"
    if alerts = ""
        return clinical . heading . "No additional priority safety rule matched the captured active orders."

    return clinical . heading
        . (urgent > 0 ? urgent " alert" (urgent = 1 ? "" : "s") : "")
        . (urgent > 0 && review > 0 ? "   |   " : "")
        . (review > 0 ? review " review item" (review = 1 ? "" : "s") : "")
        . "`r`n----------------------------------------------------------------------`r`n" alerts
}

Report_Build(ctx) {
    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    o := ""

    o .= "PATIENT SESSION`r`n"
    o .= "======================================================================`r`n"
    o .= "Session started: " ctx.startedAt "`r`n"
    o .= "Identifier: " PCtx_MaskedId(ctx) "  (full MRN/FIN held in memory only, never written to disk)`r`n"
    o .= "Captures: " ctx.captures.Length "   Fields: " PCtx_FieldCount(ctx)
        . "   Low-confidence: " PCtx_LowConfidenceCount(ctx)
        . "   Unresolved conflicts: " PCtx_UnresolvedConflicts(ctx) "`r`n"
    for c in ctx.captures
        o .= "  #" c.n "  " c.type "  " c.at "  -> " PCtx_AddedSummary(c.added) "`r`n"

    o .= "`r`nCAPTURED VALUES`r`n"
    o .= "----------------------------------------------------------------------`r`n"
    o .= Report_Line("Age", PCtx_Demo(ctx, "age"), "yr")
    o .= Report_Line("Sex", PCtx_Demo(ctx, "sex"), "")
    o .= Report_Line("Height", PCtx_Demo(ctx, "heightCm"), "cm")
    o .= Report_Line("Location", PCtx_Demo(ctx, "location"), "")
    if ctx.weights.Length = 0 {
        o .= "Weight: Not captured`r`n"
    } else {
        for w in ctx.weights
            o .= "Weight: " w.kg " kg - " w.label (w.selected ? "  [SELECTED FOR DOSING]" : "")
                . "  (capture " w.capture ")`r`n"
    }

    o .= "`r`nCALCULATED VALUES`r`n"
    o .= "----------------------------------------------------------------------`r`n"
    o .= "BMI: " (parsed.HasOwnProp("bmi") && parsed.bmi != "" ? parsed.bmi " kg/m2" : "Not calculated") "`r`n"
    o .= "CrCl: " PatientCalc_CrClDisplay(parsed) "`r`n"

    if ctx.labs.Count > 0 {
        o .= "`r`nLABORATORY RESULTS - SI / METRIC DISPLAY (most recent first)`r`n"
        o .= "----------------------------------------------------------------------`r`n"
        for key, arr in ctx.labs {
            o .= PCtx_LabLabel(key) ":"
            for e in arr
                o .= "  " LabMetric_FormatValue(key, e.value)
                    . (e.when != "" ? " (" e.when ")" : " (time not captured)")
            o .= "`r`n"
        }
    }

    if PCtx_LabCandidateCount(ctx) > 0 {
        o .= "`r`nLAB VALUES NEEDING CONFIRMATION (not used by rules or calculators)`r`n"
        o .= "----------------------------------------------------------------------`r`n"
        for key, entries in ctx.labCandidates {
            for entry in entries {
                o .= PCtx_LabLabel(key) ": " LabMetric_FormatValue(key, entry.value)
                    . (entry.when != "" ? " (" entry.when ")" : "")
                    . " — confirm against the chart`r`n"
            }
        }
    }

    if ctx.HasOwnProp("qualitativeFindings") && ctx.qualitativeFindings.Length > 0 {
        o .= "`r`nQUALITATIVE RESULTS / STUDY STATUS`r`n"
        o .= "----------------------------------------------------------------------`r`n"
        for finding in ctx.qualitativeFindings
            o .= StrUpper(finding.kind) "  " finding.label ": " finding.value
                . "  [capture " finding.capture "]`r`n"
    }

    findings := Allergy_ScanOrders(ctx.allergyRecs, PCtx_ConfirmedActiveMeds(ctx))
    o .= "`r`nALLERGY / ORDER CONFLICTS`r`n"
    o .= "----------------------------------------------------------------------`r`n"
    if findings.Length = 0 {
        o .= "No allergy/order conflict matched in the captured active orders.`r`n"
    } else {
        for f in findings
            o .= f.sev "  " f.title "`r`n      " f.detail "`r`n"
    }
    unclassified := Allergy_Unclassified(ctx.allergyRecs)
    if unclassified.Length > 0 {
        o .= "`r`nUnclassified allergy entries (retained, not treated as drug ingredients):`r`n"
        for u in unclassified
            o .= "  - " u "`r`n"
    }

    o .= "`r`nMEDICATION SAFETY REVIEW`r`n"
    o .= "----------------------------------------------------------------------`r`n"
    cols := Safety_Evaluate(ctx)
    for key in Safety_Columns() {
        c := cols[key]
        o .= Format("{1:-8}", c.label) " " Format("{1:-18}", c.status)
            . (c.short != "" ? c.short : "") "`r`n"
    }
    for key in Safety_Columns() {
        c := cols[key]
        if c.findings.Length = 0
            continue
        o .= "`r`n[" c.label "]`r`n"
        for f in c.findings
            o .= "  " f "`r`n"
    }

    o .= "`r`n" CRD5_CombinedScreenGrabReview(ctx)

    o .= "`r`nACTIVE MEDICATION LIST (normalized)`r`n"
    o .= "----------------------------------------------------------------------`r`n"
    activeMeds := PCtx_ActiveMeds(ctx)
    if activeMeds.Length = 0 {
        o .= "No active medication orders captured.`r`n"
    } else {
        for m in activeMeds {
            ing := ""
            for i in m.ingredients
                ing .= (ing = "" ? "" : " + ") i
            o .= "- " m.raw "`r`n"
            o .= "    ingredient: " (ing = "" ? "NOT NORMALIZED" : ing)
                . (m.dose != "" ? "   dose: " m.dose : "")
                . (m.route != "" ? "   route: " m.route : "")
                . (Sig_CompactFromMedication(m) != "" ? "   sig: " Sig_CompactFromMedication(m) : "")
                . (m.status != "" ? "   status: " m.status : "")
                . (m.lowConfidence ? "   [LOW OCR CONFIDENCE]" : "") "`r`n"
        }
    }

    if ctx.conflicts.Length > 0 {
        o .= "`r`nCONFLICTS REQUIRING REVIEW`r`n"
        o .= "----------------------------------------------------------------------`r`n"
        for c in ctx.conflicts {
            o .= (c.resolved ? "[resolved] " : "[OPEN] ") c.field ": capture " c.capA
                . " = " c.a "   vs   capture " c.capB " = " c.b "`r`n"
        }
    }

    o .= "`r`nMISSING INFORMATION`r`n"
    o .= "----------------------------------------------------------------------`r`n"
    missing := Report_Missing(ctx)
    if missing.Length = 0 {
        o .= "All core fields were captured.`r`n"
    } else {
        for m in missing
            o .= "  - " m " : NOT CAPTURED (not assumed absent, normal, negative, or zero)`r`n"
    }

    o .= "`r`nREFERENCE DATA`r`n"
    o .= "----------------------------------------------------------------------`r`n"
    for name, spec in RefData_Catalog()
        o .= "  " RefData_StatusLine(name) "`r`n"

    o .= "`r`n----------------------------------------------------------------------`r`n"
    o .= "Capture scope: " ctx.captures.Length " screen" (ctx.captures.Length = 1 ? "" : "s")
        . ". Hidden or off-screen data were not evaluated.`r`n"
    return o
}

Report_Line(label, value, unit) {
    if value = ""
        return label ": Not captured`r`n"
    return label ": " value (unit != "" ? " " unit : "") "`r`n"
}

Report_Missing(ctx) {
    out := []
    if PCtx_Demo(ctx, "age") = ""
        out.Push("Age")
    if PCtx_Demo(ctx, "sex") = ""
        out.Push("Sex")
    if PCtx_Demo(ctx, "heightCm") = ""
        out.Push("Height")
    if PCtx_SelectedWeight(ctx) = ""
        out.Push("Weight")
    if PCtx_LabValue(ctx, "creatinine") = ""
        out.Push("Serum creatinine")
    if PCtx_ActiveMeds(ctx).Length = 0
        out.Push("Active medication orders")
    if ctx.allergyRaw.Length = 0
        out.Push("Allergies")
    if ctx.dx.Length = 0
        out.Push("Diagnoses / problem list")
    out.Push("G6PD status")
    out.Push("Myasthenia gravis status")
    out.Push("Dialysis / RRT status")
    return out
}


; =================================================================================================
; PATIENT HUB   (blueprint §2 layout, §16 readiness, §17 captures panel, §19 Ctrl+B behavior, §20)
; -------------------------------------------------------------------------------------------------
; Demo_ShowPicker keeps its name and signature so the existing Ctrl+B call site is unchanged, but
; it now routes into the persistent patient session instead of building a one-shot calculator list.
; =================================================================================================

Demo_ShowPicker(parsed, rawText) {
    global PCtxSession
    parsed := PatientV2_NormalizeParsedShape(parsed)
    screenType := PCtx_ClassifyScreen(rawText)

    ctx := PCtx_Active()

    if !IsObject(ctx) {
        ctx := PCtx_New()
        PCtxSession := ctx
        PCtx_MergeCapture(ctx, parsed, rawText, screenType)
        Demo_OpenCaptureDestination(ctx, parsed, screenType)
        return
    }

    openCalc := PCtx_CalcWindowOpen()
    if openCalc != "" {
        choice := Hub_CalcOpenPrompt(openCalc)
        if choice = "cancel"
            return
    } else {
        choice := "refresh"
    }

    id := PCtx_IdentityCheck(ctx, parsed)
    if id["verdict"] != "match" {
        action := Hub_PatientChangePrompt(ctx, parsed, id)
        if action = "cancel"
            return
        if action = "new" {
            ctx := PCtx_New()
            PCtxSession := ctx
            PCtx_MergeCapture(ctx, parsed, rawText, screenType)
            Demo_OpenCaptureDestination(ctx, parsed, screenType)
            return
        }
    }

    ctx.finalized := false
    added := PCtx_MergeCapture(ctx, parsed, rawText, screenType)

    msg := "Capture " ctx.captures.Length " merged successfully.`n`n"
        . "Screen type: " screenType "`n"
        . "New information: " PCtx_AddedSummary(added)
    if id["verdict"] = "weak"
        msg .= "`n`nNote: " id["reason"]
    if choice = "norefresh"
        msg .= "`n`nThe open calculator was not refreshed."
    ToolTip(msg)
    SetTimer(() => ToolTip(), -3500)

    Demo_OpenCaptureDestination(ctx, parsed, screenType)
}

Demo_OpenCaptureDestination(ctx, parsed, screenType) {
    SecondCheck_Show(ctx)
}

Hub_CalcOpenPrompt(title) {
    g := Gui("+MinimizeBox", "Calculator In Use")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    g.Add("Text", "xm w420", "A calculator is currently using this patient session:")
    t := g.Add("Text", "xm y+4 w420", title)
    Theme_Heading(t)

    result := "cancel"
    g.Add("Button", "xm y+12 w420 h32", "Add Capture and Refresh Calculator")
        .OnEvent("Click", (*) => (result := "refresh", g.Destroy()))
    g.Add("Button", "xm y+6 w420 h32", "Add Capture Without Refresh")
        .OnEvent("Click", (*) => (result := "norefresh", g.Destroy()))
    g.Add("Button", "xm y+6 w420 h32", "Cancel")
        .OnEvent("Click", (*) => (result := "cancel", g.Destroy()))
    g.OnEvent("Close", (*) => (result := "cancel", g.Destroy()))
    g.Show("w460")
    WinWaitClose("ahk_id " g.Hwnd)
    return result
}

Hub_PatientChangePrompt(ctx, parsed, id) {
    g := Gui("+MinimizeBox", "Possible Patient Change")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    h := g.Add("Text", "xm w520", "POSSIBLE PATIENT CHANGE")
    h.SetFont("s11 bold c" Theme_Accent("bad"), "Segoe UI")

    body := "Current session:`n  " PCtx_MaskedId(ctx)
        . "`n  Age " (PCtx_Demo(ctx, "age") = "" ? "not captured" : PCtx_Demo(ctx, "age"))
        . "   Sex " (PCtx_Demo(ctx, "sex") = "" ? "not captured" : PCtx_Demo(ctx, "sex"))
        . "`n`nNew capture:`n  MRN " (PCtx_Prop(parsed, "mrn") = "" ? "not visible" : "visible")
        . "   FIN " (PCtx_Prop(parsed, "fin") = "" ? "not visible" : "visible")
        . "`n  Age " (PCtx_Prop(parsed, "age") = "" ? "not captured" : PCtx_Prop(parsed, "age"))
        . "   Sex " (PCtx_Prop(parsed, "sex") = "" ? "not captured" : PCtx_Prop(parsed, "sex"))
        . "`n`n" id["reason"]
        . "`n`nThe patient could not be confirmed automatically."
    g.Add("Text", "xm y+8 w520", body)

    result := "new"
    g.Add("Button", "xm y+14 w520 h32 Default", "Start New Patient Session (recommended)")
        .OnEvent("Click", (*) => (result := "new", g.Destroy()))
    g.Add("Button", "xm y+6 w520 h32", "Merge With Current Patient (explicit override)")
        .OnEvent("Click", (*) => (result := "merge", g.Destroy()))
    g.Add("Button", "xm y+6 w520 h32", "Cancel Capture")
        .OnEvent("Click", (*) => (result := "cancel", g.Destroy()))
    g.OnEvent("Close", (*) => (result := "cancel", g.Destroy()))
    g.Show("w560")
    WinWaitClose("ahk_id " g.Hwnd)
    return result
}

; -------------------------------------------------------------------------------------------------
Hub_WorkArea() {
    MonitorGetWorkArea(, &left, &top, &right, &bottom)
    return { left: left, top: top, width: right - left, height: bottom - top }
}

Hub_Show(ctx) {
    global _HubGui, _HubQuickState
    if IsObject(_HubGui) {
        try _HubGui.Destroy()
    }

    work := Hub_WorkArea()
    hubWidth := Max(900, Min(1240, work.width - 24))
    hubHeight := Max(680, Min(880, work.height - 24))
    contentWidth := hubWidth - 36
    renalWidth := Min(310, Max(250, Round(contentWidth * 0.27)))
    leftWidth := contentWidth - renalWidth - 14
    renalX := 18 + leftWidth + 14
    mainY := 122
    actionY := hubHeight - 94
    mainHeight := actionY - mainY - 12

    g := Gui("+MinimizeBox", "PhUCKIT - Patient Quick Glance")
    _HubGui := g
    ApplyTheme(g)

    brand := g.Add("Text", "x18 y14 w100 h30", "PhUCKIT")
    brand.SetFont("s14 bold c" Theme_Accent("accent"), "Segoe UI")
    title := g.Add("Text", "x130 y13 w" (contentWidth - 112) " h32", "Patient quick glance")
    title.SetFont("s18 bold c" Theme_Accent("heading"), "Segoe UI")
    Theme_Subtle(g.Add("Text", "x130 y45 w" (contentWidth - 112) " h24",
        "Current values first. Related results stay together; prior values and direction remain attached to the result."))

    patient := g.Add("Text", "x18 y79 w" contentWidth " h26", "")
    patient.SetFont("s11 bold c" Theme_Accent("heading"), "Segoe UI")
    g.Add("Progress", "x18 y111 w" contentWidth " h3 Range0-100 c007C91 BackgroundD8E2E8", 100)

    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    config := QuickGlance_LoadConfig()
    rows := QuickGlance_BuildRows(ctx, config, parsed)
    matrix := QuickGlance_CreateClinicalMatrix(g, ctx, rows, 18, mainY, leftWidth, renalX, renalWidth, mainHeight)

    buttonGap := 7
    buttonWidth := Floor((contentWidth - buttonGap * 8) / 9)
    g.Add("Button", "x18 y" actionY " w" buttonWidth " h34 Default", "Copy")
        .OnEvent("Click", (*) => QuickGlance_Copy(_HubQuickState))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "Labs && Trends")
        .OnEvent("Click", (*) => Hub_OpenLabCorrections(ctx))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "Med Rec")
        .OnEvent("Click", (*) => Hub_OpenMedRecComparison(ctx))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "Renal Dose")
        .OnEvent("Click", (*) => Hub_LaunchCalc(ctx, Hub_OpenRenalScreening, "Renal Dose"))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "Workbenches")
        .OnEvent("Click", (*) => Hub_OpenWorkbenchLauncher(ctx))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "Second Check")
        .OnEvent("Click", (*) => SecondCheck_Show(ctx))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "SQL Refresh")
        .OnEvent("Click", (*) => Hub_OpenBackgroundLookups(ctx, 0, "", "admission_medrec"))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "Capture More")
        .OnEvent("Click", (*) => (g.Destroy(), SafeRun(BMI_FromRegion)))
    g.Add("Button", "x+" buttonGap " yp w" buttonWidth " h34", "Hide")
        .OnEvent("Click", (*) => g.Minimize())

    footer := g.Add("Text", "x18 y" (hubHeight - 30) " w" contentWidth " h20",
        "© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    footer.SetFont("s8 c" Theme_Accent("subtle"), "Segoe UI")

    state := { ctx: ctx, g: g, patient: patient, cells: matrix.cells, visible: rows, flagsText: "" }
    _HubQuickState := state
    QuickGlance_RefreshState(state)
    g.OnEvent("Close", Hub_CloseQuickGlance)
    g.OnEvent("Escape", (*) => g.Minimize())

    x := work.left + Max(0, Floor((work.width - hubWidth) / 2))
    y := work.top + Max(0, Floor((work.height - hubHeight) / 2))
    g.Show("x" x " y" y " w" hubWidth " h" hubHeight)
}

QuickGlance_CreateClinicalMatrix(g, ctx, rows, leftX, topY, leftWidth, renalX, renalWidth, totalHeight) {
    chemistry := [], renal := [], cbc := [], lower := []
    for row in rows {
        if row.key = "creatinine" || row.group = "Renal & dosing"
            renal.Push(row)
        else if row.group = "BMP" || row.group = "Extended electrolytes"
            chemistry.Push(row)
        else if row.group = "CBC"
            cbc.Push(row)
        else
            lower.Push(row)
    }

    gap := 10
    chemistryHeight := Max(190, Round(totalHeight * 0.47))
    cbcHeight := Max(105, Round(totalHeight * 0.25))
    lowerHeight := Max(72, totalHeight - chemistryHeight - cbcHeight - gap * 2)
    cbcY := topY + chemistryHeight + gap
    lowerY := cbcY + cbcHeight + gap
    cells := Map()

    QuickGlance_AddMatrixPanel(g, chemistry, cells, leftX, topY, leftWidth, chemistryHeight, 5, ctx)
    QuickGlance_AddMatrixPanel(g, cbc, cells, leftX, cbcY, leftWidth, cbcHeight, Max(1, Min(5, cbc.Length)), ctx)
    QuickGlance_AddMatrixPanel(g, lower, cells, leftX, lowerY, leftWidth, lowerHeight, Max(1, Min(4, lower.Length)), ctx)
    QuickGlance_AddMatrixPanel(g, renal, cells, renalX, topY, renalWidth, totalHeight, 1, ctx)
    return { cells: cells }
}

QuickGlance_AddMatrixPanel(g, rows, cells, x, y, width, height, columns, ctx) {
    panel := g.Add("Text", "x" x " y" y " w" width " h" height " +Border BackgroundF5F8FC", "")
    panel.OnEvent("Click", (*) => Hub_OpenLabCorrections(ctx))
    if rows.Length = 0
        return
    columns := Max(1, Min(columns, rows.Length))
    rowCount := Ceil(rows.Length / columns)
    cellWidth := Floor((width - 12) / columns)
    cellHeight := Floor((height - 12) / rowCount)
    for idx, row in rows {
        col := Mod(idx - 1, columns)
        line := Floor((idx - 1) / columns)
        cellX := x + 6 + col * cellWidth
        cellY := y + 6 + line * cellHeight
        if col > 0
            g.Add("Text", "x" cellX " y" (cellY + 6) " w1 h" Max(12, cellHeight - 12) " BackgroundD8E2E8", "")
        if line > 0 && col = 0
            g.Add("Text", "x" (x + 6) " y" cellY " w" (width - 12) " h1 BackgroundD8E2E8", "")
        name := g.Add("Text", "x" (cellX + 10) " y" (cellY + 8) " w" (cellWidth - 20) " h20 Center", row.label)
        name.SetFont("s9 c" Theme_Accent("heading"), "Segoe UI")
        value := g.Add("Text", "x" (cellX + 8) " y" (cellY + 30) " w" (cellWidth - 16) " h28 Center", "")
        value.SetFont("s15 bold c" Theme_Accent("heading"), "Segoe UI")
        meta := g.Add("Text", "x" (cellX + 8) " y" (cellY + 59) " w" (cellWidth - 16) " h20 Center", "")
        meta.SetFont("s8 c" Theme_Accent("subtle"), "Segoe UI")
        for ctrl in [name, value, meta]
            ctrl.OnEvent("Click", (*) => Hub_OpenLabCorrections(ctx))
        cells[row.key] := { value: value, meta: meta }
    }
}

Hub_CloseQuickGlance(g, *) {
    global _HubGui, _HubQuickState
    _HubGui := 0
    _HubQuickState := 0
    try g.Destroy()
}

Hub_ShowLegacy(ctx) {
    global _HubGui, AppBackronym
    if IsObject(_HubGui) {
        try _HubGui.Destroy()
    }

    work := Hub_WorkArea()
    hubWidth := Min(1040, Max(900, work.width - 24))
    hubHeight := Min(1060, Max(760, work.height - 24))
    analysisHeight := Max(180, Min(430, hubHeight - 520))

    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    findings := Allergy_ScanOrders(ctx.allergyRecs, PCtx_ConfirmedActiveMeds(ctx))
    cols := Safety_Evaluate(ctx)
    ready := Safety_Readiness(ctx)

    g := Gui("+MinimizeBox +Resize", "PhUCKIT - Patient Workspace")
    _HubGui := g
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    ; ---- header -------------------------------------------------------------------------------
    brand := g.Add("Text", "xm w960", "PhUCKIT")
    brand.SetFont("s13 bold c" Theme_Accent("heading"), "Segoe UI")
    sub := g.Add("Text", "xm y+0 w960", AppBackronym)
    Theme_Subtle(sub)
    g.Add("Progress", "xm y+7 w960 h3 Range0-100 cC8FF3D Background071725", 100)
    captured := g.Add("Text", "xm y+10 w960", "CAPTURED PATIENT · PHARMACIST REVIEW WORKSPACE")
    captured.SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")

    line1 := ""
    line1 .= "Age " (PCtx_Demo(ctx, "age") = "" ? "--" : PCtx_Demo(ctx, "age") " yr") "   "
    line1 .= (PCtx_Demo(ctx, "sex") = "" ? "Sex --" : PCtx_Demo(ctx, "sex")) "   "
    line1 .= (PCtx_Demo(ctx, "heightCm") = "" ? "-- cm" : PCtx_Demo(ctx, "heightCm") " cm") "   "
    line1 .= (PCtx_SelectedWeight(ctx) = "" ? "-- kg" : PCtx_SelectedWeight(ctx) " kg") "   "
    line1 .= "SCr " (PCtx_LabValue(ctx, "creatinine") = "" ? "--" : PCtx_LabValue(ctx, "creatinine"))
    hdr := g.Add("Text", "xm y+2 w960", line1)
    hdr.SetFont("s11 bold c" Theme_Accent("accent"), "Segoe UI")

    redCount := 0
    for f in findings {
        if f.sev = "RED"
            redCount += 1
    }
    activeMedCount := PCtx_ActiveMeds(ctx).Length
    line2 := ctx.allergyRecs.Length " allergies   " activeMedCount " active medication" (activeMedCount = 1 ? "" : "s")
    if redCount > 0
        line2 .= "   " redCount " ALLERGY CONFLICT" (redCount = 1 ? "" : "S")
    l2 := g.Add("Text", "xm y+2 w960", line2)
    if redCount > 0 {
        l2.SetFont("s10 bold c" Theme_Accent("bad"), "Segoe UI")
    }

    calcLine := "BMI " (parsed.HasOwnProp("bmi") && parsed.bmi != "" ? parsed.bmi : "--")
        . "   CrCl " PatientCalc_CrClDisplay(parsed)
    Theme_Subtle(g.Add("Text", "xm y+2 w960", calcLine))

    Theme_Subtle(g.Add("Text", "xm y+6 w960",
        "Location: " (PCtx_Demo(ctx, "location") = "" ? "Not recognized" : PCtx_Demo(ctx, "location"))
        . "   |   " PCtx_MaskedId(ctx)
        . "   |   Last capture: " (ctx.lastCaptureAt = "" ? "--" : ctx.lastCaptureAt)))

    sess := ctx.captures.Length " screen" (ctx.captures.Length = 1 ? "" : "s") " captured"
        . "   " PCtx_FieldCount(ctx) " fields"
        . "   " PCtx_LowConfidenceCount(ctx) " low-confidence"
        . "   " PCtx_UnresolvedConflicts(ctx) " unresolved conflict"
        . (PCtx_UnresolvedConflicts(ctx) = 1 ? "" : "s")
        . (ctx.finalized ? "   [FINALIZED]" : "")
    Theme_Subtle(g.Add("Text", "xm y+2 w960", sess))
    if PCtx_LowConfidenceCount(ctx) > 0 || PCtx_UnresolvedConflicts(ctx) > 0 {
        ocrBanner := g.Add("Text", "xm y+4 w960",
            "CAPTURE REVIEW REQUIRED — ambiguous or ungrounded OCR was excluded. Verify flagged corrections and unresolved conflicts against the source screen.")
        ocrBanner.SetFont("s10 bold c" Theme_Accent("warn"), "Segoe UI")
    }

    g.Add("Button", "xm y+8 w145 h28", "Capture Another Screen")
        .OnEvent("Click", (*) => (g.Destroy(), SafeRun(BMI_FromRegion)))
    g.Add("Button", "x+6 yp w135 h28", "Provider Report")
        .OnEvent("Click", (*) => Hub_OpenVisualReport(ctx))
    g.Add("Button", "x+6 yp w155 h28", "Compare Home vs Acute")
        .OnEvent("Click", (*) => Hub_OpenMedRecComparison(ctx))
    g.Add("Button", "x+6 yp w115 h28", "Review Captures")
        .OnEvent("Click", (*) => Hub_ShowCaptures(ctx))
    g.Add("Button", "x+6 yp w110 h28", "Undo Capture")
        .OnEvent("Click", (*) => Hub_UndoAndRefresh(g))
    g.Add("Button", "x+6 yp w110 h28", "Finalize Session")
        .OnEvent("Click", (*) => (PCtx_FinalizeSession(), Hub_Refresh(g)))
    g.Add("Button", "x+6 yp w100 h28", "Clear Session")
        .OnEvent("Click", (*) => (PCtx_ClearSession(true), IsObject(PCtx_Active()) ? Hub_Refresh(g) : g.Destroy()))

    ; Keep the highest-use clinical destinations above the fold. The former
    ; long calculator grid could fall below a 768-pixel display with no native
    ; GUI scroll path, making these tools appear to be missing.
    quickHead := g.Add("Text", "xm y+10 w960", "QUICK CLINICAL TOOLS")
    quickHead.SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    g.Add("Button", "xm y+5 w185 h38", "Labs & Trends")
        .OnEvent("Click", (*) => Hub_OpenLabCorrections(ctx))
    g.Add("Button", "x+7 yp w185 h38", "All Workbenches")
        .OnEvent("Click", (*) => Hub_OpenWorkbenchLauncher(ctx))
    g.Add("Button", "x+7 yp w185 h38", "Renal Dose")
        .OnEvent("Click", (*) => Hub_LaunchCalc(ctx, Hub_OpenRenalScreening, "Renal Dose"))
    g.Add("Button", "x+7 yp w185 h38", "Days Supply / Taper")
        .OnEvent("Click", (*) => Hub_LaunchCalc(ctx, Calc_OpenDaySupply, "Days Supply / Taper SIG"))
    g.Add("Button", "x+7 yp w185 h38", "Edit Captured Data")
        .OnEvent("Click", (*) => Hub_EditCaptured(ctx, g, 1))

    ; ---- hard alert area ------------------------------------------------------------------------
    if findings.Length > 0 {
        top := findings[1]
        box := g.Add("Text", "xm y+12 w960 h1 0x10")
        title := g.Add("Text", "xm y+6 w960", top.sev = "RED" ? top.title : "MEDICATION ALERT")
        title.SetFont("s11 bold c" Theme_Accent(top.sev = "RED" ? "bad" : "warn"), "Segoe UI")

        alertText := ""
        shown := 0
        for f in findings {
            alertText .= (f.sev = "RED" ? "" : "Class caution: ") f.detail "`n"
            shown += 1
            if shown >= 3
                break
        }
        if findings.Length > shown
            alertText .= "+" (findings.Length - shown) " additional finding(s) in Allergy / Order Conflicts."
        at := g.Add("Text", "xm y+2 w960", Trim(alertText, "`n"))
        at.SetFont("s10 c" Theme_Accent(top.sev = "RED" ? "bad" : "warn"), "Segoe UI")

        g.Add("Button", "xm y+6 w130 h26", "Review Match")
            .OnEvent("Click", (*) => Hub_ShowAllergyFindings(ctx))
        g.Add("Button", "x+6 yp w130 h26", "Edit Allergy Data")
            .OnEvent("Click", (*) => Hub_EditCaptured(ctx, g, 3))
        g.Add("Text", "xm y+8 w960 h1 0x10")
    }

    ; ---- primary clinical analysis ---------------------------------------------------------------
    pHead := g.Add("Text", "xm y+12 w960", "PHARMACIST REVIEW · ACTIONABLE OUTPUT")
    pHead.SetFont("s12 bold c" Theme_Accent("heading"), "Segoe UI")

    analysisText := Report_BuildPriority(ctx) "`r`n`r`n" Report_Build(ctx)
    analysisOut := g.Add("Edit", "xm y+4 w960 h" analysisHeight " Multi VScroll WantTab +Wrap", analysisText)
    analysisOut.SetFont("s10 c" Theme_Accent("text"), "Segoe UI")

    g.Add("Button", "xm y+6 w150 h28", "Copy Analysis")
        .OnEvent("Click", (*) => Hub_CopyAnalysis(analysisOut.Value))
    g.Add("Button", "x+6 yp w190 h28", "Open Large Analysis")
        .OnEvent("Click", (*) => Hub_OpenAnalysis(ctx))
    g.Add("Button", "x+6 yp w180 h28", "Open Provider Report")
        .OnEvent("Click", (*) => Hub_OpenVisualReport(ctx))
    Theme_Subtle(g.Add("Text", "x+10 yp+5 w390",
        "Editable, word-wrapped output; scroll to review every line."))

    ; ---- six-column safety strip -----------------------------------------------------------------
    Theme_Subtle(g.Add("Text", "xm y+10 w960", "Medication safety review (open a category for details):"))
    firstCol := true
    for key in Safety_Columns() {
        c := cols[key]
        opt := firstCol ? "xm y+6 w155 h46" : "x+4 yp w155 h46"
        firstCol := false
        btn := g.Add("Button", opt, c.label "`n" (c.short != "" ? c.short : c.status))
        btn.OnEvent("Click", Hub_SafetyClick.Bind(ctx, key))
    }

    statusLine := ""
    for key in Safety_Columns()
        statusLine .= Format("{1:-10}", cols[key].status = "Not applicable" ? "N/A" : cols[key].status) " "
    Theme_Subtle(g.Add("Text", "xm y+4 w960", statusLine))

    ; ---- compact footer controls ------------------------------------------------------------------
    Theme_Subtle(g.Add("Text", "xm y+10 w960",
        "All dosing, medication, lab, administration, and nutrition workbenches are available from All Workbenches above."))
    g.Add("Button", "xm y+6 w233 h30", "Copy Snapshot")
        .OnEvent("Click", (*) => Hub_CopySnapshot(ctx))
    g.Add("Button", "x+6 yp w233 h30", "Reference Source Versions")
        .OnEvent("Click", (*) => Hub_ShowRefStatus())
    g.Add("Button", "x+6 yp w233 h30", "PhUCKIT (Hide)")
        .OnEvent("Click", (*) => g.Minimize())

    warn := g.Add("Text", "xm y+10 w960",
        "Analysis uses real values recognized from " ctx.captures.Length " captured screen"
        . (ctx.captures.Length = 1 ? "" : "s") ". Missing or unreadable source data remains absent from the analysis.")
    Theme_Subtle(warn)

    g.Show("x" (work.left + 8) " y" (work.top + 8) " w" hubWidth " h" hubHeight)
}


Hub_CopyAnalysis(text) {
    A_Clipboard := text
    ToolTip("Patient analysis copied.")
    SetTimer(() => ToolTip(), -1400)
}

Hub_OpenAnalysis(ctx) {
    analysisText := Report_BuildPriority(ctx) "`r`n`r`n" Report_Build(ctx)
    work := Hub_WorkArea()
    w := Min(1180, Max(820, work.width - 80))
    h := Min(900, Max(620, work.height - 80))

    g := Gui("+Resize +MinimizeBox", "PhUCKIT — MedRec + Patient Review")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    title := g.Add("Text", "xm ym w" (w - 36), "MEDREC + PATIENT REVIEW")
    title.SetFont("s13 bold c" Theme_Accent("heading"), "Segoe UI")
    g.Add("Button", "x" (w - 145) " y10 w110 h28", "Patient")
        .OnEvent("Click", Patient_OpenFromAnyScreen)
    Theme_Subtle(g.Add("Text", "xm y+2 w" (w - 36),
        "Generated directly from the captured patient session: reconciled medication list, medication findings, and patient-specific review."))

    output := g.Add("Edit", "xm y+10 w" (w - 36) " h" (h - 125) " Multi VScroll WantTab +Wrap", analysisText)
    Theme_OutputFont(output)
    g.Add("Button", "xm y+8 w140 h30 Default", "Copy Analysis")
        .OnEvent("Click", (*) => Hub_CopyAnalysis(output.Value))
    g.Add("Button", "x+8 yp w100 h30", "Close")
        .OnEvent("Click", (*) => g.Destroy())

    g.OnEvent("Size", (guiObj, minMax, newW, newH) => Hub_ResizeAnalysis(output, newW, newH))
    g.OnEvent("Escape", (*) => g.Destroy())
    g.Show("x" (work.left + 35) " y" (work.top + 35) " w" w " h" h)
}

Hub_ResizeAnalysis(output, newW, newH) {
    if newW < 500 || newH < 300
        return
    try output.Move(, , newW - 36, newH - 125)
}






MedRec_AssignSelectedProfile(ctx, lv, profile, owner, rows := 0) {
    row := lv.GetNext()
    if row = 0
        return
    changed := false
    if IsObject(rows) && row <= rows.Length {
        selected := rows[row]
        med := profile = "ambulatory" ? selected.home : selected.acute
        if !IsObject(med)
            med := IsObject(selected.home) ? selected.home : selected.acute
        if IsObject(med) {
            med.profile := profile
            med.profileConfidence := "manual"
            med.profileReason := "Profile assigned manually from Med Rec evidence review"
            changed := true
        }
    }
    if changed {
        owner.Destroy()
        Hub_OpenMedRecComparison(ctx)
    }
}

MedRec_ShowSelectedEvidence(lv, rows) {
    row := lv.GetNext()
    if row = 0 || !IsObject(rows) || row > rows.Length {
        MsgBox "Select a medication comparison row first.", "Medication evidence"
        return
    }
    selected := rows[row]
    text := "HOME / AMBULATORY`r`n" MedRec_EvidenceText(selected.home)
        . "`r`n`r`n============================================================`r`n`r`n"
        . "ACUTE / INPATIENT`r`n" MedRec_EvidenceText(selected.acute)
    g := Gui("+Resize", "Medication Capture Evidence")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    edit := g.Add("Edit", "xm ym w760 h440 Multi ReadOnly VScroll +Wrap", text)
    g.Add("Button", "xm y+8 w120 Default", "Copy Evidence").OnEvent("Click", (*) => (A_Clipboard := edit.Value))
    g.Add("Button", "x+8 yp w90", "Close").OnEvent("Click", (*) => g.Destroy())
    g.OnEvent("Size", (guiObj, minMax, w, h) => (minMax != -1 ? edit.Move(,, Max(320, w - 30), Max(180, h - 70)) : 0))
    g.Show("w790 h520")
}

Hub_OpenVisualReport(ctx) {
    path := A_Temp "\PhUCKIT-Patient-Review.html"
    try {
        if FileExist(path)
            FileDelete(path)
        FileAppend(Hub_BuildVisualHtml(ctx), path, "UTF-8")
        Run(path)
    } catch as err {
        MsgBox("Could not create visual patient report.`n`n" err.Message, "PhUCKIT")
    }
}

Hub_BuildVisualHtml(ctx) {
    age := PCtx_Demo(ctx, "age")
    sex := PCtx_Demo(ctx, "sex")
    weight := PCtx_SelectedWeight(ctx)
    scr := PCtx_CreatinineSummary(ctx)
    renal := RenalContext_Label(PCtx_ToParsed(ctx))
    findings := Report_BuildPriority(ctx)
    reviewCount := PCtx_LowConfidenceCount(ctx) + PCtx_UnresolvedConflicts(ctx)
    reviewLabel := reviewCount > 0 ? reviewCount " SOURCE REVIEW ITEM" (reviewCount = 1 ? "" : "S") : "NO OCR FLAGS"
    reviewClass := reviewCount > 0 ? "review" : "clear"

    html := "<!doctype html><html><head><meta charset='utf-8'>"
    html .= "<meta name='viewport' content='width=device-width,initial-scale=1'>"
    html .= "<title>PhUCKIT Patient Review</title><style>"
    html .= ":root{color-scheme:dark;--canvas:#070a12;--panel:#0e1622;--panel2:#121d2b;--ink:#f4f2ed;--muted:#9fabb7;--line:#26394a;--cyan:#40cbda;--lime:#c8ff3d;--amber:#ffbe4e;--coral:#ff776d}"
    html .= "*{box-sizing:border-box}body{margin:0;background:var(--canvas);color:var(--ink);font-family:Segoe UI,Arial,sans-serif;font-size:14px;line-height:1.45}"
    html .= ".wrap{max-width:1280px;margin:0 auto;padding:24px}.top{position:relative;overflow:hidden;background:linear-gradient(135deg,#0e1622,#07111e);border:1px solid var(--line);padding:22px 24px;border-radius:12px}"
    html .= ".top:before{content:'';position:absolute;inset:0 auto 0 0;width:5px;background:var(--lime)}.brand{color:var(--lime);font-size:12px;font-weight:800;letter-spacing:.11em;text-transform:uppercase}"
    html .= "h1{font-size:27px;line-height:1.1;margin:9px 0 7px}h2{font-size:17px;margin:0}.sub{color:var(--muted);font-size:13px}.topline{display:flex;align-items:flex-start;justify-content:space-between;gap:20px}"
    html .= ".quality{display:inline-flex;white-space:nowrap;padding:6px 10px;border-radius:999px;font-size:11px;font-weight:800;letter-spacing:.06em}.quality.clear{color:var(--lime);border:1px solid #63821c;background:#18220e}.quality.review{color:var(--amber);border:1px solid #7a5c1d;background:#241c0d}"
    html .= ".toolbar{display:flex;gap:8px;flex-wrap:wrap;margin:14px 0}.toolbar button{border:1px solid var(--line);background:var(--panel);color:var(--ink);padding:8px 12px;border-radius:6px;cursor:pointer}.toolbar button:hover{border-color:var(--cyan)}"
    html .= ".grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:10px;margin:12px 0}.metric,.section{background:var(--panel);border:1px solid var(--line);border-radius:10px}.metric{padding:13px 15px}"
    html .= ".metric b{display:block;font-size:19px;margin-top:4px;color:var(--ink)}.label{font-size:10px;font-weight:800;text-transform:uppercase;letter-spacing:.1em;color:var(--cyan)}"
    html .= ".section{margin:12px 0;overflow:hidden}.section h2{padding:12px 15px;border-bottom:1px solid var(--line);background:var(--panel2);letter-spacing:.01em}.section.priority{border-color:#5e6e2d}.section.priority h2{color:var(--lime)}"
    html .= ".body{padding:15px}table{width:100%;border-collapse:collapse;font-size:13px}th,td{text-align:left;padding:9px 10px;border-bottom:1px solid var(--line);vertical-align:top}"
    html .= "th{font-size:10px;text-transform:uppercase;letter-spacing:.08em;color:var(--cyan);background:#0a111b}tr:last-child td{border-bottom:0}td strong{color:var(--ink)}"
    html .= "pre{white-space:pre-wrap;margin:0;font-family:Segoe UI,Arial,sans-serif;font-size:13px;line-height:1.58;color:#e9edf0}"
    html .= ".lab-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(175px,1fr));gap:9px}.lab{background:#0a111b;border:1px solid var(--line);border-radius:8px;padding:11px 12px}.lab .value{font-size:20px;font-weight:750;margin:3px 0}.lab .prior,.lab .source{font-size:11px;color:var(--muted)}.trend{font-size:11px;font-weight:800;color:var(--cyan)}"
    html .= ".pill{display:inline-block;padding:3px 7px;border:1px solid var(--line);border-radius:999px;font-size:10px;color:var(--muted)}.muted{color:var(--muted)}details summary{cursor:pointer;color:var(--cyan);font-weight:700}"
    html .= ".footer{font-size:11px;color:#758391;margin:18px 2px 0}.compact .detail-section{display:none}.compact .section{margin:9px 0}"
    html .= "@media(max-width:760px){.grid{grid-template-columns:repeat(2,1fr)}.wrap{padding:12px}.topline{display:block}.quality{margin-top:12px}}"
    html .= "@media print{body{background:#fff;color:#111}.toolbar{display:none}.wrap{max-width:none;padding:0}.top,.metric,.section,.lab{break-inside:avoid;box-shadow:none}.detail-section{display:none}.footer{color:#555}}"
    html .= "</style></head><body><div class='wrap'>"

    html .= "<div class='top'><div class='topline'><div><div class='brand'>PhUCKIT · Provider View</div>"
    html .= "<h1>Medication Reconciliation + Patient Review</h1>"
    html .= "<div class='sub'>Pharmacist Utility for Clinical Knowledge &amp; Inpatient Tools<br>" Hub_Html(Truth_RuntimeStatus()) "</div></div>"
    html .= "<span class='quality " reviewClass "'>" Hub_Html(reviewLabel) "</span></div></div>"
    html .= "<div class='toolbar'><button onclick='window.print()'>Print / Save PDF</button><button onclick='document.body.classList.toggle(&quot;compact&quot;)'>Toggle screenshot view</button></div>"

    html .= "<div class='grid'>"
    html .= Hub_MetricHtml("Age", age != "" ? age " yr" : "Not captured")
    html .= Hub_MetricHtml("Sex", sex != "" ? sex : "Not captured")
    html .= Hub_MetricHtml("Weight", weight != "" ? weight " kg" : "Not captured")
    html .= Hub_MetricHtml("Renal", scr)
    html .= "</div>"

    html .= "<section class='section priority'><h2>Pharmacist priority review</h2><div class='body'><pre>"
    html .= Hub_Html(findings)
    html .= "</pre></div></section>"

    html .= "<section class='section'><h2>Laboratory snapshot + trends</h2><div class='body'>"
    html .= Hub_LabTableHtml(ctx)
    html .= "<p class='muted'>" Hub_Html(renal) "</p></div></section>"

    html .= "<section class='section'><h2>Acute vs ambulatory reconciliation</h2><div class='body'>"
    html .= Hub_MedRecComparisonHtml(ctx)
    html .= "</div></section>"

    html .= "<section class='section detail-section'><h2>Medication profile</h2><div class='body'>"
    html .= Hub_MedicationTableHtml(ctx)
    html .= "</div></section>"

    html .= "<section class='section detail-section'><div class='body'><details><summary>Capture provenance and source audit</summary><div style='margin-top:12px'>"
    html .= Hub_CaptureTableHtml(ctx)
    html .= "</div></details></div></section>"

    html .= "<div class='footer'>Generated locally from the active captured patient session. Missing or unreadable source data remains absent. Verify source values before clinical use.<br>© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.</div>"
    html .= "</div></body></html>"
    return html
}

Hub_MetricHtml(label, value) {
    return "<div class='metric'><span class='label'>" Hub_Html(label) "</span><b>" Hub_Html(value) "</b></div>"
}

Hub_MedicationTableHtml(ctx) {
    meds := PCtx_ActiveMeds(ctx)
    if meds.Length = 0
        return "<p>No active medication list recognized.</p>"
    html := "<table><thead><tr><th>Profile</th><th>Medication</th><th>Dose</th><th>Route</th><th>Sig</th><th>Knowledge</th></tr></thead><tbody>"
    for med in meds {
        rec := CRD5_FindMedication(med)
        name := IsObject(rec) ? rec["generic"] : (med.HasOwnProp("raw") ? med.raw : "Unrecognized")
        dose := med.HasOwnProp("dose") ? med.dose : ""
        route := med.HasOwnProp("route") ? med.route : ""
        sig := Sig_CompactFromMedication(med)
        status := IsObject(rec) ? "Matched" : "Unmatched"
        profile := med.HasOwnProp("profile") ? PCtx_ProfileLabel(med.profile) : "Unassigned"
        html .= "<tr><td>" Hub_Html(profile) "</td><td><b>" Hub_Html(name) "</b></td><td>" Hub_Html(dose) "</td><td>"
            . Hub_Html(route) "</td><td>" Hub_Html(sig) "</td><td>" Hub_Html(status) "</td></tr>"
    }
    return html "</tbody></table>"
}


Hub_MedRecComparisonHtml(ctx) {
    rows := MedRec_BuildComparison(ctx)
    homeCount := PCtx_ProfileMeds(ctx, "ambulatory").Length
    acuteCount := PCtx_ProfileMeds(ctx, "acute").Length
    unassignedCount := PCtx_ProfileMeds(ctx, "unassigned").Length
    summary := "<p class='muted'>" homeCount " home/ambulatory · " acuteCount
        . " acute/inpatient · " unassignedCount " unassigned</p>"
    if rows.Length = 0
        return summary "<p>Capture or assign both medication profiles to generate a comparison.</p>"
    html := summary "<table><thead><tr><th>Classification</th><th>Home / Ambulatory</th><th>Acute / Inpatient</th></tr></thead><tbody>"
    for row in rows {
        html .= "<tr><td><b>" Hub_Html(row.status) "</b></td><td>"
            . Hub_Html(MedRec_Display(row.home)) "</td><td>"
            . Hub_Html(MedRec_Display(row.acute)) "</td></tr>"
    }
    return html "</tbody></table>"
}

Hub_LabTableHtml(ctx) {
    rows := LabView_BuildRows(ctx)
    html := "<p class='muted'>Required pharmacist view · SI/metric display · missing values are shown, never inferred.</p>"
        . "<table><thead><tr><th>Group</th><th>Result</th><th>Latest</th><th>Prior</th><th>Trend</th><th>Collected</th></tr></thead><tbody>"
    for row in rows {
        latest := row.currentText = "—" ? "—" : row.currentText " " row.unit
        prior := row.priorText = "—" ? "—" : row.priorText " " row.unit
        html .= "<tr><td>" Hub_Html(row.group) "</td><td><b>" Hub_Html(row.label) "</b></td>"
            . "<td>" Hub_Html(latest) "</td><td>" Hub_Html(prior) "</td>"
            . "<td>" Hub_Html(row.trend) "</td><td>" Hub_Html(row.when) "</td></tr>"
    }
    return html "</tbody></table>"
}

Hub_CaptureTableHtml(ctx) {
    if ctx.captures.Length = 0
        return "<p>No captures recorded.</p>"
    html := "<table><thead><tr><th>#</th><th>Screen type</th><th>Time</th><th>Added</th></tr></thead><tbody>"
    for c in ctx.captures
        html .= "<tr><td>" c.n "</td><td>" Hub_Html(c.type) "</td><td>" Hub_Html(c.at)
            . "</td><td>" Hub_Html(PCtx_AddedSummary(c.added)) "</td></tr>"
    return html "</tbody></table>"
}

Hub_Html(value) {
    t := String(value)
    t := StrReplace(t, "&", "&amp;")
    t := StrReplace(t, "<", "&lt;")
    t := StrReplace(t, ">", "&gt;")
    t := StrReplace(t, '"', "&quot;")
    return t
}

Hub_OpenWorkbenchLauncher(ctx, *) {
    ready := Safety_Readiness(ctx)
    g := Gui("+MinimizeBox", "PhUCKIT · Clinical Workbenches")
    ApplyTheme(g)

    title := g.Add("Text", "x18 y14 w900 h30", "Clinical Workbenches")
    title.SetFont("s18 bold c" Theme_Accent("heading"), "Segoe UI")
    g.Add("Button", "x792 y12 w100 h28", "Patient")
        .OnEvent("Click", Patient_OpenFromAnyScreen)
    Theme_Subtle(g.Add("Text", "x18 y47 w900 h24",
        "Every patient-session tool in one visible launcher. Readiness reflects the evidence currently captured."))

    section := g.Add("Text", "x18 y84 w900 h22", "DOSING & PHARMACOKINETICS")
    section.SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    Hub_WorkbenchLauncherButton(g, ctx, 18, 110, "BMI / Body Size", ready["bmi"], Demo_ShowBMI)
    Hub_WorkbenchLauncherButton(g, ctx, 316, 110, "Renal Dose", ready["renal"], Hub_OpenRenalScreening)
    Hub_WorkbenchLauncherButton(g, ctx, 614, 110, "Vancomycin", ready["vanco"], Demo_LaunchVanco)
    Hub_WorkbenchLauncherButton(g, ctx, 18, 164, "Aminoglycoside", ready["ag"], Demo_LaunchAminoglycoside)
    Hub_WorkbenchLauncherButton(g, ctx, 316, 164, "RSI Dosing", ready["rsi"], Demo_LaunchRSI)
    Hub_WorkbenchLauncherButton(g, ctx, 614, 164, "Empiric Antibiotics", ready["abx"], Demo_LaunchAntibiotic)

    section := g.Add("Text", "x18 y232 w900 h22", "MEDICATION WORKBENCHES")
    section.SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    Hub_WorkbenchLauncherButton(g, ctx, 18, 258, "Medication Risk Stack", ready["riskstack"], Hub_OpenRiskStack)
    Hub_WorkbenchLauncherButton(g, ctx, 316, 258, "Days Supply / Taper SIG", ready["daysupply"], Calc_OpenDaySupply)
    Hub_WorkbenchLauncherButton(g, ctx, 614, 258, "Anticoag Workbench", ready["anticoag"], Hub_OpenAnticoagWorkbench)
    Hub_WorkbenchLauncherButton(g, ctx, 18, 312, "TLS Surveillance", ready["tls"], Hub_OpenTLSWorkbench)
    Hub_WorkbenchLauncherButton(g, ctx, 316, 312, "Order Review Queue", ready["riskstack"], Hub_OpenOrderReview)
    Hub_WorkbenchLauncherButton(g, ctx, 614, 312, "Capture Evidence", ready["labs"], Hub_OpenCaptureEvidence)

    section := g.Add("Text", "x18 y380 w900 h22", "LABS, ADMINISTRATION & NUTRITION")
    section.SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    Hub_WorkbenchLauncherButton(g, ctx, 18, 406, "Labs & Trends", ready["labs"], Hub_OpenLabCorrections)
    Hub_WorkbenchLauncherButton(g, ctx, 316, 406, "Infusion / MAR", ready["infusion"], Hub_OpenInfusionWorkbench)
    Hub_WorkbenchLauncherButton(g, ctx, 614, 406, "Nutrition & Electrolytes", ready["nutrition"], Hub_OpenNutritionWorkbench)

    g.Add("Button", "x18 y486 w170 h34", "Edit Captured Data")
        .OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 1))
    g.Add("Button", "x198 y486 w170 h34", "Provider Report")
        .OnEvent("Click", (*) => Hub_OpenVisualReport(ctx))
    g.Add("Button", "x792 y486 w120 h34", "Close")
        .OnEvent("Click", (*) => g.Destroy())

    footer := g.Add("Text", "x18 y548 w894 h28",
        "© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    footer.SetFont("s8 c" Theme_Accent("subtle"), "Segoe UI")
    Workbench29_Show(g,"w930 h590")
}

Hub_WorkbenchLauncherButton(g, ctx, x, y, label, readiness, handler) {
    text := label "`n" readiness.label
    btn := g.Add("Button", "x" x " y" y " w280 h44", text)
    btn.OnEvent("Click", Hub_LaunchCalc.Bind(ctx, handler, label))
    return btn
}


Hub_CalcButton(g, ctx, label, rdy, handler, newRow) {
    opt := (newRow ? "xm y+6 w315 h44" : "x+6 yp w315 h44")
    txt := label "`n" rdy.label
    btn := g.Add("Button", opt, txt)
    btn.OnEvent("Click", Hub_LaunchCalc.Bind(ctx, handler, label))
}

Hub_LaunchCalc(ctx, handler, label, *) {
    PCtx_Touch(ctx)
    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    try {
        if handler.MaxParams >= 3
            handler(ctx, parsed, label)
        else
            handler(parsed)
    } catch as e {
        MsgBox("Could not open " label ": " e.Message, "Patient Hub", "Icon!")
    }
}

Hub_NotBuilt(ctx, parsed := 0, label := "") {
    MsgBox(label " is defined in the implementation blueprint but is not built yet.`n`n"
        . "Phase 6 build order: Renal Dose Screening, Lab Corrections, Medication Risk Stack, "
        . "Infusion/MAR, Anticoagulation, TLS, Nutrition and Electrolytes.`n`n"
        . "The button is present so the hub layout is stable, but no clinical output is produced "
        . "until the module and its reference tables are built and reviewed.",
        "Not built yet", "Iconi")
}

; =================================================================================================
; COMPLETE PATIENT WORKBENCHES - evidence display first; missing data stays visibly missing
; =================================================================================================
Workbench_Footer(g, x, y, w) {
    footer := g.Add("Text", "x" x " y" y " w" w " h28",
        "© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    footer.SetFont("s8 c" Theme_Accent("subtle"), "Segoe UI")
}

Workbench_LabRows(ctx, parsed, keys) {
    byKey := Map()
    for row in LabView_BuildRows(ctx, parsed)
        byKey[row.key] := row
    out := []
    for key in keys {
        if byKey.Has(key)
            out.Push(byKey[key])
    }
    return out
}

Workbench_FillLabList(lv, rows) {
    captured := 0
    for row in rows {
        if row.currentNumeric != ""
            captured += 1
        lv.Add("", row.label, row.currentText, row.unit, row.priorText,
            QuickGlance_TrendForTable(row), row.when)
    }
    return captured
}

Workbench_MedMatches(med, ingredients) {
    for ingredient in ingredients {
        if Safety_MedMatchesIngredient(med, ingredient)
            return true
    }
    return false
}

Workbench_AddMedicationRows(lv, meds, ingredientFilter := 0) {
    added := 0
    for med in meds {
        if IsObject(ingredientFilter) && !Workbench_MedMatches(med, ingredientFilter)
            continue
        profile := med.HasOwnProp("profile") ? PCtx_ProfileLabel(med.profile) : "Unassigned"
        lv.Add("", MedRec_Display(med), profile,
            MedRec_Value(med, "status") = "" ? "—" : MedRec_Value(med, "status"),
            med.HasOwnProp("capture") ? med.capture : "—")
        added += 1
    }
    return added
}

Hub_OpenAnticoagWorkbench(ctx, parsed := 0, label := "") {
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }
    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Anticoagulation Workbench")
    ApplyTheme(g)
    title := g.Add("Text", "x18 y14 w1060 h30", "Anticoagulation Workbench")
    title.SetFont("s18 bold c" Theme_Accent("heading"), "Segoe UI")
    Theme_Subtle(g.Add("Text", "x18 y47 w1060 h38",
        "Anticoagulants, antiplatelets, renal function, CBC, and coagulation results in one view. "
        . "This screen reports captured facts; it does not infer an indication or clearance to treat."))

    g.Add("Text", "x18 y93 w650 h22", "ANTITHROMBOTIC MEDICATIONS").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    medLv := g.Add("ListView", "x18 y118 w650 h220 Grid -Multi", ["Order", "Profile", "Status", "Capture"])
    medLv.ModifyCol(1, 365), medLv.ModifyCol(2, 120), medLv.ModifyCol(3, 95), medLv.ModifyCol(4, 60)
    anticoags := ["warfarin", "apixaban", "rivaroxaban", "dabigatran", "edoxaban", "heparin",
        "enoxaparin", "dalteparin", "fondaparinux", "argatroban", "bivalirudin", "aspirin",
        "clopidogrel", "ticagrelor", "prasugrel", "cangrelor", "dipyridamole"]
    medCount := Workbench_AddMedicationRows(medLv, PCtx_ConfirmedActiveMeds(ctx), anticoags)
    if medCount = 0
        medLv.Add("", "No matching antithrombotic order captured", "—", "—", "—")

    g.Add("Text", "x686 y93 w394 h22", "PATIENT FACTORS & RESULTS").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    labLv := g.Add("ListView", "x686 y118 w394 h220 Grid -Multi", ["Result", "Latest", "Unit", "Prior"])
    labLv.ModifyCol(1, 130), labLv.ModifyCol(2, 75), labLv.ModifyCol(3, 90), labLv.ModifyCol(4, 70)
    labRows := Workbench_LabRows(ctx, parsed,
        ["weight", "crcl", "creatinine", "egfr", "platelets", "hemoglobin", "hematocrit", "inr", "ptt"])
    for row in labRows
        labLv.Add("", row.label, row.currentText, row.unit, row.priorText)

    body := "CLINICAL REVIEW`r`n"
    body .= "Age: " (PCtx_Demo(ctx, "age") = "" ? "not captured" : PCtx_Demo(ctx, "age") " years")
        . "   Sex: " (PCtx_Demo(ctx, "sex") = "" ? "not captured" : PCtx_Demo(ctx, "sex")) "`r`n"
    renal := Safety_Evaluate(ctx)["RENAL"]
    body .= "Renal screen: " renal.status (renal.short != "" ? " · " renal.short : "") "`r`n"
    if renal.findings.Length > 0 {
        for finding in renal.findings
            body .= "• " finding "`r`n"
    } else {
        body .= "• " renal.note "`r`n"
    }
    body .= "`r`nMissing data is intentionally blank. Verify indication, last dose, bleeding/thrombotic context, "
        . "procedures, dialysis/RRT, and product-specific labeling outside the captured screen."
    g.Add("Text", "x18 y354 w1060 h22", "EDITABLE WORKING NOTE").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    note := g.Add("Edit", "x18 y379 w1062 h190 VScroll -Wrap", body)
    Theme_OutputFont(note)
    g.Add("Button", "x18 y587 w155 h34", "Copy working note").OnEvent("Click", (*) => (A_Clipboard := note.Value))
    g.Add("Button", "x183 y587 w155 h34", "Edit captured data").OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 2))
    g.Add("Button", "x348 y587 w155 h34", "Open renal dosing").OnEvent("Click", (*) => Hub_OpenRenalScreening(ctx))
    g.Add("Button", "x958 y587 w122 h34", "Close").OnEvent("Click", (*) => g.Destroy())
    Workbench_Footer(g, 18, 642, 1062)
    Workbench29_Show(g,"w1100 h680")
}

Hub_OpenTLSWorkbench(ctx, parsed := 0, label := "") {
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }
    g := Gui("+MinimizeBox +Resize", "PhUCKIT · TLS Surveillance")
    ApplyTheme(g)
    title := g.Add("Text", "x18 y14 w1060 h30", "Tumor Lysis Surveillance")
    title.SetFont("s18 bold c" Theme_Accent("heading"), "Segoe UI")
    Theme_Subtle(g.Add("Text", "x18 y47 w1060 h38",
        "Latest and prior TLS-relevant results, without diagnosing TLS from an incomplete screenshot. "
        . "Use the trend and collection time to decide where to look next."))
    labLv := g.Add("ListView", "x18 y100 w720 h420 Grid -Multi",
        ["Result", "Latest", "Unit", "Prior", "Trend", "Collected"])
    labLv.ModifyCol(1, 150), labLv.ModifyCol(2, 78), labLv.ModifyCol(3, 88)
    labLv.ModifyCol(4, 72), labLv.ModifyCol(5, 115), labLv.ModifyCol(6, 205)
    rows := Workbench_LabRows(ctx, parsed,
        ["potassium", "phosphate", "calcium", "uricacid", "creatinine", "egfr", "ldh", "lactate"])
    captured := Workbench_FillLabList(labLv, rows)

    g.Add("Text", "x760 y100 w320 h22", "CAPTURE COMPLETENESS").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    missing := ""
    for row in rows {
        if row.currentNumeric = ""
            missing .= "• " row.label " not captured`r`n"
    }
    if missing = ""
        missing := "All displayed TLS surveillance values were captured."
    else
        missing := captured " of " rows.Length " displayed values captured.`r`n`r`n" missing
    missing .= "`r`nCollection times remain visible because non-concurrent values are not silently combined."
    miss := g.Add("Edit", "x760 y128 w320 h195 ReadOnly VScroll -Wrap", missing)
    Theme_OutputFont(miss)

    g.Add("Text", "x760 y344 w320 h22", "URATE-LOWERING THERAPY").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    medLv := g.Add("ListView", "x760 y372 w320 h148 Grid -Multi", ["Order", "Status"])
    medLv.ModifyCol(1, 220), medLv.ModifyCol(2, 85)
    tlsMeds := ["allopurinol", "rasburicase", "febuxostat"]
    count := 0
    for med in PCtx_ConfirmedActiveMeds(ctx) {
        if !Workbench_MedMatches(med, tlsMeds)
            continue
        medLv.Add("", MedRec_Display(med), MedRec_Value(med, "status") = "" ? "—" : MedRec_Value(med, "status"))
        count += 1
    }
    if count = 0
        medLv.Add("", "No matching order captured", "—")

    g.Add("Button", "x18 y540 w160 h34", "Copy displayed labs").OnEvent("Click", (*) => Hub_CopyListView(labLv, "TLS SURVEILLANCE", "No diagnosis inferred"))
    g.Add("Button", "x188 y540 w155 h34", "Open Labs & Trends").OnEvent("Click", (*) => Hub_OpenLabCorrections(ctx))
    g.Add("Button", "x353 y540 w155 h34", "Edit captured data").OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 2))
    g.Add("Button", "x958 y540 w122 h34", "Close").OnEvent("Click", (*) => g.Destroy())
    Workbench_Footer(g, 18, 594, 1062)
    Workbench29_Show(g,"w1100 h632")
}

Hub_OpenInfusionWorkbench(ctx, parsed := 0, label := "") {
    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Infusion and MAR")
    ApplyTheme(g)
    title := g.Add("Text", "x18 y14 w1060 h30", "Infusion / MAR Workbench")
    title.SetFont("s18 bold c" Theme_Accent("heading"), "Segoe UI")
    Theme_Subtle(g.Add("Text", "x18 y47 w1060 h38",
        "Captured orders and administration rows side by side. Rates, bags, and administrations are never filled in unless they were visible."))
    g.Add("Text", "x18 y93 w650 h22", "ACTIVE / PENDING ORDERS").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    medLv := g.Add("ListView", "x18 y118 w650 h405 Grid -Multi", ["Order", "Profile", "Status", "Capture"])
    medLv.ModifyCol(1, 360), medLv.ModifyCol(2, 120), medLv.ModifyCol(3, 95), medLv.ModifyCol(4, 60)
    if Workbench_AddMedicationRows(medLv, PCtx_ActiveMeds(ctx)) = 0
        medLv.Add("", "No medication order profile captured", "—", "—", "—")

    g.Add("Text", "x686 y93 w394 h22", "CAPTURED MAR EVIDENCE").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    marLv := g.Add("ListView", "x686 y118 w394 h405 Grid -Multi", ["Captured row", "Capture", "Time"])
    marLv.ModifyCol(1, 255), marLv.ModifyCol(2, 65), marLv.ModifyCol(3, 60)
    if ctx.mar.Length = 0 {
        marLv.Add("", "No MAR screen captured", "—", "—")
    } else {
        for row in ctx.mar
            marLv.Add("", row.text, row.capture, row.when = "" ? "—" : row.when)
    }
    g.Add("Button", "x18 y542 w155 h34", "Copy orders").OnEvent("Click", (*) => Hub_CopyListView(medLv, "CAPTURED ORDERS"))
    g.Add("Button", "x183 y542 w155 h34", "Copy MAR evidence").OnEvent("Click", (*) => Hub_CopyListView(marLv, "CAPTURED MAR EVIDENCE"))
    g.Add("Button", "x348 y542 w155 h34", "Edit captured data").OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 5))
    g.Add("Button", "x958 y542 w122 h34", "Close").OnEvent("Click", (*) => g.Destroy())
    Workbench_Footer(g, 18, 596, 1062)
    Workbench29_Show(g,"w1100 h634")
}

Hub_OpenNutritionWorkbench(ctx, parsed := 0, label := "") {
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }
    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Nutrition and Electrolytes")
    ApplyTheme(g)
    title := g.Add("Text", "x18 y14 w1060 h30", "Nutrition & Electrolytes")
    title.SetFont("s18 bold c" Theme_Accent("heading"), "Segoe UI")
    Theme_Subtle(g.Add("Text", "x18 y47 w1060 h38",
        "A metric, trend-first view of fluid, electrolyte, glucose, and protein data. Missing values stay missing."))
    labLv := g.Add("ListView", "x18 y100 w720 h450 Grid -Multi",
        ["Result", "Latest", "Unit", "Prior", "Trend", "Collected"])
    labLv.ModifyCol(1, 150), labLv.ModifyCol(2, 78), labLv.ModifyCol(3, 88)
    labLv.ModifyCol(4, 72), labLv.ModifyCol(5, 115), labLv.ModifyCol(6, 205)
    rows := Workbench_LabRows(ctx, parsed,
        ["weight", "sodium", "potassium", "chloride", "bicarbonate", "calcium", "magnesium",
         "phosphate", "glucose", "albumin", "bun", "creatinine"])
    captured := Workbench_FillLabList(labLv, rows)

    g.Add("Text", "x760 y100 w320 h22", "AT A GLANCE").SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")
    summary := captured " of " rows.Length " displayed values captured.`r`n`r`n"
    changed := 0
    for row in rows {
        if row.currentNumeric = "" || row.priorNumeric = "" || InStr(row.trend, "Stable")
            continue
        summary .= "• " row.label " " row.currentText " " row.unit " · " row.trend "`r`n"
        changed += 1
    }
    if changed = 0
        summary .= "No captured two-point changes to display."
    summary .= "`r`n`r`nAlbumin is displayed as a result, not treated as a stand-alone nutrition diagnosis."
    summaryBox := g.Add("Edit", "x760 y128 w320 h245 ReadOnly VScroll -Wrap", summary)
    Theme_OutputFont(summaryBox)
    g.Add("Button", "x760 y392 w320 h42", "Open evidence-grounded lab calculations")
        .OnEvent("Click", (*) => Hub_OpenCorrectionDetails(ctx))
    g.Add("Button", "x760 y444 w320 h42", "Open full Labs & Trends")
        .OnEvent("Click", (*) => Hub_OpenLabCorrections(ctx))
    g.Add("Button", "x760 y508 w320 h42", "Edit captured values")
        .OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 2))
    g.Add("Button", "x18 y570 w165 h34", "Copy displayed table")
        .OnEvent("Click", (*) => Hub_CopyListView(labLv, "NUTRITION & ELECTROLYTES", "Metric display; missing values not inferred"))
    g.Add("Button", "x958 y570 w122 h34", "Close").OnEvent("Click", (*) => g.Destroy())
    Workbench_Footer(g, 18, 624, 1062)
    Workbench29_Show(g,"w1100 h662")
}

Hub_SafetyClick(ctx, key, *) {
    Safety_ShowDetail(ctx, key)
}

Hub_Refresh(g) {
    ctx := PCtx_Active()
    try g.Destroy()
    if IsObject(ctx)
        Hub_Show(ctx)
}

Hub_UndoAndRefresh(g) {
    fresh := PCtx_UndoLastCapture()
    try g.Destroy()
    if IsObject(fresh)
        Hub_Show(fresh)
}

Hub_ShowAllergyFindings(ctx) {
    findings := Allergy_ScanOrders(ctx.allergyRecs, PCtx_ConfirmedActiveMeds(ctx))
    body := ""
    if findings.Length = 0 {
        body := "No conflict matched between the captured allergies and the captured orders.`r`n`r`n"
            . "This is not a clearance. Allergies or orders that were not visible on the captured "
            . "screens were not evaluated."
    } else {
        for f in findings {
            body .= f.sev "   " f.title "`r`n"
            body .= "   " f.detail "`r`n"
            body .= "   Order:   " f.med "`r`n"
            body .= "   Allergy: " f.allergy "`r`n`r`n"
        }
    }
    unc := Allergy_Unclassified(ctx.allergyRecs)
    if unc.Length > 0 {
        body .= "Unclassified allergy entries (retained, not treated as drug ingredients):`r`n"
        for u in unc
            body .= "  - " u "`r`n"
    }

    g := Gui("+MinimizeBox", "Allergy / Order Conflicts")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w720", "Allergy and order conflict review"))
    out := g.Add("Edit", "xm y+8 w720 h380 ReadOnly VScroll -Wrap", body)
    Theme_OutputFont(out)
    g.Add("Button", "xm y+10 w120", "Copy").OnEvent("Click", (*) => (A_Clipboard := body))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w760")
}

Hub_ShowRefStatus() {
    body := "Clinical reference data`r`n"
    body .= "======================================================================`r`n"
    body .= "Location: " RefData_Dir() "`r`n`r`n"
    for name, spec in RefData_Catalog() {
        body .= RefData_StatusLine(name) "`r`n"
        body .= "    source: " spec.src "`r`n"
        body .= "    institutional review: NOT REVIEWED`r`n`r`n"
    }
    body .= "Seed tables are curated starting points. They must be reviewed and versioned by the "
        . "institution before they are used as the basis for a clinical decision. Edit the CSV "
        . "files directly and use Reload Reference Data."

    g := Gui("+MinimizeBox", "Reference Source Versions")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    out := g.Add("Edit", "xm w700 h360 ReadOnly VScroll -Wrap", body)
    Theme_OutputFont(out)
    g.Add("Button", "xm y+10 w170", "Reload Reference Data")
        .OnEvent("Click", (*) => (RefData_Reload(), MsgBox("Reference data reloaded.", "Reference", "Iconi"), g.Destroy()))
    g.Add("Button", "x+8 yp w120", "Open Data Folder")
        .OnEvent("Click", (*) => Hub_OpenDataFolder())
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w740")
}

Hub_OpenDataFolder() {
    RefData_EnsureSeeds()
    try {
        Run('explorer.exe "' RefData_Dir() '"')
    } catch as e {
        MsgBox("Could not open " RefData_Dir() ": " e.Message, "Reference", "Icon!")
    }
}

Hub_CopySnapshot(ctx) {
    A_Clipboard := Report_Build(ctx)
    ToolTip("Snapshot copied.")
    SetTimer(() => ToolTip(), -1500)
}

; -------------------------------------------------------------------------------------------------
; §17 CAPTURES PANEL
; -------------------------------------------------------------------------------------------------
Hub_ShowCaptures(ctx) {
    g := Gui("+MinimizeBox", "Review Captures")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    lv := g.Add("ListView", "xm w700 h240 Grid -Multi",
        ["#", "Screen Type", "Time", "Information Added"])
    for c in ctx.captures
        lv.Add("", c.n, c.type, c.at, PCtx_AddedSummary(c.added))
    lv.ModifyCol(1, 40)
    lv.ModifyCol(2, 180)
    lv.ModifyCol(3, 70)
    lv.ModifyCol(4, 390)

    g.Add("Button", "xm y+10 w150", "View Extracted Data")
        .OnEvent("Click", (*) => Hub_ViewCapture(ctx, lv))
    g.Add("Button", "x+6 yp w130", "Delete Capture")
        .OnEvent("Click", (*) => Hub_DeleteCapture(ctx, lv, g))
    g.Add("Button", "x+6 yp w130", "Undo Last Capture")
        .OnEvent("Click", (*) => Hub_UndoFromPanel(g))
    g.Add("Button", "x+6 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())

    Theme_Subtle(g.Add("Text", "xm y+10 w700",
        "Reprocess is unavailable by design: source screenshots are not retained after parsing, "
        . "so there is no stored image to re-run. Recapture the screen instead."))
    g.Show("w740")
}

Hub_OpenCaptureEvidence(ctx, parsed := 0, label := "") {
    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Capture Evidence Review")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w940", "Capture evidence review"))
    Theme_Subtle(g.Add("Text", "xm y+3 w940", "Accepted values can inform the patient session. Conflicts and candidates remain visible for pharmacist confirmation and are not used by clinical rules."))
    captures := g.Add("ListView", "xm y+10 w940 h185 Grid -Multi", ["#", "Screen", "Time", "Information Added", "Warnings"])
    for capture in ctx.captures {
        warnings := 0
        if IsObject(capture.parsed) && capture.parsed.HasOwnProp("captureWarnings") && IsObject(capture.parsed.captureWarnings)
            warnings := capture.parsed.captureWarnings.Length
        captures.Add("", capture.n, capture.type, capture.at, PCtx_AddedSummary(capture.added), warnings)
    }
    captures.ModifyCol(1, 42), captures.ModifyCol(2, 180), captures.ModifyCol(3, 70), captures.ModifyCol(4, 500), captures.ModifyCol(5, 70)
    details := g.Add("Edit", "xm y+10 w940 h270 ReadOnly VScroll -Wrap", "Select a capture to inspect its accepted and unresolved evidence.")
    Theme_OutputFont(details)
    captures.OnEvent("ItemSelect", (*) => Hub_CaptureEvidenceSelected(ctx, captures, details))
    g.Add("Button", "xm y+10 w165 h32", "Edit Captured Data").OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 1))
    g.Add("Button", "x+8 yp w145 h32", "View Raw OCR").OnEvent("Click", (*) => Hub_ViewCapture(ctx, captures))
    g.Add("Button", "x+8 yp w120 h32", "Copy Evidence").OnEvent("Click", (*) => (A_Clipboard := details.Value))
    g.Add("Button", "x+8 yp w100 h32", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w980 h580")
}

Hub_CaptureEvidenceSelected(ctx, captures, details) {
    row := captures.GetNext(0, "Focused")
    if row = 0 || row > ctx.captures.Length
        return
    capture := ctx.captures[row]
    body := "CAPTURE #" capture.n " · " capture.type " · " capture.at "`r`n"
        . "======================================================================`r`n"
    if IsObject(capture.parsed) && capture.parsed.HasOwnProp("captureEvidence") && IsObject(capture.parsed.captureEvidence) {
        body .= "FIELD EVIDENCE`r`n"
        for field, record in capture.parsed.captureEvidence {
            if !IsObject(record)
                continue
            value := record.HasOwnProp("value") ? record.value : ""
            status := record.HasOwnProp("status") ? record.status : "unknown"
            unit := record.HasOwnProp("unit") && record.unit != "" ? " " record.unit : ""
            detail := record.HasOwnProp("detail") ? record.detail : ""
            body .= field ": " value unit " · " status (detail != "" ? " · " detail : "") "`r`n"
        }
    }
    if capture.parsed.HasOwnProp("captureWarnings") && IsObject(capture.parsed.captureWarnings) && capture.parsed.captureWarnings.Length {
        body .= "`r`nREVIEW ITEMS`r`n"
        for warning in capture.parsed.captureWarnings
            body .= "• " warning "`r`n"
    }
    body .= "`r`nRAW OCR`r`n----------------------------------------------------------------------`r`n" capture.rawText
    details.Value := body
}

Hub_OpenOrderReview(ctx, parsed := 0, label := "") {
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }
    meds := PCtx_ConfirmedActiveMeds(ctx)
    if meds.Length = 0 {
        MsgBox("No source-confirmed active medication orders are available. Capture an active order profile first.", "Order Review Queue", "Iconi")
        return
    }
    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Order Review Queue")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w980", "Order-by-order pharmacist review"))
    Theme_Subtle(g.Add("Text", "xm y+3 w980", "This queue identifies evidence-backed review prompts. It does not approve, submit, modify, or discontinue an order."))
    list := g.Add("ListView", "xm y+10 w980 h230 Grid -Multi", ["Order", "Status", "Profile", "Review prompts"])
    for index, med in meds {
        prompts := MedRec_ClinicalFlags(ctx, [med], parsed)
        allergies := Allergy_ScanOrders(ctx.allergyRecs, [med])
        if allergies.Length
            prompts .= (prompts != "" ? " | " : "") allergies[1].title
        list.Add("", MedRec_Display(med), MedRec_StatusLabel(med), PCtx_ProfileLabel(MedRec_Value(med, "profile")), prompts = "" ? "No matched prompt" : prompts)
    }
    list.ModifyCol(1, 330), list.ModifyCol(2, 95), list.ModifyCol(3, 125), list.ModifyCol(4, 410)
    note := g.Add("Edit", "xm y+10 w980 h210 ReadOnly VScroll -Wrap", "Select an order to review its captured context.")
    Theme_OutputFont(note)
    list.OnEvent("ItemSelect", (*) => Hub_OrderReviewSelected(ctx, meds, list, note))
    g.Add("Button", "xm y+10 w155 h32", "Open Clinical Safety").OnEvent("Click", (*) => Hub_OpenRiskStack(ctx))
    g.Add("Button", "x+8 yp w155 h32", "Open Labs & Trends").OnEvent("Click", (*) => Hub_OpenLabCorrections(ctx))
    g.Add("Button", "x+8 yp w170 h32", "Background Lookups").OnEvent("Click", (*) => Hub_OpenBackgroundLookups(ctx))
    g.Add("Button", "x+8 yp w155 h32", "Copy Review Note").OnEvent("Click", (*) => (A_Clipboard := note.Value))
    g.Add("Button", "x+8 yp w180 h32", "Copy Documentation Prompt").OnEvent("Click", (*) => Hub_OrderReviewCopyDocumentation(ctx, meds, list))
    g.Add("Button", "x+8 yp w110 h32", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w1020 h560")
}

Hub_OrderReviewSelected(ctx, meds, list, note) {
    row := list.GetNext(0, "Focused")
    if row = 0 || row > meds.Length
        return
    med := meds[row]
    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    body := "ORDER REVIEW`r`n======================================================================`r`n"
        . "Order: " MedRec_Display(med) "`r`n"
        . "Status: " MedRec_StatusLabel(med) "`r`n"
        . "Profile: " PCtx_ProfileLabel(MedRec_Value(med, "profile")) "`r`n"
        . "Dose/route/SIG: " MedRec_Value(med, "dose") " " MedRec_Value(med, "route") " " Sig_CompactFromMedication(med) "`r`n"
        . "Renal inputs: SCr " (parsed.scr != "" ? parsed.scr " mg/dL" : "not captured")
        . " · CrCl " (parsed.crcl != "" ? parsed.crcl " mL/min" : "not calculated") "`r`n`r`n"
    prompts := MedRec_ClinicalFlags(ctx, [med], parsed)
    body .= "REVIEW PROMPTS`r`n" (prompts != "" ? prompts : "No medication-specific prompt matched the captured data.") "`r`n`r`n"
    allergyFindings := Allergy_ScanOrders(ctx.allergyRecs, [med])
    body .= "ALLERGY REVIEW`r`n"
    if allergyFindings.Length {
        for finding in allergyFindings
            body .= finding.sev " · " finding.title "`r`n" finding.detail "`r`n"
    } else
        body .= "No conflict matched against captured allergy entries. This is not a clearance.`r`n"
    body .= "`r`nCHECK BEFORE PROCESSING`r`n"
        . "• Indication, dose, route, frequency, duration, and formulation`r`n"
        . "• Renal/hepatic context, dialysis/RRT, weight basis, and current labs`r`n"
        . "• Allergy reaction details, interactions, duplication, monitoring, and administration constraints`r`n"
        . "• Full MAR, current order status, and applicable local policy`r`n"
    body .= "`r`nMEDICATION-TO-LAB DEPENDENCIES`r`n" OrderReview_LabDependencies(ctx, med)
    body .= "`r`nADVERSE-EFFECT WATCHLIST`r`n" OrderReview_AdverseEffectWatchlist(med)
    body .= "`r`nRELEVANT WORKBENCH READINESS`r`n" OrderReview_Readiness(ctx, med)
    body .= "`r`nUNRESOLVED EVIDENCE`r`n" OrderReview_UnresolvedEvidence(ctx, med)
    note.Value := body
}

OrderReview_UnresolvedEvidence(ctx, med) {
    unresolved := []
    for field in ["dose", "route", "status", "profile"] {
        if Trim(MedRec_Value(med, field)) = ""
            unresolved.Push("Captured " field " is missing.")
    }
    if PCtx_LabCandidateCount(ctx) > 0
        unresolved.Push(PCtx_LabCandidateCount(ctx) " laboratory value(s) still need confirmation and are excluded from clinical rules.")
    if ctx.conflicts.Length > 0
        unresolved.Push(ctx.conflicts.Length " capture conflict(s) remain unresolved.")
    if unresolved.Length = 0
        return "• No unresolved evidence is recorded for this review. This does not confirm chart completeness.`r`n"
    out := ""
    for item in unresolved
        out .= "• " item "`r`n"
    return out
}

OrderReview_LabDependencies(ctx, med) {
    ingredients := med.HasOwnProp("ingredients") ? med.ingredients : []
    required := []
    for ingredient in ingredients {
        ing := StrLower(ingredient)
        if ing = "vancomycin"
            required := ["creatinine", "weight", "vancomycin"]
        else if ing ~= "^(gentamicin|tobramycin|amikacin)$"
            required := ["creatinine", "weight"]
        else if ing = "warfarin"
            required := ["inr", "hemoglobin", "platelets"]
        else if ing ~= "^(heparin|argatroban|bivalirudin)$"
            required := ["ptt", "hemoglobin", "platelets", "creatinine"]
        else if ing ~= "^(enoxaparin|fondaparinux|apixaban|rivaroxaban|dabigatran|edoxaban)$"
            required := ["hemoglobin", "platelets", "creatinine"]
        else if ing = "linezolid"
            required := ["platelets", "hemoglobin", "wbc"]
        else if ing ~= "^(trimethoprim|sulfamethoxazole|spironolactone|eplerenone|lisinopril|losartan)$"
            required := ["potassium", "creatinine"]
        else if ing = "digoxin"
            required := ["creatinine", "potassium", "magnesium", "digoxin"]
        else if ing = "insulin"
            required := ["glucose", "potassium"]
    }
    if required.Length = 0
        return "• No medication-specific lab dependency is configured for this captured ingredient. Review labeling, indication, and local monitoring policy.`r`n"
    out := ""
    seen := Map()
    for key in required {
        if seen.Has(key)
            continue
        seen[key] := true
        value := key = "weight" ? PCtx_SelectedWeight(ctx) : PCtx_LabValue(ctx, key)
        out .= "• " PCtx_LabLabel(key) ": " (value = "" ? "not captured" : value) "`r`n"
    }
    return out
}

OrderReview_AdverseEffectWatchlist(med) {
    record := CRD5_FindMedication(med)
    if !IsObject(record)
        return "• Medication was not matched to the clinical library; review monitoring and adverse effects from the selected reference.`r`n"
    tags := record.Has("tags") ? record["tags"] : []
    watch := []
    tagMap := Map(
        "renal", "renal function and dose accumulation",
        "qt", "QTc/electrolytes and other QT-risk therapy",
        "hyperkalemia", "potassium and renal function",
        "hypoglycemia", "glucose trend and nutrition status",
        "bleeding", "bleeding symptoms, CBC, and interacting therapy",
        "cns_depressant", "sedation, respiratory status, and co-administered CNS depressants",
        "resp_depression", "respiratory status and sedation",
        "hepatotoxicity", "hepatic function and symptoms when clinically indicated",
        "myelosuppression", "CBC trend",
        "bradycardia", "heart rate, blood pressure, and conduction risk"
    )
    for tag in tags {
        if tagMap.Has(tag)
            watch.Push(tagMap[tag])
    }
    if watch.Length = 0
        return "• No medication-specific watchlist tag is configured; use product labeling and local policy.`r`n"
    out := ""
    for item in watch
        out .= "• Monitor " item ".`r`n"
    return out
}

OrderReview_Readiness(ctx, med) {
    ready := Safety_Readiness(ctx)
    keys := ["riskstack"]
    out := ""
    raw := StrLower(MedRec_Value(med, "raw"))
    if InStr(raw, "vancomycin")
        keys.Push("vanco")
    if RegExMatch(raw, "i)\b(?:gentamicin|tobramycin|amikacin)\b")
        keys.Push("ag")
    if RegExMatch(raw, "i)\b(?:heparin|enoxaparin|warfarin|apixaban|rivaroxaban|dabigatran)\b")
        keys.Push("anticoag")
    for key in keys
        out .= "• " key ": " ready[key].label "`r`n"
    return out
}

Hub_OrderReviewCopyDocumentation(ctx, meds, list) {
    row := list.GetNext(0, "Focused")
    if row = 0 || row > meds.Length {
        MsgBox("Select an order first.", "Order Review Queue", "Iconi")
        return
    }
    med := meds[row]
    parsed := PCtx_ToParsed(ctx)
    PatientCalc_Enrich(parsed)
    text := "Pharmacist review completed for " MedRec_Display(med) ". "
    prompts := MedRec_ClinicalFlags(ctx, [med], parsed)
    text .= prompts != "" ? "Review prompts assessed: " prompts ". " : "Dose, route, frequency, formulation, and monitoring requirements reviewed. "
    text .= "Renal data: SCr " (parsed.scr != "" ? parsed.scr " mg/dL" : "not captured")
        . "; CrCl " (parsed.crcl != "" ? parsed.crcl " mL/min" : "not calculated") ". "
    text .= "Verify final documentation against the complete chart and local policy."
    A_Clipboard := text
    ToolTip("Documentation prompt copied.")
    SetTimer(() => ToolTip(), -1500)
}

Hub_UndoFromPanel(panelGui) {
    try panelGui.Destroy()
    fresh := PCtx_UndoLastCapture()
    if IsObject(fresh)
        Hub_Show(fresh)
}

Hub_ViewCapture(ctx, lv) {
    row := lv.GetNext()
    if row = 0 {
        MsgBox("Select a capture first.", "Review Captures", "Iconi")
        return
    }
    c := ctx.captures[row]
    body := "Capture #" c.n "`r`nScreen type: " c.type "`r`nCaptured: " c.at "`r`n"
        . "Added: " PCtx_AddedSummary(c.added) "`r`n"
        . "======================================================================`r`n"
        . c.rawText

    g := Gui("+MinimizeBox", "Capture #" c.n " - extracted text")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    out := g.Add("Edit", "xm w700 h420 Multi VScroll WantTab +Wrap", body)
    Theme_OutputFont(out)
    Theme_Subtle(g.Add("Text", "xm y+6 w700", "Editable copy for review; changes here do not alter the structured patient session."))
    g.Add("Button", "xm y+8 w120", "Copy Text").OnEvent("Click", (*) => (A_Clipboard := out.Value))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w740")
}

Hub_DeleteCapture(ctx, lv, owner) {
    global PCtxSession
    row := lv.GetNext()
    if row = 0 {
        MsgBox("Select a capture first.", "Review Captures", "Iconi")
        return
    }
    if MsgBox("Delete capture #" row " and rebuild the session from the remaining captures?",
        "Review Captures", "OKCancel Icon!") != "OK"
        return

    keep := []
    for i, c in ctx.captures {
        if i != row
            keep.Push(c)
    }
    if keep.Length = 0 {
        PCtx_ClearSession(false)
        try owner.Destroy()
        return
    }
    fresh := PCtx_New()
    fresh.startedAt := ctx.startedAt
    PCtxSession := fresh
    for c in keep
        PCtx_MergeCapture(fresh, c.parsed, c.rawText, c.type)
    try owner.Destroy()
    Hub_Show(fresh)
}

; -------------------------------------------------------------------------------------------------
; TABBED EDIT WINDOW  (§8 "Edit Data ... [Patient] [Labs] [Allergies] [Medications] [MAR]")
; -------------------------------------------------------------------------------------------------
Hub_EditCaptured(ctx, owner := 0, startTab := 1) {
    g := Gui("+MinimizeBox", "Edit Captured Data")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    tab := g.Add("Tab3", "xm w700 h420", ["Patient", "Labs", "Allergies", "Medications", "MAR"])

    ; --- Patient
    tab.UseTab(1)
    g.Add("Text", "xm+12 y+14 w120", "Age (yr):")
    ageE := g.Add("Edit", "x+6 yp-3 w100", PCtx_Demo(ctx, "age"))
    g.Add("Text", "xm+12 y+10 w120", "Sex:")
    sexE := g.Add("Edit", "x+6 yp-3 w100", PCtx_Demo(ctx, "sex"))
    g.Add("Text", "xm+12 y+10 w120", "Height (cm):")
    htE := g.Add("Edit", "x+6 yp-3 w100", PCtx_Demo(ctx, "heightCm"))
    g.Add("Text", "xm+12 y+10 w120", "Weight (kg):")
    wtE := g.Add("Edit", "x+6 yp-3 w100", PCtx_SelectedWeight(ctx))
    g.Add("Text", "xm+12 y+10 w120", "Location:")
    locE := g.Add("Edit", "x+6 yp-3 w220", PCtx_Demo(ctx, "location"))
    Theme_Subtle(g.Add("Text", "xm+12 y+14 w640",
        "Any value changed here is marked as manually reviewed and will not be overwritten by a "
        . "later capture. All dependent calculations and safety findings refresh on save."))

    if ctx.conflicts.Length > 0 {
        Theme_Subtle(g.Add("Text", "xm+12 y+14 w640", "Conflicts across captures:"))
        ctext := ""
        for c in ctx.conflicts
            ctext .= (c.resolved ? "[resolved] " : "[OPEN] ") c.field ": capture " c.capA " = "
                . c.a "  vs  capture " c.capB " = " c.b "`r`n"
        g.Add("Edit", "xm+12 y+4 w640 h80 ReadOnly -Wrap", ctext)
    }

    ; --- Labs
    tab.UseTab(2)
    labLv := g.Add("ListView", "xm+12 y+14 w660 h280 Grid -Multi",
        ["Analyte", "Value", "Unit", "Collected", "Status", "Capture", "Key", "Candidate"])
    for key, arr in ctx.labs {
        for e in arr
            labLv.Add("", PCtx_LabLabel(key), e.value, e.unit,
                (e.when = "" ? "not captured" : e.when), "Accepted", e.capture, key, 0)
    }
    if ctx.HasOwnProp("labCandidates") && IsObject(ctx.labCandidates) {
        for key, arr in ctx.labCandidates {
            for index, e in arr {
                statusText := e.status = "conflict" ? "Conflict" : "Confirm"
                labLv.Add("", PCtx_LabLabel(key), e.value, e.unit,
                    (e.when = "" ? "not captured" : e.when), statusText, e.capture, key, index)
            }
        }
    }
    labLv.ModifyCol(1, 145)
    labLv.ModifyCol(2, 80)
    labLv.ModifyCol(3, 80)
    labLv.ModifyCol(4, 140)
    labLv.ModifyCol(5, 80)
    labLv.ModifyCol(6, 60)
    labLv.ModifyCol(7, 0)
    labLv.ModifyCol(8, 0)
    g.Add("Text", "xm+12 y+12 w82", "Review value:")
    candidateValueE := g.Add("Edit", "x+5 yp-4 w90")
    labLv.OnEvent("ItemSelect", (*) => Hub_LabCandidateSelected(ctx, labLv, candidateValueE))
    g.Add("Button", "x+8 yp w145", "Confirm Value")
        .OnEvent("Click", (*) => Hub_ConfirmLabCandidate(ctx, labLv, candidateValueE))
    Theme_Subtle(g.Add("Text", "x+10 yp+4 w300",
        "Edit if needed. Only confirmed values reach clinical rules."))

    ; --- Allergies
    tab.UseTab(3)
    alLv := g.Add("ListView", "xm+12 y+14 w660 h280 Grid -Multi",
        ["Documented text", "Normalized ingredient(s)", "Reaction", "Type"])
    for a in ctx.allergyRecs {
        ing := ""
        for i in a.ingredients
            ing .= (ing = "" ? "" : " + ") i
        alLv.Add("", a.raw, (ing = "" ? "-" : ing),
            (a.reaction = "" ? "not captured" : a.reaction),
            (a.isDrug ? "drug" : "unclassified"))
    }
    alLv.ModifyCol(1, 200)
    alLv.ModifyCol(2, 190)
    alLv.ModifyCol(3, 170)
    alLv.ModifyCol(4, 90)
    g.Add("Button", "xm+12 y+8 w150", "Delete Selected")
        .OnEvent("Click", (*) => Hub_DeleteAllergy(ctx, alLv))
    g.Add("Text", "x+10 yp+4 w120", "Add allergy:")
    newAl := g.Add("Edit", "x+4 yp-4 w200")
    g.Add("Button", "x+6 yp w80", "Add")
        .OnEvent("Click", (*) => Hub_AddAllergy(ctx, alLv, newAl))

    ; --- Medications
    tab.UseTab(4)
    medLv := g.Add("ListView", "xm+12 y+14 w660 h300 Grid -Multi",
        ["Order text", "Ingredient(s)", "Dose", "Route", "Status"])
    for m in ctx.medRecs {
        ing := ""
        for i in m.ingredients
            ing .= (ing = "" ? "" : " + ") i
        medLv.Add("", m.raw, (ing = "" ? "NOT NORMALIZED" : ing), m.dose, m.route,
            (m.status = "" ? "-" : m.status) (m.lowConfidence ? " [low conf]" : ""))
    }
    medLv.ModifyCol(1, 250)
    medLv.ModifyCol(2, 160)
    medLv.ModifyCol(3, 80)
    medLv.ModifyCol(4, 80)
    medLv.ModifyCol(5, 90)
    g.Add("Button", "xm+12 y+8 w150", "Delete Selected")
        .OnEvent("Click", (*) => Hub_DeleteMed(ctx, medLv))
    g.Add("Text", "x+10 yp+4 w120", "Add order:")
    newMed := g.Add("Edit", "x+4 yp-4 w200")
    g.Add("Button", "x+6 yp w80", "Add")
        .OnEvent("Click", (*) => Hub_AddMed(ctx, medLv, newMed))

    ; --- MAR
    tab.UseTab(5)
    marTxt := ""
    if ctx.mar.Length = 0 {
        marTxt := "No MAR screen has been captured in this session."
    } else {
        for r in ctx.mar
            marTxt .= "capture " r.capture ": " r.text "`r`n"
    }
    g.Add("Edit", "xm+12 y+14 w660 h300 ReadOnly VScroll -Wrap", marTxt)

    tab.UseTab()
    tab.Value := startTab

    g.Add("Button", "xm y+10 w160 Default", "Save and Refresh")
        .OnEvent("Click", (*) => Hub_SaveEdits(ctx, g, owner, ageE, sexE, htE, wtE, locE))
    g.Add("Button", "x+8 yp w100", "Cancel").OnEvent("Click", (*) => g.Destroy())
    g.Show("w740")
}

Hub_SaveEdits(ctx, g, owner, ageE, sexE, htE, wtE, locE) {
    Hub_SetDemo(ctx, "age", Trim(ageE.Value))
    Hub_SetDemo(ctx, "sex", Trim(sexE.Value))
    Hub_SetDemo(ctx, "heightCm", Trim(htE.Value))
    Hub_SetDemo(ctx, "location", Trim(locE.Value))

    newWt := Trim(wtE.Value)
    if newWt != "" {
        found := false
        for w in ctx.weights {
            w.selected := false
            if w.kg = newWt {
                w.selected := true
                found := true
            }
        }
        if !found
            ctx.weights.Push({ kg: newWt, label: "manually reviewed", when: "",
                capture: 0, selected: true })
    }

    for c in ctx.conflicts
        c.resolved := true

    PCtx_Touch(ctx)
    g.Destroy()
    if IsObject(owner)
        Hub_Refresh(owner)
}

Hub_LabCandidateSelected(ctx, labLv, valueEdit) {
    row := labLv.GetNext(0)
    if row = 0 || labLv.GetText(row, 5) = "Accepted" {
        valueEdit.Value := ""
        return
    }
    valueEdit.Value := labLv.GetText(row, 2)
}

Hub_ConfirmLabCandidate(ctx, labLv, valueEdit) {
    row := labLv.GetNext(0)
    if row = 0 {
        MsgBox("Select a lab value first.", "Confirm Lab Value", "Iconi")
        return
    }
    if labLv.GetText(row, 5) = "Accepted" {
        MsgBox("That value is already accepted.", "Confirm Lab Value", "Iconi")
        return
    }
    key := labLv.GetText(row, 7)
    candidateIndex := Number(labLv.GetText(row, 8))
    if !ctx.HasOwnProp("labCandidates") || !ctx.labCandidates.Has(key)
        || candidateIndex < 1 || candidateIndex > ctx.labCandidates[key].Length {
        MsgBox("That candidate is no longer available. Reopen this window to refresh.", "Confirm Lab Value", "Icon!")
        return
    }
    entry := ctx.labCandidates[key][candidateIndex]
    reviewedValue := PCtx_NormalizeNumericToken(valueEdit.Value)
    if !PCtx_ValidateLabValue(key, reviewedValue) {
        MsgBox(
            "Enter a numeric " PCtx_LabLabel(key) " value within the supported physiologic range before confirming.",
            "Confirm Lab Value",
            "Icon!"
        )
        return
    }
    if MsgBox(
        "Confirm " PCtx_LabLabel(key) " " LabMetric_FormatValue(key, reviewedValue)
            . " against the visible chart?",
        "Confirm Lab Value",
        "YesNo Icon?"
    ) != "Yes"
        return

    entry := PCtx_AcceptLabCandidate(ctx, key, candidateIndex, reviewedValue)
    if !IsObject(entry)
        return
    labLv.Modify(row, "", PCtx_LabLabel(key), entry.value, entry.unit,
        (entry.when = "" ? "not captured" : entry.when), "Accepted", entry.capture, key, 0)
    valueEdit.Value := ""
    PCtx_Touch(ctx)
}

Hub_SetDemo(ctx, name, value) {
    if value = "" {
        if ctx.demo.Has(name)
            ctx.demo.Delete(name)
        return
    }
    if !ctx.demo.Has(name)
        ctx.demo[name] := PCtx_NewField(value, PCtx_UnitFor(name), "", "", "manual", 0)
    ctx.demo[name].value := value
    ctx.demo[name].edited := true
}

Hub_DeleteAllergy(ctx, lv) {
    row := lv.GetNext()
    if row = 0
        return
    keep := []
    for i, a in ctx.allergyRaw {
        if i != row
            keep.Push(a)
    }
    ctx.allergyRaw := keep
    ctx.allergyRecs := Allergy_Parse(ctx.allergyRaw)
    lv.Delete(row)
}

Hub_AddAllergy(ctx, lv, ctrl) {
    v := Trim(ctrl.Value)
    if v = ""
        return
    ctx.allergyRaw.Push(v)
    ctx.allergyRecs := Allergy_Parse(ctx.allergyRaw)
    rec := ctx.allergyRecs[ctx.allergyRecs.Length]
    ing := ""
    for i in rec.ingredients
        ing .= (ing = "" ? "" : " + ") i
    lv.Add("", rec.raw, (ing = "" ? "-" : ing),
        (rec.reaction = "" ? "not captured" : rec.reaction),
        (rec.isDrug ? "drug" : "unclassified"))
    ctrl.Value := ""
}

Hub_DeleteMed(ctx, lv) {
    row := lv.GetNext()
    if row = 0
        return
    keep := []
    for i, m in ctx.medRecs {
        if i != row
            keep.Push(m)
    }
    ctx.medRecs := keep
    lv.Delete(row)
}

Hub_AddMed(ctx, lv, ctrl) {
    v := Trim(ctrl.Value)
    if v = ""
        return
    rec := RxN_Normalize(v)
    rec.capture := 0
    rec.screen := "manual"
    ctx.medRecs.Push(rec)
    ing := ""
    for i in rec.ingredients
        ing .= (ing = "" ? "" : " + ") i
    lv.Add("", rec.raw, (ing = "" ? "NOT NORMALIZED" : ing), rec.dose, rec.route,
        (rec.status = "" ? "-" : rec.status))
    ctrl.Value := ""
}

; =================================================================================================
; RENAL DOSE SCREENING  (blueprint §4 first module in the phase-6 build order)
; =================================================================================================


Hub_CopyListView(lv, title, footer := "") {
    txt := title "`r`n"
    Loop lv.GetCount() {
        row := A_Index
        line := ""
        Loop lv.GetCount("Col")
            line .= (line = "" ? "" : "  |  ") lv.GetText(row, A_Index)
        txt .= line "`r`n"
    }
    if footer != ""
        txt .= "`r`n" footer "`r`n"
    A_Clipboard := txt
    ToolTip("Copied.")
    SetTimer(() => ToolTip(), -1200)
}

; =================================================================================================
; RENAL RULES LIBRARY — shared screening rules used by the patient workbench
; =================================================================================================


OpenDailyMedEvidenceSummary(*) {
    root := RegExReplace(A_ScriptDir, "\\App$", "")
    summaryPath := root "\\renal-test\\renal_evidence_summary.csv"
    if !FileExist(summaryPath) {
        MsgBox("The isolated DailyMed evidence summary was not found:`n`n" summaryPath "`n`nRun the renal-test ingestion first. Evidence remains unreviewed and is not part of the live renal rules library.", "DailyMed Evidence", "Iconi")
        return
    }
    SafeLaunchTarget(summaryPath)
}



RenalLibrary_LayoutFooter(gui, lv, footerButtons, width, height) {
    if width <= 0 || height <= 0
        return
    listX := 12
    listY := 122
    listWidth := Max(760, width - 28)
    listHeight := Max(300, height - 170)
    lv.Move(listX, listY, listWidth, listHeight)

    footerY := Max(listY + listHeight + 10, height - 54)
    xPos := listX
    for btn in footerButtons {
        btn.GetPos(, , &btnW, )
        btn.Move(xPos, footerY)
        xPos += btnW + 8
    }
}

RenalLibrary_ShowEvidence(lv) {
    row := lv.GetNext(0, "Focused")
    if !row {
        MsgBox("Select a renal rule first.", "DailyMed Evidence", "Iconi")
        return
    }
    ingredient := lv.GetText(row, 1)
    rule := PatientRenal_FindRuleForKey(RxN_IngredientKey(ingredient))
    detail := RenalEvidence_DetailText(ingredient, IsObject(rule) ? rule : Map())
    g := Gui("+Resize", "DailyMed Evidence — " ingredient)
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w980", "DailyMed evidence: " ingredient))
    Theme_Subtle(g.Add("Text", "xm y+3 w980", "Unreviewed label evidence for verification only. Existing PhUCKIT renal screening rules remain unchanged."))
    output := g.Add("Edit", "xm y+10 w980 h560 ReadOnly -Wrap VScroll", detail)
    Theme_OutputFont(output)
    g.Add("Button", "xm y+10 w130", "Copy Evidence").OnEvent("Click", (*) => (A_Clipboard := detail, ToolTip("Copied."), SetTimer(() => ToolTip(), -1200)))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w1020 h680")
}

RenalLibrary_ShowDosingMatrix(lv) {
    row := lv.GetNext(0, "Focused")
    if !row {
        MsgBox("Select a renal rule first.", "Renal Dosing Matrix", "Iconi")
        return
    }
    ingredient := lv.GetText(row, 1)
    tableRows := RenalEvidence_MatrixRows(ingredient)
    if tableRows.Length = 0 {
        MsgBox("No structured DailyMed dosing table is available for " ingredient ". This does not prove that no renal dosing guidance exists.", "Renal Dosing Matrix", "Iconi")
        return
    }
    g := Gui("+Resize", "Renal Dosing Matrix - " ingredient)
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w1140", "Renal dosing matrix: " ingredient))
    Theme_Subtle(g.Add("Text", "xm y+3 w1140", "Source-linked renal matrix rows. Provisional rows are evidence for pharmacist review, not stand-alone dosing instructions."))
    matrix := g.Add("ListView", "xm y+10 w1140 h360 Grid -Multi", ["Section", "Verbatim renal range", "Verbatim dose / interval", "Product / context", "Review"])
    matrix.ModifyCol(1, 270), matrix.ModifyCol(2, 230), matrix.ModifyCol(3, 260), matrix.ModifyCol(4, 270), matrix.ModifyCol(5, 110)
    for item in tableRows {
        cells := item.cells
        first := cells.Length >= 1 ? cells[1] : ""
        second := cells.Length >= 2 ? cells[2] : ""
        context := ""
        if cells.Length >= 3 {
            for index, cell in cells {
                if index >= 3
                    context .= (context = "" ? "" : " | ") cell
            }
        }
        productContext := item.product != "" ? item.product : context
        matrix.Add("", item.section, first, second, productContext, item.reviewStatus (item.provisional ? " · PROVISIONAL" : ""))
    }
    detail := g.Add("Edit", "xm y+10 w1140 h170 ReadOnly -Wrap VScroll", "SOURCE-LINKED TABLE ROWS`r`n`r`n"
        . "Every row above is transcribed from DailyMed evidence and remains " tableRows[1].reviewStatus (tableRows[1].provisional ? " / PROVISIONAL" : "") ".`r`n"
        . "Source: " tableRows[1].source "`r`nSPL set ID: " tableRows[1].setid "`r`n`r`n"
        . "Extraction warnings: " (tableRows[1].warning = "" ? "None recorded" : tableRows[1].warning) "`r`n"
        . "Do not apply a row without confirming indication, route, formulation, patient population, renal metric, dialysis status, and current label.`r`n"
        . "This is not a stand-alone dosing recommendation.")
    Theme_OutputFont(detail)
    g.Add("Button", "xm y+10 w130", "Full Evidence").OnEvent("Click", (*) => RenalLibrary_ShowEvidence(lv))
    g.Add("Button", "x+8 yp w130", "Copy Matrix").OnEvent("Click", (*) => Hub_CopyListView(matrix, "RENAL DOSING MATRIX - " ingredient, "Source-linked DailyMed evidence. Verify current labeling; not a stand-alone dosing recommendation."))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w1180 h650")
}

RenalLibrary_Render(lv, query, parsed) {
    lv.Delete()
    q := StrLower(Trim(String(query)))
    crcl := parsed.HasOwnProp("crcl") && IsNumber(parsed.crcl) ? Number(parsed.crcl) : 0
    for rule in RefData_Rows("renal_rules") {
        ingredient := rule.Has("ingredient") ? Trim(rule["ingredient"]) : ""
        note := rule.Has("note") ? Trim(rule["note"]) : ""
        hay := StrLower(ingredient " " note)
        if q != "" && !InStr(hay, q)
            continue
        mode := rule.Has("mode") ? Trim(rule["mode"]) : "threshold"
        review := rule.Has("review_below") ? Trim(rule["review_below"]) : ""
        avoid := rule.Has("avoid_below") ? Trim(rule["avoid_below"]) : ""
        signal := mode = "level" ? "Level / trajectory review" : "No threshold triggered"
        if crcl > 0 {
            flag := PatientRenal_FlagForMedication(ingredient, parsed)
            if flag != ""
                signal := flag
        } else {
            signal := "CrCl unavailable — review required"
        }
        tableCount := RenalEvidence_TableRows(ingredient).Length
        evidenceState := tableCount > 0 ? RenalEvidence_SummaryText(ingredient) : (RenalEvidence_ForIngredient(ingredient).Length > 0 ? "Evidence / review" : "No table")
        lv.Add("", ingredient, mode, review, avoid, signal, evidenceState, note)
    }
}

; =================================================================================================
; LABS & TRENDS - search-first pharmacist view, metric display, evidence-only values
; =================================================================================================
QuickGlance_DefaultSettingsRows() {
    rows := []
    for def in LabView_Definitions()
        rows.Push({ key: def.key, label: def.label, group: def.group,
            visible: !def.HasOwnProp("quick") || def.quick })
    return rows
}

QuickGlance_LoadConfig() {
    global AppSettingsIniPath
    defaults := QuickGlance_DefaultSettingsRows()
    byKey := Map()
    for row in defaults
        byKey[row.key] := row

    orderRaw := ""
    visibleRaw := ""
    showMissingRaw := "1"
    try orderRaw := IniRead(AppSettingsIniPath, "PatientWorkspace", "QuickGlanceOrder", "")
    try visibleRaw := IniRead(AppSettingsIniPath, "PatientWorkspace", "QuickGlanceVisible", "")
    try showMissingRaw := IniRead(AppSettingsIniPath, "PatientWorkspace", "ShowMissingSelected", "1")

    visible := Map()
    if visibleRaw = "" {
        for row in defaults
            if row.visible
                visible[row.key] := true
    } else if visibleRaw != "__none__" {
        for key in StrSplit(visibleRaw, "|") {
            key := Trim(key)
            if byKey.Has(key)
                visible[key] := true
        }
    }

    rows := []
    seen := Map()
    if orderRaw != "" {
        for key in StrSplit(orderRaw, "|") {
            key := Trim(key)
            if key = "" || !byKey.Has(key) || seen.Has(key)
                continue
            def := byKey[key]
            rows.Push({ key: def.key, label: def.label, group: def.group, visible: visible.Has(key) })
            seen[key] := true
        }
    }
    for def in defaults {
        if seen.Has(def.key)
            continue
        ; Newly introduced clinical rows default on once, even for users with
        ; an older saved layout. They remain fully hideable/reorderable.
        rows.Push({ key: def.key, label: def.label, group: def.group, visible: def.visible })
    }
    return { rows: rows, showMissing: showMissingRaw != "0" }
}

QuickGlance_SaveConfig(rows, showMissing := true) {
    global AppSettingsIniPath, LocalSettingsDir
    orderText := ""
    visibleText := ""
    for row in rows {
        orderText .= (orderText = "" ? "" : "|") row.key
        if row.visible
            visibleText .= (visibleText = "" ? "" : "|") row.key
    }
    if visibleText = ""
        visibleText := "__none__"
    try DirCreate(LocalSettingsDir)
    try {
        IniWrite(orderText, AppSettingsIniPath, "PatientWorkspace", "QuickGlanceOrder")
        IniWrite(visibleText, AppSettingsIniPath, "PatientWorkspace", "QuickGlanceVisible")
        IniWrite(showMissing ? "1" : "0", AppSettingsIniPath, "PatientWorkspace", "ShowMissingSelected")
    }
}

QuickGlance_BuildRows(ctx, config := 0, parsed := 0) {
    if !IsObject(config)
        config := QuickGlance_LoadConfig()
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }
    allRows := LabView_BuildRows(ctx, parsed)
    byKey := Map()
    for row in allRows
        byKey[row.key] := row

    visibleRows := []
    for preference in config.rows {
        if !preference.visible || !byKey.Has(preference.key)
            continue
        row := byKey[preference.key]
        if !config.showMissing && row.currentNumeric = ""
            continue
        visibleRows.Push(row)
    }
    return visibleRows
}

QuickGlance_PatientLine(ctx, parsed) {
    age := PCtx_Demo(ctx, "age")
    sex := PCtx_Demo(ctx, "sex")
    height := PCtx_Demo(ctx, "heightCm")
    weight := PCtx_SelectedWeight(ctx)
    crcl := parsed.HasOwnProp("crcl") && parsed.crcl != "" && IsNumber(parsed.crcl)
        ? LabView_FormatDirect(parsed.crcl, 1) : "—"
    return "Age " (age = "" ? "—" : age " yr")
        . "     Sex " (sex = "" ? "—" : sex)
        . "     Height " (height = "" ? "—" : height " cm")
        . "     Dosing wt " (weight = "" ? "—" : LabView_FormatDirect(weight, 1) " kg")
        . "     CrCl " crcl (crcl = "—" ? "" : " mL/min")
}

QuickGlance_TrendForTable(row) {
    if row.currentNumeric = "" || row.trend = "No prior value"
        return "—"
    if row.trend = "Calculated estimate"
        return "Calculated"
    if row.trend = "Selected for dosing"
        return "Selected"
    return row.trend
}

QuickGlance_FlagText(ctx, rows) {
    body := ""
    meds := PCtx_ConfirmedActiveMeds(ctx)
    findings := Allergy_ScanOrders(ctx.allergyRecs, meds)
    if findings.Length > 0 {
        body .= "ALLERGY / ORDER`r`n"
        shown := 0
        for finding in findings {
            body .= "• " finding.detail "`r`n"
            shown += 1
            if shown >= 4
                break
        }
        if findings.Length > shown
            body .= "• +" (findings.Length - shown) " more; open the full review.`r`n"
    }

    cols := Safety_Evaluate(ctx)
    safetyLines := []
    for key in Safety_Columns() {
        column := cols[key]
        if column.status != "Alert" && column.status != "Review"
            continue
        for finding in column.findings
            safetyLines.Push(key "  " finding)
    }
    if safetyLines.Length > 0 {
        body .= (body = "" ? "" : "`r`n") "PRIORITY CLINICAL`r`n"
        shown := 0
        for line in safetyLines {
            body .= "• " line "`r`n"
            shown += 1
            if shown >= 8
                break
        }
        if safetyLines.Length > shown
            body .= "• +" (safetyLines.Length - shown) " more in Clinical Safety.`r`n"
    } else if meds.Length > 0 && cols["RENAL"].status = "Unknown" {
        body .= (body = "" ? "" : "`r`n") "RENAL`r`n"
            . "• CrCl is unavailable; medication-specific renal screening is incomplete.`r`n"
    }

    changed := []
    for row in rows {
        if row.currentNumeric = "" || row.priorNumeric = "" || InStr(row.trend, "Stable")
            continue
        changed.Push(row.label ": " row.currentText " " row.unit "  " row.trend)
    }
    if changed.Length > 0 {
        body .= (body = "" ? "" : "`r`n") "CHANGED RESULTS`r`n"
        shown := 0
        for line in changed {
            body .= "• " line "`r`n"
            shown += 1
            if shown >= 6
                break
        }
        if changed.Length > shown
            body .= "• +" (changed.Length - shown) " more in Labs & Trends.`r`n"
    }

    if body = ""
        return "No evidence-backed flags or paired-result changes are present in the captured data."
    return RTrim(body, "`r`n")
}

QuickGlance_RefreshState(state, *) {
    parsed := PCtx_ToParsed(state.ctx)
    PatientCalc_Enrich(parsed)
    config := QuickGlance_LoadConfig()
    rows := QuickGlance_BuildRows(state.ctx, config, parsed)
    state.visible := rows
    for row in rows {
        if !state.cells.Has(row.key)
            continue
        cell := state.cells[row.key]
        cell.value.Value := row.currentText = "—" ? "—" : row.currentText " " row.unit
        trend := QuickGlance_TrendForTable(row)
        rangeState := QuickGlance_RangeState(row)
        resultColor := rangeState = "high" ? QuickGlance_ColorValue("high")
            : rangeState = "low" ? QuickGlance_ColorValue("low")
            : Theme_Accent("heading")
        cell.value.SetFont("s15 bold c" resultColor, "Segoe UI")
        statePrefix := rangeState = "high" ? "HIGH · " : rangeState = "low" ? "LOW · " : ""
        if row.priorText != "—"
            cell.meta.Value := statePrefix "Prior " row.priorText (row.unit != "" ? " " row.unit : "") (trend != "—" ? "  ·  " trend : "")
        else if trend != "—"
            cell.meta.Value := statePrefix trend
        else
            cell.meta.Value := RTrim(statePrefix, " ·")
    }
    state.patient.Value := QuickGlance_PatientLine(state.ctx, parsed)
    state.flagsText := QuickGlance_FlagText(state.ctx, rows)
}

QuickGlance_RefreshOpenHub(*) {
    global _HubQuickState
    if !IsObject(_HubQuickState)
        return
    try Hub_Show(_HubQuickState.ctx)
}

QuickGlance_Copy(state, *) {
    text := "PHUCKIT PATIENT QUICK GLANCE`r`n" state.patient.Value "`r`n"
    text .= "======================================================================`r`n"
    for row in state.visible {
        current := row.currentText = "—" ? "—" : row.currentText " " row.unit
        prior := row.priorText = "—" ? "—" : row.priorText " " row.unit
        rangeState := QuickGlance_RangeState(row)
        rangeLabel := rangeState = "high" ? "HIGH" : rangeState = "low" ? "LOW" : ""
        text .= row.label "`t" current "`tPrior " prior "`t" QuickGlance_TrendForTable(row)
            . (rangeLabel != "" ? "`t" rangeLabel : "") "`r`n"
    }
    text .= "`r`nCLINICAL FLAGS / CHANGES`r`n" state.flagsText
    A_Clipboard := text
    ToolTip("Quick glance copied.")
    SetTimer(() => ToolTip(), -1400)
}

LabView_Definitions() {
    static defs := [
        { key:"sodium", label:"Sodium", aliases:"Na", group:"BMP", quick:true },
        { key:"potassium", label:"Potassium", aliases:"K", group:"BMP", quick:true },
        { key:"chloride", label:"Chloride", aliases:"Cl", group:"BMP", quick:true },
        { key:"bicarbonate", label:"Bicarbonate", aliases:"CO2 HCO3 total carbon dioxide", group:"BMP", quick:true },
        { key:"bun", label:"BUN", aliases:"urea nitrogen", group:"BMP", quick:true },
        { key:"creatinine", label:"Serum creatinine", aliases:"SCr serum Cr creat", group:"BMP", quick:true },
        { key:"glucose", label:"Blood glucose", aliases:"glucose blood glucose BG", group:"BMP", quick:true },
        { key:"calcium", label:"Calcium", aliases:"Ca", group:"BMP", quick:true },
        { key:"magnesium", label:"Magnesium", aliases:"Mg", group:"Extended electrolytes", quick:true },
        { key:"phosphate", label:"Phosphate", aliases:"phosphorus Phos PO4", group:"Extended electrolytes", quick:true },
        { key:"egfr", label:"eGFR", aliases:"estimated glomerular filtration CKD EPI renal function", group:"Renal & dosing" },
        { key:"crcl", label:"Creatinine clearance", aliases:"CrCl Cockcroft Gault renal function", group:"Renal & dosing", quick:true },
        { key:"weight", label:"Dosing weight", aliases:"weight wt kg", group:"Renal & dosing", quick:true },
        { key:"wbc", label:"WBC", aliases:"white blood cell leukocyte", group:"CBC", quick:true },
        { key:"rbc", label:"RBC", aliases:"red blood cell erythrocyte", group:"CBC", quick:true },
        { key:"hemoglobin", label:"Hemoglobin", aliases:"haemoglobin hemaglobin Hgb Hb", group:"CBC", quick:true },
        { key:"hematocrit", label:"Hematocrit", aliases:"Hct packed cell volume", group:"CBC", quick:true },
        { key:"platelets", label:"Platelets", aliases:"platelet Plt", group:"CBC", quick:true },
        { key:"albumin", label:"Albumin", aliases:"Alb", group:"Hepatic & proteins", quick:true },
        { key:"ast", label:"AST", aliases:"SGOT aspartate aminotransferase", group:"Hepatic & proteins", quick:false },
        { key:"alt", label:"ALT", aliases:"SGPT alanine aminotransferase", group:"Hepatic & proteins", quick:false },
        { key:"alkphos", label:"Alkaline phosphatase", aliases:"ALP alk phos", group:"Hepatic & proteins", quick:false },
        { key:"bilirubin", label:"Total bilirubin", aliases:"T bili bilirubin", group:"Hepatic & proteins", quick:false },
        { key:"inr", label:"INR", aliases:"international normalized ratio", group:"Coagulation", quick:false },
        { key:"ptt", label:"aPTT", aliases:"PTT activated partial thromboplastin time", group:"Coagulation", quick:false },
        { key:"lactate", label:"Lactate", aliases:"lactic acid", group:"TLS & other", quick:true },
        { key:"ldh", label:"LDH", aliases:"lactate dehydrogenase", group:"TLS & other", quick:false },
        { key:"uricacid", label:"Uric acid", aliases:"urate", group:"TLS & other", quick:false },
        { key:"anc", label:"ANC", aliases:"absolute neutrophil count", group:"TLS & other", quick:false },
        { key:"vancomycin", label:"Vancomycin level", aliases:"vanco trough random", group:"Drug levels", quick:false },
        { key:"phenytoin", label:"Phenytoin level", aliases:"dilantin", group:"Drug levels", quick:false },
        { key:"digoxin", label:"Digoxin level", aliases:"lanoxin", group:"Drug levels", quick:false }
        ,{ key:"mcv", label:"MCV", aliases:"mean corpuscular volume", group:"CBC", quick:false }
        ,{ key:"mpv", label:"MPV", aliases:"mean platelet volume", group:"CBC", quick:false }
        ,{ key:"sedrate", label:"Sedimentation rate", aliases:"ESR sed rate", group:"CBC", quick:false }
        ,{ key:"totalprotein", label:"Total protein", aliases:"protein total", group:"Hepatic & proteins", quick:false }
        ,{ key:"tsh", label:"TSH", aliases:"thyroid stimulating hormone", group:"Thyroid studies", quick:false }
        ,{ key:"freet4", label:"Free T4", aliases:"T4 free", group:"Thyroid studies", quick:false }
        ,{ key:"cholesterol", label:"Total cholesterol", aliases:"cholesterol", group:"Lipids", quick:false }
        ,{ key:"hdl", label:"HDL cholesterol", aliases:"HDL", group:"Lipids", quick:false }
        ,{ key:"ldl", label:"LDL", aliases:"low density lipoprotein", group:"Lipids", quick:false }
        ,{ key:"triglycerides", label:"Triglycerides", aliases:"triglyceride", group:"Lipids", quick:false }
        ,{ key:"crp", label:"CRP", aliases:"C-reactive protein hsCRP", group:"Inflammation", quick:false }
        ,{ key:"folate", label:"Folate", aliases:"folate level", group:"Vitamins", quick:false }
        ,{ key:"neutrophilPercent", label:"Neutrophil %", aliases:"neutrophils differential", group:"CBC differential", quick:false }
        ,{ key:"lymphocytePercent", label:"Lymphocyte %", aliases:"lymphocytes differential", group:"CBC differential", quick:false }
        ,{ key:"monocytePercent", label:"Monocyte %", aliases:"monocytes differential", group:"CBC differential", quick:false }
        ,{ key:"eosinophilPercent", label:"Eosinophil %", aliases:"eosinophils differential", group:"CBC differential", quick:false }
        ,{ key:"basophilPercent", label:"Basophil %", aliases:"basophils differential", group:"CBC differential", quick:false }
        ,{ key:"immatureGranulocytePercent", label:"Immature granulocyte %", aliases:"immature granulocyte differential", group:"CBC differential", quick:false }
        ,{ key:"neutroAbsolute", label:"Neutrophil absolute", aliases:"absolute neutrophil ANC", group:"CBC differential", quick:false }
        ,{ key:"lymphAbsolute", label:"Lymphocyte absolute", aliases:"absolute lymphocyte", group:"CBC differential", quick:false }
        ,{ key:"monoAbsolute", label:"Monocyte absolute", aliases:"absolute monocyte", group:"CBC differential", quick:false }
        ,{ key:"eosAbsolute", label:"Eosinophil absolute", aliases:"absolute eosinophil", group:"CBC differential", quick:false }
        ,{ key:"basoAbsolute", label:"Basophil absolute", aliases:"absolute basophil", group:"CBC differential", quick:false }
        ,{ key:"nrbcs", label:"nRBC", aliases:"nucleated red blood cells", group:"CBC differential", quick:false }
        ,{ key:"bnp", label:"B-type natriuretic peptide", aliases:"BNP heart failure marker", group:"Cardiac markers", quick:false }
        ,{ key:"heartRate", label:"Heart rate", aliases:"pulse HR", group:"Vital signs", quick:false }
        ,{ key:"respiratoryRate", label:"Respiratory rate", aliases:"respirations RR", group:"Vital signs", quick:false }
        ,{ key:"temperature", label:"Temperature", aliases:"temp", group:"Vital signs", quick:false }
        ,{ key:"spo2", label:"SpO2", aliases:"oxygen saturation O2 sat", group:"Vital signs", quick:false }
        ,{ key:"systolicBP", label:"Systolic BP", aliases:"blood pressure systolic", group:"Vital signs", quick:false }
        ,{ key:"diastolicBP", label:"Diastolic BP", aliases:"blood pressure diastolic", group:"Vital signs", quick:false }
    ]
    return defs
}

LabView_FormatDirect(value, precision) {
    if value = "" || !IsNumber(value)
        return "—"
    return Format("{:." precision "f}", Number(value))
}

LabView_BuildRows(ctx, parsed := 0) {
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }

    rows := []
    for def in LabView_Definitions() {
        row := {
            key: def.key, label: def.label, aliases: def.aliases, group: def.group,
            currentText: "—", currentNumeric: "", priorText: "—", priorNumeric: "",
            unit: "", when: "Not captured", source: "No evidence-grounded value was captured.",
            trend: "—", series: [], history: [], precision: 1
        }

        if def.key = "weight" {
            row.unit := "kg"
            selected := PCtx_SelectedWeight(ctx)
            if selected != "" && IsNumber(selected) {
                row.currentNumeric := Number(selected)
                row.currentText := LabView_FormatDirect(selected, 1)
                row.when := "Selected for dosing"
                row.source := "Captured or manually reviewed dosing weight"
                row.trend := "Selected for dosing"
            }
            for w in ctx.weights {
                if IsNumber(w.kg)
                    row.series.Push(Number(w.kg))
            }
            Loop ctx.weights.Length {
                w := ctx.weights[ctx.weights.Length - A_Index + 1]
                row.history.Push(LabView_FormatDirect(w.kg, 1) " kg · " w.label
                    . (w.when != "" ? " · " w.when : ""))
            }
            rows.Push(row)
            continue
        }

        if def.key = "crcl" {
            row.unit := "mL/min"
            if parsed.HasOwnProp("crcl") && parsed.crcl != "" && IsNumber(parsed.crcl) {
                row.currentNumeric := Number(parsed.crcl)
                row.currentText := LabView_FormatDirect(parsed.crcl, 1)
                row.when := "Calculated from captured patient data"
                row.source := parsed.HasOwnProp("crclWeightLabel") && parsed.crclWeightLabel != ""
                    ? "Cockcroft-Gault using " parsed.crclWeightLabel
                    : "Cockcroft-Gault"
                row.trend := "Calculated estimate"
                row.series.Push(Number(parsed.crcl))
                row.history.Push(row.currentText " mL/min · " row.source)
            } else {
                calc := PatientCalc_Compute(parsed)
                if IsObject(calc) && calc.HasOwnProp("reason") && calc.reason != ""
                    row.source := "Not calculated: " calc.reason
            }
            rows.Push(row)
            continue
        }

        row.unit := LabMetric_DisplayUnit(def.key)
        row.precision := LabMetric_Precision(def.key)
        if ctx.labs.Has(def.key) && ctx.labs[def.key].Length > 0 {
            entries := ctx.labs[def.key]
            current := entries[1]
            row.currentNumeric := LabMetric_Convert(def.key, current.value)
            row.currentText := LabMetric_FormatNumber(def.key, current.value)
            row.when := current.when != "" ? current.when : "Collection time not captured"
            row.source := current.HasOwnProp("source") && current.source != ""
                ? current.source : "Capture " current.capture

            if entries.Length >= 2 {
                prior := entries[2]
                row.priorNumeric := LabMetric_Convert(def.key, prior.value)
                row.priorText := LabMetric_FormatNumber(def.key, prior.value)
            }

            Loop entries.Length {
                entry := entries[entries.Length - A_Index + 1]
                converted := LabMetric_Convert(def.key, entry.value)
                if converted != ""
                    row.series.Push(converted)
            }
            for entry in entries {
                row.history.Push(LabMetric_FormatValue(def.key, entry.value) " · "
                    . (entry.when != "" ? entry.when : "time not captured")
                    . " · capture " entry.capture)
            }
            row.trend := LabView_TrendText(row)
        }
        rows.Push(row)
    }
    if ctx.HasOwnProp("qualitativeFindings") && IsObject(ctx.qualitativeFindings) {
        findingIndex := 0
        for finding in ctx.qualitativeFindings {
            findingIndex += 1
            row := {
                key: "finding_" findingIndex,
                label: finding.label,
                aliases: finding.kind,
                group: StrTitle(finding.kind),
                currentText: finding.value,
                currentNumeric: "",
                priorText: "—",
                priorNumeric: "",
                unit: "",
                when: finding.HasOwnProp("when") && finding.when != "" ? finding.when : "Capture " (finding.HasOwnProp("capture") ? finding.capture : "unknown"),
                source: finding.raw " · " finding.source,
                trend: "Source-backed finding",
                series: [],
                history: [finding.raw],
                precision: 0
            }
            rows.Push(row)
        }
    }
    return rows
}

LabView_TrendText(row) {
    countSuffix := row.series.Length > 1 ? " · " row.series.Length " results" : ""
    if row.currentNumeric = "" || row.priorNumeric = ""
        return "No prior value" countSuffix
    delta := Number(row.currentNumeric) - Number(row.priorNumeric)
    threshold := 0.5 / (10 ** row.precision)
    if Abs(delta) < threshold
        return "→ Stable" countSuffix
    arrow := delta > 0 ? "↑" : "↓"
    sign := delta > 0 ? "+" : ""
    return arrow " " sign LabView_FormatDirect(delta, row.precision) " " row.unit countSuffix
}

LabView_Sparkline(values) {
    if !IsObject(values) || values.Length = 0
        return "No captured series"
    if values.Length = 1
        return "●"
    marks := ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
    low := Number(values[1]), high := Number(values[1])
    for value in values {
        low := Min(low, Number(value))
        high := Max(high, Number(value))
    }
    out := ""
    start := Max(1, values.Length - 23)
    Loop values.Length - start + 1 {
        value := Number(values[start + A_Index - 1])
        idx := high = low ? 4 : Floor(((value - low) / (high - low)) * 7) + 1
        out .= marks[idx]
    }
    return out
}

LabView_Matches(row, query, category) {
    q := StrLower(Trim(query))
    if q != "" {
        haystack := StrLower(row.label " " row.key " " row.aliases " " row.group " " row.unit)
        return InStr(haystack, q) > 0
    }
    return category = "All results" || row.group = category
}

LabView_Refresh(state, *) {
    state.lv.Delete()
    state.visible := []
    query := state.search.Value
    category := state.category.Text
    captured := 0
    for row in state.rows {
        if !LabView_Matches(row, query, category)
            continue
        state.visible.Push(row)
        if row.currentNumeric != ""
            captured += 1
        state.lv.Add("", row.label, row.currentText, row.unit, row.priorText, row.trend, row.when)
    }
    state.status.Value := state.visible.Length " shown · " captured " captured · "
        . (state.visible.Length - captured) " not captured"
    if state.visible.Length > 0 {
        state.lv.Modify(1, "Select Focus")
        LabView_ShowDetail(state, 1)
    } else {
        LabView_ClearDetail(state, "No required result matches that search.")
    }
}

LabView_ShowDetail(state, rowNumber) {
    if rowNumber < 1 || rowNumber > state.visible.Length
        return
    row := state.visible[rowNumber]
    state.detailTitle.Value := row.label
    state.detailValue.Value := row.currentText " " row.unit
    state.detailMeta.Value := row.group " · " row.trend "`r`n" row.when
    state.spark.Value := LabView_Sparkline(row.series)
    historyText := ""
    for line in row.history
        historyText .= (historyText = "" ? "" : "`r`n") line
    state.history.Value := historyText != "" ? historyText : "No evidence-grounded values captured."
    state.provenance.Value := "Source: " row.source
}

LabView_ClearDetail(state, message) {
    state.detailTitle.Value := "Result details"
    state.detailValue.Value := "—"
    state.detailMeta.Value := message
    state.spark.Value := ""
    state.history.Value := message
    state.provenance.Value := ""
}

LabView_OnRowClick(state, ctrl, rowNumber, *) {
    if rowNumber > 0
        LabView_ShowDetail(state, rowNumber)
}

LabView_Reload(state, *) {
    parsed := PCtx_ToParsed(state.ctx)
    PatientCalc_Enrich(parsed)
    state.rows := LabView_BuildRows(state.ctx, parsed)
    LabView_Refresh(state)
}

Hub_OpenLabCorrections(ctx, parsed := 0, label := "") {
    if !IsObject(parsed) {
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
    }

    g := Gui("+MinimizeBox", "PhUCKIT · Labs & Trends")
    ApplyTheme(g)
    title := g.Add("Text", "x18 y14 w1060 h30", "Labs & Trends")
    title.SetFont("s18 bold c" Theme_Accent("heading"), "Segoe UI")
    g.Add("Button", "x980 y12 w100 h28", "Patient")
        .OnEvent("Click", Patient_OpenFromAnyScreen)
    Theme_Subtle(g.Add("Text", "x18 y46 w1060 h22",
        "Find the result first. Values display in SI/metric units; calculations remain tied to captured evidence."))

    g.Add("Text", "x18 y78 w500", "Search by name or abbreviation")
    search := g.Add("Edit", "x18 y99 w500 h28")
    g.Add("Text", "x536 y78 w230", "Clinical group")
    category := g.Add("DropDownList", "x536 y99 w230 Choose1",
        ["BMP", "CBC", "Extended electrolytes", "Renal & dosing", "Hepatic & proteins",
         "Coagulation", "TLS & other", "Drug levels", "All results"])
    status := g.Add("Text", "x785 y103 w300 h22 Right")
    status.SetFont("s9 bold c" Theme_Accent("accent"), "Segoe UI")

    lv := g.Add("ListView", "x18 y142 w730 h475 Grid -Multi",
        ["Result", "Latest", "Unit", "Prior", "Trend", "Collected"])
    lv.ModifyCol(1, 155)
    lv.ModifyCol(2, 80)
    lv.ModifyCol(3, 82)
    lv.ModifyCol(4, 70)
    lv.ModifyCol(5, 125)
    lv.ModifyCol(6, 200)

    detailTitle := g.Add("Text", "x770 y148 w310 h28", "Result details")
    detailTitle.SetFont("s13 bold c" Theme_Accent("heading"), "Segoe UI")
    detailValue := g.Add("Text", "x770 y180 w310 h42", "—")
    detailValue.SetFont("s20 bold c" Theme_Accent("accent"), "Segoe UI")
    detailMeta := g.Add("Text", "x770 y225 w310 h48", "Select a row to review its trend.")
    Theme_Subtle(detailMeta)
    g.Add("Text", "x770 y282 w310 h20", "Trend · oldest → newest")
    spark := g.Add("Text", "x770 y306 w310 h52 Center", "")
    spark.SetFont("s24 bold c" Theme_Accent("good"), "Segoe UI Symbol")
    g.Add("Text", "x770 y368 w310 h20", "Captured history")
    history := g.Add("Edit", "x770 y391 w310 h154 ReadOnly VScroll -Wrap")
    provenance := g.Add("Text", "x770 y554 w310 h62", "")
    Theme_Subtle(provenance)

    state := {
        ctx: ctx, g: g, rows: LabView_BuildRows(ctx, parsed), visible: [],
        search: search, category: category, status: status, lv: lv,
        detailTitle: detailTitle, detailValue: detailValue, detailMeta: detailMeta,
        spark: spark, history: history, provenance: provenance
    }
    search.OnEvent("Change", LabView_Refresh.Bind(state))
    category.OnEvent("Change", LabView_Refresh.Bind(state))
    lv.OnEvent("Click", LabView_OnRowClick.Bind(state))
    lv.OnEvent("ItemFocus", LabView_OnRowClick.Bind(state))

    g.Add("Button", "x18 y635 w165 h36", "Edit captured data")
        .OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 2))
    g.Add("Button", "x193 y635 w165 h36", "Refresh values")
        .OnEvent("Click", LabView_Reload.Bind(state))
    g.Add("Button", "x368 y635 w165 h36", "Lab corrections")
        .OnEvent("Click", (*) => Hub_OpenCorrectionDetails(ctx))
    g.Add("Button", "x543 y635 w165 h36", "Copy displayed table")
        .OnEvent("Click", (*) => Hub_CopyListView(lv, "PHUCKIT LABS & TRENDS",
            "SI/metric display · missing values were not inferred"))
    g.Add("Button", "x958 y635 w122 h36", "Close")
        .OnEvent("Click", (*) => g.Destroy())

    footer := g.Add("Text", "x18 y690 w1062 h32",
        "© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    footer.SetFont("s8 c" Theme_Accent("subtle"), "Segoe UI")

    LabView_Refresh(state)
    g.Show("w1100 h730")
}

Hub_OpenCorrectionDetails(ctx, *) {
    g := Gui("+MinimizeBox", "Lab Corrections")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w800", "Lab corrections from captured results"))
    Theme_Subtle(g.Add("Text", "xm y+4 w800",
        "Editable working copy. Changing this text does not change the captured patient data."))

    out := g.Add("Edit", "xm y+10 w800 h470 VScroll WantTab -Wrap", Lab_BuildCorrections(ctx))
    Theme_OutputFont(out)
    g.Add("Button", "xm y+10 w140", "Copy working copy")
        .OnEvent("Click", (*) => (A_Clipboard := out.Value))
    g.Add("Button", "x+8 yp w150", "Edit Captured Labs")
        .OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 2))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w840 h590")
}

; =================================================================================================
; LAB CORRECTIONS  (blueprint §4 - only the calculations supported by captured labs activate)
; =================================================================================================

Lab_Num(ctx, key) {
    v := PCtx_LabValue(ctx, key)
    return (v != "" && IsNumber(v)) ? Number(v) : ""
}

Lab_When(ctx, key) {
    e := PCtx_LatestLab(ctx, key)
    if !IsObject(e)
        return "not captured"
    return e.when = "" ? "collection time not captured" : e.when
}

Lab_BuildCorrections(ctx) {
    o := ""
    na := Lab_Num(ctx, "sodium")
    k := Lab_Num(ctx, "potassium")
    cl := Lab_Num(ctx, "chloride")
    hco3 := Lab_Num(ctx, "bicarbonate")
    bun := Lab_Num(ctx, "bun")
    scr := Lab_Num(ctx, "creatinine")
    glu := Lab_Num(ctx, "glucose")
    ca := Lab_Num(ctx, "calcium")
    alb := Lab_Num(ctx, "albumin")
    osm := Lab_Num(ctx, "osmolality")
    phen := Lab_Num(ctx, "phenytoin")
    wbc := Lab_Num(ctx, "wbc")
    iron := Lab_Num(ctx, "iron")
    tibc := Lab_Num(ctx, "tibc")
    wt := PCtx_SelectedWeight(ctx)
    wtN := (wt != "" && IsNumber(wt)) ? Number(wt) : ""
    sex := PCtx_Demo(ctx, "sex")

    done := 0

    if ca != "" && alb != "" {
        corr := ca + 0.8 * (4.0 - alb)
        o .= Lab_Block("Corrected calcium",
            "Ca " LabMetric_FormatValue("calcium", ca) " (" Lab_When(ctx, "calcium") "), albumin "
                . LabMetric_FormatValue("albumin", alb) " (" Lab_When(ctx, "albumin") ")",
            "albumin-adjusted calcium; canonical calculation converted to SI display",
            LabMetric_FormatValue("calcium", corr),
            "Formula is unreliable in critical illness and renal failure; ionized calcium is preferred.")
        done += 1
    } else {
        o .= Lab_Missing("Corrected calcium", "calcium and albumin")
    }

    if na != "" && glu != "" && glu > 100 {
        c16 := na + 1.6 * ((glu - 100) / 100)
        c24 := na + 2.4 * ((glu - 100) / 100)
        o .= Lab_Block("Corrected sodium for hyperglycemia",
            "Na " LabMetric_FormatValue("sodium", na) " (" Lab_When(ctx, "sodium") "), glucose "
                . LabMetric_FormatValue("glucose", glu) " (" Lab_When(ctx, "glucose") ")",
            "Katz and Hillier glucose corrections; canonical calculation converted to SI display",
            "1.6 factor: " Round(c16, 1) " mmol/L   |   2.4 factor: " Round(c24, 1) " mmol/L",
            "The 2.4 factor fits better above a glucose of about 22.2 mmol/L.")
        done += 1
    } else {
        o .= Lab_Missing("Corrected sodium", "sodium and a glucose above 100 mg/dL")
    }

    if na != "" && cl != "" && hco3 != "" {
        ag := na - cl - hco3
        line := "Anion gap: " Round(ag, 1) " mmol/L"
        extra := ""
        if alb != "" {
            agc := ag + 2.5 * (4.0 - alb)
            line .= "   |   albumin-corrected: " Round(agc, 1) " mmol/L"
            if agc > 12 {
                dRatio := (hco3 < 24) ? (agc - 12) / (24 - hco3) : ""
                if dRatio != ""
                    extra := "Delta ratio " Round(dRatio, 2)
                        . " (<1 suggests concurrent non-gap acidosis, >2 suggests concurrent metabolic alkalosis)."
            }
        } else {
            extra := "Albumin was not captured, so the gap is uncorrected."
        }
        o .= Lab_Block("Anion gap",
            "Na " na " mmol/L, Cl " cl " mmol/L, HCO3 " hco3 " mmol/L (" Lab_When(ctx, "bicarbonate") ")",
            "Na - Cl - HCO3; albumin correction +2.5 mmol/L per 10 g/L below 40 g/L",
            line, extra)
        done += 1
    } else {
        o .= Lab_Missing("Anion gap", "sodium, chloride, and bicarbonate")
    }

    if na != "" && glu != "" && bun != "" {
        calcOsm := 2 * na + glu / 18 + bun / 2.8
        res := "Calculated osmolality: " Round(calcOsm, 1) " mOsm/kg"
        extra := ""
        if osm != "" {
            gap := osm - calcOsm
            res .= "   |   measured " osm "   |   osmolar gap " Round(gap, 1)
            extra := "An osmolar gap above about 10 suggests an unmeasured osmole."
        } else {
            extra := "Measured osmolality was not captured, so no osmolar gap can be produced."
        }
        o .= Lab_Block("Calculated osmolality / osmolar gap",
            "Na " LabMetric_FormatValue("sodium", na) ", glucose " LabMetric_FormatValue("glucose", glu)
                . ", BUN " LabMetric_FormatValue("bun", bun),
            "2 x Na + glucose + urea (SI-normalized inputs)", res, extra)
        done += 1
    } else {
        o .= Lab_Missing("Calculated osmolality", "sodium, glucose, and BUN")
    }

    if bun != "" && scr != "" && scr > 0 {
        o .= Lab_Block("BUN / creatinine ratio",
            "BUN " LabMetric_FormatValue("bun", bun) " (" Lab_When(ctx, "bun") "), SCr "
                . LabMetric_FormatValue("creatinine", scr) " (" Lab_When(ctx, "creatinine") ")",
            "conventional BUN / SCr mass ratio after unit normalization",
            Round(bun / scr, 1),
            "A ratio above about 20 is consistent with a prerenal pattern; interpret with volume status.")
        done += 1
    } else {
        o .= Lab_Missing("BUN/creatinine ratio", "BUN and creatinine")
    }

    if na != "" && wtN != "" && sex != "" && na > 145 {
        tbwFactor := RegExMatch(sex, "i)^m") ? 0.6 : 0.5
        tbw := tbwFactor * wtN
        deficit := tbw * ((na / 140) - 1)
        o .= Lab_Block("Free-water deficit",
            "Na " na ", weight " wtN " kg, sex " sex,
            "TBW x (Na/140 - 1), TBW factor " tbwFactor,
            Round(deficit, 2) " L",
            "Correct slowly. Ongoing losses are additional and were not captured.")
        done += 1
    } else if na != "" && na <= 145 {
        o .= Lab_Skip("Free-water deficit", "sodium is not elevated")
    } else {
        o .= Lab_Missing("Free-water deficit", "sodium, weight, and sex")
    }

    if na != "" && wtN != "" && sex != "" && na < 135 {
        tbwFactor := RegExMatch(sex, "i)^m") ? 0.6 : 0.5
        deficit := tbwFactor * wtN * (140 - na)
        o .= Lab_Block("Sodium deficit",
            "Na " na " mmol/L, weight " wtN " kg",
            "TBW x (140 - measured Na)",
            Round(deficit, 1) " mmol to reach 140 mmol/L",
            "Do not correct faster than local protocol allows; overcorrection risks osmotic "
            . "demyelination. Chronicity was not captured.")
        done += 1
    } else if na != "" && na >= 135 {
        o .= Lab_Skip("Sodium deficit", "sodium is not low")
    } else {
        o .= Lab_Missing("Sodium deficit", "sodium, weight, and sex")
    }

    if phen != "" && alb != "" {
        crcl := ""
        parsed := PCtx_ToParsed(ctx)
        PatientCalc_Enrich(parsed)
        if parsed.HasOwnProp("crcl") && IsNumber(parsed.crcl)
            crcl := Number(parsed.crcl)
        factor := (crcl != "" && crcl < 20) ? 0.1 : 0.2
        corr := phen / ((factor * alb) + 0.1)
        o .= Lab_Block("Corrected phenytoin (Sheiner-Tozer)",
            "Phenytoin " phen " mg/L, albumin " LabMetric_FormatValue("albumin", alb)
            . (crcl != "" ? ", CrCl " Round(crcl, 1) " mL/min" : ", CrCl not calculated"),
            "Sheiner-Tozer correction using unit-normalized albumin"
            . ((crcl != "" && crcl < 20) ? " - renal-impairment factor applied" : ""),
            Round(corr, 1) " mg/L",
            "A free phenytoin level is preferred when available.")
        done += 1
    } else {
        o .= Lab_Missing("Corrected phenytoin", "a phenytoin level and albumin")
    }

    if iron != "" && tibc != "" && tibc > 0 {
        o .= Lab_Block("Transferrin saturation",
            "Iron " Round(iron * 0.1791, 1) " µmol/L, TIBC " Round(tibc * 0.1791, 1) " µmol/L",
            "iron / TIBC x 100",
            Round(iron / tibc * 100, 1) " %",
            "Iron studies are affected by inflammation; check ferritin and CRP context.")
        done += 1
    } else {
        o .= Lab_Missing("Transferrin saturation", "serum iron and TIBC")
    }

    if wbc != "" {
        o .= Lab_Missing("ANC", "a differential (neutrophil and band percentages) - not captured")
    }

    header := "LAB CORRECTIONS`r`n"
        . "======================================================================`r`n"
        . done " calculation" (done = 1 ? "" : "s") " could be produced from the captured labs.`r`n"
        . "Every result below lists its inputs, units, collection times, and formula. "
        . "Values from different collection times are never mixed silently - each input shows its "
        . "own timestamp.`r`n`r`n"
    return header o
}

Lab_Block(title, inputs, formula, result, note) {
    o := title "`r`n"
    o .= "  inputs:  " inputs "`r`n"
    o .= "  formula: " formula "`r`n"
    o .= "  RESULT:  " result "`r`n"
    if note != ""
        o .= "  note:    " note "`r`n"
    o .= "`r`n"
    return o
}

Lab_Missing(title, needed) {
    return title "`r`n  NOT AVAILABLE - requires " needed ". Not captured is not the same as normal.`r`n`r`n"
}

Lab_Skip(title, why) {
    return title "`r`n  Not applicable - " why ".`r`n`r`n"
}

; =================================================================================================
; MEDICATION RISK STACK  (blueprint §4 - central medication review, reviewed in the stated order)
; =================================================================================================
Hub_OpenRiskStack(ctx, parsed := 0, label := "") {
    g := Gui("-MinimizeBox +Resize", "Medication Risk Stack")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w780", "Medication risk stack - accumulated session medication list"))

    body := RiskStack_Build(ctx)
    out := g.Add("Edit", "xm y+8 w780 h480 ReadOnly VScroll -Wrap", body)
    Theme_OutputFont(out)

    g.Add("Button", "xm y+10 w120", "Copy").OnEvent("Click", (*) => (A_Clipboard := body))
    g.Add("Button", "x+8 yp w140", "Edit Medications")
        .OnEvent("Click", (*) => Hub_EditCaptured(ctx, 0, 4))
    g.Add("Button", "x+8 yp w100", "Close").OnEvent("Click", (*) => g.Destroy())
    g.Show("w820")
}

RiskStack_Build(ctx) {
    meds := PCtx_ConfirmedActiveMeds(ctx)
    o := "MEDICATION RISK STACK`r`n"
    o .= "======================================================================`r`n"
    o .= meds.Length " active/pending order(s) across " ctx.captures.Length " capture(s).`r`n`r`n"

    if meds.Length = 0
        return o "No medication orders captured.`r`n"

    findings := Allergy_ScanOrders(ctx.allergyRecs, meds)
    o .= "1-3. ALLERGY CONFLICTS`r`n"
    if findings.Length = 0 {
        o .= "   No allergy/order conflict matched. Not a clearance.`r`n"
    } else {
        for f in findings
            o .= "   " f.sev "  " f.detail "`r`n"
    }

    o .= "`r`n4. DUPLICATE THERAPY`r`n"
    dupes := 0
    seen := Map()
    for m in meds {
        for i in m.ingredients {
            if !seen.Has(i)
                seen[i] := []
            seen[i].Push(m.raw)
        }
    }
    for ing, arr in seen {
        if arr.Length < 2
            continue
        dupes += 1
        o .= "   YELLOW  " ing " appears on " arr.Length " orders:`r`n"
        for r in arr
            o .= "        - " r "`r`n"
    }
    if dupes = 0
        o .= "   No ingredient-level duplication among the captured orders.`r`n"

    cols := Safety_Evaluate(ctx)
    labels := Map("RENAL", "5. RENAL DOSING", "QT", "6. QT", "BEERS", "7. BEERS CRITERIA",
        "MG", "8. MYASTHENIA GRAVIS", "G6P", "9. G6PD", "CRUSH", "10. CRUSHABILITY / TUBE")
    for key in Safety_Columns() {
        c := cols[key]
        o .= "`r`n" labels[key] " - " c.status
            . (c.short != "" ? " (" c.short ")" : "") "`r`n"
        if c.findings.Length = 0 {
            o .= "   " c.note "`r`n"
            continue
        }
        for f in c.findings
            o .= "   " f "`r`n"
    }

    ; burden stacks
    keys := []
    for m in meds {
        for i in m.ingredients
            keys.Push(i)
    }

    o .= "`r`n11. BLEEDING BURDEN`r`n" RiskStack_Stack(keys,
        ["warfarin", "apixaban", "rivaroxaban", "dabigatran", "edoxaban", "heparin", "enoxaparin",
         "fondaparinux", "aspirin", "clopidogrel", "ticagrelor", "prasugrel", "ibuprofen",
         "naproxen", "ketorolac", "indomethacin", "diclofenac", "meloxicam", "sertraline",
         "fluoxetine", "escitalopram", "citalopram", "paroxetine", "venlafaxine", "duloxetine"],
        2, "increased bleeding stack")

    o .= "`r`n12. SEDATIVE / FALL BURDEN`r`n" RiskStack_Stack(keys,
        ["lorazepam", "midazolam", "diazepam", "alprazolam", "clonazepam", "temazepam", "zolpidem",
         "eszopiclone", "zaleplon", "quetiapine", "olanzapine", "haloperidol", "risperidone",
         "trazodone", "mirtazapine", "diphenhydramine", "hydroxyzine", "promethazine",
         "cyclobenzaprine", "methocarbamol", "baclofen", "gabapentin", "pregabalin", "morphine",
         "hydromorphone", "oxycodone", "fentanyl", "methadone"],
        3, "sedative and fall-risk stack")

    o .= "`r`n13. ANTICHOLINERGIC BURDEN`r`n"
    score := 0
    detail := ""
    for m in meds {
        for i in m.ingredients {
            s := MedFlag_AnticholinergicScore(i)
            if s > 0 {
                score += s
                detail .= "   " m.raw " -> score " s "`r`n"
            }
        }
    }
    o .= detail = "" ? "   No scored anticholinergic medications matched.`r`n" : detail
    if score > 0
        o .= "   Total anticholinergic burden score: " score
            . (score >= 3 ? "  (>=3 is associated with cognitive and functional risk)" : "") "`r`n"

    o .= "`r`n14. SEROTONERGIC BURDEN`r`n" RiskStack_Stack(keys,
        ["sertraline", "fluoxetine", "escitalopram", "citalopram", "paroxetine", "fluvoxamine",
         "venlafaxine", "duloxetine", "trazodone", "mirtazapine", "amitriptyline", "nortriptyline",
         "linezolid", "methylene blue", "tramadol", "fentanyl", "meperidine", "methadone",
         "ondansetron", "metoclopramide", "lithium", "buspirone", "dextromethorphan"],
        3, "serotonin syndrome stack")

    o .= "`r`n15. NEPHROTOXIC COMBINATIONS`r`n" RiskStack_Stack(keys,
        ["vancomycin", "piperacillin", "tazobactam", "gentamicin", "tobramycin", "amikacin",
         "amphotericin b", "ibuprofen", "naproxen", "ketorolac", "indomethacin", "diclofenac",
         "lisinopril", "enalapril", "losartan", "valsartan", "furosemide", "tacrolimus",
         "cyclosporine", "cisplatin", "iohexol", "acyclovir"],
        2, "potential AKI medication stack")

    o .= "`r`n16. HIGH-RISK INTERACTION PAIRS`r`n"
    inter := MedFlag_Interactions(keys)
    if inter.Length = 0 {
        o .= "   No curated high-risk pair matched.`r`n"
    } else {
        for i in inter
            o .= "   YELLOW  " i "`r`n"
    }

    o .= "`r`n----------------------------------------------------------------------`r`n"
    o .= "Findings are tiered. An exact allergy match and a weak class relationship are not the "
        . "same severity. Absence of a finding never means the regimen is appropriate - it means "
        . "no loaded rule matched the captured text.`r`n"
    return o
}

RiskStack_Stack(keys, members, threshold, label) {
    hits := []
    for k in keys {
        for mem in members {
            if k = mem && !RxN_HasKey(hits, k)
                hits.Push(k)
        }
    }
    if hits.Length < threshold
        return "   Below threshold (" hits.Length " of " threshold " needed).`r`n"
    line := ""
    for h in hits
        line .= (line = "" ? "" : " + ") h
    return "   YELLOW  " line ": " label ".`r`n"
}


; =================================================================================================
; RSI DOSING - PRESENTATION REDESIGN  (blueprint §10)
; -------------------------------------------------------------------------------------------------
; Primary view is a bordered drug/dose table only. Formulas, mg/kg ranges, and cautions move to a
; reference section that is expanded by default and can be hidden. Warnings appear on their own
; row beneath the affected drug rather than inside the drug name or dose. The header always states
; which weight was used; the third column appears only when the basis is not actual body weight.
;
; DOSE SELECTION: one row per drug, one number per row. Each agent carries a selected mg/kg
; (a.pick) set to the midpoint of its published band; the selected mg/kg prints beside the dose and
; the full range stays in the reference section so the choice is auditable. There are no separate
; reduced/fragile rows - dose reduction is a caution on the drug's own warning row. Change a.pick
; to retune an agent; nothing else needs to change.
; =================================================================================================

RSI_Agents() {
    static agents := [
        { drug: "Etomidate",         pick: 0.25, lo: 0.2,  hi: 0.3,  unit: "mg",  route: "IV",
          ref: "0.2-0.3 mg/kg IV",
          warn: "Adrenal suppression after a single dose; caution in sepsis." },
        { drug: "Ketamine",          pick: 1.5,  lo: 1,    hi: 2,    unit: "mg",  route: "IV",
          ref: "1-2 mg/kg IV",
          warn: "Reduce toward 0.5-1 mg/kg in shock or catecholamine-depleted states." },
        { drug: "Propofol",          pick: 1.5,  lo: 1,    hi: 2,    unit: "mg",  route: "IV",
          ref: "1-2 mg/kg IV",
          warn: "Dose-related hypotension; reduce substantially if hemodynamically fragile." },
        { drug: "Midazolam",         pick: 0.2,  lo: 0.1,  hi: 0.3,  unit: "mg",  route: "IV",
          ref: "0.1-0.3 mg/kg IV",
          warn: "Slower onset plus hypotension and respiratory depression." },
        { drug: "Succinylcholine",   pick: 1.25, lo: 1,    hi: 1.5,  unit: "mg",  route: "IV",
          ref: "1-1.5 mg/kg IV",
          warn: "Avoid with hyperkalemia, burns, crush, denervation, neuromuscular disease, or MH risk." },
        { drug: "Rocuronium",        pick: 1.1,  lo: 1,    hi: 1.2,  unit: "mg",  route: "IV",
          ref: "1-1.2 mg/kg IV for RSI",
          warn: "Paralysis outlasts induction; ensure post-intubation sedation and analgesia." },
        { drug: "Vecuronium",        pick: 0.1,  lo: 0.1,  hi: 0.1,  unit: "mg",  route: "IV",
          ref: "0.1 mg/kg IV", warn: "" },
        { drug: "Fentanyl",          pick: 2,    lo: 1,    hi: 3,    unit: "mcg", route: "IV",
          ref: "1-3 mcg/kg IV pretreatment",
          warn: "Pretreatment only. Avoid in decompensated shock." },
        { drug: "Lidocaine",         pick: 1.5,  lo: 1.5,  hi: 1.5,  unit: "mg",  route: "IV",
          ref: "1.5 mg/kg IV pretreatment",
          warn: "Pretreatment only. Contraindicated with severe bradycardia, severe heart block, or amide anesthetic allergy." }
    ]
    return agents
}

RSI_DoseText(a, wt) {
    return RSI_RoundDose(a.pick * wt) " " a.unit " " a.route
        . "   (" RSI_Num(a.pick) " " a.unit "/kg)"
}

; Whole numbers at clinically usable magnitudes; one decimal only for small doses where the
; decimal actually changes what is drawn up (e.g. vecuronium, midazolam in a fragile patient).
RSI_RoundDose(v) {
    if v >= 10
        return Round(v)
    return RSI_Num(Round(v, 1))
}

; Trim AHK float formatting so 1.500000 prints as 1.5 and 2.000000 prints as 2.
RSI_Num(v) {
    t := Format("{:.4f}", v)
    t := RegExReplace(t, "0+$", "")
    t := RegExReplace(t, "\.$", "")
    return t = "" ? "0" : t
}

Calc_OpenRsiDosing() {
    global _PreFillDemographics

    prefWt := ""
    prefIbw := ""
    prefAdj := ""
    if _PreFillDemographics.Count > 0 {
        pf := _PreFillDemographics
        if pf.Has("weightKg")
            prefWt := Trim(String(pf["weightKg"]))
        if pf.Has("ibwKg")
            prefIbw := Trim(String(pf["ibwKg"]))
        if pf.Has("adjbwKg")
            prefAdj := Trim(String(pf["adjbwKg"]))
        _PreFillDemographics := Map()
    }

    parsedNow := PBind_CurrentParsed()
    if prefWt = ""
        prefWt := PBind_Value(parsedNow, "weightKg")
    if prefIbw = "" && parsedNow.HasOwnProp("ibwKg")
        prefIbw := parsedNow.ibwKg
    if prefAdj = "" && parsedNow.HasOwnProp("adjbwKg")
        prefAdj := parsedNow.adjbwKg

    g := Gui("+Resize", "RSI Dosing Support")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)

    warnCtrl := g.Add("Text", "xm ym w740",
        "RSI is time-critical. This is a dose display aid; the clinician chooses the agent based on "
        . "shock, asthma, ICP, contraindications, and local airway protocol.")
    warnCtrl.SetFont("s10 bold c" Theme_Accent("bad"), "Segoe UI")

    g.Add("Text", "xm y+10 w100", "Weight (kg):")
    wtCtrl := g.Add("Edit", "x+4 yp-3 w90", prefWt)
    g.Add("Text", "x+12 yp+3 w100", "Dosing weight:")
    basis := g.Add("DropDownList", "x+4 yp-3 w190",
        ["Actual body weight", "Ideal body weight", "Adjusted body weight"])
    basis.Value := 1
    calcBtn := g.Add("Button", "x+8 yp w110 Default", "Calculate")

    header := g.Add("Text", "xm y+12 w740", "RSI DOSING - enter a weight")
    header.SetFont("s13 bold c" Theme_Accent("heading"), "Segoe UI")
    subHeader := g.Add("Text", "xm y+2 w740", "Dosing weight: not set")
    Theme_Subtle(subHeader)

    lv := g.Add("ListView", "xm y+8 w740 h280 Grid -Multi", ["Drug", "Calculated Dose", "Weight Used"])
    lv.SetFont("s11", "Segoe UI")
    lv.ModifyCol(1, 250)
    lv.ModifyCol(2, 460)
    lv.ModifyCol(3, 0)

    refHeader := g.Add("Text", "xm y+10 w740", "REFERENCE RANGES")
    refHeader.SetFont("s11 bold c" Theme_Accent("heading"), "Segoe UI")
    refCtrl := g.Add("Edit", "xm y+4 w740 h180 ReadOnly VScroll -Wrap", "")
    Theme_OutputFont(refCtrl)

    toggle := g.Add("Button", "xm y+8 w140", "Hide References")
    copyDose := g.Add("Button", "x+8 yp w160", "Copy Drug && Dose Only")
    copyFull := g.Add("Button", "x+8 yp w160", "Copy Full RSI Report")
    editBtn := g.Add("Button", "x+8 yp w130", "Edit Patient Data")
    closeBtn := g.Add("Button", "x+8 yp w80", "Close")

    render := (*) => SafeRun(RSI_Render, header, subHeader, lv, refCtrl,
        wtCtrl, basis, prefIbw, prefAdj)

    calcBtn.OnEvent("Click", render)
    basis.OnEvent("Change", render)
    toggle.OnEvent("Click", (*) => RSI_ToggleRefs(toggle, refHeader, refCtrl))
    copyDose.OnEvent("Click", (*) => RSI_CopyDoseOnly(lv, subHeader))
    copyFull.OnEvent("Click", (*) => RSI_CopyFull(lv, header, subHeader, refCtrl))
    editBtn.OnEvent("Click", (*) => RSI_EditPatient())
    closeBtn.OnEvent("Click", (*) => g.Destroy())

    Workbench29_Show(g,"w780")

    if prefWt != "" && IsNumber(prefWt) && Number(prefWt) > 0
        RSI_Render(header, subHeader, lv, refCtrl, wtCtrl, basis, prefIbw, prefAdj)
}

RSI_Render(header, subHeader, lv, refCtrl, wtCtrl, basisCtrl, prefIbw, prefAdj) {
    actualTxt := Trim(wtCtrl.Value)
    if !IsNumber(actualTxt) || Number(actualTxt) <= 0 {
        MsgBox("Enter a valid weight in kg.", "RSI", "Icon!")
        return
    }
    actual := Number(actualTxt)

    basisName := "actual body weight"
    wt := actual
    if basisCtrl.Value = 2 {
        if prefIbw = "" || !IsNumber(prefIbw) || Number(prefIbw) <= 0 {
            MsgBox("Ideal body weight is not available from the captured patient. Capture height "
                . "and sex, or type the ideal weight directly into the weight field.",
                "RSI", "Icon!")
            basisCtrl.Value := 1
            return
        }
        wt := Number(prefIbw)
        basisName := "ideal body weight"
    } else if basisCtrl.Value = 3 {
        if prefAdj = "" || !IsNumber(prefAdj) || Number(prefAdj) <= 0 {
            MsgBox("Adjusted body weight is not available from the captured patient. Capture "
                . "height, sex, and weight, or type the adjusted weight directly.",
                "RSI", "Icon!")
            basisCtrl.Value := 1
            return
        }
        wt := Number(prefAdj)
        basisName := "adjusted body weight"
    }

    showBasisCol := (basisCtrl.Value != 1)
    basisLabel := Round(wt, 1) " kg " basisName

    header.Text := "RSI DOSING - " Round(wt, 1) " kg"
    subHeader.Text := "Dosing weight: " basisLabel

    lv.Opt("-Redraw")
    lv.Delete()
    for a in RSI_Agents() {
        lv.Add("", a.drug, RSI_DoseText(a, wt), showBasisCol ? basisLabel : "")
        if a.warn != ""
            lv.Add("", "", "! " a.warn, "")
    }
    lv.ModifyCol(1, 250)
    lv.ModifyCol(2, showBasisCol ? 260 : 460)
    lv.ModifyCol(3, showBasisCol ? 200 : 0)
    lv.Opt("+Redraw")

    refCtrl.Value := RSI_ReferenceText(wt, basisLabel)
}

RSI_ReferenceText(wt, basisLabel) {
    o := ""
    for a in RSI_Agents() {
        o .= a.drug "`r`n"
        o .= "  Selected by this tool: " RSI_Num(a.pick) " " a.unit "/kg"
            . "  ->  " RSI_RoundDose(a.pick * wt) " " a.unit " " a.route "`r`n"
        o .= "  Published range: " a.ref "`r`n"
        o .= "  Calculated using: " basisLabel "`r`n"
        if a.warn != ""
            o .= "  Caution: " a.warn "`r`n"
        o .= "`r`n"
    }
    o .= "Each row above is a single selected dose, not a range. Reduce for shock or "
        . "hemodynamic fragility per the caution on that drug's row.`r`n"
    o .= "Weight basis for every row above: " basisLabel ".`r`n"
    return o
}

RSI_ToggleRefs(btn, refHeader, refCtrl) {
    if btn.Text = "Hide References" {
        refHeader.Visible := false
        refCtrl.Visible := false
        btn.Text := "Show References"
    } else {
        refHeader.Visible := true
        refCtrl.Visible := true
        btn.Text := "Hide References"
    }
}

RSI_CopyDoseOnly(lv, subHeader) {
    txt := "RSI " subHeader.Text "`r`n`r`n"
    Loop lv.GetCount() {
        drug := lv.GetText(A_Index, 1)
        dose := lv.GetText(A_Index, 2)
        if drug = ""
            continue
        txt .= drug ": " dose "`r`n"
    }
    A_Clipboard := txt
    ToolTip("Drug and dose copied.")
    SetTimer(() => ToolTip(), -1500)
}

RSI_CopyFull(lv, header, subHeader, refCtrl) {
    txt := header.Text "`r`n" subHeader.Text "`r`n"
    txt .= "======================================================================`r`n"
    Loop lv.GetCount() {
        drug := lv.GetText(A_Index, 1)
        dose := lv.GetText(A_Index, 2)
        if drug = ""
            txt .= "    " dose "`r`n"
        else
            txt .= Format("{1:-32}", drug) dose "`r`n"
    }
    txt .= "`r`nREFERENCE RANGES`r`n"
    txt .= "======================================================================`r`n"
    txt .= refCtrl.Value
    txt .= "`r`nRSI is time-critical. Agent choice depends on shock, asthma, ICP, "
        . "contraindications, and local airway protocol. Verify every dose before administration.`r`n"
    A_Clipboard := txt
    ToolTip("Full RSI report copied.")
    SetTimer(() => ToolTip(), -1500)
}

RSI_EditPatient() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("No active patient session. Press Ctrl+B to capture a patient screen first, "
            . "or type the weight directly.", "RSI", "Iconi")
        return
    }
    Hub_EditCaptured(ctx, 0, 1)
}


; ---- menu entry points --------------------------------------------------------------------------
Menu_OpenPatientHub() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("No active patient session. Press Ctrl+B and drag over the patient screen to start "
            . "one.", "Patient Hub", "Iconi")
        return
    }
    Hub_Show(ctx)
}

Menu_OpenMedRec() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("Medication reconciliation reads the active captured patient session. Press Ctrl+B and capture the medication profile first.", "Medication Reconciliation", "Iconi")
        return
    }
    if PCtx_ActiveMeds(ctx).Length = 0 {
        MsgBox("No active medication orders were captured yet. Press Ctrl+B and capture the Cerner medication/order list, then reopen Medication Reconciliation.", "Medication Reconciliation", "Iconi")
        return
    }
    Hub_OpenMedRecComparison(ctx)
}

Menu_OpenOrderReview() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("Order Review Queue reads the active patient session. Hold Ctrl and drag over the medication profile first.", "Order Review Queue", "Iconi")
        return
    }
    Hub_OpenOrderReview(ctx)
}

Menu_OpenCaptureEvidence() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("Capture Evidence Review is available after the first screen capture. Hold Ctrl and drag over a patient screen first.", "Capture Evidence", "Iconi")
        return
    }
    Hub_OpenCaptureEvidence(ctx)
}

Menu_OpenBackgroundLookups(selectedKey := "admission_medrec") {
    ctx := PCtx_Active()
    needsIdentifier := !IsObject(ctx) || InpatientSql_SelectedIdentifier(ctx) = ""
    if needsIdentifier && Inpatient_EnsurePowerChartPatientContext()
        ctx := PCtx_Active()
    if needsIdentifier && (IsMedicationManagerWindow() || Inpatient_IsRemotePatientWindow()) {
        Inpatient_CaptureMedicationManagerHeader(false)
        ctx := PCtx_Active()
    }
    if !IsObject(ctx) {
        MsgBox("Background Lookups uses the active captured patient session. Press Ctrl+B and capture a patient screen first.", "Background Patient Lookups", "Iconi")
        return
    }
    Hub_OpenBackgroundLookups(ctx, 0, "", selectedKey)
}

Inpatient_IsRemotePatientWindow() {
    hwnd := WinGetID("A")
    if !hwnd
        return false
    if WinGetClass("ahk_id " hwnd) != "Transparent Windows Client"
        return false
    title := WinGetTitle("ahk_id " hwnd)
    return title != ""
        && !RegExMatch(title, "i)(?:PowerChart|Opened by|Organizer|Home|Work|Desktop|Start)")
}

Inpatient_EnsurePowerChartPatientContext() {
    title := WinGetTitle("A")
    if !RegExMatch(title, "i)\s-\s([1-9]\d{6,15})\s+Opened\s+by\b", &match)
        return false
    global PCtxSession
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        ctx := PCtx_New()
        PCtxSession := ctx
    }
    PCtx_MergeCapture(ctx, {mrn: match[1]}, title, "PowerChart patient title")
    return true
}

Menu_OpenPatientModule(which) {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("This module reads the captured patient session. Press Ctrl+B and drag over the "
            . "patient screen first.", "Patient Session", "Iconi")
        return
    }
    switch which {
        case "renal": Hub_OpenRenalScreening(ctx)
        case "labs": Hub_OpenLabCorrections(ctx)
        case "riskstack": Hub_OpenRiskStack(ctx)
        case "allergy": Hub_ShowAllergyFindings(ctx)
    }
}


; =================================================================================================
; CAPTURE V1 — CANDIDATE / ACCEPTED FIELD SAFETY FOUNDATION
; Keeps what the screen reader saw, but only copies accepted values into the
; canonical patient object used by calculators, renal rules, and prefill.
; =================================================================================================

CaptureV1_RowObservations(bundle, labelPattern) {
    observations := []
    seenParts := Map()

    for key in ["headerLeft", "headerRight", "sidebar"] {
        part := 0
        try part := bundle.%key%
        if !IsObject(part)
            continue
        partId := ObjPtr(part)
        if seenParts.Has(partId)
            continue
        seenParts[partId] := true

        lines := PatientV2_GetLines(part)
        if lines.Length = 0
            continue

        minX := lines[1].x
        maxRight := lines[1].x + lines[1].w
        for line in lines {
            minX := Min(minX, line.x)
            maxRight := Max(maxRight, line.x + line.w)
        }

        matchedRow := false
        for labelItem in lines {
            labelText := PatientV2_CleanLine(labelItem.text)
            if !RegExMatch(labelText, labelPattern)
                continue
            matchedRow := true

            rowItems := []
            tolerance := Max(7, Round(labelItem.h * 0.9))
            for item in lines {
                if Abs(item.y - labelItem.y) <= tolerance
                    rowItems.Push(item)
            }
            rowItems := PatientV4_SortByX(rowItems)

            rowText := ""
            for item in rowItems {
                piece := PatientV2_CleanLine(item.text)
                if piece != ""
                    rowText .= (rowText = "" ? "" : " ") piece
            }
            if rowText != ""
                observations.Push({text: rowText, source: key "/bundle"})

            cropY := Max(0, labelItem.y - 5)
            cropH := labelItem.h + 12
            cropW := maxRight - minX + 15
            for pass in [
                {scale: 4.5, gray: false, mono: 0, tag: "color"},
                {scale: 4.5, gray: true, mono: 0, tag: "gray"},
                {scale: 4.0, gray: true, mono: 110, tag: "mono"}
            ] {
                try {
                    result := PatientV2_TryOcrRect(minX, cropY, cropW, cropH, pass.scale, pass.gray, pass.mono)
                    text := PatientV2_CleanLine(PatientV2_ResultText(result))
                    if text != ""
                        observations.Push({text: text, source: key "/" pass.tag})
                }
            }
            break
        }
        if !matchedRow {
            try combinedText := PatientV2_ResultText(part)
            catch
                combinedText := ""
            if combinedText != "" && RegExMatch(combinedText, labelPattern)
                observations.Push({text: combinedText, source: key "/combined"})
        }
    }
    return observations
}

CaptureV1_NewEntry(value, raw, source) {
    sources := Map()
    sources[source] := true
    return {value: value, raw: raw, sources: sources, texts: []}
}

CaptureV1_AddSource(entry, source) {
    if source != ""
        entry.sources[source] := true
}

CaptureV1_UnionSources(target, sourceEntry) {
    for source, _ in sourceEntry.sources
        target.sources[source] := true
}

CaptureV1_SourceCount(entry) {
    try return entry.sources.Count
    return 0
}

CaptureV1_SortBySources(entries) {
    if entries.Length < 2
        return entries
    Loop entries.Length - 1 {
        i := A_Index
        Loop entries.Length - i {
            j := A_Index
            if CaptureV1_SourceCount(entries[j]) < CaptureV1_SourceCount(entries[j + 1]) {
                swap := entries[j]
                entries[j] := entries[j + 1]
                entries[j + 1] := swap
            }
        }
    }
    return entries
}

CaptureV1_Tally(observations, pattern, minimum, maximum) {
    tally := Map()
    order := []
    for obs in observations {
        normalized := PatientV2_NormalizeText(obs.text)
        if !RegExMatch(normalized, pattern, &match)
            continue
        raw := match[1]
        value := PatientV5_ParseNumberToken(raw)
        if value = "" || value < minimum || value > maximum
            continue
        key := Format("{:.4f}", value)
        if tally.Has(key) {
            CaptureV1_AddSource(tally[key], obs.source)
        } else {
            tally[key] := CaptureV1_NewEntry(value, raw, obs.source)
            order.Push(key)
        }
        tally[key].texts.Push(obs.text)
    }
    output := []
    for key in order
        output.Push(tally[key])
    return CaptureV1_SortBySources(output)
}

CaptureV1_TallyWithParser(observations, parser, minimum, maximum) {
    tally := Map()
    order := []
    for obs in observations {
        values := parser([obs.text])
        if !IsObject(values)
            continue
        for value in values {
            if value = "" || value < minimum || value > maximum
                continue
            key := Format("{:.4f}", value)
            if tally.Has(key) {
                CaptureV1_AddSource(tally[key], obs.source)
            } else {
                tally[key] := CaptureV1_NewEntry(value, String(value), obs.source)
                order.Push(key)
            }
            tally[key].texts.Push(obs.text)
        }
    }
    output := []
    for key in order
        output.Push(tally[key])
    return CaptureV1_SortBySources(output)
}

CaptureV1_DecimalGuard(tally) {
    if tally.Length < 2
        return tally
    removed := Map()
    Loop tally.Length {
        i := A_Index
        entry := tally[i]
        if !InStr(entry.raw, ".") && !InStr(entry.raw, ",")
            continue
        Loop tally.Length {
            j := A_Index
            if i = j || removed.Has(j)
                continue
            other := tally[j]
            if Abs(other.value - entry.value * 10) < 0.001 {
                CaptureV1_UnionSources(entry, other)
                removed[j] := true
            }
        }
    }
    kept := []
    Loop tally.Length {
        if !removed.Has(A_Index)
            kept.Push(tally[A_Index])
    }
    return CaptureV1_SortBySources(kept)
}

CaptureV1_MergeNear(tally, tolerance) {
    if tolerance <= 0 || tally.Length < 2
        return tally
    removed := Map()
    Loop tally.Length {
        i := A_Index
        if removed.Has(i)
            continue
        entry := tally[i]
        Loop tally.Length {
            j := A_Index
            if i = j || removed.Has(j)
                continue
            other := tally[j]
            if Abs(other.value - entry.value) <= tolerance {
                CaptureV1_UnionSources(entry, other)
                removed[j] := true
            }
        }
    }
    kept := []
    Loop tally.Length {
        if !removed.Has(A_Index)
            kept.Push(tally[A_Index])
    }
    return CaptureV1_SortBySources(kept)
}

CaptureV1_Resolve(tally, label, minimumSources := 2) {
    if tally.Length = 0
        return {value: "", status: "missing", accepted: false, sourceCount: 0, sources: Map(), detail: ""}

    leader := tally[1]
    leaderCount := CaptureV1_SourceCount(leader)
    if tally.Length > 1 && CaptureV1_SourceCount(tally[2]) = leaderCount {
        return {value: leader.value, status: "conflict", accepted: false,
            sourceCount: leaderCount, sources: leader.sources,
            detail: label " values disagree (" leader.value " vs " tally[2].value ")"}
    }
    accepted := leaderCount >= minimumSources
    return {value: leader.value, status: accepted ? "accepted" : "needs_confirmation",
        accepted: accepted, sourceCount: leaderCount, sources: leader.sources,
        detail: accepted ? "matching focused reads" : "one readable source"}
}

CaptureV1_ResolveText(observations, pattern, label, minimumSources := 2) {
    tally := Map()
    order := []
    for obs in observations {
        if !RegExMatch(obs.text, pattern, &match)
            continue
        value := StrLower(match[1]) = "female" ? "Female" : "Male"
        if !tally.Has(value) {
            tally[value] := CaptureV1_NewEntry(value, value, obs.source)
            order.Push(value)
        } else {
            CaptureV1_AddSource(tally[value], obs.source)
        }
    }
    output := []
    for value in order
        output.Push(tally[value])
    return CaptureV1_Resolve(CaptureV1_SortBySources(output), label, minimumSources)
}

CaptureV1_ResolveDate(observations, pattern, label, minimumSources := 1) {
    tally := Map(), order := []
    for obs in observations {
        if !RegExMatch(obs.text, pattern, &match)
            continue
        year := Number(match[3])
        if year < 100
            year += year >= 30 ? 1900 : 2000
        if year < 1900 || year > Integer(SubStr(A_YYYY, 1, 4))
            continue
        value := Format("{:02}/{:02}/{:04}", Number(match[1]), Number(match[2]), year)
        if !tally.Has(value) {
            tally[value] := CaptureV1_NewEntry(value, value, obs.source)
            order.Push(value)
        } else
            CaptureV1_AddSource(tally[value], obs.source)
    }
    output := []
    for value in order
        output.Push(tally[value])
    return CaptureV1_Resolve(CaptureV1_SortBySources(output), label, minimumSources)
}

CaptureV1_Record(parsed, field, rec, unit := "") {
    if !parsed.HasOwnProp("captureEvidence") || !IsObject(parsed.captureEvidence)
        parsed.captureEvidence := Map()
    rec.field := field
    rec.unit := unit
    rec.manual := rec.HasOwnProp("manual") ? rec.manual : false
    rec.crossChecks := rec.HasOwnProp("crossChecks") && IsObject(rec.crossChecks) ? rec.crossChecks : []
    parsed.captureEvidence[field] := rec
    return rec
}

CaptureV1_RecordAnchor(parsed, bundle, field, labelPattern, valuePattern, minimum, maximum, unit) {
    observations := CaptureV1_RowObservations(bundle, labelPattern)
    result := CaptureV1_Resolve(
        CaptureV1_DecimalGuard(CaptureV1_Tally(observations, valuePattern, minimum, maximum)),
        field
    )
    if result.value != ""
        result.value := Round(result.value, 2)
    return CaptureV1_Record(parsed, field, result, unit)
}

CaptureV1_HasEvidence(parsed, field) {
    try return IsObject(parsed.captureEvidence) && parsed.captureEvidence.Has(field)
    return false
}

CaptureV1_RecordFor(parsed, field) {
    try {
        if IsObject(parsed.captureEvidence) && parsed.captureEvidence.Has(field)
            return parsed.captureEvidence[field]
    }
    return 0
}

CaptureV1_IsAccepted(parsed, field) {
    rec := CaptureV1_RecordFor(parsed, field)
    if !IsObject(rec)
        return true
    return rec.accepted
}

CaptureV1_EditValue(parsed, field) {
    try {
        if parsed.HasOwnProp(field) && parsed.%field% != ""
            return parsed.%field%
    }
    rec := CaptureV1_RecordFor(parsed, field)
    return IsObject(rec) ? rec.value : ""
}

CaptureV1_MarkManual(parsed, field, value) {
    rec := CaptureV1_RecordFor(parsed, field)
    if Trim(String(value)) = "" {
        if IsObject(rec) {
            rec.value := ""
            rec.status := "missing"
            rec.accepted := false
            rec.manual := true
            rec.detail := "cleared by user"
        }
        return
    }
    if !IsObject(rec) {
        rec := {value: value, status: "accepted", accepted: true, sourceCount: 1,
            sources: Map("user/edit", true), detail: "confirmed by user", manual: true, crossChecks: []}
        CaptureV1_Record(parsed, field, rec, "")
        return
    }
    rec.value := value
    rec.status := "accepted"
    rec.accepted := true
    rec.manual := true
    rec.detail := "confirmed by user"
    rec.sources["user/edit"] := true
    rec.sourceCount := rec.sources.Count
}

CaptureV1_CandidateNumber(parsed, field) {
    rec := CaptureV1_RecordFor(parsed, field)
    if !IsObject(rec) || rec.value = ""
        return ""
    return PatientCalc_ReadNumber(rec.value)
}

CaptureV1_UsableAnchor(parsed, field) {
    rec := CaptureV1_RecordFor(parsed, field)
    return IsObject(rec) && rec.value != "" && rec.status != "conflict"
}

CaptureV1_Support(parsed, field, message, promote := false) {
    rec := CaptureV1_RecordFor(parsed, field)
    if !IsObject(rec)
        return
    rec.crossChecks.Push(message)
    rec.detail .= (rec.detail = "" ? "" : "; ") message
    ; A labeled/unit-bearing screen read plus an independent mathematical
    ; chart cross-check is sufficient even when only one image transform kept
    ; the punctuation. The cross-check is the second evidence type.
    if promote && rec.sourceCount >= 1 {
        rec.status := "accepted"
        rec.accepted := true
    }
}

CaptureV1_RequireConfirmation(parsed, field, message, conflict := false) {
    rec := CaptureV1_RecordFor(parsed, field)
    if !IsObject(rec) || rec.value = ""
        return
    rec.crossChecks.Push(message)
    rec.detail .= (rec.detail = "" ? "" : "; ") message
    rec.status := conflict ? "conflict" : "needs_confirmation"
    rec.accepted := false
}

CaptureV1_AssessConsistency(parsed) {
    age := CaptureV1_CandidateNumber(parsed, "age")
    height := CaptureV1_CandidateNumber(parsed, "heightCm")
    weight := CaptureV1_CandidateNumber(parsed, "weightKg")
    scr := CaptureV1_CandidateNumber(parsed, "scr")
    reportedBsa := CaptureV1_CandidateNumber(parsed, "reportedBsa")
    reportedIbw := CaptureV1_CandidateNumber(parsed, "reportedIbw")
    reportedCrCl := CaptureV1_CandidateNumber(parsed, "reportedCrCl")
    sexRec := CaptureV1_RecordFor(parsed, "sex")
    sex := IsObject(sexRec) ? sexRec.value : ""

    if height != "" && weight != "" && reportedBsa != ""
        && CaptureV1_UsableAnchor(parsed, "reportedBsa") {
        expectedBsa := Sqrt(height * weight / 3600)
        if Abs(expectedBsa - reportedBsa) <= Max(0.12, reportedBsa * 0.07) {
            CaptureV1_Support(parsed, "heightCm", "matches displayed BSA", true)
            CaptureV1_Support(parsed, "weightKg", "matches displayed BSA", true)
        } else {
            CaptureV1_RequireConfirmation(parsed, "heightCm", "does not match displayed BSA")
            CaptureV1_RequireConfirmation(parsed, "weightKg", "does not match displayed BSA")
        }
    }

    ibw := ""
    if height != "" && (sex = "Male" || sex = "Female") {
        inchesOverFiveFeet := Max(0, height / 2.54 - 60)
        ibw := (sex = "Female" ? 45.5 : 50) + 2.3 * inchesOverFiveFeet
        if reportedIbw != "" && CaptureV1_UsableAnchor(parsed, "reportedIbw") {
            if Abs(ibw - reportedIbw) <= 2.0 {
                CaptureV1_Support(parsed, "heightCm", "matches displayed IBW", true)
                CaptureV1_Support(parsed, "sex", "matches displayed IBW", true)
            } else {
                CaptureV1_RequireConfirmation(parsed, "heightCm", "does not match displayed IBW")
                CaptureV1_RequireConfirmation(parsed, "sex", "does not match displayed IBW")
            }
        }
    }

    if age != "" && weight != "" && scr != "" && reportedCrCl != ""
        && (sex = "Male" || sex = "Female") && CaptureV1_UsableAnchor(parsed, "reportedCrCl") {
        factor := sex = "Female" ? 0.85 : 1.0
        weights := [{value: weight, label: "actual weight"}]
        if ibw != "" {
            weights.Push({value: ibw, label: "ideal weight"})
            weights.Push({value: ibw + 0.4 * (weight - ibw), label: "adjusted weight"})
        }
        matched := ""
        for item in weights {
            calculated := (140 - age) * item.value / (72 * scr) * factor
            if Abs(calculated - reportedCrCl) <= Max(5, reportedCrCl * 0.15) {
                matched := item.label
                break
            }
        }
        if matched != "" {
            CaptureV1_Support(parsed, "age", "matches displayed CrCl", true)
            CaptureV1_Support(parsed, "sex", "matches displayed CrCl", true)
            CaptureV1_Support(parsed, "weightKg", "matches displayed CrCl using " matched, true)
            CaptureV1_Support(parsed, "scr", "matches displayed CrCl using " matched, true)
        } else {
            CaptureV1_RequireConfirmation(parsed, "scr", "does not reproduce displayed CrCl", true)
        }
    }
}

CaptureV1_ApplyAccepted(parsed) {
    for field in ["age", "sex", "heightCm", "weightKg", "scr"] {
        rec := CaptureV1_RecordFor(parsed, field)
        if IsObject(rec) && rec.accepted
            parsed.%field% := rec.value
        else
            parsed.%field% := ""
    }
}

CaptureV1_FieldLabel(field) {
    switch field {
        case "age": return "Age"
        case "sex": return "Sex"
        case "heightCm": return "Height"
        case "weightKg": return "Weight"
        case "scr": return "SCr"
    }
    return field
}

CaptureV1_AddActionWarnings(parsed) {
    for field in ["age", "sex", "heightCm", "weightKg", "scr"] {
        rec := CaptureV1_RecordFor(parsed, field)
        if !IsObject(rec) || rec.value = "" || rec.accepted
            continue
        unitText := rec.unit != "" ? " " rec.unit : ""
        if rec.status = "conflict"
            PatientV6_AddWarning(parsed, CaptureV1_FieldLabel(field) " needs confirmation: captured values conflict.")
        else
            PatientV6_AddWarning(parsed, CaptureV1_FieldLabel(field) " needs confirmation: " rec.value unitText ".")
    }
}

CaptureV1_ActionBlock(parsed) {
    lines := []
    for field in ["age", "sex", "heightCm", "weightKg", "scr"] {
        rec := CaptureV1_RecordFor(parsed, field)
        if !IsObject(rec) || rec.value = "" || rec.accepted
            continue
        unitText := rec.unit != "" ? " " rec.unit : ""
        if rec.status = "conflict"
            lines.Push(CaptureV1_FieldLabel(field) ": check the chart; captured values disagree")
        else
            lines.Push(CaptureV1_FieldLabel(field) ": confirm " rec.value unitText)
    }
    if lines.Length = 0
        return ""
    output := "NEEDS CONFIRMATION`r`n"
    for line in lines
        output .= "• " line "`r`n"
    return output "`r`n"
}

class OCR {
    static Version => "2.0.0"
    static IID_IRandomAccessStream := "{905A0FE1-BC53-11DF-8C49-001E4FC686DA}"
         , IID_IPicture            := "{7BF80980-BF32-101A-8BBB-00AA00300CAB}"
         , IID_IAsyncInfo          := "{00000036-0000-0000-C000-000000000046}"
         , IID_IAsyncOperation_OcrResult        := "{c7d7118e-ae36-59c0-ac76-7badee711c8b}"
         , IID_IAsyncOperation_SoftwareBitmap   := "{c4a10980-714b-5501-8da2-dbdacce70f73}"
         , IID_IAsyncOperation_BitmapDecoder    := "{aa94d8e9-caef-53f6-823d-91b6e8340510}"
         , IID_IAsyncOperationCompletedHandler_OcrResult        := "{989c1371-444a-5e7e-b197-9eaaf9d2829a}"
         , IID_IAsyncOperationCompletedHandler_SoftwareBitmap   := "{b699b653-33ed-5e2d-a75f-02bf90e32619}"
         , IID_IAsyncOperationCompletedHandler_BitmapDecoder    := "{bb6514f2-3cfb-566f-82bc-60aabd302d53}"
         , IID_IPdfDocumentStatics := "{433A0B5F-C007-4788-90F2-08143D922599}"
         , Vtbl_GetDecoder := {bmp:6, jpg:7, jpeg:7, png:8, tiff:9, gif:10, jpegxr:11, ico:12}
         , PerformanceMode := 0
         , DisplayImage := 0

    class IBase {
        __OCR := OCR
        __New(ptr?) {
            if IsSet(ptr) {
                if !ptr
                    throw ValueError('Invalid IUnknown interface pointer', -2, this.__Class)
                else if IsObject(ptr) {
                    if ptr.HasProp("Relative")
                        this.DefineProp("Relative", {value: ptr.Relative})
                    ptr := 0
                }
            }
            this.DefineProp("ptr", {Value:ptr ?? 0})
        }
        __Delete() => this.ptr ? ObjRelease(this.ptr) : 0
    }

    static __New() {
        this.LanguageFactory := this.CreateClass("Windows.Globalization.Language", ILanguageFactory := "{9B0252AC-0C27-44F8-B792-9793FB66C63E}")
        this.SoftwareBitmapFactory := this.CreateClass("Windows.Graphics.Imaging.SoftwareBitmap", "{c99feb69-2d62-4d47-a6b3-4fdb6a07fdf8}")
        this.BitmapTransform := this.CreateClass("Windows.Graphics.Imaging.BitmapTransform")
        this.BitmapDecoderStatics := this.CreateClass("Windows.Graphics.Imaging.BitmapDecoder", IBitmapDecoderStatics := "{438CCB26-BCEF-4E95-BAD6-23A822E58D01}")
        this.BitmapEncoderStatics := this.CreateClass("Windows.Graphics.Imaging.BitmapEncoder", IBitmapDecoderStatics := "{a74356a7-a4e4-4eb9-8e40-564de7e1ccb2}")
        this.SoftwareBitmapStatics := this.CreateClass("Windows.Graphics.Imaging.SoftwareBitmap", ISoftwareBitmapStatics := "{df0385db-672f-4a9d-806e-c2442f343e86}")
        this.OcrEngineStatics := this.CreateClass("Windows.Media.Ocr.OcrEngine", IOcrEngineStatics := "{5BFFA85A-3384-3540-9940-699120D428A8}")
        ComCall(6, this.OcrEngineStatics, "uint*", &MaxImageDimension:=0)   ; MaxImageDimension
        this.MaxImageDimension := MaxImageDimension
        this.PerformanceMode := 1
        DllCall("Dwmapi\DwmIsCompositionEnabled", "Int*", &compositionEnabled:=0)
        this.CAPTUREBLT := compositionEnabled ? 0 : 0x40000000
        /*  // Based on code by AHK forums user Xtra
            unsigned int Convert_GrayScale(unsigned int bitmap[], unsigned int w, unsigned int h, unsigned int Stride)
            {
                unsigned int a, r, g, b, gray, ARGB;
                unsigned int x, y, offset = Stride/4;
                for (y = 0; y < h * offset; y += offset) {
                    for (x = 0; x < w; ++x) {
                        ARGB = bitmap[x+y];
                        a = ARGB & 0xFF000000;
                        r = (ARGB & 0x00FF0000) >> 16;
                        g = (ARGB & 0x0000FF00) >> 8;
                        b = (ARGB & 0x000000FF);
                        gray = ((300 * r) + (590 * g) + (110 * b)) >> 10;
                        bitmap[x+y] = (gray << 16) | (gray << 8) | gray | a;
                    }
                }
                return 0;
            }
         */
        this.GrayScaleMCode := this.MCode((A_PtrSize = 4) 
        ? "2,x86:VVdWU4PsCIt8JCiLdCQki0QkIMHvAg+v94k0JIX2dH+FwHR7jTS9AAAAAIl0JASLdCQcjRyGMfaNtCYAAAAAkItEJByNDLCNtCYAAAAAZpCLEYPBBInQD7buwegQae1OAgAAD7bAacAsAQAAAegPtuqB4gAAAP9r7W4B6MHoConFCcLB4AjB5RAJ6gnQiUH8Odl1vAH+A1wkBDs0JHKhg8QIMcBbXl9dww==" 
        : "2,x64:V1ZTQcHpAkSJxkiJy0GJ00EPr/GF9nRnRTHAhdJ0YJBEicEPH0QAAInIg8EBTI0Ug0GLEonQD7b+wegQaf9OAgAAD7bAacAsAQAAAfgPtvqB4gAAAP9r/24B+MHoConHCcLB4AjB5xAJ+gnCQYkSRDnZdbRFAchFActBOfByoTHAW15fww==")
        /*
            unsigned int Invert_Colors(unsigned int bitmap[], unsigned int w, unsigned int h, unsigned int Stride)
            {
                unsigned int a, r, g, b, gray, ARGB;
                unsigned int x, y, offset = Stride/4;
                for (y = 0; y < h * offset; y += offset) {
                    for (x = 0; x < w; ++x) {
                        ARGB = bitmap[x+y];
                        a = ARGB & 0xFF000000;
                        r = (ARGB & 0x00FF0000) >> 16;
                        g = (ARGB & 0x0000FF00) >> 8;
                        b = (ARGB & 0x000000FF);
                        bitmap[x+y] = ((255-r) << 16) | ((255-g) << 8) | (255-b) | a;
                    }
                }
                return 0;
            }
        */
        this.InvertColorsMCode := this.MCode((A_PtrSize = 4)
        ? "2,x86:VVdWU4PsCItsJCiLfCQki0QkIMHtAg+v/Yk8JIX/dGeFwHRjjTytAAAAAIl8JASLfCQcjTSHMf+NtCYAAAAAkItEJByNDLiNtCYAAAAAZpCLEYPBBInQidOB4v8AAP/30PfTgPL/JQAA/wCB4wD/AAAJ2AnQiUH8OfF11AHvA3QkBDs8JHK5g8QIMcBbXl9dww=="
        : "2,x64:V1ZTQcHpAkSJx0iJzonTQQ+v+YX/dFNFMcCF0nRMZpBEicEPH0QAAInIg8EBTI0chkGLE4nQQYnSgeL/AAD/99BB99KA8v8lAAD/AEGB4gD/AABECdAJ0EGJAznLdclFAchEActBOfhytjHAW15fww==")
        /*
            unsigned int Convert_Monochrome(unsigned int bitmap[], unsigned int w, unsigned int h, unsigned int Stride, unsigned int threshold)
            {
                unsigned int a, r, g, b, ARGB;
                unsigned int x, y, offset = Stride / 4;
                for (y = 0; y < h * offset; y += offset) {
                    for (x = 0; x < w; ++x) {
                        ARGB = bitmap[x + y];
                        a = ARGB & 0xFF000000;
                        r = (ARGB & 0x00FF0000) >> 16;
                        g = (ARGB & 0x0000FF00) >> 8;
                        b = (ARGB & 0x000000FF);
                        unsigned int luminance = (77 * r + 150 * g + 29 * b) >> 8;
                        bitmap[x + y] = (luminance > threshold) ? 0xFFFFFFFF : 0xFF000000;
                    }
                }
                return 0;
            }
        */
        this.MonochromeMCode := this.MCode((A_PtrSize = 4)
        ? "2,x86:VVdWU4PsDIt0JCyLTCQoi0QkJIt8JDDB7gIPr86JNCSJTCQEhcl0aYXAdGXB5gIx7Yl0JAiLdCQgjTSGjXQmAItEJCCNDKiNtCYAAAAAZpCLEYnTD7bGD7bSwesQacCWAAAAD7bba9Ida9tNAdgB0MHoCDn4dinHAf////+DwQQ58XXMAywkA3QkCDlsJAR3r4PEDDHAW15fXcONdCYAkMcBAAAA/4PBBDnxdaMDLCQDdCQIOWwkBHeG69U="
        : "2,x64:VVdWU4t0JEhBwekCRInHSInLQYnTQQ+v+YX/dFyF0nRYRTHADx9AAESJwQ8fRAAAichMjRSDQYsSidUPtsYPttLB7RBpwJYAAABAD7bta9Ida+1NAegB0MHoCDnwdiGDwQFBxwL/////QTnLdcJFAchFActEOcd3rzHAW15fXcODwQFBxwIAAAD/RDnZdaFFAchFActEOcd3juvd")
    }

    /**
     * Returns an OCR results object for an IRandomAccessStream.
     * Images of other types should be first converted to this format (eg from file, from bitmap).
     * @param RandomAccessStreamOrSoftwareBitmap Pointer or an object containing a ptr to a RandomAccessStream or SoftwareBitmap
     * @param {String} lang OCR language. Default is first from available languages.
     * @param {Integer|Object} transform Either a scale factor number, or an object {scale:Float, grayscale:Boolean, invertcolors:Boolean, monochrome:0-255, rotate: 0 | 90 | 180 | 270, flip: 0 | "x" | "y"}
     * @param {String} decoder Optional bitmap codec name to decode RandomAccessStream. Default is automatic detection.
     *  Possible values are gif, ico, jpeg, jpegxr, png, tiff, bmp.
     * @returns {OCR.Result} 
     */
    static Call(RandomAccessStreamOrSoftwareBitmap, Options:=0) {
        local SoftwareBitmap := 0, RandomAccessStream := 0, lang:="FirstFromAvailableLanguages", width, height, x := 0, y := 0, w := 0, h := 0, scale, grayscale, invertcolors, monochrome, OcrResult := this.Result(), Result, transform := 0, decoder := 0
        this.__ExtractTransformParameters(Options, &transform)
        scale := transform.scale, grayscale := transform.grayscale, invertcolors := transform.invertcolors, monochrome := transform.monochrome, rotate := transform.rotate, flip := transform.flip
        this.__ExtractNamedParameters(Options, "x", &x, "y", &y, "w", &w, "h", &h, "language", &lang, "lang", &lang, "decoder", &decoder)
        this.LoadLanguage(lang)
        local customRegion := x || y || w || h

        try SoftwareBitmap := ComObjQuery(RandomAccessStreamOrSoftwareBitmap, "{689e0708-7eef-483f-963f-da938818e073}") ; ISoftwareBitmap
        if SoftwareBitmap {
            ComCall(8, SoftwareBitmap, "uint*", &width:=0)   ; get_PixelWidth
            ComCall(9, SoftwareBitmap, "uint*", &height:=0)   ; get_PixelHeight
            this.ImageWidth := width, this.ImageHeight := height
            if (Floor(width*scale) > this.MaxImageDimension) or (Floor(height*scale) > this.MaxImageDimension)
               throw ValueError("Image is too big - " width "x" height ".`nIt should be maximum - " this.MaxImageDimension " pixels (with scale applied)")
            if scale != 1 || customRegion || rotate || flip
                SoftwareBitmap := this.TransformSoftwareBitmap(SoftwareBitmap, &width, &height, scale, rotate, flip, x?, y?, w?, h?)
            goto SoftwareBitmapCommon
        }
        RandomAccessStream := RandomAccessStreamOrSoftwareBitmap

        if decoder {
            ComCall(this.Vtbl_GetDecoder.%decoder%, this.BitmapDecoderStatics, "ptr", DecoderGUID:=Buffer(16))
            ComCall(15, this.BitmapDecoderStatics, "ptr", DecoderGUID, "ptr", RandomAccessStream, "ptr*", BitmapDecoder:=ComValue(13,0))   ; CreateAsync
        } else
            ComCall(14, this.BitmapDecoderStatics, "ptr", RandomAccessStream, "ptr*", BitmapDecoder:=ComValue(13,0))   ; CreateAsync
            this.WaitForAsync(&BitmapDecoder)

        BitmapFrame := ComObjQuery(BitmapDecoder, IBitmapFrame := "{72A49A1C-8081-438D-91BC-94ECFC8185C6}")
        ComCall(12, BitmapFrame, "uint*", &width:=0)   ; get_PixelWidth
        ComCall(13, BitmapFrame, "uint*", &height:=0)   ; get_PixelHeight
        if (width > this.MaxImageDimension) or (height > this.MaxImageDimension)
           throw ValueError("Image is too big - " width "x" height ".`nIt should be maximum - " this.MaxImageDimension " pixels")

        BitmapFrameWithSoftwareBitmap := ComObjQuery(BitmapDecoder, IBitmapFrameWithSoftwareBitmap := "{FE287C9A-420C-4963-87AD-691436E08383}")
        OcrResult.ImageWidth := width, OcrResult.ImageHeight := height
        if !(customRegion || rotate || flip) && (width < 40 || height < 40 || scale != 1) {
            scale := scale = 1 ? 40.0 / Min(width, height) : scale
            ComCall(7, this.BitmapTransform, "int", width := Floor(width*scale)) ; put_ScaledWidth
            ComCall(9, this.BitmapTransform, "int", height := Floor(height*scale)) ; put_ScaledHeight
            ComCall(8, BitmapFrame, "uint*", &BitmapPixelFormat:=0) ; get_BitmapPixelFormat
            ComCall(9, BitmapFrame, "uint*", &BitmapAlphaMode:=0) ; get_BitmapAlphaMode
            ComCall(8, BitmapFrameWithSoftwareBitmap, "uint", BitmapPixelFormat, "uint", BitmapAlphaMode, "ptr", this.BitmapTransform, "uint", IgnoreExifOrientation := 0, "uint", DoNotColorManage := 0, "ptr*", SoftwareBitmap:=this.IBase()) ; GetSoftwareBitmapAsync
        } else {
            ComCall(6, BitmapFrameWithSoftwareBitmap, "ptr*", SoftwareBitmap:=this.IBase())   ; GetSoftwareBitmapAsync
        }
        this.WaitForAsync(&SoftwareBitmap)
        if customRegion || rotate || flip || scale != 1
            SoftwareBitmap := this.TransformSoftwareBitmap(SoftwareBitmap, &width, &height, scale, rotate, flip, x?, y?, w?, h?)

        SoftwareBitmapCommon:

        if (grayscale || invertcolors || monochrome || this.DisplayImage) {
            ComCall(15, SoftwareBitmap, "int", 2, "ptr*", &BitmapBuffer := 0) ; LockBuffer
            MemoryBuffer := ComObjQuery(BitmapBuffer, "{fbc4dd2a-245b-11e4-af98-689423260cf8}")
            ComCall(6, MemoryBuffer, "ptr*", &MemoryBufferReference := 0) ; CreateReference
            BufferByteAccess := ComObjQuery(MemoryBufferReference, "{5b0d3235-4dba-4d44-865e-8f1d0e4fd04d}")
            ComCall(3, BufferByteAccess, "ptr*", &SoftwareBitmapByteBuffer:=0, "uint*", &BufferSize:=0) ; GetBuffer
           
            if grayscale
                DllCall(this.GrayScaleMCode, "ptr", SoftwareBitmapByteBuffer, "uint", width, "uint", height, "uint", (width*4+3) // 4 * 4, "cdecl uint")

            if monochrome
                DllCall(this.MonochromeMCode, "ptr", SoftwareBitmapByteBuffer, "uint", width, "uint", height, "uint", (width*4+3) // 4 * 4, "uint", monochrome, "cdecl uint")
            
            if invertcolors
                DllCall(this.InvertColorsMCode, "ptr", SoftwareBitmapByteBuffer, "uint", width, "uint", height, "uint", (width*4+3) // 4 * 4, "cdecl uint")
    
            if this.DisplayImage {
                local hdc := DllCall("GetDC", "ptr", 0, "ptr"), bi := Buffer(40, 0), hbm
                NumPut("uint", 40, "int", width, "int", -height, "ushort", 1, "ushort", 32, bi)
                hbm := DllCall("CreateDIBSection", "ptr", hdc, "ptr", bi, "uint", 0, "ptr*", &ppvBits:=0, "ptr", 0, "uint", 0, "ptr")
                DllCall("ntdll\memcpy", "ptr", ppvBits, "ptr", SoftwareBitmapByteBuffer, "uint", BufferSize, "cdecl")
                DllCall("ReleaseDC", "Ptr", 0, "Ptr", hdc, "Int")
                this.DisplayHBitmap(hbm)
            }
            
            BufferByteAccess := "", ObjRelease(MemoryBufferReference), MemoryBuffer := "", ObjRelease(BitmapBuffer) ; Release in correct order
        }

        ComCall(6, this.OcrEngine, "ptr", SoftwareBitmap, "ptr*", Result:=ComValue(13,0))   ; RecognizeAsync
        this.WaitForAsync(&Result)
        OcrResult.Ptr := Result.Ptr, ObjAddRef(OcrResult.ptr)

        ; Cleanup
        if RandomAccessStream is this.IBase
            this.CloseIClosable(RandomAccessStream)
        if SoftwareBitmap is this.IBase
            this.CloseIClosable(SoftwareBitmap)

        if scale != 1 || x != 0 || y != 0
            this.NormalizeCoordinates(OcrResult, scale, x, y)

        return OcrResult
    }

    static ClearAllHighlights() => this.Result.Prototype.Highlight("clearall")

    class Result extends OCR.Common {
        ; Gets the recognized text.
        Text {
            get {
                ComCall(8, this, "ptr*", &hAllText:=0)   ; get_Text
                buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hAllText, "uint*", &length:=0, "ptr")
                this.DefineProp("Text", {Value:StrGet(buf, "UTF-16")})
                this.__OCR.DeleteHString(hAllText)
                return this.Text
            }
        }

        ; Gets the clockwise rotation of the recognized text, in degrees, around the center of the image.
        TextAngle {
            get => (ComCall(7, this, "double*", &value:=0), value)
        }

        ; Returns all Line objects for the result.
        Lines {
            get {
                ComCall(6, this, "ptr*", LinesList:=ComValue(13, 0)) ; get_Lines
                ComCall(7, LinesList, "int*", &count:=0) ; count
                lines := []
                loop count {
                    ComCall(6, LinesList, "int", A_Index-1, "ptr*", Line:=this.__OCR.Line(this)) 
                    lines.Push(Line)
                }
                this.DefineProp("Lines", {Value:lines})
                return lines
            }
        }

        ; Returns all Word objects for the result. Equivalent to looping over all the Lines and getting the Words.
        Words {
            get {
                local words := [], line, word
                for line in this.Lines
                    for word in line.Words
                        words.Push(word)
                this.DefineProp("Words", {Value:words})
                return words
            }
        }

        BoundingRect {
            get => this.DefineProp("BoundingRect", {Value:this.__OCR.WordsBoundingRect(this.Words*)}).BoundingRect
        }

        /**
         * Finds a string in the search results, and returns a new Result object.
         * If the match is partial then the result will contain the whole word: in "hello world" searching "wo" will return "world".
         * To force a full word search instead of a partial search, use IgnoreLinebreaks:True 
         *  and add a space to the beginning and end: " hello "
         * To search multi-line matches, set IgnoreLinebreaks:True and use a linebreak in the needle: "hello`nworld"
         * @param Needle The string to find. 
         * @param Options Extra search options object, which can contain the following properties:
         *  CaseSense: False (this is ignored if a custom SearchFunc is used)
         *  IgnoreLinebreaks: False (if this is True, then linebreaks are converted to whitespaces, otherwise remain `n)
         *  AllowOverlap: False (if True then the needle can overlap itself)
         *  i: 1 (which occurrence of the needle to find)
         *  x, y, w, h: defines the search area inside the result object
         *  SearchFunc: default is InStr, but if a custom function is provided then it needs to return
         *      the needle location in the haystack, and accept arguments (Haystack, Needle, &FoundMatch)
         *      This can used for example to perform a RegEx search by providing RegExMatch
         * @returns {Object} 
         */
        FindString(Needle, Options := "") => this.__FindString(Needle, Options, 0)

        /**
         * Finds all strings matching the needle in the search results. Returns an array of Result objects.
         * @param Needle The string to find. 
         * @param Options See Result.FindString. {CaseSense: False, IgnoreLinebreaks: False, AllowOverlap: false, i: 1, x, y, w, h, SearchFunc}
         *  If i is specified then the result object will contains matches starting from i.
         * @returns {Array} 
         */
        FindStrings(Needle, Options := "") => this.__FindString(Needle, Options, true)

        __FindString(Needle, Options, All) {
            local CaseSense := false, IgnoreLinebreaks := false, AllowOverlap := false, i := 1, SearchFunc, x, y, w, h
            local currentHaystack, fullHaystackLinebreaks := "`n", offset := 0, line, counter := 0, x1, y1, x2, y2, result, results := [], word

            if !(Needle is String)
                throw TypeError("Needle is required to be a string, not type " Type(Needle), -1)
            if Trim(Needle, " `t`n`r") == ""
                throw ValueError("Needle cannot be an empty string", -1)

            this.__OCR.__ExtractNamedParameters(Options, "CaseSense", &CaseSense, "IgnoreLinebreaks", &IgnoreLinebreaks, "AllowOverlap", &AllowOverlap, "i", &i, "SearchFunc", &SearchFunc, "x", &x, "y", &y, "w", &w, "h", &h)

            if !IsSet(SearchFunc)
                SearchFunc := (haystack, needle, &foundstr) => (pos := InStr(haystack, needle, casesense), foundstr := SubStr(haystack, pos, StrLen(needle)), pos)

            if (IsSet(x) || IsSet(y) || IsSet(w) || IsSet(h)) {
                x1 := x ?? -100000, y1 := y ?? -100000, x2 := IsSet(w) ? x + w : 100000, y2 := IsSet(h) ? y + h : 100000 
            }

            tokenizedHaystack := [IgnoreLinebreaks ? " " : "`n"]
            for Line in this.Lines {
                fullHaystackLinebreaks .= line.Text "`n"
                for Word in Line.Words
                    tokenizedHaystack.Push(Word, " ")
                tokenizedHaystack.Pop()
                tokenizedHaystack.Push(IgnoreLinebreaks ? " " : "`n")
            }

            fullHaystackNoLinebreaks := StrReplace(fullHaystackLinebreaks, "`n", " ") ; Make sure the words are in the same order as the tokenized version
            fullHaystack := IgnoreLinebreaks ? fullHaystackNoLinebreaks : fullHaystackLinebreaks

            Needle := RegExReplace(StrReplace(Needle, "`t", " "), " +", " ")

            fullFirst := SubStr(Needle, 1, 1) ~= "[ \n]", fullLast := SubStr(Needle, -1, 1) ~= "[ \n]"

            currentHaystack := fullHaystack
            Loop {
                if !(loc := SearchFunc(currentHaystack, Needle, &foundNeedle))
                    break

                if IsObject(foundNeedle)
                    foundNeedle := foundNeedle[]

                foundLen := AllowOverlap ? 1 : StrLen(foundNeedle)
                currentHaystack := SubStr(currentHaystack, loc + foundLen) ; Remove the match from the haystack, allowing overlap
                offset += loc + foundLen - 1

                if ++counter < i
                    continue

                tokenizedNeedle := []
                ; Tokenize the needle
                for wsNeedle in wsSplit := StrSplit(foundNeedle, " ") {
                    for lbNeedle in lbSplit := StrSplit(wsNeedle, "`n") {
                        tokenizedNeedle.Push(lbNeedle, "`n")
                    }
                    if lbSplit.Length
                        tokenizedNeedle.Pop()
                    tokenizedNeedle.Push(" ")
                }
                tokenizedNeedle.Pop()
                
                preceding := SubStr(fullHaystackNoLinebreaks, 1, offset - foundLen)
                ; Find first Word location
                StrReplace(preceding, " ",,, &startingWord:=0)
                startingWord := startingWord*2 + fullFirst - 1 ; Substracted 1 to allow subsequent loop to just add A_Index

                foundNeedle := "", foundWords := [], foundLines := [], line := this.__OCR.Line(this), line.DefineProp("Words", {value:[]}), line.DefineProp("Text", {value:""})
                Loop tokenizedNeedle.Length {
                    word := tokenizedHaystack[startingWord + A_Index]
                    if (word == "`n") {
                        foundNeedle .= line.Text
                        line.Text := RTrim(line.Text), foundLines.Push(line)
                        line := this.__OCR.Line(this), line.DefineProp("Words", {value:[]}), line.DefineProp("Text", {value:""})
                    }
                    if !IsObject(word)
                        continue
                    If IsSet(x1) && (word.x < x1 || word.y < y1 || word.x+word.w > x2 || word.y+word.h > y2) {
                        counter--
                        continue 2
                    }
                    line.Words.Push(word), line.Text .= word.Text " "
                    foundWords.Push(word)
                }
                if line.Text {
                    foundNeedle .= line.Text
                    line.Text := RTrim(line.Text), foundLines.Push(line)
                }

                result := this.Clone(), ObjAddRef(this.ptr)
                result.DefineProp("BoundingRect", {value: this.__OCR.WordsBoundingRect(foundWords*)})
                result.DefineProp("Lines", {value: foundLines})
                result.DefineProp("Words", {value: foundWords})
                result.DefineProp("Text", {value: foundNeedle})
                if All {
                    results.Push(result)
                } else
                    return result
            }
            if All
                return results

            throw TargetError('The target string "' Needle '" was not found', -1)
        }
    
        /**
         * Filters out all the words that do not satisfy the callback function and returns a new OCR.Result object
         * @param {Object} callback The callback function that accepts a OCR.Word object.
         * If the callback returns 0 then the word is filtered out (rejected), otherwise is kept.
         * @returns {OCR.Result}
         */
        Filter(callback) {
            if !HasMethod(callback)
                throw ValueError("Filter callback must be a function", -1)
            local result := this.Clone(), line, croppedLines := [], croppedText := "", croppedWords := [], lineText := "", word
            ObjAddRef(result.ptr)
            for line in result.Lines {
                croppedWords := [], lineText := ""
                for word in line.Words {
                    if callback(word)
                        croppedWords.Push(word), lineText .= word.Text " "
                }
                if croppedWords.Length {
                    line := this.__OCR.Line()
                    line.DefineProp("Text", {value:Trim(lineText)})
                    line.DefineProp("Words", {value:croppedWords})
                    croppedLines.Push(line)
                    croppedText .= lineText
                }
            }
            result.DefineProp("Lines", {Value:croppedLines})
            result.DefineProp("Text", {Value:Trim(croppedText)})
            result.DefineProp("Words", this.__OCR.Result.Prototype.GetOwnPropDesc("Words"))
            return result
        }
    
        /**
         * Crops the result object to contain only results from an area defined by points (x1,y1) and (x2,y2).
         * Note that these coordinates are relative to the result object, not to the screen.
         * @param {Integer} x1 x coordinate of the top left corner of the search area
         * @param {Integer} y1 y coordinate of the top left corner of the search area
         * @param {Integer} x2 x coordinate of the bottom right corner of the search area
         * @param {Integer} y2 y coordinate of the bottom right corner of the search area
         * @returns {OCR.Result}
         */
        Crop(x1:=-100000, y1:=-100000, x2:=100000, y2:=100000) => this.Filter((word) => word.x >= x1 && word.y >= y1 && (word.x+word.w) <= x2 && (word.y+word.h) <= y2)
    }
    class Line extends OCR.Common {
        ; Gets the recognized text for the line.
        Text {
            get {
                ComCall(7, this, "ptr*", &hText:=0)   ; get_Text
                buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr")
                text := StrGet(buf, "UTF-16")
                this.__OCR.DeleteHString(hText)
                this.DefineProp("Text", {Value:text})
                return text
            }
        }

        ; Gets the Word objects for the line
        Words {
            get {
                ComCall(6, this, "ptr*", WordsList:=ComValue(13, 0))   ; get_Words
                ComCall(7, WordsList, "int*", &WordsCount:=0)   ; Words count
                words := []
                loop WordsCount {
                   ComCall(6, WordsList, "int", A_Index-1, "ptr*", Word:=this.__OCR.Word(this))
                   words.Push(Word)
                }
                this.DefineProp("Words", {Value:words})
                return words
            }
        }

        BoundingRect {
            get => this.DefineProp("BoundingRect", {Value:this.__OCR.WordsBoundingRect(this.Words*)}).BoundingRect
        }
    }

    class Word extends OCR.Common {
        ; Gets the recognized text for the word
        Text {
            get {
                ComCall(7, this, "ptr*", &hText:=0)   ; get_Text
                buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length:=0, "ptr")
                text := StrGet(buf, "UTF-16")
                this.__OCR.DeleteHString(hText)
                this.DefineProp("Text", {Value:text})
                return text
            }
        }

        /**
         * Gets the bounding rectangle of the text in {x,y,w,h} format. 
         * The bounding rectangles coordinate system will be dependant on the image capture method.
         * For example, if the image was captured as a rectangle from the screen, then the coordinates
         * will be relative to the left top corner of the screen.
         */
        BoundingRect {
            get {
                ComCall(6, this, "ptr", RECT := Buffer(16, 0))   ; get_BoundingRect
                this.DefineProp("x", {Value:Integer(NumGet(RECT, 0, "float"))})
                , this.DefineProp("y", {Value:Integer(NumGet(RECT, 4, "float"))})
                , this.DefineProp("w", {Value:Integer(NumGet(RECT, 8, "float"))})
                , this.DefineProp("h", {Value:Integer(NumGet(RECT, 12, "float"))})
                return this.DefineProp("BoundingRect", {Value:{x:this.x, y:this.y, w:this.w, h:this.h}}).BoundingRect
            }
        }
    }

    class Common extends OCR.IBase {
        x {
            get => this.BoundingRect.x
        } 
        y {
            get => this.BoundingRect.y
        }
        w {
            get => this.BoundingRect.w
        }
        h {
            get => this.BoundingRect.h
        }
    
        /**
         * Highlights the object on the screen with a red box
         * @param {number} showTime Default is 2 seconds.
         * * Unset - if highlighting exists then removes the highlighting, otherwise pauses for 2 seconds
         * * 0 - Indefinite highlighting
         * * Positive integer (eg 2000) - will highlight and pause for the specified amount of time in ms
         * * Negative integer - will highlight for the specified amount of time in ms, but script execution will continue
         * * "clear" - removes the highlighting unconditionally
         * * "clearall" - remove highlightings from all OCR objects
         * @param {string} color The color of the highlighting. Default is red.
         * @param {number} d The border thickness of the highlighting in pixels. Default is 2.
         * @returns {OCR.Result}
         */
        Highlight(showTime?, color:="Red", d:=2) {
            static Guis := Map()
            local x, y, w, h, key, oObj, GuiObj, iw, ih
            ; showTime unset => either highlights for 2s, or removes highlight
            ; showTime clear => removes highlight
            if IsSet(showTime) {
                if showTime = "clearall" {
                    for key, oObj in Guis { ; enum all OCR result objects
                        try oObj.GuiObj.Destroy()
                        SetTimer(oObj.TimerObj, 0)
                    }
                    Guis := Map()
                    return this
                } else if showTime = "clear" {
                    if Guis.Has(this) {
                        try Guis[this].GuiObj.Destroy()
                        SetTimer(Guis[this].TimerObj, 0)
                        Guis.Delete(this)
                    }
                    return this
                }
            }
    
            if !IsSet(showTime) {
                if Guis.Has(this) {
                    try Guis[this].GuiObj.Destroy()
                    SetTimer(Guis[this].TimerObj, 0)
                    Guis.Delete(this)
                    return this
                } else
                    showTime := 2000
            }
    
            x := this.x, y := this.y, w := this.w, h := this.h
            if this.HasProp("Relative") {
                if this.Relative.HasProp("CoordMode") {
                    if this.Relative.CoordMode = "Client"
                        WinGetClientPos(&rX, &rY,,, this.Relative.hWnd), x += rX, y += rY
                    else if this.Relative.CoordMode = "Window"
                        WinGetPos(&rX, &rY,,, this.Relative.hWnd), x += rX, y += rY
                }
                x += this.Relative.HasProp("x") ? this.Relative.x : 0
                y += this.Relative.HasProp("y") ? this.Relative.y : 0
            }
    
            if !Guis.Has(this) {
                Guis[this] := {}
                Guis[this].GuiObj := Gui("-Caption +ToolWindow -DPIScale +E0x08000000")
                Guis[this].TimerObj := ObjBindMethod(this, "Highlight", "clear")
            }
            GuiObj := Guis[this].GuiObj
            GuiObj.BackColor := color
            iw:= w+d, ih:= h+d, w:=w+d*2, h:=h+d*2, x:=x-d, y:=y-d
            WinSetRegion("0-0 " w "-0 " w "-" h " 0-" h " 0-0 " d "-" d " " iw "-" d " " iw "-" ih " " d "-" ih " " d "-" d, GuiObj.Hwnd)
            GuiObj.Show("NA x" . x . " y" . y . " w" . w . " h" . h)
    
            if showTime > 0 {
                Sleep(showTime)
                this.Highlight()
            } else if showTime < 0
                SetTimer(Guis[this].TimerObj, -Abs(showTime))
            return this
        }
        ClearHighlight() => this.Highlight("clear")
    
        /**
         * Clicks an object
         * If this object (the one Click is called from) contains a "Relative" property (this is
         * added by default with OCR.FromWindow) containing a hWnd property, then that window will be activated,
         * otherwise the Relative objects x/y properties values will be added to the x and y coordinates as offsets.
         */
        Click(WhichButton?, ClickCount?, DownOrUp?) {
            local x := this.x, y := this.y, w := this.w, h := this.h, mode := "Screen", hwnd
            if this.HasProp("Relative") {
                if this.Relative.HasProp("CoordMode") {
                    if this.Relative.CoordMode = "Window"
                        mode := "Window", hwnd := this.Relative.Hwnd
                    else if this.Relative.CoordMode = "Client"
                        mode := "Client", hwnd := this.Relative.Hwnd
                    if IsSet(hwnd) && !WinActive(hwnd) {
                        WinActivate(hwnd)
                        WinWaitActive(hwnd,,1)
                    }
                }
                x += this.Relative.HasProp("x") ? this.Relative.x : 0
                y += this.Relative.HasProp("y") ? this.Relative.y : 0
            }
            oldCoordMode := A_CoordModeMouse
            CoordMode "Mouse", mode
            Click(x+w//2, y+h//2, WhichButton?, ClickCount?, DownOrUp?)
            CoordMode "Mouse", oldCoordMode
        }
    
        /**
         * ControlClicks an object.
         * If the result object originates from OCR.FromWindow which captured only the client area,
         * then the result object will contain correct coordinates for the ControlClick. 
         * Coordinates will be adjusted to Client area from the CoordMode that the OCR happened in.
         * Otherwise, if additionally a WinTitle is provided then the coordinates are treated as Screen 
         * coordinates and converted to Client coordinates.
         * @param WinTitle If WinTitle is set, then the coordinates stored in Obj will be converted to
         * client coordinates and ControlClicked.
         */
        ControlClick(WinTitle?, WinText?, WhichButton?, ClickCount?, Options?, ExcludeTitle?, ExcludeText?) {
            local x := this.x, y := this.y, w := this.w, h := this.h, hWnd
            if this.HasProp("Relative") {
                x += this.Relative.HasProp("x") ? this.Relative.x : 0
                y += this.Relative.HasProp("y") ? this.Relative.y : 0
            }
            if this.HasProp("Relative") && this.Relative.HasProp("CoordMode") && (this.Relative.CoordMode = "Client" || this.Relative.CoordMode = "Window") {
                mode := this.Relative.CoordMode, hWnd := this.Relative.hWnd
                if mode = "Window" {
                    ; Window -> Client
                    RECT := Buffer(16, 0), pt := Buffer(8, 0)
                    DllCall("user32\GetWindowRect", "Ptr", hWnd, "Ptr", RECT)
                    winX := NumGet(RECT, 0, "Int"), winY := NumGet(RECT, 4, "Int")
                    NumPut("int", winX+x, "int", winY+y, pt)
                    DllCall("user32\ScreenToClient", "Ptr", hWnd, "Ptr", pt)
                    x := NumGet(pt,0,"int"), y := NumGet(pt,4,"int")
                }
            } else if IsSet(WinTitle) {
                hWnd := WinExist(WinTitle, WinText?, ExcludeTitle?, ExcludeText?)
                pt := Buffer(8), NumPut("int",x,pt), NumPut("int", y,pt,4)
                DllCall("ScreenToClient", "Int", Hwnd, "Ptr", pt)
                x := NumGet(pt,0,"int"), y := NumGet(pt,4,"int")
            } else
                throw TargetError("ControlClick needs to be called either after a OCR.FromWindow result or with a WinTitle argument")
                
            ControlClick("X" (x+w//2) " Y" (y+h//2), hWnd,, WhichButton?, ClickCount?, Options?)
        }
    
        OffsetCoordinates(offsetX?, offsetY?) {
            if !IsSet(offsetX) || !IsSet(offsetY) {
                if this.HasOwnProp("Relative") {
                    offsetX := this.Relative.HasProp("x") ? this.Relative.X : 0
                    offsetY := this.Relative.HasProp("y") ? this.Relative.Y : 0
                } else
                    throw Error("No Relative property found",, -1)
            }
            if offsetX = 0 && offsetY = 0
                return this
            local word
            for word in this.Words
                word.x += offsetX, word.y += offsetY, word.BoundingRect := {X:word.x, Y:word.y, W:word.w, H:word.h}
            return this
        }
    }

    /**
     * Returns an OCR results object for an image file. Locations of the words will be relative to
     * the top left corner of the image.
     * @param FileName Either full or relative (to A_WorkingDir) path to the file.
     * @param lang OCR language. Default is first from available languages.
     * @param transform Either a scale factor number, or an object {scale:Float, grayscale:Boolean, invertcolors:Boolean, monochrome:0-255, rotate: 0 | 90 | 180 | 270, flip: 0 | "x" | "y"}
     * @returns {OCR.Result} 
     */
    static FromFile(FileName, Options:=0) {
        if !(fe := FileExist(FileName)) or InStr(fe, "D")
            throw TargetError("File `"" FileName "`" doesn't exist", -1)
        GUID := this.CLSIDFromString(this.IID_IRandomAccessStream)
        DllCall("ShCore\CreateRandomAccessStreamOnFile", "wstr", FileName, "uint", Read := 0, "ptr", GUID, "ptr*", IRandomAccessStream:=this.IBase())
        if IsObject(Options) && !Options.HasProp("Decoder")
            Options.Decoder := this.Vtbl_GetDecoder.HasOwnProp(ext := StrSplit(FileName, ".")[-1]) ? ext : ""
        return this(IRandomAccessStream, Options)
    }

    /**
     * Returns an array of OCR results objects for a PDF file. Locations of the words will be relative to
     * the top left corner of the PDF page.
     * @param FileName Either full or relative (to A_WorkingDir) path to the file.
     * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. 
     * @param Start Optional: Page number to start from. Default is first page.
     * @param End Optional: Page number to end with (included). Default is last page.
     * @param Password Optional: PDF password.
     * @returns {OCR.Result} 
     */
    static FromPDF(FileName, Options:=0, Start:=1, End?, Password:="") {
        this.__ExtractNamedParameters(Options, "lang", &lang, "start", &Start, "end", &End, "password", &Password)
        if !(fe := FileExist(FileName)) or InStr(fe, "D")
            throw TargetError("File `"" FileName "`" doesn't exist", -1)

        DllCall("ShCore\CreateRandomAccessStreamOnFile", "wstr", FileName, "uint", Read := 0, "ptr", GUID := this.CLSIDFromString(this.IID_IRandomAccessStream), "ptr*", IRandomAccessStream:=ComValue(13,0))
        PdfDocument := this.__OpenPdfDocument(IRandomAccessStream, Password)
        this.CloseIClosable(IRandomAccessStream)
        if !IsSet(End) {
            ComCall(7, PdfDocument, "uint*", &End:=0) ; GetPageCount
            if !End
                throw Error("Unable to get PDF page count", -1)
        }
        local results := []
        Loop (End+1-Start)
            results.Push(this.FromPDFPage(PdfDocument, Start+(A_Index-1), Options))
        return results
    }

    static GetPdfPageCount(FileName, Password:="") {
        DllCall("ShCore\CreateRandomAccessStreamOnFile", "wstr", FileName, "uint", Read := 0, "ptr", GUID := this.CLSIDFromString(this.IID_IRandomAccessStream), "ptr*", IRandomAccessStream:=ComValue(13,0))
        PdfDocument := this.__OpenPdfDocument(IRandomAccessStream, Password)
        this.CloseIClosable(IRandomAccessStream)
        ComCall(7, PdfDocument, "uint*", &PageCount:=0) ; GetPageCount
        if !PageCount
            throw Error("Unable to get PDF page count", -1)
        
        return PageCount
    }

    ; Returns {Width, Height, Rotation, PreferredZoom}
    static GetPdfPageProperties(FileName, Page, Password:="") {
        DllCall("ShCore\CreateRandomAccessStreamOnFile", "wstr", FileName, "uint", Read := 0, "ptr", GUID := this.CLSIDFromString(this.IID_IRandomAccessStream), "ptr*", IRandomAccessStream:=ComValue(13,0))
        PdfDocument := this.__OpenPdfDocument(IRandomAccessStream, Password)
        this.CloseIClosable(IRandomAccessStream)
        ComCall(6, PdfDocument, "uint", Page-1, "ptr*", PdfPage:=ComValue(13, 0)) ; GetPage
        ComCall(10, PdfPage, "ptr*", Size:=Buffer(8, 0)) ; Size
        ComCall(12, PdfPage, "uint*", &Rotation:=0)
        ComCall(12, PdfPage, "float*", &PreferredZoom:=0)
        return {Width: NumGet(Size, 0, "float"), Height: NumGet(size, 4, "float"), Rotation: Rotation*90, PreferredZoom:PreferredZoom}
    }

    /**
     * Returns an OCR result object for a PDF page. Locations of the words will be relative to
     * the top left corner of the PDF page.
     * @param FileName Either full or relative (to A_WorkingDir) path to the file.
     * @param Page The page number to OCR.
     * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. 
     * @param Password Optional: PDF password.
     * @returns {OCR.Result} 
     */
    static FromPDFPage(FileName, Page, Options:=0, Password:="") {
        local scale := 1, x := 0, y := 0, w := 0, h := 0
        if IsObject(Options)
            Options := Options.Clone()
        this.__ExtractNamedParameters(Options, "Password", &Password, "scale", &scale, "x", &x, "y", &y, "w", &w, "h", &h)
        if FileName is String {
            if !(fe := FileExist(FileName)) or InStr(fe, "D")
                throw TargetError("File `"" FileName "`" doesn't exist", -1)
            GUID := this.CLSIDFromString(this.IID_IRandomAccessStream)
            DllCall("ShCore\CreateRandomAccessStreamOnFile", "wstr", FileName, "uint", Read := 0, "ptr", GUID, "ptr*", IRandomAccessStream:=ComValue(13, 0))
            PdfDocument := this.__OpenPdfDocument(IRandomAccessStream, Password)
        } else
            PdfDocument := FileName
        ComCall(6, PdfDocument, "uint", Page-1, "ptr*", PdfPage:=ComValue(13, 0)) ; GetPage
        InMemoryRandomAccessStream := this.CreateClass("Windows.Storage.Streams.InMemoryRandomAccessStream")
        PdfPageRenderOptions := this.CreateClass("Windows.Data.Pdf.PdfPageRenderOptions")
        ComCall(15, PdfPageRenderOptions, "uint", true) ; IsIgnoringHighContrast
        if x || y || w || h {
            rect := Buffer(16, 0), NumPut("float", x, "float", y, "float", w, "float", h, rect)
            ComCall(7, PdfPageRenderOptions, "ptr", rect) ; put_SourceRect
            Options.w := Options.w*scale, Options.h := Options.h*scale
            Options.DeleteProp("x"), Options.DeleteProp("y"), Options.DeleteProp("w"), Options.DeleteProp("h")
        }
        if (scale != 1) {
            ComCall(10, PdfPage, "ptr", Size:=Buffer(8, 0)) ; get_Size
            ComCall(9, PdfPageRenderOptions, "uint", Floor((w || NumGet(size, 0, "float"))*scale)) ; put_DestinationWidth
            ComCall(11, PdfPageRenderOptions, "uint", Floor((h || NumGet(size, 4, "float"))*scale)) ; put_DestinationHeight
            Options.DeleteProp("scale")
        }
        ComCall(7, PdfPage, "ptr", InMemoryRandomAccessStream, "ptr", PdfPageRenderOptions, "ptr*", asyncInfo:=ComValue(13, 0)) ; RenderWithOptionsToStreamAsync
        this.WaitForAsync(&asyncInfo)
        if FileName is String
            this.CloseIClosable(IRandomAccessStream)
        PdfPage := "", PdfDocument := "", IRandomAccessStream := ""
        OcrResult := this(InMemoryRandomAccessStream, Options)
        if scale != 1
            this.NormalizeCoordinates(OcrResult, scale)
        return OcrResult
    }

    /**
     * Returns an OCR results object for a given window. Locations of the words will be relative
     * using the CoordMode from A_CoordModePixel (default is Client). 
     * The window from where the image was captured is stored in Result.Relative.hWnd
     * Additionally, Result.Relative.CoordMode is stored (the A_CoordModePixel at the time of OCR).
     * @param WinTitle A window title or other criteria identifying the target window.
     * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. 
     * Additionally for FromWindow the options may include:
     *      mode:  Different methods of capturing the window. 
     *        0 = uses GetDC with BitBlt
     *        1 = same as 0 but window transparency is turned off beforehand with WinSetTransparent
     *        2 = uses PrintWindow. 
     *        3 = same as 1 but window transparency is turned off beforehand with WinSetTransparent
     *        4 = uses PrintWindow with undocumented PW_RENDERFULLCONTENT flag, allowing capture of hardware-accelerated windows
     *        5 = uses Direct3D11 from UWP Windows.Graphics.Capture (slowest option, but may work with games) 
     *             This may draw a yellow border around the target window in older Windows versions.
     * @param WinText Additional window criteria.
     * @param ExcludeTitle Additional window criteria.
     * @param ExcludeText Additional window criteria.
     * @returns {OCR.Result} 
     */
    static FromWindow(WinTitle:="", Options:=0, WinText:="", ExcludeTitle:="", ExcludeText:="") {
        local result, coordsmode := A_CoordModePixel, onlyClientArea := coordsMode = "Client", mode := 4, X := 0, Y := 0, W := 0, H := 0, sX, sY, hBitMap, hwnd, customRect := 0, transform := 0
        if !Options && Type(WinTitle) = "Object"
            Options := WinTitle, WinTitle := ""
        if IsObject(Options)
            Options := Options.Clone()
        this.__ExtractTransformParameters(Options, &transform)
        this.__ExtractNamedParameters(Options, "x", &x, "y", &y, "w", &w, "width", &w, "h", &h, "height", &h, "mode", &mode, "WinTitle", &WinTitle, "WinText", &WinText, "ExcludeTitle", &ExcludeTitle, "ExcludeText", &ExcludeText)
        this.__DeleteProps(Options, "x", "y", "w", "width", "h", "height", "scale", "mode")
        if (x !=0 || y != 0 || w != 0 || h != 0)
            customRect := 1
        if !(hWnd := WinExist(WinTitle, WinText, ExcludeTitle, ExcludeText))
            throw TargetError("Target window not found", -1)
        if DllCall("IsIconic", "uptr", hwnd)
            DllCall("ShowWindow", "uptr", hwnd, "int", 4)
        if mode < 4 && mode&1 {
            oldStyle := WinGetExStyle(hwnd), i := 0
            WinSetTransparent(255, hwnd)
            While (WinGetTransparent(hwnd) != 255 && ++i < 30)
                Sleep 100
        }

        WinGetPos(&wX, &wY, &wW, &wH, hWnd)
        If onlyClientArea {
            WinGetClientPos(&cX, &cY, &cW, &cH, hWnd)
            W := W || cW, H := H || cH, sX := X + cX, sY := Y + cY  ; Calculate final X and Y screen coordinates
        } else {
            W := W || wW, H := H || wH, sX := X + wX, sY := Y + wY
        }

        if mode = 5 {
            /*
                If we are capturing the whole window, then WinGetPos/MouseGetPos might include hidden borders.
                Eg (0,0) might be (-11, -11) for Direct3D, meaning (11,11) by WinGetPos is (0,0) for Direct3D.
                These offsets are calculated and stored in offsetX, offsetY, and if only the window
                area is captured then the result object coordinates are adjusted accordingly.

                If the SoftwareBitmap needs to be transformed in any way (eg scale or custom rect is
                provided) then we need to offset coordinates and possibly width/height as well.

            */
            SoftwareBitmap := this.CreateDirect3DSoftwareBitmapFromWindow(hWnd)

            local sbW := SoftwareBitmap.W, sbH := SoftwareBitmap.H, sbX := SoftwareBitmap.X, sbY := SoftwareBitmap.Y
            local offsetX := 0, offsetY := 0

            if transform.scale != 1 || transform.rotate || transform.flip || customRect || onlyClientArea {
                ; The bounds need to fit inside the SoftwareBitmap bounds, so possibly X,Y need to be adjusted along with W,H
                local tX := X, tY := Y, tW := W, tH := H
                if onlyClientArea
                    tX -= SoftwareBitmap.X-cX, tY -= SoftwareBitmap.Y-cY
                else
                    tX -= SoftwareBitmap.X-wX, tY -= SoftwareBitmap.Y-wY
                if tX < 0 ; If resulting coordinates are negative then adjust width and height accordingly 
                    tW += tX, offsetX := -tX, tX := 0
                if tY < 0
                    tH += tY, offsetY := -tY, tY := 0
                tW := Min(sbW-tX, tW), tH := Min(sbH-tY, tH)

                SoftwareBitmap := this.TransformSoftwareBitmap(SoftwareBitmap, &sbW, &sbH, transform.scale, transform.rotate, transform.flip, tX, tY, tW, tH)
                this.__DeleteProps(Options, "scale", "rotate", "flip")
            } else
                offsetX := sbX-wX, offsetY := sbY-wY
            result := this(SoftwareBitmap, Options)
        } else {
            hBitMap := this.CreateHBitmap(X, Y, W, H, {hWnd:hWnd, onlyClientArea:onlyClientArea, mode:(mode//2)}, transform.scale)
            if mode&1
                WinSetExStyle(oldStyle, hwnd)
            SoftwareBitmap := this.HBitmapToSoftwareBitmap(hBitMap,, transform)
            this.__DeleteProps(Options, "invertcolors", "grayscale", "monochrome")
            result := this(SoftwareBitmap, Options)
        }

        result.Relative := {CoordMode:coordsmode, hWnd:hWnd}
        if coordsmode = "Screen"
            x += sX, y += sY
        this.NormalizeCoordinates(result, transform.scale, x, y)
        if mode = 5 && !onlyClientArea
            result.OffsetCoordinates(offsetX, offsetY)
        return result
    }

    /**
     * Returns an OCR results object for the specified monitor. Locations of the words will be relative to
     * the primary screen (CoordMode "Screen"), even if a secondary monitor is being captured.
     * @param Monitor Optional: The monitor from which to get the desktop area. Default is primary monitor.
     *   If screen scaling between monitors differs, then use DllCall("SetThreadDpiAwarenessContext", "ptr", -3)
     * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. 
     * @returns {OCR.Result} 
     */
    static FromMonitor(Monitor?, Options:=0) {
        if !Options && IsSet(Monitor) && IsObject(Monitor)
            Options := Monitor, Monitor := unset
        this.__ExtractNamedParameters(Options, "Monitor", &Monitor)
        MonitorGet(monitor?, &Left, &Top, &Right, &Bottom)
        return this.FromRect(Left, Top, Right-Left, Bottom-Top, Options)
    }

    /**
     * Returns an OCR results object for the whole virtual screen. Locations of the words will be relative to
     * the primary screen (CoordMode "Screen").
     * @param Options Optional: OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. 
     *   If screen scaling between monitors differs, then use DllCall("SetThreadDpiAwarenessContext", "ptr", -3)
     * @returns {OCR.Result}
     */
    static FromDesktop(Options:=0) => this.FromRect(SysGet(76), SysGet(77), SysGet(78), SysGet(79), Options)

    /**
     * Returns an OCR results object for a region of the screen. Locations of the words will be relative
     * to the screen.
     * @param x Screen x coordinate
     * @param y Screen y coordinate
     * @param w Region width. Maximum is OCR.MaxImageDimension; minimum is 40 pixels (source: user FanaticGuru in AutoHotkey forums), smaller images will be scaled to at least 40 pixels.
     * @param h Region height. Maximum is OCR.MaxImageDimension; minimum is 40 pixels, smaller images will be scaled accordingly.
     * @param Options OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. 
     * @returns {OCR.Result} 
     */
    static FromRect(x, y, w, h, Options:=0) {
        local transform := 0, result
        if IsObject(Options)
            Options := Options.Clone()
        this.__ExtractTransformParameters(Options, &transform)
        this.__DeleteProps(Options, "scale", "invertcolors", "grayscale")
        local scale := transform.scale
            , hBitmap := this.CreateHBitmap(X, Y, W, H,, scale)
            , SoftwareBitmap := this.HBitmapToSoftwareBitmap(hBitmap,, transform)
            , result := this(SoftwareBitmap, Options)
        return this.NormalizeCoordinates(result, scale, x, y)
    }

    /**
     * Returns an OCR results object from a bitmap. Locations of the words will be relative
     * to the top left corner of the bitmap.
     * @param Bitmap A pointer to a GDIP Bitmap object, or HBITMAP, or an object with a ptr property
     *  set to one of the two.
     * @param Options OCR options {lang, scale, grayscale, invertcolors, rotate, flip, x, y, w, h, decoder}. 
     * @param hDC Optional: a device context for the bitmap. If omitted then the screen DC is used.
     * @returns {OCR.Result} 
     */
    static FromBitmap(Bitmap, Options:=0, hDC?) {
        local result, pDC, hBitmap, hBM2, oBM, oBM2, pBitmapInfo := Buffer(32, 0), W, H, scale, transform := 0
        if IsObject(Options)
            Options := Options.Clone()
        this.__ExtractTransformParameters(Options, &transform)
        scale := transform.scale
        this.__ExtractNamedParameters(Options, "hDC", &hDC)
        this.__DeleteProps(Options, "scale", "invertcolors", "grayscale")
        if !DllCall("GetObject", "ptr", Bitmap, "int", pBitmapInfo.Size, "ptr", pBitmapInfo) {
            DllCall("gdiplus\GdipCreateHBITMAPFromBitmap", "UPtr", Bitmap, "UPtr*", &hBitmap:=0, "Int", 0xffffffff)
            DllCall("GetObject", "ptr", hBitmap, "int", pBitmapInfo.Size, "ptr", pBitmapInfo)
            Bitmap := 0 ; Marks hBitmap to be deleted afterwards
        } else
            hBitmap := Bitmap

        W := NumGet(pBitmapInfo, 4, "int"), H := NumGet(pBitmapInfo, 8, "int")

        if scale != 1 || (W && H && (W < 40 || H < 40)) {
            sW := Ceil(W * scale), sH := Ceil(H * scale)

            hDC := DllCall("CreateCompatibleDC", "Ptr", 0, "Ptr")
            , oBM := DllCall("SelectObject", "Ptr", hDC, "Ptr", hBitmap, "Ptr")
            , pDC := DllCall("CreateCompatibleDC", "Ptr", hDC, "Ptr")
            , hBM2 := DllCall("CreateCompatibleBitmap", "Ptr", hDC, "Int", Max(40, sW), "Int", Max(40, sH), "Ptr")
            , oBM2 := DllCall("SelectObject", "Ptr", pDC, "Ptr", hBM2, "Ptr")
            if sW < 40 || sH < 40 ; Fills the bitmap so it's at least 40x40, which seems to improve recognition
                DllCall("StretchBlt", "Ptr", pDC, "Int", 0, "Int", 0, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr", hDC, "Int", 0, "Int", 0, "Int", 1, "Int", 1, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY. 
            PrevStretchBltMode := DllCall("SetStretchBltMode", "Ptr", PDC, "Int", 3, "Int") ; COLORONCOLOR
            , DllCall("StretchBlt", "Ptr", pDC, "Int", 0, "Int", 0, "Int", sW, "Int", sH, "Ptr", hDC, "Int", 0, "Int", 0, "Int", W, "Int", H, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY
            , DllCall("SetStretchBltMode", "Ptr", PDC, "Int", PrevStretchBltMode)
            , DllCall("SelectObject", "Ptr", pDC, "Ptr", oBM2)
            , DllCall("SelectObject", "Ptr", hDC, "Ptr", oBM)
            , DllCall("DeleteDC", "Ptr", hDC)
            SoftwareBitmap := this.HBitmapToSoftwareBitmap(hBM2, pDC, transform)
            result := this(SoftwareBitmap, Options)
            this.NormalizeCoordinates(result, scale)
            DllCall("DeleteDC", "Ptr", pDC)
            , DllCall("DeleteObject", "UPtr", hBM2)
            goto End
        }
        result := this(this.HBitmapToSoftwareBitmap(hBitmap, hDC?, transform), Options)
        End:
        if !Bitmap
            DllCall("DeleteObject", "UPtr", hBitmap)
        return result
    } 

    /**
     * Returns all available languages as a string, where the languages are separated by newlines.
     * @returns {String} 
     */
    static GetAvailableLanguages() {
        ComCall(7, this.OcrEngineStatics, "ptr*", &LanguageList := 0)   ; AvailableRecognizerLanguages
        ComCall(7, LanguageList, "int*", &count := 0)   ; count
        Loop count {
            ComCall(6, LanguageList, "int", A_Index - 1, "ptr*", &Language := 0)   ; get_Item
            ComCall(6, Language, "ptr*", &hText := 0)
            buf := DllCall("Combase.dll\WindowsGetStringRawBuffer", "ptr", hText, "uint*", &length := 0, "ptr")
            text .= StrGet(buf, "UTF-16") "`n"
            this.DeleteHString(hText)
            ObjRelease(Language)
        }
        ObjRelease(LanguageList)
        return text
    }

    /**
     * Loads a new language which will be used with subsequent OCR calls.
     * @param {string} lang OCR language. Default is first from available languages.
     * @returns {void} 
     */
    static LoadLanguage(lang:="FirstFromAvailableLanguages") {
        local hString, Language:=ComValue(13, 0), OcrEngine:=ComValue(13, 0)
        if this.HasOwnProp("CurrentLanguage") && this.HasOwnProp("OcrEngine") && this.CurrentLanguage = lang
            return
        if HasMethod(lang)
            lang := lang()
        if (lang = "FirstFromAvailableLanguages")
            ComCall(10, this.OcrEngineStatics, "ptr*", OcrEngine)   ; TryCreateFromUserProfileLanguages
        else {
            hString := this.CreateHString(lang)
            , ComCall(6, this.LanguageFactory, "ptr", hString, "ptr*", Language)   ; CreateLanguage
            , this.DeleteHString(hString)
            , ComCall(9, this.OcrEngineStatics, "ptr", Language, "ptr*", OcrEngine)   ; TryCreateFromLanguage
        }
        if (OcrEngine.ptr = 0)
            Throw Error(lang = "FirstFromAvailableLanguages" ? "Failed to use FirstFromAvailableLanguages for OCR:`nmake sure the primary language pack has OCR capabilities installed.`n`nAlternatively try `"en-us`" as the language." : "Can not use language `"" lang "`" for OCR, please install language pack.")
        this.OcrEngine := OcrEngine, this.CurrentLanguage := lang
    }

    /**
     * Returns a bounding rectangle {x,y,w,h} for the provided Word objects
     * @param words Word object arguments (at least 1)
     * @returns {Object}
     */
    static WordsBoundingRect(words*) {
        if !words.Length
            throw ValueError("This function requires at least one argument", -1)
        local X1 := 100000000, Y1 := 100000000, X2 := -100000000, Y2 := -100000000, word
        for word in words {
            X1 := Min(word.x, X1), Y1 := Min(word.y, Y1), X2 := Max(word.x+word.w, X2), Y2 := Max(word.y+word.h, Y2)
        }
        return {X:X1, Y:Y1, W:X2-X1, H:Y2-Y1, X2:X2, Y2:Y2}
    }
    
    /**
     * Waits text to appear on screen. If the method is successful, then Func's return value is returned.
     * Otherwise nothing is returned.
     * @param needle The searched text
     * @param {number} timeout Timeout in milliseconds. Less than 0 is indefinite wait (default)
     * @param func The function to be called for the OCR. Default is OCR.FromDesktop
     * @param casesense Text comparison case-sensitivity
     * @param comparefunc A custom string compare/search function, that accepts two arguments: haystack and needle.
     *      Default is InStr. If a custom function is used, then casesense is ignored.
     * @returns {OCR.Result} 
     */
    static WaitText(needle, timeout:=-1, func?, casesense:=False, comparefunc?) {
        local endTime := A_TickCount+timeout, result, line, total
        if !IsSet(func)
            func := this.FromDesktop
        if !IsSet(comparefunc)
            comparefunc := InStr.Bind(,,casesense)
        While timeout > 0 ? (A_TickCount < endTime) : 1 {
            result := func(), total := ""
            for line in result.Lines
                total .= line.Text "`n"
            if comparefunc(Trim(total, "`n"), needle)
                return result
        }
        return
    }

    /**
     * Returns word clusters using a two-dimensional DBSCAN algorithm
     * @param objs An array of objects (Words, Lines etc) to cluster. Must have x, y, w, h and Text properties.
     * @param eps_x Optional epsilon value for x-axis. Default is infinite.
     * This is unused if compareFunc is provided.
     * @param eps_y Optional epsilon value for y-axis. Default is median height of objects divided by two.
     * This is unused if compareFunc is provided.
     * @param minPts Optional minimum cluster size.
     * @param compareFunc Optional comparison function to judge the minimum distance between objects
     * to consider it a cluster. Must accept two objects to compare.
     * Default comparison function determines whether the difference of middle y-coordinates of 
     * the objects are less than epsilon-y, and whether objects are less than eps_x apart on the x-axis.
     * 
     * Eg `(p1, p2) => ((Abs(p1.y+p1.h-p2.y) < 5 || Abs(p2.y+p2.h-p1.y) < 5) && ((p1.x >= p2.x && p1.x <= (p2.x+p2.w)) || ((p1.x+p1.w) >= p2.x && (p1.x+p1.w) <= (p2.x+p2.w))))`
     * will cluster objects if they are located on top of eachother on the x-axis, and less than 5 pixels
     * apart in the y-axis.
     * @param noise If provided, then will be set to an array of clusters that didn't satisfy minPts
     * @returns {Array} Array of objects with {x,y,w,h,Text,Words} properties
     */
    static Cluster(objs, eps_x:=-1, eps_y:=-1, minPts:=1, compareFunc?, &noise?) {
        local clusters := [], start := 0, cluster, word
        visited := Map(), clustered := Map(), C := [], c_n := 0, sum := 0, noise := IsSet(noise) && (noise is Array) ? noise : []
        if !IsObject(objs) || !(objs is Array)
            throw ValueError("objs argument must be an Array", -1)
        if !objs.Length
            return []
        if IsSet(compareFunc) && !HasMethod(compareFunc)
            throw ValueError("compareFunc must be a valid function", -1)

        if !IsSet(compareFunc) {
            if (eps_y < 0) {
                for point in objs
                    sum += point.h
                eps_y := (sum // objs.Length) // 2
            }
            compareFunc := (p1, p2) => Abs(p1.y+p1.h//2-p2.y-p2.h//2)<eps_y && (eps_x < 0 || (Abs(p1.x+p1.w-p2.x)<eps_x || Abs(p1.x-p2.x-p2.w)<eps_x))
        }

        ; DBSCAN adapted from https://github.com/ninopereira/DBSCAN_1D
        for point in objs {
            visited[point] := 1, neighbourPts := [], RegionQuery(point)
            if !clustered.Has(point) {
                C.Push([]), c_n += 1, C[c_n].Push(point), clustered[point] := 1
                ExpandCluster(point)
            }
            if C[c_n].Length < minPts
                noise.Push(C[c_n]), C.RemoveAt(c_n), c_n--
        }

        ; Sort clusters by x-coordinate, get cluster bounding rects, and concatenate word texts
        for cluster in C {
            this.SortArray(cluster,,"x")
            br := this.Common(), br.DefineProp("BoundingRect", {value:this.WordsBoundingRect(cluster*)}), br.DefineProp("Words", {value:cluster}), br.DefineProp("Text", {value: ""})
            for word in cluster
                br.Text .= word.Text " "
            br.Text := RTrim(br.Text)
            clusters.Push(br)
        }
        ; Sort clusters/lines by y-coordinate
        this.SortArray(clusters,,"y")
        return clusters

        ExpandCluster(P) {
            local point
            for point in neighbourPts {
                if !visited.Has(point) {
                    visited[point] := 1, RegionQuery(point)
                    if !clustered.Has(point)
                        C[c_n].Push(point), clustered[point] := 1
                }
            }
        }

        RegionQuery(P) {
            local point
            for point in objs
                if !visited.Has(point)
                    if compareFunc(P, point)
                        neighbourPts.Push(point)
        }
    }

    /**
     * Sorts an array in-place, optionally by object keys or using a callback function.
     * @param arr The array to be sorted
     * @param OptionsOrCallback Optional: either a callback function, or one of the following:
     * 
     *     N => array is considered to consist of only numeric values. This is the default option.
     *     C, C1 or COn => case-sensitive sort of strings
     *     C0 or COff => case-insensitive sort of strings
     * 
     *     The callback function should accept two parameters elem1 and elem2 and return an integer:
     *     Return integer < 0 if elem1 less than elem2
     *     Return 0 is elem1 is equal to elem2
     *     Return > 0 if elem1 greater than elem2
     * @param Key Optional: Omit it if you want to sort a array of primitive values (strings, numbers etc).
     *     If you have an array of objects, specify here the key by which contents the object will be sorted.
     * @returns {Array}
     */
    static SortArray(arr, optionsOrCallback:="N", key?) {
        if (arr.Length < 2)
            return this
        if HasMethod(optionsOrCallback)
            compareFunc := optionsOrCallback, optionsOrCallback := ""
        else {
            if InStr(optionsOrCallback, "N")
                compareFunc := IsSet(key) ? NumericCompareKey.Bind(key) : NumericCompare
            if RegExMatch(optionsOrCallback, "i)C(?!0)|C1|COn")
                compareFunc := IsSet(key) ? StringCompareKey.Bind(key,,True) : StringCompare.Bind(,,True)
            if RegExMatch(optionsOrCallback, "i)C0|COff")
                compareFunc := IsSet(key) ? StringCompareKey.Bind(key) : StringCompare
            if InStr(optionsOrCallback, "Random") {
                len := arr.Length
                Loop len-1 {
                    i := len + 1 - A_Index
                    j := Random(1, i)
                    if (j != i)
                        tmp := arr[i], arr[i] := arr[j], arr[j] := tmp
                }
                return arr
            }
            if !IsSet(compareFunc)
                throw ValueError("No valid options provided!", -1)
        }
        QuickSort(1, arr.Length)
        if RegExMatch(optionsOrCallback, "i)R(?!a)")
            this.ReverseArray(arr)
        if InStr(optionsOrCallback, "U")
            arr := this.UniqueArray(arr)
        return arr

        NumericCompare(left, right) => (left > right) - (left < right)
        NumericCompareKey(key, left, right) => ((f1 := left.HasProp("__Item") ? left[key] : left.%key%), (f2 := right.HasProp("__Item") ? right[key] : right.%key%), (f1 > f2) - (f1 < f2))
        StringCompare(left, right, casesense := False) => StrCompare(left "", right "", casesense)
        StringCompareKey(key, left, right, casesense := False) => StrCompare((left.HasProp("__Item") ? left[key] : left.%key%) "", (right.HasProp("__Item") ? right[key] : right.%key%) "", casesense)

        ; In-place quicksort (Hoare-style partition with middle pivot)
        QuickSort(left, right) {
            i := left
            j := right
            pivot := arr[(left + right) // 2]

            while (i <= j) {
                while (compareFunc(arr[i], pivot) < 0)
                    i++
                while (compareFunc(arr[j], pivot) > 0)
                    j--
                if (i <= j) {
                    temp := arr[i], arr[i] := arr[j], arr[j] := temp
                    i++, j--
                }
            }
            if (left < j)
                QuickSort(left, j)
            if (i < right)
                QuickSort(i, right)
        }
    }
    ; Reverses the array in-place
    static ReverseArray(arr) {
        local len := arr.Length + 1, max := (len // 2), i := 0
        while ++i <= max
            temp := arr[len - i], arr[len - i] := arr[i], arr[i] := temp
        return arr
    }
    ; Returns a new array with only unique values
    static UniqueArray(arr) {
        local unique := Map()
        for v in arr
            unique[v] := 1
        return [unique*]
    }

    ; Returns a one-dimensional array from a multi-dimensional array
    static FlattenArray(arr) {
        local r := []
        for v in arr {
            if v is Array
                r.Push(this.FlattenArray(v)*)
            else
                r.Push(v)
        }
        return r
    }

    ;; Only internal methods ahead

    ; Scales and optionally crops a SoftwareBitmap. Crop parameters need to not be scale-adjusted.
    ; Rotation can be clockwise 0, 90, 180, or 270 degrees
    ; Flip: 0 = no flip, 1 = around y-axis, 2 = around x-axis
    static TransformSoftwareBitmap(SoftwareBitmap, &sbW, &sbH, scale:=1, rotate:=0, flip:=0, X?, Y?, W?, H?) {
        InMemoryRandomAccessStream := this.SoftwareBitmapToRandomAccessStream(SoftwareBitmap)

        ComCall(this.Vtbl_GetDecoder.png, this.BitmapDecoderStatics, "ptr", DecoderGUID:=Buffer(16))
        ComCall(15, this.BitmapDecoderStatics, "ptr", DecoderGUID, "ptr", InMemoryRandomAccessStream, "ptr*", BitmapDecoder:=ComValue(13,0))   ; CreateAsync
        this.WaitForAsync(&BitmapDecoder)

        BitmapFrameWithSoftwareBitmap := ComObjQuery(BitmapDecoder, IBitmapFrameWithSoftwareBitmap := "{FE287C9A-420C-4963-87AD-691436E08383}")
        BitmapFrame := ComObjQuery(BitmapDecoder, IBitmapFrame := "{72A49A1C-8081-438D-91BC-94ECFC8185C6}")

        BitmapTransform := this.CreateClass("Windows.Graphics.Imaging.BitmapTransform")

        if IsSet(W) && W
            sbW := Min(sbW, W)
        if IsSet(H) && H
            sbH := Min(sbH, H)
        local sW := Floor(sbW*scale), sH := Floor(sbH*scale), intermediate
        if scale != 1 {
            ; First the bitmap is scaled, then cropped
            ComCall(7, BitmapTransform, "uint", sW) ; put_ScaledWidth
            ComCall(9, BitmapTransform, "uint", sH) ; put_ScaledHeight
        }
        if rotate {
            ComCall(15, BitmapTransform, "uint", rotate//90) ; put_Rotation
            if rotate = 90 || rotate = 270
                intermediate := sW, sW := sH, sH := intermediate
        }
        if flip
            ComCall(13, BitmapTransform, "uint", flip) ; put_Flip

        if (IsSet(X) && X != 0) || (IsSet(Y) && Y != 0) || IsSet(W) || IsSet(H)  {
            bounds := Buffer(16,0), NumPut("int", Floor(X*scale), "int", Floor(Y*scale), "int", Floor(sbW*scale), "int", Floor(sbH*scale), bounds)
            ComCall(17, BitmapTransform, "ptr", bounds) ; put_Bounds
        }
        ComCall(8, BitmapFrame, "uint*", &BitmapPixelFormat:=0) ; get_BitmapPixelFormat
        ComCall(9, BitmapFrame, "uint*", &BitmapAlphaMode:=0) ; get_BitmapAlphaMode
        ComCall(8, BitmapFrameWithSoftwareBitmap, "uint", BitmapPixelFormat, "uint", BitmapAlphaMode, "ptr", BitmapTransform, "uint", IgnoreExifOrientation := 0, "uint", DoNotColorManage := 0, "ptr*", SoftwareBitmap:=ComValue(13,0)) ; GetSoftwareBitmapTransformedAsync

        this.WaitForAsync(&SoftwareBitmap)
        ; this.CloseIClosable(BitmapFrameWithSoftwareBitmap) ; Implemented, but is it necessary?
        this.CloseIClosable(InMemoryRandomAccessStream)
        sbW := sW, sbH := sH
        return SoftwareBitmap
    }

    static CreateDIBSection(w, h, hdc?, bpp:=32, &ppvBits:=0) {
        local hdc2 := IsSet(hdc) ? hdc : DllCall("GetDC", "Ptr", 0, "UPtr")
        , bi := Buffer(40, 0), hbm
        NumPut("int", 40, "int", w, "int", h, "ushort", 1, "ushort", bpp, "int", 0, bi)
        hbm := DllCall("CreateDIBSection", "uint", hdc2, "ptr" , bi, "uint" , 0, "uint*", &ppvBits:=0, "uint" , 0, "uint" , 0)
        if !IsSet(hdc)
            DllCall("ReleaseDC", "Ptr", 0, "Ptr", hdc2)
        return hbm
    }

    /**
     * Creates an hBitmap of a region of the screen or a specific window
     * @param X Captured rectangle X coordinate. This is relative to the screen unless hWnd is specified,
     *  in which case it may be relative to the window/client
     * @param Y Captured rectangle Y coordinate.
     * @param W Captured rectangle width.
     * @param H Captured rectangle height.
     * @param {Integer|Object} hWnd Window handle which to capture. Coordinates will be relative to the window. 
     *  hWnd may also be an object {hWnd, onlyClientArea, mode} where onlyClientArea:1 means the client area will be captured instead of the whole window (and X, Y will also be relative to client)
     *  mode 0 uses GetDC + StretchBlt, mode 1 uses PrintWindow, mode 2 uses PrintWindow with undocumented PW_RENDERFULLCONTENT flag. 
     *  Default is mode 2.
     * @param {Integer} scale 
     * @returns {OCR.IBase} 
     */
    static CreateHBitmap(X, Y, W, H, hWnd:=0, scale:=1) {
        local sW := Ceil(W*scale), sH := Ceil(H*scale), onlyClientArea := 0, mode := 2, HDC, obm, hbm, pdc, hbm2
        if hWnd {
            if IsObject(hWnd)
                onlyClientArea := hWnd.HasOwnProp("onlyClientArea") ? hWnd.onlyClientArea : onlyClientArea, mode := hWnd.HasOwnProp("mode") ? hWnd.mode : mode, hWnd := hWnd.hWnd
            HDC := DllCall("GetDCEx", "Ptr", hWnd, "Ptr", 0, "Int", 2|!onlyClientArea, "Ptr")
            if mode > 0 {
                PDC := DllCall("CreateCompatibleDC", "Ptr", 0, "Ptr")
                HBM := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Max(40,X+W), "Int", Max(40,Y+H), "Ptr")
                , OBM := DllCall("SelectObject", "Ptr", PDC, "Ptr", HBM, "Ptr")
                , DllCall("PrintWindow", "Ptr", hWnd, "Ptr", PDC, "UInt", (mode=2?2:0)|!!onlyClientArea)
                if scale != 1 || X != 0 || Y != 0 {
                    PDC2 := DllCall("CreateCompatibleDC", "Ptr", PDC, "Ptr")
                    , HBM2 := DllCall("CreateCompatibleBitmap", "Ptr", PDC, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr")
                    , OBM2 := DllCall("SelectObject", "Ptr", PDC2, "Ptr", HBM2, "Ptr")
                    , PrevStretchBltMode := DllCall("SetStretchBltMode", "Ptr", PDC, "Int", 3, "Int") ; COLORONCOLOR
                    , DllCall("StretchBlt", "Ptr", PDC2, "Int", 0, "Int", 0, "Int", sW, "Int", sH, "Ptr", PDC, "Int", X, "Int", Y, "Int", W, "Int", H, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY
                    , DllCall("SetStretchBltMode", "Ptr", PDC, "Int", PrevStretchBltMode)
                    , DllCall("SelectObject", "Ptr", PDC2, "Ptr", obm2)
                    , DllCall("DeleteDC", "Ptr", PDC)
                    , DllCall("DeleteObject", "UPtr", HBM)
                    , hbm := hbm2, pdc := pdc2
                }
                DllCall("SelectObject", "Ptr", PDC, "Ptr", OBM)
                , DllCall("DeleteDC", "Ptr", HDC)
                , oHBM := this.IBase(HBM), oHBM.DC := PDC
                return oHBM.DefineProp("__Delete", {call:(this, *)=>(DllCall("DeleteObject", "Ptr", this), DllCall("DeleteDC", "Ptr", this.DC))})
            }
        } else {
            HDC := DllCall("GetDC", "Ptr", 0, "Ptr")
        }
        PDC := DllCall("CreateCompatibleDC", "Ptr", HDC, "Ptr")
        , HBM := DllCall("CreateCompatibleBitmap", "Ptr", HDC, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr")
        , OBM := DllCall("SelectObject", "Ptr", PDC, "Ptr", HBM, "Ptr")
        if sW < 40 || sH < 40 ; Fills the bitmap so it's at least 40x40, which seems to improve recognition
            DllCall("StretchBlt", "Ptr", PDC, "Int", 0, "Int", 0, "Int", Max(40,sW), "Int", Max(40,sH), "Ptr", HDC, "Int", X, "Int", Y, "Int", 1, "Int", 1, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY. 
        PrevStretchBltMode := DllCall("SetStretchBltMode", "Ptr", PDC, "Int", 3, "Int") ; COLORONCOLOR
        , DllCall("StretchBlt", "Ptr", PDC, "Int", 0, "Int", 0, "Int", sW, "Int", sH, "Ptr", HDC, "Int", X, "Int", Y, "Int", W, "Int", H, "UInt", 0x00CC0020 | this.CAPTUREBLT) ; SRCCOPY
        , DllCall("SetStretchBltMode", "Ptr", PDC, "Int", PrevStretchBltMode)
        , DllCall("SelectObject", "Ptr", PDC, "Ptr", OBM)
        , DllCall("DeleteDC", "Ptr", HDC)
        , oHBM := this.IBase(HBM), oHBM.DC := PDC
        return oHBM.DefineProp("__Delete", {call:(this, *)=>(DllCall("DeleteObject", "Ptr", this), DllCall("DeleteDC", "Ptr", this.DC))})
    }

    static CreateDirect3DSoftwareBitmapFromWindow(hWnd) {
        static init := 0, DXGIDevice, Direct3DDevice, Direct3D11CaptureFramePoolStatics, GraphicsCaptureItemInterop, GraphicsCaptureItemGUID, D3D_Device, D3D_Context
        local x, y, w, h, rect
        if !init {
            DllCall("LoadLibrary","str","DXGI")
            DllCall("LoadLibrary","str","D3D11")
            DllCall("LoadLibrary","str","Dwmapi")
            DllCall("D3D11\D3D11CreateDevice", "ptr", 0, "int", D3D_DRIVER_TYPE_HARDWARE := 1, "ptr", 0, "uint", D3D11_CREATE_DEVICE_BGRA_SUPPORT := 0x20, "ptr", 0, "uint", 0, "uint", D3D11_SDK_VERSION := 7, "ptr*", D3D_Device:=ComValue(13, 0), "ptr*", 0, "ptr*", D3D_Context:=ComValue(13, 0))
            DXGIDevice := ComObjQuery(D3D_Device, IID_IDXGIDevice := "{54ec77fa-1377-44e6-8c32-88fd5f44c84c}")
            DllCall("D3D11\CreateDirect3D11DeviceFromDXGIDevice", "ptr", DXGIDevice, "ptr*", GraphicsDevice:=ComValue(13, 0))
            Direct3DDevice := ComObjQuery(GraphicsDevice, IDirect3DDevice := "{A37624AB-8D5F-4650-9D3E-9EAE3D9BC670}")
            Direct3D11CaptureFramePoolStatics := this.CreateClass("Windows.Graphics.Capture.Direct3D11CaptureFramePool", IDirect3D11CaptureFramePoolStatics := "{7784056a-67aa-4d53-ae54-1088d5a8ca21}")
            GraphicsCaptureItemStatics := this.CreateClass("Windows.Graphics.Capture.GraphicsCaptureItem", IGraphicsCaptureItemStatics := "{A87EBEA5-457C-5788-AB47-0CF1D3637E74}")
            GraphicsCaptureItemInterop := ComObjQuery(GraphicsCaptureItemStatics, IGraphicsCaptureItemInterop := "{3628E81B-3CAC-4C60-B7F4-23CE0E0C3356}")
            GraphicsCaptureItemGUID := Buffer(16,0)
            DllCall("ole32\CLSIDFromString", "wstr", IGraphicsCaptureItem := "{79c3f95b-31f7-4ec2-a464-632ef5d30760}", "ptr", GraphicsCaptureItemGUID)
            init := 1
        }
        ; INIT done

        DllCall("Dwmapi.dll\DwmGetWindowAttribute", "ptr", hWnd, "uint", DWMWA_EXTENDED_FRAME_BOUNDS := 9, "ptr", rect := Buffer(16,0), "uint", 16)
        x := NumGet(rect, 0, "int"), y := NumGet(rect, 4, "int"), w := NumGet(rect, 8, "int") - x, h := NumGet(rect, 12, "int") - y
        ComCall(6, Direct3D11CaptureFramePoolStatics, "ptr", Direct3DDevice, "int", B8G8R8A8UIntNormalized := 87, "int", numberOfBuffers := 2, "int64", (h << 32) | w, "ptr*", Direct3D11CaptureFramePool:=ComValue(13, 0))   ; Direct3D11CaptureFramePool.Create
        if ComCall(3, GraphicsCaptureItemInterop, "ptr", hWnd, "ptr", GraphicsCaptureItemGUID, "ptr*", GraphicsCaptureItem:=ComValue(13, 0), "uint") {   ; IGraphicsCaptureItemInterop::CreateForWindow
            this.CloseIClosable(Direct3D11CaptureFramePool)
            throw Error("Failed to capture GraphicsItem of window",, -1)
        }
        ComCall(10, Direct3D11CaptureFramePool, "ptr", GraphicsCaptureItem, "ptr*", GraphicsCaptureSession:=ComValue(13, 0))   ; Direct3D11CaptureFramePool.CreateCaptureSession

        GraphicsCaptureSession2 := ComObjQuery(GraphicsCaptureSession, IGraphicsCaptureSession2 := "{2c39ae40-7d2e-5044-804e-8b6799d4cf9e}")
        ComCall(7, GraphicsCaptureSession2, "int", 0)   ; GraphicsCaptureSession.IsCursorCaptureEnabled put

        if (Integer(StrSplit(A_OSVersion, ".")[3]) >= 20348) { ; hide border
            GraphicsCaptureSession3 := ComObjQuery(GraphicsCaptureSession, IGraphicsCaptureSession3 := "{f2cdd966-22ae-5ea1-9596-3a289344c3be}")
            ComCall(7, GraphicsCaptureSession3, "int", 0)   ; GraphicsCaptureSession.IsBorderRequired put
        }
        ComCall(6, GraphicsCaptureSession)   ; GraphicsCaptureSession.StartCapture
        Loop {
            ComCall(7, Direct3D11CaptureFramePool, "ptr*", Direct3D11CaptureFrame:=ComValue(13, 0))   ; Direct3D11CaptureFramePool.TryGetNextFrame
            if (Direct3D11CaptureFrame.ptr != 0)
                break
        }
        ComCall(6, Direct3D11CaptureFrame, "ptr*", Direct3DSurface:=ComValue(13, 0))   ; Direct3D11CaptureFrame.Surface

        ComCall(11, this.SoftwareBitmapStatics, "ptr", Direct3DSurface, "ptr*", SoftwareBitmap:=ComValue(13, 0)) ; SoftwareBitmap::CreateCopyFromSurfaceAsync
        this.WaitForAsync(&SoftwareBitmap)

        this.CloseIClosable(Direct3D11CaptureFramePool)
        this.CloseIClosable(GraphicsCaptureSession)
        if GraphicsCaptureSession2 {
            this.CloseIClosable(GraphicsCaptureSession2)
        }
        if IsSet(GraphicsCaptureSession3) {
            this.CloseIClosable(GraphicsCaptureSession3)
        }
        this.CloseIClosable(Direct3D11CaptureFrame)
        this.CloseIClosable(Direct3DSurface)

        SoftwareBitmap.x := x, SoftwareBitmap.y := y, SoftwareBitmap.w := w, SoftwareBitmap.h := h
        return SoftwareBitmap
    }

    static HBitmapToRandomAccessStream(hBitmap) {
        static PICTYPE_BITMAP := 1
             , BSOS_DEFAULT   := 0
             , sz := 8 + A_PtrSize*2
        local PICTDESC, riid, size, pIRandomAccessStream
             
        DllCall("Ole32\CreateStreamOnHGlobal", "Ptr", 0, "UInt", true, "Ptr*", pIStream:=ComValue(13,0), "UInt")
        , PICTDESC := Buffer(sz, 0)
        , NumPut("uint", sz, "uint", PICTYPE_BITMAP, "ptr", IsInteger(hBitmap) ? hBitmap : hBitmap.ptr, PICTDESC)
        , riid := this.CLSIDFromString(this.IID_IPicture)
        , DllCall("OleAut32\OleCreatePictureIndirect", "Ptr", PICTDESC, "Ptr", riid, "UInt", 0, "Ptr*", pIPicture:=ComValue(13,0), "UInt")
        , ComCall(15, pIPicture, "Ptr", pIStream, "UInt", true, "uint*", &size:=0, "UInt") ; IPicture::SaveAsFile
        , riid := this.CLSIDFromString(this.IID_IRandomAccessStream)
        , DllCall("ShCore\CreateRandomAccessStreamOverStream", "Ptr", pIStream, "UInt", BSOS_DEFAULT, "Ptr", riid, "Ptr*", pIRandomAccessStream:=ComValue(13, 0), "UInt")
        Return pIRandomAccessStream
    }

    ; Converts HBITMAP to SoftwareBitmap. NOTE: SetStretchBltMode HALFTONE breaks this
    ; The optional transform parameter may contain {grayscale, invertcolors}
    static HBitmapToSoftwareBitmap(hBitmap, hDC?, transform?) {
        local bi := Buffer(40, 0), W, H, BitmapBuffer, MemoryBuffer, MemoryBufferReference, BufferByteAccess, BufferSize
        hDC := (hBitmap is OCR.IBase ? hBitmap.DC : (hDC ?? dhDC := DllCall("GetDC", "Ptr", 0, "UPtr")))

        NumPut("uint", 40, bi, 0)
        DllCall("GetDIBits", "ptr", hDC, "ptr", hBitmap, "uint", 0, "uint", 0, "ptr", 0, "ptr", bi, "uint", 0)
        W := NumGet(bi, 4, "int"), H := NumGet(bi, 8, "int")

        ComCall(7, this.SoftwareBitmapFactory, "int", 87, "int", W, "int", H, "int", 0, "ptr*", SoftwareBitmap := ComValue(13,0)) ; CreateWithAlpha: Bgra8 & Premultiplied
        ComCall(15, SoftwareBitmap, "int", 2, "ptr*", &BitmapBuffer := 0) ; LockBuffer
        MemoryBuffer := ComObjQuery(BitmapBuffer, "{fbc4dd2a-245b-11e4-af98-689423260cf8}")
        ComCall(6, MemoryBuffer, "ptr*", &MemoryBufferReference := 0) ; CreateReference
        BufferByteAccess := ComObjQuery(MemoryBufferReference, "{5b0d3235-4dba-4d44-865e-8f1d0e4fd04d}")
        ComCall(3, BufferByteAccess, "ptr*", &SoftwareBitmapByteBuffer:=0, "uint*", &BufferSize:=0) ; GetBuffer

        NumPut("short", 32, "short", 0, bi, 14), NumPut("int", -H, bi, 8) ; Negative height to get correctly oriented image
        DllCall("GetDIBits", "ptr", hDC, "ptr", hBitmap, "uint", 0, "uint", H, "ptr", SoftwareBitmapByteBuffer, "ptr", bi, "uint", 0)
        if IsSet(transform) {
            if (transform.HasProp("grayscale") && transform.grayscale)
                DllCall(this.GrayScaleMCode, "ptr", SoftwareBitmapByteBuffer, "uint", w, "uint", h, "uint", (w*4+3) // 4 * 4, "cdecl uint")
            if (transform.HasProp("monochrome") && transform.monochrome)
                DllCall(this.MonochromeMCode, "ptr", SoftwareBitmapByteBuffer, "uint", w, "uint", h, "uint", (w*4+3) // 4 * 4, "uint", transform.monochrome, "cdecl uint")
            if (transform.HasProp("invertcolors") && transform.invertcolors)
                DllCall(this.InvertColorsMCode, "ptr", SoftwareBitmapByteBuffer, "uint", w, "uint", h, "uint", (w*4+3) // 4 * 4, "cdecl uint")
        }
        
        if IsSet(dhDC)
            DllCall("DeleteDC", "ptr", dhDC)
        if BufferByteAccess.HasMethod("Dispose")
            BufferByteAccess.Dispose()
        if MemoryBuffer.HasMethod("Dispose")
            MemoryBuffer.Dispose()
        BufferByteAccess := "", ObjRelease(MemoryBufferReference), MemoryBuffer := "", ObjRelease(BitmapBuffer) ; Release in correct order

        return SoftwareBitmap
    }

    static MCode(mcode) {
        static e := Map('1', 4, '2', 1), c := (A_PtrSize=8) ? "x64" : "x86"
        if (!regexmatch(mcode, "^([0-9]+),(" c ":|.*?," c ":)([^,]+)", &m))
          return
        if (!DllCall("crypt32\CryptStringToBinary", "str", m.3, "uint", 0, "uint", e[m.1], "ptr", 0, "uint*", &s := 0, "ptr", 0, "ptr", 0))
          return
        p := DllCall("GlobalAlloc", "uint", 0, "ptr", s, "ptr")
        if (c="x64")
          DllCall("VirtualProtect", "ptr", p, "ptr", s, "uint", 0x40, "uint*", &op := 0)
        if (DllCall("crypt32\CryptStringToBinary", "str", m.3, "uint", 0, "uint", e[m.1], "ptr", p, "uint*", &s, "ptr", 0, "ptr", 0))
          return p
        DllCall("GlobalFree", "ptr", p)
      }

    static DisplayHBitmap(hBitmap) {
        local gImage := Gui("-DPIScale"), W, H
        , hPic := gImage.Add("Text", "0xE w640 h640")
        SendMessage(0x172, 0, hBitmap,, hPic.hWnd)
        hPic.GetPos(,,&W, &H)
        gImage.Show("w" (W+20) " H" (H+20))
        WinWaitClose gImage
    }

    static SoftwareBitmapToRandomAccessStream(SoftwareBitmap) {
        InMemoryRandomAccessStream := this.CreateClass("Windows.Storage.Streams.InMemoryRandomAccessStream")
        ComCall(8, this.BitmapEncoderStatics, "ptr", encoderId := Buffer(16, 0)) ; IBitmapEncoderStatics::PngEncoderId
        ComCall(13, this.BitmapEncoderStatics, "ptr", encoderId, "ptr", InMemoryRandomAccessStream, "ptr*", BitmapEncoder:=ComValue(13,0)) ; IBitmapEncoderStatics::CreateAsync
        this.WaitForAsync(&BitmapEncoder)
        BitmapEncoderWithSoftwareBitmap := ComObjQuery(BitmapEncoder, "{686cd241-4330-4c77-ace4-0334968b1768}")
        ComCall(6, BitmapEncoderWithSoftwareBitmap, "ptr", SoftwareBitmap) ; SetSoftwareBitmap
        ComCall(19, BitmapEncoder, "ptr*", asyncAction:=ComValue(13,0)) ; FlushAsync
        this.WaitForAsync(&asyncAction)
        ComCall(11, InMemoryRandomAccessStream, "int64", 0) ; Seek to beginning
        return InMemoryRandomAccessStream
    }

    static CreateClass(str, interface?) {
        local hString := this.CreateHString(str), result
        if !IsSet(interface) {
            result := DllCall("Combase.dll\RoActivateInstance", "ptr", hString, "ptr*", cls:=ComValue(13, 0), "uint")
        } else {
            GUID := this.CLSIDFromString(interface)
            result := DllCall("Combase.dll\RoGetActivationFactory", "ptr", hString, "ptr", GUID, "ptr*", cls:=ComValue(13, 0), "uint")
        }
        if (result != 0) {
            if (result = 0x80004002)
                throw Error("No such interface supported", -1, interface)
            else if (result = 0x80040154)
                throw Error("Class not registered", -1)
            else
                throw Error(result)
        }
        this.DeleteHString(hString)
        return cls
    }
    
    static CreateHString(str) => (DllCall("Combase.dll\WindowsCreateString", "wstr", str, "uint", StrLen(str), "ptr*", &hString:=0), hString)
    
    static DeleteHString(hString) => DllCall("Combase.dll\WindowsDeleteString", "ptr", hString)
    
    static WaitForAsync(&obj) {
        local AsyncInfo := ComObjQuery(obj, this.IID_IAsyncInfo), status, ErrorCode
        Loop {
            ComCall(7, AsyncInfo, "uint*", &status:=0)   ; IAsyncInfo.Status
            if (status != 0) {
                if (status != 1) {
                    ComCall(8, ASyncInfo, "uint*", &ErrorCode:=0)   ; IAsyncInfo.ErrorCode
                    throw Error("AsyncInfo failed with status error " ErrorCode, -1)
                }
                break
            }
            Sleep this.PerformanceMode ? -1 : 0
        }
        ComCall(8, obj, "ptr*", ObjectResult:=this.IBase())   ; GetResults
        obj := ObjectResult
    }

    static CloseIClosable(pClosable) {
        static IClosable := "{30D5A829-7FA4-4026-83BB-D75BAE4EA99E}"
        local Close := ComObjQuery(pClosable, IClosable)
        ComCall(6, Close)   ; Close
    }

    static CLSIDFromString(IID) {
        local CLSID := Buffer(16), res
        if res := DllCall("ole32\CLSIDFromString", "WStr", IID, "Ptr", CLSID, "UInt")
           throw Error("CLSIDFromString failed. Error: " . Format("{:#x}", res))
        Return CLSID
    }

    static NormalizeCoordinates(result, scale, x:=0, y:=0) {
        local word
        if (scale == 1 && x == 0 && y == 0)
            return result
        for word in result.Words
            word.x := Integer(word.x / scale)+x, word.y := Integer(word.y / scale)+y, word.w := Integer(word.w / scale), word.h := Integer(word.h / scale), word.BoundingRect := {X:word.x, Y:word.y, W:word.w, H:word.h}
        return result
    }
    
    static __OpenPdfDocument(IRandomAccessStream, Password:="") {
        PdfDocumentStatics := this.CreateClass("Windows.Data.Pdf.PdfDocument", this.IID_IPdfDocumentStatics)
        ComCall(8, PdfDocumentStatics, "ptr", IRandomAccessStream, "ptr*", PdfDocument:=ComValue(13, 0)) ; LoadFromStreamAsync
        this.WaitForAsync(&PdfDocument)
        return PdfDocument
    }

    static __ExtractNamedParameters(obj, params*) {
        local i := 0
        if !IsObject(obj) || Type(obj) != "Object"
            return 0
        Loop params.Length // 2 {
            name := params[++i], value := params[++i]
            if obj.HasProp(name)
                %value% := obj.%name%
        }
        return 1
    }

    static __ExtractTransformParameters(obj, &transform) {
        local scale := 1, grayscale := 0, invertcolors := 0, monochrome := 0, rotate := 0, flip := 0
        if IsObject(obj)
            this.__ExtractNamedParameters(obj, "scale", &scale, "grayscale", &grayscale, "invertcolors", &invertcolors, "monochrome", &monochrome, "rotate", &rotate, "flip", &flip, "transform", &transform)

        if IsSet(transform) && IsObject(transform) {
            for prop in ["scale", "grayscale", "invertcolors", "monochrome", "rotate", "flip"]
                if !transform.HasProp(prop)
                    transform.%prop% := %prop%
        } else
            transform := {scale:scale, grayscale:grayscale, invertcolors:invertcolors, monochrome:monochrome, rotate:rotate, flip:flip}
    
        transform.flip := transform.flip = "y" ? 1 : transform.flip = "x" ? 2 : transform.flip
    }

    static __DeleteProps(obj, props*) {
        if IsObject(obj)
            for prop in props
                obj.DeleteProp(prop)
    }

    /**
     * Converts coordinates between screen, window and client.
     * @param X X-coordinate to convert
     * @param Y Y-coordinate to convert
     * @param outX Variable where to store the converted X-coordinate
     * @param outY Variable where to store the converted Y-coordinate
     * @param relativeFrom CoordMode where to convert from. Default is A_CoordModeMouse.
     * @param relativeTo CoordMode where to convert to. Default is Screen.
     * @param winTitle A window title or other criteria identifying the target window. 
     * @param winText If present, this parameter must be a substring from a single text element of the target window.
     * @param excludeTitle Windows whose titles include this value will not be considered.
     * @param excludeText Windows whose text include this value will not be considered.
     */
    static ConvertWinPos(X, Y, &outX, &outY, relativeFrom:="", relativeTo:="screen", winTitle?, winText?, excludeTitle?, excludeText?) {
        relativeFrom := relativeFrom || A_CoordModeMouse
        if relativeFrom = relativeTo {
            outX := X, outY := Y
            return
        }
        local hWnd := WinExist(winTitle?, winText?, excludeTitle?, excludeText?)

        switch relativeFrom, 0 {
            case "screen", "s":
                if relativeTo = "window" || relativeTo = "w" {
                    DllCall("user32\GetWindowRect", "Int", hWnd, "Ptr", RECT := Buffer(16))
                    outX := X-NumGet(RECT, 0, "Int"), outY := Y-NumGet(RECT, 4, "Int")
                } else { 
                    ; screen to client
                    pt := Buffer(8), NumPut("int",X,pt), NumPut("int",Y,pt,4)
                    DllCall("ScreenToClient", "Int", hWnd, "Ptr", pt)
                    outX := NumGet(pt,0,"int"), outY := NumGet(pt,4,"int")
                }
            case "window", "w":
                ; window to screen
                WinGetPos(&outX, &outY,,,hWnd)
                outX += X, outY += Y
                if relativeTo = "client" || relativeTo = "c" {
                    ; screen to client
                    pt := Buffer(8), NumPut("int",outX,pt), NumPut("int",outY,pt,4)
                    DllCall("ScreenToClient", "Int", hWnd, "Ptr", pt)
                    outX := NumGet(pt,0,"int"), outY := NumGet(pt,4,"int")
                }
            case "client", "c":
                ; client to screen
                pt := Buffer(8), NumPut("int",X,pt), NumPut("int",Y,pt,4)
                DllCall("ClientToScreen", "Int", hWnd, "Ptr", pt)
                outX := NumGet(pt,0,"int"), outY := NumGet(pt,4,"int")
                if relativeTo = "window" || relativeTo = "w" { ; screen to window
                    DllCall("user32\GetWindowRect", "Int", hWnd, "Ptr", RECT := Buffer(16))
                    outX -= NumGet(RECT, 0, "Int"), outY -= NumGet(RECT, 4, "Int")
                }
        }
    }
}



; =====================================================================
; PHUCKIT Clinical Reasoning Database v1
; Complete medication schema + field-level evidence/provenance framework
; =====================================================================

global ClinicalMedicationRepository := Map()
global ClinicalMedicationAliasIndex := Map()
global ClinicalSchemaVersion := "1.0.0"

global ClinicalMedicationFields := [
    "generic", "brands", "ocrAliases", "commonMisspellings",
    "pharmacologicClass", "therapeuticClass", "indications",
    "doseByIndication", "renalDosing", "hepaticDosing", "hd", "crrt", "pd",
    "loadingDose", "maximumDose", "administration", "infusionRates",
    "extendedInfusion", "ySiteCompatibility", "stability", "extravasation",
    "vesicantClassification", "antidote", "tubeAdministration", "crushability",
    "hazardousHandling", "pregnancy", "lactation", "blackBoxWarnings",
    "contraindications", "monitoring", "majorInteractions",
    "highYieldInteractions", "therapeuticSubstitutions", "formularyAlternatives",
    "clinicalPearls", "references", "versionHistory"
]

Clinical_NewMedicationRecord(genericName) {
    global ClinicalMedicationFields, ClinicalSchemaVersion
    rec := Map()
    for field in ClinicalMedicationFields
        rec[field] := Clinical_DefaultFieldValue(field)

    rec["generic"] := Trim(genericName)
    rec["schemaVersion"] := ClinicalSchemaVersion
    rec["recordStatus"] := "draft"
    rec["createdAt"] := A_NowUTC
    rec["updatedAt"] := A_NowUTC
    rec["evidence"] := Map()
    rec["validation"] := Map(
        "status", "unvalidated",
        "validatedFieldCount", 0,
        "requiredFieldCount", ClinicalMedicationFields.Length,
        "lastReviewedAt", "",
        "reviewedBy", "",
        "reviewNotes", ""
    )
    rec["versionHistory"] := [Map(
        "version", "0.1.0",
        "timestamp", A_NowUTC,
        "changeType", "record_created",
        "summary", "Initial structured medication record created.",
        "author", "system"
    )]
    return rec
}

Clinical_DefaultFieldValue(field) {
    switch field {
        case "generic", "pharmacologicClass", "therapeuticClass", "recordStatus":
            return ""
        default:
            return []
    }
}

Clinical_RegisterMedication(record) {
    global ClinicalMedicationRepository
    if !IsObject(record) || !record.Has("generic")
        throw Error("Medication record must contain a generic field.")

    key := Clinical_NormalizeKey(record["generic"])
    if (key = "")
        throw Error("Medication generic name cannot be blank.")

    record["updatedAt"] := A_NowUTC
    ClinicalMedicationRepository[key] := record
    Clinical_IndexMedicationAliases(record)
    return key
}

Clinical_GetMedication(nameOrAlias) {
    global ClinicalMedicationRepository, ClinicalMedicationAliasIndex
    key := Clinical_NormalizeKey(nameOrAlias)
    if ClinicalMedicationRepository.Has(key)
        return ClinicalMedicationRepository[key]
    if ClinicalMedicationAliasIndex.Has(key) {
        canonical := ClinicalMedicationAliasIndex[key]
        return ClinicalMedicationRepository.Has(canonical) ? ClinicalMedicationRepository[canonical] : ""
    }
    return ""
}

Clinical_NormalizeKey(value) {
    value := StrLower(Trim(value))
    value := RegExReplace(value, "[^a-z0-9]+", " ")
    return Trim(RegExReplace(value, "\s+", " "))
}

Clinical_NormalizeMedicationName(name) {
    rec := Clinical_GetMedication(name)
    return IsObject(rec) ? rec["generic"] : Trim(StrLower(name))
}

Clinical_IndexMedicationAliases(record) {
    global ClinicalMedicationAliasIndex
    canonical := Clinical_NormalizeKey(record["generic"])
    ClinicalMedicationAliasIndex[canonical] := canonical

    for field in ["brands", "ocrAliases", "commonMisspellings"] {
        if record.Has(field) && IsObject(record[field]) {
            for alias in record[field] {
                aliasKey := Clinical_NormalizeKey(alias)
                if (aliasKey != "")
                    ClinicalMedicationAliasIndex[aliasKey] := canonical
            }
        }
    }
}

Clinical_SetField(record, field, value, evidenceRecords := "", author := "system", note := "") {
    global ClinicalMedicationFields
    if !Clinical_ArrayContains(ClinicalMedicationFields, field)
        throw Error("Unknown medication field: " field)

    record[field] := value
    record["updatedAt"] := A_NowUTC

    if IsObject(evidenceRecords) {
        record["evidence"][field] := evidenceRecords
    } else if !record["evidence"].Has(field) {
        record["evidence"][field] := []
    }

    Clinical_AddVersionEvent(record, "field_updated", field " updated.", author, note)
    Clinical_RecalculateValidation(record)
    return record
}

Clinical_NewEvidence(sourceType, citation, title := "", publisher := "", publicationDate := "", urlOrId := "", accessedAt := "", excerptOrLocator := "", evidenceLevel := "", notes := "") {
    return Map(
        "sourceType", sourceType,
        "citation", citation,
        "title", title,
        "publisher", publisher,
        "publicationDate", publicationDate,
        "urlOrId", urlOrId,
        "accessedAt", accessedAt != "" ? accessedAt : A_NowUTC,
        "excerptOrLocator", excerptOrLocator,
        "evidenceLevel", evidenceLevel,
        "notes", notes,
        "verificationStatus", "pending",
        "verifiedBy", "",
        "verifiedAt", ""
    )
}

Clinical_VerifyEvidence(evidence, reviewer, status := "verified", notes := "") {
    if !IsObject(evidence)
        throw Error("Evidence must be an object.")
    evidence["verificationStatus"] := status
    evidence["verifiedBy"] := reviewer
    evidence["verifiedAt"] := A_NowUTC
    if (notes != "")
        evidence["notes"] := notes
    return evidence
}

Clinical_FieldValidationStatus(record, field) {
    if !record.Has("evidence") || !record["evidence"].Has(field)
        return "no_source"

    sources := record["evidence"][field]
    if !IsObject(sources) || sources.Length = 0
        return "no_source"

    verified := 0
    pending := 0
    rejected := 0
    for src in sources {
        status := src.Has("verificationStatus") ? src["verificationStatus"] : "pending"
        switch status {
            case "verified": verified += 1
            case "rejected": rejected += 1
            default: pending += 1
        }
    }

    if (rejected > 0)
        return "conflict_or_rejected"
    if (verified > 0 && pending = 0)
        return "validated"
    if (verified > 0)
        return "partially_validated"
    return "pending_review"
}

Clinical_RecalculateValidation(record) {
    global ClinicalMedicationFields
    validated := 0
    partially := 0
    missing := 0
    conflicts := 0

    for field in ClinicalMedicationFields {
        status := Clinical_FieldValidationStatus(record, field)
        switch status {
            case "validated": validated += 1
            case "partially_validated", "pending_review": partially += 1
            case "conflict_or_rejected": conflicts += 1
            default: missing += 1
        }
    }

    record["validation"]["validatedFieldCount"] := validated
    record["validation"]["requiredFieldCount"] := ClinicalMedicationFields.Length
    record["validation"]["missingSourceCount"] := missing
    record["validation"]["partialReviewCount"] := partially
    record["validation"]["conflictCount"] := conflicts

    if (conflicts > 0)
        status := "conflict"
    else if (validated = ClinicalMedicationFields.Length)
        status := "validated"
    else if (validated > 0 || partially > 0)
        status := "in_review"
    else
        status := "unvalidated"

    record["validation"]["status"] := status
    return status
}

Clinical_ValidateMedicationRecord(record) {
    global ClinicalMedicationFields
    report := Map(
        "generic", record.Has("generic") ? record["generic"] : "",
        "schemaVersion", record.Has("schemaVersion") ? record["schemaVersion"] : "",
        "fieldStatus", Map(),
        "missingFields", [],
        "unsourcedFields", [],
        "conflictedFields", [],
        "valid", true
    )

    for field in ClinicalMedicationFields {
        if !record.Has(field) {
            report["missingFields"].Push(field)
            report["valid"] := false
            continue
        }
        status := Clinical_FieldValidationStatus(record, field)
        report["fieldStatus"][field] := status
        if (status = "no_source")
            report["unsourcedFields"].Push(field)
        else if (status = "conflict_or_rejected") {
            report["conflictedFields"].Push(field)
            report["valid"] := false
        }
    }

    Clinical_RecalculateValidation(record)
    report["overallStatus"] := record["validation"]["status"]
    return report
}

Clinical_AddVersionEvent(record, changeType, summary, author := "system", notes := "") {
    if !record.Has("versionHistory") || !IsObject(record["versionHistory"])
        record["versionHistory"] := []
    record["versionHistory"].Push(Map(
        "version", Clinical_NextPatchVersion(record),
        "timestamp", A_NowUTC,
        "changeType", changeType,
        "summary", summary,
        "author", author,
        "notes", notes
    ))
}

Clinical_NextPatchVersion(record) {
    if !record.Has("versionHistory") || record["versionHistory"].Length = 0
        return "0.1.0"
    last := record["versionHistory"][record["versionHistory"].Length]
    version := last.Has("version") ? last["version"] : "0.1.0"
    parts := StrSplit(version, ".")
    major := parts.Length >= 1 ? Integer(parts[1]) : 0
    minor := parts.Length >= 2 ? Integer(parts[2]) : 1
    patch := parts.Length >= 3 ? Integer(parts[3]) + 1 : 1
    return major "." minor "." patch
}

Clinical_ArrayContains(arr, value) {
    for item in arr
        if (item = value)
            return true
    return false
}

Clinical_GetFieldWithEvidence(nameOrAlias, field) {
    rec := Clinical_GetMedication(nameOrAlias)
    if !IsObject(rec) || !rec.Has(field)
        return ""
    return Map(
        "value", rec[field],
        "validationStatus", Clinical_FieldValidationStatus(rec, field),
        "evidence", rec["evidence"].Has(field) ? rec["evidence"][field] : []
    )
}

Clinical_CanPublishMedication(record) {
    report := Clinical_ValidateMedicationRecord(record)
    return report["overallStatus"] = "validated" && report["conflictedFields"].Length = 0
}

Clinical_SeedReasoningDatabase() {
    ; Seed records are structural only. No clinical field is marked validated
    ; until supporting evidence is attached and independently verified.
    for genericName in [
        "vancomycin", "meropenem", "piperacillin/tazobactam", "apixaban",
        "rivaroxaban", "pantoprazole", "omeprazole",
        "trimethoprim/sulfamethoxazole"
    ] {
        rec := Clinical_NewMedicationRecord(genericName)
        Clinical_RegisterMedication(rec)
    }

    Clinical_SetField(Clinical_GetMedication("piperacillin/tazobactam"), "brands", ["Zosyn"], "", "system", "Seed alias only; requires evidence before publication.")
    Clinical_SetField(Clinical_GetMedication("piperacillin/tazobactam"), "ocrAliases", ["pip/tazo", "pip tazo", "pip-tazo", "TZP"], "", "system")
    Clinical_SetField(Clinical_GetMedication("vancomycin"), "ocrAliases", ["vanc"], "", "system")
    Clinical_SetField(Clinical_GetMedication("meropenem"), "ocrAliases", ["mero"], "", "system")
    Clinical_SetField(Clinical_GetMedication("trimethoprim/sulfamethoxazole"), "brands", ["Bactrim"], "", "system")
    Clinical_SetField(Clinical_GetMedication("trimethoprim/sulfamethoxazole"), "ocrAliases", ["TMP-SMX", "SMX-TMP"], "", "system")
    Clinical_SetField(Clinical_GetMedication("pantoprazole"), "brands", ["Protonix"], "", "system")
    Clinical_SetField(Clinical_GetMedication("apixaban"), "brands", ["Eliquis"], "", "system")
    Clinical_SetField(Clinical_GetMedication("rivaroxaban"), "brands", ["Xarelto"], "", "system")
}

Clinical_SeedReasoningDatabase()

MedRec_ClassifyChange(homeName, inpatientName) {
    h := Clinical_GetMedication(homeName)
    i := Clinical_GetMedication(inpatientName)

    if IsObject(h) && IsObject(i) && Clinical_NormalizeKey(h["generic"]) = Clinical_NormalizeKey(i["generic"])
        return Map("type", "MATCH", "home", h["generic"], "inpatient", i["generic"])

    if IsObject(h) && IsObject(i) {
        substitutions := h.Has("therapeuticSubstitutions") ? h["therapeuticSubstitutions"] : []
        for candidate in substitutions {
            candidateName := IsObject(candidate) && candidate.Has("generic") ? candidate["generic"] : candidate
            if Clinical_NormalizeKey(candidateName) = Clinical_NormalizeKey(i["generic"])
                return Map(
                    "type", "THERAPEUTIC_SUBSTITUTION",
                    "home", h["generic"],
                    "inpatient", i["generic"],
                    "visibility", "always_show",
                    "validationStatus", Clinical_FieldValidationStatus(h, "therapeuticSubstitutions")
                )
        }
    }

    return Map(
        "type", "DIFFERENT",
        "home", IsObject(h) ? h["generic"] : homeName,
        "inpatient", IsObject(i) ? i["generic"] : inpatientName,
        "visibility", "always_show"
    )
}


; =====================================================================
; Pharmacist.Guide Clinical Reasoning Database - Sprint 2
; Claim engine + evidence engine + independent reviewer workflow
; AutoHotkey v2 compatible module
; Structural implementation only: contains no clinical recommendations.
; =====================================================================

global CRD2_ClaimIndex := Map()
global CRD2_EvidenceIndex := Map()
global CRD2_SchemaVersion := "2.0.0"

global CRD2_ClaimStatuses := [
    "draft", "source_attached", "locator_verified", "clinical_reviewed",
    "independent_reviewed", "approved", "published", "changes_requested",
    "rejected", "conflicted"
]

global CRD2_ReviewStages := [
    "locator", "primary_clinical", "secondary_independent", "publication"
]

CRD2_NewId(prefix) {
    static sequence := 0
    sequence += 1
    return prefix "_" A_NowUTC "_" sequence "_" Random(100000, 999999)
}

CRD2_EnsureMedicationClaims(record) {
    if !IsObject(record)
        throw Error("Medication record must be an object.")
    if !record.Has("claims") || !IsObject(record["claims"])
        record["claims"] := Map()
    return record["claims"]
}

CRD2_NewClaim(record, field, value, authoredBy, population := "", indication := "", route := "", formulation := "", conditions := "", applicability := "applicable", consumers := "") {
    global ClinicalMedicationFields, CRD2_SchemaVersion

    if !IsObject(record)
        throw Error("Medication record must be an object.")
    if !Clinical_ArrayContains(ClinicalMedicationFields, field)
        throw Error("Unknown medication field: " field)
    if (Trim(authoredBy) = "")
        throw Error("Claim author is required.")

    claim := Map(
        "claimId", CRD2_NewId("claim"),
        "medicationId", Clinical_NormalizeKey(record["generic"]),
        "field", field,
        "value", value,
        "population", population,
        "indication", indication,
        "route", route,
        "formulation", formulation,
        "conditions", IsObject(conditions) ? conditions : Map(),
        "applicability", applicability,
        "status", "draft",
        "evidenceIds", [],
        "reviews", [],
        "conflictResolution", Map(
            "resolutionStatus", "unresolved",
            "preferredEvidenceIds", [],
            "selectionRationale", "",
            "uncertaintyStatement", "",
            "localPolicyOverride", "",
            "resolvedBy", "",
            "resolvedAt", ""
        ),
        "consumers", IsObject(consumers) ? consumers : [],
        "authoredBy", Trim(authoredBy),
        "createdAt", A_NowUTC,
        "updatedAt", A_NowUTC,
        "approvedAt", "",
        "publishedAt", "",
        "nextReviewDue", "",
        "schemaVersion", CRD2_SchemaVersion,
        "version", "0.1.0"
    )

    CRD2_RegisterClaim(record, claim)
    return claim
}

CRD2_RegisterClaim(record, claim) {
    global CRD2_ClaimIndex
    claims := CRD2_EnsureMedicationClaims(record)
    id := claim["claimId"]
    if claims.Has(id) || CRD2_ClaimIndex.Has(id)
        throw Error("Duplicate claim ID: " id)
    claims[id] := claim
    CRD2_ClaimIndex[id] := claim
    return claim
}

CRD2_NewEvidence(sourceType, citation, title, publisher, publicationDate, sourceVersion, sourceIdentifier, section, subsection := "", page := "", table := "", figure := "", recommendation := "", paragraphOrBullet := "", appendix := "", electronicAnchor := "", claimSupported := "", supportSummary := "", supportType := "supports", createdBy := "system") {
    if (Trim(sourceType) = "" || Trim(citation) = "" || Trim(title) = "")
        throw Error("Evidence source type, citation, and title are required.")

    evidence := Map(
        "evidenceId", CRD2_NewId("evidence"),
        "sourceType", sourceType,
        "citation", citation,
        "title", title,
        "publisher", publisher,
        "publicationDate", publicationDate,
        "sourceVersion", sourceVersion,
        "sourceIdentifier", sourceIdentifier,
        "accessedAt", A_NowUTC,
        "locator", Map(
            "section", section,
            "subsection", subsection,
            "page", page,
            "table", table,
            "figure", figure,
            "recommendation", recommendation,
            "paragraphOrBullet", paragraphOrBullet,
            "appendix", appendix,
            "electronicAnchor", electronicAnchor
        ),
        "claimSupported", claimSupported,
        "supportSummary", supportSummary,
        "shortVerbatimSupport", "",
        "supportType", supportType,
        "evidenceLevel", "",
        "authorityRank", "",
        "notes", "",
        "verificationStatus", "pending",
        "verificationHistory", [],
        "createdBy", createdBy,
        "createdAt", A_NowUTC,
        "updatedAt", A_NowUTC
    )

    CRD2_RegisterEvidence(evidence)
    return evidence
}

CRD2_RegisterEvidence(evidence) {
    global CRD2_EvidenceIndex
    if !IsObject(evidence) || !evidence.Has("evidenceId")
        throw Error("Invalid evidence record.")
    id := evidence["evidenceId"]
    if CRD2_EvidenceIndex.Has(id)
        throw Error("Duplicate evidence ID: " id)
    CRD2_EvidenceIndex[id] := evidence
    return evidence
}

CRD2_AttachEvidence(claim, evidence) {
    if !IsObject(claim) || !IsObject(evidence)
        throw Error("Claim and evidence must be objects.")
    evidenceId := evidence["evidenceId"]
    if !Clinical_ArrayContains(claim["evidenceIds"], evidenceId)
        claim["evidenceIds"].Push(evidenceId)
    claim["updatedAt"] := A_NowUTC
    CRD2_RecalculateClaimStatus(claim)
    return claim
}

CRD2_HasPreciseLocator(locator) {
    if !IsObject(locator)
        return false
    for key in ["subsection", "page", "table", "figure", "recommendation", "paragraphOrBullet", "appendix", "electronicAnchor"] {
        if locator.Has(key) && Trim(locator[key]) != ""
            return true
    }
    return false
}

CRD2_LocatorComplete(evidence) {
    if !IsObject(evidence) || !evidence.Has("locator")
        return false
    locator := evidence["locator"]
    return locator.Has("section") && Trim(locator["section"]) != "" && CRD2_HasPreciseLocator(locator)
}

CRD2_ValidateEvidence(evidence) {
    errors := []
    warnings := []

    for required in ["sourceType", "citation", "title", "publisher", "publicationDate", "sourceVersion", "sourceIdentifier", "claimSupported", "supportSummary"] {
        if !evidence.Has(required) || Trim(evidence[required]) = ""
            errors.Push("Missing evidence field: " required)
    }

    if !evidence.Has("locator") || !IsObject(evidence["locator"])
        errors.Push("Missing source locator.")
    else {
        locator := evidence["locator"]
        if !locator.Has("section") || Trim(locator["section"]) = ""
            errors.Push("Source section is required.")
        if !CRD2_HasPreciseLocator(locator)
            errors.Push("Precise source locator is required.")
    }

    return Map(
        "valid", errors.Length = 0,
        "errors", errors,
        "warnings", warnings
    )
}

CRD2_AddReview(claim, stage, reviewer, decision, notes := "") {
    global CRD2_ReviewStages, CRD2_EvidenceIndex

    if !Clinical_ArrayContains(CRD2_ReviewStages, stage)
        throw Error("Unknown review stage: " stage)
    if !Clinical_ArrayContains(["approve", "reject", "request_changes"], decision)
        throw Error("Unknown review decision: " decision)
    reviewer := Trim(reviewer)
    if (reviewer = "")
        throw Error("Reviewer is required.")

    if (decision = "approve") {
        if (reviewer = claim["authoredBy"])
            throw Error("Claim author cannot approve their own claim.")

        if (stage = "locator") {
            report := CRD2_ValidateAttachedEvidence(claim)
            if !report["valid"]
                throw Error("Locator review blocked: " CRD2_Join(report["errors"], "; "))
        }

        if (stage = "primary_clinical" && !CRD2_HasApprovedReview(claim, "locator"))
            throw Error("Approved locator review is required first.")

        if (stage = "secondary_independent") {
            if !CRD2_HasApprovedReview(claim, "primary_clinical")
                throw Error("Approved primary clinical review is required first.")
            primaryReviewer := CRD2_GetApprovedReviewer(claim, "primary_clinical")
            if (primaryReviewer = reviewer)
                throw Error("Secondary reviewer must differ from primary reviewer.")
        }

        if (stage = "publication") {
            if !CRD2_HasApprovedReview(claim, "secondary_independent")
                throw Error("Approved independent secondary review is required first.")
            secondaryReviewer := CRD2_GetApprovedReviewer(claim, "secondary_independent")
            if (secondaryReviewer = reviewer)
                throw Error("Publication approver must differ from secondary reviewer.")
            report := CRD2_ValidateClaimForApproval(claim)
            if !report["valid"]
                throw Error("Publication approval blocked: " CRD2_Join(report["errors"], "; "))
        }
    }

    review := Map(
        "reviewId", CRD2_NewId("review"),
        "stage", stage,
        "reviewer", reviewer,
        "decision", decision,
        "notes", notes,
        "reviewedAt", A_NowUTC
    )
    claim["reviews"].Push(review)
    claim["updatedAt"] := A_NowUTC

    if (decision = "approve" && Clinical_ArrayContains(["locator", "primary_clinical", "secondary_independent"], stage)) {
        switch stage {
            case "locator": evidenceStatus := "locator_verified"
            case "primary_clinical": evidenceStatus := "clinically_verified"
            case "secondary_independent": evidenceStatus := "independently_verified"
        }
        for evidenceId in claim["evidenceIds"] {
            if CRD2_EvidenceIndex.Has(evidenceId) {
                evidence := CRD2_EvidenceIndex[evidenceId]
                evidence["verificationStatus"] := evidenceStatus
                evidence["verificationHistory"].Push(review.Clone())
                evidence["updatedAt"] := A_NowUTC
            }
        }
    }

    if (decision = "reject")
        claim["status"] := "rejected"
    else if (decision = "request_changes")
        claim["status"] := "changes_requested"
    else
        CRD2_RecalculateClaimStatus(claim)

    return review
}

CRD2_ValidateAttachedEvidence(claim) {
    global CRD2_EvidenceIndex
    errors := []
    warnings := []

    if claim["applicability"] = "applicable" && claim["evidenceIds"].Length = 0
        errors.Push("Applicable claim requires at least one evidence record.")

    for evidenceId in claim["evidenceIds"] {
        if !CRD2_EvidenceIndex.Has(evidenceId) {
            errors.Push("Unknown evidence ID: " evidenceId)
            continue
        }
        report := CRD2_ValidateEvidence(CRD2_EvidenceIndex[evidenceId])
        for item in report["errors"]
            errors.Push(evidenceId ": " item)
        for item in report["warnings"]
            warnings.Push(evidenceId ": " item)
    }

    return Map("valid", errors.Length = 0, "errors", errors, "warnings", warnings)
}

CRD2_HasApprovedReview(claim, stage) {
    for review in claim["reviews"] {
        if review["stage"] = stage && review["decision"] = "approve"
            return true
    }
    return false
}

CRD2_GetApprovedReviewer(claim, stage) {
    for review in claim["reviews"] {
        if review["stage"] = stage && review["decision"] = "approve"
            return review["reviewer"]
    }
    return ""
}

CRD2_HasConflictingEvidence(claim) {
    global CRD2_EvidenceIndex
    for evidenceId in claim["evidenceIds"] {
        if CRD2_EvidenceIndex.Has(evidenceId) && CRD2_EvidenceIndex[evidenceId]["supportType"] = "conflicts"
            return true
    }
    return false
}

CRD2_ConflictResolved(claim) {
    resolution := claim["conflictResolution"]
    return resolution["resolutionStatus"] = "resolved"
        && resolution["preferredEvidenceIds"].Length > 0
        && Trim(resolution["selectionRationale"]) != ""
        && Trim(resolution["resolvedBy"]) != ""
        && Trim(resolution["resolvedAt"]) != ""
}

CRD2_ResolveConflict(claim, preferredEvidenceIds, selectionRationale, resolvedBy, uncertaintyStatement := "", localPolicyOverride := "") {
    if !IsObject(preferredEvidenceIds) || preferredEvidenceIds.Length = 0
        throw Error("At least one preferred evidence record is required.")
    if (Trim(selectionRationale) = "")
        throw Error("Conflict selection rationale is required.")
    if (Trim(resolvedBy) = "")
        throw Error("Conflict resolver is required.")

    for evidenceId in preferredEvidenceIds {
        if !Clinical_ArrayContains(claim["evidenceIds"], evidenceId)
            throw Error("Preferred evidence is not attached to claim: " evidenceId)
    }

    resolution := claim["conflictResolution"]
    resolution["resolutionStatus"] := "resolved"
    resolution["preferredEvidenceIds"] := preferredEvidenceIds
    resolution["selectionRationale"] := selectionRationale
    resolution["uncertaintyStatement"] := uncertaintyStatement
    resolution["localPolicyOverride"] := localPolicyOverride
    resolution["resolvedBy"] := resolvedBy
    resolution["resolvedAt"] := A_NowUTC
    claim["updatedAt"] := A_NowUTC
    CRD2_RecalculateClaimStatus(claim)
    return claim
}

CRD2_ValidateClaimForApproval(claim) {
    evidenceReport := CRD2_ValidateAttachedEvidence(claim)
    errors := []
    warnings := []

    for item in evidenceReport["errors"]
        errors.Push(item)
    for item in evidenceReport["warnings"]
        warnings.Push(item)

    if !CRD2_HasApprovedReview(claim, "locator")
        errors.Push("Locator review approval is required.")
    if !CRD2_HasApprovedReview(claim, "primary_clinical")
        errors.Push("Primary clinical review approval is required.")
    if !CRD2_HasApprovedReview(claim, "secondary_independent")
        errors.Push("Independent secondary review approval is required.")
    if CRD2_HasConflictingEvidence(claim) && !CRD2_ConflictResolved(claim)
        errors.Push("Conflicting evidence must be explicitly resolved.")
    if claim["status"] = "rejected" || claim["status"] = "changes_requested"
        errors.Push("Current claim status prevents approval: " claim["status"])

    return Map(
        "valid", errors.Length = 0,
        "status", errors.Length = 0 ? "ready_for_approval" : "blocked",
        "errors", errors,
        "warnings", warnings
    )
}

CRD2_ApproveClaim(claim, approver, notes := "") {
    report := CRD2_ValidateClaimForApproval(claim)
    if !report["valid"]
        throw Error("Claim approval blocked: " CRD2_Join(report["errors"], "; "))
    CRD2_AddReview(claim, "publication", approver, "approve", notes)
    claim["status"] := "approved"
    claim["approvedAt"] := A_NowUTC
    claim["updatedAt"] := A_NowUTC
    return claim
}

CRD2_PublishClaim(claim) {
    if claim["status"] != "approved"
        throw Error("Only an approved claim can be published.")
    claim["status"] := "published"
    claim["publishedAt"] := A_NowUTC
    claim["updatedAt"] := A_NowUTC
    return claim
}

CRD2_RecalculateClaimStatus(claim) {
    global CRD2_EvidenceIndex

    if Clinical_ArrayContains(["rejected", "changes_requested", "published"], claim["status"])
        return claim["status"]

    if CRD2_HasConflictingEvidence(claim) && !CRD2_ConflictResolved(claim)
        status := "conflicted"
    else if CRD2_HasApprovedReview(claim, "publication")
        status := "approved"
    else if CRD2_HasApprovedReview(claim, "secondary_independent")
        status := "independent_reviewed"
    else if CRD2_HasApprovedReview(claim, "primary_clinical")
        status := "clinical_reviewed"
    else if CRD2_HasApprovedReview(claim, "locator")
        status := "locator_verified"
    else if claim["evidenceIds"].Length > 0 {
        allComplete := true
        for evidenceId in claim["evidenceIds"] {
            if !CRD2_EvidenceIndex.Has(evidenceId) || !CRD2_LocatorComplete(CRD2_EvidenceIndex[evidenceId]) {
                allComplete := false
                break
            }
        }
        status := allComplete ? "locator_verified" : "source_attached"
    } else
        status := "draft"

    claim["status"] := status
    return status
}

CRD2_GetClaimEvidence(claim) {
    global CRD2_EvidenceIndex
    records := []
    for evidenceId in claim["evidenceIds"] {
        if CRD2_EvidenceIndex.Has(evidenceId)
            records.Push(CRD2_EvidenceIndex[evidenceId])
    }
    return records
}

CRD2_Join(items, delimiter := ", ") {
    output := ""
    for index, item in items
        output .= (index > 1 ? delimiter : "") item
    return output
}

; =====================================================================
; Pharmacist.Guide Clinical Reasoning Database - Sprint 3
; JSON persistence, migrations, manifests, checksums, releases, rollback
; AutoHotkey v2 module. Contains no clinical recommendations.
; =====================================================================


global CRD3_SchemaVersion := "3.0.0"
global CRD3_Migrations := Map()

CRD3_EnsureDir(path) {
    if !DirExist(path)
        DirCreate(path)
    return path
}

CRD3_SafeId(value) {
    value := StrLower(Trim(value))
    value := RegExReplace(value, "[^a-z0-9]+", "_")
    value := Trim(value, "_")
    if (value = "")
        throw Error("Identifier cannot be empty.")
    return value
}

CRD3_WriteTextAtomic(path, text, encoding := "UTF-8") {
    CRD3_EnsureDir(RegExReplace(path, "\\[^\\]+$", ""))
    temp := path "." A_TickCount ".tmp"
    try {
        if FileExist(temp)
            FileDelete(temp)
        FileAppend(text, temp, encoding)
        FileMove(temp, path, true)
    } catch as err {
        if FileExist(temp)
            FileDelete(temp)
        throw err
    }
    return path
}

CRD3_WriteJson(path, value, pretty := true) {
    return CRD3_WriteTextAtomic(path, CRD3_JSON_Stringify(value, pretty) "`n", "UTF-8")
}

CRD3_ReadJson(path) {
    if !FileExist(path)
        throw Error("JSON file not found: " path)
    return CRD3_JSON_Parse(FileRead(path, "UTF-8"))
}

CRD3_InitRepository(rootDir, createdBy := "system", schemaVersion := "") {
    global CRD3_SchemaVersion
    if (schemaVersion = "")
        schemaVersion := CRD3_SchemaVersion
    CRD3_EnsureDir(rootDir)
    for folder in ["medications", "claims", "evidence"]
        CRD3_EnsureDir(rootDir "\" folder)
    metaPath := rootDir "\repository.json"
    if !FileExist(metaPath) {
        CRD3_WriteJson(metaPath, Map(
            "repositoryType", "pharmacist.guide.clinical-reasoning-database",
            "schemaVersion", schemaVersion,
            "createdAt", A_NowUTC,
            "createdBy", createdBy,
            "updatedAt", A_NowUTC
        ))
    }
    return rootDir
}

CRD3_SaveEntity(rootDir, entityType, entityId, record) {
    if !CRD3_ArrayContains(["medications", "claims", "evidence"], entityType)
        throw Error("Unknown entity type: " entityType)
    if !IsObject(record)
        throw Error("Entity record must be an object.")
    CRD3_InitRepository(rootDir)
    path := rootDir "\" entityType "\" CRD3_SafeId(entityId) ".json"
    CRD3_WriteJson(path, record)
    return path
}

CRD3_LoadEntity(rootDir, entityType, entityId) {
    path := rootDir "\" entityType "\" CRD3_SafeId(entityId) ".json"
    return CRD3_ReadJson(path)
}

CRD3_ListEntityIds(rootDir, entityType) {
    ids := []
    folder := rootDir "\" entityType
    if !DirExist(folder)
        return ids
    Loop Files, folder "\*.json", "F"
        ids.Push(RegExReplace(A_LoopFileName, "\.json$", ""))
    return ids
}

CRD3_ExportCurrentIndexes(rootDir) {
    counts := Map()
    entities := Map()
    for entityType in ["medications", "claims", "evidence"] {
        ids := CRD3_ListEntityIds(rootDir, entityType)
        counts[entityType] := ids.Length
        entities[entityType] := ids
    }
    meta := CRD3_ReadJson(rootDir "\repository.json")
    index := Map(
        "schemaVersion", meta.Has("schemaVersion") ? meta["schemaVersion"] : "",
        "generatedAt", A_NowUTC,
        "counts", counts,
        "entities", entities
    )
    return CRD3_WriteJson(rootDir "\index.json", index)
}

CRD3_RegisterMigration(fromVersion, toVersion, callback) {
    global CRD3_Migrations
    if !HasMethod(callback, "Call")
        throw Error("Migration callback must be callable.")
    if CRD3_Migrations.Has(fromVersion)
        throw Error("Migration already registered from version " fromVersion)
    CRD3_Migrations[fromVersion] := Map("toVersion", toVersion, "callback", callback)
}

CRD3_Migrate(value, fromVersion, toVersion) {
    global CRD3_Migrations
    current := fromVersion
    visited := Map()
    while (current != toVersion) {
        if visited.Has(current)
            throw Error("Migration cycle detected.")
        visited[current] := true
        if !CRD3_Migrations.Has(current)
            throw Error("No migration path from " current " to " toVersion)
        step := CRD3_Migrations[current]
        value := step["callback"].Call(value)
        current := step["toVersion"]
    }
    return value
}

CRD3_SHA256File(path) {
    if !FileExist(path)
        throw Error("Cannot hash missing file: " path)
    output := A_Temp "\crd_sha256_" A_TickCount ".txt"
    command := A_ComSpec " /D /C certutil -hashfile " CRD3_Quote(path) " SHA256 > " CRD3_Quote(output) " 2>&1"
    exitCode := RunWait(command, , "Hide")
    raw := ""
    try {
        raw := FileRead(output, "UTF-8")
    } finally {
        if FileExist(output)
            FileDelete(output)
    }
    if (exitCode != 0)
        throw Error("SHA-256 calculation failed: " raw)
    if !RegExMatch(raw, "i)([a-f0-9]{64})", &match)
        throw Error("SHA-256 output could not be parsed.")
    return StrLower(match[1])
}

CRD3_CreateRelease(workingDir, releasesDir, version, createdBy, notes := "", channel := "draft") {
    global CRD3_SchemaVersion
    if (channel != "draft")
        throw Error("AHK release creation is limited to draft releases. Candidate and production promotion require the schema/policy release service.")
    if !DirExist(workingDir)
        throw Error("Working repository does not exist: " workingDir)
    releaseName := SubStr(version, 1, 1) = "v" ? version : "v" version
    releaseDir := releasesDir "\" releaseName
    if DirExist(releaseDir)
        throw Error("Release already exists: " releaseDir)
    CRD3_EnsureDir(releasesDir)
    tempDir := releasesDir "\." releaseName "." A_TickCount ".tmp"
    try {
        DirCopy(workingDir, tempDir)
        files := []
        Loop Files, tempDir "\*", "FR" {
            if (A_LoopFileName = "manifest.json")
                continue
            rel := SubStr(A_LoopFileFullPath, StrLen(tempDir) + 2)
            files.Push(Map(
                "path", StrReplace(rel, "\", "/"),
                "sha256", CRD3_SHA256File(A_LoopFileFullPath),
                "bytes", A_LoopFileSize
            ))
        }
        manifest := Map(
            "manifestVersion", "1.0.0",
            "databaseType", "pharmacist.guide.clinical-reasoning-database",
            "releaseVersion", LTrim(releaseName, "v"),
            "releaseChannel", channel,
            "schemaVersion", CRD3_SchemaVersion,
            "createdAt", A_NowUTC,
            "createdBy", createdBy,
            "notes", notes,
            "validationSummary", Map(
                "schemaValidated", CRD3_JSONFalse(),
                "schemaCounts", Map(),
                "policy", Map(
                    "channel", "draft",
                    "valid", CRD3_JSONTrue(),
                    "errors", [],
                    "warnings", ["AHK-created releases are draft-only and require workbench validation before promotion."],
                    "counts", Map()
                )
            ),
            "fileCount", files.Length,
            "files", files
        )
        CRD3_WriteJson(tempDir "\manifest.json", manifest)
        DirMove(tempDir, releaseDir)
    } catch as err {
        if DirExist(tempDir)
            DirDelete(tempDir, true)
        throw err
    }
    CRD3_VerifyRelease(releaseDir)
    return releaseDir
}

CRD3_IsSafeRelativePath(relative) {
    relative := StrReplace(relative, "\", "/")
    if (relative = "" || SubStr(relative, 1, 1) = "/" || InStr(relative, ":"))
        return false
    for part in StrSplit(relative, "/")
        if (part = "" || part = "." || part = "..")
            return false
    return true
}

CRD3_VerifyRelease(releaseDir) {
    manifestPath := releaseDir "\manifest.json"
    if !FileExist(manifestPath)
        throw Error("Release manifest missing: " manifestPath)
    manifest := CRD3_ReadJson(manifestPath)
    errors := []
    expected := Map()
    if !manifest.Has("files") || Type(manifest["files"]) != "Array"
        throw Error("Release manifest files array is missing.")
    if manifest.Has("fileCount") && manifest["fileCount"] != manifest["files"].Length
        errors.Push("Manifest fileCount does not match files array length.")
    for item in manifest["files"] {
        relative := item["path"]
        if !CRD3_IsSafeRelativePath(relative) {
            errors.Push("Unsafe manifest path: " relative)
            continue
        }
        if expected.Has(relative)
            errors.Push("Duplicate manifest path: " relative)
        expected[relative] := true
        path := releaseDir "\" StrReplace(relative, "/", "\")
        if !FileExist(path) {
            errors.Push("Missing file: " relative)
            continue
        }
        if (CRD3_SHA256File(path) != StrLower(item["sha256"]))
            errors.Push("Checksum mismatch: " relative)
        if (FileGetSize(path) != item["bytes"])
            errors.Push("Size mismatch: " relative)
    }
    Loop Files, releaseDir "\*", "FR" {
        if (A_LoopFileName = "manifest.json")
            continue
        relative := StrReplace(SubStr(A_LoopFileFullPath, StrLen(releaseDir) + 2), "\", "/")
        if !expected.Has(relative)
            errors.Push("Unmanifested file: " relative)
    }
    if errors.Length
        throw Error("Release validation failed: " CRD3_Join(errors, "; "))
    return manifest
}

CRD3_ActivateRelease(releaseDir, activeDir) {
    CRD3_VerifyRelease(releaseDir)
    backupDir := activeDir ".backup"
    tempDir := activeDir "." A_TickCount ".tmp"
    try {
        if DirExist(tempDir)
            DirDelete(tempDir, true)
        DirCopy(releaseDir, tempDir)
        if DirExist(backupDir)
            DirDelete(backupDir, true)
        if DirExist(activeDir)
            DirMove(activeDir, backupDir)
        DirMove(tempDir, activeDir)
        if DirExist(backupDir)
            DirDelete(backupDir, true)
    } catch as err {
        if DirExist(tempDir)
            DirDelete(tempDir, true)
        if !DirExist(activeDir) && DirExist(backupDir)
            DirMove(backupDir, activeDir)
        throw err
    }
    return activeDir
}

CRD3_Rollback(releasesDir, version, activeDir) {
    releaseName := SubStr(version, 1, 1) = "v" ? version : "v" version
    return CRD3_ActivateRelease(releasesDir "\" releaseName, activeDir)
}

CRD3_Quote(value) {
    return '"' value '"'
}

CRD3_ArrayContains(array, needle) {
    if !IsObject(array)
        return false
    for value in array
        if (value = needle)
            return true
    return false
}

CRD3_Join(array, delimiter := ", ") {
    result := ""
    for index, value in array
        result .= (index > 1 ? delimiter : "") value
    return result
}

class CRD3_JSONBoolean {
    __New(value) {
        this.Value := value ? true : false
    }
}

CRD3_JSONTrue() {
    static instance := CRD3_JSONBoolean(true)
    return instance
}

CRD3_JSONFalse() {
    static instance := CRD3_JSONBoolean(false)
    return instance
}

CRD3_JSON_Stringify(value, pretty := true, level := 0) {
    indent := pretty ? CRD3_StrRepeat("  ", level) : ""
    childIndent := pretty ? CRD3_StrRepeat("  ", level + 1) : ""
    newline := pretty ? "`n" : ""
    space := pretty ? " " : ""
    typeName := Type(value)

    if (typeName = "CRD3_JSONBoolean")
        return value.Value ? "true" : "false"
    if (typeName = "Map") {
        parts := []
        for key, item in value
            parts.Push(childIndent CRD3_JSON_Escape(key) ":" space CRD3_JSON_Stringify(item, pretty, level + 1))
        if !parts.Length
            return "{}"
        return "{" newline CRD3_Join(parts, "," newline) newline indent "}"
    }
    if (typeName = "Array") {
        parts := []
        for item in value
            parts.Push(childIndent CRD3_JSON_Stringify(item, pretty, level + 1))
        if !parts.Length
            return "[]"
        return "[" newline CRD3_Join(parts, "," newline) newline indent "]"
    }
    if (typeName = "Integer" || typeName = "Float")
        return value
    if (typeName = "String")
        return CRD3_JSON_Escape(value)
    throw Error("Unsupported JSON value type: " typeName)
}

CRD3_JSON_Escape(value) {
    value := StrReplace(value, "\", "\\")
    value := StrReplace(value, '"', '\"')
    value := StrReplace(value, "`b", "\b")
    value := StrReplace(value, "`f", "\f")
    value := StrReplace(value, "`n", "\n")
    value := StrReplace(value, "`r", "\r")
    value := StrReplace(value, "`t", "\t")
    return '"' value '"'
}

CRD3_JSON_Parse(text) {
    position := 1
    value := CRD3_JSON_ParseValue(text, &position)
    CRD3_JSON_SkipWhitespace(text, &position)
    if (position <= StrLen(text))
        throw Error("Unexpected trailing JSON content at position " position)
    return value
}

CRD3_JSON_ParseValue(text, &position) {
    CRD3_JSON_SkipWhitespace(text, &position)
    char := SubStr(text, position, 1)
    if (char = "{")
        return CRD3_JSON_ParseObject(text, &position)
    if (char = "[")
        return CRD3_JSON_ParseArray(text, &position)
    if (char = '"')
        return CRD3_JSON_ParseString(text, &position)
    if RegExMatch(SubStr(text, position), "^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?", &match) {
        position += StrLen(match[0])
        return match[0] + 0
    }
    if (SubStr(text, position, 4) = "true") {
        position += 4
        return CRD3_JSONTrue()
    }
    if (SubStr(text, position, 5) = "false") {
        position += 5
        return CRD3_JSONFalse()
    }
    if (SubStr(text, position, 4) = "null") {
        position += 4
        return ""
    }
    throw Error("Invalid JSON value at position " position)
}

CRD3_JSON_ParseObject(text, &position) {
    result := Map()
    position += 1
    CRD3_JSON_SkipWhitespace(text, &position)
    if (SubStr(text, position, 1) = "}") {
        position += 1
        return result
    }
    loop {
        CRD3_JSON_SkipWhitespace(text, &position)
        if (SubStr(text, position, 1) != '"')
            throw Error("JSON object key expected at position " position)
        key := CRD3_JSON_ParseString(text, &position)
        CRD3_JSON_SkipWhitespace(text, &position)
        if (SubStr(text, position, 1) != ":")
            throw Error("JSON colon expected at position " position)
        position += 1
        result[key] := CRD3_JSON_ParseValue(text, &position)
        CRD3_JSON_SkipWhitespace(text, &position)
        char := SubStr(text, position, 1)
        if (char = "}") {
            position += 1
            return result
        }
        if (char != ",")
            throw Error("JSON comma expected at position " position)
        position += 1
    }
}

CRD3_JSON_ParseArray(text, &position) {
    result := []
    position += 1
    CRD3_JSON_SkipWhitespace(text, &position)
    if (SubStr(text, position, 1) = "]") {
        position += 1
        return result
    }
    loop {
        result.Push(CRD3_JSON_ParseValue(text, &position))
        CRD3_JSON_SkipWhitespace(text, &position)
        char := SubStr(text, position, 1)
        if (char = "]") {
            position += 1
            return result
        }
        if (char != ",")
            throw Error("JSON comma expected at position " position)
        position += 1
    }
}

CRD3_JSON_ParseString(text, &position) {
    if (SubStr(text, position, 1) != '"')
        throw Error("JSON string expected at position " position)
    position += 1
    result := ""
    length := StrLen(text)
    while (position <= length) {
        char := SubStr(text, position, 1)
        position += 1
        if (char = '"')
            return result
        if (char != "\") {
            result .= char
            continue
        }
        escape := SubStr(text, position, 1)
        position += 1
        switch escape {
            case '"': result .= '"'
            case "\": result .= "\"
            case "/": result .= "/"
            case "b": result .= "`b"
            case "f": result .= "`f"
            case "n": result .= "`n"
            case "r": result .= "`r"
            case "t": result .= "`t"
            case "u":
                hex := SubStr(text, position, 4)
                if !RegExMatch(hex, "i)^[0-9a-f]{4}$")
                    throw Error("Invalid JSON unicode escape at position " position)
                result .= Chr("0x" hex)
                position += 4
            default: throw Error("Invalid JSON escape at position " position)
        }
    }
    throw Error("Unterminated JSON string.")
}

CRD3_JSON_SkipWhitespace(text, &position) {
    while RegExMatch(SubStr(text, position, 1), "\s")
        position += 1
}

CRD3_StrRepeat(value, count) {
    result := ""
    Loop count
        result .= value
    return result
}

#Requires AutoHotkey v2.0
#SingleInstance Force

; ============================================================
; Double-tap Numpad Enter to dismiss a Cerner Discern alert.
; A SINGLE press of Numpad Enter behaves completely normally
; (passes through untouched) so it never interferes with your
; regular typing/order entry. Only a DOUBLE-tap within the
; timeout window triggers the dismiss action.
;
; You are always the one who decides to double-tap — the script
; does not detect or auto-click any popup on its own.
; ============================================================

DoubleTapMs := 350

lastPress := 0
pendingSingle := false

*NumpadEnter::
{
    global lastPress, pendingSingle
    now := A_TickCount

    if (now - lastPress <= DoubleTapMs) {
        ; --- Double-tap detected ---
        pendingSingle := false  ; cancel the queued single-press send
        DismissDialog()
        lastPress := 0
        return
    }

    ; --- First press: wait briefly to see if a second tap follows ---
    lastPress := now
    pendingSingle := true
    SetTimer(SendDelayedSingle, -DoubleTapMs - 1)
    return
}

SendDelayedSingle() {
    global pendingSingle
    if (pendingSingle) {
        pendingSingle := false
        Send("{NumpadEnter}")   ; behave like a normal single press
    }
}

DismissDialog() {
    if not (WinActive("ahk_exe DiscernClientService.exe")
        or WinActive("Discern")
        or WinActive("ahk_class ThunderRT6FormDC")) {
        Send("{Enter}")
        return
    }

    CoordMode("Mouse", "Screen")
    origX := 0, origY := 0
    MouseGetPos(&origX, &origY)
    hwnd := WinGetID("A")
    if CernerDismiss_ByControlText(hwnd) {
        MouseMove(origX, origY, 0)
        return
    }

    title := WinGetTitle("ahk_id " hwnd)
    profiles := []
    if InStr(title, "Medication condition alert")
        profiles.Push({overrideX:29, overrideY:673, okX:1177, okY:718})
    else if InStr(title, "Dose Range Alert")
        profiles.Push({overrideX:28, overrideY:363, okX:824, okY:458})
    else
        profiles.Push({continueX:27, continueY:341, okX:820, okY:411})

    for layout in profiles {
        CoordMode("Mouse", "Window")
        if layout.HasOwnProp("overrideX") {
            Click(layout.overrideX, layout.overrideY)
            Sleep(80)
            Send("{Enter}")
            CernerDismiss_ReasonDialog()
        } else {
            Click(layout.continueX, layout.continueY)
            Sleep(100)
            Click(layout.okX, layout.okY)
        }
        CoordMode("Mouse", "Screen")
        MouseMove(origX, origY, 0)
        return
    }
}

CernerDismiss_ReasonDialog() {
    if WinWaitActive("Provide Reason for Override",,2)
        Send("{Enter}")
}

CernerDismiss_ByControlText(hwnd) {
    continueControl := ""
    confirmControl := ""
    for control in WinGetControls("ahk_id " hwnd) {
        try text := Trim(ControlGetText(control, "ahk_id " hwnd))
        catch
            continue
        if continueControl = "" && RegExMatch(text, "i)^(?:continue|proceed)$")
            continueControl := control
        if confirmControl = "" && RegExMatch(text, "i)^(?:ok|yes)$")
            confirmControl := control
    }
    if continueControl != ""
        ControlClick(continueControl, "ahk_id " hwnd)
    if confirmControl != "" {
        if continueControl != ""
            Sleep(100)
        ControlClick(confirmControl, "ahk_id " hwnd)
        return true
    }
    return false
}

PopupCloser_IsEnabled() {
    global AppSettingsIniPath
    try return IniRead(AppSettingsIniPath, "Automation", "NotificationPopupCloser", "1") = "1"
    return false
}

PopupCloser_Toggle(*) {
    global AppSettingsIniPath
    enabled := !PopupCloser_IsEnabled()
    IniWrite(enabled ? "1" : "0", AppSettingsIniPath, "Automation", "NotificationPopupCloser")
    PopupCloser_Refresh()
    InitTray()
}

PopupCloser_Refresh() {
    global PopupCloserImagePath, PopupCloserTimerActive
    enabled := PopupCloser_IsEnabled() && FileExist(PopupCloserImagePath)
    SetTimer(PopupCloser_Check, enabled ? 150 : 0)
    PopupCloserTimerActive := enabled
}

PopupCloser_Check(*) {
    global PopupCloserImagePath
    static busy := false
    if busy || !WinActive("ahk_exe DiscernClientService.exe")
        return
    busy := true
    try {
        screenW := A_ScreenWidth
        screenH := A_ScreenHeight
        if ImageSearch(&foundX, &foundY, Max(0, screenW - 240), 0, screenW, Min(screenH, 420), "*20 " PopupCloserImagePath) {
            MouseGetPos(&priorX, &priorY)
            Click(foundX + 5, foundY + 5)
            MouseMove(priorX, priorY, 0)
        }
    } catch {
    } finally {
        busy := false
    }
}



PatientV7_GridNumericFragment(text) {
    t := Trim(String(text))
    if RegExMatch(t, "^\d{1,4}$")
        return t
    if RegExMatch(t, "^\.\d{1,4}$")
        return t
    return ""
}

PatientV7_UniqueDecimalRepair(token, def) {
    digits := RegExReplace(String(token), "\D", "")
    if StrLen(digits) < 2
        return ""
    candidates := Map()
    Loop StrLen(digits) - 1 {
        split := A_Index
        candidate := SubStr(digits, 1, split) "." SubStr(digits, split + 1)
        value := Number(candidate)
        if value >= def.lo && value <= def.hi
            candidates[PatientV7_NormalizedGridNumber(value)] := true
    }
    if candidates.Count != 1
        return ""
    for value, _ in candidates
        return value
    return ""
}

PatientV11_FocusedCellValue(x, y, w, h, def) {
    passes := [
        PatientV2_TryOcrRect(x, y, w, h, 3.2, false),
        PatientV2_TryOcrRect(x, y, w, h, 4.4, true)
    ]
    values := Map()
    passValues := []
    passRaw := []
    raw := ""
    for result in passes {
        if !IsObject(result)
        {
            passValues.Push("")
            passRaw.Push("")
            continue
        }
        value := PatientV7_SingleGridNumber(result, def)
        try rawText := Trim(result.Text)
        catch
            rawText := ""
        passValues.Push(value)
        passRaw.Push(rawText)
        try raw .= (raw = "" ? "" : " | ") rawText
        if value = ""
            continue
        values[value] := values.Has(value) ? values[value] + 1 : 1
    }

    best := ""
    bestCount := 0
    tied := false
    for value, count in values {
        if count > bestCount {
            best := value
            bestCount := count
            tied := false
        } else if count = bestCount {
            tied := true
        }
    }
    ; If one transform preserved a decimal but the other dropped it (1.60 vs
    ; 160), the raw digit sequence and the narrow cell geometry still agree.
    ; Prefer the explicitly decimalized observation; do not manufacture a
    ; decimal when neither pass shows one.
    if best != "" && bestCount < 2 {
        for index, value in passValues {
            if value = ""
                continue
            digits := PatientV11_RawDigits(passRaw[index])
            if digits = ""
                continue
            for otherIndex, otherValue in passValues {
                if index = otherIndex || otherValue != ""
                    continue
                if PatientV11_RawDigits(passRaw[otherIndex]) != digits
                    continue
                if !RegExMatch(passRaw[index], "\d[\.,]\d")
                    continue
                best := value
                bestCount := 2
                tied := false
                break
            }
            if bestCount >= 2
                break
        }
    }
    if best = "" || tied || bestCount < 2
        return 0
    return {value:best, support:bestCount, raw:raw}
}

PatientV11_RawDigits(text) {
    return RegExReplace(String(text), "\D", "")
}

PatientV11_GridEvidenceSufficient(result) {
    if !IsObject(result)
        return false
    words := PatientV7_ResultWords(result)
    if words.Length = 0
        return false
    probe := {labGrid:result, orders:0, sidebar:0, headerLeft:0, headerRight:0}
    headers := PatientV7_GridHeaders(words)
    times := PatientV7_GridTimes(words)
    numeric := 0
    for word in words {
        if PatientV7_GridNumericToken(word.text) != ""
            numeric += 1
    }
    ; Two or more headers plus two grounded numeric cells are enough to trust
    ; the direct pass. Missing analytes remain missing; this is not a value
    ; completeness test.
    return headers.Length >= 2 && numeric >= 2 && (times.Length > 0 || headers.Length >= 3)
}

PatientV11_ExtractFixedOrderGridLabs(bundle) {
    labs := PatientV7_ExtractGridLabsFromBundle(bundle)
    words := PatientV7_LabBundleWords(bundle)
    if words.Length = 0
        return labs

    headers := PatientV7_GridHeaders(words)
    if headers.Length = 0
        return labs

    times := PatientV7_GridTimes(words)
    plans := PatientV8_BuildBandPlans(headers)
    if plans.Length = 0
        return PatientV7_SortGeometry(PatientV8_RecomputeRowSupport(labs), false, true)

    for plan in plans {
        nextY := PatientV8_NextBandY(plans, plan)
        ; false is critical: row geometry must come from visible evidence only.
        rows := PatientV8_BandRows(words, times, plan, nextY, labs, false)
        if rows.Length = 0
            continue
        halfCache := Map()
        for headerKey, candidate in plan.anchors {
            header := candidate.header
            if !IsObject(header) || !header.HasOwnProp("def")
                continue
            bounds := PatientV7_GridColumnBounds(headers, header)
            for row in rows {
                if PatientV8_LabAtRow(labs, header.key, row.y, Max(10, row.h * 0.9))
                    continue
                cacheKey := Round(row.y / 4)
                if !halfCache.Has(cacheKey)
                    halfCache[cacheKey] := PatientV8_CellRowHalfHeight(rows, row)
                halfHeight := halfCache[cacheKey]
                cropX := Round(bounds.left)
                cropW := Max(40, Round(bounds.right - bounds.left))
                cropY := Round(row.y - halfHeight)
                cropH := Max(10, Round(halfHeight * 2))
                ToolTip "READING " StrUpper(PCtx_LabLabel(header.key)) "  ·  FIXED-ORDER CELL"
                focused := PatientV11_FocusedCellValue(cropX, cropY, cropW, cropH, header.def)
                if !IsObject(focused)
                    continue
                labs.Push({
                    key:header.key,
                    value:focused.value,
                    unit:header.def.unit,
                    when:row.when,
                    conf:"moderate",
                    source:"Cerner fixed-order grid; visible header and evidenced result row; no template-only row assumed; source unit inferred from configured analyte profile (" header.def.unit ")",
                    raw:PCtx_LabLabel(header.key) " fixed-order focused cell " focused.raw,
                    screenY:row.y,
                    x:cropX,
                    y:cropY,
                    w:cropW,
                    h:cropH,
                    headerX:header.x,
                    headerY:header.y,
                    ocrSupport:focused.support,
                    rowSupport:1,
                    focusedConfirmed:true,
                    verifyOriginal:focused.value,
                    verifyNormal:"",
                    verifyGray:""
                })
            }
        }
    }

    ; A deliberately cropped or stacked Cerner panel may contain no readable
    ; timestamp and may put a value beside/below its label instead of in a
    ; normal horizontal result row. Recover only numeric tokens that are
    ; inside the visible header's own local column block. The cell is then
    ; re-read with the same two-pass consensus; no schema coordinate is used
    ; to manufacture a candidate.
    if times.Length = 0 {
        for header in headers {
            if !IsObject(header) || !header.HasOwnProp("def")
                continue
            for cell in PatientV11_VisibleCellCandidates(words, headers, header) {
                if PatientV11_HasLabNearKey(labs, header.key, cell.y)
                    continue
                crop := PatientV11_VisibleCellCrop(header, cell)
                focused := PatientV11_FocusedCellValue(crop.x, crop.y, crop.w, crop.h, header.def)
                if !IsObject(focused)
                    continue
                labs.Push({
                    key:header.key,
                    value:focused.value,
                    unit:header.def.unit,
                    when:"",
                    conf:"moderate",
                    source:"Cerner fixed-order visible header/cell block; no timestamp was captured; source unit inferred from configured analyte profile (" header.def.unit ")",
                    raw:PCtx_LabLabel(header.key) " visible cell " focused.raw,
                    screenY:cell.y,
                    x:crop.x,
                    y:crop.y,
                    w:crop.w,
                    h:crop.h,
                    headerX:header.x,
                    headerY:header.y,
                    ocrSupport:focused.support,
                    rowSupport:1,
                    focusedConfirmed:true,
                    verifyOriginal:focused.value,
                    verifyNormal:"",
                    verifyGray:""
                })
            }
        }
    }

    return PatientV7_SortGeometry(PatientV8_RecomputeRowSupport(labs), false, true)
}

PatientV11_VisibleCellCandidates(words, headers, header) {
    bounds := PatientV7_GridColumnBounds(headers, header)
    ; OCR may place the numeric cell to the right of the midpoint between
    ; long neighboring labels (for example "Creatinine Level" followed by
    ; 1.60). Give the header a bounded local extension without allowing the
    ; entire results canvas to become one candidate column.
    bounds.left := Min(bounds.left, header.x - Max(120, header.h * 5))
    bounds.right := Max(bounds.right, header.x + Max(280, header.w + 170))
    top := header.y + header.h * 0.25
    bottom := header.y + Max(90, header.h * 8)
    for other in headers {
        if other = header || other.y <= header.y + header.h
            continue
        if Abs(other.x - header.x) > Max(180, header.w * 1.5)
            continue
        bottom := Min(bottom, other.y - Max(3, header.h * 0.25))
    }
    candidates := []
    seen := Map()
    for word in words {
        centerX := word.x + word.w / 2
        centerY := word.y + word.h / 2
        if centerX < bounds.left || centerX >= bounds.right
            continue
        if centerY <= top || centerY >= bottom
            continue
        token := PatientV7_GridNumericToken(word.text)
        if token = ""
            token := PatientV7_GridNumericFragment(word.text)
        if token = ""
            continue
        sig := Round(centerX / 4) "|" Round(centerY / 4)
        if seen.Has(sig)
            continue
        seen[sig] := true
        candidates.Push({ x:word.x, y:word.y, w:word.w, h:word.h, token:token })
    }
    candidates := PatientV7_SortGeometry(candidates)
    while candidates.Length > 2
        candidates.Pop()
    return candidates
}

PatientV11_HasLabNearKey(labs, key, y) {
    for lab in labs {
        if lab.key = key && Abs(lab.screenY - y) <= Max(12, lab.h * 0.9)
            return true
    }
    return false
}

PatientV11_VisibleCellCrop(header, cell) {
    left := Max(1, Round(Min(header.x - Max(32, header.w * 0.6), cell.x - Max(30, cell.w * 2))))
    right := Round(Max(cell.x + cell.w + Max(34, cell.w * 2), header.x + header.w + Max(34, header.w * 0.35)))
    top := Max(1, Round(Min(header.y - Max(28, header.h * 2), cell.y - Max(48, header.h * 4))))
    bottom := Round(cell.y + cell.h + Max(38, header.h * 3))
    return {x:left, y:top, w:Max(60, Min(420, right - left)), h:Max(60, Min(180, bottom - top))}
}

; RC28 COMBINED UTILITIES
#HotIf
^Up::SafeRun(Combined_OpenBUD)
^!d::SafeRun(FillDate_Open)
#HotIf FillDate_IsSourceActive()
~+LButton::SafeRun(FillDate_FromClick)
#HotIf MCDS_IsActive()
F10::SafeRun(MCDS_Preview, false)
F11::SafeRun(MCDS_Preview, true)
#HotIf
; ---------------- ENTRY GUI ----------------
BUD_ShowEntryGui() {
    global BUD_AnchorOffsetSec

    anchorTime := DateAdd(A_Now, BUD_AnchorOffsetSec, "Seconds")
    anchorNote := BUD_AnchorOffsetSec = 0 ? "" : "Anchor shifted to: " . FormatTime(anchorTime, "yyyy-MM-dd HH:mm:ss")

    entryGui := Gui("+AlwaysOnTop", "PhUCKIT - BUD Date/Time Arithmetic")
    entryGui.SetFont("s10")
    entryGui.AddText("w400", "Date arithmetic only. Does not determine a preparation-specific BUD or validate stability/storage.")
    entryGui.AddText("w300", "Enter approved duration (4h, 2d, 1w, 3m):")
    edit := entryGui.AddEdit("w220 vInput")
    infoBtn := entryGui.AddButton("x+8 w24 h24", "i")
    infoBtn.SetFont("s9 bold")

    infoTip := "4h/2d/1w/3m = amount+unit  |  -2d = 2 days ago  |  On results: 'b 3d' shifts NOW back 3 days"
    BUD_AttachHoverTip(infoBtn, infoTip)

    if anchorNote != ""
        entryGui.AddText("w300 cRed", anchorNote)

    okBtn := entryGui.AddButton("w100 Default", "OK")
    cancelBtn := entryGui.AddButton("x+10 w100", "Cancel")

    okBtn.OnEvent("Click", (*) => BUD_SubmitEntry(entryGui, edit))
    cancelBtn.OnEvent("Click", (*) => entryGui.Destroy())
    infoBtn.OnEvent("Click", (*) => BUD_ShowHelp())
    entryGui.OnEvent("Close", (*) => entryGui.Destroy())


    Combined_Footer(entryGui, 400)
    entryGui.Show()
    edit.Focus()
}

BUD_SubmitEntry(entryGui, edit) {
    input := Trim(edit.Value)
    entryGui.Destroy()
    if input = ""
        return

    if !RegExMatch(input, "i)^(-?\d+)\s*([dhmw])$", &m) {
        MsgBox("Invalid format. Use a number followed by D, H, M, or W (e.g. 4h, -2d).", "Error", "Icon!")
        return
    }

    global BUD_AnchorOffsetSec
    amount := Integer(m[1])
    unit := StrLower(m[2])
    anchorTime := DateAdd(A_Now, BUD_AnchorOffsetSec, "Seconds")
    try newTime := BUD_AddUnit(anchorTime, amount, unit)
    catch {
        MsgBox("The calculated date is outside the supported range.", "Date calculation")
        return
    }
    BUD_ShowResultGui(newTime)
}

BUD_AddUnit(baseTime, amount, unit) {
    switch unit {
        case "d":
            return DateAdd(baseTime, amount, "Days")
        case "h":
            return DateAdd(baseTime, amount, "Hours")
        case "m":
            return Combined_AddMonths(baseTime, amount)
        case "w":
            return DateAdd(baseTime, amount * 7, "Days")
    }
}

; ---------------- RESULT GUI ----------------
BUD_ShowResultGui(newTime) {
    formatted := FormatTime(newTime, "yyyy-MM-dd HH:mm:ss")
    friendly := FormatTime(newTime, "dddd, MMMM d, yyyy h:mm tt")
    A_Clipboard := formatted

    resultGui := Gui("+AlwaysOnTop", "Result")
    resultGui.SetFont("s10")
    resultGui.AddText("w360", "Copied to clipboard:")
    resultGui.SetFont("s12 bold")
    resultGui.AddText("w360", formatted)
    resultGui.SetFont("s9 norm")
    resultGui.AddText("w360", friendly)

    resultGui.SetFont("s10")
    resultGui.AddText("w360 y+15", "Enter new value, or 'b <n><unit>' to shift now:")
    edit := resultGui.AddEdit("w260 vInput")
    infoBtn := resultGui.AddButton("x+8 w24 h24", "i")
    infoBtn.SetFont("s9 bold")

    infoTip := "Plain value (6h) = recalc from current anchor`n'b 3d' = shift now back 3 days, then re-enter`n'b -3d' = shift now forward instead"
    BUD_AttachHoverTip(infoBtn, infoTip)

    okBtn := resultGui.AddButton("w100 Default y+15", "OK")
    closeBtn := resultGui.AddButton("x+10 w100", "Close")

    okBtn.OnEvent("Click", (*) => BUD_SubmitResult(resultGui, edit))
    closeBtn.OnEvent("Click", (*) => resultGui.Destroy())
    infoBtn.OnEvent("Click", (*) => BUD_ShowHelp())
    resultGui.OnEvent("Close", (*) => resultGui.Destroy())


    Combined_Footer(resultGui, 430)
    resultGui.Show()
    edit.Focus()
}

BUD_SubmitResult(resultGui, edit) {
    global BUD_AnchorOffsetSec
    newInput := Trim(edit.Value)
    resultGui.Destroy()
    if newInput = ""
        return

    ; Backdate command: "b <amount><unit>"
    if RegExMatch(newInput, "i)^b\s*(-?\d+)\s*([dhmw])$", &bm) {
        bAmount := Integer(bm[1])
        bUnit := StrLower(bm[2])
        shiftAmount := -bAmount
        try shiftedTime := BUD_AddUnit(A_Now, shiftAmount, bUnit)
        catch {
            MsgBox("The anchor date is outside the supported range.", "Date calculation")
            return
        }
        BUD_AnchorOffsetSec := DateDiff(shiftedTime, A_Now, "Seconds")
        BUD_ShowEntryGui()
        return
    }

    if !RegExMatch(newInput, "i)^(-?\d+)\s*([dhmw])$", &m2) {
        MsgBox("Invalid format.", "Error", "Icon!")
        return
    }

    amount := Integer(m2[1])
    unit := StrLower(m2[2])
    anchorTime := DateAdd(A_Now, BUD_AnchorOffsetSec, "Seconds")
    try newTime := BUD_AddUnit(anchorTime, amount, unit)
    catch {
        MsgBox("The calculated date is outside the supported range.", "Date calculation")
        return
    }
    BUD_ShowResultGui(newTime)
}

; ---------------- HOVER TOOLTIP HELPER ----------------
; Attaches a mouse-hover tooltip to any control using a timer to poll mouse position.
BUD_AttachHoverTip(ctrl, tipText) {
    ; Help remains on the visible i button. No permanent polling timer is needed.
}

BUD_CheckHoverProc(ctrl, tipText, state) {
    try {
        MouseGetPos(&mx, &my, &winUnderMouse, &ctrlUnderMouse, 2)
        ctrlHwnd := ctrl.Hwnd
        if (ctrlUnderMouse = ctrlHwnd) {
            if !state.isOver {
                state.isOver := true
            }
            ToolTip(tipText, mx + 20, my + 20)
        } else {
            if state.isOver {
                state.isOver := false
            }
            ToolTip()
        }
    } catch {
        ToolTip()
    }
}

; ---------------- HELP GUI (still available via click) ----------------
BUD_ShowHelp() {
    helpGui := Gui("+AlwaysOnTop", "Help - Date/Time Calc")
    helpGui.SetFont("s10")

    helpText := "
    (
HOTKEY
  Ctrl + Up Arrow   Opens entry box (always starts from real "now")

ENTRY BOX
  Type a number followed by a unit letter:
    D = Days
    H = Hours
    M = Months
    W = Weeks

  Examples:
    4h      -> 4 hours from now
    2d      -> 2 days from now
    1w      -> 1 week from now
    3m      -> 3 months from now
    -2d     -> 2 days before now

  Press Enter or click OK to calculate.
  Result is auto-copied to your clipboard.

RESULT SCREEN
  From here you can type again:

  Plain value (e.g. 6h)
    Recalculates from the current anchor (real now unless shifted).

  'b <n><unit>' (e.g. b 3d)
    Shifts the "now" anchor BACK by that amount,
    then reopens the entry box so you can add
    more time on top of that shifted anchor.
    Example: b 3d, then 4h
      = 3 days ago, plus 4 hours

  'b -<n><unit>' (e.g. b -3d)
    Shifts the anchor FORWARD instead (opposite
    of backdating), if you ever need it.

  Leave blank and click Close/Cancel to finish.

NOTES
  - Every fresh Ctrl+Up resets the anchor to the
    real current time - shifts never persist
    between sessions.
  - Months auto-adjust for shorter target months
    (e.g. Jan 31 + 1 month lands on last day of Feb).
  - Weeks are calculated as 7 x days.
    )"

    helpGui.AddText("w420", helpText)
    closeBtn := helpGui.AddButton("w100 Default y+15", "Close")
    closeBtn.OnEvent("Click", (*) => helpGui.Destroy())
    helpGui.OnEvent("Close", (*) => helpGui.Destroy())
    Combined_Footer(helpGui, 430)
    helpGui.Show()
}
MCDS_RunOverrideAutomation()
{
    CoordMode("Mouse", "Screen")
    CoordMode("Pixel", "Screen")
    global MCDS_DropdownXFromRight
    global MCDS_DropdownYFromHighlight
    global MCDS_ContinueXFromRight
    global MCDS_ContinueYFromHighlight
    global MCDS_OverrideOption
    global MCDS_AutoContinue


    ; --------------------------------------------------------
    ; Find mCDS.
    ;
    ; It does NOT need to currently be active.
    ; --------------------------------------------------------

    hwnd := MCDS_FindMCDSWindow()


    if !hwnd
    {
        MsgBox(
            "Could not locate the mCDS patient window.",
            "mCDS Automation",
            "Icon!"
        )

        return
    }


    ; Save mouse location so it can be restored afterward.
    MouseGetPos &oldX, &oldY


    try
    {
        ; ====================================================
        ; ACTIVATE mCDS
        ; ====================================================

        MCDS_ActivateMCDS(hwnd)


        ; ====================================================
        ; CTRL+F -> Override Reason -> ESC
        ;
        ; Ctrl+F performs the scrolling.
        ;
        ; Returns the vertical center of the highlighted
        ; "Override Reason" text.
        ; ====================================================

        highlightY := MCDS_PrepareOverrideTarget(hwnd)


        if !highlightY
        {
            MsgBox(
                "Override Reason was searched for, but the "
                . "blue Ctrl+F highlight could not be located.",
                "mCDS Automation",
                "Icon!"
            )

            return
        }


        ; ====================================================
        ; GET CURRENT WINDOW POSITION AND DPI
        ; ====================================================

        scale := MCDS_GetWindowScale(hwnd)


        WinGetPos(
            &wx,
            &wy,
            &ww,
            &wh,
            "ahk_id " hwnd
        )


        rightEdge := wx + ww


        ; ====================================================
        ; CALCULATE OVERRIDE DROPDOWN POSITION
        ;
        ; Notice that this does NOT depend on:
        ;
        ;   - desktop resolution
        ;   - screen width
        ;   - screen height
        ;   - mCDS window height
        ;
        ; X follows the RIGHT edge of mCDS.
        ; Y follows the Ctrl+F highlight.
        ; ====================================================

        dropdownX :=
            rightEdge
            - Round(
                MCDS_DropdownXFromRight
                * scale
            )


        dropdownY :=
            highlightY
            + Round(
                MCDS_DropdownYFromHighlight
                * scale
            )


        ; ====================================================
        ; CLICK OVERRIDE REASON
        ; ====================================================

        Combined_RequirePoint(hwnd, dropdownX, dropdownY)
        MouseMove dropdownX, dropdownY, 0

        Sleep 200

        Combined_RequireWindow(hwnd)
        Click

        Sleep 350


        ; ====================================================
        ; SELECT:
        ;
        ; Pharmacist Clinical Judgement
        ;
        ; Type-ahead means we don't depend on option order.
        ; ====================================================

        Combined_RequireWindow(hwnd)
        MCDS_TypeDropdownText(
            MCDS_OverrideOption
        )


        Sleep 250


        Combined_RequireWindow(hwnd)
        Send "{Enter}"


        Sleep 650


        ; ====================================================
        ; OPTIONAL STOP
        ; ====================================================

        if !MCDS_AutoContinue
        {
            ToolTip(
                "Review the selected reason, then click Continue yourself:`n"
                . MCDS_OverrideOption
            )

            SetTimer(
                () => ToolTip(),
                -3000
            )

            return
        }


        ; ====================================================
        ; CONTINUE BUTTON
        ; ====================================================

        ; Re-read current mCDS position in case something
        ; changed after selecting the reason.

        WinGetPos(
            &wx,
            &wy,
            &ww,
            &wh,
            "ahk_id " hwnd
        )


        rightEdge := wx + ww

        scale := MCDS_GetWindowScale(hwnd)


        ; X follows current mCDS right edge.
        continueX :=
            rightEdge
            - Round(
                MCDS_ContinueXFromRight
                * scale
            )


        ; Y follows current Override Reason highlight.
        continueY :=
            highlightY
            + Round(
                MCDS_ContinueYFromHighlight
                * scale
            )


        ; ====================================================
        ; CLICK CONTINUE
        ; ====================================================

        Combined_RequirePoint(hwnd, continueX, continueY)
        MouseMove continueX, continueY, 0

        Sleep 300

        Combined_RequireWindow(hwnd)
        Click

        Sleep 400
    }
    finally
    {
        ; Restore original mouse location.
        MouseMove oldX, oldY, 0
    }
}



; ============================================================
; PREPARE OVERRIDE TARGET
;
; Ctrl+F
; Override Reason
; Esc
;
; Ctrl+F handles scrolling regardless of how much alert
; content exists above the override controls.
;
; Returns the Y position of the highlighted text.
; ============================================================

MCDS_PrepareOverrideTarget(hwnd)
{
    global MCDS_SearchText


    MCDS_ActivateMCDS(hwnd)


    ; Open Find.
    Send "^f"


    Sleep 300


    ; Clear any previous search.
    Send "^a"


    Sleep 75


    ; Search for Override Reason.
    SendText MCDS_SearchText


    Sleep 600


    ; Close the Find box.
    ;
    ; mCDS leaves the matching words highlighted.
    Send "{Esc}"


    Sleep 350


    return MCDS_FindOverrideHighlightY(hwnd)
}



; ============================================================
; FIND CTRL+F HIGHLIGHT
;
; Observed highlight:
;
; RGB 51,103,209
; HEX #3367D1
;
; mCDS hyperlinks can also be blue, so a single blue pixel is
; NOT enough.
;
; We find candidate blue pixels, then verify that the area is
; a solid blue rectangle across several points.
; ============================================================

MCDS_FindOverrideHighlightY(hwnd)
{
    scale := MCDS_GetWindowScale(hwnd)


    WinGetPos(
        &wx,
        &wy,
        &ww,
        &wh,
        "ahk_id " hwnd
    )


    rightEdge := wx + ww


    ; ========================================================
    ; SEARCH REGION
    ;
    ; Search the right-hand portion of the CURRENT mCDS
    ; window.
    ;
    ; This is based on the mCDS window position, not the
    ; physical screen size.
    ; ========================================================

    searchLeft :=
        Max(
            wx + 5,
            rightEdge
            - Round(
                500 * scale
            )
        )


    searchRight :=
        rightEdge
        - Round(
            30 * scale
        )


    searchTop :=
        wy
        + Round(
            50 * scale
        )


    searchBottom :=
        wy
        + wh
        - Round(
            10 * scale
        )


    currentTop := searchTop


    ; ========================================================
    ; SEARCH CANDIDATES
    ; ========================================================

    Loop 40
    {
        px := 0
        py := 0


        try
        {
            found := PixelSearch(
                &px,
                &py,
                searchLeft,
                currentTop,
                searchRight,
                searchBottom,
                0x3367D1,
                8
            )
        }
        catch
        {
            return 0
        }


        if !found
            return 0


        ; Verify candidate.
        if MCDS_IsSolidFindHighlight(
            px,
            py,
            searchRight,
            searchBottom,
            scale
        )
        {
            ; py is approximately the top of the rectangle.
            ;
            ; Return its approximate vertical center.
            return py
                + Round(
                    8 * scale
                )
        }


        ; Not the Ctrl+F rectangle.
        ;
        ; Continue searching below this candidate.
        currentTop := py + 1


        if (currentTop >= searchBottom)
            break
    }


    return 0
}



; ============================================================
; VERIFY SOLID CTRL+F RECTANGLE
; ============================================================

MCDS_IsSolidFindHighlight(
    x,
    y,
    rightLimit,
    bottomLimit,
    scale
)
{
    dx1 := Round(10 * scale)
    dx2 := Round(30 * scale)
    dx3 := Round(55 * scale)

    dy1 := Max(
        1,
        Round(1 * scale)
    )

    dy2 := Max(
        2,
        Round(2 * scale)
    )

    dy3 := Max(
        3,
        Round(3 * scale)
    )


    if (
        x + dx3 > rightLimit
        || y + dy3 > bottomLimit
    )
    {
        return false
    }


    ; ========================================================
    ; TOP ROW
    ; ========================================================

    if !MCDS_IsFindBlue(x, y)
        return false


    if !MCDS_IsFindBlue(
        x + dx1,
        y
    )
        return false


    if !MCDS_IsFindBlue(
        x + dx2,
        y
    )
        return false


    if !MCDS_IsFindBlue(
        x + dx3,
        y
    )
        return false


    ; ========================================================
    ; ADDITIONAL ROWS
    ;
    ; Hyperlink underlines won't normally satisfy these.
    ; ========================================================

    if !MCDS_IsFindBlue(
        x + dx1,
        y + dy1
    )
        return false


    if !MCDS_IsFindBlue(
        x + dx2,
        y + dy2
    )
        return false


    if !MCDS_IsFindBlue(
        x + dx3,
        y + dy3
    )
        return false


    return true
}



; ============================================================
; TEST WHETHER PIXEL MATCHES FIND-HIGHLIGHT BLUE
; ============================================================

MCDS_IsFindBlue(x, y)
{
    try
        color := PixelGetColor(x, y)
    catch
        return false


    r :=
        (color >> 16)
        & 0xFF


    g :=
        (color >> 8)
        & 0xFF


    b :=
        color
        & 0xFF


    return (
        Abs(r - 51) <= 10
        && Abs(g - 103) <= 10
        && Abs(b - 209) <= 10
    )
}



; ============================================================
; TYPE DROPDOWN OPTION SLOWLY
;
; Slower sending is friendlier to the remote-rendered app.
; ============================================================

MCDS_TypeDropdownText(text)
{
    for character in StrSplit(text)
    {
        SendText character

        Sleep 18
    }
}



; ============================================================
; ACTIVATE mCDS
;
; If another window is active when ` + P is pressed,
; this explicitly brings mCDS to the foreground first.
; ============================================================

MCDS_ActivateMCDS(hwnd)
{
    try
    {
        WinRestore "ahk_id " hwnd
    }
    catch
    {
    }


    WinActivate "ahk_id " hwnd


    if !WinWaitActive(
        "ahk_id " hwnd,
        ,
        2
    )
    {
        throw Error(
            "mCDS was found but could not be activated."
        )
    }


    Sleep 250
}



; ============================================================
; FIND mCDS PATIENT WINDOW
; ============================================================

MCDS_FindMCDSWindow() {
    active := WinExist("A")
    if active && MCDS_IsMCDSPatientTitle(WinGetTitle("ahk_id " active))
        return active
    matches := []
    for hwnd in WinGetList() {
        try {
            if MCDS_IsMCDSPatientTitle(WinGetTitle("ahk_id " hwnd)) {
                WinGetPos(&x, &y, &w, &h, "ahk_id " hwnd)
                if w >= 500 && h >= 220
                    matches.Push(hwnd)
            }
        }
    }
    if matches.Length > 1
        throw Error("Multiple patient windows are open. Activate the intended mCDS patient first.")
    return matches.Length = 1 ? matches[1] : 0
}



; ============================================================
; IDENTIFY PATIENT mCDS WINDOW
;
; Examples:
;
; Example: TEST, PATIENT - 000000000000001
; Example: TEST, PATIENT - 000000000000001
;
; ============================================================

MCDS_IsMCDSPatientTitle(title)
{
    if (title = "")
        return false


    ; Don't select the parent Verify Med Order window.
    if InStr(
        title,
        "Verify Med Order",
        false
    )
    {
        return false
    }


    ; Patient mCDS title includes a long numeric ID.
    if RegExMatch(
        title,
        " - \d{10,}"
    )
    {
        return true
    }


    return false
}



; ============================================================
; WINDOWS DISPLAY / DPI SCALING
;
; At 100% Windows scaling:
;     scale = 1.00
;
; At 125%:
;     scale = 1.25
;
; At 150%:
;     scale = 1.50
;
; This is why the calibrated logical distances can adapt when
; moving between displays that use different Windows scaling.
; ============================================================

MCDS_GetWindowScale(hwnd)
{
    dpi := 96


    try
    {
        currentDPI :=
            DllCall(
                "user32\GetDpiForWindow",
                "Ptr", hwnd,
                "UInt"
            )


        if currentDPI
            dpi := currentDPI
    }
    catch
    {
        dpi := 96
    }


    return dpi / 96
}



; ============================================================

; Unified helpers. All clinical review stays local and in memory.
Combined_Footer(g, width := 760) {
    t := g.AddText("xm y+14 w" width, "© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    t.SetFont("s8", "Segoe UI")
}

Combined_RequireWindow(hwnd) {
    if !WinActive("ahk_id " hwnd)
        throw Error("The target window lost focus. Automation stopped; verify the current field before retrying.")
}

Combined_RequirePoint(hwnd, x, y) {
    Combined_RequireWindow(hwnd)
    WinGetPos(&wx, &wy, &ww, &wh, "ahk_id " hwnd)
    if x < wx || y < wy || x >= wx + ww || y >= wy + wh
        throw Error("The calculated target is outside the intended window. Check the layout and calibration.")
}

Combined_Tray() {
    A_TrayMenu.Add("Second Check - current session", (*) => SafeRun(SecondCheck_Current))
    A_TrayMenu.Add("BUD date arithmetic (Ctrl+Up)", (*) => SafeRun(Combined_OpenBUD))
    A_TrayMenu.Add("Fill date calculator (Ctrl+Alt+D)", (*) => SafeRun(FillDate_Open))
    A_TrayMenu.Add("Configure fill-date automation", (*) => SafeRun(FillDate_Configure))
}

Combined_OpenBUD() {
    global BUD_AnchorOffsetSec
    BUD_AnchorOffsetSec := 0
    BUD_ShowEntryGui()
}

Combined_AddMonths(stamp, months) {
    total := Integer(SubStr(stamp, 1, 4)) * 12 + Integer(SubStr(stamp, 5, 2)) - 1 + months
    year := Floor(total / 12), month := Mod(total, 12) + 1
    if year < 1601 || year > 9998
        throw ValueError("The calculated date is outside the supported calendar range.")
    nextYear := month = 12 ? year + 1 : year
    nextMonth := month = 12 ? 1 : month + 1
    last := DateAdd(Format("{:04}{:02}01", nextYear, nextMonth), -1, "Days")
    day := Min(Integer(SubStr(stamp, 7, 2)), Integer(SubStr(last, 7, 2)))
    return Format("{:04}{:02}{:02}", year, month, day) SubStr(stamp, 9)
}

FillDate_Calculate(lastFill, supply) {
    if !RegExMatch(Trim(lastFill), "^(\d{1,2})/(\d{1,2})/(\d{4})$", &m)
        throw ValueError("Use MM/DD/YYYY for the last fill date.")
    if !RegExMatch(Trim(supply), "^\d+$") || Number(supply) < 1 || Number(supply) > 9999
        throw ValueError("Days supply must be a whole number from 1 to 9999.")
    stamp := Format("{:04}{:02}{:02}", Integer(m[3]), Integer(m[1]), Integer(m[2]))
    try {
        normalized := FormatTime(stamp, "MM/dd/yyyy")
        if normalized != Format("{:02}/{:02}/{:04}", Integer(m[1]), Integer(m[2]), Integer(m[3]))
            throw ValueError("Invalid calendar date.")
        return FormatTime(DateAdd(stamp, Integer(supply), "Days"), "MM/dd/yyyy")
    } catch {
        throw ValueError("The date is not a valid supported calendar date.")
    }
}

FillDate_Config() {
    global AppSettingsIniPath
    return { source: IniRead(AppSettingsIniPath, "FillDate", "Source", ""),
        control: IniRead(AppSettingsIniPath, "FillDate", "Control", "SysListView321"),
        column: IniRead(AppSettingsIniPath, "FillDate", "Column", "4"),
        destination: IniRead(AppSettingsIniPath, "FillDate", "Destination", ""),
        dateControl: IniRead(AppSettingsIniPath, "FillDate", "DateControl", ""),
        okControl: IniRead(AppSettingsIniPath, "FillDate", "OkControl", ""),
        popup: IniRead(AppSettingsIniPath, "FillDate", "Popup", ""),
        dateX: IniRead(AppSettingsIniPath, "FillDate", "DateX", "235"),
        dateY: IniRead(AppSettingsIniPath, "FillDate", "DateY", "579"),
        okX: IniRead(AppSettingsIniPath, "FillDate", "OkX", "691"),
        okY: IniRead(AppSettingsIniPath, "FillDate", "OkY", "750"),
        popupX: IniRead(AppSettingsIniPath, "FillDate", "PopupX", "26"),
        popupY: IniRead(AppSettingsIniPath, "FillDate", "PopupY", "341") }
}

FillDate_IsSourceActive() {
    try {
        config := FillDate_Config()
        return config.source != "" && WinActive(config.source)
    }
    return false
}

FillDate_Configure() {
    config := FillDate_Config(), fields := Map()
    g := Gui("+MinimizeBox", "PhUCKIT - Fill Date Automation Setup")
    g.SetFont("s10", "Segoe UI")
    g.AddText("w740", "Calculate & Submit enters the date, clicks OK, clicks the popup target and sends Enter twice. Use Window Spy for window selectors and controls. The supplied script's coordinate defaults are retained below (window-relative pixels).")
    specs := [["source", "Source window (Shift+click)"], ["control", "Source ListView ClassNN"], ["column", "Last-fill column (starts at 1)"],
        ["destination", "Destination window selector"], ["dateControl", "Date field ClassNN (optional)"], ["okControl", "OK control ClassNN (optional)"],
        ["popup", "Popup selector (blank: detect new owned window)"], ["dateX", "Date field X"], ["dateY", "Date field Y"],
        ["okX", "OK button X"], ["okY", "OK button Y"], ["popupX", "Popup click X"], ["popupY", "Popup click Y"]]
    for spec in specs {
        g.AddText("xm y+9 w355", spec[2])
        fields[spec[1]] := g.AddEdit("x+8 yp-3 w360", config.%spec[1]%)
    }
    status := g.AddText("xm y+10 w740 h35", "Use a unique destination title/selector. Optional ClassNN controls replace coordinate targeting for that field/button.")
    g.AddButton("xm y+10 w180 Default", "Save Setup").OnEvent("Click", (*) => FillDate_SaveConfig(fields, status))
    g.AddButton("x+8 yp w180", "Close").OnEvent("Click", (*) => g.Destroy())
    Combined_Footer(g,740)
    g.OnEvent("Escape", (*) => g.Destroy())
    g.Show()
}

FillDate_SaveConfig(fields, status) {
    global AppSettingsIniPath
    for key in ["column", "dateX", "dateY", "okX", "okY", "popupX", "popupY"] {
        value := Trim(fields[key].Value)
        if !RegExMatch(value, "^\d+$") || (key = "column" && (Number(value) < 1 || Number(value) > 100)) {
            status.Text := "Invalid " key ". Use a nonnegative pixel coordinate, or a column from 1 to 100."
            return
        }
    }
    EnsureLocalSettingsDir()
    for key, ctrl in fields
        IniWrite(Trim(ctrl.Value), AppSettingsIniPath, "FillDate", key)
    status.Text := "Saved. Submission is automatic when you choose Calculate & Submit."
}

FillDate_ReadSelected(config, hwnd) {
    count := ListViewGetContent("Count Selected", config.control, "ahk_id " hwnd)
    if count != 1
        throw ValueError("Select exactly one prescription row first.")
    value := Trim(ListViewGetContent("Selected Col" Integer(config.column), config.control, "ahk_id " hwnd), " `t`r`n")
    ; Validate the complete cell. Never pick a date from a different column or row.
    FillDate_Calculate(value, "1")
    return value
}

FillDate_FromClick() {
    static running := false
    if running
        return
    running := true
    try {
        hwnd := WinGetID("A")
        config := FillDate_Config()
        KeyWait("LButton")
        KeyWait("Shift")
        Sleep(100)
        Combined_RequireWindow(hwnd)
        try value := FillDate_ReadSelected(config, hwnd)
        catch {
            FillDate_Open("", "Automatic read unavailable. Enter and verify the date from the intended prescription.")
            return
        }
        FillDate_Open(value, "Read from one selected row. Confirm the patient, prescription, and last-fill date before calculating.")
    } finally running := false
}

FillDate_Open(value := "", source := "Manual entry: confirm the patient and prescription in the live chart.") {
    g := Gui("+MinimizeBox", "PhUCKIT - Fill Date Calculator")
    g.SetFont("s10", "Segoe UI")
    g.AddText("w540", source)
    g.AddText("xm y+12", "Last fill date (MM/DD/YYYY)")
    date := g.AddEdit("xm w230", value)
    g.AddText("xm y+10", "Days supply")
    days := g.AddEdit("xm w120 Number")
    result := g.AddEdit("xm y+12 w540 h90 ReadOnly", "Next date = last fill date + days supply. This is calendar arithmetic; it does not determine refill eligibility.")
    g.AddButton("xm y+10 w170 Default", "Calculate && Submit").OnEvent("Click", (*) => FillDate_Submit(g, date, days, result))
    g.AddButton("x+8 yp w170", "Calculate && Copy").OnEvent("Click", (*) => FillDate_Update(date, days, result, true))
    g.AddButton("x+8 yp w170", "Automation Setup").OnEvent("Click", (*) => FillDate_Configure())
    Combined_Footer(g, 540)
    g.OnEvent("Escape", (*) => g.Destroy())
    g.Show()
}

FillDate_UniqueWindow(selector) {
    if Trim(selector) = ""
        throw Error("Set the destination window in Automation Setup. The supplied source contained YourPharmacySystem.exe as a placeholder.")
    windows := WinGetList(selector)
    if windows.Length != 1
        throw Error("Expected one matching window; found " windows.Length ". Use a unique window selector in Automation Setup.")
    return windows[1]
}

FillDate_ClickWindowPoint(hwnd, x, y) {
    CoordMode("Mouse", "Window")
    Combined_RequireWindow(hwnd)
    WinGetPos(&wx, &wy, &ww, &wh, "ahk_id " hwnd)
    if x < 0 || y < 0 || x >= ww || y >= wh
        throw Error("Configured click is outside the target window. Update the coordinate in Automation Setup.")
    Click(Integer(x), Integer(y))
}

FillDate_WaitPopup(config, destination, before) {
    started := A_TickCount, targetPid := WinGetPID("ahk_id " destination)
    while A_TickCount - started < 4000 {
        if config.popup != "" {
            matches := WinGetList(config.popup)
            if matches.Length = 1 && WinActive("ahk_id " matches[1])
                return matches[1]
            if matches.Length > 1
                throw Error("Multiple popup windows match. Use a unique popup selector.")
        } else {
            active := WinExist("A")
            if active && active != destination && !before.Has(active) {
                if WinGetPID("ahk_id " active) = targetPid
                    return active
                owner := DllCall("GetWindow", "ptr", active, "uint", 4, "ptr")
                if owner = destination
                    return active
            }
        }
        Sleep(50)
    }
    throw Error("The date and OK click were sent, but the expected popup was not identified. No popup clicks or Enter keys were sent; inspect the current workflow before retrying.")
}

FillDate_SubmitValue(next, config) {
    destination := FillDate_UniqueWindow(config.destination)
    before := Map()
    for hwnd in WinGetList()
        before[hwnd] := true
    WinActivate("ahk_id " destination)
    if !WinWaitActive("ahk_id " destination, , 2)
        throw Error("Destination did not become active. Nothing was entered.")
    ; Release invocation modifiers before sending replacement text.
    for key in ["Ctrl", "Shift", "Alt"]
        KeyWait(key)
    if config.dateControl != "" {
        Combined_RequireWindow(destination)
        ControlFocus(config.dateControl, "ahk_id " destination)
    } else
        FillDate_ClickWindowPoint(destination, config.dateX, config.dateY)
    Sleep(100)
    Combined_RequireWindow(destination)
    Send("^a")
    SendText(next)
    Sleep(100)
    if config.okControl != "" {
        Combined_RequireWindow(destination)
        ControlClick(config.okControl, "ahk_id " destination)
    } else
        FillDate_ClickWindowPoint(destination, config.okX, config.okY)
    Sleep(300)
    popup := FillDate_WaitPopup(config, destination, before)
    FillDate_ClickWindowPoint(popup, config.popupX, config.popupY)
    Sleep(100)
    Combined_RequireWindow(popup)
    Send("{Enter}")
    Sleep(100)
    ; The first Enter may close the popup and return to the original form.
    active := WinExist("A")
    if active != popup && active != destination
        throw Error("Popup focus changed to an unexpected window. The second Enter was not sent.")
    Send("{Enter}")
    return next
}

FillDate_Submit(g, date, days, result) {
    static running := false
    if running
        return
    running := true
    try {
        next := FillDate_Calculate(date.Value, days.Value)
        config := FillDate_Config()
        FillDate_UniqueWindow(config.destination)
        g.Hide()
        FillDate_SubmitValue(next, config)
        result.Value := "Submitted " next ": date entered, OK clicked, popup clicked, Enter sent twice."
        ToolTip("Fill date submission sequence sent: " next)
        SetTimer(() => ToolTip(), -2000)
    } catch as e {
        result.Value := e.Message
        g.Show()
    } finally running := false
}

FillDate_Update(date, days, result, copy := false) {
    try {
        next := FillDate_Calculate(date.Value, days.Value)
        result.Value := "Last fill: " date.Value "  +  " days.Value " days`r`nCalculated next date: " next
        if copy {
            A_Clipboard := next
            result.Value .= "`r`nCopied. Verify the destination field before pasting."
        }
    } catch as e {
        result.Value := e.Message
    }
}

MCDS_IsActive() {
    try return MCDS_IsMCDSPatientTitle(WinGetTitle("A"))
    return false
}

MCDS_Preview(continueButton := false) {
    global MCDS_DropdownXFromRight, MCDS_DropdownYFromHighlight
    global MCDS_ContinueXFromRight, MCDS_ContinueYFromHighlight
    CoordMode("Mouse", "Screen")
    CoordMode("Pixel", "Screen")
    hwnd := MCDS_FindMCDSWindow()
    if !hwnd
        return
    y := MCDS_PrepareOverrideTarget(hwnd)
    if !y
        throw Error("Could not identify the highlighted Override Reason label.")
    WinGetPos(&wx, &wy, &ww, &wh, "ahk_id " hwnd)
    scale := MCDS_GetWindowScale(hwnd)
    x := wx + ww - Round((continueButton ? MCDS_ContinueXFromRight : MCDS_DropdownXFromRight) * scale)
    y += Round((continueButton ? MCDS_ContinueYFromHighlight : MCDS_DropdownYFromHighlight) * scale)
    Combined_RequireWindow(hwnd)
    MouseMove(x, y, 0)
    ToolTip(continueButton ? "Continue target preview (no click)" : "Override Reason target preview (no click)")
    SetTimer(() => ToolTip(), -2500)
}

SecondCheck_Current() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("Ctrl+drag a screen region to start a patient capture, then review the recognized data.", "PhUCKIT - Second Check")
        return
    }
    SecondCheck_Show(ctx)
}

SecondCheck_Coverage(ctx) {
    active := PCtx_ConfirmedActiveMeds(ctx)
    uncertain := PCtx_UncertainActiveMeds(ctx)
    conflicts := PCtx_UnresolvedConflicts(ctx)
    rows := []
    hasId := (ctx.ident.Has("mrn") && ctx.ident["mrn"] != "") || (ctx.ident.Has("fin") && ctx.ident["fin"] != "")
    rows.Push(["Identity", hasId ? "VERIFY" : "MISSING", hasId ? "Identifier captured; compare with the live patient and encounter." : "No MRN/FIN captured. Patient identity is not established."])
    rows.Push(["Medication scope", "PARTIAL", active.Length " active orders eligible for screening; " uncertain.Length " uncertain active orders excluded; " (ctx.medRecs.Length - active.Length - uncertain.Length) " other-status orders retained for manual review."])
    rows.Push(["Allergies", ctx.allergyRecs.Length ? "VERIFY" : "MISSING", ctx.allergyRecs.Length ? "Captured allergy entries: " ctx.allergyRecs.Length ". Verify reactions and completeness." : "Allergy status not established. Absence of captured entries does not mean no allergies."])
    rows.Push(["OCR / conflicts", conflicts || PCtx_LowConfidenceCount(ctx) ? "REVIEW" : "LIMITED", conflicts " unresolved conflicts; " PCtx_LowConfidenceCount(ctx) " candidates/warnings. Review raw evidence and units."])
    rows.Push(["Timing", "VERIFY", "Latest screen capture: " (ctx.lastCaptureAt != "" ? ctx.lastCaptureAt : "unknown") ". Capture time is not the laboratory collection time. Confirm relevance and current orders."])
    rows.Push(["Order completeness", "MANUAL", "Verify indication, dose, route, frequency, duration, last dose, monitoring, organ function and interactions against the complete live chart."])
    return rows
}

SecondCheck_Report(ctx) {
    out := "SECOND CHECK - ASSISTED REVIEW ONLY`r`n"
        . "No complete safety clearance is issued. Rules cover only supported captured evidence and configured references.`r`n`r`n"
    cols := Safety_Evaluate(ctx)
    findings := ""
    for f in Allergy_ScanOrders(ctx.allergyRecs, PCtx_ConfirmedActiveMeds(ctx))
        findings .= "ALLERGY [" f.sev "] " f.title "`r`n" f.detail "`r`n`r`n"
    for key in Safety_Columns() {
        c := cols[key]
        if c.status = "Alert" || c.status = "Review" {
            for finding in c.findings
                findings .= key " [" c.status "] " finding "`r`n"
        }
    }
    out .= "FINDINGS TO REVIEW`r`n" (findings != "" ? findings : "No configured safety rule matched the eligible captured orders. This is not clearance; review the gaps below.") "`r`n`r`n"
    excluded := ""
    for med in ctx.medRecs {
        if !RxN_IsActiveStatus(med.status) || RxN_IsUncertain(med)
            excluded .= "[" med.status "] " med.raw "`r`n"
    }
    if excluded != ""
        out .= "ORDERS NOT SCREENED - MANUAL REVIEW REQUIRED`r`n" excluded "`r`n"
    out .= "COVERAGE AND GAPS`r`n"
    for row in SecondCheck_Coverage(ctx)
        out .= row[1] " [" row[2] "]: " row[3] "`r`n"
    out .= "`r`nRULE COVERAGE`r`n"
    for key in Safety_Columns() {
        c := cols[key]
        out .= key " [" c.status "] " c.short "`r`n" c.note "`r`n"
    }
    out .= "`r`nREFERENCE VERSIONS`r`n" Truth_RuntimeStatus()
    out .= "`r`nUse Full Clinical Safety, Order Review Queue and Med Rec for additional review and source details."
    return out
}



if CombinedSmoke {
    try {
        BUD_ShowEntryGui()
        FillDate_Open()
        FillDate_Configure()
        SecondCheck_Show(PCtx_New())
        FileAppend("PASS isolated startup and four utility windows`n", "*")
        ExitApp 0
    } catch as e {
        FileAppend("FAIL startup " e.Message " line " e.Line "`n", "*")
        ExitApp 1
    }
}

; RC29 prescription arithmetic. All calculation is local; no patient text is sent to a service.
RxSupply_Products() {
    ; name, units/mL, mL/container, prime/injection, in-use days, max injection, increment, source
    return [
        ["Lantus SoloStar U-100",100,3,2,28,80,1,"https://products.sanofi.us/lantus/lantus.html"],
        ["Lantus vial U-100",100,10,0,28,0,1,"https://products.sanofi.us/lantus/lantus.html"],
        ["Tresiba FlexTouch U-100",100,3,2,56,80,1,"https://www.novo-pi.com/tresiba.pdf"],
        ["Tresiba FlexTouch U-200",200,3,2,56,160,2,"https://www.novo-pi.com/tresiba.pdf"],
        ["Tresiba vial U-100",100,10,0,56,0,1,"https://www.novo-pi.com/tresiba.pdf"],
        ["Toujeo SoloStar U-300",300,1.5,3,56,80,1,"https://products.sanofi.us/toujeo/toujeo.html"],
        ["Toujeo Max SoloStar U-300",300,3,4,56,160,2,"https://products.sanofi.us/toujeo/toujeo.html"],
        ["Humalog KwikPen U-100",100,3,2,28,60,1,"https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=c8ecbd7a-0e22-4fc7-a503-faa58c1b6f3f"],
        ["Humalog KwikPen U-200",200,3,2,28,60,1,"https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=c8ecbd7a-0e22-4fc7-a503-faa58c1b6f3f"],
        ["Humalog vial U-100 (10 mL)",100,10,0,28,0,1,"https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=c8ecbd7a-0e22-4fc7-a503-faa58c1b6f3f"],
        ["Humalog vial U-100 (3 mL)",100,3,0,28,0,1,"https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=c8ecbd7a-0e22-4fc7-a503-faa58c1b6f3f"],
        ["Humalog Junior KwikPen U-100",100,3,2,28,30,0.5,"https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=c8ecbd7a-0e22-4fc7-a503-faa58c1b6f3f"]
    ]
}

RxSupply_Rate(sig, maxDaily := "", injections := "") {
    s := DaySupply_NormalizeSig(sig)
    if maxDaily != "" {
        if !IsNumber(maxDaily) || maxDaily <= 0 || !IsNumber(injections) || injections <= 0 || Mod(injections,1)
            return {ok:false,error:"Maximum-use calculation needs positive units/day and a whole number of injections/day."}
        return {ok:true,daily:Number(maxDaily),freq:Number(injections),dose:Number(maxDaily)/Number(injections),maximum:true}
    }
    if RegExMatch(s,"i)\b(?:sliding|scale|carb|correction|titrate|increase|decrease|adjust|as directed|prn|as needed|up to|maximum|max)\b")
        return {ok:false,error:"Variable SIG: enter the prescribed maximum total units/day and injections/day to calculate maximum-use supply."}
    if RegExMatch(s,"\d\s*[-–]\s*\d")
        return {ok:false,error:"Dose/frequency range detected. Enter documented maximum use or clarify the SIG."}
    count := 0, pos := 1
    while RegExMatch(s,"i)(\d+(?:\.\d+)?)\s*(?:units?|iu)\b",&m,pos) {
        count += 1, dose := Number(m[1]), pos := m.Pos+m.Len
    }
    if count != 1 || dose <= 0
        return {ok:false,error:"Expected one explicit insulin dose in units. For different morning/evening doses, enter total units/day and injections/day."}
    if RegExMatch(s,"i)\b(?:then|for \d+ days|every other|weekly)\b")
        return {ok:false,error:"This insulin schedule changes over time. Enter the prescribed maximum daily use for a bounded supply estimate."}
    f := DaySupply_ParseFrequency(s)
    if !f.ok
        return f
    if f.perDay < 1 || Mod(f.perDay,1)
        return {ok:false,error:"Insulin device simulation requires a whole daily injection frequency."}
    return {ok:true,daily:dose*f.perDay,freq:f.perDay,dose:dose,maximum:false}
}

RxSupply_Insulin(sig, quantity, quantityUnit, concentration, containerMl, prime, expiry, maxDose := 0, increment := 1, maxDaily := "", injections := "") {
    for value in [quantity,concentration,containerMl,expiry,increment] {
        if !IsNumber(value) || value <= 0
            return {ok:false,error:"Quantity, concentration, container size, in-use days and dose increment must be positive numbers."}
    }
    if !IsNumber(prime) || prime < 0 || !IsNumber(maxDose) || maxDose < 0
        return {ok:false,error:"Priming and maximum injection must be nonnegative numeric values."}
    n := quantityUnit = "mL" ? quantity/containerMl : quantity
    if Abs(n-Round(n)) > 0.00001 || n > 1000
        return {ok:false,error:"Dispense quantity must describe whole pens/vials (up to 1000); check mL versus container count."}
    rate := RxSupply_Rate(sig,maxDaily,injections)
    if !rate.ok
        return rate
    if !rate.maximum && Abs(rate.dose/increment-Round(rate.dose/increment)) > 0.00001
        return {ok:false,error:"Written dose is not selectable in this device's dose increment. Verify product and SIG."}
    if rate.maximum {
        ; Variable regimens do not define an exact dose sequence. Report an estimate honestly.
        dailyUse := rate.daily+prime*rate.freq
        days := n*Min(containerMl*concentration/dailyUse,expiry)
        return {ok:true,days:days,theoretical:n*containerMl*concentration/rate.daily,
            daily:rate.daily,primeDaily:prime*rate.freq,containers:n,maximum:true,
            detail:"Maximum-use estimate assumes the stated injections/day already includes split injections. Actual dose sequence, residual insulin and extra safety tests may shorten supply."}
    }
    parts := maxDose > 0 ? Ceil(rate.dose/maxDose) : 1
    doses := [], remaining := rate.dose
    Loop parts {
        part := maxDose > 0 ? Min(remaining,maxDose) : remaining
        doses.Push(part+prime), remaining -= part
    }
    capacity := containerMl*concentration
    for amount in doses {
        if amount > capacity
            return {ok:false,error:"One injection plus priming exceeds container capacity."}
    }
    used := 1, left := capacity, opened := 0.0, completed := 0
    ; Simulate scheduled administrations, including split injections and discarded residuals.
    Loop 200000 {
        moment := completed/rate.freq
        for amount in doses {
            if moment-opened >= expiry || left+0.000001 < amount {
                used += 1, left := capacity, opened := moment
            }
            if used > n
                return {ok:true,days:completed/rate.freq,theoretical:n*capacity/rate.daily,
                    daily:rate.daily,primeDaily:prime*parts*rate.freq,containers:n,maximum:false,
                    detail:"Scheduled doses supported: " completed ". " parts " injection(s) per administration. Assumes unused containers remain refrigerated until opened; one safety test per injection. Repeated tests and storage outside label conditions are not included."}
            left -= amount
        }
        completed += 1
    }
    return {ok:false,error:"Calculation exceeds supported simulation length."}
}

RxSupply_Report(r, product, sig) {
    if !r.ok
        return "NEEDS INPUT`r`n" r.error
    return (r.maximum ? "MAXIMUM-USE ESTIMATE" : "DEVICE-USE SUPPLY") ": " Round(r.days,2) " days`r`n"
        . "Full days: " Floor(r.days) " | Medication-only arithmetic: " Round(r.theoretical,2) " days`r`n"
        . "Prescribed use: " r.daily " units/day | Priming: " r.primeDaily " units/day`r`n"
        . "Containers: " r.containers " | " product "`r`n`r`n" r.detail "`r`n`r`n"
        . "Concentration converts dispensed mL to units; the pen's prescribed units are NOT multiplied by concentration.`r`n"
        . "The final billing value is editable below; payer rounding/packaging rules are not inferred.`r`n`r`nSIG: " sig
}

; REPLACE Calc_OpenDaySupply
Calc_OpenDaySupply(parsed := 0) {
    g := Gui("+Resize +MinSize880x650", "Days Supply / SIG + Insulin")
    g.SetFont("s10","Segoe UI")
    ApplyTheme(g)
    g.AddText("x16 y12 w850 h28","DAYS SUPPLY  |  SIG → quantity → device → result").SetFont("s14 bold")
    g.AddText("x16 y48 w850","Paste a SIG or open this tool from a captured medication. Results update as you type.")
    mode := g.AddDropDownList("x16 y78 w300 Choose1",["Tablets / capsules / other SIG units","Insulin pens or vials"])
    names := ["Custom insulin product — enter label values"]
    for p in RxSupply_Products()
        names.Push(p[1])
    product := g.AddDropDownList("x330 y78 w530 Choose1",names)
    g.AddText("x16 y116 w850","Quantity                 Quantity unit         U/mL        mL/container       Prime units        In-use days")
    qty := g.AddEdit("x16 y138 w130")
    qu := g.AddDropDownList("x155 y138 w130 Choose1",["mL","containers"])
    conc := g.AddEdit("x298 y138 w90")
    size := g.AddEdit("x405 y138 w110")
    prime := g.AddEdit("x535 y138 w110")
    expiry := g.AddEdit("x665 y138 w100")
    g.AddText("x16 y177 w850","Max units/injection     Device increment     Maximum units/day (variable SIG)     Injections/day")
    maxDose := g.AddEdit("x16 y199 w130","0")
    step := g.AddEdit("x155 y199 w130","1")
    maximum := g.AddEdit("x298 y199 w260")
    injections := g.AddEdit("x575 y199 w190")
    sig := g.AddEdit("x16 y240 w844 h100 Multi VScroll")
    output := g.AddEdit("x16 y352 w844 h190 ReadOnly Multi VScroll")
    g.AddText("x16 y558 w180","Final days supply:")
    final := g.AddEdit("x195 y554 w90")
    state := {g:g,mode:mode,product:product,qty:qty,qu:qu,conc:conc,size:size,prime:prime,expiry:expiry,
        maxDose:maxDose,step:step,maximum:maximum,injections:injections,sig:sig,output:output,final:final,last:"",source:""}
    run := (*) => RxSupply_Update(state)
    for control in [mode,qty,qu,conc,size,prime,expiry,maxDose,step,maximum,injections,sig]
        control.OnEvent("Change",run)
    product.OnEvent("Change",(*) => RxSupply_Select(state))
    g.AddButton("x300 y552 w130","Copy days").OnEvent("Click",(*) => RxSupply_Copy(state))
    g.AddButton("x438 y552 w130","Copy report").OnEvent("Click",(*) => (A_Clipboard := output.Value))
    g.AddButton("x576 y552 w130","Product label").OnEvent("Click",(*) => RxSupply_Source(state))
    g.AddButton("x714 y552 w146","Close").OnEvent("Click",(*) => g.Destroy())
    g.AddText("x16 y600 w844 h36","© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    if IsObject(parsed) {
        captured := RxSupply_FromMedication(parsed)
        if parsed.HasOwnProp("raw")
            sig.Value := parsed.raw
        if parsed.HasOwnProp("sig") && parsed.sig != ""
            sig.Value := parsed.sig
        if parsed.HasOwnProp("quantity")
            qty.Value := parsed.quantity
        if RegExMatch(sig.Value,"i)\b(insulin|lantus|tresiba|toujeo|humalog|novolog|basaglar|semglee)\b")
            mode.Choose(2)
        if captured.sig != ""
            sig.Value := captured.sig
        if captured.quantity != ""
            qty.Value := captured.quantity
        if captured.product > 0 {
            product.Choose(captured.product+1)
            RxSupply_Select(state)
            qu.Choose(captured.unit = "mL" ? 1 : 2)
        }
    }
    RxSupply_Update(state)
    g.OnEvent("Escape",(*) => g.Destroy())
    Workbench29_Show(g,"w880 h650")
    return g
}

RxSupply_Select(s) {
    if s.product.Value > 1 {
        p := RxSupply_Products()[s.product.Value-1]
        s.mode.Choose(2), s.conc.Value := p[2], s.size.Value := p[3], s.prime.Value := p[4]
        s.expiry.Value := p[5], s.maxDose.Value := p[6], s.step.Value := p[7], s.source := p[8]
    } else
        s.source := ""
    RxSupply_Update(s)
}

RxSupply_Update(s) {
    try {
        insulin := s.mode.Value = 2
        for c in [s.product,s.qu,s.conc,s.size,s.prime,s.expiry,s.maxDose,s.step,s.maximum,s.injections]
            c.Enabled := insulin
        s.final.Value := ""
        if insulin {
            r := RxSupply_Insulin(s.sig.Value,s.qty.Value,s.qu.Text,s.conc.Value,s.size.Value,s.prime.Value,s.expiry.Value,s.maxDose.Value,s.step.Value,s.maximum.Value,s.injections.Value)
            s.output.Value := RxSupply_Report(r,s.product.Text,s.sig.Value)
            if s.source != ""
                s.output.Value .= "`r`nLabel checked 2026-09-25: " s.source
        } else {
            if RegExMatch(s.sig.Value,"i)\b(insulin|lantus|tresiba|toujeo|humalog|novolog|units? subcut)\b") {
                s.output.Value := "Select Insulin pens or vials and confirm the dispensed product and quantity units."
                return
            }
            r := DaySupply_Calculate(s.sig.Value,s.qty.Value)
            s.output.Value := DaySupply_BuildReport(r,s.sig.Value,s.qty.Value)
        }
        if r.ok
            s.final.Value := Floor(r.days)
    } catch as e
        s.output.Value := "Calculation could not complete: " e.Message
}

RxSupply_Copy(s) {
    if !IsNumber(s.final.Value) || s.final.Value <= 0 || Mod(s.final.Value,1) {
        MsgBox("Enter a positive whole final days supply.")
        return
    }
    A_Clipboard := s.final.Value
}

RxSupply_Source(s) {
    if s.source != ""
        SafeLaunchTarget(s.source)
    else
        MsgBox("Custom product: use the exact product's prescribing information and device instructions.")
}

RxSupply_FromMedication(med) {
    raw := med.HasOwnProp("raw") ? med.raw : ""
    sig := med.HasOwnProp("sig") ? med.sig : ""
    if sig = "" && RegExMatch(raw,"i)\b(?:sig|directions?)\s*:\s*(.+)",&m)
        sig := m[1]
    if sig = "" && RegExMatch(raw,"i)\b(?:inject|take|inhale|instill|apply|use)\b.+",&m)
        sig := m[0]
    sig := RegExReplace(sig,"i)\s*(?:\b(?:qty|quantity|dispense|refills?)\s*:).*$","")
    quantity := med.HasOwnProp("quantity") ? med.quantity : "",unit := ""
    if RegExMatch(raw,"i)\b(?:qty|quantity|dispense)\s*:\s*(\d+(?:\.\d+)?)\s*(mL|pens?|vials?|containers?)?",&m) {
        quantity := m[1],unit := StrLower(m[2]) = "ml" ? "mL" : (m[2] != "" ? "containers" : "")
    }
    product := 0
    for i,p in RxSupply_Products() {
        brand := StrSplit(p[1]," ")[1]
        if !RegExMatch(raw,"i)\b" brand "\b")
            continue
        isVial := InStr(StrLower(p[1]),"vial")
        if isVial && !RegExMatch(raw,"i)\bvial\b")
            continue
        if !isVial && !RegExMatch(raw,"i)\b(?:pen|solostar|kwikpen|flextouch)\b")
            continue
        if brand = "Humalog" {
            if isVial && !RegExMatch(raw,"i)\b" p[3] "\s*mL\s*(?:multiple[- ]dose\s*)?vial\b")
                continue
            if !isVial && (!!InStr(p[1],"Junior") != !!InStr(raw,"Junior"))
                continue
        }
        if InStr(p[1],"Max") && !RegExMatch(raw,"i)\bmax\s+solostar\b")
            continue
        if !InStr(p[1],"Max") && RegExMatch(raw,"i)\bmax\s+solostar\b")
            continue
        if !RegExMatch(raw,"i)(?:\bU[- ]?" p[2] "\b|\b" p[2] "\s*(?:units?|u)\s*/\s*mL\b)")
            continue
        product := i
        break
    }
    ; Product + qty unit are required before insulin may calculate automatically.
    if unit = ""
        product := 0
    return {sig:sig,quantity:quantity,unit:unit,product:product}
}

RxSupply_Background(ctx) {
    out := "OUTPATIENT DAYS SUPPLY`r`n",count := 0
    for med in ctx.medRecs {
        if MedRec_Value(med,"profile") != "ambulatory" || RxN_IsUncertain(med) || !RxN_IsActiveStatus(med.status)
            continue
        count += 1,c := RxSupply_FromMedication(med)
        if c.sig = "" || c.quantity = "" {
            out .= "• " med.name ": needs explicit SIG / dispense quantity. Open Selected RX days supply.`r`n"
            continue
        }
        if RegExMatch(med.raw,"i)\b(insulin|lantus|tresiba|toujeo|humalog|novolog|basaglar|semglee)\b") {
            if !c.product {
                out .= "• " med.name ": confirm exact insulin product, concentration, device and quantity unit.`r`n"
                continue
            }
            p := RxSupply_Products()[c.product]
            r := RxSupply_Insulin(c.sig,c.quantity,c.unit,p[2],p[3],p[4],p[5],p[6],p[7])
        } else
            r := DaySupply_Calculate(c.sig,c.quantity)
        out .= "• " med.name ": " (r.ok ? Round(r.days,2) " days (verify captured inputs / billing value)" : r.error) "`r`n"
    }
    return out (count ? "" : "No eligible outpatient prescriptions captured.`r`n")
}

; RC29 local review workspace. Patient state and acknowledgements remain in memory.
Review_Value(value) {
    if !IsObject(value)
        return StrLen(String(value)) ":" String(value)
    out := Type(value) "["
    if value is Map || value is Array {
        for k,v in value
            out .= Review_Value(k) Review_Value(v)
    } else {
        for k,v in value.OwnProps()
            out .= Review_Value(k) Review_Value(v)
    }
    return out "]"
}

Review_State(ctx) {
    if !ctx.HasOwnProp("review29")
        ctx.review29 := {fingerprint:"",snapshot:Map(),revision:0,report:"",changes:"First assessment",ack:Map(),complete:Map(),error:"",when:""}
    return ctx.review29
}

Review_Snapshot(ctx) {
    snap := Map()
    for key in ["ident","demo","weights","labs","labCandidates","captureCandidates","medRecs","allergyRecs","captures","conflicts","renal29"] {
        snap[key] := ctx.HasOwnProp(key) ? Review_Value(ctx.%key%) : ""
    }
    refs := "RC29.20260925"
    for filename in [RefData_Dir() "\renal_rules.csv",Renal29_Path()] {
        if FileExist(filename)
            refs .= filename FileRead(filename,"UTF-8")
    }
    for name in ["beers_rules","qt_rules","mg_rules","g6pd_rules","crush_rules_v2"] {
        filename := RefData_Dir() "\" name ".csv"
        if FileExist(filename)
            refs .= filename FileRead(filename,"UTF-8")
    }
    snap["references"] := refs
    return snap
}

Review_ProfileSignature(ctx) {
    return Review_Value(ctx.ident) Review_Value(ctx.medRecs) Review_Value(ctx.captures)
}

; REPLACE MedRec_ProfileComplete
MedRec_ProfileComplete(ctx, profile) {
    st := Review_State(ctx)
    return st.complete.Has(profile) && st.complete[profile] = Review_ProfileSignature(ctx)
}

Review_Complete(ctx, profile, checked) {
    st := Review_State(ctx)
    st.complete[profile] := checked ? Review_ProfileSignature(ctx) : ""
    st.fingerprint := ""
    Review_Run(ctx)
}

Review_Start(ctx) {
    ; One local watcher, no network and no repeated EHR clicks.
    static callback := 0
    if callback
        SetTimer(callback,0)
    callback := (*) => Review_Run(ctx)
    SetTimer(callback,1500)
    Review_Run(ctx)
}

Review_Run(ctx) {
    global PCtxSession, RefDataCache
    if IsSet(PCtxSession) && IsObject(PCtxSession) && ObjPtr(PCtxSession) != ObjPtr(ctx)
        return
    st := Review_State(ctx)
    try {
        snap := Review_Snapshot(ctx), fingerprint := Review_Value(snap)
        if fingerprint = st.fingerprint
            return
        if st.snapshot.Has("references") && st.snapshot["references"] != snap["references"]
            RefDataCache := Map()
        changes := ""
        for key,value in snap {
            if !st.snapshot.Has(key) || st.snapshot[key] != value
                changes .= (changes = "" ? "" : ", ") Review_FieldLabel(key)
        }
        st.ack := Map()
        st.revision += 1, st.snapshot := snap, st.fingerprint := fingerprint
        st.changes := changes, st.when := FormatTime(,"HH:mm:ss"), st.error := ""
        report := "ASSESSMENT " st.revision "  •  " st.when "`r`nChanged: " changes "`r`n`r`n"
        report .= Review_Priority(ctx) "`r`n"
        comparisons := MedRec_BuildComparison(ctx)
        report .= "MED REC — " comparisons.Length " comparison rows`r`n"
        for row in comparisons {
            if row.priority = 1
                report .= "• " row.status " | " MedRec_Display(row.home) " → " MedRec_Display(row.acute) "`r`n"
        }
        report .= "`r`n" RxSupply_Background(ctx) "`r`n"
        report .= Review_InteractionReport(ctx) "`r`n"
        report .= Renal29_Report(ctx) "`r`n"
        report .= "`r`nCOVERAGE`r`n"
        for row in SecondCheck_Coverage(ctx)
            report .= row[1] " [" row[2] "] " row[3] "`r`n"
        st.report := report
    } catch as e {
        st.error := "Assessment incomplete: " e.Message
        st.report := st.error "`r`nOpen source evidence and refresh after correcting the inputs."
        st.fingerprint := "" ; retry instead of preserving a false successful cache
    }
}

Review_FieldLabel(key) {
    labels := Map("ident","patient / encounter","demo","demographics","weights","weight","labs","labs",
        "labCandidates","unconfirmed labs","captureCandidates","unconfirmed inputs","medRecs","medications",
        "allergyRecs","allergies","captures","capture evidence","conflicts","conflicts","renal29","renal context","references","reference library")
    return labels.Has(key) ? labels[key] : key
}

Review_Priority(ctx) {
    out := "PRIORITY REVIEW`r`n",hits := 0
    for f in Allergy_ScanOrders(ctx.allergyRecs,PCtx_ConfirmedActiveMeds(ctx)) {
        out .= "• ALLERGY [" f.sev "] " f.title " — " f.detail "`r`n",hits += 1
    }
    cols := Safety_Evaluate(ctx)
    for key in Safety_Columns() {
        if key = "RENAL"
            continue
        c := cols[key]
        if c.status = "Alert" || c.status = "Review" {
            for finding in c.findings
                out .= "• " key " [" c.status "] " finding "`r`n",hits += 1
        }
    }
    return out (hits ? "" : "No allergy or other configured priority-rule match. Review interaction, renal and coverage results below.`r`n")
}

Review_InteractionReport(ctx) {
    active := PCtx_ConfirmedActiveMeds(ctx), keys := [], pending := []
    for m in active
        keys.Push(PatientV4_MedicationNameKey(m.raw))
    out := "INTERACTIONS — CURRENT ACTIVE ORDERS`r`n"
    hits := MedFlag_Interactions(keys)
    for hit in hits
        out .= "• " hit "`r`n"
    if !hits.Length
        out .= "No match in the bundled targeted interaction rules.`r`n"
    out .= "Coverage: " active.Length " eligible orders; targeted legacy rules, not a comprehensive interaction database. Confirm management in your interaction reference.`r`n"
    for m in ctx.medRecs {
        if RxN_StatusCategory(m.status) = "pending" && !RxN_IsUncertain(m)
            pending.Push(m)
    }
    if pending.Length {
        out .= "`r`nPROSPECTIVE / PENDING ORDERS (not assumed administered)`r`n"
        for m in pending {
            proposed := keys.Clone(), proposed.Push(PatientV4_MedicationNameKey(m.raw))
            out .= m.raw "`r`n"
            for hit in MedFlag_Interactions(proposed) {
                found := false
                for existing in hits {
                    if existing = hit
                        found := true
                }
                if !found
                    out .= "  Proposed-order signal: " hit "`r`n"
            }
            for allergy in Allergy_ScanOrders(ctx.allergyRecs,[m])
                out .= "  Allergy: " allergy.title " — " allergy.detail "`r`n"
        }
    }
    return out
}

; REPLACE SecondCheck_Show
SecondCheck_Show(ctx) {
    static previous := 0
    if IsObject(previous)
        try previous.Destroy()
    Review_Start(ctx)
    g := Gui("+Resize +MinSize940x650","PhUCKIT - Second Check")
    previous := g
    g.SetFont("s10","Segoe UI"), ApplyTheme(g)
    heading := g.AddText("x16 y10 w920 h30","PATIENT WORKSPACE  |  " PCtx_MaskedId(ctx))
    heading.SetFont("s15 bold")
    summary := g.AddText("x16 y46 w920 h46","")
    tabs := g.AddTab3("x16 y98 w920 h442",["Assessments","Medications","Changes / coverage","Evidence / tools"])
    tabs.UseTab(1)
    report := g.AddEdit("x30 y134 w890 h385 ReadOnly Multi VScroll","")
    tabs.UseTab(2)
    meds := g.AddListView("x30 y134 w890 h338 Grid -Multi",["Profile","Status","Medication / captured order"])
    meds.ModifyCol(1,120),meds.ModifyCol(2,130),meds.ModifyCol(3,610)
    g.AddButton("x30 y482 w210","Selected RX days supply").OnEvent("Click",(*) => Review_SelectedSupply(ctx,meds))
    g.AddButton("x250 y482 w190","Medication reconciliation").OnEvent("Click",(*) => Hub_OpenMedRecComparison(ctx))
    tabs.UseTab(3)
    coverage := g.AddEdit("x30 y134 w890 h338 ReadOnly Multi VScroll","")
    ack := g.AddText("x30 y483 w890 h32","This assessment has not been marked reviewed.")
    tabs.UseTab(4)
    for i,entry in [["Capture evidence",Hub_OpenCaptureEvidence.Bind(ctx)],["Edit patient / labs",Hub_EditCaptured.Bind(ctx)],
        ["Order review",Hub_OpenOrderReview.Bind(ctx)],["All clinical workbenches",Hub_OpenWorkbenchLauncher.Bind(ctx)],
        ["Renal library",Hub_OpenRenalLibrary.Bind(ctx)],["Shortcut guide",Review_Guide]] {
        g.AddButton("x30 y" (132+(i-1)*54) " w390 h38",entry[1]).OnEvent("Click",Review_Invoke.Bind(entry[2]))
    }
    tabs.UseTab()
    g.AddButton("x16 y552 w140","Refresh Review").OnEvent("Click",(*) => (Review_State(ctx).fingerprint := "", Review_Run(ctx)))
    g.AddButton("x164 y552 w140","Mark reviewed").OnEvent("Click",(*) => Review_Acknowledge(ctx,ack))
    g.AddButton("x312 y552 w140","Med Rec").OnEvent("Click",(*) => Hub_OpenMedRecComparison(ctx))
    g.AddButton("x460 y552 w140","Renal assessment").OnEvent("Click",(*) => Hub_OpenRenalScreening(ctx))
    g.AddButton("x608 y552 w140","Capture more").OnEvent("Click",(*) => (g.Destroy(),SafeRun(BMI_FromRegion)))
    g.AddButton("x756 y552 w140","New patient").OnEvent("Click",(*) => (PCtx_ClearSession(),g.Destroy()))
    g.AddText("x16 y602 w920 h36","© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    ui := {ctx:ctx,summary:summary,report:report,coverage:coverage,meds:meds,ack:ack,last:-1}
    tick := (*) => Review_Render(ui)
    Review_Render(ui),SetTimer(tick,750)
    g.OnEvent("Close",(*) => SetTimer(tick,0))
    g.OnEvent("Escape",(*) => (SetTimer(tick,0),g.Destroy()))
    ; Destroying a GUI programmatically does not issue Close; renderer also stops itself.
    ui.tick := tick
    Workbench29_Show(g,"w952 h650")
    return g
}

Review_Invoke(fn, *) {
    SafeRun(fn)
}

Review_Render(ui) {
    try {
        if !DllCall("IsWindow","Ptr",ui.report.Gui.Hwnd) {
            if ui.HasOwnProp("tick")
                SetTimer(ui.tick,0)
            return
        }
        ctx := ui.ctx, st := Review_State(ctx)
        if ui.last = st.revision
            return
        ui.last := st.revision
        p := PCtx_ToParsed(ctx)
        ui.summary.Value := "Age " p.age " | " p.sex " | " p.weightKg " kg | " p.heightCm " cm | SCr " p.scr " mg/dL`n"
            . ctx.captures.Length " captures | " ctx.medRecs.Length " medication rows | Assessed " st.when " | Revision " st.revision
        ui.report.Value := st.report
        ui.coverage.Value := "CHANGES SINCE PREVIOUS ASSESSMENT`r`n" st.changes "`r`n`r`n"
        for row in SecondCheck_Coverage(ctx)
            ui.coverage.Value .= row[1] " [" row[2] "] " row[3] "`r`n`r`n"
        ui.ack.Value := "New data/reference revision — previous review marks have expired. Findings remain visible."
        ui.meds.Delete()
        for m in ctx.medRecs
            ui.meds.Add("",MedRec_Value(m,"profile"),m.status,m.raw)
    } catch {
        if ui.HasOwnProp("tick")
            SetTimer(ui.tick,0)
    }
}

Review_Acknowledge(ctx,control) {
    Review_Run(ctx)
    st := Review_State(ctx)
    st.ack["assessment"] := st.fingerprint
    control.Value := "Marked reviewed at " FormatTime(,"HH:mm:ss") " for revision " st.revision ". Findings remain visible."
}

Review_SelectedSupply(ctx,lv) {
    row := lv.GetNext()
    if row && row <= ctx.medRecs.Length
        Calc_OpenDaySupply(ctx.medRecs[row])
    else
        Calc_OpenDaySupply()
}

; REPLACE Hub_OpenMedRecComparison
Hub_OpenMedRecComparison(ctx) {
    Review_Start(ctx)
    g := Gui("+Resize +MinSize1000x680","Acute vs Ambulatory Medication Reconciliation")
    g.SetFont("s10","Segoe UI"),ApplyTheme(g)
    g.AddText("x16 y12 w970 h28","MEDICATION RECONCILIATION  |  " PCtx_MaskedId(ctx)).SetFont("s14 bold")
    g.AddText("x16 y48 w970 h36","Compare ambulatory history with acute orders. Confirm each complete profile, inspect discrepancies, then document intent. A captured prescription does not establish actual home use.")
    home := g.AddCheckbox("x16 y92 w350","I have captured the complete home profile")
    acute := g.AddCheckbox("x400 y92 w400","I have captured the complete acute profile")
    home.Value := MedRec_ProfileComplete(ctx,"ambulatory"),acute.Value := MedRec_ProfileComplete(ctx,"acute")
    home.OnEvent("Click",(*) => Review_Complete(ctx,"ambulatory",home.Value))
    acute.OnEvent("Click",(*) => Review_Complete(ctx,"acute",acute.Value))
    search := g.AddEdit("x16 y124 w600")
    filter := g.AddDropDownList("x630 y124 w345 Choose1",["All comparisons","Unreviewed","Reviewed","Discrepancies / evidence gaps","Ambulatory only","Acute only","Matched on both"])
    summary := g.AddText("x16 y155 w959 h34", "")
    lv := g.AddListView("x16 y192 w959 h264 Grid -Multi",["Review state","Reconciliation","Home / ambulatory","Acute / inpatient"])
    lv.ModifyCol(1,120),lv.ModifyCol(2,260),lv.ModifyCol(3,280),lv.ModifyCol(4,280)
    detail := g.AddEdit("x16 y468 w959 h105 ReadOnly Multi VScroll")
    state := {ctx:ctx,g:g,lv:lv,search:search,filter:filter,detail:detail,rows:[],last:"",home:home,acute:acute,summary:summary}
    for c in [search,filter]
        c.OnEvent("Change",(*) => MedRec29_Render(state,true))
    lv.OnEvent("ItemSelect",(*) => MedRec29_Detail(state))
    g.AddButton("x16 y586 w128","Assign home").OnEvent("Click",(*) => MedRec29_Assign(state,"ambulatory"))
    g.AddButton("x152 y586 w128","Assign acute").OnEvent("Click",(*) => MedRec29_Assign(state,"acute"))
    g.AddButton("x288 y586 w128","Review / decision").OnEvent("Click",(*) => MedRec29_Decision(state))
    g.AddButton("x424 y586 w128","Verify / correct").OnEvent("Click",(*) => MedRec29_Correct(state))
    g.AddButton("x560 y586 w128","Days supply").OnEvent("Click",(*) => MedRec29_Supply(state))
    g.AddButton("x696 y586 w128","Copy comparison").OnEvent("Click",(*) => MedRec30_Copy(state))
    g.AddButton("x832 y586 w128","Close").OnEvent("Click",(*) => g.Destroy())
    g.AddText("x16 y635 w959 h36","© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    timer := (*) => MedRec29_Render(state)
    state.timer := timer,SetTimer(timer,1000)
    MedRec29_Render(state,true)
    g.OnEvent("Escape",(*) => (SetTimer(timer,0),g.Destroy()))
    g.OnEvent("Close",(*) => SetTimer(timer,0))
    Workbench29_Show(g,"w1000 h680")
    return g
}

MedRec29_Render(s, force := false) {
    try {
        if !DllCall("IsWindow","Ptr",s.g.Hwnd) {
            SetTimer(s.timer,0)
            return
        }
        Review_Run(s.ctx), st := Review_State(s.ctx)
        sig := st.fingerprint Review_Value(st.complete) Review_Value(st.ack)
        if !force && s.last = sig
            return
        selected := s.lv.GetNext(), selectedKey := selected && selected <= s.rows.Length ? Review_Value(s.rows[selected]) : ""
        s.last := sig,s.rows := [],s.lv.Delete()
        allRows := MedRec_BuildComparison(s.ctx), reviewedCount := 0
        for r in allRows {
            if st.ack.Has(Review_Value(r))
                reviewedCount += 1
        }
        s.summary.Text := PCtx_ProfileMeds(s.ctx,"ambulatory").Length " ambulatory | " PCtx_ProfileMeds(s.ctx,"acute").Length " acute | " PCtx_ProfileMeds(s.ctx,"unassigned").Length " unassigned | " reviewedCount "/" allRows.Length " reviewed. Blank fields require source review."
        s.home.Value := MedRec_ProfileComplete(s.ctx,"ambulatory"),s.acute.Value := MedRec_ProfileComplete(s.ctx,"acute")
        for row in allRows {
            key := Review_Value(row), reviewed := st.ack.Has(key)
            text := row.status " " row.flags " " MedRec_Display(row.home) " " MedRec_Display(row.acute)
            if s.search.Value != "" && !InStr(StrLower(text),StrLower(s.search.Value))
                continue
            if (s.filter.Value = 2 && reviewed) || (s.filter.Value = 3 && !reviewed)
                continue
            if (s.filter.Value = 4 && row.priority = 3) || (s.filter.Value = 5 && (!IsObject(row.home) || IsObject(row.acute))) || (s.filter.Value = 6 && (!IsObject(row.acute) || IsObject(row.home))) || (s.filter.Value = 7 && (!IsObject(row.home) || !IsObject(row.acute)))
                continue
            s.rows.Push(row)
            s.lv.Add("",reviewed ? st.ack[key] : "Unreviewed",row.status,MedRec_Display(row.home),MedRec_Display(row.acute))
            if key = selectedKey
                s.lv.Modify(s.rows.Length,"Select Focus")
        }
        s.detail.Value := "Select a row. Completeness and review decisions expire when captured profiles or assessment inputs change."
        MedRec29_Detail(s)
    } catch as e {
        s.detail.Value := "Comparison could not refresh: " e.Message
    }
}

MedRec29_Detail(s) {
    i := s.lv.GetNext()
    if i && i <= s.rows.Length {
        r := s.rows[i]
        s.detail.Value := r.status "`r`n" MedRec30_Fields(r.home,r.acute) "`r`n" r.flags "`r`nHOME: " MedRec_EvidenceText(r.home) "`r`nACUTE: " MedRec_EvidenceText(r.acute)
    }
}

MedRec29_Assign(s,profile) {
    i := s.lv.GetNext()
    if !i || i > s.rows.Length
        return
    r := s.rows[i], m := IsObject(r.home) ? r.home : r.acute
    if IsObject(r.home) && IsObject(r.acute) {
        MsgBox("Both sides are already assigned. Edit the captured medication to correct its source profile.")
        return
    }
    m.profile := profile,m.profileConfidence := "manual",m.profileReason := "Assigned by pharmacist in Med Rec"
    MedRec29_Render(s,true)
}

MedRec29_Decision(s) {
    i := s.lv.GetNext()
    if !i || i > s.rows.Length
        return
    key := Review_Value(s.rows[i]),fingerprint := Review_State(s.ctx).fingerprint
    answer := InputBox("Record your decision (e.g. intentional hold, continue, substitution accepted, clarify with prescriber). This is a local review note; orders continue through your existing automation.","Med Rec decision","w550 h170")
    if answer.Result != "OK" || Trim(answer.Value) = ""
        return
    Review_Run(s.ctx)
    if fingerprint != Review_State(s.ctx).fingerprint {
        MsgBox("Inputs changed while the decision was open. Review the refreshed row.")
        return
    }
    Review_State(s.ctx).ack[key] := FormatTime(,"yyyy-MM-dd HH:mm:ss") " | " Trim(answer.Value)
    MedRec29_Render(s,true)
}

MedRec29_Supply(s) {
    i := s.lv.GetNext()
    if i && i <= s.rows.Length {
        r := s.rows[i]
        Calc_OpenDaySupply(IsObject(r.home) ? r.home : r.acute)
    }
}

MedRec29_Correct(s) {
    i := s.lv.GetNext()
    if !i || i > s.rows.Length
        return
    row := s.rows[i]
    if IsObject(row.home) && IsObject(row.acute) {
        choice := InputBox("Which source order are you verifying? Type home or acute.","Choose source","w430 h135","home")
        if choice.Result != "OK" || !RegExMatch(choice.Value,"i)^(home|acute)$")
            return
        med := StrLower(choice.Value) = "home" ? row.home : row.acute
    } else
        med := IsObject(row.home) ? row.home : row.acute
    fingerprint := Review_State(s.ctx).fingerprint
    edited := InputBox("Verify medication, strength, formulation, dose, route, frequency and status against the source. Correct the full order text below. For outpatient supply, include SIG: and Qty: with quantity units. OK marks this text manually verified.","Verify captured medication","w850 h220",med.raw)
    if edited.Result != "OK" || Trim(edited.Value) = ""
        return
    Review_Run(s.ctx)
    if fingerprint != Review_State(s.ctx).fingerprint {
        MsgBox("Patient inputs changed. Select the refreshed row before applying a correction.")
        return
    }
    replacement := RxN_Normalize(edited.Value)
    if RegExMatch(edited.Value,"i)\[(?:missing|verify OCR)") {
        MsgBox("Resolve the explicit missing/OCR markers in the source text before marking it verified.")
        return
    }
    oldRaw := med.raw,profile := MedRec_Value(med,"profile"),status := med.status
    for key,value in replacement.OwnProps()
        med.%key% := value
    med.profile := profile,med.status := status,med.previousRaw := oldRaw
    if RegExMatch(edited.Value,"i)\b(discontinued|expired|completed|suspended|stopped|cancelled|canceled|inactive|held|pending verify|pending verification|active)\b")
        med.status := PatientV12_OrderStatus(edited.Value)
    med.captureState := "captured",med.lowConfidence := false,med.sourceVerifiedAt := FormatTime(,"yyyy-MM-dd HH:mm:ss")
    med.profileReason := "Pharmacist verified/corrected source order text"
    MedRec29_Render(s,true)
}

Renal29_Path() {
    global LocalSettingsDir
    return (IsSet(LocalSettingsDir) ? LocalSettingsDir : A_ScriptDir) "\renal-dose-rules.ini"
}

Renal29_Context(ctx) {
    if !ctx.HasOwnProp("renal29")
        ctx.renal29 := {stability:"Unknown",rrt:"Unknown",indication:"",metric:"CG",value:""}
    return ctx.renal29
}

Renal29_Rules() {
    rows := Renal29_Seeds()
    path := Renal29_Path()
    if !FileExist(path)
        return rows
    for section in StrSplit(IniRead(path),"`n") {
        if section = ""
            continue
        r := Map("id",section)
        for key in ["ingredient","metric","lower","upper","indication","action","source","version"]
            r[key] := IniRead(path,section,key,"")
        if r["ingredient"] != "" && IsNumber(r["lower"]) && IsNumber(r["upper"]) && r["action"] != "" && r["source"] != ""
            rows.Push(r)
    }
    return rows
}

Renal29_Seeds() {
    source := "https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=b001d60e-b8fb-54ff-e053-2a95a90a2970"
    rows := []
    for i,r in [[20,50,"Adult oral regimen normally 750 mg q24h","750 mg every 48 hours"],
        [10,20,"Adult oral regimen normally 750 mg q24h","750 mg initial dose, then 500 mg every 48 hours"],
        [20,50,"Adult oral regimen normally 500 mg q24h","500 mg initial dose, then 250 mg every 24 hours"],
        [10,20,"Adult oral regimen normally 500 mg q24h","500 mg initial dose, then 250 mg every 48 hours"],
        [20,50,"Adult oral regimen normally 250 mg q24h","No renal adjustment to the 250 mg every 24 hour regimen"],
        [10,20,"Adult oral 250 mg q24h regimen excluding uncomplicated UTI","250 mg every 48 hours; uncomplicated UTI is an exception and requires the separate label guidance"]] {
        rows.Push(Map("id","label-levo-" i,"ingredient","levofloxacin","metric","CG","lower",r[1],"upper",r[2],
            "indication",r[3],"action",r[4],"source",source,"version","Label table 3; checked 2026-09-25; not institution reviewed"))
    }
    return rows
}

Renal29_Report(ctx) {
    p := PCtx_ToParsed(ctx),c := Renal29_Context(ctx)
    PatientCalc_Enrich(p)
    out := "RENAL ASSESSMENT`r`nCockcroft–Gault: " PatientCalc_CrClDisplay(p) "`r`n"
    egfr := PCtx_LabValue(ctx,"egfr")
    out .= "Captured eGFR: " (egfr = "" ? "not available" : egfr " mL/min/1.73 m²") "`r`n"
    out .= "Renal stability: " c.stability " | RRT: " c.rrt " | Indication: " (c.indication = "" ? "not entered" : c.indication) "`r`n"
    if IsNumber(p.heightCm) && IsNumber(p.weightKg) && IsNumber(egfr) && p.heightCm > 0 && p.weightKg > 0 {
        bsa := Sqrt(p.heightCm*p.weightKg/3600)
        out .= "BSA " Round(bsa,2) " m²; de-indexed captured eGFR " Round(egfr*bsa/1.73,1) " mL/min. Match the metric required by the product label.`r`n"
    }
    rules := Renal29_Rules()
    for m in ctx.medRecs {
        category := RxN_StatusCategory(m.status)
        if (category != "active" && category != "pending") || RxN_IsUncertain(m)
            continue
        out .= "`r`n[" category "] " m.raw "`r`n"
        cardText := Renal30_LabelCardText(PatientV4_MedicationNameKey(m.raw))
        if cardText != ""
            out .= cardText
        if InStr(PatientV4_MedicationNameKey(m.raw),"metformin") {
            out .= !IsNumber(egfr) ? "Needs numeric eGFR; CG is not substituted for the label's indexed eGFR metric.`r`n"
                : egfr < 30 ? "LABEL SIGNAL: eGFR <30 — contraindication/discontinuation review.`r`n"
                : egfr < 45 ? "LABEL SIGNAL: eGFR 30–<45 — initiation not recommended; reassess benefit/risk for continuation.`r`n"
                : "No <45 eGFR signal; contrast and other contraindications still require review.`r`n"
            out .= "Source: https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=a944a167-e3ac-4084-af1c-22b48713471c (ER label, checked 2026-09-25). Verify exact formulation.`r`n"
        } else {
            signal := PatientRenal_FlagForMedication(m.raw,p)
            rule := PatientRenal_FindRuleForKey(PatientV4_MedicationNameKey(m.raw))
            out .= signal != "" ? signal "`r`n" : !IsObject(rule) ? "No bundled renal rule for this medication.`r`n" : "Bundled screening threshold not triggered, or required metric missing; see inputs above.`r`n"
        }
        matched := false
        for r in rules {
            if !PatientRenal_KeyMatchesAny(PatientV4_MedicationNameKey(m.raw),[r["ingredient"]])
                continue
            matched := true
            value := r["metric"] = "CG" ? p.crcl : egfr
            if !IsNumber(p.age) || p.age < 18 {
                out .= "Adult dose rules need confirmed age >=18. Pediatric dosing is not inferred.`r`n"
                continue
            }
            if c.stability != "Stable" || c.rrt != "None" || RenalContext_IsRRT(p) || RenalContext_IsUnstable(p) {
                out .= "Local dose rule needs stable renal function and confirmed no RRT. Captured AKI/RRT cues also require reconciliation.`r`n"
                continue
            }
            if !IsNumber(value) || value <= 0 || StrLower(Trim(c.indication)) != StrLower(Trim(r["indication"])) {
                out .= "Local dose rule needs its exact indication and numeric " r["metric"] " metric.`r`n"
                continue
            }
            if value >= Number(r["lower"]) && value < Number(r["upper"]) {
                out .= "LOCAL DOSE GUIDANCE: " r["action"] "`r`nRange [" r["lower"] ", " r["upper"] ") " r["metric"]
                    . "; indication " r["indication"] "; version " r["version"] "`r`nSource: " r["source"] "`r`n"
            }
        }
        if !matched
            out .= "No local indication-specific dose rule configured. Open the renal library for the product label.`r`n"
    }
    out .= "`r`nWeight method and inputs are shown above. Estimates may be unreliable with changing SCr; neither a threshold match nor its absence selects an individualized dose.`r`n"
    return out
}

PatientRenal_FlagForMedication(medication,parsed) {
    key := PatientV4_MedicationNameKey(medication)
    if InStr(key,"metformin") {
        value := parsed.HasOwnProp("egfr") ? parsed.egfr : ""
        if !IsNumber(value)
            return "RENAL REVIEW — metformin requires indexed eGFR; CrCl is not substituted."
        return value < 30 ? "RENAL REVIEW — metformin eGFR <30; contraindication/discontinuation review."
            : value < 45 ? "RENAL REVIEW — metformin eGFR 30–<45; initiation not recommended; reassess continuation."
            : ""
    }
    if InStr(key,"empagliflozin") || InStr(key,"dapagliflozin")
        return "RENAL REVIEW — verify indication-specific indexed eGFR criteria in current product labeling; CG thresholds are not applied."
    return PatientRenal_LegacyFlagForMedication(medication,parsed)
}

; REPLACE Hub_OpenRenalScreening
Hub_OpenRenalScreening(ctx, parsed := 0, label := "") {
    c := Renal29_Context(ctx)
    g := Gui("+Resize +MinSize930x640","Renal Assessment & Dose Review")
    g.SetFont("s10","Segoe UI"),ApplyTheme(g)
    g.AddText("x16 y12 w890 h28","RENAL ASSESSMENT  |  " PCtx_MaskedId(ctx)).SetFont("s14 bold")
    g.AddText("x16 y52 w890","Renal stability                  Renal replacement             Exact indication for local dose rules")
    stability := g.AddDropDownList("x16 y76 w215",["Unknown","Stable","Changing / AKI"])
    rrt := g.AddDropDownList("x247 y76 w215",["Unknown","None","Hemodialysis","Peritoneal dialysis","CRRT"])
    contexts := [""]
    for rule in Renal29_Rules() {
        found := false
        for item in contexts {
            if item = rule["indication"]
                found := true
        }
        if !found
            contexts.Push(rule["indication"])
    }
    indication := g.AddComboBox("x478 y76 w425",contexts)
    indication.Text := c.indication
    stability.Choose(c.stability),rrt.Choose(c.rrt)
    output := g.AddEdit("x16 y126 w887 h400 ReadOnly Multi VScroll",Renal29_Report(ctx))
    refresh := (*) => Renal29_Update(ctx,stability,rrt,indication,output)
    for control in [stability,rrt,indication]
        control.OnEvent("Change",refresh)
    g.AddButton("x16 y543 w165","Enter renal inputs").OnEvent("Click",(*) => Renal29_Inputs(ctx,refresh))
    g.AddButton("x189 y543 w165","Refresh assessment").OnEvent("Click",refresh)
    g.AddButton("x362 y543 w165","Renal library").OnEvent("Click",(*) => Hub_OpenRenalLibrary(ctx))
    g.AddButton("x535 y543 w165","Copy assessment").OnEvent("Click",(*) => (A_Clipboard := output.Value))
    g.AddButton("x708 y543 w165","Close").OnEvent("Click",(*) => g.Destroy())
    g.AddText("x16 y593 w887 h36","© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    g.OnEvent("Escape",(*) => g.Destroy()),Workbench29_Show(g,"w930 h640")
    return g
}

Renal29_Inputs(ctx,refresh) {
    p := PCtx_ToParsed(ctx),g := Gui(,"Renal inputs — source verified entry")
    g.SetFont("s10","Segoe UI")
    controls := Map()
    labels := [["age","Age (years)",p.age],["sex","Sex (Male / Female)",p.sex],["heightCm","Height (cm)",p.heightCm],
        ["weightKg","Weight (kg)",p.weightKg],["scr","Serum creatinine (mg/dL)",p.scr],["egfr","eGFR (mL/min/1.73 m²)",PCtx_LabValue(ctx,"egfr")]]
    for i,row in labels {
        g.AddText("x16 y" (18+(i-1)*42) " w260",row[2])
        controls[row[1]] := g.AddEdit("x290 y" (14+(i-1)*42) " w260",row[3])
    }
    g.AddText("x16 y280 w540 h45","Enter values verified against the chart. Blank optional eGFR stays unknown. Units are explicit; collection time remains unknown unless present in the captured evidence.")
    g.AddButton("x16 y340 w260","Apply verified inputs").OnEvent("Click",(*) => Renal29_SaveInputs(ctx,g,controls,refresh))
    g.AddButton("x290 y340 w260","Cancel").OnEvent("Click",(*) => g.Destroy())
    g.Show("w570 h390")
    return g
}

Renal29_SaveInputs(ctx,g,controls,refresh) {
    v := Map()
    for k,c in controls
        v[k] := Trim(c.Value)
    for key in ["age","heightCm","weightKg","scr"] {
        if !IsNumber(v[key]) || v[key] <= 0 {
            MsgBox("Enter a positive numeric " key ".")
            return
        }
    }
    if v["age"] < 18 || v["age"] > 120 || v["heightCm"] < 100 || v["heightCm"] > 250 || v["weightKg"] < 20 || v["weightKg"] > 400 || v["scr"] > 25 || !RegExMatch(v["sex"],"i)^(male|female|m|f)$") {
        MsgBox("Check the adult age, sex, metric height/weight and SCr units. Inputs are outside supported adult ranges.")
        return
    }
    if v["egfr"] != "" && (!IsNumber(v["egfr"]) || v["egfr"] <= 0 || v["egfr"] > 250) {
        MsgBox("Enter an exact numeric eGFR 0–250, or leave it blank. Do not remove a > or < sign to manufacture an exact value.")
        return
    }
    for key in ["age","sex","heightCm"]
        Hub_SetDemo(ctx,key,v[key])
    for w in ctx.weights
        w.selected := false
    ctx.weights.Push({kg:v["weightKg"],label:"manually reviewed",when:"",capture:0,selected:true})
    for pair in [["scr","creatinine","mg/dL"],["egfr","egfr","mL/min/1.73 m²"]] {
        if v[pair[1]] = ""
            continue
        previous := PCtx_LabValue(ctx,pair[2])
        if previous = v[pair[1]]
            continue
        field := PCtx_NewField(v[pair[1]],pair[3],"","manual","renal input entry",0),field.edited := true
        if !ctx.labs.Has(pair[2])
            ctx.labs[pair[2]] := []
        ctx.labs[pair[2]].InsertAt(1,field)
    }
    for key in ["age","sex","heightCm","weightKg","scr"] {
        if ctx.captureCandidates.Has(key)
            ctx.captureCandidates.Delete(key)
    }
    PCtx_Touch(ctx),refresh(),g.Destroy()
}

Renal29_Update(ctx,stability,rrt,indication,output) {
    c := Renal29_Context(ctx),c.stability := stability.Text,c.rrt := rrt.Text,c.indication := Trim(indication.Text)
    output.Value := Renal29_Report(ctx)
    Review_Run(ctx)
}

; REPLACE Hub_OpenRenalLibrary
Hub_OpenRenalLibrary(ctx := 0, parsed := 0, label := "") {
    if !IsObject(ctx)
        ctx := PCtx_New()
    g := Gui("+Resize +MinSize980x640","Renal Rules Library")
    g.SetFont("s10","Segoe UI"),ApplyTheme(g)
    g.AddText("x16 y12 w950 h28","RENAL LIBRARY  |  Screening + local dose guidance").SetFont("s14 bold")
    g.AddText("x16 y49 w950 h42","Search the offline screening library. Product labels open directly in DailyMed. Local indication-specific dose rules are stored separately and survive upgrades.")
    search := g.AddEdit("x16 y99 w945")
    lv := g.AddListView("x16 y140 w945 h365 Grid -Multi",["Medication","Mode / metric","Review below / lower","Avoid below / upper","Rule / guidance","ID"])
    lv.ModifyCol(1,160),lv.ModifyCol(2,130),lv.ModifyCol(3,125),lv.ModifyCol(4,125),lv.ModifyCol(5,380)
    lv.ModifyCol(6,0)
    render := (*) => Renal29_LibraryRender(lv,search.Value)
    search.OnEvent("Change",render)
    g.AddButton("x16 y523 w175","Current product label").OnEvent("Click",(*) => Renal29_Label(lv))
    g.AddButton("x199 y523 w175","Add local dose rule").OnEvent("Click",(*) => Renal29_EditRule(render))
    g.AddButton("x382 y523 w175","Edit local rule").OnEvent("Click",(*) => Renal29_EditSelected(lv,render))
    g.AddButton("x565 y523 w175","Patient assessment").OnEvent("Click",(*) => Hub_OpenRenalScreening(ctx))
    g.AddButton("x748 y523 w175","Copy visible rules").OnEvent("Click",(*) => Hub_CopyListView(lv,"RENAL LIBRARY"))
    g.AddText("x16 y564 w945 h24","Legacy thresholds are screening prompts. Local rules require their specified metric, indication, stable renal function and no RRT.")
    g.AddText("x16 y601 w945 h32","© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    render(),g.OnEvent("Escape",(*) => g.Destroy()),Workbench29_Show(g,"w980 h650")
    return g
}



Renal29_Label(lv) {
    row := lv.GetNext()
    if !row
        return
    ingredient := RegExReplace(lv.GetText(row,1),"[^a-zA-Z0-9 -]","")
    SafeLaunchTarget("https://dailymed.nlm.nih.gov/dailymed/search.cfm?query=" StrReplace(ingredient," ","%20"))
}

Renal29_EditSelected(lv,callback) {
    row := lv.GetNext()
    if !row
        return
    id := lv.GetText(row,6)
    for rule in Renal29_Rules() {
        if rule["id"] = id {
            Renal29_EditRule(callback,rule)
            return
        }
    }
    MsgBox("This is a legacy screening threshold. Add a sourced local dose rule to supplement it.")
}

Renal29_EditRule(callback,rule := 0) {
    g := Gui(,"Local renal dose rule")
    g.SetFont("s10","Segoe UI")
    controls := Map()
    for i,field in ["ingredient","metric","lower","upper","indication","action","source","version"] {
        g.AddText("x16 y" (16+(i-1)*42) " w190",field (field="metric" ? " (CG or eGFR)" : ""))
        controls[field] := g.AddEdit("x220 y" (12+(i-1)*42) " w560",IsObject(rule) ? rule[field] : (field="metric" ? "CG" : ""))
    }
    g.AddText("x16 y356 w764 h55","Range includes lower, excludes upper. Enter the exact route/formulation and indication in the indication field and guidance. Saving makes this a user-maintained local rule; it is not represented as institution-approved.")
    id := IsObject(rule) && !InStr(rule["id"],"label-") ? rule["id"] : ""
    g.AddButton("x16 y423 w200","Save local rule").OnEvent("Click",(*) => Renal29_SaveRule(g,controls,callback,id))
    g.AddButton("x230 y423 w200","Cancel").OnEvent("Click",(*) => g.Destroy())
    if id != ""
        g.AddButton("x444 y423 w200","Delete local rule").OnEvent("Click",(*) => (IniDelete(Renal29_Path(),id),callback(),g.Destroy()))
    g.Show("w800 h470")
}

Renal29_SaveRule(g,controls,callback,id := "") {
    r := Map()
    for k,c in controls {
        r[k] := Trim(c.Value)
        if r[k] = "" || InStr(r[k],"`n") || InStr(r[k],"`r") {
            MsgBox("Every field is required and must fit on one line.")
            return
        }
    }
    if (r["metric"] != "CG" && r["metric"] != "eGFR") || !IsNumber(r["lower"]) || !IsNumber(r["upper"]) || r["lower"] < 0 || Number(r["upper"]) <= Number(r["lower"]) {
        MsgBox("Use CG or eGFR and a valid nonnegative lower < upper interval.")
        return
    }
    path := Renal29_Path(),SplitPath(path,,&dir),DirCreate(dir)
    if id = ""
        id := FormatTime(,"yyyyMMddHHmmss") "-" A_TickCount
    for k,v in r
        IniWrite(v,path,id,k)
    callback(),g.Destroy()
}

; REPLACE RunDailyMedEvidenceInquiry
RunDailyMedEvidenceInquiry(*) {
    Hub_OpenRenalLibrary()
}

Review_Guide(*) {
    text := "PhUCKIT RC29 — SHORTCUT GUIDE`r`n`r`n"
        . "Ctrl + left mouse drag: capture patient/chart region; open the patient workspace.`r`n"
        . "Ctrl + Up: BUD calculator.`r`nCtrl + Alt + D: fill-date calculator; Calculate & Submit runs the configured submission sequence.`r`n"
        . "Shift + left click: read selected fill row in the configured source window.`r`n"
        . "F10 / F11: mCDS target preview in its matching window.`r`n"
        . "Type eye in the verify-medication order window: eye-drop workflow.`r`n"
        . "Ctrl + Space: patient lookups.`r`n`r`n"
        . "AFTER CAPTURE`r`nAssessments refresh locally when inputs change. Review marks expire on changes. Medications → selected RX days supply reads the captured SIG. Med Rec → assign home/acute, confirm profile completeness, record a decision. Renal → verify stability/RRT/indication; Library → add sourced local dose guidance.`r`n`r`n"
        . "INSULIN`r`nChoose exact product, quantity unit and quantity. Confirm concentration, container size, priming and in-use days. Variable SIGs need maximum units/day and injections/day. The result includes medication-only arithmetic and device-use supply; final billing days remain editable.`r`n`r`n"
        . "AUTOMATION`r`nExisting medication Continue and fill-date submission remain enabled. Background review calculates findings; it does not silently change a prescription dose. Patient capture text remains local.`r`n`r`n"
        . "© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC."
    g := Gui("+Resize","PhUCKIT Shortcut Guide")
    g.SetFont("s11","Segoe UI")
    g.AddEdit("w840 h600 ReadOnly Multi VScroll",text)
    g.AddButton("w150","Copy guide").OnEvent("Click",(*) => (A_Clipboard := text))
    g.Show()
}

; Scrollable workbenches preserve readable fonts on smaller screens and high-DPI displays.
Workbench29_States() {
    static states := Map()
    return states
}

Workbench29_Show(g, options := "") {
    static installed := false
    if !installed {
        OnMessage(0x115,Workbench29_Scroll)
        OnMessage(0x114,Workbench29_Scroll)
        installed := true
    }
    positions := [],wide := 0,tall := 0
    stale := []
    for hwnd,state in Workbench29_States() {
        if !DllCall("IsWindow","Ptr",hwnd)
            stale.Push(hwnd)
    }
    for hwnd in stale
        Workbench29_States().Delete(hwnd)
    for hwnd,c in g {
        c.GetPos(&x,&y,&w,&h)
        positions.Push({c:c,x:x,y:y})
        wide := Max(wide,x+w+16),tall := Max(tall,y+h+16)
    }
    work := Hub_WorkArea(),scale := A_ScreenDPI/96
    width := Min(wide+20,Floor(work.width/scale)-55)
    height := Min(tall+20,Floor(work.height/scale)-85)
    width := Max(540,width),height := Max(350,height)
    g.Opt("+Resize +MinSize500x320 +0x300000")
    state := {g:g,positions:positions,wide:wide,tall:tall,x:0,y:0,pageW:width,pageH:height}
    Workbench29_States()[g.Hwnd] := state
    g.OnEvent("Size",Workbench29_Size)
    g.OnEvent("Close",(*) => Workbench29_Forget(g.Hwnd))
    g.Show("w" width " h" height)
    Workbench29_Size(g,0,width,height)
}

Review_Replay(*) {
    path := FileSelect(1,,"Choose a de-identified OCR-line replay fixture","JSON (*.json)")
    if path = ""
        return
    try {
        result := Review_ReplayFile(path)
        MsgBox("Medication rows: " result.actual "`nExpected rows: " result.expected "`nMissed expected matches: " result.missed "`nUnexpected rows: " result.extra
            . "`n`nThis checks the parser against OCR lines, not image-to-text OCR accuracy. No fixture content was sent over the network.","Capture replay")
    } catch as e
        MsgBox("Replay failed: " e.Message)
}

Review_ReplayFile(path) {
    data := CRD3_ReadJson(path)
    if !data.Has("deidentified") || data["deidentified"] != "yes"
        throw Error("Fixture must explicitly declare deidentified: yes.")
    part := {Text:data["text"],Lines:[]}
    for line in data["lines"]
        part.Lines.Push({Text:line["text"],x:line["x"],y:line["y"],w:line["w"],h:line["h"]})
    rows := PatientV4_ExtractOrderRows(part,false), matched := Map(),missed := 0
    for expected in data["expected"] {
        found := false
        for i,row in rows {
            if !matched.Has(i) && InStr(StrLower(row),StrLower(expected)) {
                matched[i] := true,found := true
                break
            }
        }
        if !found
            missed += 1
    }
    return {actual:rows.Length,expected:data["expected"].Length,missed:missed,extra:rows.Length-matched.Count}
}

Workbench29_Forget(hwnd) {
    if Workbench29_States().Has(hwnd)
        Workbench29_States().Delete(hwnd)
}

Workbench29_Size(g,minMax,width,height) {
    states := Workbench29_States()
    if minMax = -1 || !states.Has(g.Hwnd)
        return
    s := states[g.Hwnd],s.pageW := width,s.pageH := height
    s.x := Max(0,Min(s.x,s.wide-width)),s.y := Max(0,Min(s.y,s.tall-height))
    Workbench29_Position(s)
}

Workbench29_Position(s) {
    for item in s.positions
        try item.c.Move(item.x-s.x,item.y-s.y)
    for axis in [0,1] {
        info := Buffer(28,0)
        NumPut("UInt",28,"UInt",0x17,"Int",0,"Int",Round((axis ? s.tall : s.wide)-1),info)
        NumPut("UInt",Round(axis ? s.pageH : s.pageW),"Int",Round(axis ? s.y : s.x),info,16)
        DllCall("SetScrollInfo","Ptr",s.g.Hwnd,"Int",axis,"Ptr",info,"Int",true)
    }
}

Workbench29_Scroll(wParam,lParam,msg,hwnd) {
    states := Workbench29_States()
    ; Ignore scroll notifications from Edit/ListView controls.
    if lParam || !states.Has(hwnd)
        return
    s := states[hwnd],vertical := msg = 0x115,command := wParam & 0xFFFF
    pos := vertical ? s.y : s.x,page := vertical ? s.pageH : s.pageW
    maximum := Max(0,(vertical ? s.tall : s.wide)-page)
    if command = 0
        pos -= 32
    else if command = 1
        pos += 32
    else if command = 2
        pos -= page*0.8
    else if command = 3
        pos += page*0.8
    else if command = 4 || command = 5
        pos := (wParam >> 16) & 0xFFFF
    else if command = 6
        pos := 0
    else if command = 7
        pos := maximum
    if vertical
        s.y := Min(maximum,Max(0,pos))
    else
        s.x := Min(maximum,Max(0,pos))
    Workbench29_Position(s)
    return 0
}

Preparation29_Path() {
    global LocalSettingsDir
    return (IsSet(LocalSettingsDir) ? LocalSettingsDir : A_ScriptDir) "\preparation-bud-library.ini"
}

Preparation29_Open(*) {
    g := Gui("+Resize","Preparation BUD Library")
    g.SetFont("s10","Segoe UI")
    g.AddText("x16 y12 w860 h28","PREPARATION-SPECIFIC BUD").SetFont("s14 bold")
    g.AddText("x16 y50 w860 h42","Store the exact preparation and its source-approved duration together. Select a saved preparation or enter one below. No universal sterile-compounding BUD is assumed.")
    controls := Map()
    names := ["New preparation"]
    if FileExist(Preparation29_Path()) {
        for name in StrSplit(IniRead(Preparation29_Path()),"`n") {
            if name != ""
                names.Push(name)
        }
    }
    chooser := g.AddDropDownList("x16 y100 w860 Choose1",names)
    for i,field in ["name","drug","concentration","diluent","container","storage","durationHours","source","sourceVersion"] {
        g.AddText("x16 y" (147+(i-1)*36) " w165",field)
        controls[field] := g.AddEdit("x185 y" (143+(i-1)*36) " w690")
    }
    chooser.OnEvent("Change",(*) => Preparation29_Load(chooser.Text,controls))
    g.AddText("x16 y480 w160","Prepared date/time:")
    prepared := g.AddDateTime("x185 y475 w260","yyyy-MM-dd HH:mm")
    output := g.AddEdit("x16 y514 w860 h115 ReadOnly Multi VScroll")
    g.AddButton("x16 y644 w200","Calculate BUD").OnEvent("Click",(*) => Preparation29_Calculate(controls,prepared,output))
    g.AddButton("x230 y644 w200","Save preparation").OnEvent("Click",(*) => Preparation29_Save(controls,chooser))
    g.AddButton("x444 y644 w200","Copy result").OnEvent("Click",(*) => (A_Clipboard := output.Value))
    g.AddButton("x658 y644 w200","Date arithmetic").OnEvent("Click",(*) => Combined_OpenBUD())
    g.AddText("x16 y690 w860 h36","© 2026 Pharmacist.Guide. All rights reserved. Pharmacist.Guide is owned and operated by Carry LLC.")
    Workbench29_Show(g)
    return g
}

Preparation29_Load(name,controls) {
    for key,c in controls
        c.Value := name = "New preparation" ? "" : IniRead(Preparation29_Path(),name,key,"")
}

Preparation29_Read(controls) {
    r := Map()
    for key,c in controls {
        value := Trim(c.Value)
        if value = "" || RegExMatch(value,"[\r\n\[\]]")
            throw Error("Complete all preparation fields; brackets and line breaks are not supported.")
        r[key] := value
    }
    if !IsNumber(r["durationHours"]) || r["durationHours"] <= 0 || r["durationHours"] > 87600
        throw Error("Enter a positive source-supported duration in hours (maximum 10 years).")
    return r
}

Preparation29_Save(controls,chooser) {
    try {
        r := Preparation29_Read(controls),path := Preparation29_Path()
        SplitPath(path,,&dir),DirCreate(dir)
        for key,value in r
            IniWrite(value,path,r["name"],key)
        chooser.Delete(),chooser.Add(["New preparation"])
        for name in StrSplit(IniRead(path),"`n")
            chooser.Add([name])
        chooser.Choose(r["name"])
    } catch as e
        MsgBox(e.Message)
}

Preparation29_Calculate(controls,prepared,output) {
    try {
        r := Preparation29_Read(controls)
        expires := DateAdd(prepared.Value,Round(r["durationHours"]*3600),"Seconds")
        output.Value := r["drug"] " | " r["concentration"] " | " r["diluent"] " | " r["container"] " | " r["storage"]
            . "`r`nBUD: " FormatTime(expires,"yyyy-MM-dd HH:mm") " (" r["durationHours"] " hours after preparation)"
            . "`r`nSource: " r["source"] " | " r["sourceVersion"] "`r`nApplies only to the documented preparation, storage, and source conditions."
    } catch as e
        output.Value := "Needs input: " e.Message
}

; RC30 reconciliation: exact regimen pass precedes unique ingredient pairing.
Menu_OpenPatientContext() {
    ctx := PCtx_Active()
    if !IsObject(ctx) {
        MsgBox("Capture a patient screen first. Ctrl+Space opens the active patient workspace and medication comparison.", "Patient workspace", "Iconi")
        return
    }
    ; The action surface is the comparison itself: ambulatory and acute rows
    ; are rendered together with dose, route, SIG, formulation and status
    ; changes. The broader second-check workspace remains one click away.
    Hub_OpenMedRecComparison(ctx)
}

MedRec30_Status(m) {
    raw := MedRec_Value(m,"status")
    return raw = "" ? "unknown" : RxN_StatusCategory(raw)
}

MedRec30_Form(m) {
    raw := MedRec_Value(m,"raw"), tags := []
    for pattern,label in Map("i)\b(extended.release|sustained.release|controlled.release|ER|XR|XL|SR|CR)\b","modified release","i)\b(delayed.release|enteric.coated|DR|EC)\b","delayed release","i)\b(immediate.release|IR)\b","immediate release") {
        if RegExMatch(raw,pattern)
            tags.Push(label)
    }
    form := StrLower(MedRec_Value(m,"form"))
    if RegExMatch(form,"^(tab|tabs|tablet)$")
        form := "tablet"
    if RegExMatch(form,"^(cap|caps|capsule)$")
        form := "capsule"
    return form "|" DoseAware_Join(tags,"+") "|" StrLower(MedRec_Value(m,"conc"))
}

MedRec30_Regimen(m) {
    return MedRec_DoseKey(m) "|" MedRec_RouteKey(m) "|" StrLower(Sig_CompactFromMedication(m)) "|" MedRec30_Form(m) "|" MedRec30_Status(m)
}

; REPLACE MedRec_StatusLabel
MedRec_StatusLabel(med) {
    switch MedRec30_Status(med) {
        case "active": return "Active"
        case "inactive": return "Inactive / discontinued"
        case "held": return "Held"
        case "pending": return "Pending verification"
        case "administered": return "Administered"
        default: return "Status not captured"
    }
}

; REPLACE MedRec_ComparePair
MedRec_ComparePair(home, acute) {
    changes := []
    status := MedRec_StatusChange(home,acute)
    if status != ""
        changes.Push(status)
    if MedRec30_Status(home) = "unknown" || MedRec30_Status(acute) = "unknown"
        changes.Push("Status not captured — verify")
    for spec in [["Dose",MedRec_DoseKey(home),MedRec_DoseKey(acute)],["Route",MedRec_RouteKey(home),MedRec_RouteKey(acute)],["Frequency/SIG",Sig_CompactFromMedication(home),Sig_CompactFromMedication(acute)]] {
        if spec[2] = "" || spec[3] = ""
            changes.Push(spec[1] " missing — verify source")
        else if StrLower(spec[2]) != StrLower(spec[3])
            changes.Push(spec[1] " changed")
    }
    if MedRec30_Form(home) != MedRec30_Form(acute)
        changes.Push("Formulation/release/concentration differs or is unspecified")
    return changes.Length ? DoseAware_Join(changes,"; ") : "Present on both"
}

MedRec30_Candidates(m, others, sameIngredient := true) {
    out := [], key := sameIngredient ? MedRec_IngredientKey(m) : MedRec_TherapeuticGroup(m)
    if key = ""
        return ""
    for other in others {
        otherKey := sameIngredient ? MedRec_IngredientKey(other) : MedRec_TherapeuticGroup(other)
        if key = otherKey && (sameIngredient || MedRec_IngredientKey(m) != MedRec_IngredientKey(other))
            out.Push(MedRec_Display(other))
    }
    return DoseAware_Join(out,"`r`n")
}

MedRec30_Duplicates(m, profile) {
    count := 0, key := MedRec_IngredientKey(m)
    if key = "" || MedRec30_Status(m) = "inactive"
        return ""
    for other in profile {
        if MedRec_IngredientKey(other) = key && MedRec30_Status(other) != "inactive"
            count += 1
    }
    return count > 1 ? "Multiple same-ingredient orders in this profile (" count ") — distinguish split regimens, PRN, duplicate capture and duplicate therapy." : ""
}

MedRec30_Row(ctx, h, a, status, parsed, home, acute) {
    meds := [], notes := []
    if IsObject(h) {
        meds.Push(h)
        note := MedRec30_Duplicates(h,home)
        if note != ""
            notes.Push("AMBULATORY: " note)
    }
    if IsObject(a) {
        meds.Push(a)
        note := MedRec30_Duplicates(a,acute)
        if note != ""
            notes.Push("ACUTE: " note)
    }
    for m in meds {
        if RxN_IsUncertain(m)
            notes.Push("OCR uncertain — verify source before acting.")
    }
    for m in meds {
        if RegExMatch(MedRec_Value(m,"raw"),"i)\b(SIG|take|inject|hold if|hold for|sliding scale|taper|with meals|before meals|after meals|as directed)\b")
            notes.Push("Full SIG / administration instructions present: verify administered dose versus product strength, schedule, PRN indication and hold parameters in source text; compact fields do not establish complete equivalence.")
    }
    clinical := MedRec_ClinicalFlags(ctx,meds,parsed)
    if clinical != ""
        notes.Push(clinical)
    if !IsObject(h) || !IsObject(a) {
        m := IsObject(h) ? h : a, others := IsObject(h) ? acute : home
        same := MedRec30_Candidates(m,others)
        if same != ""
            notes.Push("Same-ingredient candidates (not automatically linked):`r`n" same)
        therapeutic := MedRec30_Candidates(m,others,false)
        if therapeutic != ""
            notes.Push("Possible therapeutic substitution candidates — verify intent/equivalence; not a matched order:`r`n" therapeutic)
    }
    flags := DoseAware_Join(notes,"`r`n")
    priority := status = "Present on both" && flags = "" ? 3 : 1
    return {home:h,acute:a,status:status,flags:flags,priority:priority}
}

; REPLACE MedRec_BuildComparison
MedRec_BuildComparison(ctx) {
    home := PCtx_ProfileMeds(ctx,"ambulatory"),acute := PCtx_ProfileMeds(ctx,"acute")
    parsed := PCtx_ToParsed(ctx),PatientCalc_Enrich(parsed)
    matched := Map(),used := Map(),rows := []
    ; Complete exact-regimen pass across every ingredient before considering changes.
    for hi,h in home {
        key := MedRec_IngredientKey(h)
        if key = ""
            continue
        candidates := []
        for ai,a in acute {
            if !used.Has(ai) && key = MedRec_IngredientKey(a) && MedRec30_Regimen(h) = MedRec30_Regimen(a)
                candidates.Push(ai)
        }
        ; Identical duplicate rows remain visibly flagged; pair only a unique candidate.
        sameHome := 0
        for hj,other in home {
            if !matched.Has(hj) && MedRec_IngredientKey(other) = key && MedRec30_Regimen(other) = MedRec30_Regimen(h)
                sameHome += 1
        }
        if candidates.Length = 1 && sameHome = 1 {
            ai := candidates[1],matched[hi] := ai,used[ai] := true
        }
    }
    ; Only unique remaining same-ingredient pairs are safe to compare automatically.
    for hi,h in home {
        if matched.Has(hi)
            continue
        key := MedRec_IngredientKey(h),hc := 0,candidates := []
        if key = ""
            continue
        for hj,other in home {
            if !matched.Has(hj) && MedRec_IngredientKey(other) = key
                hc += 1
        }
        for ai,a in acute {
            if !used.Has(ai) && MedRec_IngredientKey(a) = key
                candidates.Push(ai)
        }
        if hc = 1 && candidates.Length = 1 {
            ai := candidates[1],matched[hi] := ai,used[ai] := true
        }
    }
    for hi,h in home {
        if matched.Has(hi) {
            a := acute[matched[hi]]
            rows.Push(MedRec30_Row(ctx,h,a,MedRec_ComparePair(h,a),parsed,home,acute))
            continue
        }
        if MedRec30_Candidates(h,acute) != ""
            status := "Ambiguous / additional ambulatory order — review same-ingredient candidates"
        else if MedRec30_Status(h) = "inactive"
            status := "Outpatient medication inactive/discontinued — verify intended status"
        else if MedRec30_Status(h) = "held"
            status := "Held outpatient medication — verify intended inpatient plan"
        else if MedRec30_Status(h) != "active"
            status := "Outpatient status unresolved — verify current use and inpatient plan"
        else
            status := MedRec_ProfileComplete(ctx,"acute") ? "Possible omission — not seen in complete acute order profile" : "Not seen in captured acute profile — verify complete order list"
        rows.Push(MedRec30_Row(ctx,h,0,status,parsed,home,acute))
    }
    for ai,a in acute {
        if used.Has(ai)
            continue
        if MedRec30_Candidates(a,home) != ""
            status := "Ambiguous / additional acute order — review same-ingredient candidates"
        else if MedRec30_Status(a) = "inactive"
            status := "Acute order inactive/discontinued — verify intended status"
        else
            status := MedRec_ProfileComplete(ctx,"ambulatory") ? "Acute-only order — verify indication and transition plan" : "Not seen in captured ambulatory profile — verify complete home list"
        rows.Push(MedRec30_Row(ctx,0,a,status,parsed,home,acute))
    }
    for m in PCtx_ProfileMeds(ctx,"unassigned")
        rows.Push(MedRec30_Row(ctx,m,0,"Profile not assigned — comparison withheld; review source tab",parsed,home,acute))
    ordered := []
    for priority in [1,3] {
        for row in rows {
            if row.priority = priority
                ordered.Push(row)
        }
    }
    return ordered
}

MedRec30_Fields(h,a) {
    out := "FIELD | AMBULATORY | ACUTE`r`n"
    for field in ["dose","route","freq","form","conc","status","startAt","stopAt"] {
        left := MedRec_Value(h,field),right := MedRec_Value(a,field)
        out .= field " | " (left = "" ? "[not captured]" : left) " | " (right = "" ? "[not captured]" : right) "`r`n"
    }
    return out
}

MedRec30_Copy(s) {
    Review_Run(s.ctx)
    st := Review_State(s.ctx)
    out := "MEDICATION RECONCILIATION — " PCtx_MaskedId(s.ctx) "`r`n" FormatTime(,"yyyy-MM-dd HH:mm:ss") "`r`n"
    out .= "Ambulatory profile complete: " (MedRec_ProfileComplete(s.ctx,"ambulatory") ? "confirmed" : "NOT confirmed") "`r`n"
    out .= "Acute profile complete: " (MedRec_ProfileComplete(s.ctx,"acute") ? "confirmed" : "NOT confirmed") "`r`n"
    for r in MedRec_BuildComparison(s.ctx) {
        key := Review_Value(r)
        out .= "`r`n" r.status "`r`nAMBULATORY: " MedRec_Display(r.home) "`r`nACUTE: " MedRec_Display(r.acute) "`r`n" r.flags "`r`nDECISION: " (st.ack.Has(key) ? st.ack[key] : "UNREVIEWED") "`r`n"
    }
    A_Clipboard := out
    s.detail.Value := "Copied all comparison rows, current completeness, findings and decisions. Search filters do not omit rows from this handoff."
}

; RC30 source-card layer. These are label tables for display and review, not
; automatic orders. Keep the source, metric, age scope and dialysis caveat
; attached to every card so a screening hit cannot masquerade as a complete
; patient-specific dosing recommendation.
Renal30_LabelCards(key) {
    key := StrLower(Trim(key))
    if InStr(key,"gabapentin")
        return {title:"Gabapentin — adult/age >=12 renal table",metric:"Cockcroft–Gault CrCl (mL/min)",source:"https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=401b30fc-e143-4906-aae1-e5b5c190d4a8",checked:"2026-09-25",text:">=60: total daily 900–3600 mg; examples 300–1200 mg TID.`r`n>30–59: total daily 400–1400 mg; examples 200–700 mg BID.`r`n>15–29: total daily 200–700 mg; examples 200–700 mg QD.`r`n15: total daily 100–300 mg; examples 100–300 mg QD.`r`n<15: reduce the daily dose proportionally to CrCl.`r`nHemodialysis: use the maintenance table plus a post-HD supplemental dose after each 4-hour HD session; the label table lists 125–350 mg by selected maintenance dose.`r`nScope: age >=12; indication-specific starting/titration and formulation labeling still apply."}
    if InStr(key,"cefepime")
        return {title:"Cefepime — adult maintenance table",metric:"Cockcroft–Gault CrCl (mL/min)",source:"https://dailymed.nlm.nih.gov/dailymed/getFile.cfm?setid=c654ef2e-1067-4026-8931-6a0dc2a17ad1&type=pdf",checked:"2026-09-25",text:"Initial dose is generally the same as CrCl >60, except in hemodialysis; adjust maintenance when CrCl <=60.`r`nCrCl 30–60: regimen-dependent examples in label Table 2 include 500 mg q24h, 1 g q24h, 2 g q24h, or 2 g q12h.`r`nCrCl 11–29: regimen-dependent examples include 500 mg q24h, 500 mg q24h, 1 g q24h, or 2 g q24h.`r`nCrCl <11 and hemodialysis: use the label table and dialysis timing; do not infer a fixed regimen from a screening threshold.`r`nNeurotoxicity risk and indication/infusion strategy require active review."}
    return 0
}

Renal30_LabelCardText(medicationKey) {
    card := Renal30_LabelCards(medicationKey)
    if !IsObject(card)
        return ""
    return "SOURCE-LINKED RENAL DOSING CARD: " card.title "`r`nMetric: " card.metric "`r`n" card.text "`r`nSource: " card.source "`r`nChecked: " card.checked " | NOT institution reviewed; pharmacist verification required.`r`n"
}

; REPLACE Renal29_LibraryRender
Renal29_LibraryRender(lv,query) {
    lv.Delete()
    for r in RefData_Rows("renal_rules") {
        if query != "" && !InStr(StrLower(Review_Value(r)),StrLower(query))
            continue
        lv.Add("",r["ingredient"],r["mode"],r["review_below"],r["avoid_below"],r["note"])
    }
    for r in Renal29_Rules() {
        if query != "" && !InStr(StrLower(Review_Value(r)),StrLower(query))
            continue
        lv.Add("",r["ingredient"],"LABEL " r["metric"],r["lower"],r["upper"],r["indication"] " | " r["action"] " | " r["source"] " | " r["version"],r["id"])
    }
    for key in ["gabapentin","cefepime"] {
        card := Renal30_LabelCards(key)
        if query != "" && !InStr(StrLower(Review_Value(card)),StrLower(query))
            continue
        lv.Add("",key,"LABEL CARD " card.metric,"source-linked","review","" card.title " | " card.source " | checked " card.checked,"card-" key)
    }
}

; REPLACE MedRec_StatusChange
MedRec_StatusChange(home, acute) {
    if !IsObject(home) || !IsObject(acute)
        return ""
    homeCat := MedRec30_Status(home)
    acuteCat := MedRec30_Status(acute)
    changes := []

    switch acuteCat {
        case "inactive": changes.Push("Stopped/discontinued in acute profile")
        case "held": changes.Push("Held in acute profile")
        case "pending": changes.Push("Pending verification in acute profile")
        case "administered": changes.Push("Administered in acute profile")
    }
    if homeCat = "inactive" && acuteCat = "active"
        changes.Push("Restarted in acute profile")
    else if homeCat = "held" && acuteCat = "active"
        changes.Push("Released from outpatient hold")
    if MedRec_Value(acute, "startAt") != ""
        changes.Push("Acute start " MedRec_Value(acute, "startAt"))
    if MedRec_Value(acute, "stopAt") != ""
        changes.Push("Acute stop " MedRec_Value(acute, "stopAt"))
    return DoseAware_Join(changes, "; ")
}

; REPLACE Hub_ShowBackgroundMedicationComparison
Hub_ShowBackgroundMedicationComparison(ctx, data, elapsedMs) {
    outpatient := []
    inpatient := []
    for line in StrSplit(data, "`n", "`r") {
        fields := StrSplit(line, "`t")
        if fields.Length < 2 || Trim(fields[2]) = ""
            continue
        med := RxN_Normalize(fields[2])
        med.profile := Trim(fields[1]) = "outpatient" ? "ambulatory" : "acute"
        ; Returned text may omit status; do not invent active therapy.
        if med.profile = "ambulatory"
            outpatient.Push(med)
        else
            inpatient.Push(med)
    }

    comparisonCtx := PCtx_New()
    comparisonCtx.ident := ctx.ident.Clone()
    comparisonCtx.medRecs := []
    for m in outpatient
        comparisonCtx.medRecs.Push(m)
    for m in inpatient
        comparisonCtx.medRecs.Push(m)
    rows := []
    for row in MedRec_BuildComparison(comparisonCtx)
        rows.Push({home:row.home,acute:row.acute,finding:row.status "`r`n" row.flags})

    if rows.Length = 0 {
        finding := Trim(data) = ""
            ? "No rows returned from the verified inpatient source. Compare against the live Acute Profile and confirm the LSV source includes this encounter."
            : "Source data was retrieved but could not be normalized. Review the raw returned rows below."
        rows.Push({home:0, acute:0, finding:finding, rawData:data})
    }

    g := Gui("+MinimizeBox +Resize", "PhUCKIT · Admission Medication Comparison")
    g.SetFont("s10", "Segoe UI")
    ApplyTheme(g)
    Theme_Heading(g.Add("Text", "xm w1180", "Outpatient and inpatient medication comparison"))
    Theme_Subtle(g.Add("Text", "xm y+3 w1180", "Background LSV context retrieved in " elapsedMs " ms. Compare against the live Medication Manager profile before acting; not a complete medication reconciliation."))
    list := g.Add("ListView", "xm y+10 w1180 h385 Grid -Multi", ["Outpatient medication", "Inpatient medication", "Difference / review prompt"])
    for row in rows
        list.Add("", MedRec_Display(row.home), MedRec_Display(row.acute), row.finding)
    list.ModifyCol(1, 390), list.ModifyCol(2, 390), list.ModifyCol(3, 380)
    details := g.Add("Edit", "xm y+10 w1180 h105 ReadOnly VScroll -Wrap", "Select a row to inspect the background source text.")
    Theme_OutputFont(details)
    if rows.Length = 1 && rows[1].home = 0 && rows[1].acute = 0 {
        details.Value := Trim(data) = ""
            ? "NO INPATIENT SOURCE ROWS RETURNED`r`n`r`n" rows[1].finding
            : "RAW BACKGROUND SOURCE DATA`r`n`r`n" data
    }
    list.OnEvent("ItemSelect", (*) => Hub_BackgroundComparisonSelected(rows, list, details))
    g.Add("Button", "xm y+10 w145 h32", "Copy Comparison").OnEvent("Click", (*) => (A_Clipboard := Hub_BackgroundComparisonText(rows)))
    g.Add("Button", "x+8 yp w100 h32", "Close").OnEvent("Click", (*) => g.Destroy())
    Workbench29_Show(g,"w1220 h590")
}

; REPLACE RxN_Signature
RxN_Signature(rec) {
    ; Deduplicate only equivalent source text, not just a lossy dose/route tuple.
    return MedRec_IngredientKey(rec) "#" MedRec30_Regimen(rec) "#" StrLower(RegExReplace(Trim(MedRec_Value(rec,"raw")),"\s+"," "))
}

; REPLACE PatientV6_GroundMedicationList
; Preserve every plausible medication-grid row for pharmacist review.  A row
; that lacks a dose or local-library match is visible in Med Rec, but its
; explicit state keeps it out of automated clinical rules until verified.
PatientV6_GroundMedicationList(medications, parsed) {
    output := []
    retainedNoDose := 0
    retainedUnknownDrug := 0
    retainedUnresolved := 0

    for medication in medications {
        text := Trim(String(medication))
        if text = ""
            continue
        if PatientV6_IsMedicationHeaderOrNoise(text)
            continue

        hasDose := RegExMatch(text, "i)\\b\\d+(?:[.,]\\d+)?\\s*(?:mcg|mg|g|mL|units?|mEq|mmol|%)\\b")
        known := IsObject(CRD5_FindMedication(text))
        if !hasDose {
            retainedNoDose += 1
            if !InStr(text, "[MISSING DOSE]")
                text .= " [MISSING DOSE]"
        }
        if !known {
            retainedUnknownDrug += 1
            if !InStr(text, "[UNRESOLVED MEDICATION]")
                text .= " [UNRESOLVED MEDICATION]"
        }
        if !hasDose || !known {
            retainedUnresolved += 1
            if !InStr(text, "[VERIFY OCR]")
                text .= " [VERIFY OCR]"
        }
        output.Push(text)
    }

    if retainedNoDose > 0
        PatientV6_AddWarning(parsed, retainedNoDose " medication row" (retainedNoDose = 1 ? " lacks" : "s lack") " a captured dose and remains review-gated.")
    if retainedUnknownDrug > 0
        PatientV6_AddWarning(parsed, retainedUnknownDrug " medication row" (retainedUnknownDrug = 1 ? " is" : "s are") " not standardized to the local drug library and remains review-gated.")
    if retainedUnresolved > 0
        PatientV6_AddWarning(parsed, "Unresolved medication rows remain visible in Med Rec; verify the source before clinical action.")
    return output
}

PatientV6_IsMedicationHeaderOrNoise(text) {
    return RegExMatch(text, "i)^(?:Order\\s+Sentence|Medication(?:s)?|Medication\\s+Profile|Current\\s+Medications|Start|Stop|Order\\s+Type|Last\\s+Fill|Rx\\s+Number|Status|Source\\s+Type|Action|Drug)\\s*:?(?:\\s|$)")
        || RegExMatch(text, "i)^(?:Nursing|Medical|Diagnoses|Problems|Allergies|Vitals|Patient\\s+Notes?)\\b")
}

; REPLACE PatientV2_NormalizeParsedShape
PatientV2_NormalizeParsedShape(parsed) {
    if !IsObject(parsed)
        return PatientV2_NewParsedResult()
    for field in ["age","dob","sex","location","heightCm","weightKg","scr","egfr","mrn","fin","patientName","systolicBP","diastolicBP"] {
        if !parsed.HasOwnProp(field)
            parsed.%field% := ""
    }
    for field in ["allergies","medications","medicationsPendingReview","captureWarnings","gridLabs","qualitativeFindings","vitalEvidence"] {
        if !parsed.HasOwnProp(field) || !IsObject(parsed.%field%)
            parsed.%field% := []
    }
    if !parsed.HasOwnProp("captureEvidence") || !IsObject(parsed.captureEvidence)
        parsed.captureEvidence := Map()
    return parsed
}

; REPLACE PatientV2_MergeScalars
PatientV2_MergeScalars(target, source) {
    if !IsObject(source)
        return
    for key in ["age","dob","sex","location","heightCm","weightKg","scr","egfr","mrn","fin","patientName"] {
        if !source.HasOwnProp(key)
            continue
        if !target.HasOwnProp(key)
            target.%key% := ""
        if target.%key% = "" && source.%key% != ""
            target.%key% := source.%key%
    }
}