@omniradiology/omnirad 0.1.3

package/lib/auth.ts

@@ -0,0 +1,22 @@
+import bcrypt from "bcryptjs";
+
+/**
+ * Hashes a plaintext password using bcrypt.
+ */
+export async function hashPassword(password: string): Promise<string> {
+    return await bcrypt.hash(password, 10);
+}
+
+/**
+ * Verifies a plaintext password against a stored bcrypt hash.
+ */
+export async function verifyPassword(password: string, hash: string): Promise<boolean> {
+    return await bcrypt.compare(password, hash);
+}
+
+/**
+ * Generates a secure random session ID.
+ */
+export function generateSessionId(): string {
+    return crypto.randomUUID();
+}

package/lib/copilot/action-executor.ts

@@ -0,0 +1,94 @@
+// ─── Viewer Action Executor ──────────────────────────────────────────────────
+// Deterministic executor that processes AI viewer actions against the
+// CopilotCornerstoneViewer ref in the correct order.
+
+import type {
+    AIViewerAction,
+    CopilotViewerRef,
+    AnnotationAction,
+    SegmentationAction,
+} from "@/types/copilot-viewer";
+import {
+    sortViewerActions,
+    isNavigateAction,
+    isAnnotationAction,
+    isSegmentationAction,
+    isViewportAction,
+    isClearAction,
+} from "./action-types";
+
+/**
+ * Execute a list of AI viewer actions against the viewer ref.
+ * Actions are sorted by priority: clear → navigate → segment → annotate → viewport
+ * and executed sequentially with a small delay between groups.
+ */
+export async function executeViewerActions(
+    actions: AIViewerAction[],
+    viewerRef: CopilotViewerRef | null,
+): Promise<void> {
+    if (!viewerRef || !actions || actions.length === 0) return;
+
+    const sorted = sortViewerActions(actions);
+
+    for (const action of sorted) {
+        try {
+            executeSingleAction(action, viewerRef);
+            // Small delay between actions for visual feedback
+            await sleep(50);
+        } catch (err) {
+            console.error("[ActionExecutor] Error executing action:", action, err);
+        }
+    }
+}
+
+/**
+ * Execute a single viewer action.
+ */
+function executeSingleAction(
+    action: AIViewerAction,
+    viewer: CopilotViewerRef,
+): void {
+    if (isClearAction(action)) {
+        switch (action.action) {
+            case "clear_ai_annotations":
+            case "clear_ai_segmentations":
+            case "clear_all_ai_findings":
+                viewer.clearAIFindings();
+                break;
+        }
+        return;
+    }
+
+    if (isNavigateAction(action)) {
+        viewer.jumpToSlice(action.slice);
+        return;
+    }
+
+    if (isSegmentationAction(action)) {
+        viewer.addSegmentation(action as SegmentationAction);
+        return;
+    }
+
+    if (isAnnotationAction(action)) {
+        viewer.addAnnotation(action as AnnotationAction);
+        return;
+    }
+
+    if (isViewportAction(action)) {
+        switch (action.action) {
+            case "zoom_to_region":
+                if (action.x !== undefined && action.y !== undefined && action.width !== undefined && action.height !== undefined) {
+                    viewer.zoomToRegion(action.x, action.y, action.width, action.height);
+                }
+                break;
+            case "reset_viewport":
+                viewer.resetViewport();
+                break;
+        }
+        return;
+    }
+}
+
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/copilot/action-types.ts

