@niivue/nv-ohif 0.1.0-rc.0

package/dist/index.js

@@ -0,0 +1,2952 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/commands.ts
+import {
+  SLICE_TYPE,
+  slice2DToMM
+} from "@niivue/niivue";
+
+// src/dicomWadoRs.ts
+function retrieveInstanceUrlFromImageId(imageId) {
+  if (!imageId)
+    return null;
+  const raw = imageId.replace(/^(wadors|dicomweb|wadouri):/i, "");
+  if (!/^https?:\/\//i.test(raw))
+    return null;
+  const m = raw.match(/^(.*\/instances\/[^/?#]+)(?:[/?#].*)?$/i);
+  return m?.[1] ?? null;
+}
+function multipartBoundary(contentType) {
+  const m = /boundary=(?:"([^"]+)"|([^\s;]+))/i.exec(contentType);
+  const b = m?.[1] ?? m?.[2];
+  return b ? b.trim() : null;
+}
+function boundaryFromBody(bytes) {
+  if (bytes[0] !== 45 || bytes[1] !== 45)
+    return null;
+  let end = 2;
+  const limit = Math.min(bytes.length, 256);
+  while (end < limit && bytes[end] !== 13 && bytes[end] !== 10)
+    end++;
+  if (end <= 2)
+    return null;
+  return new TextDecoder("latin1").decode(bytes.subarray(2, end));
+}
+function indexOfSubarray(haystack, needle, from) {
+  outer:
+    for (let i = from;i + needle.length <= haystack.length; i++) {
+      for (let j = 0;j < needle.length; j++) {
+        if (haystack[i + j] !== needle[j])
+          continue outer;
+      }
+      return i;
+    }
+  return -1;
+}
+function parseMultipartRelated(body, contentType) {
+  const bytes = body instanceof Uint8Array ? body : new Uint8Array(body);
+  const boundary = multipartBoundary(contentType) ?? boundaryFromBody(bytes);
+  if (!boundary) {
+    return bytes.length > 0 ? [bytes] : [];
+  }
+  const encoder = new TextEncoder;
+  const delimiter = encoder.encode(`--${boundary}`);
+  const crlfcrlf = encoder.encode(`\r
+\r
+`);
+  const parts = [];
+  let cursor = indexOfSubarray(bytes, delimiter, 0);
+  while (cursor !== -1) {
+    const partStart = cursor + delimiter.length;
+    if (bytes[partStart] === 45 && bytes[partStart + 1] === 45)
+      break;
+    const headerEnd = indexOfSubarray(bytes, crlfcrlf, partStart);
+    const next = indexOfSubarray(bytes, delimiter, partStart);
+    if (headerEnd === -1 || next === -1)
+      break;
+    const bodyStart = headerEnd + crlfcrlf.length;
+    let bodyEnd = next;
+    if (bytes[bodyEnd - 2] === 13 && bytes[bodyEnd - 1] === 10)
+      bodyEnd -= 2;
+    if (bodyEnd > bodyStart)
+      parts.push(bytes.slice(bodyStart, bodyEnd));
+    cursor = next;
+  }
+  return parts;
+}
+
+// src/displaySetToNiivue.ts
+var NIIVUE_URL_EXTS = [
+  ".nii",
+  ".nii.gz",
+  ".nrrd",
+  ".nhdr",
+  ".mgh",
+  ".mgz",
+  ".mha",
+  ".mhd",
+  ".mif",
+  ".npy",
+  ".head",
+  ".brik"
+];
+function looksLikeNiivueVolumeUrl(url) {
+  const path = url.split(/[?#]/)[0]?.toLowerCase() ?? "";
+  return NIIVUE_URL_EXTS.some((ext) => path.endsWith(ext));
+}
+function firstString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function displaySetToNiivue(displaySet) {
+  const name = firstString(displaySet.SeriesDescription) ?? firstString(displaySet.SeriesInstanceUID) ?? "series";
+  const direct = firstString(displaySet.url);
+  if (direct && looksLikeNiivueVolumeUrl(direct)) {
+    return { url: direct, name };
+  }
+  const firstInstance = displaySet.instances?.[0];
+  const instanceUrl = firstInstance ? firstString(firstInstance.url) : undefined;
+  if (instanceUrl && looksLikeNiivueVolumeUrl(instanceUrl)) {
+    return { url: instanceUrl, name };
+  }
+  return null;
+}
+
+// src/classifyDisplaySet.ts
+var WSI_MODALITIES = new Set(["SM"]);
+function hasWadoInstances(ds) {
+  const instances = ds.instances;
+  if (!instances || instances.length === 0)
+    return false;
+  return instances.some((inst) => {
+    const id = inst.imageId;
+    return typeof id === "string" && retrieveInstanceUrlFromImageId(id) !== null;
+  });
+}
+function classifyDisplaySet(ds) {
+  if (displaySetToNiivue(ds) !== null)
+    return "nifti";
+  const modality = typeof ds.Modality === "string" ? ds.Modality : undefined;
+  if (modality && WSI_MODALITIES.has(modality) && hasWadoInstances(ds)) {
+    return "wsi";
+  }
+  if (hasWadoInstances(ds))
+    return "dicom-volume";
+  return "unsupported";
+}
+
+// src/reconstructP10.ts
+var EXPLICIT_VR_LITTLE_ENDIAN = "1.2.840.10008.1.2.1";
+var IMPLEMENTATION_CLASS_UID = "1.2.826.0.1.3680043.9.7433.1.1";
+function firstValue(el) {
+  return el?.Value?.[0];
+}
+function sanitizeDataset(source) {
+  const out = {};
+  for (const [tag, el] of Object.entries(source)) {
+    if (tag.startsWith("0002") || tag === "7FE00010")
+      continue;
+    if (typeof el.vr !== "string" || el.vr.length !== 2)
+      continue;
+    if (el.Value === undefined)
+      continue;
+    if (el.vr === "SQ" && Array.isArray(el.Value)) {
+      out[tag] = {
+        ...el,
+        Value: el.Value.map((item) => item && typeof item === "object" ? sanitizeDataset(item) : item)
+      };
+      continue;
+    }
+    out[tag] = el;
+  }
+  return out;
+}
+function framesUrlFromImageId(imageId) {
+  if (typeof imageId !== "string")
+    return null;
+  const raw = imageId.replace(/^(wadors|dicomweb):/i, "");
+  return /^https?:\/\/.*\/frames\//i.test(raw) ? raw : null;
+}
+function seriesMetadataUrlFromFramesUrl(framesUrl) {
+  const seriesBase = framesUrl.split("/instances/")[0];
+  return seriesBase ? `${seriesBase}/metadata` : null;
+}
+function sopFromFramesUrl(framesUrl) {
+  return framesUrl.split("/instances/")[1]?.split(/[/?#]/)[0] ?? null;
+}
+var UNCOMPRESSED_SYNTAXES = new Set([
+  "1.2.840.10008.1.2",
+  "1.2.840.10008.1.2.1",
+  "1.2.840.10008.1.2.2"
+]);
+function assemblePart10(DicomDict, metadata, pixelBytes, transferSyntaxUID) {
+  const dataset = sanitizeDataset(metadata);
+  const syntax = transferSyntaxUID || EXPLICIT_VR_LITTLE_ENDIAN;
+  const pixelBuffer = new ArrayBuffer(pixelBytes.byteLength);
+  new Uint8Array(pixelBuffer).set(pixelBytes);
+  if (UNCOMPRESSED_SYNTAXES.has(syntax)) {
+    const bitsAllocated = firstValue(metadata["00280100"]) ?? 16;
+    dataset["7FE00010"] = {
+      vr: bitsAllocated > 8 ? "OW" : "OB",
+      Value: [pixelBuffer]
+    };
+  } else {
+    dataset["7FE00010"] = { vr: "OB", Value: [pixelBuffer] };
+  }
+  const meta = {
+    "00020010": { vr: "UI", Value: [syntax] },
+    "00020002": { vr: "UI", Value: [firstValue(metadata["00080016"])] },
+    "00020003": { vr: "UI", Value: [firstValue(metadata["00080018"])] },
+    "00020012": { vr: "UI", Value: [IMPLEMENTATION_CLASS_UID] }
+  };
+  const dicomDict = new DicomDict(meta);
+  dicomDict.dict = dataset;
+  return dicomDict.write({
+    allowInvalidVRLength: true,
+    fragmentMultiframe: false
+  });
+}
+async function loadDicomDictCtor() {
+  const mod = await import("dcmjs");
+  const dcmjs = mod.default ?? mod;
+  return dcmjs.data.DicomDict;
+}
+function transferSyntaxOf(contentType, buffer) {
+  const fromResp = /transfer-syntax=([0-9.]+)/i.exec(contentType)?.[1];
+  if (fromResp)
+    return fromResp;
+  const head = new TextDecoder("latin1").decode(new Uint8Array(buffer).slice(0, 1024));
+  return /transfer-syntax=([0-9.]+)/i.exec(head)?.[1] ?? null;
+}
+async function fetchFrame(url, headers, signal) {
+  const resp = await fetch(url, {
+    headers: {
+      Accept: 'multipart/related; type="application/octet-stream"',
+      ...headers
+    },
+    signal
+  });
+  if (!resp.ok)
+    throw new Error(`frame fetch failed (${resp.status} ${resp.statusText})`);
+  const contentType = resp.headers.get("content-type") ?? "";
+  const buffer = await resp.arrayBuffer();
+  const transferSyntaxUID = transferSyntaxOf(contentType, buffer);
+  const parts = parseMultipartRelated(buffer, contentType);
+  let bytes;
+  if (parts.length === 0)
+    bytes = new Uint8Array(buffer);
+  else if (parts.length === 1)
+    bytes = parts[0] ?? new Uint8Array;
+  else {
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    bytes = new Uint8Array(total);
+    let o = 0;
+    for (const p of parts) {
+      bytes.set(p, o);
+      o += p.length;
+    }
+  }
+  return { bytes, transferSyntaxUID };
+}
+async function reconstructInstanceFiles(framesUrls, options = {}) {
+  const { headers = {}, onProgress, signal, concurrency = 6 } = options;
+  if (framesUrls.length === 0)
+    return [];
+  const firstUrl = framesUrls[0];
+  if (firstUrl === undefined)
+    return [];
+  const metadataUrl = seriesMetadataUrlFromFramesUrl(firstUrl);
+  if (!metadataUrl)
+    throw new Error("Could not derive series metadata URL");
+  const [DicomDict, metaResp] = await Promise.all([
+    loadDicomDictCtor(),
+    fetch(metadataUrl, {
+      headers: { Accept: "application/dicom+json", ...headers },
+      signal
+    })
+  ]);
+  if (!metaResp.ok) {
+    throw new Error(`series metadata fetch failed (${metaResp.status})`);
+  }
+  const metaJson = await metaResp.json();
+  const metaList = Array.isArray(metaJson) ? metaJson : [metaJson];
+  const metaBySop = new Map;
+  for (const m of metaList) {
+    const sop = firstValue(m["00080018"]);
+    if (sop)
+      metaBySop.set(sop, m);
+  }
+  const files = [];
+  let done = 0;
+  let next = 0;
+  const worker = async () => {
+    while (next < framesUrls.length) {
+      const idx = next++;
+      const framesUrl = framesUrls[idx];
+      if (framesUrl === undefined)
+        break;
+      const sop = sopFromFramesUrl(framesUrl);
+      const metadata = sop ? metaBySop.get(sop) : undefined;
+      if (metadata && sop) {
+        const frame = await fetchFrame(framesUrl, headers, signal);
+        const p10 = assemblePart10(DicomDict, metadata, frame.bytes, frame.transferSyntaxUID ?? undefined);
+        files.push(new File([p10], `${sop}-${idx}.dcm`, { type: "application/dicom" }));
+      }
+      onProgress?.(++done, framesUrls.length);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, framesUrls.length) }, () => worker()));
+  if (files.length < framesUrls.length) {
+    console.warn(`[nv-ohif] reconstructed ${files.length} of ${framesUrls.length} DICOM instances (${framesUrls.length - files.length} skipped for missing metadata); the converted volume may be missing slices.`);
+  }
+  return files;
+}
+
+// src/dicomToNiivue.ts
+function instanceFramesUrls(ds) {
+  const urls = [];
+  const seen = new Set;
+  for (const inst of ds.instances ?? []) {
+    const id = inst.imageId;
+    const url = typeof id === "string" ? framesUrlFromImageId(id) : null;
+    if (url && !seen.has(url)) {
+      seen.add(url);
+      urls.push(url);
+    }
+  }
+  return urls;
+}
+async function fetchDicomInstanceFiles(ds, options = {}) {
+  const { headers, onProgress, signal, concurrency } = options;
+  const framesUrls = instanceFramesUrls(ds);
+  if (framesUrls.length === 0)
+    return [];
+  return reconstructInstanceFiles(framesUrls, {
+    headers,
+    signal,
+    concurrency,
+    onProgress: (loaded, total) => onProgress?.("fetching", loaded, total)
+  });
+}
+async function convertDisplaySetToNifti(ds, options = {}) {
+  const files = await fetchDicomInstanceFiles(ds, options);
+  if (files.length === 0)
+    return null;
+  options.onProgress?.("converting", 0, 1);
+  const { Dcm2niix } = await import("@niivue/dcm2niix");
+  const dcm2niix = new Dcm2niix;
+  try {
+    await dcm2niix.init();
+    dcm2niix.worker?.addEventListener("message", (e) => {
+      const data = e.data;
+      if (data?.type === "error") {
+        console.error("[nv-ohif] dcm2niix worker error", data.message, data.error);
+      }
+    });
+    const result = await dcm2niix.input(files).run();
+    const nifti = result.filter((f) => /\.nii(\.gz)?$/i.test(f.name)).sort((a, b) => b.size - a.size);
+    if (nifti.length > 1) {
+      console.warn(`[nv-ohif] dcm2niix produced ${nifti.length} NIfTI volumes for this series; showing the largest ("${nifti[0]?.name}"). Others not shown: ` + nifti.slice(1).map((f) => f.name).join(", "));
+    }
+    return nifti[0] ?? null;
+  } finally {
+    dcm2niix.worker?.terminate();
+  }
+}
+
+// src/niivueRegistry.ts
+var instances = new Map;
+function registerNiivue(viewportId, nv) {
+  instances.set(viewportId, {
+    viewportId,
+    nv,
+    displaySets: [],
+    overlayUIDs: [],
+    overlayLoading: false,
+    clipPlane: "none"
+  });
+}
+function unregisterNiivue(viewportId) {
+  instances.delete(viewportId);
+}
+function updateNiivueViewport(viewportId, patch) {
+  const entry = instances.get(viewportId);
+  if (entry)
+    Object.assign(entry, patch);
+}
+function getNiivueEntry(viewportId) {
+  return viewportId === undefined ? undefined : instances.get(viewportId);
+}
+function ohifServices(servicesManager) {
+  if (servicesManager?.services)
+    return servicesManager.services;
+  const g = globalThis;
+  return g.services;
+}
+function getNiivueEntryForViewport(viewportId) {
+  const exact = getNiivueEntry(viewportId);
+  if (exact)
+    return exact;
+  if (instances.size === 1) {
+    for (const entry of instances.values())
+      return entry;
+  }
+  return;
+}
+function getNiivueForViewport(viewportId) {
+  return getNiivueEntryForViewport(viewportId)?.nv;
+}
+function getActiveNiivueEntry(servicesManager) {
+  const grid = ohifServices(servicesManager)?.viewportGridService;
+  return getNiivueEntryForViewport(grid?.getActiveViewportId?.());
+}
+function getActiveNiivue(servicesManager) {
+  return getActiveNiivueEntry(servicesManager)?.nv;
+}
+function refreshToolbar(servicesManager, viewportId) {
+  const svc = ohifServices(servicesManager)?.toolbarService;
+  svc?.refreshToolbarState?.({ viewportId });
+}
+function ohifCommandsManager(commandsManager) {
+  if (commandsManager?.runCommand)
+    return commandsManager;
+  const g = globalThis;
+  return g.commandsManager;
+}
+function authHeaders(servicesManager) {
+  const svc = ohifServices(servicesManager)?.userAuthenticationService;
+  const header = svc?.getAuthorizationHeader?.();
+  return header?.Authorization ? { Authorization: header.Authorization } : {};
+}
+
+// src/commands.ts
+var NIIVUE_SLICE_TYPES = {
+  axial: SLICE_TYPE.AXIAL,
+  coronal: SLICE_TYPE.CORONAL,
+  sagittal: SLICE_TYPE.SAGITTAL,
+  multiplanar: SLICE_TYPE.MULTIPLANAR,
+  render: SLICE_TYPE.RENDER
+};
+var NIIVUE_CLIP_PLANES = {
+  none: [2, 0, 0],
+  right: [0, 90, 0],
+  left: [0, 270, 0],
+  anterior: [0, 180, 0],
+  posterior: [0, 0, 0],
+  superior: [0, 0, 90],
+  inferior: [0, 0, -90]
+};
+var OVERLAY_COLORMAP = "warm";
+var OVERLAY_OPACITY = 0.5;
+var NIIVUE_COLORMAPS = [
+  { name: "gray", label: "Gray" },
+  { name: "hot", label: "Hot" },
+  { name: "bone", label: "Bone" },
+  { name: "cool", label: "Cool" },
+  { name: "warm", label: "Warm" },
+  { name: "viridis", label: "Viridis" },
+  { name: "plasma", label: "Plasma" },
+  { name: "inferno", label: "Inferno" },
+  { name: "turbo", label: "Turbo" },
+  { name: "jet", label: "Jet" }
+];
+var FALLBACK_WL_PRESETS = {
+  CT: [
+    {
+      id: "ct-soft-tissue",
+      description: "Soft tissue",
+      window: 400,
+      level: 40
+    },
+    { id: "ct-lung", description: "Lung", window: 1500, level: -600 },
+    { id: "ct-liver", description: "Liver", window: 150, level: 90 },
+    { id: "ct-bone", description: "Bone", window: 2500, level: 480 },
+    { id: "ct-brain", description: "Brain", window: 80, level: 40 }
+  ],
+  PT: [
+    { id: "pt-default", description: "Default", window: 5, level: 2.5 },
+    { id: "pt-suv-5", description: "SUV 5", window: 0, level: 5 },
+    { id: "pt-suv-10", description: "SUV 10", window: 0, level: 10 }
+  ]
+};
+var VIEW_DEFAULTS = {
+  azimuth: 110,
+  elevation: 10,
+  scaleMultiplier: 1,
+  pan2Dxyzmm: [0, 0, 0, 1],
+  renderPan: [0, 0],
+  crosshairPos: [0.5, 0.5, 0.5]
+};
+function findOverlayCandidate(entry, activeDisplaySets) {
+  const loaded = new Set(entry.overlayUIDs);
+  for (const ds of entry.displaySets) {
+    if (typeof ds.displaySetInstanceUID === "string")
+      loaded.add(ds.displaySetInstanceUID);
+  }
+  return activeDisplaySets.find((ds) => {
+    const uid = ds.displaySetInstanceUID;
+    if (typeof uid !== "string" || loaded.has(uid))
+      return false;
+    const kind = classifyDisplaySet(ds);
+    return kind === "nifti" || kind === "dicom-volume";
+  });
+}
+var statusTokens = new WeakMap;
+function writeStatus(entry, message) {
+  statusTokens.set(entry, (statusTokens.get(entry) ?? 0) + 1);
+  entry.setStatus?.(message);
+}
+function flashStatus(entry, message, ms = 4000) {
+  writeStatus(entry, message);
+  const token = statusTokens.get(entry);
+  setTimeout(() => {
+    if (statusTokens.get(entry) === token)
+      writeStatus(entry, null);
+  }, ms);
+}
+function baseModality(entry) {
+  const modality = entry.displaySets[0]?.Modality;
+  return typeof modality === "string" ? modality : undefined;
+}
+function windowLevelPresets(servicesManager) {
+  const svc = ohifServices(servicesManager)?.customizationService;
+  const custom = svc?.getCustomization?.("cornerstone.windowLevelPresets");
+  if (custom && typeof custom === "object") {
+    return custom;
+  }
+  return FALLBACK_WL_PRESETS;
+}
+function resolveWindowLevel(presets, modality, presetId, presetIndex) {
+  const list = modality ? presets[modality] : undefined;
+  if (!list || list.length === 0)
+    return;
+  const preset = (presetId ? list.find((p) => p.id === presetId) : undefined) ?? (presetIndex !== undefined ? list[presetIndex] : undefined);
+  if (!preset)
+    return;
+  const width = Number(preset.window);
+  const center = Number(preset.level);
+  if (!Number.isFinite(width) || !Number.isFinite(center))
+    return;
+  if (width === 0)
+    return [0, center];
+  return [center - width / 2, center + width / 2];
+}
+function readBaseWindowLevel(nv) {
+  const vol = nv.volumes[0];
+  if (!vol)
+    return;
+  const { calMin, calMax } = vol;
+  if (calMin === undefined || calMax === undefined || !Number.isFinite(calMin) || !Number.isFinite(calMax))
+    return;
+  return { window: calMax - calMin, level: (calMin + calMax) / 2 };
+}
+function recordWindowLevel(entry, calMin, calMax) {
+  if (entry)
+    entry.windowLevel = {
+      window: calMax - calMin,
+      level: (calMin + calMax) / 2
+    };
+}
+function sameWindowLevel(a, b) {
+  const eps = Math.max(0.001, Math.abs(a.window) * 0.001);
+  return Math.abs(a.window - b.window) < eps && Math.abs(a.level - b.level) < eps;
+}
+function viewportEntries(servicesManager) {
+  const grid = ohifServices(servicesManager)?.viewportGridService;
+  const viewports = grid?.getState?.().viewports;
+  if (!viewports)
+    return [];
+  const raw = viewports instanceof Map ? [...viewports.entries()] : Object.entries(viewports);
+  return raw.map(([id, vp]) => [id, vp?.displaySetInstanceUIDs ?? []]);
+}
+function syncWindowLevelToSiblings(entry, viewportId, wl, servicesManager, commandsManager) {
+  const baseUIDs = new Set(entry.displaySets.map((ds) => ds.displaySetInstanceUID).filter((u) => typeof u === "string"));
+  if (baseUIDs.size === 0)
+    return;
+  const cm = ohifCommandsManager(commandsManager);
+  if (!cm)
+    return;
+  for (const [id, uids] of viewportEntries(servicesManager)) {
+    if (id === viewportId || !uids.some((u) => baseUIDs.has(u)))
+      continue;
+    try {
+      cm.runCommand?.("setViewportWindowLevel", {
+        viewportId: id,
+        windowWidth: wl.window,
+        windowCenter: wl.level
+      });
+    } catch (err) {
+      console.warn("[nv-ohif] setViewportWindowLevel sync failed", err);
+    }
+  }
+}
+var POLYLINE_VALUE_TYPE = "value_type::polyline";
+function annotationToolType(a) {
+  return a.shape?.type ?? (a.polygons[0]?.outer.length ? "freehand" : undefined);
+}
+var DEFAULT_LABEL_PREFIX = {
+  measureLine: "Length",
+  arrow: "Arrow",
+  measureBidirectional: "Bidirectional",
+  measureEllipse: "ROI",
+  measureRect: "ROI",
+  measureCircle: "ROI",
+  measureSpline: "ROI",
+  measureLivewire: "ROI",
+  freehand: "ROI"
+};
+function defaultLabelPrefix(a) {
+  const type = annotationToolType(a);
+  return type && DEFAULT_LABEL_PREFIX[type] || "ROI";
+}
+function applyDefaultAnnotationText(annotation, annotations) {
+  if (annotation.text?.length)
+    return false;
+  if (annotationToolType(annotation) === "measureLine")
+    return false;
+  const prefix = defaultLabelPrefix(annotation);
+  const re = new RegExp(`^${prefix} #(\\d+)$`);
+  let maxN = 0;
+  for (const candidate of annotations) {
+    const m = candidate.text ? re.exec(candidate.text) : null;
+    if (m) {
+      const n = Number(m[1]);
+      if (n > maxN)
+        maxN = n;
+    }
+  }
+  const text = `${prefix} #${maxN + 1}`;
+  annotation.text = text;
+  const stored = annotations.find((c) => c.id === annotation.id);
+  if (stored)
+    stored.text = text;
+  return true;
+}
+var ELLIPSE_VALUE_TYPE = "value_type::ellipse";
+var CIRCLE_VALUE_TYPE = "value_type::circle";
+var POINT_VALUE_TYPE = "value_type::point";
+var BIDIRECTIONAL_VALUE_TYPE = "value_type::bidirectional";
+var ANNOTATION_TO_OHIF = {
+  measureEllipse: {
+    toolName: "EllipticalROI",
+    valueType: ELLIPSE_VALUE_TYPE,
+    minPoints: 4
+  },
+  measureRect: {
+    toolName: "RectangleROI",
+    valueType: POLYLINE_VALUE_TYPE,
+    minPoints: 4
+  },
+  measureCircle: {
+    toolName: "CircleROI",
+    valueType: CIRCLE_VALUE_TYPE,
+    minPoints: 2
+  },
+  measureLine: {
+    toolName: "Length",
+    valueType: POLYLINE_VALUE_TYPE,
+    minPoints: 2,
+    points: 2
+  },
+  measureSpline: {
+    toolName: "SplineROI",
+    valueType: POLYLINE_VALUE_TYPE,
+    minPoints: 2
+  },
+  measureLivewire: {
+    toolName: "LivewireContour",
+    valueType: POLYLINE_VALUE_TYPE,
+    minPoints: 2
+  },
+  measureBidirectional: {
+    toolName: "Bidirectional",
+    valueType: BIDIRECTIONAL_VALUE_TYPE,
+    minPoints: 4
+  },
+  freehand: {
+    toolName: "PlanarFreehandROI",
+    valueType: POLYLINE_VALUE_TYPE,
+    minPoints: 2
+  },
+  arrow: {
+    toolName: "ArrowAnnotate",
+    valueType: POINT_VALUE_TYPE,
+    minPoints: 2,
+    points: 2
+  }
+};
+var measurementSources = new WeakMap;
+function niivueMeasurementSource(measurementService) {
+  const cached = measurementSources.get(measurementService);
+  if (cached)
+    return cached;
+  const source = measurementService.createSource("NiiVue", "1.0");
+  for (const { toolName, valueType, points } of Object.values(ANNOTATION_TO_OHIF)) {
+    measurementService.addMapping(source, toolName, [{ valueType, ...points === undefined ? {} : { points } }], () => ({}), (data) => data.measurement);
+  }
+  measurementSources.set(measurementService, source);
+  return source;
+}
+var niivueMeasurementCounter = 0;
+function resolveBackingSeries(entry, displaySetService) {
+  for (const ds of entry.displaySets) {
+    if (!ds.SeriesInstanceUID)
+      continue;
+    const resolved = displaySetService.getDisplaySetsForSeries?.(ds.SeriesInstanceUID);
+    const withInstances = resolved?.find((r) => (r.instances?.length ?? 0) > 0);
+    if (withInstances?.SeriesInstanceUID)
+      return withInstances;
+  }
+  return;
+}
+function rasToLps(p) {
+  return [p[0] === 0 ? 0 : -p[0], p[1] === 0 ? 0 : -p[1], p[2]];
+}
+function annotationPointToLps(annotation, point) {
+  return rasToLps(slice2DToMM(point, annotation.slicePosition, annotation.sliceType));
+}
+function annotationPointsLps(annotation) {
+  const shape = annotation.shape;
+  if (!shape) {
+    const outer = annotation.polygons[0]?.outer;
+    if (outer && outer.length >= 2)
+      return outer.map((point) => annotationPointToLps(annotation, point));
+    return annotation.anchorMM ? [rasToLps(annotation.anchorMM)] : [];
+  }
+  const { start, end } = shape;
+  const cx = (start.x + end.x) / 2;
+  const cy = (start.y + end.y) / 2;
+  const minX = Math.min(start.x, end.x);
+  const maxX = Math.max(start.x, end.x);
+  const minY = Math.min(start.y, end.y);
+  const maxY = Math.max(start.y, end.y);
+  let points;
+  switch (shape.type) {
+    case "measureEllipse":
+      points = [
+        { x: cx, y: minY },
+        { x: cx, y: maxY },
+        { x: minX, y: cy },
+        { x: maxX, y: cy }
+      ];
+      break;
+    case "measureRect":
+      points = [
+        { x: minX, y: minY },
+        { x: maxX, y: minY },
+        { x: maxX, y: maxY },
+        { x: minX, y: maxY }
+      ];
+      break;
+    case "measureCircle":
+      points = [
+        { x: cx, y: cy },
+        { x: maxX, y: cy }
+      ];
+      break;
+    case "measureBidirectional":
+      points = shape.start2 && shape.end2 ? [start, end, shape.start2, shape.end2] : [start, end];
+      break;
+    case "measureSpline":
+    case "measureLivewire":
+    case "freehand": {
+      const outer = annotation.polygons[0]?.outer;
+      points = outer && outer.length >= 2 ? outer : [start, end];
+      break;
+    }
+    case "measureLine":
+      points = [start, end];
+      break;
+    case "arrow":
+      points = [end, start];
+      break;
+    default:
+      points = [start];
+  }
+  return points.map((point) => annotationPointToLps(annotation, point));
+}
+var reflectedAnnotations = new Map;
+function annotationContentHash(a) {
+  const s = a.stats;
+  const shape = a.shape;
+  return JSON.stringify([
+    a.text ?? "",
+    a.sliceType,
+    a.slicePosition,
+    a.anchorMM ?? null,
+    s ? [s.area, s.min, s.mean, s.max, s.stdDev, s.length, s.shortLength] : 0,
+    shape ? [shape.type, shape.start, shape.end, shape.start2, shape.end2] : 0,
+    a.polygons.map((polygon) => [
+      polygon.outer.map((p) => [p.x, p.y]),
+      polygon.holes.map((hole) => hole.map((p) => [p.x, p.y]))
+    ])
+  ]);
+}
+var measurementToAnnotation = new Map;
+var removingUids = new Set;
+var hiddenAnnotations = new Map;
+var labelSyncSubscriptions = new WeakMap;
+function releaseLabelSync(service) {
+  const subscription = labelSyncSubscriptions.get(service);
+  if (!subscription)
+    return;
+  subscription.refCount -= 1;
+  if (subscription.refCount > 0)
+    return;
+  subscription.unsubscribe();
+  labelSyncSubscriptions.delete(service);
+}
+function modalityUnit(entry) {
+  const modality = baseModality(entry);
+  if (modality === "CT")
+    return "HU";
+  if (modality === "PT")
+    return "SUV";
+  return "";
+}
+function buildAnnotationDisplay(toolName, stats, unit) {
+  const label = `NiiVue ${toolName}`;
+  if (toolName === "ArrowAnnotate" || !stats) {
+    return { primary: [label], data: {}, label };
+  }
+  if (toolName === "Length" && stats.length !== undefined) {
+    return {
+      primary: [`${stats.length.toFixed(1)} mm`],
+      data: { length: stats.length, unit: "mm" },
+      label
+    };
+  }
+  if (toolName === "Bidirectional" && stats.length !== undefined) {
+    const short = stats.shortLength ?? 0;
+    return {
+      primary: [
+        `L: ${stats.length.toFixed(1)} mm`,
+        `W: ${short.toFixed(1)} mm`
+      ],
+      data: { length: stats.length, width: short, unit: "mm" },
+      label
+    };
+  }
+  const withUnit = (v, key) => unit ? `${key}: ${v.toFixed(1)} ${unit}` : `${key}: ${v.toFixed(1)}`;
+  return {
+    primary: [
+      `${stats.area.toFixed(1)} mm²`,
+      withUnit(stats.max, "Max"),
+      withUnit(stats.mean, "Mean")
+    ],
+    data: {
+      area: stats.area,
+      mean: stats.mean,
+      stdDev: stats.stdDev,
+      max: stats.max,
+      min: stats.min,
+      unit,
+      areaUnit: "mm²"
+    },
+    label
+  };
+}
+function reflectNiivueAnnotationResult(viewportId, servicesManager, annotation, existingUid) {
+  const services = ohifServices(servicesManager);
+  const measurementService = services?.measurementService;
+  const displaySetService = services?.displaySetService;
+  if (!measurementService?.addRawMeasurement || !displaySetService?.getDisplaySetsForSeries)
+    return { status: "retryableFailure" };
+  const toolType = annotationToolType(annotation);
+  const mapping = toolType ? ANNOTATION_TO_OHIF[toolType] : undefined;
+  if (!mapping)
+    return { status: "permanentlyUnsupported" };
+  if (toolType === "freehand" && (annotation.polygons.length !== 1 || (annotation.polygons[0]?.holes.length ?? 0) > 0))
+    return { status: "permanentlyUnsupported" };
+  const entry = getNiivueEntry(viewportId);
+  if (!entry)
+    return { status: "retryableFailure" };
+  const backing = resolveBackingSeries(entry, displaySetService);
+  if (!backing?.SeriesInstanceUID)
+    return { status: "retryableFailure" };
+  const source = niivueMeasurementSource(measurementService);
+  const uid = existingUid ?? `niivue-${mapping.toolName}-${++niivueMeasurementCounter}`;
+  const forUID = backing.instances?.[0]?.FrameOfReferenceUID;
+  const points = annotationPointsLps(annotation);
+  if (points.length < (mapping.minPoints ?? 0))
+    return { status: "permanentlyUnsupported" };
+  const unit = modalityUnit(entry);
+  const { primary, data } = buildAnnotationDisplay(mapping.toolName, annotation.stats, unit);
+  const rowLabel = annotation.text ?? "";
+  let acceptedUid;
+  try {
+    acceptedUid = measurementService.addRawMeasurement(source, mapping.toolName, {
+      uid,
+      annotation: { data: {} },
+      measurement: {
+        uid,
+        toolName: mapping.toolName,
+        label: rowLabel,
+        referenceSeriesUID: backing.SeriesInstanceUID,
+        referenceStudyUID: backing.StudyInstanceUID,
+        displaySetInstanceUID: backing.displaySetInstanceUID,
+        FrameOfReferenceUID: forUID,
+        points,
+        displayText: { primary, secondary: [] },
+        data,
+        type: mapping.valueType,
+        metadata: { toolName: mapping.toolName, FrameOfReferenceUID: forUID }
+      }
+    }, (d) => d.measurement);
+  } catch {
+    return { status: "retryableFailure" };
+  }
+  if (!acceptedUid)
+    return { status: "retryableFailure" };
+  let byView = reflectedAnnotations.get(viewportId);
+  if (!byView) {
+    byView = new Map;
+    reflectedAnnotations.set(viewportId, byView);
+  }
+  byView.set(annotation.id, {
+    uid: acceptedUid,
+    hash: annotationContentHash(annotation)
+  });
+  measurementToAnnotation.set(acceptedUid, {
+    viewportId,
+    annotationId: annotation.id
+  });
+  return { status: "success" };
+}
+function reflectNiivueAnnotation(viewportId, servicesManager, annotation, existingUid) {
+  return reflectNiivueAnnotationResult(viewportId, servicesManager, annotation, existingUid).status === "success";
+}
+function applyOhifLabelToAnnotation(measurementUid, label) {
+  const ref = measurementToAnnotation.get(measurementUid);
+  if (!ref)
+    return;
+  const entry = getNiivueEntry(ref.viewportId);
+  if (!entry)
+    return;
+  const current = entry.nv.annotations.find((a) => a.id === ref.annotationId);
+  if (current && (current.text ?? "") === (label ?? ""))
+    return;
+  entry.nv.setAnnotationText(ref.annotationId, label ?? "");
+}
+function jumpToNiivueMeasurement(measurementUid, servicesManager) {
+  const ref = measurementToAnnotation.get(measurementUid);
+  if (!ref)
+    return;
+  const entry = getNiivueEntry(ref.viewportId);
+  const annotation = entry?.nv.annotations.find((candidate) => candidate.id === ref.annotationId);
+  if (!entry || !annotation)
+    return;
+  const services = ohifServices(servicesManager);
+  const viewportGridService = services?.viewportGridService;
+  viewportGridService?.setActiveViewportId?.(ref.viewportId);
+  let target;
+  const shape = annotation.shape;
+  if (shape) {
+    const at = shape.type === "arrow" ? shape.end : {
+      x: (shape.start.x + shape.end.x) / 2,
+      y: (shape.start.y + shape.end.y) / 2
+    };
+    target = slice2DToMM(at, annotation.slicePosition, annotation.sliceType);
+  } else {
+    const outer = annotation.polygons[0]?.outer;
+    if (outer && outer.length > 0) {
+      const sum = outer.reduce((acc, point) => ({ x: acc.x + point.x, y: acc.y + point.y }), { x: 0, y: 0 });
+      target = slice2DToMM({ x: sum.x / outer.length, y: sum.y / outer.length }, annotation.slicePosition, annotation.sliceType);
+    }
+  }
+  if (!target)
+    target = annotation.anchorMM;
+  if (target)
+    entry.nv.setCrosshairPos(target);
+  entry.nv.selectAnnotation(annotation.id);
+}
+function applyOhifRemoveToAnnotation(measurementUid) {
+  if (removingUids.has(measurementUid))
+    return;
+  const ref = measurementToAnnotation.get(measurementUid);
+  if (!ref)
+    return;
+  const byView = reflectedAnnotations.get(ref.viewportId);
+  byView?.delete(ref.annotationId);
+  if (byView && byView.size === 0)
+    reflectedAnnotations.delete(ref.viewportId);
+  measurementToAnnotation.delete(measurementUid);
+  clearHiddenAnnotation(ref.viewportId, ref.annotationId);
+  getNiivueEntry(ref.viewportId)?.nv.removeAnnotation(ref.annotationId);
+}
+function clearHiddenAnnotation(viewportId, annotationId) {
+  const set = hiddenAnnotations.get(viewportId);
+  if (!set)
+    return;
+  set.delete(annotationId);
+  if (set.size === 0)
+    hiddenAnnotations.delete(viewportId);
+}
+function visibleAnnotationScreenShapes(viewportId, shapes) {
+  const hidden = hiddenAnnotations.get(viewportId);
+  if (!hidden || hidden.size === 0)
+    return shapes;
+  return shapes.filter((shape) => !hidden.has(shape.id));
+}
+function applyOhifVisibilityToAnnotation(measurementUid, isVisible) {
+  const ref = measurementToAnnotation.get(measurementUid);
+  if (!ref)
+    return;
+  const set = hiddenAnnotations.get(ref.viewportId);
+  const currentlyHidden = set?.has(ref.annotationId) ?? false;
+  if (isVisible === !currentlyHidden)
+    return;
+  if (isVisible) {
+    clearHiddenAnnotation(ref.viewportId, ref.annotationId);
+  } else {
+    const target = set ?? new Set;
+    target.add(ref.annotationId);
+    hiddenAnnotations.set(ref.viewportId, target);
+  }
+  getNiivueEntry(ref.viewportId)?.nv.drawScene();
+}
+function subscribeOhifLabelSync(servicesManager) {
+  const svc = ohifServices(servicesManager)?.measurementService;
+  const labelEvent = svc?.EVENTS?.MEASUREMENT_UPDATED;
+  const jumpEvent = svc?.EVENTS?.JUMP_TO_MEASUREMENT;
+  const removeEvent = svc?.EVENTS?.MEASUREMENT_REMOVED;
+  if (!svc?.subscribe || !labelEvent && !jumpEvent && !removeEvent)
+    return;
+  const existing = labelSyncSubscriptions.get(svc);
+  if (existing) {
+    existing.refCount += 1;
+    return () => releaseLabelSync(svc);
+  }
+  const subscriptions = [];
+  if (labelEvent) {
+    subscriptions.push(svc.subscribe(labelEvent, (payload) => {
+      const m = payload?.measurement;
+      if (typeof m !== "object" || !m?.uid)
+        return;
+      if (typeof m.label === "string")
+        applyOhifLabelToAnnotation(m.uid, m.label);
+      if (typeof m.isVisible === "boolean")
+        applyOhifVisibilityToAnnotation(m.uid, m.isVisible);
+    }));
+  }
+  if (jumpEvent) {
+    subscriptions.push(svc.subscribe(jumpEvent, (payload) => {
+      const m = payload?.measurement;
+      const uid = typeof m === "object" ? m?.uid : undefined;
+      if (uid)
+        jumpToNiivueMeasurement(uid, servicesManager);
+    }));
+  }
+  if (removeEvent) {
+    subscriptions.push(svc.subscribe(removeEvent, (payload) => {
+      const m = payload?.measurement;
+      const uid = typeof m === "string" ? m : m?.uid;
+      if (uid)
+        applyOhifRemoveToAnnotation(uid);
+    }));
+  }
+  labelSyncSubscriptions.set(svc, {
+    refCount: 1,
+    unsubscribe: () => {
+      for (const subscription of subscriptions)
+        subscription?.unsubscribe?.();
+    }
+  });
+  return () => releaseLabelSync(svc);
+}
+function removeNiivueAnnotation(viewportId, servicesManager, annotationId) {
+  const byView = reflectedAnnotations.get(viewportId);
+  const row = byView?.get(annotationId);
+  if (!byView || !row)
+    return true;
+  const measurementService = ohifServices(servicesManager)?.measurementService;
+  if (row.uid) {
+    if (measurementService?.remove) {
+      removingUids.add(row.uid);
+      try {
+        measurementService.remove(row.uid);
+      } catch {
+        return false;
+      } finally {
+        removingUids.delete(row.uid);
+      }
+    }
+    measurementToAnnotation.delete(row.uid);
+  }
+  byView.delete(annotationId);
+  if (byView.size === 0)
+    reflectedAnnotations.delete(viewportId);
+  const stillPresent = getNiivueEntry(viewportId)?.nv.annotations.some((a) => a.id === annotationId) ?? false;
+  if (!stillPresent)
+    clearHiddenAnnotation(viewportId, annotationId);
+  return true;
+}
+function clearNiivueAnnotations(viewportId, servicesManager) {
+  const byView = reflectedAnnotations.get(viewportId);
+  if (!byView)
+    return;
+  const measurementService = ohifServices(servicesManager)?.measurementService;
+  for (const { uid } of byView.values()) {
+    if (!uid)
+      continue;
+    removingUids.add(uid);
+    try {
+      measurementService?.remove?.(uid);
+    } catch {} finally {
+      removingUids.delete(uid);
+    }
+    measurementToAnnotation.delete(uid);
+  }
+  reflectedAnnotations.delete(viewportId);
+  hiddenAnnotations.delete(viewportId);
+}
+var reconcilingViewports = new Set;
+function reconcileNiivueAnnotations(viewportId, servicesManager) {
+  if (reconcilingViewports.has(viewportId))
+    return;
+  const entry = getNiivueEntry(viewportId);
+  if (!entry)
+    return;
+  reconcilingViewports.add(viewportId);
+  try {
+    const live = entry.nv.annotations;
+    const liveIds = new Set(live.map((a) => a.id));
+    const byView = reflectedAnnotations.get(viewportId);
+    if (byView) {
+      for (const annotationId of [...byView.keys()]) {
+        if (!liveIds.has(annotationId))
+          removeNiivueAnnotation(viewportId, servicesManager, annotationId);
+      }
+    }
+    for (const annotation of live) {
+      const existing = reflectedAnnotations.get(viewportId)?.get(annotation.id);
+      const hash = annotationContentHash(annotation);
+      if (existing && existing.hash === hash)
+        continue;
+      const result = reflectNiivueAnnotationResult(viewportId, servicesManager, annotation, existing?.uid);
+      if (result.status === "permanentlyUnsupported") {
+        const removed = existing?.uid ? removeNiivueAnnotation(viewportId, servicesManager, annotation.id) : true;
+        if (!removed)
+          continue;
+        let map = reflectedAnnotations.get(viewportId);
+        if (!map) {
+          map = new Map;
+          reflectedAnnotations.set(viewportId, map);
+        }
+        map.set(annotation.id, { hash });
+      }
+    }
+  } finally {
+    reconcilingViewports.delete(viewportId);
+  }
+}
+function syncNiivueWindowLevelToOhif(viewportId, servicesManager, commandsManager) {
+  const entry = getNiivueEntry(viewportId);
+  if (!entry)
+    return;
+  const wl = readBaseWindowLevel(entry.nv);
+  if (!wl)
+    return;
+  if (entry.windowLevel && sameWindowLevel(entry.windowLevel, wl))
+    return;
+  const seeded = entry.windowLevel !== undefined;
+  entry.windowLevel = wl;
+  if (!seeded)
+    return;
+  syncWindowLevelToSiblings(entry, viewportId, wl, servicesManager, commandsManager);
+  return wl;
+}
+function getNiivueCommandsModule({
+  servicesManager,
+  commandsManager
+}) {
+  const actions = {
+    niivueSetSliceType: ({ sliceType } = {}) => {
+      const nv = getActiveNiivue(servicesManager);
+      const mapped = sliceType ? NIIVUE_SLICE_TYPES[sliceType] : undefined;
+      if (!nv || mapped === undefined)
+        return;
+      nv.sliceType = mapped;
+    },
+    niivueSetMeasurementMode: () => {
+      const cmds = ohifCommandsManager(commandsManager);
+      if (cmds?.runCommand) {
+        cmds.runCommand("setToolActiveToolbar", { toolName: "Length" });
+        return;
+      }
+      const nv = getActiveNiivue(servicesManager);
+      if (nv) {
+        nv.annotationTool = "measureLine";
+        nv.annotationIsEnabled = true;
+      }
+    },
+    niivueResetView: () => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry)
+        return;
+      if (entry.slideView) {
+        entry.slideView.resetView();
+        return;
+      }
+      const { nv } = entry;
+      nv.azimuth = VIEW_DEFAULTS.azimuth;
+      nv.elevation = VIEW_DEFAULTS.elevation;
+      nv.scaleMultiplier = VIEW_DEFAULTS.scaleMultiplier;
+      nv.pan2Dxyzmm = [...VIEW_DEFAULTS.pan2Dxyzmm];
+      nv.renderPan = [...VIEW_DEFAULTS.renderPan];
+      nv.crosshairPos = [...VIEW_DEFAULTS.crosshairPos];
+    },
+    niivueSaveBitmap: async () => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry)
+        return;
+      if (entry.slideView) {
+        await entry.slideView.saveBitmap();
+        return;
+      }
+      await entry.nv.saveBitmap("niivue.png");
+    },
+    niivueSetClipPlane: ({ plane } = {}) => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      const preset = plane ? NIIVUE_CLIP_PLANES[plane] : undefined;
+      if (!entry || !preset || plane === undefined)
+        return;
+      entry.nv.setClipPlane([...preset]);
+      entry.clipPlane = plane;
+    },
+    niivueToggleOverlay: async () => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry || entry.overlayLoading)
+        return;
+      const { nv, viewportId } = entry;
+      if (entry.overlayUIDs.length > 0) {
+        while (nv.volumes.length > 1) {
+          nv.model.removeVolume(nv.volumes.length - 1);
+        }
+        entry.overlayUIDs = [];
+        await nv.updateGLVolume();
+        refreshToolbar(servicesManager, viewportId);
+        return;
+      }
+      if (nv.volumes.length === 0)
+        return;
+      const dsService = ohifServices(servicesManager)?.displaySetService;
+      const candidate = findOverlayCandidate(entry, dsService?.getActiveDisplaySets?.() ?? []);
+      if (!candidate) {
+        flashStatus(entry, "No other loadable series in this study.");
+        return;
+      }
+      const uid = String(candidate.displaySetInstanceUID);
+      const label = typeof candidate.SeriesDescription === "string" ? candidate.SeriesDescription : "overlay";
+      const baseDisplaySets = entry.displaySets;
+      const stillLive = () => getNiivueEntry(viewportId) === entry && entry.displaySets === baseDisplaySets;
+      const addOverlayGuarded = async (spec) => {
+        const before = nv.volumes.length;
+        await nv.addVolume(spec);
+        if (stillLive())
+          return true;
+        if (nv.volumes.length === before + 1) {
+          nv.model.removeVolume(nv.volumes.length - 1);
+          await nv.updateGLVolume();
+        }
+        return false;
+      };
+      entry.overlayLoading = true;
+      try {
+        const direct = displaySetToNiivue(candidate);
+        let added;
+        if (direct) {
+          if (!stillLive())
+            return;
+          added = await addOverlayGuarded({
+            ...direct,
+            colormap: OVERLAY_COLORMAP,
+            opacity: OVERLAY_OPACITY
+          });
+        } else {
+          writeStatus(entry, `Fetching overlay: ${label}...`);
+          const niftiFile = await convertDisplaySetToNifti(candidate, {
+            headers: authHeaders(servicesManager),
+            onProgress: (phase, loaded, total) => {
+              writeStatus(entry, phase === "fetching" ? `Fetching overlay: ${label}... ${loaded}/${total}` : `Converting overlay: ${label} (dcm2niix)...`);
+            }
+          });
+          if (!stillLive())
+            return;
+          if (!niftiFile)
+            throw new Error("conversion produced no volume");
+          added = await addOverlayGuarded({
+            url: niftiFile,
+            name: niftiFile.name,
+            colormap: OVERLAY_COLORMAP,
+            opacity: OVERLAY_OPACITY
+          });
+        }
+        if (!added)
+          return;
+        entry.overlayUIDs.push(uid);
+        writeStatus(entry, null);
+      } catch (err) {
+        console.error("[nv-ohif] overlay load failed", err);
+        const message = err instanceof Error ? err.message : String(err);
+        flashStatus(entry, `Overlay load failed: ${message || "unknown error"}`);
+      } finally {
+        if (stillLive()) {
+          entry.overlayLoading = false;
+          refreshToolbar(servicesManager, viewportId);
+        }
+      }
+    },
+    niivueSetWindowLevel: ({
+      window: window2,
+      level
+    } = {}) => {
+      const nv = getActiveNiivue(servicesManager);
+      if (!nv || nv.volumes.length === 0)
+        return;
+      if (window2 === undefined || level === undefined || !Number.isFinite(window2) || !Number.isFinite(level))
+        return;
+      const [calMin, calMax] = window2 === 0 ? [0, level] : [level - window2 / 2, level + window2 / 2];
+      nv.setVolume(0, { calMin, calMax });
+      recordWindowLevel(getActiveNiivueEntry(servicesManager), calMin, calMax);
+    },
+    niivueSetWindowLevelPreset: ({
+      presetId,
+      presetIndex
+    } = {}) => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry || entry.nv.volumes.length === 0)
+        return;
+      const range = resolveWindowLevel(windowLevelPresets(servicesManager), baseModality(entry), presetId, presetIndex);
+      if (!range)
+        return;
+      entry.nv.setVolume(0, { calMin: range[0], calMax: range[1] });
+      recordWindowLevel(entry, range[0], range[1]);
+    },
+    niivueAutoWindowLevel: () => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry || entry.nv.volumes.length === 0)
+        return;
+      entry.nv.recalculateCalMinMax(0).then(() => {
+        const wl = readBaseWindowLevel(entry.nv);
+        if (wl)
+          entry.windowLevel = wl;
+      });
+    },
+    niivueSetColormap: ({ colormap } = {}) => {
+      const nv = getActiveNiivue(servicesManager);
+      if (!nv || nv.volumes.length === 0 || !colormap)
+        return;
+      nv.setVolume(0, { colormap });
+    },
+    niivueToggleColorbar: () => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry)
+        return;
+      entry.nv.isColorbarVisible = !entry.nv.isColorbarVisible;
+      refreshToolbar(servicesManager, entry.viewportId);
+    },
+    niivueToggleInterpolation: () => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry)
+        return;
+      entry.nv.volumeIsNearestInterpolation = !entry.nv.volumeIsNearestInterpolation;
+      refreshToolbar(servicesManager, entry.viewportId);
+    },
+    niivueToggleCrosshair: () => {
+      const entry = getActiveNiivueEntry(servicesManager);
+      if (!entry)
+        return;
+      const visible = entry.nv.crosshairWidth > 0;
+      entry.nv.crosshairWidth = visible ? 0 : 1;
+      entry.nv.is3DCrosshairVisible = !visible;
+      entry.nv.drawScene();
+      refreshToolbar(servicesManager, entry.viewportId);
+    }
+  };
+  return {
+    actions,
+    definitions: {
+      niivueSetSliceType: actions.niivueSetSliceType,
+      niivueSetMeasurementMode: actions.niivueSetMeasurementMode,
+      niivueResetView: actions.niivueResetView,
+      niivueSaveBitmap: actions.niivueSaveBitmap,
+      niivueSetClipPlane: actions.niivueSetClipPlane,
+      niivueToggleOverlay: actions.niivueToggleOverlay,
+      niivueSetWindowLevel: actions.niivueSetWindowLevel,
+      niivueSetWindowLevelPreset: actions.niivueSetWindowLevelPreset,
+      niivueAutoWindowLevel: actions.niivueAutoWindowLevel,
+      niivueSetColormap: actions.niivueSetColormap,
+      niivueToggleColorbar: actions.niivueToggleColorbar,
+      niivueToggleInterpolation: actions.niivueToggleInterpolation,
+      niivueToggleCrosshair: actions.niivueToggleCrosshair
+    },
+    defaultContext: "NIIVUE"
+  };
+}
+
+// src/NiivueViewport.tsx
+import NiiVue, { NVSlide, SLICE_TYPE as SLICE_TYPE2 } from "@niivue/niivue";
+import { loadDefaultFont as loadDefaultFont2 } from "@niivue/uikit";
+import { useEffect, useRef, useState } from "react";
+
+// src/toolBridge.ts
+import { DRAG_MODE } from "@niivue/niivue";
+function ohifToolToAnnotationTool(tool) {
+  switch (tool) {
+    case "Length":
+      return "measureLine";
+    case "EllipticalROI":
+      return "measureEllipse";
+    case "RectangleROI":
+      return "measureRect";
+    case "CircleROI":
+      return "measureCircle";
+    case "PlanarFreehandROI":
+      return "freehand";
+    case "SplineROI":
+      return "measureSpline";
+    case "LivewireContour":
+      return "measureLivewire";
+    case "Bidirectional":
+      return "measureBidirectional";
+    case "ArrowAnnotate":
+      return "arrow";
+    default:
+      return null;
+  }
+}
+var UNSUPPORTED_MEASUREMENT_TOOLS = new Set;
+function ohifToolToDragMode(tool) {
+  switch (tool) {
+    case "WindowLevel":
+      return DRAG_MODE.windowing;
+    case "Pan":
+      return DRAG_MODE.pan;
+    case "Zoom":
+      return DRAG_MODE.slicer3D;
+    case "Angle":
+    case "CobbAngle":
+      return DRAG_MODE.angle;
+    case "RectangleROI":
+    case "EllipticalROI":
+    case "CircleROI":
+      return DRAG_MODE.roiSelection;
+    default:
+      return DRAG_MODE.crosshair;
+  }
+}
+
+// src/volumeAnnotationOverlay.ts
+import {
+  buildAnnotationGeometry,
+  UIKitLineOverlay,
+  UIKitTextOverlay
+} from "@niivue/uikit";
+var LABEL_CSS_PX = 14;
+
+class VolumeAnnotationOverlay {
+  getShapes;
+  lines = new UIKitLineOverlay;
+  labels;
+  lastSig = "";
+  constructor(font, getShapes) {
+    this.getShapes = getShapes;
+    this.labels = new UIKitTextOverlay(font);
+  }
+  drawOverlay(frame) {
+    const dpr = frame.dpr;
+    const shapes = this.getShapes();
+    let sig = `${dpr}`;
+    for (const s of shapes) {
+      sig += `|${s.id};`;
+      for (const p of s.outer)
+        sig += `${p.x | 0},${p.y | 0};`;
+      if (s.start)
+        sig += `s${s.start.x | 0},${s.start.y | 0};`;
+      if (s.end)
+        sig += `e${s.end.x | 0},${s.end.y | 0};`;
+      if (s.start2)
+        sig += `S${s.start2.x | 0},${s.start2.y | 0};`;
+      if (s.end2)
+        sig += `E${s.end2.x | 0},${s.end2.y | 0};`;
+      if (s.label)
+        sig += `t${s.label.lines.join("\x1F")};`;
+    }
+    if (sig !== this.lastSig) {
+      this.lastSig = sig;
+      const geo = buildAnnotationGeometry(shapes, {
+        dpr,
+        labelCssPx: LABEL_CSS_PX
+      });
+      this.lines.setLines(geo.lines);
+      this.labels.setItems(geo.text);
+    }
+    this.lines.drawOverlay(frame);
+    this.labels.drawOverlay(frame);
+  }
+  destroy() {
+    this.lines.destroy();
+    this.labels.destroy();
+  }
+}
+
+// src/wsiSlideView.ts
+import { SlideRenderer } from "@niivue/niivue";
+import { loadDefaultFont, UIKitRulerOverlay } from "@niivue/uikit";
+var RULER_COLOR = [1, 0.85, 0, 1];
+var RULER_LABEL_CSS_PX = 28;
+var RULER_THICKNESS_CSS_PX = 2;
+var RULER_TICK_CSS_PX = 6;
+function measure(a, b, spacing) {
+  const dpx = b.x - a.x;
+  const dpy = b.y - a.y;
+  if (!spacing) {
+    return {
+      length: Math.hypot(dpx, dpy),
+      units: "px",
+      decimals: 0,
+      ticks: false
+    };
+  }
+  const mm = Math.hypot(dpx * spacing[0], dpy * spacing[1]);
+  return mm < 1 ? { length: mm * 1000, units: "um", decimals: 0, ticks: false } : { length: mm, units: "mm", decimals: 2, ticks: true };
+}
+function mountWsiSlideView(canvas, slide, options = {}) {
+  const gl = canvas.getContext("webgl2", {
+    alpha: false,
+    antialias: false,
+    preserveDrawingBuffer: true
+  });
+  if (!gl)
+    throw new Error("WebGL2 is required for the whole-slide viewer");
+  const renderer = new SlideRenderer;
+  renderer.init(gl);
+  let disposed = false;
+  let userInteracted = false;
+  let activeTool = "Pan";
+  let lastFitWidth = 0;
+  let lastFitHeight = 0;
+  let ruler = null;
+  let ruleA = null;
+  let ruleB = null;
+  const onMeasure = options.onMeasure;
+  const screenOf = () => ({
+    widthCss: canvas.clientWidth || 1,
+    heightCss: canvas.clientHeight || 1,
+    devicePixelRatio: window.devicePixelRatio || 1
+  });
+  const slideToDevice = (p, screen) => {
+    const { xCss, yCss } = slide.slideToScreen(p.x, p.y, screen);
+    const dpr = screen.devicePixelRatio ?? 1;
+    return [xCss * dpr, yCss * dpr];
+  };
+  const clearMeasurement = () => {
+    ruleA = null;
+    ruleB = null;
+    ruler?.clear();
+    onMeasure?.(null);
+  };
+  const updateRuler = (screen) => {
+    if (!ruler)
+      return;
+    const a = ruleA;
+    const b = ruleB;
+    if (!a || !b) {
+      ruler.clear();
+      return;
+    }
+    const m = measure(a, b, slide.manifest.pixelSpacingMM);
+    const dpr = screen.devicePixelRatio ?? 1;
+    ruler.setRuler({
+      a: slideToDevice(a, screen),
+      b: slideToDevice(b, screen),
+      length: m.length,
+      units: m.units,
+      decimals: m.decimals,
+      sizePx: RULER_LABEL_CSS_PX * dpr,
+      thickness: RULER_THICKNESS_CSS_PX * dpr,
+      tickLength: RULER_TICK_CSS_PX * dpr,
+      showTicks: m.ticks,
+      showTickNumbers: m.ticks,
+      lineColor: RULER_COLOR,
+      textColor: RULER_COLOR
+    });
+    onMeasure?.(`${m.length.toFixed(m.decimals)} ${m.units}`);
+  };
+  const syncCanvasSize = (screen) => {
+    const dpr = screen.devicePixelRatio ?? 1;
+    const width = Math.max(1, Math.floor(screen.widthCss * dpr));
+    const height = Math.max(1, Math.floor(screen.heightCss * dpr));
+    if (canvas.width !== width)
+      canvas.width = width;
+    if (canvas.height !== height)
+      canvas.height = height;
+  };
+  const render = () => {
+    if (disposed)
+      return;
+    const screen = screenOf();
+    syncCanvasSize(screen);
+    if (!userInteracted && screen.widthCss > 1 && screen.heightCss > 1 && (screen.widthCss !== lastFitWidth || screen.heightCss !== lastFitHeight)) {
+      lastFitWidth = screen.widthCss;
+      lastFitHeight = screen.heightCss;
+      slide.fitToScreen(screen);
+    }
+    slide.clampViewport(screen);
+    updateRuler(screen);
+    renderer.draw(gl, [slide], screen);
+  };
+  let scheduled = false;
+  const flush = () => {
+    if (!scheduled || disposed)
+      return;
+    scheduled = false;
+    render();
+  };
+  const scheduleRender = () => {
+    if (scheduled || disposed)
+      return;
+    scheduled = true;
+    requestAnimationFrame(flush);
+    setTimeout(flush, 100);
+  };
+  loadDefaultFont().then((font) => {
+    if (disposed)
+      return;
+    ruler = new UIKitRulerOverlay(font);
+    renderer.overlayDraw = (frame) => ruler?.drawOverlay(frame);
+    scheduleRender();
+  }).catch((err) => {
+    console.error("[nv-ohif] UIKit ruler font failed to load", err);
+  });
+  const cssPos = (e) => {
+    const rect = canvas.getBoundingClientRect();
+    return [e.clientX - rect.left, e.clientY - rect.top];
+  };
+  const onWheel = (e) => {
+    e.preventDefault();
+    userInteracted = true;
+    const rect = canvas.getBoundingClientRect();
+    const factor = Math.exp(-e.deltaY * 0.001);
+    slide.zoomBy(factor, e.clientX - rect.left, e.clientY - rect.top, screenOf());
+    scheduleRender();
+  };
+  const slidePointAt = (e) => {
+    const [cx, cy] = cssPos(e);
+    return slide.screenToSlide(cx, cy, screenOf());
+  };
+  let dragging = false;
+  let measuring = false;
+  let lastX = 0;
+  let lastY = 0;
+  const onPointerDown = (e) => {
+    canvas.setPointerCapture?.(e.pointerId);
+    if (activeTool === "Length") {
+      measuring = true;
+      const s = slidePointAt(e);
+      ruleA = { x: s.x, y: s.y };
+      ruleB = { x: s.x, y: s.y };
+      scheduleRender();
+      return;
+    }
+    dragging = true;
+    lastX = e.clientX;
+    lastY = e.clientY;
+  };
+  const onPointerMove = (e) => {
+    if (measuring) {
+      ruleB = slidePointAt(e);
+      scheduleRender();
+      return;
+    }
+    if (!dragging)
+      return;
+    userInteracted = true;
+    const dx = e.clientX - lastX;
+    const dy = e.clientY - lastY;
+    lastX = e.clientX;
+    lastY = e.clientY;
+    if (activeTool === "Zoom") {
+      const rect = canvas.getBoundingClientRect();
+      slide.zoomBy(Math.exp(-dy * 0.01), e.clientX - rect.left, e.clientY - rect.top, screenOf());
+    } else {
+      slide.panByScreenDelta(dx, dy, screenOf());
+    }
+    scheduleRender();
+  };
+  const onPointerUp = (e) => {
+    canvas.releasePointerCapture?.(e.pointerId);
+    if (measuring) {
+      measuring = false;
+      ruleB = slidePointAt(e);
+      if (ruleA && ruleB && ruleA.x === ruleB.x && ruleA.y === ruleB.y) {
+        clearMeasurement();
+      }
+      scheduleRender();
+      return;
+    }
+    dragging = false;
+  };
+  canvas.addEventListener("pointerdown", onPointerDown);
+  canvas.addEventListener("pointermove", onPointerMove);
+  canvas.addEventListener("pointerup", onPointerUp);
+  canvas.addEventListener("pointercancel", onPointerUp);
+  canvas.addEventListener("wheel", onWheel, { passive: false });
+  const onChange = () => scheduleRender();
+  slide.addEventListener("change", onChange);
+  const resizeObserver = new ResizeObserver(() => scheduleRender());
+  resizeObserver.observe(canvas);
+  scheduleRender();
+  return {
+    setTool(tool) {
+      if (tool !== "Length")
+        measuring = false;
+      activeTool = tool;
+    },
+    resetView() {
+      userInteracted = false;
+      lastFitWidth = 0;
+      lastFitHeight = 0;
+      clearMeasurement();
+      scheduleRender();
+    },
+    async saveBitmap(filename = "niivue-slide.png") {
+      const blob = await new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
+      if (!blob)
+        return;
+      const url = URL.createObjectURL(blob);
+      const link = document.createElement("a");
+      link.href = url;
+      link.download = filename;
+      link.click();
+      window.setTimeout(() => URL.revokeObjectURL(url), 0);
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      resizeObserver.disconnect();
+      slide.removeEventListener("change", onChange);
+      canvas.removeEventListener("pointerdown", onPointerDown);
+      canvas.removeEventListener("pointermove", onPointerMove);
+      canvas.removeEventListener("pointerup", onPointerUp);
+      canvas.removeEventListener("pointercancel", onPointerUp);
+      canvas.removeEventListener("wheel", onWheel);
+      ruler?.destroy();
+      slide.dispose();
+      renderer.destroy();
+    }
+  };
+}
+
+// src/wsiTileSource.ts
+var JPEG_TRANSFER_SYNTAXES = new Set([
+  "1.2.840.10008.1.2.4.50",
+  "1.2.840.10008.1.2.4.51"
+]);
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function toNum(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string") {
+    const n = Number.parseFloat(value);
+    return Number.isFinite(n) ? n : undefined;
+  }
+  return;
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function first(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function imageTypeString(value) {
+  if (Array.isArray(value)) {
+    const parts = value.filter((v) => typeof v === "string" && v.length > 0);
+    return parts.length > 0 ? parts.join("\\") : undefined;
+  }
+  return str(value);
+}
+function deriveSpacingMM(inst, matrixColumns, matrixRows) {
+  const spacingFrom = (group) => first(first(group)?.PixelMeasuresSequence)?.PixelSpacing;
+  const pixelSpacing = spacingFrom(inst.SharedFunctionalGroupsSequence) ?? spacingFrom(inst.PerFrameFunctionalGroupsSequence) ?? inst.PixelSpacing;
+  if (Array.isArray(pixelSpacing)) {
+    const dy = toNum(pixelSpacing[0]);
+    const dx = toNum(pixelSpacing[1]);
+    if (dx && dy && dx > 0 && dy > 0)
+      return [dx, dy];
+  }
+  const volW = toNum(inst.ImagedVolumeWidth);
+  const volH = toNum(inst.ImagedVolumeHeight);
+  if (volW && volH && matrixColumns > 0 && matrixRows > 0) {
+    return [volW / matrixColumns, volH / matrixRows];
+  }
+  return;
+}
+function isVolumeLevel(inst) {
+  const imageType = imageTypeString(inst.ImageType);
+  if (imageType)
+    return imageType.includes("VOLUME");
+  const matCols = num(inst.TotalPixelMatrixColumns) ?? 0;
+  const tileCols = num(inst.Columns) ?? 0;
+  const matRows = num(inst.TotalPixelMatrixRows) ?? 0;
+  const tileRows = num(inst.Rows) ?? 0;
+  return matCols > tileCols || matRows > tileRows;
+}
+function wsiVolumeLevels(ds) {
+  const instances2 = ds.instances ?? [];
+  const imageIds = ds.imageIds ?? [];
+  const positionalSafe = imageIds.length === instances2.length;
+  const levels = [];
+  instances2.forEach((inst, i) => {
+    const instImageId = inst.imageId;
+    const imageId = typeof instImageId === "string" ? instImageId : positionalSafe ? imageIds[i] : undefined;
+    const matrixColumns = num(inst.TotalPixelMatrixColumns);
+    const matrixRows = num(inst.TotalPixelMatrixRows);
+    const tileColumns = num(inst.Columns);
+    const tileRows = num(inst.Rows);
+    if (!imageId || !matrixColumns || !matrixRows || !tileColumns || !tileRows || !isVolumeLevel(inst))
+      return;
+    const noScheme = imageId.replace(/^(wadors|dicomweb|wadouri):/i, "");
+    const qIdx = noScheme.indexOf("?");
+    const frameQuery = qIdx >= 0 ? noScheme.slice(qIdx) : "";
+    const frameBaseUrl = (qIdx >= 0 ? noScheme.slice(0, qIdx) : noScheme).replace(/\/\d+$/, "");
+    const transferSyntax = str(inst.TransferSyntaxUID) ?? str(inst.AvailableTransferSyntaxUID);
+    levels.push({
+      matrixColumns,
+      matrixRows,
+      tileColumns,
+      tileRows,
+      frameBaseUrl,
+      frameQuery,
+      isJpeg: transferSyntax ? JPEG_TRANSFER_SYNTAXES.has(transferSyntax) : true,
+      spacingMM: deriveSpacingMM(inst, matrixColumns, matrixRows),
+      tiledFull: (() => {
+        let v = inst.DimensionOrganizationType;
+        while (Array.isArray(v))
+          v = v[0];
+        const org = str(v);
+        return org === undefined || org.toUpperCase() === "TILED_FULL";
+      })()
+    });
+  });
+  return levels.sort((a, b) => b.matrixColumns * b.matrixRows - a.matrixColumns * a.matrixRows);
+}
+function levelTiles(level) {
+  const columns = Math.ceil(level.matrixColumns / level.tileColumns);
+  const rows = Math.ceil(level.matrixRows / level.tileRows);
+  const tiles = [];
+  for (let row = 0;row < rows; row++) {
+    for (let col = 0;col < columns; col++) {
+      const pixelX = col * level.tileColumns;
+      const pixelY = row * level.tileRows;
+      tiles.push({
+        x: col,
+        y: row,
+        width: Math.min(level.tileColumns, level.matrixColumns - pixelX),
+        height: Math.min(level.tileRows, level.matrixRows - pixelY),
+        frame: row * columns + col + 1
+      });
+    }
+  }
+  return { columns, rows, tiles };
+}
+function buildWsiManifest(ds) {
+  const volumeLevels = wsiVolumeLevels(ds);
+  if (volumeLevels.length === 0)
+    return null;
+  const level0 = volumeLevels[0];
+  if (!level0)
+    return null;
+  const levels = [];
+  const levelBaseUrls = [];
+  const levelQueries = [];
+  let allJpeg = true;
+  let tiledFull = true;
+  volumeLevels.forEach((level, index) => {
+    const { columns, rows, tiles } = levelTiles(level);
+    levels.push({
+      index,
+      width: level.matrixColumns,
+      height: level.matrixRows,
+      downsample: level0.matrixColumns / level.matrixColumns,
+      tileWidth: level.tileColumns,
+      tileHeight: level.tileRows,
+      columns,
+      rows,
+      codec: level.isJpeg ? "image/jpeg" : "image/jp2",
+      tiles
+    });
+    levelBaseUrls[index] = level.frameBaseUrl;
+    levelQueries[index] = level.frameQuery;
+    if (!level.isJpeg)
+      allJpeg = false;
+    if (!level.tiledFull)
+      tiledFull = false;
+  });
+  const manifest = {
+    id: str(ds.displaySetInstanceUID) ?? "wsi",
+    name: str(ds.SeriesDescription) ?? "Whole-slide image",
+    format: "dicom-wsi-ohif",
+    width: level0.matrixColumns,
+    height: level0.matrixRows,
+    displayYAxis: "up",
+    tileSize: level0.tileColumns,
+    dtype: "uint8",
+    channels: "encoded-rgb",
+    ...level0.spacingMM ? { pixelSpacingMM: level0.spacingMM } : {},
+    levels
+  };
+  return { manifest, levelBaseUrls, levelQueries, allJpeg, tiledFull };
+}
+
+class DicomWsiTileSource {
+  manifest;
+  levelBaseUrls;
+  levelQueries;
+  headers;
+  constructor(built, headers = {}) {
+    this.manifest = built.manifest;
+    this.levelBaseUrls = built.levelBaseUrls;
+    this.levelQueries = built.levelQueries;
+    this.headers = headers;
+  }
+  bind(_host) {}
+  async fetchTileBytes(level, tile) {
+    const base = this.levelBaseUrls[level.index];
+    if (!base)
+      throw new Error(`no frame URL for WSI level ${level.index}`);
+    if (tile.frame === undefined)
+      throw new Error("WSI tile has no frame number");
+    const query = this.levelQueries[level.index] ?? "";
+    const response = await fetch(`${base}/${tile.frame}${query}`, {
+      headers: {
+        Accept: 'multipart/related; type="image/jpeg"',
+        ...this.headers
+      }
+    });
+    if (!response.ok)
+      throw new Error(`WSI tile HTTP ${response.status}`);
+    const contentType = response.headers.get("content-type") ?? "";
+    const body = new Uint8Array(await response.arrayBuffer());
+    const parts = parseMultipartRelated(body, contentType);
+    const jpeg = parts[0];
+    if (!jpeg || jpeg.length === 0)
+      throw new Error("empty WSI tile body");
+    return jpeg;
+  }
+}
+
+// src/NiivueViewport.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+var DEFAULT_OPTIONS = {
+  backgroundColor: [0, 0, 0, 1],
+  backend: "webgl2",
+  annotationMergesOverlaps: false
+};
+function NiivueViewport(props) {
+  const { displaySets, viewportId, servicesManager, commandsManager } = props;
+  const containerRef = useRef(null);
+  const nvRef = useRef(null);
+  const slideViewRef = useRef(null);
+  const activeOhifToolRef = useRef(undefined);
+  const [ready, setReady] = useState(false);
+  const [status, setStatus] = useState({ kind: "idle" });
+  const displaySetsRef = useRef(displaySets);
+  displaySetsRef.current = displaySets;
+  const servicesManagerRef = useRef(servicesManager);
+  servicesManagerRef.current = servicesManager;
+  const commandsManagerRef = useRef(commandsManager);
+  commandsManagerRef.current = commandsManager;
+  const displaySetsKey = displaySets.map((ds) => String(ds.displaySetInstanceUID ?? ds.SeriesInstanceUID ?? "")).join("|");
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container)
+      return;
+    let disposed = false;
+    let annotationOverlay = null;
+    let unregisterAnnotation = null;
+    const canvas = document.createElement("canvas");
+    canvas.style.cssText = "position:absolute;top:0;left:0;width:100%;height:100%";
+    container.appendChild(canvas);
+    const nv = new NiiVue(DEFAULT_OPTIONS);
+    nvRef.current = nv;
+    nv.attachToCanvas(canvas).then(() => {
+      if (disposed)
+        return;
+      nv.sliceType = SLICE_TYPE2.MULTIPLANAR;
+      loadDefaultFont2().then((font) => {
+        if (disposed)
+          return;
+        annotationOverlay = new VolumeAnnotationOverlay(font, () => visibleAnnotationScreenShapes(viewportId, nv.annotationScreenShapes));
+        unregisterAnnotation = nv.registerOverlayRenderer(annotationOverlay);
+        nv.isAnnotationDrawn = false;
+      }).catch((err) => console.error("[nv-ohif] annotation font failed to load", err));
+      registerNiivue(viewportId, nv);
+      updateNiivueViewport(viewportId, {
+        setStatus: (message) => setStatus(message === null ? { kind: "idle" } : {
+          kind: /failed/i.test(message) ? "error" : /\.\.\./.test(message) ? "loading" : "note",
+          message
+        })
+      });
+      refreshToolbar(servicesManagerRef.current, viewportId);
+      setReady(true);
+    });
+    const ro = new ResizeObserver(() => nv.resize());
+    ro.observe(container);
+    const onPointerUp = () => {
+      const wl = syncNiivueWindowLevelToOhif(viewportId, servicesManagerRef.current, commandsManagerRef.current);
+      if (!wl)
+        return;
+      const message = `W: ${Math.round(wl.window)}  L: ${Math.round(wl.level)}`;
+      setStatus({ kind: "note", message });
+      window.setTimeout(() => setStatus((s) => s.kind === "note" && s.message === message ? { kind: "idle" } : s), 2000);
+    };
+    canvas.addEventListener("pointerup", onPointerUp);
+    const onAnnotationAdded = (e) => {
+      const annotation = e.detail?.annotation;
+      if (!annotation)
+        return;
+      if (applyDefaultAnnotationText(annotation, nv.annotations))
+        nv.drawScene();
+      const stored = nv.annotations.find((a) => a.id === annotation.id) ?? annotation;
+      const added = reflectNiivueAnnotation(viewportId, servicesManagerRef.current, stored);
+      const stats = stored.stats;
+      if (!added || !stats)
+        return;
+      const message = stats.length !== undefined ? `Length: ${stats.length.toFixed(1)} mm` : `Area: ${stats.area.toFixed(1)} mm²`;
+      setStatus({ kind: "note", message });
+      window.setTimeout(() => setStatus((s) => s.kind === "note" && s.message === message ? { kind: "idle" } : s), 2000);
+    };
+    const onAnnotationRemoved = (e) => {
+      const id = e.detail?.id;
+      if (id)
+        removeNiivueAnnotation(viewportId, servicesManagerRef.current, id);
+    };
+    const onAnnotationChanged = (e) => {
+      const action = e.detail?.action;
+      if (!action)
+        return;
+      reconcileNiivueAnnotations(viewportId, servicesManagerRef.current);
+    };
+    nv.addEventListener("annotationAdded", onAnnotationAdded);
+    nv.addEventListener("annotationRemoved", onAnnotationRemoved);
+    nv.addEventListener("annotationChanged", onAnnotationChanged);
+    const unsubscribeLabelSync = subscribeOhifLabelSync(servicesManagerRef.current);
+    return () => {
+      disposed = true;
+      setReady(false);
+      clearNiivueAnnotations(viewportId, servicesManagerRef.current);
+      unregisterNiivue(viewportId);
+      refreshToolbar(servicesManagerRef.current, viewportId);
+      canvas.removeEventListener("pointerup", onPointerUp);
+      nv.removeEventListener("annotationAdded", onAnnotationAdded);
+      nv.removeEventListener("annotationRemoved", onAnnotationRemoved);
+      nv.removeEventListener("annotationChanged", onAnnotationChanged);
+      unsubscribeLabelSync?.();
+      unregisterAnnotation?.();
+      annotationOverlay?.destroy();
+      ro.disconnect();
+      nv.destroy();
+      canvas.width = 0;
+      canvas.height = 0;
+      canvas.remove();
+      nvRef.current = null;
+    };
+  }, [viewportId]);
+  useEffect(() => {
+    const nv = nvRef.current;
+    const displaySets2 = displaySetsRef.current;
+    const servicesManager2 = servicesManagerRef.current;
+    if (!nv || !ready)
+      return;
+    nv.clearAnnotations();
+    updateNiivueViewport(viewportId, {
+      displaySets: displaySets2,
+      overlayUIDs: [],
+      overlayLoading: false
+    });
+    refreshToolbar(servicesManager2, viewportId);
+    const dropStaleVolumes = () => {
+      if (nv.volumes.length > 0)
+        nv.removeAllVolumes().catch(() => {});
+    };
+    if (displaySets2.length === 0) {
+      dropStaleVolumes();
+      setStatus({ kind: "idle" });
+      return;
+    }
+    let cancelled = false;
+    const abort = new AbortController;
+    const seedWindowLevel = () => {
+      if (cancelled)
+        return;
+      updateNiivueViewport(viewportId, { windowLevel: readBaseWindowLevel(nv) });
+      reconcileNiivueAnnotations(viewportId, servicesManagerRef.current);
+      refreshToolbar(servicesManagerRef.current, viewportId);
+    };
+    const directSpecs = displaySets2.map((ds2) => displaySetToNiivue(ds2)).filter((s) => s !== null);
+    if (directSpecs.length > 0) {
+      setStatus({ kind: "idle" });
+      nv.loadVolumes(directSpecs).then(() => {
+        if (cancelled) {
+          nv.removeAllVolumes().catch(() => {});
+          return;
+        }
+        seedWindowLevel();
+      }, () => {
+        if (!cancelled)
+          setStatus({ kind: "error", message: "Failed to load volume." });
+      });
+      return () => {
+        cancelled = true;
+      };
+    }
+    const ds = displaySets2[0];
+    if (!ds) {
+      dropStaleVolumes();
+      setStatus({ kind: "idle" });
+      return;
+    }
+    const kind = classifyDisplaySet(ds);
+    if (kind === "wsi") {
+      dropStaleVolumes();
+      const built = buildWsiManifest(ds);
+      if (!built) {
+        setStatus({
+          kind: "note",
+          message: "This slide has no tiled (VOLUME) pyramid levels to display."
+        });
+        return;
+      }
+      if (!built.allJpeg) {
+        setStatus({
+          kind: "note",
+          message: "This slide is JPEG 2000, which the viewer cannot decode yet (JPEG slides are supported)."
+        });
+        return;
+      }
+      if (!built.tiledFull) {
+        setStatus({
+          kind: "note",
+          message: "This slide uses TILED_SPARSE frame organization, which the viewer cannot render yet (TILED_FULL slides are supported)."
+        });
+        return;
+      }
+      const container = containerRef.current;
+      if (!container)
+        return;
+      const slideCanvas = document.createElement("canvas");
+      slideCanvas.style.cssText = "position:absolute;top:0;left:0;width:100%;height:100%;touch-action:none";
+      container.appendChild(slideCanvas);
+      const source = new DicomWsiTileSource(built, authHeaders(servicesManager2));
+      const slide = NVSlide.fromSource(source);
+      let view = null;
+      try {
+        view = mountWsiSlideView(slideCanvas, slide);
+        slideViewRef.current = view;
+        view.setTool(activeOhifToolRef.current);
+        updateNiivueViewport(viewportId, { slideView: view });
+        refreshToolbar(servicesManager2, viewportId);
+        setStatus({ kind: "idle" });
+      } catch (err) {
+        slideCanvas.remove();
+        console.error("[nv-ohif] WSI view failed", err);
+        setStatus({
+          kind: "error",
+          message: "Failed to start the whole-slide viewer."
+        });
+        return;
+      }
+      return () => {
+        cancelled = true;
+        updateNiivueViewport(viewportId, { slideView: undefined });
+        slideViewRef.current = null;
+        view?.dispose();
+        slideCanvas.width = 0;
+        slideCanvas.height = 0;
+        slideCanvas.remove();
+      };
+    }
+    if (kind === "unsupported") {
+      dropStaleVolumes();
+      setStatus({
+        kind: "note",
+        message: "This series isn't something NiiVue can load yet."
+      });
+      return;
+    }
+    setStatus({ kind: "loading", message: "Fetching DICOM series..." });
+    convertDisplaySetToNifti(ds, {
+      headers: authHeaders(servicesManager2),
+      signal: abort.signal,
+      onProgress: (phase, loaded, total) => {
+        if (cancelled)
+          return;
+        setStatus({
+          kind: "loading",
+          message: phase === "fetching" ? `Fetching DICOM series... ${loaded}/${total}` : "Converting DICOM to NIfTI (dcm2niix)..."
+        });
+      }
+    }).then((niftiFile) => {
+      if (cancelled)
+        return;
+      if (!niftiFile) {
+        setStatus({
+          kind: "error",
+          message: "DICOM conversion produced no volume."
+        });
+        return;
+      }
+      setStatus({ kind: "idle" });
+      return nv.loadVolumes([{ url: niftiFile, name: niftiFile.name }]).then(() => {
+        if (cancelled) {
+          nv.removeAllVolumes().catch(() => {});
+          return;
+        }
+        seedWindowLevel();
+      });
+    }).catch((err) => {
+      if (cancelled || abort.signal.aborted)
+        return;
+      console.error("[nv-ohif] DICOM load failed", err);
+      const message = err instanceof Error ? err.message : String(err);
+      setStatus({
+        kind: "error",
+        message: `DICOM load failed: ${message || "unknown error"}`
+      });
+    });
+    return () => {
+      cancelled = true;
+      abort.abort();
+    };
+  }, [displaySetsKey, ready]);
+  useEffect(() => {
+    const nv = nvRef.current;
+    if (!nv || !ready)
+      return;
+    const svc = ohifServices(servicesManager)?.toolGroupService;
+    if (!svc?.getActivePrimaryMouseButtonTool)
+      return;
+    const apply = () => {
+      const tool = svc.getActivePrimaryMouseButtonTool?.("default");
+      activeOhifToolRef.current = tool;
+      const annoTool = ohifToolToAnnotationTool(tool);
+      if (annoTool) {
+        nv.annotationTool = annoTool;
+        nv.annotationIsEnabled = true;
+      } else {
+        nv.annotationIsEnabled = false;
+        nv.primaryDragMode = ohifToolToDragMode(tool);
+        if (tool && UNSUPPORTED_MEASUREMENT_TOOLS.has(tool)) {
+          const message = `${tool} is not supported in NiiVue`;
+          setStatus({ kind: "note", message });
+          window.setTimeout(() => setStatus((s) => s.kind === "note" && s.message === message ? { kind: "idle" } : s), 2500);
+        }
+      }
+      slideViewRef.current?.setTool(tool);
+    };
+    apply();
+    const event = svc.EVENTS?.PRIMARY_TOOL_ACTIVATED;
+    const sub = event ? svc.subscribe?.(event, apply) : undefined;
+    return () => sub?.unsubscribe?.();
+  }, [ready, servicesManager]);
+  const overlay = status.kind === "idle" ? null : status.message;
+  return /* @__PURE__ */ jsxDEV("div", {
+    "data-viewport-id": viewportId,
+    style: { position: "relative", width: "100%", height: "100%" },
+    children: [
+      /* @__PURE__ */ jsxDEV("div", {
+        ref: containerRef,
+        style: { position: "absolute", inset: 0 }
+      }, undefined, false, undefined, this),
+      overlay ? /* @__PURE__ */ jsxDEV("div", {
+        style: {
+          position: "absolute",
+          inset: 0,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          color: status.kind === "error" ? "#e88" : "#9aa",
+          font: "14px sans-serif",
+          textAlign: "center",
+          padding: "1rem",
+          pointerEvents: "none"
+        },
+        children: overlay
+      }, undefined, false, undefined, this) : null
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/getNiivueViewportModule.tsx
+var NIIVUE_VIEWPORT_NAME = "niivue";
+function getNiivueViewportModule() {
+  return [{ name: NIIVUE_VIEWPORT_NAME, component: NiivueViewport }];
+}
+
+// src/wsiThumbnail.ts
+function frameCount(inst) {
+  const n = Number(inst.NumberOfFrames);
+  return Number.isFinite(n) && n > 0 ? n : 1;
+}
+function flavorRank(inst) {
+  const it = imageTypeString(inst.ImageType) ?? "";
+  if (it.includes("OVERVIEW"))
+    return 0;
+  if (it.includes("THUMBNAIL"))
+    return 1;
+  if (it.includes("LABEL"))
+    return 3;
+  return 2;
+}
+function pickThumbnailInstance(instances2) {
+  const eligible = instances2.filter((inst) => typeof inst.imageId === "string");
+  if (eligible.length === 0)
+    return;
+  return eligible.reduce((best, inst) => {
+    const r = flavorRank(inst);
+    const rBest = flavorRank(best);
+    if (r !== rBest)
+      return r < rBest ? inst : best;
+    return frameCount(inst) < frameCount(best) ? inst : best;
+  });
+}
+function frameEncoding(bytes) {
+  if (bytes[0] === 255 && bytes[1] === 216)
+    return "jpeg";
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78)
+    return "png";
+  return "raw";
+}
+var MAX_THUMBNAIL_FETCH_BYTES = 32 * 1024 * 1024;
+var MAX_THUMBNAIL_DECODE_PIXELS = 16 * 1024 * 1024;
+function rawImageInfo(inst, byteLength) {
+  const width = Number(inst.Columns);
+  const height = Number(inst.Rows);
+  const channels = Number(inst.SamplesPerPixel);
+  if (!Number.isFinite(width) || !Number.isFinite(height))
+    return null;
+  if (width * height > MAX_THUMBNAIL_DECODE_PIXELS)
+    return null;
+  if (channels !== 1 && channels !== 3)
+    return null;
+  const photometric = typeof inst.PhotometricInterpretation === "string" ? inst.PhotometricInterpretation : "";
+  if (channels === 3 && photometric && !photometric.startsWith("RGB"))
+    return null;
+  if (width * height * channels !== byteLength)
+    return null;
+  return { width, height, channels };
+}
+var MAX_THUMBNAIL_EDGE = 256;
+function rawFrameToDataUrl(raw, info) {
+  if (typeof document === "undefined")
+    return null;
+  const { width, height, channels } = info;
+  const full = document.createElement("canvas");
+  full.width = width;
+  full.height = height;
+  const fctx = full.getContext("2d");
+  if (!fctx)
+    return null;
+  const image = fctx.createImageData(width, height);
+  const out = image.data;
+  if (channels === 3) {
+    for (let px = 0, s = 0, d = 0;px < width * height; px++) {
+      out[d++] = raw[s++] ?? 0;
+      out[d++] = raw[s++] ?? 0;
+      out[d++] = raw[s++] ?? 0;
+      out[d++] = 255;
+    }
+  } else {
+    for (let px = 0, d = 0;px < width * height; px++) {
+      const v = raw[px] ?? 0;
+      out[d++] = v;
+      out[d++] = v;
+      out[d++] = v;
+      out[d++] = 255;
+    }
+  }
+  fctx.putImageData(image, 0, 0);
+  const scale = Math.min(1, MAX_THUMBNAIL_EDGE / Math.max(width, height));
+  if (scale === 1)
+    return full.toDataURL("image/png");
+  const small = document.createElement("canvas");
+  small.width = Math.max(1, Math.round(width * scale));
+  small.height = Math.max(1, Math.round(height * scale));
+  const sctx = small.getContext("2d");
+  if (!sctx)
+    return full.toDataURL("image/png");
+  sctx.drawImage(full, 0, 0, small.width, small.height);
+  return small.toDataURL("image/jpeg", 0.85);
+}
+function bytesToDataUrl(bytes, mime) {
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0;i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return `data:${mime};base64,${btoa(binary)}`;
+}
+async function encodedFrameToThumbnailUrl(frame, mime) {
+  if (typeof document === "undefined")
+    return null;
+  if (typeof createImageBitmap !== "function")
+    return null;
+  let bitmap = null;
+  try {
+    bitmap = await createImageBitmap(new Blob([new Uint8Array(frame)], { type: mime }));
+    const scale = Math.min(1, MAX_THUMBNAIL_EDGE / Math.max(bitmap.width, bitmap.height));
+    const canvas = document.createElement("canvas");
+    canvas.width = Math.max(1, Math.round(bitmap.width * scale));
+    canvas.height = Math.max(1, Math.round(bitmap.height * scale));
+    const ctx = canvas.getContext("2d");
+    if (!ctx)
+      return null;
+    ctx.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
+    return canvas.toDataURL("image/jpeg", 0.85);
+  } catch {
+    return null;
+  } finally {
+    bitmap?.close();
+  }
+}
+async function fetchWsiThumbnailObjectUrl(instances2, headers = {}, signal) {
+  const inst = pickThumbnailInstance(instances2);
+  if (!inst)
+    return null;
+  const imageId = inst.imageId;
+  if (typeof imageId !== "string")
+    return null;
+  const url = imageId.replace(/^(wadors|dicomweb|wadouri):/i, "");
+  if (!/^https?:\/\//i.test(url))
+    return null;
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: 'multipart/related; type="image/jpeg"', ...headers },
+      signal
+    });
+    if (!response.ok)
+      return null;
+    const advertised = Number(response.headers.get("content-length"));
+    if (Number.isFinite(advertised) && advertised > MAX_THUMBNAIL_FETCH_BYTES) {
+      return null;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    const body = new Uint8Array(await response.arrayBuffer());
+    if (body.byteLength > MAX_THUMBNAIL_FETCH_BYTES)
+      return null;
+    const frame = parseMultipartRelated(body, contentType)[0];
+    if (!frame || frame.length === 0)
+      return null;
+    const encoding = frameEncoding(frame);
+    if (encoding !== "raw") {
+      const mime = `image/${encoding}`;
+      const scaled = await encodedFrameToThumbnailUrl(frame, mime);
+      if (scaled)
+        return scaled;
+      return bytesToDataUrl(frame, mime);
+    }
+    const info = rawImageInfo(inst, frame.length);
+    if (!info)
+      return null;
+    return rawFrameToDataUrl(frame, info);
+  } catch {
+    return null;
+  }
+}
+
+// src/sopClassHandler.ts
+var NIIVUE_SOP_CLASS_HANDLER_NAME = "niivue-wsi";
+var NIIVUE_SOP_CLASS_HANDLER_ID = "@niivue/nv-ohif.sopClassHandlerModule.niivue-wsi";
+var VL_WHOLE_SLIDE_MICROSCOPY_IMAGE_STORAGE = "1.2.840.10008.5.1.4.1.1.77.1.6";
+function getNiivueSopClassHandlerModule() {
+  return [
+    {
+      name: NIIVUE_SOP_CLASS_HANDLER_NAME,
+      sopClassUids: [VL_WHOLE_SLIDE_MICROSCOPY_IMAGE_STORAGE],
+      getDisplaySetsFromSeries: (instances2) => {
+        if (!instances2 || instances2.length === 0)
+          return [];
+        const first2 = instances2[0];
+        const seriesUID = String(first2.SeriesInstanceUID ?? "");
+        const imageIds = instances2.map((inst) => inst.imageId).filter((id) => typeof id === "string");
+        const description = String(first2.SeriesDescription ?? "Whole-slide image");
+        const displaySet = {
+          displaySetInstanceUID: `${seriesUID}-niivue-wsi`,
+          SOPClassHandlerId: NIIVUE_SOP_CLASS_HANDLER_ID,
+          Modality: "SM",
+          SeriesInstanceUID: seriesUID,
+          StudyInstanceUID: String(first2.StudyInstanceUID ?? ""),
+          SeriesDescription: description,
+          SeriesNumber: first2.SeriesNumber,
+          SOPClassUID: first2.SOPClassUID,
+          numImageFrames: 0,
+          numInstances: instances2.length,
+          instances: instances2,
+          imageIds,
+          getThumbnailSrc: (options) => fetchWsiThumbnailObjectUrl(instances2, authHeaders(undefined), options?.signal),
+          label: description
+        };
+        return [displaySet];
+      }
+    }
+  ];
+}
+
+// src/toolbar.ts
+var NIIVUE_VIEWS_SECTION = "NiivueViews";
+var NIIVUE_CLIP_SECTION = "NiivueClip";
+var NIIVUE_WL_SECTION = "NiivueWindowLevel";
+var NIIVUE_COLORMAP_SECTION = "NiivueColormap";
+var NIIVUE_RESET_BUTTON = "NiivueReset";
+var NIIVUE_OVERLAY_BUTTON = "NiivueOverlay";
+var NIIVUE_COLORBAR_BUTTON = "NiivueColorbar";
+var NIIVUE_INTERPOLATION_BUTTON = "NiivueInterpolation";
+var NIIVUE_RULER_BUTTON = "NiivueRuler";
+var NIIVUE_CAPTURE_BUTTON = "NiivueCapture";
+var NIIVUE_CROSSHAIR_BUTTON = "NiivueCrosshair";
+var SLICE_TYPE_EVALUATOR = "evaluate.niivue.sliceType";
+var CLIP_PLANE_EVALUATOR = "evaluate.niivue.clipPlane";
+var OVERLAY_EVALUATOR = "evaluate.niivue.overlay";
+var WL_PRESET_EVALUATOR = "evaluate.niivue.windowLevelPreset";
+var COLORMAP_EVALUATOR = "evaluate.niivue.colormap";
+var COLORBAR_EVALUATOR = "evaluate.niivue.colorbar";
+var INTERPOLATION_EVALUATOR = "evaluate.niivue.interpolation";
+var CROSSHAIR_EVALUATOR = "evaluate.niivue.crosshair";
+var MEASUREMENT_EVALUATOR = "evaluate.niivue.measurement";
+var NIIVUE_EVALUATOR = "evaluate.niivue";
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var colormapButtonId = (name) => `NiivueCmap${capitalize(name)}`;
+function sliceTypeButton(id, sliceType, icon, label) {
+  return {
+    id,
+    uiType: "ohif.toolButton",
+    props: {
+      icon,
+      label,
+      tooltip: `${label} (NiiVue)`,
+      commands: {
+        commandName: "niivueSetSliceType",
+        commandOptions: { sliceType }
+      },
+      evaluate: SLICE_TYPE_EVALUATOR
+    }
+  };
+}
+function clipPlaneButton(id, plane, icon, label) {
+  return {
+    id,
+    uiType: "ohif.toolButton",
+    props: {
+      icon,
+      label,
+      tooltip: `${label} (NiiVue clip plane)`,
+      commands: {
+        commandName: "niivueSetClipPlane",
+        commandOptions: { plane }
+      },
+      evaluate: CLIP_PLANE_EVALUATOR
+    }
+  };
+}
+function wlPresetButton(id, modality, presetId, presetIndex, label) {
+  return {
+    id,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "tool-window-level",
+      label,
+      tooltip: `${label} window (${modality}, NiiVue)`,
+      commands: {
+        commandName: "niivueSetWindowLevelPreset",
+        commandOptions: { modality, presetId, presetIndex }
+      },
+      evaluate: WL_PRESET_EVALUATOR
+    }
+  };
+}
+function colormapButton(name, label) {
+  return {
+    id: colormapButtonId(name),
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "icon-color-lut",
+      label,
+      tooltip: `${label} colormap (NiiVue)`,
+      commands: {
+        commandName: "niivueSetColormap",
+        commandOptions: { colormap: name }
+      },
+      evaluate: COLORMAP_EVALUATOR
+    }
+  };
+}
+var NIIVUE_TOOLBAR_BUTTONS = [
+  {
+    id: NIIVUE_VIEWS_SECTION,
+    uiType: "ohif.toolButtonList",
+    props: { buttonSection: true }
+  },
+  sliceTypeButton("NiivueMultiplanar", "multiplanar", "icon-mpr", "Multiplanar"),
+  sliceTypeButton("NiivueAxial", "axial", "OrientationSwitchA", "Axial"),
+  sliceTypeButton("NiivueCoronal", "coronal", "OrientationSwitchC", "Coronal"),
+  sliceTypeButton("NiivueSagittal", "sagittal", "OrientationSwitchS", "Sagittal"),
+  sliceTypeButton("NiivueRender", "render", "tool-3d-rotate", "3D Render"),
+  {
+    id: NIIVUE_CLIP_SECTION,
+    uiType: "ohif.toolButtonList",
+    props: { buttonSection: true }
+  },
+  clipPlaneButton("NiivueClipNone", "none", "icon-clear", "No Clip"),
+  clipPlaneButton("NiivueClipRight", "right", "OrientationSwitchS", "Clip Right"),
+  clipPlaneButton("NiivueClipLeft", "left", "OrientationSwitchS", "Clip Left"),
+  clipPlaneButton("NiivueClipAnterior", "anterior", "OrientationSwitchC", "Clip Anterior"),
+  clipPlaneButton("NiivueClipPosterior", "posterior", "OrientationSwitchC", "Clip Posterior"),
+  clipPlaneButton("NiivueClipSuperior", "superior", "OrientationSwitchA", "Clip Superior"),
+  clipPlaneButton("NiivueClipInferior", "inferior", "OrientationSwitchA", "Clip Inferior"),
+  {
+    id: NIIVUE_WL_SECTION,
+    uiType: "ohif.toolButtonList",
+    props: { buttonSection: true }
+  },
+  {
+    id: "NiivueWLAuto",
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "tool-window-level",
+      label: "Auto Window",
+      tooltip: "Auto window/level (robust 2-98%, NiiVue)",
+      commands: "niivueAutoWindowLevel",
+      evaluate: NIIVUE_EVALUATOR
+    }
+  },
+  wlPresetButton("NiivueWLCtSoft", "CT", "ct-soft-tissue", 0, "Soft Tissue"),
+  wlPresetButton("NiivueWLCtLung", "CT", "ct-lung", 1, "Lung"),
+  wlPresetButton("NiivueWLCtLiver", "CT", "ct-liver", 2, "Liver"),
+  wlPresetButton("NiivueWLCtBone", "CT", "ct-bone", 3, "Bone"),
+  wlPresetButton("NiivueWLCtBrain", "CT", "ct-brain", 4, "Brain"),
+  wlPresetButton("NiivueWLPtDefault", "PT", "pt-default", 0, "PET Default"),
+  wlPresetButton("NiivueWLPtSuv5", "PT", "pt-suv-5", 1, "SUV 5"),
+  wlPresetButton("NiivueWLPtSuv10", "PT", "pt-suv-10", 2, "SUV 10"),
+  {
+    id: NIIVUE_COLORMAP_SECTION,
+    uiType: "ohif.toolButtonList",
+    props: { buttonSection: true }
+  },
+  ...NIIVUE_COLORMAPS.map((c) => colormapButton(c.name, c.label)),
+  {
+    id: NIIVUE_COLORBAR_BUTTON,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "icon-color-lut",
+      label: "Colorbar",
+      tooltip: "Toggle the colormap legend (NiiVue)",
+      commands: "niivueToggleColorbar",
+      evaluate: COLORBAR_EVALUATOR
+    }
+  },
+  {
+    id: NIIVUE_INTERPOLATION_BUTTON,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "icon-tool-interpolation",
+      label: "Smoothing",
+      tooltip: "Toggle nearest-neighbor vs smooth interpolation (NiiVue)",
+      commands: "niivueToggleInterpolation",
+      evaluate: INTERPOLATION_EVALUATOR
+    }
+  },
+  {
+    id: NIIVUE_RULER_BUTTON,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "tool-length",
+      label: "Ruler",
+      tooltip: "Ruler: drag to measure; length appears in Measurements (NiiVue)",
+      commands: "niivueSetMeasurementMode",
+      evaluate: MEASUREMENT_EVALUATOR
+    }
+  },
+  {
+    id: NIIVUE_OVERLAY_BUTTON,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "toggle-dicom-overlay",
+      label: "Overlay",
+      tooltip: "Toggle a colormapped overlay of the next series in this study (NiiVue)",
+      commands: "niivueToggleOverlay",
+      evaluate: OVERLAY_EVALUATOR
+    }
+  },
+  {
+    id: NIIVUE_CROSSHAIR_BUTTON,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "tool-crosshair",
+      label: "Crosshairs",
+      tooltip: "Toggle the crosshair on/off (NiiVue)",
+      commands: "niivueToggleCrosshair",
+      evaluate: CROSSHAIR_EVALUATOR
+    }
+  },
+  {
+    id: NIIVUE_CAPTURE_BUTTON,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "tool-capture",
+      label: "Capture",
+      tooltip: "Download the NiiVue viewport as PNG",
+      commands: "niivueSaveBitmap",
+      evaluate: NIIVUE_EVALUATOR
+    }
+  },
+  {
+    id: NIIVUE_RESET_BUTTON,
+    uiType: "ohif.toolButton",
+    props: {
+      icon: "tool-reset",
+      label: "Reset View",
+      tooltip: "Reset View (NiiVue)",
+      commands: "niivueResetView",
+      evaluate: NIIVUE_EVALUATOR
+    }
+  }
+];
+var NIIVUE_TOOLBAR_SECTIONS = {
+  [NIIVUE_VIEWS_SECTION]: [
+    "NiivueMultiplanar",
+    "NiivueAxial",
+    "NiivueCoronal",
+    "NiivueSagittal",
+    "NiivueRender"
+  ],
+  [NIIVUE_CLIP_SECTION]: [
+    "NiivueClipNone",
+    "NiivueClipRight",
+    "NiivueClipLeft",
+    "NiivueClipAnterior",
+    "NiivueClipPosterior",
+    "NiivueClipSuperior",
+    "NiivueClipInferior"
+  ],
+  [NIIVUE_WL_SECTION]: [
+    "NiivueWLAuto",
+    "NiivueWLCtSoft",
+    "NiivueWLCtLung",
+    "NiivueWLCtLiver",
+    "NiivueWLCtBone",
+    "NiivueWLCtBrain",
+    "NiivueWLPtDefault",
+    "NiivueWLPtSuv5",
+    "NiivueWLPtSuv10"
+  ],
+  [NIIVUE_COLORMAP_SECTION]: NIIVUE_COLORMAPS.map((c) => colormapButtonId(c.name))
+};
+var niivueToolbarCustomization = {
+  "niivue.toolbarButtons": NIIVUE_TOOLBAR_BUTTONS,
+  "niivue.toolbarSections": NIIVUE_TOOLBAR_SECTIONS
+};
+function buttonCommandOption(button, option) {
+  const commands = button?.props?.commands;
+  const options = commands && typeof commands === "object" && !Array.isArray(commands) ? commands.commandOptions : undefined;
+  const value = options?.[option];
+  return typeof value === "string" ? value : undefined;
+}
+var DISABLED = {
+  disabled: true,
+  disabledText: "Available on NiiVue viewports"
+};
+var VOLUME_DISABLED = {
+  disabled: true,
+  disabledText: "Available for NiiVue volume viewports"
+};
+function volumeDisabled(viewportId) {
+  const nv = getNiivueForViewport(viewportId);
+  return !nv || !Array.isArray(nv.volumes) || nv.volumes.length === 0;
+}
+function getNiivueToolbarModule() {
+  return [
+    {
+      name: NIIVUE_EVALUATOR,
+      evaluate: ({ viewportId }) => getNiivueForViewport(viewportId) ? { disabled: false } : DISABLED
+    },
+    {
+      name: SLICE_TYPE_EVALUATOR,
+      evaluate: ({ viewportId, button }) => {
+        const nv = getNiivueForViewport(viewportId);
+        if (!nv)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        const name = buttonCommandOption(button, "sliceType");
+        const target = name === undefined ? undefined : NIIVUE_SLICE_TYPES[name];
+        return {
+          disabled: false,
+          isActive: target !== undefined && nv.sliceType === target
+        };
+      }
+    },
+    {
+      name: CLIP_PLANE_EVALUATOR,
+      evaluate: ({ viewportId, button }) => {
+        const entry = getNiivueEntryForViewport(viewportId);
+        if (!entry)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        const plane = buttonCommandOption(button, "plane");
+        return {
+          disabled: false,
+          isActive: plane !== undefined && plane !== "none" && entry.clipPlane === plane
+        };
+      }
+    },
+    {
+      name: OVERLAY_EVALUATOR,
+      evaluate: ({ viewportId }) => {
+        const entry = getNiivueEntryForViewport(viewportId);
+        if (!entry)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        return { disabled: false, isActive: entry.overlayUIDs.length > 0 };
+      }
+    },
+    {
+      name: WL_PRESET_EVALUATOR,
+      evaluate: ({ viewportId, button }) => {
+        const entry = getNiivueEntryForViewport(viewportId);
+        if (!entry)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        const modality = buttonCommandOption(button, "modality");
+        if (modality !== undefined && modality !== baseModality(entry)) {
+          return {
+            disabled: true,
+            disabledText: `Applies to ${modality} series`
+          };
+        }
+        return { disabled: false };
+      }
+    },
+    {
+      name: COLORMAP_EVALUATOR,
+      evaluate: ({ viewportId, button }) => {
+        const nv = getNiivueForViewport(viewportId);
+        if (!nv)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        const name = buttonCommandOption(button, "colormap");
+        const current = nv.volumes[0]?.colormap;
+        return {
+          disabled: false,
+          isActive: name !== undefined && typeof current === "string" && current.toLowerCase() === name.toLowerCase()
+        };
+      }
+    },
+    {
+      name: COLORBAR_EVALUATOR,
+      evaluate: ({ viewportId }) => {
+        const nv = getNiivueForViewport(viewportId);
+        if (!nv)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        return { disabled: false, isActive: nv.isColorbarVisible === true };
+      }
+    },
+    {
+      name: INTERPOLATION_EVALUATOR,
+      evaluate: ({ viewportId }) => {
+        const nv = getNiivueForViewport(viewportId);
+        if (!nv)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        return {
+          disabled: false,
+          isActive: nv.volumeIsNearestInterpolation === true
+        };
+      }
+    },
+    {
+      name: CROSSHAIR_EVALUATOR,
+      evaluate: ({ viewportId }) => {
+        const nv = getNiivueForViewport(viewportId);
+        if (!nv)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        return { disabled: false, isActive: nv.crosshairWidth > 0 };
+      }
+    },
+    {
+      name: MEASUREMENT_EVALUATOR,
+      evaluate: ({ viewportId }) => {
+        const nv = getNiivueForViewport(viewportId);
+        if (!nv)
+          return DISABLED;
+        if (volumeDisabled(viewportId))
+          return VOLUME_DISABLED;
+        return {
+          disabled: false,
+          isActive: nv.annotationIsEnabled === true && nv.annotationTool === "measureLine"
+        };
+      }
+    }
+  ];
+}
+
+// src/index.ts
+var NIIVUE_OHIF_EXTENSION_ID = "@niivue/nv-ohif";
+var niivueOhifExtension = {
+  id: NIIVUE_OHIF_EXTENSION_ID,
+  version: "0.0.0",
+  getViewportModule: () => getNiivueViewportModule(),
+  getSopClassHandlerModule: () => getNiivueSopClassHandlerModule(),
+  getCommandsModule: (params) => getNiivueCommandsModule(params),
+  getToolbarModule: () => getNiivueToolbarModule(),
+  getCustomizationModule: () => [
+    { name: "default", value: niivueToolbarCustomization }
+  ]
+};
+var src_default = niivueOhifExtension;
+export {
+  niivueToolbarCustomization,
+  getNiivueViewportModule,
+  getNiivueToolbarModule,
+  getNiivueSopClassHandlerModule,
+  getNiivueCommandsModule,
+  displaySetToNiivue,
+  src_default as default,
+  NiivueViewport,
+  NIIVUE_WL_SECTION,
+  NIIVUE_VIEWS_SECTION,
+  NIIVUE_VIEWPORT_NAME,
+  NIIVUE_TOOLBAR_SECTIONS,
+  NIIVUE_TOOLBAR_BUTTONS,
+  NIIVUE_SOP_CLASS_HANDLER_NAME,
+  NIIVUE_SLICE_TYPES,
+  NIIVUE_RESET_BUTTON,
+  NIIVUE_OVERLAY_BUTTON,
+  NIIVUE_OHIF_EXTENSION_ID,
+  NIIVUE_INTERPOLATION_BUTTON,
+  NIIVUE_COLORMAP_SECTION,
+  NIIVUE_COLORMAPS,
+  NIIVUE_COLORBAR_BUTTON,
+  NIIVUE_CLIP_SECTION,
+  NIIVUE_CLIP_PLANES
+};