@niivue/nv-ohif 0.1.0-rc.0

package/dist/types/NiivueViewport.d.ts

@@ -0,0 +1,14 @@
+import type { OhifViewportProps } from './ohif-types';
+/**
+ * The NiiVue viewport React component OHIF hangs a display set in. It routes each
+ * display set to the right NiiVue load path (see {@link classifyDisplaySet}):
+ *   - a NIfTI/volume URL loads directly,
+ *   - a volumetric DICOM series is fetched + converted with dcm2niix, then loaded,
+ *   - whole-slide (SM) series render with NVSlide (JPEG / TILED_FULL; JPEG 2000 and
+ *     TILED_SPARSE are declined with a note),
+ *   - anything else shows an explanatory note.
+ *
+ * NiiVue's core is framework-agnostic, so this owns a plain <canvas> + a `NiiVue`
+ * instance directly (React 18) rather than depending on `@niivue/nvreact` (React 19).
+ */
+export declare function NiivueViewport(props: OhifViewportProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/classifyDisplaySet.d.ts

@@ -0,0 +1,7 @@
+import type { OhifDisplaySet } from './ohif-types';
+export type NiivueLoadKind = 'nifti' | 'dicom-volume' | 'wsi' | 'unsupported';
+/**
+ * Decide which NiiVue load path a display set takes. Pure; drives the viewport's
+ * branching and is unit-tested against representative display-set shapes.
+ */
+export declare function classifyDisplaySet(ds: OhifDisplaySet): NiivueLoadKind;

package/dist/types/commands.d.ts

@@ -0,0 +1,202 @@
+import { type AnnotationScreenShape, type VectorAnnotation } from '@niivue/niivue';
+import { type NiivueViewportEntry } from './niivueRegistry';
+import type { OhifDisplaySet, OhifExtensionParams } from './ohif-types';
+export declare const NIIVUE_SLICE_TYPES: Record<string, number>;
+export declare const NIIVUE_CLIP_PLANES: Record<string, [number, number, number]>;
+export declare const OVERLAY_COLORMAP = "warm";
+export declare const OVERLAY_OPACITY = 0.5;
+export declare const NIIVUE_COLORMAPS: Array<{
+    name: string;
+    label: string;
+}>;
+export interface WindowLevelPreset {
+    id?: string;
+    description?: string;
+    window: string | number;
+    level: string | number;
+}
+export declare const FALLBACK_WL_PRESETS: Record<string, WindowLevelPreset[]>;
+export declare function findOverlayCandidate(entry: Pick<NiivueViewportEntry, 'displaySets' | 'overlayUIDs'>, activeDisplaySets: ReadonlyArray<OhifDisplaySet>): OhifDisplaySet | undefined;
+export declare function flashStatus(entry: NiivueViewportEntry, message: string, ms?: number): void;
+export declare function baseModality(entry: Pick<NiivueViewportEntry, 'displaySets'>): string | undefined;
+/** OHIF's window/level presets (customization first, built-in fallback). */
+export declare function windowLevelPresets(servicesManager: OhifExtensionParams['servicesManager']): Record<string, WindowLevelPreset[]>;
+/**
+ * Resolve a preset for the base modality, by id then index (OHIF's own
+ * fallback order). Returns the [calMin, calMax] window it maps to.
+ */
+export declare function resolveWindowLevel(presets: Record<string, WindowLevelPreset[]>, modality: string | undefined, presetId: string | undefined, presetIndex: number | undefined): [number, number] | undefined;
+interface NiivueLike {
+    volumes: ReadonlyArray<{
+        calMin?: number;
+        calMax?: number;
+    }>;
+}
+/** Read the base volume's window/level ({ window: width, level: center }). */
+export declare function readBaseWindowLevel(nv: NiivueLike): {
+    window: number;
+    level: number;
+} | undefined;
+/**
+ * Assign the default viewport label before reflecting a new annotation to OHIF.
+ * The label is tool-aware ('Arrow #N' / 'Bidirectional #N' / 'ROI #N') and the
+ * number is one past the highest existing "<prefix> #N", so a label is never
+ * reused after a deletion. Returns true if it assigned text (so the caller can
+ * redraw).
+ *
+ * A measured line (Length) gets NO default text: its ruler already draws the mm
+ * reading, and a free-text label would cross / obscure the ruler.
+ */
+export declare function applyDefaultAnnotationText(annotation: VectorAnnotation, annotations: readonly VectorAnnotation[]): boolean;
+export declare function reflectNiivueAnnotation(viewportId: string, servicesManager: OhifExtensionParams['servicesManager'], annotation: VectorAnnotation, existingUid?: string): boolean;
+/**
+ * Push an OHIF measurement's label (edited in the panel) back onto the NiiVue
+ * annotation it reflects, so the free text shows on the viewport. No-op if the
+ * uid is not one of ours.
+ */
+export declare function applyOhifLabelToAnnotation(measurementUid: string, label: string): void;
+/** Navigate the owning NiiVue viewport to a reflected OHIF measurement. */
+export declare function jumpToNiivueMeasurement(measurementUid: string, servicesManager: OhifExtensionParams['servicesManager']): void;
+/**
+ * Delete the NiiVue annotation backing an OHIF measurement removed from the
+ * panel, then re-render. No-op when the uid is not one of ours, or when WE are
+ * the ones removing it (removeNiivueAnnotation -> measurementService.remove
+ * echoes MEASUREMENT_REMOVED synchronously; removingUids marks those so we do
+ * not double-remove).
+ */
+export declare function applyOhifRemoveToAnnotation(measurementUid: string): void;
+/**
+ * The overlay shape provider: `nv.annotationScreenShapes` minus any annotation
+ * hidden via its OHIF measurement's visibility toggle. Core still projects every
+ * annotation each frame; we drop the hidden ones just before the overlay draws.
+ */
+export declare function visibleAnnotationScreenShapes(viewportId: string, shapes: readonly AnnotationScreenShape[]): readonly AnnotationScreenShape[];
+/**
+ * Show or hide the NiiVue annotation backing an OHIF measurement whose panel
+ * visibility (eye icon) was toggled, then re-render. No-op when the uid is not
+ * one of ours or the state already matches.
+ */
+export declare function applyOhifVisibilityToAnnotation(measurementUid: string, isVisible: boolean): void;
+/**
+ * Subscribe once per MeasurementService to OHIF events handled by NiiVue:
+ * label edits are pushed to annotation text, and panel jumps navigate to the
+ * owning annotation. The historical function name remains part of the API.
+ */
+export declare function subscribeOhifLabelSync(servicesManager: OhifExtensionParams['servicesManager']): (() => void) | undefined;
+/** Remove one reflected annotation's OHIF panel row (annotationRemoved). */
+/**
+ * Returns true when the row is gone (removed, or there was nothing / no uid to
+ * remove, or the host has no remove so recovery is impossible). Returns FALSE only
+ * when an available remove() THREW: the bookkeeping is preserved so the caller can
+ * retry on a later reconcile instead of orphaning the OHIF row (round-5 F1).
+ */
+export declare function removeNiivueAnnotation(viewportId: string, servicesManager: OhifExtensionParams['servicesManager'], annotationId: string): boolean;
+/** Remove every reflected row for a viewport (annotation clear / series swap). */
+export declare function clearNiivueAnnotations(viewportId: string, servicesManager: OhifExtensionParams['servicesManager']): void;
+export declare function reconcileNiivueAnnotations(viewportId: string, servicesManager: OhifExtensionParams['servicesManager']): void;
+export declare function syncNiivueWindowLevelToOhif(viewportId: string, servicesManager: OhifExtensionParams['servicesManager'], commandsManager: OhifExtensionParams['commandsManager']): {
+    window: number;
+    level: number;
+} | undefined;
+/**
+ * getCommandsModule: OHIF commands operating on the active NiiVue viewport.
+ * Toolbar buttons (see toolbar.ts) reference these by name; they are also
+ * runnable from any OHIF surface via `commandsManager.runCommand(...)`.
+ */
+export declare function getNiivueCommandsModule({ servicesManager, commandsManager, }: OhifExtensionParams): {
+    actions: {
+        /** Switch the view: axial / coronal / sagittal / multiplanar / render. */
+        niivueSetSliceType: ({ sliceType }?: {
+            sliceType?: string;
+        }) => void;
+        /**
+         * Activate the ruler (length) tool. Routes through OHIF's `setToolActiveToolbar`
+         * so OHIF's active-tool state and NiiVue agree: the tool bridge in
+         * NiivueViewport maps the active `Length` tool onto NiiVue's `measureLine`
+         * annotation (the same system as the ROI tools). Setting the annotation tool
+         * directly would be reset by that bridge the next time OHIF's active tool
+         * (e.g. WindowLevel) re-applies. On release the completed line annotation is
+         * reflected into OHIF's measurement panel (see the annotationAdded
+         * subscription in NiivueViewport). Falls back to enabling NiiVue's measureLine
+         * annotation directly when no commandsManager is available.
+         */
+        niivueSetMeasurementMode: () => void;
+        /** Reset camera, pan, zoom, and crosshair to their defaults. */
+        niivueResetView: () => void;
+        /** Download the visible NiiVue volume or NVSlide canvas as a PNG. */
+        niivueSaveBitmap: () => Promise<void>;
+        /** Set (or clear, plane: 'none') the 3D render clip plane. */
+        niivueSetClipPlane: ({ plane }?: {
+            plane?: string;
+        }) => void;
+        /**
+         * Toggle a colormapped overlay: with overlays loaded, remove them;
+         * otherwise load the study's next loadable series on top of the base
+         * (fetch + dcm2niix conversion for DICOM).
+         */
+        niivueToggleOverlay: () => Promise<void>;
+        /**
+         * Apply a window/level (width + center) to the base volume as NiiVue
+         * calMin/calMax. Bridges OHIF's W/L model onto NiiVue's calibration range.
+         */
+        niivueSetWindowLevel: ({ window, level, }?: {
+            window?: number;
+            level?: number;
+        }) => void;
+        /**
+         * Apply one of OHIF's modality window/level presets (resolved from the
+         * `cornerstone.windowLevelPresets` customization, keyed by the base series'
+         * modality) to the base volume.
+         */
+        niivueSetWindowLevelPreset: ({ presetId, presetIndex, }?: {
+            presetId?: string;
+            presetIndex?: number;
+        }) => void;
+        /** Recompute the base volume's robust (2-98%) auto window. */
+        niivueAutoWindowLevel: () => void;
+        /** Set the base volume's colormap (e.g. gray / hot / viridis). */
+        niivueSetColormap: ({ colormap }?: {
+            colormap?: string;
+        }) => void;
+        /** Toggle the colormap legend (colorbar) on the viewport. */
+        niivueToggleColorbar: () => void;
+        /** Toggle nearest-neighbor vs smooth (linear) volume interpolation. */
+        niivueToggleInterpolation: () => void;
+        /**
+         * Toggle the crosshair on/off. Overrides OHIF's cornerstone Crosshairs
+         * button on a NiiVue viewport. `crosshairWidth = 0` hides the 2D crosshair
+         * (its width is the marker radius); `is3DCrosshairVisible` follows for the
+         * 3D render tile. Neither setter redraws on its own, so drawScene() here.
+         */
+        niivueToggleCrosshair: () => void;
+    };
+    definitions: {
+        niivueSetSliceType: ({ sliceType }?: {
+            sliceType?: string;
+        }) => void;
+        niivueSetMeasurementMode: () => void;
+        niivueResetView: () => void;
+        niivueSaveBitmap: () => Promise<void>;
+        niivueSetClipPlane: ({ plane }?: {
+            plane?: string;
+        }) => void;
+        niivueToggleOverlay: () => Promise<void>;
+        niivueSetWindowLevel: ({ window, level, }?: {
+            window?: number;
+            level?: number;
+        }) => void;
+        niivueSetWindowLevelPreset: ({ presetId, presetIndex, }?: {
+            presetId?: string;
+            presetIndex?: number;
+        }) => void;
+        niivueAutoWindowLevel: () => void;
+        niivueSetColormap: ({ colormap }?: {
+            colormap?: string;
+        }) => void;
+        niivueToggleColorbar: () => void;
+        niivueToggleInterpolation: () => void;
+        niivueToggleCrosshair: () => void;
+    };
+    defaultContext: string;
+};
+export {};

package/dist/types/dicomToNiivue.d.ts

@@ -0,0 +1,21 @@
+import type { OhifDisplaySet } from './ohif-types';
+export interface DicomConvertOptions {
+    /** Extra request headers (e.g. an Authorization header from OHIF's auth service). */
+    headers?: Record<string, string>;
+    /** Called as instances are fetched, then once more when conversion starts. */
+    onProgress?: (phase: 'fetching' | 'converting', loaded: number, total: number) => void;
+    signal?: AbortSignal;
+    /** Max concurrent instance fetches. Default 6. */
+    concurrency?: number;
+}
+/**
+ * Fetch every instance of a DICOMweb display set as a reconstructed DICOM P10 File.
+ * Fetches run with bounded concurrency; progress is reported per instance.
+ */
+export declare function fetchDicomInstanceFiles(ds: OhifDisplaySet, options?: DicomConvertOptions): Promise<File[]>;
+/**
+ * Convert a DICOMweb display set to a single NIfTI File via dcm2niix. Returns the
+ * primary NIfTI output (largest `.nii`/`.nii.gz`), or null if nothing converted.
+ * dcm2niix is dynamically imported so its WASM only loads on a DICOM series.
+ */
+export declare function convertDisplaySetToNifti(ds: OhifDisplaySet, options?: DicomConvertOptions): Promise<File | null>;

package/dist/types/dicomWadoRs.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Turn a cornerstone `wadors:`/`dicomweb:` frame imageId into the WADO-RS
+ * retrieve-instance URL. Returns null if the id is not an http(s) DICOMweb
+ * instance reference.
+ */
+export declare function retrieveInstanceUrlFromImageId(imageId: string): string | null;
+/** Extract the boundary token from a multipart/related Content-Type header. */
+export declare function multipartBoundary(contentType: string): string | null;
+/**
+ * Recover the boundary from a multipart body's opening delimiter line
+ * (`--<boundary>\r\n`). The browser `fetch` API commonly exposes the response
+ * Content-Type as bare `multipart/related` with the `boundary` parameter
+ * stripped, so we fall back to reading it off the body.
+ */
+export declare function boundaryFromBody(bytes: Uint8Array): string | null;
+/**
+ * Split a multipart/related body into its part bodies (raw bytes, headers
+ * stripped). If the response is actually single-part `application/dicom`
+ * (some servers ignore the multipart Accept), the whole body is returned as
+ * one part.
+ */
+export declare function parseMultipartRelated(body: ArrayBuffer | Uint8Array, contentType: string): Uint8Array[];

package/dist/types/displaySetToNiivue.d.ts

@@ -0,0 +1,7 @@
+import type { ImageFromUrlOptions } from '@niivue/niivue';
+import type { OhifDisplaySet } from './ohif-types';
+/**
+ * Extract a NiiVue load spec from an OHIF display set, or null if this display set is
+ * not a Phase-1 (NIfTI/volume-URL) case.
+ */
+export declare function displaySetToNiivue(displaySet: OhifDisplaySet): ImageFromUrlOptions | null;

package/dist/types/getNiivueViewportModule.d.ts

@@ -0,0 +1,4 @@
+import type { OhifViewportModuleEntry } from './ohif-types';
+export declare const NIIVUE_VIEWPORT_NAME = "niivue";
+/** getViewportModule: register the NiiVue viewport component with OHIF. */
+export declare function getNiivueViewportModule(): OhifViewportModuleEntry[];

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+import { getNiivueCommandsModule, NIIVUE_CLIP_PLANES, NIIVUE_COLORMAPS, NIIVUE_SLICE_TYPES } from './commands';
+import { displaySetToNiivue } from './displaySetToNiivue';
+import { getNiivueViewportModule, NIIVUE_VIEWPORT_NAME } from './getNiivueViewportModule';
+import { NiivueViewport } from './NiivueViewport';
+import type { OhifDisplaySet, OhifExtension, OhifSopClassHandlerEntry, OhifToolbarButton, OhifViewportModuleEntry, OhifViewportProps } from './ohif-types';
+import { getNiivueSopClassHandlerModule, NIIVUE_SOP_CLASS_HANDLER_NAME } from './sopClassHandler';
+import { getNiivueToolbarModule, NIIVUE_CLIP_SECTION, NIIVUE_COLORBAR_BUTTON, NIIVUE_COLORMAP_SECTION, NIIVUE_INTERPOLATION_BUTTON, NIIVUE_OVERLAY_BUTTON, NIIVUE_RESET_BUTTON, NIIVUE_TOOLBAR_BUTTONS, NIIVUE_TOOLBAR_SECTIONS, NIIVUE_VIEWS_SECTION, NIIVUE_WL_SECTION, niivueToolbarCustomization } from './toolbar';
+export declare const NIIVUE_OHIF_EXTENSION_ID = "@niivue/nv-ohif";
+declare const niivueOhifExtension: OhifExtension;
+export default niivueOhifExtension;
+export type { OhifDisplaySet, OhifExtension, OhifSopClassHandlerEntry, OhifToolbarButton, OhifViewportModuleEntry, OhifViewportProps, };
+export { displaySetToNiivue, getNiivueCommandsModule, getNiivueSopClassHandlerModule, getNiivueToolbarModule, getNiivueViewportModule, NIIVUE_CLIP_PLANES, NIIVUE_CLIP_SECTION, NIIVUE_COLORBAR_BUTTON, NIIVUE_COLORMAP_SECTION, NIIVUE_COLORMAPS, NIIVUE_INTERPOLATION_BUTTON, NIIVUE_OVERLAY_BUTTON, NIIVUE_RESET_BUTTON, NIIVUE_SLICE_TYPES, NIIVUE_SOP_CLASS_HANDLER_NAME, NIIVUE_TOOLBAR_BUTTONS, NIIVUE_TOOLBAR_SECTIONS, NIIVUE_VIEWPORT_NAME, NIIVUE_VIEWS_SECTION, NIIVUE_WL_SECTION, NiivueViewport, niivueToolbarCustomization, };

package/dist/types/niivueRegistry.d.ts

@@ -0,0 +1,60 @@
+import type NiiVue from '@niivue/niivue';
+import type { OhifDisplaySet, OhifServicesManager } from './ohif-types';
+import type { WsiSlideView } from './wsiSlideView';
+/**
+ * Per-viewport state shared between the React viewport and the OHIF
+ * commands / toolbar evaluators (which live outside React). The viewport
+ * registers on attach and keeps `displaySets` / `setStatus` current; commands
+ * mutate the overlay/clip state they own.
+ */
+export interface NiivueViewportEntry {
+    viewportId: string;
+    nv: NiiVue;
+    /** Display sets currently hung in the viewport (the base load). */
+    displaySets: ReadonlyArray<OhifDisplaySet>;
+    /** displaySetInstanceUIDs loaded as overlays (niivueToggleOverlay). */
+    overlayUIDs: string[];
+    /** Guard against concurrent overlay loads. */
+    overlayLoading: boolean;
+    /** Current clip plane preset name ('none' when off). See commands.ts. */
+    clipPlane: string;
+    /**
+     * Last known base-volume window/level ({ window: width, level: center }).
+     * Tracks both directions: forward commands set it; the viewport's
+     * pointer-release observer updates it from a manual contrast drag and pushes
+     * the change to OHIF (see commands.ts syncNiivueWindowLevelToOhif).
+     */
+    windowLevel?: {
+        window: number;
+        level: number;
+    };
+    /** Visible NVSlide view when this viewport is showing a whole-slide series. */
+    slideView?: WsiSlideView;
+    /** Viewport-provided sink so commands can surface progress text (null = clear). */
+    setStatus?: (message: string | null) => void;
+}
+export declare function registerNiivue(viewportId: string, nv: NiiVue): void;
+export declare function unregisterNiivue(viewportId: string): void;
+/** Merge viewport-owned fields into an entry (no-op when not registered). */
+export declare function updateNiivueViewport(viewportId: string, patch: Partial<Pick<NiivueViewportEntry, 'displaySets' | 'setStatus' | 'slideView' | 'windowLevel' | 'overlayUIDs' | 'overlayLoading'>>): void;
+export declare function getNiivueEntry(viewportId: string | undefined): NiivueViewportEntry | undefined;
+export declare function ohifServices(servicesManager: OhifServicesManager | undefined): Record<string, unknown> | undefined;
+/**
+ * The entry for a viewport id, falling back to the sole registered entry
+ * (covers layouts where a non-NiiVue viewport holds focus next to a single
+ * NiiVue viewport).
+ */
+export declare function getNiivueEntryForViewport(viewportId: string | undefined): NiivueViewportEntry | undefined;
+/** The instance for a viewport id (same fallback as the entry lookup). */
+export declare function getNiivueForViewport(viewportId: string | undefined): NiiVue | undefined;
+/** The entry a toolbar command should act on: the active viewport's. */
+export declare function getActiveNiivueEntry(servicesManager: OhifServicesManager | undefined): NiivueViewportEntry | undefined;
+/** The NiiVue instance a toolbar command should act on: the active viewport's. */
+export declare function getActiveNiivue(servicesManager: OhifServicesManager | undefined): NiiVue | undefined;
+export declare function refreshToolbar(servicesManager: OhifServicesManager | undefined, viewportId: string): void;
+interface CommandsManagerLike {
+    runCommand?: (name: string, options?: Record<string, unknown>) => unknown;
+}
+export declare function ohifCommandsManager(commandsManager: CommandsManagerLike | undefined): CommandsManagerLike | undefined;
+export declare function authHeaders(servicesManager: OhifServicesManager | undefined): Record<string, string>;
+export {};

package/dist/types/ohif-types.d.ts

@@ -0,0 +1,97 @@
+export interface OhifDisplaySet {
+    displaySetInstanceUID?: string;
+    SeriesInstanceUID?: string;
+    SeriesDescription?: string;
+    Modality?: string;
+    url?: string;
+    instances?: ReadonlyArray<Record<string, unknown>>;
+    imageIds?: ReadonlyArray<string>;
+    getThumbnailSrc?: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<string | null>;
+    [key: string]: unknown;
+}
+export interface OhifServicesManager {
+    services: Record<string, unknown>;
+}
+export interface OhifExtensionManager {
+    getModuleEntry: (id: string) => unknown;
+}
+export interface OhifCommandsManager {
+    runCommand: (name: string, options?: Record<string, unknown>) => unknown;
+}
+export interface OhifViewportProps {
+    displaySets: ReadonlyArray<OhifDisplaySet>;
+    viewportId: string;
+    viewportOptions?: {
+        orientation?: string;
+        viewportType?: string;
+    };
+    servicesManager?: OhifServicesManager;
+    extensionManager?: OhifExtensionManager;
+    commandsManager?: OhifCommandsManager;
+    children?: unknown;
+}
+export interface OhifViewportModuleEntry {
+    name: string;
+    component: (props: OhifViewportProps) => unknown;
+}
+export interface OhifSopClassHandlerEntry {
+    name: string;
+    sopClassUids: string[];
+    getDisplaySetsFromSeries: (instances: ReadonlyArray<Record<string, unknown>>) => ReadonlyArray<OhifDisplaySet>;
+}
+export interface OhifExtensionParams {
+    servicesManager?: OhifServicesManager;
+    extensionManager?: OhifExtensionManager;
+    commandsManager?: OhifCommandsManager;
+}
+export interface OhifToolbarButtonCommand {
+    commandName: string;
+    commandOptions?: Record<string, unknown>;
+}
+export interface OhifToolbarButton {
+    id: string;
+    uiType: string;
+    props: {
+        icon?: string;
+        label?: string;
+        tooltip?: string;
+        buttonSection?: boolean;
+        commands?: string | OhifToolbarButtonCommand | OhifToolbarButtonCommand[];
+        evaluate?: string | Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+export interface OhifToolbarEvaluation {
+    disabled?: boolean;
+    disabledText?: string;
+    isActive?: boolean;
+    className?: string;
+}
+export interface OhifToolbarModuleEntry {
+    name: string;
+    evaluate?: (state: {
+        viewportId?: string;
+        button?: OhifToolbarButton;
+        [key: string]: unknown;
+    }) => OhifToolbarEvaluation | undefined;
+}
+export interface OhifCommandsModule {
+    actions: Record<string, (...args: never[]) => unknown>;
+    definitions: Record<string, (...args: never[]) => unknown>;
+    defaultContext?: string;
+}
+export interface OhifCustomizationModuleEntry {
+    name: string;
+    value: Record<string, unknown>;
+}
+export interface OhifExtension {
+    id: string;
+    version?: string;
+    getViewportModule: (context: OhifExtensionParams) => OhifViewportModuleEntry[];
+    getSopClassHandlerModule?: (context: OhifExtensionParams) => OhifSopClassHandlerEntry[];
+    getCommandsModule?: (context: OhifExtensionParams) => OhifCommandsModule;
+    getToolbarModule?: (context: OhifExtensionParams) => OhifToolbarModuleEntry[];
+    getCustomizationModule?: (context: OhifExtensionParams) => OhifCustomizationModuleEntry[];
+}

package/dist/types/reconstructP10.d.ts

@@ -0,0 +1,35 @@
+interface JsonElement {
+    vr?: string;
+    Value?: unknown[];
+    BulkDataURI?: string;
+    InlineBinary?: string;
+}
+type JsonDataset = Record<string, JsonElement>;
+/** Frames pixel URL (absolute) from a cornerstone `wadors:` imageId. */
+export declare function framesUrlFromImageId(imageId: string): string | null;
+/** Series `/metadata` URL derived from an instance frames URL. */
+export declare function seriesMetadataUrlFromFramesUrl(framesUrl: string): string | null;
+/** SOP Instance UID embedded in a frames/instance URL. */
+export declare function sopFromFramesUrl(framesUrl: string): string | null;
+export declare function assemblePart10(DicomDict: DcmjsDicomDictCtor, metadata: JsonDataset, pixelBytes: Uint8Array, transferSyntaxUID?: string): ArrayBuffer;
+export interface DcmjsDicomDict {
+    meta: JsonDataset;
+    dict: JsonDataset;
+    write(options?: {
+        allowInvalidVRLength?: boolean;
+        fragmentMultiframe?: boolean;
+    }): ArrayBuffer;
+}
+export type DcmjsDicomDictCtor = new (meta: JsonDataset) => DcmjsDicomDict;
+export interface ReconstructOptions {
+    headers?: Record<string, string>;
+    onProgress?: (loaded: number, total: number) => void;
+    signal?: AbortSignal;
+    concurrency?: number;
+}
+/**
+ * Reconstruct P10 `File`s for every instance identified by `framesUrls`, using one
+ * shared series-metadata fetch plus a per-instance pixel fetch.
+ */
+export declare function reconstructInstanceFiles(framesUrls: string[], options?: ReconstructOptions): Promise<File[]>;
+export {};

package/dist/types/sopClassHandler.d.ts

@@ -0,0 +1,16 @@
+import type { OhifSopClassHandlerEntry } from './ohif-types';
+export declare const NIIVUE_SOP_CLASS_HANDLER_NAME = "niivue-wsi";
+export declare const NIIVUE_SOP_CLASS_HANDLER_ID = "@niivue/nv-ohif.sopClassHandlerModule.niivue-wsi";
+/**
+ * Build the NiiVue display set for a whole-slide (SM) series. Unlike OHIF's
+ * built-in `DicomMicroscopySopClassHandler`, this does NOT set
+ * `viewportType: WHOLE_SLIDE` — that field forces OHIF's own microscopy
+ * viewport and would override the mode's viewport routing. Omitting it lets the
+ * series land in the NiiVue viewport, which renders it with NVSlide.
+ *
+ * A mode that wants NiiVue to own whole-slide imaging registers this handler in
+ * its `sopClassHandlers` (and `displaySetsToDisplay`) INSTEAD of OHIF's
+ * `wsiSopClassHandler`; otherwise both handlers claim the SM SOP class and two
+ * competing display sets are produced.
+ */
+export declare function getNiivueSopClassHandlerModule(): OhifSopClassHandlerEntry[];

package/dist/types/toolBridge.d.ts

@@ -0,0 +1,16 @@
+import { type AnnotationTool } from '@niivue/niivue';
+/**
+ * Map an OHIF measurement tool to a NiiVue vector-annotation tool. Returns null
+ * for tools that are not annotation-backed (handled as drag modes instead).
+ * Setting `nv.annotationTool` to the result + `nv.annotationIsEnabled = true`
+ * makes a left-drag on a 2D slice draw the shape; the measure* variants also
+ * compute ROI stats (area/mean) and fire `annotationAdded` with them.
+ */
+export declare function ohifToolToAnnotationTool(tool: string | undefined): AnnotationTool | null;
+/**
+ * OHIF measurement tools NiiVue cannot back yet (no core primitive). Activating
+ * one shows a brief 'not supported' status and keeps safe crosshair navigation.
+ */
+export declare const UNSUPPORTED_MEASUREMENT_TOOLS: ReadonlySet<string>;
+/** Map an OHIF primary tool name to NiiVue's matching left-drag mode. */
+export declare function ohifToolToDragMode(tool: string | undefined): number;

package/dist/types/toolbar.d.ts

@@ -0,0 +1,38 @@
+import type { OhifToolbarButton, OhifToolbarModuleEntry } from './ohif-types';
+export declare const NIIVUE_VIEWS_SECTION = "NiivueViews";
+export declare const NIIVUE_CLIP_SECTION = "NiivueClip";
+export declare const NIIVUE_WL_SECTION = "NiivueWindowLevel";
+export declare const NIIVUE_COLORMAP_SECTION = "NiivueColormap";
+export declare const NIIVUE_RESET_BUTTON = "NiivueReset";
+export declare const NIIVUE_OVERLAY_BUTTON = "NiivueOverlay";
+export declare const NIIVUE_COLORBAR_BUTTON = "NiivueColorbar";
+export declare const NIIVUE_INTERPOLATION_BUTTON = "NiivueInterpolation";
+export declare const NIIVUE_RULER_BUTTON = "NiivueRuler";
+export declare const NIIVUE_CAPTURE_BUTTON = "NiivueCapture";
+export declare const NIIVUE_CROSSHAIR_BUTTON = "NiivueCrosshair";
+/**
+ * Toolbar button definitions: a "Views" dropdown (axial / coronal / sagittal /
+ * multiplanar / 3D render), a clip-plane dropdown, a window/level dropdown
+ * (auto + OHIF's modality presets), an overlay toggle, and a reset-view button,
+ * all running the commands in commands.ts. Registered with the toolbar service
+ * via the `niivue.toolbarButtons` customization (see below) or directly.
+ */
+export declare const NIIVUE_TOOLBAR_BUTTONS: OhifToolbarButton[];
+export declare const NIIVUE_TOOLBAR_SECTIONS: Record<string, string[]>;
+/**
+ * Customization pack (auto-registered at default scope via the extension's
+ * customizationModule). A mode composes it by reference:
+ *   toolbarButtons:  [..., { $reference: 'niivue.toolbarButtons' }]
+ *   toolbarSections: [..., { $reference: 'niivue.toolbarSections' },
+ *                     { primary: [...ids, 'NiivueViews', 'NiivueClip',
+ *                                 'NiivueOverlay', 'NiivueReset'] }]
+ */
+export declare const niivueToolbarCustomization: {
+    'niivue.toolbarButtons': OhifToolbarButton[];
+    'niivue.toolbarSections': Record<string, string[]>;
+};
+/**
+ * getToolbarModule: evaluators the buttons above reference. OHIF calls these
+ * against the active viewport to derive enabled/active state.
+ */
+export declare function getNiivueToolbarModule(): OhifToolbarModuleEntry[];

package/dist/types/volumeAnnotationOverlay.d.ts

@@ -0,0 +1,20 @@
+import type { AnnotationScreenShape, UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { type UIKitFont } from '@niivue/uikit';
+/**
+ * Draws NiiVue's vector annotations (ellipse / rectangle / circle / line / arrow
+ * ROIs) as @niivue/uikit shapes through the controller's overlay hook, so the
+ * ROIs render in UIKit instead of NiiVue's built-in on-canvas annotation drawing
+ * (which the caller disables with `nv.isAnnotationDrawn = false`). Reads the
+ * current screen projection from `nv.annotationScreenShapes` each frame so the
+ * shapes track pan / zoom / slice changes, rebuilding geometry only when the
+ * projection or dpr changes.
+ */
+export declare class VolumeAnnotationOverlay implements UIKitOverlayRenderer {
+    private readonly getShapes;
+    private readonly lines;
+    private readonly labels;
+    private lastSig;
+    constructor(font: UIKitFont, getShapes: () => readonly AnnotationScreenShape[]);
+    drawOverlay(frame: UIKitOverlayFrame): void;
+    destroy(): void;
+}

package/dist/types/wsiSlideView.d.ts

@@ -0,0 +1,30 @@
+import type { NVSlide } from '@niivue/niivue';
+export interface WsiSlideViewOptions {
+    /**
+     * Called when the measurement (ruler) changes: a formatted length string
+     * while measuring, or null when the ruler is cleared. Lets the host reflect
+     * the reading into its own status UI.
+     */
+    onMeasure?: (text: string | null) => void;
+}
+export interface WsiSlideView {
+    setTool(tool: string | undefined): void;
+    resetView(): void;
+    saveBitmap(filename?: string): Promise<void>;
+    dispose(): void;
+}
+/**
+ * Mount a standalone NVSlide deep-zoom view on a canvas: WebGL2 + SlideRenderer,
+ * an on-demand render loop (redraw only when tiles stream in or the user
+ * interacts), and pointer pan / wheel zoom. This is independent of NiiVue's
+ * volume renderer; the caller uses it for DICOM-WSI (SM) display sets.
+ *
+ * When the active tool is `Length`, clicks place a two-point ruler (a UIKit
+ * overlay drawn over the slide) that measures in real physical units recovered
+ * from the slide's DICOM pixel spacing. Endpoints are stored in slide
+ * coordinates so the ruler tracks the tissue through pan and zoom.
+ *
+ * Returns a handle whose `dispose()` tears down every listener, the RAF, and
+ * the GL resources.
+ */
+export declare function mountWsiSlideView(canvas: HTMLCanvasElement, slide: NVSlide, options?: WsiSlideViewOptions): WsiSlideView;