@@ -0,0 +1,72 @@
+// ─── Copilot Viewer Action Types & Utilities ─────────────────────────────────
+// Central definitions and type guards for all viewer actions.
+
+import type {
+    AIViewerAction,
+    NavigateAction,
+    AnnotationAction,
+    SegmentationAction,
+    ViewportAction,
+    ClearAction,
+} from "@/types/copilot-viewer";
+
+// ── Type Guards ──────────────────────────────────────────────────────────────
+
+export function isNavigateAction(a: AIViewerAction): a is NavigateAction {
+    return a.type === "navigate";
+}
+
+export function isAnnotationAction(a: AIViewerAction): a is AnnotationAction {
+    return a.type === "annotation";
+}
+
+export function isSegmentationAction(a: AIViewerAction): a is SegmentationAction {
+    return a.type === "segmentation";
+}
+
+export function isViewportAction(a: AIViewerAction): a is ViewportAction {
+    return a.type === "viewport";
+}
+
+export function isClearAction(a: AIViewerAction): a is ClearAction {
+    return a.type === "clear";
+}
+
+// ── Action Sorting ───────────────────────────────────────────────────────────
+// Execution order: clear → navigate → segment → annotate → viewport
+
+const ACTION_PRIORITY: Record<string, number> = {
+    clear: 0,
+    navigate: 1,
+    segmentation: 2,
+    annotation: 3,
+    viewport: 4,
+};
+
+export function sortViewerActions(actions: AIViewerAction[]): AIViewerAction[] {
+    return [...actions].sort(
+        (a, b) => (ACTION_PRIORITY[a.type] ?? 99) - (ACTION_PRIORITY[b.type] ?? 99)
+    );
+}
+
+// ── Default Styling ──────────────────────────────────────────────────────────
+
+export const AI_ANNOTATION_DEFAULTS = {
+    color: "#ff4d4f",         // Red for abnormal findings
+    normalColor: "#52c41a",   // Green for normal findings
+    labelMode: "always" as const,
+    segmentationOpacity: 0.3,
+    segmentationColor: "#ff4d4f",
+    contourColor: "#ff6b6b",
+    contourWidth: 2,
+};
+
+// ── Label Formatting ─────────────────────────────────────────────────────────
+
+export function formatAILabel(name: string, confidence?: number): string {
+    const base = name || "Finding";
+    if (confidence !== undefined && confidence > 0) {
+        return `${base} (AI) — ${Math.round(confidence * 100)}%`;
+    }
+    return `${base} (AI)`;
+}

package/lib/copilot/coordinate-mapper.ts

@@ -0,0 +1,84 @@
+// ─── Coordinate Mapper ───────────────────────────────────────────────────────
+// Maps between MedSAM3 pixel-space coordinates and the Cornerstone viewport.
+// First implementation uses image pixel space which is sufficient for stack viewports.
+
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+
+/**
+ * Convert image pixel coordinates to viewport coordinates.
+ * For stack viewports with standard 2D slice rendering, image-space
+ * coordinates map 1:1 with Cornerstone image coordinates.
+ */
+export function imageToViewportCoordinates(
+    imageX: number,
+    imageY: number,
+    imageDims: ImageDimensions,
+    viewportDims: ImageDimensions
+): { x: number; y: number } {
+    const scaleX = viewportDims.width / imageDims.width;
+    const scaleY = viewportDims.height / imageDims.height;
+    const scale = Math.min(scaleX, scaleY);
+
+    const offsetX = (viewportDims.width - imageDims.width * scale) / 2;
+    const offsetY = (viewportDims.height - imageDims.height * scale) / 2;
+
+    return {
+        x: imageX * scale + offsetX,
+        y: imageY * scale + offsetY,
+    };
+}
+
+/**
+ * Convert viewport coordinates back to image pixel coordinates.
+ */
+export function viewportToImageCoordinates(
+    viewportX: number,
+    viewportY: number,
+    imageDims: ImageDimensions,
+    viewportDims: ImageDimensions
+): { x: number; y: number } {
+    const scaleX = viewportDims.width / imageDims.width;
+    const scaleY = viewportDims.height / imageDims.height;
+    const scale = Math.min(scaleX, scaleY);
+
+    const offsetX = (viewportDims.width - imageDims.width * scale) / 2;
+    const offsetY = (viewportDims.height - imageDims.height * scale) / 2;
+
+    return {
+        x: (viewportX - offsetX) / scale,
+        y: (viewportY - offsetY) / scale,
+    };
+}
+
+/**
+ * Convert percentage-based coordinates (0-1 range) to pixel coordinates.
+ * Useful when an upstream vision model returns normalized bounding boxes.
+ */
+export function percentToPixelCoordinates(
+    percentX: number,
+    percentY: number,
+    imageDims: ImageDimensions
+): { x: number; y: number } {
+    return {
+        x: percentX * imageDims.width,
+        y: percentY * imageDims.height,
+    };
+}
+
+/**
+ * Convert a percentage-based bounding box to pixel bbox.
+ */
+export function percentBboxToPixelBbox(
+    bbox: [number, number, number, number],
+    imageDims: ImageDimensions
+): [number, number, number, number] {
+    return [
+        bbox[0] * imageDims.width,
+        bbox[1] * imageDims.height,
+        bbox[2] * imageDims.width,
+        bbox[3] * imageDims.height,
+    ];
+}

package/lib/dicomImageExtractor.ts

@@ -0,0 +1,103 @@
+import * as dicomParser from 'dicom-parser';
+
+export async function extractUncompressedDicomFrame(file: File): Promise<string | null> {
+    try {
+        const arrayBuffer = await file.arrayBuffer();
+        const byteArray = new Uint8Array(arrayBuffer);
+        const dataSet = dicomParser.parseDicom(byteArray);
+        
+        const transferSyntax = dataSet.string('x00020010')?.trim() || '';
+        
+        // Uncompressed syntaxes (Implicit VR Little Endian, Explicit VR Little/Big Endian)
+        const uncompressedSyntaxes = ['1.2.840.10008.1.2', '1.2.840.10008.1.2.1', '1.2.840.10008.1.2.2'];
+        
+        if (!uncompressedSyntaxes.includes(transferSyntax)) {
+            // Not supported by this simple extractor. Will fall back to Cornerstone Viewer.
+            return null;
+        }
+
+        const rows = dataSet.uint16('x00280010');
+        const columns = dataSet.uint16('x00280011');
+        const bitsAllocated = dataSet.uint16('x00280100');
+        const pixelRepresentation = dataSet.uint16('x00280103') || 0; // 0=unsigned, 1=signed
+        
+        let windowCenter = dataSet.string('x00281050') ? parseFloat(dataSet.string('x00281050')!) : undefined;
+        let windowWidth = dataSet.string('x00281051') ? parseFloat(dataSet.string('x00281051')!) : undefined;
+
+        if (!rows || !columns || !bitsAllocated) return null;
+
+        const pixelDataElement = dataSet.elements.x7fe00010;
+        if (!pixelDataElement) return null;
+
+        // Extract raw bytes
+        const pixelBytes = byteArray.slice(pixelDataElement.dataOffset, pixelDataElement.dataOffset + pixelDataElement.length);
+        
+        let minPixel = Infinity;
+        let maxPixel = -Infinity;
+        const pixelValues = new Float32Array(rows * columns);
+
+        if (bitsAllocated === 16) {
+            const dataView = new DataView(pixelBytes.buffer, pixelBytes.byteOffset, pixelBytes.byteLength);
+            for (let i = 0; i < rows * columns; i++) {
+                let val = pixelRepresentation === 1 ? dataView.getInt16(i * 2, true) : dataView.getUint16(i * 2, true);
+                pixelValues[i] = val;
+                if (val < minPixel) minPixel = val;
+                if (val > maxPixel) maxPixel = val;
+            }
+        } else if (bitsAllocated === 8) {
+            for (let i = 0; i < rows * columns; i++) {
+                let val = pixelBytes[i];
+                pixelValues[i] = val;
+                if (val < minPixel) minPixel = val;
+                if (val > maxPixel) maxPixel = val;
+            }
+        } else {
+            return null; // Unsupported bit depth
+        }
+
+        // Apply Window/Level if provided, otherwise auto-window to min/max
+        if (windowCenter === undefined || windowWidth === undefined) {
+            windowCenter = (maxPixel + minPixel) / 2;
+            windowWidth = maxPixel - minPixel;
+        }
+
+        const lowerBound = windowCenter - 0.5 - (windowWidth - 1) / 2;
+        const upperBound = windowCenter - 0.5 + (windowWidth - 1) / 2;
+
+        const canvas = document.createElement('canvas');
+        canvas.width = columns;
+        canvas.height = rows;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) return null;
+
+        const imageData = ctx.createImageData(columns, rows);
+        const data = imageData.data;
+
+        for (let i = 0; i < pixelValues.length; i++) {
+            let val = pixelValues[i];
+            
+            // Apply VOI LUT
+            let luminance = 0;
+            if (val <= lowerBound) {
+                luminance = 0;
+            } else if (val >= upperBound) {
+                luminance = 255;
+            } else {
+                luminance = Math.floor(((val - windowCenter - 0.5) / (windowWidth - 1) + 0.5) * 255);
+            }
+
+            const offset = i * 4;
+            data[offset]     = luminance; // R
+            data[offset + 1] = luminance; // G
+            data[offset + 2] = luminance; // B
+            data[offset + 3] = 255;       // A
+        }
+
+        ctx.putImageData(imageData, 0, 0);
+        return canvas.toDataURL('image/jpeg', 0.92);
+
+    } catch (e) {
+        console.error("Simple extractor failed:", e);
+        return null;
+    }
+}

package/lib/dicomMetadataParser.ts

@@ -0,0 +1,111 @@
+import * as dicomParser from 'dicom-parser';
+import { DicomMetadata, DicomExtractionResult } from '@/types';
+
+// Helper to safely extract and trim string values
+function getString(dataSet: dicomParser.DataSet, tag: string): string | undefined {
+    const val = dataSet.string(tag);
+    if (val) return val.trim();
+    return undefined;
+}
+
+// Helper to safely extract numeric values
+function getNumber(dataSet: dicomParser.DataSet, tag: string): number | undefined {
+    // Try uint16 first, which is common for rows/cols/bits
+    try {
+        const val = dataSet.uint16(tag);
+        if (val !== undefined && !isNaN(val)) return val;
+        
+        const val32 = dataSet.uint32(tag);
+        if (val32 !== undefined && !isNaN(val32)) return val32;
+    } catch (e) {
+        // Tag might missing or wrong type
+    }
+    return undefined;
+}
+
+/**
+ * Formats the patient name from DICOM but does not filter out technical names.
+ */
+function formatPatientName(raw: string | undefined): string | undefined {
+    if (!raw) return undefined;
+
+    // Replace DICOM ^ separator with spaces
+    let name = raw.replace(/\^/g, ' ').trim();
+    if (name.length === 0) return undefined;
+
+    // Proper case formatting: "DOE^JOHN" or "doe john" -> "Doe John"
+    // (Only applies to words separated by spaces. Things like Ultra_fast_Brain will become Ultra_fast_brain)
+    name = name
+        .split(/\s+/)
+        .map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join(' ');
+
+    return name;
+}
+
+/**
+ * Returns the patient ID as-is, trimmed.
+ */
+function formatPatientId(raw: string | undefined): string | undefined {
+    if (!raw) return undefined;
+    const id = raw.trim();
+    if (id.length === 0) return undefined;
+    return id;
+}
+
+export async function parseDicomMetadata(file: File): Promise<DicomExtractionResult> {
+    try {
+        const arrayBuffer = await file.arrayBuffer();
+        const byteArray = new Uint8Array(arrayBuffer);
+        
+        // Parse the DICOM file
+        // This throws if the file is not a valid DICOM file
+        const dataSet = dicomParser.parseDicom(byteArray);
+        
+        // Extract raw tags
+        const rawPatientName = getString(dataSet, 'x00100010');
+        const rawPatientId = getString(dataSet, 'x00100020');
+
+        // Format names but allow all values
+        const cleanName = formatPatientName(rawPatientName);
+        const cleanId = formatPatientId(rawPatientId);
+
+        const metadata: DicomMetadata = {
+            patientName: cleanName,
+            patientId: cleanId,
+            patientBirthDate: getString(dataSet, 'x00100030'),
+            patientAge: getString(dataSet, 'x00101010'),
+            patientSex: getString(dataSet, 'x00100040'),
+            modality: getString(dataSet, 'x00080060'),
+            studyDate: getString(dataSet, 'x00080020'),
+            studyTime: getString(dataSet, 'x00080030'),
+            institutionName: getString(dataSet, 'x00080080'),
+            studyDescription: getString(dataSet, 'x00081030'),
+            seriesDescription: getString(dataSet, 'x0008103e'),
+            bodyPartExamined: getString(dataSet, 'x00180015'),
+            referringPhysicianName: getString(dataSet, 'x00080090'),
+            accessionNumber: getString(dataSet, 'x00080050'),
+            
+            // Note: transfer syntax is technically in the File Meta Information (x00020010)
+            // dicom-parser handles this if Part 10 file format.
+            transferSyntaxUID: getString(dataSet, 'x00020010'), 
+            
+            rows: getNumber(dataSet, 'x00280010'),
+            columns: getNumber(dataSet, 'x00280011'),
+            bitsAllocated: getNumber(dataSet, 'x00280100'),
+            numberOfFrames: getNumber(dataSet, 'x00280008') || 1, // Default to 1 if missing
+        };
+
+        return {
+            success: true,
+            metadata
+        };
+    } catch (error: any) {
+        console.error('DICOM parsing error:', error);
+        return {
+            success: false,
+            error: error?.message || 'File does not appear to be a valid DICOM file.'
+        };
+    }
+}
+

package/lib/fhir/client.ts

@@ -0,0 +1,25 @@
+import { Client } from "fhir-kit-client";
+
+export function createFhirClient(
+    baseUrl: string,
+    authType: string,
+    bearerToken?: string,
+    clientId?: string,
+    clientSecret?: string
+): Client {
+    const config: any = {
+        baseUrl: baseUrl
+    };
+
+    if (authType === "bearer" && bearerToken) {
+        config.bearerToken = bearerToken;
+    } else if (authType === "basic" && clientId && clientSecret) {
+        // According to fhir-kit-client, for basic auth we can pass custom headers
+        const encoded = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
+        config.customHeaders = {
+            Authorization: `Basic ${encoded}`
+        };
+    }
+
+    return new Client(config);
+}

package/lib/fhir/constants.ts

@@ -0,0 +1,21 @@
+export const FHIR_SYSTEMS = {
+    LOINC: "http://loinc.org",
+    HL7_V2_0074: "http://terminology.hl7.org/CodeSystem/v2-0074",
+    OMNIRAD_REPORT_ID: "urn:oid:1.3.6.1.4.1.59626.1.1", // Or another domain-specific URL
+    OMNIRAD_PATIENT_ID: "urn:oid:1.3.6.1.4.1.59626.1.2",
+    OMNIRAD_STUDY_UID: "urn:ietf:rfc:3986" // For DICOM UIDs like urn:oid:...
+};
+
+export const DEFAULT_DIAGNOSTIC_REPORT_CODE = {
+    system: FHIR_SYSTEMS.LOINC,
+    code: "18748-4",
+    display: "Diagnostic imaging study"
+};
+
+export const RADIOLOGY_CATEGORY = {
+    system: FHIR_SYSTEMS.HL7_V2_0074,
+    code: "RAD",
+    display: "Radiology"
+};
+
+export const FHIR_CONTENT_TYPE = "application/fhir+json";

package/lib/fhir/diagnostic-report.ts

@@ -0,0 +1,88 @@
+/// <reference types="fhir" />
+import { DiagnosticReportInput } from "../../types/fhir";
+import { FHIR_SYSTEMS, DEFAULT_DIAGNOSTIC_REPORT_CODE, RADIOLOGY_CATEGORY } from "./constants";
+import { sanitizeId } from "./helpers";
+
+export function toFhirDiagnosticReport({
+    report,
+    reportData,
+    patient,
+    pdfBase64,
+    serviceRequestId
+}: DiagnosticReportInput): fhir4.DiagnosticReport {
+    let status: fhir4.DiagnosticReport["status"] = "unknown";
+    const pStatus = report.reportStatus?.toLowerCase();
+    if (pStatus === "pending") status = "preliminary";
+    else if (pStatus === "approved" || pStatus === "final") status = "final";
+    else if (pStatus === "rejected") status = "cancelled";
+
+    const identifiers = [];
+    if (reportData?.report_header?.report_id) {
+        identifiers.push({
+            system: FHIR_SYSTEMS.OMNIRAD_REPORT_ID,
+            value: reportData.report_header.report_id
+        });
+    } else {
+        identifiers.push({
+            system: FHIR_SYSTEMS.OMNIRAD_REPORT_ID,
+            value: report.id
+        });
+    }
+
+    const effectiveDateTime = reportData?.report_header?.report_date || report.createdAt;
+    let issued = reportData?.report_footer?.approved_at || report.createdAt;
+
+    const conclusion = reportData?.impression ? reportData.impression.join("\n") : undefined;
+
+    const resource: fhir4.DiagnosticReport = {
+        resourceType: "DiagnosticReport",
+        id: sanitizeId(report.id),
+        identifier: identifiers,
+        status,
+        category: [
+            {
+                coding: [RADIOLOGY_CATEGORY],
+                text: RADIOLOGY_CATEGORY.display
+            }
+        ],
+        code: {
+            coding: [DEFAULT_DIAGNOSTIC_REPORT_CODE],
+            text: reportData?.study?.examination || `${report.modality || "Imaging"} report`
+        },
+        subject: {
+            reference: patient ? `Patient/${sanitizeId(patient.id)}` : `Patient/${sanitizeId(report.patientId || "unknown")}`,
+            display: patient?.patientName || report.patientName || undefined
+        },
+        effectiveDateTime: effectiveDateTime ? new Date(effectiveDateTime).toISOString() : undefined,
+        issued: issued ? new Date(issued).toISOString() : undefined,
+        conclusion
+    };
+
+    if (report.pacsStudyUid || report.id) {
+        resource.imagingStudy = [
+            {
+                reference: `ImagingStudy/${sanitizeId(report.pacsStudyUid || report.id)}`
+            }
+        ];
+    }
+
+    if (serviceRequestId) {
+        resource.basedOn = [
+            {
+                reference: `ServiceRequest/${sanitizeId(serviceRequestId)}`
+            }
+        ];
+    }
+
+    if (pdfBase64) {
+        resource.presentedForm = [
+            {
+                contentType: "application/pdf",
+                title: "OmniRad Radiology Report",
+                data: pdfBase64
+            }
+        ];
+    }
+
+    return resource;
+}